238 files changed, 14591 insertions, 10178 deletions

diff --git a/fs/9p/9p.h b/fs/9p/9p.h
deleted file mode 100644
index 94e2f92ab2e..00000000000
--- a/fs/9p/9p.h
+++ /dev/null
@@ -1,375 +0,0 @@
-/*
- * linux/fs/9p/9p.h
- *
- * 9P protocol definitions.
- *
- *  Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net>
- *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
- *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2
- *  as published by the Free Software Foundation.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to:
- *  Free Software Foundation
- *  51 Franklin Street, Fifth Floor
- *  Boston, MA  02111-1301  USA
- *
- */
-
-/* Message Types */
-enum {
-        TVERSION = 100,
-        RVERSION,
-        TAUTH = 102,
-        RAUTH,
-        TATTACH = 104,
-        RATTACH,
-        TERROR = 106,
-        RERROR,
-        TFLUSH = 108,
-        RFLUSH,
-        TWALK = 110,
-        RWALK,
-        TOPEN = 112,
-        ROPEN,
-        TCREATE = 114,
-        RCREATE,
-        TREAD = 116,
-        RREAD,
-        TWRITE = 118,
-        RWRITE,
-        TCLUNK = 120,
-        RCLUNK,
-        TREMOVE = 122,
-        RREMOVE,
-        TSTAT = 124,
-        RSTAT,
-        TWSTAT = 126,
-        RWSTAT,
-};
-
-/* modes */
-enum {
-        V9FS_OREAD = 0x00,
-        V9FS_OWRITE = 0x01,
-        V9FS_ORDWR = 0x02,
-        V9FS_OEXEC = 0x03,
-        V9FS_OEXCL = 0x04,
-        V9FS_OTRUNC = 0x10,
-        V9FS_OREXEC = 0x20,
-        V9FS_ORCLOSE = 0x40,
-        V9FS_OAPPEND = 0x80,
-};
-
-/* permissions */
-enum {
-        V9FS_DMDIR = 0x80000000,
-        V9FS_DMAPPEND = 0x40000000,
-        V9FS_DMEXCL = 0x20000000,
-        V9FS_DMMOUNT = 0x10000000,
-        V9FS_DMAUTH = 0x08000000,
-        V9FS_DMTMP = 0x04000000,
-        V9FS_DMSYMLINK = 0x02000000,
-        V9FS_DMLINK = 0x01000000,
-        /* 9P2000.u extensions */
-        V9FS_DMDEVICE = 0x00800000,
-        V9FS_DMNAMEDPIPE = 0x00200000,
-        V9FS_DMSOCKET = 0x00100000,
-        V9FS_DMSETUID = 0x00080000,
-        V9FS_DMSETGID = 0x00040000,
-};
-
-/* qid.types */
-enum {
-        V9FS_QTDIR = 0x80,
-        V9FS_QTAPPEND = 0x40,
-        V9FS_QTEXCL = 0x20,
-        V9FS_QTMOUNT = 0x10,
-        V9FS_QTAUTH = 0x08,
-        V9FS_QTTMP = 0x04,
-        V9FS_QTSYMLINK = 0x02,
-        V9FS_QTLINK = 0x01,
-        V9FS_QTFILE = 0x00,
-};
-
-#define V9FS_NOTAG      (u16)(~0)
-#define V9FS_NOFID      (u32)(~0)
-#define V9FS_MAXWELEM   16
-
-/* ample room for Twrite/Rread header (iounit) */
-#define V9FS_IOHDRSZ    24
-
-struct v9fs_str {
-        u16 len;
-        char *str;
-};
-
-/* qids are the unique ID for a file (like an inode */
-struct v9fs_qid {
-        u8 type;
-        u32 version;
-        u64 path;
-};
-
-/* Plan 9 file metadata (stat) structure */
-struct v9fs_stat {
-        u16 size;
-        u16 type;
-        u32 dev;
-        struct v9fs_qid qid;
-        u32 mode;
-        u32 atime;
-        u32 mtime;
-        u64 length;
-        struct v9fs_str name;
-        struct v9fs_str uid;
-        struct v9fs_str gid;
-        struct v9fs_str muid;
-        struct v9fs_str extension;      /* 9p2000.u extensions */
-        u32 n_uid;              /* 9p2000.u extensions */
-        u32 n_gid;              /* 9p2000.u extensions */
-        u32 n_muid;             /* 9p2000.u extensions */
-};
-
-/* file metadata (stat) structure used to create Twstat message
-   The is similar to v9fs_stat, but the strings don't point to
-   the same memory block and should be freed separately
-*/
-struct v9fs_wstat {
-        u16 size;
-        u16 type;
-        u32 dev;
-        struct v9fs_qid qid;
-        u32 mode;
-        u32 atime;
-        u32 mtime;
-        u64 length;
-        char *name;
-        char *uid;
-        char *gid;
-        char *muid;
-        char *extension;        /* 9p2000.u extensions */
-        u32 n_uid;              /* 9p2000.u extensions */
-        u32 n_gid;              /* 9p2000.u extensions */
-        u32 n_muid;             /* 9p2000.u extensions */
-};
-
-/* Structures for Protocol Operations */
-
-struct Tversion {
-        u32 msize;
-        struct v9fs_str version;
-};
-
-struct Rversion {
-        u32 msize;
-        struct v9fs_str version;
-};
-
-struct Tauth {
-        u32 afid;
-        struct v9fs_str uname;
-        struct v9fs_str aname;
-};
-
-struct Rauth {
-        struct v9fs_qid qid;
-};
-
-struct Rerror {
-        struct v9fs_str error;
-        u32 errno;              /* 9p2000.u extension */
-};
-
-struct Tflush {
-        u16 oldtag;
-};
-
-struct Rflush {
-};
-
-struct Tattach {
-        u32 fid;
-        u32 afid;
-        struct v9fs_str uname;
-        struct v9fs_str aname;
-};
-
-struct Rattach {
-        struct v9fs_qid qid;
-};
-
-struct Twalk {
-        u32 fid;
-        u32 newfid;
-        u16 nwname;
-        struct v9fs_str wnames[16];
-};
-
-struct Rwalk {
-        u16 nwqid;
-        struct v9fs_qid wqids[16];
-};
-
-struct Topen {
-        u32 fid;
-        u8 mode;
-};
-
-struct Ropen {
-        struct v9fs_qid qid;
-        u32 iounit;
-};
-
-struct Tcreate {
-        u32 fid;
-        struct v9fs_str name;
-        u32 perm;
-        u8 mode;
-        struct v9fs_str extension;
-};
-
-struct Rcreate {
-        struct v9fs_qid qid;
-        u32 iounit;
-};
-
-struct Tread {
-        u32 fid;
-        u64 offset;
-        u32 count;
-};
-
-struct Rread {
-        u32 count;
-        u8 *data;
-};
-
-struct Twrite {
-        u32 fid;
-        u64 offset;
-        u32 count;
-        u8 *data;
-};
-
-struct Rwrite {
-        u32 count;
-};
-
-struct Tclunk {
-        u32 fid;
-};
-
-struct Rclunk {
-};
-
-struct Tremove {
-        u32 fid;
-};
-
-struct Rremove {
-};
-
-struct Tstat {
-        u32 fid;
-};
-
-struct Rstat {
-        struct v9fs_stat stat;
-};
-
-struct Twstat {
-        u32 fid;
-        struct v9fs_stat stat;
-};
-
-struct Rwstat {
-};
-
-/*
-  * fcall is the primary packet structure
-  *
-  */
-
-struct v9fs_fcall {
-        u32 size;
-        u8 id;
-        u16 tag;
-        void *sdata;
-
-        union {
-                struct Tversion tversion;
-                struct Rversion rversion;
-                struct Tauth tauth;
-                struct Rauth rauth;
-                struct Rerror rerror;
-                struct Tflush tflush;
-                struct Rflush rflush;
-                struct Tattach tattach;
-                struct Rattach rattach;
-                struct Twalk twalk;
-                struct Rwalk rwalk;
-                struct Topen topen;
-                struct Ropen ropen;
-                struct Tcreate tcreate;
-                struct Rcreate rcreate;
-                struct Tread tread;
-                struct Rread rread;
-                struct Twrite twrite;
-                struct Rwrite rwrite;
-                struct Tclunk tclunk;
-                struct Rclunk rclunk;
-                struct Tremove tremove;
-                struct Rremove rremove;
-                struct Tstat tstat;
-                struct Rstat rstat;
-                struct Twstat twstat;
-                struct Rwstat rwstat;
-        } params;
-};
-
-#define PRINT_FCALL_ERROR(s, fcall) dprintk(DEBUG_ERROR, "%s: %.*s\n", s, \
-        fcall?fcall->params.rerror.error.len:0, \
-        fcall?fcall->params.rerror.error.str:"");
-
-int v9fs_t_version(struct v9fs_session_info *v9ses, u32 msize,
-                   char *version, struct v9fs_fcall **rcall);
-
-int v9fs_t_attach(struct v9fs_session_info *v9ses, char *uname, char *aname,
-                  u32 fid, u32 afid, struct v9fs_fcall **rcall);
-
-int v9fs_t_clunk(struct v9fs_session_info *v9ses, u32 fid);
-
-int v9fs_t_stat(struct v9fs_session_info *v9ses, u32 fid,
-                struct v9fs_fcall **rcall);
-
-int v9fs_t_wstat(struct v9fs_session_info *v9ses, u32 fid,
-                 struct v9fs_wstat *wstat, struct v9fs_fcall **rcall);
-
-int v9fs_t_walk(struct v9fs_session_info *v9ses, u32 fid, u32 newfid,
-                char *name, struct v9fs_fcall **rcall);
-
-int v9fs_t_open(struct v9fs_session_info *v9ses, u32 fid, u8 mode,
-                struct v9fs_fcall **rcall);
-
-int v9fs_t_remove(struct v9fs_session_info *v9ses, u32 fid,
-                  struct v9fs_fcall **rcall);
-
-int v9fs_t_create(struct v9fs_session_info *v9ses, u32 fid, char *name,
-        u32 perm, u8 mode, char *extension, struct v9fs_fcall **rcall);
-
-int v9fs_t_read(struct v9fs_session_info *v9ses, u32 fid,
-                u64 offset, u32 count, struct v9fs_fcall **rcall);
-
-int v9fs_t_write(struct v9fs_session_info *v9ses, u32 fid, u64 offset,
-                 u32 count, const char __user * data,
-                 struct v9fs_fcall **rcall);
-int v9fs_printfcall(char *, int, struct v9fs_fcall *, int);
diff --git a/fs/9p/Makefile b/fs/9p/Makefile
index 87897f84dfb..bc7f0d1551e 100644
--- a/fs/9p/Makefile
+++ b/fs/9p/Makefile
@@ -1,18 +1,12 @@
 obj-$(CONFIG_9P_FS) := 9p.o
 
 9p-objs := \
-        trans_fd.o \
-        mux.o \
-        fcall.o \
-        conv.o \
         vfs_super.o \
         vfs_inode.o \
         vfs_addr.o \
         vfs_file.o \
         vfs_dir.o \
         vfs_dentry.o \
-        error.o \
         v9fs.o \
         fid.o \
-        fcprint.o
 
diff --git a/fs/9p/conv.c b/fs/9p/conv.c
deleted file mode 100644
index a3ed571eee3..00000000000
--- a/fs/9p/conv.c
+++ /dev/null
@@ -1,845 +0,0 @@
-/*
- * linux/fs/9p/conv.c
- *
- * 9P protocol conversion functions
- *
- *  Copyright (C) 2004, 2005 by Latchesar Ionkov <lucho@ionkov.net>
- *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
- *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2
- *  as published by the Free Software Foundation.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to:
- *  Free Software Foundation
- *  51 Franklin Street, Fifth Floor
- *  Boston, MA  02111-1301  USA
- *
- */
-
-#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"
-#include "v9fs.h"
-#include "9p.h"
-#include "conv.h"
-
-/*
- * Buffer to help with string parsing
- */
-struct cbuf {
-        unsigned char *sp;
-        unsigned char *p;
-        unsigned char *ep;
-};
-
-static inline void buf_init(struct cbuf *buf, void *data, int datalen)
-{
-        buf->sp = buf->p = data;
-        buf->ep = data + datalen;
-}
-
-static inline int buf_check_overflow(struct cbuf *buf)
-{
-        return buf->p > buf->ep;
-}
-
-static int buf_check_size(struct cbuf *buf, int len)
-{
-        if (buf->p + len > buf->ep) {
-                if (buf->p < buf->ep) {
-                        eprintk(KERN_ERR, "buffer overflow: want %d has %d\n",
-                                len, (int)(buf->ep - buf->p));
-                        dump_stack();
-                        buf->p = buf->ep + 1;
-                }
-
-                return 0;
-        }
-
-        return 1;
-}
-
-static void *buf_alloc(struct cbuf *buf, int len)
-{
-        void *ret = NULL;
-
-        if (buf_check_size(buf, len)) {
-                ret = buf->p;
-                buf->p += len;
-        }
-
-        return ret;
-}
-
-static void buf_put_int8(struct cbuf *buf, u8 val)
-{
-        if (buf_check_size(buf, 1)) {
-                buf->p[0] = val;
-                buf->p++;
-        }
-}
-
-static void buf_put_int16(struct cbuf *buf, u16 val)
-{
-        if (buf_check_size(buf, 2)) {
-                *(__le16 *) buf->p = cpu_to_le16(val);
-                buf->p += 2;
-        }
-}
-
-static void buf_put_int32(struct cbuf *buf, u32 val)
-{
-        if (buf_check_size(buf, 4)) {
-                *(__le32 *)buf->p = cpu_to_le32(val);
-                buf->p += 4;
-        }
-}
-
-static void buf_put_int64(struct cbuf *buf, u64 val)
-{
-        if (buf_check_size(buf, 8)) {
-                *(__le64 *)buf->p = cpu_to_le64(val);
-                buf->p += 8;
-        }
-}
-
-static char *buf_put_stringn(struct cbuf *buf, const char *s, u16 slen)
-{
-        char *ret;
-
-        ret = NULL;
-        if (buf_check_size(buf, slen + 2)) {
-                buf_put_int16(buf, slen);
-                ret = buf->p;
-                memcpy(buf->p, s, slen);
-                buf->p += slen;
-        }
-
-        return ret;
-}
-
-static inline void buf_put_string(struct cbuf *buf, const char *s)
-{
-        buf_put_stringn(buf, s, strlen(s));
-}
-
-static u8 buf_get_int8(struct cbuf *buf)
-{
-        u8 ret = 0;
-
-        if (buf_check_size(buf, 1)) {
-                ret = buf->p[0];
-                buf->p++;
-        }
-
-        return ret;
-}
-
-static u16 buf_get_int16(struct cbuf *buf)
-{
-        u16 ret = 0;
-
-        if (buf_check_size(buf, 2)) {
-                ret = le16_to_cpu(*(__le16 *)buf->p);
-                buf->p += 2;
-        }
-
-        return ret;
-}
-
-static u32 buf_get_int32(struct cbuf *buf)
-{
-        u32 ret = 0;
-
-        if (buf_check_size(buf, 4)) {
-                ret = le32_to_cpu(*(__le32 *)buf->p);
-                buf->p += 4;
-        }
-
-        return ret;
-}
-
-static u64 buf_get_int64(struct cbuf *buf)
-{
-        u64 ret = 0;
-
-        if (buf_check_size(buf, 8)) {
-                ret = le64_to_cpu(*(__le64 *)buf->p);
-                buf->p += 8;
-        }
-
-        return ret;
-}
-
-static void buf_get_str(struct cbuf *buf, struct v9fs_str *vstr)
-{
-        vstr->len = buf_get_int16(buf);
-        if (!buf_check_overflow(buf) && buf_check_size(buf, vstr->len)) {
-                vstr->str = buf->p;
-                buf->p += vstr->len;
-        } else {
-                vstr->len = 0;
-                vstr->str = NULL;
-        }
-}
-
-static void buf_get_qid(struct cbuf *bufp, struct v9fs_qid *qid)
-{
-        qid->type = buf_get_int8(bufp);
-        qid->version = buf_get_int32(bufp);
-        qid->path = buf_get_int64(bufp);
-}
-
-/**
- * v9fs_size_wstat - calculate the size of a variable length stat struct
- * @stat: metadata (stat) structure
- * @extended: non-zero if 9P2000.u
- *
- */
-
-static int v9fs_size_wstat(struct v9fs_wstat *wstat, int extended)
-{
-        int size = 0;
-
-        if (wstat == NULL) {
-                eprintk(KERN_ERR, "v9fs_size_stat: got a NULL stat pointer\n");
-                return 0;
-        }
-
-        size =                  /* 2 + *//* size[2] */
-            2 +                 /* type[2] */
-            4 +                 /* dev[4] */
-            1 +                 /* qid.type[1] */
-            4 +                 /* qid.vers[4] */
-            8 +                 /* qid.path[8] */
-            4 +                 /* mode[4] */
-            4 +                 /* atime[4] */
-            4 +                 /* mtime[4] */
-            8 +                 /* length[8] */
-            8;                  /* minimum sum of string lengths */
-
-        if (wstat->name)
-                size += strlen(wstat->name);
-        if (wstat->uid)
-                size += strlen(wstat->uid);
-        if (wstat->gid)
-                size += strlen(wstat->gid);
-        if (wstat->muid)
-                size += strlen(wstat->muid);
-
-        if (extended) {
-                size += 4 +     /* n_uid[4] */
-                    4 +         /* n_gid[4] */
-                    4 +         /* n_muid[4] */
-                    2;          /* string length of extension[4] */
-                if (wstat->extension)
-                        size += strlen(wstat->extension);
-        }
-
-        return size;
-}
-
-/**
- * buf_get_stat - safely decode a recieved metadata (stat) structure
- * @bufp: buffer to deserialize
- * @stat: metadata (stat) structure
- * @extended: non-zero if 9P2000.u
- *
- */
-
-static void
-buf_get_stat(struct cbuf *bufp, struct v9fs_stat *stat, int extended)
-{
-        stat->size = buf_get_int16(bufp);
-        stat->type = buf_get_int16(bufp);
-        stat->dev = buf_get_int32(bufp);
-        stat->qid.type = buf_get_int8(bufp);
-        stat->qid.version = buf_get_int32(bufp);
-        stat->qid.path = buf_get_int64(bufp);
-        stat->mode = buf_get_int32(bufp);
-        stat->atime = buf_get_int32(bufp);
-        stat->mtime = buf_get_int32(bufp);
-        stat->length = buf_get_int64(bufp);
-        buf_get_str(bufp, &stat->name);
-        buf_get_str(bufp, &stat->uid);
-        buf_get_str(bufp, &stat->gid);
-        buf_get_str(bufp, &stat->muid);
-
-        if (extended) {
-                buf_get_str(bufp, &stat->extension);
-                stat->n_uid = buf_get_int32(bufp);
-                stat->n_gid = buf_get_int32(bufp);
-                stat->n_muid = buf_get_int32(bufp);
-        }
-}
-
-/**
- * v9fs_deserialize_stat - decode a received metadata structure
- * @buf: buffer to deserialize
- * @buflen: length of received buffer
- * @stat: metadata structure to decode into
- * @extended: non-zero if 9P2000.u
- *
- * Note: stat will point to the buf region.
- */
-
-int
-v9fs_deserialize_stat(void *buf, u32 buflen, struct v9fs_stat *stat,
-                int extended)
-{
-        struct cbuf buffer;
-        struct cbuf *bufp = &buffer;
-        unsigned char *p;
-
-        buf_init(bufp, buf, buflen);
-        p = bufp->p;
-        buf_get_stat(bufp, stat, extended);
-
-        if (buf_check_overflow(bufp))
-                return 0;
-        else
-                return bufp->p - p;
-}
-
-/**
- * deserialize_fcall - unmarshal a response
- * @buf: recieved buffer
- * @buflen: length of received buffer
- * @rcall: fcall structure to populate
- * @rcalllen: length of fcall structure to populate
- * @extended: non-zero if 9P2000.u
- *
- */
-
-int
-v9fs_deserialize_fcall(void *buf, u32 buflen, struct v9fs_fcall *rcall,
-                       int extended)
-{
-
-        struct cbuf buffer;
-        struct cbuf *bufp = &buffer;
-        int i = 0;
-
-        buf_init(bufp, buf, buflen);
-
-        rcall->size = buf_get_int32(bufp);
-        rcall->id = buf_get_int8(bufp);
-        rcall->tag = buf_get_int16(bufp);
-
-        dprintk(DEBUG_CONV, "size %d id %d tag %d\n", rcall->size, rcall->id,
-                rcall->tag);
-
-        switch (rcall->id) {
-        default:
-                eprintk(KERN_ERR, "unknown message type: %d\n", rcall->id);
-                return -EPROTO;
-        case RVERSION:
-                rcall->params.rversion.msize = buf_get_int32(bufp);
-                buf_get_str(bufp, &rcall->params.rversion.version);
-                break;
-        case RFLUSH:
-                break;
-        case RATTACH:
-                rcall->params.rattach.qid.type = buf_get_int8(bufp);
-                rcall->params.rattach.qid.version = buf_get_int32(bufp);
-                rcall->params.rattach.qid.path = buf_get_int64(bufp);
-                break;
-        case RWALK:
-                rcall->params.rwalk.nwqid = buf_get_int16(bufp);
-                if (rcall->params.rwalk.nwqid > V9FS_MAXWELEM) {
-                        eprintk(KERN_ERR, "Rwalk with more than %d qids: %d\n",
-                                V9FS_MAXWELEM, rcall->params.rwalk.nwqid);
-                        return -EPROTO;
-                }
-
-                for (i = 0; i < rcall->params.rwalk.nwqid; i++)
-                        buf_get_qid(bufp, &rcall->params.rwalk.wqids[i]);
-                break;
-        case ROPEN:
-                buf_get_qid(bufp, &rcall->params.ropen.qid);
-                rcall->params.ropen.iounit = buf_get_int32(bufp);
-                break;
-        case RCREATE:
-                buf_get_qid(bufp, &rcall->params.rcreate.qid);
-                rcall->params.rcreate.iounit = buf_get_int32(bufp);
-                break;
-        case RREAD:
-                rcall->params.rread.count = buf_get_int32(bufp);
-                rcall->params.rread.data = bufp->p;
-                buf_check_size(bufp, rcall->params.rread.count);
-                break;
-        case RWRITE:
-                rcall->params.rwrite.count = buf_get_int32(bufp);
-                break;
-        case RCLUNK:
-                break;
-        case RREMOVE:
-                break;
-        case RSTAT:
-                buf_get_int16(bufp);
-                buf_get_stat(bufp, &rcall->params.rstat.stat, extended);
-                break;
-        case RWSTAT:
-                break;
-        case RERROR:
-                buf_get_str(bufp, &rcall->params.rerror.error);
-                if (extended)
-                        rcall->params.rerror.errno = buf_get_int16(bufp);
-                break;
-        }
-
-        if (buf_check_overflow(bufp)) {
-                dprintk(DEBUG_ERROR, "buffer overflow\n");
-                return -EIO;
-        }
-
-        return bufp->p - bufp->sp;
-}
-
-static inline void v9fs_put_int8(struct cbuf *bufp, u8 val, u8 * p)
-{
-        *p = val;
-        buf_put_int8(bufp, val);
-}
-
-static inline void v9fs_put_int16(struct cbuf *bufp, u16 val, u16 * p)
-{
-        *p = val;
-        buf_put_int16(bufp, val);
-}
-
-static inline void v9fs_put_int32(struct cbuf *bufp, u32 val, u32 * p)
-{
-        *p = val;
-        buf_put_int32(bufp, val);
-}
-
-static inline void v9fs_put_int64(struct cbuf *bufp, u64 val, u64 * p)
-{
-        *p = val;
-        buf_put_int64(bufp, val);
-}
-
-static void
-v9fs_put_str(struct cbuf *bufp, char *data, struct v9fs_str *str)
-{
-        int len;
-        char *s;
-
-        if (data)
-                len = strlen(data);
-        else
-                len = 0;
-
-        s = buf_put_stringn(bufp, data, len);
-        if (str) {
-                str->len = len;
-                str->str = s;
-        }
-}
-
-static int
-v9fs_put_user_data(struct cbuf *bufp, const char __user * data, int count,
-                   unsigned char **pdata)
-{
-        *pdata = buf_alloc(bufp, count);
-        return copy_from_user(*pdata, data, count);
-}
-
-static void
-v9fs_put_wstat(struct cbuf *bufp, struct v9fs_wstat *wstat,
-               struct v9fs_stat *stat, int statsz, int extended)
-{
-        v9fs_put_int16(bufp, statsz, &stat->size);
-        v9fs_put_int16(bufp, wstat->type, &stat->type);
-        v9fs_put_int32(bufp, wstat->dev, &stat->dev);
-        v9fs_put_int8(bufp, wstat->qid.type, &stat->qid.type);
-        v9fs_put_int32(bufp, wstat->qid.version, &stat->qid.version);
-        v9fs_put_int64(bufp, wstat->qid.path, &stat->qid.path);
-        v9fs_put_int32(bufp, wstat->mode, &stat->mode);
-        v9fs_put_int32(bufp, wstat->atime, &stat->atime);
-        v9fs_put_int32(bufp, wstat->mtime, &stat->mtime);
-        v9fs_put_int64(bufp, wstat->length, &stat->length);
-
-        v9fs_put_str(bufp, wstat->name, &stat->name);
-        v9fs_put_str(bufp, wstat->uid, &stat->uid);
-        v9fs_put_str(bufp, wstat->gid, &stat->gid);
-        v9fs_put_str(bufp, wstat->muid, &stat->muid);
-
-        if (extended) {
-                v9fs_put_str(bufp, wstat->extension, &stat->extension);
-                v9fs_put_int32(bufp, wstat->n_uid, &stat->n_uid);
-                v9fs_put_int32(bufp, wstat->n_gid, &stat->n_gid);
-                v9fs_put_int32(bufp, wstat->n_muid, &stat->n_muid);
-        }
-}
-
-static struct v9fs_fcall *
-v9fs_create_common(struct cbuf *bufp, u32 size, u8 id)
-{
-        struct v9fs_fcall *fc;
-
-        size += 4 + 1 + 2;      /* size[4] id[1] tag[2] */
-        fc = kmalloc(sizeof(struct v9fs_fcall) + size, GFP_KERNEL);
-        if (!fc)
-                return ERR_PTR(-ENOMEM);
-
-        fc->sdata = (char *)fc + sizeof(*fc);
-
-        buf_init(bufp, (char *)fc->sdata, size);
-        v9fs_put_int32(bufp, size, &fc->size);
-        v9fs_put_int8(bufp, id, &fc->id);
-        v9fs_put_int16(bufp, V9FS_NOTAG, &fc->tag);
-
-        return fc;
-}
-
-void v9fs_set_tag(struct v9fs_fcall *fc, u16 tag)
-{
-        fc->tag = tag;
-        *(__le16 *) (fc->sdata + 5) = cpu_to_le16(tag);
-}
-
-struct v9fs_fcall *v9fs_create_tversion(u32 msize, char *version)
-{
-        int size;
-        struct v9fs_fcall *fc;
-        struct cbuf buffer;
-        struct cbuf *bufp = &buffer;
-
-        size = 4 + 2 + strlen(version); /* msize[4] version[s] */
-        fc = v9fs_create_common(bufp, size, TVERSION);
-        if (IS_ERR(fc))
-                goto error;
-
-        v9fs_put_int32(bufp, msize, &fc->params.tversion.msize);
-        v9fs_put_str(bufp, version, &fc->params.tversion.version);
-
-        if (buf_check_overflow(bufp)) {
-                kfree(fc);
-                fc = ERR_PTR(-ENOMEM);
-        }
-      error:
-        return fc;
-}
-
-#if 0
-struct v9fs_fcall *v9fs_create_tauth(u32 afid, char *uname, char *aname)
-{
-        int size;
-        struct v9fs_fcall *fc;
-        struct cbuf buffer;
-        struct cbuf *bufp = &buffer;
-
-        size = 4 + 2 + strlen(uname) + 2 + strlen(aname);       /* afid[4] uname[s] aname[s] */
-        fc = v9fs_create_common(bufp, size, TAUTH);
-        if (IS_ERR(fc))
-                goto error;
-
-        v9fs_put_int32(bufp, afid, &fc->params.tauth.afid);
-        v9fs_put_str(bufp, uname, &fc->params.tauth.uname);
-        v9fs_put_str(bufp, aname, &fc->params.tauth.aname);
-
-        if (buf_check_overflow(bufp)) {
-                kfree(fc);
-                fc = ERR_PTR(-ENOMEM);
-        }
-      error:
-        return fc;
-}
-#endif  /*  0  */
-
-struct v9fs_fcall *
-v9fs_create_tattach(u32 fid, u32 afid, char *uname, char *aname)
-{
-        int size;
-        struct v9fs_fcall *fc;
-        struct cbuf buffer;
-        struct cbuf *bufp = &buffer;
-
-        size = 4 + 4 + 2 + strlen(uname) + 2 + strlen(aname);   /* fid[4] afid[4] uname[s] aname[s] */
-        fc = v9fs_create_common(bufp, size, TATTACH);
-        if (IS_ERR(fc))
-                goto error;
-
-        v9fs_put_int32(bufp, fid, &fc->params.tattach.fid);
-        v9fs_put_int32(bufp, afid, &fc->params.tattach.afid);
-        v9fs_put_str(bufp, uname, &fc->params.tattach.uname);
-        v9fs_put_str(bufp, aname, &fc->params.tattach.aname);
-
-      error:
-        return fc;
-}
-
-struct v9fs_fcall *v9fs_create_tflush(u16 oldtag)
-{
-        int size;
-        struct v9fs_fcall *fc;
-        struct cbuf buffer;
-        struct cbuf *bufp = &buffer;
-
-        size = 2;               /* oldtag[2] */
-        fc = v9fs_create_common(bufp, size, TFLUSH);
-        if (IS_ERR(fc))
-                goto error;
-
-        v9fs_put_int16(bufp, oldtag, &fc->params.tflush.oldtag);
-
-        if (buf_check_overflow(bufp)) {
-                kfree(fc);
-                fc = ERR_PTR(-ENOMEM);
-        }
-      error:
-        return fc;
-}
-
-struct v9fs_fcall *v9fs_create_twalk(u32 fid, u32 newfid, u16 nwname,
-                                     char **wnames)
-{
-        int i, size;
-        struct v9fs_fcall *fc;
-        struct cbuf buffer;
-        struct cbuf *bufp = &buffer;
-
-        if (nwname > V9FS_MAXWELEM) {
-                dprintk(DEBUG_ERROR, "nwname > %d\n", V9FS_MAXWELEM);
-                return NULL;
-        }
-
-        size = 4 + 4 + 2;       /* fid[4] newfid[4] nwname[2] ... */
-        for (i = 0; i < nwname; i++) {
-                size += 2 + strlen(wnames[i]);  /* wname[s] */
-        }
-
-        fc = v9fs_create_common(bufp, size, TWALK);
-        if (IS_ERR(fc))
-                goto error;
-
-        v9fs_put_int32(bufp, fid, &fc->params.twalk.fid);
-        v9fs_put_int32(bufp, newfid, &fc->params.twalk.newfid);
-        v9fs_put_int16(bufp, nwname, &fc->params.twalk.nwname);
-        for (i = 0; i < nwname; i++) {
-                v9fs_put_str(bufp, wnames[i], &fc->params.twalk.wnames[i]);
-        }
-
-        if (buf_check_overflow(bufp)) {
-                kfree(fc);
-                fc = ERR_PTR(-ENOMEM);
-        }
-      error:
-        return fc;
-}
-
-struct v9fs_fcall *v9fs_create_topen(u32 fid, u8 mode)
-{
-        int size;
-        struct v9fs_fcall *fc;
-        struct cbuf buffer;
-        struct cbuf *bufp = &buffer;
-
-        size = 4 + 1;           /* fid[4] mode[1] */
-        fc = v9fs_create_common(bufp, size, TOPEN);
-        if (IS_ERR(fc))
-                goto error;
-
-        v9fs_put_int32(bufp, fid, &fc->params.topen.fid);
-        v9fs_put_int8(bufp, mode, &fc->params.topen.mode);
-
-        if (buf_check_overflow(bufp)) {
-                kfree(fc);
-                fc = ERR_PTR(-ENOMEM);
-        }
-      error:
-        return fc;
-}
-
-struct v9fs_fcall *v9fs_create_tcreate(u32 fid, char *name, u32 perm, u8 mode,
-        char *extension, int extended)
-{
-        int size;
-        struct v9fs_fcall *fc;
-        struct cbuf buffer;
-        struct cbuf *bufp = &buffer;
-
-        size = 4 + 2 + strlen(name) + 4 + 1;    /* fid[4] name[s] perm[4] mode[1] */
-        if (extended) {
-                size += 2 +                     /* extension[s] */
-                    (extension == NULL ? 0 : strlen(extension));
-        }
-
-        fc = v9fs_create_common(bufp, size, TCREATE);
-        if (IS_ERR(fc))
-                goto error;
-
-        v9fs_put_int32(bufp, fid, &fc->params.tcreate.fid);
-        v9fs_put_str(bufp, name, &fc->params.tcreate.name);
-        v9fs_put_int32(bufp, perm, &fc->params.tcreate.perm);
-        v9fs_put_int8(bufp, mode, &fc->params.tcreate.mode);
-        if (extended)
-                v9fs_put_str(bufp, extension, &fc->params.tcreate.extension);
-
-        if (buf_check_overflow(bufp)) {
-                kfree(fc);
-                fc = ERR_PTR(-ENOMEM);
-        }
-      error:
-        return fc;
-}
-
-struct v9fs_fcall *v9fs_create_tread(u32 fid, u64 offset, u32 count)
-{
-        int size;
-        struct v9fs_fcall *fc;
-        struct cbuf buffer;
-        struct cbuf *bufp = &buffer;
-
-        size = 4 + 8 + 4;       /* fid[4] offset[8] count[4] */
-        fc = v9fs_create_common(bufp, size, TREAD);
-        if (IS_ERR(fc))
-                goto error;
-
-        v9fs_put_int32(bufp, fid, &fc->params.tread.fid);
-        v9fs_put_int64(bufp, offset, &fc->params.tread.offset);
-        v9fs_put_int32(bufp, count, &fc->params.tread.count);
-
-        if (buf_check_overflow(bufp)) {
-                kfree(fc);
-                fc = ERR_PTR(-ENOMEM);
-        }
-      error:
-        return fc;
-}
-
-struct v9fs_fcall *v9fs_create_twrite(u32 fid, u64 offset, u32 count,
-                                      const char __user * data)
-{
-        int size, err;
-        struct v9fs_fcall *fc;
-        struct cbuf buffer;
-        struct cbuf *bufp = &buffer;
-
-        size = 4 + 8 + 4 + count;       /* fid[4] offset[8] count[4] data[count] */
-        fc = v9fs_create_common(bufp, size, TWRITE);
-        if (IS_ERR(fc))
-                goto error;
-
-        v9fs_put_int32(bufp, fid, &fc->params.twrite.fid);
-        v9fs_put_int64(bufp, offset, &fc->params.twrite.offset);
-        v9fs_put_int32(bufp, count, &fc->params.twrite.count);
-        err = v9fs_put_user_data(bufp, data, count, &fc->params.twrite.data);
-        if (err) {
-                kfree(fc);
-                fc = ERR_PTR(err);
-        }
-
-        if (buf_check_overflow(bufp)) {
-                kfree(fc);
-                fc = ERR_PTR(-ENOMEM);
-        }
-      error:
-        return fc;
-}
-
-struct v9fs_fcall *v9fs_create_tclunk(u32 fid)
-{
-        int size;
-        struct v9fs_fcall *fc;
-        struct cbuf buffer;
-        struct cbuf *bufp = &buffer;
-
-        size = 4;               /* fid[4] */
-        fc = v9fs_create_common(bufp, size, TCLUNK);
-        if (IS_ERR(fc))
-                goto error;
-
-        v9fs_put_int32(bufp, fid, &fc->params.tclunk.fid);
-
-        if (buf_check_overflow(bufp)) {
-                kfree(fc);
-                fc = ERR_PTR(-ENOMEM);
-        }
-      error:
-        return fc;
-}
-
-struct v9fs_fcall *v9fs_create_tremove(u32 fid)
-{
-        int size;
-        struct v9fs_fcall *fc;
-        struct cbuf buffer;
-        struct cbuf *bufp = &buffer;
-
-        size = 4;               /* fid[4] */
-        fc = v9fs_create_common(bufp, size, TREMOVE);
-        if (IS_ERR(fc))
-                goto error;
-
-        v9fs_put_int32(bufp, fid, &fc->params.tremove.fid);
-
-        if (buf_check_overflow(bufp)) {
-                kfree(fc);
-                fc = ERR_PTR(-ENOMEM);
-        }
-      error:
-        return fc;
-}
-
-struct v9fs_fcall *v9fs_create_tstat(u32 fid)
-{
-        int size;
-        struct v9fs_fcall *fc;
-        struct cbuf buffer;
-        struct cbuf *bufp = &buffer;
-
-        size = 4;               /* fid[4] */
-        fc = v9fs_create_common(bufp, size, TSTAT);
-        if (IS_ERR(fc))
-                goto error;
-
-        v9fs_put_int32(bufp, fid, &fc->params.tstat.fid);
-
-        if (buf_check_overflow(bufp)) {
-                kfree(fc);
-                fc = ERR_PTR(-ENOMEM);
-        }
-      error:
-        return fc;
-}
-
-struct v9fs_fcall *v9fs_create_twstat(u32 fid, struct v9fs_wstat *wstat,
-                                      int extended)
-{
-        int size, statsz;
-        struct v9fs_fcall *fc;
-        struct cbuf buffer;
-        struct cbuf *bufp = &buffer;
-
-        statsz = v9fs_size_wstat(wstat, extended);
-        size = 4 + 2 + 2 + statsz;      /* fid[4] stat[n] */
-        fc = v9fs_create_common(bufp, size, TWSTAT);
-        if (IS_ERR(fc))
-                goto error;
-
-        v9fs_put_int32(bufp, fid, &fc->params.twstat.fid);
-        buf_put_int16(bufp, statsz + 2);
-        v9fs_put_wstat(bufp, wstat, &fc->params.twstat.stat, statsz, extended);
-
-        if (buf_check_overflow(bufp)) {
-                kfree(fc);
-                fc = ERR_PTR(-ENOMEM);
-        }
-      error:
-        return fc;
-}
diff --git a/fs/9p/conv.h b/fs/9p/conv.h
deleted file mode 100644
index dd5b6b1b610..00000000000
--- a/fs/9p/conv.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/*
- * linux/fs/9p/conv.h
- *
- * 9P protocol conversion definitions.
- *
- *  Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net>
- *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
- *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2
- *  as published by the Free Software Foundation.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to:
- *  Free Software Foundation
- *  51 Franklin Street, Fifth Floor
- *  Boston, MA  02111-1301  USA
- *
- */
-
-int v9fs_deserialize_stat(void *buf, u32 buflen, struct v9fs_stat *stat,
-        int extended);
-int v9fs_deserialize_fcall(void *buf, u32 buflen, struct v9fs_fcall *rcall,
-        int extended);
-
-void v9fs_set_tag(struct v9fs_fcall *fc, u16 tag);
-
-struct v9fs_fcall *v9fs_create_tversion(u32 msize, char *version);
-struct v9fs_fcall *v9fs_create_tattach(u32 fid, u32 afid, char *uname,
-        char *aname);
-struct v9fs_fcall *v9fs_create_tflush(u16 oldtag);
-struct v9fs_fcall *v9fs_create_twalk(u32 fid, u32 newfid, u16 nwname,
-        char **wnames);
-struct v9fs_fcall *v9fs_create_topen(u32 fid, u8 mode);
-struct v9fs_fcall *v9fs_create_tcreate(u32 fid, char *name, u32 perm, u8 mode,
-        char *extension, int extended);
-struct v9fs_fcall *v9fs_create_tread(u32 fid, u64 offset, u32 count);
-struct v9fs_fcall *v9fs_create_twrite(u32 fid, u64 offset, u32 count,
-        const char __user *data);
-struct v9fs_fcall *v9fs_create_tclunk(u32 fid);
-struct v9fs_fcall *v9fs_create_tremove(u32 fid);
-struct v9fs_fcall *v9fs_create_tstat(u32 fid);
-struct v9fs_fcall *v9fs_create_twstat(u32 fid, struct v9fs_wstat *wstat,
-        int extended);
diff --git a/fs/9p/debug.h b/fs/9p/debug.h
deleted file mode 100644
index 4228c0bb3c3..00000000000
--- a/fs/9p/debug.h
+++ /dev/null
@@ -1,77 +0,0 @@
-/*
- *  linux/fs/9p/debug.h - V9FS Debug Definitions
- *
- *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
- *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2
- *  as published by the Free Software Foundation.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to:
- *  Free Software Foundation
- *  51 Franklin Street, Fifth Floor
- *  Boston, MA  02111-1301  USA
- *
- */
-
-#define DEBUG_ERROR             (1<<0)
-#define DEBUG_CURRENT           (1<<1)
-#define DEBUG_9P                (1<<2)
-#define DEBUG_VFS               (1<<3)
-#define DEBUG_CONV              (1<<4)
-#define DEBUG_MUX               (1<<5)
-#define DEBUG_TRANS             (1<<6)
-#define DEBUG_SLABS             (1<<7)
-#define DEBUG_FCALL             (1<<8)
-
-#define DEBUG_DUMP_PKT          0
-
-extern int v9fs_debug_level;
-
-#define dprintk(level, format, arg...) \
-do {  \
-        if((v9fs_debug_level & level)==level) \
-                printk(KERN_NOTICE "-- %s (%d): " \
-                format , __FUNCTION__, current->pid , ## arg); \
-} while(0)
-
-#define eprintk(level, format, arg...) \
-do { \
-        printk(level "v9fs: %s (%d): " \
-                format , __FUNCTION__, current->pid , ## arg); \
-} while(0)
-
-#if DEBUG_DUMP_PKT
-static inline void dump_data(const unsigned char *data, unsigned int datalen)
-{
-        int i, n;
-        char buf[5*8];
-
-        n = 0;
-        i = 0;
-        while (i < datalen) {
-                n += snprintf(buf+n, sizeof(buf)-n, "%02x", data[i++]);
-                if (i%4 == 0)
-                        n += snprintf(buf+n, sizeof(buf)-n, " ");
-
-                if (i%16 == 0) {
-                        dprintk(DEBUG_ERROR, "%s\n", buf);
-                        n = 0;
-                }
-        }
-
-        dprintk(DEBUG_ERROR, "%s\n", buf);
-}
-#else                           /* DEBUG_DUMP_PKT */
-static inline void dump_data(const unsigned char *data, unsigned int datalen)
-{
-
-}
-#endif                          /* DEBUG_DUMP_PKT */
diff --git a/fs/9p/error.c b/fs/9p/error.c
deleted file mode 100644
index 0d7fa4e0881..00000000000
--- a/fs/9p/error.c
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- * linux/fs/9p/error.c
- *
- * Error string handling
- *
- * Plan 9 uses error strings, Unix uses error numbers.  These functions
- * try to help manage that and provide for dynamically adding error
- * mappings.
- *
- *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
- *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2
- *  as published by the Free Software Foundation.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to:
- *  Free Software Foundation
- *  51 Franklin Street, Fifth Floor
- *  Boston, MA  02111-1301  USA
- *
- */
-
-#include <linux/module.h>
-
-#include <linux/list.h>
-#include <linux/jhash.h>
-
-#include "debug.h"
-#include "error.h"
-
-/**
- * v9fs_error_init - preload
- * @errstr: error string
- *
- */
-
-int v9fs_error_init(void)
-{
-        struct errormap *c;
-        int bucket;
-
-        /* initialize hash table */
-        for (bucket = 0; bucket < ERRHASHSZ; bucket++)
-                INIT_HLIST_HEAD(&hash_errmap[bucket]);
-
-        /* load initial error map into hash table */
-        for (c = errmap; c->name != NULL; c++) {
-                c->namelen = strlen(c->name);
-                bucket = jhash(c->name, c->namelen, 0) % ERRHASHSZ;
-                INIT_HLIST_NODE(&c->list);
-                hlist_add_head(&c->list, &hash_errmap[bucket]);
-        }
-
-        return 1;
-}
-
-/**
- * errstr2errno - convert error string to error number
- * @errstr: error string
- *
- */
-
-int v9fs_errstr2errno(char *errstr, int len)
-{
-        int errno = 0;
-        struct hlist_node *p = NULL;
-        struct errormap *c = NULL;
-        int bucket = jhash(errstr, len, 0) % ERRHASHSZ;
-
-        hlist_for_each_entry(c, p, &hash_errmap[bucket], list) {
-                if (c->namelen==len && !memcmp(c->name, errstr, len)) {
-                        errno = c->val;
-                        break;
-                }
-        }
-
-        if (errno == 0) {
-                /* TODO: if error isn't found, add it dynamically */
-                errstr[len] = 0;
-                printk(KERN_ERR "%s: errstr :%s: not found\n", __FUNCTION__,
-                       errstr);
-                errno = 1;
-        }
-
-        return -errno;
-}
diff --git a/fs/9p/error.h b/fs/9p/error.h
deleted file mode 100644
index 5f3ca522b31..00000000000
--- a/fs/9p/error.h
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- * linux/fs/9p/error.h
- *
- * Huge Nasty Error Table
- *
- * Plan 9 uses error strings, Unix uses error numbers.  This table tries to
- * match UNIX strings and Plan 9 strings to unix error numbers.  It is used
- * to preload the dynamic error table which can also track user-specific error
- * strings.
- *
- *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
- *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2
- *  as published by the Free Software Foundation.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to:
- *  Free Software Foundation
- *  51 Franklin Street, Fifth Floor
- *  Boston, MA  02111-1301  USA
- *
- */
-
-#include <linux/errno.h>
-#include <asm/errno.h>
-
-struct errormap {
-        char *name;
-        int val;
-
-        int namelen;
-        struct hlist_node list;
-};
-
-#define ERRHASHSZ               32
-static struct hlist_head hash_errmap[ERRHASHSZ];
-
-/* FixMe - reduce to a reasonable size */
-static struct errormap errmap[] = {
-        {"Operation not permitted", EPERM},
-        {"wstat prohibited", EPERM},
-        {"No such file or directory", ENOENT},
-        {"directory entry not found", ENOENT},
-        {"file not found", ENOENT},
-        {"Interrupted system call", EINTR},
-        {"Input/output error", EIO},
-        {"No such device or address", ENXIO},
-        {"Argument list too long", E2BIG},
-        {"Bad file descriptor", EBADF},
-        {"Resource temporarily unavailable", EAGAIN},
-        {"Cannot allocate memory", ENOMEM},
-        {"Permission denied", EACCES},
-        {"Bad address", EFAULT},
-        {"Block device required", ENOTBLK},
-        {"Device or resource busy", EBUSY},
-        {"File exists", EEXIST},
-        {"Invalid cross-device link", EXDEV},
-        {"No such device", ENODEV},
-        {"Not a directory", ENOTDIR},
-        {"Is a directory", EISDIR},
-        {"Invalid argument", EINVAL},
-        {"Too many open files in system", ENFILE},
-        {"Too many open files", EMFILE},
-        {"Text file busy", ETXTBSY},
-        {"File too large", EFBIG},
-        {"No space left on device", ENOSPC},
-        {"Illegal seek", ESPIPE},
-        {"Read-only file system", EROFS},
-        {"Too many links", EMLINK},
-        {"Broken pipe", EPIPE},
-        {"Numerical argument out of domain", EDOM},
-        {"Numerical result out of range", ERANGE},
-        {"Resource deadlock avoided", EDEADLK},
-        {"File name too long", ENAMETOOLONG},
-        {"No locks available", ENOLCK},
-        {"Function not implemented", ENOSYS},
-        {"Directory not empty", ENOTEMPTY},
-        {"Too many levels of symbolic links", ELOOP},
-        {"No message of desired type", ENOMSG},
-        {"Identifier removed", EIDRM},
-        {"No data available", ENODATA},
-        {"Machine is not on the network", ENONET},
-        {"Package not installed", ENOPKG},
-        {"Object is remote", EREMOTE},
-        {"Link has been severed", ENOLINK},
-        {"Communication error on send", ECOMM},
-        {"Protocol error", EPROTO},
-        {"Bad message", EBADMSG},
-        {"File descriptor in bad state", EBADFD},
-        {"Streams pipe error", ESTRPIPE},
-        {"Too many users", EUSERS},
-        {"Socket operation on non-socket", ENOTSOCK},
-        {"Message too long", EMSGSIZE},
-        {"Protocol not available", ENOPROTOOPT},
-        {"Protocol not supported", EPROTONOSUPPORT},
-        {"Socket type not supported", ESOCKTNOSUPPORT},
-        {"Operation not supported", EOPNOTSUPP},
-        {"Protocol family not supported", EPFNOSUPPORT},
-        {"Network is down", ENETDOWN},
-        {"Network is unreachable", ENETUNREACH},
-        {"Network dropped connection on reset", ENETRESET},
-        {"Software caused connection abort", ECONNABORTED},
-        {"Connection reset by peer", ECONNRESET},
-        {"No buffer space available", ENOBUFS},
-        {"Transport endpoint is already connected", EISCONN},
-        {"Transport endpoint is not connected", ENOTCONN},
-        {"Cannot send after transport endpoint shutdown", ESHUTDOWN},
-        {"Connection timed out", ETIMEDOUT},
-        {"Connection refused", ECONNREFUSED},
-        {"Host is down", EHOSTDOWN},
-        {"No route to host", EHOSTUNREACH},
-        {"Operation already in progress", EALREADY},
-        {"Operation now in progress", EINPROGRESS},
-        {"Is a named type file", EISNAM},
-        {"Remote I/O error", EREMOTEIO},
-        {"Disk quota exceeded", EDQUOT},
-/* errors from fossil, vacfs, and u9fs */
-        {"fid unknown or out of range", EBADF},
-        {"permission denied", EACCES},
-        {"file does not exist", ENOENT},
-        {"authentication failed", ECONNREFUSED},
-        {"bad offset in directory read", ESPIPE},
-        {"bad use of fid", EBADF},
-        {"wstat can't convert between files and directories", EPERM},
-        {"directory is not empty", ENOTEMPTY},
-        {"file exists", EEXIST},
-        {"file already exists", EEXIST},
-        {"file or directory already exists", EEXIST},
-        {"fid already in use", EBADF},
-        {"file in use", ETXTBSY},
-        {"i/o error", EIO},
-        {"file already open for I/O", ETXTBSY},
-        {"illegal mode", EINVAL},
-        {"illegal name", ENAMETOOLONG},
-        {"not a directory", ENOTDIR},
-        {"not a member of proposed group", EPERM},
-        {"not owner", EACCES},
-        {"only owner can change group in wstat", EACCES},
-        {"read only file system", EROFS},
-        {"no access to special file", EPERM},
-        {"i/o count too large", EIO},
-        {"unknown group", EINVAL},
-        {"unknown user", EINVAL},
-        {"bogus wstat buffer", EPROTO},
-        {"exclusive use file already open", EAGAIN},
-        {"corrupted directory entry", EIO},
-        {"corrupted file entry", EIO},
-        {"corrupted block label", EIO},
-        {"corrupted meta data", EIO},
-        {"illegal offset", EINVAL},
-        {"illegal path element", ENOENT},
-        {"root of file system is corrupted", EIO},
-        {"corrupted super block", EIO},
-        {"protocol botch", EPROTO},
-        {"file system is full", ENOSPC},
-        {"file is in use", EAGAIN},
-        {"directory entry is not allocated", ENOENT},
-        {"file is read only", EROFS},
-        {"file has been removed", EIDRM},
-        {"only support truncation to zero length", EPERM},
-        {"cannot remove root", EPERM},
-        {"file too big", EFBIG},
-        {"venti i/o error", EIO},
-        /* these are not errors */
-        {"u9fs rhostsauth: no authentication required", 0},
-        {"u9fs authnone: no authentication required", 0},
-        {NULL, -1}
-};
-
-extern int v9fs_error_init(void);
diff --git a/fs/9p/fcall.c b/fs/9p/fcall.c
deleted file mode 100644
index dc336a67592..00000000000
--- a/fs/9p/fcall.c
+++ /dev/null
@@ -1,427 +0,0 @@
-/*
- *  linux/fs/9p/fcall.c
- *
- *  This file contains functions to perform synchronous 9P calls
- *
- *  Copyright (C) 2004 by Latchesar Ionkov <lucho@ionkov.net>
- *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
- *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2
- *  as published by the Free Software Foundation.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to:
- *  Free Software Foundation
- *  51 Franklin Street, Fifth Floor
- *  Boston, MA  02111-1301  USA
- *
- */
-
-#include <linux/module.h>
-#include <linux/errno.h>
-#include <linux/fs.h>
-#include <linux/sched.h>
-#include <linux/idr.h>
-
-#include "debug.h"
-#include "v9fs.h"
-#include "9p.h"
-#include "conv.h"
-#include "mux.h"
-
-/**
- * v9fs_t_version - negotiate protocol parameters with sever
- * @v9ses: 9P2000 session information
- * @msize: requested max size packet
- * @version: requested version.extension string
- * @fcall: pointer to response fcall pointer
- *
- */
-
-int
-v9fs_t_version(struct v9fs_session_info *v9ses, u32 msize,
-               char *version, struct v9fs_fcall **rcp)
-{
-        int ret;
-        struct v9fs_fcall *tc;
-
-        dprintk(DEBUG_9P, "msize: %d version: %s\n", msize, version);
-        tc = v9fs_create_tversion(msize, version);
-
-        if (!IS_ERR(tc)) {
-                ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
-                kfree(tc);
-        } else
-                ret = PTR_ERR(tc);
-
-        return ret;
-}
-
-/**
- * v9fs_t_attach - mount the server
- * @v9ses: 9P2000 session information
- * @uname: user name doing the attach
- * @aname: remote name being attached to
- * @fid: mount fid to attatch to root node
- * @afid: authentication fid (in this case result key)
- * @fcall: pointer to response fcall pointer
- *
- */
-
-int
-v9fs_t_attach(struct v9fs_session_info *v9ses, char *uname, char *aname,
-              u32 fid, u32 afid, struct v9fs_fcall **rcp)
-{
-        int ret;
-        struct v9fs_fcall* tc;
-
-        dprintk(DEBUG_9P, "uname '%s' aname '%s' fid %d afid %d\n", uname,
-                aname, fid, afid);
-
-        tc = v9fs_create_tattach(fid, afid, uname, aname);
-        if (!IS_ERR(tc)) {
-                ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
-                kfree(tc);
-        } else
-                ret = PTR_ERR(tc);
-
-        return ret;
-}
-
-static void v9fs_t_clunk_cb(void *a, struct v9fs_fcall *tc,
-        struct v9fs_fcall *rc, int err)
-{
-        int fid, id;
-        struct v9fs_session_info *v9ses;
-
-        id = 0;
-        fid = tc->params.tclunk.fid;
-        if (rc)
-                id = rc->id;
-
-        kfree(tc);
-        kfree(rc);
-        if (id == RCLUNK) {
-                v9ses = a;
-                v9fs_put_idpool(fid, &v9ses->fidpool);
-        }
-}
-
-/**
- * v9fs_t_clunk - release a fid (finish a transaction)
- * @v9ses: 9P2000 session information
- * @fid: fid to release
- * @fcall: pointer to response fcall pointer
- *
- */
-
-int
-v9fs_t_clunk(struct v9fs_session_info *v9ses, u32 fid)
-{
-        int ret;
-        struct v9fs_fcall *tc, *rc;
-
-        dprintk(DEBUG_9P, "fid %d\n", fid);
-
-        rc = NULL;
-        tc = v9fs_create_tclunk(fid);
-        if (!IS_ERR(tc))
-                ret = v9fs_mux_rpc(v9ses->mux, tc, &rc);
-        else
-                ret = PTR_ERR(tc);
-
-        if (ret)
-                dprintk(DEBUG_ERROR, "failed fid %d err %d\n", fid, ret);
-
-        v9fs_t_clunk_cb(v9ses, tc, rc, ret);
-        return ret;
-}
-
-#if 0
-/**
- * v9fs_v9fs_t_flush - flush a pending transaction
- * @v9ses: 9P2000 session information
- * @tag: tag to release
- *
- */
-int v9fs_t_flush(struct v9fs_session_info *v9ses, u16 oldtag)
-{
-        int ret;
-        struct v9fs_fcall *tc;
-
-        dprintk(DEBUG_9P, "oldtag %d\n", oldtag);
-
-        tc = v9fs_create_tflush(oldtag);
-        if (!IS_ERR(tc)) {
-                ret = v9fs_mux_rpc(v9ses->mux, tc, NULL);
-                kfree(tc);
-        } else
-                ret = PTR_ERR(tc);
-
-        return ret;
-}
-#endif
-
-/**
- * v9fs_t_stat - read a file's meta-data
- * @v9ses: 9P2000 session information
- * @fid: fid pointing to file or directory to get info about
- * @fcall: pointer to response fcall
- *
- */
-
-int
-v9fs_t_stat(struct v9fs_session_info *v9ses, u32 fid, struct v9fs_fcall **rcp)
-{
-        int ret;
-        struct v9fs_fcall *tc;
-
-        dprintk(DEBUG_9P, "fid %d\n", fid);
-
-        ret = -ENOMEM;
-        tc = v9fs_create_tstat(fid);
-        if (!IS_ERR(tc)) {
-                ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
-                kfree(tc);
-        } else
-                ret = PTR_ERR(tc);
-
-        return ret;
-}
-
-/**
- * v9fs_t_wstat - write a file's meta-data
- * @v9ses: 9P2000 session information
- * @fid: fid pointing to file or directory to write info about
- * @stat: metadata
- * @fcall: pointer to response fcall
- *
- */
-
-int
-v9fs_t_wstat(struct v9fs_session_info *v9ses, u32 fid,
-             struct v9fs_wstat *wstat, struct v9fs_fcall **rcp)
-{
-        int ret;
-        struct v9fs_fcall *tc;
-
-        dprintk(DEBUG_9P, "fid %d\n", fid);
-
-        tc = v9fs_create_twstat(fid, wstat, v9ses->extended);
-        if (!IS_ERR(tc)) {
-                ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
-                kfree(tc);
-        } else
-                ret = PTR_ERR(tc);
-
-        return ret;
-}
-
-/**
- * v9fs_t_walk - walk a fid to a new file or directory
- * @v9ses: 9P2000 session information
- * @fid: fid to walk
- * @newfid: new fid (for clone operations)
- * @name: path to walk fid to
- * @fcall: pointer to response fcall
- *
- */
-
-/* TODO: support multiple walk */
-
-int
-v9fs_t_walk(struct v9fs_session_info *v9ses, u32 fid, u32 newfid,
-            char *name, struct v9fs_fcall **rcp)
-{
-        int ret;
-        struct v9fs_fcall *tc;
-        int nwname;
-
-        dprintk(DEBUG_9P, "fid %d newfid %d wname '%s'\n", fid, newfid, name);
-
-        if (name)
-                nwname = 1;
-        else
-                nwname = 0;
-
-        tc = v9fs_create_twalk(fid, newfid, nwname, &name);
-        if (!IS_ERR(tc)) {
-                ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
-                kfree(tc);
-        } else
-                ret = PTR_ERR(tc);
-
-        return ret;
-}
-
-/**
- * v9fs_t_open - open a file
- *
- * @v9ses - 9P2000 session information
- * @fid - fid to open
- * @mode - mode to open file (R, RW, etc)
- * @fcall - pointer to response fcall
- *
- */
-
-int
-v9fs_t_open(struct v9fs_session_info *v9ses, u32 fid, u8 mode,
-            struct v9fs_fcall **rcp)
-{
-        int ret;
-        struct v9fs_fcall *tc;
-
-        dprintk(DEBUG_9P, "fid %d mode %d\n", fid, mode);
-
-        tc = v9fs_create_topen(fid, mode);
-        if (!IS_ERR(tc)) {
-                ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
-                kfree(tc);
-        } else
-                ret = PTR_ERR(tc);
-
-        return ret;
-}
-
-/**
- * v9fs_t_remove - remove a file or directory
- * @v9ses: 9P2000 session information
- * @fid: fid to remove
- * @fcall: pointer to response fcall
- *
- */
-
-int
-v9fs_t_remove(struct v9fs_session_info *v9ses, u32 fid,
-              struct v9fs_fcall **rcp)
-{
-        int ret;
-        struct v9fs_fcall *tc;
-
-        dprintk(DEBUG_9P, "fid %d\n", fid);
-
-        tc = v9fs_create_tremove(fid);
-        if (!IS_ERR(tc)) {
-                ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
-                kfree(tc);
-        } else
-                ret = PTR_ERR(tc);
-
-        return ret;
-}
-
-/**
- * v9fs_t_create - create a file or directory
- * @v9ses: 9P2000 session information
- * @fid: fid to create
- * @name: name of the file or directory to create
- * @perm: permissions to create with
- * @mode: mode to open file (R, RW, etc)
- * @fcall: pointer to response fcall
- *
- */
-
-int
-v9fs_t_create(struct v9fs_session_info *v9ses, u32 fid, char *name, u32 perm,
-        u8 mode, char *extension, struct v9fs_fcall **rcp)
-{
-        int ret;
-        struct v9fs_fcall *tc;
-
-        dprintk(DEBUG_9P, "fid %d name '%s' perm %x mode %d\n",
-                fid, name, perm, mode);
-
-        tc = v9fs_create_tcreate(fid, name, perm, mode, extension,
-                v9ses->extended);
-
-        if (!IS_ERR(tc)) {
-                ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
-                kfree(tc);
-        } else
-                ret = PTR_ERR(tc);
-
-        return ret;
-}
-
-/**
- * v9fs_t_read - read data
- * @v9ses: 9P2000 session information
- * @fid: fid to read from
- * @offset: offset to start read at
- * @count: how many bytes to read
- * @fcall: pointer to response fcall (with data)
- *
- */
-
-int
-v9fs_t_read(struct v9fs_session_info *v9ses, u32 fid, u64 offset,
-            u32 count, struct v9fs_fcall **rcp)
-{
-        int ret;
-        struct v9fs_fcall *tc, *rc;
-
-        dprintk(DEBUG_9P, "fid %d offset 0x%llux count 0x%x\n", fid,
-                (long long unsigned) offset, count);
-
-        tc = v9fs_create_tread(fid, offset, count);
-        if (!IS_ERR(tc)) {
-                ret = v9fs_mux_rpc(v9ses->mux, tc, &rc);
-                if (!ret)
-                        ret = rc->params.rread.count;
-                if (rcp)
-                        *rcp = rc;
-                else
-                        kfree(rc);
-
-                kfree(tc);
-        } else
-                ret = PTR_ERR(tc);
-
-        return ret;
-}
-
-/**
- * v9fs_t_write - write data
- * @v9ses: 9P2000 session information
- * @fid: fid to write to
- * @offset: offset to start write at
- * @count: how many bytes to write
- * @fcall: pointer to response fcall
- *
- */
-
-int
-v9fs_t_write(struct v9fs_session_info *v9ses, u32 fid, u64 offset, u32 count,
-        const char __user *data, struct v9fs_fcall **rcp)
-{
-        int ret;
-        struct v9fs_fcall *tc, *rc;
-
-        dprintk(DEBUG_9P, "fid %d offset 0x%llux count 0x%x\n", fid,
-                (long long unsigned) offset, count);
-
-        tc = v9fs_create_twrite(fid, offset, count, data);
-        if (!IS_ERR(tc)) {
-                ret = v9fs_mux_rpc(v9ses->mux, tc, &rc);
-
-                if (!ret)
-                        ret = rc->params.rwrite.count;
-                if (rcp)
-                        *rcp = rc;
-                else
-                        kfree(rc);
-
-                kfree(tc);
-        } else
-                ret = PTR_ERR(tc);
-
-        return ret;
-}
-
diff --git a/fs/9p/fcprint.c b/fs/9p/fcprint.c
deleted file mode 100644
index 34b96114a28..00000000000
--- a/fs/9p/fcprint.c
+++ /dev/null
@@ -1,345 +0,0 @@
-/*
- *  linux/fs/9p/fcprint.c
- *
- *  Print 9P call.
- *
- *  Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2
- *  as published by the Free Software Foundation.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to:
- *  Free Software Foundation
- *  51 Franklin Street, Fifth Floor
- *  Boston, MA  02111-1301  USA
- *
- */
-#include <linux/module.h>
-#include <linux/errno.h>
-#include <linux/fs.h>
-#include <linux/idr.h>
-
-#include "debug.h"
-#include "v9fs.h"
-#include "9p.h"
-#include "mux.h"
-
-static int
-v9fs_printqid(char *buf, int buflen, struct v9fs_qid *q)
-{
-        int n;
-        char b[10];
-
-        n = 0;
-        if (q->type & V9FS_QTDIR)
-                b[n++] = 'd';
-        if (q->type & V9FS_QTAPPEND)
-                b[n++] = 'a';
-        if (q->type & V9FS_QTAUTH)
-                b[n++] = 'A';
-        if (q->type & V9FS_QTEXCL)
-                b[n++] = 'l';
-        if (q->type & V9FS_QTTMP)
-                b[n++] = 't';
-        if (q->type & V9FS_QTSYMLINK)
-                b[n++] = 'L';
-        b[n] = '\0';
-
-        return scnprintf(buf, buflen, "(%.16llx %x %s)", (long long int) q->path,
-                q->version, b);
-}
-
-static int
-v9fs_printperm(char *buf, int buflen, int perm)
-{
-        int n;
-        char b[15];
-
-        n = 0;
-        if (perm & V9FS_DMDIR)
-                b[n++] = 'd';
-        if (perm & V9FS_DMAPPEND)
-                b[n++] = 'a';
-        if (perm & V9FS_DMAUTH)
-                b[n++] = 'A';
-        if (perm & V9FS_DMEXCL)
-                b[n++] = 'l';
-        if (perm & V9FS_DMTMP)
-                b[n++] = 't';
-        if (perm & V9FS_DMDEVICE)
-                b[n++] = 'D';
-        if (perm & V9FS_DMSOCKET)
-                b[n++] = 'S';
-        if (perm & V9FS_DMNAMEDPIPE)
-                b[n++] = 'P';
-        if (perm & V9FS_DMSYMLINK)
-                b[n++] = 'L';
-        b[n] = '\0';
-
-        return scnprintf(buf, buflen, "%s%03o", b, perm&077);
-}
-
-static int
-v9fs_printstat(char *buf, int buflen, struct v9fs_stat *st, int extended)
-{
-        int n;
-
-        n = scnprintf(buf, buflen, "'%.*s' '%.*s'", st->name.len,
-                st->name.str, st->uid.len, st->uid.str);
-        if (extended)
-                n += scnprintf(buf+n, buflen-n, "(%d)", st->n_uid);
-
-        n += scnprintf(buf+n, buflen-n, " '%.*s'", st->gid.len, st->gid.str);
-        if (extended)
-                n += scnprintf(buf+n, buflen-n, "(%d)", st->n_gid);
-
-        n += scnprintf(buf+n, buflen-n, " '%.*s'", st->muid.len, st->muid.str);
-        if (extended)
-                n += scnprintf(buf+n, buflen-n, "(%d)", st->n_muid);
-
-        n += scnprintf(buf+n, buflen-n, " q ");
-        n += v9fs_printqid(buf+n, buflen-n, &st->qid);
-        n += scnprintf(buf+n, buflen-n, " m ");
-        n += v9fs_printperm(buf+n, buflen-n, st->mode);
-        n += scnprintf(buf+n, buflen-n, " at %d mt %d l %lld",
-                st->atime, st->mtime, (long long int) st->length);
-
-        if (extended)
-                n += scnprintf(buf+n, buflen-n, " ext '%.*s'",
-                        st->extension.len, st->extension.str);
-
-        return n;
-}
-
-static int
-v9fs_dumpdata(char *buf, int buflen, u8 *data, int datalen)
-{
-        int i, n;
-
-        i = n = 0;
-        while (i < datalen) {
-                n += scnprintf(buf + n, buflen - n, "%02x", data[i]);
-                if (i%4 == 3)
-                        n += scnprintf(buf + n, buflen - n, " ");
-                if (i%32 == 31)
-                        n += scnprintf(buf + n, buflen - n, "\n");
-
-                i++;
-        }
-        n += scnprintf(buf + n, buflen - n, "\n");
-
-        return n;
-}
-
-static int
-v9fs_printdata(char *buf, int buflen, u8 *data, int datalen)
-{
-        return v9fs_dumpdata(buf, buflen, data, datalen<16?datalen:16);
-}
-
-int
-v9fs_printfcall(char *buf, int buflen, struct v9fs_fcall *fc, int extended)
-{
-        int i, ret, type, tag;
-
-        if (!fc)
-                return scnprintf(buf, buflen, "<NULL>");
-
-        type = fc->id;
-        tag = fc->tag;
-
-        ret = 0;
-        switch (type) {
-        case TVERSION:
-                ret += scnprintf(buf+ret, buflen-ret,
-                        "Tversion tag %u msize %u version '%.*s'", tag,
-                        fc->params.tversion.msize, fc->params.tversion.version.len,
-                        fc->params.tversion.version.str);
-                break;
-
-        case RVERSION:
-                ret += scnprintf(buf+ret, buflen-ret,
-                        "Rversion tag %u msize %u version '%.*s'", tag,
-                        fc->params.rversion.msize, fc->params.rversion.version.len,
-                        fc->params.rversion.version.str);
-                break;
-
-        case TAUTH:
-                ret += scnprintf(buf+ret, buflen-ret,
-                        "Tauth tag %u afid %d uname '%.*s' aname '%.*s'", tag,
-                        fc->params.tauth.afid, fc->params.tauth.uname.len,
-                        fc->params.tauth.uname.str, fc->params.tauth.aname.len,
-                        fc->params.tauth.aname.str);
-                break;
-
-        case RAUTH:
-                ret += scnprintf(buf+ret, buflen-ret, "Rauth tag %u qid ", tag);
-                v9fs_printqid(buf+ret, buflen-ret, &fc->params.rauth.qid);
-                break;
-
-        case TATTACH:
-                ret += scnprintf(buf+ret, buflen-ret,
-                        "Tattach tag %u fid %d afid %d uname '%.*s' aname '%.*s'",
-                        tag, fc->params.tattach.fid, fc->params.tattach.afid,
-                        fc->params.tattach.uname.len, fc->params.tattach.uname.str,
-                        fc->params.tattach.aname.len, fc->params.tattach.aname.str);
-                break;
-
-        case RATTACH:
-                ret += scnprintf(buf+ret, buflen-ret, "Rattach tag %u qid ", tag);
-                v9fs_printqid(buf+ret, buflen-ret, &fc->params.rattach.qid);
-                break;
-
-        case RERROR:
-                ret += scnprintf(buf+ret, buflen-ret, "Rerror tag %u ename '%.*s'",
-                        tag, fc->params.rerror.error.len,
-                        fc->params.rerror.error.str);
-                if (extended)
-                        ret += scnprintf(buf+ret, buflen-ret, " ecode %d\n",
-                                fc->params.rerror.errno);
-                break;
-
-        case TFLUSH:
-                ret += scnprintf(buf+ret, buflen-ret, "Tflush tag %u oldtag %u",
-                        tag, fc->params.tflush.oldtag);
-                break;
-
-        case RFLUSH:
-                ret += scnprintf(buf+ret, buflen-ret, "Rflush tag %u", tag);
-                break;
-
-        case TWALK:
-                ret += scnprintf(buf+ret, buflen-ret,
-                        "Twalk tag %u fid %d newfid %d nwname %d", tag,
-                        fc->params.twalk.fid, fc->params.twalk.newfid,
-                        fc->params.twalk.nwname);
-                for(i = 0; i < fc->params.twalk.nwname; i++)
-                        ret += scnprintf(buf+ret, buflen-ret," '%.*s'",
-                                fc->params.twalk.wnames[i].len,
-                                fc->params.twalk.wnames[i].str);
-                break;
-
-        case RWALK:
-                ret += scnprintf(buf+ret, buflen-ret, "Rwalk tag %u nwqid %d",
-                        tag, fc->params.rwalk.nwqid);
-                for(i = 0; i < fc->params.rwalk.nwqid; i++)
-                        ret += v9fs_printqid(buf+ret, buflen-ret,
-                                &fc->params.rwalk.wqids[i]);
-                break;
-
-        case TOPEN:
-                ret += scnprintf(buf+ret, buflen-ret,
-                        "Topen tag %u fid %d mode %d", tag,
-                        fc->params.topen.fid, fc->params.topen.mode);
-                break;
-
-        case ROPEN:
-                ret += scnprintf(buf+ret, buflen-ret, "Ropen tag %u", tag);
-                ret += v9fs_printqid(buf+ret, buflen-ret, &fc->params.ropen.qid);
-                ret += scnprintf(buf+ret, buflen-ret," iounit %d",
-                        fc->params.ropen.iounit);
-                break;
-
-        case TCREATE:
-                ret += scnprintf(buf+ret, buflen-ret,
-                        "Tcreate tag %u fid %d name '%.*s' perm ", tag,
-                        fc->params.tcreate.fid, fc->params.tcreate.name.len,
-                        fc->params.tcreate.name.str);
-
-                ret += v9fs_printperm(buf+ret, buflen-ret, fc->params.tcreate.perm);
-                ret += scnprintf(buf+ret, buflen-ret, " mode %d",
-                        fc->params.tcreate.mode);
-                break;
-
-        case RCREATE:
-                ret += scnprintf(buf+ret, buflen-ret, "Rcreate tag %u", tag);
-                ret += v9fs_printqid(buf+ret, buflen-ret, &fc->params.rcreate.qid);
-                ret += scnprintf(buf+ret, buflen-ret, " iounit %d",
-                        fc->params.rcreate.iounit);
-                break;
-
-        case TREAD:
-                ret += scnprintf(buf+ret, buflen-ret,
-                        "Tread tag %u fid %d offset %lld count %u", tag,
-                        fc->params.tread.fid,
-                        (long long int) fc->params.tread.offset,
-                        fc->params.tread.count);
-                break;
-
-        case RREAD:
-                ret += scnprintf(buf+ret, buflen-ret,
-                        "Rread tag %u count %u data ", tag,
-                        fc->params.rread.count);
-                ret += v9fs_printdata(buf+ret, buflen-ret, fc->params.rread.data,
-                        fc->params.rread.count);
-                break;
-
-        case TWRITE:
-                ret += scnprintf(buf+ret, buflen-ret,
-                        "Twrite tag %u fid %d offset %lld count %u data ",
-                        tag, fc->params.twrite.fid,
-                        (long long int) fc->params.twrite.offset,
-                        fc->params.twrite.count);
-                ret += v9fs_printdata(buf+ret, buflen-ret, fc->params.twrite.data,
-                        fc->params.twrite.count);
-                break;
-
-        case RWRITE:
-                ret += scnprintf(buf+ret, buflen-ret, "Rwrite tag %u count %u",
-                        tag, fc->params.rwrite.count);
-                break;
-
-        case TCLUNK:
-                ret += scnprintf(buf+ret, buflen-ret, "Tclunk tag %u fid %d",
-                        tag, fc->params.tclunk.fid);
-                break;
-
-        case RCLUNK:
-                ret += scnprintf(buf+ret, buflen-ret, "Rclunk tag %u", tag);
-                break;
-
-        case TREMOVE:
-                ret += scnprintf(buf+ret, buflen-ret, "Tremove tag %u fid %d",
-                        tag, fc->params.tremove.fid);
-                break;
-
-        case RREMOVE:
-                ret += scnprintf(buf+ret, buflen-ret, "Rremove tag %u", tag);
-                break;
-
-        case TSTAT:
-                ret += scnprintf(buf+ret, buflen-ret, "Tstat tag %u fid %d",
-                        tag, fc->params.tstat.fid);
-                break;
-
-        case RSTAT:
-                ret += scnprintf(buf+ret, buflen-ret, "Rstat tag %u ", tag);
-                ret += v9fs_printstat(buf+ret, buflen-ret, &fc->params.rstat.stat,
-                        extended);
-                break;
-
-        case TWSTAT:
-                ret += scnprintf(buf+ret, buflen-ret, "Twstat tag %u fid %d ",
-                        tag, fc->params.twstat.fid);
-                ret += v9fs_printstat(buf+ret, buflen-ret, &fc->params.twstat.stat,
-                        extended);
-                break;
-
-        case RWSTAT:
-                ret += scnprintf(buf+ret, buflen-ret, "Rwstat tag %u", tag);
-                break;
-
-        default:
-                ret += scnprintf(buf+ret, buflen-ret, "unknown type %d", type);
-                break;
-        }
-
-        return ret;
-}
diff --git a/fs/9p/fid.c b/fs/9p/fid.c
index 90419715c7e..08fa320b7e6 100644
--- a/fs/9p/fid.c
+++ b/fs/9p/fid.c
@@ -26,10 +26,10 @@
 #include <linux/sched.h>
 #include <linux/idr.h>
 #include <asm/semaphore.h>
+#include <net/9p/9p.h>
+#include <net/9p/client.h>
 
-#include "debug.h"
 #include "v9fs.h"
-#include "9p.h"
 #include "v9fs_vfs.h"
 #include "fid.h"
 
@@ -40,67 +40,29 @@
  *
  */
 
-int v9fs_fid_insert(struct v9fs_fid *fid, struct dentry *dentry)
+int v9fs_fid_add(struct dentry *dentry, struct p9_fid *fid)
 {
-        struct list_head *fid_list = (struct list_head *)dentry->d_fsdata;
-        dprintk(DEBUG_9P, "fid %d (%p) dentry %s (%p)\n", fid->fid, fid,
-                dentry->d_iname, dentry);
-        if (dentry->d_fsdata == NULL) {
-                dentry->d_fsdata =
-                    kmalloc(sizeof(struct list_head), GFP_KERNEL);
-                if (dentry->d_fsdata == NULL) {
-                        dprintk(DEBUG_ERROR, "Out of memory\n");
-                        return -ENOMEM;
-                }
-                fid_list = (struct list_head *)dentry->d_fsdata;
-                INIT_LIST_HEAD(fid_list);       /* Initialize list head */
-        }
+        struct v9fs_dentry *dent;
 
-        fid->uid = current->uid;
-        list_add(&fid->list, fid_list);
-        return 0;
-}
+        P9_DPRINTK(P9_DEBUG_VFS, "fid %d dentry %s\n",
+                                        fid->fid, dentry->d_iname);
 
-/**
- * v9fs_fid_create - allocate a FID structure
- * @dentry - dentry to link newly created fid to
- *
- */
-
-struct v9fs_fid *v9fs_fid_create(struct v9fs_session_info *v9ses, int fid)
-{
-        struct v9fs_fid *new;
+        dent = dentry->d_fsdata;
+        if (!dent) {
+                dent = kmalloc(sizeof(struct v9fs_dentry), GFP_KERNEL);
+                if (!dent)
+                        return -ENOMEM;
 
-        dprintk(DEBUG_9P, "fid create fid %d\n", fid);
-        new = kmalloc(sizeof(struct v9fs_fid), GFP_KERNEL);
-        if (new == NULL) {
-                dprintk(DEBUG_ERROR, "Out of Memory\n");
-                return ERR_PTR(-ENOMEM);
+                spin_lock_init(&dent->lock);
+                INIT_LIST_HEAD(&dent->fidlist);
+                dentry->d_fsdata = dent;
         }
 
-        new->fid = fid;
-        new->v9ses = v9ses;
-        new->fidopen = 0;
-        new->fidclunked = 0;
-        new->iounit = 0;
-        new->rdir_pos = 0;
-        new->rdir_fcall = NULL;
-        init_MUTEX(&new->lock);
-        INIT_LIST_HEAD(&new->list);
-
-        return new;
-}
-
-/**
- * v9fs_fid_destroy - deallocate a FID structure
- * @fid: fid to destroy
- *
- */
+        spin_lock(&dent->lock);
+        list_add(&fid->dlist, &dent->fidlist);
+        spin_unlock(&dent->lock);
 
-void v9fs_fid_destroy(struct v9fs_fid *fid)
-{
-        list_del(&fid->list);
-        kfree(fid);
+        return 0;
 }
 
 /**
@@ -114,30 +76,42 @@ void v9fs_fid_destroy(struct v9fs_fid *fid)
  *
  */
 
-struct v9fs_fid *v9fs_fid_lookup(struct dentry *dentry)
+struct p9_fid *v9fs_fid_lookup(struct dentry *dentry)
 {
-        struct list_head *fid_list = (struct list_head *)dentry->d_fsdata;
-        struct v9fs_fid *return_fid = NULL;
-
-        dprintk(DEBUG_9P, " dentry: %s (%p)\n", dentry->d_iname, dentry);
-
-        if (fid_list)
-                return_fid = list_entry(fid_list->next, struct v9fs_fid, list);
+        struct v9fs_dentry *dent;
+        struct p9_fid *fid;
+
+        P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
+        dent = dentry->d_fsdata;
+        if (dent)
+                fid = list_entry(dent->fidlist.next, struct p9_fid, dlist);
+        else
+                fid = ERR_PTR(-EBADF);
+
+        P9_DPRINTK(P9_DEBUG_VFS, " fid: %p\n", fid);
+        return fid;
+}
 
-        if (!return_fid) {
-                dprintk(DEBUG_ERROR, "Couldn't find a fid in dentry\n");
-                return_fid = ERR_PTR(-EBADF);
+struct p9_fid *v9fs_fid_lookup_remove(struct dentry *dentry)
+{
+        struct p9_fid *fid;
+        struct v9fs_dentry *dent;
+
+        dent = dentry->d_fsdata;
+        fid = v9fs_fid_lookup(dentry);
+        if (!IS_ERR(fid)) {
+                spin_lock(&dent->lock);
+                list_del(&fid->dlist);
+                spin_unlock(&dent->lock);
         }
 
-        if(down_interruptible(&return_fid->lock))
-                return ERR_PTR(-EINTR);
-
-        return return_fid;
+        return fid;
 }
 
+
 /**
  * v9fs_fid_clone - lookup the fid for a dentry, clone a private copy and
- *                      release it
+ *      release it
  * @dentry: dentry to look for fid in
  *
  * find a fid in the dentry and then clone to a new private fid
@@ -146,49 +120,15 @@ struct v9fs_fid *v9fs_fid_lookup(struct dentry *dentry)
  *
  */
 
-struct v9fs_fid *v9fs_fid_clone(struct dentry *dentry)
+struct p9_fid *v9fs_fid_clone(struct dentry *dentry)
 {
-        struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
-        struct v9fs_fid *base_fid, *new_fid = ERR_PTR(-EBADF);
-        struct v9fs_fcall *fcall = NULL;
-        int fid, err;
-
-        base_fid = v9fs_fid_lookup(dentry);
-
-        if(IS_ERR(base_fid))
-                return base_fid;
-
-        if(base_fid) {  /* clone fid */
-                fid = v9fs_get_idpool(&v9ses->fidpool);
-                if (fid < 0) {
-                        eprintk(KERN_WARNING, "newfid fails!\n");
-                        new_fid = ERR_PTR(-ENOSPC);
-                        goto Release_Fid;
-                }
-
-                err = v9fs_t_walk(v9ses, base_fid->fid, fid, NULL, &fcall);
-                if (err < 0) {
-                        dprintk(DEBUG_ERROR, "clone walk didn't work\n");
-                        v9fs_put_idpool(fid, &v9ses->fidpool);
-                        new_fid = ERR_PTR(err);
-                        goto Free_Fcall;
-                }
-                new_fid = v9fs_fid_create(v9ses, fid);
-                if (new_fid == NULL) {
-                        dprintk(DEBUG_ERROR, "out of memory\n");
-                        new_fid = ERR_PTR(-ENOMEM);
-                }
-Free_Fcall:
-                kfree(fcall);
-        }
+        struct p9_fid *ofid, *fid;
 
-Release_Fid:
-        up(&base_fid->lock);
-        return new_fid;
-}
+        P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
+        ofid = v9fs_fid_lookup(dentry);
+        if (IS_ERR(ofid))
+                return ofid;
 
-void v9fs_fid_clunk(struct v9fs_session_info *v9ses, struct v9fs_fid *fid)
-{
-        v9fs_t_clunk(v9ses, fid->fid);
-        v9fs_fid_destroy(fid);
+        fid = p9_client_walk(ofid, 0, NULL, 1);
+        return fid;
 }
diff --git a/fs/9p/fid.h b/fs/9p/fid.h
index 48fc170c26c..47a0ba74287 100644
--- a/fs/9p/fid.h
+++ b/fs/9p/fid.h
@@ -22,41 +22,12 @@
 
 #include <linux/list.h>
 
-#define FID_OP   0
-#define FID_WALK 1
-#define FID_CREATE 2
-
-struct v9fs_fid {
-        struct list_head list;   /* list of fids associated with a dentry */
-        struct list_head active; /* XXX - debug */
-
-        struct semaphore lock;
-
-        u32 fid;
-        unsigned char fidopen;    /* set when fid is opened */
-        unsigned char fidclunked; /* set when fid has already been clunked */
-
-        struct v9fs_qid qid;
-        u32 iounit;
-
-        /* readdir stuff */
-        int rdir_fpos;
-        loff_t rdir_pos;
-        struct v9fs_fcall *rdir_fcall;
-
-        /* management stuff */
-        uid_t uid;              /* user associated with this fid */
-
-        /* private data */
-        struct file *filp;      /* backpointer to File struct for open files */
-        struct v9fs_session_info *v9ses;        /* session info for this FID */
+struct v9fs_dentry {
+        spinlock_t lock; /* protect fidlist */
+        struct list_head fidlist;
 };
 
-struct v9fs_fid *v9fs_fid_lookup(struct dentry *dentry);
-struct v9fs_fid *v9fs_fid_get_created(struct dentry *);
-void v9fs_fid_destroy(struct v9fs_fid *fid);
-struct v9fs_fid *v9fs_fid_create(struct v9fs_session_info *, int fid);
-int v9fs_fid_insert(struct v9fs_fid *fid, struct dentry *dentry);
-struct v9fs_fid *v9fs_fid_clone(struct dentry *dentry);
-void v9fs_fid_clunk(struct v9fs_session_info *v9ses, struct v9fs_fid *fid);
-
+struct p9_fid *v9fs_fid_lookup(struct dentry *dentry);
+struct p9_fid *v9fs_fid_lookup_remove(struct dentry *dentry);
+struct p9_fid *v9fs_fid_clone(struct dentry *dentry);
+int v9fs_fid_add(struct dentry *dentry, struct p9_fid *fid);
diff --git a/fs/9p/mux.c b/fs/9p/mux.c
deleted file mode 100644
index c783874a9ca..00000000000
--- a/fs/9p/mux.c
+++ /dev/null
@@ -1,1033 +0,0 @@
-/*
- * linux/fs/9p/mux.c
- *
- * Protocol Multiplexer
- *
- *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
- *  Copyright (C) 2004-2005 by Latchesar Ionkov <lucho@ionkov.net>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2
- *  as published by the Free Software Foundation.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to:
- *  Free Software Foundation
- *  51 Franklin Street, Fifth Floor
- *  Boston, MA  02111-1301  USA
- *
- */
-
-#include <linux/module.h>
-#include <linux/errno.h>
-#include <linux/fs.h>
-#include <linux/poll.h>
-#include <linux/kthread.h>
-#include <linux/idr.h>
-#include <linux/mutex.h>
-
-#include "debug.h"
-#include "v9fs.h"
-#include "9p.h"
-#include "conv.h"
-#include "transport.h"
-#include "mux.h"
-
-#define ERREQFLUSH      1
-#define SCHED_TIMEOUT   10
-#define MAXPOLLWADDR    2
-
-enum {
-        Rworksched = 1,         /* read work scheduled or running */
-        Rpending = 2,           /* can read */
-        Wworksched = 4,         /* write work scheduled or running */
-        Wpending = 8,           /* can write */
-};
-
-enum {
-        None,
-        Flushing,
-        Flushed,
-};
-
-struct v9fs_mux_poll_task;
-
-struct v9fs_req {
-        spinlock_t lock;
-        int tag;
-        struct v9fs_fcall *tcall;
-        struct v9fs_fcall *rcall;
-        int err;
-        v9fs_mux_req_callback cb;
-        void *cba;
-        int flush;
-        struct list_head req_list;
-};
-
-struct v9fs_mux_data {
-        spinlock_t lock;
-        struct list_head mux_list;
-        struct v9fs_mux_poll_task *poll_task;
-        int msize;
-        unsigned char *extended;
-        struct v9fs_transport *trans;
-        struct v9fs_idpool tagpool;
-        int err;
-        wait_queue_head_t equeue;
-        struct list_head req_list;
-        struct list_head unsent_req_list;
-        struct v9fs_fcall *rcall;
-        int rpos;
-        char *rbuf;
-        int wpos;
-        int wsize;
-        char *wbuf;
-        wait_queue_t poll_wait[MAXPOLLWADDR];
-        wait_queue_head_t *poll_waddr[MAXPOLLWADDR];
-        poll_table pt;
-        struct work_struct rq;
-        struct work_struct wq;
-        unsigned long wsched;
-};
-
-struct v9fs_mux_poll_task {
-        struct task_struct *task;
-        struct list_head mux_list;
-        int muxnum;
-};
-
-struct v9fs_mux_rpc {
-        struct v9fs_mux_data *m;
-        int err;
-        struct v9fs_fcall *tcall;
-        struct v9fs_fcall *rcall;
-        wait_queue_head_t wqueue;
-};
-
-static int v9fs_poll_proc(void *);
-static void v9fs_read_work(struct work_struct *work);
-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 *);
-static void v9fs_mux_put_tag(struct v9fs_mux_data *, u16);
-
-static DEFINE_MUTEX(v9fs_mux_task_lock);
-static struct workqueue_struct *v9fs_mux_wq;
-
-static int v9fs_mux_num;
-static int v9fs_mux_poll_task_num;
-static struct v9fs_mux_poll_task v9fs_mux_poll_tasks[100];
-
-int v9fs_mux_global_init(void)
-{
-        int i;
-
-        for (i = 0; i < ARRAY_SIZE(v9fs_mux_poll_tasks); i++)
-                v9fs_mux_poll_tasks[i].task = NULL;
-
-        v9fs_mux_wq = create_workqueue("v9fs");
-        if (!v9fs_mux_wq) {
-                printk(KERN_WARNING "v9fs: mux: creating workqueue failed\n");
-                return -ENOMEM;
-        }
-
-        return 0;
-}
-
-void v9fs_mux_global_exit(void)
-{
-        destroy_workqueue(v9fs_mux_wq);
-}
-
-/**
- * v9fs_mux_calc_poll_procs - calculates the number of polling procs
- * based on the number of mounted v9fs filesystems.
- *
- * The current implementation returns sqrt of the number of mounts.
- */
-static int v9fs_mux_calc_poll_procs(int muxnum)
-{
-        int n;
-
-        if (v9fs_mux_poll_task_num)
-                n = muxnum / v9fs_mux_poll_task_num +
-                    (muxnum % v9fs_mux_poll_task_num ? 1 : 0);
-        else
-                n = 1;
-
-        if (n > ARRAY_SIZE(v9fs_mux_poll_tasks))
-                n = ARRAY_SIZE(v9fs_mux_poll_tasks);
-
-        return n;
-}
-
-static int v9fs_mux_poll_start(struct v9fs_mux_data *m)
-{
-        int i, n;
-        struct v9fs_mux_poll_task *vpt, *vptlast;
-        struct task_struct *pproc;
-
-        dprintk(DEBUG_MUX, "mux %p muxnum %d procnum %d\n", m, v9fs_mux_num,
-                v9fs_mux_poll_task_num);
-        mutex_lock(&v9fs_mux_task_lock);
-
-        n = v9fs_mux_calc_poll_procs(v9fs_mux_num + 1);
-        if (n > v9fs_mux_poll_task_num) {
-                for (i = 0; i < ARRAY_SIZE(v9fs_mux_poll_tasks); i++) {
-                        if (v9fs_mux_poll_tasks[i].task == NULL) {
-                                vpt = &v9fs_mux_poll_tasks[i];
-                                dprintk(DEBUG_MUX, "create proc %p\n", vpt);
-                                pproc = kthread_create(v9fs_poll_proc, vpt,
-                                                   "v9fs-poll");
-
-                                if (!IS_ERR(pproc)) {
-                                        vpt->task = pproc;
-                                        INIT_LIST_HEAD(&vpt->mux_list);
-                                        vpt->muxnum = 0;
-                                        v9fs_mux_poll_task_num++;
-                                        wake_up_process(vpt->task);
-                                }
-                                break;
-                        }
-                }
-
-                if (i >= ARRAY_SIZE(v9fs_mux_poll_tasks))
-                        dprintk(DEBUG_ERROR, "warning: no free poll slots\n");
-        }
-
-        n = (v9fs_mux_num + 1) / v9fs_mux_poll_task_num +
-            ((v9fs_mux_num + 1) % v9fs_mux_poll_task_num ? 1 : 0);
-
-        vptlast = NULL;
-        for (i = 0; i < ARRAY_SIZE(v9fs_mux_poll_tasks); i++) {
-                vpt = &v9fs_mux_poll_tasks[i];
-                if (vpt->task != NULL) {
-                        vptlast = vpt;
-                        if (vpt->muxnum < n) {
-                                dprintk(DEBUG_MUX, "put in proc %d\n", i);
-                                list_add(&m->mux_list, &vpt->mux_list);
-                                vpt->muxnum++;
-                                m->poll_task = vpt;
-                                memset(&m->poll_waddr, 0, sizeof(m->poll_waddr));
-                                init_poll_funcptr(&m->pt, v9fs_pollwait);
-                                break;
-                        }
-                }
-        }
-
-        if (i >= ARRAY_SIZE(v9fs_mux_poll_tasks)) {
-                if (vptlast == NULL)
-                        return -ENOMEM;
-
-                dprintk(DEBUG_MUX, "put in proc %d\n", i);
-                list_add(&m->mux_list, &vptlast->mux_list);
-                vptlast->muxnum++;
-                m->poll_task = vptlast;
-                memset(&m->poll_waddr, 0, sizeof(m->poll_waddr));
-                init_poll_funcptr(&m->pt, v9fs_pollwait);
-        }
-
-        v9fs_mux_num++;
-        mutex_unlock(&v9fs_mux_task_lock);
-
-        return 0;
-}
-
-static void v9fs_mux_poll_stop(struct v9fs_mux_data *m)
-{
-        int i;
-        struct v9fs_mux_poll_task *vpt;
-
-        mutex_lock(&v9fs_mux_task_lock);
-        vpt = m->poll_task;
-        list_del(&m->mux_list);
-        for(i = 0; i < ARRAY_SIZE(m->poll_waddr); i++) {
-                if (m->poll_waddr[i] != NULL) {
-                        remove_wait_queue(m->poll_waddr[i], &m->poll_wait[i]);
-                        m->poll_waddr[i] = NULL;
-                }
-        }
-        vpt->muxnum--;
-        if (!vpt->muxnum) {
-                dprintk(DEBUG_MUX, "destroy proc %p\n", vpt);
-                kthread_stop(vpt->task);
-                vpt->task = NULL;
-                v9fs_mux_poll_task_num--;
-        }
-        v9fs_mux_num--;
-        mutex_unlock(&v9fs_mux_task_lock);
-}
-
-/**
- * v9fs_mux_init - allocate and initialize the per-session mux data
- * Creates the polling task if this is the first session.
- *
- * @trans - transport structure
- * @msize - maximum message size
- * @extended - pointer to the extended flag
- */
-struct v9fs_mux_data *v9fs_mux_init(struct v9fs_transport *trans, int msize,
-                                    unsigned char *extended)
-{
-        int i, n;
-        struct v9fs_mux_data *m, *mtmp;
-
-        dprintk(DEBUG_MUX, "transport %p msize %d\n", trans, msize);
-        m = kmalloc(sizeof(struct v9fs_mux_data), GFP_KERNEL);
-        if (!m)
-                return ERR_PTR(-ENOMEM);
-
-        spin_lock_init(&m->lock);
-        INIT_LIST_HEAD(&m->mux_list);
-        m->msize = msize;
-        m->extended = extended;
-        m->trans = trans;
-        idr_init(&m->tagpool.pool);
-        init_MUTEX(&m->tagpool.lock);
-        m->err = 0;
-        init_waitqueue_head(&m->equeue);
-        INIT_LIST_HEAD(&m->req_list);
-        INIT_LIST_HEAD(&m->unsent_req_list);
-        m->rcall = NULL;
-        m->rpos = 0;
-        m->rbuf = NULL;
-        m->wpos = m->wsize = 0;
-        m->wbuf = NULL;
-        INIT_WORK(&m->rq, v9fs_read_work);
-        INIT_WORK(&m->wq, v9fs_write_work);
-        m->wsched = 0;
-        memset(&m->poll_waddr, 0, sizeof(m->poll_waddr));
-        m->poll_task = NULL;
-        n = v9fs_mux_poll_start(m);
-        if (n)
-                return ERR_PTR(n);
-
-        n = trans->poll(trans, &m->pt);
-        if (n & POLLIN) {
-                dprintk(DEBUG_MUX, "mux %p can read\n", m);
-                set_bit(Rpending, &m->wsched);
-        }
-
-        if (n & POLLOUT) {
-                dprintk(DEBUG_MUX, "mux %p can write\n", m);
-                set_bit(Wpending, &m->wsched);
-        }
-
-        for(i = 0; i < ARRAY_SIZE(m->poll_waddr); i++) {
-                if (IS_ERR(m->poll_waddr[i])) {
-                        v9fs_mux_poll_stop(m);
-                        mtmp = (void *)m->poll_waddr;   /* the error code */
-                        kfree(m);
-                        m = mtmp;
-                        break;
-                }
-        }
-
-        return m;
-}
-
-/**
- * v9fs_mux_destroy - cancels all pending requests and frees mux resources
- */
-void v9fs_mux_destroy(struct v9fs_mux_data *m)
-{
-        dprintk(DEBUG_MUX, "mux %p prev %p next %p\n", m,
-                m->mux_list.prev, m->mux_list.next);
-        v9fs_mux_cancel(m, -ECONNRESET);
-
-        if (!list_empty(&m->req_list)) {
-                /* wait until all processes waiting on this session exit */
-                dprintk(DEBUG_MUX, "mux %p waiting for empty request queue\n",
-                        m);
-                wait_event_timeout(m->equeue, (list_empty(&m->req_list)), 5000);
-                dprintk(DEBUG_MUX, "mux %p request queue empty: %d\n", m,
-                        list_empty(&m->req_list));
-        }
-
-        v9fs_mux_poll_stop(m);
-        m->trans = NULL;
-
-        kfree(m);
-}
-
-/**
- * v9fs_pollwait - called by files poll operation to add v9fs-poll task
- *      to files wait queue
- */
-static void
-v9fs_pollwait(struct file *filp, wait_queue_head_t * wait_address,
-              poll_table * p)
-{
-        int i;
-        struct v9fs_mux_data *m;
-
-        m = container_of(p, struct v9fs_mux_data, pt);
-        for(i = 0; i < ARRAY_SIZE(m->poll_waddr); i++)
-                if (m->poll_waddr[i] == NULL)
-                        break;
-
-        if (i >= ARRAY_SIZE(m->poll_waddr)) {
-                dprintk(DEBUG_ERROR, "not enough wait_address slots\n");
-                return;
-        }
-
-        m->poll_waddr[i] = wait_address;
-
-        if (!wait_address) {
-                dprintk(DEBUG_ERROR, "no wait_address\n");
-                m->poll_waddr[i] = ERR_PTR(-EIO);
-                return;
-        }
-
-        init_waitqueue_entry(&m->poll_wait[i], m->poll_task->task);
-        add_wait_queue(wait_address, &m->poll_wait[i]);
-}
-
-/**
- * v9fs_poll_mux - polls a mux and schedules read or write works if necessary
- */
-static void v9fs_poll_mux(struct v9fs_mux_data *m)
-{
-        int n;
-
-        if (m->err < 0)
-                return;
-
-        n = m->trans->poll(m->trans, NULL);
-        if (n < 0 || n & (POLLERR | POLLHUP | POLLNVAL)) {
-                dprintk(DEBUG_MUX, "error mux %p err %d\n", m, n);
-                if (n >= 0)
-                        n = -ECONNRESET;
-                v9fs_mux_cancel(m, n);
-        }
-
-        if (n & POLLIN) {
-                set_bit(Rpending, &m->wsched);
-                dprintk(DEBUG_MUX, "mux %p can read\n", m);
-                if (!test_and_set_bit(Rworksched, &m->wsched)) {
-                        dprintk(DEBUG_MUX, "schedule read work mux %p\n", m);
-                        queue_work(v9fs_mux_wq, &m->rq);
-                }
-        }
-
-        if (n & POLLOUT) {
-                set_bit(Wpending, &m->wsched);
-                dprintk(DEBUG_MUX, "mux %p can write\n", m);
-                if ((m->wsize || !list_empty(&m->unsent_req_list))
-                    && !test_and_set_bit(Wworksched, &m->wsched)) {
-                        dprintk(DEBUG_MUX, "schedule write work mux %p\n", m);
-                        queue_work(v9fs_mux_wq, &m->wq);
-                }
-        }
-}
-
-/**
- * v9fs_poll_proc - polls all v9fs transports for new events and queues
- *      the appropriate work to the work queue
- */
-static int v9fs_poll_proc(void *a)
-{
-        struct v9fs_mux_data *m, *mtmp;
-        struct v9fs_mux_poll_task *vpt;
-
-        vpt = a;
-        dprintk(DEBUG_MUX, "start %p %p\n", current, vpt);
-        while (!kthread_should_stop()) {
-                set_current_state(TASK_INTERRUPTIBLE);
-
-                list_for_each_entry_safe(m, mtmp, &vpt->mux_list, mux_list) {
-                        v9fs_poll_mux(m);
-                }
-
-                dprintk(DEBUG_MUX, "sleeping...\n");
-                schedule_timeout(SCHED_TIMEOUT * HZ);
-        }
-
-        __set_current_state(TASK_RUNNING);
-        dprintk(DEBUG_MUX, "finish\n");
-        return 0;
-}
-
-/**
- * v9fs_write_work - called when a transport can send some data
- */
-static void v9fs_write_work(struct work_struct *work)
-{
-        int n, err;
-        struct v9fs_mux_data *m;
-        struct v9fs_req *req;
-
-        m = container_of(work, struct v9fs_mux_data, wq);
-
-        if (m->err < 0) {
-                clear_bit(Wworksched, &m->wsched);
-                return;
-        }
-
-        if (!m->wsize) {
-                if (list_empty(&m->unsent_req_list)) {
-                        clear_bit(Wworksched, &m->wsched);
-                        return;
-                }
-
-                spin_lock(&m->lock);
-again:
-                req = list_entry(m->unsent_req_list.next, struct v9fs_req,
-                               req_list);
-                list_move_tail(&req->req_list, &m->req_list);
-                if (req->err == ERREQFLUSH)
-                        goto again;
-
-                m->wbuf = req->tcall->sdata;
-                m->wsize = req->tcall->size;
-                m->wpos = 0;
-                dump_data(m->wbuf, m->wsize);
-                spin_unlock(&m->lock);
-        }
-
-        dprintk(DEBUG_MUX, "mux %p pos %d size %d\n", m, m->wpos, m->wsize);
-        clear_bit(Wpending, &m->wsched);
-        err = m->trans->write(m->trans, m->wbuf + m->wpos, m->wsize - m->wpos);
-        dprintk(DEBUG_MUX, "mux %p sent %d bytes\n", m, err);
-        if (err == -EAGAIN) {
-                clear_bit(Wworksched, &m->wsched);
-                return;
-        }
-
-        if (err <= 0)
-                goto error;
-
-        m->wpos += err;
-        if (m->wpos == m->wsize)
-                m->wpos = m->wsize = 0;
-
-        if (m->wsize == 0 && !list_empty(&m->unsent_req_list)) {
-                if (test_and_clear_bit(Wpending, &m->wsched))
-                        n = POLLOUT;
-                else
-                        n = m->trans->poll(m->trans, NULL);
-
-                if (n & POLLOUT) {
-                        dprintk(DEBUG_MUX, "schedule write work mux %p\n", m);
-                        queue_work(v9fs_mux_wq, &m->wq);
-                } else
-                        clear_bit(Wworksched, &m->wsched);
-        } else
-                clear_bit(Wworksched, &m->wsched);
-
-        return;
-
-      error:
-        v9fs_mux_cancel(m, err);
-        clear_bit(Wworksched, &m->wsched);
-}
-
-static void process_request(struct v9fs_mux_data *m, struct v9fs_req *req)
-{
-        int ecode;
-        struct v9fs_str *ename;
-
-        if (!req->err && req->rcall->id == RERROR) {
-                ecode = req->rcall->params.rerror.errno;
-                ename = &req->rcall->params.rerror.error;
-
-                dprintk(DEBUG_MUX, "Rerror %.*s\n", ename->len, ename->str);
-
-                if (*m->extended)
-                        req->err = -ecode;
-
-                if (!req->err) {
-                        req->err = v9fs_errstr2errno(ename->str, ename->len);
-
-                        if (!req->err) {        /* string match failed */
-                                PRINT_FCALL_ERROR("unknown error", req->rcall);
-                        }
-
-                        if (!req->err)
-                                req->err = -ESERVERFAULT;
-                }
-        } else if (req->tcall && req->rcall->id != req->tcall->id + 1) {
-                dprintk(DEBUG_ERROR, "fcall mismatch: expected %d, got %d\n",
-                        req->tcall->id + 1, req->rcall->id);
-                if (!req->err)
-                        req->err = -EIO;
-        }
-}
-
-/**
- * v9fs_read_work - called when there is some data to be read from a transport
- */
-static void v9fs_read_work(struct work_struct *work)
-{
-        int n, err;
-        struct v9fs_mux_data *m;
-        struct v9fs_req *req, *rptr, *rreq;
-        struct v9fs_fcall *rcall;
-        char *rbuf;
-
-        m = container_of(work, struct v9fs_mux_data, rq);
-
-        if (m->err < 0)
-                return;
-
-        rcall = NULL;
-        dprintk(DEBUG_MUX, "start mux %p pos %d\n", m, m->rpos);
-
-        if (!m->rcall) {
-                m->rcall =
-                    kmalloc(sizeof(struct v9fs_fcall) + m->msize, GFP_KERNEL);
-                if (!m->rcall) {
-                        err = -ENOMEM;
-                        goto error;
-                }
-
-                m->rbuf = (char *)m->rcall + sizeof(struct v9fs_fcall);
-                m->rpos = 0;
-        }
-
-        clear_bit(Rpending, &m->wsched);
-        err = m->trans->read(m->trans, m->rbuf + m->rpos, m->msize - m->rpos);
-        dprintk(DEBUG_MUX, "mux %p got %d bytes\n", m, err);
-        if (err == -EAGAIN) {
-                clear_bit(Rworksched, &m->wsched);
-                return;
-        }
-
-        if (err <= 0)
-                goto error;
-
-        m->rpos += err;
-        while (m->rpos > 4) {
-                n = le32_to_cpu(*(__le32 *) m->rbuf);
-                if (n >= m->msize) {
-                        dprintk(DEBUG_ERROR,
-                                "requested packet size too big: %d\n", n);
-                        err = -EIO;
-                        goto error;
-                }
-
-                if (m->rpos < n)
-                        break;
-
-                dump_data(m->rbuf, n);
-                err =
-                    v9fs_deserialize_fcall(m->rbuf, n, m->rcall, *m->extended);
-                if (err < 0) {
-                        goto error;
-                }
-
-                if ((v9fs_debug_level&DEBUG_FCALL) == DEBUG_FCALL) {
-                        char buf[150];
-
-                        v9fs_printfcall(buf, sizeof(buf), m->rcall,
-                                *m->extended);
-                        printk(KERN_NOTICE ">>> %p %s\n", m, buf);
-                }
-
-                rcall = m->rcall;
-                rbuf = m->rbuf;
-                if (m->rpos > n) {
-                        m->rcall = kmalloc(sizeof(struct v9fs_fcall) + m->msize,
-                                           GFP_KERNEL);
-                        if (!m->rcall) {
-                                err = -ENOMEM;
-                                goto error;
-                        }
-
-                        m->rbuf = (char *)m->rcall + sizeof(struct v9fs_fcall);
-                        memmove(m->rbuf, rbuf + n, m->rpos - n);
-                        m->rpos -= n;
-                } else {
-                        m->rcall = NULL;
-                        m->rbuf = NULL;
-                        m->rpos = 0;
-                }
-
-                dprintk(DEBUG_MUX, "mux %p fcall id %d tag %d\n", m, rcall->id,
-                        rcall->tag);
-
-                req = NULL;
-                spin_lock(&m->lock);
-                list_for_each_entry_safe(rreq, rptr, &m->req_list, req_list) {
-                        if (rreq->tag == rcall->tag) {
-                                req = rreq;
-                                if (req->flush != Flushing)
-                                        list_del(&req->req_list);
-                                break;
-                        }
-                }
-                spin_unlock(&m->lock);
-
-                if (req) {
-                        req->rcall = rcall;
-                        process_request(m, req);
-
-                        if (req->flush != Flushing) {
-                                if (req->cb)
-                                        (*req->cb) (req, req->cba);
-                                else
-                                        kfree(req->rcall);
-
-                                wake_up(&m->equeue);
-                        }
-                } else {
-                        if (err >= 0 && rcall->id != RFLUSH)
-                                dprintk(DEBUG_ERROR,
-                                        "unexpected response mux %p id %d tag %d\n",
-                                        m, rcall->id, rcall->tag);
-                        kfree(rcall);
-                }
-        }
-
-        if (!list_empty(&m->req_list)) {
-                if (test_and_clear_bit(Rpending, &m->wsched))
-                        n = POLLIN;
-                else
-                        n = m->trans->poll(m->trans, NULL);
-
-                if (n & POLLIN) {
-                        dprintk(DEBUG_MUX, "schedule read work mux %p\n", m);
-                        queue_work(v9fs_mux_wq, &m->rq);
-                } else
-                        clear_bit(Rworksched, &m->wsched);
-        } else
-                clear_bit(Rworksched, &m->wsched);
-
-        return;
-
-      error:
-        v9fs_mux_cancel(m, err);
-        clear_bit(Rworksched, &m->wsched);
-}
-
-/**
- * v9fs_send_request - send 9P request
- * The function can sleep until the request is scheduled for sending.
- * The function can be interrupted. Return from the function is not
- * a guarantee that the request is sent successfully. Can return errors
- * that can be retrieved by PTR_ERR macros.
- *
- * @m: mux data
- * @tc: request to be sent
- * @cb: callback function to call when response is received
- * @cba: parameter to pass to the callback function
- */
-static struct v9fs_req *v9fs_send_request(struct v9fs_mux_data *m,
-                                          struct v9fs_fcall *tc,
-                                          v9fs_mux_req_callback cb, void *cba)
-{
-        int n;
-        struct v9fs_req *req;
-
-        dprintk(DEBUG_MUX, "mux %p task %p tcall %p id %d\n", m, current,
-                tc, tc->id);
-        if (m->err < 0)
-                return ERR_PTR(m->err);
-
-        req = kmalloc(sizeof(struct v9fs_req), GFP_KERNEL);
-        if (!req)
-                return ERR_PTR(-ENOMEM);
-
-        if (tc->id == TVERSION)
-                n = V9FS_NOTAG;
-        else
-                n = v9fs_mux_get_tag(m);
-
-        if (n < 0)
-                return ERR_PTR(-ENOMEM);
-
-        v9fs_set_tag(tc, n);
-        if ((v9fs_debug_level&DEBUG_FCALL) == DEBUG_FCALL) {
-                char buf[150];
-
-                v9fs_printfcall(buf, sizeof(buf), tc, *m->extended);
-                printk(KERN_NOTICE "<<< %p %s\n", m, buf);
-        }
-
-        spin_lock_init(&req->lock);
-        req->tag = n;
-        req->tcall = tc;
-        req->rcall = NULL;
-        req->err = 0;
-        req->cb = cb;
-        req->cba = cba;
-        req->flush = None;
-
-        spin_lock(&m->lock);
-        list_add_tail(&req->req_list, &m->unsent_req_list);
-        spin_unlock(&m->lock);
-
-        if (test_and_clear_bit(Wpending, &m->wsched))
-                n = POLLOUT;
-        else
-                n = m->trans->poll(m->trans, NULL);
-
-        if (n & POLLOUT && !test_and_set_bit(Wworksched, &m->wsched))
-                queue_work(v9fs_mux_wq, &m->wq);
-
-        return req;
-}
-
-static void v9fs_mux_free_request(struct v9fs_mux_data *m, struct v9fs_req *req)
-{
-        v9fs_mux_put_tag(m, req->tag);
-        kfree(req);
-}
-
-static void v9fs_mux_flush_cb(struct v9fs_req *freq, void *a)
-{
-        v9fs_mux_req_callback cb;
-        int tag;
-        struct v9fs_mux_data *m;
-        struct v9fs_req *req, *rreq, *rptr;
-
-        m = a;
-        dprintk(DEBUG_MUX, "mux %p tc %p rc %p err %d oldtag %d\n", m,
-                freq->tcall, freq->rcall, freq->err,
-                freq->tcall->params.tflush.oldtag);
-
-        spin_lock(&m->lock);
-        cb = NULL;
-        tag = freq->tcall->params.tflush.oldtag;
-        req = NULL;
-        list_for_each_entry_safe(rreq, rptr, &m->req_list, req_list) {
-                if (rreq->tag == tag) {
-                        req = rreq;
-                        list_del(&req->req_list);
-                        break;
-                }
-        }
-        spin_unlock(&m->lock);
-
-        if (req) {
-                spin_lock(&req->lock);
-                req->flush = Flushed;
-                spin_unlock(&req->lock);
-
-                if (req->cb)
-                        (*req->cb) (req, req->cba);
-                else
-                        kfree(req->rcall);
-
-                wake_up(&m->equeue);
-        }
-
-        kfree(freq->tcall);
-        kfree(freq->rcall);
-        v9fs_mux_free_request(m, freq);
-}
-
-static int
-v9fs_mux_flush_request(struct v9fs_mux_data *m, struct v9fs_req *req)
-{
-        struct v9fs_fcall *fc;
-        struct v9fs_req *rreq, *rptr;
-
-        dprintk(DEBUG_MUX, "mux %p req %p tag %d\n", m, req, req->tag);
-
-        /* if a response was received for a request, do nothing */
-        spin_lock(&req->lock);
-        if (req->rcall || req->err) {
-                spin_unlock(&req->lock);
-                dprintk(DEBUG_MUX, "mux %p req %p response already received\n", m, req);
-                return 0;
-        }
-
-        req->flush = Flushing;
-        spin_unlock(&req->lock);
-
-        spin_lock(&m->lock);
-        /* if the request is not sent yet, just remove it from the list */
-        list_for_each_entry_safe(rreq, rptr, &m->unsent_req_list, req_list) {
-                if (rreq->tag == req->tag) {
-                        dprintk(DEBUG_MUX, "mux %p req %p request is not sent yet\n", m, req);
-                        list_del(&rreq->req_list);
-                        req->flush = Flushed;
-                        spin_unlock(&m->lock);
-                        if (req->cb)
-                                (*req->cb) (req, req->cba);
-                        return 0;
-                }
-        }
-        spin_unlock(&m->lock);
-
-        clear_thread_flag(TIF_SIGPENDING);
-        fc = v9fs_create_tflush(req->tag);
-        v9fs_send_request(m, fc, v9fs_mux_flush_cb, m);
-        return 1;
-}
-
-static void
-v9fs_mux_rpc_cb(struct v9fs_req *req, void *a)
-{
-        struct v9fs_mux_rpc *r;
-
-        dprintk(DEBUG_MUX, "req %p r %p\n", req, a);
-        r = a;
-        r->rcall = req->rcall;
-        r->err = req->err;
-
-        if (req->flush!=None && !req->err)
-                r->err = -ERESTARTSYS;
-
-        wake_up(&r->wqueue);
-}
-
-/**
- * v9fs_mux_rpc - sends 9P request and waits until a response is available.
- *      The function can be interrupted.
- * @m: mux data
- * @tc: request to be sent
- * @rc: pointer where a pointer to the response is stored
- */
-int
-v9fs_mux_rpc(struct v9fs_mux_data *m, struct v9fs_fcall *tc,
-             struct v9fs_fcall **rc)
-{
-        int err, sigpending;
-        unsigned long flags;
-        struct v9fs_req *req;
-        struct v9fs_mux_rpc r;
-
-        r.err = 0;
-        r.tcall = tc;
-        r.rcall = NULL;
-        r.m = m;
-        init_waitqueue_head(&r.wqueue);
-
-        if (rc)
-                *rc = NULL;
-
-        sigpending = 0;
-        if (signal_pending(current)) {
-                sigpending = 1;
-                clear_thread_flag(TIF_SIGPENDING);
-        }
-
-        req = v9fs_send_request(m, tc, v9fs_mux_rpc_cb, &r);
-        if (IS_ERR(req)) {
-                err = PTR_ERR(req);
-                dprintk(DEBUG_MUX, "error %d\n", err);
-                return err;
-        }
-
-        err = wait_event_interruptible(r.wqueue, r.rcall != NULL || r.err < 0);
-        if (r.err < 0)
-                err = r.err;
-
-        if (err == -ERESTARTSYS && m->trans->status == Connected && m->err == 0) {
-                if (v9fs_mux_flush_request(m, req)) {
-                        /* wait until we get response of the flush message */
-                        do {
-                                clear_thread_flag(TIF_SIGPENDING);
-                                err = wait_event_interruptible(r.wqueue,
-                                        r.rcall || r.err);
-                        } while (!r.rcall && !r.err && err==-ERESTARTSYS &&
-                                m->trans->status==Connected && !m->err);
-
-                        err = -ERESTARTSYS;
-                }
-                sigpending = 1;
-        }
-
-        if (sigpending) {
-                spin_lock_irqsave(&current->sighand->siglock, flags);
-                recalc_sigpending();
-                spin_unlock_irqrestore(&current->sighand->siglock, flags);
-        }
-
-        if (rc)
-                *rc = r.rcall;
-        else
-                kfree(r.rcall);
-
-        v9fs_mux_free_request(m, req);
-        if (err > 0)
-                err = -EIO;
-
-        return err;
-}
-
-#if 0
-/**
- * v9fs_mux_rpcnb - sends 9P request without waiting for response.
- * @m: mux data
- * @tc: request to be sent
- * @cb: callback function to be called when response arrives
- * @cba: value to pass to the callback function
- */
-int v9fs_mux_rpcnb(struct v9fs_mux_data *m, struct v9fs_fcall *tc,
-                   v9fs_mux_req_callback cb, void *a)
-{
-        int err;
-        struct v9fs_req *req;
-
-        req = v9fs_send_request(m, tc, cb, a);
-        if (IS_ERR(req)) {
-                err = PTR_ERR(req);
-                dprintk(DEBUG_MUX, "error %d\n", err);
-                return PTR_ERR(req);
-        }
-
-        dprintk(DEBUG_MUX, "mux %p tc %p tag %d\n", m, tc, req->tag);
-        return 0;
-}
-#endif  /*  0  */
-
-/**
- * v9fs_mux_cancel - cancel all pending requests with error
- * @m: mux data
- * @err: error code
- */
-void v9fs_mux_cancel(struct v9fs_mux_data *m, int err)
-{
-        struct v9fs_req *req, *rtmp;
-        LIST_HEAD(cancel_list);
-
-        dprintk(DEBUG_ERROR, "mux %p err %d\n", m, err);
-        m->err = err;
-        spin_lock(&m->lock);
-        list_for_each_entry_safe(req, rtmp, &m->req_list, req_list) {
-                list_move(&req->req_list, &cancel_list);
-        }
-        list_for_each_entry_safe(req, rtmp, &m->unsent_req_list, req_list) {
-                list_move(&req->req_list, &cancel_list);
-        }
-        spin_unlock(&m->lock);
-
-        list_for_each_entry_safe(req, rtmp, &cancel_list, req_list) {
-                list_del(&req->req_list);
-                if (!req->err)
-                        req->err = err;
-
-                if (req->cb)
-                        (*req->cb) (req, req->cba);
-                else
-                        kfree(req->rcall);
-        }
-
-        wake_up(&m->equeue);
-}
-
-static u16 v9fs_mux_get_tag(struct v9fs_mux_data *m)
-{
-        int tag;
-
-        tag = v9fs_get_idpool(&m->tagpool);
-        if (tag < 0)
-                return V9FS_NOTAG;
-        else
-                return (u16) tag;
-}
-
-static void v9fs_mux_put_tag(struct v9fs_mux_data *m, u16 tag)
-{
-        if (tag != V9FS_NOTAG && v9fs_check_idpool(tag, &m->tagpool))
-                v9fs_put_idpool(tag, &m->tagpool);
-}
diff --git a/fs/9p/mux.h b/fs/9p/mux.h
deleted file mode 100644
index fb10c50186a..00000000000
--- a/fs/9p/mux.h
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * linux/fs/9p/mux.h
- *
- * Multiplexer Definitions
- *
- *  Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net>
- *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2
- *  as published by the Free Software Foundation.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to:
- *  Free Software Foundation
- *  51 Franklin Street, Fifth Floor
- *  Boston, MA  02111-1301  USA
- *
- */
-
-struct v9fs_mux_data;
-struct v9fs_req;
-
-/**
- * v9fs_mux_req_callback - callback function that is called when the
- * response of a request is received. The callback is called from
- * a workqueue and shouldn't block.
- *
- * @a - the pointer that was specified when the request was send to be
- *      passed to the callback
- * @tc - request call
- * @rc - response call
- * @err - error code (non-zero if error occured)
- */
-typedef void (*v9fs_mux_req_callback)(struct v9fs_req *req, void *a);
-
-int v9fs_mux_global_init(void);
-void v9fs_mux_global_exit(void);
-
-struct v9fs_mux_data *v9fs_mux_init(struct v9fs_transport *trans, int msize,
-        unsigned char *extended);
-void v9fs_mux_destroy(struct v9fs_mux_data *);
-
-int v9fs_mux_send(struct v9fs_mux_data *m, struct v9fs_fcall *tc);
-struct v9fs_fcall *v9fs_mux_recv(struct v9fs_mux_data *m);
-int v9fs_mux_rpc(struct v9fs_mux_data *m, struct v9fs_fcall *tc, struct v9fs_fcall **rc);
-
-void v9fs_mux_flush(struct v9fs_mux_data *m, int sendflush);
-void v9fs_mux_cancel(struct v9fs_mux_data *m, int err);
-int v9fs_errstr2errno(char *errstr, int len);
diff --git a/fs/9p/trans_fd.c b/fs/9p/trans_fd.c
deleted file mode 100644
index 34d43355beb..00000000000
--- a/fs/9p/trans_fd.c
+++ /dev/null
@@ -1,308 +0,0 @@
-/*
- * linux/fs/9p/trans_fd.c
- *
- * Fd transport layer.  Includes deprecated socket layer.
- *
- *  Copyright (C) 2006 by Russ Cox <rsc@swtch.com>
- *  Copyright (C) 2004-2005 by Latchesar Ionkov <lucho@ionkov.net>
- *  Copyright (C) 2004-2005 by Eric Van Hensbergen <ericvh@gmail.com>
- *  Copyright (C) 1997-2002 by Ron Minnich <rminnich@sarnoff.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2
- *  as published by the Free Software Foundation.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to:
- *  Free Software Foundation
- *  51 Franklin Street, Fifth Floor
- *  Boston, MA  02111-1301  USA
- *
- */
-
-#include <linux/in.h>
-#include <linux/module.h>
-#include <linux/net.h>
-#include <linux/ipv6.h>
-#include <linux/errno.h>
-#include <linux/kernel.h>
-#include <linux/un.h>
-#include <asm/uaccess.h>
-#include <linux/inet.h>
-#include <linux/idr.h>
-#include <linux/file.h>
-
-#include "debug.h"
-#include "v9fs.h"
-#include "transport.h"
-
-#define V9FS_PORT 564
-
-struct v9fs_trans_fd {
-        struct file *rd;
-        struct file *wr;
-};
-
-/**
- * v9fs_fd_read- read from a fd
- * @v9ses: session information
- * @v: buffer to receive data into
- * @len: size of receive buffer
- *
- */
-static int v9fs_fd_read(struct v9fs_transport *trans, void *v, int len)
-{
-        int ret;
-        struct v9fs_trans_fd *ts;
-
-        if (!trans || trans->status == Disconnected || !(ts = trans->priv))
-                return -EREMOTEIO;
-
-        if (!(ts->rd->f_flags & O_NONBLOCK))
-                dprintk(DEBUG_ERROR, "blocking read ...\n");
-
-        ret = kernel_read(ts->rd, ts->rd->f_pos, v, len);
-        if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
-                trans->status = Disconnected;
-        return ret;
-}
-
-/**
- * v9fs_fd_write - write to a socket
- * @v9ses: session information
- * @v: buffer to send data from
- * @len: size of send buffer
- *
- */
-static int v9fs_fd_write(struct v9fs_transport *trans, void *v, int len)
-{
-        int ret;
-        mm_segment_t oldfs;
-        struct v9fs_trans_fd *ts;
-
-        if (!trans || trans->status == Disconnected || !(ts = trans->priv))
-                return -EREMOTEIO;
-
-        if (!(ts->wr->f_flags & O_NONBLOCK))
-                dprintk(DEBUG_ERROR, "blocking write ...\n");
-
-        oldfs = get_fs();
-        set_fs(get_ds());
-        /* The cast to a user pointer is valid due to the set_fs() */
-        ret = vfs_write(ts->wr, (void __user *)v, len, &ts->wr->f_pos);
-        set_fs(oldfs);
-
-        if (ret <= 0 && ret != -ERESTARTSYS && ret != -EAGAIN)
-                trans->status = Disconnected;
-        return ret;
-}
-
-static unsigned int
-v9fs_fd_poll(struct v9fs_transport *trans, struct poll_table_struct *pt)
-{
-        int ret, n;
-        struct v9fs_trans_fd *ts;
-        mm_segment_t oldfs;
-
-        if (!trans || trans->status != Connected || !(ts = trans->priv))
-                return -EREMOTEIO;
-
-        if (!ts->rd->f_op || !ts->rd->f_op->poll)
-                return -EIO;
-
-        if (!ts->wr->f_op || !ts->wr->f_op->poll)
-                return -EIO;
-
-        oldfs = get_fs();
-        set_fs(get_ds());
-
-        ret = ts->rd->f_op->poll(ts->rd, pt);
-        if (ret < 0)
-                goto end;
-
-        if (ts->rd != ts->wr) {
-                n = ts->wr->f_op->poll(ts->wr, pt);
-                if (n < 0) {
-                        ret = n;
-                        goto end;
-                }
-                ret = (ret & ~POLLOUT) | (n & ~POLLIN);
-        }
-
-      end:
-        set_fs(oldfs);
-        return ret;
-}
-
-static int v9fs_fd_open(struct v9fs_session_info *v9ses, int rfd, int wfd)
-{
-        struct v9fs_transport *trans = v9ses->transport;
-        struct v9fs_trans_fd *ts = kmalloc(sizeof(struct v9fs_trans_fd),
-                                           GFP_KERNEL);
-        if (!ts)
-                return -ENOMEM;
-
-        ts->rd = fget(rfd);
-        ts->wr = fget(wfd);
-        if (!ts->rd || !ts->wr) {
-                if (ts->rd)
-                        fput(ts->rd);
-                if (ts->wr)
-                        fput(ts->wr);
-                kfree(ts);
-                return -EIO;
-        }
-
-        trans->priv = ts;
-        trans->status = Connected;
-
-        return 0;
-}
-
-static int v9fs_fd_init(struct v9fs_session_info *v9ses, const char *addr,
-                        char *data)
-{
-        if (v9ses->rfdno == ~0 || v9ses->wfdno == ~0) {
-                printk(KERN_ERR "v9fs: Insufficient options for proto=fd\n");
-                return -ENOPROTOOPT;
-        }
-
-        return v9fs_fd_open(v9ses, v9ses->rfdno, v9ses->wfdno);
-}
-
-static int v9fs_socket_open(struct v9fs_session_info *v9ses,
-                            struct socket *csocket)
-{
-        int fd, ret;
-
-        csocket->sk->sk_allocation = GFP_NOIO;
-        if ((fd = sock_map_fd(csocket)) < 0) {
-                eprintk(KERN_ERR, "v9fs_socket_open: failed to map fd\n");
-                ret = fd;
-              release_csocket:
-                sock_release(csocket);
-                return ret;
-        }
-
-        if ((ret = v9fs_fd_open(v9ses, fd, fd)) < 0) {
-                sockfd_put(csocket);
-                eprintk(KERN_ERR, "v9fs_socket_open: failed to open fd\n");
-                goto release_csocket;
-        }
-
-        ((struct v9fs_trans_fd *)v9ses->transport->priv)->rd->f_flags |=
-            O_NONBLOCK;
-        return 0;
-}
-
-static int v9fs_tcp_init(struct v9fs_session_info *v9ses, const char *addr,
-                         char *data)
-{
-        int ret;
-        struct socket *csocket = NULL;
-        struct sockaddr_in sin_server;
-
-        sin_server.sin_family = AF_INET;
-        sin_server.sin_addr.s_addr = in_aton(addr);
-        sin_server.sin_port = htons(v9ses->port);
-        sock_create_kern(PF_INET, SOCK_STREAM, IPPROTO_TCP, &csocket);
-
-        if (!csocket) {
-                eprintk(KERN_ERR, "v9fs_trans_tcp: problem creating socket\n");
-                return -1;
-        }
-
-        ret = csocket->ops->connect(csocket,
-                                    (struct sockaddr *)&sin_server,
-                                    sizeof(struct sockaddr_in), 0);
-        if (ret < 0) {
-                eprintk(KERN_ERR,
-                        "v9fs_trans_tcp: problem connecting socket to %s\n",
-                        addr);
-                return ret;
-        }
-
-        return v9fs_socket_open(v9ses, csocket);
-}
-
-static int
-v9fs_unix_init(struct v9fs_session_info *v9ses, const char *addr, char *data)
-{
-        int ret;
-        struct socket *csocket;
-        struct sockaddr_un sun_server;
-
-        if (strlen(addr) > UNIX_PATH_MAX) {
-                eprintk(KERN_ERR, "v9fs_trans_unix: address too long: %s\n",
-                        addr);
-                return -ENAMETOOLONG;
-        }
-
-        sun_server.sun_family = PF_UNIX;
-        strcpy(sun_server.sun_path, addr);
-        sock_create_kern(PF_UNIX, SOCK_STREAM, 0, &csocket);
-        ret = csocket->ops->connect(csocket, (struct sockaddr *)&sun_server,
-                        sizeof(struct sockaddr_un) - 1, 0);
-        if (ret < 0) {
-                eprintk(KERN_ERR,
-                        "v9fs_trans_unix: problem connecting socket: %s: %d\n",
-                        addr, ret);
-                return ret;
-        }
-
-        return v9fs_socket_open(v9ses, csocket);
-}
-
-/**
- * v9fs_sock_close - shutdown socket
- * @trans: private socket structure
- *
- */
-static void v9fs_fd_close(struct v9fs_transport *trans)
-{
-        struct v9fs_trans_fd *ts;
-
-        if (!trans)
-                return;
-
-        ts = xchg(&trans->priv, NULL);
-
-        if (!ts)
-                return;
-
-        trans->status = Disconnected;
-        if (ts->rd)
-                fput(ts->rd);
-        if (ts->wr)
-                fput(ts->wr);
-        kfree(ts);
-}
-
-struct v9fs_transport v9fs_trans_fd = {
-        .init = v9fs_fd_init,
-        .write = v9fs_fd_write,
-        .read = v9fs_fd_read,
-        .close = v9fs_fd_close,
-        .poll = v9fs_fd_poll,
-};
-
-struct v9fs_transport v9fs_trans_tcp = {
-        .init = v9fs_tcp_init,
-        .write = v9fs_fd_write,
-        .read = v9fs_fd_read,
-        .close = v9fs_fd_close,
-        .poll = v9fs_fd_poll,
-};
-
-struct v9fs_transport v9fs_trans_unix = {
-        .init = v9fs_unix_init,
-        .write = v9fs_fd_write,
-        .read = v9fs_fd_read,
-        .close = v9fs_fd_close,
-        .poll = v9fs_fd_poll,
-};
diff --git a/fs/9p/transport.h b/fs/9p/transport.h
deleted file mode 100644
index b38a4b8a41c..00000000000
--- a/fs/9p/transport.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * linux/fs/9p/transport.h
- *
- * Transport Definition
- *
- *  Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net>
- *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 2
- *  as published by the Free Software Foundation.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to:
- *  Free Software Foundation
- *  51 Franklin Street, Fifth Floor
- *  Boston, MA  02111-1301  USA
- *
- */
-
-enum v9fs_transport_status {
-        Connected,
-        Disconnected,
-        Hung,
-};
-
-struct v9fs_transport {
-        enum v9fs_transport_status status;
-        void *priv;
-
-        int (*init) (struct v9fs_session_info *, const char *, char *);
-        int (*write) (struct v9fs_transport *, void *, int);
-        int (*read) (struct v9fs_transport *, void *, int);
-        void (*close) (struct v9fs_transport *);
-        unsigned int (*poll)(struct v9fs_transport *, struct poll_table_struct *);
-};
-
-extern struct v9fs_transport v9fs_trans_tcp;
-extern struct v9fs_transport v9fs_trans_unix;
-extern struct v9fs_transport v9fs_trans_fd;
diff --git a/fs/9p/v9fs.c b/fs/9p/v9fs.c
index 6ad6f192b6e..45c35986d49 100644
--- a/fs/9p/v9fs.c
+++ b/fs/9p/v9fs.c
@@ -29,16 +29,12 @@
 #include <linux/sched.h>
 #include <linux/parser.h>
 #include <linux/idr.h>
-
-#include "debug.h"
+#include <net/9p/9p.h>
+#include <net/9p/transport.h>
+#include <net/9p/conn.h>
+#include <net/9p/client.h>
 #include "v9fs.h"
-#include "9p.h"
 #include "v9fs_vfs.h"
-#include "transport.h"
-#include "mux.h"
-
-/* TODO: sysfs or debugfs interface */
-int v9fs_debug_level = 0;       /* feature-rific global debug level  */
 
 /*
   * Option Parsing (code inspired by NFS code)
@@ -47,12 +43,12 @@ int v9fs_debug_level = 0;	/* feature-rific global debug level  */
 
 enum {
         /* Options that take integer arguments */
-        Opt_port, Opt_msize, Opt_uid, Opt_gid, Opt_afid, Opt_debug,
+        Opt_debug, Opt_port, Opt_msize, Opt_uid, Opt_gid, Opt_afid,
         Opt_rfdno, Opt_wfdno,
         /* String options */
         Opt_uname, Opt_remotename,
         /* Options that take no arguments */
-        Opt_legacy, Opt_nodevmap, Opt_unix, Opt_tcp, Opt_fd,
+        Opt_legacy, Opt_nodevmap, Opt_unix, Opt_tcp, Opt_fd, Opt_pci,
         /* Cache options */
         Opt_cache_loose,
         /* Error token */
@@ -60,6 +56,7 @@ enum {
 };
 
 static match_table_t tokens = {
+        {Opt_debug, "debug=%x"},
         {Opt_port, "port=%u"},
         {Opt_msize, "msize=%u"},
         {Opt_uid, "uid=%u"},
@@ -67,12 +64,14 @@ static match_table_t tokens = {
         {Opt_afid, "afid=%u"},
         {Opt_rfdno, "rfdno=%u"},
         {Opt_wfdno, "wfdno=%u"},
-        {Opt_debug, "debug=%x"},
         {Opt_uname, "uname=%s"},
         {Opt_remotename, "aname=%s"},
         {Opt_unix, "proto=unix"},
         {Opt_tcp, "proto=tcp"},
         {Opt_fd, "proto=fd"},
+#ifdef CONFIG_PCI_9P
+        {Opt_pci, "proto=pci"},
+#endif
         {Opt_tcp, "tcp"},
         {Opt_unix, "unix"},
         {Opt_fd, "fd"},
@@ -83,6 +82,8 @@ static match_table_t tokens = {
         {Opt_err, NULL}
 };
 
+extern struct p9_transport *p9pci_trans_create(void);
+
 /*
  *  Parse option string.
  */
@@ -122,12 +123,16 @@ static void v9fs_parse_options(char *options, struct v9fs_session_info *v9ses)
                 token = match_token(p, tokens, args);
                 if (token < Opt_uname) {
                         if ((ret = match_int(&args[0], &option)) < 0) {
-                                dprintk(DEBUG_ERROR,
+                                P9_DPRINTK(P9_DEBUG_ERROR,
                                         "integer field, but no integer?\n");
                                 continue;
                         }
                 }
                 switch (token) {
+                case Opt_debug:
+                        v9ses->debug = option;
+                        p9_debug_level = option;
+                        break;
                 case Opt_port:
                         v9ses->port = option;
                         break;
@@ -149,15 +154,15 @@ static void v9fs_parse_options(char *options, struct v9fs_session_info *v9ses)
                 case Opt_wfdno:
                         v9ses->wfdno = option;
                         break;
-                case Opt_debug:
-                        v9ses->debug = option;
-                        break;
                 case Opt_tcp:
                         v9ses->proto = PROTO_TCP;
                         break;
                 case Opt_unix:
                         v9ses->proto = PROTO_UNIX;
                         break;
+                case Opt_pci:
+                        v9ses->proto = PROTO_PCI;
+                        break;
                 case Opt_fd:
                         v9ses->proto = PROTO_FD;
                         break;
@@ -183,82 +188,6 @@ static void v9fs_parse_options(char *options, struct v9fs_session_info *v9ses)
 }
 
 /**
- * v9fs_inode2v9ses - safely extract v9fs session info from super block
- * @inode: inode to extract information from
- *
- * Paranoid function to extract v9ses information from superblock,
- * if anything is missing it will report an error.
- *
- */
-
-struct v9fs_session_info *v9fs_inode2v9ses(struct inode *inode)
-{
-        return (inode->i_sb->s_fs_info);
-}
-
-/**
- * v9fs_get_idpool - allocate numeric id from pool
- * @p - pool to allocate from
- *
- * XXX - This seems to be an awful generic function, should it be in idr.c with
- *            the lock included in struct idr?
- */
-
-int v9fs_get_idpool(struct v9fs_idpool *p)
-{
-        int i = 0;
-        int error;
-
-retry:
-        if (idr_pre_get(&p->pool, GFP_KERNEL) == 0)
-                return 0;
-
-        if (down_interruptible(&p->lock) == -EINTR) {
-                eprintk(KERN_WARNING, "Interrupted while locking\n");
-                return -1;
-        }
-
-        /* no need to store exactly p, we just need something non-null */
-        error = idr_get_new(&p->pool, p, &i);
-        up(&p->lock);
-
-        if (error == -EAGAIN)
-                goto retry;
-        else if (error)
-                return -1;
-
-        return i;
-}
-
-/**
- * v9fs_put_idpool - release numeric id from pool
- * @p - pool to allocate from
- *
- * XXX - This seems to be an awful generic function, should it be in idr.c with
- *            the lock included in struct idr?
- */
-
-void v9fs_put_idpool(int id, struct v9fs_idpool *p)
-{
-        if (down_interruptible(&p->lock) == -EINTR) {
-                eprintk(KERN_WARNING, "Interrupted while locking\n");
-                return;
-        }
-        idr_remove(&p->pool, id);
-        up(&p->lock);
-}
-
-/**
- * v9fs_check_idpool - check if the specified id is available
- * @id - id to check
- * @p - pool
- */
-int v9fs_check_idpool(int id, struct v9fs_idpool *p)
-{
-        return idr_find(&p->pool, id) != NULL;
-}
-
-/**
  * v9fs_session_init - initialize session
  * @v9ses: session information structure
  * @dev_name: device being mounted
@@ -266,25 +195,21 @@ int v9fs_check_idpool(int id, struct v9fs_idpool *p)
  *
  */
 
-int
-v9fs_session_init(struct v9fs_session_info *v9ses,
+struct p9_fid *v9fs_session_init(struct v9fs_session_info *v9ses,
                   const char *dev_name, char *data)
 {
-        struct v9fs_fcall *fcall = NULL;
-        struct v9fs_transport *trans_proto;
-        int n = 0;
-        int newfid = -1;
         int retval = -EINVAL;
-        struct v9fs_str *version;
+        struct p9_transport *trans;
+        struct p9_fid *fid;
 
         v9ses->name = __getname();
         if (!v9ses->name)
-                return -ENOMEM;
+                return ERR_PTR(-ENOMEM);
 
         v9ses->remotename = __getname();
         if (!v9ses->remotename) {
                 __putname(v9ses->name);
-                return -ENOMEM;
+                return ERR_PTR(-ENOMEM);
         }
 
         strcpy(v9ses->name, V9FS_DEFUSER);
@@ -292,130 +217,60 @@ v9fs_session_init(struct v9fs_session_info *v9ses,
 
         v9fs_parse_options(data, v9ses);
 
-        /* set global debug level */
-        v9fs_debug_level = v9ses->debug;
-
-        /* id pools that are session-dependent: fids and tags */
-        idr_init(&v9ses->fidpool.pool);
-        init_MUTEX(&v9ses->fidpool.lock);
-
         switch (v9ses->proto) {
         case PROTO_TCP:
-                trans_proto = &v9fs_trans_tcp;
+                trans = p9_trans_create_tcp(dev_name, v9ses->port);
                 break;
         case PROTO_UNIX:
-                trans_proto = &v9fs_trans_unix;
+                trans = p9_trans_create_unix(dev_name);
                 *v9ses->remotename = 0;
                 break;
         case PROTO_FD:
-                trans_proto = &v9fs_trans_fd;
+                trans = p9_trans_create_fd(v9ses->rfdno, v9ses->wfdno);
                 *v9ses->remotename = 0;
                 break;
+#ifdef CONFIG_PCI_9P
+        case PROTO_PCI:
+                trans = p9pci_trans_create();
+                *v9ses->remotename = 0;
+                break;
+#endif
         default:
                 printk(KERN_ERR "v9fs: Bad mount protocol %d\n", v9ses->proto);
                 retval = -ENOPROTOOPT;
-                goto SessCleanUp;
+                goto error;
         };
 
-        v9ses->transport = kmalloc(sizeof(*v9ses->transport), GFP_KERNEL);
-        if (!v9ses->transport) {
-                retval = -ENOMEM;
-                goto SessCleanUp;
+        if (IS_ERR(trans)) {
+                retval = PTR_ERR(trans);
+                trans = NULL;
+                goto error;
         }
 
-        memmove(v9ses->transport, trans_proto, sizeof(*v9ses->transport));
+        v9ses->clnt = p9_client_create(trans, v9ses->maxdata + P9_IOHDRSZ,
+                v9ses->extended);
 
-        if ((retval = v9ses->transport->init(v9ses, dev_name, data)) < 0) {
-                eprintk(KERN_ERR, "problem initializing transport\n");
-                goto SessCleanUp;
+        if (IS_ERR(v9ses->clnt)) {
+                retval = PTR_ERR(v9ses->clnt);
+                v9ses->clnt = NULL;
+                P9_DPRINTK(P9_DEBUG_ERROR, "problem initializing 9p client\n");
+                goto error;
         }
 
-        v9ses->inprogress = 0;
-        v9ses->shutdown = 0;
-        v9ses->session_hung = 0;
-
-        v9ses->mux = v9fs_mux_init(v9ses->transport, v9ses->maxdata + V9FS_IOHDRSZ,
-                &v9ses->extended);
-
-        if (IS_ERR(v9ses->mux)) {
-                retval = PTR_ERR(v9ses->mux);
-                v9ses->mux = NULL;
-                dprintk(DEBUG_ERROR, "problem initializing mux\n");
-                goto SessCleanUp;
+        fid = p9_client_attach(v9ses->clnt, NULL, v9ses->name,
+                                                        v9ses->remotename);
+        if (IS_ERR(fid)) {
+                retval = PTR_ERR(fid);
+                fid = NULL;
+                P9_DPRINTK(P9_DEBUG_ERROR, "cannot attach\n");
+                goto error;
         }
 
-        if (v9ses->afid == ~0) {
-                if (v9ses->extended)
-                        retval =
-                            v9fs_t_version(v9ses, v9ses->maxdata, "9P2000.u",
-                                           &fcall);
-                else
-                        retval = v9fs_t_version(v9ses, v9ses->maxdata, "9P2000",
-                                                &fcall);
-
-                if (retval < 0) {
-                        dprintk(DEBUG_ERROR, "v9fs_t_version failed\n");
-                        goto FreeFcall;
-                }
-
-                version = &fcall->params.rversion.version;
-                if (version->len==8 && !memcmp(version->str, "9P2000.u", 8)) {
-                        dprintk(DEBUG_9P, "9P2000 UNIX extensions enabled\n");
-                        v9ses->extended = 1;
-                } else if (version->len==6 && !memcmp(version->str, "9P2000", 6)) {
-                        dprintk(DEBUG_9P, "9P2000 legacy mode enabled\n");
-                        v9ses->extended = 0;
-                } else {
-                        retval = -EREMOTEIO;
-                        goto FreeFcall;
-                }
+        return fid;
 
-                n = fcall->params.rversion.msize;
-                kfree(fcall);
-
-                if (n < v9ses->maxdata)
-                        v9ses->maxdata = n;
-        }
-
-        newfid = v9fs_get_idpool(&v9ses->fidpool);
-        if (newfid < 0) {
-                eprintk(KERN_WARNING, "couldn't allocate FID\n");
-                retval = -ENOMEM;
-                goto SessCleanUp;
-        }
-        /* it is a little bit ugly, but we have to prevent newfid */
-        /* being the same as afid, so if it is, get a new fid     */
-        if (v9ses->afid != ~0 && newfid == v9ses->afid) {
-                newfid = v9fs_get_idpool(&v9ses->fidpool);
-                if (newfid < 0) {
-                        eprintk(KERN_WARNING, "couldn't allocate FID\n");
-                        retval = -ENOMEM;
-                        goto SessCleanUp;
-                }
-        }
-
-        if ((retval =
-             v9fs_t_attach(v9ses, v9ses->name, v9ses->remotename, newfid,
-                           v9ses->afid, NULL))
-            < 0) {
-                dprintk(DEBUG_ERROR, "cannot attach\n");
-                goto SessCleanUp;
-        }
-
-        if (v9ses->afid != ~0) {
-                dprintk(DEBUG_ERROR, "afid not equal to ~0\n");
-                if (v9fs_t_clunk(v9ses, v9ses->afid))
-                        dprintk(DEBUG_ERROR, "clunk failed\n");
-        }
-
-        return newfid;
-
-      FreeFcall:
-        kfree(fcall);
-
-      SessCleanUp:
+error:
         v9fs_session_close(v9ses);
-        return retval;
+        return ERR_PTR(retval);
 }
 
 /**
@@ -426,15 +281,9 @@ v9fs_session_init(struct v9fs_session_info *v9ses,
 
 void v9fs_session_close(struct v9fs_session_info *v9ses)
 {
-        if (v9ses->mux) {
-                v9fs_mux_destroy(v9ses->mux);
-                v9ses->mux = NULL;
-        }
-
-        if (v9ses->transport) {
-                v9ses->transport->close(v9ses->transport);
-                kfree(v9ses->transport);
-                v9ses->transport = NULL;
+        if (v9ses->clnt) {
+                p9_client_destroy(v9ses->clnt);
+                v9ses->clnt = NULL;
         }
 
         __putname(v9ses->name);
@@ -446,9 +295,8 @@ void v9fs_session_close(struct v9fs_session_info *v9ses)
  *      and cancel all pending requests.
  */
 void v9fs_session_cancel(struct v9fs_session_info *v9ses) {
-        dprintk(DEBUG_ERROR, "cancel session %p\n", v9ses);
-        v9ses->transport->status = Disconnected;
-        v9fs_mux_cancel(v9ses->mux, -EIO);
+        P9_DPRINTK(P9_DEBUG_ERROR, "cancel session %p\n", v9ses);
+        p9_client_disconnect(v9ses->clnt);
 }
 
 extern int v9fs_error_init(void);
@@ -460,24 +308,9 @@ extern int v9fs_error_init(void);
 
 static int __init init_v9fs(void)
 {
-        int ret;
-
-        v9fs_error_init();
-
         printk(KERN_INFO "Installing v9fs 9p2000 file system support\n");
 
-        ret = v9fs_mux_global_init();
-        if (ret) {
-                printk(KERN_WARNING "v9fs: starting mux failed\n");
-                return ret;
-        }
-        ret = register_filesystem(&v9fs_fs_type);
-        if (ret) {
-                printk(KERN_WARNING "v9fs: registering file system failed\n");
-                v9fs_mux_global_exit();
-        }
-
-        return ret;
+        return register_filesystem(&v9fs_fs_type);
 }
 
 /**
@@ -487,13 +320,13 @@ static int __init init_v9fs(void)
 
 static void __exit exit_v9fs(void)
 {
-        v9fs_mux_global_exit();
         unregister_filesystem(&v9fs_fs_type);
 }
 
 module_init(init_v9fs)
 module_exit(exit_v9fs)
 
+MODULE_AUTHOR("Latchesar Ionkov <lucho@ionkov.net>");
 MODULE_AUTHOR("Eric Van Hensbergen <ericvh@gmail.com>");
 MODULE_AUTHOR("Ron Minnich <rminnich@lanl.gov>");
 MODULE_LICENSE("GPL");
diff --git a/fs/9p/v9fs.h b/fs/9p/v9fs.h
index 820bf5ca35d..abc4b1668ac 100644
--- a/fs/9p/v9fs.h
+++ b/fs/9p/v9fs.h
@@ -22,16 +22,6 @@
  */
 
 /*
-  * Idpool structure provides lock and id management
-  *
-  */
-
-struct v9fs_idpool {
-        struct semaphore lock;
-        struct idr pool;
-};
-
-/*
   * Session structure provides information for an opened session
   *
   */
@@ -54,15 +44,7 @@ struct v9fs_session_info {
         unsigned int uid;       /* default uid/muid for legacy support */
         unsigned int gid;       /* default gid for legacy support */
 
-        /* book keeping */
-        struct v9fs_idpool fidpool;     /* The FID pool for file descriptors */
-
-        struct v9fs_transport *transport;
-        struct v9fs_mux_data *mux;
-
-        int inprogress;         /* session in progress => true */
-        int shutdown;           /* session shutting down. no more attaches. */
-        unsigned char session_hung;
+        struct p9_client *clnt; /* 9p client */
         struct dentry *debugfs_dir;
 };
 
@@ -71,6 +53,7 @@ enum {
         PROTO_TCP,
         PROTO_UNIX,
         PROTO_FD,
+        PROTO_PCI,
 };
 
 /* possible values of ->cache */
@@ -82,12 +65,9 @@ enum {
 
 extern struct dentry *v9fs_debugfs_root;
 
-int v9fs_session_init(struct v9fs_session_info *, const char *, char *);
-struct v9fs_session_info *v9fs_inode2v9ses(struct inode *);
+struct p9_fid *v9fs_session_init(struct v9fs_session_info *, const char *,
+                                                                        char *);
 void v9fs_session_close(struct v9fs_session_info *v9ses);
-int v9fs_get_idpool(struct v9fs_idpool *p);
-void v9fs_put_idpool(int id, struct v9fs_idpool *p);
-int v9fs_check_idpool(int id, struct v9fs_idpool *p);
 void v9fs_session_cancel(struct v9fs_session_info *v9ses);
 
 #define V9FS_MAGIC 0x01021997
@@ -97,3 +77,7 @@ void v9fs_session_cancel(struct v9fs_session_info *v9ses);
 #define V9FS_DEFUSER    "nobody"
 #define V9FS_DEFANAME   ""
 
+static inline struct v9fs_session_info *v9fs_inode2v9ses(struct inode *inode)
+{
+        return (inode->i_sb->s_fs_info);
+}
diff --git a/fs/9p/v9fs_vfs.h b/fs/9p/v9fs_vfs.h
index 6a82d39dc49..fd01d90cada 100644
--- a/fs/9p/v9fs_vfs.h
+++ b/fs/9p/v9fs_vfs.h
@@ -45,10 +45,10 @@ extern struct dentry_operations v9fs_dentry_operations;
 extern struct dentry_operations v9fs_cached_dentry_operations;
 
 struct inode *v9fs_get_inode(struct super_block *sb, int mode);
-ino_t v9fs_qid2ino(struct v9fs_qid *qid);
-void v9fs_stat2inode(struct v9fs_stat *, struct inode *, struct super_block *);
+ino_t v9fs_qid2ino(struct p9_qid *qid);
+void v9fs_stat2inode(struct p9_stat *, struct inode *, struct super_block *);
 int v9fs_dir_release(struct inode *inode, struct file *filp);
 int v9fs_file_open(struct inode *inode, struct file *file);
-void v9fs_inode2stat(struct inode *inode, struct v9fs_stat *stat);
+void v9fs_inode2stat(struct inode *inode, struct p9_stat *stat);
 void v9fs_dentry_release(struct dentry *);
 int v9fs_uflags2omode(int uflags);
diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c
index 9ac4ffe9ac7..6248f0e727a 100644
--- a/fs/9p/vfs_addr.c
+++ b/fs/9p/vfs_addr.c
@@ -33,10 +33,10 @@
 #include <linux/pagemap.h>
 #include <linux/idr.h>
 #include <linux/sched.h>
+#include <net/9p/9p.h>
+#include <net/9p/client.h>
 
-#include "debug.h"
 #include "v9fs.h"
-#include "9p.h"
 #include "v9fs_vfs.h"
 #include "fid.h"
 
@@ -50,55 +50,26 @@
 
 static int v9fs_vfs_readpage(struct file *filp, struct page *page)
 {
-        char *buffer = NULL;
-        int retval = -EIO;
-        loff_t offset = page_offset(page);
-        int count = PAGE_CACHE_SIZE;
-        struct inode *inode = filp->f_path.dentry->d_inode;
-        struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
-        int rsize = v9ses->maxdata - V9FS_IOHDRSZ;
-        struct v9fs_fid *v9f = filp->private_data;
-        struct v9fs_fcall *fcall = NULL;
-        int fid = v9f->fid;
-        int total = 0;
-        int result = 0;
-
-        dprintk(DEBUG_VFS, "\n");
+        int retval;
+        loff_t offset;
+        char *buffer;
+        struct p9_fid *fid;
 
+        P9_DPRINTK(P9_DEBUG_VFS, "\n");
+        fid = filp->private_data;
         buffer = kmap(page);
-        do {
-                if (count < rsize)
-                        rsize = count;
-
-                result = v9fs_t_read(v9ses, fid, offset, rsize, &fcall);
-
-                if (result < 0) {
-                        printk(KERN_ERR "v9fs_t_read returned %d\n",
-                               result);
-
-                        kfree(fcall);
-                        goto UnmapAndUnlock;
-                } else
-                        offset += result;
-
-                memcpy(buffer, fcall->params.rread.data, result);
-
-                count -= result;
-                buffer += result;
-                total += result;
-
-                kfree(fcall);
+        offset = page_offset(page);
 
-                if (result < rsize)
-                        break;
-        } while (count);
+        retval = p9_client_readn(fid, buffer, offset, PAGE_CACHE_SIZE);
+        if (retval < 0)
+                goto done;
 
-        memset(buffer, 0, count);
+        memset(buffer + retval, 0, PAGE_CACHE_SIZE - retval);
         flush_dcache_page(page);
         SetPageUptodate(page);
         retval = 0;
 
-UnmapAndUnlock:
+done:
         kunmap(page);
         unlock_page(page);
         return retval;
diff --git a/fs/9p/vfs_dentry.c b/fs/9p/vfs_dentry.c
index d93960429c0..f9534f18df0 100644
--- a/fs/9p/vfs_dentry.c
+++ b/fs/9p/vfs_dentry.c
@@ -34,10 +34,10 @@
 #include <linux/namei.h>
 #include <linux/idr.h>
 #include <linux/sched.h>
+#include <net/9p/9p.h>
+#include <net/9p/client.h>
 
-#include "debug.h"
 #include "v9fs.h"
-#include "9p.h"
 #include "v9fs_vfs.h"
 #include "fid.h"
 
@@ -52,7 +52,7 @@
 
 static int v9fs_dentry_delete(struct dentry *dentry)
 {
-        dprintk(DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
+        P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
 
         return 1;
 }
@@ -69,7 +69,7 @@ static int v9fs_dentry_delete(struct dentry *dentry)
 static int v9fs_cached_dentry_delete(struct dentry *dentry)
 {
         struct inode *inode = dentry->d_inode;
-        dprintk(DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
+        P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
 
         if(!inode)
                 return 1;
@@ -85,26 +85,19 @@ static int v9fs_cached_dentry_delete(struct dentry *dentry)
 
 void v9fs_dentry_release(struct dentry *dentry)
 {
-        int err;
-
-        dprintk(DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
-
-        if (dentry->d_fsdata != NULL) {
-                struct list_head *fid_list = dentry->d_fsdata;
-                struct v9fs_fid *temp = NULL;
-                struct v9fs_fid *current_fid = NULL;
-
-                list_for_each_entry_safe(current_fid, temp, fid_list, list) {
-                        err = v9fs_t_clunk(current_fid->v9ses, current_fid->fid);
-
-                        if (err < 0)
-                                dprintk(DEBUG_ERROR, "clunk failed: %d name %s\n",
-                                        err, dentry->d_iname);
-
-                        v9fs_fid_destroy(current_fid);
+        struct v9fs_dentry *dent;
+        struct p9_fid *temp, *current_fid;
+
+        P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
+        dent = dentry->d_fsdata;
+        if (dent) {
+                list_for_each_entry_safe(current_fid, temp, &dent->fidlist,
+                                                                        dlist) {
+                        p9_client_clunk(current_fid);
                 }
 
-                kfree(dentry->d_fsdata);        /* free the list_head */
+                kfree(dent);
+                dentry->d_fsdata = NULL;
         }
 }
 
diff --git a/fs/9p/vfs_dir.c b/fs/9p/vfs_dir.c
index 1dd86ee90bc..0924d4477da 100644
--- a/fs/9p/vfs_dir.c
+++ b/fs/9p/vfs_dir.c
@@ -32,11 +32,10 @@
 #include <linux/sched.h>
 #include <linux/inet.h>
 #include <linux/idr.h>
+#include <net/9p/9p.h>
+#include <net/9p/client.h>
 
-#include "debug.h"
 #include "v9fs.h"
-#include "9p.h"
-#include "conv.h"
 #include "v9fs_vfs.h"
 #include "fid.h"
 
@@ -46,14 +45,14 @@
  *
  */
 
-static inline int dt_type(struct v9fs_stat *mistat)
+static inline int dt_type(struct p9_stat *mistat)
 {
         unsigned long perm = mistat->mode;
         int rettype = DT_REG;
 
-        if (perm & V9FS_DMDIR)
+        if (perm & P9_DMDIR)
                 rettype = DT_DIR;
-        if (perm & V9FS_DMSYMLINK)
+        if (perm & P9_DMSYMLINK)
                 rettype = DT_LNK;
 
         return rettype;
@@ -69,106 +68,36 @@ static inline int dt_type(struct v9fs_stat *mistat)
 
 static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir)
 {
-        struct v9fs_fcall *fcall = NULL;
-        struct inode *inode = filp->f_path.dentry->d_inode;
-        struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
-        struct v9fs_fid *file = filp->private_data;
-        unsigned int i, n, s;
-        int fid = -1;
-        int ret = 0;
-        struct v9fs_stat stat;
-        int over = 0;
-
-        dprintk(DEBUG_VFS, "name %s\n", filp->f_path.dentry->d_name.name);
-
-        fid = file->fid;
-
-        if (file->rdir_fcall && (filp->f_pos != file->rdir_pos)) {
-                kfree(file->rdir_fcall);
-                file->rdir_fcall = NULL;
-        }
-
-        if (file->rdir_fcall) {
-                n = file->rdir_fcall->params.rread.count;
-                i = file->rdir_fpos;
-                while (i < n) {
-                        s = v9fs_deserialize_stat(
-                                file->rdir_fcall->params.rread.data + i,
-                                n - i, &stat, v9ses->extended);
-
-                        if (s == 0) {
-                                dprintk(DEBUG_ERROR,
-                                        "error while deserializing stat\n");
-                                ret = -EIO;
-                                goto FreeStructs;
-                        }
-
-                        over = filldir(dirent, stat.name.str, stat.name.len,
-                                    filp->f_pos, v9fs_qid2ino(&stat.qid),
-                                    dt_type(&stat));
-
-                        if (over) {
-                                file->rdir_fpos = i;
-                                file->rdir_pos = filp->f_pos;
-                                break;
-                        }
-
-                        i += s;
-                        filp->f_pos += s;
-                }
-
-                if (!over) {
-                        kfree(file->rdir_fcall);
-                        file->rdir_fcall = NULL;
-                }
-        }
-
-        while (!over) {
-                ret = v9fs_t_read(v9ses, fid, filp->f_pos,
-                        v9ses->maxdata-V9FS_IOHDRSZ, &fcall);
-                if (ret < 0) {
-                        dprintk(DEBUG_ERROR, "error while reading: %d: %p\n",
-                                ret, fcall);
-                        goto FreeStructs;
-                } else if (ret == 0)
+        int over;
+        struct p9_fid *fid;
+        struct v9fs_session_info *v9ses;
+        struct inode *inode;
+        struct p9_stat *st;
+
+        P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", filp->f_path.dentry->d_name.name);
+        inode = filp->f_path.dentry->d_inode;
+        v9ses = v9fs_inode2v9ses(inode);
+        fid = filp->private_data;
+        while ((st = p9_client_dirread(fid, filp->f_pos)) != NULL) {
+                if (IS_ERR(st))
+                        return PTR_ERR(st);
+
+                over = filldir(dirent, st->name.str, st->name.len, filp->f_pos,
+                        v9fs_qid2ino(&st->qid), dt_type(st));
+
+                if (over)
                         break;
 
-                n = ret;
-                i = 0;
-                while (i < n) {
-                        s = v9fs_deserialize_stat(fcall->params.rread.data + i,
-                                n - i, &stat, v9ses->extended);
-
-                        if (s == 0) {
-                                dprintk(DEBUG_ERROR,
-                                        "error while deserializing stat\n");
-                                return -EIO;
-                        }
-
-                        over = filldir(dirent, stat.name.str, stat.name.len,
-                                    filp->f_pos, v9fs_qid2ino(&stat.qid),
-                                    dt_type(&stat));
-
-                        if (over) {
-                                file->rdir_fcall = fcall;
-                                file->rdir_fpos = i;
-                                file->rdir_pos = filp->f_pos;
-                                fcall = NULL;
-                                break;
-                        }
-
-                        i += s;
-                        filp->f_pos += s;
-                }
-
-                kfree(fcall);
+                filp->f_pos += st->size;
+                kfree(st);
+                st = NULL;
         }
 
-      FreeStructs:
-        kfree(fcall);
-        return ret;
+        kfree(st);
+        return 0;
 }
 
+
 /**
  * v9fs_dir_release - close a directory
  * @inode: inode of the directory
@@ -178,29 +107,13 @@ static int v9fs_dir_readdir(struct file *filp, void *dirent, filldir_t filldir)
 
 int v9fs_dir_release(struct inode *inode, struct file *filp)
 {
-        struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
-        struct v9fs_fid *fid = filp->private_data;
-        int fidnum = -1;
-
-        dprintk(DEBUG_VFS, "inode: %p filp: %p fid: %d\n", inode, filp,
-                fid->fid);
-        fidnum = fid->fid;
+        struct p9_fid *fid;
 
+        fid = filp->private_data;
+        P9_DPRINTK(P9_DEBUG_VFS,
+                        "inode: %p filp: %p fid: %d\n", inode, filp, fid->fid);
         filemap_write_and_wait(inode->i_mapping);
-
-        if (fidnum >= 0) {
-                dprintk(DEBUG_VFS, "fidopen: %d v9f->fid: %d\n", fid->fidopen,
-                        fid->fid);
-
-                if (v9fs_t_clunk(v9ses, fidnum))
-                        dprintk(DEBUG_ERROR, "clunk failed\n");
-
-                kfree(fid->rdir_fcall);
-                kfree(fid);
-
-                filp->private_data = NULL;
-        }
-
+        p9_client_clunk(fid);
         return 0;
 }
 
diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index 6e7678e4852..2a40c2946d0 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -34,10 +34,10 @@
 #include <linux/list.h>
 #include <asm/uaccess.h>
 #include <linux/idr.h>
+#include <net/9p/9p.h>
+#include <net/9p/client.h>
 
-#include "debug.h"
 #include "v9fs.h"
-#include "9p.h"
 #include "v9fs_vfs.h"
 #include "fid.h"
 
@@ -52,48 +52,40 @@ static const struct file_operations v9fs_cached_file_operations;
 
 int v9fs_file_open(struct inode *inode, struct file *file)
 {
-        struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
-        struct v9fs_fid *vfid;
-        struct v9fs_fcall *fcall = NULL;
-        int omode;
         int err;
+        struct v9fs_session_info *v9ses;
+        struct p9_fid *fid;
+        int omode;
 
-        dprintk(DEBUG_VFS, "inode: %p file: %p \n", inode, file);
-
-        vfid = v9fs_fid_clone(file->f_path.dentry);
-        if (IS_ERR(vfid))
-                return PTR_ERR(vfid);
-
+        P9_DPRINTK(P9_DEBUG_VFS, "inode: %p file: %p \n", inode, file);
+        v9ses = v9fs_inode2v9ses(inode);
         omode = v9fs_uflags2omode(file->f_flags);
-        err = v9fs_t_open(v9ses, vfid->fid, omode, &fcall);
-        if (err < 0) {
-                PRINT_FCALL_ERROR("open failed", fcall);
-                goto Clunk_Fid;
+        fid = file->private_data;
+        if (!fid) {
+                fid = v9fs_fid_clone(file->f_path.dentry);
+                if (IS_ERR(fid))
+                        return PTR_ERR(fid);
+
+                err = p9_client_open(fid, omode);
+                if (err < 0) {
+                        p9_client_clunk(fid);
+                        return err;
+                }
+                if (omode & P9_OTRUNC) {
+                        inode->i_size = 0;
+                        inode->i_blocks = 0;
+                }
         }
 
-        file->private_data = vfid;
-        vfid->fidopen = 1;
-        vfid->fidclunked = 0;
-        vfid->iounit = fcall->params.ropen.iounit;
-        vfid->rdir_pos = 0;
-        vfid->rdir_fcall = NULL;
-        vfid->filp = file;
-        kfree(fcall);
-
-        if((vfid->qid.version) && (v9ses->cache)) {
-                dprintk(DEBUG_VFS, "cached");
+        file->private_data = fid;
+        if ((fid->qid.version) && (v9ses->cache)) {
+                P9_DPRINTK(P9_DEBUG_VFS, "cached");
                 /* enable cached file options */
                 if(file->f_op == &v9fs_file_operations)
                         file->f_op = &v9fs_cached_file_operations;
         }
 
         return 0;
-
-Clunk_Fid:
-        v9fs_fid_clunk(v9ses, vfid);
-        kfree(fcall);
-
-        return err;
 }
 
 /**
@@ -110,7 +102,7 @@ static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl)
         int res = 0;
         struct inode *inode = filp->f_path.dentry->d_inode;
 
-        dprintk(DEBUG_VFS, "filp: %p lock: %p\n", filp, fl);
+        P9_DPRINTK(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl);
 
         /* No mandatory locks */
         if ((inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
@@ -136,55 +128,16 @@ static ssize_t
 v9fs_file_read(struct file *filp, char __user * data, size_t count,
                loff_t * offset)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
-        struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
-        struct v9fs_fid *v9f = filp->private_data;
-        struct v9fs_fcall *fcall = NULL;
-        int fid = v9f->fid;
-        int rsize = 0;
-        int result = 0;
-        int total = 0;
-        int n;
-
-        dprintk(DEBUG_VFS, "\n");
-
-        rsize = v9ses->maxdata - V9FS_IOHDRSZ;
-        if (v9f->iounit != 0 && rsize > v9f->iounit)
-                rsize = v9f->iounit;
-
-        do {
-                if (count < rsize)
-                        rsize = count;
+        int ret;
+        struct p9_fid *fid;
 
-                result = v9fs_t_read(v9ses, fid, *offset, rsize, &fcall);
+        P9_DPRINTK(P9_DEBUG_VFS, "\n");
+        fid = filp->private_data;
+        ret = p9_client_uread(fid, data, *offset, count);
+        if (ret > 0)
+                *offset += ret;
 
-                if (result < 0) {
-                        printk(KERN_ERR "9P2000: v9fs_t_read returned %d\n",
-                               result);
-
-                        kfree(fcall);
-                        return total;
-                } else
-                        *offset += result;
-
-                n = copy_to_user(data, fcall->params.rread.data, result);
-                if (n) {
-                        dprintk(DEBUG_ERROR, "Problem copying to user %d\n", n);
-                        kfree(fcall);
-                        return -EFAULT;
-                }
-
-                count -= result;
-                data += result;
-                total += result;
-
-                kfree(fcall);
-
-                if (result < rsize)
-                        break;
-        } while (count);
-
-        return total;
+        return ret;
 }
 
 /**
@@ -200,50 +153,25 @@ static ssize_t
 v9fs_file_write(struct file *filp, const char __user * data,
                 size_t count, loff_t * offset)
 {
+        int ret;
+        struct p9_fid *fid;
         struct inode *inode = filp->f_path.dentry->d_inode;
-        struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
-        struct v9fs_fid *v9fid = filp->private_data;
-        struct v9fs_fcall *fcall;
-        int fid = v9fid->fid;
-        int result = -EIO;
-        int rsize = 0;
-        int total = 0;
-
-        dprintk(DEBUG_VFS, "data %p count %d offset %x\n", data, (int)count,
-                (int)*offset);
-        rsize = v9ses->maxdata - V9FS_IOHDRSZ;
-        if (v9fid->iounit != 0 && rsize > v9fid->iounit)
-                rsize = v9fid->iounit;
-
-        do {
-                if (count < rsize)
-                        rsize = count;
 
-                result = v9fs_t_write(v9ses, fid, *offset, rsize, data, &fcall);
-                if (result < 0) {
-                        PRINT_FCALL_ERROR("error while writing", fcall);
-                        kfree(fcall);
-                        return result;
-                } else
-                        *offset += result;
+        P9_DPRINTK(P9_DEBUG_VFS, "data %p count %d offset %x\n", data,
+                (int)count, (int)*offset);
 
-                kfree(fcall);
-                fcall = NULL;
+        fid = filp->private_data;
+        ret = p9_client_uwrite(fid, data, *offset, count);
+        if (ret > 0)
+                *offset += ret;
 
-                if (result != rsize) {
-                        eprintk(KERN_ERR,
-                                "short write: v9fs_t_write returned %d\n",
-                                result);
-                        break;
-                }
-
-                count -= result;
-                data += result;
-                total += result;
-        } while (count);
+        if (*offset > inode->i_size) {
+                inode->i_size = *offset;
+                inode->i_blocks = (inode->i_size + 512 - 1) >> 9;
+        }
 
         invalidate_inode_pages2(inode->i_mapping);
-        return total;
+        return ret;
 }
 
 static const struct file_operations v9fs_cached_file_operations = {
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index c76cd8fa3f6..e5c45eed58a 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -34,10 +34,10 @@
 #include <linux/namei.h>
 #include <linux/idr.h>
 #include <linux/sched.h>
+#include <net/9p/9p.h>
+#include <net/9p/client.h>
 
-#include "debug.h"
 #include "v9fs.h"
-#include "9p.h"
 #include "v9fs_vfs.h"
 #include "fid.h"
 
@@ -58,27 +58,27 @@ static int unixmode2p9mode(struct v9fs_session_info *v9ses, int mode)
         int res;
         res = mode & 0777;
         if (S_ISDIR(mode))
-                res |= V9FS_DMDIR;
+                res |= P9_DMDIR;
         if (v9ses->extended) {
                 if (S_ISLNK(mode))
-                        res |= V9FS_DMSYMLINK;
+                        res |= P9_DMSYMLINK;
                 if (v9ses->nodev == 0) {
                         if (S_ISSOCK(mode))
-                                res |= V9FS_DMSOCKET;
+                                res |= P9_DMSOCKET;
                         if (S_ISFIFO(mode))
-                                res |= V9FS_DMNAMEDPIPE;
+                                res |= P9_DMNAMEDPIPE;
                         if (S_ISBLK(mode))
-                                res |= V9FS_DMDEVICE;
+                                res |= P9_DMDEVICE;
                         if (S_ISCHR(mode))
-                                res |= V9FS_DMDEVICE;
+                                res |= P9_DMDEVICE;
                 }
 
                 if ((mode & S_ISUID) == S_ISUID)
-                        res |= V9FS_DMSETUID;
+                        res |= P9_DMSETUID;
                 if ((mode & S_ISGID) == S_ISGID)
-                        res |= V9FS_DMSETGID;
-                if ((mode & V9FS_DMLINK))
-                        res |= V9FS_DMLINK;
+                        res |= P9_DMSETGID;
+                if ((mode & P9_DMLINK))
+                        res |= P9_DMLINK;
         }
 
         return res;
@@ -97,27 +97,27 @@ static int p9mode2unixmode(struct v9fs_session_info *v9ses, int mode)
 
         res = mode & 0777;
 
-        if ((mode & V9FS_DMDIR) == V9FS_DMDIR)
+        if ((mode & P9_DMDIR) == P9_DMDIR)
                 res |= S_IFDIR;
-        else if ((mode & V9FS_DMSYMLINK) && (v9ses->extended))
+        else if ((mode & P9_DMSYMLINK) && (v9ses->extended))
                 res |= S_IFLNK;
-        else if ((mode & V9FS_DMSOCKET) && (v9ses->extended)
+        else if ((mode & P9_DMSOCKET) && (v9ses->extended)
                  && (v9ses->nodev == 0))
                 res |= S_IFSOCK;
-        else if ((mode & V9FS_DMNAMEDPIPE) && (v9ses->extended)
+        else if ((mode & P9_DMNAMEDPIPE) && (v9ses->extended)
                  && (v9ses->nodev == 0))
                 res |= S_IFIFO;
-        else if ((mode & V9FS_DMDEVICE) && (v9ses->extended)
+        else if ((mode & P9_DMDEVICE) && (v9ses->extended)
                  && (v9ses->nodev == 0))
                 res |= S_IFBLK;
         else
                 res |= S_IFREG;
 
         if (v9ses->extended) {
-                if ((mode & V9FS_DMSETUID) == V9FS_DMSETUID)
+                if ((mode & P9_DMSETUID) == P9_DMSETUID)
                         res |= S_ISUID;
 
-                if ((mode & V9FS_DMSETGID) == V9FS_DMSETGID)
+                if ((mode & P9_DMSETGID) == P9_DMSETGID)
                         res |= S_ISGID;
         }
 
@@ -132,26 +132,26 @@ int v9fs_uflags2omode(int uflags)
         switch (uflags&3) {
         default:
         case O_RDONLY:
-                ret = V9FS_OREAD;
+                ret = P9_OREAD;
                 break;
 
         case O_WRONLY:
-                ret = V9FS_OWRITE;
+                ret = P9_OWRITE;
                 break;
 
         case O_RDWR:
-                ret = V9FS_ORDWR;
+                ret = P9_ORDWR;
                 break;
         }
 
         if (uflags & O_EXCL)
-                ret |= V9FS_OEXCL;
+                ret |= P9_OEXCL;
 
         if (uflags & O_TRUNC)
-                ret |= V9FS_OTRUNC;
+                ret |= P9_OTRUNC;
 
         if (uflags & O_APPEND)
-                ret |= V9FS_OAPPEND;
+                ret |= P9_OAPPEND;
 
         return ret;
 }
@@ -164,7 +164,7 @@ int v9fs_uflags2omode(int uflags)
  */
 
 static void
-v9fs_blank_wstat(struct v9fs_wstat *wstat)
+v9fs_blank_wstat(struct p9_wstat *wstat)
 {
         wstat->type = ~0;
         wstat->dev = ~0;
@@ -197,7 +197,7 @@ struct inode *v9fs_get_inode(struct super_block *sb, int mode)
         struct inode *inode;
         struct v9fs_session_info *v9ses = sb->s_fs_info;
 
-        dprintk(DEBUG_VFS, "super block: %p mode: %o\n", sb, mode);
+        P9_DPRINTK(P9_DEBUG_VFS, "super block: %p mode: %o\n", sb, mode);
 
         inode = new_inode(sb);
         if (inode) {
@@ -215,7 +215,8 @@ struct inode *v9fs_get_inode(struct super_block *sb, int mode)
                 case S_IFCHR:
                 case S_IFSOCK:
                         if(!v9ses->extended) {
-                                dprintk(DEBUG_ERROR, "special files without extended mode\n");
+                                P9_DPRINTK(P9_DEBUG_ERROR,
+                                      "special files without extended mode\n");
                                 return ERR_PTR(-EINVAL);
                         }
                         init_special_inode(inode, inode->i_mode,
@@ -227,7 +228,8 @@ struct inode *v9fs_get_inode(struct super_block *sb, int mode)
                         break;
                 case S_IFLNK:
                         if(!v9ses->extended) {
-                                dprintk(DEBUG_ERROR, "extended modes used w/o 9P2000.u\n");
+                                P9_DPRINTK(P9_DEBUG_ERROR,
+                                        "extended modes used w/o 9P2000.u\n");
                                 return ERR_PTR(-EINVAL);
                         }
                         inode->i_op = &v9fs_symlink_inode_operations;
@@ -241,71 +243,19 @@ struct inode *v9fs_get_inode(struct super_block *sb, int mode)
                         inode->i_fop = &v9fs_dir_operations;
                         break;
                 default:
-                        dprintk(DEBUG_ERROR, "BAD mode 0x%x S_IFMT 0x%x\n",
+                        P9_DPRINTK(P9_DEBUG_ERROR,
+                                "BAD mode 0x%x S_IFMT 0x%x\n",
                                 mode, mode & S_IFMT);
                         return ERR_PTR(-EINVAL);
                 }
         } else {
-                eprintk(KERN_WARNING, "Problem allocating inode\n");
+                P9_EPRINTK(KERN_WARNING, "Problem allocating inode\n");
                 return ERR_PTR(-ENOMEM);
         }
         return inode;
 }
 
-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)
-{
-        int fid;
-        int err;
-        struct v9fs_fcall *fcall;
-
-        fid = v9fs_get_idpool(&v9ses->fidpool);
-        if (fid < 0) {
-                eprintk(KERN_WARNING, "no free fids available\n");
-                return -ENOSPC;
-        }
-
-        err = v9fs_t_walk(v9ses, pfid, fid, NULL, &fcall);
-        if (err < 0) {
-                PRINT_FCALL_ERROR("clone error", fcall);
-                if (fcall && fcall->id == RWALK)
-                        goto clunk_fid;
-                else
-                        goto put_fid;
-        }
-        kfree(fcall);
-
-        err = v9fs_t_create(v9ses, fid, name, perm, mode, extension, &fcall);
-        if (err < 0) {
-                PRINT_FCALL_ERROR("create fails", fcall);
-                goto clunk_fid;
-        }
-
-        if (iounit)
-                *iounit = fcall->params.rcreate.iounit;
-
-        if (qid)
-                *qid = fcall->params.rcreate.qid;
-
-        if (fidp)
-                *fidp = fid;
-
-        kfree(fcall);
-        return 0;
-
-clunk_fid:
-        v9fs_t_clunk(v9ses, fid);
-        fid = V9FS_NOFID;
-
-put_fid:
-        if (fid != V9FS_NOFID)
-                v9fs_put_idpool(fid, &v9ses->fidpool);
-
-        kfree(fcall);
-        return err;
-}
-
+/*
 static struct v9fs_fid*
 v9fs_clone_walk(struct v9fs_session_info *v9ses, u32 fid, struct dentry *dentry)
 {
@@ -355,23 +305,25 @@ error:
         kfree(fcall);
         return ERR_PTR(err);
 }
+*/
 
 static struct inode *
-v9fs_inode_from_fid(struct v9fs_session_info *v9ses, u32 fid,
+v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
         struct super_block *sb)
 {
         int err, umode;
         struct inode *ret;
-        struct v9fs_fcall *fcall;
+        struct p9_stat *st;
 
         ret = NULL;
-        err = v9fs_t_stat(v9ses, fid, &fcall);
-        if (err) {
-                PRINT_FCALL_ERROR("stat error", fcall);
+        st = p9_client_stat(fid);
+        if (IS_ERR(st)) {
+                err = PTR_ERR(st);
+                st = NULL;
                 goto error;
         }
 
-        umode = p9mode2unixmode(v9ses, fcall->params.rstat.stat.mode);
+        umode = p9mode2unixmode(v9ses, st->mode);
         ret = v9fs_get_inode(sb, umode);
         if (IS_ERR(ret)) {
                 err = PTR_ERR(ret);
@@ -379,12 +331,13 @@ v9fs_inode_from_fid(struct v9fs_session_info *v9ses, u32 fid,
                 goto error;
         }
 
-        v9fs_stat2inode(&fcall->params.rstat.stat, ret, sb);
-        kfree(fcall);
+        v9fs_stat2inode(st, ret, sb);
+        ret->i_ino = v9fs_qid2ino(&st->qid);
+        kfree(st);
         return ret;
 
 error:
-        kfree(fcall);
+        kfree(st);
         if (ret)
                 iput(ret);
 
@@ -401,43 +354,20 @@ error:
 
 static int v9fs_remove(struct inode *dir, struct dentry *file, int rmdir)
 {
-        struct v9fs_fcall *fcall = NULL;
-        struct super_block *sb = NULL;
-        struct v9fs_session_info *v9ses = NULL;
-        struct v9fs_fid *v9fid = NULL;
-        struct inode *file_inode = NULL;
-        int fid = -1;
-        int result = 0;
+        struct inode *file_inode;
+        struct v9fs_session_info *v9ses;
+        struct p9_fid *v9fid;
 
-        dprintk(DEBUG_VFS, "inode: %p dentry: %p rmdir: %d\n", dir, file,
+        P9_DPRINTK(P9_DEBUG_VFS, "inode: %p dentry: %p rmdir: %d\n", dir, file,
                 rmdir);
 
         file_inode = file->d_inode;
-        sb = file_inode->i_sb;
         v9ses = v9fs_inode2v9ses(file_inode);
         v9fid = v9fs_fid_clone(file);
         if(IS_ERR(v9fid))
                 return PTR_ERR(v9fid);
 
-        fid = v9fid->fid;
-        if (fid < 0) {
-                dprintk(DEBUG_ERROR, "inode #%lu, no fid!\n",
-                        file_inode->i_ino);
-                return -EBADF;
-        }
-
-        result = v9fs_t_remove(v9ses, fid, &fcall);
-        if (result < 0) {
-                PRINT_FCALL_ERROR("remove fails", fcall);
-                goto Error;
-        }
-
-        v9fs_put_idpool(fid, &v9ses->fidpool);
-        v9fs_fid_destroy(v9fid);
-
-Error:
-        kfree(fcall);
-        return result;
+        return p9_client_remove(v9fid);
 }
 
 static int
@@ -446,61 +376,59 @@ v9fs_open_created(struct inode *inode, struct file *file)
         return 0;
 }
 
+
 /**
- * v9fs_vfs_create - VFS hook to create files
- * @inode: directory inode that is being deleted
- * @dentry:  dentry that is being deleted
- * @mode: create permissions
- * @nd: path information
+ * v9fs_create - Create a file
+ * @dentry:  dentry that is being created
+ * @perm: create permissions
+ * @mode: open mode
  *
  */
-
-static int
-v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
-                struct nameidata *nd)
+static struct p9_fid *
+v9fs_create(struct v9fs_session_info *v9ses, struct inode *dir,
+                struct dentry *dentry, char *extension, u32 perm, u8 mode)
 {
         int err;
-        u32 fid, perm, iounit;
-        int flags;
-        struct v9fs_session_info *v9ses;
-        struct v9fs_fid *dfid, *vfid, *ffid;
+        char *name;
+        struct p9_fid *dfid, *ofid, *fid;
         struct inode *inode;
-        struct v9fs_qid qid;
-        struct file *filp;
 
-        inode = NULL;
-        vfid = NULL;
-        v9ses = v9fs_inode2v9ses(dir);
+        err = 0;
+        ofid = NULL;
+        fid = NULL;
+        name = (char *) dentry->d_name.name;
         dfid = v9fs_fid_clone(dentry->d_parent);
         if(IS_ERR(dfid)) {
                 err = PTR_ERR(dfid);
+                dfid = NULL;
                 goto error;
         }
 
-        perm = unixmode2p9mode(v9ses, mode);
-        if (nd && nd->flags & LOOKUP_OPEN)
-                flags = nd->intent.open.flags - 1;
-        else
-                flags = O_RDWR;
-
-        err = v9fs_create(v9ses, dfid->fid, (char *) dentry->d_name.name,
-                perm, v9fs_uflags2omode(flags), NULL, &fid, &qid, &iounit);
+        /* clone a fid to use for creation */
+        ofid = p9_client_walk(dfid, 0, NULL, 1);
+        if (IS_ERR(ofid)) {
+                err = PTR_ERR(ofid);
+                ofid = NULL;
+                goto error;
+        }
 
-        if (err)
-                goto clunk_dfid;
+        err = p9_client_fcreate(ofid, name, perm, mode, extension);
+        if (err < 0)
+                goto error;
 
-        vfid = v9fs_clone_walk(v9ses, dfid->fid, dentry);
-        v9fs_fid_clunk(v9ses, dfid);
-        if (IS_ERR(vfid)) {
-                err = PTR_ERR(vfid);
-                vfid = NULL;
+        /* now walk from the parent so we can get unopened fid */
+        fid = p9_client_walk(dfid, 1, &name, 0);
+        if (IS_ERR(fid)) {
+                err = PTR_ERR(fid);
+                fid = NULL;
                 goto error;
-        }
+        } else
+                dfid = NULL;
 
-        inode = v9fs_inode_from_fid(v9ses, vfid->fid, dir->i_sb);
+        /* instantiate inode and assign the unopened fid to the dentry */
+        inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
         if (IS_ERR(inode)) {
                 err = PTR_ERR(inode);
-                inode = NULL;
                 goto error;
         }
 
@@ -508,35 +436,78 @@ v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
                 dentry->d_op = &v9fs_cached_dentry_operations;
         else
                 dentry->d_op = &v9fs_dentry_operations;
+
         d_instantiate(dentry, inode);
+        v9fs_fid_add(dentry, fid);
+        return ofid;
 
-        if (nd && nd->flags & LOOKUP_OPEN) {
-                ffid = v9fs_fid_create(v9ses, fid);
-                if (!ffid)
-                        return -ENOMEM;
+error:
+        if (dfid)
+                p9_client_clunk(dfid);
+
+        if (ofid)
+                p9_client_clunk(ofid);
+
+        if (fid)
+                p9_client_clunk(fid);
+
+        return ERR_PTR(err);
+}
+
+/**
+ * v9fs_vfs_create - VFS hook to create files
+ * @inode: directory inode that is being created
+ * @dentry:  dentry that is being deleted
+ * @mode: create permissions
+ * @nd: path information
+ *
+ */
 
+static int
+v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
+                struct nameidata *nd)
+{
+        int err;
+        u32 perm;
+        int flags;
+        struct v9fs_session_info *v9ses;
+        struct p9_fid *fid;
+        struct file *filp;
+
+        err = 0;
+        fid = NULL;
+        v9ses = v9fs_inode2v9ses(dir);
+        perm = unixmode2p9mode(v9ses, mode);
+        if (nd && nd->flags & LOOKUP_OPEN)
+                flags = nd->intent.open.flags - 1;
+        else
+                flags = O_RDWR;
+
+        fid = v9fs_create(v9ses, dir, dentry, NULL, perm,
+                                                v9fs_uflags2omode(flags));
+        if (IS_ERR(fid)) {
+                err = PTR_ERR(fid);
+                fid = NULL;
+                goto error;
+        }
+
+        /* if we are opening a file, assign the open fid to the file */
+        if (nd && nd->flags & LOOKUP_OPEN) {
                 filp = lookup_instantiate_filp(nd, dentry, v9fs_open_created);
                 if (IS_ERR(filp)) {
-                        v9fs_fid_destroy(ffid);
-                        return PTR_ERR(filp);
+                        err = PTR_ERR(filp);
+                        goto error;
                 }
 
-                ffid->rdir_pos = 0;
-                ffid->rdir_fcall = NULL;
-                ffid->fidopen = 1;
-                ffid->iounit = iounit;
-                ffid->filp = filp;
-                filp->private_data = ffid;
-        }
+                filp->private_data = fid;
+        } else
+                p9_client_clunk(fid);
 
         return 0;
 
-clunk_dfid:
-        v9fs_fid_clunk(v9ses, dfid);
-
 error:
-        if (vfid)
-                v9fs_fid_destroy(vfid);
+        if (fid)
+                p9_client_clunk(fid);
 
         return err;
 }
@@ -552,57 +523,23 @@ error:
 static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 {
         int err;
-        u32 fid, perm;
+        u32 perm;
         struct v9fs_session_info *v9ses;
-        struct v9fs_fid *dfid, *vfid;
-        struct inode *inode;
+        struct p9_fid *fid;
 
-        inode = NULL;
-        vfid = NULL;
+        P9_DPRINTK(P9_DEBUG_VFS, "name %s\n", dentry->d_name.name);
+        err = 0;
         v9ses = v9fs_inode2v9ses(dir);
-        dfid = v9fs_fid_clone(dentry->d_parent);
-        if(IS_ERR(dfid)) {
-                err = PTR_ERR(dfid);
-                goto error;
-        }
-
         perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
-
-        err = v9fs_create(v9ses, dfid->fid, (char *) dentry->d_name.name,
-                perm, V9FS_OREAD, NULL, &fid, NULL, NULL);
-
-        if (err) {
-                dprintk(DEBUG_ERROR, "create error %d\n", err);
-                goto clean_up_dfid;
+        fid = v9fs_create(v9ses, dir, dentry, NULL, perm, P9_OREAD);
+        if (IS_ERR(fid)) {
+                err = PTR_ERR(fid);
+                fid = NULL;
         }
 
-        vfid = v9fs_clone_walk(v9ses, dfid->fid, dentry);
-        if (IS_ERR(vfid)) {
-                err = PTR_ERR(vfid);
-                vfid = NULL;
-                goto clean_up_dfid;
-        }
+        if (fid)
+                p9_client_clunk(fid);
 
-        v9fs_fid_clunk(v9ses, dfid);
-        inode = v9fs_inode_from_fid(v9ses, vfid->fid, dir->i_sb);
-        if (IS_ERR(inode)) {
-                err = PTR_ERR(inode);
-                inode = NULL;
-                v9fs_fid_destroy(vfid);
-                goto error;
-        }
-
-        if(v9ses->cache)
-                dentry->d_op = &v9fs_cached_dentry_operations;
-        else
-                dentry->d_op = &v9fs_dentry_operations;
-        d_instantiate(dentry, inode);
-        return 0;
-
-clean_up_dfid:
-        v9fs_fid_clunk(v9ses, dfid);
-
-error:
         return err;
 }
 
@@ -619,104 +556,54 @@ static struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
 {
         struct super_block *sb;
         struct v9fs_session_info *v9ses;
-        struct v9fs_fid *dirfid;
-        struct v9fs_fid *fid;
+        struct p9_fid *dfid, *fid;
         struct inode *inode;
-        struct v9fs_fcall *fcall = NULL;
-        int dirfidnum = -1;
-        int newfid = -1;
+        char *name;
         int result = 0;
 
-        dprintk(DEBUG_VFS, "dir: %p dentry: (%s) %p nameidata: %p\n",
+        P9_DPRINTK(P9_DEBUG_VFS, "dir: %p dentry: (%s) %p nameidata: %p\n",
                 dir, dentry->d_name.name, dentry, nameidata);
 
         sb = dir->i_sb;
         v9ses = v9fs_inode2v9ses(dir);
-        dirfid = v9fs_fid_lookup(dentry->d_parent);
-
-        if(IS_ERR(dirfid))
-                return ERR_PTR(PTR_ERR(dirfid));
-
-        dirfidnum = dirfid->fid;
-
-        newfid = v9fs_get_idpool(&v9ses->fidpool);
-        if (newfid < 0) {
-                eprintk(KERN_WARNING, "newfid fails!\n");
-                result = -ENOSPC;
-                goto Release_Dirfid;
-        }
-
-        result = v9fs_t_walk(v9ses, dirfidnum, newfid,
-                (char *)dentry->d_name.name, &fcall);
-
-        up(&dirfid->lock);
-
-        if (result < 0) {
-                if (fcall && fcall->id == RWALK)
-                        v9fs_t_clunk(v9ses, newfid);
-                else
-                        v9fs_put_idpool(newfid, &v9ses->fidpool);
-
+        dfid = v9fs_fid_lookup(dentry->d_parent);
+        if (IS_ERR(dfid))
+                return ERR_PTR(PTR_ERR(dfid));
+
+        name = (char *) dentry->d_name.name;
+        fid = p9_client_walk(dfid, 1, &name, 1);
+        if (IS_ERR(fid)) {
+                result = PTR_ERR(fid);
                 if (result == -ENOENT) {
                         d_add(dentry, NULL);
-                        dprintk(DEBUG_VFS,
-                                "Return negative dentry %p count %d\n",
-                                dentry, atomic_read(&dentry->d_count));
-                        kfree(fcall);
                         return NULL;
                 }
-                dprintk(DEBUG_ERROR, "walk error:%d\n", result);
-                goto FreeFcall;
-        }
-        kfree(fcall);
-
-        result = v9fs_t_stat(v9ses, newfid, &fcall);
-        if (result < 0) {
-                dprintk(DEBUG_ERROR, "stat error\n");
-                goto FreeFcall;
-        }
-
-        inode = v9fs_get_inode(sb, p9mode2unixmode(v9ses,
-                fcall->params.rstat.stat.mode));
 
-        if (IS_ERR(inode) && (PTR_ERR(inode) == -ENOSPC)) {
-                eprintk(KERN_WARNING, "inode alloc failes, returns %ld\n",
-                        PTR_ERR(inode));
-
-                result = -ENOSPC;
-                goto FreeFcall;
+                return ERR_PTR(result);
         }
 
-        inode->i_ino = v9fs_qid2ino(&fcall->params.rstat.stat.qid);
-
-        fid = v9fs_fid_create(v9ses, newfid);
-        if (fid == NULL) {
-                dprintk(DEBUG_ERROR, "couldn't insert\n");
-                result = -ENOMEM;
-                goto FreeFcall;
+        inode = v9fs_inode_from_fid(v9ses, fid, dir->i_sb);
+        if (IS_ERR(inode)) {
+                result = PTR_ERR(inode);
+                inode = NULL;
+                goto error;
         }
 
-        result = v9fs_fid_insert(fid, dentry);
+        result = v9fs_fid_add(dentry, fid);
         if (result < 0)
-                goto FreeFcall;
+                goto error;
 
-        fid->qid = fcall->params.rstat.stat.qid;
-        v9fs_stat2inode(&fcall->params.rstat.stat, inode, inode->i_sb);
         if((fid->qid.version)&&(v9ses->cache))
                 dentry->d_op = &v9fs_cached_dentry_operations;
         else
                 dentry->d_op = &v9fs_dentry_operations;
 
         d_add(dentry, inode);
-        kfree(fcall);
-
         return NULL;
 
-Release_Dirfid:
-        up(&dirfid->lock);
-
-FreeFcall:
-        kfree(fcall);
+error:
+        if (fid)
+                p9_client_clunk(fid);
 
         return ERR_PTR(result);
 }
@@ -758,73 +645,54 @@ static int
 v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                 struct inode *new_dir, struct dentry *new_dentry)
 {
-        struct inode *old_inode = old_dentry->d_inode;
-        struct v9fs_session_info *v9ses = v9fs_inode2v9ses(old_inode);
-        struct v9fs_fid *oldfid = v9fs_fid_lookup(old_dentry);
-        struct v9fs_fid *olddirfid;
-        struct v9fs_fid *newdirfid;
-        struct v9fs_wstat wstat;
-        struct v9fs_fcall *fcall = NULL;
-        int fid = -1;
-        int olddirfidnum = -1;
-        int newdirfidnum = -1;
-        int retval = 0;
-
-        dprintk(DEBUG_VFS, "\n");
+        struct inode *old_inode;
+        struct v9fs_session_info *v9ses;
+        struct p9_fid *oldfid;
+        struct p9_fid *olddirfid;
+        struct p9_fid *newdirfid;
+        struct p9_wstat wstat;
+        int retval;
 
+        P9_DPRINTK(P9_DEBUG_VFS, "\n");
+        retval = 0;
+        old_inode = old_dentry->d_inode;
+        v9ses = v9fs_inode2v9ses(old_inode);
+        oldfid = v9fs_fid_lookup(old_dentry);
         if(IS_ERR(oldfid))
                 return PTR_ERR(oldfid);
 
         olddirfid = v9fs_fid_clone(old_dentry->d_parent);
         if(IS_ERR(olddirfid)) {
                 retval = PTR_ERR(olddirfid);
-                goto Release_lock;
+                goto done;
         }
 
         newdirfid = v9fs_fid_clone(new_dentry->d_parent);
         if(IS_ERR(newdirfid)) {
                 retval = PTR_ERR(newdirfid);
-                goto Clunk_olddir;
+                goto clunk_olddir;
         }
 
         /* 9P can only handle file rename in the same directory */
         if (memcmp(&olddirfid->qid, &newdirfid->qid, sizeof(newdirfid->qid))) {
-                dprintk(DEBUG_ERROR, "old dir and new dir are different\n");
+                P9_DPRINTK(P9_DEBUG_ERROR,
+                                "old dir and new dir are different\n");
                 retval = -EXDEV;
-                goto Clunk_newdir;
-        }
-
-        fid = oldfid->fid;
-        olddirfidnum = olddirfid->fid;
-        newdirfidnum = newdirfid->fid;
-
-        if (fid < 0) {
-                dprintk(DEBUG_ERROR, "no fid for old file #%lu\n",
-                        old_inode->i_ino);
-                retval = -EBADF;
-                goto Clunk_newdir;
+                goto clunk_newdir;
         }
 
         v9fs_blank_wstat(&wstat);
         wstat.muid = v9ses->name;
         wstat.name = (char *) new_dentry->d_name.name;
+        retval = p9_client_wstat(oldfid, &wstat);
 
-        retval = v9fs_t_wstat(v9ses, fid, &wstat, &fcall);
+clunk_newdir:
+        p9_client_clunk(olddirfid);
 
-        if (retval < 0)
-                PRINT_FCALL_ERROR("wstat error", fcall);
-
-        kfree(fcall);
-
-Clunk_newdir:
-        v9fs_fid_clunk(v9ses, newdirfid);
-
-Clunk_olddir:
-        v9fs_fid_clunk(v9ses, olddirfid);
-
-Release_lock:
-        up(&oldfid->lock);
+clunk_olddir:
+        p9_client_clunk(newdirfid);
 
+done:
         return retval;
 }
 
@@ -840,28 +708,30 @@ static int
 v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
                  struct kstat *stat)
 {
-        struct v9fs_fcall *fcall = NULL;
-        struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
-        struct v9fs_fid *fid = v9fs_fid_clone(dentry);
-        int err = -EPERM;
+        int err;
+        struct v9fs_session_info *v9ses;
+        struct p9_fid *fid;
+        struct p9_stat *st;
 
-        dprintk(DEBUG_VFS, "dentry: %p\n", dentry);
-        if(IS_ERR(fid))
+        P9_DPRINTK(P9_DEBUG_VFS, "dentry: %p\n", dentry);
+        err = -EPERM;
+        v9ses = v9fs_inode2v9ses(dentry->d_inode);
+        if (v9ses->cache == CACHE_LOOSE)
+                return simple_getattr(mnt, dentry, stat);
+
+        fid = v9fs_fid_lookup(dentry);
+        if (IS_ERR(fid))
                 return PTR_ERR(fid);
 
-        err = v9fs_t_stat(v9ses, fid->fid, &fcall);
+        st = p9_client_stat(fid);
+        if (IS_ERR(st))
+                return PTR_ERR(st);
 
-        if (err < 0)
-                dprintk(DEBUG_ERROR, "stat error\n");
-        else {
-                v9fs_stat2inode(&fcall->params.rstat.stat, dentry->d_inode,
-                                  dentry->d_inode->i_sb);
+        v9fs_stat2inode(st, dentry->d_inode, dentry->d_inode->i_sb);
                 generic_fillattr(dentry->d_inode, stat);
-        }
 
-        kfree(fcall);
-        v9fs_fid_clunk(v9ses, fid);
-        return err;
+        kfree(st);
+        return 0;
 }
 
 /**
@@ -873,13 +743,15 @@ v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 
 static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
 {
-        struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
-        struct v9fs_fid *fid = v9fs_fid_clone(dentry);
-        struct v9fs_fcall *fcall = NULL;
-        struct v9fs_wstat wstat;
-        int res = -EPERM;
+        int retval;
+        struct v9fs_session_info *v9ses;
+        struct p9_fid *fid;
+        struct p9_wstat wstat;
 
-        dprintk(DEBUG_VFS, "\n");
+        P9_DPRINTK(P9_DEBUG_VFS, "\n");
+        retval = -EPERM;
+        v9ses = v9fs_inode2v9ses(dentry->d_inode);
+        fid = v9fs_fid_lookup(dentry);
         if(IS_ERR(fid))
                 return PTR_ERR(fid);
 
@@ -904,17 +776,11 @@ static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
                         wstat.n_gid = iattr->ia_gid;
         }
 
-        res = v9fs_t_wstat(v9ses, fid->fid, &wstat, &fcall);
+        retval = p9_client_wstat(fid, &wstat);
+        if (retval >= 0)
+                retval = inode_setattr(dentry->d_inode, iattr);
 
-        if (res < 0)
-                PRINT_FCALL_ERROR("wstat error", fcall);
-
-        kfree(fcall);
-        if (res >= 0)
-                res = inode_setattr(dentry->d_inode, iattr);
-
-        v9fs_fid_clunk(v9ses, fid);
-        return res;
+        return retval;
 }
 
 /**
@@ -926,7 +792,7 @@ static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
  */
 
 void
-v9fs_stat2inode(struct v9fs_stat *stat, struct inode *inode,
+v9fs_stat2inode(struct p9_stat *stat, struct inode *inode,
         struct super_block *sb)
 {
         int n;
@@ -967,8 +833,9 @@ v9fs_stat2inode(struct v9fs_stat *stat, struct inode *inode,
                 case 'b':
                         break;
                 default:
-                        dprintk(DEBUG_ERROR, "Unknown special type %c (%.*s)\n",
-                                type, stat->extension.len, stat->extension.str);
+                        P9_DPRINTK(P9_DEBUG_ERROR,
+                                "Unknown special type %c (%.*s)\n", type,
+                                stat->extension.len, stat->extension.str);
                 };
                 inode->i_rdev = MKDEV(major, minor);
         } else
@@ -976,8 +843,8 @@ v9fs_stat2inode(struct v9fs_stat *stat, struct inode *inode,
 
         inode->i_size = stat->length;
 
-        inode->i_blocks =
-            (inode->i_size + sb->s_blocksize - 1) >> sb->s_blocksize_bits;
+        /* not real number of blocks, but 512 byte ones ... */
+        inode->i_blocks = (inode->i_size + 512 - 1) >> 9;
 }
 
 /**
@@ -987,7 +854,7 @@ v9fs_stat2inode(struct v9fs_stat *stat, struct inode *inode,
  * BUG: potential for inode number collisions?
  */
 
-ino_t v9fs_qid2ino(struct v9fs_qid *qid)
+ino_t v9fs_qid2ino(struct p9_qid *qid)
 {
         u64 path = qid->path + 2;
         ino_t i = 0;
@@ -1010,56 +877,46 @@ ino_t v9fs_qid2ino(struct v9fs_qid *qid)
 
 static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
 {
-        int retval = -EPERM;
+        int retval;
 
-        struct v9fs_fcall *fcall = NULL;
-        struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
-        struct v9fs_fid *fid = v9fs_fid_clone(dentry);
+        struct v9fs_session_info *v9ses;
+        struct p9_fid *fid;
+        struct p9_stat *st;
 
+        P9_DPRINTK(P9_DEBUG_VFS, " %s\n", dentry->d_name.name);
+        retval = -EPERM;
+        v9ses = v9fs_inode2v9ses(dentry->d_inode);
+        fid = v9fs_fid_lookup(dentry);
         if(IS_ERR(fid))
                 return PTR_ERR(fid);
 
-        if (!v9ses->extended) {
-                retval = -EBADF;
-                dprintk(DEBUG_ERROR, "not extended\n");
-                goto ClunkFid;
-        }
-
-        dprintk(DEBUG_VFS, " %s\n", dentry->d_name.name);
-        retval = v9fs_t_stat(v9ses, fid->fid, &fcall);
-
-        if (retval < 0) {
-                dprintk(DEBUG_ERROR, "stat error\n");
-                goto FreeFcall;
-        }
+        if (!v9ses->extended)
+                return -EBADF;
 
-        if (!fcall) {
-                retval = -EIO;
-                goto ClunkFid;
-        }
+        st = p9_client_stat(fid);
+        if (IS_ERR(st))
+                return PTR_ERR(st);
 
-        if (!(fcall->params.rstat.stat.mode & V9FS_DMSYMLINK)) {
+        if (!(st->mode & P9_DMSYMLINK)) {
                 retval = -EINVAL;
-                goto FreeFcall;
+                goto done;
         }
 
         /* copy extension buffer into buffer */
-        if (fcall->params.rstat.stat.extension.len < buflen)
-                buflen = fcall->params.rstat.stat.extension.len + 1;
+        if (st->extension.len < buflen)
+                buflen = st->extension.len + 1;
 
-        memmove(buffer, fcall->params.rstat.stat.extension.str, buflen - 1);
+        memmove(buffer, st->extension.str, buflen - 1);
         buffer[buflen-1] = 0;
 
-        dprintk(DEBUG_ERROR, "%s -> %.*s (%s)\n", dentry->d_name.name, fcall->params.rstat.stat.extension.len,
-                fcall->params.rstat.stat.extension.str, buffer);
-        retval = buflen;
+        P9_DPRINTK(P9_DEBUG_VFS,
+                "%s -> %.*s (%s)\n", dentry->d_name.name, st->extension.len,
+                st->extension.str, buffer);
 
-FreeFcall:
-        kfree(fcall);
-
-ClunkFid:
-        v9fs_fid_clunk(v9ses, fid);
+        retval = buflen;
 
+done:
+        kfree(st);
         return retval;
 }
 
@@ -1084,14 +941,14 @@ static int v9fs_vfs_readlink(struct dentry *dentry, char __user * buffer,
         if (buflen > PATH_MAX)
                 buflen = PATH_MAX;
 
-        dprintk(DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
+        P9_DPRINTK(P9_DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
 
         retval = v9fs_readlink(dentry, link, buflen);
 
         if (retval > 0) {
                 if ((ret = copy_to_user(buffer, link, retval)) != 0) {
-                        dprintk(DEBUG_ERROR, "problem copying to user: %d\n",
-                                ret);
+                        P9_DPRINTK(P9_DEBUG_ERROR,
+                                        "problem copying to user: %d\n", ret);
                         retval = ret;
                 }
         }
@@ -1112,7 +969,7 @@ static void *v9fs_vfs_follow_link(struct dentry *dentry, struct nameidata *nd)
         int len = 0;
         char *link = __getname();
 
-        dprintk(DEBUG_VFS, "%s n", dentry->d_name.name);
+        P9_DPRINTK(P9_DEBUG_VFS, "%s n", dentry->d_name.name);
 
         if (!link)
                 link = ERR_PTR(-ENOMEM);
@@ -1141,7 +998,7 @@ static void v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void
 {
         char *s = nd_get_link(nd);
 
-        dprintk(DEBUG_VFS, " %s %s\n", dentry->d_name.name, s);
+        P9_DPRINTK(P9_DEBUG_VFS, " %s %s\n", dentry->d_name.name, s);
         if (!IS_ERR(s))
                 __putname(s);
 }
@@ -1149,66 +1006,24 @@ static void v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void
 static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
         int mode, const char *extension)
 {
-        int err;
-        u32 fid, perm;
+        u32 perm;
         struct v9fs_session_info *v9ses;
-        struct v9fs_fid *dfid, *vfid = NULL;
-        struct inode *inode = NULL;
+        struct p9_fid *fid;
 
         v9ses = v9fs_inode2v9ses(dir);
         if (!v9ses->extended) {
-                dprintk(DEBUG_ERROR, "not extended\n");
+                P9_DPRINTK(P9_DEBUG_ERROR, "not extended\n");
                 return -EPERM;
         }
 
-        dfid = v9fs_fid_clone(dentry->d_parent);
-        if(IS_ERR(dfid)) {
-                err = PTR_ERR(dfid);
-                goto error;
-        }
-
         perm = unixmode2p9mode(v9ses, mode);
+        fid = v9fs_create(v9ses, dir, dentry, (char *) extension, perm,
+                                                                P9_OREAD);
+        if (IS_ERR(fid))
+                return PTR_ERR(fid);
 
-        err = v9fs_create(v9ses, dfid->fid, (char *) dentry->d_name.name,
-                perm, V9FS_OREAD, (char *) extension, &fid, NULL, NULL);
-
-        if (err)
-                goto clunk_dfid;
-
-        err = v9fs_t_clunk(v9ses, fid);
-        if (err)
-                goto clunk_dfid;
-
-        vfid = v9fs_clone_walk(v9ses, dfid->fid, dentry);
-        if (IS_ERR(vfid)) {
-                err = PTR_ERR(vfid);
-                vfid = NULL;
-                goto clunk_dfid;
-        }
-
-        inode = v9fs_inode_from_fid(v9ses, vfid->fid, dir->i_sb);
-        if (IS_ERR(inode)) {
-                err = PTR_ERR(inode);
-                inode = NULL;
-                goto free_vfid;
-        }
-
-        if(v9ses->cache)
-                dentry->d_op = &v9fs_cached_dentry_operations;
-        else
-                dentry->d_op = &v9fs_dentry_operations;
-        d_instantiate(dentry, inode);
+        p9_client_clunk(fid);
         return 0;
-
-free_vfid:
-        v9fs_fid_destroy(vfid);
-
-clunk_dfid:
-        v9fs_fid_clunk(v9ses, dfid);
-
-error:
-        return err;
-
 }
 
 /**
@@ -1224,8 +1039,8 @@ error:
 static int
 v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
 {
-        dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
-                symname);
+        P9_DPRINTK(P9_DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino,
+                                        dentry->d_name.name, symname);
 
         return v9fs_vfs_mkspecial(dir, dentry, S_IFLNK, symname);
 }
@@ -1247,11 +1062,11 @@ v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
               struct dentry *dentry)
 {
         int retval;
-        struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dir);
-        struct v9fs_fid *oldfid;
+        struct p9_fid *oldfid;
         char *name;
 
-        dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
+        P9_DPRINTK(P9_DEBUG_VFS,
+                " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
                 old_dentry->d_name.name);
 
         oldfid = v9fs_fid_clone(old_dentry);
@@ -1265,11 +1080,11 @@ v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
         }
 
         sprintf(name, "%d\n", oldfid->fid);
-        retval = v9fs_vfs_mkspecial(dir, dentry, V9FS_DMLINK, name);
+        retval = v9fs_vfs_mkspecial(dir, dentry, P9_DMLINK, name);
         __putname(name);
 
 clunk_fid:
-        v9fs_fid_clunk(v9ses, oldfid);
+        p9_client_clunk(oldfid);
         return retval;
 }
 
@@ -1288,7 +1103,8 @@ v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
         int retval;
         char *name;
 
-        dprintk(DEBUG_VFS, " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
+        P9_DPRINTK(P9_DEBUG_VFS,
+                " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
                 dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
 
         if (!new_valid_dev(rdev))
diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
index 7bdf8b32684..ba904371218 100644
--- a/fs/9p/vfs_super.c
+++ b/fs/9p/vfs_super.c
@@ -37,10 +37,10 @@
 #include <linux/mount.h>
 #include <linux/idr.h>
 #include <linux/sched.h>
+#include <net/9p/9p.h>
+#include <net/9p/client.h>
 
-#include "debug.h"
 #include "v9fs.h"
-#include "9p.h"
 #include "v9fs_vfs.h"
 #include "fid.h"
 
@@ -107,41 +107,48 @@ static int v9fs_get_sb(struct file_system_type *fs_type, int flags,
                        struct vfsmount *mnt)
 {
         struct super_block *sb = NULL;
-        struct v9fs_fcall *fcall = NULL;
         struct inode *inode = NULL;
         struct dentry *root = NULL;
         struct v9fs_session_info *v9ses = NULL;
-        struct v9fs_fid *root_fid = NULL;
+        struct p9_stat *st = NULL;
         int mode = S_IRWXUGO | S_ISVTX;
         uid_t uid = current->fsuid;
         gid_t gid = current->fsgid;
-        int stat_result = 0;
-        int newfid = 0;
+        struct p9_fid *fid;
         int retval = 0;
 
-        dprintk(DEBUG_VFS, " \n");
+        P9_DPRINTK(P9_DEBUG_VFS, " \n");
 
         v9ses = kzalloc(sizeof(struct v9fs_session_info), GFP_KERNEL);
         if (!v9ses)
                 return -ENOMEM;
 
-        if ((newfid = v9fs_session_init(v9ses, dev_name, data)) < 0) {
-                dprintk(DEBUG_ERROR, "problem initiating session\n");
-                retval = newfid;
-                goto out_free_session;
+        fid = v9fs_session_init(v9ses, dev_name, data);
+        if (IS_ERR(fid)) {
+                retval = PTR_ERR(fid);
+                fid = NULL;
+                kfree(v9ses);
+                v9ses = NULL;
+                goto error;
+        }
+
+        st = p9_client_stat(fid);
+        if (IS_ERR(st)) {
+                retval = PTR_ERR(st);
+                goto error;
         }
 
         sb = sget(fs_type, NULL, v9fs_set_super, v9ses);
         if (IS_ERR(sb)) {
                 retval = PTR_ERR(sb);
-                goto out_close_session;
+                goto error;
         }
         v9fs_fill_super(sb, v9ses, flags);
 
         inode = v9fs_get_inode(sb, S_IFDIR | mode);
         if (IS_ERR(inode)) {
                 retval = PTR_ERR(inode);
-                goto put_back_sb;
+                goto error;
         }
 
         inode->i_uid = uid;
@@ -150,54 +157,30 @@ static int v9fs_get_sb(struct file_system_type *fs_type, int flags,
         root = d_alloc_root(inode);
         if (!root) {
                 retval = -ENOMEM;
-                goto put_back_sb;
+                goto error;
         }
 
         sb->s_root = root;
+        root->d_inode->i_ino = v9fs_qid2ino(&st->qid);
+        v9fs_stat2inode(st, root->d_inode, sb);
+        v9fs_fid_add(root, fid);
 
-        stat_result = v9fs_t_stat(v9ses, newfid, &fcall);
-        if (stat_result < 0) {
-                dprintk(DEBUG_ERROR, "stat error\n");
-                v9fs_t_clunk(v9ses, newfid);
-        } else {
-                /* Setup the Root Inode */
-                root_fid = v9fs_fid_create(v9ses, newfid);
-                if (root_fid == NULL) {
-                        retval = -ENOMEM;
-                        goto put_back_sb;
-                }
-
-                retval = v9fs_fid_insert(root_fid, root);
-                if (retval < 0) {
-                        kfree(fcall);
-                        goto put_back_sb;
-                }
-
-                root_fid->qid = fcall->params.rstat.stat.qid;
-                root->d_inode->i_ino =
-                    v9fs_qid2ino(&fcall->params.rstat.stat.qid);
-                v9fs_stat2inode(&fcall->params.rstat.stat, root->d_inode, sb);
-        }
+        return simple_set_mnt(mnt, sb);
 
-        kfree(fcall);
+error:
+        if (fid)
+                p9_client_clunk(fid);
 
-        if (stat_result < 0) {
-                retval = stat_result;
-                goto put_back_sb;
+        if (v9ses) {
+                v9fs_session_close(v9ses);
+                kfree(v9ses);
         }
 
-        return simple_set_mnt(mnt, sb);
-
-out_close_session:
-        v9fs_session_close(v9ses);
-out_free_session:
-        kfree(v9ses);
-        return retval;
+        if (sb) {
+                up_write(&sb->s_umount);
+                deactivate_super(sb);
+        }
 
-put_back_sb:
-        /* deactivate_super calls v9fs_kill_super which will frees the rest */
-        up_write(&sb->s_umount);
-        deactivate_super(sb);
         return retval;
 }
 
@@ -211,7 +194,7 @@ static void v9fs_kill_super(struct super_block *s)
 {
         struct v9fs_session_info *v9ses = s->s_fs_info;
 
-        dprintk(DEBUG_VFS, " %p\n", s);
+        P9_DPRINTK(P9_DEBUG_VFS, " %p\n", s);
 
         v9fs_dentry_release(s->s_root); /* clunk root */
 
@@ -219,7 +202,7 @@ static void v9fs_kill_super(struct super_block *s)
 
         v9fs_session_close(v9ses);
         kfree(v9ses);
-        dprintk(DEBUG_VFS, "exiting kill_super\n");
+        P9_DPRINTK(P9_DEBUG_VFS, "exiting kill_super\n");
 }
 
 /**
@@ -234,7 +217,7 @@ static int v9fs_show_options(struct seq_file *m, struct vfsmount *mnt)
         struct v9fs_session_info *v9ses = mnt->mnt_sb->s_fs_info;
 
         if (v9ses->debug != 0)
-                seq_printf(m, ",debug=%u", v9ses->debug);
+                seq_printf(m, ",debug=%x", v9ses->debug);
         if (v9ses->port != V9FS_PORT)
                 seq_printf(m, ",port=%u", v9ses->port);
         if (v9ses->maxdata != 9000)
diff --git a/fs/Kconfig b/fs/Kconfig
index 0fa0c1193e8..ee11f8d9408 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -991,7 +991,7 @@ config TMPFS_POSIX_ACL
 
 config HUGETLBFS
         bool "HugeTLB file system support"
-        depends on X86 || IA64 || PPC64 || SPARC64 || SUPERH || BROKEN
+        depends on X86 || IA64 || PPC64 || SPARC64 || (SUPERH && MMU) || BROKEN
         help
           hugetlbfs is a filesystem backing for HugeTLB pages, based on
           ramfs. For architectures that support it, say Y here and read
@@ -2048,7 +2048,7 @@ config AFS_DEBUG
 
 config 9P_FS
         tristate "Plan 9 Resource Sharing Support (9P2000) (Experimental)"
-        depends on INET && EXPERIMENTAL
+        depends on INET && NET_9P && EXPERIMENTAL
         help
           If you say Y here, you will get experimental support for
           Plan 9 resource sharing via the 9P2000 protocol.
diff --git a/fs/afs/Makefile b/fs/afs/Makefile
index 73ce561f3ea..a66671082cf 100644
--- a/fs/afs/Makefile
+++ b/fs/afs/Makefile
@@ -8,6 +8,7 @@ kafs-objs := \
         cmservice.o \
         dir.o \
         file.o \
+        flock.o \
         fsclient.o \
         inode.o \
         main.o \
diff --git a/fs/afs/afs.h b/fs/afs/afs.h
index 24525794814..c548aa346f0 100644
--- a/fs/afs/afs.h
+++ b/fs/afs/afs.h
@@ -37,6 +37,13 @@ typedef enum {
         AFS_FTYPE_SYMLINK       = 3,
 } afs_file_type_t;
 
+typedef enum {
+        AFS_LOCK_READ           = 0,    /* read lock request */
+        AFS_LOCK_WRITE          = 1,    /* write lock request */
+} afs_lock_type_t;
+
+#define AFS_LOCKWAIT            (5 * 60) /* time until a lock times out (seconds) */
+
 /*
  * AFS file identifier
  */
@@ -120,6 +127,7 @@ struct afs_file_status {
         struct afs_fid          parent;         /* parent dir ID for non-dirs only */
         time_t                  mtime_client;   /* last time client changed data */
         time_t                  mtime_server;   /* last time server changed data */
+        s32                     lock_count;     /* file lock count (0=UNLK -1=WRLCK +ve=#RDLCK */
 };
 
 /*
diff --git a/fs/afs/afs_fs.h b/fs/afs/afs_fs.h
index a18c374ebe0..eb647323d8f 100644
--- a/fs/afs/afs_fs.h
+++ b/fs/afs/afs_fs.h
@@ -31,6 +31,9 @@ enum AFS_FS_Operations {
         FSGETVOLUMEINFO         = 148,  /* AFS Get information about a volume */
         FSGETVOLUMESTATUS       = 149,  /* AFS Get volume status information */
         FSGETROOTVOLUME         = 151,  /* AFS Get root volume name */
+        FSSETLOCK               = 156,  /* AFS Request a file lock */
+        FSEXTENDLOCK            = 157,  /* AFS Extend a file lock */
+        FSRELEASELOCK           = 158,  /* AFS Release a file lock */
         FSLOOKUP                = 161,  /* AFS lookup file in directory */
         FSFETCHDATA64           = 65537, /* AFS Fetch file data */
         FSSTOREDATA64           = 65538, /* AFS Store file data */
diff --git a/fs/afs/callback.c b/fs/afs/callback.c
index bacf518c6fa..b8243945818 100644
--- a/fs/afs/callback.c
+++ b/fs/afs/callback.c
@@ -125,6 +125,9 @@ static void afs_break_callback(struct afs_server *server,
                 spin_unlock(&server->cb_lock);
 
                 queue_work(afs_callback_update_worker, &vnode->cb_broken_work);
+                if (list_empty(&vnode->granted_locks) &&
+                    !list_empty(&vnode->pending_locks))
+                        afs_lock_may_be_available(vnode);
                 spin_unlock(&vnode->lock);
         }
 }
diff --git a/fs/afs/dir.c b/fs/afs/dir.c
index 546c59522eb..33fe39ad4e0 100644
--- a/fs/afs/dir.c
+++ b/fs/afs/dir.c
@@ -44,6 +44,7 @@ const struct file_operations afs_dir_file_operations = {
         .open           = afs_dir_open,
         .release        = afs_release,
         .readdir        = afs_readdir,
+        .lock           = afs_lock,
 };
 
 const struct inode_operations afs_dir_inode_operations = {
diff --git a/fs/afs/file.c b/fs/afs/file.c
index aede7eb66dd..525f7c56e06 100644
--- a/fs/afs/file.c
+++ b/fs/afs/file.c
@@ -34,6 +34,8 @@ const struct file_operations afs_file_operations = {
         .mmap           = generic_file_readonly_mmap,
         .splice_read    = generic_file_splice_read,
         .fsync          = afs_fsync,
+        .lock           = afs_lock,
+        .flock          = afs_flock,
 };
 
 const struct inode_operations afs_file_inode_operations = {
diff --git a/fs/afs/flock.c b/fs/afs/flock.c
new file mode 100644
index 00000000000..8f07f8d1bfa
--- /dev/null
+++ b/fs/afs/flock.c
@@ -0,0 +1,558 @@
+/* AFS file locking support
+ *
+ * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
+ * Written by David Howells (dhowells@redhat.com)
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version
+ * 2 of the License, or (at your option) any later version.
+ */
+
+#include <linux/smp_lock.h>
+#include "internal.h"
+
+#define AFS_LOCK_GRANTED        0
+#define AFS_LOCK_PENDING        1
+
+static void afs_fl_copy_lock(struct file_lock *new, struct file_lock *fl);
+static void afs_fl_release_private(struct file_lock *fl);
+
+static struct workqueue_struct *afs_lock_manager;
+
+static struct file_lock_operations afs_lock_ops = {
+        .fl_copy_lock           = afs_fl_copy_lock,
+        .fl_release_private     = afs_fl_release_private,
+};
+
+/*
+ * initialise the lock manager thread if it isn't already running
+ */
+static int afs_init_lock_manager(void)
+{
+        if (!afs_lock_manager) {
+                afs_lock_manager = create_singlethread_workqueue("kafs_lockd");
+                if (!afs_lock_manager)
+                        return -ENOMEM;
+        }
+        return 0;
+}
+
+/*
+ * destroy the lock manager thread if it's running
+ */
+void __exit afs_kill_lock_manager(void)
+{
+        if (afs_lock_manager)
+                destroy_workqueue(afs_lock_manager);
+}
+
+/*
+ * if the callback is broken on this vnode, then the lock may now be available
+ */
+void afs_lock_may_be_available(struct afs_vnode *vnode)
+{
+        _enter("{%x:%u}", vnode->fid.vid, vnode->fid.vnode);
+
+        queue_delayed_work(afs_lock_manager, &vnode->lock_work, 0);
+}
+
+/*
+ * the lock will time out in 5 minutes unless we extend it, so schedule
+ * extension in a bit less than that time
+ */
+static void afs_schedule_lock_extension(struct afs_vnode *vnode)
+{
+        queue_delayed_work(afs_lock_manager, &vnode->lock_work,
+                           AFS_LOCKWAIT * HZ / 2);
+}
+
+/*
+ * do work for a lock, including:
+ * - probing for a lock we're waiting on but didn't get immediately
+ * - extending a lock that's close to timing out
+ */
+void afs_lock_work(struct work_struct *work)
+{
+        struct afs_vnode *vnode =
+                container_of(work, struct afs_vnode, lock_work.work);
+        struct file_lock *fl;
+        afs_lock_type_t type;
+        struct key *key;
+        int ret;
+
+        _enter("{%x:%u}", vnode->fid.vid, vnode->fid.vnode);
+
+        spin_lock(&vnode->lock);
+
+        if (test_bit(AFS_VNODE_UNLOCKING, &vnode->flags)) {
+                _debug("unlock");
+                spin_unlock(&vnode->lock);
+
+                /* attempt to release the server lock; if it fails, we just
+                 * wait 5 minutes and it'll time out anyway */
+                ret = afs_vnode_release_lock(vnode, vnode->unlock_key);
+                if (ret < 0)
+                        printk(KERN_WARNING "AFS:"
+                               " Failed to release lock on {%x:%x} error %d\n",
+                               vnode->fid.vid, vnode->fid.vnode, ret);
+
+                spin_lock(&vnode->lock);
+                key_put(vnode->unlock_key);
+                vnode->unlock_key = NULL;
+                clear_bit(AFS_VNODE_UNLOCKING, &vnode->flags);
+        }
+
+        /* if we've got a lock, then it must be time to extend that lock as AFS
+         * locks time out after 5 minutes */
+        if (!list_empty(&vnode->granted_locks)) {
+                _debug("extend");
+
+                if (test_and_set_bit(AFS_VNODE_LOCKING, &vnode->flags))
+                        BUG();
+                fl = list_entry(vnode->granted_locks.next,
+                                struct file_lock, fl_u.afs.link);
+                key = key_get(fl->fl_file->private_data);
+                spin_unlock(&vnode->lock);
+
+                ret = afs_vnode_extend_lock(vnode, key);
+                clear_bit(AFS_VNODE_LOCKING, &vnode->flags);
+                key_put(key);
+                switch (ret) {
+                case 0:
+                        afs_schedule_lock_extension(vnode);
+                        break;
+                default:
+                        /* ummm... we failed to extend the lock - retry
+                         * extension shortly */
+                        printk(KERN_WARNING "AFS:"
+                               " Failed to extend lock on {%x:%x} error %d\n",
+                               vnode->fid.vid, vnode->fid.vnode, ret);
+                        queue_delayed_work(afs_lock_manager, &vnode->lock_work,
+                                           HZ * 10);
+                        break;
+                }
+                _leave(" [extend]");
+                return;
+        }
+
+        /* if we don't have a granted lock, then we must've been called back by
+         * the server, and so if might be possible to get a lock we're
+         * currently waiting for */
+        if (!list_empty(&vnode->pending_locks)) {
+                _debug("get");
+
+                if (test_and_set_bit(AFS_VNODE_LOCKING, &vnode->flags))
+                        BUG();
+                fl = list_entry(vnode->pending_locks.next,
+                                struct file_lock, fl_u.afs.link);
+                key = key_get(fl->fl_file->private_data);
+                type = (fl->fl_type == F_RDLCK) ?
+                        AFS_LOCK_READ : AFS_LOCK_WRITE;
+                spin_unlock(&vnode->lock);
+
+                ret = afs_vnode_set_lock(vnode, key, type);
+                clear_bit(AFS_VNODE_LOCKING, &vnode->flags);
+                switch (ret) {
+                case -EWOULDBLOCK:
+                        _debug("blocked");
+                        break;
+                case 0:
+                        _debug("acquired");
+                        if (type == AFS_LOCK_READ)
+                                set_bit(AFS_VNODE_READLOCKED, &vnode->flags);
+                        else
+                                set_bit(AFS_VNODE_WRITELOCKED, &vnode->flags);
+                        ret = AFS_LOCK_GRANTED;
+                default:
+                        spin_lock(&vnode->lock);
+                        /* the pending lock may have been withdrawn due to a
+                         * signal */
+                        if (list_entry(vnode->pending_locks.next,
+                                       struct file_lock, fl_u.afs.link) == fl) {
+                                fl->fl_u.afs.state = ret;
+                                if (ret == AFS_LOCK_GRANTED)
+                                        list_move_tail(&fl->fl_u.afs.link,
+                                                       &vnode->granted_locks);
+                                else
+                                        list_del_init(&fl->fl_u.afs.link);
+                                wake_up(&fl->fl_wait);
+                                spin_unlock(&vnode->lock);
+                        } else {
+                                _debug("withdrawn");
+                                clear_bit(AFS_VNODE_READLOCKED, &vnode->flags);
+                                clear_bit(AFS_VNODE_WRITELOCKED, &vnode->flags);
+                                spin_unlock(&vnode->lock);
+                                afs_vnode_release_lock(vnode, key);
+                                if (!list_empty(&vnode->pending_locks))
+                                        afs_lock_may_be_available(vnode);
+                        }
+                        break;
+                }
+                key_put(key);
+                _leave(" [pend]");
+                return;
+        }
+
+        /* looks like the lock request was withdrawn on a signal */
+        spin_unlock(&vnode->lock);
+        _leave(" [no locks]");
+}
+
+/*
+ * pass responsibility for the unlocking of a vnode on the server to the
+ * manager thread, lest a pending signal in the calling thread interrupt
+ * AF_RXRPC
+ * - the caller must hold the vnode lock
+ */
+static void afs_defer_unlock(struct afs_vnode *vnode, struct key *key)
+{
+        cancel_delayed_work(&vnode->lock_work);
+        if (!test_and_clear_bit(AFS_VNODE_READLOCKED, &vnode->flags) &&
+            !test_and_clear_bit(AFS_VNODE_WRITELOCKED, &vnode->flags))
+                BUG();
+        if (test_and_set_bit(AFS_VNODE_UNLOCKING, &vnode->flags))
+                BUG();
+        vnode->unlock_key = key_get(key);
+        afs_lock_may_be_available(vnode);
+}
+
+/*
+ * request a lock on a file on the server
+ */
+static int afs_do_setlk(struct file *file, struct file_lock *fl)
+{
+        struct afs_vnode *vnode = AFS_FS_I(file->f_mapping->host);
+        afs_lock_type_t type;
+        struct key *key = file->private_data;
+        int ret;
+
+        _enter("{%x:%u},%u", vnode->fid.vid, vnode->fid.vnode, fl->fl_type);
+
+        /* only whole-file locks are supported */
+        if (fl->fl_start != 0 || fl->fl_end != OFFSET_MAX)
+                return -EINVAL;
+
+        ret = afs_init_lock_manager();
+        if (ret < 0)
+                return ret;
+
+        fl->fl_ops = &afs_lock_ops;
+        INIT_LIST_HEAD(&fl->fl_u.afs.link);
+        fl->fl_u.afs.state = AFS_LOCK_PENDING;
+
+        type = (fl->fl_type == F_RDLCK) ? AFS_LOCK_READ : AFS_LOCK_WRITE;
+
+        lock_kernel();
+
+        /* make sure we've got a callback on this file and that our view of the
+         * data version is up to date */
+        ret = afs_vnode_fetch_status(vnode, NULL, key);
+        if (ret < 0)
+                goto error;
+
+        if (vnode->status.lock_count != 0 && !(fl->fl_flags & FL_SLEEP)) {
+                ret = -EAGAIN;
+                goto error;
+        }
+
+        spin_lock(&vnode->lock);
+
+        if (list_empty(&vnode->pending_locks)) {
+                /* if there's no-one else with a lock on this vnode, then we
+                 * need to ask the server for a lock */
+                if (list_empty(&vnode->granted_locks)) {
+                        _debug("not locked");
+                        ASSERTCMP(vnode->flags &
+                                  ((1 << AFS_VNODE_LOCKING) |
+                                   (1 << AFS_VNODE_READLOCKED) |
+                                   (1 << AFS_VNODE_WRITELOCKED)), ==, 0);
+                        list_add_tail(&fl->fl_u.afs.link, &vnode->pending_locks);
+                        set_bit(AFS_VNODE_LOCKING, &vnode->flags);
+                        spin_unlock(&vnode->lock);
+
+                        ret = afs_vnode_set_lock(vnode, key, type);
+                        clear_bit(AFS_VNODE_LOCKING, &vnode->flags);
+                        switch (ret) {
+                        case 0:
+                                goto acquired_server_lock;
+                        case -EWOULDBLOCK:
+                                spin_lock(&vnode->lock);
+                                ASSERT(list_empty(&vnode->granted_locks));
+                                ASSERTCMP(vnode->pending_locks.next, ==,
+                                          &fl->fl_u.afs.link);
+                                goto wait;
+                        default:
+                                spin_lock(&vnode->lock);
+                                list_del_init(&fl->fl_u.afs.link);
+                                spin_unlock(&vnode->lock);
+                                goto error;
+                        }
+                }
+
+                /* if we've already got a readlock on the server and no waiting
+                 * writelocks, then we might be able to instantly grant another
+                 * readlock */
+                if (type == AFS_LOCK_READ &&
+                    vnode->flags & (1 << AFS_VNODE_READLOCKED)) {
+                        _debug("instant readlock");
+                        ASSERTCMP(vnode->flags &
+                                  ((1 << AFS_VNODE_LOCKING) |
+                                   (1 << AFS_VNODE_WRITELOCKED)), ==, 0);
+                        ASSERT(!list_empty(&vnode->granted_locks));
+                        goto sharing_existing_lock;
+                }
+        }
+
+        /* otherwise, we need to wait for a local lock to become available */
+        _debug("wait local");
+        list_add_tail(&fl->fl_u.afs.link, &vnode->pending_locks);
+wait:
+        if (!(fl->fl_flags & FL_SLEEP)) {
+                _debug("noblock");
+                ret = -EAGAIN;
+                goto abort_attempt;
+        }
+        spin_unlock(&vnode->lock);
+
+        /* now we need to sleep and wait for the lock manager thread to get the
+         * lock from the server */
+        _debug("sleep");
+        ret = wait_event_interruptible(fl->fl_wait,
+                                       fl->fl_u.afs.state <= AFS_LOCK_GRANTED);
+        if (fl->fl_u.afs.state <= AFS_LOCK_GRANTED) {
+                ret = fl->fl_u.afs.state;
+                if (ret < 0)
+                        goto error;
+                spin_lock(&vnode->lock);
+                goto given_lock;
+        }
+
+        /* we were interrupted, but someone may still be in the throes of
+         * giving us the lock */
+        _debug("intr");
+        ASSERTCMP(ret, ==, -ERESTARTSYS);
+
+        spin_lock(&vnode->lock);
+        if (fl->fl_u.afs.state <= AFS_LOCK_GRANTED) {
+                ret = fl->fl_u.afs.state;
+                if (ret < 0) {
+                        spin_unlock(&vnode->lock);
+                        goto error;
+                }
+                goto given_lock;
+        }
+
+abort_attempt:
+        /* we aren't going to get the lock, either because we're unwilling to
+         * wait, or because some signal happened */
+        _debug("abort");
+        if (list_empty(&vnode->granted_locks) &&
+            vnode->pending_locks.next == &fl->fl_u.afs.link) {
+                if (vnode->pending_locks.prev != &fl->fl_u.afs.link) {
+                        /* kick the next pending lock into having a go */
+                        list_del_init(&fl->fl_u.afs.link);
+                        afs_lock_may_be_available(vnode);
+                }
+        } else {
+                list_del_init(&fl->fl_u.afs.link);
+        }
+        spin_unlock(&vnode->lock);
+        goto error;
+
+acquired_server_lock:
+        /* we've acquired a server lock, but it needs to be renewed after 5
+         * mins */
+        spin_lock(&vnode->lock);
+        afs_schedule_lock_extension(vnode);
+        if (type == AFS_LOCK_READ)
+                set_bit(AFS_VNODE_READLOCKED, &vnode->flags);
+        else
+                set_bit(AFS_VNODE_WRITELOCKED, &vnode->flags);
+sharing_existing_lock:
+        /* the lock has been granted as far as we're concerned... */
+        fl->fl_u.afs.state = AFS_LOCK_GRANTED;
+        list_move_tail(&fl->fl_u.afs.link, &vnode->granted_locks);
+given_lock:
+        /* ... but we do still need to get the VFS's blessing */
+        ASSERT(!(vnode->flags & (1 << AFS_VNODE_LOCKING)));
+        ASSERT((vnode->flags & ((1 << AFS_VNODE_READLOCKED) |
+                                (1 << AFS_VNODE_WRITELOCKED))) != 0);
+        ret = posix_lock_file(file, fl, NULL);
+        if (ret < 0)
+                goto vfs_rejected_lock;
+        spin_unlock(&vnode->lock);
+
+        /* again, make sure we've got a callback on this file and, again, make
+         * sure that our view of the data version is up to date (we ignore
+         * errors incurred here and deal with the consequences elsewhere) */
+        afs_vnode_fetch_status(vnode, NULL, key);
+
+error:
+        unlock_kernel();
+        _leave(" = %d", ret);
+        return ret;
+
+vfs_rejected_lock:
+        /* the VFS rejected the lock we just obtained, so we have to discard
+         * what we just got */
+        _debug("vfs refused %d", ret);
+        list_del_init(&fl->fl_u.afs.link);
+        if (list_empty(&vnode->granted_locks))
+                afs_defer_unlock(vnode, key);
+        spin_unlock(&vnode->lock);
+        goto abort_attempt;
+}
+
+/*
+ * unlock on a file on the server
+ */
+static int afs_do_unlk(struct file *file, struct file_lock *fl)
+{
+        struct afs_vnode *vnode = AFS_FS_I(file->f_mapping->host);
+        struct key *key = file->private_data;
+        int ret;
+
+        _enter("{%x:%u},%u", vnode->fid.vid, vnode->fid.vnode, fl->fl_type);
+
+        /* only whole-file unlocks are supported */
+        if (fl->fl_start != 0 || fl->fl_end != OFFSET_MAX)
+                return -EINVAL;
+
+        fl->fl_ops = &afs_lock_ops;
+        INIT_LIST_HEAD(&fl->fl_u.afs.link);
+        fl->fl_u.afs.state = AFS_LOCK_PENDING;
+
+        spin_lock(&vnode->lock);
+        ret = posix_lock_file(file, fl, NULL);
+        if (ret < 0) {
+                spin_unlock(&vnode->lock);
+                _leave(" = %d [vfs]", ret);
+                return ret;
+        }
+
+        /* discard the server lock only if all granted locks are gone */
+        if (list_empty(&vnode->granted_locks))
+                afs_defer_unlock(vnode, key);
+        spin_unlock(&vnode->lock);
+        _leave(" = 0");
+        return 0;
+}
+
+/*
+ * return information about a lock we currently hold, if indeed we hold one
+ */
+static int afs_do_getlk(struct file *file, struct file_lock *fl)
+{
+        struct afs_vnode *vnode = AFS_FS_I(file->f_mapping->host);
+        struct key *key = file->private_data;
+        int ret, lock_count;
+
+        _enter("");
+
+        fl->fl_type = F_UNLCK;
+
+        mutex_lock(&vnode->vfs_inode.i_mutex);
+
+        /* check local lock records first */
+        ret = 0;
+        if (posix_test_lock(file, fl) == 0) {
+                /* no local locks; consult the server */
+                ret = afs_vnode_fetch_status(vnode, NULL, key);
+                if (ret < 0)
+                        goto error;
+                lock_count = vnode->status.lock_count;
+                if (lock_count) {
+                        if (lock_count > 0)
+                                fl->fl_type = F_RDLCK;
+                        else
+                                fl->fl_type = F_WRLCK;
+                        fl->fl_start = 0;
+                        fl->fl_end = OFFSET_MAX;
+                }
+        }
+
+error:
+        mutex_unlock(&vnode->vfs_inode.i_mutex);
+        _leave(" = %d [%hd]", ret, fl->fl_type);
+        return ret;
+}
+
+/*
+ * manage POSIX locks on a file
+ */
+int afs_lock(struct file *file, int cmd, struct file_lock *fl)
+{
+        struct afs_vnode *vnode = AFS_FS_I(file->f_dentry->d_inode);
+
+        _enter("{%x:%u},%d,{t=%x,fl=%x,r=%Ld:%Ld}",
+               vnode->fid.vid, vnode->fid.vnode, cmd,
+               fl->fl_type, fl->fl_flags,
+               (long long) fl->fl_start, (long long) fl->fl_end);
+
+        /* AFS doesn't support mandatory locks */
+        if ((vnode->vfs_inode.i_mode & (S_ISGID | S_IXGRP)) == S_ISGID &&
+            fl->fl_type != F_UNLCK)
+                return -ENOLCK;
+
+        if (IS_GETLK(cmd))
+                return afs_do_getlk(file, fl);
+        if (fl->fl_type == F_UNLCK)
+                return afs_do_unlk(file, fl);
+        return afs_do_setlk(file, fl);
+}
+
+/*
+ * manage FLOCK locks on a file
+ */
+int afs_flock(struct file *file, int cmd, struct file_lock *fl)
+{
+        struct afs_vnode *vnode = AFS_FS_I(file->f_dentry->d_inode);
+
+        _enter("{%x:%u},%d,{t=%x,fl=%x}",
+               vnode->fid.vid, vnode->fid.vnode, cmd,
+               fl->fl_type, fl->fl_flags);
+
+        /*
+         * No BSD flocks over NFS allowed.
+         * Note: we could try to fake a POSIX lock request here by
+         * using ((u32) filp | 0x80000000) or some such as the pid.
+         * Not sure whether that would be unique, though, or whether
+         * that would break in other places.
+         */
+        if (!(fl->fl_flags & FL_FLOCK))
+                return -ENOLCK;
+
+        /* we're simulating flock() locks using posix locks on the server */
+        fl->fl_owner = (fl_owner_t) file;
+        fl->fl_start = 0;
+        fl->fl_end = OFFSET_MAX;
+
+        if (fl->fl_type == F_UNLCK)
+                return afs_do_unlk(file, fl);
+        return afs_do_setlk(file, fl);
+}
+
+/*
+ * the POSIX lock management core VFS code copies the lock record and adds the
+ * copy into its own list, so we need to add that copy to the vnode's lock
+ * queue in the same place as the original (which will be deleted shortly
+ * after)
+ */
+static void afs_fl_copy_lock(struct file_lock *new, struct file_lock *fl)
+{
+        _enter("");
+
+        list_add(&new->fl_u.afs.link, &fl->fl_u.afs.link);
+}
+
+/*
+ * need to remove this lock from the vnode queue when it's removed from the
+ * VFS's list
+ */
+static void afs_fl_release_private(struct file_lock *fl)
+{
+        _enter("");
+
+        list_del_init(&fl->fl_u.afs.link);
+}
diff --git a/fs/afs/fsclient.c b/fs/afs/fsclient.c
index 5dff1308b6f..023b95b0d9d 100644
--- a/fs/afs/fsclient.c
+++ b/fs/afs/fsclient.c
@@ -67,7 +67,7 @@ static void xdr_decode_AFSFetchStatus(const __be32 **_bp,
         EXTRACT(status->group);
         bp++; /* sync counter */
         data_version |= (u64) ntohl(*bp++) << 32;
-        bp++; /* lock count */
+        EXTRACT(status->lock_count);
         size |= (u64) ntohl(*bp++) << 32;
         bp++; /* spare 4 */
         *_bp = bp;
@@ -1748,3 +1748,156 @@ int afs_fs_get_volume_status(struct afs_server *server,
 
         return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
 }
+
+/*
+ * deliver reply data to an FS.SetLock, FS.ExtendLock or FS.ReleaseLock
+ */
+static int afs_deliver_fs_xxxx_lock(struct afs_call *call,
+                                    struct sk_buff *skb, bool last)
+{
+        const __be32 *bp;
+
+        _enter("{%u},{%u},%d", call->unmarshall, skb->len, last);
+
+        afs_transfer_reply(call, skb);
+        if (!last)
+                return 0;
+
+        if (call->reply_size != call->reply_max)
+                return -EBADMSG;
+
+        /* unmarshall the reply once we've received all of it */
+        bp = call->buffer;
+        /* xdr_decode_AFSVolSync(&bp, call->replyX); */
+
+        _leave(" = 0 [done]");
+        return 0;
+}
+
+/*
+ * FS.SetLock operation type
+ */
+static const struct afs_call_type afs_RXFSSetLock = {
+        .name           = "FS.SetLock",
+        .deliver        = afs_deliver_fs_xxxx_lock,
+        .abort_to_error = afs_abort_to_error,
+        .destructor     = afs_flat_call_destructor,
+};
+
+/*
+ * FS.ExtendLock operation type
+ */
+static const struct afs_call_type afs_RXFSExtendLock = {
+        .name           = "FS.ExtendLock",
+        .deliver        = afs_deliver_fs_xxxx_lock,
+        .abort_to_error = afs_abort_to_error,
+        .destructor     = afs_flat_call_destructor,
+};
+
+/*
+ * FS.ReleaseLock operation type
+ */
+static const struct afs_call_type afs_RXFSReleaseLock = {
+        .name           = "FS.ReleaseLock",
+        .deliver        = afs_deliver_fs_xxxx_lock,
+        .abort_to_error = afs_abort_to_error,
+        .destructor     = afs_flat_call_destructor,
+};
+
+/*
+ * get a lock on a file
+ */
+int afs_fs_set_lock(struct afs_server *server,
+                    struct key *key,
+                    struct afs_vnode *vnode,
+                    afs_lock_type_t type,
+                    const struct afs_wait_mode *wait_mode)
+{
+        struct afs_call *call;
+        __be32 *bp;
+
+        _enter("");
+
+        call = afs_alloc_flat_call(&afs_RXFSSetLock, 5 * 4, 6 * 4);
+        if (!call)
+                return -ENOMEM;
+
+        call->key = key;
+        call->reply = vnode;
+        call->service_id = FS_SERVICE;
+        call->port = htons(AFS_FS_PORT);
+
+        /* marshall the parameters */
+        bp = call->request;
+        *bp++ = htonl(FSSETLOCK);
+        *bp++ = htonl(vnode->fid.vid);
+        *bp++ = htonl(vnode->fid.vnode);
+        *bp++ = htonl(vnode->fid.unique);
+        *bp++ = htonl(type);
+
+        return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
+}
+
+/*
+ * extend a lock on a file
+ */
+int afs_fs_extend_lock(struct afs_server *server,
+                       struct key *key,
+                       struct afs_vnode *vnode,
+                       const struct afs_wait_mode *wait_mode)
+{
+        struct afs_call *call;
+        __be32 *bp;
+
+        _enter("");
+
+        call = afs_alloc_flat_call(&afs_RXFSExtendLock, 4 * 4, 6 * 4);
+        if (!call)
+                return -ENOMEM;
+
+        call->key = key;
+        call->reply = vnode;
+        call->service_id = FS_SERVICE;
+        call->port = htons(AFS_FS_PORT);
+
+        /* marshall the parameters */
+        bp = call->request;
+        *bp++ = htonl(FSEXTENDLOCK);
+        *bp++ = htonl(vnode->fid.vid);
+        *bp++ = htonl(vnode->fid.vnode);
+        *bp++ = htonl(vnode->fid.unique);
+
+        return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
+}
+
+/*
+ * release a lock on a file
+ */
+int afs_fs_release_lock(struct afs_server *server,
+                        struct key *key,
+                        struct afs_vnode *vnode,
+                        const struct afs_wait_mode *wait_mode)
+{
+        struct afs_call *call;
+        __be32 *bp;
+
+        _enter("");
+
+        call = afs_alloc_flat_call(&afs_RXFSReleaseLock, 4 * 4, 6 * 4);
+        if (!call)
+                return -ENOMEM;
+
+        call->key = key;
+        call->reply = vnode;
+        call->service_id = FS_SERVICE;
+        call->port = htons(AFS_FS_PORT);
+
+        /* marshall the parameters */
+        bp = call->request;
+        *bp++ = htonl(FSRELEASELOCK);
+        *bp++ = htonl(vnode->fid.vid);
+        *bp++ = htonl(vnode->fid.vnode);
+        *bp++ = htonl(vnode->fid.unique);
+
+        return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
+}
diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index 2c55dd94a1d..6306438f331 100644
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -351,10 +351,18 @@ struct afs_vnode {
 #define AFS_VNODE_ZAP_DATA      3               /* set if vnode's data should be invalidated */
 #define AFS_VNODE_DELETED       4               /* set if vnode deleted on server */
 #define AFS_VNODE_MOUNTPOINT    5               /* set if vnode is a mountpoint symlink */
+#define AFS_VNODE_LOCKING       6               /* set if waiting for lock on vnode */
+#define AFS_VNODE_READLOCKED    7               /* set if vnode is read-locked on the server */
+#define AFS_VNODE_WRITELOCKED   8               /* set if vnode is write-locked on the server */
+#define AFS_VNODE_UNLOCKING     9               /* set if vnode is being unlocked on the server */
 
         long                    acl_order;      /* ACL check count (callback break count) */
 
         struct list_head        writebacks;     /* alterations in pagecache that need writing */
+        struct list_head        pending_locks;  /* locks waiting to be granted */
+        struct list_head        granted_locks;  /* locks granted on this file */
+        struct delayed_work     lock_work;      /* work to be done in locking */
+        struct key              *unlock_key;    /* key to be used in unlocking */
 
         /* outstanding callback notification on this file */
         struct rb_node          server_rb;      /* link in server->fs_vnodes */
@@ -474,6 +482,15 @@ extern int afs_open(struct inode *, struct file *);
 extern int afs_release(struct inode *, struct file *);
 
 /*
+ * flock.c
+ */
+extern void __exit afs_kill_lock_manager(void);
+extern void afs_lock_work(struct work_struct *);
+extern void afs_lock_may_be_available(struct afs_vnode *);
+extern int afs_lock(struct file *, int, struct file_lock *);
+extern int afs_flock(struct file *, int, struct file_lock *);
+
+/*
  * fsclient.c
  */
 extern int afs_fs_fetch_file_status(struct afs_server *, struct key *,
@@ -513,6 +530,15 @@ extern int afs_fs_get_volume_status(struct afs_server *, struct key *,
                                     struct afs_vnode *,
                                     struct afs_volume_status *,
                                     const struct afs_wait_mode *);
+extern int afs_fs_set_lock(struct afs_server *, struct key *,
+                           struct afs_vnode *, afs_lock_type_t,
+                           const struct afs_wait_mode *);
+extern int afs_fs_extend_lock(struct afs_server *, struct key *,
+                              struct afs_vnode *,
+                              const struct afs_wait_mode *);
+extern int afs_fs_release_lock(struct afs_server *, struct key *,
+                               struct afs_vnode *,
+                               const struct afs_wait_mode *);
 
 /*
  * inode.c
@@ -681,6 +707,10 @@ extern int afs_vnode_store_data(struct afs_writeback *, pgoff_t, pgoff_t,
 extern int afs_vnode_setattr(struct afs_vnode *, struct key *, struct iattr *);
 extern int afs_vnode_get_volume_status(struct afs_vnode *, struct key *,
                                        struct afs_volume_status *);
+extern int afs_vnode_set_lock(struct afs_vnode *, struct key *,
+                              afs_lock_type_t);
+extern int afs_vnode_extend_lock(struct afs_vnode *, struct key *);
+extern int afs_vnode_release_lock(struct afs_vnode *, struct key *);
 
 /*
  * volume.c
diff --git a/fs/afs/main.c b/fs/afs/main.c
index cd21195bbb2..0f60f6b3576 100644
--- a/fs/afs/main.c
+++ b/fs/afs/main.c
@@ -168,6 +168,7 @@ static void __exit afs_exit(void)
         printk(KERN_INFO "kAFS: Red Hat AFS client v0.1 unregistering.\n");
 
         afs_fs_exit();
+        afs_kill_lock_manager();
         afs_close_socket();
         afs_purge_servers();
         afs_callback_update_kill();
diff --git a/fs/afs/misc.c b/fs/afs/misc.c
index d1a889c4074..2d33a5f7d21 100644
--- a/fs/afs/misc.c
+++ b/fs/afs/misc.c
@@ -35,6 +35,7 @@ int afs_abort_to_error(u32 abort_code)
         case VOVERQUOTA:        return -EDQUOT;
         case VBUSY:             return -EBUSY;
         case VMOVED:            return -ENXIO;
+        case 0x2f6df0a:         return -EWOULDBLOCK;
         case 0x2f6df0c:         return -EACCES;
         case 0x2f6df0f:         return -EBUSY;
         case 0x2f6df10:         return -EEXIST;
diff --git a/fs/afs/proc.c b/fs/afs/proc.c
index 13df512aea9..6edb56683b9 100644
--- a/fs/afs/proc.c
+++ b/fs/afs/proc.c
@@ -201,23 +201,9 @@ static int afs_proc_cells_open(struct inode *inode, struct file *file)
  */
 static void *afs_proc_cells_start(struct seq_file *m, loff_t *_pos)
 {
-        struct list_head *_p;
-        loff_t pos = *_pos;
-
         /* lock the list against modification */
         down_read(&afs_proc_cells_sem);
-
-        /* allow for the header line */
-        if (!pos)
-                return (void *) 1;
-        pos--;
-
-        /* find the n'th element in the list */
-        list_for_each(_p, &afs_proc_cells)
-                if (!pos--)
-                        break;
-
-        return _p != &afs_proc_cells ? _p : NULL;
+        return seq_list_start_head(&afs_proc_cells, *_pos);
 }
 
 /*
@@ -225,14 +211,7 @@ static void *afs_proc_cells_start(struct seq_file *m, loff_t *_pos)
  */
 static void *afs_proc_cells_next(struct seq_file *p, void *v, loff_t *pos)
 {
-        struct list_head *_p;
-
-        (*pos)++;
-
-        _p = v;
-        _p = v == (void *) 1 ? afs_proc_cells.next : _p->next;
-
-        return _p != &afs_proc_cells ? _p : NULL;
+        return seq_list_next(v, &afs_proc_cells, pos);
 }
 
 /*
@@ -250,7 +229,7 @@ static int afs_proc_cells_show(struct seq_file *m, void *v)
 {
         struct afs_cell *cell = list_entry(v, struct afs_cell, proc_link);
 
-        if (v == (void *) 1) {
+        if (v == &afs_proc_cells) {
                 /* display header on line 1 */
                 seq_puts(m, "USE NAME\n");
                 return 0;
@@ -503,26 +482,13 @@ static int afs_proc_cell_volumes_release(struct inode *inode, struct file *file)
  */
 static void *afs_proc_cell_volumes_start(struct seq_file *m, loff_t *_pos)
 {
-        struct list_head *_p;
         struct afs_cell *cell = m->private;
-        loff_t pos = *_pos;
 
         _enter("cell=%p pos=%Ld", cell, *_pos);
 
         /* lock the list against modification */
         down_read(&cell->vl_sem);
-
-        /* allow for the header line */
-        if (!pos)
-                return (void *) 1;
-        pos--;
-
-        /* find the n'th element in the list */
-        list_for_each(_p, &cell->vl_list)
-                if (!pos--)
-                        break;
-
-        return _p != &cell->vl_list ? _p : NULL;
+        return seq_list_start_head(&cell->vl_list, *_pos);
 }
 
 /*
@@ -531,17 +497,10 @@ static void *afs_proc_cell_volumes_start(struct seq_file *m, loff_t *_pos)
 static void *afs_proc_cell_volumes_next(struct seq_file *p, void *v,
                                         loff_t *_pos)
 {
-        struct list_head *_p;
         struct afs_cell *cell = p->private;
 
         _enter("cell=%p pos=%Ld", cell, *_pos);
-
-        (*_pos)++;
-
-        _p = v;
-        _p = (v == (void *) 1) ? cell->vl_list.next : _p->next;
-
-        return (_p != &cell->vl_list) ? _p : NULL;
+        return seq_list_next(v, &cell->vl_list, _pos);
 }
 
 /*
@@ -569,11 +528,12 @@ const char afs_vlocation_states[][4] = {
  */
 static int afs_proc_cell_volumes_show(struct seq_file *m, void *v)
 {
+        struct afs_cell *cell = m->private;
         struct afs_vlocation *vlocation =
                 list_entry(v, struct afs_vlocation, link);
 
         /* display header on line 1 */
-        if (v == (void *) 1) {
+        if (v == &cell->vl_list) {
                 seq_puts(m, "USE STT VLID[0]  VLID[1]  VLID[2]  NAME\n");
                 return 0;
         }
@@ -734,26 +694,13 @@ static int afs_proc_cell_servers_release(struct inode *inode,
 static void *afs_proc_cell_servers_start(struct seq_file *m, loff_t *_pos)
         __acquires(m->private->servers_lock)
 {
-        struct list_head *_p;
         struct afs_cell *cell = m->private;
-        loff_t pos = *_pos;
 
         _enter("cell=%p pos=%Ld", cell, *_pos);
 
         /* lock the list against modification */
         read_lock(&cell->servers_lock);
-
-        /* allow for the header line */
-        if (!pos)
-                return (void *) 1;
-        pos--;
-
-        /* find the n'th element in the list */
-        list_for_each(_p, &cell->servers)
-                if (!pos--)
-                        break;
-
-        return _p != &cell->servers ? _p : NULL;
+        return seq_list_start_head(&cell->servers, *_pos);
 }
 
 /*
@@ -762,17 +709,10 @@ static void *afs_proc_cell_servers_start(struct seq_file *m, loff_t *_pos)
 static void *afs_proc_cell_servers_next(struct seq_file *p, void *v,
                                         loff_t *_pos)
 {
-        struct list_head *_p;
         struct afs_cell *cell = p->private;
 
         _enter("cell=%p pos=%Ld", cell, *_pos);
-
-        (*_pos)++;
-
-        _p = v;
-        _p = v == (void *) 1 ? cell->servers.next : _p->next;
-
-        return _p != &cell->servers ? _p : NULL;
+        return seq_list_next(v, &cell->servers, _pos);
 }
 
 /*
@@ -791,11 +731,12 @@ static void afs_proc_cell_servers_stop(struct seq_file *p, void *v)
  */
 static int afs_proc_cell_servers_show(struct seq_file *m, void *v)
 {
+        struct afs_cell *cell = m->private;
         struct afs_server *server = list_entry(v, struct afs_server, link);
         char ipaddr[20];
 
         /* display header on line 1 */
-        if (v == (void *) 1) {
+        if (v == &cell->servers) {
                 seq_puts(m, "USE ADDR            STATE\n");
                 return 0;
         }
diff --git a/fs/afs/super.c b/fs/afs/super.c
index 2e8496ba120..993cdf1cce3 100644
--- a/fs/afs/super.c
+++ b/fs/afs/super.c
@@ -460,6 +460,9 @@ static void afs_i_init_once(void *_vnode, struct kmem_cache *cachep,
         spin_lock_init(&vnode->writeback_lock);
         spin_lock_init(&vnode->lock);
         INIT_LIST_HEAD(&vnode->writebacks);
+        INIT_LIST_HEAD(&vnode->pending_locks);
+        INIT_LIST_HEAD(&vnode->granted_locks);
+        INIT_DELAYED_WORK(&vnode->lock_work, afs_lock_work);
         INIT_WORK(&vnode->cb_broken_work, afs_broken_callback_work);
 }
 
diff --git a/fs/afs/vnode.c b/fs/afs/vnode.c
index 232c55dc245..2f05c4fc2a7 100644
--- a/fs/afs/vnode.c
+++ b/fs/afs/vnode.c
@@ -561,7 +561,7 @@ no_server:
 /*
  * create a hard link
  */
-extern int afs_vnode_link(struct afs_vnode *dvnode, struct afs_vnode *vnode,
+int afs_vnode_link(struct afs_vnode *dvnode, struct afs_vnode *vnode,
                           struct key *key, const char *name)
 {
         struct afs_server *server;
@@ -887,11 +887,6 @@ int afs_vnode_get_volume_status(struct afs_vnode *vnode, struct key *key,
                vnode->fid.unique,
                key_serial(key));
 
-        /* this op will fetch the status */
-        spin_lock(&vnode->lock);
-        vnode->update_cnt++;
-        spin_unlock(&vnode->lock);
-
         do {
                 /* pick a server to query */
                 server = afs_volume_pick_fileserver(vnode);
@@ -905,20 +900,127 @@ int afs_vnode_get_volume_status(struct afs_vnode *vnode, struct key *key,
         } while (!afs_volume_release_fileserver(vnode, server, ret));
 
         /* adjust the flags */
-        if (ret == 0) {
-                afs_vnode_finalise_status_update(vnode, server);
+        if (ret == 0)
+                afs_put_server(server);
+
+        _leave(" = %d", ret);
+        return ret;
+
+no_server:
+        return PTR_ERR(server);
+}
+
+/*
+ * get a lock on a file
+ */
+int afs_vnode_set_lock(struct afs_vnode *vnode, struct key *key,
+                       afs_lock_type_t type)
+{
+        struct afs_server *server;
+        int ret;
+
+        _enter("%s{%x:%u.%u},%x,%u",
+               vnode->volume->vlocation->vldb.name,
+               vnode->fid.vid,
+               vnode->fid.vnode,
+               vnode->fid.unique,
+               key_serial(key), type);
+
+        do {
+                /* pick a server to query */
+                server = afs_volume_pick_fileserver(vnode);
+                if (IS_ERR(server))
+                        goto no_server;
+
+                _debug("USING SERVER: %08x\n", ntohl(server->addr.s_addr));
+
+                ret = afs_fs_set_lock(server, key, vnode, type, &afs_sync_call);
+
+        } while (!afs_volume_release_fileserver(vnode, server, ret));
+
+        /* adjust the flags */
+        if (ret == 0)
+                afs_put_server(server);
+
+        _leave(" = %d", ret);
+        return ret;
+
+no_server:
+        return PTR_ERR(server);
+}
+
+/*
+ * extend a lock on a file
+ */
+int afs_vnode_extend_lock(struct afs_vnode *vnode, struct key *key)
+{
+        struct afs_server *server;
+        int ret;
+
+        _enter("%s{%x:%u.%u},%x",
+               vnode->volume->vlocation->vldb.name,
+               vnode->fid.vid,
+               vnode->fid.vnode,
+               vnode->fid.unique,
+               key_serial(key));
+
+        do {
+                /* pick a server to query */
+                server = afs_volume_pick_fileserver(vnode);
+                if (IS_ERR(server))
+                        goto no_server;
+
+                _debug("USING SERVER: %08x\n", ntohl(server->addr.s_addr));
+
+                ret = afs_fs_extend_lock(server, key, vnode, &afs_sync_call);
+
+        } while (!afs_volume_release_fileserver(vnode, server, ret));
+
+        /* adjust the flags */
+        if (ret == 0)
+                afs_put_server(server);
+
+        _leave(" = %d", ret);
+        return ret;
+
+no_server:
+        return PTR_ERR(server);
+}
+
+/*
+ * release a lock on a file
+ */
+int afs_vnode_release_lock(struct afs_vnode *vnode, struct key *key)
+{
+        struct afs_server *server;
+        int ret;
+
+        _enter("%s{%x:%u.%u},%x",
+               vnode->volume->vlocation->vldb.name,
+               vnode->fid.vid,
+               vnode->fid.vnode,
+               vnode->fid.unique,
+               key_serial(key));
+
+        do {
+                /* pick a server to query */
+                server = afs_volume_pick_fileserver(vnode);
+                if (IS_ERR(server))
+                        goto no_server;
+
+                _debug("USING SERVER: %08x\n", ntohl(server->addr.s_addr));
+
+                ret = afs_fs_release_lock(server, key, vnode, &afs_sync_call);
+
+        } while (!afs_volume_release_fileserver(vnode, server, ret));
+
+        /* adjust the flags */
+        if (ret == 0)
                 afs_put_server(server);
-        } else {
-                afs_vnode_status_update_failed(vnode, ret);
-        }
 
         _leave(" = %d", ret);
         return ret;
 
 no_server:
-        spin_lock(&vnode->lock);
-        vnode->update_cnt--;
-        ASSERTCMP(vnode->update_cnt, >=, 0);
-        spin_unlock(&vnode->lock);
         return PTR_ERR(server);
 }
diff --git a/fs/anon_inodes.c b/fs/anon_inodes.c
index 40fe3a3222e..a260198306c 100644
--- a/fs/anon_inodes.c
+++ b/fs/anon_inodes.c
@@ -53,7 +53,7 @@ static struct dentry_operations anon_inodefs_dentry_operations = {
 };
 
 /**
- * anon_inode_getfd - creates a new file instance by hooking it up to and
+ * anon_inode_getfd - creates a new file instance by hooking it up to an
  *                    anonymous inode, and a dentry that describe the "class"
  *                    of the file
  *
@@ -66,7 +66,7 @@ static struct dentry_operations anon_inodefs_dentry_operations = {
  *
  * Creates a new file by hooking it on a single inode. This is useful for files
  * that do not need to have a full-fledged inode in order to operate correctly.
- * All the files created with anon_inode_getfd() will share a single inode, by
+ * All the files created with anon_inode_getfd() will share a single inode,
  * hence saving memory and avoiding code duplication for the file/inode/dentry
  * setup.
  */
@@ -141,9 +141,9 @@ err_put_filp:
 }
 
 /*
- * A single inode exist for all anon_inode files. Contrary to pipes,
- * anon_inode inodes has no per-instance data associated, so we can avoid
- * the allocation of multiple of them.
+ * A single inode exists for all anon_inode files. Contrary to pipes,
+ * anon_inode inodes have no associated per-instance data, so we need
+ * only allocate one of them.
  */
 static struct inode *anon_inode_mkinode(void)
 {
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 08e4414b837..a27e42bf340 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -45,7 +45,7 @@
 
 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);
+static unsigned long elf_map (struct file *, unsigned long, struct elf_phdr *, int, int, unsigned long);
 
 /*
  * If we don't support core dumping, then supply a NULL so we
@@ -80,7 +80,7 @@ static struct linux_binfmt elf_format = {
                 .hasvdso        = 1
 };
 
-#define BAD_ADDR(x) ((unsigned long)(x) >= TASK_SIZE)
+#define BAD_ADDR(x) IS_ERR_VALUE(x)
 
 static int set_brk(unsigned long start, unsigned long end)
 {
@@ -285,33 +285,70 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
 #ifndef elf_map
 
 static unsigned long elf_map(struct file *filep, unsigned long addr,
-                struct elf_phdr *eppnt, int prot, int type)
+                struct elf_phdr *eppnt, int prot, int type,
+                unsigned long total_size)
 {
         unsigned long map_addr;
-        unsigned long pageoffset = ELF_PAGEOFFSET(eppnt->p_vaddr);
+        unsigned long size = eppnt->p_filesz + ELF_PAGEOFFSET(eppnt->p_vaddr);
+        unsigned long off = eppnt->p_offset - ELF_PAGEOFFSET(eppnt->p_vaddr);
+        addr = ELF_PAGESTART(addr);
+        size = ELF_PAGEALIGN(size);
 
-        down_write(&current->mm->mmap_sem);
         /* mmap() will return -EINVAL if given a zero size, but a
          * segment with zero filesize is perfectly valid */
-        if (eppnt->p_filesz + pageoffset)
-                map_addr = do_mmap(filep, ELF_PAGESTART(addr),
-                                   eppnt->p_filesz + pageoffset, prot, type,
-                                   eppnt->p_offset - pageoffset);
-        else
-                map_addr = ELF_PAGESTART(addr);
+        if (!size)
+                return addr;
+
+        down_write(&current->mm->mmap_sem);
+        /*
+        * total_size is the size of the ELF (interpreter) image.
+        * The _first_ mmap needs to know the full size, otherwise
+        * randomization might put this image into an overlapping
+        * position with the ELF binary image. (since size < total_size)
+        * So we first map the 'big' image - and unmap the remainder at
+        * the end. (which unmap is needed for ELF images with holes.)
+        */
+        if (total_size) {
+                total_size = ELF_PAGEALIGN(total_size);
+                map_addr = do_mmap(filep, addr, total_size, prot, type, off);
+                if (!BAD_ADDR(map_addr))
+                        do_munmap(current->mm, map_addr+size, total_size-size);
+        } else
+                map_addr = do_mmap(filep, addr, size, prot, type, off);
+
         up_write(&current->mm->mmap_sem);
         return(map_addr);
 }
 
 #endif /* !elf_map */
 
+static unsigned long total_mapping_size(struct elf_phdr *cmds, int nr)
+{
+        int i, first_idx = -1, last_idx = -1;
+
+        for (i = 0; i < nr; i++) {
+                if (cmds[i].p_type == PT_LOAD) {
+                        last_idx = i;
+                        if (first_idx == -1)
+                                first_idx = i;
+                }
+        }
+        if (first_idx == -1)
+                return 0;
+
+        return cmds[last_idx].p_vaddr + cmds[last_idx].p_memsz -
+                                ELF_PAGESTART(cmds[first_idx].p_vaddr);
+}
+
+
 /* This is much more generalized than the library routine read function,
    so we keep this separate.  Technically the library read function
    is only provided so that we can read a.out libraries that have
    an ELF header */
 
 static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
-                struct file *interpreter, unsigned long *interp_load_addr)
+                struct file *interpreter, unsigned long *interp_map_addr,
+                unsigned long no_base)
 {
         struct elf_phdr *elf_phdata;
         struct elf_phdr *eppnt;
@@ -319,6 +356,7 @@ static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
         int load_addr_set = 0;
         unsigned long last_bss = 0, elf_bss = 0;
         unsigned long error = ~0UL;
+        unsigned long total_size;
         int retval, i, size;
 
         /* First of all, some simple consistency checks */
@@ -357,6 +395,12 @@ static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
                 goto out_close;
         }
 
+        total_size = total_mapping_size(elf_phdata, interp_elf_ex->e_phnum);
+        if (!total_size) {
+                error = -EINVAL;
+                goto out_close;
+        }
+
         eppnt = elf_phdata;
         for (i = 0; i < interp_elf_ex->e_phnum; i++, eppnt++) {
                 if (eppnt->p_type == PT_LOAD) {
@@ -374,9 +418,14 @@ static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
                         vaddr = eppnt->p_vaddr;
                         if (interp_elf_ex->e_type == ET_EXEC || load_addr_set)
                                 elf_type |= MAP_FIXED;
+                        else if (no_base && interp_elf_ex->e_type == ET_DYN)
+                                load_addr = -vaddr;
 
                         map_addr = elf_map(interpreter, load_addr + vaddr,
-                                           eppnt, elf_prot, elf_type);
+                                           eppnt, elf_prot, elf_type, total_size);
+                        total_size = 0;
+                        if (!*interp_map_addr)
+                                *interp_map_addr = map_addr;
                         error = map_addr;
                         if (BAD_ADDR(map_addr))
                                 goto out_close;
@@ -442,8 +491,7 @@ static unsigned long load_elf_interp(struct elfhdr *interp_elf_ex,
                         goto out_close;
         }
 
-        *interp_load_addr = load_addr;
-        error = ((unsigned long)interp_elf_ex->e_entry) + load_addr;
+        error = load_addr;
 
 out_close:
         kfree(elf_phdata);
@@ -540,7 +588,8 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
         int elf_exec_fileno;
         int retval, i;
         unsigned int size;
-        unsigned long elf_entry, interp_load_addr = 0;
+        unsigned long elf_entry;
+        unsigned long interp_load_addr = 0;
         unsigned long start_code, end_code, start_data, end_data;
         unsigned long reloc_func_desc = 0;
         char passed_fileno[6];
@@ -808,9 +857,7 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
         current->mm->start_stack = bprm->p;
 
         /* Now we do a little grungy work by mmaping the ELF image into
-           the correct location in memory.  At this point, we assume that
-           the image should be loaded at fixed address, not at a variable
-           address. */
+           the correct location in memory. */
         for(i = 0, elf_ppnt = elf_phdata;
             i < loc->elf_ex.e_phnum; i++, elf_ppnt++) {
                 int elf_prot = 0, elf_flags;
@@ -864,11 +911,15 @@ 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.  */
+#ifdef CONFIG_X86
+                        load_bias = 0;
+#else
                         load_bias = ELF_PAGESTART(ELF_ET_DYN_BASE - vaddr);
+#endif
                 }
 
                 error = elf_map(bprm->file, load_bias + vaddr, elf_ppnt,
-                                elf_prot, elf_flags);
+                                elf_prot, elf_flags,0);
                 if (BAD_ADDR(error)) {
                         send_sig(SIGKILL, current, 0);
                         retval = IS_ERR((void *)error) ?
@@ -944,13 +995,25 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
         }
 
         if (elf_interpreter) {
-                if (interpreter_type == INTERPRETER_AOUT)
+                if (interpreter_type == INTERPRETER_AOUT) {
                         elf_entry = load_aout_interp(&loc->interp_ex,
                                                      interpreter);
-                else
+                } else {
+                        unsigned long uninitialized_var(interp_map_addr);
+
                         elf_entry = load_elf_interp(&loc->interp_elf_ex,
                                                     interpreter,
-                                                    &interp_load_addr);
+                                                    &interp_map_addr,
+                                                    load_bias);
+                        if (!BAD_ADDR(elf_entry)) {
+                                /*
+                                 * load_elf_interp() returns relocation
+                                 * adjustment
+                                 */
+                                interp_load_addr = elf_entry;
+                                elf_entry += loc->interp_elf_ex.e_entry;
+                        }
+                }
                 if (BAD_ADDR(elf_entry)) {
                         force_sig(SIGSEGV, current);
                         retval = IS_ERR((void *)elf_entry) ?
diff --git a/fs/block_dev.c b/fs/block_dev.c
index b3e9bfa748c..3635315e3b9 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -588,12 +588,10 @@ EXPORT_SYMBOL(bdget);
 
 long nr_blockdev_pages(void)
 {
-        struct list_head *p;
+        struct block_device *bdev;
         long ret = 0;
         spin_lock(&bdev_lock);
-        list_for_each(p, &all_bdevs) {
-                struct block_device *bdev;
-                bdev = list_entry(p, struct block_device, bd_list);
+        list_for_each_entry(bdev, &all_bdevs, bd_list) {
                 ret += bdev->bd_inode->i_mapping->nrpages;
         }
         spin_unlock(&bdev_lock);
@@ -874,7 +872,7 @@ static struct bd_holder *find_bd_holder(struct block_device *bdev,
  */
 static int add_bd_holder(struct block_device *bdev, struct bd_holder *bo)
 {
-        int ret;
+        int err;
 
         if (!bo)
                 return -EINVAL;
@@ -882,15 +880,18 @@ static int add_bd_holder(struct block_device *bdev, struct bd_holder *bo)
         if (!bd_holder_grab_dirs(bdev, bo))
                 return -EBUSY;
 
-        ret = add_symlink(bo->sdir, bo->sdev);
-        if (ret == 0) {
-                ret = add_symlink(bo->hdir, bo->hdev);
-                if (ret)
-                        del_symlink(bo->sdir, bo->sdev);
+        err = add_symlink(bo->sdir, bo->sdev);
+        if (err)
+                return err;
+
+        err = add_symlink(bo->hdir, bo->hdev);
+        if (err) {
+                del_symlink(bo->sdir, bo->sdev);
+                return err;
         }
-        if (ret == 0)
-                list_add_tail(&bo->list, &bdev->bd_holder_list);
-        return ret;
+
+        list_add_tail(&bo->list, &bdev->bd_holder_list);
+        return 0;
 }
 
 /**
@@ -948,7 +949,7 @@ static struct bd_holder *del_bd_holder(struct block_device *bdev,
 static int bd_claim_by_kobject(struct block_device *bdev, void *holder,
                                 struct kobject *kobj)
 {
-        int res;
+        int err;
         struct bd_holder *bo, *found;
 
         if (!kobj)
@@ -959,21 +960,24 @@ static int bd_claim_by_kobject(struct block_device *bdev, void *holder,
                 return -ENOMEM;
 
         mutex_lock(&bdev->bd_mutex);
-        res = bd_claim(bdev, holder);
-        if (res == 0) {
-                found = find_bd_holder(bdev, bo);
-                if (found == NULL) {
-                        res = add_bd_holder(bdev, bo);
-                        if (res)
-                                bd_release(bdev);
-                }
-        }
 
-        if (res || found)
-                free_bd_holder(bo);
-        mutex_unlock(&bdev->bd_mutex);
+        err = bd_claim(bdev, holder);
+        if (err)
+                goto fail;
 
-        return res;
+        found = find_bd_holder(bdev, bo);
+        if (found)
+                goto fail;
+
+        err = add_bd_holder(bdev, bo);
+        if (err)
+                bd_release(bdev);
+        else
+                bo = NULL;
+fail:
+        mutex_unlock(&bdev->bd_mutex);
+        free_bd_holder(bo);
+        return err;
 }
 
 /**
@@ -987,15 +991,12 @@ static int bd_claim_by_kobject(struct block_device *bdev, void *holder,
 static void bd_release_from_kobject(struct block_device *bdev,
                                         struct kobject *kobj)
 {
-        struct bd_holder *bo;
-
         if (!kobj)
                 return;
 
         mutex_lock(&bdev->bd_mutex);
         bd_release(bdev);
-        if ((bo = del_bd_holder(bdev, kobj)))
-                free_bd_holder(bo);
+        free_bd_holder(del_bd_holder(bdev, kobj));
         mutex_unlock(&bdev->bd_mutex);
 }
 
diff --git a/fs/buffer.c b/fs/buffer.c
index aa68206bd51..424165b569f 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -1026,11 +1026,6 @@ failed:
 /*
  * Create buffers for the specified block device block's page.  If
  * that page was dirty, the buffers are set dirty also.
- *
- * Except that's a bug.  Attaching dirty buffers to a dirty
- * blockdev's page can result in filesystem corruption, because
- * some of those buffers may be aliases of filesystem data.
- * grow_dev_page() will go BUG() if this happens.
  */
 static int
 grow_buffers(struct block_device *bdev, sector_t block, int size)
diff --git a/fs/coda/dir.c b/fs/coda/dir.c
index 9ddf5ed6216..898a86dde8f 100644
--- a/fs/coda/dir.c
+++ b/fs/coda/dir.c
@@ -470,7 +470,7 @@ int coda_readdir(struct file *coda_file, void *dirent, filldir_t filldir)
 
                 ret = -ENOENT;
                 if (!IS_DEADDIR(host_inode)) {
-                        ret = host_file->f_op->readdir(host_file, filldir, dirent);
+                        ret = host_file->f_op->readdir(host_file, dirent, filldir);
                         file_accessed(host_file);
                 }
         }
diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c
index 6b44cdc96fa..e440a7b95d0 100644
--- a/fs/compat_ioctl.c
+++ b/fs/compat_ioctl.c
@@ -63,6 +63,7 @@
 #include <linux/wireless.h>
 #include <linux/atalk.h>
 #include <linux/blktrace_api.h>
+#include <linux/loop.h>
 
 #include <net/bluetooth/bluetooth.h>
 #include <net/bluetooth/hci.h>
@@ -3489,6 +3490,9 @@ HANDLE_IOCTL(LPSETTIMEOUT, lp_timeout_trans)
 
 IGNORE_IOCTL(VFAT_IOCTL_READDIR_BOTH32)
 IGNORE_IOCTL(VFAT_IOCTL_READDIR_SHORT32)
+
+/* loop */
+IGNORE_IOCTL(LOOP_CLR_FD)
 };
 
 #define IOCTL_HASHSIZE 256
diff --git a/fs/configfs/configfs_internal.h b/fs/configfs/configfs_internal.h
index 7b48c034b31..3b0185fdf9a 100644
--- a/fs/configfs/configfs_internal.h
+++ b/fs/configfs/configfs_internal.h
@@ -29,10 +29,11 @@
 
 struct configfs_dirent {
         atomic_t                s_count;
+        int                     s_dependent_count;
         struct list_head        s_sibling;
         struct list_head        s_children;
         struct list_head        s_links;
-        void                    * s_element;
+        void                    * s_element;
         int                     s_type;
         umode_t                 s_mode;
         struct dentry           * s_dentry;
@@ -41,8 +42,8 @@ struct configfs_dirent {
 
 #define CONFIGFS_ROOT           0x0001
 #define CONFIGFS_DIR            0x0002
-#define CONFIGFS_ITEM_ATTR      0x0004
-#define CONFIGFS_ITEM_LINK      0x0020
+#define CONFIGFS_ITEM_ATTR      0x0004
+#define CONFIGFS_ITEM_LINK      0x0020
 #define CONFIGFS_USET_DIR       0x0040
 #define CONFIGFS_USET_DEFAULT   0x0080
 #define CONFIGFS_USET_DROPPING  0x0100
diff --git a/fs/configfs/dir.c b/fs/configfs/dir.c
index 5e6e37e58f3..2f436d4f1d6 100644
--- a/fs/configfs/dir.c
+++ b/fs/configfs/dir.c
@@ -355,6 +355,10 @@ static int configfs_detach_prep(struct dentry *dentry)
                         /* Mark that we've taken i_mutex */
                         sd->s_type |= CONFIGFS_USET_DROPPING;
 
+                        /*
+                         * Yup, recursive.  If there's a problem, blame
+                         * deep nesting of default_groups
+                         */
                         ret = configfs_detach_prep(sd->s_dentry);
                         if (!ret)
                                 continue;
@@ -562,7 +566,7 @@ static int populate_groups(struct config_group *group)
 
 /*
  * All of link_obj/unlink_obj/link_group/unlink_group require that
- * subsys->su_sem is held.
+ * subsys->su_mutex is held.
  */
 
 static void unlink_obj(struct config_item *item)
@@ -714,6 +718,28 @@ static void configfs_detach_group(struct config_item *item)
 }
 
 /*
+ * After the item has been detached from the filesystem view, we are
+ * ready to tear it out of the hierarchy.  Notify the client before
+ * we do that so they can perform any cleanup that requires
+ * navigating the hierarchy.  A client does not need to provide this
+ * callback.  The subsystem semaphore MUST be held by the caller, and
+ * references must be valid for both items.  It also assumes the
+ * caller has validated ci_type.
+ */
+static void client_disconnect_notify(struct config_item *parent_item,
+                                     struct config_item *item)
+{
+        struct config_item_type *type;
+
+        type = parent_item->ci_type;
+        BUG_ON(!type);
+
+        if (type->ct_group_ops && type->ct_group_ops->disconnect_notify)
+                type->ct_group_ops->disconnect_notify(to_config_group(parent_item),
+                                                      item);
+}
+
+/*
  * Drop the initial reference from make_item()/make_group()
  * This function assumes that reference is held on item
  * and that item holds a valid reference to the parent.  Also, it
@@ -733,11 +759,244 @@ static void client_drop_item(struct config_item *parent_item,
          */
         if (type->ct_group_ops && type->ct_group_ops->drop_item)
                 type->ct_group_ops->drop_item(to_config_group(parent_item),
-                                                item);
+                                              item);
         else
                 config_item_put(item);
 }
 
+#ifdef DEBUG
+static void configfs_dump_one(struct configfs_dirent *sd, int level)
+{
+        printk(KERN_INFO "%*s\"%s\":\n", level, " ", configfs_get_name(sd));
+
+#define type_print(_type) if (sd->s_type & _type) printk(KERN_INFO "%*s %s\n", level, " ", #_type);
+        type_print(CONFIGFS_ROOT);
+        type_print(CONFIGFS_DIR);
+        type_print(CONFIGFS_ITEM_ATTR);
+        type_print(CONFIGFS_ITEM_LINK);
+        type_print(CONFIGFS_USET_DIR);
+        type_print(CONFIGFS_USET_DEFAULT);
+        type_print(CONFIGFS_USET_DROPPING);
+#undef type_print
+}
+
+static int configfs_dump(struct configfs_dirent *sd, int level)
+{
+        struct configfs_dirent *child_sd;
+        int ret = 0;
+
+        configfs_dump_one(sd, level);
+
+        if (!(sd->s_type & (CONFIGFS_DIR|CONFIGFS_ROOT)))
+                return 0;
+
+        list_for_each_entry(child_sd, &sd->s_children, s_sibling) {
+                ret = configfs_dump(child_sd, level + 2);
+                if (ret)
+                        break;
+        }
+
+        return ret;
+}
+#endif
+
+
+/*
+ * configfs_depend_item() and configfs_undepend_item()
+ *
+ * WARNING: Do not call these from a configfs callback!
+ *
+ * This describes these functions and their helpers.
+ *
+ * Allow another kernel system to depend on a config_item.  If this
+ * happens, the item cannot go away until the dependant can live without
+ * it.  The idea is to give client modules as simple an interface as
+ * possible.  When a system asks them to depend on an item, they just
+ * call configfs_depend_item().  If the item is live and the client
+ * driver is in good shape, we'll happily do the work for them.
+ *
+ * Why is the locking complex?  Because configfs uses the VFS to handle
+ * all locking, but this function is called outside the normal
+ * VFS->configfs path.  So it must take VFS locks to prevent the
+ * VFS->configfs stuff (configfs_mkdir(), configfs_rmdir(), etc).  This is
+ * why you can't call these functions underneath configfs callbacks.
+ *
+ * Note, btw, that this can be called at *any* time, even when a configfs
+ * subsystem isn't registered, or when configfs is loading or unloading.
+ * Just like configfs_register_subsystem().  So we take the same
+ * precautions.  We pin the filesystem.  We lock each i_mutex _in_order_
+ * on our way down the tree.  If we can find the target item in the
+ * configfs tree, it must be part of the subsystem tree as well, so we
+ * do not need the subsystem semaphore.  Holding the i_mutex chain locks
+ * out mkdir() and rmdir(), who might be racing us.
+ */
+
+/*
+ * configfs_depend_prep()
+ *
+ * Only subdirectories count here.  Files (CONFIGFS_NOT_PINNED) are
+ * attributes.  This is similar but not the same to configfs_detach_prep().
+ * Note that configfs_detach_prep() expects the parent to be locked when it
+ * is called, but we lock the parent *inside* configfs_depend_prep().  We
+ * do that so we can unlock it if we find nothing.
+ *
+ * Here we do a depth-first search of the dentry hierarchy looking for
+ * our object.  We take i_mutex on each step of the way down.  IT IS
+ * ESSENTIAL THAT i_mutex LOCKING IS ORDERED.  If we come back up a branch,
+ * we'll drop the i_mutex.
+ *
+ * If the target is not found, -ENOENT is bubbled up and we have released
+ * all locks.  If the target was found, the locks will be cleared by
+ * configfs_depend_rollback().
+ *
+ * This adds a requirement that all config_items be unique!
+ *
+ * This is recursive because the locking traversal is tricky.  There isn't
+ * much on the stack, though, so folks that need this function - be careful
+ * about your stack!  Patches will be accepted to make it iterative.
+ */
+static int configfs_depend_prep(struct dentry *origin,
+                                struct config_item *target)
+{
+        struct configfs_dirent *child_sd, *sd = origin->d_fsdata;
+        int ret = 0;
+
+        BUG_ON(!origin || !sd);
+
+        /* Lock this guy on the way down */
+        mutex_lock(&sd->s_dentry->d_inode->i_mutex);
+        if (sd->s_element == target)  /* Boo-yah */
+                goto out;
+
+        list_for_each_entry(child_sd, &sd->s_children, s_sibling) {
+                if (child_sd->s_type & CONFIGFS_DIR) {
+                        ret = configfs_depend_prep(child_sd->s_dentry,
+                                                   target);
+                        if (!ret)
+                                goto out;  /* Child path boo-yah */
+                }
+        }
+
+        /* We looped all our children and didn't find target */
+        mutex_unlock(&sd->s_dentry->d_inode->i_mutex);
+        ret = -ENOENT;
+
+out:
+        return ret;
+}
+
+/*
+ * This is ONLY called if configfs_depend_prep() did its job.  So we can
+ * trust the entire path from item back up to origin.
+ *
+ * We walk backwards from item, unlocking each i_mutex.  We finish by
+ * unlocking origin.
+ */
+static void configfs_depend_rollback(struct dentry *origin,
+                                     struct config_item *item)
+{
+        struct dentry *dentry = item->ci_dentry;
+
+        while (dentry != origin) {
+                mutex_unlock(&dentry->d_inode->i_mutex);
+                dentry = dentry->d_parent;
+        }
+
+        mutex_unlock(&origin->d_inode->i_mutex);
+}
+
+int configfs_depend_item(struct configfs_subsystem *subsys,
+                         struct config_item *target)
+{
+        int ret;
+        struct configfs_dirent *p, *root_sd, *subsys_sd = NULL;
+        struct config_item *s_item = &subsys->su_group.cg_item;
+
+        /*
+         * Pin the configfs filesystem.  This means we can safely access
+         * the root of the configfs filesystem.
+         */
+        ret = configfs_pin_fs();
+        if (ret)
+                return ret;
+
+        /*
+         * Next, lock the root directory.  We're going to check that the
+         * subsystem is really registered, and so we need to lock out
+         * configfs_[un]register_subsystem().
+         */
+        mutex_lock(&configfs_sb->s_root->d_inode->i_mutex);
+
+        root_sd = configfs_sb->s_root->d_fsdata;
+
+        list_for_each_entry(p, &root_sd->s_children, s_sibling) {
+                if (p->s_type & CONFIGFS_DIR) {
+                        if (p->s_element == s_item) {
+                                subsys_sd = p;
+                                break;
+                        }
+                }
+        }
+
+        if (!subsys_sd) {
+                ret = -ENOENT;
+                goto out_unlock_fs;
+        }
+
+        /* Ok, now we can trust subsys/s_item */
+
+        /* Scan the tree, locking i_mutex recursively, return 0 if found */
+        ret = configfs_depend_prep(subsys_sd->s_dentry, target);
+        if (ret)
+                goto out_unlock_fs;
+
+        /* We hold all i_mutexes from the subsystem down to the target */
+        p = target->ci_dentry->d_fsdata;
+        p->s_dependent_count += 1;
+
+        configfs_depend_rollback(subsys_sd->s_dentry, target);
+
+out_unlock_fs:
+        mutex_unlock(&configfs_sb->s_root->d_inode->i_mutex);
+
+        /*
+         * If we succeeded, the fs is pinned via other methods.  If not,
+         * we're done with it anyway.  So release_fs() is always right.
+         */
+        configfs_release_fs();
+
+        return ret;
+}
+EXPORT_SYMBOL(configfs_depend_item);
+
+/*
+ * Release the dependent linkage.  This is much simpler than
+ * configfs_depend_item() because we know that that the client driver is
+ * pinned, thus the subsystem is pinned, and therefore configfs is pinned.
+ */
+void configfs_undepend_item(struct configfs_subsystem *subsys,
+                            struct config_item *target)
+{
+        struct configfs_dirent *sd;
+
+        /*
+         * Since we can trust everything is pinned, we just need i_mutex
+         * on the item.
+         */
+        mutex_lock(&target->ci_dentry->d_inode->i_mutex);
+
+        sd = target->ci_dentry->d_fsdata;
+        BUG_ON(sd->s_dependent_count < 1);
+
+        sd->s_dependent_count -= 1;
+
+        /*
+         * After this unlock, we cannot trust the item to stay alive!
+         * DO NOT REFERENCE item after this unlock.
+         */
+        mutex_unlock(&target->ci_dentry->d_inode->i_mutex);
+}
+EXPORT_SYMBOL(configfs_undepend_item);
 
 static int configfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 {
@@ -783,7 +1042,7 @@ static int configfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 
         snprintf(name, dentry->d_name.len + 1, "%s", dentry->d_name.name);
 
-        down(&subsys->su_sem);
+        mutex_lock(&subsys->su_mutex);
         group = NULL;
         item = NULL;
         if (type->ct_group_ops->make_group) {
@@ -797,7 +1056,7 @@ static int configfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
                 if (item)
                         link_obj(parent_item, item);
         }
-        up(&subsys->su_sem);
+        mutex_unlock(&subsys->su_mutex);
 
         kfree(name);
         if (!item) {
@@ -841,13 +1100,16 @@ static int configfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 out_unlink:
         if (ret) {
                 /* Tear down everything we built up */
-                down(&subsys->su_sem);
+                mutex_lock(&subsys->su_mutex);
+
+                client_disconnect_notify(parent_item, item);
                 if (group)
                         unlink_group(group);
                 else
                         unlink_obj(item);
                 client_drop_item(parent_item, item);
-                up(&subsys->su_sem);
+
+                mutex_unlock(&subsys->su_mutex);
 
                 if (module_got)
                         module_put(owner);
@@ -881,6 +1143,13 @@ static int configfs_rmdir(struct inode *dir, struct dentry *dentry)
         if (sd->s_type & CONFIGFS_USET_DEFAULT)
                 return -EPERM;
 
+        /*
+         * Here's where we check for dependents.  We're protected by
+         * i_mutex.
+         */
+        if (sd->s_dependent_count)
+                return -EBUSY;
+
         /* Get a working ref until we have the child */
         parent_item = configfs_get_config_item(dentry->d_parent);
         subsys = to_config_group(parent_item)->cg_subsys;
@@ -910,17 +1179,19 @@ static int configfs_rmdir(struct inode *dir, struct dentry *dentry)
         if (sd->s_type & CONFIGFS_USET_DIR) {
                 configfs_detach_group(item);
 
-                down(&subsys->su_sem);
+                mutex_lock(&subsys->su_mutex);
+                client_disconnect_notify(parent_item, item);
                 unlink_group(to_config_group(item));
         } else {
                 configfs_detach_item(item);
 
-                down(&subsys->su_sem);
+                mutex_lock(&subsys->su_mutex);
+                client_disconnect_notify(parent_item, item);
                 unlink_obj(item);
         }
 
         client_drop_item(parent_item, item);
-        up(&subsys->su_sem);
+        mutex_unlock(&subsys->su_mutex);
 
         /* Drop our reference from above */
         config_item_put(item);
diff --git a/fs/configfs/file.c b/fs/configfs/file.c
index 3527c7c6def..a3658f9a082 100644
--- a/fs/configfs/file.c
+++ b/fs/configfs/file.c
@@ -27,19 +27,26 @@
 #include <linux/fs.h>
 #include <linux/module.h>
 #include <linux/slab.h>
+#include <linux/mutex.h>
 #include <asm/uaccess.h>
-#include <asm/semaphore.h>
 
 #include <linux/configfs.h>
 #include "configfs_internal.h"
 
+/*
+ * A simple attribute can only be 4096 characters.  Why 4k?  Because the
+ * original code limited it to PAGE_SIZE.  That's a bad idea, though,
+ * because an attribute of 16k on ia64 won't work on x86.  So we limit to
+ * 4k, our minimum common page size.
+ */
+#define SIMPLE_ATTR_SIZE 4096
 
 struct configfs_buffer {
         size_t                  count;
         loff_t                  pos;
         char                    * page;
         struct configfs_item_operations * ops;
-        struct semaphore        sem;
+        struct mutex            mutex;
         int                     needs_read_fill;
 };
 
@@ -69,7 +76,7 @@ static int fill_read_buffer(struct dentry * dentry, struct configfs_buffer * buf
 
         count = ops->show_attribute(item,attr,buffer->page);
         buffer->needs_read_fill = 0;
-        BUG_ON(count > (ssize_t)PAGE_SIZE);
+        BUG_ON(count > (ssize_t)SIMPLE_ATTR_SIZE);
         if (count >= 0)
                 buffer->count = count;
         else
@@ -102,7 +109,7 @@ configfs_read_file(struct file *file, char __user *buf, size_t count, loff_t *pp
         struct configfs_buffer * buffer = file->private_data;
         ssize_t retval = 0;
 
-        down(&buffer->sem);
+        mutex_lock(&buffer->mutex);
         if (buffer->needs_read_fill) {
                 if ((retval = fill_read_buffer(file->f_path.dentry,buffer)))
                         goto out;
@@ -112,7 +119,7 @@ configfs_read_file(struct file *file, char __user *buf, size_t count, loff_t *pp
         retval = simple_read_from_buffer(buf, count, ppos, buffer->page,
                                          buffer->count);
 out:
-        up(&buffer->sem);
+        mutex_unlock(&buffer->mutex);
         return retval;
 }
 
@@ -137,8 +144,8 @@ fill_write_buffer(struct configfs_buffer * buffer, const char __user * buf, size
         if (!buffer->page)
                 return -ENOMEM;
 
-        if (count >= PAGE_SIZE)
-                count = PAGE_SIZE - 1;
+        if (count >= SIMPLE_ATTR_SIZE)
+                count = SIMPLE_ATTR_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,
@@ -193,13 +200,13 @@ configfs_write_file(struct file *file, const char __user *buf, size_t count, lof
         struct configfs_buffer * buffer = file->private_data;
         ssize_t len;
 
-        down(&buffer->sem);
+        mutex_lock(&buffer->mutex);
         len = fill_write_buffer(buffer, buf, count);
         if (len > 0)
                 len = flush_write_buffer(file->f_path.dentry, buffer, count);
         if (len > 0)
                 *ppos += len;
-        up(&buffer->sem);
+        mutex_unlock(&buffer->mutex);
         return len;
 }
 
@@ -253,7 +260,7 @@ static int check_perm(struct inode * inode, struct file * file)
                 error = -ENOMEM;
                 goto Enomem;
         }
-        init_MUTEX(&buffer->sem);
+        mutex_init(&buffer->mutex);
         buffer->needs_read_fill = 1;
         buffer->ops = ops;
         file->private_data = buffer;
@@ -292,6 +299,7 @@ static int configfs_release(struct inode * inode, struct file * filp)
         if (buffer) {
                 if (buffer->page)
                         free_page((unsigned long)buffer->page);
+                mutex_destroy(&buffer->mutex);
                 kfree(buffer);
         }
         return 0;
diff --git a/fs/configfs/item.c b/fs/configfs/item.c
index 24421209f85..76dc4c3e5d5 100644
--- a/fs/configfs/item.c
+++ b/fs/configfs/item.c
@@ -62,7 +62,6 @@ void config_item_init(struct config_item * item)
  *      dynamically allocated string that @item->ci_name points to.
  *      Otherwise, use the static @item->ci_namebuf array.
  */
-
 int config_item_set_name(struct config_item * item, const char * fmt, ...)
 {
         int error = 0;
@@ -139,12 +138,7 @@ struct config_item * config_item_get(struct config_item * item)
         return item;
 }
 
-/**
- *      config_item_cleanup - free config_item resources.
- *      @item:  item.
- */
-
-void config_item_cleanup(struct config_item * item)
+static void config_item_cleanup(struct config_item * item)
 {
         struct config_item_type * t = item->ci_type;
         struct config_group * s = item->ci_group;
@@ -179,39 +173,35 @@ void config_item_put(struct config_item * item)
                 kref_put(&item->ci_kref, config_item_release);
 }
 
-
 /**
  *      config_group_init - initialize a group for use
  *      @k:     group
  */
-
 void config_group_init(struct config_group *group)
 {
         config_item_init(&group->cg_item);
         INIT_LIST_HEAD(&group->cg_children);
 }
 
-
 /**
- *      config_group_find_obj - search for item in group.
+ *      config_group_find_item - search for item in group.
  *      @group: group we're looking in.
  *      @name:  item's name.
  *
- *      Lock group via @group->cg_subsys, and iterate over @group->cg_list,
- *      looking for a matching config_item. If matching item is found
- *      take a reference and return the item.
+ *      Iterate over @group->cg_list, looking for a matching config_item.
+ *      If matching item is found take a reference and return the item.
+ *      Caller must have locked group via @group->cg_subsys->su_mtx.
  */
-
-struct config_item * config_group_find_obj(struct config_group * group, const char * name)
+struct config_item *config_group_find_item(struct config_group *group,
+                                           const char *name)
 {
         struct list_head * entry;
         struct config_item * ret = NULL;
 
-        /* XXX LOCKING! */
         list_for_each(entry,&group->cg_children) {
                 struct config_item * item = to_item(entry);
                 if (config_item_name(item) &&
-                    !strcmp(config_item_name(item), name)) {
+                    !strcmp(config_item_name(item), name)) {
                         ret = config_item_get(item);
                         break;
                 }
@@ -219,9 +209,8 @@ struct config_item * config_group_find_obj(struct config_group * group, const ch
         return ret;
 }
 
-
 EXPORT_SYMBOL(config_item_init);
 EXPORT_SYMBOL(config_group_init);
 EXPORT_SYMBOL(config_item_get);
 EXPORT_SYMBOL(config_item_put);
-EXPORT_SYMBOL(config_group_find_obj);
+EXPORT_SYMBOL(config_group_find_item);
diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c
index ec8896b264d..1d533a2ec3a 100644
--- a/fs/debugfs/inode.c
+++ b/fs/debugfs/inode.c
@@ -368,6 +368,69 @@ void debugfs_remove(struct dentry *dentry)
 }
 EXPORT_SYMBOL_GPL(debugfs_remove);
 
+/**
+ * debugfs_rename - rename a file/directory in the debugfs filesystem
+ * @old_dir: a pointer to the parent dentry for the renamed object. This
+ *          should be a directory dentry.
+ * @old_dentry: dentry of an object to be renamed.
+ * @new_dir: a pointer to the parent dentry where the object should be
+ *          moved. This should be a directory dentry.
+ * @new_name: a pointer to a string containing the target name.
+ *
+ * This function renames a file/directory in debugfs.  The target must not
+ * exist for rename to succeed.
+ *
+ * This function will return a pointer to old_dentry (which is updated to
+ * reflect renaming) if it succeeds. If an error occurs, %NULL will be
+ * returned.
+ *
+ * If debugfs is not enabled in the kernel, the value -%ENODEV will be
+ * returned.
+ */
+struct dentry *debugfs_rename(struct dentry *old_dir, struct dentry *old_dentry,
+                struct dentry *new_dir, const char *new_name)
+{
+        int error;
+        struct dentry *dentry = NULL, *trap;
+        const char *old_name;
+
+        trap = lock_rename(new_dir, old_dir);
+        /* Source or destination directories don't exist? */
+        if (!old_dir->d_inode || !new_dir->d_inode)
+                goto exit;
+        /* Source does not exist, cyclic rename, or mountpoint? */
+        if (!old_dentry->d_inode || old_dentry == trap ||
+            d_mountpoint(old_dentry))
+                goto exit;
+        dentry = lookup_one_len(new_name, new_dir, strlen(new_name));
+        /* Lookup failed, cyclic rename or target exists? */
+        if (IS_ERR(dentry) || dentry == trap || dentry->d_inode)
+                goto exit;
+
+        old_name = fsnotify_oldname_init(old_dentry->d_name.name);
+
+        error = simple_rename(old_dir->d_inode, old_dentry, new_dir->d_inode,
+                dentry);
+        if (error) {
+                fsnotify_oldname_free(old_name);
+                goto exit;
+        }
+        d_move(old_dentry, dentry);
+        fsnotify_move(old_dir->d_inode, new_dir->d_inode, old_name,
+                old_dentry->d_name.name, S_ISDIR(old_dentry->d_inode->i_mode),
+                NULL, old_dentry->d_inode);
+        fsnotify_oldname_free(old_name);
+        unlock_rename(new_dir, old_dir);
+        dput(dentry);
+        return old_dentry;
+exit:
+        if (dentry && !IS_ERR(dentry))
+                dput(dentry);
+        unlock_rename(new_dir, old_dir);
+        return NULL;
+}
+EXPORT_SYMBOL_GPL(debugfs_rename);
+
 static decl_subsys(debug, NULL, NULL);
 
 static int __init debugfs_init(void)
diff --git a/fs/dlm/config.c b/fs/dlm/config.c
index 5069b2cb5a1..2f8e3c81bc1 100644
--- a/fs/dlm/config.c
+++ b/fs/dlm/config.c
@@ -133,14 +133,6 @@ static ssize_t cluster_set(struct cluster *cl, unsigned int *cl_field,
         return len;
 }
 
-#define __CONFIGFS_ATTR(_name,_mode,_read,_write) {                           \
-        .attr   = { .ca_name = __stringify(_name),                            \
-                    .ca_mode = _mode,                                         \
-                    .ca_owner = THIS_MODULE },                                \
-        .show   = _read,                                                      \
-        .store  = _write,                                                     \
-}
-
 #define CLUSTER_ATTR(name, check_zero)                                        \
 static ssize_t name##_write(struct cluster *cl, const char *buf, size_t len)  \
 {                                                                             \
@@ -615,7 +607,7 @@ static struct clusters clusters_root = {
 int dlm_config_init(void)
 {
         config_group_init(&clusters_root.subsys.su_group);
-        init_MUTEX(&clusters_root.subsys.su_sem);
+        mutex_init(&clusters_root.subsys.su_mutex);
         return configfs_register_subsystem(&clusters_root.subsys);
 }
 
@@ -759,9 +751,9 @@ static struct space *get_space(char *name)
         if (!space_list)
                 return NULL;
 
-        down(&space_list->cg_subsys->su_sem);
-        i = config_group_find_obj(space_list, name);
-        up(&space_list->cg_subsys->su_sem);
+        mutex_lock(&space_list->cg_subsys->su_mutex);
+        i = config_group_find_item(space_list, name);
+        mutex_unlock(&space_list->cg_subsys->su_mutex);
 
         return to_space(i);
 }
@@ -780,7 +772,7 @@ static struct comm *get_comm(int nodeid, struct sockaddr_storage *addr)
         if (!comm_list)
                 return NULL;
 
-        down(&clusters_root.subsys.su_sem);
+        mutex_lock(&clusters_root.subsys.su_mutex);
 
         list_for_each_entry(i, &comm_list->cg_children, ci_entry) {
                 cm = to_comm(i);
@@ -800,7 +792,7 @@ static struct comm *get_comm(int nodeid, struct sockaddr_storage *addr)
                         break;
                 }
         }
-        up(&clusters_root.subsys.su_sem);
+        mutex_unlock(&clusters_root.subsys.su_mutex);
 
         if (!found)
                 cm = NULL;
diff --git a/fs/drop_caches.c b/fs/drop_caches.c
index 03ea7696fe3..59375efcf39 100644
--- a/fs/drop_caches.c
+++ b/fs/drop_caches.c
@@ -20,7 +20,7 @@ static void drop_pagecache_sb(struct super_block *sb)
         list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
                 if (inode->i_state & (I_FREEING|I_WILL_FREE))
                         continue;
-                invalidate_mapping_pages(inode->i_mapping, 0, -1);
+                __invalidate_mapping_pages(inode->i_mapping, 0, -1, true);
         }
         spin_unlock(&inode_lock);
 }
diff --git a/fs/ecryptfs/main.c b/fs/ecryptfs/main.c
index 606128f5c92..02ca6f1e55d 100644
--- a/fs/ecryptfs/main.c
+++ b/fs/ecryptfs/main.c
@@ -840,8 +840,6 @@ static int __init ecryptfs_init(void)
                 goto out;
         }
         kobj_set_kset_s(&ecryptfs_subsys, fs_subsys);
-        sysfs_attr_version.attr.owner = THIS_MODULE;
-        sysfs_attr_version_str.attr.owner = THIS_MODULE;
         rc = do_sysfs_registration();
         if (rc) {
                 printk(KERN_ERR "sysfs registration failed\n");
diff --git a/fs/ext2/file.c b/fs/ext2/file.c
index 04afeecaaef..ab7961260c4 100644
--- a/fs/ext2/file.c
+++ b/fs/ext2/file.c
@@ -24,9 +24,9 @@
 #include "acl.h"
 
 /*
- * Called when an inode is released. Note that this is different
- * from ext2_open_file: open gets called at every open, but release
- * gets called only when /all/ the files are closed.
+ * Called when filp is released. This happens when all file descriptors
+ * for a single struct file are closed. Note that different open() calls
+ * for the same file yield different struct file structures.
  */
 static int ext2_release_file (struct inode * inode, struct file * filp)
 {
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 5de5061eb33..b2efd9083b9 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -1099,15 +1099,18 @@ 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;
-        else {
+                sbi->s_overhead_last = 0;
+        else if (sbi->s_blocks_last != le32_to_cpu(es->s_blocks_count)) {
+                unsigned long i, overhead = 0;
+                smp_rmb();
+
                 /*
-                 * Compute the overhead (FS structures)
+                 * Compute the overhead (FS structures). This is constant
+                 * for a given filesystem unless the number of block groups
+                 * changes so we cache the previous value until it does.
                  */
 
                 /*
@@ -1131,17 +1134,22 @@ static int ext2_statfs (struct dentry * dentry, struct kstatfs * buf)
                  */
                 overhead += (sbi->s_groups_count *
                              (2 + sbi->s_itb_per_group));
+                sbi->s_overhead_last = overhead;
+                smp_wmb();
+                sbi->s_blocks_last = le32_to_cpu(es->s_blocks_count);
         }
 
         buf->f_type = EXT2_SUPER_MAGIC;
         buf->f_bsize = sb->s_blocksize;
-        buf->f_blocks = le32_to_cpu(es->s_blocks_count) - overhead;
+        buf->f_blocks = le32_to_cpu(es->s_blocks_count) - sbi->s_overhead_last;
         buf->f_bfree = ext2_count_free_blocks(sb);
+        es->s_free_blocks_count = cpu_to_le32(buf->f_bfree);
         buf->f_bavail = buf->f_bfree - le32_to_cpu(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(es->s_inodes_count);
         buf->f_ffree = ext2_count_free_inodes(sb);
+        es->s_free_inodes_count = cpu_to_le32(buf->f_ffree);
         buf->f_namelen = EXT2_NAME_LEN;
         fsid = le64_to_cpup((void *)es->s_uuid) ^
                le64_to_cpup((void *)es->s_uuid + sizeof(u64));
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index 2a85ddee474..de4e3161e47 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -3195,7 +3195,7 @@ int ext3_change_inode_journal_flag(struct inode *inode, int val)
          */
 
         journal = EXT3_JOURNAL(inode);
-        if (is_journal_aborted(journal) || IS_RDONLY(inode))
+        if (is_journal_aborted(journal))
                 return -EROFS;
 
         journal_lock_updates(journal);
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index 9bb046df827..1586807b817 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -1019,6 +1019,11 @@ static struct dentry *ext3_lookup(struct inode * dir, struct dentry *dentry, str
 
                 if (!inode)
                         return ERR_PTR(-EACCES);
+
+                if (is_bad_inode(inode)) {
+                        iput(inode);
+                        return ERR_PTR(-ENOENT);
+                }
         }
         return d_splice_alias(inode, dentry);
 }
@@ -1054,6 +1059,11 @@ struct dentry *ext3_get_parent(struct dentry *child)
         if (!inode)
                 return ERR_PTR(-EACCES);
 
+        if (is_bad_inode(inode)) {
+                iput(inode);
+                return ERR_PTR(-ENOENT);
+        }
+
         parent = d_alloc_anon(inode);
         if (!parent) {
                 iput(inode);
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 6e3062913a9..51d1c456cda 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -35,6 +35,7 @@
 #include <linux/namei.h>
 #include <linux/quotaops.h>
 #include <linux/seq_file.h>
+#include <linux/log2.h>
 
 #include <asm/uaccess.h>
 
@@ -459,6 +460,14 @@ static struct inode *ext3_alloc_inode(struct super_block *sb)
 
 static void ext3_destroy_inode(struct inode *inode)
 {
+        if (!list_empty(&(EXT3_I(inode)->i_orphan))) {
+                printk("EXT3 Inode %p: orphan list check failed!\n",
+                        EXT3_I(inode));
+                print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
+                                EXT3_I(inode), sizeof(struct ext3_inode_info),
+                                false);
+                dump_stack();
+        }
         kmem_cache_free(ext3_inode_cachep, EXT3_I(inode));
 }
 
@@ -1566,7 +1575,7 @@ static int ext3_fill_super (struct super_block *sb, void *data, int silent)
                 sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
                 sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
                 if ((sbi->s_inode_size < EXT3_GOOD_OLD_INODE_SIZE) ||
-                    (sbi->s_inode_size & (sbi->s_inode_size - 1)) ||
+                    (!is_power_of_2(sbi->s_inode_size)) ||
                     (sbi->s_inode_size > blocksize)) {
                         printk (KERN_ERR
                                 "EXT3-fs: unsupported inode size: %d\n",
@@ -2075,6 +2084,7 @@ static int ext3_create_journal(struct super_block * sb,
                                unsigned int journal_inum)
 {
         journal_t *journal;
+        int err;
 
         if (sb->s_flags & MS_RDONLY) {
                 printk(KERN_ERR "EXT3-fs: readonly filesystem when trying to "
@@ -2082,13 +2092,15 @@ static int ext3_create_journal(struct super_block * sb,
                 return -EROFS;
         }
 
-        if (!(journal = ext3_get_journal(sb, journal_inum)))
+        journal = ext3_get_journal(sb, journal_inum);
+        if (!journal)
                 return -EINVAL;
 
         printk(KERN_INFO "EXT3-fs: creating new journal on inode %u\n",
                journal_inum);
 
-        if (journal_create(journal)) {
+        err = journal_create(journal);
+        if (err) {
                 printk(KERN_ERR "EXT3-fs: error creating journal.\n");
                 journal_destroy(journal);
                 return -EIO;
@@ -2139,12 +2151,14 @@ static void ext3_mark_recovery_complete(struct super_block * sb,
 
         journal_lock_updates(journal);
         journal_flush(journal);
+        lock_super(sb);
         if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER) &&
             sb->s_flags & MS_RDONLY) {
                 EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
                 sb->s_dirt = 0;
                 ext3_commit_super(sb, es, 1);
         }
+        unlock_super(sb);
         journal_unlock_updates(journal);
 }
 
@@ -2333,7 +2347,13 @@ static int ext3_remount (struct super_block * sb, int * flags, char * data)
                             (sbi->s_mount_state & EXT3_VALID_FS))
                                 es->s_state = cpu_to_le16(sbi->s_mount_state);
 
+                        /*
+                         * We have to unlock super so that we can wait for
+                         * transactions.
+                         */
+                        unlock_super(sb);
                         ext3_mark_recovery_complete(sb, es);
+                        lock_super(sb);
                 } else {
                         __le32 ret;
                         if ((ret = EXT3_HAS_RO_COMPAT_FEATURE(sb,
@@ -2406,19 +2426,19 @@ static int ext3_statfs (struct dentry * dentry, struct kstatfs * buf)
         struct super_block *sb = dentry->d_sb;
         struct ext3_sb_info *sbi = EXT3_SB(sb);
         struct ext3_super_block *es = sbi->s_es;
-        ext3_fsblk_t overhead;
-        int i;
         u64 fsid;
 
-        if (test_opt (sb, MINIX_DF))
-                overhead = 0;
-        else {
-                unsigned long ngroups;
-                ngroups = EXT3_SB(sb)->s_groups_count;
+        if (test_opt(sb, MINIX_DF)) {
+                sbi->s_overhead_last = 0;
+        } else if (sbi->s_blocks_last != le32_to_cpu(es->s_blocks_count)) {
+                unsigned long ngroups = sbi->s_groups_count, i;
+                ext3_fsblk_t overhead = 0;
                 smp_rmb();
 
                 /*
-                 * Compute the overhead (FS structures)
+                 * Compute the overhead (FS structures).  This is constant
+                 * for a given filesystem unless the number of block groups
+                 * changes so we cache the previous value until it does.
                  */
 
                 /*
@@ -2442,18 +2462,23 @@ static int ext3_statfs (struct dentry * dentry, struct kstatfs * buf)
                  * Every block group has an inode bitmap, a block
                  * bitmap, and an inode table.
                  */
-                overhead += (ngroups * (2 + EXT3_SB(sb)->s_itb_per_group));
+                overhead += ngroups * (2 + sbi->s_itb_per_group);
+                sbi->s_overhead_last = overhead;
+                smp_wmb();
+                sbi->s_blocks_last = le32_to_cpu(es->s_blocks_count);
         }
 
         buf->f_type = EXT3_SUPER_MAGIC;
         buf->f_bsize = sb->s_blocksize;
-        buf->f_blocks = le32_to_cpu(es->s_blocks_count) - overhead;
+        buf->f_blocks = le32_to_cpu(es->s_blocks_count) - sbi->s_overhead_last;
         buf->f_bfree = percpu_counter_sum(&sbi->s_freeblocks_counter);
+        es->s_free_blocks_count = cpu_to_le32(buf->f_bfree);
         buf->f_bavail = buf->f_bfree - le32_to_cpu(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(es->s_inodes_count);
         buf->f_ffree = percpu_counter_sum(&sbi->s_freeinodes_counter);
+        es->s_free_inodes_count = cpu_to_le32(buf->f_ffree);
         buf->f_namelen = EXT3_NAME_LEN;
         fsid = le64_to_cpup((void *)es->s_uuid) ^
                le64_to_cpup((void *)es->s_uuid + sizeof(u64));
diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index 3b64bb16c72..9de54ae48de 100644
--- a/fs/ext4/balloc.c
+++ b/fs/ext4/balloc.c
@@ -1585,7 +1585,7 @@ allocated:
         ret_block = grp_alloc_blk + ext4_group_first_block_no(sb, group_no);
 
         if (in_range(ext4_block_bitmap(sb, gdp), ret_block, num) ||
-            in_range(ext4_block_bitmap(sb, gdp), ret_block, num) ||
+            in_range(ext4_inode_bitmap(sb, gdp), ret_block, num) ||
             in_range(ret_block, ext4_inode_table(sb, gdp),
                      EXT4_SB(sb)->s_itb_per_group) ||
             in_range(ret_block + num - 1, ext4_inode_table(sb, gdp),
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index 2811e5720ad..2de339dd755 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -1017,6 +1017,11 @@ static struct dentry *ext4_lookup(struct inode * dir, struct dentry *dentry, str
 
                 if (!inode)
                         return ERR_PTR(-EACCES);
+
+                if (is_bad_inode(inode)) {
+                        iput(inode);
+                        return ERR_PTR(-ENOENT);
+                }
         }
         return d_splice_alias(inode, dentry);
 }
@@ -1052,6 +1057,11 @@ struct dentry *ext4_get_parent(struct dentry *child)
         if (!inode)
                 return ERR_PTR(-EACCES);
 
+        if (is_bad_inode(inode)) {
+                iput(inode);
+                return ERR_PTR(-ENOENT);
+        }
+
         parent = d_alloc_anon(inode);
         if (!parent) {
                 iput(inode);
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 175b68c6096..d0d8c76c7ed 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -510,6 +510,14 @@ static struct inode *ext4_alloc_inode(struct super_block *sb)
 
 static void ext4_destroy_inode(struct inode *inode)
 {
+        if (!list_empty(&(EXT4_I(inode)->i_orphan))) {
+                printk("EXT4 Inode %p: orphan list check failed!\n",
+                        EXT4_I(inode));
+                print_hex_dump(KERN_INFO, "", DUMP_PREFIX_ADDRESS, 16, 4,
+                                EXT4_I(inode), sizeof(struct ext4_inode_info),
+                                true);
+                dump_stack();
+        }
         kmem_cache_free(ext4_inode_cachep, EXT4_I(inode));
 }
 
@@ -2150,6 +2158,7 @@ static int ext4_create_journal(struct super_block * sb,
                                unsigned int journal_inum)
 {
         journal_t *journal;
+        int err;
 
         if (sb->s_flags & MS_RDONLY) {
                 printk(KERN_ERR "EXT4-fs: readonly filesystem when trying to "
@@ -2157,13 +2166,15 @@ static int ext4_create_journal(struct super_block * sb,
                 return -EROFS;
         }
 
-        if (!(journal = ext4_get_journal(sb, journal_inum)))
+        journal = ext4_get_journal(sb, journal_inum);
+        if (!journal)
                 return -EINVAL;
 
         printk(KERN_INFO "EXT4-fs: creating new journal on inode %u\n",
                journal_inum);
 
-        if (jbd2_journal_create(journal)) {
+        err = jbd2_journal_create(journal);
+        if (err) {
                 printk(KERN_ERR "EXT4-fs: error creating journal.\n");
                 jbd2_journal_destroy(journal);
                 return -EIO;
@@ -2214,12 +2225,14 @@ static void ext4_mark_recovery_complete(struct super_block * sb,
 
         jbd2_journal_lock_updates(journal);
         jbd2_journal_flush(journal);
+        lock_super(sb);
         if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER) &&
             sb->s_flags & MS_RDONLY) {
                 EXT4_CLEAR_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_RECOVER);
                 sb->s_dirt = 0;
                 ext4_commit_super(sb, es, 1);
         }
+        unlock_super(sb);
         jbd2_journal_unlock_updates(journal);
 }
 
@@ -2408,7 +2421,13 @@ static int ext4_remount (struct super_block * sb, int * flags, char * data)
                             (sbi->s_mount_state & EXT4_VALID_FS))
                                 es->s_state = cpu_to_le16(sbi->s_mount_state);
 
+                        /*
+                         * We have to unlock super so that we can wait for
+                         * transactions.
+                         */
+                        unlock_super(sb);
                         ext4_mark_recovery_complete(sb, es);
+                        lock_super(sb);
                 } else {
                         __le32 ret;
                         if ((ret = EXT4_HAS_RO_COMPAT_FEATURE(sb,
@@ -2481,19 +2500,19 @@ static int ext4_statfs (struct dentry * dentry, struct kstatfs * buf)
         struct super_block *sb = dentry->d_sb;
         struct ext4_sb_info *sbi = EXT4_SB(sb);
         struct ext4_super_block *es = sbi->s_es;
-        ext4_fsblk_t overhead;
-        int i;
         u64 fsid;
 
-        if (test_opt (sb, MINIX_DF))
-                overhead = 0;
-        else {
-                unsigned long ngroups;
-                ngroups = EXT4_SB(sb)->s_groups_count;
+        if (test_opt(sb, MINIX_DF)) {
+                sbi->s_overhead_last = 0;
+        } else if (sbi->s_blocks_last != le32_to_cpu(es->s_blocks_count)) {
+                unsigned long ngroups = sbi->s_groups_count, i;
+                ext4_fsblk_t overhead = 0;
                 smp_rmb();
 
                 /*
-                 * Compute the overhead (FS structures)
+                 * Compute the overhead (FS structures).  This is constant
+                 * for a given filesystem unless the number of block groups
+                 * changes so we cache the previous value until it does.
                  */
 
                 /*
@@ -2517,18 +2536,23 @@ static int ext4_statfs (struct dentry * dentry, struct kstatfs * buf)
                  * Every block group has an inode bitmap, a block
                  * bitmap, and an inode table.
                  */
-                overhead += (ngroups * (2 + EXT4_SB(sb)->s_itb_per_group));
+                overhead += ngroups * (2 + sbi->s_itb_per_group);
+                sbi->s_overhead_last = overhead;
+                smp_wmb();
+                sbi->s_blocks_last = le32_to_cpu(es->s_blocks_count);
         }
 
         buf->f_type = EXT4_SUPER_MAGIC;
         buf->f_bsize = sb->s_blocksize;
-        buf->f_blocks = ext4_blocks_count(es) - overhead;
+        buf->f_blocks = ext4_blocks_count(es) - sbi->s_overhead_last;
         buf->f_bfree = percpu_counter_sum(&sbi->s_freeblocks_counter);
+        es->s_free_blocks_count = cpu_to_le32(buf->f_bfree);
         buf->f_bavail = buf->f_bfree - ext4_r_blocks_count(es);
         if (buf->f_bfree < ext4_r_blocks_count(es))
                 buf->f_bavail = 0;
         buf->f_files = le32_to_cpu(es->s_inodes_count);
         buf->f_ffree = percpu_counter_sum(&sbi->s_freeinodes_counter);
+        es->s_free_inodes_count = cpu_to_le32(buf->f_ffree);
         buf->f_namelen = EXT4_NAME_LEN;
         fsid = le64_to_cpup((void *)es->s_uuid) ^
                le64_to_cpup((void *)es->s_uuid + sizeof(u64));
diff --git a/fs/fat/dir.c b/fs/fat/dir.c
index ccf161dffb6..72cbcd61bd9 100644
--- a/fs/fat/dir.c
+++ b/fs/fat/dir.c
@@ -313,7 +313,7 @@ int fat_search_long(struct inode *inode, const unsigned char *name,
         wchar_t bufuname[14];
         unsigned char xlate_len, nr_slots;
         wchar_t *unicode = NULL;
-        unsigned char work[8], bufname[260];    /* 256 + 4 */
+        unsigned char work[MSDOS_NAME], bufname[260];   /* 256 + 4 */
         int uni_xlate = sbi->options.unicode_xlate;
         int utf8 = sbi->options.utf8;
         int anycase = (sbi->options.name_check != 's');
@@ -351,7 +351,8 @@ parse_record:
                 if (work[0] == 0x05)
                         work[0] = 0xE5;
                 for (i = 0, j = 0, last_u = 0; i < 8;) {
-                        if (!work[i]) break;
+                        if (!work[i])
+                                break;
                         chl = fat_shortname2uni(nls_disk, &work[i], 8 - i,
                                                 &bufuname[j++], opt_shortname,
                                                 de->lcase & CASE_LOWER_BASE);
@@ -365,13 +366,15 @@ parse_record:
                 }
                 j = last_u;
                 fat_short2uni(nls_disk, ".", 1, &bufuname[j++]);
-                for (i = 0; i < 3;) {
-                        if (!de->ext[i]) break;
-                        chl = fat_shortname2uni(nls_disk, &de->ext[i], 3 - i,
+                for (i = 8; i < MSDOS_NAME;) {
+                        if (!work[i])
+                                break;
+                        chl = fat_shortname2uni(nls_disk, &work[i],
+                                                MSDOS_NAME - i,
                                                 &bufuname[j++], opt_shortname,
                                                 de->lcase & CASE_LOWER_EXT);
                         if (chl <= 1) {
-                                if (de->ext[i] != ' ')
+                                if (work[i] != ' ')
                                         last_u = j;
                         } else {
                                 last_u = j;
@@ -445,7 +448,7 @@ static int __fat_readdir(struct inode *inode, struct file *filp, void *dirent,
         int fill_len;
         wchar_t bufuname[14];
         wchar_t *unicode = NULL;
-        unsigned char c, work[8], bufname[56], *ptname = bufname;
+        unsigned char c, work[MSDOS_NAME], bufname[56], *ptname = bufname;
         unsigned long lpos, dummy, *furrfu = &lpos;
         int uni_xlate = sbi->options.unicode_xlate;
         int isvfat = sbi->options.isvfat;
@@ -527,7 +530,8 @@ parse_record:
         if (work[0] == 0x05)
                 work[0] = 0xE5;
         for (i = 0, j = 0, last = 0, last_u = 0; i < 8;) {
-                if (!(c = work[i])) break;
+                if (!(c = work[i]))
+                        break;
                 chl = fat_shortname2uni(nls_disk, &work[i], 8 - i,
                                         &bufuname[j++], opt_shortname,
                                         de->lcase & CASE_LOWER_BASE);
@@ -549,9 +553,10 @@ parse_record:
         j = last_u;
         fat_short2uni(nls_disk, ".", 1, &bufuname[j++]);
         ptname[i++] = '.';
-        for (i2 = 0; i2 < 3;) {
-                if (!(c = de->ext[i2])) break;
-                chl = fat_shortname2uni(nls_disk, &de->ext[i2], 3 - i2,
+        for (i2 = 8; i2 < MSDOS_NAME;) {
+                if (!(c = work[i2]))
+                        break;
+                chl = fat_shortname2uni(nls_disk, &work[i2], MSDOS_NAME - i2,
                                         &bufuname[j++], opt_shortname,
                                         de->lcase & CASE_LOWER_EXT);
                 if (chl <= 1) {
@@ -563,8 +568,8 @@ parse_record:
                         }
                 } else {
                         last_u = j;
-                        for (chi = 0; chi < chl && i2 < 3; chi++) {
-                                ptname[i++] = de->ext[i2++];
+                        for (chi = 0; chi < chl && i2 < MSDOS_NAME; chi++) {
+                                ptname[i++] = work[i2++];
                                 last = i;
                         }
                 }
diff --git a/fs/fat/fatent.c b/fs/fat/fatent.c
index ab171ea8e86..2c1b73fb82a 100644
--- a/fs/fat/fatent.c
+++ b/fs/fat/fatent.c
@@ -17,6 +17,8 @@ struct fatent_operations {
         int (*ent_next)(struct fat_entry *);
 };
 
+static DEFINE_SPINLOCK(fat12_entry_lock);
+
 static void fat12_ent_blocknr(struct super_block *sb, int entry,
                               int *offset, sector_t *blocknr)
 {
@@ -116,10 +118,13 @@ static int fat12_ent_get(struct fat_entry *fatent)
         u8 **ent12_p = fatent->u.ent12_p;
         int next;
 
+        spin_lock(&fat12_entry_lock);
         if (fatent->entry & 1)
                 next = (*ent12_p[0] >> 4) | (*ent12_p[1] << 4);
         else
                 next = (*ent12_p[1] << 8) | *ent12_p[0];
+        spin_unlock(&fat12_entry_lock);
+
         next &= 0x0fff;
         if (next >= BAD_FAT12)
                 next = FAT_ENT_EOF;
@@ -151,6 +156,7 @@ static void fat12_ent_put(struct fat_entry *fatent, int new)
         if (new == FAT_ENT_EOF)
                 new = EOF_FAT12;
 
+        spin_lock(&fat12_entry_lock);
         if (fatent->entry & 1) {
                 *ent12_p[0] = (new << 4) | (*ent12_p[0] & 0x0f);
                 *ent12_p[1] = new >> 4;
@@ -158,6 +164,7 @@ static void fat12_ent_put(struct fat_entry *fatent, int new)
                 *ent12_p[0] = new & 0xff;
                 *ent12_p[1] = (*ent12_p[1] & 0xf0) | (new >> 8);
         }
+        spin_unlock(&fat12_entry_lock);
 
         mark_buffer_dirty(fatent->bhs[0]);
         if (fatent->nr_bhs == 2)
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index 479722d8966..cfaf5877d98 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -354,8 +354,7 @@ static int fat_fill_inode(struct inode *inode, struct msdos_dir_entry *de)
         } else { /* not a directory */
                 inode->i_generation |= 1;
                 inode->i_mode = MSDOS_MKMODE(de->attr,
-                    ((sbi->options.showexec &&
-                        !is_exec(de->ext))
+                    ((sbi->options.showexec && !is_exec(de->name + 8))
                         ? S_IRUGO|S_IWUGO : S_IRWXUGO)
                     & ~sbi->options.fs_fmask) | S_IFREG;
                 MSDOS_I(inode)->i_start = le16_to_cpu(de->start);
diff --git a/fs/freevxfs/vxfs_dir.h b/fs/freevxfs/vxfs_dir.h
index 8a4dfef1dda..3c96d6e6397 100644
--- a/fs/freevxfs/vxfs_dir.h
+++ b/fs/freevxfs/vxfs_dir.h
@@ -80,7 +80,7 @@ struct vxfs_direct {
  *      a d_name with size len.
  */
 #define VXFS_DIRPAD             4
-#define VXFS_NAMEMIN            ((int)((struct vxfs_direct *)0)->d_name)
+#define VXFS_NAMEMIN            offsetof(struct vxfs_direct, d_name)
 #define VXFS_DIRROUND(len)      ((VXFS_DIRPAD + (len) - 1) & ~(VXFS_DIRPAD -1))
 #define VXFS_DIRLEN(len)        (VXFS_DIRROUND(VXFS_NAMEMIN + (len)))
 
diff --git a/fs/gfs2/eaops.c b/fs/gfs2/eaops.c
index c1f44009853..1ab3e9d7388 100644
--- a/fs/gfs2/eaops.c
+++ b/fs/gfs2/eaops.c
@@ -11,6 +11,7 @@
 #include <linux/spinlock.h>
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
+#include <linux/capability.h>
 #include <linux/xattr.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/lm_interface.h>
diff --git a/fs/hfsplus/btree.c b/fs/hfsplus/btree.c
index 90ebab753d3..050d29c0a5b 100644
--- a/fs/hfsplus/btree.c
+++ b/fs/hfsplus/btree.c
@@ -62,8 +62,10 @@ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id)
                 if ((HFSPLUS_SB(sb).flags & HFSPLUS_SB_HFSX) &&
                     (head->key_type == HFSPLUS_KEY_BINARY))
                         tree->keycmp = hfsplus_cat_bin_cmp_key;
-                else
+                else {
                         tree->keycmp = hfsplus_cat_case_cmp_key;
+                        HFSPLUS_SB(sb).flags |= HFSPLUS_SB_CASEFOLD;
+                }
         } else {
                 printk(KERN_ERR "hfs: unknown B*Tree requested\n");
                 goto fail_page;
diff --git a/fs/hfsplus/dir.c b/fs/hfsplus/dir.c
index 80b5682a227..1955ee61251 100644
--- a/fs/hfsplus/dir.c
+++ b/fs/hfsplus/dir.c
@@ -36,6 +36,8 @@ static struct dentry *hfsplus_lookup(struct inode *dir, struct dentry *dentry,
         u16 type;
 
         sb = dir->i_sb;
+
+        dentry->d_op = &hfsplus_dentry_operations;
         dentry->d_fsdata = NULL;
         hfs_find_init(HFSPLUS_SB(sb).cat_tree, &fd);
         hfsplus_cat_build_key(sb, fd.search_key, dir->i_ino, &dentry->d_name);
diff --git a/fs/hfsplus/hfsplus_fs.h b/fs/hfsplus/hfsplus_fs.h
index 3915635b447..d9f5eda6d03 100644
--- a/fs/hfsplus/hfsplus_fs.h
+++ b/fs/hfsplus/hfsplus_fs.h
@@ -150,6 +150,7 @@ struct hfsplus_sb_info {
 #define HFSPLUS_SB_NODECOMPOSE  0x0002
 #define HFSPLUS_SB_FORCE        0x0004
 #define HFSPLUS_SB_HFSX         0x0008
+#define HFSPLUS_SB_CASEFOLD     0x0010
 
 
 struct hfsplus_inode_info {
@@ -321,6 +322,7 @@ void hfsplus_file_truncate(struct inode *);
 /* inode.c */
 extern const struct address_space_operations hfsplus_aops;
 extern const struct address_space_operations hfsplus_btree_aops;
+extern struct dentry_operations hfsplus_dentry_operations;
 
 void hfsplus_inode_read_fork(struct inode *, struct hfsplus_fork_raw *);
 void hfsplus_inode_write_fork(struct inode *, struct hfsplus_fork_raw *);
@@ -353,6 +355,8 @@ int hfsplus_strcasecmp(const struct hfsplus_unistr *, const struct hfsplus_unist
 int hfsplus_strcmp(const struct hfsplus_unistr *, const struct hfsplus_unistr *);
 int hfsplus_uni2asc(struct super_block *, const struct hfsplus_unistr *, char *, int *);
 int hfsplus_asc2uni(struct super_block *, struct hfsplus_unistr *, const char *, int);
+int hfsplus_hash_dentry(struct dentry *dentry, struct qstr *str);
+int hfsplus_compare_dentry(struct dentry *dentry, struct qstr *s1, struct qstr *s2);
 
 /* wrapper.c */
 int hfsplus_read_wrapper(struct super_block *);
diff --git a/fs/hfsplus/inode.c b/fs/hfsplus/inode.c
index 409ce5429c9..6f7c662174d 100644
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -131,6 +131,11 @@ const struct address_space_operations hfsplus_aops = {
         .writepages     = hfsplus_writepages,
 };
 
+struct dentry_operations hfsplus_dentry_operations = {
+        .d_hash       = hfsplus_hash_dentry,
+        .d_compare    = hfsplus_compare_dentry,
+};
+
 static struct dentry *hfsplus_file_lookup(struct inode *dir, struct dentry *dentry,
                                           struct nameidata *nd)
 {
diff --git a/fs/hfsplus/super.c b/fs/hfsplus/super.c
index ebd1b380cbb..6d87a2a9534 100644
--- a/fs/hfsplus/super.c
+++ b/fs/hfsplus/super.c
@@ -283,11 +283,10 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
         struct nls_table *nls = NULL;
         int err = -EINVAL;
 
-        sbi = kmalloc(sizeof(struct hfsplus_sb_info), GFP_KERNEL);
+        sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
         if (!sbi)
                 return -ENOMEM;
 
-        memset(sbi, 0, sizeof(HFSPLUS_SB(sb)));
         sb->s_fs_info = sbi;
         INIT_HLIST_HEAD(&sbi->rsrc_inodes);
         hfsplus_fill_defaults(sbi);
@@ -381,6 +380,7 @@ static int hfsplus_fill_super(struct super_block *sb, void *data, int silent)
                 iput(root);
                 goto cleanup;
         }
+        sb->s_root->d_op = &hfsplus_dentry_operations;
 
         str.len = sizeof(HFSP_HIDDENDIR_NAME) - 1;
         str.name = HFSP_HIDDENDIR_NAME;
diff --git a/fs/hfsplus/unicode.c b/fs/hfsplus/unicode.c
index 689c8bd721f..9e10f9444b6 100644
--- a/fs/hfsplus/unicode.c
+++ b/fs/hfsplus/unicode.c
@@ -239,61 +239,201 @@ out:
         return res;
 }
 
-int hfsplus_asc2uni(struct super_block *sb, struct hfsplus_unistr *ustr, const char *astr, int len)
+/*
+ * Convert one or more ASCII characters into a single unicode character.
+ * Returns the number of ASCII characters corresponding to the unicode char.
+ */
+static inline int asc2unichar(struct super_block *sb, const char *astr, int len,
+                              wchar_t *uc)
 {
-        struct nls_table *nls = HFSPLUS_SB(sb).nls;
-        int size, off, decompose;
+        int size = HFSPLUS_SB(sb).nls->char2uni(astr, len, uc);
+        if (size <= 0) {
+                *uc = '?';
+                size = 1;
+        }
+        switch (*uc) {
+        case 0x2400:
+                *uc = 0;
+                break;
+        case ':':
+                *uc = '/';
+                break;
+        }
+        return size;
+}
+
+/* Decomposes a single unicode character. */
+static inline u16 *decompose_unichar(wchar_t uc, int *size)
+{
+        int off;
+
+        off = hfsplus_decompose_table[(uc >> 12) & 0xf];
+        if (off == 0 || off == 0xffff)
+                return NULL;
+
+        off = hfsplus_decompose_table[off + ((uc >> 8) & 0xf)];
+        if (!off)
+                return NULL;
+
+        off = hfsplus_decompose_table[off + ((uc >> 4) & 0xf)];
+        if (!off)
+                return NULL;
+
+        off = hfsplus_decompose_table[off + (uc & 0xf)];
+        *size = off & 3;
+        if (*size == 0)
+                return NULL;
+        return hfsplus_decompose_table + (off / 4);
+}
+
+int hfsplus_asc2uni(struct super_block *sb, struct hfsplus_unistr *ustr,
+                    const char *astr, int len)
+{
+        int size, dsize, decompose;
+        u16 *dstr, outlen = 0;
         wchar_t c;
-        u16 outlen = 0;
 
         decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);
-
         while (outlen < HFSPLUS_MAX_STRLEN && len > 0) {
-                size = nls->char2uni(astr, len, &c);
-                if (size <= 0) {
-                        c = '?';
-                        size = 1;
-                }
-                astr += size;
-                len -= size;
-                switch (c) {
-                case 0x2400:
-                        c = 0;
-                        break;
-                case ':':
-                        c = '/';
-                        break;
-                }
-                if (c >= 0xc0 && decompose) {
-                        off = hfsplus_decompose_table[(c >> 12) & 0xf];
-                        if (!off)
-                                goto done;
-                        if (off == 0xffff) {
-                                goto done;
-                        }
-                        off = hfsplus_decompose_table[off + ((c >> 8) & 0xf)];
-                        if (!off)
-                                goto done;
-                        off = hfsplus_decompose_table[off + ((c >> 4) & 0xf)];
-                        if (!off)
-                                goto done;
-                        off = hfsplus_decompose_table[off + (c & 0xf)];
-                        size = off & 3;
-                        if (!size)
-                                goto done;
-                        off /= 4;
-                        if (outlen + size > HFSPLUS_MAX_STRLEN)
+                size = asc2unichar(sb, astr, len, &c);
+
+                if (decompose && (dstr = decompose_unichar(c, &dsize))) {
+                        if (outlen + dsize > HFSPLUS_MAX_STRLEN)
                                 break;
                         do {
-                                ustr->unicode[outlen++] = cpu_to_be16(hfsplus_decompose_table[off++]);
-                        } while (--size > 0);
-                        continue;
-                }
-        done:
-                ustr->unicode[outlen++] = cpu_to_be16(c);
+                                ustr->unicode[outlen++] = cpu_to_be16(*dstr++);
+                        } while (--dsize > 0);
+                } else
+                        ustr->unicode[outlen++] = cpu_to_be16(c);
+
+                astr += size;
+                len -= size;
         }
         ustr->length = cpu_to_be16(outlen);
         if (len > 0)
                 return -ENAMETOOLONG;
         return 0;
 }
+
+/*
+ * Hash a string to an integer as appropriate for the HFS+ filesystem.
+ * Composed unicode characters are decomposed and case-folding is performed
+ * if the appropriate bits are (un)set on the superblock.
+ */
+int hfsplus_hash_dentry(struct dentry *dentry, struct qstr *str)
+{
+        struct super_block *sb = dentry->d_sb;
+        const char *astr;
+        const u16 *dstr;
+        int casefold, decompose, size, dsize, len;
+        unsigned long hash;
+        wchar_t c;
+        u16 c2;
+
+        casefold = (HFSPLUS_SB(sb).flags & HFSPLUS_SB_CASEFOLD);
+        decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);
+        hash = init_name_hash();
+        astr = str->name;
+        len = str->len;
+        while (len > 0) {
+                size = asc2unichar(sb, astr, len, &c);
+                astr += size;
+                len -= size;
+
+                if (decompose && (dstr = decompose_unichar(c, &dsize))) {
+                        do {
+                                c2 = *dstr++;
+                                if (!casefold || (c2 = case_fold(c2)))
+                                        hash = partial_name_hash(c2, hash);
+                        } while (--dsize > 0);
+                } else {
+                        c2 = c;
+                        if (!casefold || (c2 = case_fold(c2)))
+                                hash = partial_name_hash(c2, hash);
+                }
+        }
+        str->hash = end_name_hash(hash);
+
+        return 0;
+}
+
+/*
+ * Compare strings with HFS+ filename ordering.
+ * Composed unicode characters are decomposed and case-folding is performed
+ * if the appropriate bits are (un)set on the superblock.
+ */
+int hfsplus_compare_dentry(struct dentry *dentry, struct qstr *s1, struct qstr *s2)
+{
+        struct super_block *sb = dentry->d_sb;
+        int casefold, decompose, size;
+        int dsize1, dsize2, len1, len2;
+        const u16 *dstr1, *dstr2;
+        const char *astr1, *astr2;
+        u16 c1, c2;
+        wchar_t c;
+
+        casefold = (HFSPLUS_SB(sb).flags & HFSPLUS_SB_CASEFOLD);
+        decompose = !(HFSPLUS_SB(sb).flags & HFSPLUS_SB_NODECOMPOSE);
+        astr1 = s1->name;
+        len1 = s1->len;
+        astr2 = s2->name;
+        len2 = s2->len;
+        dsize1 = dsize2 = 0;
+        dstr1 = dstr2 = NULL;
+
+        while (len1 > 0 && len2 > 0) {
+                if (!dsize1) {
+                        size = asc2unichar(sb, astr1, len1, &c);
+                        astr1 += size;
+                        len1 -= size;
+
+                        if (!decompose || !(dstr1 = decompose_unichar(c, &dsize1))) {
+                                c1 = c;
+                                dstr1 = &c1;
+                                dsize1 = 1;
+                        }
+                }
+
+                if (!dsize2) {
+                        size = asc2unichar(sb, astr2, len2, &c);
+                        astr2 += size;
+                        len2 -= size;
+
+                        if (!decompose || !(dstr2 = decompose_unichar(c, &dsize2))) {
+                                c2 = c;
+                                dstr2 = &c2;
+                                dsize2 = 1;
+                        }
+                }
+
+                c1 = *dstr1;
+                c2 = *dstr2;
+                if (casefold) {
+                        if  (!(c1 = case_fold(c1))) {
+                                dstr1++;
+                                dsize1--;
+                                continue;
+                        }
+                        if (!(c2 = case_fold(c2))) {
+                                dstr2++;
+                                dsize2--;
+                                continue;
+                        }
+                }
+                if (c1 < c2)
+                        return -1;
+                else if (c1 > c2)
+                        return 1;
+
+                dstr1++;
+                dsize1--;
+                dstr2++;
+                dsize2--;
+        }
+
+        if (len1 < len2)
+                return -1;
+        if (len1 > len2)
+                return 1;
+        return 0;
+}
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index e6b46b3ac2f..d145cb79c30 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -13,15 +13,18 @@
 #include <linux/fs.h>
 #include <linux/mount.h>
 #include <linux/file.h>
+#include <linux/kernel.h>
 #include <linux/writeback.h>
 #include <linux/pagemap.h>
 #include <linux/highmem.h>
 #include <linux/init.h>
 #include <linux/string.h>
 #include <linux/capability.h>
+#include <linux/ctype.h>
 #include <linux/backing-dev.h>
 #include <linux/hugetlb.h>
 #include <linux/pagevec.h>
+#include <linux/parser.h>
 #include <linux/mman.h>
 #include <linux/quotaops.h>
 #include <linux/slab.h>
@@ -47,6 +50,21 @@ static struct backing_dev_info hugetlbfs_backing_dev_info = {
 
 int sysctl_hugetlb_shm_group;
 
+enum {
+        Opt_size, Opt_nr_inodes,
+        Opt_mode, Opt_uid, Opt_gid,
+        Opt_err,
+};
+
+static match_table_t tokens = {
+        {Opt_size,      "size=%s"},
+        {Opt_nr_inodes, "nr_inodes=%s"},
+        {Opt_mode,      "mode=%o"},
+        {Opt_uid,       "uid=%u"},
+        {Opt_gid,       "gid=%u"},
+        {Opt_err,       NULL},
+};
+
 static void huge_pagevec_release(struct pagevec *pvec)
 {
         int i;
@@ -594,46 +612,73 @@ static const struct super_operations hugetlbfs_ops = {
 static int
 hugetlbfs_parse_options(char *options, struct hugetlbfs_config *pconfig)
 {
-        char *opt, *value, *rest;
+        char *p, *rest;
+        substring_t args[MAX_OPT_ARGS];
+        int option;
 
         if (!options)
                 return 0;
-        while ((opt = strsep(&options, ",")) != NULL) {
-                if (!*opt)
+
+        while ((p = strsep(&options, ",")) != NULL) {
+                int token;
+                if (!*p)
                         continue;
 
-                value = strchr(opt, '=');
-                if (!value || !*value)
-                        return -EINVAL;
-                else
-                        *value++ = '\0';
-
-                if (!strcmp(opt, "uid"))
-                        pconfig->uid = simple_strtoul(value, &value, 0);
-                else if (!strcmp(opt, "gid"))
-                        pconfig->gid = simple_strtoul(value, &value, 0);
-                else if (!strcmp(opt, "mode"))
-                        pconfig->mode = simple_strtoul(value,&value,0) & 0777U;
-                else if (!strcmp(opt, "size")) {
-                        unsigned long long size = memparse(value, &rest);
+                token = match_token(p, tokens, args);
+                switch (token) {
+                case Opt_uid:
+                        if (match_int(&args[0], &option))
+                                goto bad_val;
+                        pconfig->uid = option;
+                        break;
+
+                case Opt_gid:
+                        if (match_int(&args[0], &option))
+                                goto bad_val;
+                        pconfig->gid = option;
+                        break;
+
+                case Opt_mode:
+                        if (match_octal(&args[0], &option))
+                                goto bad_val;
+                        pconfig->mode = option & 0777U;
+                        break;
+
+                case Opt_size: {
+                        unsigned long long size;
+                        /* memparse() will accept a K/M/G without a digit */
+                        if (!isdigit(*args[0].from))
+                                goto bad_val;
+                        size = memparse(args[0].from, &rest);
                         if (*rest == '%') {
                                 size <<= HPAGE_SHIFT;
                                 size *= max_huge_pages;
                                 do_div(size, 100);
-                                rest++;
                         }
                         pconfig->nr_blocks = (size >> HPAGE_SHIFT);
-                        value = rest;
-                } else if (!strcmp(opt,"nr_inodes")) {
-                        pconfig->nr_inodes = memparse(value, &rest);
-                        value = rest;
-                } else
-                        return -EINVAL;
+                        break;
+                }
+
+                case Opt_nr_inodes:
+                        /* memparse() will accept a K/M/G without a digit */
+                        if (!isdigit(*args[0].from))
+                                goto bad_val;
+                        pconfig->nr_inodes = memparse(args[0].from, &rest);
+                        break;
 
-                if (*value)
+                default:
+                        printk(KERN_ERR "hugetlbfs: Bad mount option: \"%s\"\n",
+                                 p);
                         return -EINVAL;
+                        break;
+                }
         }
         return 0;
+
+bad_val:
+        printk(KERN_ERR "hugetlbfs: Bad value '%s' for mount option '%s'\n",
+               args[0].from, p);
+        return 1;
 }
 
 static int
@@ -651,7 +696,6 @@ hugetlbfs_fill_super(struct super_block *sb, void *data, int silent)
         config.gid = current->fsgid;
         config.mode = 0755;
         ret = hugetlbfs_parse_options(data, &config);
-
         if (ret)
                 return ret;
 
diff --git a/fs/ioctl.c b/fs/ioctl.c
index 8c90cbc903f..c2a773e8620 100644
--- a/fs/ioctl.c
+++ b/fs/ioctl.c
@@ -12,7 +12,6 @@
 #include <linux/fs.h>
 #include <linux/security.h>
 #include <linux/module.h>
-#include <linux/kallsyms.h>
 
 #include <asm/uaccess.h>
 #include <asm/ioctls.h>
@@ -21,7 +20,6 @@ static long do_ioctl(struct file *filp, unsigned int cmd,
                 unsigned long arg)
 {
         int error = -ENOTTY;
-        void *f;
 
         if (!filp->f_op)
                 goto out;
@@ -31,16 +29,10 @@ static long do_ioctl(struct file *filp, unsigned int cmd,
                 if (error == -ENOIOCTLCMD)
                         error = -EINVAL;
                 goto out;
-        } else if ((f = filp->f_op->ioctl)) {
+        } else if (filp->f_op->ioctl) {
                 lock_kernel();
-                if (!filp->f_op->ioctl) {
-                        printk("%s: ioctl %p disappeared\n", __FUNCTION__, f);
-                        print_symbol("symbol: %s\n", (unsigned long)f);
-                        dump_stack();
-                } else {
-                        error = filp->f_op->ioctl(filp->f_path.dentry->d_inode,
-                                                  filp, cmd, arg);
-                }
+                error = filp->f_op->ioctl(filp->f_path.dentry->d_inode,
+                                          filp, cmd, arg);
                 unlock_kernel();
         }
 
@@ -182,11 +174,3 @@ asmlinkage long sys_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
  out:
         return error;
 }
-
-/*
- * Platforms implementing 32 bit compatibility ioctl handlers in
- * modules need this exported
- */
-#ifdef CONFIG_COMPAT
-EXPORT_SYMBOL(sys_ioctl);
-#endif
diff --git a/fs/isofs/dir.c b/fs/isofs/dir.c
index 0e94c31cad9..1ba407c64df 100644
--- a/fs/isofs/dir.c
+++ b/fs/isofs/dir.c
@@ -7,34 +7,18 @@
  *
  *  Steve Beynon                       : Missing last directory entries fixed
  *  (stephen@askone.demon.co.uk)      : 21st June 1996
- * 
+ *
  *  isofs directory handling functions
  */
 #include <linux/smp_lock.h>
 #include "isofs.h"
 
-static int isofs_readdir(struct file *, void *, filldir_t);
-
-const struct file_operations isofs_dir_operations =
-{
-        .read           = generic_read_dir,
-        .readdir        = isofs_readdir,
-};
-
-/*
- * directories can handle most operations...
- */
-const struct inode_operations isofs_dir_inode_operations =
-{
-        .lookup         = isofs_lookup,
-};
-
 int isofs_name_translate(struct iso_directory_record *de, char *new, struct inode *inode)
 {
         char * old = de->name;
         int len = de->name_len[0];
         int i;
-                        
+
         for (i = 0; i < len; i++) {
                 unsigned char c = old[i];
                 if (!c)
@@ -62,22 +46,27 @@ int isofs_name_translate(struct iso_directory_record *de, char *new, struct inod
 }
 
 /* Acorn extensions written by Matthew Wilcox <willy@bofh.ai> 1998 */
-int get_acorn_filename(struct iso_directory_record * de,
-                            char * retname, struct inode * inode)
+int get_acorn_filename(struct iso_directory_record *de,
+                            char *retname, struct inode *inode)
 {
         int std;
-        unsigned char * chr;
+        unsigned char *chr;
         int retnamlen = isofs_name_translate(de, retname, inode);
-        if (retnamlen == 0) return 0;
+
+        if (retnamlen == 0)
+                return 0;
         std = sizeof(struct iso_directory_record) + de->name_len[0];
-        if (std & 1) std++;
-        if ((*((unsigned char *) de) - std) != 32) return retnamlen;
+        if (std & 1)
+                std++;
+        if ((*((unsigned char *) de) - std) != 32)
+                return retnamlen;
         chr = ((unsigned char *) de) + std;
-        if (strncmp(chr, "ARCHIMEDES", 10)) return retnamlen;
-        if ((*retname == '_') && ((chr[19] & 1) == 1)) *retname = '!';
+        if (strncmp(chr, "ARCHIMEDES", 10))
+                return retnamlen;
+        if ((*retname == '_') && ((chr[19] & 1) == 1))
+                *retname = '!';
         if (((de->flags[0] & 2) == 0) && (chr[13] == 0xff)
-                && ((chr[12] & 0xf0) == 0xf0))
-        {
+                && ((chr[12] & 0xf0) == 0xf0)) {
                 retname[retnamlen] = ',';
                 sprintf(retname+retnamlen+1, "%3.3x",
                         ((chr[12] & 0xf) << 8) | chr[11]);
@@ -91,7 +80,7 @@ int get_acorn_filename(struct iso_directory_record * de,
  */
 static int do_isofs_readdir(struct inode *inode, struct file *filp,
                 void *dirent, filldir_t filldir,
-                char * tmpname, struct iso_directory_record * tmpde)
+                char *tmpname, struct iso_directory_record *tmpde)
 {
         unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
         unsigned char bufbits = ISOFS_BUFFER_BITS(inode);
@@ -121,9 +110,11 @@ static int do_isofs_readdir(struct inode *inode, struct file *filp,
 
                 de_len = *(unsigned char *) de;
 
-                /* If the length byte is zero, we should move on to the next
-                   CDROM sector.  If we are at the end of the directory, we
-                   kick out of the while loop. */
+                /*
+                 * If the length byte is zero, we should move on to the next
+                 * CDROM sector.  If we are at the end of the directory, we
+                 * kick out of the while loop.
+                 */
 
                 if (de_len == 0) {
                         brelse(bh);
@@ -157,11 +148,10 @@ static int do_isofs_readdir(struct inode *inode, struct file *filp,
 
                 if (first_de) {
                         isofs_normalize_block_and_offset(de,
-                                                         &block_saved,
-                                                         &offset_saved);
+                                                        &block_saved,
+                                                        &offset_saved);
                         inode_number = isofs_get_ino(block_saved,
-                                                     offset_saved,
-                                                     bufbits);
+                                                        offset_saved, bufbits);
                 }
 
                 if (de->flags[-sbi->s_high_sierra] & 0x80) {
@@ -199,7 +189,7 @@ static int do_isofs_readdir(struct inode *inode, struct file *filp,
                  */
                 if ((sbi->s_hide == 'y' &&
                                 (de->flags[-sbi->s_high_sierra] & 1)) ||
-                      (sbi->s_showassoc =='n' &&
+                                (sbi->s_showassoc =='n' &&
                                 (de->flags[-sbi->s_high_sierra] & 4))) {
                         filp->f_pos += de_len;
                         continue;
@@ -240,7 +230,8 @@ static int do_isofs_readdir(struct inode *inode, struct file *filp,
 
                 continue;
         }
-        if (bh) brelse(bh);
+        if (bh)
+                brelse(bh);
         return 0;
 }
 
@@ -253,8 +244,8 @@ static int isofs_readdir(struct file *filp,
                 void *dirent, filldir_t filldir)
 {
         int result;
-        char * tmpname;
-        struct iso_directory_record * tmpde;
+        char *tmpname;
+        struct iso_directory_record *tmpde;
         struct inode *inode = filp->f_path.dentry->d_inode;
 
         tmpname = (char *)__get_free_page(GFP_KERNEL);
@@ -270,3 +261,19 @@ static int isofs_readdir(struct file *filp,
         unlock_kernel();
         return result;
 }
+
+const struct file_operations isofs_dir_operations =
+{
+        .read = generic_read_dir,
+        .readdir = isofs_readdir,
+};
+
+/*
+ * directories can handle most operations...
+ */
+const struct inode_operations isofs_dir_inode_operations =
+{
+        .lookup = isofs_lookup,
+};
+
+
diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index 5c3eecf7542..4f5418be059 100644
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -73,20 +73,20 @@ static void isofs_destroy_inode(struct inode *inode)
         kmem_cache_free(isofs_inode_cachep, ISOFS_I(inode));
 }
 
-static void init_once(void *foo, struct kmem_cache * cachep, unsigned long flags)
+static void init_once(void *foo, struct kmem_cache *cachep, unsigned long flags)
 {
         struct iso_inode_info *ei = foo;
 
         inode_init_once(&ei->vfs_inode);
 }
- 
+
 static int init_inodecache(void)
 {
         isofs_inode_cachep = kmem_cache_create("isofs_inode_cache",
-                                             sizeof(struct iso_inode_info),
-                                             0, (SLAB_RECLAIM_ACCOUNT|
-                                                SLAB_MEM_SPREAD),
-                                             init_once, NULL);
+                                        sizeof(struct iso_inode_info),
+                                        0, (SLAB_RECLAIM_ACCOUNT|
+                                        SLAB_MEM_SPREAD),
+                                        init_once, NULL);
         if (isofs_inode_cachep == NULL)
                 return -ENOMEM;
         return 0;
@@ -150,9 +150,9 @@ struct iso9660_options{
         uid_t uid;
         char *iocharset;
         unsigned char utf8;
-        /* LVE */
-        s32 session;
-        s32 sbsector;
+        /* LVE */
+        s32 session;
+        s32 sbsector;
 };
 
 /*
@@ -197,7 +197,7 @@ isofs_hashi_common(struct dentry *dentry, struct qstr *qstr, int ms)
         hash = init_name_hash();
         while (len--) {
                 c = tolower(*name++);
-                hash = partial_name_hash(tolower(c), hash);
+                hash = partial_name_hash(c, hash);
         }
         qstr->hash = end_name_hash(hash);
 
@@ -360,10 +360,12 @@ static int parse_options(char *options, struct iso9660_options *popt)
         popt->check = 'u';              /* unset */
         popt->nocompress = 0;
         popt->blocksize = 1024;
-        popt->mode = S_IRUGO | S_IXUGO; /* r-x for all.  The disc could
-                                           be shared with DOS machines so
-                                           virtually anything could be
-                                           a valid executable. */
+        popt->mode = S_IRUGO | S_IXUGO; /*
+                                         * r-x for all.  The disc could
+                                         * be shared with DOS machines so
+                                         * virtually anything could be
+                                         * a valid executable.
+                                         */
         popt->gid = 0;
         popt->uid = 0;
         popt->iocharset = NULL;
@@ -503,30 +505,30 @@ static unsigned int isofs_get_last_session(struct super_block *sb, s32 session)
                 Te.cdte_format=CDROM_LBA;
                 i = ioctl_by_bdev(bdev, CDROMREADTOCENTRY, (unsigned long) &Te);
                 if (!i) {
-                        printk(KERN_DEBUG "Session %d start %d type %d\n",
-                               session, Te.cdte_addr.lba,
-                               Te.cdte_ctrl&CDROM_DATA_TRACK);
+                        printk(KERN_DEBUG "ISOFS: Session %d start %d type %d\n",
+                                session, Te.cdte_addr.lba,
+                                Te.cdte_ctrl&CDROM_DATA_TRACK);
                         if ((Te.cdte_ctrl&CDROM_DATA_TRACK) == 4)
                                 return Te.cdte_addr.lba;
                 }
-                        
-                printk(KERN_ERR "Invalid session number or type of track\n");
+
+                printk(KERN_ERR "ISOFS: Invalid session number or type of track\n");
         }
         i = ioctl_by_bdev(bdev, CDROMMULTISESSION, (unsigned long) &ms_info);
         if (session > 0)
-                printk(KERN_ERR "Invalid session number\n");
+                printk(KERN_ERR "ISOFS: Invalid session number\n");
 #if 0
-        printk("isofs.inode: CDROMMULTISESSION: rc=%d\n",i);
+        printk(KERN_DEBUG "isofs.inode: CDROMMULTISESSION: rc=%d\n",i);
         if (i==0) {
-                printk("isofs.inode: XA disk: %s\n",ms_info.xa_flag?"yes":"no");
-                printk("isofs.inode: vol_desc_start = %d\n", ms_info.addr.lba);
+                printk(KERN_DEBUG "isofs.inode: XA disk: %s\n",ms_info.xa_flag?"yes":"no");
+                printk(KERN_DEBUG "isofs.inode: vol_desc_start = %d\n", ms_info.addr.lba);
         }
 #endif
         if (i==0)
 #if WE_OBEY_THE_WRITTEN_STANDARDS
-        if (ms_info.xa_flag) /* necessary for a valid ms_info.addr */
+                if (ms_info.xa_flag) /* necessary for a valid ms_info.addr */
 #endif
-                vol_desc_start=ms_info.addr.lba;
+                        vol_desc_start=ms_info.addr.lba;
         return vol_desc_start;
 }
 
@@ -538,20 +540,20 @@ static unsigned int isofs_get_last_session(struct super_block *sb, s32 session)
  */
 static int isofs_fill_super(struct super_block *s, void *data, int silent)
 {
-        struct buffer_head            * bh = NULL, *pri_bh = NULL;
-        struct hs_primary_descriptor  * h_pri = NULL;
-        struct iso_primary_descriptor * pri = NULL;
+        struct buffer_head *bh = NULL, *pri_bh = NULL;
+        struct hs_primary_descriptor *h_pri = NULL;
+        struct iso_primary_descriptor *pri = NULL;
         struct iso_supplementary_descriptor *sec = NULL;
-        struct iso_directory_record   * rootp;
-        int                             joliet_level = 0;
-        int                             iso_blknum, block;
-        int                             orig_zonesize;
-        int                             table;
-        unsigned int                    vol_desc_start;
-        unsigned long                   first_data_zone;
-        struct inode                  * inode;
-        struct iso9660_options          opt;
-        struct isofs_sb_info          * sbi;
+        struct iso_directory_record *rootp;
+        struct inode *inode;
+        struct iso9660_options opt;
+        struct isofs_sb_info *sbi;
+        unsigned long first_data_zone;
+        int joliet_level = 0;
+        int iso_blknum, block;
+        int orig_zonesize;
+        int table;
+        unsigned int vol_desc_start;
 
         sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
         if (!sbi)
@@ -577,72 +579,73 @@ static int isofs_fill_super(struct super_block *s, void *data, int silent)
         vol_desc_start = (opt.sbsector != -1) ?
                 opt.sbsector : isofs_get_last_session(s,opt.session);
 
-        for (iso_blknum = vol_desc_start+16;
-             iso_blknum < vol_desc_start+100; iso_blknum++)
-        {
-            struct hs_volume_descriptor   * hdp;
-            struct iso_volume_descriptor  * vdp;
-
-            block = iso_blknum << (ISOFS_BLOCK_BITS - s->s_blocksize_bits);
-            if (!(bh = sb_bread(s, block)))
-                goto out_no_read;
-
-            vdp = (struct iso_volume_descriptor *)bh->b_data;
-            hdp = (struct hs_volume_descriptor *)bh->b_data;
-            
-            /* Due to the overlapping physical location of the descriptors, 
-             * ISO CDs can match hdp->id==HS_STANDARD_ID as well. To ensure 
-             * proper identification in this case, we first check for ISO.
-             */
-            if (strncmp (vdp->id, ISO_STANDARD_ID, sizeof vdp->id) == 0) {
-                if (isonum_711 (vdp->type) == ISO_VD_END)
-                    break;
-                if (isonum_711 (vdp->type) == ISO_VD_PRIMARY) {
-                    if (pri == NULL) {
-                        pri = (struct iso_primary_descriptor *)vdp;
-                        /* Save the buffer in case we need it ... */
-                        pri_bh = bh;
-                        bh = NULL;
-                    }
-                }
+        for (iso_blknum = vol_desc_start+16;
+                iso_blknum < vol_desc_start+100; iso_blknum++) {
+                struct hs_volume_descriptor *hdp;
+                struct iso_volume_descriptor  *vdp;
+
+                block = iso_blknum << (ISOFS_BLOCK_BITS - s->s_blocksize_bits);
+                if (!(bh = sb_bread(s, block)))
+                        goto out_no_read;
+
+                vdp = (struct iso_volume_descriptor *)bh->b_data;
+                hdp = (struct hs_volume_descriptor *)bh->b_data;
+
+                /*
+                 * Due to the overlapping physical location of the descriptors,
+                 * ISO CDs can match hdp->id==HS_STANDARD_ID as well. To ensure
+                 * proper identification in this case, we first check for ISO.
+                 */
+                if (strncmp (vdp->id, ISO_STANDARD_ID, sizeof vdp->id) == 0) {
+                        if (isonum_711(vdp->type) == ISO_VD_END)
+                                break;
+                        if (isonum_711(vdp->type) == ISO_VD_PRIMARY) {
+                                if (pri == NULL) {
+                                        pri = (struct iso_primary_descriptor *)vdp;
+                                        /* Save the buffer in case we need it ... */
+                                        pri_bh = bh;
+                                        bh = NULL;
+                                }
+                        }
 #ifdef CONFIG_JOLIET
-                else if (isonum_711 (vdp->type) == ISO_VD_SUPPLEMENTARY) {
-                    sec = (struct iso_supplementary_descriptor *)vdp;
-                    if (sec->escape[0] == 0x25 && sec->escape[1] == 0x2f) {
-                        if (opt.joliet == 'y') {
-                            if (sec->escape[2] == 0x40) {
-                                joliet_level = 1;
-                            } else if (sec->escape[2] == 0x43) {
-                                joliet_level = 2;
-                            } else if (sec->escape[2] == 0x45) {
-                                joliet_level = 3;
-                            }
-                            printk(KERN_DEBUG"ISO 9660 Extensions: Microsoft Joliet Level %d\n",
-                                   joliet_level);
+                        else if (isonum_711(vdp->type) == ISO_VD_SUPPLEMENTARY) {
+                                sec = (struct iso_supplementary_descriptor *)vdp;
+                                if (sec->escape[0] == 0x25 && sec->escape[1] == 0x2f) {
+                                        if (opt.joliet == 'y') {
+                                                if (sec->escape[2] == 0x40)
+                                                        joliet_level = 1;
+                                                else if (sec->escape[2] == 0x43)
+                                                        joliet_level = 2;
+                                                else if (sec->escape[2] == 0x45)
+                                                        joliet_level = 3;
+
+                                                printk(KERN_DEBUG "ISO 9660 Extensions: "
+                                                        "Microsoft Joliet Level %d\n",
+                                                        joliet_level);
+                                        }
+                                        goto root_found;
+                                } else {
+                                /* Unknown supplementary volume descriptor */
+                                sec = NULL;
+                                }
                         }
-                        goto root_found;
-                    } else {
-                        /* Unknown supplementary volume descriptor */
-                        sec = NULL;
-                    }
-                }
 #endif
-            } else {
-                if (strncmp (hdp->id, HS_STANDARD_ID, sizeof hdp->id) == 0) {
-                    if (isonum_711 (hdp->type) != ISO_VD_PRIMARY)
-                        goto out_freebh;
-                
-                    sbi->s_high_sierra = 1;
-                    opt.rock = 'n';
-                    h_pri = (struct hs_primary_descriptor *)vdp;
-                    goto root_found;
+                } else {
+                        if (strncmp (hdp->id, HS_STANDARD_ID, sizeof hdp->id) == 0) {
+                                if (isonum_711(hdp->type) != ISO_VD_PRIMARY)
+                                        goto out_freebh;
+
+                                sbi->s_high_sierra = 1;
+                                opt.rock = 'n';
+                                h_pri = (struct hs_primary_descriptor *)vdp;
+                                goto root_found;
+                        }
                 }
-            }
 
-            /* Just skip any volume descriptors we don't recognize */
+                /* Just skip any volume descriptors we don't recognize */
 
-            brelse(bh);
-            bh = NULL;
+                brelse(bh);
+                bh = NULL;
         }
         /*
          * If we fall through, either no volume descriptor was found,
@@ -657,24 +660,24 @@ static int isofs_fill_super(struct super_block *s, void *data, int silent)
 root_found:
 
         if (joliet_level && (pri == NULL || opt.rock == 'n')) {
-            /* This is the case of Joliet with the norock mount flag.
-             * A disc with both Joliet and Rock Ridge is handled later
-             */
-            pri = (struct iso_primary_descriptor *) sec;
+                /* This is the case of Joliet with the norock mount flag.
+                 * A disc with both Joliet and Rock Ridge is handled later
+                 */
+                pri = (struct iso_primary_descriptor *) sec;
         }
 
         if(sbi->s_high_sierra){
-          rootp = (struct iso_directory_record *) h_pri->root_directory_record;
-          sbi->s_nzones = isonum_733 (h_pri->volume_space_size);
-          sbi->s_log_zone_size = isonum_723 (h_pri->logical_block_size);
-          sbi->s_max_size = isonum_733(h_pri->volume_space_size);
+                rootp = (struct iso_directory_record *) h_pri->root_directory_record;
+                sbi->s_nzones = isonum_733(h_pri->volume_space_size);
+                sbi->s_log_zone_size = isonum_723(h_pri->logical_block_size);
+                sbi->s_max_size = isonum_733(h_pri->volume_space_size);
         } else {
-          if (!pri)
-            goto out_freebh;
-          rootp = (struct iso_directory_record *) pri->root_directory_record;
-          sbi->s_nzones = isonum_733 (pri->volume_space_size);
-          sbi->s_log_zone_size = isonum_723 (pri->logical_block_size);
-          sbi->s_max_size = isonum_733(pri->volume_space_size);
+                if (!pri)
+                        goto out_freebh;
+                rootp = (struct iso_directory_record *) pri->root_directory_record;
+                sbi->s_nzones = isonum_733(pri->volume_space_size);
+                sbi->s_log_zone_size = isonum_723(pri->logical_block_size);
+                sbi->s_max_size = isonum_733(pri->volume_space_size);
         }
 
         sbi->s_ninodes = 0; /* No way to figure this out easily */
@@ -687,42 +690,43 @@ root_found:
          * blocks that were 512 bytes (which should only very rarely
          * happen.)
          */
-        if(orig_zonesize < opt.blocksize)
+        if (orig_zonesize < opt.blocksize)
                 goto out_bad_size;
 
         /* RDE: convert log zone size to bit shift */
-        switch (sbi->s_log_zone_size)
-          { case  512: sbi->s_log_zone_size =  9; break;
-            case 1024: sbi->s_log_zone_size = 10; break;
-            case 2048: sbi->s_log_zone_size = 11; break;
+        switch (sbi->s_log_zone_size) {
+        case  512: sbi->s_log_zone_size =  9; break;
+        case 1024: sbi->s_log_zone_size = 10; break;
+        case 2048: sbi->s_log_zone_size = 11; break;
 
-            default:
+        default:
                 goto out_bad_zone_size;
-          }
+        }
 
         s->s_magic = ISOFS_SUPER_MAGIC;
         s->s_maxbytes = 0xffffffff; /* We can handle files up to 4 GB */
 
-        /* The CDROM is read-only, has no nodes (devices) on it, and since
-           all of the files appear to be owned by root, we really do not want
-           to allow suid.  (suid or devices will not show up unless we have
-           Rock Ridge extensions) */
+        /*
+         * The CDROM is read-only, has no nodes (devices) on it, and since
+         * all of the files appear to be owned by root, we really do not want
+         * to allow suid.  (suid or devices will not show up unless we have
+         * Rock Ridge extensions)
+         */
 
         s->s_flags |= MS_RDONLY /* | MS_NODEV | MS_NOSUID */;
 
         /* Set this for reference. Its not currently used except on write
            which we don't have .. */
-           
-        first_data_zone = isonum_733 (rootp->extent) +
-                          isonum_711 (rootp->ext_attr_length);
+
+        first_data_zone = isonum_733(rootp->extent) +
+                          isonum_711(rootp->ext_attr_length);
         sbi->s_firstdatazone = first_data_zone;
 #ifndef BEQUIET
-        printk(KERN_DEBUG "Max size:%ld   Log zone size:%ld\n",
-               sbi->s_max_size,
-               1UL << sbi->s_log_zone_size);
-        printk(KERN_DEBUG "First datazone:%ld\n", sbi->s_firstdatazone);
+        printk(KERN_DEBUG "ISOFS: Max size:%ld   Log zone size:%ld\n",
+                sbi->s_max_size, 1UL << sbi->s_log_zone_size);
+        printk(KERN_DEBUG "ISOFS: First datazone:%ld\n", sbi->s_firstdatazone);
         if(sbi->s_high_sierra)
-                printk(KERN_DEBUG "Disc in High Sierra format.\n");
+                printk(KERN_DEBUG "ISOFS: Disc in High Sierra format.\n");
 #endif
 
         /*
@@ -737,8 +741,8 @@ root_found:
                 pri = (struct iso_primary_descriptor *) sec;
                 rootp = (struct iso_directory_record *)
                         pri->root_directory_record;
-                first_data_zone = isonum_733 (rootp->extent) +
-                                isonum_711 (rootp->ext_attr_length);
+                first_data_zone = isonum_733(rootp->extent) +
+                                isonum_711(rootp->ext_attr_length);
         }
 
         /*
@@ -771,7 +775,7 @@ root_found:
 
 #ifdef CONFIG_JOLIET
         if (joliet_level && opt.utf8 == 0) {
-                char * p = opt.iocharset ? opt.iocharset : CONFIG_NLS_DEFAULT;
+                char *p = opt.iocharset ? opt.iocharset : CONFIG_NLS_DEFAULT;
                 sbi->s_nls_iocharset = load_nls(p);
                 if (! sbi->s_nls_iocharset) {
                         /* Fail only if explicit charset specified */
@@ -821,7 +825,7 @@ root_found:
                 sbi->s_rock = 0;
                 if (sbi->s_firstdatazone != first_data_zone) {
                         sbi->s_firstdatazone = first_data_zone;
-                        printk(KERN_DEBUG 
+                        printk(KERN_DEBUG
                                 "ISOFS: changing to secondary root\n");
                         iput(inode);
                         inode = isofs_iget(s, sbi->s_firstdatazone, 0);
@@ -830,8 +834,10 @@ root_found:
 
         if (opt.check == 'u') {
                 /* Only Joliet is case insensitive by default */
-                if (joliet_level) opt.check = 'r';
-                else opt.check = 's';
+                if (joliet_level)
+                        opt.check = 'r';
+                else
+                        opt.check = 's';
         }
         sbi->s_joliet_level = joliet_level;
 
@@ -846,8 +852,10 @@ root_found:
                 goto out_no_root;
 
         table = 0;
-        if (joliet_level) table += 2;
-        if (opt.check == 'r') table++;
+        if (joliet_level)
+                table += 2;
+        if (opt.check == 'r')
+                table++;
         s->s_root->d_op = &isofs_dentry_ops[table];
 
         kfree(opt.iocharset);
@@ -858,10 +866,10 @@ root_found:
          * Display error messages and free resources.
          */
 out_bad_root:
-        printk(KERN_WARNING "isofs_fill_super: root inode not initialized\n");
+        printk(KERN_WARNING "%s: root inode not initialized\n", __func__);
         goto out_iput;
 out_no_root:
-        printk(KERN_WARNING "isofs_fill_super: get root inode failed\n");
+        printk(KERN_WARNING "%s: get root inode failed\n", __func__);
 out_iput:
         iput(inode);
 #ifdef CONFIG_JOLIET
@@ -870,21 +878,20 @@ out_iput:
 #endif
         goto out_freesbi;
 out_no_read:
-        printk(KERN_WARNING "isofs_fill_super: "
-                "bread failed, dev=%s, iso_blknum=%d, block=%d\n",
-                s->s_id, iso_blknum, block);
+        printk(KERN_WARNING "%s: bread failed, dev=%s, iso_blknum=%d, block=%d\n",
+                __func__, s->s_id, iso_blknum, block);
         goto out_freesbi;
 out_bad_zone_size:
-        printk(KERN_WARNING "Bad logical zone size %ld\n",
+        printk(KERN_WARNING "ISOFS: Bad logical zone size %ld\n",
                 sbi->s_log_zone_size);
         goto out_freebh;
 out_bad_size:
-        printk(KERN_WARNING "Logical zone size(%d) < hardware blocksize(%u)\n",
+        printk(KERN_WARNING "ISOFS: Logical zone size(%d) < hardware blocksize(%u)\n",
                 orig_zonesize, opt.blocksize);
         goto out_freebh;
 out_unknown_format:
         if (!silent)
-                printk(KERN_WARNING "Unable to identify CD-ROM format.\n");
+                printk(KERN_WARNING "ISOFS: Unable to identify CD-ROM format.\n");
 
 out_freebh:
         brelse(bh);
@@ -902,7 +909,7 @@ static int isofs_statfs (struct dentry *dentry, struct kstatfs *buf)
         buf->f_type = ISOFS_SUPER_MAGIC;
         buf->f_bsize = sb->s_blocksize;
         buf->f_blocks = (ISOFS_SB(sb)->s_nzones
-                  << (ISOFS_SB(sb)->s_log_zone_size - sb->s_blocksize_bits));
+                << (ISOFS_SB(sb)->s_log_zone_size - sb->s_blocksize_bits));
         buf->f_bfree = 0;
         buf->f_bavail = 0;
         buf->f_files = ISOFS_SB(sb)->s_ninodes;
@@ -931,20 +938,20 @@ int isofs_get_blocks(struct inode *inode, sector_t iblock_s,
 
         rv = 0;
         if (iblock < 0 || iblock != iblock_s) {
-                printk("isofs_get_blocks: block number too large\n");
+                printk(KERN_DEBUG "%s: block number too large\n", __func__);
                 goto abort;
         }
 
         b_off = iblock;
-        
-        offset    = 0;
-        firstext  = ei->i_first_extent;
+
+        offset = 0;
+        firstext = ei->i_first_extent;
         sect_size = ei->i_section_size >> ISOFS_BUFFER_BITS(inode);
-        nextblk   = ei->i_next_section_block;
-        nextoff   = ei->i_next_section_offset;
-        section   = 0;
+        nextblk = ei->i_next_section_block;
+        nextoff = ei->i_next_section_offset;
+        section = 0;
 
-        while ( nblocks ) {
+        while (nblocks) {
                 /* If we are *way* beyond the end of the file, print a message.
                  * Access beyond the end of the file up to the next page boundary
                  * is normal, however because of the way the page cache works.
@@ -953,11 +960,11 @@ int isofs_get_blocks(struct inode *inode, sector_t iblock_s,
                  * I/O errors.
                  */
                 if (b_off > ((inode->i_size + PAGE_CACHE_SIZE - 1) >> ISOFS_BUFFER_BITS(inode))) {
-                        printk("isofs_get_blocks: block >= EOF (%ld, %ld)\n",
-                               iblock, (unsigned long) inode->i_size);
+                        printk(KERN_DEBUG "%s: block >= EOF (%ld, %ld)\n",
+                                __func__, iblock, (unsigned long) inode->i_size);
                         goto abort;
                 }
-                
+
                 /* On the last section, nextblk == 0, section size is likely to
                  * exceed sect_size by a partial block, and access beyond the
                  * end of the file will reach beyond the section size, too.
@@ -976,20 +983,21 @@ int isofs_get_blocks(struct inode *inode, sector_t iblock_s,
                         iput(ninode);
 
                         if (++section > 100) {
-                                printk("isofs_get_blocks: More than 100 file sections ?!?, aborting...\n");
-                                printk("isofs_get_blocks: block=%ld firstext=%u sect_size=%u "
-                                       "nextblk=%lu nextoff=%lu\n",
-                                       iblock, firstext, (unsigned) sect_size,
-                                       nextblk, nextoff);
+                                printk(KERN_DEBUG "%s: More than 100 file sections ?!?"
+                                        " aborting...\n", __func__);
+                                printk(KERN_DEBUG "%s: block=%ld firstext=%u sect_size=%u "
+                                        "nextblk=%lu nextoff=%lu\n", __func__,
+                                        iblock, firstext, (unsigned) sect_size,
+                                        nextblk, nextoff);
                                 goto abort;
                         }
                 }
-                
-                if ( *bh ) {
+
+                if (*bh) {
                         map_bh(*bh, inode->i_sb, firstext + b_off - offset);
                 } else {
                         *bh = sb_getblk(inode->i_sb, firstext+b_off-offset);
-                        if ( !*bh )
+                        if (!*bh)
                                 goto abort;
                 }
                 bh++;   /* Next buffer head */
@@ -1010,7 +1018,7 @@ static int isofs_get_block(struct inode *inode, sector_t iblock,
                     struct buffer_head *bh_result, int create)
 {
         if (create) {
-                printk("isofs_get_block: Kernel tries to allocate a block\n");
+                printk(KERN_DEBUG "%s: Kernel tries to allocate a block\n", __func__);
                 return -EROFS;
         }
 
@@ -1070,11 +1078,11 @@ static int isofs_read_level3_size(struct inode *inode)
 {
         unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
         int high_sierra = ISOFS_SB(inode->i_sb)->s_high_sierra;
-        struct buffer_head * bh = NULL;
+        struct buffer_head *bh = NULL;
         unsigned long block, offset, block_saved, offset_saved;
         int i = 0;
         int more_entries = 0;
-        struct iso_directory_record * tmpde = NULL;
+        struct iso_directory_record *tmpde = NULL;
         struct iso_inode_info *ei = ISOFS_I(inode);
 
         inode->i_size = 0;
@@ -1089,7 +1097,7 @@ static int isofs_read_level3_size(struct inode *inode)
         offset = ei->i_iget5_offset;
 
         do {
-                struct iso_directory_record * de;
+                struct iso_directory_record *de;
                 unsigned int de_len;
 
                 if (!bh) {
@@ -1163,10 +1171,9 @@ out_noread:
         return -EIO;
 
 out_toomany:
-        printk(KERN_INFO "isofs_read_level3_size: "
-                "More than 100 file sections ?!?, aborting...\n"
-                "isofs_read_level3_size: inode=%lu\n",
-                inode->i_ino);
+        printk(KERN_INFO "%s: More than 100 file sections ?!?, aborting...\n"
+                "isofs_read_level3_size: inode=%lu\n",
+                __func__, inode->i_ino);
         goto out;
 }
 
@@ -1177,9 +1184,9 @@ static void isofs_read_inode(struct inode *inode)
         unsigned long bufsize = ISOFS_BUFFER_SIZE(inode);
         unsigned long block;
         int high_sierra = sbi->s_high_sierra;
-        struct buffer_head * bh = NULL;
-        struct iso_directory_record * de;
-        struct iso_directory_record * tmpde = NULL;
+        struct buffer_head *bh = NULL;
+        struct iso_directory_record *de;
+        struct iso_directory_record *tmpde = NULL;
         unsigned int de_len;
         unsigned long offset;
         struct iso_inode_info *ei = ISOFS_I(inode);
@@ -1199,7 +1206,7 @@ static void isofs_read_inode(struct inode *inode)
 
                 tmpde = kmalloc(de_len, GFP_KERNEL);
                 if (tmpde == NULL) {
-                        printk(KERN_INFO "isofs_read_inode: out of memory\n");
+                        printk(KERN_INFO "%s: out of memory\n", __func__);
                         goto fail;
                 }
                 memcpy(tmpde, bh->b_data + offset, frag1);
@@ -1212,24 +1219,26 @@ static void isofs_read_inode(struct inode *inode)
         }
 
         inode->i_ino = isofs_get_ino(ei->i_iget5_block,
-                                     ei->i_iget5_offset,
-                                     ISOFS_BUFFER_BITS(inode));
+                                        ei->i_iget5_offset,
+                                        ISOFS_BUFFER_BITS(inode));
 
         /* Assume it is a normal-format file unless told otherwise */
         ei->i_file_format = isofs_file_normal;
 
         if (de->flags[-high_sierra] & 2) {
                 inode->i_mode = S_IRUGO | S_IXUGO | S_IFDIR;
-                inode->i_nlink = 1; /* Set to 1.  We know there are 2, but
-                                       the find utility tries to optimize
-                                       if it is 2, and it screws up.  It is
-                                       easier to give 1 which tells find to
-                                       do it the hard way. */
+                inode->i_nlink = 1;     /*
+                                         * Set to 1.  We know there are 2, but
+                                         * the find utility tries to optimize
+                                         * if it is 2, and it screws up.  It is
+                                         * easier to give 1 which tells find to
+                                         * do it the hard way.
+                                         */
         } else {
-                /* Everybody gets to read the file. */
+                /* Everybody gets to read the file. */
                 inode->i_mode = sbi->s_mode;
                 inode->i_nlink = 1;
-                inode->i_mode |= S_IFREG;
+                inode->i_mode |= S_IFREG;
         }
         inode->i_uid = sbi->s_uid;
         inode->i_gid = sbi->s_gid;
@@ -1239,13 +1248,14 @@ static void isofs_read_inode(struct inode *inode)
         ei->i_format_parm[1] = 0;
         ei->i_format_parm[2] = 0;
 
-        ei->i_section_size = isonum_733 (de->size);
+        ei->i_section_size = isonum_733(de->size);
         if (de->flags[-high_sierra] & 0x80) {
-                if(isofs_read_level3_size(inode)) goto fail;
+                if(isofs_read_level3_size(inode))
+                        goto fail;
         } else {
                 ei->i_next_section_block = 0;
                 ei->i_next_section_offset = 0;
-                inode->i_size = isonum_733 (de->size);
+                inode->i_size = isonum_733(de->size);
         }
 
         /*
@@ -1258,23 +1268,24 @@ static void isofs_read_inode(struct inode *inode)
                 inode->i_size &= 0x00ffffff;
 
         if (de->interleave[0]) {
-                printk("Interleaved files not (yet) supported.\n");
+                printk(KERN_DEBUG "ISOFS: Interleaved files not (yet) supported.\n");
                 inode->i_size = 0;
         }
 
         /* I have no idea what file_unit_size is used for, so
            we will flag it for now */
         if (de->file_unit_size[0] != 0) {
-                printk("File unit size != 0 for ISO file (%ld).\n",
-                       inode->i_ino);
+                printk(KERN_DEBUG "ISOFS: File unit size != 0 for ISO file (%ld).\n",
+                        inode->i_ino);
         }
 
         /* I have no idea what other flag bits are used for, so
            we will flag it for now */
 #ifdef DEBUG
         if((de->flags[-high_sierra] & ~2)!= 0){
-                printk("Unusual flag settings for ISO file (%ld %x).\n",
-                       inode->i_ino, de->flags[-high_sierra]);
+                printk(KERN_DEBUG "ISOFS: Unusual flag settings for ISO file "
+                                "(%ld %x).\n",
+                        inode->i_ino, de->flags[-high_sierra]);
         }
 #endif
 
@@ -1285,11 +1296,11 @@ static void isofs_read_inode(struct inode *inode)
         inode->i_atime.tv_nsec =
         inode->i_ctime.tv_nsec = 0;
 
-        ei->i_first_extent = (isonum_733 (de->extent) +
-                              isonum_711 (de->ext_attr_length));
+        ei->i_first_extent = (isonum_733(de->extent) +
+                        isonum_711(de->ext_attr_length));
 
         /* Set the number of blocks for stat() - should be done before RR */
-        inode->i_blocks  = (inode->i_size + 511) >> 9;
+        inode->i_blocks = (inode->i_size + 511) >> 9;
 
         /*
          * Now test for possible Rock Ridge extensions which will override
@@ -1306,7 +1317,7 @@ static void isofs_read_inode(struct inode *inode)
         /* Install the inode operations vector */
         if (S_ISREG(inode->i_mode)) {
                 inode->i_fop = &generic_ro_fops;
-                switch ( ei->i_file_format ) {
+                switch (ei->i_file_format) {
 #ifdef CONFIG_ZISOFS
                 case isofs_file_compressed:
                         inode->i_data.a_ops = &zisofs_aops;
@@ -1350,7 +1361,7 @@ static int isofs_iget5_test(struct inode *ino, void *data)
         struct isofs_iget5_callback_data *d =
                 (struct isofs_iget5_callback_data*)data;
         return (i->i_iget5_block == d->block)
-               && (i->i_iget5_offset == d->offset);
+                && (i->i_iget5_offset == d->offset);
 }
 
 static int isofs_iget5_set(struct inode *ino, void *data)
@@ -1384,7 +1395,7 @@ struct inode *isofs_iget(struct super_block *sb,
         hashval = (block << sb->s_blocksize_bits) | offset;
 
         inode = iget5_locked(sb, hashval, &isofs_iget5_test,
-                             &isofs_iget5_set, &data);
+                                &isofs_iget5_set, &data);
 
         if (inode && (inode->i_state & I_NEW)) {
                 sb->s_op->read_inode(inode);
@@ -1398,7 +1409,7 @@ static int isofs_get_sb(struct file_system_type *fs_type,
         int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
         return get_sb_bdev(fs_type, flags, dev_name, data, isofs_fill_super,
-                           mnt);
+                                mnt);
 }
 
 static struct file_system_type iso9660_fs_type = {
diff --git a/fs/isofs/joliet.c b/fs/isofs/joliet.c
index fb8fe7a9ddc..92c14b850e9 100644
--- a/fs/isofs/joliet.c
+++ b/fs/isofs/joliet.c
@@ -80,22 +80,20 @@ get_joliet_filename(struct iso_directory_record * de, unsigned char *outname, st
 
         if (utf8) {
                 len = wcsntombs_be(outname, de->name,
-                                   de->name_len[0] >> 1, PAGE_SIZE);
+                                de->name_len[0] >> 1, PAGE_SIZE);
         } else {
                 len = uni16_to_x8(outname, (__be16 *) de->name,
-                                  de->name_len[0] >> 1, nls);
+                                de->name_len[0] >> 1, nls);
         }
-        if ((len > 2) && (outname[len-2] == ';') && (outname[len-1] == '1')) {
+        if ((len > 2) && (outname[len-2] == ';') && (outname[len-1] == '1'))
                 len -= 2;
-        }
 
         /*
          * Windows doesn't like periods at the end of a name,
          * so neither do we
          */
-        while (len >= 2 && (outname[len-1] == '.')) {
+        while (len >= 2 && (outname[len-1] == '.'))
                 len--;
-        }
 
         return len;
 }
diff --git a/fs/isofs/namei.c b/fs/isofs/namei.c
index c04b3a14a3e..c8c7e5138a0 100644
--- a/fs/isofs/namei.c
+++ b/fs/isofs/namei.c
@@ -15,7 +15,7 @@
  * some sanity tests.
  */
 static int
-isofs_cmp(struct dentry * dentry, const char * compare, int dlen)
+isofs_cmp(struct dentry *dentry, const char *compare, int dlen)
 {
         struct qstr qstr;
 
@@ -48,24 +48,24 @@ isofs_cmp(struct dentry * dentry, const char * compare, int dlen)
  */
 static unsigned long
 isofs_find_entry(struct inode *dir, struct dentry *dentry,
-        unsigned long *block_rv, unsigned long* offset_rv,
-        char * tmpname, struct iso_directory_record * tmpde)
+        unsigned long *block_rv, unsigned long *offset_rv,
+        char *tmpname, struct iso_directory_record *tmpde)
 {
         unsigned long bufsize = ISOFS_BUFFER_SIZE(dir);
         unsigned char bufbits = ISOFS_BUFFER_BITS(dir);
         unsigned long block, f_pos, offset, block_saved, offset_saved;
-        struct buffer_head * bh = NULL;
+        struct buffer_head *bh = NULL;
         struct isofs_sb_info *sbi = ISOFS_SB(dir->i_sb);
 
         if (!ISOFS_I(dir)->i_first_extent)
                 return 0;
-  
+
         f_pos = 0;
         offset = 0;
         block = 0;
 
         while (f_pos < dir->i_size) {
-                struct iso_directory_record * de;
+                struct iso_directory_record *de;
                 int de_len, match, i, dlen;
                 char *dpnt;
 
@@ -114,7 +114,7 @@ isofs_find_entry(struct inode *dir, struct dentry *dentry,
 
                 if (sbi->s_rock &&
                     ((i = get_rock_ridge_filename(de, tmpname, dir)))) {
-                        dlen = i;       /* possibly -1 */
+                        dlen = i;       /* possibly -1 */
                         dpnt = tmpname;
 #ifdef CONFIG_JOLIET
                 } else if (sbi->s_joliet_level) {
@@ -145,8 +145,8 @@ isofs_find_entry(struct inode *dir, struct dentry *dentry,
                         isofs_normalize_block_and_offset(de,
                                                          &block_saved,
                                                          &offset_saved);
-                        *block_rv = block_saved;
-                        *offset_rv = offset_saved;
+                        *block_rv = block_saved;
+                        *offset_rv = offset_saved;
                         brelse(bh);
                         return 1;
                 }
@@ -155,7 +155,7 @@ isofs_find_entry(struct inode *dir, struct dentry *dentry,
         return 0;
 }
 
-struct dentry *isofs_lookup(struct inode * dir, struct dentry * dentry, struct nameidata *nd)
+struct dentry *isofs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
 {
         int found;
         unsigned long block, offset;
@@ -170,9 +170,9 @@ struct dentry *isofs_lookup(struct inode * dir, struct dentry * dentry, struct n
 
         lock_kernel();
         found = isofs_find_entry(dir, dentry,
-                                 &block, &offset,
-                                 page_address(page),
-                                 1024 + page_address(page));
+                                &block, &offset,
+                                page_address(page),
+                                1024 + page_address(page));
         __free_page(page);
 
         inode = NULL;
diff --git a/fs/jbd/commit.c b/fs/jbd/commit.c
index 1facfaff97c..a003d50edcd 100644
--- a/fs/jbd/commit.c
+++ b/fs/jbd/commit.c
@@ -887,7 +887,8 @@ restart_loop:
         journal->j_committing_transaction = NULL;
         spin_unlock(&journal->j_state_lock);
 
-        if (commit_transaction->t_checkpoint_list == NULL) {
+        if (commit_transaction->t_checkpoint_list == NULL &&
+            commit_transaction->t_checkpoint_io_list == NULL) {
                 __journal_drop_transaction(journal, commit_transaction);
         } else {
                 if (journal->j_checkpoint_transactions == NULL) {
diff --git a/fs/jbd/revoke.c b/fs/jbd/revoke.c
index 824e3b7d4ec..8db2fa25170 100644
--- a/fs/jbd/revoke.c
+++ b/fs/jbd/revoke.c
@@ -68,6 +68,7 @@
 #include <linux/list.h>
 #include <linux/init.h>
 #endif
+#include <linux/log2.h>
 
 static struct kmem_cache *revoke_record_cache;
 static struct kmem_cache *revoke_table_cache;
@@ -211,7 +212,7 @@ int journal_init_revoke(journal_t *journal, int hash_size)
         journal->j_revoke = journal->j_revoke_table[0];
 
         /* Check that the hash_size is a power of two */
-        J_ASSERT ((hash_size & (hash_size-1)) == 0);
+        J_ASSERT(is_power_of_2(hash_size));
 
         journal->j_revoke->hash_size = hash_size;
 
@@ -238,7 +239,7 @@ int journal_init_revoke(journal_t *journal, int hash_size)
         journal->j_revoke = journal->j_revoke_table[1];
 
         /* Check that the hash_size is a power of two */
-        J_ASSERT ((hash_size & (hash_size-1)) == 0);
+        J_ASSERT(is_power_of_2(hash_size));
 
         journal->j_revoke->hash_size = hash_size;
 
diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
index 2856e1100a5..c0f59d1b13d 100644
--- a/fs/jbd2/commit.c
+++ b/fs/jbd2/commit.c
@@ -896,7 +896,8 @@ restart_loop:
         journal->j_committing_transaction = NULL;
         spin_unlock(&journal->j_state_lock);
 
-        if (commit_transaction->t_checkpoint_list == NULL) {
+        if (commit_transaction->t_checkpoint_list == NULL &&
+            commit_transaction->t_checkpoint_io_list == NULL) {
                 __jbd2_journal_drop_transaction(journal, commit_transaction);
         } else {
                 if (journal->j_checkpoint_transactions == NULL) {
diff --git a/fs/jbd2/revoke.c b/fs/jbd2/revoke.c
index 9246e763da7..28cac049a56 100644
--- a/fs/jbd2/revoke.c
+++ b/fs/jbd2/revoke.c
@@ -68,6 +68,7 @@
 #include <linux/list.h>
 #include <linux/init.h>
 #endif
+#include <linux/log2.h>
 
 static struct kmem_cache *jbd2_revoke_record_cache;
 static struct kmem_cache *jbd2_revoke_table_cache;
@@ -212,7 +213,7 @@ int jbd2_journal_init_revoke(journal_t *journal, int hash_size)
         journal->j_revoke = journal->j_revoke_table[0];
 
         /* Check that the hash_size is a power of two */
-        J_ASSERT ((hash_size & (hash_size-1)) == 0);
+        J_ASSERT(is_power_of_2(hash_size));
 
         journal->j_revoke->hash_size = hash_size;
 
@@ -239,7 +240,7 @@ int jbd2_journal_init_revoke(journal_t *journal, int hash_size)
         journal->j_revoke = journal->j_revoke_table[1];
 
         /* Check that the hash_size is a power of two */
-        J_ASSERT ((hash_size & (hash_size-1)) == 0);
+        J_ASSERT(is_power_of_2(hash_size));
 
         journal->j_revoke->hash_size = hash_size;
 
diff --git a/fs/lockd/host.c b/fs/lockd/host.c
index 96070bff93f..572601e98dc 100644
--- a/fs/lockd/host.c
+++ b/fs/lockd/host.c
@@ -44,9 +44,8 @@ static struct nsm_handle *	nsm_find(const struct sockaddr_in *sin,
  */
 static struct nlm_host *
 nlm_lookup_host(int server, const struct sockaddr_in *sin,
-                                        int proto, int version,
-                                        const char *hostname,
-                                        int hostname_len)
+                int proto, int version, const char *hostname,
+                int hostname_len, const struct sockaddr_in *ssin)
 {
         struct hlist_head *chain;
         struct hlist_node *pos;
@@ -54,7 +53,9 @@ nlm_lookup_host(int server, const struct sockaddr_in *sin,
         struct nsm_handle *nsm = NULL;
         int             hash;
 
-        dprintk("lockd: nlm_lookup_host(%u.%u.%u.%u, p=%d, v=%d, my role=%s, name=%.*s)\n",
+        dprintk("lockd: nlm_lookup_host("NIPQUAD_FMT"->"NIPQUAD_FMT
+                        ", p=%d, v=%d, my role=%s, name=%.*s)\n",
+                        NIPQUAD(ssin->sin_addr.s_addr),
                         NIPQUAD(sin->sin_addr.s_addr), proto, version,
                         server? "server" : "client",
                         hostname_len,
@@ -91,6 +92,8 @@ nlm_lookup_host(int server, const struct sockaddr_in *sin,
                         continue;
                 if (host->h_server != server)
                         continue;
+                if (!nlm_cmp_addr(&host->h_saddr, ssin))
+                        continue;
 
                 /* Move to head of hash chain. */
                 hlist_del(&host->h_hash);
@@ -118,6 +121,7 @@ nlm_lookup_host(int server, const struct sockaddr_in *sin,
         host->h_name       = nsm->sm_name;
         host->h_addr       = *sin;
         host->h_addr.sin_port = 0;      /* ouch! */
+        host->h_saddr      = *ssin;
         host->h_version    = version;
         host->h_proto      = proto;
         host->h_rpcclnt    = NULL;
@@ -161,15 +165,9 @@ nlm_destroy_host(struct nlm_host *host)
          */
         nsm_unmonitor(host);
 
-        if ((clnt = host->h_rpcclnt) != NULL) {
-                if (atomic_read(&clnt->cl_users)) {
-                        printk(KERN_WARNING
-                                "lockd: active RPC handle\n");
-                        clnt->cl_dead = 1;
-                } else {
-                        rpc_destroy_client(host->h_rpcclnt);
-                }
-        }
+        clnt = host->h_rpcclnt;
+        if (clnt != NULL)
+                rpc_shutdown_client(clnt);
         kfree(host);
 }
 
@@ -180,8 +178,10 @@ struct nlm_host *
 nlmclnt_lookup_host(const struct sockaddr_in *sin, int proto, int version,
                         const char *hostname, int hostname_len)
 {
+        struct sockaddr_in ssin = {0};
+
         return nlm_lookup_host(0, sin, proto, version,
-                               hostname, hostname_len);
+                               hostname, hostname_len, &ssin);
 }
 
 /*
@@ -191,9 +191,12 @@ struct nlm_host *
 nlmsvc_lookup_host(struct svc_rqst *rqstp,
                         const char *hostname, int hostname_len)
 {
+        struct sockaddr_in ssin = {0};
+
+        ssin.sin_addr = rqstp->rq_daddr.addr;
         return nlm_lookup_host(1, svc_addr_in(rqstp),
                                rqstp->rq_prot, rqstp->rq_vers,
-                               hostname, hostname_len);
+                               hostname, hostname_len, &ssin);
 }
 
 /*
@@ -204,8 +207,9 @@ nlm_bind_host(struct nlm_host *host)
 {
         struct rpc_clnt *clnt;
 
-        dprintk("lockd: nlm_bind_host(%08x)\n",
-                        (unsigned)ntohl(host->h_addr.sin_addr.s_addr));
+        dprintk("lockd: nlm_bind_host("NIPQUAD_FMT"->"NIPQUAD_FMT")\n",
+                        NIPQUAD(host->h_saddr.sin_addr),
+                        NIPQUAD(host->h_addr.sin_addr));
 
         /* Lock host handle */
         mutex_lock(&host->h_mutex);
@@ -232,6 +236,7 @@ nlm_bind_host(struct nlm_host *host)
                         .protocol       = host->h_proto,
                         .address        = (struct sockaddr *)&host->h_addr,
                         .addrsize       = sizeof(host->h_addr),
+                        .saddress       = (struct sockaddr *)&host->h_saddr,
                         .timeout        = &timeparms,
                         .servername     = host->h_name,
                         .program        = &nlm_program,
diff --git a/fs/lockd/mon.c b/fs/lockd/mon.c
index 2102e2d0134..3353ed8421a 100644
--- a/fs/lockd/mon.c
+++ b/fs/lockd/mon.c
@@ -61,6 +61,7 @@ nsm_mon_unmon(struct nsm_handle *nsm, u32 proc, struct nsm_res *res)
                         status);
         else
                 status = 0;
+        rpc_shutdown_client(clnt);
  out:
         return status;
 }
@@ -138,7 +139,6 @@ nsm_create(void)
                 .program        = &nsm_program,
                 .version        = SM_VERSION,
                 .authflavor     = RPC_AUTH_NULL,
-                .flags          = (RPC_CLNT_CREATE_ONESHOT),
         };
 
         return rpc_create(&args);
diff --git a/fs/lockd/svc.c b/fs/lockd/svc.c
index 126b1bf02c0..26809325469 100644
--- a/fs/lockd/svc.c
+++ b/fs/lockd/svc.c
@@ -123,9 +123,6 @@ lockd(struct svc_rqst *rqstp)
         /* Process request with signals blocked, but allow SIGKILL.  */
         allow_signal(SIGKILL);
 
-        /* kick rpciod */
-        rpciod_up();
-
         dprintk("NFS locking service started (ver " LOCKD_VERSION ").\n");
 
         if (!nlm_timeout)
@@ -202,9 +199,6 @@ lockd(struct svc_rqst *rqstp)
         /* Exit the RPC thread */
         svc_exit_thread(rqstp);
 
-        /* release rpciod */
-        rpciod_down();
-
         /* Release module */
         unlock_kernel();
         module_put_and_exit(0);
diff --git a/fs/namespace.c b/fs/namespace.c
index b696e3a0d18..4198003d7e1 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -28,6 +28,7 @@
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
 #include "pnode.h"
+#include "internal.h"
 
 /* spinlock for vfsmount related operations, inplace of dcache_lock */
 __cacheline_aligned_in_smp DEFINE_SPINLOCK(vfsmount_lock);
@@ -320,22 +321,16 @@ EXPORT_SYMBOL(mnt_unpin);
 static void *m_start(struct seq_file *m, loff_t *pos)
 {
         struct mnt_namespace *n = m->private;
-        struct list_head *p;
-        loff_t l = *pos;
 
         down_read(&namespace_sem);
-        list_for_each(p, &n->list)
-                if (!l--)
-                        return list_entry(p, struct vfsmount, mnt_list);
-        return NULL;
+        return seq_list_start(&n->list, *pos);
 }
 
 static void *m_next(struct seq_file *m, void *v, loff_t *pos)
 {
         struct mnt_namespace *n = m->private;
-        struct list_head *p = ((struct vfsmount *)v)->mnt_list.next;
-        (*pos)++;
-        return p == &n->list ? NULL : list_entry(p, struct vfsmount, mnt_list);
+
+        return seq_list_next(v, &n->list, pos);
 }
 
 static void m_stop(struct seq_file *m, void *v)
@@ -350,7 +345,7 @@ static inline void mangle(struct seq_file *m, const char *s)
 
 static int show_vfsmnt(struct seq_file *m, void *v)
 {
-        struct vfsmount *mnt = v;
+        struct vfsmount *mnt = list_entry(v, struct vfsmount, mnt_list);
         int err = 0;
         static struct proc_fs_info {
                 int flag;
@@ -405,7 +400,7 @@ struct seq_operations mounts_op = {
 
 static int show_vfsstat(struct seq_file *m, void *v)
 {
-        struct vfsmount *mnt = v;
+        struct vfsmount *mnt = list_entry(v, struct vfsmount, mnt_list);
         int err = 0;
 
         /* device */
@@ -1457,7 +1452,7 @@ static struct mnt_namespace *dup_mnt_ns(struct mnt_namespace *mnt_ns,
 
         new_ns = kmalloc(sizeof(struct mnt_namespace), GFP_KERNEL);
         if (!new_ns)
-                return NULL;
+                return ERR_PTR(-ENOMEM);
 
         atomic_set(&new_ns->count, 1);
         INIT_LIST_HEAD(&new_ns->list);
@@ -1471,7 +1466,7 @@ static struct mnt_namespace *dup_mnt_ns(struct mnt_namespace *mnt_ns,
         if (!new_ns->root) {
                 up_write(&namespace_sem);
                 kfree(new_ns);
-                return NULL;
+                return ERR_PTR(-ENOMEM);;
         }
         spin_lock(&vfsmount_lock);
         list_add_tail(&new_ns->list, &new_ns->root->mnt_list);
@@ -1515,7 +1510,7 @@ static struct mnt_namespace *dup_mnt_ns(struct mnt_namespace *mnt_ns,
         return new_ns;
 }
 
-struct mnt_namespace *copy_mnt_ns(int flags, struct mnt_namespace *ns,
+struct mnt_namespace *copy_mnt_ns(unsigned long flags, struct mnt_namespace *ns,
                 struct fs_struct *new_fs)
 {
         struct mnt_namespace *new_ns;
diff --git a/fs/ncpfs/file.c b/fs/ncpfs/file.c
index d3152f8d95c..2b145de45b3 100644
--- a/fs/ncpfs/file.c
+++ b/fs/ncpfs/file.c
@@ -203,7 +203,6 @@ ncp_file_write(struct file *file, const char __user *buf, size_t count, loff_t *
 
         if (pos + count > MAX_NON_LFS && !(file->f_flags&O_LARGEFILE)) {
                 if (pos >= MAX_NON_LFS) {
-                        send_sig(SIGXFSZ, current, 0);
                         return -EFBIG;
                 }
                 if (count > MAX_NON_LFS - (u32)pos) {
@@ -212,7 +211,6 @@ ncp_file_write(struct file *file, const char __user *buf, size_t count, loff_t *
         }
         if (pos >= inode->i_sb->s_maxbytes) {
                 if (count || pos > inode->i_sb->s_maxbytes) {
-                        send_sig(SIGXFSZ, current, 0);
                         return -EFBIG;
                 }
         }
diff --git a/fs/nfs/Makefile b/fs/nfs/Makefile
index f4580b44eef..b55cb236cf7 100644
--- a/fs/nfs/Makefile
+++ b/fs/nfs/Makefile
@@ -6,8 +6,8 @@ obj-$(CONFIG_NFS_FS) += nfs.o
 
 nfs-y                   := client.o dir.o file.o getroot.o inode.o super.o nfs2xdr.o \
                            pagelist.o proc.o read.o symlink.o unlink.o \
-                           write.o namespace.o
-nfs-$(CONFIG_ROOT_NFS)  += nfsroot.o mount_clnt.o      
+                           write.o namespace.o mount_clnt.o
+nfs-$(CONFIG_ROOT_NFS)  += nfsroot.o
 nfs-$(CONFIG_NFS_V3)    += nfs3proc.o nfs3xdr.o
 nfs-$(CONFIG_NFS_V3_ACL)        += nfs3acl.o
 nfs-$(CONFIG_NFS_V4)    += nfs4proc.o nfs4xdr.o nfs4state.o nfs4renewd.o \
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 881fa490092..a49f9feff77 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -102,19 +102,10 @@ static struct nfs_client *nfs_alloc_client(const char *hostname,
                                            int nfsversion)
 {
         struct nfs_client *clp;
-        int error;
 
         if ((clp = kzalloc(sizeof(*clp), GFP_KERNEL)) == NULL)
                 goto error_0;
 
-        error = rpciod_up();
-        if (error < 0) {
-                dprintk("%s: couldn't start rpciod! Error = %d\n",
-                                __FUNCTION__, error);
-                goto error_1;
-        }
-        __set_bit(NFS_CS_RPCIOD, &clp->cl_res_state);
-
         if (nfsversion == 4) {
                 if (nfs_callback_up() < 0)
                         goto error_2;
@@ -139,8 +130,6 @@ static struct nfs_client *nfs_alloc_client(const char *hostname,
 #ifdef CONFIG_NFS_V4
         init_rwsem(&clp->cl_sem);
         INIT_LIST_HEAD(&clp->cl_delegations);
-        INIT_LIST_HEAD(&clp->cl_state_owners);
-        INIT_LIST_HEAD(&clp->cl_unused);
         spin_lock_init(&clp->cl_lock);
         INIT_DELAYED_WORK(&clp->cl_renewd, nfs4_renew_state);
         rpc_init_wait_queue(&clp->cl_rpcwaitq, "NFS client");
@@ -154,9 +143,6 @@ error_3:
         if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state))
                 nfs_callback_down();
 error_2:
-        rpciod_down();
-        __clear_bit(NFS_CS_RPCIOD, &clp->cl_res_state);
-error_1:
         kfree(clp);
 error_0:
         return NULL;
@@ -167,16 +153,7 @@ static void nfs4_shutdown_client(struct nfs_client *clp)
 #ifdef CONFIG_NFS_V4
         if (__test_and_clear_bit(NFS_CS_RENEWD, &clp->cl_res_state))
                 nfs4_kill_renewd(clp);
-        while (!list_empty(&clp->cl_unused)) {
-                struct nfs4_state_owner *sp;
-
-                sp = list_entry(clp->cl_unused.next,
-                                struct nfs4_state_owner,
-                                so_list);
-                list_del(&sp->so_list);
-                kfree(sp);
-        }
-        BUG_ON(!list_empty(&clp->cl_state_owners));
+        BUG_ON(!RB_EMPTY_ROOT(&clp->cl_state_owners));
         if (__test_and_clear_bit(NFS_CS_IDMAP, &clp->cl_res_state))
                 nfs_idmap_delete(clp);
 #endif
@@ -198,9 +175,6 @@ static void nfs_free_client(struct nfs_client *clp)
         if (__test_and_clear_bit(NFS_CS_CALLBACK, &clp->cl_res_state))
                 nfs_callback_down();
 
-        if (__test_and_clear_bit(NFS_CS_RPCIOD, &clp->cl_res_state))
-                rpciod_down();
-
         kfree(clp->cl_hostname);
         kfree(clp);
 
@@ -1232,23 +1206,9 @@ static int nfs_server_list_open(struct inode *inode, struct file *file)
  */
 static void *nfs_server_list_start(struct seq_file *m, loff_t *_pos)
 {
-        struct list_head *_p;
-        loff_t pos = *_pos;
-
         /* lock the list against modification */
         spin_lock(&nfs_client_lock);
-
-        /* allow for the header line */
-        if (!pos)
-                return SEQ_START_TOKEN;
-        pos--;
-
-        /* find the n'th element in the list */
-        list_for_each(_p, &nfs_client_list)
-                if (!pos--)
-                        break;
-
-        return _p != &nfs_client_list ? _p : NULL;
+        return seq_list_start_head(&nfs_client_list, *_pos);
 }
 
 /*
@@ -1256,14 +1216,7 @@ static void *nfs_server_list_start(struct seq_file *m, loff_t *_pos)
  */
 static void *nfs_server_list_next(struct seq_file *p, void *v, loff_t *pos)
 {
-        struct list_head *_p;
-
-        (*pos)++;
-
-        _p = v;
-        _p = (v == SEQ_START_TOKEN) ? nfs_client_list.next : _p->next;
-
-        return _p != &nfs_client_list ? _p : NULL;
+        return seq_list_next(v, &nfs_client_list, pos);
 }
 
 /*
@@ -1282,7 +1235,7 @@ static int nfs_server_list_show(struct seq_file *m, void *v)
         struct nfs_client *clp;
 
         /* display header on line 1 */
-        if (v == SEQ_START_TOKEN) {
+        if (v == &nfs_client_list) {
                 seq_puts(m, "NV SERVER   PORT USE HOSTNAME\n");
                 return 0;
         }
@@ -1323,23 +1276,9 @@ static int nfs_volume_list_open(struct inode *inode, struct file *file)
  */
 static void *nfs_volume_list_start(struct seq_file *m, loff_t *_pos)
 {
-        struct list_head *_p;
-        loff_t pos = *_pos;
-
         /* lock the list against modification */
         spin_lock(&nfs_client_lock);
-
-        /* allow for the header line */
-        if (!pos)
-                return SEQ_START_TOKEN;
-        pos--;
-
-        /* find the n'th element in the list */
-        list_for_each(_p, &nfs_volume_list)
-                if (!pos--)
-                        break;
-
-        return _p != &nfs_volume_list ? _p : NULL;
+        return seq_list_start_head(&nfs_volume_list, *_pos);
 }
 
 /*
@@ -1347,14 +1286,7 @@ static void *nfs_volume_list_start(struct seq_file *m, loff_t *_pos)
  */
 static void *nfs_volume_list_next(struct seq_file *p, void *v, loff_t *pos)
 {
-        struct list_head *_p;
-
-        (*pos)++;
-
-        _p = v;
-        _p = (v == SEQ_START_TOKEN) ? nfs_volume_list.next : _p->next;
-
-        return _p != &nfs_volume_list ? _p : NULL;
+        return seq_list_next(v, &nfs_volume_list, pos);
 }
 
 /*
@@ -1375,7 +1307,7 @@ static int nfs_volume_list_show(struct seq_file *m, void *v)
         char dev[8], fsid[17];
 
         /* display header on line 1 */
-        if (v == SEQ_START_TOKEN) {
+        if (v == &nfs_volume_list) {
                 seq_puts(m, "NV SERVER   PORT DEV     FSID\n");
                 return 0;
         }
diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c
index 7f37d1bea83..20ac403469a 100644
--- a/fs/nfs/delegation.c
+++ b/fs/nfs/delegation.c
@@ -27,6 +27,13 @@ static void nfs_free_delegation(struct nfs_delegation *delegation)
         kfree(delegation);
 }
 
+static void nfs_free_delegation_callback(struct rcu_head *head)
+{
+        struct nfs_delegation *delegation = container_of(head, struct nfs_delegation, rcu);
+
+        nfs_free_delegation(delegation);
+}
+
 static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_state *state)
 {
         struct inode *inode = state->inode;
@@ -57,7 +64,7 @@ out_err:
         return status;
 }
 
-static void nfs_delegation_claim_opens(struct inode *inode)
+static void nfs_delegation_claim_opens(struct inode *inode, const nfs4_stateid *stateid)
 {
         struct nfs_inode *nfsi = NFS_I(inode);
         struct nfs_open_context *ctx;
@@ -72,9 +79,11 @@ again:
                         continue;
                 if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
                         continue;
+                if (memcmp(state->stateid.data, stateid->data, sizeof(state->stateid.data)) != 0)
+                        continue;
                 get_nfs_open_context(ctx);
                 spin_unlock(&inode->i_lock);
-                err = nfs4_open_delegation_recall(ctx->dentry, state);
+                err = nfs4_open_delegation_recall(ctx, state, stateid);
                 if (err >= 0)
                         err = nfs_delegation_claim_locks(ctx, state);
                 put_nfs_open_context(ctx);
@@ -115,10 +124,6 @@ int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct
         struct nfs_delegation *delegation;
         int status = 0;
 
-        /* Ensure we first revalidate the attributes and page cache! */
-        if ((nfsi->cache_validity & (NFS_INO_REVAL_PAGECACHE|NFS_INO_INVALID_ATTR)))
-                __nfs_revalidate_inode(NFS_SERVER(inode), inode);
-
         delegation = kmalloc(sizeof(*delegation), GFP_KERNEL);
         if (delegation == NULL)
                 return -ENOMEM;
@@ -131,10 +136,10 @@ int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct
         delegation->inode = inode;
 
         spin_lock(&clp->cl_lock);
-        if (nfsi->delegation == NULL) {
-                list_add(&delegation->super_list, &clp->cl_delegations);
-                nfsi->delegation = delegation;
+        if (rcu_dereference(nfsi->delegation) == NULL) {
+                list_add_rcu(&delegation->super_list, &clp->cl_delegations);
                 nfsi->delegation_state = delegation->type;
+                rcu_assign_pointer(nfsi->delegation, delegation);
                 delegation = NULL;
         } else {
                 if (memcmp(&delegation->stateid, &nfsi->delegation->stateid,
@@ -145,6 +150,12 @@ int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct
                         status = -EIO;
                 }
         }
+
+        /* Ensure we revalidate the attributes and page cache! */
+        spin_lock(&inode->i_lock);
+        nfsi->cache_validity |= NFS_INO_REVAL_FORCED;
+        spin_unlock(&inode->i_lock);
+
         spin_unlock(&clp->cl_lock);
         kfree(delegation);
         return status;
@@ -155,7 +166,7 @@ static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *
         int res = 0;
 
         res = nfs4_proc_delegreturn(inode, delegation->cred, &delegation->stateid);
-        nfs_free_delegation(delegation);
+        call_rcu(&delegation->rcu, nfs_free_delegation_callback);
         return res;
 }
 
@@ -170,33 +181,55 @@ static void nfs_msync_inode(struct inode *inode)
 /*
  * Basic procedure for returning a delegation to the server
  */
-int __nfs_inode_return_delegation(struct inode *inode)
+static int __nfs_inode_return_delegation(struct inode *inode, struct nfs_delegation *delegation)
 {
         struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
         struct nfs_inode *nfsi = NFS_I(inode);
-        struct nfs_delegation *delegation;
-        int res = 0;
 
         nfs_msync_inode(inode);
         down_read(&clp->cl_sem);
         /* Guard against new delegated open calls */
         down_write(&nfsi->rwsem);
-        spin_lock(&clp->cl_lock);
-        delegation = nfsi->delegation;
-        if (delegation != NULL) {
-                list_del_init(&delegation->super_list);
-                nfsi->delegation = NULL;
-                nfsi->delegation_state = 0;
-        }
-        spin_unlock(&clp->cl_lock);
-        nfs_delegation_claim_opens(inode);
+        nfs_delegation_claim_opens(inode, &delegation->stateid);
         up_write(&nfsi->rwsem);
         up_read(&clp->cl_sem);
         nfs_msync_inode(inode);
 
-        if (delegation != NULL)
-                res = nfs_do_return_delegation(inode, delegation);
-        return res;
+        return nfs_do_return_delegation(inode, delegation);
+}
+
+static struct nfs_delegation *nfs_detach_delegation_locked(struct nfs_inode *nfsi, const nfs4_stateid *stateid)
+{
+        struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation);
+
+        if (delegation == NULL)
+                goto nomatch;
+        if (stateid != NULL && memcmp(delegation->stateid.data, stateid->data,
+                                sizeof(delegation->stateid.data)) != 0)
+                goto nomatch;
+        list_del_rcu(&delegation->super_list);
+        nfsi->delegation_state = 0;
+        rcu_assign_pointer(nfsi->delegation, NULL);
+        return delegation;
+nomatch:
+        return NULL;
+}
+
+int nfs_inode_return_delegation(struct inode *inode)
+{
+        struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
+        struct nfs_inode *nfsi = NFS_I(inode);
+        struct nfs_delegation *delegation;
+        int err = 0;
+
+        if (rcu_dereference(nfsi->delegation) != NULL) {
+                spin_lock(&clp->cl_lock);
+                delegation = nfs_detach_delegation_locked(nfsi, NULL);
+                spin_unlock(&clp->cl_lock);
+                if (delegation != NULL)
+                        err = __nfs_inode_return_delegation(inode, delegation);
+        }
+        return err;
 }
 
 /*
@@ -211,19 +244,23 @@ void nfs_return_all_delegations(struct super_block *sb)
         if (clp == NULL)
                 return;
 restart:
-        spin_lock(&clp->cl_lock);
-        list_for_each_entry(delegation, &clp->cl_delegations, super_list) {
+        rcu_read_lock();
+        list_for_each_entry_rcu(delegation, &clp->cl_delegations, super_list) {
                 if (delegation->inode->i_sb != sb)
                         continue;
                 inode = igrab(delegation->inode);
                 if (inode == NULL)
                         continue;
+                spin_lock(&clp->cl_lock);
+                delegation = nfs_detach_delegation_locked(NFS_I(inode), NULL);
                 spin_unlock(&clp->cl_lock);
-                nfs_inode_return_delegation(inode);
+                rcu_read_unlock();
+                if (delegation != NULL)
+                        __nfs_inode_return_delegation(inode, delegation);
                 iput(inode);
                 goto restart;
         }
-        spin_unlock(&clp->cl_lock);
+        rcu_read_unlock();
 }
 
 static int nfs_do_expire_all_delegations(void *ptr)
@@ -234,22 +271,26 @@ static int nfs_do_expire_all_delegations(void *ptr)
 
         allow_signal(SIGKILL);
 restart:
-        spin_lock(&clp->cl_lock);
         if (test_bit(NFS4CLNT_STATE_RECOVER, &clp->cl_state) != 0)
                 goto out;
         if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state) == 0)
                 goto out;
-        list_for_each_entry(delegation, &clp->cl_delegations, super_list) {
+        rcu_read_lock();
+        list_for_each_entry_rcu(delegation, &clp->cl_delegations, super_list) {
                 inode = igrab(delegation->inode);
                 if (inode == NULL)
                         continue;
+                spin_lock(&clp->cl_lock);
+                delegation = nfs_detach_delegation_locked(NFS_I(inode), NULL);
                 spin_unlock(&clp->cl_lock);
-                nfs_inode_return_delegation(inode);
+                rcu_read_unlock();
+                if (delegation)
+                        __nfs_inode_return_delegation(inode, delegation);
                 iput(inode);
                 goto restart;
         }
+        rcu_read_unlock();
 out:
-        spin_unlock(&clp->cl_lock);
         nfs_put_client(clp);
         module_put_and_exit(0);
 }
@@ -280,17 +321,21 @@ void nfs_handle_cb_pathdown(struct nfs_client *clp)
         if (clp == NULL)
                 return;
 restart:
-        spin_lock(&clp->cl_lock);
-        list_for_each_entry(delegation, &clp->cl_delegations, super_list) {
+        rcu_read_lock();
+        list_for_each_entry_rcu(delegation, &clp->cl_delegations, super_list) {
                 inode = igrab(delegation->inode);
                 if (inode == NULL)
                         continue;
+                spin_lock(&clp->cl_lock);
+                delegation = nfs_detach_delegation_locked(NFS_I(inode), NULL);
                 spin_unlock(&clp->cl_lock);
-                nfs_inode_return_delegation(inode);
+                rcu_read_unlock();
+                if (delegation != NULL)
+                        __nfs_inode_return_delegation(inode, delegation);
                 iput(inode);
                 goto restart;
         }
-        spin_unlock(&clp->cl_lock);
+        rcu_read_unlock();
 }
 
 struct recall_threadargs {
@@ -316,21 +361,14 @@ static int recall_thread(void *data)
         down_read(&clp->cl_sem);
         down_write(&nfsi->rwsem);
         spin_lock(&clp->cl_lock);
-        delegation = nfsi->delegation;
-        if (delegation != NULL && memcmp(delegation->stateid.data,
-                                args->stateid->data,
-                                sizeof(delegation->stateid.data)) == 0) {
-                list_del_init(&delegation->super_list);
-                nfsi->delegation = NULL;
-                nfsi->delegation_state = 0;
+        delegation = nfs_detach_delegation_locked(nfsi, args->stateid);
+        if (delegation != NULL)
                 args->result = 0;
-        } else {
-                delegation = NULL;
+        else
                 args->result = -ENOENT;
-        }
         spin_unlock(&clp->cl_lock);
         complete(&args->started);
-        nfs_delegation_claim_opens(inode);
+        nfs_delegation_claim_opens(inode, args->stateid);
         up_write(&nfsi->rwsem);
         up_read(&clp->cl_sem);
         nfs_msync_inode(inode);
@@ -371,14 +409,14 @@ struct inode *nfs_delegation_find_inode(struct nfs_client *clp, const struct nfs
 {
         struct nfs_delegation *delegation;
         struct inode *res = NULL;
-        spin_lock(&clp->cl_lock);
-        list_for_each_entry(delegation, &clp->cl_delegations, super_list) {
+        rcu_read_lock();
+        list_for_each_entry_rcu(delegation, &clp->cl_delegations, super_list) {
                 if (nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) {
                         res = igrab(delegation->inode);
                         break;
                 }
         }
-        spin_unlock(&clp->cl_lock);
+        rcu_read_unlock();
         return res;
 }
 
@@ -388,10 +426,10 @@ struct inode *nfs_delegation_find_inode(struct nfs_client *clp, const struct nfs
 void nfs_delegation_mark_reclaim(struct nfs_client *clp)
 {
         struct nfs_delegation *delegation;
-        spin_lock(&clp->cl_lock);
-        list_for_each_entry(delegation, &clp->cl_delegations, super_list)
+        rcu_read_lock();
+        list_for_each_entry_rcu(delegation, &clp->cl_delegations, super_list)
                 delegation->flags |= NFS_DELEGATION_NEED_RECLAIM;
-        spin_unlock(&clp->cl_lock);
+        rcu_read_unlock();
 }
 
 /*
@@ -399,39 +437,35 @@ void nfs_delegation_mark_reclaim(struct nfs_client *clp)
  */
 void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
 {
-        struct nfs_delegation *delegation, *n;
-        LIST_HEAD(head);
-        spin_lock(&clp->cl_lock);
-        list_for_each_entry_safe(delegation, n, &clp->cl_delegations, super_list) {
+        struct nfs_delegation *delegation;
+restart:
+        rcu_read_lock();
+        list_for_each_entry_rcu(delegation, &clp->cl_delegations, super_list) {
                 if ((delegation->flags & NFS_DELEGATION_NEED_RECLAIM) == 0)
                         continue;
-                list_move(&delegation->super_list, &head);
-                NFS_I(delegation->inode)->delegation = NULL;
-                NFS_I(delegation->inode)->delegation_state = 0;
-        }
-        spin_unlock(&clp->cl_lock);
-        while(!list_empty(&head)) {
-                delegation = list_entry(head.next, struct nfs_delegation, super_list);
-                list_del(&delegation->super_list);
-                nfs_free_delegation(delegation);
+                spin_lock(&clp->cl_lock);
+                delegation = nfs_detach_delegation_locked(NFS_I(delegation->inode), NULL);
+                spin_unlock(&clp->cl_lock);
+                rcu_read_unlock();
+                if (delegation != NULL)
+                        call_rcu(&delegation->rcu, nfs_free_delegation_callback);
+                goto restart;
         }
+        rcu_read_unlock();
 }
 
 int nfs4_copy_delegation_stateid(nfs4_stateid *dst, struct inode *inode)
 {
-        struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
         struct nfs_inode *nfsi = NFS_I(inode);
         struct nfs_delegation *delegation;
-        int res = 0;
+        int ret = 0;
 
-        if (nfsi->delegation_state == 0)
-                return 0;
-        spin_lock(&clp->cl_lock);
-        delegation = nfsi->delegation;
+        rcu_read_lock();
+        delegation = rcu_dereference(nfsi->delegation);
         if (delegation != NULL) {
                 memcpy(dst->data, delegation->stateid.data, sizeof(dst->data));
-                res = 1;
+                ret = 1;
         }
-        spin_unlock(&clp->cl_lock);
-        return res;
+        rcu_read_unlock();
+        return ret;
 }
diff --git a/fs/nfs/delegation.h b/fs/nfs/delegation.h
index 2cfd4b24c7f..5874ce7fdba 100644
--- a/fs/nfs/delegation.h
+++ b/fs/nfs/delegation.h
@@ -22,11 +22,12 @@ struct nfs_delegation {
         long flags;
         loff_t maxsize;
         __u64 change_attr;
+        struct rcu_head rcu;
 };
 
 int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct nfs_openres *res);
 void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred, struct nfs_openres *res);
-int __nfs_inode_return_delegation(struct inode *inode);
+int nfs_inode_return_delegation(struct inode *inode);
 int nfs_async_inode_return_delegation(struct inode *inode, const nfs4_stateid *stateid);
 
 struct inode *nfs_delegation_find_inode(struct nfs_client *clp, const struct nfs_fh *fhandle);
@@ -39,27 +40,24 @@ void nfs_delegation_reap_unclaimed(struct nfs_client *clp);
 
 /* NFSv4 delegation-related procedures */
 int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid);
-int nfs4_open_delegation_recall(struct dentry *dentry, struct nfs4_state *state);
+int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid);
 int nfs4_lock_delegation_recall(struct nfs4_state *state, struct file_lock *fl);
 int nfs4_copy_delegation_stateid(nfs4_stateid *dst, struct inode *inode);
 
 static inline int nfs_have_delegation(struct inode *inode, int flags)
 {
+        struct nfs_delegation *delegation;
+        int ret = 0;
+
         flags &= FMODE_READ|FMODE_WRITE;
-        smp_rmb();
-        if ((NFS_I(inode)->delegation_state & flags) == flags)
-                return 1;
-        return 0;
+        rcu_read_lock();
+        delegation = rcu_dereference(NFS_I(inode)->delegation);
+        if (delegation != NULL && (delegation->type & flags) == flags)
+                ret = 1;
+        rcu_read_unlock();
+        return ret;
 }
 
-static inline int nfs_inode_return_delegation(struct inode *inode)
-{
-        int err = 0;
-
-        if (NFS_I(inode)->delegation != NULL)
-                err = __nfs_inode_return_delegation(inode);
-        return err;
-}
 #else
 static inline int nfs_have_delegation(struct inode *inode, int flags)
 {
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index c27258b5d3e..322141f4ab4 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -897,14 +897,13 @@ int nfs_is_exclusive_create(struct inode *dir, struct nameidata *nd)
         return (nd->intent.open.flags & O_EXCL) != 0;
 }
 
-static inline int nfs_reval_fsid(struct vfsmount *mnt, struct inode *dir,
-                                 struct nfs_fh *fh, struct nfs_fattr *fattr)
+static inline int nfs_reval_fsid(struct inode *dir, const struct nfs_fattr *fattr)
 {
         struct nfs_server *server = NFS_SERVER(dir);
 
         if (!nfs_fsid_equal(&server->fsid, &fattr->fsid))
-                /* Revalidate fsid on root dir */
-                return __nfs_revalidate_inode(server, mnt->mnt_root->d_inode);
+                /* Revalidate fsid using the parent directory */
+                return __nfs_revalidate_inode(server, dir);
         return 0;
 }
 
@@ -946,7 +945,7 @@ static struct dentry *nfs_lookup(struct inode *dir, struct dentry * dentry, stru
                 res = ERR_PTR(error);
                 goto out_unlock;
         }
-        error = nfs_reval_fsid(nd->mnt, dir, &fhandle, &fattr);
+        error = nfs_reval_fsid(dir, &fattr);
         if (error < 0) {
                 res = ERR_PTR(error);
                 goto out_unlock;
@@ -1244,7 +1243,7 @@ static int nfs_create(struct inode *dir, struct dentry *dentry, int mode,
         attr.ia_mode = mode;
         attr.ia_valid = ATTR_MODE;
 
-        if (nd && (nd->flags & LOOKUP_CREATE))
+        if ((nd->flags & LOOKUP_CREATE) != 0)
                 open_flags = nd->intent.open.flags;
 
         lock_kernel();
@@ -1535,7 +1534,7 @@ static int nfs_symlink(struct inode *dir, struct dentry *dentry, const char *sym
 
         lock_kernel();
 
-        page = alloc_page(GFP_KERNEL);
+        page = alloc_page(GFP_HIGHUSER);
         if (!page) {
                 unlock_kernel();
                 return -ENOMEM;
@@ -1744,8 +1743,8 @@ int nfs_access_cache_shrinker(int nr_to_scan, gfp_t gfp_mask)
         struct nfs_inode *nfsi;
         struct nfs_access_entry *cache;
 
-        spin_lock(&nfs_access_lru_lock);
 restart:
+        spin_lock(&nfs_access_lru_lock);
         list_for_each_entry(nfsi, &nfs_access_lru_list, access_cache_inode_lru) {
                 struct inode *inode;
 
@@ -1770,6 +1769,7 @@ remove_lru_entry:
                         clear_bit(NFS_INO_ACL_LRU_SET, &nfsi->flags);
                 }
                 spin_unlock(&inode->i_lock);
+                spin_unlock(&nfs_access_lru_lock);
                 iput(inode);
                 goto restart;
         }
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index 00eee87510f..a5c82b6f3b4 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -266,7 +266,7 @@ static const struct rpc_call_ops nfs_read_direct_ops = {
 static ssize_t nfs_direct_read_schedule(struct nfs_direct_req *dreq, unsigned long user_addr, size_t count, loff_t pos)
 {
         struct nfs_open_context *ctx = dreq->ctx;
-        struct inode *inode = ctx->dentry->d_inode;
+        struct inode *inode = ctx->path.dentry->d_inode;
         size_t rsize = NFS_SERVER(inode)->rsize;
         unsigned int pgbase;
         int result;
@@ -295,9 +295,14 @@ static ssize_t nfs_direct_read_schedule(struct nfs_direct_req *dreq, unsigned lo
                         break;
                 }
                 if ((unsigned)result < data->npages) {
-                        nfs_direct_release_pages(data->pagevec, result);
-                        nfs_readdata_release(data);
-                        break;
+                        bytes = result * PAGE_SIZE;
+                        if (bytes <= pgbase) {
+                                nfs_direct_release_pages(data->pagevec, result);
+                                nfs_readdata_release(data);
+                                break;
+                        }
+                        bytes -= pgbase;
+                        data->npages = result;
                 }
 
                 get_dreq(dreq);
@@ -601,7 +606,7 @@ static const struct rpc_call_ops nfs_write_direct_ops = {
 static ssize_t nfs_direct_write_schedule(struct nfs_direct_req *dreq, unsigned long user_addr, size_t count, loff_t pos, int sync)
 {
         struct nfs_open_context *ctx = dreq->ctx;
-        struct inode *inode = ctx->dentry->d_inode;
+        struct inode *inode = ctx->path.dentry->d_inode;
         size_t wsize = NFS_SERVER(inode)->wsize;
         unsigned int pgbase;
         int result;
@@ -630,9 +635,14 @@ static ssize_t nfs_direct_write_schedule(struct nfs_direct_req *dreq, unsigned l
                         break;
                 }
                 if ((unsigned)result < data->npages) {
-                        nfs_direct_release_pages(data->pagevec, result);
-                        nfs_writedata_release(data);
-                        break;
+                        bytes = result * PAGE_SIZE;
+                        if (bytes <= pgbase) {
+                                nfs_direct_release_pages(data->pagevec, result);
+                                nfs_writedata_release(data);
+                                break;
+                        }
+                        bytes -= pgbase;
+                        data->npages = result;
                 }
 
                 get_dreq(dreq);
@@ -763,10 +773,8 @@ ssize_t nfs_file_direct_read(struct kiocb *iocb, const struct iovec *iov,
                 (unsigned long) count, (long long) pos);
 
         if (nr_segs != 1)
-                return -EINVAL;
-
-        if (count < 0)
                 goto out;
+
         retval = -EFAULT;
         if (!access_ok(VERIFY_WRITE, buf, count))
                 goto out;
@@ -814,7 +822,7 @@ out:
 ssize_t nfs_file_direct_write(struct kiocb *iocb, const struct iovec *iov,
                                 unsigned long nr_segs, loff_t pos)
 {
-        ssize_t retval;
+        ssize_t retval = -EINVAL;
         struct file *file = iocb->ki_filp;
         struct address_space *mapping = file->f_mapping;
         /* XXX: temporary */
@@ -827,7 +835,7 @@ ssize_t nfs_file_direct_write(struct kiocb *iocb, const struct iovec *iov,
                 (unsigned long) count, (long long) pos);
 
         if (nr_segs != 1)
-                return -EINVAL;
+                goto out;
 
         retval = generic_write_checks(file, &pos, &count, 0);
         if (retval)
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index bd9f5a83659..3d9fccf4ef9 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -461,14 +461,14 @@ static struct nfs_open_context *alloc_nfs_open_context(struct vfsmount *mnt, str
 
         ctx = kmalloc(sizeof(*ctx), GFP_KERNEL);
         if (ctx != NULL) {
-                atomic_set(&ctx->count, 1);
-                ctx->dentry = dget(dentry);
-                ctx->vfsmnt = mntget(mnt);
+                ctx->path.dentry = dget(dentry);
+                ctx->path.mnt = mntget(mnt);
                 ctx->cred = get_rpccred(cred);
                 ctx->state = NULL;
                 ctx->lockowner = current->files;
                 ctx->error = 0;
                 ctx->dir_cookie = 0;
+                kref_init(&ctx->kref);
         }
         return ctx;
 }
@@ -476,27 +476,33 @@ static struct nfs_open_context *alloc_nfs_open_context(struct vfsmount *mnt, str
 struct nfs_open_context *get_nfs_open_context(struct nfs_open_context *ctx)
 {
         if (ctx != NULL)
-                atomic_inc(&ctx->count);
+                kref_get(&ctx->kref);
         return ctx;
 }
 
-void put_nfs_open_context(struct nfs_open_context *ctx)
+static void nfs_free_open_context(struct kref *kref)
 {
-        if (atomic_dec_and_test(&ctx->count)) {
-                if (!list_empty(&ctx->list)) {
-                        struct inode *inode = ctx->dentry->d_inode;
-                        spin_lock(&inode->i_lock);
-                        list_del(&ctx->list);
-                        spin_unlock(&inode->i_lock);
-                }
-                if (ctx->state != NULL)
-                        nfs4_close_state(ctx->state, ctx->mode);
-                if (ctx->cred != NULL)
-                        put_rpccred(ctx->cred);
-                dput(ctx->dentry);
-                mntput(ctx->vfsmnt);
-                kfree(ctx);
+        struct nfs_open_context *ctx = container_of(kref,
+                        struct nfs_open_context, kref);
+
+        if (!list_empty(&ctx->list)) {
+                struct inode *inode = ctx->path.dentry->d_inode;
+                spin_lock(&inode->i_lock);
+                list_del(&ctx->list);
+                spin_unlock(&inode->i_lock);
         }
+        if (ctx->state != NULL)
+                nfs4_close_state(&ctx->path, ctx->state, ctx->mode);
+        if (ctx->cred != NULL)
+                put_rpccred(ctx->cred);
+        dput(ctx->path.dentry);
+        mntput(ctx->path.mnt);
+        kfree(ctx);
+}
+
+void put_nfs_open_context(struct nfs_open_context *ctx)
+{
+        kref_put(&ctx->kref, nfs_free_open_context);
 }
 
 /*
@@ -961,8 +967,8 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                 goto out_changed;
 
         server = NFS_SERVER(inode);
-        /* Update the fsid if and only if this is the root directory */
-        if (inode == inode->i_sb->s_root->d_inode
+        /* Update the fsid? */
+        if (S_ISDIR(inode->i_mode)
                         && !nfs_fsid_equal(&server->fsid, &fattr->fsid))
                 server->fsid = fattr->fsid;
 
@@ -1066,8 +1072,10 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
                 invalid &= ~NFS_INO_INVALID_DATA;
         if (data_stable)
                 invalid &= ~(NFS_INO_INVALID_ATTR|NFS_INO_INVALID_ATIME|NFS_INO_REVAL_PAGECACHE);
-        if (!nfs_have_delegation(inode, FMODE_READ))
+        if (!nfs_have_delegation(inode, FMODE_READ) ||
+                        (nfsi->cache_validity & NFS_INO_REVAL_FORCED))
                 nfsi->cache_validity |= invalid;
+        nfsi->cache_validity &= ~NFS_INO_REVAL_FORCED;
 
         return 0;
  out_changed:
@@ -1103,27 +1111,10 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
  */
 void nfs4_clear_inode(struct inode *inode)
 {
-        struct nfs_inode *nfsi = NFS_I(inode);
-
         /* If we are holding a delegation, return it! */
         nfs_inode_return_delegation(inode);
         /* First call standard NFS clear_inode() code */
         nfs_clear_inode(inode);
-        /* Now clear out any remaining state */
-        while (!list_empty(&nfsi->open_states)) {
-                struct nfs4_state *state;
-                
-                state = list_entry(nfsi->open_states.next,
-                                struct nfs4_state,
-                                inode_states);
-                dprintk("%s(%s/%Ld): found unclaimed NFSv4 state %p\n",
-                                __FUNCTION__,
-                                inode->i_sb->s_id,
-                                (long long)NFS_FILEID(inode),
-                                state);
-                BUG_ON(atomic_read(&state->count) != 1);
-                nfs4_close_state(state, state->state);
-        }
 }
 #endif
 
@@ -1165,15 +1156,11 @@ static void init_once(void * foo, struct kmem_cache * cachep, unsigned long flag
         struct nfs_inode *nfsi = (struct nfs_inode *) foo;
 
         inode_init_once(&nfsi->vfs_inode);
-        spin_lock_init(&nfsi->req_lock);
-        INIT_LIST_HEAD(&nfsi->dirty);
-        INIT_LIST_HEAD(&nfsi->commit);
         INIT_LIST_HEAD(&nfsi->open_files);
         INIT_LIST_HEAD(&nfsi->access_cache_entry_lru);
         INIT_LIST_HEAD(&nfsi->access_cache_inode_lru);
         INIT_RADIX_TREE(&nfsi->nfs_page_tree, GFP_ATOMIC);
         atomic_set(&nfsi->data_updates, 0);
-        nfsi->ndirty = 0;
         nfsi->ncommit = 0;
         nfsi->npages = 0;
         nfs4_init_once(nfsi);
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index ad2b40db1e6..76cf55d5710 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -183,9 +183,9 @@ unsigned long nfs_block_bits(unsigned long bsize, unsigned char *nrbitsp)
 /*
  * Calculate the number of 512byte blocks used.
  */
-static inline unsigned long nfs_calc_block_size(u64 tsize)
+static inline blkcnt_t nfs_calc_block_size(u64 tsize)
 {
-        loff_t used = (tsize + 511) >> 9;
+        blkcnt_t used = (tsize + 511) >> 9;
         return (used > ULONG_MAX) ? ULONG_MAX : used;
 }
 
diff --git a/fs/nfs/mount_clnt.c b/fs/nfs/mount_clnt.c
index ca5a266a314..8afd9f7e7a9 100644
--- a/fs/nfs/mount_clnt.c
+++ b/fs/nfs/mount_clnt.c
@@ -1,7 +1,5 @@
 /*
- * linux/fs/nfs/mount_clnt.c
- *
- * MOUNT client to support NFSroot.
+ * In-kernel MOUNT protocol client
  *
  * Copyright (C) 1997, Olaf Kirch <okir@monad.swb.de>
  */
@@ -18,33 +16,31 @@
 #include <linux/nfs_fs.h>
 
 #ifdef RPC_DEBUG
-# define NFSDBG_FACILITY        NFSDBG_ROOT
+# define NFSDBG_FACILITY        NFSDBG_MOUNT
 #endif
 
-/*
-#define MOUNT_PROGRAM           100005
-#define MOUNT_VERSION           1
-#define MOUNT_MNT               1
-#define MOUNT_UMNT              3
- */
-
-static struct rpc_clnt *        mnt_create(char *, struct sockaddr_in *,
-                                                                int, int);
 static struct rpc_program       mnt_program;
 
 struct mnt_fhstatus {
-        unsigned int            status;
-        struct nfs_fh *         fh;
+        u32 status;
+        struct nfs_fh *fh;
 };
 
-/*
- * Obtain an NFS file handle for the given host and path
+/**
+ * nfs_mount - Obtain an NFS file handle for the given host and path
+ * @addr: pointer to server's address
+ * @len: size of server's address
+ * @hostname: name of server host, or NULL
+ * @path: pointer to string containing export path to mount
+ * @version: mount version to use for this request
+ * @protocol: transport protocol to use for thie request
+ * @fh: pointer to location to place returned file handle
+ *
+ * Uses default timeout parameters specified by underlying transport.
  */
-int
-nfsroot_mount(struct sockaddr_in *addr, char *path, struct nfs_fh *fh,
-                int version, int protocol)
+int nfs_mount(struct sockaddr *addr, size_t len, char *hostname, char *path,
+              int version, int protocol, struct nfs_fh *fh)
 {
-        struct rpc_clnt         *mnt_clnt;
         struct mnt_fhstatus     result = {
                 .fh             = fh
         };
@@ -52,16 +48,25 @@ nfsroot_mount(struct sockaddr_in *addr, char *path, struct nfs_fh *fh,
                 .rpc_argp       = path,
                 .rpc_resp       = &result,
         };
-        char                    hostname[32];
+        struct rpc_create_args args = {
+                .protocol       = protocol,
+                .address        = addr,
+                .addrsize       = len,
+                .servername     = hostname,
+                .program        = &mnt_program,
+                .version        = version,
+                .authflavor     = RPC_AUTH_UNIX,
+                .flags          = RPC_CLNT_CREATE_INTR,
+        };
+        struct rpc_clnt         *mnt_clnt;
         int                     status;
 
-        dprintk("NFS:      nfs_mount(%08x:%s)\n",
-                        (unsigned)ntohl(addr->sin_addr.s_addr), path);
+        dprintk("NFS: sending MNT request for %s:%s\n",
+                (hostname ? hostname : "server"), path);
 
-        sprintf(hostname, "%u.%u.%u.%u", NIPQUAD(addr->sin_addr.s_addr));
-        mnt_clnt = mnt_create(hostname, addr, version, protocol);
+        mnt_clnt = rpc_create(&args);
         if (IS_ERR(mnt_clnt))
-                return PTR_ERR(mnt_clnt);
+                goto out_clnt_err;
 
         if (version == NFS_MNT3_VERSION)
                 msg.rpc_proc = &mnt_clnt->cl_procinfo[MOUNTPROC3_MNT];
@@ -69,33 +74,39 @@ nfsroot_mount(struct sockaddr_in *addr, char *path, struct nfs_fh *fh,
                 msg.rpc_proc = &mnt_clnt->cl_procinfo[MNTPROC_MNT];
 
         status = rpc_call_sync(mnt_clnt, &msg, 0);
-        return status < 0? status : (result.status? -EACCES : 0);
-}
+        rpc_shutdown_client(mnt_clnt);
 
-static struct rpc_clnt *
-mnt_create(char *hostname, struct sockaddr_in *srvaddr, int version,
-                int protocol)
-{
-        struct rpc_create_args args = {
-                .protocol       = protocol,
-                .address        = (struct sockaddr *)srvaddr,
-                .addrsize       = sizeof(*srvaddr),
-                .servername     = hostname,
-                .program        = &mnt_program,
-                .version        = version,
-                .authflavor     = RPC_AUTH_UNIX,
-                .flags          = (RPC_CLNT_CREATE_ONESHOT |
-                                   RPC_CLNT_CREATE_INTR),
-        };
+        if (status < 0)
+                goto out_call_err;
+        if (result.status != 0)
+                goto out_mnt_err;
+
+        dprintk("NFS: MNT request succeeded\n");
+        status = 0;
+
+out:
+        return status;
+
+out_clnt_err:
+        status = PTR_ERR(mnt_clnt);
+        dprintk("NFS: failed to create RPC client, status=%d\n", status);
+        goto out;
+
+out_call_err:
+        dprintk("NFS: failed to start MNT request, status=%d\n", status);
+        goto out;
 
-        return rpc_create(&args);
+out_mnt_err:
+        dprintk("NFS: MNT server returned result %d\n", result.status);
+        status = -EACCES;
+        goto out;
 }
 
 /*
  * XDR encode/decode functions for MOUNT
  */
-static int
-xdr_encode_dirpath(struct rpc_rqst *req, __be32 *p, const char *path)
+static int xdr_encode_dirpath(struct rpc_rqst *req, __be32 *p,
+                              const char *path)
 {
         p = xdr_encode_string(p, path);
 
@@ -103,8 +114,8 @@ xdr_encode_dirpath(struct rpc_rqst *req, __be32 *p, const char *path)
         return 0;
 }
 
-static int
-xdr_decode_fhstatus(struct rpc_rqst *req, __be32 *p, struct mnt_fhstatus *res)
+static int xdr_decode_fhstatus(struct rpc_rqst *req, __be32 *p,
+                               struct mnt_fhstatus *res)
 {
         struct nfs_fh *fh = res->fh;
 
@@ -115,8 +126,8 @@ xdr_decode_fhstatus(struct rpc_rqst *req, __be32 *p, struct mnt_fhstatus *res)
         return 0;
 }
 
-static int
-xdr_decode_fhstatus3(struct rpc_rqst *req, __be32 *p, struct mnt_fhstatus *res)
+static int xdr_decode_fhstatus3(struct rpc_rqst *req, __be32 *p,
+                                struct mnt_fhstatus *res)
 {
         struct nfs_fh *fh = res->fh;
 
@@ -135,53 +146,53 @@ xdr_decode_fhstatus3(struct rpc_rqst *req, __be32 *p, struct mnt_fhstatus *res)
 #define MNT_fhstatus_sz         (1 + 8)
 #define MNT_fhstatus3_sz        (1 + 16)
 
-static struct rpc_procinfo      mnt_procedures[] = {
-[MNTPROC_MNT] = {
-          .p_proc               = MNTPROC_MNT,
-          .p_encode             = (kxdrproc_t) xdr_encode_dirpath,      
-          .p_decode             = (kxdrproc_t) xdr_decode_fhstatus,
-          .p_arglen             = MNT_dirpath_sz,
-          .p_replen             = MNT_fhstatus_sz,
-          .p_statidx            = MNTPROC_MNT,
-          .p_name               = "MOUNT",
+static struct rpc_procinfo mnt_procedures[] = {
+        [MNTPROC_MNT] = {
+                .p_proc         = MNTPROC_MNT,
+                .p_encode       = (kxdrproc_t) xdr_encode_dirpath,
+                .p_decode       = (kxdrproc_t) xdr_decode_fhstatus,
+                .p_arglen       = MNT_dirpath_sz,
+                .p_replen       = MNT_fhstatus_sz,
+                .p_statidx      = MNTPROC_MNT,
+                .p_name         = "MOUNT",
         },
 };
 
 static struct rpc_procinfo mnt3_procedures[] = {
-[MOUNTPROC3_MNT] = {
-          .p_proc               = MOUNTPROC3_MNT,
-          .p_encode             = (kxdrproc_t) xdr_encode_dirpath,
-          .p_decode             = (kxdrproc_t) xdr_decode_fhstatus3,
-          .p_arglen             = MNT_dirpath_sz,
-          .p_replen             = MNT_fhstatus3_sz,
-          .p_statidx            = MOUNTPROC3_MNT,
-          .p_name               = "MOUNT",
+        [MOUNTPROC3_MNT] = {
+                .p_proc         = MOUNTPROC3_MNT,
+                .p_encode       = (kxdrproc_t) xdr_encode_dirpath,
+                .p_decode       = (kxdrproc_t) xdr_decode_fhstatus3,
+                .p_arglen       = MNT_dirpath_sz,
+                .p_replen       = MNT_fhstatus3_sz,
+                .p_statidx      = MOUNTPROC3_MNT,
+                .p_name         = "MOUNT",
         },
 };
 
 
-static struct rpc_version       mnt_version1 = {
-                .number         = 1,
-                .nrprocs        = 2,
-                .procs          = mnt_procedures
+static struct rpc_version mnt_version1 = {
+        .number         = 1,
+        .nrprocs        = 2,
+        .procs          = mnt_procedures,
 };
 
-static struct rpc_version       mnt_version3 = {
-                .number         = 3,
-                .nrprocs        = 2,
-                .procs          = mnt3_procedures
+static struct rpc_version mnt_version3 = {
+        .number         = 3,
+        .nrprocs        = 2,
+        .procs          = mnt3_procedures,
 };
 
-static struct rpc_version *     mnt_version[] = {
+static struct rpc_version *mnt_version[] = {
         NULL,
         &mnt_version1,
         NULL,
         &mnt_version3,
 };
 
-static struct rpc_stat          mnt_stats;
+static struct rpc_stat mnt_stats;
 
-static struct rpc_program       mnt_program = {
+static struct rpc_program mnt_program = {
         .name           = "mount",
         .number         = NFS_MNT_PROGRAM,
         .nrvers         = ARRAY_SIZE(mnt_version),
diff --git a/fs/nfs/nfs2xdr.c b/fs/nfs/nfs2xdr.c
index cd3ca7b5d3d..7fcc78f2aa7 100644
--- a/fs/nfs/nfs2xdr.c
+++ b/fs/nfs/nfs2xdr.c
@@ -223,7 +223,7 @@ nfs_xdr_diropargs(struct rpc_rqst *req, __be32 *p, struct nfs_diropargs *args)
 static int
 nfs_xdr_readargs(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args)
 {
-        struct rpc_auth *auth = req->rq_task->tk_auth;
+        struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
         unsigned int replen;
         u32 offset = (u32)args->offset;
         u32 count = args->count;
@@ -380,7 +380,7 @@ static int
 nfs_xdr_readdirargs(struct rpc_rqst *req, __be32 *p, struct nfs_readdirargs *args)
 {
         struct rpc_task *task = req->rq_task;
-        struct rpc_auth *auth = task->tk_auth;
+        struct rpc_auth *auth = task->tk_msg.rpc_cred->cr_auth;
         unsigned int replen;
         u32 count = args->count;
 
@@ -541,7 +541,7 @@ nfs_xdr_diropres(struct rpc_rqst *req, __be32 *p, struct nfs_diropok *res)
 static int
 nfs_xdr_readlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs_readlinkargs *args)
 {
-        struct rpc_auth *auth = req->rq_task->tk_auth;
+        struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
         unsigned int replen;
 
         p = xdr_encode_fhandle(p, args->fh);
diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index 45268d6def2..814d886b6aa 100644
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -335,9 +335,7 @@ again:
                  * not sure this buys us anything (and I'd have
                  * to revamp the NFSv3 XDR code) */
                 status = nfs3_proc_setattr(dentry, &fattr, sattr);
-                if (status == 0)
-                        nfs_setattr_update_inode(dentry->d_inode, sattr);
-                nfs_refresh_inode(dentry->d_inode, &fattr);
+                nfs_post_op_update_inode(dentry->d_inode, &fattr);
                 dprintk("NFS reply setattr (post-create): %d\n", status);
         }
         if (status != 0)
diff --git a/fs/nfs/nfs3xdr.c b/fs/nfs/nfs3xdr.c
index b51df8eb9f0..b4647a22f34 100644
--- a/fs/nfs/nfs3xdr.c
+++ b/fs/nfs/nfs3xdr.c
@@ -319,7 +319,7 @@ nfs3_xdr_accessargs(struct rpc_rqst *req, __be32 *p, struct nfs3_accessargs *arg
 static int
 nfs3_xdr_readargs(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args)
 {
-        struct rpc_auth *auth = req->rq_task->tk_auth;
+        struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
         unsigned int replen;
         u32 count = args->count;
 
@@ -458,7 +458,7 @@ nfs3_xdr_linkargs(struct rpc_rqst *req, __be32 *p, struct nfs3_linkargs *args)
 static int
 nfs3_xdr_readdirargs(struct rpc_rqst *req, __be32 *p, struct nfs3_readdirargs *args)
 {
-        struct rpc_auth *auth = req->rq_task->tk_auth;
+        struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
         unsigned int replen;
         u32 count = args->count;
 
@@ -643,7 +643,7 @@ static int
 nfs3_xdr_getaclargs(struct rpc_rqst *req, __be32 *p,
                     struct nfs3_getaclargs *args)
 {
-        struct rpc_auth *auth = req->rq_task->tk_auth;
+        struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
         unsigned int replen;
 
         p = xdr_encode_fhandle(p, args->fh);
@@ -773,7 +773,7 @@ nfs3_xdr_accessres(struct rpc_rqst *req, __be32 *p, struct nfs3_accessres *res)
 static int
 nfs3_xdr_readlinkargs(struct rpc_rqst *req, __be32 *p, struct nfs3_readlinkargs *args)
 {
-        struct rpc_auth *auth = req->rq_task->tk_auth;
+        struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
         unsigned int replen;
 
         p = xdr_encode_fhandle(p, args->fh);
diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index cf3a17eb5c0..6c028e734fe 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -70,19 +70,26 @@ static inline void nfs_confirm_seqid(struct nfs_seqid_counter *seqid, int status
                 seqid->flags |= NFS_SEQID_CONFIRMED;
 }
 
+struct nfs_unique_id {
+        struct rb_node rb_node;
+        __u64 id;
+};
+
 /*
  * NFS4 state_owners and lock_owners are simply labels for ordered
  * sequences of RPC calls. Their sole purpose is to provide once-only
  * semantics by allowing the server to identify replayed requests.
  */
 struct nfs4_state_owner {
-        spinlock_t           so_lock;
-        struct list_head     so_list;    /* per-clientid list of state_owners */
+        struct nfs_unique_id so_owner_id;
         struct nfs_client    *so_client;
-        u32                  so_id;      /* 32-bit identifier, unique */
-        atomic_t             so_count;
+        struct nfs_server    *so_server;
+        struct rb_node       so_client_node;
 
         struct rpc_cred      *so_cred;   /* Associated cred */
+
+        spinlock_t           so_lock;
+        atomic_t             so_count;
         struct list_head     so_states;
         struct list_head     so_delegations;
         struct nfs_seqid_counter so_seqid;
@@ -108,7 +115,7 @@ struct nfs4_lock_state {
 #define NFS_LOCK_INITIALIZED 1
         int                     ls_flags;
         struct nfs_seqid_counter        ls_seqid;
-        u32                     ls_id;
+        struct nfs_unique_id    ls_id;
         nfs4_stateid            ls_stateid;
         atomic_t                ls_count;
 };
@@ -116,7 +123,10 @@ struct nfs4_lock_state {
 /* bits for nfs4_state->flags */
 enum {
         LK_STATE_IN_USE,
-        NFS_DELEGATED_STATE,
+        NFS_DELEGATED_STATE,            /* Current stateid is delegation */
+        NFS_O_RDONLY_STATE,             /* OPEN stateid has read-only state */
+        NFS_O_WRONLY_STATE,             /* OPEN stateid has write-only state */
+        NFS_O_RDWR_STATE,               /* OPEN stateid has read/write state */
 };
 
 struct nfs4_state {
@@ -130,11 +140,14 @@ struct nfs4_state {
         unsigned long flags;            /* Do we hold any locks? */
         spinlock_t state_lock;          /* Protects the lock_states list */
 
-        nfs4_stateid stateid;
+        seqlock_t seqlock;              /* Protects the stateid/open_stateid */
+        nfs4_stateid stateid;           /* Current stateid: may be delegation */
+        nfs4_stateid open_stateid;      /* OPEN stateid */
 
-        unsigned int n_rdonly;
-        unsigned int n_wronly;
-        unsigned int n_rdwr;
+        /* The following 3 fields are protected by owner->so_lock */
+        unsigned int n_rdonly;          /* Number of read-only references */
+        unsigned int n_wronly;          /* Number of write-only references */
+        unsigned int n_rdwr;            /* Number of read/write references */
         int state;                      /* State on the server (R,W, or RW) */
         atomic_t count;
 };
@@ -165,7 +178,7 @@ extern int nfs4_proc_setclientid(struct nfs_client *, u32, unsigned short, struc
 extern int nfs4_proc_setclientid_confirm(struct nfs_client *, struct rpc_cred *);
 extern int nfs4_proc_async_renew(struct nfs_client *, struct rpc_cred *);
 extern int nfs4_proc_renew(struct nfs_client *, struct rpc_cred *);
-extern int nfs4_do_close(struct inode *inode, struct nfs4_state *state);
+extern int nfs4_do_close(struct path *path, struct nfs4_state *state);
 extern struct dentry *nfs4_atomic_open(struct inode *, struct dentry *, struct nameidata *);
 extern int nfs4_open_revalidate(struct inode *, struct dentry *, int, struct nameidata *);
 extern int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle);
@@ -189,14 +202,13 @@ extern void nfs4_renew_state(struct work_struct *);
 
 /* nfs4state.c */
 struct rpc_cred *nfs4_get_renew_cred(struct nfs_client *clp);
-extern u32 nfs4_alloc_lockowner_id(struct nfs_client *);
 
 extern struct nfs4_state_owner * nfs4_get_state_owner(struct nfs_server *, struct rpc_cred *);
 extern void nfs4_put_state_owner(struct nfs4_state_owner *);
 extern void nfs4_drop_state_owner(struct nfs4_state_owner *);
 extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state_owner *);
 extern void nfs4_put_open_state(struct nfs4_state *);
-extern void nfs4_close_state(struct nfs4_state *, mode_t);
+extern void nfs4_close_state(struct path *, struct nfs4_state *, mode_t);
 extern void nfs4_state_set_mode_locked(struct nfs4_state *, mode_t);
 extern void nfs4_schedule_state_recovery(struct nfs_client *);
 extern void nfs4_put_lock_state(struct nfs4_lock_state *lsp);
@@ -222,7 +234,7 @@ extern struct svc_version nfs4_callback_version1;
 
 #else
 
-#define nfs4_close_state(a, b) do { } while (0)
+#define nfs4_close_state(a, b, c) do { } while (0)
 
 #endif /* CONFIG_NFS_V4 */
 #endif /* __LINUX_FS_NFS_NFS4_FS.H */
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index 648e0ac0f90..fee2da856c9 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -65,6 +65,7 @@ static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *)
 static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry);
 static int nfs4_handle_exception(const struct nfs_server *server, int errorcode, struct nfs4_exception *exception);
 static int nfs4_wait_clnt_recover(struct rpc_clnt *clnt, struct nfs_client *clp);
+static int _nfs4_do_access(struct inode *inode, struct rpc_cred *cred, int openflags);
 
 /* Prevent leaks of NFSv4 errors into userland */
 int nfs4_map_errors(int err)
@@ -214,27 +215,39 @@ static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo)
 }
 
 struct nfs4_opendata {
-        atomic_t count;
+        struct kref kref;
         struct nfs_openargs o_arg;
         struct nfs_openres o_res;
         struct nfs_open_confirmargs c_arg;
         struct nfs_open_confirmres c_res;
         struct nfs_fattr f_attr;
         struct nfs_fattr dir_attr;
-        struct dentry *dentry;
+        struct path path;
         struct dentry *dir;
         struct nfs4_state_owner *owner;
+        struct nfs4_state *state;
         struct iattr attrs;
         unsigned long timestamp;
+        unsigned int rpc_done : 1;
         int rpc_status;
         int cancelled;
 };
 
-static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
+
+static void nfs4_init_opendata_res(struct nfs4_opendata *p)
+{
+        p->o_res.f_attr = &p->f_attr;
+        p->o_res.dir_attr = &p->dir_attr;
+        p->o_res.server = p->o_arg.server;
+        nfs_fattr_init(&p->f_attr);
+        nfs_fattr_init(&p->dir_attr);
+}
+
+static struct nfs4_opendata *nfs4_opendata_alloc(struct path *path,
                 struct nfs4_state_owner *sp, int flags,
                 const struct iattr *attrs)
 {
-        struct dentry *parent = dget_parent(dentry);
+        struct dentry *parent = dget_parent(path->dentry);
         struct inode *dir = parent->d_inode;
         struct nfs_server *server = NFS_SERVER(dir);
         struct nfs4_opendata *p;
@@ -245,24 +258,19 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
         p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid);
         if (p->o_arg.seqid == NULL)
                 goto err_free;
-        atomic_set(&p->count, 1);
-        p->dentry = dget(dentry);
+        p->path.mnt = mntget(path->mnt);
+        p->path.dentry = dget(path->dentry);
         p->dir = parent;
         p->owner = sp;
         atomic_inc(&sp->so_count);
         p->o_arg.fh = NFS_FH(dir);
         p->o_arg.open_flags = flags,
         p->o_arg.clientid = server->nfs_client->cl_clientid;
-        p->o_arg.id = sp->so_id;
-        p->o_arg.name = &dentry->d_name;
+        p->o_arg.id = sp->so_owner_id.id;
+        p->o_arg.name = &p->path.dentry->d_name;
         p->o_arg.server = server;
         p->o_arg.bitmask = server->attr_bitmask;
         p->o_arg.claim = NFS4_OPEN_CLAIM_NULL;
-        p->o_res.f_attr = &p->f_attr;
-        p->o_res.dir_attr = &p->dir_attr;
-        p->o_res.server = server;
-        nfs_fattr_init(&p->f_attr);
-        nfs_fattr_init(&p->dir_attr);
         if (flags & O_EXCL) {
                 u32 *s = (u32 *) p->o_arg.u.verifier.data;
                 s[0] = jiffies;
@@ -274,6 +282,8 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
         p->c_arg.fh = &p->o_res.fh;
         p->c_arg.stateid = &p->o_res.stateid;
         p->c_arg.seqid = p->o_arg.seqid;
+        nfs4_init_opendata_res(p);
+        kref_init(&p->kref);
         return p;
 err_free:
         kfree(p);
@@ -282,27 +292,25 @@ err:
         return NULL;
 }
 
-static void nfs4_opendata_free(struct nfs4_opendata *p)
+static void nfs4_opendata_free(struct kref *kref)
 {
-        if (p != NULL && atomic_dec_and_test(&p->count)) {
-                nfs_free_seqid(p->o_arg.seqid);
-                nfs4_put_state_owner(p->owner);
-                dput(p->dir);
-                dput(p->dentry);
-                kfree(p);
-        }
+        struct nfs4_opendata *p = container_of(kref,
+                        struct nfs4_opendata, kref);
+
+        nfs_free_seqid(p->o_arg.seqid);
+        if (p->state != NULL)
+                nfs4_put_open_state(p->state);
+        nfs4_put_state_owner(p->owner);
+        dput(p->dir);
+        dput(p->path.dentry);
+        mntput(p->path.mnt);
+        kfree(p);
 }
 
-/* Helper for asynchronous RPC calls */
-static int nfs4_call_async(struct rpc_clnt *clnt,
-                const struct rpc_call_ops *tk_ops, void *calldata)
+static void nfs4_opendata_put(struct nfs4_opendata *p)
 {
-        struct rpc_task *task;
-
-        if (!(task = rpc_new_task(clnt, RPC_TASK_ASYNC, tk_ops, calldata)))
-                return -ENOMEM;
-        rpc_execute(task);
-        return 0;
+        if (p != NULL)
+                kref_put(&p->kref, nfs4_opendata_free);
 }
 
 static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)
@@ -316,7 +324,34 @@ static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)
         return ret;
 }
 
-static inline void update_open_stateflags(struct nfs4_state *state, mode_t open_flags)
+static int can_open_cached(struct nfs4_state *state, int mode)
+{
+        int ret = 0;
+        switch (mode & (FMODE_READ|FMODE_WRITE|O_EXCL)) {
+                case FMODE_READ:
+                        ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0;
+                        ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0;
+                        break;
+                case FMODE_WRITE:
+                        ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0;
+                        ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0;
+                        break;
+                case FMODE_READ|FMODE_WRITE:
+                        ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0;
+        }
+        return ret;
+}
+
+static int can_open_delegated(struct nfs_delegation *delegation, mode_t open_flags)
+{
+        if ((delegation->type & open_flags) != open_flags)
+                return 0;
+        if (delegation->flags & NFS_DELEGATION_NEED_RECLAIM)
+                return 0;
+        return 1;
+}
+
+static void update_open_stateflags(struct nfs4_state *state, mode_t open_flags)
 {
         switch (open_flags) {
                 case FMODE_WRITE:
@@ -328,41 +363,176 @@ static inline void update_open_stateflags(struct nfs4_state *state, mode_t open_
                 case FMODE_READ|FMODE_WRITE:
                         state->n_rdwr++;
         }
+        nfs4_state_set_mode_locked(state, state->state | open_flags);
 }
 
-static void update_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, int open_flags)
+static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, int open_flags)
 {
-        struct inode *inode = state->inode;
+        if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
+                memcpy(state->stateid.data, stateid->data, sizeof(state->stateid.data));
+        memcpy(state->open_stateid.data, stateid->data, sizeof(state->open_stateid.data));
+        switch (open_flags) {
+                case FMODE_READ:
+                        set_bit(NFS_O_RDONLY_STATE, &state->flags);
+                        break;
+                case FMODE_WRITE:
+                        set_bit(NFS_O_WRONLY_STATE, &state->flags);
+                        break;
+                case FMODE_READ|FMODE_WRITE:
+                        set_bit(NFS_O_RDWR_STATE, &state->flags);
+        }
+}
+
+static void nfs_set_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, int open_flags)
+{
+        write_seqlock(&state->seqlock);
+        nfs_set_open_stateid_locked(state, stateid, open_flags);
+        write_sequnlock(&state->seqlock);
+}
 
+static void update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, nfs4_stateid *deleg_stateid, int open_flags)
+{
         open_flags &= (FMODE_READ|FMODE_WRITE);
-        /* Protect against nfs4_find_state_byowner() */
+        /*
+         * Protect the call to nfs4_state_set_mode_locked and
+         * serialise the stateid update
+         */
+        write_seqlock(&state->seqlock);
+        if (deleg_stateid != NULL) {
+                memcpy(state->stateid.data, deleg_stateid->data, sizeof(state->stateid.data));
+                set_bit(NFS_DELEGATED_STATE, &state->flags);
+        }
+        if (open_stateid != NULL)
+                nfs_set_open_stateid_locked(state, open_stateid, open_flags);
+        write_sequnlock(&state->seqlock);
         spin_lock(&state->owner->so_lock);
-        spin_lock(&inode->i_lock);
-        memcpy(&state->stateid, stateid, sizeof(state->stateid));
         update_open_stateflags(state, open_flags);
-        nfs4_state_set_mode_locked(state, state->state | open_flags);
-        spin_unlock(&inode->i_lock);
         spin_unlock(&state->owner->so_lock);
 }
 
+static void nfs4_return_incompatible_delegation(struct inode *inode, mode_t open_flags)
+{
+        struct nfs_delegation *delegation;
+
+        rcu_read_lock();
+        delegation = rcu_dereference(NFS_I(inode)->delegation);
+        if (delegation == NULL || (delegation->type & open_flags) == open_flags) {
+                rcu_read_unlock();
+                return;
+        }
+        rcu_read_unlock();
+        nfs_inode_return_delegation(inode);
+}
+
+static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
+{
+        struct nfs4_state *state = opendata->state;
+        struct nfs_inode *nfsi = NFS_I(state->inode);
+        struct nfs_delegation *delegation;
+        int open_mode = opendata->o_arg.open_flags & (FMODE_READ|FMODE_WRITE|O_EXCL);
+        nfs4_stateid stateid;
+        int ret = -EAGAIN;
+
+        rcu_read_lock();
+        delegation = rcu_dereference(nfsi->delegation);
+        for (;;) {
+                if (can_open_cached(state, open_mode)) {
+                        spin_lock(&state->owner->so_lock);
+                        if (can_open_cached(state, open_mode)) {
+                                update_open_stateflags(state, open_mode);
+                                spin_unlock(&state->owner->so_lock);
+                                rcu_read_unlock();
+                                goto out_return_state;
+                        }
+                        spin_unlock(&state->owner->so_lock);
+                }
+                if (delegation == NULL)
+                        break;
+                if (!can_open_delegated(delegation, open_mode))
+                        break;
+                /* Save the delegation */
+                memcpy(stateid.data, delegation->stateid.data, sizeof(stateid.data));
+                rcu_read_unlock();
+                lock_kernel();
+                ret = _nfs4_do_access(state->inode, state->owner->so_cred, open_mode);
+                unlock_kernel();
+                if (ret != 0)
+                        goto out;
+                ret = -EAGAIN;
+                rcu_read_lock();
+                delegation = rcu_dereference(nfsi->delegation);
+                /* If no delegation, try a cached open */
+                if (delegation == NULL)
+                        continue;
+                /* Is the delegation still valid? */
+                if (memcmp(stateid.data, delegation->stateid.data, sizeof(stateid.data)) != 0)
+                        continue;
+                rcu_read_unlock();
+                update_open_stateid(state, NULL, &stateid, open_mode);
+                goto out_return_state;
+        }
+        rcu_read_unlock();
+out:
+        return ERR_PTR(ret);
+out_return_state:
+        atomic_inc(&state->count);
+        return state;
+}
+
 static struct nfs4_state *nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
 {
         struct inode *inode;
         struct nfs4_state *state = NULL;
+        struct nfs_delegation *delegation;
+        nfs4_stateid *deleg_stateid = NULL;
+        int ret;
 
-        if (!(data->f_attr.valid & NFS_ATTR_FATTR))
+        if (!data->rpc_done) {
+                state = nfs4_try_open_cached(data);
                 goto out;
+        }
+
+        ret = -EAGAIN;
+        if (!(data->f_attr.valid & NFS_ATTR_FATTR))
+                goto err;
         inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr);
+        ret = PTR_ERR(inode);
         if (IS_ERR(inode))
-                goto out;
+                goto err;
+        ret = -ENOMEM;
         state = nfs4_get_open_state(inode, data->owner);
         if (state == NULL)
-                goto put_inode;
-        update_open_stateid(state, &data->o_res.stateid, data->o_arg.open_flags);
-put_inode:
+                goto err_put_inode;
+        if (data->o_res.delegation_type != 0) {
+                int delegation_flags = 0;
+
+                rcu_read_lock();
+                delegation = rcu_dereference(NFS_I(inode)->delegation);
+                if (delegation)
+                        delegation_flags = delegation->flags;
+                rcu_read_unlock();
+                if (!(delegation_flags & NFS_DELEGATION_NEED_RECLAIM))
+                        nfs_inode_set_delegation(state->inode,
+                                        data->owner->so_cred,
+                                        &data->o_res);
+                else
+                        nfs_inode_reclaim_delegation(state->inode,
+                                        data->owner->so_cred,
+                                        &data->o_res);
+        }
+        rcu_read_lock();
+        delegation = rcu_dereference(NFS_I(inode)->delegation);
+        if (delegation != NULL)
+                deleg_stateid = &delegation->stateid;
+        update_open_stateid(state, &data->o_res.stateid, deleg_stateid, data->o_arg.open_flags);
+        rcu_read_unlock();
         iput(inode);
 out:
         return state;
+err_put_inode:
+        iput(inode);
+err:
+        return ERR_PTR(ret);
 }
 
 static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state)
@@ -382,79 +552,66 @@ static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *
         return ERR_PTR(-ENOENT);
 }
 
-static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, mode_t openflags, nfs4_stateid *stateid)
+static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, mode_t openflags, struct nfs4_state **res)
 {
+        struct nfs4_state *newstate;
         int ret;
 
         opendata->o_arg.open_flags = openflags;
+        memset(&opendata->o_res, 0, sizeof(opendata->o_res));
+        memset(&opendata->c_res, 0, sizeof(opendata->c_res));
+        nfs4_init_opendata_res(opendata);
         ret = _nfs4_proc_open(opendata);
         if (ret != 0)
                 return ret; 
-        memcpy(stateid->data, opendata->o_res.stateid.data,
-                        sizeof(stateid->data));
+        newstate = nfs4_opendata_to_nfs4_state(opendata);
+        if (IS_ERR(newstate))
+                return PTR_ERR(newstate);
+        nfs4_close_state(&opendata->path, newstate, openflags);
+        *res = newstate;
         return 0;
 }
 
 static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state)
 {
-        nfs4_stateid stateid;
         struct nfs4_state *newstate;
-        int mode = 0;
-        int delegation = 0;
         int ret;
 
         /* memory barrier prior to reading state->n_* */
+        clear_bit(NFS_DELEGATED_STATE, &state->flags);
         smp_rmb();
         if (state->n_rdwr != 0) {
-                ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &stateid);
+                ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &newstate);
                 if (ret != 0)
                         return ret;
-                mode |= FMODE_READ|FMODE_WRITE;
-                if (opendata->o_res.delegation_type != 0)
-                        delegation = opendata->o_res.delegation_type;
-                smp_rmb();
+                if (newstate != state)
+                        return -ESTALE;
         }
         if (state->n_wronly != 0) {
-                ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &stateid);
+                ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &newstate);
                 if (ret != 0)
                         return ret;
-                mode |= FMODE_WRITE;
-                if (opendata->o_res.delegation_type != 0)
-                        delegation = opendata->o_res.delegation_type;
-                smp_rmb();
+                if (newstate != state)
+                        return -ESTALE;
         }
         if (state->n_rdonly != 0) {
-                ret = nfs4_open_recover_helper(opendata, FMODE_READ, &stateid);
+                ret = nfs4_open_recover_helper(opendata, FMODE_READ, &newstate);
                 if (ret != 0)
                         return ret;
-                mode |= FMODE_READ;
+                if (newstate != state)
+                        return -ESTALE;
         }
-        clear_bit(NFS_DELEGATED_STATE, &state->flags);
-        if (mode == 0)
-                return 0;
-        if (opendata->o_res.delegation_type == 0)
-                opendata->o_res.delegation_type = delegation;
-        opendata->o_arg.open_flags |= mode;
-        newstate = nfs4_opendata_to_nfs4_state(opendata);
-        if (newstate != NULL) {
-                if (opendata->o_res.delegation_type != 0) {
-                        struct nfs_inode *nfsi = NFS_I(newstate->inode);
-                        int delegation_flags = 0;
-                        if (nfsi->delegation)
-                                delegation_flags = nfsi->delegation->flags;
-                        if (!(delegation_flags & NFS_DELEGATION_NEED_RECLAIM))
-                                nfs_inode_set_delegation(newstate->inode,
-                                                opendata->owner->so_cred,
-                                                &opendata->o_res);
-                        else
-                                nfs_inode_reclaim_delegation(newstate->inode,
-                                                opendata->owner->so_cred,
-                                                &opendata->o_res);
-                }
-                nfs4_close_state(newstate, opendata->o_arg.open_flags);
+        /*
+         * We may have performed cached opens for all three recoveries.
+         * Check if we need to update the current stateid.
+         */
+        if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 &&
+            memcmp(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data)) != 0) {
+                write_seqlock(&state->seqlock);
+                if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
+                        memcpy(state->stateid.data, state->open_stateid.data, sizeof(state->stateid.data));
+                write_sequnlock(&state->seqlock);
         }
-        if (newstate != state)
-                return -ESTALE;
         return 0;
 }
 
@@ -462,41 +619,37 @@ static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *
  * OPEN_RECLAIM:
  *      reclaim state on the server after a reboot.
  */
-static int _nfs4_do_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state, struct dentry *dentry)
+static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
 {
-        struct nfs_delegation *delegation = NFS_I(state->inode)->delegation;
+        struct nfs_delegation *delegation;
         struct nfs4_opendata *opendata;
         int delegation_type = 0;
         int status;
 
-        if (delegation != NULL) {
-                if (!(delegation->flags & NFS_DELEGATION_NEED_RECLAIM)) {
-                        memcpy(&state->stateid, &delegation->stateid,
-                                        sizeof(state->stateid));
-                        set_bit(NFS_DELEGATED_STATE, &state->flags);
-                        return 0;
-                }
-                delegation_type = delegation->type;
-        }
-        opendata = nfs4_opendata_alloc(dentry, sp, 0, NULL);
+        opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL);
         if (opendata == NULL)
                 return -ENOMEM;
         opendata->o_arg.claim = NFS4_OPEN_CLAIM_PREVIOUS;
         opendata->o_arg.fh = NFS_FH(state->inode);
         nfs_copy_fh(&opendata->o_res.fh, opendata->o_arg.fh);
+        rcu_read_lock();
+        delegation = rcu_dereference(NFS_I(state->inode)->delegation);
+        if (delegation != NULL && (delegation->flags & NFS_DELEGATION_NEED_RECLAIM) != 0)
+                delegation_type = delegation->flags;
+        rcu_read_unlock();
         opendata->o_arg.u.delegation_type = delegation_type;
         status = nfs4_open_recover(opendata, state);
-        nfs4_opendata_free(opendata);
+        nfs4_opendata_put(opendata);
         return status;
 }
 
-static int nfs4_do_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state, struct dentry *dentry)
+static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
 {
         struct nfs_server *server = NFS_SERVER(state->inode);
         struct nfs4_exception exception = { };
         int err;
         do {
-                err = _nfs4_do_open_reclaim(sp, state, dentry);
+                err = _nfs4_do_open_reclaim(ctx, state);
                 if (err != -NFS4ERR_DELAY)
                         break;
                 nfs4_handle_exception(server, err, &exception);
@@ -512,37 +665,35 @@ static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *sta
         ctx = nfs4_state_find_open_context(state);
         if (IS_ERR(ctx))
                 return PTR_ERR(ctx);
-        ret = nfs4_do_open_reclaim(sp, state, ctx->dentry);
+        ret = nfs4_do_open_reclaim(ctx, state);
         put_nfs_open_context(ctx);
         return ret;
 }
 
-static int _nfs4_open_delegation_recall(struct dentry *dentry, struct nfs4_state *state)
+static int _nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
 {
         struct nfs4_state_owner  *sp  = state->owner;
         struct nfs4_opendata *opendata;
         int ret;
 
-        if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
-                return 0;
-        opendata = nfs4_opendata_alloc(dentry, sp, 0, NULL);
+        opendata = nfs4_opendata_alloc(&ctx->path, sp, 0, NULL);
         if (opendata == NULL)
                 return -ENOMEM;
         opendata->o_arg.claim = NFS4_OPEN_CLAIM_DELEGATE_CUR;
-        memcpy(opendata->o_arg.u.delegation.data, state->stateid.data,
+        memcpy(opendata->o_arg.u.delegation.data, stateid->data,
                         sizeof(opendata->o_arg.u.delegation.data));
         ret = nfs4_open_recover(opendata, state);
-        nfs4_opendata_free(opendata);
+        nfs4_opendata_put(opendata);
         return ret;
 }
 
-int nfs4_open_delegation_recall(struct dentry *dentry, struct nfs4_state *state)
+int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
 {
         struct nfs4_exception exception = { };
-        struct nfs_server *server = NFS_SERVER(dentry->d_inode);
+        struct nfs_server *server = NFS_SERVER(state->inode);
         int err;
         do {
-                err = _nfs4_open_delegation_recall(dentry, state);
+                err = _nfs4_open_delegation_recall(ctx, state, stateid);
                 switch (err) {
                         case 0:
                                 return err;
@@ -582,9 +733,10 @@ static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
                 memcpy(data->o_res.stateid.data, data->c_res.stateid.data,
                                 sizeof(data->o_res.stateid.data));
                 renew_lease(data->o_res.server, data->timestamp);
+                data->rpc_done = 1;
         }
-        nfs_increment_open_seqid(data->rpc_status, data->c_arg.seqid);
         nfs_confirm_seqid(&data->owner->so_seqid, data->rpc_status);
+        nfs_increment_open_seqid(data->rpc_status, data->c_arg.seqid);
 }
 
 static void nfs4_open_confirm_release(void *calldata)
@@ -596,14 +748,14 @@ static void nfs4_open_confirm_release(void *calldata)
         if (data->cancelled == 0)
                 goto out_free;
         /* In case of error, no cleanup! */
-        if (data->rpc_status != 0)
+        if (!data->rpc_done)
                 goto out_free;
         nfs_confirm_seqid(&data->owner->so_seqid, 0);
         state = nfs4_opendata_to_nfs4_state(data);
-        if (state != NULL)
-                nfs4_close_state(state, data->o_arg.open_flags);
+        if (!IS_ERR(state))
+                nfs4_close_state(&data->path, state, data->o_arg.open_flags);
 out_free:
-        nfs4_opendata_free(data);
+        nfs4_opendata_put(data);
 }
 
 static const struct rpc_call_ops nfs4_open_confirm_ops = {
@@ -621,12 +773,9 @@ static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
         struct rpc_task *task;
         int status;
 
-        atomic_inc(&data->count);
-        /*
-         * If rpc_run_task() ends up calling ->rpc_release(), we
-         * want to ensure that it takes the 'error' code path.
-         */
-        data->rpc_status = -ENOMEM;
+        kref_get(&data->kref);
+        data->rpc_done = 0;
+        data->rpc_status = 0;
         task = rpc_run_task(server->client, RPC_TASK_ASYNC, &nfs4_open_confirm_ops, data);
         if (IS_ERR(task))
                 return PTR_ERR(task);
@@ -653,13 +802,35 @@ static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
         
         if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)
                 return;
+        /*
+         * Check if we still need to send an OPEN call, or if we can use
+         * a delegation instead.
+         */
+        if (data->state != NULL) {
+                struct nfs_delegation *delegation;
+
+                if (can_open_cached(data->state, data->o_arg.open_flags & (FMODE_READ|FMODE_WRITE|O_EXCL)))
+                        goto out_no_action;
+                rcu_read_lock();
+                delegation = rcu_dereference(NFS_I(data->state->inode)->delegation);
+                if (delegation != NULL &&
+                   (delegation->flags & NFS_DELEGATION_NEED_RECLAIM) == 0) {
+                        rcu_read_unlock();
+                        goto out_no_action;
+                }
+                rcu_read_unlock();
+        }
         /* Update sequence id. */
-        data->o_arg.id = sp->so_id;
+        data->o_arg.id = sp->so_owner_id.id;
         data->o_arg.clientid = sp->so_client->cl_clientid;
         if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS)
                 msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];
         data->timestamp = jiffies;
         rpc_call_setup(task, &msg, 0);
+        return;
+out_no_action:
+        task->tk_action = NULL;
+
 }
 
 static void nfs4_open_done(struct rpc_task *task, void *calldata)
@@ -683,8 +854,11 @@ static void nfs4_open_done(struct rpc_task *task, void *calldata)
                                 data->rpc_status = -ENOTDIR;
                 }
                 renew_lease(data->o_res.server, data->timestamp);
+                if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM))
+                        nfs_confirm_seqid(&data->owner->so_seqid, 0);
         }
         nfs_increment_open_seqid(data->rpc_status, data->o_arg.seqid);
+        data->rpc_done = 1;
 }
 
 static void nfs4_open_release(void *calldata)
@@ -696,17 +870,17 @@ static void nfs4_open_release(void *calldata)
         if (data->cancelled == 0)
                 goto out_free;
         /* In case of error, no cleanup! */
-        if (data->rpc_status != 0)
+        if (data->rpc_status != 0 || !data->rpc_done)
                 goto out_free;
         /* In case we need an open_confirm, no cleanup! */
         if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)
                 goto out_free;
         nfs_confirm_seqid(&data->owner->so_seqid, 0);
         state = nfs4_opendata_to_nfs4_state(data);
-        if (state != NULL)
-                nfs4_close_state(state, data->o_arg.open_flags);
+        if (!IS_ERR(state))
+                nfs4_close_state(&data->path, state, data->o_arg.open_flags);
 out_free:
-        nfs4_opendata_free(data);
+        nfs4_opendata_put(data);
 }
 
 static const struct rpc_call_ops nfs4_open_ops = {
@@ -727,12 +901,10 @@ static int _nfs4_proc_open(struct nfs4_opendata *data)
         struct rpc_task *task;
         int status;
 
-        atomic_inc(&data->count);
-        /*
-         * If rpc_run_task() ends up calling ->rpc_release(), we
-         * want to ensure that it takes the 'error' code path.
-         */
-        data->rpc_status = -ENOMEM;
+        kref_get(&data->kref);
+        data->rpc_done = 0;
+        data->rpc_status = 0;
+        data->cancelled = 0;
         task = rpc_run_task(server->client, RPC_TASK_ASYNC, &nfs4_open_ops, data);
         if (IS_ERR(task))
                 return PTR_ERR(task);
@@ -743,7 +915,7 @@ static int _nfs4_proc_open(struct nfs4_opendata *data)
         } else
                 status = data->rpc_status;
         rpc_put_task(task);
-        if (status != 0)
+        if (status != 0 || !data->rpc_done)
                 return status;
 
         if (o_arg->open_flags & O_CREAT) {
@@ -756,7 +928,6 @@ static int _nfs4_proc_open(struct nfs4_opendata *data)
                 if (status != 0)
                         return status;
         }
-        nfs_confirm_seqid(&data->owner->so_seqid, 0);
         if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))
                 return server->nfs_client->rpc_ops->getattr(server, &o_res->fh, o_res->f_attr);
         return 0;
@@ -772,6 +943,8 @@ static int _nfs4_do_access(struct inode *inode, struct rpc_cred *cred, int openf
                 mask |= MAY_READ;
         if (openflags & FMODE_WRITE)
                 mask |= MAY_WRITE;
+        if (openflags & FMODE_EXEC)
+                mask |= MAY_EXEC;
         status = nfs_access_get_cached(inode, cred, &cache);
         if (status == 0)
                 goto out;
@@ -811,43 +984,32 @@ static int nfs4_recover_expired_lease(struct nfs_server *server)
  *      reclaim state on the server after a network partition.
  *      Assumes caller holds the appropriate lock
  */
-static int _nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state, struct dentry *dentry)
+static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
 {
-        struct inode *inode = state->inode;
-        struct nfs_delegation *delegation = NFS_I(inode)->delegation;
         struct nfs4_opendata *opendata;
-        int openflags = state->state & (FMODE_READ|FMODE_WRITE);
         int ret;
 
-        if (delegation != NULL && !(delegation->flags & NFS_DELEGATION_NEED_RECLAIM)) {
-                ret = _nfs4_do_access(inode, sp->so_cred, openflags);
-                if (ret < 0)
-                        return ret;
-                memcpy(&state->stateid, &delegation->stateid, sizeof(state->stateid));
-                set_bit(NFS_DELEGATED_STATE, &state->flags);
-                return 0;
-        }
-        opendata = nfs4_opendata_alloc(dentry, sp, openflags, NULL);
+        opendata = nfs4_opendata_alloc(&ctx->path, state->owner, 0, NULL);
         if (opendata == NULL)
                 return -ENOMEM;
         ret = nfs4_open_recover(opendata, state);
         if (ret == -ESTALE) {
                 /* Invalidate the state owner so we don't ever use it again */
-                nfs4_drop_state_owner(sp);
-                d_drop(dentry);
+                nfs4_drop_state_owner(state->owner);
+                d_drop(ctx->path.dentry);
         }
-        nfs4_opendata_free(opendata);
+        nfs4_opendata_put(opendata);
         return ret;
 }
 
-static inline int nfs4_do_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state, struct dentry *dentry)
+static inline int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
 {
-        struct nfs_server *server = NFS_SERVER(dentry->d_inode);
+        struct nfs_server *server = NFS_SERVER(state->inode);
         struct nfs4_exception exception = { };
         int err;
 
         do {
-                err = _nfs4_open_expired(sp, state, dentry);
+                err = _nfs4_open_expired(ctx, state);
                 if (err == -NFS4ERR_DELAY)
                         nfs4_handle_exception(server, err, &exception);
         } while (exception.retry);
@@ -862,107 +1024,38 @@ static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *sta
         ctx = nfs4_state_find_open_context(state);
         if (IS_ERR(ctx))
                 return PTR_ERR(ctx);
-        ret = nfs4_do_open_expired(sp, state, ctx->dentry);
+        ret = nfs4_do_open_expired(ctx, state);
         put_nfs_open_context(ctx);
         return ret;
 }
 
 /*
- * Returns a referenced nfs4_state if there is an open delegation on the file
+ * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
+ * fields corresponding to attributes that were used to store the verifier.
+ * Make sure we clobber those fields in the later setattr call
  */
-static int _nfs4_open_delegated(struct inode *inode, int flags, struct rpc_cred *cred, struct nfs4_state **res)
-{
-        struct nfs_delegation *delegation;
-        struct nfs_server *server = NFS_SERVER(inode);
-        struct nfs_client *clp = server->nfs_client;
-        struct nfs_inode *nfsi = NFS_I(inode);
-        struct nfs4_state_owner *sp = NULL;
-        struct nfs4_state *state = NULL;
-        int open_flags = flags & (FMODE_READ|FMODE_WRITE);
-        int err;
-
-        err = -ENOMEM;
-        if (!(sp = nfs4_get_state_owner(server, cred))) {
-                dprintk("%s: nfs4_get_state_owner failed!\n", __FUNCTION__);
-                return err;
-        }
-        err = nfs4_recover_expired_lease(server);
-        if (err != 0)
-                goto out_put_state_owner;
-        /* Protect against reboot recovery - NOTE ORDER! */
-        down_read(&clp->cl_sem);
-        /* Protect against delegation recall */
-        down_read(&nfsi->rwsem);
-        delegation = NFS_I(inode)->delegation;
-        err = -ENOENT;
-        if (delegation == NULL || (delegation->type & open_flags) != open_flags)
-                goto out_err;
-        err = -ENOMEM;
-        state = nfs4_get_open_state(inode, sp);
-        if (state == NULL)
-                goto out_err;
-
-        err = -ENOENT;
-        if ((state->state & open_flags) == open_flags) {
-                spin_lock(&inode->i_lock);
-                update_open_stateflags(state, open_flags);
-                spin_unlock(&inode->i_lock);
-                goto out_ok;
-        } else if (state->state != 0)
-                goto out_put_open_state;
-
-        lock_kernel();
-        err = _nfs4_do_access(inode, cred, open_flags);
-        unlock_kernel();
-        if (err != 0)
-                goto out_put_open_state;
-        set_bit(NFS_DELEGATED_STATE, &state->flags);
-        update_open_stateid(state, &delegation->stateid, open_flags);
-out_ok:
-        nfs4_put_state_owner(sp);
-        up_read(&nfsi->rwsem);
-        up_read(&clp->cl_sem);
-        *res = state;
-        return 0;
-out_put_open_state:
-        nfs4_put_open_state(state);
-out_err:
-        up_read(&nfsi->rwsem);
-        up_read(&clp->cl_sem);
-        if (err != -EACCES)
-                nfs_inode_return_delegation(inode);
-out_put_state_owner:
-        nfs4_put_state_owner(sp);
-        return err;
-}
-
-static struct nfs4_state *nfs4_open_delegated(struct inode *inode, int flags, struct rpc_cred *cred)
+static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct iattr *sattr)
 {
-        struct nfs4_exception exception = { };
-        struct nfs4_state *res = ERR_PTR(-EIO);
-        int err;
+        if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_ACCESS) &&
+            !(sattr->ia_valid & ATTR_ATIME_SET))
+                sattr->ia_valid |= ATTR_ATIME;
 
-        do {
-                err = _nfs4_open_delegated(inode, flags, cred, &res);
-                if (err == 0)
-                        break;
-                res = ERR_PTR(nfs4_handle_exception(NFS_SERVER(inode),
-                                        err, &exception));
-        } while (exception.retry);
-        return res;
+        if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_MODIFY) &&
+            !(sattr->ia_valid & ATTR_MTIME_SET))
+                sattr->ia_valid |= ATTR_MTIME;
 }
 
 /*
  * Returns a referenced nfs4_state
  */
-static int _nfs4_do_open(struct inode *dir, struct dentry *dentry, int flags, struct iattr *sattr, struct rpc_cred *cred, struct nfs4_state **res)
+static int _nfs4_do_open(struct inode *dir, struct path *path, int flags, struct iattr *sattr, struct rpc_cred *cred, struct nfs4_state **res)
 {
         struct nfs4_state_owner  *sp;
         struct nfs4_state     *state = NULL;
         struct nfs_server       *server = NFS_SERVER(dir);
         struct nfs_client *clp = server->nfs_client;
         struct nfs4_opendata *opendata;
-        int                     status;
+        int status;
 
         /* Protect against reboot recovery conflicts */
         status = -ENOMEM;
@@ -973,29 +1066,35 @@ static int _nfs4_do_open(struct inode *dir, struct dentry *dentry, int flags, st
         status = nfs4_recover_expired_lease(server);
         if (status != 0)
                 goto err_put_state_owner;
+        if (path->dentry->d_inode != NULL)
+                nfs4_return_incompatible_delegation(path->dentry->d_inode, flags & (FMODE_READ|FMODE_WRITE));
         down_read(&clp->cl_sem);
         status = -ENOMEM;
-        opendata = nfs4_opendata_alloc(dentry, sp, flags, sattr);
+        opendata = nfs4_opendata_alloc(path, sp, flags, sattr);
         if (opendata == NULL)
                 goto err_release_rwsem;
 
+        if (path->dentry->d_inode != NULL)
+                opendata->state = nfs4_get_open_state(path->dentry->d_inode, sp);
+
         status = _nfs4_proc_open(opendata);
         if (status != 0)
-                goto err_opendata_free;
+                goto err_opendata_put;
+
+        if (opendata->o_arg.open_flags & O_EXCL)
+                nfs4_exclusive_attrset(opendata, sattr);
 
-        status = -ENOMEM;
         state = nfs4_opendata_to_nfs4_state(opendata);
-        if (state == NULL)
-                goto err_opendata_free;
-        if (opendata->o_res.delegation_type != 0)
-                nfs_inode_set_delegation(state->inode, cred, &opendata->o_res);
-        nfs4_opendata_free(opendata);
+        status = PTR_ERR(state);
+        if (IS_ERR(state))
+                goto err_opendata_put;
+        nfs4_opendata_put(opendata);
         nfs4_put_state_owner(sp);
         up_read(&clp->cl_sem);
         *res = state;
         return 0;
-err_opendata_free:
-        nfs4_opendata_free(opendata);
+err_opendata_put:
+        nfs4_opendata_put(opendata);
 err_release_rwsem:
         up_read(&clp->cl_sem);
 err_put_state_owner:
@@ -1006,14 +1105,14 @@ out_err:
 }
 
 
-static struct nfs4_state *nfs4_do_open(struct inode *dir, struct dentry *dentry, int flags, struct iattr *sattr, struct rpc_cred *cred)
+static struct nfs4_state *nfs4_do_open(struct inode *dir, struct path *path, int flags, struct iattr *sattr, struct rpc_cred *cred)
 {
         struct nfs4_exception exception = { };
         struct nfs4_state *res;
         int status;
 
         do {
-                status = _nfs4_do_open(dir, dentry, flags, sattr, cred, &res);
+                status = _nfs4_do_open(dir, path, flags, sattr, cred, &res);
                 if (status == 0)
                         break;
                 /* NOTE: BAD_SEQID means the server and client disagree about the
@@ -1028,7 +1127,9 @@ static struct nfs4_state *nfs4_do_open(struct inode *dir, struct dentry *dentry,
                  * the user though...
                  */
                 if (status == -NFS4ERR_BAD_SEQID) {
-                        printk(KERN_WARNING "NFS: v4 server returned a bad sequence-id error!\n");
+                        printk(KERN_WARNING "NFS: v4 server %s "
+                                        " returned a bad sequence-id error!\n",
+                                        NFS_SERVER(dir)->nfs_client->cl_hostname);
                         exception.retry = 1;
                         continue;
                 }
@@ -1042,6 +1143,11 @@ static struct nfs4_state *nfs4_do_open(struct inode *dir, struct dentry *dentry,
                         exception.retry = 1;
                         continue;
                 }
+                if (status == -EAGAIN) {
+                        /* We must have found a delegation */
+                        exception.retry = 1;
+                        continue;
+                }
                 res = ERR_PTR(nfs4_handle_exception(NFS_SERVER(dir),
                                         status, &exception));
         } while (exception.retry);
@@ -1101,6 +1207,7 @@ static int nfs4_do_setattr(struct inode *inode, struct nfs_fattr *fattr,
 }
 
 struct nfs4_closedata {
+        struct path path;
         struct inode *inode;
         struct nfs4_state *state;
         struct nfs_closeargs arg;
@@ -1117,6 +1224,8 @@ static void nfs4_free_closedata(void *data)
         nfs4_put_open_state(calldata->state);
         nfs_free_seqid(calldata->arg.seqid);
         nfs4_put_state_owner(sp);
+        dput(calldata->path.dentry);
+        mntput(calldata->path.mnt);
         kfree(calldata);
 }
 
@@ -1134,8 +1243,7 @@ static void nfs4_close_done(struct rpc_task *task, void *data)
         nfs_increment_open_seqid(task->tk_status, calldata->arg.seqid);
         switch (task->tk_status) {
                 case 0:
-                        memcpy(&state->stateid, &calldata->res.stateid,
-                                        sizeof(state->stateid));
+                        nfs_set_open_stateid(state, &calldata->res.stateid, calldata->arg.open_flags);
                         renew_lease(server, calldata->timestamp);
                         break;
                 case -NFS4ERR_STALE_STATEID:
@@ -1160,26 +1268,30 @@ static void nfs4_close_prepare(struct rpc_task *task, void *data)
                 .rpc_resp = &calldata->res,
                 .rpc_cred = state->owner->so_cred,
         };
-        int mode = 0, old_mode;
+        int clear_rd, clear_wr, clear_rdwr;
+        int mode;
 
         if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
                 return;
-        /* Recalculate the new open mode in case someone reopened the file
-         * while we were waiting in line to be scheduled.
-         */
+
+        mode = FMODE_READ|FMODE_WRITE;
+        clear_rd = clear_wr = clear_rdwr = 0;
         spin_lock(&state->owner->so_lock);
-        spin_lock(&calldata->inode->i_lock);
-        mode = old_mode = state->state;
+        /* Calculate the change in open mode */
         if (state->n_rdwr == 0) {
-                if (state->n_rdonly == 0)
+                if (state->n_rdonly == 0) {
                         mode &= ~FMODE_READ;
-                if (state->n_wronly == 0)
+                        clear_rd |= test_and_clear_bit(NFS_O_RDONLY_STATE, &state->flags);
+                        clear_rdwr |= test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags);
+                }
+                if (state->n_wronly == 0) {
                         mode &= ~FMODE_WRITE;
+                        clear_wr |= test_and_clear_bit(NFS_O_WRONLY_STATE, &state->flags);
+                        clear_rdwr |= test_and_clear_bit(NFS_O_RDWR_STATE, &state->flags);
+                }
         }
-        nfs4_state_set_mode_locked(state, mode);
-        spin_unlock(&calldata->inode->i_lock);
         spin_unlock(&state->owner->so_lock);
-        if (mode == old_mode || test_bit(NFS_DELEGATED_STATE, &state->flags)) {
+        if (!clear_rd && !clear_wr && !clear_rdwr) {
                 /* Note: exit _without_ calling nfs4_close_done */
                 task->tk_action = NULL;
                 return;
@@ -1209,19 +1321,21 @@ static const struct rpc_call_ops nfs4_close_ops = {
  *
  * NOTE: Caller must be holding the sp->so_owner semaphore!
  */
-int nfs4_do_close(struct inode *inode, struct nfs4_state *state) 
+int nfs4_do_close(struct path *path, struct nfs4_state *state)
 {
-        struct nfs_server *server = NFS_SERVER(inode);
+        struct nfs_server *server = NFS_SERVER(state->inode);
         struct nfs4_closedata *calldata;
+        struct nfs4_state_owner *sp = state->owner;
+        struct rpc_task *task;
         int status = -ENOMEM;
 
         calldata = kmalloc(sizeof(*calldata), GFP_KERNEL);
         if (calldata == NULL)
                 goto out;
-        calldata->inode = inode;
+        calldata->inode = state->inode;
         calldata->state = state;
-        calldata->arg.fh = NFS_FH(inode);
-        calldata->arg.stateid = &state->stateid;
+        calldata->arg.fh = NFS_FH(state->inode);
+        calldata->arg.stateid = &state->open_stateid;
         /* Serialization for the sequence id */
         calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid);
         if (calldata->arg.seqid == NULL)
@@ -1229,36 +1343,55 @@ int nfs4_do_close(struct inode *inode, struct nfs4_state *state)
         calldata->arg.bitmask = server->attr_bitmask;
         calldata->res.fattr = &calldata->fattr;
         calldata->res.server = server;
+        calldata->path.mnt = mntget(path->mnt);
+        calldata->path.dentry = dget(path->dentry);
 
-        status = nfs4_call_async(server->client, &nfs4_close_ops, calldata);
-        if (status == 0)
-                goto out;
-
-        nfs_free_seqid(calldata->arg.seqid);
+        task = rpc_run_task(server->client, RPC_TASK_ASYNC, &nfs4_close_ops, calldata);
+        if (IS_ERR(task))
+                return PTR_ERR(task);
+        rpc_put_task(task);
+        return 0;
 out_free_calldata:
         kfree(calldata);
 out:
+        nfs4_put_open_state(state);
+        nfs4_put_state_owner(sp);
         return status;
 }
 
-static int nfs4_intent_set_file(struct nameidata *nd, struct dentry *dentry, struct nfs4_state *state)
+static int nfs4_intent_set_file(struct nameidata *nd, struct path *path, struct nfs4_state *state)
 {
         struct file *filp;
+        int ret;
 
-        filp = lookup_instantiate_filp(nd, dentry, NULL);
+        /* If the open_intent is for execute, we have an extra check to make */
+        if (nd->intent.open.flags & FMODE_EXEC) {
+                ret = _nfs4_do_access(state->inode,
+                                state->owner->so_cred,
+                                nd->intent.open.flags);
+                if (ret < 0)
+                        goto out_close;
+        }
+        filp = lookup_instantiate_filp(nd, path->dentry, NULL);
         if (!IS_ERR(filp)) {
                 struct nfs_open_context *ctx;
                 ctx = (struct nfs_open_context *)filp->private_data;
                 ctx->state = state;
                 return 0;
         }
-        nfs4_close_state(state, nd->intent.open.flags);
-        return PTR_ERR(filp);
+        ret = PTR_ERR(filp);
+out_close:
+        nfs4_close_state(path, state, nd->intent.open.flags);
+        return ret;
 }
 
 struct dentry *
 nfs4_atomic_open(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
 {
+        struct path path = {
+                .mnt = nd->mnt,
+                .dentry = dentry,
+        };
         struct iattr attr;
         struct rpc_cred *cred;
         struct nfs4_state *state;
@@ -1277,7 +1410,7 @@ nfs4_atomic_open(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
         cred = rpcauth_lookupcred(NFS_CLIENT(dir)->cl_auth, 0);
         if (IS_ERR(cred))
                 return (struct dentry *)cred;
-        state = nfs4_do_open(dir, dentry, nd->intent.open.flags, &attr, cred);
+        state = nfs4_do_open(dir, &path, nd->intent.open.flags, &attr, cred);
         put_rpccred(cred);
         if (IS_ERR(state)) {
                 if (PTR_ERR(state) == -ENOENT)
@@ -1287,22 +1420,24 @@ nfs4_atomic_open(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
         res = d_add_unique(dentry, igrab(state->inode));
         if (res != NULL)
                 dentry = res;
-        nfs4_intent_set_file(nd, dentry, state);
+        nfs4_intent_set_file(nd, &path, state);
         return res;
 }
 
 int
 nfs4_open_revalidate(struct inode *dir, struct dentry *dentry, int openflags, struct nameidata *nd)
 {
+        struct path path = {
+                .mnt = nd->mnt,
+                .dentry = dentry,
+        };
         struct rpc_cred *cred;
         struct nfs4_state *state;
 
         cred = rpcauth_lookupcred(NFS_CLIENT(dir)->cl_auth, 0);
         if (IS_ERR(cred))
                 return PTR_ERR(cred);
-        state = nfs4_open_delegated(dentry->d_inode, openflags, cred);
-        if (IS_ERR(state))
-                state = nfs4_do_open(dir, dentry, openflags, NULL, cred);
+        state = nfs4_do_open(dir, &path, openflags, NULL, cred);
         put_rpccred(cred);
         if (IS_ERR(state)) {
                 switch (PTR_ERR(state)) {
@@ -1318,10 +1453,10 @@ nfs4_open_revalidate(struct inode *dir, struct dentry *dentry, int openflags, st
                 }
         }
         if (state->inode == dentry->d_inode) {
-                nfs4_intent_set_file(nd, dentry, state);
+                nfs4_intent_set_file(nd, &path, state);
                 return 1;
         }
-        nfs4_close_state(state, openflags);
+        nfs4_close_state(&path, state, openflags);
 out_drop:
         d_drop(dentry);
         return 0;
@@ -1559,8 +1694,6 @@ static int _nfs4_proc_lookupfh(struct nfs_server *server, struct nfs_fh *dirfh,
         dprintk("NFS call  lookupfh %s\n", name->name);
         status = rpc_call_sync(server->client, &msg, 0);
         dprintk("NFS reply lookupfh: %d\n", status);
-        if (status == -NFS4ERR_MOVED)
-                status = -EREMOTE;
         return status;
 }
 
@@ -1571,10 +1704,13 @@ static int nfs4_proc_lookupfh(struct nfs_server *server, struct nfs_fh *dirfh,
         struct nfs4_exception exception = { };
         int err;
         do {
-                err = nfs4_handle_exception(server,
-                                _nfs4_proc_lookupfh(server, dirfh, name,
-                                                    fhandle, fattr),
-                                &exception);
+                err = _nfs4_proc_lookupfh(server, dirfh, name, fhandle, fattr);
+                /* FIXME: !!!! */
+                if (err == -NFS4ERR_MOVED) {
+                        err = -EREMOTE;
+                        break;
+                }
+                err = nfs4_handle_exception(server, err, &exception);
         } while (exception.retry);
         return err;
 }
@@ -1582,28 +1718,10 @@ static int nfs4_proc_lookupfh(struct nfs_server *server, struct nfs_fh *dirfh,
 static int _nfs4_proc_lookup(struct inode *dir, struct qstr *name,
                 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
 {
-        int                    status;
-        struct nfs_server *server = NFS_SERVER(dir);
-        struct nfs4_lookup_arg args = {
-                .bitmask = server->attr_bitmask,
-                .dir_fh = NFS_FH(dir),
-                .name = name,
-        };
-        struct nfs4_lookup_res res = {
-                .server = server,
-                .fattr = fattr,
-                .fh = fhandle,
-        };
-        struct rpc_message msg = {
-                .rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],
-                .rpc_argp = &args,
-                .rpc_resp = &res,
-        };
-        
-        nfs_fattr_init(fattr);
+        int status;
         
         dprintk("NFS call  lookup %s\n", name->name);
-        status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
+        status = _nfs4_proc_lookupfh(NFS_SERVER(dir), NFS_FH(dir), name, fhandle, fattr);
         if (status == -NFS4ERR_MOVED)
                 status = nfs4_get_referral(dir, name, fattr, fhandle);
         dprintk("NFS reply lookup: %d\n", status);
@@ -1752,6 +1870,10 @@ static int
 nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
                  int flags, struct nameidata *nd)
 {
+        struct path path = {
+                .mnt = nd->mnt,
+                .dentry = dentry,
+        };
         struct nfs4_state *state;
         struct rpc_cred *cred;
         int status = 0;
@@ -1761,7 +1883,7 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
                 status = PTR_ERR(cred);
                 goto out;
         }
-        state = nfs4_do_open(dir, dentry, flags, sattr, cred);
+        state = nfs4_do_open(dir, &path, flags, sattr, cred);
         put_rpccred(cred);
         if (IS_ERR(state)) {
                 status = PTR_ERR(state);
@@ -1773,11 +1895,12 @@ nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
                 status = nfs4_do_setattr(state->inode, &fattr, sattr, state);
                 if (status == 0)
                         nfs_setattr_update_inode(state->inode, sattr);
+                nfs_post_op_update_inode(state->inode, &fattr);
         }
-        if (status == 0 && nd != NULL && (nd->flags & LOOKUP_OPEN))
-                status = nfs4_intent_set_file(nd, dentry, state);
+        if (status == 0 && (nd->flags & LOOKUP_OPEN) != 0)
+                status = nfs4_intent_set_file(nd, &path, state);
         else
-                nfs4_close_state(state, flags);
+                nfs4_close_state(&path, state, flags);
 out:
         return status;
 }
@@ -3008,7 +3131,7 @@ static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock
         if (status != 0)
                 goto out;
         lsp = request->fl_u.nfs4_fl.owner;
-        arg.lock_owner.id = lsp->ls_id; 
+        arg.lock_owner.id = lsp->ls_id.id;
         status = rpc_call_sync(server->client, &msg, 0);
         switch (status) {
                 case 0:
@@ -3152,6 +3275,11 @@ static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
 {
         struct nfs4_unlockdata *data;
 
+        /* Ensure this is an unlock - when canceling a lock, the
+         * canceled lock is passed in, and it won't be an unlock.
+         */
+        fl->fl_type = F_UNLCK;
+
         data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);
         if (data == NULL) {
                 nfs_free_seqid(seqid);
@@ -3222,7 +3350,7 @@ static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl,
                 goto out_free;
         p->arg.lock_stateid = &lsp->ls_stateid;
         p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;
-        p->arg.lock_owner.id = lsp->ls_id;
+        p->arg.lock_owner.id = lsp->ls_id.id;
         p->lsp = lsp;
         atomic_inc(&lsp->ls_count);
         p->ctx = get_nfs_open_context(ctx);
@@ -3285,7 +3413,7 @@ static void nfs4_lock_done(struct rpc_task *task, void *calldata)
                 memcpy(data->lsp->ls_stateid.data, data->res.stateid.data,
                                         sizeof(data->lsp->ls_stateid.data));
                 data->lsp->ls_flags |= NFS_LOCK_INITIALIZED;
-                renew_lease(NFS_SERVER(data->ctx->dentry->d_inode), data->timestamp);
+                renew_lease(NFS_SERVER(data->ctx->path.dentry->d_inode), data->timestamp);
         }
         nfs_increment_lock_seqid(data->rpc_status, data->arg.lock_seqid);
 out:
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 8ed79d5c54f..e9662ba81d8 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -38,12 +38,14 @@
  * subsequent patch.
  */
 
+#include <linux/kernel.h>
 #include <linux/slab.h>
 #include <linux/smp_lock.h>
 #include <linux/nfs_fs.h>
 #include <linux/nfs_idmap.h>
 #include <linux/kthread.h>
 #include <linux/module.h>
+#include <linux/random.h>
 #include <linux/workqueue.h>
 #include <linux/bitops.h>
 
@@ -69,33 +71,14 @@ static int nfs4_init_client(struct nfs_client *clp, struct rpc_cred *cred)
         return status;
 }
 
-u32
-nfs4_alloc_lockowner_id(struct nfs_client *clp)
-{
-        return clp->cl_lockowner_id ++;
-}
-
-static struct nfs4_state_owner *
-nfs4_client_grab_unused(struct nfs_client *clp, struct rpc_cred *cred)
-{
-        struct nfs4_state_owner *sp = NULL;
-
-        if (!list_empty(&clp->cl_unused)) {
-                sp = list_entry(clp->cl_unused.next, struct nfs4_state_owner, so_list);
-                atomic_inc(&sp->so_count);
-                sp->so_cred = cred;
-                list_move(&sp->so_list, &clp->cl_state_owners);
-                clp->cl_nunused--;
-        }
-        return sp;
-}
-
 struct rpc_cred *nfs4_get_renew_cred(struct nfs_client *clp)
 {
         struct nfs4_state_owner *sp;
+        struct rb_node *pos;
         struct rpc_cred *cred = NULL;
 
-        list_for_each_entry(sp, &clp->cl_state_owners, so_list) {
+        for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) {
+                sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);
                 if (list_empty(&sp->so_states))
                         continue;
                 cred = get_rpccred(sp->so_cred);
@@ -107,32 +90,146 @@ struct rpc_cred *nfs4_get_renew_cred(struct nfs_client *clp)
 static struct rpc_cred *nfs4_get_setclientid_cred(struct nfs_client *clp)
 {
         struct nfs4_state_owner *sp;
+        struct rb_node *pos;
 
-        if (!list_empty(&clp->cl_state_owners)) {
-                sp = list_entry(clp->cl_state_owners.next,
-                                struct nfs4_state_owner, so_list);
+        pos = rb_first(&clp->cl_state_owners);
+        if (pos != NULL) {
+                sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);
                 return get_rpccred(sp->so_cred);
         }
         return NULL;
 }
 
+static void nfs_alloc_unique_id(struct rb_root *root, struct nfs_unique_id *new,
+                __u64 minval, int maxbits)
+{
+        struct rb_node **p, *parent;
+        struct nfs_unique_id *pos;
+        __u64 mask = ~0ULL;
+
+        if (maxbits < 64)
+                mask = (1ULL << maxbits) - 1ULL;
+
+        /* Ensure distribution is more or less flat */
+        get_random_bytes(&new->id, sizeof(new->id));
+        new->id &= mask;
+        if (new->id < minval)
+                new->id += minval;
+retry:
+        p = &root->rb_node;
+        parent = NULL;
+
+        while (*p != NULL) {
+                parent = *p;
+                pos = rb_entry(parent, struct nfs_unique_id, rb_node);
+
+                if (new->id < pos->id)
+                        p = &(*p)->rb_left;
+                else if (new->id > pos->id)
+                        p = &(*p)->rb_right;
+                else
+                        goto id_exists;
+        }
+        rb_link_node(&new->rb_node, parent, p);
+        rb_insert_color(&new->rb_node, root);
+        return;
+id_exists:
+        for (;;) {
+                new->id++;
+                if (new->id < minval || (new->id & mask) != new->id) {
+                        new->id = minval;
+                        break;
+                }
+                parent = rb_next(parent);
+                if (parent == NULL)
+                        break;
+                pos = rb_entry(parent, struct nfs_unique_id, rb_node);
+                if (new->id < pos->id)
+                        break;
+        }
+        goto retry;
+}
+
+static void nfs_free_unique_id(struct rb_root *root, struct nfs_unique_id *id)
+{
+        rb_erase(&id->rb_node, root);
+}
+
 static struct nfs4_state_owner *
-nfs4_find_state_owner(struct nfs_client *clp, struct rpc_cred *cred)
+nfs4_find_state_owner(struct nfs_server *server, struct rpc_cred *cred)
 {
+        struct nfs_client *clp = server->nfs_client;
+        struct rb_node **p = &clp->cl_state_owners.rb_node,
+                       *parent = NULL;
         struct nfs4_state_owner *sp, *res = NULL;
 
-        list_for_each_entry(sp, &clp->cl_state_owners, so_list) {
-                if (sp->so_cred != cred)
+        while (*p != NULL) {
+                parent = *p;
+                sp = rb_entry(parent, struct nfs4_state_owner, so_client_node);
+
+                if (server < sp->so_server) {
+                        p = &parent->rb_left;
                         continue;
-                atomic_inc(&sp->so_count);
-                /* Move to the head of the list */
-                list_move(&sp->so_list, &clp->cl_state_owners);
-                res = sp;
-                break;
+                }
+                if (server > sp->so_server) {
+                        p = &parent->rb_right;
+                        continue;
+                }
+                if (cred < sp->so_cred)
+                        p = &parent->rb_left;
+                else if (cred > sp->so_cred)
+                        p = &parent->rb_right;
+                else {
+                        atomic_inc(&sp->so_count);
+                        res = sp;
+                        break;
+                }
         }
         return res;
 }
 
+static struct nfs4_state_owner *
+nfs4_insert_state_owner(struct nfs_client *clp, struct nfs4_state_owner *new)
+{
+        struct rb_node **p = &clp->cl_state_owners.rb_node,
+                       *parent = NULL;
+        struct nfs4_state_owner *sp;
+
+        while (*p != NULL) {
+                parent = *p;
+                sp = rb_entry(parent, struct nfs4_state_owner, so_client_node);
+
+                if (new->so_server < sp->so_server) {
+                        p = &parent->rb_left;
+                        continue;
+                }
+                if (new->so_server > sp->so_server) {
+                        p = &parent->rb_right;
+                        continue;
+                }
+                if (new->so_cred < sp->so_cred)
+                        p = &parent->rb_left;
+                else if (new->so_cred > sp->so_cred)
+                        p = &parent->rb_right;
+                else {
+                        atomic_inc(&sp->so_count);
+                        return sp;
+                }
+        }
+        nfs_alloc_unique_id(&clp->cl_openowner_id, &new->so_owner_id, 1, 64);
+        rb_link_node(&new->so_client_node, parent, p);
+        rb_insert_color(&new->so_client_node, &clp->cl_state_owners);
+        return new;
+}
+
+static void
+nfs4_remove_state_owner(struct nfs_client *clp, struct nfs4_state_owner *sp)
+{
+        if (!RB_EMPTY_NODE(&sp->so_client_node))
+                rb_erase(&sp->so_client_node, &clp->cl_state_owners);
+        nfs_free_unique_id(&clp->cl_openowner_id, &sp->so_owner_id);
+}
+
 /*
  * nfs4_alloc_state_owner(): this is called on the OPEN or CREATE path to
  * create a new state_owner.
@@ -160,10 +257,14 @@ nfs4_alloc_state_owner(void)
 void
 nfs4_drop_state_owner(struct nfs4_state_owner *sp)
 {
-        struct nfs_client *clp = sp->so_client;
-        spin_lock(&clp->cl_lock);
-        list_del_init(&sp->so_list);
-        spin_unlock(&clp->cl_lock);
+        if (!RB_EMPTY_NODE(&sp->so_client_node)) {
+                struct nfs_client *clp = sp->so_client;
+
+                spin_lock(&clp->cl_lock);
+                rb_erase(&sp->so_client_node, &clp->cl_state_owners);
+                RB_CLEAR_NODE(&sp->so_client_node);
+                spin_unlock(&clp->cl_lock);
+        }
 }
 
 /*
@@ -175,26 +276,25 @@ struct nfs4_state_owner *nfs4_get_state_owner(struct nfs_server *server, struct
         struct nfs_client *clp = server->nfs_client;
         struct nfs4_state_owner *sp, *new;
 
-        get_rpccred(cred);
-        new = nfs4_alloc_state_owner();
         spin_lock(&clp->cl_lock);
-        sp = nfs4_find_state_owner(clp, cred);
-        if (sp == NULL)
-                sp = nfs4_client_grab_unused(clp, cred);
-        if (sp == NULL && new != NULL) {
-                list_add(&new->so_list, &clp->cl_state_owners);
-                new->so_client = clp;
-                new->so_id = nfs4_alloc_lockowner_id(clp);
-                new->so_cred = cred;
-                sp = new;
-                new = NULL;
-        }
+        sp = nfs4_find_state_owner(server, cred);
         spin_unlock(&clp->cl_lock);
-        kfree(new);
         if (sp != NULL)
                 return sp;
-        put_rpccred(cred);
-        return NULL;
+        new = nfs4_alloc_state_owner();
+        if (new == NULL)
+                return NULL;
+        new->so_client = clp;
+        new->so_server = server;
+        new->so_cred = cred;
+        spin_lock(&clp->cl_lock);
+        sp = nfs4_insert_state_owner(clp, new);
+        spin_unlock(&clp->cl_lock);
+        if (sp == new)
+                get_rpccred(cred);
+        else
+                kfree(new);
+        return sp;
 }
 
 /*
@@ -208,18 +308,7 @@ void nfs4_put_state_owner(struct nfs4_state_owner *sp)
 
         if (!atomic_dec_and_lock(&sp->so_count, &clp->cl_lock))
                 return;
-        if (clp->cl_nunused >= OPENOWNER_POOL_SIZE)
-                goto out_free;
-        if (list_empty(&sp->so_list))
-                goto out_free;
-        list_move(&sp->so_list, &clp->cl_unused);
-        clp->cl_nunused++;
-        spin_unlock(&clp->cl_lock);
-        put_rpccred(cred);
-        cred = NULL;
-        return;
-out_free:
-        list_del(&sp->so_list);
+        nfs4_remove_state_owner(clp, sp);
         spin_unlock(&clp->cl_lock);
         put_rpccred(cred);
         kfree(sp);
@@ -236,6 +325,7 @@ nfs4_alloc_open_state(void)
         atomic_set(&state->count, 1);
         INIT_LIST_HEAD(&state->lock_states);
         spin_lock_init(&state->state_lock);
+        seqlock_init(&state->seqlock);
         return state;
 }
 
@@ -263,13 +353,10 @@ __nfs4_find_state_byowner(struct inode *inode, struct nfs4_state_owner *owner)
         struct nfs4_state *state;
 
         list_for_each_entry(state, &nfsi->open_states, inode_states) {
-                /* Is this in the process of being freed? */
-                if (state->state == 0)
+                if (state->owner != owner)
                         continue;
-                if (state->owner == owner) {
-                        atomic_inc(&state->count);
+                if (atomic_inc_not_zero(&state->count))
                         return state;
-                }
         }
         return NULL;
 }
@@ -341,16 +428,15 @@ void nfs4_put_open_state(struct nfs4_state *state)
 /*
  * Close the current file.
  */
-void nfs4_close_state(struct nfs4_state *state, mode_t mode)
+void nfs4_close_state(struct path *path, struct nfs4_state *state, mode_t mode)
 {
-        struct inode *inode = state->inode;
         struct nfs4_state_owner *owner = state->owner;
-        int oldstate, newstate = 0;
+        int call_close = 0;
+        int newstate;
 
         atomic_inc(&owner->so_count);
         /* Protect against nfs4_find_state() */
         spin_lock(&owner->so_lock);
-        spin_lock(&inode->i_lock);
         switch (mode & (FMODE_READ | FMODE_WRITE)) {
                 case FMODE_READ:
                         state->n_rdonly--;
@@ -361,24 +447,29 @@ void nfs4_close_state(struct nfs4_state *state, mode_t mode)
                 case FMODE_READ|FMODE_WRITE:
                         state->n_rdwr--;
         }
-        oldstate = newstate = state->state;
+        newstate = FMODE_READ|FMODE_WRITE;
         if (state->n_rdwr == 0) {
-                if (state->n_rdonly == 0)
+                if (state->n_rdonly == 0) {
                         newstate &= ~FMODE_READ;
-                if (state->n_wronly == 0)
+                        call_close |= test_bit(NFS_O_RDONLY_STATE, &state->flags);
+                        call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
+                }
+                if (state->n_wronly == 0) {
                         newstate &= ~FMODE_WRITE;
+                        call_close |= test_bit(NFS_O_WRONLY_STATE, &state->flags);
+                        call_close |= test_bit(NFS_O_RDWR_STATE, &state->flags);
+                }
+                if (newstate == 0)
+                        clear_bit(NFS_DELEGATED_STATE, &state->flags);
         }
-        if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
-                nfs4_state_set_mode_locked(state, newstate);
-                oldstate = newstate;
-        }
-        spin_unlock(&inode->i_lock);
+        nfs4_state_set_mode_locked(state, newstate);
         spin_unlock(&owner->so_lock);
 
-        if (oldstate != newstate && nfs4_do_close(inode, state) == 0)
-                return;
-        nfs4_put_open_state(state);
-        nfs4_put_state_owner(owner);
+        if (!call_close) {
+                nfs4_put_open_state(state);
+                nfs4_put_state_owner(owner);
+        } else
+                nfs4_do_close(path, state);
 }
 
 /*
@@ -415,12 +506,22 @@ static struct nfs4_lock_state *nfs4_alloc_lock_state(struct nfs4_state *state, f
         atomic_set(&lsp->ls_count, 1);
         lsp->ls_owner = fl_owner;
         spin_lock(&clp->cl_lock);
-        lsp->ls_id = nfs4_alloc_lockowner_id(clp);
+        nfs_alloc_unique_id(&clp->cl_lockowner_id, &lsp->ls_id, 1, 64);
         spin_unlock(&clp->cl_lock);
         INIT_LIST_HEAD(&lsp->ls_locks);
         return lsp;
 }
 
+static void nfs4_free_lock_state(struct nfs4_lock_state *lsp)
+{
+        struct nfs_client *clp = lsp->ls_state->owner->so_client;
+
+        spin_lock(&clp->cl_lock);
+        nfs_free_unique_id(&clp->cl_lockowner_id, &lsp->ls_id);
+        spin_unlock(&clp->cl_lock);
+        kfree(lsp);
+}
+
 /*
  * Return a compatible lock_state. If no initialized lock_state structure
  * exists, return an uninitialized one.
@@ -450,7 +551,8 @@ static struct nfs4_lock_state *nfs4_get_lock_state(struct nfs4_state *state, fl_
                         return NULL;
         }
         spin_unlock(&state->state_lock);
-        kfree(new);
+        if (new != NULL)
+                nfs4_free_lock_state(new);
         return lsp;
 }
 
@@ -471,7 +573,7 @@ void nfs4_put_lock_state(struct nfs4_lock_state *lsp)
         if (list_empty(&state->lock_states))
                 clear_bit(LK_STATE_IN_USE, &state->flags);
         spin_unlock(&state->state_lock);
-        kfree(lsp);
+        nfs4_free_lock_state(lsp);
 }
 
 static void nfs4_fl_copy_lock(struct file_lock *dst, struct file_lock *src)
@@ -513,8 +615,12 @@ int nfs4_set_lock_state(struct nfs4_state *state, struct file_lock *fl)
 void nfs4_copy_stateid(nfs4_stateid *dst, struct nfs4_state *state, fl_owner_t fl_owner)
 {
         struct nfs4_lock_state *lsp;
+        int seq;
 
-        memcpy(dst, &state->stateid, sizeof(*dst));
+        do {
+                seq = read_seqbegin(&state->seqlock);
+                memcpy(dst, &state->stateid, sizeof(*dst));
+        } while (read_seqretry(&state->seqlock, seq));
         if (test_bit(LK_STATE_IN_USE, &state->flags) == 0)
                 return;
 
@@ -557,12 +663,18 @@ void nfs_free_seqid(struct nfs_seqid *seqid)
  * failed with a seqid incrementing error -
  * see comments nfs_fs.h:seqid_mutating_error()
  */
-static inline void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
+static void nfs_increment_seqid(int status, struct nfs_seqid *seqid)
 {
         switch (status) {
                 case 0:
                         break;
                 case -NFS4ERR_BAD_SEQID:
+                        if (seqid->sequence->flags & NFS_SEQID_CONFIRMED)
+                                return;
+                        printk(KERN_WARNING "NFS: v4 server returned a bad"
+                                        "sequence-id error on an"
+                                        "unconfirmed sequence %p!\n",
+                                        seqid->sequence);
                 case -NFS4ERR_STALE_CLIENTID:
                 case -NFS4ERR_STALE_STATEID:
                 case -NFS4ERR_BAD_STATEID:
@@ -586,7 +698,7 @@ void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid)
                                 struct nfs4_state_owner, so_seqid);
                 nfs4_drop_state_owner(sp);
         }
-        return nfs_increment_seqid(status, seqid);
+        nfs_increment_seqid(status, seqid);
 }
 
 /*
@@ -596,7 +708,7 @@ void nfs_increment_open_seqid(int status, struct nfs_seqid *seqid)
  */
 void nfs_increment_lock_seqid(int status, struct nfs_seqid *seqid)
 {
-        return nfs_increment_seqid(status, seqid);
+        nfs_increment_seqid(status, seqid);
 }
 
 int nfs_wait_on_sequence(struct nfs_seqid *seqid, struct rpc_task *task)
@@ -748,15 +860,21 @@ out_err:
 static void nfs4_state_mark_reclaim(struct nfs_client *clp)
 {
         struct nfs4_state_owner *sp;
+        struct rb_node *pos;
         struct nfs4_state *state;
         struct nfs4_lock_state *lock;
 
         /* Reset all sequence ids to zero */
-        list_for_each_entry(sp, &clp->cl_state_owners, so_list) {
+        for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) {
+                sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);
                 sp->so_seqid.counter = 0;
                 sp->so_seqid.flags = 0;
                 spin_lock(&sp->so_lock);
                 list_for_each_entry(state, &sp->so_states, open_states) {
+                        clear_bit(NFS_DELEGATED_STATE, &state->flags);
+                        clear_bit(NFS_O_RDONLY_STATE, &state->flags);
+                        clear_bit(NFS_O_WRONLY_STATE, &state->flags);
+                        clear_bit(NFS_O_RDWR_STATE, &state->flags);
                         list_for_each_entry(lock, &state->lock_states, ls_locks) {
                                 lock->ls_seqid.counter = 0;
                                 lock->ls_seqid.flags = 0;
@@ -771,6 +889,7 @@ static int reclaimer(void *ptr)
 {
         struct nfs_client *clp = ptr;
         struct nfs4_state_owner *sp;
+        struct rb_node *pos;
         struct nfs4_state_recovery_ops *ops;
         struct rpc_cred *cred;
         int status = 0;
@@ -816,7 +935,8 @@ restart_loop:
         /* Mark all delegations for reclaim */
         nfs_delegation_mark_reclaim(clp);
         /* Note: list is protected by exclusive lock on cl->cl_sem */
-        list_for_each_entry(sp, &clp->cl_state_owners, so_list) {
+        for (pos = rb_first(&clp->cl_state_owners); pos != NULL; pos = rb_next(pos)) {
+                sp = rb_entry(pos, struct nfs4_state_owner, so_client_node);
                 status = nfs4_reclaim_open_state(ops, sp);
                 if (status < 0) {
                         if (status == -NFS4ERR_NO_GRACE) {
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index 8003c91ccb9..c08738441f7 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -68,9 +68,10 @@ static int nfs4_stat_to_errno(int);
 #endif
 
 /* lock,open owner id: 
- * we currently use size 1 (u32) out of (NFS4_OPAQUE_LIMIT  >> 2)
+ * we currently use size 2 (u64) out of (NFS4_OPAQUE_LIMIT  >> 2)
  */
-#define owner_id_maxsz          (1 + 1)
+#define open_owner_id_maxsz     (1 + 4)
+#define lock_owner_id_maxsz     (1 + 4)
 #define compound_encode_hdr_maxsz       (3 + (NFS4_MAXTAGLEN >> 2))
 #define compound_decode_hdr_maxsz       (3 + (NFS4_MAXTAGLEN >> 2))
 #define op_encode_hdr_maxsz     (1)
@@ -87,9 +88,11 @@ static int nfs4_stat_to_errno(int);
 #define encode_getattr_maxsz    (op_encode_hdr_maxsz + nfs4_fattr_bitmap_maxsz)
 #define nfs4_name_maxsz         (1 + ((3 + NFS4_MAXNAMLEN) >> 2))
 #define nfs4_path_maxsz         (1 + ((3 + NFS4_MAXPATHLEN) >> 2))
+#define nfs4_owner_maxsz        (1 + XDR_QUADLEN(IDMAP_NAMESZ))
+#define nfs4_group_maxsz        (1 + XDR_QUADLEN(IDMAP_NAMESZ))
 /* This is based on getfattr, which uses the most attributes: */
 #define nfs4_fattr_value_maxsz  (1 + (1 + 2 + 2 + 4 + 2 + 1 + 1 + 2 + 2 + \
-                                3 + 3 + 3 + 2 * nfs4_name_maxsz))
+                                3 + 3 + 3 + nfs4_owner_maxsz + nfs4_group_maxsz))
 #define nfs4_fattr_maxsz        (nfs4_fattr_bitmap_maxsz + \
                                 nfs4_fattr_value_maxsz)
 #define decode_getattr_maxsz    (op_decode_hdr_maxsz + nfs4_fattr_maxsz)
@@ -116,8 +119,27 @@ static int nfs4_stat_to_errno(int);
                                 3 + (NFS4_VERIFIER_SIZE >> 2))
 #define decode_setclientid_confirm_maxsz \
                                 (op_decode_hdr_maxsz)
-#define encode_lookup_maxsz     (op_encode_hdr_maxsz + \
-                                1 + ((3 + NFS4_FHSIZE) >> 2))
+#define encode_lookup_maxsz     (op_encode_hdr_maxsz + nfs4_name_maxsz)
+#define decode_lookup_maxsz     (op_decode_hdr_maxsz)
+#define encode_share_access_maxsz \
+                                (2)
+#define encode_createmode_maxsz (1 + nfs4_fattr_maxsz)
+#define encode_opentype_maxsz   (1 + encode_createmode_maxsz)
+#define encode_claim_null_maxsz (1 + nfs4_name_maxsz)
+#define encode_open_maxsz       (op_encode_hdr_maxsz + \
+                                2 + encode_share_access_maxsz + 2 + \
+                                open_owner_id_maxsz + \
+                                encode_opentype_maxsz + \
+                                encode_claim_null_maxsz)
+#define decode_ace_maxsz        (3 + nfs4_owner_maxsz)
+#define decode_delegation_maxsz (1 + XDR_QUADLEN(NFS4_STATEID_SIZE) + 1 + \
+                                decode_ace_maxsz)
+#define decode_change_info_maxsz        (5)
+#define decode_open_maxsz       (op_decode_hdr_maxsz + \
+                                XDR_QUADLEN(NFS4_STATEID_SIZE) + \
+                                decode_change_info_maxsz + 1 + \
+                                nfs4_fattr_bitmap_maxsz + \
+                                decode_delegation_maxsz)
 #define encode_remove_maxsz     (op_encode_hdr_maxsz + \
                                 nfs4_name_maxsz)
 #define encode_rename_maxsz     (op_encode_hdr_maxsz + \
@@ -134,9 +156,15 @@ static int nfs4_stat_to_errno(int);
 #define encode_create_maxsz     (op_encode_hdr_maxsz + \
                                 2 + nfs4_name_maxsz + \
                                 nfs4_fattr_maxsz)
-#define decode_create_maxsz     (op_decode_hdr_maxsz + 8)
+#define decode_create_maxsz     (op_decode_hdr_maxsz + \
+                                decode_change_info_maxsz + \
+                                nfs4_fattr_bitmap_maxsz)
 #define encode_delegreturn_maxsz (op_encode_hdr_maxsz + 4)
 #define decode_delegreturn_maxsz (op_decode_hdr_maxsz)
+#define encode_fs_locations_maxsz \
+                                (encode_getattr_maxsz)
+#define decode_fs_locations_maxsz \
+                                (0)
 #define NFS4_enc_compound_sz    (1024)  /* XXX: large enough? */
 #define NFS4_dec_compound_sz    (1024)  /* XXX: large enough? */
 #define NFS4_enc_read_sz        (compound_encode_hdr_maxsz + \
@@ -174,16 +202,21 @@ static int nfs4_stat_to_errno(int);
                                 op_decode_hdr_maxsz + 2 + \
                                 decode_getattr_maxsz)
 #define NFS4_enc_open_sz        (compound_encode_hdr_maxsz + \
-                                encode_putfh_maxsz + \
-                                op_encode_hdr_maxsz + \
-                                13 + 3 + 2 + 64 + \
-                                encode_getattr_maxsz + \
-                                encode_getfh_maxsz)
+                                encode_putfh_maxsz + \
+                                encode_savefh_maxsz + \
+                                encode_open_maxsz + \
+                                encode_getfh_maxsz + \
+                                encode_getattr_maxsz + \
+                                encode_restorefh_maxsz + \
+                                encode_getattr_maxsz)
 #define NFS4_dec_open_sz        (compound_decode_hdr_maxsz + \
-                                decode_putfh_maxsz + \
-                                op_decode_hdr_maxsz + 4 + 5 + 2 + 3 + \
-                                decode_getattr_maxsz + \
-                                decode_getfh_maxsz)
+                                decode_putfh_maxsz + \
+                                decode_savefh_maxsz + \
+                                decode_open_maxsz + \
+                                decode_getfh_maxsz + \
+                                decode_getattr_maxsz + \
+                                decode_restorefh_maxsz + \
+                                decode_getattr_maxsz)
 #define NFS4_enc_open_confirm_sz      \
                                 (compound_encode_hdr_maxsz + \
                                 encode_putfh_maxsz + \
@@ -193,12 +226,12 @@ static int nfs4_stat_to_errno(int);
                                         op_decode_hdr_maxsz + 4)
 #define NFS4_enc_open_noattr_sz (compound_encode_hdr_maxsz + \
                                         encode_putfh_maxsz + \
-                                        op_encode_hdr_maxsz + \
-                                        11)
+                                        encode_open_maxsz + \
+                                        encode_getattr_maxsz)
 #define NFS4_dec_open_noattr_sz (compound_decode_hdr_maxsz + \
                                         decode_putfh_maxsz + \
-                                        op_decode_hdr_maxsz + \
-                                        4 + 5 + 2 + 3)
+                                        decode_open_maxsz + \
+                                        decode_getattr_maxsz)
 #define NFS4_enc_open_downgrade_sz \
                                 (compound_encode_hdr_maxsz + \
                                 encode_putfh_maxsz + \
@@ -256,19 +289,19 @@ static int nfs4_stat_to_errno(int);
                                 op_encode_hdr_maxsz + \
                                 1 + 1 + 2 + 2 + \
                                 1 + 4 + 1 + 2 + \
-                                owner_id_maxsz)
+                                lock_owner_id_maxsz)
 #define NFS4_dec_lock_sz        (compound_decode_hdr_maxsz + \
                                 decode_putfh_maxsz + \
                                 decode_getattr_maxsz + \
                                 op_decode_hdr_maxsz + \
                                 2 + 2 + 1 + 2 + \
-                                owner_id_maxsz)
+                                lock_owner_id_maxsz)
 #define NFS4_enc_lockt_sz       (compound_encode_hdr_maxsz + \
                                 encode_putfh_maxsz + \
                                 encode_getattr_maxsz + \
                                 op_encode_hdr_maxsz + \
                                 1 + 2 + 2 + 2 + \
-                                owner_id_maxsz)
+                                lock_owner_id_maxsz)
 #define NFS4_dec_lockt_sz       (NFS4_dec_lock_sz)
 #define NFS4_enc_locku_sz       (compound_encode_hdr_maxsz + \
                                 encode_putfh_maxsz + \
@@ -298,7 +331,7 @@ static int nfs4_stat_to_errno(int);
                                 encode_getfh_maxsz)
 #define NFS4_dec_lookup_sz      (compound_decode_hdr_maxsz + \
                                 decode_putfh_maxsz + \
-                                op_decode_hdr_maxsz + \
+                                decode_lookup_maxsz + \
                                 decode_getattr_maxsz + \
                                 decode_getfh_maxsz)
 #define NFS4_enc_lookup_root_sz (compound_encode_hdr_maxsz + \
@@ -417,12 +450,13 @@ static int nfs4_stat_to_errno(int);
 #define NFS4_enc_fs_locations_sz \
                                 (compound_encode_hdr_maxsz + \
                                  encode_putfh_maxsz + \
-                                 encode_getattr_maxsz)
+                                 encode_lookup_maxsz + \
+                                 encode_fs_locations_maxsz)
 #define NFS4_dec_fs_locations_sz \
                                 (compound_decode_hdr_maxsz + \
                                  decode_putfh_maxsz + \
-                                 op_decode_hdr_maxsz + \
-                                 nfs4_fattr_bitmap_maxsz)
+                                 decode_lookup_maxsz + \
+                                 decode_fs_locations_maxsz)
 
 static struct {
         unsigned int    mode;
@@ -793,13 +827,14 @@ static int encode_lock(struct xdr_stream *xdr, const struct nfs_lock_args *args)
         WRITE64(nfs4_lock_length(args->fl));
         WRITE32(args->new_lock_owner);
         if (args->new_lock_owner){
-                RESERVE_SPACE(4+NFS4_STATEID_SIZE+20);
+                RESERVE_SPACE(4+NFS4_STATEID_SIZE+32);
                 WRITE32(args->open_seqid->sequence->counter);
                 WRITEMEM(args->open_stateid->data, NFS4_STATEID_SIZE);
                 WRITE32(args->lock_seqid->sequence->counter);
                 WRITE64(args->lock_owner.clientid);
-                WRITE32(4);
-                WRITE32(args->lock_owner.id);
+                WRITE32(16);
+                WRITEMEM("lock id:", 8);
+                WRITE64(args->lock_owner.id);
         }
         else {
                 RESERVE_SPACE(NFS4_STATEID_SIZE+4);
@@ -814,14 +849,15 @@ static int encode_lockt(struct xdr_stream *xdr, const struct nfs_lockt_args *arg
 {
         __be32 *p;
 
-        RESERVE_SPACE(40);
+        RESERVE_SPACE(52);
         WRITE32(OP_LOCKT);
         WRITE32(nfs4_lock_type(args->fl, 0));
         WRITE64(args->fl->fl_start);
         WRITE64(nfs4_lock_length(args->fl));
         WRITE64(args->lock_owner.clientid);
-        WRITE32(4);
-        WRITE32(args->lock_owner.id);
+        WRITE32(16);
+        WRITEMEM("lock id:", 8);
+        WRITE64(args->lock_owner.id);
 
         return 0;
 }
@@ -886,10 +922,11 @@ static inline void encode_openhdr(struct xdr_stream *xdr, const struct nfs_opena
         WRITE32(OP_OPEN);
         WRITE32(arg->seqid->sequence->counter);
         encode_share_access(xdr, arg->open_flags);
-        RESERVE_SPACE(16);
+        RESERVE_SPACE(28);
         WRITE64(arg->clientid);
-        WRITE32(4);
-        WRITE32(arg->id);
+        WRITE32(16);
+        WRITEMEM("open id:", 8);
+        WRITE64(arg->id);
 }
 
 static inline void encode_createmode(struct xdr_stream *xdr, const struct nfs_openargs *arg)
@@ -1071,7 +1108,7 @@ static int encode_read(struct xdr_stream *xdr, const struct nfs_readargs *args)
 
 static int encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg *readdir, struct rpc_rqst *req)
 {
-        struct rpc_auth *auth = req->rq_task->tk_auth;
+        struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
         uint32_t attrs[2] = {
                 FATTR4_WORD0_RDATTR_ERROR|FATTR4_WORD0_FILEID,
                 FATTR4_WORD1_MOUNTED_ON_FILEID,
@@ -1117,7 +1154,7 @@ static int encode_readdir(struct xdr_stream *xdr, const struct nfs4_readdir_arg
 
 static int encode_readlink(struct xdr_stream *xdr, const struct nfs4_readlink *readlink, struct rpc_rqst *req)
 {
-        struct rpc_auth *auth = req->rq_task->tk_auth;
+        struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
         unsigned int replen;
         __be32 *p;
 
@@ -1735,7 +1772,7 @@ out:
  */
 static int nfs4_xdr_enc_read(struct rpc_rqst *req, __be32 *p, struct nfs_readargs *args)
 {
-        struct rpc_auth *auth = req->rq_task->tk_auth;
+        struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
         struct xdr_stream xdr;
         struct compound_hdr hdr = {
                 .nops = 2,
@@ -1795,7 +1832,7 @@ nfs4_xdr_enc_getacl(struct rpc_rqst *req, __be32 *p,
                 struct nfs_getaclargs *args)
 {
         struct xdr_stream xdr;
-        struct rpc_auth *auth = req->rq_task->tk_auth;
+        struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
         struct compound_hdr hdr = {
                 .nops   = 2,
         };
@@ -2030,7 +2067,7 @@ static int nfs4_xdr_enc_fs_locations(struct rpc_rqst *req, __be32 *p, struct nfs
         struct compound_hdr hdr = {
                 .nops = 3,
         };
-        struct rpc_auth *auth = req->rq_task->tk_auth;
+        struct rpc_auth *auth = req->rq_task->tk_msg.rpc_cred->cr_auth;
         int replen;
         int status;
 
@@ -3269,7 +3306,7 @@ static int decode_delegation(struct xdr_stream *xdr, struct nfs_openres *res)
 static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res)
 {
         __be32 *p;
-        uint32_t bmlen;
+        uint32_t savewords, bmlen, i;
         int status;
 
         status = decode_op_hdr(xdr, OP_OPEN);
@@ -3287,7 +3324,12 @@ static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res)
                 goto xdr_error;
 
         READ_BUF(bmlen << 2);
-        p += bmlen;
+        savewords = min_t(uint32_t, bmlen, NFS4_BITMAP_SIZE);
+        for (i = 0; i < savewords; ++i)
+                READ32(res->attrset[i]);
+        for (; i < NFS4_BITMAP_SIZE; i++)
+                res->attrset[i] = 0;
+
         return decode_delegation(xdr, res);
 xdr_error:
         dprintk("%s: Bitmap too large! Length = %u\n", __FUNCTION__, bmlen);
diff --git a/fs/nfs/nfsroot.c b/fs/nfs/nfsroot.c
index 49d1008ce1d..3490322d114 100644
--- a/fs/nfs/nfsroot.c
+++ b/fs/nfs/nfsroot.c
@@ -428,7 +428,7 @@ static int __init root_nfs_getport(int program, int version, int proto)
         printk(KERN_NOTICE "Looking up port of RPC %d/%d on %u.%u.%u.%u\n",
                 program, version, NIPQUAD(servaddr));
         set_sockaddr(&sin, servaddr, 0);
-        return rpcb_getport_external(&sin, program, version, proto);
+        return rpcb_getport_sync(&sin, program, version, proto);
 }
 
 
@@ -496,7 +496,8 @@ static int __init root_nfs_get_handle(void)
                                         NFS_MNT3_VERSION : NFS_MNT_VERSION;
 
         set_sockaddr(&sin, servaddr, htons(mount_port));
-        status = nfsroot_mount(&sin, nfs_path, &fh, version, protocol);
+        status = nfs_mount((struct sockaddr *) &sin, sizeof(sin), NULL,
+                           nfs_path, version, protocol, &fh);
         if (status < 0)
                 printk(KERN_ERR "Root-NFS: Server returned error %d "
                                 "while mounting %s\n", status, nfs_path);
diff --git a/fs/nfs/pagelist.c b/fs/nfs/pagelist.c
index c5bb51a29e8..f56dae5216f 100644
--- a/fs/nfs/pagelist.c
+++ b/fs/nfs/pagelist.c
@@ -85,9 +85,8 @@ nfs_create_request(struct nfs_open_context *ctx, struct inode *inode,
         req->wb_offset  = offset;
         req->wb_pgbase  = offset;
         req->wb_bytes   = count;
-        atomic_set(&req->wb_count, 1);
         req->wb_context = get_nfs_open_context(ctx);
-
+        kref_init(&req->wb_kref);
         return req;
 }
 
@@ -109,30 +108,31 @@ void nfs_unlock_request(struct nfs_page *req)
 }
 
 /**
- * nfs_set_page_writeback_locked - Lock a request for writeback
+ * nfs_set_page_tag_locked - Tag a request as locked
  * @req:
  */
-int nfs_set_page_writeback_locked(struct nfs_page *req)
+static int nfs_set_page_tag_locked(struct nfs_page *req)
 {
-        struct nfs_inode *nfsi = NFS_I(req->wb_context->dentry->d_inode);
+        struct nfs_inode *nfsi = NFS_I(req->wb_context->path.dentry->d_inode);
 
         if (!nfs_lock_request(req))
                 return 0;
-        radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index, NFS_PAGE_TAG_WRITEBACK);
+        radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index, NFS_PAGE_TAG_LOCKED);
         return 1;
 }
 
 /**
- * nfs_clear_page_writeback - Unlock request and wake up sleepers
+ * nfs_clear_page_tag_locked - Clear request tag and wake up sleepers
  */
-void nfs_clear_page_writeback(struct nfs_page *req)
+void nfs_clear_page_tag_locked(struct nfs_page *req)
 {
-        struct nfs_inode *nfsi = NFS_I(req->wb_context->dentry->d_inode);
+        struct inode *inode = req->wb_context->path.dentry->d_inode;
+        struct nfs_inode *nfsi = NFS_I(inode);
 
         if (req->wb_page != NULL) {
-                spin_lock(&nfsi->req_lock);
-                radix_tree_tag_clear(&nfsi->nfs_page_tree, req->wb_index, NFS_PAGE_TAG_WRITEBACK);
-                spin_unlock(&nfsi->req_lock);
+                spin_lock(&inode->i_lock);
+                radix_tree_tag_clear(&nfsi->nfs_page_tree, req->wb_index, NFS_PAGE_TAG_LOCKED);
+                spin_unlock(&inode->i_lock);
         }
         nfs_unlock_request(req);
 }
@@ -160,11 +160,9 @@ void nfs_clear_request(struct nfs_page *req)
  *
  * Note: Should never be called with the spinlock held!
  */
-void
-nfs_release_request(struct nfs_page *req)
+static void nfs_free_request(struct kref *kref)
 {
-        if (!atomic_dec_and_test(&req->wb_count))
-                return;
+        struct nfs_page *req = container_of(kref, struct nfs_page, wb_kref);
 
         /* Release struct file or cached credential */
         nfs_clear_request(req);
@@ -172,6 +170,11 @@ nfs_release_request(struct nfs_page *req)
         nfs_page_free(req);
 }
 
+void nfs_release_request(struct nfs_page *req)
+{
+        kref_put(&req->wb_kref, nfs_free_request);
+}
+
 static int nfs_wait_bit_interruptible(void *word)
 {
         int ret = 0;
@@ -193,7 +196,7 @@ static int nfs_wait_bit_interruptible(void *word)
 int
 nfs_wait_on_request(struct nfs_page *req)
 {
-        struct rpc_clnt *clnt = NFS_CLIENT(req->wb_context->dentry->d_inode);
+        struct rpc_clnt *clnt = NFS_CLIENT(req->wb_context->path.dentry->d_inode);
         sigset_t oldmask;
         int ret = 0;
 
@@ -379,20 +382,20 @@ void nfs_pageio_cond_complete(struct nfs_pageio_descriptor *desc, pgoff_t index)
 /**
  * nfs_scan_list - Scan a list for matching requests
  * @nfsi: NFS inode
- * @head: One of the NFS inode request lists
  * @dst: Destination list
  * @idx_start: lower bound of page->index to scan
  * @npages: idx_start + npages sets the upper bound to scan.
+ * @tag: tag to scan for
  *
  * Moves elements from one of the inode request lists.
  * If the number of requests is set to 0, the entire address_space
  * starting at index idx_start, is scanned.
  * The requests are *not* checked to ensure that they form a contiguous set.
- * You must be holding the inode's req_lock when calling this function
+ * You must be holding the inode's i_lock when calling this function
  */
-int nfs_scan_list(struct nfs_inode *nfsi, struct list_head *head,
+int nfs_scan_list(struct nfs_inode *nfsi,
                 struct list_head *dst, pgoff_t idx_start,
-                unsigned int npages)
+                unsigned int npages, int tag)
 {
         struct nfs_page *pgvec[NFS_SCAN_MAXENTRIES];
         struct nfs_page *req;
@@ -407,9 +410,9 @@ int nfs_scan_list(struct nfs_inode *nfsi, struct list_head *head,
                 idx_end = idx_start + npages - 1;
 
         for (;;) {
-                found = radix_tree_gang_lookup(&nfsi->nfs_page_tree,
+                found = radix_tree_gang_lookup_tag(&nfsi->nfs_page_tree,
                                 (void **)&pgvec[0], idx_start,
-                                NFS_SCAN_MAXENTRIES);
+                                NFS_SCAN_MAXENTRIES, tag);
                 if (found <= 0)
                         break;
                 for (i = 0; i < found; i++) {
@@ -417,15 +420,18 @@ int nfs_scan_list(struct nfs_inode *nfsi, struct list_head *head,
                         if (req->wb_index > idx_end)
                                 goto out;
                         idx_start = req->wb_index + 1;
-                        if (req->wb_list_head != head)
-                                continue;
-                        if (nfs_set_page_writeback_locked(req)) {
+                        if (nfs_set_page_tag_locked(req)) {
                                 nfs_list_remove_request(req);
+                                radix_tree_tag_clear(&nfsi->nfs_page_tree,
+                                                req->wb_index, tag);
                                 nfs_list_add_request(req, dst);
                                 res++;
+                                if (res == INT_MAX)
+                                        goto out;
                         }
                 }
-
+                /* for latency reduction */
+                cond_resched_lock(&nfsi->vfs_inode.i_lock);
         }
 out:
         return res;
diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index 7bd7cb95c03..6ae2e58ed05 100644
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -145,8 +145,8 @@ static void nfs_readpage_release(struct nfs_page *req)
         unlock_page(req->wb_page);
 
         dprintk("NFS: read done (%s/%Ld %d@%Ld)\n",
-                        req->wb_context->dentry->d_inode->i_sb->s_id,
-                        (long long)NFS_FILEID(req->wb_context->dentry->d_inode),
+                        req->wb_context->path.dentry->d_inode->i_sb->s_id,
+                        (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
                         req->wb_bytes,
                         (long long)req_offset(req));
         nfs_clear_request(req);
@@ -164,7 +164,7 @@ static void nfs_read_rpcsetup(struct nfs_page *req, struct nfs_read_data *data,
         int flags;
 
         data->req         = req;
-        data->inode       = inode = req->wb_context->dentry->d_inode;
+        data->inode       = inode = req->wb_context->path.dentry->d_inode;
         data->cred        = req->wb_context->cred;
 
         data->args.fh     = NFS_FH(inode);
@@ -483,17 +483,19 @@ int nfs_readpage(struct file *file, struct page *page)
          */
         error = nfs_wb_page(inode, page);
         if (error)
-                goto out_error;
+                goto out_unlock;
+        if (PageUptodate(page))
+                goto out_unlock;
 
         error = -ESTALE;
         if (NFS_STALE(inode))
-                goto out_error;
+                goto out_unlock;
 
         if (file == NULL) {
                 error = -EBADF;
                 ctx = nfs_find_open_context(inode, NULL, FMODE_READ);
                 if (ctx == NULL)
-                        goto out_error;
+                        goto out_unlock;
         } else
                 ctx = get_nfs_open_context((struct nfs_open_context *)
                                 file->private_data);
@@ -502,8 +504,7 @@ int nfs_readpage(struct file *file, struct page *page)
 
         put_nfs_open_context(ctx);
         return error;
-
-out_error:
+out_unlock:
         unlock_page(page);
         return error;
 }
@@ -520,21 +521,32 @@ readpage_async_filler(void *data, struct page *page)
         struct inode *inode = page->mapping->host;
         struct nfs_page *new;
         unsigned int len;
+        int error;
+
+        error = nfs_wb_page(inode, page);
+        if (error)
+                goto out_unlock;
+        if (PageUptodate(page))
+                goto out_unlock;
 
-        nfs_wb_page(inode, page);
         len = nfs_page_length(page);
         if (len == 0)
                 return nfs_return_empty_page(page);
+
         new = nfs_create_request(desc->ctx, inode, page, 0, len);
-        if (IS_ERR(new)) {
-                        SetPageError(page);
-                        unlock_page(page);
-                        return PTR_ERR(new);
-        }
+        if (IS_ERR(new))
+                goto out_error;
+
         if (len < PAGE_CACHE_SIZE)
                 zero_user_page(page, len, PAGE_CACHE_SIZE - len, KM_USER0);
         nfs_pageio_add_request(desc->pgio, new);
         return 0;
+out_error:
+        error = PTR_ERR(new);
+        SetPageError(page);
+out_unlock:
+        unlock_page(page);
+        return error;
 }
 
 int nfs_readpages(struct file *filp, struct address_space *mapping,
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index ca20d3cc260..a2b1af89ca1 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -45,6 +45,7 @@
 #include <linux/inet.h>
 #include <linux/nfs_xdr.h>
 #include <linux/magic.h>
+#include <linux/parser.h>
 
 #include <asm/system.h>
 #include <asm/uaccess.h>
@@ -57,6 +58,167 @@
 
 #define NFSDBG_FACILITY         NFSDBG_VFS
 
+
+struct nfs_parsed_mount_data {
+        int                     flags;
+        int                     rsize, wsize;
+        int                     timeo, retrans;
+        int                     acregmin, acregmax,
+                                acdirmin, acdirmax;
+        int                     namlen;
+        unsigned int            bsize;
+        unsigned int            auth_flavor_len;
+        rpc_authflavor_t        auth_flavors[1];
+        char                    *client_address;
+
+        struct {
+                struct sockaddr_in      address;
+                unsigned int            program;
+                unsigned int            version;
+                unsigned short          port;
+                int                     protocol;
+        } mount_server;
+
+        struct {
+                struct sockaddr_in      address;
+                char                    *hostname;
+                char                    *export_path;
+                unsigned int            program;
+                int                     protocol;
+        } nfs_server;
+};
+
+enum {
+        /* Mount options that take no arguments */
+        Opt_soft, Opt_hard,
+        Opt_intr, Opt_nointr,
+        Opt_posix, Opt_noposix,
+        Opt_cto, Opt_nocto,
+        Opt_ac, Opt_noac,
+        Opt_lock, Opt_nolock,
+        Opt_v2, Opt_v3,
+        Opt_udp, Opt_tcp,
+        Opt_acl, Opt_noacl,
+        Opt_rdirplus, Opt_nordirplus,
+        Opt_sharecache, Opt_nosharecache,
+
+        /* Mount options that take integer arguments */
+        Opt_port,
+        Opt_rsize, Opt_wsize, Opt_bsize,
+        Opt_timeo, Opt_retrans,
+        Opt_acregmin, Opt_acregmax,
+        Opt_acdirmin, Opt_acdirmax,
+        Opt_actimeo,
+        Opt_namelen,
+        Opt_mountport,
+        Opt_mountprog, Opt_mountvers,
+        Opt_nfsprog, Opt_nfsvers,
+
+        /* Mount options that take string arguments */
+        Opt_sec, Opt_proto, Opt_mountproto,
+        Opt_addr, Opt_mounthost, Opt_clientaddr,
+
+        /* Mount options that are ignored */
+        Opt_userspace, Opt_deprecated,
+
+        Opt_err
+};
+
+static match_table_t nfs_mount_option_tokens = {
+        { Opt_userspace, "bg" },
+        { Opt_userspace, "fg" },
+        { Opt_soft, "soft" },
+        { Opt_hard, "hard" },
+        { Opt_intr, "intr" },
+        { Opt_nointr, "nointr" },
+        { Opt_posix, "posix" },
+        { Opt_noposix, "noposix" },
+        { Opt_cto, "cto" },
+        { Opt_nocto, "nocto" },
+        { Opt_ac, "ac" },
+        { Opt_noac, "noac" },
+        { Opt_lock, "lock" },
+        { Opt_nolock, "nolock" },
+        { Opt_v2, "v2" },
+        { Opt_v3, "v3" },
+        { Opt_udp, "udp" },
+        { Opt_tcp, "tcp" },
+        { Opt_acl, "acl" },
+        { Opt_noacl, "noacl" },
+        { Opt_rdirplus, "rdirplus" },
+        { Opt_nordirplus, "nordirplus" },
+        { Opt_sharecache, "sharecache" },
+        { Opt_nosharecache, "nosharecache" },
+
+        { Opt_port, "port=%u" },
+        { Opt_rsize, "rsize=%u" },
+        { Opt_wsize, "wsize=%u" },
+        { Opt_bsize, "bsize=%u" },
+        { Opt_timeo, "timeo=%u" },
+        { Opt_retrans, "retrans=%u" },
+        { Opt_acregmin, "acregmin=%u" },
+        { Opt_acregmax, "acregmax=%u" },
+        { Opt_acdirmin, "acdirmin=%u" },
+        { Opt_acdirmax, "acdirmax=%u" },
+        { Opt_actimeo, "actimeo=%u" },
+        { Opt_userspace, "retry=%u" },
+        { Opt_namelen, "namlen=%u" },
+        { Opt_mountport, "mountport=%u" },
+        { Opt_mountprog, "mountprog=%u" },
+        { Opt_mountvers, "mountvers=%u" },
+        { Opt_nfsprog, "nfsprog=%u" },
+        { Opt_nfsvers, "nfsvers=%u" },
+        { Opt_nfsvers, "vers=%u" },
+
+        { Opt_sec, "sec=%s" },
+        { Opt_proto, "proto=%s" },
+        { Opt_mountproto, "mountproto=%s" },
+        { Opt_addr, "addr=%s" },
+        { Opt_clientaddr, "clientaddr=%s" },
+        { Opt_mounthost, "mounthost=%s" },
+
+        { Opt_err, NULL }
+};
+
+enum {
+        Opt_xprt_udp, Opt_xprt_tcp,
+
+        Opt_xprt_err
+};
+
+static match_table_t nfs_xprt_protocol_tokens = {
+        { Opt_xprt_udp, "udp" },
+        { Opt_xprt_tcp, "tcp" },
+
+        { Opt_xprt_err, NULL }
+};
+
+enum {
+        Opt_sec_none, Opt_sec_sys,
+        Opt_sec_krb5, Opt_sec_krb5i, Opt_sec_krb5p,
+        Opt_sec_lkey, Opt_sec_lkeyi, Opt_sec_lkeyp,
+        Opt_sec_spkm, Opt_sec_spkmi, Opt_sec_spkmp,
+
+        Opt_sec_err
+};
+
+static match_table_t nfs_secflavor_tokens = {
+        { Opt_sec_none, "none" },
+        { Opt_sec_none, "null" },
+        { Opt_sec_sys, "sys" },
+
+        { Opt_sec_krb5, "krb5" },
+        { Opt_sec_krb5i, "krb5i" },
+        { Opt_sec_krb5p, "krb5p" },
+
+        { Opt_sec_lkey, "lkey" },
+        { Opt_sec_lkeyi, "lkeyi" },
+        { Opt_sec_lkeyp, "lkeyp" },
+
+        { Opt_sec_err, NULL }
+};
+
+
 static void nfs_umount_begin(struct vfsmount *, int);
 static int  nfs_statfs(struct dentry *, struct kstatfs *);
 static int  nfs_show_options(struct seq_file *, struct vfsmount *);
@@ -263,11 +425,11 @@ static const char *nfs_pseudoflavour_to_name(rpc_authflavor_t flavour)
                 { RPC_AUTH_GSS_SPKM, "spkm" },
                 { RPC_AUTH_GSS_SPKMI, "spkmi" },
                 { RPC_AUTH_GSS_SPKMP, "spkmp" },
-                { -1, "unknown" }
+                { UINT_MAX, "unknown" }
         };
         int i;
 
-        for (i=0; sec_flavours[i].flavour != -1; i++) {
+        for (i = 0; sec_flavours[i].flavour != UINT_MAX; i++) {
                 if (sec_flavours[i].flavour == flavour)
                         break;
         }
@@ -291,6 +453,7 @@ static void nfs_show_mount_options(struct seq_file *m, struct nfs_server *nfss,
                 { NFS_MOUNT_NONLM, ",nolock", "" },
                 { NFS_MOUNT_NOACL, ",noacl", "" },
                 { NFS_MOUNT_NORDIRPLUS, ",nordirplus", "" },
+                { NFS_MOUNT_UNSHARED, ",nosharecache", ""},
                 { 0, NULL, NULL }
         };
         const struct proc_nfs_info *nfs_infop;
@@ -430,87 +593,641 @@ static int nfs_show_stats(struct seq_file *m, struct vfsmount *mnt)
  */
 static void nfs_umount_begin(struct vfsmount *vfsmnt, int flags)
 {
+        struct nfs_server *server = NFS_SB(vfsmnt->mnt_sb);
+        struct rpc_clnt *rpc;
+
         shrink_submounts(vfsmnt, &nfs_automount_list);
+
+        if (!(flags & MNT_FORCE))
+                return;
+        /* -EIO all pending I/O */
+        rpc = server->client_acl;
+        if (!IS_ERR(rpc))
+                rpc_killall_tasks(rpc);
+        rpc = server->client;
+        if (!IS_ERR(rpc))
+                rpc_killall_tasks(rpc);
 }
 
 /*
- * Validate the NFS2/NFS3 mount data
- * - fills in the mount root filehandle
+ * Sanity-check a server address provided by the mount command
  */
-static int nfs_validate_mount_data(struct nfs_mount_data *data,
-                                   struct nfs_fh *mntfh)
+static int nfs_verify_server_address(struct sockaddr *addr)
 {
-        if (data == NULL) {
-                dprintk("%s: missing data argument\n", __FUNCTION__);
-                return -EINVAL;
+        switch (addr->sa_family) {
+        case AF_INET: {
+                struct sockaddr_in *sa = (struct sockaddr_in *) addr;
+                if (sa->sin_addr.s_addr != INADDR_ANY)
+                        return 1;
+                break;
+        }
         }
 
-        if (data->version <= 0 || data->version > NFS_MOUNT_VERSION) {
-                dprintk("%s: bad mount version\n", __FUNCTION__);
-                return -EINVAL;
+        return 0;
+}
+
+/*
+ * Error-check and convert a string of mount options from user space into
+ * a data structure
+ */
+static int nfs_parse_mount_options(char *raw,
+                                   struct nfs_parsed_mount_data *mnt)
+{
+        char *p, *string;
+
+        if (!raw) {
+                dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
+                return 1;
         }
+        dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
 
-        switch (data->version) {
-                case 1:
-                        data->namlen = 0;
-                case 2:
-                        data->bsize  = 0;
-                case 3:
-                        if (data->flags & NFS_MOUNT_VER3) {
-                                dprintk("%s: mount structure version %d does not support NFSv3\n",
-                                                __FUNCTION__,
-                                                data->version);
-                                return -EINVAL;
+        while ((p = strsep(&raw, ",")) != NULL) {
+                substring_t args[MAX_OPT_ARGS];
+                int option, token;
+
+                if (!*p)
+                        continue;
+
+                dfprintk(MOUNT, "NFS:   parsing nfs mount option '%s'\n", p);
+
+                token = match_token(p, nfs_mount_option_tokens, args);
+                switch (token) {
+                case Opt_soft:
+                        mnt->flags |= NFS_MOUNT_SOFT;
+                        break;
+                case Opt_hard:
+                        mnt->flags &= ~NFS_MOUNT_SOFT;
+                        break;
+                case Opt_intr:
+                        mnt->flags |= NFS_MOUNT_INTR;
+                        break;
+                case Opt_nointr:
+                        mnt->flags &= ~NFS_MOUNT_INTR;
+                        break;
+                case Opt_posix:
+                        mnt->flags |= NFS_MOUNT_POSIX;
+                        break;
+                case Opt_noposix:
+                        mnt->flags &= ~NFS_MOUNT_POSIX;
+                        break;
+                case Opt_cto:
+                        mnt->flags &= ~NFS_MOUNT_NOCTO;
+                        break;
+                case Opt_nocto:
+                        mnt->flags |= NFS_MOUNT_NOCTO;
+                        break;
+                case Opt_ac:
+                        mnt->flags &= ~NFS_MOUNT_NOAC;
+                        break;
+                case Opt_noac:
+                        mnt->flags |= NFS_MOUNT_NOAC;
+                        break;
+                case Opt_lock:
+                        mnt->flags &= ~NFS_MOUNT_NONLM;
+                        break;
+                case Opt_nolock:
+                        mnt->flags |= NFS_MOUNT_NONLM;
+                        break;
+                case Opt_v2:
+                        mnt->flags &= ~NFS_MOUNT_VER3;
+                        break;
+                case Opt_v3:
+                        mnt->flags |= NFS_MOUNT_VER3;
+                        break;
+                case Opt_udp:
+                        mnt->flags &= ~NFS_MOUNT_TCP;
+                        mnt->nfs_server.protocol = IPPROTO_UDP;
+                        mnt->timeo = 7;
+                        mnt->retrans = 5;
+                        break;
+                case Opt_tcp:
+                        mnt->flags |= NFS_MOUNT_TCP;
+                        mnt->nfs_server.protocol = IPPROTO_TCP;
+                        mnt->timeo = 600;
+                        mnt->retrans = 2;
+                        break;
+                case Opt_acl:
+                        mnt->flags &= ~NFS_MOUNT_NOACL;
+                        break;
+                case Opt_noacl:
+                        mnt->flags |= NFS_MOUNT_NOACL;
+                        break;
+                case Opt_rdirplus:
+                        mnt->flags &= ~NFS_MOUNT_NORDIRPLUS;
+                        break;
+                case Opt_nordirplus:
+                        mnt->flags |= NFS_MOUNT_NORDIRPLUS;
+                        break;
+                case Opt_sharecache:
+                        mnt->flags &= ~NFS_MOUNT_UNSHARED;
+                        break;
+                case Opt_nosharecache:
+                        mnt->flags |= NFS_MOUNT_UNSHARED;
+                        break;
+
+                case Opt_port:
+                        if (match_int(args, &option))
+                                return 0;
+                        if (option < 0 || option > 65535)
+                                return 0;
+                        mnt->nfs_server.address.sin_port = htonl(option);
+                        break;
+                case Opt_rsize:
+                        if (match_int(args, &mnt->rsize))
+                                return 0;
+                        break;
+                case Opt_wsize:
+                        if (match_int(args, &mnt->wsize))
+                                return 0;
+                        break;
+                case Opt_bsize:
+                        if (match_int(args, &option))
+                                return 0;
+                        if (option < 0)
+                                return 0;
+                        mnt->bsize = option;
+                        break;
+                case Opt_timeo:
+                        if (match_int(args, &mnt->timeo))
+                                return 0;
+                        break;
+                case Opt_retrans:
+                        if (match_int(args, &mnt->retrans))
+                                return 0;
+                        break;
+                case Opt_acregmin:
+                        if (match_int(args, &mnt->acregmin))
+                                return 0;
+                        break;
+                case Opt_acregmax:
+                        if (match_int(args, &mnt->acregmax))
+                                return 0;
+                        break;
+                case Opt_acdirmin:
+                        if (match_int(args, &mnt->acdirmin))
+                                return 0;
+                        break;
+                case Opt_acdirmax:
+                        if (match_int(args, &mnt->acdirmax))
+                                return 0;
+                        break;
+                case Opt_actimeo:
+                        if (match_int(args, &option))
+                                return 0;
+                        if (option < 0)
+                                return 0;
+                        mnt->acregmin =
+                        mnt->acregmax =
+                        mnt->acdirmin =
+                        mnt->acdirmax = option;
+                        break;
+                case Opt_namelen:
+                        if (match_int(args, &mnt->namlen))
+                                return 0;
+                        break;
+                case Opt_mountport:
+                        if (match_int(args, &option))
+                                return 0;
+                        if (option < 0 || option > 65535)
+                                return 0;
+                        mnt->mount_server.port = option;
+                        break;
+                case Opt_mountprog:
+                        if (match_int(args, &option))
+                                return 0;
+                        if (option < 0)
+                                return 0;
+                        mnt->mount_server.program = option;
+                        break;
+                case Opt_mountvers:
+                        if (match_int(args, &option))
+                                return 0;
+                        if (option < 0)
+                                return 0;
+                        mnt->mount_server.version = option;
+                        break;
+                case Opt_nfsprog:
+                        if (match_int(args, &option))
+                                return 0;
+                        if (option < 0)
+                                return 0;
+                        mnt->nfs_server.program = option;
+                        break;
+                case Opt_nfsvers:
+                        if (match_int(args, &option))
+                                return 0;
+                        switch (option) {
+                        case 2:
+                                mnt->flags &= ~NFS_MOUNT_VER3;
+                                break;
+                        case 3:
+                                mnt->flags |= NFS_MOUNT_VER3;
+                                break;
+                        default:
+                                goto out_unrec_vers;
                         }
-                        data->root.size = NFS2_FHSIZE;
-                        memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
-                case 4:
-                        if (data->flags & NFS_MOUNT_SECFLAVOUR) {
-                                dprintk("%s: mount structure version %d does not support strong security\n",
-                                                __FUNCTION__,
-                                                data->version);
-                                return -EINVAL;
+                        break;
+
+                case Opt_sec:
+                        string = match_strdup(args);
+                        if (string == NULL)
+                                goto out_nomem;
+                        token = match_token(string, nfs_secflavor_tokens, args);
+                        kfree(string);
+
+                        /*
+                         * The flags setting is for v2/v3.  The flavor_len
+                         * setting is for v4.  v2/v3 also need to know the
+                         * difference between NULL and UNIX.
+                         */
+                        switch (token) {
+                        case Opt_sec_none:
+                                mnt->flags &= ~NFS_MOUNT_SECFLAVOUR;
+                                mnt->auth_flavor_len = 0;
+                                mnt->auth_flavors[0] = RPC_AUTH_NULL;
+                                break;
+                        case Opt_sec_sys:
+                                mnt->flags &= ~NFS_MOUNT_SECFLAVOUR;
+                                mnt->auth_flavor_len = 0;
+                                mnt->auth_flavors[0] = RPC_AUTH_UNIX;
+                                break;
+                        case Opt_sec_krb5:
+                                mnt->flags |= NFS_MOUNT_SECFLAVOUR;
+                                mnt->auth_flavor_len = 1;
+                                mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5;
+                                break;
+                        case Opt_sec_krb5i:
+                                mnt->flags |= NFS_MOUNT_SECFLAVOUR;
+                                mnt->auth_flavor_len = 1;
+                                mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5I;
+                                break;
+                        case Opt_sec_krb5p:
+                                mnt->flags |= NFS_MOUNT_SECFLAVOUR;
+                                mnt->auth_flavor_len = 1;
+                                mnt->auth_flavors[0] = RPC_AUTH_GSS_KRB5P;
+                                break;
+                        case Opt_sec_lkey:
+                                mnt->flags |= NFS_MOUNT_SECFLAVOUR;
+                                mnt->auth_flavor_len = 1;
+                                mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEY;
+                                break;
+                        case Opt_sec_lkeyi:
+                                mnt->flags |= NFS_MOUNT_SECFLAVOUR;
+                                mnt->auth_flavor_len = 1;
+                                mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYI;
+                                break;
+                        case Opt_sec_lkeyp:
+                                mnt->flags |= NFS_MOUNT_SECFLAVOUR;
+                                mnt->auth_flavor_len = 1;
+                                mnt->auth_flavors[0] = RPC_AUTH_GSS_LKEYP;
+                                break;
+                        case Opt_sec_spkm:
+                                mnt->flags |= NFS_MOUNT_SECFLAVOUR;
+                                mnt->auth_flavor_len = 1;
+                                mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKM;
+                                break;
+                        case Opt_sec_spkmi:
+                                mnt->flags |= NFS_MOUNT_SECFLAVOUR;
+                                mnt->auth_flavor_len = 1;
+                                mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMI;
+                                break;
+                        case Opt_sec_spkmp:
+                                mnt->flags |= NFS_MOUNT_SECFLAVOUR;
+                                mnt->auth_flavor_len = 1;
+                                mnt->auth_flavors[0] = RPC_AUTH_GSS_SPKMP;
+                                break;
+                        default:
+                                goto out_unrec_sec;
                         }
-                case 5:
-                        memset(data->context, 0, sizeof(data->context));
-        }
+                        break;
+                case Opt_proto:
+                        string = match_strdup(args);
+                        if (string == NULL)
+                                goto out_nomem;
+                        token = match_token(string,
+                                            nfs_xprt_protocol_tokens, args);
+                        kfree(string);
+
+                        switch (token) {
+                        case Opt_udp:
+                                mnt->flags &= ~NFS_MOUNT_TCP;
+                                mnt->nfs_server.protocol = IPPROTO_UDP;
+                                mnt->timeo = 7;
+                                mnt->retrans = 5;
+                                break;
+                        case Opt_tcp:
+                                mnt->flags |= NFS_MOUNT_TCP;
+                                mnt->nfs_server.protocol = IPPROTO_TCP;
+                                mnt->timeo = 600;
+                                mnt->retrans = 2;
+                                break;
+                        default:
+                                goto out_unrec_xprt;
+                        }
+                        break;
+                case Opt_mountproto:
+                        string = match_strdup(args);
+                        if (string == NULL)
+                                goto out_nomem;
+                        token = match_token(string,
+                                            nfs_xprt_protocol_tokens, args);
+                        kfree(string);
+
+                        switch (token) {
+                        case Opt_udp:
+                                mnt->mount_server.protocol = IPPROTO_UDP;
+                                break;
+                        case Opt_tcp:
+                                mnt->mount_server.protocol = IPPROTO_TCP;
+                                break;
+                        default:
+                                goto out_unrec_xprt;
+                        }
+                        break;
+                case Opt_addr:
+                        string = match_strdup(args);
+                        if (string == NULL)
+                                goto out_nomem;
+                        mnt->nfs_server.address.sin_family = AF_INET;
+                        mnt->nfs_server.address.sin_addr.s_addr =
+                                                        in_aton(string);
+                        kfree(string);
+                        break;
+                case Opt_clientaddr:
+                        string = match_strdup(args);
+                        if (string == NULL)
+                                goto out_nomem;
+                        mnt->client_address = string;
+                        break;
+                case Opt_mounthost:
+                        string = match_strdup(args);
+                        if (string == NULL)
+                                goto out_nomem;
+                        mnt->mount_server.address.sin_family = AF_INET;
+                        mnt->mount_server.address.sin_addr.s_addr =
+                                                        in_aton(string);
+                        kfree(string);
+                        break;
 
-        /* Set the pseudoflavor */
-        if (!(data->flags & NFS_MOUNT_SECFLAVOUR))
-                data->pseudoflavor = RPC_AUTH_UNIX;
+                case Opt_userspace:
+                case Opt_deprecated:
+                        break;
 
-#ifndef CONFIG_NFS_V3
-        /* If NFSv3 is not compiled in, return -EPROTONOSUPPORT */
-        if (data->flags & NFS_MOUNT_VER3) {
-                dprintk("%s: NFSv3 not compiled into kernel\n", __FUNCTION__);
-                return -EPROTONOSUPPORT;
+                default:
+                        goto out_unknown;
+                }
         }
-#endif /* CONFIG_NFS_V3 */
 
-        /* We now require that the mount process passes the remote address */
-        if (data->addr.sin_addr.s_addr == INADDR_ANY) {
-                dprintk("%s: mount program didn't pass remote address!\n",
-                        __FUNCTION__);
-                return -EINVAL;
+        return 1;
+
+out_nomem:
+        printk(KERN_INFO "NFS: not enough memory to parse option\n");
+        return 0;
+
+out_unrec_vers:
+        printk(KERN_INFO "NFS: unrecognized NFS version number\n");
+        return 0;
+
+out_unrec_xprt:
+        printk(KERN_INFO "NFS: unrecognized transport protocol\n");
+        return 0;
+
+out_unrec_sec:
+        printk(KERN_INFO "NFS: unrecognized security flavor\n");
+        return 0;
+
+out_unknown:
+        printk(KERN_INFO "NFS: unknown mount option: %s\n", p);
+        return 0;
+}
+
+/*
+ * Use the remote server's MOUNT service to request the NFS file handle
+ * corresponding to the provided path.
+ */
+static int nfs_try_mount(struct nfs_parsed_mount_data *args,
+                         struct nfs_fh *root_fh)
+{
+        struct sockaddr_in sin;
+        int status;
+
+        if (args->mount_server.version == 0) {
+                if (args->flags & NFS_MOUNT_VER3)
+                        args->mount_server.version = NFS_MNT3_VERSION;
+                else
+                        args->mount_server.version = NFS_MNT_VERSION;
         }
 
-        /* Prepare the root filehandle */
-        if (data->flags & NFS_MOUNT_VER3)
-                mntfh->size = data->root.size;
+        /*
+         * Construct the mount server's address.
+         */
+        if (args->mount_server.address.sin_addr.s_addr != INADDR_ANY)
+                sin = args->mount_server.address;
         else
-                mntfh->size = NFS2_FHSIZE;
+                sin = args->nfs_server.address;
+        if (args->mount_server.port == 0) {
+                status = rpcb_getport_sync(&sin,
+                                           args->mount_server.program,
+                                           args->mount_server.version,
+                                           args->mount_server.protocol);
+                if (status < 0)
+                        goto out_err;
+                sin.sin_port = htons(status);
+        } else
+                sin.sin_port = htons(args->mount_server.port);
+
+        /*
+         * Now ask the mount server to map our export path
+         * to a file handle.
+         */
+        status = nfs_mount((struct sockaddr *) &sin,
+                           sizeof(sin),
+                           args->nfs_server.hostname,
+                           args->nfs_server.export_path,
+                           args->mount_server.version,
+                           args->mount_server.protocol,
+                           root_fh);
+        if (status < 0)
+                goto out_err;
+
+        return status;
 
-        if (mntfh->size > sizeof(mntfh->data)) {
-                dprintk("%s: invalid root filehandle\n", __FUNCTION__);
-                return -EINVAL;
+out_err:
+        dfprintk(MOUNT, "NFS: unable to contact server on host "
+                 NIPQUAD_FMT "\n", NIPQUAD(sin.sin_addr.s_addr));
+        return status;
+}
+
+/*
+ * Validate the NFS2/NFS3 mount data
+ * - fills in the mount root filehandle
+ *
+ * For option strings, user space handles the following behaviors:
+ *
+ * + DNS: mapping server host name to IP address ("addr=" option)
+ *
+ * + failure mode: how to behave if a mount request can't be handled
+ *   immediately ("fg/bg" option)
+ *
+ * + retry: how often to retry a mount request ("retry=" option)
+ *
+ * + breaking back: trying proto=udp after proto=tcp, v2 after v3,
+ *   mountproto=tcp after mountproto=udp, and so on
+ *
+ * XXX: as far as I can tell, changing the NFS program number is not
+ *      supported in the NFS client.
+ */
+static int nfs_validate_mount_data(struct nfs_mount_data **options,
+                                   struct nfs_fh *mntfh,
+                                   const char *dev_name)
+{
+        struct nfs_mount_data *data = *options;
+
+        if (data == NULL)
+                goto out_no_data;
+
+        switch (data->version) {
+        case 1:
+                data->namlen = 0;
+        case 2:
+                data->bsize = 0;
+        case 3:
+                if (data->flags & NFS_MOUNT_VER3)
+                        goto out_no_v3;
+                data->root.size = NFS2_FHSIZE;
+                memcpy(data->root.data, data->old_root.data, NFS2_FHSIZE);
+        case 4:
+                if (data->flags & NFS_MOUNT_SECFLAVOUR)
+                        goto out_no_sec;
+        case 5:
+                memset(data->context, 0, sizeof(data->context));
+        case 6:
+                if (data->flags & NFS_MOUNT_VER3)
+                        mntfh->size = data->root.size;
+                else
+                        mntfh->size = NFS2_FHSIZE;
+
+                if (mntfh->size > sizeof(mntfh->data))
+                        goto out_invalid_fh;
+
+                memcpy(mntfh->data, data->root.data, mntfh->size);
+                if (mntfh->size < sizeof(mntfh->data))
+                        memset(mntfh->data + mntfh->size, 0,
+                               sizeof(mntfh->data) - mntfh->size);
+                break;
+        default: {
+                unsigned int len;
+                char *c;
+                int status;
+                struct nfs_parsed_mount_data args = {
+                        .flags          = (NFS_MOUNT_VER3 | NFS_MOUNT_TCP),
+                        .rsize          = NFS_MAX_FILE_IO_SIZE,
+                        .wsize          = NFS_MAX_FILE_IO_SIZE,
+                        .timeo          = 600,
+                        .retrans        = 2,
+                        .acregmin       = 3,
+                        .acregmax       = 60,
+                        .acdirmin       = 30,
+                        .acdirmax       = 60,
+                        .mount_server.protocol = IPPROTO_UDP,
+                        .mount_server.program = NFS_MNT_PROGRAM,
+                        .nfs_server.protocol = IPPROTO_TCP,
+                        .nfs_server.program = NFS_PROGRAM,
+                };
+
+                if (nfs_parse_mount_options((char *) *options, &args) == 0)
+                        return -EINVAL;
+
+                data = kzalloc(sizeof(*data), GFP_KERNEL);
+                if (data == NULL)
+                        return -ENOMEM;
+
+                /*
+                 * NB: after this point, caller will free "data"
+                 * if we return an error
+                 */
+                *options = data;
+
+                c = strchr(dev_name, ':');
+                if (c == NULL)
+                        return -EINVAL;
+                len = c - dev_name - 1;
+                if (len > sizeof(data->hostname))
+                        return -EINVAL;
+                strncpy(data->hostname, dev_name, len);
+                args.nfs_server.hostname = data->hostname;
+
+                c++;
+                if (strlen(c) > NFS_MAXPATHLEN)
+                        return -EINVAL;
+                args.nfs_server.export_path = c;
+
+                status = nfs_try_mount(&args, mntfh);
+                if (status)
+                        return -EINVAL;
+
+                /*
+                 * Translate to nfs_mount_data, which nfs_fill_super
+                 * can deal with.
+                 */
+                data->version           = 6;
+                data->flags             = args.flags;
+                data->rsize             = args.rsize;
+                data->wsize             = args.wsize;
+                data->timeo             = args.timeo;
+                data->retrans           = args.retrans;
+                data->acregmin          = args.acregmin;
+                data->acregmax          = args.acregmax;
+                data->acdirmin          = args.acdirmin;
+                data->acdirmax          = args.acdirmax;
+                data->addr              = args.nfs_server.address;
+                data->namlen            = args.namlen;
+                data->bsize             = args.bsize;
+                data->pseudoflavor      = args.auth_flavors[0];
+
+                break;
+                }
         }
 
-        memcpy(mntfh->data, data->root.data, mntfh->size);
-        if (mntfh->size < sizeof(mntfh->data))
-                memset(mntfh->data + mntfh->size, 0,
-                       sizeof(mntfh->data) - mntfh->size);
+        if (!(data->flags & NFS_MOUNT_SECFLAVOUR))
+                data->pseudoflavor = RPC_AUTH_UNIX;
+
+#ifndef CONFIG_NFS_V3
+        if (data->flags & NFS_MOUNT_VER3)
+                goto out_v3_not_compiled;
+#endif /* !CONFIG_NFS_V3 */
+
+        if (!nfs_verify_server_address((struct sockaddr *) &data->addr))
+                goto out_no_address;
 
         return 0;
+
+out_no_data:
+        dfprintk(MOUNT, "NFS: mount program didn't pass any mount data\n");
+        return -EINVAL;
+
+out_no_v3:
+        dfprintk(MOUNT, "NFS: nfs_mount_data version %d does not support v3\n",
+                 data->version);
+        return -EINVAL;
+
+out_no_sec:
+        dfprintk(MOUNT, "NFS: nfs_mount_data version supports only AUTH_SYS\n");
+        return -EINVAL;
+
+#ifndef CONFIG_NFS_V3
+out_v3_not_compiled:
+        dfprintk(MOUNT, "NFS: NFSv3 is not compiled into kernel\n");
+        return -EPROTONOSUPPORT;
+#endif /* !CONFIG_NFS_V3 */
+
+out_no_address:
+        dfprintk(MOUNT, "NFS: mount program didn't pass remote address\n");
+        return -EINVAL;
+
+out_invalid_fh:
+        dfprintk(MOUNT, "NFS: invalid root filehandle\n");
+        return -EINVAL;
 }
 
 /*
@@ -600,13 +1317,51 @@ static int nfs_compare_super(struct super_block *sb, void *data)
 {
         struct nfs_server *server = data, *old = NFS_SB(sb);
 
-        if (old->nfs_client != server->nfs_client)
+        if (memcmp(&old->nfs_client->cl_addr,
+                                &server->nfs_client->cl_addr,
+                                sizeof(old->nfs_client->cl_addr)) != 0)
+                return 0;
+        /* Note: NFS_MOUNT_UNSHARED == NFS4_MOUNT_UNSHARED */
+        if (old->flags & NFS_MOUNT_UNSHARED)
                 return 0;
         if (memcmp(&old->fsid, &server->fsid, sizeof(old->fsid)) != 0)
                 return 0;
         return 1;
 }
 
+#define NFS_MS_MASK (MS_RDONLY|MS_NOSUID|MS_NODEV|MS_NOEXEC|MS_SYNCHRONOUS)
+
+static int nfs_compare_mount_options(const struct super_block *s, const struct nfs_server *b, int flags)
+{
+        const struct nfs_server *a = s->s_fs_info;
+        const struct rpc_clnt *clnt_a = a->client;
+        const struct rpc_clnt *clnt_b = b->client;
+
+        if ((s->s_flags & NFS_MS_MASK) != (flags & NFS_MS_MASK))
+                goto Ebusy;
+        if (a->nfs_client != b->nfs_client)
+                goto Ebusy;
+        if (a->flags != b->flags)
+                goto Ebusy;
+        if (a->wsize != b->wsize)
+                goto Ebusy;
+        if (a->rsize != b->rsize)
+                goto Ebusy;
+        if (a->acregmin != b->acregmin)
+                goto Ebusy;
+        if (a->acregmax != b->acregmax)
+                goto Ebusy;
+        if (a->acdirmin != b->acdirmin)
+                goto Ebusy;
+        if (a->acdirmax != b->acdirmax)
+                goto Ebusy;
+        if (clnt_a->cl_auth->au_flavor != clnt_b->cl_auth->au_flavor)
+                goto Ebusy;
+        return 0;
+Ebusy:
+        return -EBUSY;
+}
+
 static int nfs_get_sb(struct file_system_type *fs_type,
         int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt)
 {
@@ -615,30 +1370,37 @@ static int nfs_get_sb(struct file_system_type *fs_type,
         struct nfs_fh mntfh;
         struct nfs_mount_data *data = raw_data;
         struct dentry *mntroot;
+        int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
         int error;
 
         /* Validate the mount data */
-        error = nfs_validate_mount_data(data, &mntfh);
+        error = nfs_validate_mount_data(&data, &mntfh, dev_name);
         if (error < 0)
-                return error;
+                goto out;
 
         /* Get a volume representation */
         server = nfs_create_server(data, &mntfh);
         if (IS_ERR(server)) {
                 error = PTR_ERR(server);
-                goto out_err_noserver;
+                goto out;
         }
 
+        if (server->flags & NFS_MOUNT_UNSHARED)
+                compare_super = NULL;
+
         /* Get a superblock - note that we may end up sharing one that already exists */
-        s = sget(fs_type, nfs_compare_super, nfs_set_super, server);
+        s = sget(fs_type, compare_super, nfs_set_super, server);
         if (IS_ERR(s)) {
                 error = PTR_ERR(s);
                 goto out_err_nosb;
         }
 
         if (s->s_fs_info != server) {
+                error = nfs_compare_mount_options(s, server, flags);
                 nfs_free_server(server);
                 server = NULL;
+                if (error < 0)
+                        goto error_splat_super;
         }
 
         if (!s->s_root) {
@@ -656,17 +1418,21 @@ static int nfs_get_sb(struct file_system_type *fs_type,
         s->s_flags |= MS_ACTIVE;
         mnt->mnt_sb = s;
         mnt->mnt_root = mntroot;
-        return 0;
+        error = 0;
+
+out:
+        if (data != raw_data)
+                kfree(data);
+        return error;
 
 out_err_nosb:
         nfs_free_server(server);
-out_err_noserver:
-        return error;
+        goto out;
 
 error_splat_super:
         up_write(&s->s_umount);
         deactivate_super(s);
-        return error;
+        goto out;
 }
 
 /*
@@ -691,6 +1457,7 @@ static int nfs_xdev_get_sb(struct file_system_type *fs_type, int flags,
         struct super_block *s;
         struct nfs_server *server;
         struct dentry *mntroot;
+        int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
         int error;
 
         dprintk("--> nfs_xdev_get_sb()\n");
@@ -702,16 +1469,22 @@ static int nfs_xdev_get_sb(struct file_system_type *fs_type, int flags,
                 goto out_err_noserver;
         }
 
+        if (server->flags & NFS_MOUNT_UNSHARED)
+                compare_super = NULL;
+
         /* Get a superblock - note that we may end up sharing one that already exists */
-        s = sget(&nfs_fs_type, nfs_compare_super, nfs_set_super, server);
+        s = sget(&nfs_fs_type, compare_super, nfs_set_super, server);
         if (IS_ERR(s)) {
                 error = PTR_ERR(s);
                 goto out_err_nosb;
         }
 
         if (s->s_fs_info != server) {
+                error = nfs_compare_mount_options(s, server, flags);
                 nfs_free_server(server);
                 server = NULL;
+                if (error < 0)
+                        goto error_splat_super;
         }
 
         if (!s->s_root) {
@@ -772,25 +1545,164 @@ static void nfs4_fill_super(struct super_block *sb)
         nfs_initialise_sb(sb);
 }
 
-static void *nfs_copy_user_string(char *dst, struct nfs_string *src, int maxlen)
+/*
+ * Validate NFSv4 mount options
+ */
+static int nfs4_validate_mount_data(struct nfs4_mount_data **options,
+                                    const char *dev_name,
+                                    struct sockaddr_in *addr,
+                                    rpc_authflavor_t *authflavour,
+                                    char **hostname,
+                                    char **mntpath,
+                                    char **ip_addr)
 {
-        void *p = NULL;
-
-        if (!src->len)
-                return ERR_PTR(-EINVAL);
-        if (src->len < maxlen)
-                maxlen = src->len;
-        if (dst == NULL) {
-                p = dst = kmalloc(maxlen + 1, GFP_KERNEL);
-                if (p == NULL)
-                        return ERR_PTR(-ENOMEM);
-        }
-        if (copy_from_user(dst, src->data, maxlen)) {
-                kfree(p);
-                return ERR_PTR(-EFAULT);
+        struct nfs4_mount_data *data = *options;
+        char *c;
+
+        if (data == NULL)
+                goto out_no_data;
+
+        switch (data->version) {
+        case 1:
+                if (data->host_addrlen != sizeof(*addr))
+                        goto out_no_address;
+                if (copy_from_user(addr, data->host_addr, sizeof(*addr)))
+                        return -EFAULT;
+                if (addr->sin_port == 0)
+                        addr->sin_port = htons(NFS_PORT);
+                if (!nfs_verify_server_address((struct sockaddr *) addr))
+                        goto out_no_address;
+
+                switch (data->auth_flavourlen) {
+                case 0:
+                        *authflavour = RPC_AUTH_UNIX;
+                        break;
+                case 1:
+                        if (copy_from_user(authflavour, data->auth_flavours,
+                                           sizeof(*authflavour)))
+                                return -EFAULT;
+                        break;
+                default:
+                        goto out_inval_auth;
+                }
+
+                c = strndup_user(data->hostname.data, NFS4_MAXNAMLEN);
+                if (IS_ERR(c))
+                        return PTR_ERR(c);
+                *hostname = c;
+
+                c = strndup_user(data->mnt_path.data, NFS4_MAXPATHLEN);
+                if (IS_ERR(c))
+                        return PTR_ERR(c);
+                *mntpath = c;
+                dfprintk(MOUNT, "NFS: MNTPATH: '%s'\n", *mntpath);
+
+                c = strndup_user(data->client_addr.data, 16);
+                if (IS_ERR(c))
+                        return PTR_ERR(c);
+                *ip_addr = c;
+
+                break;
+        default: {
+                unsigned int len;
+                struct nfs_parsed_mount_data args = {
+                        .rsize          = NFS_MAX_FILE_IO_SIZE,
+                        .wsize          = NFS_MAX_FILE_IO_SIZE,
+                        .timeo          = 600,
+                        .retrans        = 2,
+                        .acregmin       = 3,
+                        .acregmax       = 60,
+                        .acdirmin       = 30,
+                        .acdirmax       = 60,
+                        .nfs_server.protocol = IPPROTO_TCP,
+                };
+
+                if (nfs_parse_mount_options((char *) *options, &args) == 0)
+                        return -EINVAL;
+
+                if (!nfs_verify_server_address((struct sockaddr *)
+                                                &args.nfs_server.address))
+                        return -EINVAL;
+                *addr = args.nfs_server.address;
+
+                switch (args.auth_flavor_len) {
+                case 0:
+                        *authflavour = RPC_AUTH_UNIX;
+                        break;
+                case 1:
+                        *authflavour = (rpc_authflavor_t) args.auth_flavors[0];
+                        break;
+                default:
+                        goto out_inval_auth;
+                }
+
+                /*
+                 * Translate to nfs4_mount_data, which nfs4_fill_super
+                 * can deal with.
+                 */
+                data = kzalloc(sizeof(*data), GFP_KERNEL);
+                if (data == NULL)
+                        return -ENOMEM;
+                *options = data;
+
+                data->version   = 1;
+                data->flags     = args.flags & NFS4_MOUNT_FLAGMASK;
+                data->rsize     = args.rsize;
+                data->wsize     = args.wsize;
+                data->timeo     = args.timeo;
+                data->retrans   = args.retrans;
+                data->acregmin  = args.acregmin;
+                data->acregmax  = args.acregmax;
+                data->acdirmin  = args.acdirmin;
+                data->acdirmax  = args.acdirmax;
+                data->proto     = args.nfs_server.protocol;
+
+                /*
+                 * Split "dev_name" into "hostname:mntpath".
+                 */
+                c = strchr(dev_name, ':');
+                if (c == NULL)
+                        return -EINVAL;
+                /* while calculating len, pretend ':' is '\0' */
+                len = c - dev_name;
+                if (len > NFS4_MAXNAMLEN)
+                        return -EINVAL;
+                *hostname = kzalloc(len, GFP_KERNEL);
+                if (*hostname == NULL)
+                        return -ENOMEM;
+                strncpy(*hostname, dev_name, len - 1);
+
+                c++;                    /* step over the ':' */
+                len = strlen(c);
+                if (len > NFS4_MAXPATHLEN)
+                        return -EINVAL;
+                *mntpath = kzalloc(len + 1, GFP_KERNEL);
+                if (*mntpath == NULL)
+                        return -ENOMEM;
+                strncpy(*mntpath, c, len);
+
+                dprintk("MNTPATH: %s\n", *mntpath);
+
+                *ip_addr = args.client_address;
+
+                break;
+                }
         }
-        dst[maxlen] = '\0';
-        return dst;
+
+        return 0;
+
+out_no_data:
+        dfprintk(MOUNT, "NFS4: mount program didn't pass any mount data\n");
+        return -EINVAL;
+
+out_inval_auth:
+        dfprintk(MOUNT, "NFS4: Invalid number of RPC auth flavours %d\n",
+                 data->auth_flavourlen);
+        return -EINVAL;
+
+out_no_address:
+        dfprintk(MOUNT, "NFS4: mount program didn't pass remote address\n");
+        return -EINVAL;
 }
 
 /*
@@ -806,81 +1718,29 @@ static int nfs4_get_sb(struct file_system_type *fs_type,
         rpc_authflavor_t authflavour;
         struct nfs_fh mntfh;
         struct dentry *mntroot;
-        char *mntpath = NULL, *hostname = NULL, ip_addr[16];
-        void *p;
+        char *mntpath = NULL, *hostname = NULL, *ip_addr = NULL;
+        int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
         int error;
 
-        if (data == NULL) {
-                dprintk("%s: missing data argument\n", __FUNCTION__);
-                return -EINVAL;
-        }
-        if (data->version <= 0 || data->version > NFS4_MOUNT_VERSION) {
-                dprintk("%s: bad mount version\n", __FUNCTION__);
-                return -EINVAL;
-        }
-
-        /* We now require that the mount process passes the remote address */
-        if (data->host_addrlen != sizeof(addr))
-                return -EINVAL;
-
-        if (copy_from_user(&addr, data->host_addr, sizeof(addr)))
-                return -EFAULT;
-
-        if (addr.sin_family != AF_INET ||
-            addr.sin_addr.s_addr == INADDR_ANY
-            ) {
-                dprintk("%s: mount program didn't pass remote IP address!\n",
-                                __FUNCTION__);
-                return -EINVAL;
-        }
-        /* RFC3530: The default port for NFS is 2049 */
-        if (addr.sin_port == 0)
-                addr.sin_port = htons(NFS_PORT);
-
-        /* Grab the authentication type */
-        authflavour = RPC_AUTH_UNIX;
-        if (data->auth_flavourlen != 0) {
-                if (data->auth_flavourlen != 1) {
-                        dprintk("%s: Invalid number of RPC auth flavours %d.\n",
-                                        __FUNCTION__, data->auth_flavourlen);
-                        error = -EINVAL;
-                        goto out_err_noserver;
-                }
-
-                if (copy_from_user(&authflavour, data->auth_flavours,
-                                   sizeof(authflavour))) {
-                        error = -EFAULT;
-                        goto out_err_noserver;
-                }
-        }
-
-        p = nfs_copy_user_string(NULL, &data->hostname, 256);
-        if (IS_ERR(p))
-                goto out_err;
-        hostname = p;
-
-        p = nfs_copy_user_string(NULL, &data->mnt_path, 1024);
-        if (IS_ERR(p))
-                goto out_err;
-        mntpath = p;
-
-        dprintk("MNTPATH: %s\n", mntpath);
-
-        p = nfs_copy_user_string(ip_addr, &data->client_addr,
-                                 sizeof(ip_addr) - 1);
-        if (IS_ERR(p))
-                goto out_err;
+        /* Validate the mount data */
+        error = nfs4_validate_mount_data(&data, dev_name, &addr, &authflavour,
+                                         &hostname, &mntpath, &ip_addr);
+        if (error < 0)
+                goto out;
 
         /* Get a volume representation */
         server = nfs4_create_server(data, hostname, &addr, mntpath, ip_addr,
                                     authflavour, &mntfh);
         if (IS_ERR(server)) {
                 error = PTR_ERR(server);
-                goto out_err_noserver;
+                goto out;
         }
 
+        if (server->flags & NFS4_MOUNT_UNSHARED)
+                compare_super = NULL;
+
         /* Get a superblock - note that we may end up sharing one that already exists */
-        s = sget(fs_type, nfs_compare_super, nfs_set_super, server);
+        s = sget(fs_type, compare_super, nfs_set_super, server);
         if (IS_ERR(s)) {
                 error = PTR_ERR(s);
                 goto out_free;
@@ -906,25 +1766,22 @@ static int nfs4_get_sb(struct file_system_type *fs_type,
         s->s_flags |= MS_ACTIVE;
         mnt->mnt_sb = s;
         mnt->mnt_root = mntroot;
+        error = 0;
+
+out:
+        kfree(ip_addr);
         kfree(mntpath);
         kfree(hostname);
-        return 0;
-
-out_err:
-        error = PTR_ERR(p);
-        goto out_err_noserver;
+        return error;
 
 out_free:
         nfs_free_server(server);
-out_err_noserver:
-        kfree(mntpath);
-        kfree(hostname);
-        return error;
+        goto out;
 
 error_splat_super:
         up_write(&s->s_umount);
         deactivate_super(s);
-        goto out_err_noserver;
+        goto out;
 }
 
 static void nfs4_kill_super(struct super_block *sb)
@@ -949,6 +1806,7 @@ static int nfs4_xdev_get_sb(struct file_system_type *fs_type, int flags,
         struct super_block *s;
         struct nfs_server *server;
         struct dentry *mntroot;
+        int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
         int error;
 
         dprintk("--> nfs4_xdev_get_sb()\n");
@@ -960,8 +1818,11 @@ static int nfs4_xdev_get_sb(struct file_system_type *fs_type, int flags,
                 goto out_err_noserver;
         }
 
+        if (server->flags & NFS4_MOUNT_UNSHARED)
+                compare_super = NULL;
+
         /* Get a superblock - note that we may end up sharing one that already exists */
-        s = sget(&nfs_fs_type, nfs_compare_super, nfs_set_super, server);
+        s = sget(&nfs_fs_type, compare_super, nfs_set_super, server);
         if (IS_ERR(s)) {
                 error = PTR_ERR(s);
                 goto out_err_nosb;
@@ -1016,6 +1877,7 @@ static int nfs4_referral_get_sb(struct file_system_type *fs_type, int flags,
         struct nfs_server *server;
         struct dentry *mntroot;
         struct nfs_fh mntfh;
+        int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
         int error;
 
         dprintk("--> nfs4_referral_get_sb()\n");
@@ -1027,8 +1889,11 @@ static int nfs4_referral_get_sb(struct file_system_type *fs_type, int flags,
                 goto out_err_noserver;
         }
 
+        if (server->flags & NFS4_MOUNT_UNSHARED)
+                compare_super = NULL;
+
         /* Get a superblock - note that we may end up sharing one that already exists */
-        s = sget(&nfs_fs_type, nfs_compare_super, nfs_set_super, server);
+        s = sget(&nfs_fs_type, compare_super, nfs_set_super, server);
         if (IS_ERR(s)) {
                 error = PTR_ERR(s);
                 goto out_err_nosb;
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index af344a158e0..73ac992ece8 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -117,19 +117,19 @@ static struct nfs_page *nfs_page_find_request_locked(struct page *page)
         if (PagePrivate(page)) {
                 req = (struct nfs_page *)page_private(page);
                 if (req != NULL)
-                        atomic_inc(&req->wb_count);
+                        kref_get(&req->wb_kref);
         }
         return req;
 }
 
 static struct nfs_page *nfs_page_find_request(struct page *page)
 {
+        struct inode *inode = page->mapping->host;
         struct nfs_page *req = NULL;
-        spinlock_t *req_lock = &NFS_I(page->mapping->host)->req_lock;
 
-        spin_lock(req_lock);
+        spin_lock(&inode->i_lock);
         req = nfs_page_find_request_locked(page);
-        spin_unlock(req_lock);
+        spin_unlock(&inode->i_lock);
         return req;
 }
 
@@ -191,8 +191,6 @@ static int nfs_writepage_setup(struct nfs_open_context *ctx, struct page *page,
         }
         /* Update file length */
         nfs_grow_file(page, offset, count);
-        /* Set the PG_uptodate flag? */
-        nfs_mark_uptodate(page, offset, count);
         nfs_unlock_request(req);
         return 0;
 }
@@ -253,16 +251,16 @@ static void nfs_end_page_writeback(struct page *page)
 static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
                                 struct page *page)
 {
+        struct inode *inode = page->mapping->host;
+        struct nfs_inode *nfsi = NFS_I(inode);
         struct nfs_page *req;
-        struct nfs_inode *nfsi = NFS_I(page->mapping->host);
-        spinlock_t *req_lock = &nfsi->req_lock;
         int ret;
 
-        spin_lock(req_lock);
+        spin_lock(&inode->i_lock);
         for(;;) {
                 req = nfs_page_find_request_locked(page);
                 if (req == NULL) {
-                        spin_unlock(req_lock);
+                        spin_unlock(&inode->i_lock);
                         return 1;
                 }
                 if (nfs_lock_request_dontget(req))
@@ -272,28 +270,28 @@ static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
                  *       succeed provided that someone hasn't already marked the
                  *       request as dirty (in which case we don't care).
                  */
-                spin_unlock(req_lock);
+                spin_unlock(&inode->i_lock);
                 ret = nfs_wait_on_request(req);
                 nfs_release_request(req);
                 if (ret != 0)
                         return ret;
-                spin_lock(req_lock);
+                spin_lock(&inode->i_lock);
         }
         if (test_bit(PG_NEED_COMMIT, &req->wb_flags)) {
                 /* This request is marked for commit */
-                spin_unlock(req_lock);
+                spin_unlock(&inode->i_lock);
                 nfs_unlock_request(req);
                 nfs_pageio_complete(pgio);
                 return 1;
         }
         if (nfs_set_page_writeback(page) != 0) {
-                spin_unlock(req_lock);
+                spin_unlock(&inode->i_lock);
                 BUG();
         }
         radix_tree_tag_set(&nfsi->nfs_page_tree, req->wb_index,
-                        NFS_PAGE_TAG_WRITEBACK);
+                        NFS_PAGE_TAG_LOCKED);
         ret = test_bit(PG_NEED_FLUSH, &req->wb_flags);
-        spin_unlock(req_lock);
+        spin_unlock(&inode->i_lock);
         nfs_pageio_add_request(pgio, req);
         return ret;
 }
@@ -400,7 +398,7 @@ static int nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
         if (PageDirty(req->wb_page))
                 set_bit(PG_NEED_FLUSH, &req->wb_flags);
         nfsi->npages++;
-        atomic_inc(&req->wb_count);
+        kref_get(&req->wb_kref);
         return 0;
 }
 
@@ -409,12 +407,12 @@ static int nfs_inode_add_request(struct inode *inode, struct nfs_page *req)
  */
 static void nfs_inode_remove_request(struct nfs_page *req)
 {
-        struct inode *inode = req->wb_context->dentry->d_inode;
+        struct inode *inode = req->wb_context->path.dentry->d_inode;
         struct nfs_inode *nfsi = NFS_I(inode);
 
         BUG_ON (!NFS_WBACK_BUSY(req));
 
-        spin_lock(&nfsi->req_lock);
+        spin_lock(&inode->i_lock);
         set_page_private(req->wb_page, 0);
         ClearPagePrivate(req->wb_page);
         radix_tree_delete(&nfsi->nfs_page_tree, req->wb_index);
@@ -422,11 +420,11 @@ static void nfs_inode_remove_request(struct nfs_page *req)
                 __set_page_dirty_nobuffers(req->wb_page);
         nfsi->npages--;
         if (!nfsi->npages) {
-                spin_unlock(&nfsi->req_lock);
+                spin_unlock(&inode->i_lock);
                 nfs_end_data_update(inode);
                 iput(inode);
         } else
-                spin_unlock(&nfsi->req_lock);
+                spin_unlock(&inode->i_lock);
         nfs_clear_request(req);
         nfs_release_request(req);
 }
@@ -457,14 +455,16 @@ nfs_dirty_request(struct nfs_page *req)
 static void
 nfs_mark_request_commit(struct nfs_page *req)
 {
-        struct inode *inode = req->wb_context->dentry->d_inode;
+        struct inode *inode = req->wb_context->path.dentry->d_inode;
         struct nfs_inode *nfsi = NFS_I(inode);
 
-        spin_lock(&nfsi->req_lock);
-        nfs_list_add_request(req, &nfsi->commit);
+        spin_lock(&inode->i_lock);
         nfsi->ncommit++;
         set_bit(PG_NEED_COMMIT, &(req)->wb_flags);
-        spin_unlock(&nfsi->req_lock);
+        radix_tree_tag_set(&nfsi->nfs_page_tree,
+                        req->wb_index,
+                        NFS_PAGE_TAG_COMMIT);
+        spin_unlock(&inode->i_lock);
         inc_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
         __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
 }
@@ -526,18 +526,18 @@ static int nfs_wait_on_requests_locked(struct inode *inode, pgoff_t idx_start, u
                 idx_end = idx_start + npages - 1;
 
         next = idx_start;
-        while (radix_tree_gang_lookup_tag(&nfsi->nfs_page_tree, (void **)&req, next, 1, NFS_PAGE_TAG_WRITEBACK)) {
+        while (radix_tree_gang_lookup_tag(&nfsi->nfs_page_tree, (void **)&req, next, 1, NFS_PAGE_TAG_LOCKED)) {
                 if (req->wb_index > idx_end)
                         break;
 
                 next = req->wb_index + 1;
                 BUG_ON(!NFS_WBACK_BUSY(req));
 
-                atomic_inc(&req->wb_count);
-                spin_unlock(&nfsi->req_lock);
+                kref_get(&req->wb_kref);
+                spin_unlock(&inode->i_lock);
                 error = nfs_wait_on_request(req);
                 nfs_release_request(req);
-                spin_lock(&nfsi->req_lock);
+                spin_lock(&inode->i_lock);
                 if (error < 0)
                         return error;
                 res++;
@@ -577,10 +577,9 @@ nfs_scan_commit(struct inode *inode, struct list_head *dst, pgoff_t idx_start, u
         int res = 0;
 
         if (nfsi->ncommit != 0) {
-                res = nfs_scan_list(nfsi, &nfsi->commit, dst, idx_start, npages);
+                res = nfs_scan_list(nfsi, dst, idx_start, npages,
+                                NFS_PAGE_TAG_COMMIT);
                 nfsi->ncommit -= res;
-                if ((nfsi->ncommit == 0) != list_empty(&nfsi->commit))
-                        printk(KERN_ERR "NFS: desynchronized value of nfs_i.ncommit.\n");
         }
         return res;
 }
@@ -603,7 +602,6 @@ static struct nfs_page * nfs_update_request(struct nfs_open_context* ctx,
 {
         struct address_space *mapping = page->mapping;
         struct inode *inode = mapping->host;
-        struct nfs_inode *nfsi = NFS_I(inode);
         struct nfs_page         *req, *new = NULL;
         pgoff_t         rqend, end;
 
@@ -613,13 +611,13 @@ static struct nfs_page * nfs_update_request(struct nfs_open_context* ctx,
                 /* Loop over all inode entries and see if we find
                  * A request for the page we wish to update
                  */
-                spin_lock(&nfsi->req_lock);
+                spin_lock(&inode->i_lock);
                 req = nfs_page_find_request_locked(page);
                 if (req) {
                         if (!nfs_lock_request_dontget(req)) {
                                 int error;
 
-                                spin_unlock(&nfsi->req_lock);
+                                spin_unlock(&inode->i_lock);
                                 error = nfs_wait_on_request(req);
                                 nfs_release_request(req);
                                 if (error < 0) {
@@ -629,7 +627,7 @@ static struct nfs_page * nfs_update_request(struct nfs_open_context* ctx,
                                 }
                                 continue;
                         }
-                        spin_unlock(&nfsi->req_lock);
+                        spin_unlock(&inode->i_lock);
                         if (new)
                                 nfs_release_request(new);
                         break;
@@ -640,14 +638,14 @@ static struct nfs_page * nfs_update_request(struct nfs_open_context* ctx,
                         nfs_lock_request_dontget(new);
                         error = nfs_inode_add_request(inode, new);
                         if (error) {
-                                spin_unlock(&nfsi->req_lock);
+                                spin_unlock(&inode->i_lock);
                                 nfs_unlock_request(new);
                                 return ERR_PTR(error);
                         }
-                        spin_unlock(&nfsi->req_lock);
+                        spin_unlock(&inode->i_lock);
                         return new;
                 }
-                spin_unlock(&nfsi->req_lock);
+                spin_unlock(&inode->i_lock);
 
                 new = nfs_create_request(ctx, inode, page, offset, bytes);
                 if (IS_ERR(new))
@@ -751,12 +749,17 @@ int nfs_updatepage(struct file *file, struct page *page,
 static void nfs_writepage_release(struct nfs_page *req)
 {
 
-        if (PageError(req->wb_page) || !nfs_reschedule_unstable_write(req)) {
+        if (PageError(req->wb_page)) {
+                nfs_end_page_writeback(req->wb_page);
+                nfs_inode_remove_request(req);
+        } else if (!nfs_reschedule_unstable_write(req)) {
+                /* Set the PG_uptodate flag */
+                nfs_mark_uptodate(req->wb_page, req->wb_pgbase, req->wb_bytes);
                 nfs_end_page_writeback(req->wb_page);
                 nfs_inode_remove_request(req);
         } else
                 nfs_end_page_writeback(req->wb_page);
-        nfs_clear_page_writeback(req);
+        nfs_clear_page_tag_locked(req);
 }
 
 static inline int flush_task_priority(int how)
@@ -786,7 +789,7 @@ static void nfs_write_rpcsetup(struct nfs_page *req,
          * NB: take care not to mess about with data->commit et al. */
 
         data->req = req;
-        data->inode = inode = req->wb_context->dentry->d_inode;
+        data->inode = inode = req->wb_context->path.dentry->d_inode;
         data->cred = req->wb_context->cred;
 
         data->args.fh     = NFS_FH(inode);
@@ -885,7 +888,7 @@ out_bad:
         }
         nfs_redirty_request(req);
         nfs_end_page_writeback(req->wb_page);
-        nfs_clear_page_writeback(req);
+        nfs_clear_page_tag_locked(req);
         return -ENOMEM;
 }
 
@@ -928,7 +931,7 @@ static int nfs_flush_one(struct inode *inode, struct list_head *head, unsigned i
                 nfs_list_remove_request(req);
                 nfs_redirty_request(req);
                 nfs_end_page_writeback(req->wb_page);
-                nfs_clear_page_writeback(req);
+                nfs_clear_page_tag_locked(req);
         }
         return -ENOMEM;
 }
@@ -954,8 +957,8 @@ static void nfs_writeback_done_partial(struct rpc_task *task, void *calldata)
         struct page             *page = req->wb_page;
 
         dprintk("NFS: write (%s/%Ld %d@%Ld)",
-                req->wb_context->dentry->d_inode->i_sb->s_id,
-                (long long)NFS_FILEID(req->wb_context->dentry->d_inode),
+                req->wb_context->path.dentry->d_inode->i_sb->s_id,
+                (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
                 req->wb_bytes,
                 (long long)req_offset(req));
 
@@ -970,9 +973,9 @@ static void nfs_writeback_done_partial(struct rpc_task *task, void *calldata)
         }
 
         if (nfs_write_need_commit(data)) {
-                spinlock_t *req_lock = &NFS_I(page->mapping->host)->req_lock;
+                struct inode *inode = page->mapping->host;
 
-                spin_lock(req_lock);
+                spin_lock(&inode->i_lock);
                 if (test_bit(PG_NEED_RESCHED, &req->wb_flags)) {
                         /* Do nothing we need to resend the writes */
                 } else if (!test_and_set_bit(PG_NEED_COMMIT, &req->wb_flags)) {
@@ -983,7 +986,7 @@ static void nfs_writeback_done_partial(struct rpc_task *task, void *calldata)
                         clear_bit(PG_NEED_COMMIT, &req->wb_flags);
                         dprintk(" server reboot detected\n");
                 }
-                spin_unlock(req_lock);
+                spin_unlock(&inode->i_lock);
         } else
                 dprintk(" OK\n");
 
@@ -1020,8 +1023,8 @@ static void nfs_writeback_done_full(struct rpc_task *task, void *calldata)
                 page = req->wb_page;
 
                 dprintk("NFS: write (%s/%Ld %d@%Ld)",
-                        req->wb_context->dentry->d_inode->i_sb->s_id,
-                        (long long)NFS_FILEID(req->wb_context->dentry->d_inode),
+                        req->wb_context->path.dentry->d_inode->i_sb->s_id,
+                        (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
                         req->wb_bytes,
                         (long long)req_offset(req));
 
@@ -1039,12 +1042,14 @@ static void nfs_writeback_done_full(struct rpc_task *task, void *calldata)
                         dprintk(" marked for commit\n");
                         goto next;
                 }
+                /* Set the PG_uptodate flag? */
+                nfs_mark_uptodate(page, req->wb_pgbase, req->wb_bytes);
                 dprintk(" OK\n");
 remove_request:
                 nfs_end_page_writeback(page);
                 nfs_inode_remove_request(req);
         next:
-                nfs_clear_page_writeback(req);
+                nfs_clear_page_tag_locked(req);
         }
 }
 
@@ -1157,7 +1162,7 @@ static void nfs_commit_rpcsetup(struct list_head *head,
 
         list_splice_init(head, &data->pages);
         first = nfs_list_entry(data->pages.next);
-        inode = first->wb_context->dentry->d_inode;
+        inode = first->wb_context->path.dentry->d_inode;
 
         data->inode       = inode;
         data->cred        = first->wb_context->cred;
@@ -1207,7 +1212,7 @@ nfs_commit_list(struct inode *inode, struct list_head *head, int how)
                 nfs_list_remove_request(req);
                 nfs_mark_request_commit(req);
                 dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
-                nfs_clear_page_writeback(req);
+                nfs_clear_page_tag_locked(req);
         }
         return -ENOMEM;
 }
@@ -1234,8 +1239,8 @@ static void nfs_commit_done(struct rpc_task *task, void *calldata)
                 dec_zone_page_state(req->wb_page, NR_UNSTABLE_NFS);
 
                 dprintk("NFS: commit (%s/%Ld %d@%Ld)",
-                        req->wb_context->dentry->d_inode->i_sb->s_id,
-                        (long long)NFS_FILEID(req->wb_context->dentry->d_inode),
+                        req->wb_context->path.dentry->d_inode->i_sb->s_id,
+                        (long long)NFS_FILEID(req->wb_context->path.dentry->d_inode),
                         req->wb_bytes,
                         (long long)req_offset(req));
                 if (task->tk_status < 0) {
@@ -1249,6 +1254,9 @@ static void nfs_commit_done(struct rpc_task *task, void *calldata)
                  * returned by the server against all stored verfs. */
                 if (!memcmp(req->wb_verf.verifier, data->verf.verifier, sizeof(data->verf.verifier))) {
                         /* We have a match */
+                        /* Set the PG_uptodate flag */
+                        nfs_mark_uptodate(req->wb_page, req->wb_pgbase,
+                                        req->wb_bytes);
                         nfs_inode_remove_request(req);
                         dprintk(" OK\n");
                         goto next;
@@ -1257,7 +1265,7 @@ static void nfs_commit_done(struct rpc_task *task, void *calldata)
                 dprintk(" mismatch\n");
                 nfs_redirty_request(req);
         next:
-                nfs_clear_page_writeback(req);
+                nfs_clear_page_tag_locked(req);
         }
 }
 
@@ -1268,13 +1276,12 @@ static const struct rpc_call_ops nfs_commit_ops = {
 
 int nfs_commit_inode(struct inode *inode, int how)
 {
-        struct nfs_inode *nfsi = NFS_I(inode);
         LIST_HEAD(head);
         int res;
 
-        spin_lock(&nfsi->req_lock);
+        spin_lock(&inode->i_lock);
         res = nfs_scan_commit(inode, &head, 0, 0);
-        spin_unlock(&nfsi->req_lock);
+        spin_unlock(&inode->i_lock);
         if (res) {
                 int error = nfs_commit_list(inode, &head, how);
                 if (error < 0)
@@ -1292,7 +1299,6 @@ static inline int nfs_commit_list(struct inode *inode, struct list_head *head, i
 long nfs_sync_mapping_wait(struct address_space *mapping, struct writeback_control *wbc, int how)
 {
         struct inode *inode = mapping->host;
-        struct nfs_inode *nfsi = NFS_I(inode);
         pgoff_t idx_start, idx_end;
         unsigned int npages = 0;
         LIST_HEAD(head);
@@ -1314,7 +1320,7 @@ long nfs_sync_mapping_wait(struct address_space *mapping, struct writeback_contr
                 }
         }
         how &= ~FLUSH_NOCOMMIT;
-        spin_lock(&nfsi->req_lock);
+        spin_lock(&inode->i_lock);
         do {
                 ret = nfs_wait_on_requests_locked(inode, idx_start, npages);
                 if (ret != 0)
@@ -1325,18 +1331,19 @@ long nfs_sync_mapping_wait(struct address_space *mapping, struct writeback_contr
                 if (pages == 0)
                         break;
                 if (how & FLUSH_INVALIDATE) {
-                        spin_unlock(&nfsi->req_lock);
+                        spin_unlock(&inode->i_lock);
                         nfs_cancel_commit_list(&head);
                         ret = pages;
-                        spin_lock(&nfsi->req_lock);
+                        spin_lock(&inode->i_lock);
                         continue;
                 }
                 pages += nfs_scan_commit(inode, &head, 0, 0);
-                spin_unlock(&nfsi->req_lock);
+                spin_unlock(&inode->i_lock);
                 ret = nfs_commit_list(inode, &head, how);
-                spin_lock(&nfsi->req_lock);
+                spin_lock(&inode->i_lock);
+
         } while (ret >= 0);
-        spin_unlock(&nfsi->req_lock);
+        spin_unlock(&inode->i_lock);
         return ret;
 }
 
@@ -1430,7 +1437,6 @@ int nfs_set_page_dirty(struct page *page)
 {
         struct address_space *mapping = page->mapping;
         struct inode *inode;
-        spinlock_t *req_lock;
         struct nfs_page *req;
         int ret;
 
@@ -1439,18 +1445,17 @@ int nfs_set_page_dirty(struct page *page)
         inode = mapping->host;
         if (!inode)
                 goto out_raced;
-        req_lock = &NFS_I(inode)->req_lock;
-        spin_lock(req_lock);
+        spin_lock(&inode->i_lock);
         req = nfs_page_find_request_locked(page);
         if (req != NULL) {
                 /* Mark any existing write requests for flushing */
                 ret = !test_and_set_bit(PG_NEED_FLUSH, &req->wb_flags);
-                spin_unlock(req_lock);
+                spin_unlock(&inode->i_lock);
                 nfs_release_request(req);
                 return ret;
         }
         ret = __set_page_dirty_nobuffers(page);
-        spin_unlock(req_lock);
+        spin_unlock(&inode->i_lock);
         return ret;
 out_raced:
         return !TestSetPageDirty(page);
diff --git a/fs/nfsd/nfs4callback.c b/fs/nfsd/nfs4callback.c
index 864090edc28..5443c52b57a 100644
--- a/fs/nfsd/nfs4callback.c
+++ b/fs/nfsd/nfs4callback.c
@@ -394,7 +394,6 @@ nfsd4_probe_callback(struct nfs4_client *clp)
                 .rpc_proc       = &nfs4_cb_procedures[NFSPROC4_CLNT_CB_NULL],
                 .rpc_argp       = clp,
         };
-        char clientname[16];
         int status;
 
         if (atomic_read(&cb->cb_set))
@@ -417,11 +416,6 @@ nfsd4_probe_callback(struct nfs4_client *clp)
         memset(program->stats, 0, sizeof(cb->cb_stat));
         program->stats->program = program;
 
-        /* Just here to make some printk's more useful: */
-        snprintf(clientname, sizeof(clientname),
-                "%u.%u.%u.%u", NIPQUAD(addr.sin_addr));
-        args.servername = clientname;
-
         /* Create RPC client */
         cb->cb_client = rpc_create(&args);
         if (IS_ERR(cb->cb_client)) {
@@ -429,29 +423,23 @@ nfsd4_probe_callback(struct nfs4_client *clp)
                 goto out_err;
         }
 
-        /* Kick rpciod, put the call on the wire. */
-        if (rpciod_up() != 0)
-                goto out_clnt;
-
         /* the task holds a reference to the nfs4_client struct */
         atomic_inc(&clp->cl_count);
 
         msg.rpc_cred = nfsd4_lookupcred(clp,0);
         if (IS_ERR(msg.rpc_cred))
-                goto out_rpciod;
+                goto out_release_clp;
         status = rpc_call_async(cb->cb_client, &msg, RPC_TASK_ASYNC, &nfs4_cb_null_ops, NULL);
         put_rpccred(msg.rpc_cred);
 
         if (status != 0) {
                 dprintk("NFSD: asynchronous NFSPROC4_CB_NULL failed!\n");
-                goto out_rpciod;
+                goto out_release_clp;
         }
         return;
 
-out_rpciod:
+out_release_clp:
         atomic_dec(&clp->cl_count);
-        rpciod_down();
-out_clnt:
         rpc_shutdown_client(cb->cb_client);
 out_err:
         cb->cb_client = NULL;
diff --git a/fs/nfsd/nfs4state.c b/fs/nfsd/nfs4state.c
index 3cc8ce422ab..8c52913d7cb 100644
--- a/fs/nfsd/nfs4state.c
+++ b/fs/nfsd/nfs4state.c
@@ -378,7 +378,6 @@ shutdown_callback_client(struct nfs4_client *clp)
         if (clnt) {
                 clp->cl_callback.cb_client = NULL;
                 rpc_shutdown_client(clnt);
-                rpciod_down();
         }
 }
 
diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 8604e35bd48..945b1cedde2 100644
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -879,6 +879,7 @@ nfsd_vfs_read(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
                         .u.data         = rqstp,
                 };
 
+                rqstp->rq_resused = 1;
                 host_err = splice_direct_to_actor(file, &sd, nfsd_direct_splice_actor);
         } else {
                 oldfs = get_fs();
diff --git a/fs/nls/Makefile b/fs/nls/Makefile
index a7ade138d68..f499dd7c390 100644
--- a/fs/nls/Makefile
+++ b/fs/nls/Makefile
@@ -36,11 +36,9 @@ obj-$(CONFIG_NLS_ISO8859_6)	+= nls_iso8859-6.o
 obj-$(CONFIG_NLS_ISO8859_7)     += nls_iso8859-7.o
 obj-$(CONFIG_NLS_ISO8859_8)     += nls_cp1255.o
 obj-$(CONFIG_NLS_ISO8859_9)     += nls_iso8859-9.o
-obj-$(CONFIG_NLS_ISO8859_10)    += nls_iso8859-10.o
 obj-$(CONFIG_NLS_ISO8859_13)    += nls_iso8859-13.o
 obj-$(CONFIG_NLS_ISO8859_14)    += nls_iso8859-14.o
 obj-$(CONFIG_NLS_ISO8859_15)    += nls_iso8859-15.o
 obj-$(CONFIG_NLS_KOI8_R)        += nls_koi8-r.o
 obj-$(CONFIG_NLS_KOI8_U)        += nls_koi8-u.o nls_koi8-ru.o
-obj-$(CONFIG_NLS_ABC)           += nls_abc.o
 obj-$(CONFIG_NLS_UTF8)          += nls_utf8.o
diff --git a/fs/ocfs2/alloc.c b/fs/ocfs2/alloc.c
index 19712a7d145..f5e11f4fa95 100644
--- a/fs/ocfs2/alloc.c
+++ b/fs/ocfs2/alloc.c
@@ -50,6 +50,8 @@
 #include "buffer_head_io.h"
 
 static void ocfs2_free_truncate_context(struct ocfs2_truncate_context *tc);
+static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt,
+                                         struct ocfs2_extent_block *eb);
 
 /*
  * Structures which describe a path through a btree, and functions to
@@ -117,6 +119,31 @@ static void ocfs2_free_path(struct ocfs2_path *path)
 }
 
 /*
+ * All the elements of src into dest. After this call, src could be freed
+ * without affecting dest.
+ *
+ * Both paths should have the same root. Any non-root elements of dest
+ * will be freed.
+ */
+static void ocfs2_cp_path(struct ocfs2_path *dest, struct ocfs2_path *src)
+{
+        int i;
+
+        BUG_ON(path_root_bh(dest) != path_root_bh(src));
+        BUG_ON(path_root_el(dest) != path_root_el(src));
+
+        ocfs2_reinit_path(dest, 1);
+
+        for(i = 1; i < OCFS2_MAX_PATH_DEPTH; i++) {
+                dest->p_node[i].bh = src->p_node[i].bh;
+                dest->p_node[i].el = src->p_node[i].el;
+
+                if (dest->p_node[i].bh)
+                        get_bh(dest->p_node[i].bh);
+        }
+}
+
+/*
  * Make the *dest path the same as src and re-initialize src path to
  * have a root only.
  */
@@ -212,10 +239,41 @@ out:
         return ret;
 }
 
+/*
+ * Return the index of the extent record which contains cluster #v_cluster.
+ * -1 is returned if it was not found.
+ *
+ * Should work fine on interior and exterior nodes.
+ */
+int ocfs2_search_extent_list(struct ocfs2_extent_list *el, u32 v_cluster)
+{
+        int ret = -1;
+        int i;
+        struct ocfs2_extent_rec *rec;
+        u32 rec_end, rec_start, clusters;
+
+        for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
+                rec = &el->l_recs[i];
+
+                rec_start = le32_to_cpu(rec->e_cpos);
+                clusters = ocfs2_rec_clusters(el, rec);
+
+                rec_end = rec_start + clusters;
+
+                if (v_cluster >= rec_start && v_cluster < rec_end) {
+                        ret = i;
+                        break;
+                }
+        }
+
+        return ret;
+}
+
 enum ocfs2_contig_type {
         CONTIG_NONE = 0,
         CONTIG_LEFT,
-        CONTIG_RIGHT
+        CONTIG_RIGHT,
+        CONTIG_LEFTRIGHT,
 };
 
 
@@ -253,6 +311,14 @@ static enum ocfs2_contig_type
 {
         u64 blkno = le64_to_cpu(insert_rec->e_blkno);
 
+        /*
+         * Refuse to coalesce extent records with different flag
+         * fields - we don't want to mix unwritten extents with user
+         * data.
+         */
+        if (ext->e_flags != insert_rec->e_flags)
+                return CONTIG_NONE;
+
         if (ocfs2_extents_adjacent(ext, insert_rec) &&
             ocfs2_block_extent_contig(inode->i_sb, ext, blkno))
                         return CONTIG_RIGHT;
@@ -277,7 +343,14 @@ enum ocfs2_append_type {
         APPEND_TAIL,
 };
 
+enum ocfs2_split_type {
+        SPLIT_NONE = 0,
+        SPLIT_LEFT,
+        SPLIT_RIGHT,
+};
+
 struct ocfs2_insert_type {
+        enum ocfs2_split_type   ins_split;
         enum ocfs2_append_type  ins_appending;
         enum ocfs2_contig_type  ins_contig;
         int                     ins_contig_index;
@@ -285,6 +358,13 @@ struct ocfs2_insert_type {
         int                     ins_tree_depth;
 };
 
+struct ocfs2_merge_ctxt {
+        enum ocfs2_contig_type  c_contig_type;
+        int                     c_has_empty_extent;
+        int                     c_split_covers_rec;
+        int                     c_used_tail_recs;
+};
+
 /*
  * How many free extents have we got before we need more meta data?
  */
@@ -384,13 +464,7 @@ static int ocfs2_create_new_meta_bhs(struct ocfs2_super *osb,
                         strcpy(eb->h_signature, OCFS2_EXTENT_BLOCK_SIGNATURE);
                         eb->h_blkno = cpu_to_le64(first_blkno);
                         eb->h_fs_generation = cpu_to_le32(osb->fs_generation);
-
-#ifndef OCFS2_USE_ALL_METADATA_SUBALLOCATORS
-                        /* we always use slot zero's suballocator */
-                        eb->h_suballoc_slot = 0;
-#else
                         eb->h_suballoc_slot = cpu_to_le16(osb->slot_num);
-#endif
                         eb->h_suballoc_bit = cpu_to_le16(suballoc_bit_start);
                         eb->h_list.l_count =
                                 cpu_to_le16(ocfs2_extent_recs_per_eb(osb->sb));
@@ -461,7 +535,7 @@ static int ocfs2_add_branch(struct ocfs2_super *osb,
                             struct inode *inode,
                             struct buffer_head *fe_bh,
                             struct buffer_head *eb_bh,
-                            struct buffer_head *last_eb_bh,
+                            struct buffer_head **last_eb_bh,
                             struct ocfs2_alloc_context *meta_ac)
 {
         int status, new_blocks, i;
@@ -476,7 +550,7 @@ static int ocfs2_add_branch(struct ocfs2_super *osb,
 
         mlog_entry_void();
 
-        BUG_ON(!last_eb_bh);
+        BUG_ON(!last_eb_bh || !*last_eb_bh);
 
         fe = (struct ocfs2_dinode *) fe_bh->b_data;
 
@@ -507,7 +581,7 @@ static int ocfs2_add_branch(struct ocfs2_super *osb,
                 goto bail;
         }
 
-        eb = (struct ocfs2_extent_block *)last_eb_bh->b_data;
+        eb = (struct ocfs2_extent_block *)(*last_eb_bh)->b_data;
         new_cpos = ocfs2_sum_rightmost_rec(&eb->h_list);
 
         /* Note: new_eb_bhs[new_blocks - 1] is the guy which will be
@@ -568,7 +642,7 @@ static int ocfs2_add_branch(struct ocfs2_super *osb,
          * journal_dirty erroring as it won't unless we've aborted the
          * handle (in which case we would never be here) so reserving
          * the write with journal_access is all we need to do. */
-        status = ocfs2_journal_access(handle, inode, last_eb_bh,
+        status = ocfs2_journal_access(handle, inode, *last_eb_bh,
                                       OCFS2_JOURNAL_ACCESS_WRITE);
         if (status < 0) {
                 mlog_errno(status);
@@ -601,10 +675,10 @@ static int ocfs2_add_branch(struct ocfs2_super *osb,
          * next_leaf on the previously last-extent-block. */
         fe->i_last_eb_blk = cpu_to_le64(new_last_eb_blk);
 
-        eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
+        eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data;
         eb->h_next_leaf_blk = cpu_to_le64(new_last_eb_blk);
 
-        status = ocfs2_journal_dirty(handle, last_eb_bh);
+        status = ocfs2_journal_dirty(handle, *last_eb_bh);
         if (status < 0)
                 mlog_errno(status);
         status = ocfs2_journal_dirty(handle, fe_bh);
@@ -616,6 +690,14 @@ static int ocfs2_add_branch(struct ocfs2_super *osb,
                         mlog_errno(status);
         }
 
+        /*
+         * Some callers want to track the rightmost leaf so pass it
+         * back here.
+         */
+        brelse(*last_eb_bh);
+        get_bh(new_eb_bhs[0]);
+        *last_eb_bh = new_eb_bhs[0];
+
         status = 0;
 bail:
         if (new_eb_bhs) {
@@ -829,6 +911,87 @@ bail:
 }
 
 /*
+ * Grow a b-tree so that it has more records.
+ *
+ * We might shift the tree depth in which case existing paths should
+ * be considered invalid.
+ *
+ * Tree depth after the grow is returned via *final_depth.
+ *
+ * *last_eb_bh will be updated by ocfs2_add_branch().
+ */
+static int ocfs2_grow_tree(struct inode *inode, handle_t *handle,
+                           struct buffer_head *di_bh, int *final_depth,
+                           struct buffer_head **last_eb_bh,
+                           struct ocfs2_alloc_context *meta_ac)
+{
+        int ret, shift;
+        struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
+        int depth = le16_to_cpu(di->id2.i_list.l_tree_depth);
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct buffer_head *bh = NULL;
+
+        BUG_ON(meta_ac == NULL);
+
+        shift = ocfs2_find_branch_target(osb, inode, di_bh, &bh);
+        if (shift < 0) {
+                ret = shift;
+                mlog_errno(ret);
+                goto out;
+        }
+
+        /* We traveled all the way to the bottom of the allocation tree
+         * and didn't find room for any more extents - we need to add
+         * another tree level */
+        if (shift) {
+                BUG_ON(bh);
+                mlog(0, "need to shift tree depth (current = %d)\n", depth);
+
+                /* ocfs2_shift_tree_depth will return us a buffer with
+                 * the new extent block (so we can pass that to
+                 * ocfs2_add_branch). */
+                ret = ocfs2_shift_tree_depth(osb, handle, inode, di_bh,
+                                             meta_ac, &bh);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                depth++;
+                if (depth == 1) {
+                        /*
+                         * Special case: we have room now if we shifted from
+                         * tree_depth 0, so no more work needs to be done.
+                         *
+                         * We won't be calling add_branch, so pass
+                         * back *last_eb_bh as the new leaf. At depth
+                         * zero, it should always be null so there's
+                         * no reason to brelse.
+                         */
+                        BUG_ON(*last_eb_bh);
+                        get_bh(bh);
+                        *last_eb_bh = bh;
+                        goto out;
+                }
+        }
+
+        /* call ocfs2_add_branch to add the final part of the tree with
+         * the new data. */
+        mlog(0, "add branch. bh = %p\n", bh);
+        ret = ocfs2_add_branch(osb, handle, inode, di_bh, bh, last_eb_bh,
+                               meta_ac);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+out:
+        if (final_depth)
+                *final_depth = depth;
+        brelse(bh);
+        return ret;
+}
+
+/*
  * This is only valid for leaf nodes, which are the only ones that can
  * have empty extents anyway.
  */
@@ -934,6 +1097,22 @@ static void ocfs2_rotate_leaf(struct ocfs2_extent_list *el,
 
 }
 
+static void ocfs2_remove_empty_extent(struct ocfs2_extent_list *el)
+{
+        int size, num_recs = le16_to_cpu(el->l_next_free_rec);
+
+        BUG_ON(num_recs == 0);
+
+        if (ocfs2_is_empty_extent(&el->l_recs[0])) {
+                num_recs--;
+                size = num_recs * sizeof(struct ocfs2_extent_rec);
+                memmove(&el->l_recs[0], &el->l_recs[1], size);
+                memset(&el->l_recs[num_recs], 0,
+                       sizeof(struct ocfs2_extent_rec));
+                el->l_next_free_rec = cpu_to_le16(num_recs);
+        }
+}
+
 /*
  * Create an empty extent record .
  *
@@ -1211,6 +1390,10 @@ static void ocfs2_adjust_adjacent_records(struct ocfs2_extent_rec *left_rec,
          * immediately to their right.
          */
         left_clusters = le32_to_cpu(right_child_el->l_recs[0].e_cpos);
+        if (ocfs2_is_empty_extent(&right_child_el->l_recs[0])) {
+                BUG_ON(le16_to_cpu(right_child_el->l_next_free_rec) <= 1);
+                left_clusters = le32_to_cpu(right_child_el->l_recs[1].e_cpos);
+        }
         left_clusters -= le32_to_cpu(left_rec->e_cpos);
         left_rec->e_int_clusters = cpu_to_le32(left_clusters);
 
@@ -1531,10 +1714,16 @@ out:
         return ret;
 }
 
+/*
+ * Extend the transaction by enough credits to complete the rotation,
+ * and still leave at least the original number of credits allocated
+ * to this transaction.
+ */
 static int ocfs2_extend_rotate_transaction(handle_t *handle, int subtree_depth,
+                                           int op_credits,
                                            struct ocfs2_path *path)
 {
-        int credits = (path->p_tree_depth - subtree_depth) * 2 + 1;
+        int credits = (path->p_tree_depth - subtree_depth) * 2 + 1 + op_credits;
 
         if (handle->h_buffer_credits < credits)
                 return ocfs2_extend_trans(handle, credits);
@@ -1568,6 +1757,29 @@ static int ocfs2_rotate_requires_path_adjustment(struct ocfs2_path *left_path,
         return 0;
 }
 
+static int ocfs2_leftmost_rec_contains(struct ocfs2_extent_list *el, u32 cpos)
+{
+        int next_free = le16_to_cpu(el->l_next_free_rec);
+        unsigned int range;
+        struct ocfs2_extent_rec *rec;
+
+        if (next_free == 0)
+                return 0;
+
+        rec = &el->l_recs[0];
+        if (ocfs2_is_empty_extent(rec)) {
+                /* Empty list. */
+                if (next_free == 1)
+                        return 0;
+                rec = &el->l_recs[1];
+        }
+
+        range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
+        if (cpos >= le32_to_cpu(rec->e_cpos) && cpos < range)
+                return 1;
+        return 0;
+}
+
 /*
  * Rotate all the records in a btree right one record, starting at insert_cpos.
  *
@@ -1586,11 +1798,12 @@ static int ocfs2_rotate_requires_path_adjustment(struct ocfs2_path *left_path,
  */
 static int ocfs2_rotate_tree_right(struct inode *inode,
                                    handle_t *handle,
+                                   enum ocfs2_split_type split,
                                    u32 insert_cpos,
                                    struct ocfs2_path *right_path,
                                    struct ocfs2_path **ret_left_path)
 {
-        int ret, start;
+        int ret, start, orig_credits = handle->h_buffer_credits;
         u32 cpos;
         struct ocfs2_path *left_path = NULL;
 
@@ -1657,9 +1870,9 @@ static int ocfs2_rotate_tree_right(struct inode *inode,
                                 (unsigned long long)
                                 path_leaf_bh(left_path)->b_blocknr);
 
-                if (ocfs2_rotate_requires_path_adjustment(left_path,
+                if (split == SPLIT_NONE &&
+                    ocfs2_rotate_requires_path_adjustment(left_path,
                                                           insert_cpos)) {
-                        mlog(0, "Path adjustment required\n");
 
                         /*
                          * We've rotated the tree as much as we
@@ -1687,7 +1900,7 @@ static int ocfs2_rotate_tree_right(struct inode *inode,
                      right_path->p_tree_depth);
 
                 ret = ocfs2_extend_rotate_transaction(handle, start,
-                                                      right_path);
+                                                      orig_credits, right_path);
                 if (ret) {
                         mlog_errno(ret);
                         goto out;
@@ -1700,6 +1913,24 @@ static int ocfs2_rotate_tree_right(struct inode *inode,
                         goto out;
                 }
 
+                if (split != SPLIT_NONE &&
+                    ocfs2_leftmost_rec_contains(path_leaf_el(right_path),
+                                                insert_cpos)) {
+                        /*
+                         * A rotate moves the rightmost left leaf
+                         * record over to the leftmost right leaf
+                         * slot. If we're doing an extent split
+                         * instead of a real insert, then we have to
+                         * check that the extent to be split wasn't
+                         * just moved over. If it was, then we can
+                         * exit here, passing left_path back -
+                         * ocfs2_split_extent() is smart enough to
+                         * search both leaves.
+                         */
+                        *ret_left_path = left_path;
+                        goto out_ret_path;
+                }
+
                 /*
                  * There is no need to re-read the next right path
                  * as we know that it'll be our current left
@@ -1722,6 +1953,1031 @@ out_ret_path:
         return ret;
 }
 
+static void ocfs2_update_edge_lengths(struct inode *inode, handle_t *handle,
+                                      struct ocfs2_path *path)
+{
+        int i, idx;
+        struct ocfs2_extent_rec *rec;
+        struct ocfs2_extent_list *el;
+        struct ocfs2_extent_block *eb;
+        u32 range;
+
+        /* Path should always be rightmost. */
+        eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
+        BUG_ON(eb->h_next_leaf_blk != 0ULL);
+
+        el = &eb->h_list;
+        BUG_ON(le16_to_cpu(el->l_next_free_rec) == 0);
+        idx = le16_to_cpu(el->l_next_free_rec) - 1;
+        rec = &el->l_recs[idx];
+        range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
+
+        for (i = 0; i < path->p_tree_depth; i++) {
+                el = path->p_node[i].el;
+                idx = le16_to_cpu(el->l_next_free_rec) - 1;
+                rec = &el->l_recs[idx];
+
+                rec->e_int_clusters = cpu_to_le32(range);
+                le32_add_cpu(&rec->e_int_clusters, -le32_to_cpu(rec->e_cpos));
+
+                ocfs2_journal_dirty(handle, path->p_node[i].bh);
+        }
+}
+
+static void ocfs2_unlink_path(struct inode *inode, handle_t *handle,
+                              struct ocfs2_cached_dealloc_ctxt *dealloc,
+                              struct ocfs2_path *path, int unlink_start)
+{
+        int ret, i;
+        struct ocfs2_extent_block *eb;
+        struct ocfs2_extent_list *el;
+        struct buffer_head *bh;
+
+        for(i = unlink_start; i < path_num_items(path); i++) {
+                bh = path->p_node[i].bh;
+
+                eb = (struct ocfs2_extent_block *)bh->b_data;
+                /*
+                 * Not all nodes might have had their final count
+                 * decremented by the caller - handle this here.
+                 */
+                el = &eb->h_list;
+                if (le16_to_cpu(el->l_next_free_rec) > 1) {
+                        mlog(ML_ERROR,
+                             "Inode %llu, attempted to remove extent block "
+                             "%llu with %u records\n",
+                             (unsigned long long)OCFS2_I(inode)->ip_blkno,
+                             (unsigned long long)le64_to_cpu(eb->h_blkno),
+                             le16_to_cpu(el->l_next_free_rec));
+
+                        ocfs2_journal_dirty(handle, bh);
+                        ocfs2_remove_from_cache(inode, bh);
+                        continue;
+                }
+
+                el->l_next_free_rec = 0;
+                memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
+
+                ocfs2_journal_dirty(handle, bh);
+
+                ret = ocfs2_cache_extent_block_free(dealloc, eb);
+                if (ret)
+                        mlog_errno(ret);
+
+                ocfs2_remove_from_cache(inode, bh);
+        }
+}
+
+static void ocfs2_unlink_subtree(struct inode *inode, handle_t *handle,
+                                 struct ocfs2_path *left_path,
+                                 struct ocfs2_path *right_path,
+                                 int subtree_index,
+                                 struct ocfs2_cached_dealloc_ctxt *dealloc)
+{
+        int i;
+        struct buffer_head *root_bh = left_path->p_node[subtree_index].bh;
+        struct ocfs2_extent_list *root_el = left_path->p_node[subtree_index].el;
+        struct ocfs2_extent_list *el;
+        struct ocfs2_extent_block *eb;
+
+        el = path_leaf_el(left_path);
+
+        eb = (struct ocfs2_extent_block *)right_path->p_node[subtree_index + 1].bh->b_data;
+
+        for(i = 1; i < le16_to_cpu(root_el->l_next_free_rec); i++)
+                if (root_el->l_recs[i].e_blkno == eb->h_blkno)
+                        break;
+
+        BUG_ON(i >= le16_to_cpu(root_el->l_next_free_rec));
+
+        memset(&root_el->l_recs[i], 0, sizeof(struct ocfs2_extent_rec));
+        le16_add_cpu(&root_el->l_next_free_rec, -1);
+
+        eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
+        eb->h_next_leaf_blk = 0;
+
+        ocfs2_journal_dirty(handle, root_bh);
+        ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
+
+        ocfs2_unlink_path(inode, handle, dealloc, right_path,
+                          subtree_index + 1);
+}
+
+static int ocfs2_rotate_subtree_left(struct inode *inode, handle_t *handle,
+                                     struct ocfs2_path *left_path,
+                                     struct ocfs2_path *right_path,
+                                     int subtree_index,
+                                     struct ocfs2_cached_dealloc_ctxt *dealloc,
+                                     int *deleted)
+{
+        int ret, i, del_right_subtree = 0, right_has_empty = 0;
+        struct buffer_head *root_bh, *di_bh = path_root_bh(right_path);
+        struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
+        struct ocfs2_extent_list *right_leaf_el, *left_leaf_el;
+        struct ocfs2_extent_block *eb;
+
+        *deleted = 0;
+
+        right_leaf_el = path_leaf_el(right_path);
+        left_leaf_el = path_leaf_el(left_path);
+        root_bh = left_path->p_node[subtree_index].bh;
+        BUG_ON(root_bh != right_path->p_node[subtree_index].bh);
+
+        if (!ocfs2_is_empty_extent(&left_leaf_el->l_recs[0]))
+                return 0;
+
+        eb = (struct ocfs2_extent_block *)path_leaf_bh(right_path)->b_data;
+        if (ocfs2_is_empty_extent(&right_leaf_el->l_recs[0])) {
+                /*
+                 * It's legal for us to proceed if the right leaf is
+                 * the rightmost one and it has an empty extent. There
+                 * are two cases to handle - whether the leaf will be
+                 * empty after removal or not. If the leaf isn't empty
+                 * then just remove the empty extent up front. The
+                 * next block will handle empty leaves by flagging
+                 * them for unlink.
+                 *
+                 * Non rightmost leaves will throw -EAGAIN and the
+                 * caller can manually move the subtree and retry.
+                 */
+
+                if (eb->h_next_leaf_blk != 0ULL)
+                        return -EAGAIN;
+
+                if (le16_to_cpu(right_leaf_el->l_next_free_rec) > 1) {
+                        ret = ocfs2_journal_access(handle, inode,
+                                                   path_leaf_bh(right_path),
+                                                   OCFS2_JOURNAL_ACCESS_WRITE);
+                        if (ret) {
+                                mlog_errno(ret);
+                                goto out;
+                        }
+
+                        ocfs2_remove_empty_extent(right_leaf_el);
+                } else
+                        right_has_empty = 1;
+        }
+
+        if (eb->h_next_leaf_blk == 0ULL &&
+            le16_to_cpu(right_leaf_el->l_next_free_rec) == 1) {
+                /*
+                 * We have to update i_last_eb_blk during the meta
+                 * data delete.
+                 */
+                ret = ocfs2_journal_access(handle, inode, di_bh,
+                                           OCFS2_JOURNAL_ACCESS_WRITE);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                del_right_subtree = 1;
+        }
+
+        /*
+         * Getting here with an empty extent in the right path implies
+         * that it's the rightmost path and will be deleted.
+         */
+        BUG_ON(right_has_empty && !del_right_subtree);
+
+        ret = ocfs2_journal_access(handle, inode, root_bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        for(i = subtree_index + 1; i < path_num_items(right_path); i++) {
+                ret = ocfs2_journal_access(handle, inode,
+                                           right_path->p_node[i].bh,
+                                           OCFS2_JOURNAL_ACCESS_WRITE);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                ret = ocfs2_journal_access(handle, inode,
+                                           left_path->p_node[i].bh,
+                                           OCFS2_JOURNAL_ACCESS_WRITE);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+        }
+
+        if (!right_has_empty) {
+                /*
+                 * Only do this if we're moving a real
+                 * record. Otherwise, the action is delayed until
+                 * after removal of the right path in which case we
+                 * can do a simple shift to remove the empty extent.
+                 */
+                ocfs2_rotate_leaf(left_leaf_el, &right_leaf_el->l_recs[0]);
+                memset(&right_leaf_el->l_recs[0], 0,
+                       sizeof(struct ocfs2_extent_rec));
+        }
+        if (eb->h_next_leaf_blk == 0ULL) {
+                /*
+                 * Move recs over to get rid of empty extent, decrease
+                 * next_free. This is allowed to remove the last
+                 * extent in our leaf (setting l_next_free_rec to
+                 * zero) - the delete code below won't care.
+                 */
+                ocfs2_remove_empty_extent(right_leaf_el);
+        }
+
+        ret = ocfs2_journal_dirty(handle, path_leaf_bh(left_path));
+        if (ret)
+                mlog_errno(ret);
+        ret = ocfs2_journal_dirty(handle, path_leaf_bh(right_path));
+        if (ret)
+                mlog_errno(ret);
+
+        if (del_right_subtree) {
+                ocfs2_unlink_subtree(inode, handle, left_path, right_path,
+                                     subtree_index, dealloc);
+                ocfs2_update_edge_lengths(inode, handle, left_path);
+
+                eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
+                di->i_last_eb_blk = eb->h_blkno;
+
+                /*
+                 * Removal of the extent in the left leaf was skipped
+                 * above so we could delete the right path
+                 * 1st.
+                 */
+                if (right_has_empty)
+                        ocfs2_remove_empty_extent(left_leaf_el);
+
+                ret = ocfs2_journal_dirty(handle, di_bh);
+                if (ret)
+                        mlog_errno(ret);
+
+                *deleted = 1;
+        } else
+                ocfs2_complete_edge_insert(inode, handle, left_path, right_path,
+                                           subtree_index);
+
+out:
+        return ret;
+}
+
+/*
+ * Given a full path, determine what cpos value would return us a path
+ * containing the leaf immediately to the right of the current one.
+ *
+ * Will return zero if the path passed in is already the rightmost path.
+ *
+ * This looks similar, but is subtly different to
+ * ocfs2_find_cpos_for_left_leaf().
+ */
+static int ocfs2_find_cpos_for_right_leaf(struct super_block *sb,
+                                          struct ocfs2_path *path, u32 *cpos)
+{
+        int i, j, ret = 0;
+        u64 blkno;
+        struct ocfs2_extent_list *el;
+
+        *cpos = 0;
+
+        if (path->p_tree_depth == 0)
+                return 0;
+
+        blkno = path_leaf_bh(path)->b_blocknr;
+
+        /* Start at the tree node just above the leaf and work our way up. */
+        i = path->p_tree_depth - 1;
+        while (i >= 0) {
+                int next_free;
+
+                el = path->p_node[i].el;
+
+                /*
+                 * Find the extent record just after the one in our
+                 * path.
+                 */
+                next_free = le16_to_cpu(el->l_next_free_rec);
+                for(j = 0; j < le16_to_cpu(el->l_next_free_rec); j++) {
+                        if (le64_to_cpu(el->l_recs[j].e_blkno) == blkno) {
+                                if (j == (next_free - 1)) {
+                                        if (i == 0) {
+                                                /*
+                                                 * We've determined that the
+                                                 * path specified is already
+                                                 * the rightmost one - return a
+                                                 * cpos of zero.
+                                                 */
+                                                goto out;
+                                        }
+                                        /*
+                                         * The rightmost record points to our
+                                         * leaf - we need to travel up the
+                                         * tree one level.
+                                         */
+                                        goto next_node;
+                                }
+
+                                *cpos = le32_to_cpu(el->l_recs[j + 1].e_cpos);
+                                goto out;
+                        }
+                }
+
+                /*
+                 * If we got here, we never found a valid node where
+                 * the tree indicated one should be.
+                 */
+                ocfs2_error(sb,
+                            "Invalid extent tree at extent block %llu\n",
+                            (unsigned long long)blkno);
+                ret = -EROFS;
+                goto out;
+
+next_node:
+                blkno = path->p_node[i].bh->b_blocknr;
+                i--;
+        }
+
+out:
+        return ret;
+}
+
+static int ocfs2_rotate_rightmost_leaf_left(struct inode *inode,
+                                            handle_t *handle,
+                                            struct buffer_head *bh,
+                                            struct ocfs2_extent_list *el)
+{
+        int ret;
+
+        if (!ocfs2_is_empty_extent(&el->l_recs[0]))
+                return 0;
+
+        ret = ocfs2_journal_access(handle, inode, bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        ocfs2_remove_empty_extent(el);
+
+        ret = ocfs2_journal_dirty(handle, bh);
+        if (ret)
+                mlog_errno(ret);
+
+out:
+        return ret;
+}
+
+static int __ocfs2_rotate_tree_left(struct inode *inode,
+                                    handle_t *handle, int orig_credits,
+                                    struct ocfs2_path *path,
+                                    struct ocfs2_cached_dealloc_ctxt *dealloc,
+                                    struct ocfs2_path **empty_extent_path)
+{
+        int ret, subtree_root, deleted;
+        u32 right_cpos;
+        struct ocfs2_path *left_path = NULL;
+        struct ocfs2_path *right_path = NULL;
+
+        BUG_ON(!ocfs2_is_empty_extent(&(path_leaf_el(path)->l_recs[0])));
+
+        *empty_extent_path = NULL;
+
+        ret = ocfs2_find_cpos_for_right_leaf(inode->i_sb, path,
+                                             &right_cpos);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        left_path = ocfs2_new_path(path_root_bh(path),
+                                   path_root_el(path));
+        if (!left_path) {
+                ret = -ENOMEM;
+                mlog_errno(ret);
+                goto out;
+        }
+
+        ocfs2_cp_path(left_path, path);
+
+        right_path = ocfs2_new_path(path_root_bh(path),
+                                    path_root_el(path));
+        if (!right_path) {
+                ret = -ENOMEM;
+                mlog_errno(ret);
+                goto out;
+        }
+
+        while (right_cpos) {
+                ret = ocfs2_find_path(inode, right_path, right_cpos);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                subtree_root = ocfs2_find_subtree_root(inode, left_path,
+                                                       right_path);
+
+                mlog(0, "Subtree root at index %d (blk %llu, depth %d)\n",
+                     subtree_root,
+                     (unsigned long long)
+                     right_path->p_node[subtree_root].bh->b_blocknr,
+                     right_path->p_tree_depth);
+
+                ret = ocfs2_extend_rotate_transaction(handle, subtree_root,
+                                                      orig_credits, left_path);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                ret = ocfs2_rotate_subtree_left(inode, handle, left_path,
+                                                right_path, subtree_root,
+                                                dealloc, &deleted);
+                if (ret == -EAGAIN) {
+                        /*
+                         * The rotation has to temporarily stop due to
+                         * the right subtree having an empty
+                         * extent. Pass it back to the caller for a
+                         * fixup.
+                         */
+                        *empty_extent_path = right_path;
+                        right_path = NULL;
+                        goto out;
+                }
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                /*
+                 * The subtree rotate might have removed records on
+                 * the rightmost edge. If so, then rotation is
+                 * complete.
+                 */
+                if (deleted)
+                        break;
+
+                ocfs2_mv_path(left_path, right_path);
+
+                ret = ocfs2_find_cpos_for_right_leaf(inode->i_sb, left_path,
+                                                     &right_cpos);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+        }
+
+out:
+        ocfs2_free_path(right_path);
+        ocfs2_free_path(left_path);
+
+        return ret;
+}
+
+static int ocfs2_remove_rightmost_path(struct inode *inode, handle_t *handle,
+                                       struct ocfs2_path *path,
+                                       struct ocfs2_cached_dealloc_ctxt *dealloc)
+{
+        int ret, subtree_index;
+        u32 cpos;
+        struct ocfs2_path *left_path = NULL;
+        struct ocfs2_dinode *di;
+        struct ocfs2_extent_block *eb;
+        struct ocfs2_extent_list *el;
+
+        /*
+         * XXX: This code assumes that the root is an inode, which is
+         * true for now but may change as tree code gets generic.
+         */
+        di = (struct ocfs2_dinode *)path_root_bh(path)->b_data;
+        if (!OCFS2_IS_VALID_DINODE(di)) {
+                ret = -EIO;
+                ocfs2_error(inode->i_sb,
+                            "Inode %llu has invalid path root",
+                            (unsigned long long)OCFS2_I(inode)->ip_blkno);
+                goto out;
+        }
+
+        /*
+         * There's two ways we handle this depending on
+         * whether path is the only existing one.
+         */
+        ret = ocfs2_extend_rotate_transaction(handle, 0,
+                                              handle->h_buffer_credits,
+                                              path);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        ret = ocfs2_journal_access_path(inode, handle, path);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, path, &cpos);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        if (cpos) {
+                /*
+                 * We have a path to the left of this one - it needs
+                 * an update too.
+                 */
+                left_path = ocfs2_new_path(path_root_bh(path),
+                                           path_root_el(path));
+                if (!left_path) {
+                        ret = -ENOMEM;
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                ret = ocfs2_find_path(inode, left_path, cpos);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                ret = ocfs2_journal_access_path(inode, handle, left_path);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                subtree_index = ocfs2_find_subtree_root(inode, left_path, path);
+
+                ocfs2_unlink_subtree(inode, handle, left_path, path,
+                                     subtree_index, dealloc);
+                ocfs2_update_edge_lengths(inode, handle, left_path);
+
+                eb = (struct ocfs2_extent_block *)path_leaf_bh(left_path)->b_data;
+                di->i_last_eb_blk = eb->h_blkno;
+        } else {
+                /*
+                 * 'path' is also the leftmost path which
+                 * means it must be the only one. This gets
+                 * handled differently because we want to
+                 * revert the inode back to having extents
+                 * in-line.
+                 */
+                ocfs2_unlink_path(inode, handle, dealloc, path, 1);
+
+                el = &di->id2.i_list;
+                el->l_tree_depth = 0;
+                el->l_next_free_rec = 0;
+                memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
+
+                di->i_last_eb_blk = 0;
+        }
+
+        ocfs2_journal_dirty(handle, path_root_bh(path));
+
+out:
+        ocfs2_free_path(left_path);
+        return ret;
+}
+
+/*
+ * Left rotation of btree records.
+ *
+ * In many ways, this is (unsurprisingly) the opposite of right
+ * rotation. We start at some non-rightmost path containing an empty
+ * extent in the leaf block. The code works its way to the rightmost
+ * path by rotating records to the left in every subtree.
+ *
+ * This is used by any code which reduces the number of extent records
+ * in a leaf. After removal, an empty record should be placed in the
+ * leftmost list position.
+ *
+ * This won't handle a length update of the rightmost path records if
+ * the rightmost tree leaf record is removed so the caller is
+ * responsible for detecting and correcting that.
+ */
+static int ocfs2_rotate_tree_left(struct inode *inode, handle_t *handle,
+                                  struct ocfs2_path *path,
+                                  struct ocfs2_cached_dealloc_ctxt *dealloc)
+{
+        int ret, orig_credits = handle->h_buffer_credits;
+        struct ocfs2_path *tmp_path = NULL, *restart_path = NULL;
+        struct ocfs2_extent_block *eb;
+        struct ocfs2_extent_list *el;
+
+        el = path_leaf_el(path);
+        if (!ocfs2_is_empty_extent(&el->l_recs[0]))
+                return 0;
+
+        if (path->p_tree_depth == 0) {
+rightmost_no_delete:
+                /*
+                 * In-inode extents. This is trivially handled, so do
+                 * it up front.
+                 */
+                ret = ocfs2_rotate_rightmost_leaf_left(inode, handle,
+                                                       path_leaf_bh(path),
+                                                       path_leaf_el(path));
+                if (ret)
+                        mlog_errno(ret);
+                goto out;
+        }
+
+        /*
+         * Handle rightmost branch now. There's several cases:
+         *  1) simple rotation leaving records in there. That's trivial.
+         *  2) rotation requiring a branch delete - there's no more
+         *     records left. Two cases of this:
+         *     a) There are branches to the left.
+         *     b) This is also the leftmost (the only) branch.
+         *
+         *  1) is handled via ocfs2_rotate_rightmost_leaf_left()
+         *  2a) we need the left branch so that we can update it with the unlink
+         *  2b) we need to bring the inode back to inline extents.
+         */
+
+        eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
+        el = &eb->h_list;
+        if (eb->h_next_leaf_blk == 0) {
+                /*
+                 * This gets a bit tricky if we're going to delete the
+                 * rightmost path. Get the other cases out of the way
+                 * 1st.
+                 */
+                if (le16_to_cpu(el->l_next_free_rec) > 1)
+                        goto rightmost_no_delete;
+
+                if (le16_to_cpu(el->l_next_free_rec) == 0) {
+                        ret = -EIO;
+                        ocfs2_error(inode->i_sb,
+                                    "Inode %llu has empty extent block at %llu",
+                                    (unsigned long long)OCFS2_I(inode)->ip_blkno,
+                                    (unsigned long long)le64_to_cpu(eb->h_blkno));
+                        goto out;
+                }
+
+                /*
+                 * XXX: The caller can not trust "path" any more after
+                 * this as it will have been deleted. What do we do?
+                 *
+                 * In theory the rotate-for-merge code will never get
+                 * here because it'll always ask for a rotate in a
+                 * nonempty list.
+                 */
+
+                ret = ocfs2_remove_rightmost_path(inode, handle, path,
+                                                  dealloc);
+                if (ret)
+                        mlog_errno(ret);
+                goto out;
+        }
+
+        /*
+         * Now we can loop, remembering the path we get from -EAGAIN
+         * and restarting from there.
+         */
+try_rotate:
+        ret = __ocfs2_rotate_tree_left(inode, handle, orig_credits, path,
+                                       dealloc, &restart_path);
+        if (ret && ret != -EAGAIN) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        while (ret == -EAGAIN) {
+                tmp_path = restart_path;
+                restart_path = NULL;
+
+                ret = __ocfs2_rotate_tree_left(inode, handle, orig_credits,
+                                               tmp_path, dealloc,
+                                               &restart_path);
+                if (ret && ret != -EAGAIN) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                ocfs2_free_path(tmp_path);
+                tmp_path = NULL;
+
+                if (ret == 0)
+                        goto try_rotate;
+        }
+
+out:
+        ocfs2_free_path(tmp_path);
+        ocfs2_free_path(restart_path);
+        return ret;
+}
+
+static void ocfs2_cleanup_merge(struct ocfs2_extent_list *el,
+                                int index)
+{
+        struct ocfs2_extent_rec *rec = &el->l_recs[index];
+        unsigned int size;
+
+        if (rec->e_leaf_clusters == 0) {
+                /*
+                 * We consumed all of the merged-from record. An empty
+                 * extent cannot exist anywhere but the 1st array
+                 * position, so move things over if the merged-from
+                 * record doesn't occupy that position.
+                 *
+                 * This creates a new empty extent so the caller
+                 * should be smart enough to have removed any existing
+                 * ones.
+                 */
+                if (index > 0) {
+                        BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0]));
+                        size = index * sizeof(struct ocfs2_extent_rec);
+                        memmove(&el->l_recs[1], &el->l_recs[0], size);
+                }
+
+                /*
+                 * Always memset - the caller doesn't check whether it
+                 * created an empty extent, so there could be junk in
+                 * the other fields.
+                 */
+                memset(&el->l_recs[0], 0, sizeof(struct ocfs2_extent_rec));
+        }
+}
+
+/*
+ * Remove split_rec clusters from the record at index and merge them
+ * onto the beginning of the record at index + 1.
+ */
+static int ocfs2_merge_rec_right(struct inode *inode, struct buffer_head *bh,
+                                handle_t *handle,
+                                struct ocfs2_extent_rec *split_rec,
+                                struct ocfs2_extent_list *el, int index)
+{
+        int ret;
+        unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters);
+        struct ocfs2_extent_rec *left_rec;
+        struct ocfs2_extent_rec *right_rec;
+
+        BUG_ON(index >= le16_to_cpu(el->l_next_free_rec));
+
+        left_rec = &el->l_recs[index];
+        right_rec = &el->l_recs[index + 1];
+
+        ret = ocfs2_journal_access(handle, inode, bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        le16_add_cpu(&left_rec->e_leaf_clusters, -split_clusters);
+
+        le32_add_cpu(&right_rec->e_cpos, -split_clusters);
+        le64_add_cpu(&right_rec->e_blkno,
+                     -ocfs2_clusters_to_blocks(inode->i_sb, split_clusters));
+        le16_add_cpu(&right_rec->e_leaf_clusters, split_clusters);
+
+        ocfs2_cleanup_merge(el, index);
+
+        ret = ocfs2_journal_dirty(handle, bh);
+        if (ret)
+                mlog_errno(ret);
+
+out:
+        return ret;
+}
+
+/*
+ * Remove split_rec clusters from the record at index and merge them
+ * onto the tail of the record at index - 1.
+ */
+static int ocfs2_merge_rec_left(struct inode *inode, struct buffer_head *bh,
+                                handle_t *handle,
+                                struct ocfs2_extent_rec *split_rec,
+                                struct ocfs2_extent_list *el, int index)
+{
+        int ret, has_empty_extent = 0;
+        unsigned int split_clusters = le16_to_cpu(split_rec->e_leaf_clusters);
+        struct ocfs2_extent_rec *left_rec;
+        struct ocfs2_extent_rec *right_rec;
+
+        BUG_ON(index <= 0);
+
+        left_rec = &el->l_recs[index - 1];
+        right_rec = &el->l_recs[index];
+        if (ocfs2_is_empty_extent(&el->l_recs[0]))
+                has_empty_extent = 1;
+
+        ret = ocfs2_journal_access(handle, inode, bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        if (has_empty_extent && index == 1) {
+                /*
+                 * The easy case - we can just plop the record right in.
+                 */
+                *left_rec = *split_rec;
+
+                has_empty_extent = 0;
+        } else {
+                le16_add_cpu(&left_rec->e_leaf_clusters, split_clusters);
+        }
+
+        le32_add_cpu(&right_rec->e_cpos, split_clusters);
+        le64_add_cpu(&right_rec->e_blkno,
+                     ocfs2_clusters_to_blocks(inode->i_sb, split_clusters));
+        le16_add_cpu(&right_rec->e_leaf_clusters, -split_clusters);
+
+        ocfs2_cleanup_merge(el, index);
+
+        ret = ocfs2_journal_dirty(handle, bh);
+        if (ret)
+                mlog_errno(ret);
+
+out:
+        return ret;
+}
+
+static int ocfs2_try_to_merge_extent(struct inode *inode,
+                                     handle_t *handle,
+                                     struct ocfs2_path *left_path,
+                                     int split_index,
+                                     struct ocfs2_extent_rec *split_rec,
+                                     struct ocfs2_cached_dealloc_ctxt *dealloc,
+                                     struct ocfs2_merge_ctxt *ctxt)
+
+{
+        int ret = 0, delete_tail_recs = 0;
+        struct ocfs2_extent_list *el = path_leaf_el(left_path);
+        struct ocfs2_extent_rec *rec = &el->l_recs[split_index];
+
+        BUG_ON(ctxt->c_contig_type == CONTIG_NONE);
+
+        if (ctxt->c_split_covers_rec) {
+                delete_tail_recs++;
+
+                if (ctxt->c_contig_type == CONTIG_LEFTRIGHT ||
+                    ctxt->c_has_empty_extent)
+                        delete_tail_recs++;
+
+                if (ctxt->c_has_empty_extent) {
+                        /*
+                         * The merge code will need to create an empty
+                         * extent to take the place of the newly
+                         * emptied slot. Remove any pre-existing empty
+                         * extents - having more than one in a leaf is
+                         * illegal.
+                         */
+                        ret = ocfs2_rotate_tree_left(inode, handle, left_path,
+                                                     dealloc);
+                        if (ret) {
+                                mlog_errno(ret);
+                                goto out;
+                        }
+                        split_index--;
+                        rec = &el->l_recs[split_index];
+                }
+        }
+
+        if (ctxt->c_contig_type == CONTIG_LEFTRIGHT) {
+                /*
+                 * Left-right contig implies this.
+                 */
+                BUG_ON(!ctxt->c_split_covers_rec);
+                BUG_ON(split_index == 0);
+
+                /*
+                 * Since the leftright insert always covers the entire
+                 * extent, this call will delete the insert record
+                 * entirely, resulting in an empty extent record added to
+                 * the extent block.
+                 *
+                 * Since the adding of an empty extent shifts
+                 * everything back to the right, there's no need to
+                 * update split_index here.
+                 */
+                ret = ocfs2_merge_rec_left(inode, path_leaf_bh(left_path),
+                                           handle, split_rec, el, split_index);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                /*
+                 * We can only get this from logic error above.
+                 */
+                BUG_ON(!ocfs2_is_empty_extent(&el->l_recs[0]));
+
+                /*
+                 * The left merge left us with an empty extent, remove
+                 * it.
+                 */
+                ret = ocfs2_rotate_tree_left(inode, handle, left_path, dealloc);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+                split_index--;
+                rec = &el->l_recs[split_index];
+
+                /*
+                 * Note that we don't pass split_rec here on purpose -
+                 * we've merged it into the left side.
+                 */
+                ret = ocfs2_merge_rec_right(inode, path_leaf_bh(left_path),
+                                            handle, rec, el, split_index);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                BUG_ON(!ocfs2_is_empty_extent(&el->l_recs[0]));
+
+                ret = ocfs2_rotate_tree_left(inode, handle, left_path,
+                                             dealloc);
+                /*
+                 * Error from this last rotate is not critical, so
+                 * print but don't bubble it up.
+                 */
+                if (ret)
+                        mlog_errno(ret);
+                ret = 0;
+        } else {
+                /*
+                 * Merge a record to the left or right.
+                 *
+                 * 'contig_type' is relative to the existing record,
+                 * so for example, if we're "right contig", it's to
+                 * the record on the left (hence the left merge).
+                 */
+                if (ctxt->c_contig_type == CONTIG_RIGHT) {
+                        ret = ocfs2_merge_rec_left(inode,
+                                                   path_leaf_bh(left_path),
+                                                   handle, split_rec, el,
+                                                   split_index);
+                        if (ret) {
+                                mlog_errno(ret);
+                                goto out;
+                        }
+                } else {
+                        ret = ocfs2_merge_rec_right(inode,
+                                                    path_leaf_bh(left_path),
+                                                    handle, split_rec, el,
+                                                    split_index);
+                        if (ret) {
+                                mlog_errno(ret);
+                                goto out;
+                        }
+                }
+
+                if (ctxt->c_split_covers_rec) {
+                        /*
+                         * The merge may have left an empty extent in
+                         * our leaf. Try to rotate it away.
+                         */
+                        ret = ocfs2_rotate_tree_left(inode, handle, left_path,
+                                                     dealloc);
+                        if (ret)
+                                mlog_errno(ret);
+                        ret = 0;
+                }
+        }
+
+out:
+        return ret;
+}
+
+static void ocfs2_subtract_from_rec(struct super_block *sb,
+                                    enum ocfs2_split_type split,
+                                    struct ocfs2_extent_rec *rec,
+                                    struct ocfs2_extent_rec *split_rec)
+{
+        u64 len_blocks;
+
+        len_blocks = ocfs2_clusters_to_blocks(sb,
+                                le16_to_cpu(split_rec->e_leaf_clusters));
+
+        if (split == SPLIT_LEFT) {
+                /*
+                 * Region is on the left edge of the existing
+                 * record.
+                 */
+                le32_add_cpu(&rec->e_cpos,
+                             le16_to_cpu(split_rec->e_leaf_clusters));
+                le64_add_cpu(&rec->e_blkno, len_blocks);
+                le16_add_cpu(&rec->e_leaf_clusters,
+                             -le16_to_cpu(split_rec->e_leaf_clusters));
+        } else {
+                /*
+                 * Region is on the right edge of the existing
+                 * record.
+                 */
+                le16_add_cpu(&rec->e_leaf_clusters,
+                             -le16_to_cpu(split_rec->e_leaf_clusters));
+        }
+}
+
 /*
  * Do the final bits of extent record insertion at the target leaf
  * list. If this leaf is part of an allocation tree, it is assumed
@@ -1738,6 +2994,15 @@ static void ocfs2_insert_at_leaf(struct ocfs2_extent_rec *insert_rec,
 
         BUG_ON(le16_to_cpu(el->l_tree_depth) != 0);
 
+        if (insert->ins_split != SPLIT_NONE) {
+                i = ocfs2_search_extent_list(el, le32_to_cpu(insert_rec->e_cpos));
+                BUG_ON(i == -1);
+                rec = &el->l_recs[i];
+                ocfs2_subtract_from_rec(inode->i_sb, insert->ins_split, rec,
+                                        insert_rec);
+                goto rotate;
+        }
+
         /*
          * Contiguous insert - either left or right.
          */
@@ -1792,6 +3057,7 @@ static void ocfs2_insert_at_leaf(struct ocfs2_extent_rec *insert_rec,
                 return;
         }
 
+rotate:
         /*
          * Ok, we have to rotate.
          *
@@ -1815,13 +3081,53 @@ static inline void ocfs2_update_dinode_clusters(struct inode *inode,
         spin_unlock(&OCFS2_I(inode)->ip_lock);
 }
 
+static void ocfs2_adjust_rightmost_records(struct inode *inode,
+                                           handle_t *handle,
+                                           struct ocfs2_path *path,
+                                           struct ocfs2_extent_rec *insert_rec)
+{
+        int ret, i, next_free;
+        struct buffer_head *bh;
+        struct ocfs2_extent_list *el;
+        struct ocfs2_extent_rec *rec;
+
+        /*
+         * Update everything except the leaf block.
+         */
+        for (i = 0; i < path->p_tree_depth; i++) {
+                bh = path->p_node[i].bh;
+                el = path->p_node[i].el;
+
+                next_free = le16_to_cpu(el->l_next_free_rec);
+                if (next_free == 0) {
+                        ocfs2_error(inode->i_sb,
+                                    "Dinode %llu has a bad extent list",
+                                    (unsigned long long)OCFS2_I(inode)->ip_blkno);
+                        ret = -EIO;
+                        return;
+                }
+
+                rec = &el->l_recs[next_free - 1];
+
+                rec->e_int_clusters = insert_rec->e_cpos;
+                le32_add_cpu(&rec->e_int_clusters,
+                             le16_to_cpu(insert_rec->e_leaf_clusters));
+                le32_add_cpu(&rec->e_int_clusters,
+                             -le32_to_cpu(rec->e_cpos));
+
+                ret = ocfs2_journal_dirty(handle, bh);
+                if (ret)
+                        mlog_errno(ret);
+
+        }
+}
+
 static int ocfs2_append_rec_to_path(struct inode *inode, handle_t *handle,
                                     struct ocfs2_extent_rec *insert_rec,
                                     struct ocfs2_path *right_path,
                                     struct ocfs2_path **ret_left_path)
 {
-        int ret, i, next_free;
-        struct buffer_head *bh;
+        int ret, next_free;
         struct ocfs2_extent_list *el;
         struct ocfs2_path *left_path = NULL;
 
@@ -1887,40 +3193,7 @@ static int ocfs2_append_rec_to_path(struct inode *inode, handle_t *handle,
                 goto out;
         }
 
-        el = path_root_el(right_path);
-        bh = path_root_bh(right_path);
-        i = 0;
-        while (1) {
-                struct ocfs2_extent_rec *rec;
-
-                next_free = le16_to_cpu(el->l_next_free_rec);
-                if (next_free == 0) {
-                        ocfs2_error(inode->i_sb,
-                                    "Dinode %llu has a bad extent list",
-                                    (unsigned long long)OCFS2_I(inode)->ip_blkno);
-                        ret = -EIO;
-                        goto out;
-                }
-
-                rec = &el->l_recs[next_free - 1];
-
-                rec->e_int_clusters = insert_rec->e_cpos;
-                le32_add_cpu(&rec->e_int_clusters,
-                             le16_to_cpu(insert_rec->e_leaf_clusters));
-                le32_add_cpu(&rec->e_int_clusters,
-                             -le32_to_cpu(rec->e_cpos));
-
-                ret = ocfs2_journal_dirty(handle, bh);
-                if (ret)
-                        mlog_errno(ret);
-
-                /* Don't touch the leaf node */
-                if (++i >= right_path->p_tree_depth)
-                        break;
-
-                bh = right_path->p_node[i].bh;
-                el = right_path->p_node[i].el;
-        }
+        ocfs2_adjust_rightmost_records(inode, handle, right_path, insert_rec);
 
         *ret_left_path = left_path;
         ret = 0;
@@ -1931,6 +3204,83 @@ out:
         return ret;
 }
 
+static void ocfs2_split_record(struct inode *inode,
+                               struct ocfs2_path *left_path,
+                               struct ocfs2_path *right_path,
+                               struct ocfs2_extent_rec *split_rec,
+                               enum ocfs2_split_type split)
+{
+        int index;
+        u32 cpos = le32_to_cpu(split_rec->e_cpos);
+        struct ocfs2_extent_list *left_el = NULL, *right_el, *insert_el, *el;
+        struct ocfs2_extent_rec *rec, *tmprec;
+
+        right_el = path_leaf_el(right_path);;
+        if (left_path)
+                left_el = path_leaf_el(left_path);
+
+        el = right_el;
+        insert_el = right_el;
+        index = ocfs2_search_extent_list(el, cpos);
+        if (index != -1) {
+                if (index == 0 && left_path) {
+                        BUG_ON(ocfs2_is_empty_extent(&el->l_recs[0]));
+
+                        /*
+                         * This typically means that the record
+                         * started in the left path but moved to the
+                         * right as a result of rotation. We either
+                         * move the existing record to the left, or we
+                         * do the later insert there.
+                         *
+                         * In this case, the left path should always
+                         * exist as the rotate code will have passed
+                         * it back for a post-insert update.
+                         */
+
+                        if (split == SPLIT_LEFT) {
+                                /*
+                                 * It's a left split. Since we know
+                                 * that the rotate code gave us an
+                                 * empty extent in the left path, we
+                                 * can just do the insert there.
+                                 */
+                                insert_el = left_el;
+                        } else {
+                                /*
+                                 * Right split - we have to move the
+                                 * existing record over to the left
+                                 * leaf. The insert will be into the
+                                 * newly created empty extent in the
+                                 * right leaf.
+                                 */
+                                tmprec = &right_el->l_recs[index];
+                                ocfs2_rotate_leaf(left_el, tmprec);
+                                el = left_el;
+
+                                memset(tmprec, 0, sizeof(*tmprec));
+                                index = ocfs2_search_extent_list(left_el, cpos);
+                                BUG_ON(index == -1);
+                        }
+                }
+        } else {
+                BUG_ON(!left_path);
+                BUG_ON(!ocfs2_is_empty_extent(&left_el->l_recs[0]));
+                /*
+                 * Left path is easy - we can just allow the insert to
+                 * happen.
+                 */
+                el = left_el;
+                insert_el = left_el;
+                index = ocfs2_search_extent_list(el, cpos);
+                BUG_ON(index == -1);
+        }
+
+        rec = &el->l_recs[index];
+        ocfs2_subtract_from_rec(inode->i_sb, split, rec, split_rec);
+        ocfs2_rotate_leaf(insert_el, split_rec);
+}
+
 /*
  * This function only does inserts on an allocation b-tree. For dinode
  * lists, ocfs2_insert_at_leaf() is called directly.
@@ -1948,7 +3298,6 @@ static int ocfs2_insert_path(struct inode *inode,
 {
         int ret, subtree_index;
         struct buffer_head *leaf_bh = path_leaf_bh(right_path);
-        struct ocfs2_extent_list *el;
 
         /*
          * Pass both paths to the journal. The majority of inserts
@@ -1984,9 +3333,18 @@ static int ocfs2_insert_path(struct inode *inode,
                 }
         }
 
-        el = path_leaf_el(right_path);
+        if (insert->ins_split != SPLIT_NONE) {
+                /*
+                 * We could call ocfs2_insert_at_leaf() for some types
+                 * of splits, but it's easier to just let one seperate
+                 * function sort it all out.
+                 */
+                ocfs2_split_record(inode, left_path, right_path,
+                                   insert_rec, insert->ins_split);
+        } else
+                ocfs2_insert_at_leaf(insert_rec, path_leaf_el(right_path),
+                                     insert, inode);
 
-        ocfs2_insert_at_leaf(insert_rec, el, insert, inode);
         ret = ocfs2_journal_dirty(handle, leaf_bh);
         if (ret)
                 mlog_errno(ret);
@@ -2075,7 +3433,7 @@ static int ocfs2_do_insert_extent(struct inode *inode,
          * can wind up skipping both of these two special cases...
          */
         if (rotate) {
-                ret = ocfs2_rotate_tree_right(inode, handle,
+                ret = ocfs2_rotate_tree_right(inode, handle, type->ins_split,
                                               le32_to_cpu(insert_rec->e_cpos),
                                               right_path, &left_path);
                 if (ret) {
@@ -2100,8 +3458,9 @@ static int ocfs2_do_insert_extent(struct inode *inode,
         }
 
 out_update_clusters:
-        ocfs2_update_dinode_clusters(inode, di,
-                                     le16_to_cpu(insert_rec->e_leaf_clusters));
+        if (type->ins_split == SPLIT_NONE)
+                ocfs2_update_dinode_clusters(inode, di,
+                                             le16_to_cpu(insert_rec->e_leaf_clusters));
 
         ret = ocfs2_journal_dirty(handle, di_bh);
         if (ret)
@@ -2114,6 +3473,44 @@ out:
         return ret;
 }
 
+static enum ocfs2_contig_type
+ocfs2_figure_merge_contig_type(struct inode *inode,
+                               struct ocfs2_extent_list *el, int index,
+                               struct ocfs2_extent_rec *split_rec)
+{
+        struct ocfs2_extent_rec *rec;
+        enum ocfs2_contig_type ret = CONTIG_NONE;
+
+        /*
+         * We're careful to check for an empty extent record here -
+         * the merge code will know what to do if it sees one.
+         */
+
+        if (index > 0) {
+                rec = &el->l_recs[index - 1];
+                if (index == 1 && ocfs2_is_empty_extent(rec)) {
+                        if (split_rec->e_cpos == el->l_recs[index].e_cpos)
+                                ret = CONTIG_RIGHT;
+                } else {
+                        ret = ocfs2_extent_contig(inode, rec, split_rec);
+                }
+        }
+
+        if (index < (le16_to_cpu(el->l_next_free_rec) - 1)) {
+                enum ocfs2_contig_type contig_type;
+
+                rec = &el->l_recs[index + 1];
+                contig_type = ocfs2_extent_contig(inode, rec, split_rec);
+
+                if (contig_type == CONTIG_LEFT && ret == CONTIG_RIGHT)
+                        ret = CONTIG_LEFTRIGHT;
+                else if (ret == CONTIG_NONE)
+                        ret = contig_type;
+        }
+
+        return ret;
+}
+
 static void ocfs2_figure_contig_type(struct inode *inode,
                                      struct ocfs2_insert_type *insert,
                                      struct ocfs2_extent_list *el,
@@ -2205,6 +3602,8 @@ static int ocfs2_figure_insert_type(struct inode *inode,
         struct ocfs2_path *path = NULL;
         struct buffer_head *bh = NULL;
 
+        insert->ins_split = SPLIT_NONE;
+
         el = &di->id2.i_list;
         insert->ins_tree_depth = le16_to_cpu(el->l_tree_depth);
 
@@ -2327,9 +3726,10 @@ int ocfs2_insert_extent(struct ocfs2_super *osb,
                         u32 cpos,
                         u64 start_blk,
                         u32 new_clusters,
+                        u8 flags,
                         struct ocfs2_alloc_context *meta_ac)
 {
-        int status, shift;
+        int status;
         struct buffer_head *last_eb_bh = NULL;
         struct buffer_head *bh = NULL;
         struct ocfs2_insert_type insert = {0, };
@@ -2350,6 +3750,7 @@ int ocfs2_insert_extent(struct ocfs2_super *osb,
         rec.e_cpos = cpu_to_le32(cpos);
         rec.e_blkno = cpu_to_le64(start_blk);
         rec.e_leaf_clusters = cpu_to_le16(new_clusters);
+        rec.e_flags = flags;
 
         status = ocfs2_figure_insert_type(inode, fe_bh, &last_eb_bh, &rec,
                                           &insert);
@@ -2364,55 +3765,16 @@ int ocfs2_insert_extent(struct ocfs2_super *osb,
              insert.ins_appending, insert.ins_contig, insert.ins_contig_index,
              insert.ins_free_records, insert.ins_tree_depth);
 
-        /*
-         * Avoid growing the tree unless we're out of records and the
-         * insert type requres one.
-         */
-        if (insert.ins_contig != CONTIG_NONE || insert.ins_free_records)
-                goto out_add;
-
-        shift = ocfs2_find_branch_target(osb, inode, fe_bh, &bh);
-        if (shift < 0) {
-                status = shift;
-                mlog_errno(status);
-                goto bail;
-        }
-
-        /* We traveled all the way to the bottom of the allocation tree
-         * and didn't find room for any more extents - we need to add
-         * another tree level */
-        if (shift) {
-                BUG_ON(bh);
-                mlog(0, "need to shift tree depth "
-                     "(current = %d)\n", insert.ins_tree_depth);
-
-                /* ocfs2_shift_tree_depth will return us a buffer with
-                 * the new extent block (so we can pass that to
-                 * ocfs2_add_branch). */
-                status = ocfs2_shift_tree_depth(osb, handle, inode, fe_bh,
-                                                meta_ac, &bh);
-                if (status < 0) {
+        if (insert.ins_contig == CONTIG_NONE && insert.ins_free_records == 0) {
+                status = ocfs2_grow_tree(inode, handle, fe_bh,
+                                         &insert.ins_tree_depth, &last_eb_bh,
+                                         meta_ac);
+                if (status) {
                         mlog_errno(status);
                         goto bail;
                 }
-                insert.ins_tree_depth++;
-                /* Special case: we have room now if we shifted from
-                 * tree_depth 0 */
-                if (insert.ins_tree_depth == 1)
-                        goto out_add;
-        }
-
-        /* call ocfs2_add_branch to add the final part of the tree with
-         * the new data. */
-        mlog(0, "add branch. bh = %p\n", bh);
-        status = ocfs2_add_branch(osb, handle, inode, fe_bh, bh, last_eb_bh,
-                                  meta_ac);
-        if (status < 0) {
-                mlog_errno(status);
-                goto bail;
         }
 
-out_add:
         /* Finally, we can add clusters. This might rotate the tree for us. */
         status = ocfs2_do_insert_extent(inode, handle, fe_bh, &rec, &insert);
         if (status < 0)
@@ -2431,7 +3793,720 @@ bail:
         return status;
 }
 
-static inline int ocfs2_truncate_log_needs_flush(struct ocfs2_super *osb)
+static void ocfs2_make_right_split_rec(struct super_block *sb,
+                                       struct ocfs2_extent_rec *split_rec,
+                                       u32 cpos,
+                                       struct ocfs2_extent_rec *rec)
+{
+        u32 rec_cpos = le32_to_cpu(rec->e_cpos);
+        u32 rec_range = rec_cpos + le16_to_cpu(rec->e_leaf_clusters);
+
+        memset(split_rec, 0, sizeof(struct ocfs2_extent_rec));
+
+        split_rec->e_cpos = cpu_to_le32(cpos);
+        split_rec->e_leaf_clusters = cpu_to_le16(rec_range - cpos);
+
+        split_rec->e_blkno = rec->e_blkno;
+        le64_add_cpu(&split_rec->e_blkno,
+                     ocfs2_clusters_to_blocks(sb, cpos - rec_cpos));
+
+        split_rec->e_flags = rec->e_flags;
+}
+
+static int ocfs2_split_and_insert(struct inode *inode,
+                                  handle_t *handle,
+                                  struct ocfs2_path *path,
+                                  struct buffer_head *di_bh,
+                                  struct buffer_head **last_eb_bh,
+                                  int split_index,
+                                  struct ocfs2_extent_rec *orig_split_rec,
+                                  struct ocfs2_alloc_context *meta_ac)
+{
+        int ret = 0, depth;
+        unsigned int insert_range, rec_range, do_leftright = 0;
+        struct ocfs2_extent_rec tmprec;
+        struct ocfs2_extent_list *rightmost_el;
+        struct ocfs2_extent_rec rec;
+        struct ocfs2_extent_rec split_rec = *orig_split_rec;
+        struct ocfs2_insert_type insert;
+        struct ocfs2_extent_block *eb;
+        struct ocfs2_dinode *di;
+
+leftright:
+        /*
+         * Store a copy of the record on the stack - it might move
+         * around as the tree is manipulated below.
+         */
+        rec = path_leaf_el(path)->l_recs[split_index];
+
+        di = (struct ocfs2_dinode *)di_bh->b_data;
+        rightmost_el = &di->id2.i_list;
+
+        depth = le16_to_cpu(rightmost_el->l_tree_depth);
+        if (depth) {
+                BUG_ON(!(*last_eb_bh));
+                eb = (struct ocfs2_extent_block *) (*last_eb_bh)->b_data;
+                rightmost_el = &eb->h_list;
+        }
+
+        if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
+            le16_to_cpu(rightmost_el->l_count)) {
+                int old_depth = depth;
+
+                ret = ocfs2_grow_tree(inode, handle, di_bh, &depth, last_eb_bh,
+                                      meta_ac);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                if (old_depth != depth) {
+                        eb = (struct ocfs2_extent_block *)(*last_eb_bh)->b_data;
+                        rightmost_el = &eb->h_list;
+                }
+        }
+
+        memset(&insert, 0, sizeof(struct ocfs2_insert_type));
+        insert.ins_appending = APPEND_NONE;
+        insert.ins_contig = CONTIG_NONE;
+        insert.ins_free_records = le16_to_cpu(rightmost_el->l_count)
+                - le16_to_cpu(rightmost_el->l_next_free_rec);
+        insert.ins_tree_depth = depth;
+
+        insert_range = le32_to_cpu(split_rec.e_cpos) +
+                le16_to_cpu(split_rec.e_leaf_clusters);
+        rec_range = le32_to_cpu(rec.e_cpos) +
+                le16_to_cpu(rec.e_leaf_clusters);
+
+        if (split_rec.e_cpos == rec.e_cpos) {
+                insert.ins_split = SPLIT_LEFT;
+        } else if (insert_range == rec_range) {
+                insert.ins_split = SPLIT_RIGHT;
+        } else {
+                /*
+                 * Left/right split. We fake this as a right split
+                 * first and then make a second pass as a left split.
+                 */
+                insert.ins_split = SPLIT_RIGHT;
+
+                ocfs2_make_right_split_rec(inode->i_sb, &tmprec, insert_range,
+                                           &rec);
+
+                split_rec = tmprec;
+
+                BUG_ON(do_leftright);
+                do_leftright = 1;
+        }
+
+        ret = ocfs2_do_insert_extent(inode, handle, di_bh, &split_rec,
+                                     &insert);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        if (do_leftright == 1) {
+                u32 cpos;
+                struct ocfs2_extent_list *el;
+
+                do_leftright++;
+                split_rec = *orig_split_rec;
+
+                ocfs2_reinit_path(path, 1);
+
+                cpos = le32_to_cpu(split_rec.e_cpos);
+                ret = ocfs2_find_path(inode, path, cpos);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                el = path_leaf_el(path);
+                split_index = ocfs2_search_extent_list(el, cpos);
+                goto leftright;
+        }
+out:
+
+        return ret;
+}
+
+/*
+ * Mark part or all of the extent record at split_index in the leaf
+ * pointed to by path as written. This removes the unwritten
+ * extent flag.
+ *
+ * Care is taken to handle contiguousness so as to not grow the tree.
+ *
+ * meta_ac is not strictly necessary - we only truly need it if growth
+ * of the tree is required. All other cases will degrade into a less
+ * optimal tree layout.
+ *
+ * last_eb_bh should be the rightmost leaf block for any inode with a
+ * btree. Since a split may grow the tree or a merge might shrink it, the caller cannot trust the contents of that buffer after this call.
+ *
+ * This code is optimized for readability - several passes might be
+ * made over certain portions of the tree. All of those blocks will
+ * have been brought into cache (and pinned via the journal), so the
+ * extra overhead is not expressed in terms of disk reads.
+ */
+static int __ocfs2_mark_extent_written(struct inode *inode,
+                                       struct buffer_head *di_bh,
+                                       handle_t *handle,
+                                       struct ocfs2_path *path,
+                                       int split_index,
+                                       struct ocfs2_extent_rec *split_rec,
+                                       struct ocfs2_alloc_context *meta_ac,
+                                       struct ocfs2_cached_dealloc_ctxt *dealloc)
+{
+        int ret = 0;
+        struct ocfs2_extent_list *el = path_leaf_el(path);
+        struct buffer_head *eb_bh, *last_eb_bh = NULL;
+        struct ocfs2_extent_rec *rec = &el->l_recs[split_index];
+        struct ocfs2_merge_ctxt ctxt;
+        struct ocfs2_extent_list *rightmost_el;
+
+        if (!rec->e_flags & OCFS2_EXT_UNWRITTEN) {
+                ret = -EIO;
+                mlog_errno(ret);
+                goto out;
+        }
+
+        if (le32_to_cpu(rec->e_cpos) > le32_to_cpu(split_rec->e_cpos) ||
+            ((le32_to_cpu(rec->e_cpos) + le16_to_cpu(rec->e_leaf_clusters)) <
+             (le32_to_cpu(split_rec->e_cpos) + le16_to_cpu(split_rec->e_leaf_clusters)))) {
+                ret = -EIO;
+                mlog_errno(ret);
+                goto out;
+        }
+
+        eb_bh = path_leaf_bh(path);
+        ret = ocfs2_journal_access(handle, inode, eb_bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        ctxt.c_contig_type = ocfs2_figure_merge_contig_type(inode, el,
+                                                            split_index,
+                                                            split_rec);
+
+        /*
+         * The core merge / split code wants to know how much room is
+         * left in this inodes allocation tree, so we pass the
+         * rightmost extent list.
+         */
+        if (path->p_tree_depth) {
+                struct ocfs2_extent_block *eb;
+                struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
+
+                ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
+                                       le64_to_cpu(di->i_last_eb_blk),
+                                       &last_eb_bh, OCFS2_BH_CACHED, inode);
+                if (ret) {
+                        mlog_exit(ret);
+                        goto out;
+                }
+
+                eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
+                if (!OCFS2_IS_VALID_EXTENT_BLOCK(eb)) {
+                        OCFS2_RO_ON_INVALID_EXTENT_BLOCK(inode->i_sb, eb);
+                        ret = -EROFS;
+                        goto out;
+                }
+
+                rightmost_el = &eb->h_list;
+        } else
+                rightmost_el = path_root_el(path);
+
+        ctxt.c_used_tail_recs = le16_to_cpu(rightmost_el->l_next_free_rec);
+        if (ctxt.c_used_tail_recs > 0 &&
+            ocfs2_is_empty_extent(&rightmost_el->l_recs[0]))
+                ctxt.c_used_tail_recs--;
+
+        if (rec->e_cpos == split_rec->e_cpos &&
+            rec->e_leaf_clusters == split_rec->e_leaf_clusters)
+                ctxt.c_split_covers_rec = 1;
+        else
+                ctxt.c_split_covers_rec = 0;
+
+        ctxt.c_has_empty_extent = ocfs2_is_empty_extent(&el->l_recs[0]);
+
+        mlog(0, "index: %d, contig: %u, used_tail_recs: %u, "
+             "has_empty: %u, split_covers: %u\n", split_index,
+             ctxt.c_contig_type, ctxt.c_used_tail_recs,
+             ctxt.c_has_empty_extent, ctxt.c_split_covers_rec);
+
+        if (ctxt.c_contig_type == CONTIG_NONE) {
+                if (ctxt.c_split_covers_rec)
+                        el->l_recs[split_index] = *split_rec;
+                else
+                        ret = ocfs2_split_and_insert(inode, handle, path, di_bh,
+                                                     &last_eb_bh, split_index,
+                                                     split_rec, meta_ac);
+                if (ret)
+                        mlog_errno(ret);
+        } else {
+                ret = ocfs2_try_to_merge_extent(inode, handle, path,
+                                                split_index, split_rec,
+                                                dealloc, &ctxt);
+                if (ret)
+                        mlog_errno(ret);
+        }
+
+        ocfs2_journal_dirty(handle, eb_bh);
+
+out:
+        brelse(last_eb_bh);
+        return ret;
+}
+
+/*
+ * Mark the already-existing extent at cpos as written for len clusters.
+ *
+ * If the existing extent is larger than the request, initiate a
+ * split. An attempt will be made at merging with adjacent extents.
+ *
+ * The caller is responsible for passing down meta_ac if we'll need it.
+ */
+int ocfs2_mark_extent_written(struct inode *inode, struct buffer_head *di_bh,
+                              handle_t *handle, u32 cpos, u32 len, u32 phys,
+                              struct ocfs2_alloc_context *meta_ac,
+                              struct ocfs2_cached_dealloc_ctxt *dealloc)
+{
+        int ret, index;
+        u64 start_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys);
+        struct ocfs2_extent_rec split_rec;
+        struct ocfs2_path *left_path = NULL;
+        struct ocfs2_extent_list *el;
+
+        mlog(0, "Inode %lu cpos %u, len %u, phys %u (%llu)\n",
+             inode->i_ino, cpos, len, phys, (unsigned long long)start_blkno);
+
+        if (!ocfs2_writes_unwritten_extents(OCFS2_SB(inode->i_sb))) {
+                ocfs2_error(inode->i_sb, "Inode %llu has unwritten extents "
+                            "that are being written to, but the feature bit "
+                            "is not set in the super block.",
+                            (unsigned long long)OCFS2_I(inode)->ip_blkno);
+                ret = -EROFS;
+                goto out;
+        }
+
+        /*
+         * XXX: This should be fixed up so that we just re-insert the
+         * next extent records.
+         */
+        ocfs2_extent_map_trunc(inode, 0);
+
+        left_path = ocfs2_new_inode_path(di_bh);
+        if (!left_path) {
+                ret = -ENOMEM;
+                mlog_errno(ret);
+                goto out;
+        }
+
+        ret = ocfs2_find_path(inode, left_path, cpos);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+        el = path_leaf_el(left_path);
+
+        index = ocfs2_search_extent_list(el, cpos);
+        if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) {
+                ocfs2_error(inode->i_sb,
+                            "Inode %llu has an extent at cpos %u which can no "
+                            "longer be found.\n",
+                            (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos);
+                ret = -EROFS;
+                goto out;
+        }
+
+        memset(&split_rec, 0, sizeof(struct ocfs2_extent_rec));
+        split_rec.e_cpos = cpu_to_le32(cpos);
+        split_rec.e_leaf_clusters = cpu_to_le16(len);
+        split_rec.e_blkno = cpu_to_le64(start_blkno);
+        split_rec.e_flags = path_leaf_el(left_path)->l_recs[index].e_flags;
+        split_rec.e_flags &= ~OCFS2_EXT_UNWRITTEN;
+
+        ret = __ocfs2_mark_extent_written(inode, di_bh, handle, left_path,
+                                          index, &split_rec, meta_ac, dealloc);
+        if (ret)
+                mlog_errno(ret);
+
+out:
+        ocfs2_free_path(left_path);
+        return ret;
+}
+
+static int ocfs2_split_tree(struct inode *inode, struct buffer_head *di_bh,
+                            handle_t *handle, struct ocfs2_path *path,
+                            int index, u32 new_range,
+                            struct ocfs2_alloc_context *meta_ac)
+{
+        int ret, depth, credits = handle->h_buffer_credits;
+        struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
+        struct buffer_head *last_eb_bh = NULL;
+        struct ocfs2_extent_block *eb;
+        struct ocfs2_extent_list *rightmost_el, *el;
+        struct ocfs2_extent_rec split_rec;
+        struct ocfs2_extent_rec *rec;
+        struct ocfs2_insert_type insert;
+
+        /*
+         * Setup the record to split before we grow the tree.
+         */
+        el = path_leaf_el(path);
+        rec = &el->l_recs[index];
+        ocfs2_make_right_split_rec(inode->i_sb, &split_rec, new_range, rec);
+
+        depth = path->p_tree_depth;
+        if (depth > 0) {
+                ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
+                                       le64_to_cpu(di->i_last_eb_blk),
+                                       &last_eb_bh, OCFS2_BH_CACHED, inode);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                eb = (struct ocfs2_extent_block *) last_eb_bh->b_data;
+                rightmost_el = &eb->h_list;
+        } else
+                rightmost_el = path_leaf_el(path);
+
+        credits += path->p_tree_depth + ocfs2_extend_meta_needed(di);
+        ret = ocfs2_extend_trans(handle, credits);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        if (le16_to_cpu(rightmost_el->l_next_free_rec) ==
+            le16_to_cpu(rightmost_el->l_count)) {
+                int old_depth = depth;
+
+                ret = ocfs2_grow_tree(inode, handle, di_bh, &depth, &last_eb_bh,
+                                      meta_ac);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                if (old_depth != depth) {
+                        eb = (struct ocfs2_extent_block *)last_eb_bh->b_data;
+                        rightmost_el = &eb->h_list;
+                }
+        }
+
+        memset(&insert, 0, sizeof(struct ocfs2_insert_type));
+        insert.ins_appending = APPEND_NONE;
+        insert.ins_contig = CONTIG_NONE;
+        insert.ins_split = SPLIT_RIGHT;
+        insert.ins_free_records = le16_to_cpu(rightmost_el->l_count)
+                - le16_to_cpu(rightmost_el->l_next_free_rec);
+        insert.ins_tree_depth = depth;
+
+        ret = ocfs2_do_insert_extent(inode, handle, di_bh, &split_rec, &insert);
+        if (ret)
+                mlog_errno(ret);
+
+out:
+        brelse(last_eb_bh);
+        return ret;
+}
+
+static int ocfs2_truncate_rec(struct inode *inode, handle_t *handle,
+                              struct ocfs2_path *path, int index,
+                              struct ocfs2_cached_dealloc_ctxt *dealloc,
+                              u32 cpos, u32 len)
+{
+        int ret;
+        u32 left_cpos, rec_range, trunc_range;
+        int wants_rotate = 0, is_rightmost_tree_rec = 0;
+        struct super_block *sb = inode->i_sb;
+        struct ocfs2_path *left_path = NULL;
+        struct ocfs2_extent_list *el = path_leaf_el(path);
+        struct ocfs2_extent_rec *rec;
+        struct ocfs2_extent_block *eb;
+
+        if (ocfs2_is_empty_extent(&el->l_recs[0]) && index > 0) {
+                ret = ocfs2_rotate_tree_left(inode, handle, path, dealloc);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                index--;
+        }
+
+        if (index == (le16_to_cpu(el->l_next_free_rec) - 1) &&
+            path->p_tree_depth) {
+                /*
+                 * Check whether this is the rightmost tree record. If
+                 * we remove all of this record or part of its right
+                 * edge then an update of the record lengths above it
+                 * will be required.
+                 */
+                eb = (struct ocfs2_extent_block *)path_leaf_bh(path)->b_data;
+                if (eb->h_next_leaf_blk == 0)
+                        is_rightmost_tree_rec = 1;
+        }
+
+        rec = &el->l_recs[index];
+        if (index == 0 && path->p_tree_depth &&
+            le32_to_cpu(rec->e_cpos) == cpos) {
+                /*
+                 * Changing the leftmost offset (via partial or whole
+                 * record truncate) of an interior (or rightmost) path
+                 * means we have to update the subtree that is formed
+                 * by this leaf and the one to it's left.
+                 *
+                 * There are two cases we can skip:
+                 *   1) Path is the leftmost one in our inode tree.
+                 *   2) The leaf is rightmost and will be empty after
+                 *      we remove the extent record - the rotate code
+                 *      knows how to update the newly formed edge.
+                 */
+
+                ret = ocfs2_find_cpos_for_left_leaf(inode->i_sb, path,
+                                                    &left_cpos);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                if (left_cpos && le16_to_cpu(el->l_next_free_rec) > 1) {
+                        left_path = ocfs2_new_path(path_root_bh(path),
+                                                   path_root_el(path));
+                        if (!left_path) {
+                                ret = -ENOMEM;
+                                mlog_errno(ret);
+                                goto out;
+                        }
+
+                        ret = ocfs2_find_path(inode, left_path, left_cpos);
+                        if (ret) {
+                                mlog_errno(ret);
+                                goto out;
+                        }
+                }
+        }
+
+        ret = ocfs2_extend_rotate_transaction(handle, 0,
+                                              handle->h_buffer_credits,
+                                              path);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        ret = ocfs2_journal_access_path(inode, handle, path);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        ret = ocfs2_journal_access_path(inode, handle, left_path);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
+        trunc_range = cpos + len;
+
+        if (le32_to_cpu(rec->e_cpos) == cpos && rec_range == trunc_range) {
+                int next_free;
+
+                memset(rec, 0, sizeof(*rec));
+                ocfs2_cleanup_merge(el, index);
+                wants_rotate = 1;
+
+                next_free = le16_to_cpu(el->l_next_free_rec);
+                if (is_rightmost_tree_rec && next_free > 1) {
+                        /*
+                         * We skip the edge update if this path will
+                         * be deleted by the rotate code.
+                         */
+                        rec = &el->l_recs[next_free - 1];
+                        ocfs2_adjust_rightmost_records(inode, handle, path,
+                                                       rec);
+                }
+        } else if (le32_to_cpu(rec->e_cpos) == cpos) {
+                /* Remove leftmost portion of the record. */
+                le32_add_cpu(&rec->e_cpos, len);
+                le64_add_cpu(&rec->e_blkno, ocfs2_clusters_to_blocks(sb, len));
+                le16_add_cpu(&rec->e_leaf_clusters, -len);
+        } else if (rec_range == trunc_range) {
+                /* Remove rightmost portion of the record */
+                le16_add_cpu(&rec->e_leaf_clusters, -len);
+                if (is_rightmost_tree_rec)
+                        ocfs2_adjust_rightmost_records(inode, handle, path, rec);
+        } else {
+                /* Caller should have trapped this. */
+                mlog(ML_ERROR, "Inode %llu: Invalid record truncate: (%u, %u) "
+                     "(%u, %u)\n", (unsigned long long)OCFS2_I(inode)->ip_blkno,
+                     le32_to_cpu(rec->e_cpos),
+                     le16_to_cpu(rec->e_leaf_clusters), cpos, len);
+                BUG();
+        }
+
+        if (left_path) {
+                int subtree_index;
+
+                subtree_index = ocfs2_find_subtree_root(inode, left_path, path);
+                ocfs2_complete_edge_insert(inode, handle, left_path, path,
+                                           subtree_index);
+        }
+
+        ocfs2_journal_dirty(handle, path_leaf_bh(path));
+
+        ret = ocfs2_rotate_tree_left(inode, handle, path, dealloc);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+out:
+        ocfs2_free_path(left_path);
+        return ret;
+}
+
+int ocfs2_remove_extent(struct inode *inode, struct buffer_head *di_bh,
+                        u32 cpos, u32 len, handle_t *handle,
+                        struct ocfs2_alloc_context *meta_ac,
+                        struct ocfs2_cached_dealloc_ctxt *dealloc)
+{
+        int ret, index;
+        u32 rec_range, trunc_range;
+        struct ocfs2_extent_rec *rec;
+        struct ocfs2_extent_list *el;
+        struct ocfs2_path *path;
+
+        ocfs2_extent_map_trunc(inode, 0);
+
+        path = ocfs2_new_inode_path(di_bh);
+        if (!path) {
+                ret = -ENOMEM;
+                mlog_errno(ret);
+                goto out;
+        }
+
+        ret = ocfs2_find_path(inode, path, cpos);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        el = path_leaf_el(path);
+        index = ocfs2_search_extent_list(el, cpos);
+        if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) {
+                ocfs2_error(inode->i_sb,
+                            "Inode %llu has an extent at cpos %u which can no "
+                            "longer be found.\n",
+                            (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos);
+                ret = -EROFS;
+                goto out;
+        }
+
+        /*
+         * We have 3 cases of extent removal:
+         *   1) Range covers the entire extent rec
+         *   2) Range begins or ends on one edge of the extent rec
+         *   3) Range is in the middle of the extent rec (no shared edges)
+         *
+         * For case 1 we remove the extent rec and left rotate to
+         * fill the hole.
+         *
+         * For case 2 we just shrink the existing extent rec, with a
+         * tree update if the shrinking edge is also the edge of an
+         * extent block.
+         *
+         * For case 3 we do a right split to turn the extent rec into
+         * something case 2 can handle.
+         */
+        rec = &el->l_recs[index];
+        rec_range = le32_to_cpu(rec->e_cpos) + ocfs2_rec_clusters(el, rec);
+        trunc_range = cpos + len;
+
+        BUG_ON(cpos < le32_to_cpu(rec->e_cpos) || trunc_range > rec_range);
+
+        mlog(0, "Inode %llu, remove (cpos %u, len %u). Existing index %d "
+             "(cpos %u, len %u)\n",
+             (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos, len, index,
+             le32_to_cpu(rec->e_cpos), ocfs2_rec_clusters(el, rec));
+
+        if (le32_to_cpu(rec->e_cpos) == cpos || rec_range == trunc_range) {
+                ret = ocfs2_truncate_rec(inode, handle, path, index, dealloc,
+                                         cpos, len);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+        } else {
+                ret = ocfs2_split_tree(inode, di_bh, handle, path, index,
+                                       trunc_range, meta_ac);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                /*
+                 * The split could have manipulated the tree enough to
+                 * move the record location, so we have to look for it again.
+                 */
+                ocfs2_reinit_path(path, 1);
+
+                ret = ocfs2_find_path(inode, path, cpos);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                el = path_leaf_el(path);
+                index = ocfs2_search_extent_list(el, cpos);
+                if (index == -1 || index >= le16_to_cpu(el->l_next_free_rec)) {
+                        ocfs2_error(inode->i_sb,
+                                    "Inode %llu: split at cpos %u lost record.",
+                                    (unsigned long long)OCFS2_I(inode)->ip_blkno,
+                                    cpos);
+                        ret = -EROFS;
+                        goto out;
+                }
+
+                /*
+                 * Double check our values here. If anything is fishy,
+                 * it's easier to catch it at the top level.
+                 */
+                rec = &el->l_recs[index];
+                rec_range = le32_to_cpu(rec->e_cpos) +
+                        ocfs2_rec_clusters(el, rec);
+                if (rec_range != trunc_range) {
+                        ocfs2_error(inode->i_sb,
+                                    "Inode %llu: error after split at cpos %u"
+                                    "trunc len %u, existing record is (%u,%u)",
+                                    (unsigned long long)OCFS2_I(inode)->ip_blkno,
+                                    cpos, len, le32_to_cpu(rec->e_cpos),
+                                    ocfs2_rec_clusters(el, rec));
+                        ret = -EROFS;
+                        goto out;
+                }
+
+                ret = ocfs2_truncate_rec(inode, handle, path, index, dealloc,
+                                         cpos, len);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+        }
+
+out:
+        ocfs2_free_path(path);
+        return ret;
+}
+
+int ocfs2_truncate_log_needs_flush(struct ocfs2_super *osb)
 {
         struct buffer_head *tl_bh = osb->osb_tl_bh;
         struct ocfs2_dinode *di;
@@ -2464,10 +4539,10 @@ static int ocfs2_truncate_log_can_coalesce(struct ocfs2_truncate_log *tl,
         return current_tail == new_start;
 }
 
-static int ocfs2_truncate_log_append(struct ocfs2_super *osb,
-                                     handle_t *handle,
-                                     u64 start_blk,
-                                     unsigned int num_clusters)
+int ocfs2_truncate_log_append(struct ocfs2_super *osb,
+                              handle_t *handle,
+                              u64 start_blk,
+                              unsigned int num_clusters)
 {
         int status, index;
         unsigned int start_cluster, tl_count;
@@ -2623,7 +4698,7 @@ bail:
 }
 
 /* Expects you to already be holding tl_inode->i_mutex */
-static int __ocfs2_flush_truncate_log(struct ocfs2_super *osb)
+int __ocfs2_flush_truncate_log(struct ocfs2_super *osb)
 {
         int status;
         unsigned int num_to_flush;
@@ -2957,6 +5032,219 @@ int ocfs2_truncate_log_init(struct ocfs2_super *osb)
         return status;
 }
 
+/*
+ * Delayed de-allocation of suballocator blocks.
+ *
+ * Some sets of block de-allocations might involve multiple suballocator inodes.
+ *
+ * The locking for this can get extremely complicated, especially when
+ * the suballocator inodes to delete from aren't known until deep
+ * within an unrelated codepath.
+ *
+ * ocfs2_extent_block structures are a good example of this - an inode
+ * btree could have been grown by any number of nodes each allocating
+ * out of their own suballoc inode.
+ *
+ * These structures allow the delay of block de-allocation until a
+ * later time, when locking of multiple cluster inodes won't cause
+ * deadlock.
+ */
+
+/*
+ * Describes a single block free from a suballocator
+ */
+struct ocfs2_cached_block_free {
+        struct ocfs2_cached_block_free          *free_next;
+        u64                                     free_blk;
+        unsigned int                            free_bit;
+};
+
+struct ocfs2_per_slot_free_list {
+        struct ocfs2_per_slot_free_list         *f_next_suballocator;
+        int                                     f_inode_type;
+        int                                     f_slot;
+        struct ocfs2_cached_block_free          *f_first;
+};
+
+static int ocfs2_free_cached_items(struct ocfs2_super *osb,
+                                   int sysfile_type,
+                                   int slot,
+                                   struct ocfs2_cached_block_free *head)
+{
+        int ret;
+        u64 bg_blkno;
+        handle_t *handle;
+        struct inode *inode;
+        struct buffer_head *di_bh = NULL;
+        struct ocfs2_cached_block_free *tmp;
+
+        inode = ocfs2_get_system_file_inode(osb, sysfile_type, slot);
+        if (!inode) {
+                ret = -EINVAL;
+                mlog_errno(ret);
+                goto out;
+        }
+
+        mutex_lock(&inode->i_mutex);
+
+        ret = ocfs2_meta_lock(inode, &di_bh, 1);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_mutex;
+        }
+
+        handle = ocfs2_start_trans(osb, OCFS2_SUBALLOC_FREE);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                mlog_errno(ret);
+                goto out_unlock;
+        }
+
+        while (head) {
+                bg_blkno = ocfs2_which_suballoc_group(head->free_blk,
+                                                      head->free_bit);
+                mlog(0, "Free bit: (bit %u, blkno %llu)\n",
+                     head->free_bit, (unsigned long long)head->free_blk);
+
+                ret = ocfs2_free_suballoc_bits(handle, inode, di_bh,
+                                               head->free_bit, bg_blkno, 1);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out_journal;
+                }
+
+                ret = ocfs2_extend_trans(handle, OCFS2_SUBALLOC_FREE);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out_journal;
+                }
+
+                tmp = head;
+                head = head->free_next;
+                kfree(tmp);
+        }
+
+out_journal:
+        ocfs2_commit_trans(osb, handle);
+
+out_unlock:
+        ocfs2_meta_unlock(inode, 1);
+        brelse(di_bh);
+out_mutex:
+        mutex_unlock(&inode->i_mutex);
+        iput(inode);
+out:
+        while(head) {
+                /* Premature exit may have left some dangling items. */
+                tmp = head;
+                head = head->free_next;
+                kfree(tmp);
+        }
+
+        return ret;
+}
+
+int ocfs2_run_deallocs(struct ocfs2_super *osb,
+                       struct ocfs2_cached_dealloc_ctxt *ctxt)
+{
+        int ret = 0, ret2;
+        struct ocfs2_per_slot_free_list *fl;
+
+        if (!ctxt)
+                return 0;
+
+        while (ctxt->c_first_suballocator) {
+                fl = ctxt->c_first_suballocator;
+
+                if (fl->f_first) {
+                        mlog(0, "Free items: (type %u, slot %d)\n",
+                             fl->f_inode_type, fl->f_slot);
+                        ret2 = ocfs2_free_cached_items(osb, fl->f_inode_type,
+                                                       fl->f_slot, fl->f_first);
+                        if (ret2)
+                                mlog_errno(ret2);
+                        if (!ret)
+                                ret = ret2;
+                }
+
+                ctxt->c_first_suballocator = fl->f_next_suballocator;
+                kfree(fl);
+        }
+
+        return ret;
+}
+
+static struct ocfs2_per_slot_free_list *
+ocfs2_find_per_slot_free_list(int type,
+                              int slot,
+                              struct ocfs2_cached_dealloc_ctxt *ctxt)
+{
+        struct ocfs2_per_slot_free_list *fl = ctxt->c_first_suballocator;
+
+        while (fl) {
+                if (fl->f_inode_type == type && fl->f_slot == slot)
+                        return fl;
+
+                fl = fl->f_next_suballocator;
+        }
+
+        fl = kmalloc(sizeof(*fl), GFP_NOFS);
+        if (fl) {
+                fl->f_inode_type = type;
+                fl->f_slot = slot;
+                fl->f_first = NULL;
+                fl->f_next_suballocator = ctxt->c_first_suballocator;
+
+                ctxt->c_first_suballocator = fl;
+        }
+        return fl;
+}
+
+static int ocfs2_cache_block_dealloc(struct ocfs2_cached_dealloc_ctxt *ctxt,
+                                     int type, int slot, u64 blkno,
+                                     unsigned int bit)
+{
+        int ret;
+        struct ocfs2_per_slot_free_list *fl;
+        struct ocfs2_cached_block_free *item;
+
+        fl = ocfs2_find_per_slot_free_list(type, slot, ctxt);
+        if (fl == NULL) {
+                ret = -ENOMEM;
+                mlog_errno(ret);
+                goto out;
+        }
+
+        item = kmalloc(sizeof(*item), GFP_NOFS);
+        if (item == NULL) {
+                ret = -ENOMEM;
+                mlog_errno(ret);
+                goto out;
+        }
+
+        mlog(0, "Insert: (type %d, slot %u, bit %u, blk %llu)\n",
+             type, slot, bit, (unsigned long long)blkno);
+
+        item->free_blk = blkno;
+        item->free_bit = bit;
+        item->free_next = fl->f_first;
+
+        fl->f_first = item;
+
+        ret = 0;
+out:
+        return ret;
+}
+
+static int ocfs2_cache_extent_block_free(struct ocfs2_cached_dealloc_ctxt *ctxt,
+                                         struct ocfs2_extent_block *eb)
+{
+        return ocfs2_cache_block_dealloc(ctxt, EXTENT_ALLOC_SYSTEM_INODE,
+                                         le16_to_cpu(eb->h_suballoc_slot),
+                                         le64_to_cpu(eb->h_blkno),
+                                         le16_to_cpu(eb->h_suballoc_bit));
+}
+
 /* This function will figure out whether the currently last extent
  * block will be deleted, and if it will, what the new last extent
  * block will be so we can update his h_next_leaf_blk field, as well
@@ -3238,27 +5526,10 @@ delete:
                         BUG_ON(le32_to_cpu(el->l_recs[0].e_cpos));
                         BUG_ON(le64_to_cpu(el->l_recs[0].e_blkno));
 
-                        if (le16_to_cpu(eb->h_suballoc_slot) == 0) {
-                                /*
-                                 * This code only understands how to
-                                 * lock the suballocator in slot 0,
-                                 * which is fine because allocation is
-                                 * only ever done out of that
-                                 * suballocator too. A future version
-                                 * might change that however, so avoid
-                                 * a free if we don't know how to
-                                 * handle it. This way an fs incompat
-                                 * bit will not be necessary.
-                                 */
-                                ret = ocfs2_free_extent_block(handle,
-                                                              tc->tc_ext_alloc_inode,
-                                                              tc->tc_ext_alloc_bh,
-                                                              eb);
-
-                                /* An error here is not fatal. */
-                                if (ret < 0)
-                                        mlog_errno(ret);
-                        }
+                        ret = ocfs2_cache_extent_block_free(&tc->tc_dealloc, eb);
+                        /* An error here is not fatal. */
+                        if (ret < 0)
+                                mlog_errno(ret);
                 } else {
                         deleted_eb = 0;
                 }
@@ -3397,9 +5668,9 @@ static int ocfs2_ordered_zero_func(handle_t *handle, struct buffer_head *bh)
         return ocfs2_journal_dirty_data(handle, bh);
 }
 
-static void ocfs2_zero_cluster_pages(struct inode *inode, loff_t isize,
-                                     struct page **pages, int numpages,
-                                     u64 phys, handle_t *handle)
+static void ocfs2_zero_cluster_pages(struct inode *inode, loff_t start,
+                                     loff_t end, struct page **pages,
+                                     int numpages, u64 phys, handle_t *handle)
 {
         int i, ret, partial = 0;
         void *kaddr;
@@ -3412,26 +5683,14 @@ static void ocfs2_zero_cluster_pages(struct inode *inode, loff_t isize,
         if (numpages == 0)
                 goto out;
 
-        from = isize & (PAGE_CACHE_SIZE - 1); /* 1st page offset */
-        if (PAGE_CACHE_SHIFT > OCFS2_SB(sb)->s_clustersize_bits) {
-                /*
-                 * Since 'from' has been capped to a value below page
-                 * size, this calculation won't be able to overflow
-                 * 'to'
-                 */
-                to = ocfs2_align_bytes_to_clusters(sb, from);
-
-                /*
-                 * The truncate tail in this case should never contain
-                 * more than one page at maximum. The loop below also
-                 * assumes this.
-                 */
-                BUG_ON(numpages != 1);
-        }
-
+        to = PAGE_CACHE_SIZE;
         for(i = 0; i < numpages; i++) {
                 page = pages[i];
 
+                from = start & (PAGE_CACHE_SIZE - 1);
+                if ((end >> PAGE_CACHE_SHIFT) == page->index)
+                        to = end & (PAGE_CACHE_SIZE - 1);
+
                 BUG_ON(from > PAGE_CACHE_SIZE);
                 BUG_ON(to > PAGE_CACHE_SIZE);
 
@@ -3468,10 +5727,7 @@ static void ocfs2_zero_cluster_pages(struct inode *inode, loff_t isize,
 
                 flush_dcache_page(page);
 
-                /*
-                 * Every page after the 1st one should be completely zero'd.
-                 */
-                from = 0;
+                start = (page->index + 1) << PAGE_CACHE_SHIFT;
         }
 out:
         if (pages) {
@@ -3484,24 +5740,26 @@ out:
         }
 }
 
-static int ocfs2_grab_eof_pages(struct inode *inode, loff_t isize, struct page **pages,
-                                int *num, u64 *phys)
+static int ocfs2_grab_eof_pages(struct inode *inode, loff_t start, loff_t end,
+                                struct page **pages, int *num, u64 *phys)
 {
         int i, numpages = 0, ret = 0;
-        unsigned int csize = OCFS2_SB(inode->i_sb)->s_clustersize;
         unsigned int ext_flags;
         struct super_block *sb = inode->i_sb;
         struct address_space *mapping = inode->i_mapping;
         unsigned long index;
-        u64 next_cluster_bytes;
+        loff_t last_page_bytes;
 
         BUG_ON(!ocfs2_sparse_alloc(OCFS2_SB(sb)));
+        BUG_ON(start > end);
 
-        /* Cluster boundary, so we don't need to grab any pages. */
-        if ((isize & (csize - 1)) == 0)
+        if (start == end)
                 goto out;
 
-        ret = ocfs2_extent_map_get_blocks(inode, isize >> sb->s_blocksize_bits,
+        BUG_ON(start >> OCFS2_SB(sb)->s_clustersize_bits !=
+               (end - 1) >> OCFS2_SB(sb)->s_clustersize_bits);
+
+        ret = ocfs2_extent_map_get_blocks(inode, start >> sb->s_blocksize_bits,
                                           phys, NULL, &ext_flags);
         if (ret) {
                 mlog_errno(ret);
@@ -3517,8 +5775,8 @@ static int ocfs2_grab_eof_pages(struct inode *inode, loff_t isize, struct page *
         if (ext_flags & OCFS2_EXT_UNWRITTEN)
                 goto out;
 
-        next_cluster_bytes = ocfs2_align_bytes_to_clusters(inode->i_sb, isize);
-        index = isize >> PAGE_CACHE_SHIFT;
+        last_page_bytes = PAGE_ALIGN(end);
+        index = start >> PAGE_CACHE_SHIFT;
         do {
                 pages[numpages] = grab_cache_page(mapping, index);
                 if (!pages[numpages]) {
@@ -3529,7 +5787,7 @@ static int ocfs2_grab_eof_pages(struct inode *inode, loff_t isize, struct page *
 
                 numpages++;
                 index++;
-        } while (index < (next_cluster_bytes >> PAGE_CACHE_SHIFT));
+        } while (index < (last_page_bytes >> PAGE_CACHE_SHIFT));
 
 out:
         if (ret != 0) {
@@ -3558,11 +5816,10 @@ out:
  * otherwise block_write_full_page() will skip writeout of pages past
  * i_size. The new_i_size parameter is passed for this reason.
  */
-int ocfs2_zero_tail_for_truncate(struct inode *inode, handle_t *handle,
-                                 u64 new_i_size)
+int ocfs2_zero_range_for_truncate(struct inode *inode, handle_t *handle,
+                                  u64 range_start, u64 range_end)
 {
         int ret, numpages;
-        loff_t endbyte;
         struct page **pages = NULL;
         u64 phys;
 
@@ -3581,7 +5838,8 @@ int ocfs2_zero_tail_for_truncate(struct inode *inode, handle_t *handle,
                 goto out;
         }
 
-        ret = ocfs2_grab_eof_pages(inode, new_i_size, pages, &numpages, &phys);
+        ret = ocfs2_grab_eof_pages(inode, range_start, range_end, pages,
+                                   &numpages, &phys);
         if (ret) {
                 mlog_errno(ret);
                 goto out;
@@ -3590,17 +5848,16 @@ int ocfs2_zero_tail_for_truncate(struct inode *inode, handle_t *handle,
         if (numpages == 0)
                 goto out;
 
-        ocfs2_zero_cluster_pages(inode, new_i_size, pages, numpages, phys,
-                                 handle);
+        ocfs2_zero_cluster_pages(inode, range_start, range_end, pages,
+                                 numpages, phys, handle);
 
         /*
          * Initiate writeout of the pages we zero'd here. We don't
          * wait on them - the truncate_inode_pages() call later will
          * do that for us.
          */
-        endbyte = ocfs2_align_bytes_to_clusters(inode->i_sb, new_i_size);
-        ret = do_sync_mapping_range(inode->i_mapping, new_i_size,
-                                    endbyte - 1, SYNC_FILE_RANGE_WRITE);
+        ret = do_sync_mapping_range(inode->i_mapping, range_start,
+                                    range_end - 1, SYNC_FILE_RANGE_WRITE);
         if (ret)
                 mlog_errno(ret);
 
@@ -3631,8 +5888,6 @@ int ocfs2_commit_truncate(struct ocfs2_super *osb,
 
         mlog_entry_void();
 
-        down_write(&OCFS2_I(inode)->ip_alloc_sem);
-
         new_highest_cpos = ocfs2_clusters_for_bytes(osb->sb,
                                                      i_size_read(inode));
 
@@ -3754,7 +6009,6 @@ start:
         goto start;
 
 bail:
-        up_write(&OCFS2_I(inode)->ip_alloc_sem);
 
         ocfs2_schedule_truncate_log_flush(osb, 1);
 
@@ -3764,6 +6018,8 @@ bail:
         if (handle)
                 ocfs2_commit_trans(osb, handle);
 
+        ocfs2_run_deallocs(osb, &tc->tc_dealloc);
+
         ocfs2_free_path(path);
 
         /* This will drop the ext_alloc cluster lock for us */
@@ -3774,23 +6030,18 @@ bail:
 }
 
 /*
- * Expects the inode to already be locked. This will figure out which
- * inodes need to be locked and will put them on the returned truncate
- * context.
+ * Expects the inode to already be locked.
  */
 int ocfs2_prepare_truncate(struct ocfs2_super *osb,
                            struct inode *inode,
                            struct buffer_head *fe_bh,
                            struct ocfs2_truncate_context **tc)
 {
-        int status, metadata_delete, i;
+        int status;
         unsigned int new_i_clusters;
         struct ocfs2_dinode *fe;
         struct ocfs2_extent_block *eb;
-        struct ocfs2_extent_list *el;
         struct buffer_head *last_eb_bh = NULL;
-        struct inode *ext_alloc_inode = NULL;
-        struct buffer_head *ext_alloc_bh = NULL;
 
         mlog_entry_void();
 
@@ -3810,12 +6061,9 @@ int ocfs2_prepare_truncate(struct ocfs2_super *osb,
                 mlog_errno(status);
                 goto bail;
         }
+        ocfs2_init_dealloc_ctxt(&(*tc)->tc_dealloc);
 
-        metadata_delete = 0;
         if (fe->id2.i_list.l_tree_depth) {
-                /* If we have a tree, then the truncate may result in
-                 * metadata deletes. Figure this out from the
-                 * rightmost leaf block.*/
                 status = ocfs2_read_block(osb, le64_to_cpu(fe->i_last_eb_blk),
                                           &last_eb_bh, OCFS2_BH_CACHED, inode);
                 if (status < 0) {
@@ -3830,43 +6078,10 @@ int ocfs2_prepare_truncate(struct ocfs2_super *osb,
                         status = -EIO;
                         goto bail;
                 }
-                el = &(eb->h_list);
-
-                i = 0;
-                if (ocfs2_is_empty_extent(&el->l_recs[0]))
-                        i = 1;
-                /*
-                 * XXX: Should we check that next_free_rec contains
-                 * the extent?
-                 */
-                if (le32_to_cpu(el->l_recs[i].e_cpos) >= new_i_clusters)
-                        metadata_delete = 1;
         }
 
         (*tc)->tc_last_eb_bh = last_eb_bh;
 
-        if (metadata_delete) {
-                mlog(0, "Will have to delete metadata for this trunc. "
-                     "locking allocator.\n");
-                ext_alloc_inode = ocfs2_get_system_file_inode(osb, EXTENT_ALLOC_SYSTEM_INODE, 0);
-                if (!ext_alloc_inode) {
-                        status = -ENOMEM;
-                        mlog_errno(status);
-                        goto bail;
-                }
-
-                mutex_lock(&ext_alloc_inode->i_mutex);
-                (*tc)->tc_ext_alloc_inode = ext_alloc_inode;
-
-                status = ocfs2_meta_lock(ext_alloc_inode, &ext_alloc_bh, 1);
-                if (status < 0) {
-                        mlog_errno(status);
-                        goto bail;
-                }
-                (*tc)->tc_ext_alloc_bh = ext_alloc_bh;
-                (*tc)->tc_ext_alloc_locked = 1;
-        }
-
         status = 0;
 bail:
         if (status < 0) {
@@ -3880,16 +6095,13 @@ bail:
 
 static void ocfs2_free_truncate_context(struct ocfs2_truncate_context *tc)
 {
-        if (tc->tc_ext_alloc_inode) {
-                if (tc->tc_ext_alloc_locked)
-                        ocfs2_meta_unlock(tc->tc_ext_alloc_inode, 1);
-
-                mutex_unlock(&tc->tc_ext_alloc_inode->i_mutex);
-                iput(tc->tc_ext_alloc_inode);
-        }
-
-        if (tc->tc_ext_alloc_bh)
-                brelse(tc->tc_ext_alloc_bh);
+        /*
+         * The caller is responsible for completing deallocation
+         * before freeing the context.
+         */
+        if (tc->tc_dealloc.c_first_suballocator != NULL)
+                mlog(ML_NOTICE,
+                     "Truncate completion has non-empty dealloc context\n");
 
         if (tc->tc_last_eb_bh)
                 brelse(tc->tc_last_eb_bh);
diff --git a/fs/ocfs2/alloc.h b/fs/ocfs2/alloc.h
index fbcb5934a08..990df48ae8d 100644
--- a/fs/ocfs2/alloc.h
+++ b/fs/ocfs2/alloc.h
@@ -34,7 +34,17 @@ int ocfs2_insert_extent(struct ocfs2_super *osb,
                         u32 cpos,
                         u64 start_blk,
                         u32 new_clusters,
+                        u8 flags,
                         struct ocfs2_alloc_context *meta_ac);
+struct ocfs2_cached_dealloc_ctxt;
+int ocfs2_mark_extent_written(struct inode *inode, struct buffer_head *di_bh,
+                              handle_t *handle, u32 cpos, u32 len, u32 phys,
+                              struct ocfs2_alloc_context *meta_ac,
+                              struct ocfs2_cached_dealloc_ctxt *dealloc);
+int ocfs2_remove_extent(struct inode *inode, struct buffer_head *di_bh,
+                        u32 cpos, u32 len, handle_t *handle,
+                        struct ocfs2_alloc_context *meta_ac,
+                        struct ocfs2_cached_dealloc_ctxt *dealloc);
 int ocfs2_num_free_extents(struct ocfs2_super *osb,
                            struct inode *inode,
                            struct ocfs2_dinode *fe);
@@ -62,17 +72,41 @@ int ocfs2_begin_truncate_log_recovery(struct ocfs2_super *osb,
                                       struct ocfs2_dinode **tl_copy);
 int ocfs2_complete_truncate_log_recovery(struct ocfs2_super *osb,
                                          struct ocfs2_dinode *tl_copy);
+int ocfs2_truncate_log_needs_flush(struct ocfs2_super *osb);
+int ocfs2_truncate_log_append(struct ocfs2_super *osb,
+                              handle_t *handle,
+                              u64 start_blk,
+                              unsigned int num_clusters);
+int __ocfs2_flush_truncate_log(struct ocfs2_super *osb);
+
+/*
+ * Process local structure which describes the block unlinks done
+ * during an operation. This is populated via
+ * ocfs2_cache_block_dealloc().
+ *
+ * ocfs2_run_deallocs() should be called after the potentially
+ * de-allocating routines. No journal handles should be open, and most
+ * locks should have been dropped.
+ */
+struct ocfs2_cached_dealloc_ctxt {
+        struct ocfs2_per_slot_free_list         *c_first_suballocator;
+};
+static inline void ocfs2_init_dealloc_ctxt(struct ocfs2_cached_dealloc_ctxt *c)
+{
+        c->c_first_suballocator = NULL;
+}
+int ocfs2_run_deallocs(struct ocfs2_super *osb,
+                       struct ocfs2_cached_dealloc_ctxt *ctxt);
 
 struct ocfs2_truncate_context {
-        struct inode *tc_ext_alloc_inode;
-        struct buffer_head *tc_ext_alloc_bh;
+        struct ocfs2_cached_dealloc_ctxt tc_dealloc;
         int tc_ext_alloc_locked; /* is it cluster locked? */
         /* these get destroyed once it's passed to ocfs2_commit_truncate. */
         struct buffer_head *tc_last_eb_bh;
 };
 
-int ocfs2_zero_tail_for_truncate(struct inode *inode, handle_t *handle,
-                                 u64 new_i_size);
+int ocfs2_zero_range_for_truncate(struct inode *inode, handle_t *handle,
+                                  u64 range_start, u64 range_end);
 int ocfs2_prepare_truncate(struct ocfs2_super *osb,
                            struct inode *inode,
                            struct buffer_head *fe_bh,
@@ -84,6 +118,7 @@ int ocfs2_commit_truncate(struct ocfs2_super *osb,
 
 int ocfs2_find_leaf(struct inode *inode, struct ocfs2_extent_list *root_el,
                     u32 cpos, struct buffer_head **leaf_bh);
+int ocfs2_search_extent_list(struct ocfs2_extent_list *el, u32 v_cluster);
 
 /*
  * Helper function to look at the # of clusters in an extent record.
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index a480b09c79b..84bf6e79de2 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -684,6 +684,8 @@ int ocfs2_map_page_blocks(struct page *page, u64 *p_blkno,
              bh = bh->b_this_page, block_start += bsize) {
                 block_end = block_start + bsize;
 
+                clear_buffer_new(bh);
+
                 /*
                  * Ignore blocks outside of our i/o range -
                  * they may belong to unallocated clusters.
@@ -698,9 +700,8 @@ int ocfs2_map_page_blocks(struct page *page, u64 *p_blkno,
                  * For an allocating write with cluster size >= page
                  * size, we always write the entire page.
                  */
-
-                if (buffer_new(bh))
-                        clear_buffer_new(bh);
+                if (new)
+                        set_buffer_new(bh);
 
                 if (!buffer_mapped(bh)) {
                         map_bh(bh, inode->i_sb, *p_blkno);
@@ -711,7 +712,8 @@ int ocfs2_map_page_blocks(struct page *page, u64 *p_blkno,
                         if (!buffer_uptodate(bh))
                                 set_buffer_uptodate(bh);
                 } else if (!buffer_uptodate(bh) && !buffer_delay(bh) &&
-                     (block_start < from || block_end > to)) {
+                           !buffer_new(bh) &&
+                           (block_start < from || block_end > to)) {
                         ll_rw_block(READ, 1, &bh);
                         *wait_bh++=bh;
                 }
@@ -738,18 +740,13 @@ int ocfs2_map_page_blocks(struct page *page, u64 *p_blkno,
         bh = head;
         block_start = 0;
         do {
-                void *kaddr;
-
                 block_end = block_start + bsize;
                 if (block_end <= from)
                         goto next_bh;
                 if (block_start >= to)
                         break;
 
-                kaddr = kmap_atomic(page, KM_USER0);
-                memset(kaddr+block_start, 0, bh->b_size);
-                flush_dcache_page(page);
-                kunmap_atomic(kaddr, KM_USER0);
+                zero_user_page(page, block_start, bh->b_size, KM_USER0);
                 set_buffer_uptodate(bh);
                 mark_buffer_dirty(bh);
 
@@ -761,217 +758,240 @@ next_bh:
         return ret;
 }
 
+#if (PAGE_CACHE_SIZE >= OCFS2_MAX_CLUSTERSIZE)
+#define OCFS2_MAX_CTXT_PAGES    1
+#else
+#define OCFS2_MAX_CTXT_PAGES    (OCFS2_MAX_CLUSTERSIZE / PAGE_CACHE_SIZE)
+#endif
+
+#define OCFS2_MAX_CLUSTERS_PER_PAGE     (PAGE_CACHE_SIZE / OCFS2_MIN_CLUSTERSIZE)
+
 /*
- * This will copy user data from the buffer page in the splice
- * context.
- *
- * For now, we ignore SPLICE_F_MOVE as that would require some extra
- * communication out all the way to ocfs2_write().
+ * Describe the state of a single cluster to be written to.
  */
-int ocfs2_map_and_write_splice_data(struct inode *inode,
-                                  struct ocfs2_write_ctxt *wc, u64 *p_blkno,
-                                  unsigned int *ret_from, unsigned int *ret_to)
+struct ocfs2_write_cluster_desc {
+        u32             c_cpos;
+        u32             c_phys;
+        /*
+         * Give this a unique field because c_phys eventually gets
+         * filled.
+         */
+        unsigned        c_new;
+        unsigned        c_unwritten;
+};
+
+static inline int ocfs2_should_zero_cluster(struct ocfs2_write_cluster_desc *d)
 {
-        int ret;
-        unsigned int to, from, cluster_start, cluster_end;
-        char *src, *dst;
-        struct ocfs2_splice_write_priv *sp = wc->w_private;
-        struct pipe_buffer *buf = sp->s_buf;
-        unsigned long bytes, src_from;
-        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        return d->c_new || d->c_unwritten;
+}
 
-        ocfs2_figure_cluster_boundaries(osb, wc->w_cpos, &cluster_start,
-                                        &cluster_end);
+struct ocfs2_write_ctxt {
+        /* Logical cluster position / len of write */
+        u32                             w_cpos;
+        u32                             w_clen;
 
-        from = sp->s_offset;
-        src_from = sp->s_buf_offset;
-        bytes = wc->w_count;
+        struct ocfs2_write_cluster_desc w_desc[OCFS2_MAX_CLUSTERS_PER_PAGE];
 
-        if (wc->w_large_pages) {
-                /*
-                 * For cluster size < page size, we have to
-                 * calculate pos within the cluster and obey
-                 * the rightmost boundary.
-                 */
-                bytes = min(bytes, (unsigned long)(osb->s_clustersize
-                                   - (wc->w_pos & (osb->s_clustersize - 1))));
-        }
-        to = from + bytes;
+        /*
+         * This is true if page_size > cluster_size.
+         *
+         * It triggers a set of special cases during write which might
+         * have to deal with allocating writes to partial pages.
+         */
+        unsigned int                    w_large_pages;
+
+        /*
+         * Pages involved in this write.
+         *
+         * w_target_page is the page being written to by the user.
+         *
+         * w_pages is an array of pages which always contains
+         * w_target_page, and in the case of an allocating write with
+         * page_size < cluster size, it will contain zero'd and mapped
+         * pages adjacent to w_target_page which need to be written
+         * out in so that future reads from that region will get
+         * zero's.
+         */
+        struct page                     *w_pages[OCFS2_MAX_CTXT_PAGES];
+        unsigned int                    w_num_pages;
+        struct page                     *w_target_page;
 
-        BUG_ON(from > PAGE_CACHE_SIZE);
-        BUG_ON(to > PAGE_CACHE_SIZE);
-        BUG_ON(from < cluster_start);
-        BUG_ON(to > cluster_end);
+        /*
+         * ocfs2_write_end() uses this to know what the real range to
+         * write in the target should be.
+         */
+        unsigned int                    w_target_from;
+        unsigned int                    w_target_to;
 
-        if (wc->w_this_page_new)
-                ret = ocfs2_map_page_blocks(wc->w_this_page, p_blkno, inode,
-                                            cluster_start, cluster_end, 1);
-        else
-                ret = ocfs2_map_page_blocks(wc->w_this_page, p_blkno, inode,
-                                            from, to, 0);
-        if (ret) {
-                mlog_errno(ret);
-                goto out;
+        /*
+         * We could use journal_current_handle() but this is cleaner,
+         * IMHO -Mark
+         */
+        handle_t                        *w_handle;
+
+        struct buffer_head              *w_di_bh;
+
+        struct ocfs2_cached_dealloc_ctxt w_dealloc;
+};
+
+static void ocfs2_free_write_ctxt(struct ocfs2_write_ctxt *wc)
+{
+        int i;
+
+        for(i = 0; i < wc->w_num_pages; i++) {
+                if (wc->w_pages[i] == NULL)
+                        continue;
+
+                unlock_page(wc->w_pages[i]);
+                mark_page_accessed(wc->w_pages[i]);
+                page_cache_release(wc->w_pages[i]);
         }
 
-        src = buf->ops->map(sp->s_pipe, buf, 1);
-        dst = kmap_atomic(wc->w_this_page, KM_USER1);
-        memcpy(dst + from, src + src_from, bytes);
-        kunmap_atomic(wc->w_this_page, KM_USER1);
-        buf->ops->unmap(sp->s_pipe, buf, src);
+        brelse(wc->w_di_bh);
+        kfree(wc);
+}
+
+static int ocfs2_alloc_write_ctxt(struct ocfs2_write_ctxt **wcp,
+                                  struct ocfs2_super *osb, loff_t pos,
+                                  unsigned len, struct buffer_head *di_bh)
+{
+        struct ocfs2_write_ctxt *wc;
+
+        wc = kzalloc(sizeof(struct ocfs2_write_ctxt), GFP_NOFS);
+        if (!wc)
+                return -ENOMEM;
 
-        wc->w_finished_copy = 1;
+        wc->w_cpos = pos >> osb->s_clustersize_bits;
+        wc->w_clen = ocfs2_clusters_for_bytes(osb->sb, len);
+        get_bh(di_bh);
+        wc->w_di_bh = di_bh;
 
-        *ret_from = from;
-        *ret_to = to;
-out:
+        if (unlikely(PAGE_CACHE_SHIFT > osb->s_clustersize_bits))
+                wc->w_large_pages = 1;
+        else
+                wc->w_large_pages = 0;
+
+        ocfs2_init_dealloc_ctxt(&wc->w_dealloc);
+
+        *wcp = wc;
 
-        return bytes ? (unsigned int)bytes : ret;
+        return 0;
 }
 
 /*
- * This will copy user data from the iovec in the buffered write
- * context.
+ * If a page has any new buffers, zero them out here, and mark them uptodate
+ * and dirty so they'll be written out (in order to prevent uninitialised
+ * block data from leaking). And clear the new bit.
  */
-int ocfs2_map_and_write_user_data(struct inode *inode,
-                                  struct ocfs2_write_ctxt *wc, u64 *p_blkno,
-                                  unsigned int *ret_from, unsigned int *ret_to)
+static void ocfs2_zero_new_buffers(struct page *page, unsigned from, unsigned to)
 {
-        int ret;
-        unsigned int to, from, cluster_start, cluster_end;
-        unsigned long bytes, src_from;
-        char *dst;
-        struct ocfs2_buffered_write_priv *bp = wc->w_private;
-        const struct iovec *cur_iov = bp->b_cur_iov;
-        char __user *buf;
-        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        unsigned int block_start, block_end;
+        struct buffer_head *head, *bh;
 
-        ocfs2_figure_cluster_boundaries(osb, wc->w_cpos, &cluster_start,
-                                        &cluster_end);
+        BUG_ON(!PageLocked(page));
+        if (!page_has_buffers(page))
+                return;
 
-        buf = cur_iov->iov_base + bp->b_cur_off;
-        src_from = (unsigned long)buf & ~PAGE_CACHE_MASK;
+        bh = head = page_buffers(page);
+        block_start = 0;
+        do {
+                block_end = block_start + bh->b_size;
 
-        from = wc->w_pos & (PAGE_CACHE_SIZE - 1);
+                if (buffer_new(bh)) {
+                        if (block_end > from && block_start < to) {
+                                if (!PageUptodate(page)) {
+                                        unsigned start, end;
 
-        /*
-         * This is a lot of comparisons, but it reads quite
-         * easily, which is important here.
-         */
-        /* Stay within the src page */
-        bytes = PAGE_SIZE - src_from;
-        /* Stay within the vector */
-        bytes = min(bytes,
-                    (unsigned long)(cur_iov->iov_len - bp->b_cur_off));
-        /* Stay within count */
-        bytes = min(bytes, (unsigned long)wc->w_count);
-        /*
-         * For clustersize > page size, just stay within
-         * target page, otherwise we have to calculate pos
-         * within the cluster and obey the rightmost
-         * boundary.
-         */
-        if (wc->w_large_pages) {
-                /*
-                 * For cluster size < page size, we have to
-                 * calculate pos within the cluster and obey
-                 * the rightmost boundary.
-                 */
-                bytes = min(bytes, (unsigned long)(osb->s_clustersize
-                                   - (wc->w_pos & (osb->s_clustersize - 1))));
-        } else {
-                /*
-                 * cluster size > page size is the most common
-                 * case - we just stay within the target page
-                 * boundary.
-                 */
-                bytes = min(bytes, PAGE_CACHE_SIZE - from);
-        }
+                                        start = max(from, block_start);
+                                        end = min(to, block_end);
 
-        to = from + bytes;
+                                        zero_user_page(page, start, end - start, KM_USER0);
+                                        set_buffer_uptodate(bh);
+                                }
 
-        BUG_ON(from > PAGE_CACHE_SIZE);
-        BUG_ON(to > PAGE_CACHE_SIZE);
-        BUG_ON(from < cluster_start);
-        BUG_ON(to > cluster_end);
+                                clear_buffer_new(bh);
+                                mark_buffer_dirty(bh);
+                        }
+                }
 
-        if (wc->w_this_page_new)
-                ret = ocfs2_map_page_blocks(wc->w_this_page, p_blkno, inode,
-                                            cluster_start, cluster_end, 1);
-        else
-                ret = ocfs2_map_page_blocks(wc->w_this_page, p_blkno, inode,
-                                            from, to, 0);
-        if (ret) {
-                mlog_errno(ret);
-                goto out;
-        }
+                block_start = block_end;
+                bh = bh->b_this_page;
+        } while (bh != head);
+}
 
-        dst = kmap(wc->w_this_page);
-        memcpy(dst + from, bp->b_src_buf + src_from, bytes);
-        kunmap(wc->w_this_page);
+/*
+ * Only called when we have a failure during allocating write to write
+ * zero's to the newly allocated region.
+ */
+static void ocfs2_write_failure(struct inode *inode,
+                                struct ocfs2_write_ctxt *wc,
+                                loff_t user_pos, unsigned user_len)
+{
+        int i;
+        unsigned from, to;
+        struct page *tmppage;
 
-        /*
-         * XXX: This is slow, but simple. The caller of
-         * ocfs2_buffered_write_cluster() is responsible for
-         * passing through the iovecs, so it's difficult to
-         * predict what our next step is in here after our
-         * initial write. A future version should be pushing
-         * that iovec manipulation further down.
-         *
-         * By setting this, we indicate that a copy from user
-         * data was done, and subsequent calls for this
-         * cluster will skip copying more data.
-         */
-        wc->w_finished_copy = 1;
+        ocfs2_zero_new_buffers(wc->w_target_page, user_pos, user_len);
 
-        *ret_from = from;
-        *ret_to = to;
-out:
+        if (wc->w_large_pages) {
+                from = wc->w_target_from;
+                to = wc->w_target_to;
+        } else {
+                from = 0;
+                to = PAGE_CACHE_SIZE;
+        }
+
+        for(i = 0; i < wc->w_num_pages; i++) {
+                tmppage = wc->w_pages[i];
 
-        return bytes ? (unsigned int)bytes : ret;
+                if (ocfs2_should_order_data(inode))
+                        walk_page_buffers(wc->w_handle, page_buffers(tmppage),
+                                          from, to, NULL,
+                                          ocfs2_journal_dirty_data);
+
+                block_commit_write(tmppage, from, to);
+        }
 }
 
-/*
- * Map, fill and write a page to disk.
- *
- * The work of copying data is done via callback.  Newly allocated
- * pages which don't take user data will be zero'd (set 'new' to
- * indicate an allocating write)
- *
- * Returns a negative error code or the number of bytes copied into
- * the page.
- */
-static int ocfs2_write_data_page(struct inode *inode, handle_t *handle,
-                                 u64 *p_blkno, struct page *page,
-                                 struct ocfs2_write_ctxt *wc, int new)
+static int ocfs2_prepare_page_for_write(struct inode *inode, u64 *p_blkno,
+                                        struct ocfs2_write_ctxt *wc,
+                                        struct page *page, u32 cpos,
+                                        loff_t user_pos, unsigned user_len,
+                                        int new)
 {
-        int ret, copied = 0;
-        unsigned int from = 0, to = 0;
+        int ret;
+        unsigned int map_from = 0, map_to = 0;
         unsigned int cluster_start, cluster_end;
-        unsigned int zero_from = 0, zero_to = 0;
+        unsigned int user_data_from = 0, user_data_to = 0;
 
-        ocfs2_figure_cluster_boundaries(OCFS2_SB(inode->i_sb), wc->w_cpos,
+        ocfs2_figure_cluster_boundaries(OCFS2_SB(inode->i_sb), cpos,
                                         &cluster_start, &cluster_end);
 
-        if ((wc->w_pos >> PAGE_CACHE_SHIFT) == page->index
-            && !wc->w_finished_copy) {
-
-                wc->w_this_page = page;
-                wc->w_this_page_new = new;
-                ret = wc->w_write_data_page(inode, wc, p_blkno, &from, &to);
-                if (ret < 0) {
+        if (page == wc->w_target_page) {
+                map_from = user_pos & (PAGE_CACHE_SIZE - 1);
+                map_to = map_from + user_len;
+
+                if (new)
+                        ret = ocfs2_map_page_blocks(page, p_blkno, inode,
+                                                    cluster_start, cluster_end,
+                                                    new);
+                else
+                        ret = ocfs2_map_page_blocks(page, p_blkno, inode,
+                                                    map_from, map_to, new);
+                if (ret) {
                         mlog_errno(ret);
                         goto out;
                 }
 
-                copied = ret;
-
-                zero_from = from;
-                zero_to = to;
+                user_data_from = map_from;
+                user_data_to = map_to;
                 if (new) {
-                        from = cluster_start;
-                        to = cluster_end;
+                        map_from = cluster_start;
+                        map_to = cluster_end;
                 }
+
+                wc->w_target_from = map_from;
+                wc->w_target_to = map_to;
         } else {
                 /*
                  * If we haven't allocated the new page yet, we
@@ -980,11 +1000,11 @@ static int ocfs2_write_data_page(struct inode *inode, handle_t *handle,
                  */
                 BUG_ON(!new);
 
-                from = cluster_start;
-                to = cluster_end;
+                map_from = cluster_start;
+                map_to = cluster_end;
 
                 ret = ocfs2_map_page_blocks(page, p_blkno, inode,
-                                            cluster_start, cluster_end, 1);
+                                            cluster_start, cluster_end, new);
                 if (ret) {
                         mlog_errno(ret);
                         goto out;
@@ -1003,108 +1023,113 @@ static int ocfs2_write_data_page(struct inode *inode, handle_t *handle,
          */
         if (new && !PageUptodate(page))
                 ocfs2_clear_page_regions(page, OCFS2_SB(inode->i_sb),
-                                         wc->w_cpos, zero_from, zero_to);
+                                         cpos, user_data_from, user_data_to);
 
         flush_dcache_page(page);
 
-        if (ocfs2_should_order_data(inode)) {
-                ret = walk_page_buffers(handle,
-                                        page_buffers(page),
-                                        from, to, NULL,
-                                        ocfs2_journal_dirty_data);
-                if (ret < 0)
-                        mlog_errno(ret);
-        }
-
-        /*
-         * We don't use generic_commit_write() because we need to
-         * handle our own i_size update.
-         */
-        ret = block_commit_write(page, from, to);
-        if (ret)
-                mlog_errno(ret);
 out:
-
-        return copied ? copied : ret;
+        return ret;
 }
 
 /*
- * Do the actual write of some data into an inode. Optionally allocate
- * in order to fulfill the write.
- *
- * cpos is the logical cluster offset within the file to write at
- *
- * 'phys' is the physical mapping of that offset. a 'phys' value of
- * zero indicates that allocation is required. In this case, data_ac
- * and meta_ac should be valid (meta_ac can be null if metadata
- * allocation isn't required).
+ * This function will only grab one clusters worth of pages.
  */
-static ssize_t ocfs2_write(struct file *file, u32 phys, handle_t *handle,
-                           struct buffer_head *di_bh,
-                           struct ocfs2_alloc_context *data_ac,
-                           struct ocfs2_alloc_context *meta_ac,
-                           struct ocfs2_write_ctxt *wc)
+static int ocfs2_grab_pages_for_write(struct address_space *mapping,
+                                      struct ocfs2_write_ctxt *wc,
+                                      u32 cpos, loff_t user_pos, int new,
+                                      struct page *mmap_page)
 {
-        int ret, i, numpages = 1, new;
-        unsigned int copied = 0;
-        u32 tmp_pos;
-        u64 v_blkno, p_blkno;
-        struct address_space *mapping = file->f_mapping;
+        int ret = 0, i;
+        unsigned long start, target_index, index;
         struct inode *inode = mapping->host;
-        unsigned long index, start;
-        struct page **cpages;
 
-        new = phys == 0 ? 1 : 0;
+        target_index = user_pos >> PAGE_CACHE_SHIFT;
 
         /*
          * Figure out how many pages we'll be manipulating here. For
          * non allocating write, we just change the one
          * page. Otherwise, we'll need a whole clusters worth.
          */
-        if (new)
-                numpages = ocfs2_pages_per_cluster(inode->i_sb);
-
-        cpages = kzalloc(sizeof(*cpages) * numpages, GFP_NOFS);
-        if (!cpages) {
-                ret = -ENOMEM;
-                mlog_errno(ret);
-                return ret;
-        }
-
-        /*
-         * Fill our page array first. That way we've grabbed enough so
-         * that we can zero and flush if we error after adding the
-         * extent.
-         */
         if (new) {
-                start = ocfs2_align_clusters_to_page_index(inode->i_sb,
-                                                           wc->w_cpos);
-                v_blkno = ocfs2_clusters_to_blocks(inode->i_sb, wc->w_cpos);
+                wc->w_num_pages = ocfs2_pages_per_cluster(inode->i_sb);
+                start = ocfs2_align_clusters_to_page_index(inode->i_sb, cpos);
         } else {
-                start = wc->w_pos >> PAGE_CACHE_SHIFT;
-                v_blkno = wc->w_pos >> inode->i_sb->s_blocksize_bits;
+                wc->w_num_pages = 1;
+                start = target_index;
         }
 
-        for(i = 0; i < numpages; i++) {
+        for(i = 0; i < wc->w_num_pages; i++) {
                 index = start + i;
 
-                cpages[i] = find_or_create_page(mapping, index, GFP_NOFS);
-                if (!cpages[i]) {
-                        ret = -ENOMEM;
-                        mlog_errno(ret);
-                        goto out;
+                if (index == target_index && mmap_page) {
+                        /*
+                         * ocfs2_pagemkwrite() is a little different
+                         * and wants us to directly use the page
+                         * passed in.
+                         */
+                        lock_page(mmap_page);
+
+                        if (mmap_page->mapping != mapping) {
+                                unlock_page(mmap_page);
+                                /*
+                                 * Sanity check - the locking in
+                                 * ocfs2_pagemkwrite() should ensure
+                                 * that this code doesn't trigger.
+                                 */
+                                ret = -EINVAL;
+                                mlog_errno(ret);
+                                goto out;
+                        }
+
+                        page_cache_get(mmap_page);
+                        wc->w_pages[i] = mmap_page;
+                } else {
+                        wc->w_pages[i] = find_or_create_page(mapping, index,
+                                                             GFP_NOFS);
+                        if (!wc->w_pages[i]) {
+                                ret = -ENOMEM;
+                                mlog_errno(ret);
+                                goto out;
+                        }
                 }
+
+                if (index == target_index)
+                        wc->w_target_page = wc->w_pages[i];
         }
+out:
+        return ret;
+}
+
+/*
+ * Prepare a single cluster for write one cluster into the file.
+ */
+static int ocfs2_write_cluster(struct address_space *mapping,
+                               u32 phys, unsigned int unwritten,
+                               struct ocfs2_alloc_context *data_ac,
+                               struct ocfs2_alloc_context *meta_ac,
+                               struct ocfs2_write_ctxt *wc, u32 cpos,
+                               loff_t user_pos, unsigned user_len)
+{
+        int ret, i, new, should_zero = 0;
+        u64 v_blkno, p_blkno;
+        struct inode *inode = mapping->host;
+
+        new = phys == 0 ? 1 : 0;
+        if (new || unwritten)
+                should_zero = 1;
 
         if (new) {
+                u32 tmp_pos;
+
                 /*
                  * This is safe to call with the page locks - it won't take
                  * any additional semaphores or cluster locks.
                  */
-                tmp_pos = wc->w_cpos;
+                tmp_pos = cpos;
                 ret = ocfs2_do_extend_allocation(OCFS2_SB(inode->i_sb), inode,
-                                                 &tmp_pos, 1, di_bh, handle,
-                                                 data_ac, meta_ac, NULL);
+                                                 &tmp_pos, 1, 0, wc->w_di_bh,
+                                                 wc->w_handle, data_ac,
+                                                 meta_ac, NULL);
                 /*
                  * This shouldn't happen because we must have already
                  * calculated the correct meta data allocation required. The
@@ -1121,159 +1146,433 @@ static ssize_t ocfs2_write(struct file *file, u32 phys, handle_t *handle,
                         mlog_errno(ret);
                         goto out;
                 }
+        } else if (unwritten) {
+                ret = ocfs2_mark_extent_written(inode, wc->w_di_bh,
+                                                wc->w_handle, cpos, 1, phys,
+                                                meta_ac, &wc->w_dealloc);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto out;
+                }
         }
 
+        if (should_zero)
+                v_blkno = ocfs2_clusters_to_blocks(inode->i_sb, cpos);
+        else
+                v_blkno = user_pos >> inode->i_sb->s_blocksize_bits;
+
+        /*
+         * The only reason this should fail is due to an inability to
+         * find the extent added.
+         */
         ret = ocfs2_extent_map_get_blocks(inode, v_blkno, &p_blkno, NULL,
                                           NULL);
         if (ret < 0) {
-
-                /*
-                 * XXX: Should we go readonly here?
-                 */
-
-                mlog_errno(ret);
+                ocfs2_error(inode->i_sb, "Corrupting extend for inode %llu, "
+                            "at logical block %llu",
+                            (unsigned long long)OCFS2_I(inode)->ip_blkno,
+                            (unsigned long long)v_blkno);
                 goto out;
         }
 
         BUG_ON(p_blkno == 0);
 
-        for(i = 0; i < numpages; i++) {
-                ret = ocfs2_write_data_page(inode, handle, &p_blkno, cpages[i],
-                                            wc, new);
-                if (ret < 0) {
-                        mlog_errno(ret);
-                        goto out;
+        for(i = 0; i < wc->w_num_pages; i++) {
+                int tmpret;
+
+                tmpret = ocfs2_prepare_page_for_write(inode, &p_blkno, wc,
+                                                      wc->w_pages[i], cpos,
+                                                      user_pos, user_len,
+                                                      should_zero);
+                if (tmpret) {
+                        mlog_errno(tmpret);
+                        if (ret == 0)
+                                tmpret = ret;
                 }
-
-                copied += ret;
         }
 
+        /*
+         * We only have cleanup to do in case of allocating write.
+         */
+        if (ret && new)
+                ocfs2_write_failure(inode, wc, user_pos, user_len);
+
 out:
-        for(i = 0; i < numpages; i++) {
-                unlock_page(cpages[i]);
-                mark_page_accessed(cpages[i]);
-                page_cache_release(cpages[i]);
+
+        return ret;
+}
+
+static int ocfs2_write_cluster_by_desc(struct address_space *mapping,
+                                       struct ocfs2_alloc_context *data_ac,
+                                       struct ocfs2_alloc_context *meta_ac,
+                                       struct ocfs2_write_ctxt *wc,
+                                       loff_t pos, unsigned len)
+{
+        int ret, i;
+        struct ocfs2_write_cluster_desc *desc;
+
+        for (i = 0; i < wc->w_clen; i++) {
+                desc = &wc->w_desc[i];
+
+                ret = ocfs2_write_cluster(mapping, desc->c_phys,
+                                          desc->c_unwritten, data_ac, meta_ac,
+                                          wc, desc->c_cpos, pos, len);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
         }
-        kfree(cpages);
 
-        return copied ? copied : ret;
+        ret = 0;
+out:
+        return ret;
 }
 
-static void ocfs2_write_ctxt_init(struct ocfs2_write_ctxt *wc,
-                                  struct ocfs2_super *osb, loff_t pos,
-                                  size_t count, ocfs2_page_writer *cb,
-                                  void *cb_priv)
+/*
+ * ocfs2_write_end() wants to know which parts of the target page it
+ * should complete the write on. It's easiest to compute them ahead of
+ * time when a more complete view of the write is available.
+ */
+static void ocfs2_set_target_boundaries(struct ocfs2_super *osb,
+                                        struct ocfs2_write_ctxt *wc,
+                                        loff_t pos, unsigned len, int alloc)
 {
-        wc->w_count = count;
-        wc->w_pos = pos;
-        wc->w_cpos = wc->w_pos >> osb->s_clustersize_bits;
-        wc->w_finished_copy = 0;
+        struct ocfs2_write_cluster_desc *desc;
 
-        if (unlikely(PAGE_CACHE_SHIFT > osb->s_clustersize_bits))
-                wc->w_large_pages = 1;
-        else
-                wc->w_large_pages = 0;
+        wc->w_target_from = pos & (PAGE_CACHE_SIZE - 1);
+        wc->w_target_to = wc->w_target_from + len;
 
-        wc->w_write_data_page = cb;
-        wc->w_private = cb_priv;
+        if (alloc == 0)
+                return;
+
+        /*
+         * Allocating write - we may have different boundaries based
+         * on page size and cluster size.
+         *
+         * NOTE: We can no longer compute one value from the other as
+         * the actual write length and user provided length may be
+         * different.
+         */
+
+        if (wc->w_large_pages) {
+                /*
+                 * We only care about the 1st and last cluster within
+                 * our range and whether they should be zero'd or not. Either
+                 * value may be extended out to the start/end of a
+                 * newly allocated cluster.
+                 */
+                desc = &wc->w_desc[0];
+                if (ocfs2_should_zero_cluster(desc))
+                        ocfs2_figure_cluster_boundaries(osb,
+                                                        desc->c_cpos,
+                                                        &wc->w_target_from,
+                                                        NULL);
+
+                desc = &wc->w_desc[wc->w_clen - 1];
+                if (ocfs2_should_zero_cluster(desc))
+                        ocfs2_figure_cluster_boundaries(osb,
+                                                        desc->c_cpos,
+                                                        NULL,
+                                                        &wc->w_target_to);
+        } else {
+                wc->w_target_from = 0;
+                wc->w_target_to = PAGE_CACHE_SIZE;
+        }
 }
 
 /*
- * Write a cluster to an inode. The cluster may not be allocated yet,
- * in which case it will be. This only exists for buffered writes -
- * O_DIRECT takes a more "traditional" path through the kernel.
- *
- * The caller is responsible for incrementing pos, written counts, etc
+ * Populate each single-cluster write descriptor in the write context
+ * with information about the i/o to be done.
  *
- * For file systems that don't support sparse files, pre-allocation
- * and page zeroing up until cpos should be done prior to this
- * function call.
- *
- * Callers should be holding i_sem, and the rw cluster lock.
- *
- * Returns the number of user bytes written, or less than zero for
- * error.
+ * Returns the number of clusters that will have to be allocated, as
+ * well as a worst case estimate of the number of extent records that
+ * would have to be created during a write to an unwritten region.
  */
-ssize_t ocfs2_buffered_write_cluster(struct file *file, loff_t pos,
-                                     size_t count, ocfs2_page_writer *actor,
-                                     void *priv)
+static int ocfs2_populate_write_desc(struct inode *inode,
+                                     struct ocfs2_write_ctxt *wc,
+                                     unsigned int *clusters_to_alloc,
+                                     unsigned int *extents_to_split)
+{
+        int ret;
+        struct ocfs2_write_cluster_desc *desc;
+        unsigned int num_clusters = 0;
+        unsigned int ext_flags = 0;
+        u32 phys = 0;
+        int i;
+
+        *clusters_to_alloc = 0;
+        *extents_to_split = 0;
+
+        for (i = 0; i < wc->w_clen; i++) {
+                desc = &wc->w_desc[i];
+                desc->c_cpos = wc->w_cpos + i;
+
+                if (num_clusters == 0) {
+                        /*
+                         * Need to look up the next extent record.
+                         */
+                        ret = ocfs2_get_clusters(inode, desc->c_cpos, &phys,
+                                                 &num_clusters, &ext_flags);
+                        if (ret) {
+                                mlog_errno(ret);
+                                goto out;
+                        }
+
+                        /*
+                         * Assume worst case - that we're writing in
+                         * the middle of the extent.
+                         *
+                         * We can assume that the write proceeds from
+                         * left to right, in which case the extent
+                         * insert code is smart enough to coalesce the
+                         * next splits into the previous records created.
+                         */
+                        if (ext_flags & OCFS2_EXT_UNWRITTEN)
+                                *extents_to_split = *extents_to_split + 2;
+                } else if (phys) {
+                        /*
+                         * Only increment phys if it doesn't describe
+                         * a hole.
+                         */
+                        phys++;
+                }
+
+                desc->c_phys = phys;
+                if (phys == 0) {
+                        desc->c_new = 1;
+                        *clusters_to_alloc = *clusters_to_alloc + 1;
+                }
+                if (ext_flags & OCFS2_EXT_UNWRITTEN)
+                        desc->c_unwritten = 1;
+
+                num_clusters--;
+        }
+
+        ret = 0;
+out:
+        return ret;
+}
+
+int ocfs2_write_begin_nolock(struct address_space *mapping,
+                             loff_t pos, unsigned len, unsigned flags,
+                             struct page **pagep, void **fsdata,
+                             struct buffer_head *di_bh, struct page *mmap_page)
 {
         int ret, credits = OCFS2_INODE_UPDATE_CREDITS;
-        ssize_t written = 0;
-        u32 phys;
-        struct inode *inode = file->f_mapping->host;
+        unsigned int clusters_to_alloc, extents_to_split;
+        struct ocfs2_write_ctxt *wc;
+        struct inode *inode = mapping->host;
         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
-        struct buffer_head *di_bh = NULL;
         struct ocfs2_dinode *di;
         struct ocfs2_alloc_context *data_ac = NULL;
         struct ocfs2_alloc_context *meta_ac = NULL;
         handle_t *handle;
-        struct ocfs2_write_ctxt wc;
-
-        ocfs2_write_ctxt_init(&wc, osb, pos, count, actor, priv);
 
-        ret = ocfs2_meta_lock(inode, &di_bh, 1);
+        ret = ocfs2_alloc_write_ctxt(&wc, osb, pos, len, di_bh);
         if (ret) {
                 mlog_errno(ret);
-                goto out;
+                return ret;
         }
-        di = (struct ocfs2_dinode *)di_bh->b_data;
-
-        /*
-         * Take alloc sem here to prevent concurrent lookups. That way
-         * the mapping, zeroing and tree manipulation within
-         * ocfs2_write() will be safe against ->readpage(). This
-         * should also serve to lock out allocation from a shared
-         * writeable region.
-         */
-        down_write(&OCFS2_I(inode)->ip_alloc_sem);
 
-        ret = ocfs2_get_clusters(inode, wc.w_cpos, &phys, NULL, NULL);
+        ret = ocfs2_populate_write_desc(inode, wc, &clusters_to_alloc,
+                                        &extents_to_split);
         if (ret) {
                 mlog_errno(ret);
-                goto out_meta;
+                goto out;
         }
 
-        /* phys == 0 means that allocation is required. */
-        if (phys == 0) {
-                ret = ocfs2_lock_allocators(inode, di, 1, &data_ac, &meta_ac);
+        di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
+
+        /*
+         * We set w_target_from, w_target_to here so that
+         * ocfs2_write_end() knows which range in the target page to
+         * write out. An allocation requires that we write the entire
+         * cluster range.
+         */
+        if (clusters_to_alloc || extents_to_split) {
+                /*
+                 * XXX: We are stretching the limits of
+                 * ocfs2_lock_allocators(). It greatly over-estimates
+                 * the work to be done.
+                 */
+                ret = ocfs2_lock_allocators(inode, di, clusters_to_alloc,
+                                            extents_to_split, &data_ac, &meta_ac);
                 if (ret) {
                         mlog_errno(ret);
-                        goto out_meta;
+                        goto out;
                 }
 
-                credits = ocfs2_calc_extend_credits(inode->i_sb, di, 1);
-        }
+                credits = ocfs2_calc_extend_credits(inode->i_sb, di,
+                                                    clusters_to_alloc);
 
-        ret = ocfs2_data_lock(inode, 1);
-        if (ret) {
-                mlog_errno(ret);
-                goto out_meta;
         }
 
+        ocfs2_set_target_boundaries(osb, wc, pos, len,
+                                    clusters_to_alloc + extents_to_split);
+
         handle = ocfs2_start_trans(osb, credits);
         if (IS_ERR(handle)) {
                 ret = PTR_ERR(handle);
                 mlog_errno(ret);
-                goto out_data;
+                goto out;
         }
 
-        written = ocfs2_write(file, phys, handle, di_bh, data_ac,
-                              meta_ac, &wc);
-        if (written < 0) {
-                ret = written;
+        wc->w_handle = handle;
+
+        /*
+         * We don't want this to fail in ocfs2_write_end(), so do it
+         * here.
+         */
+        ret = ocfs2_journal_access(handle, inode, wc->w_di_bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
                 mlog_errno(ret);
                 goto out_commit;
         }
 
-        ret = ocfs2_journal_access(handle, inode, di_bh,
-                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        /*
+         * Fill our page array first. That way we've grabbed enough so
+         * that we can zero and flush if we error after adding the
+         * extent.
+         */
+        ret = ocfs2_grab_pages_for_write(mapping, wc, wc->w_cpos, pos,
+                                         clusters_to_alloc + extents_to_split,
+                                         mmap_page);
         if (ret) {
                 mlog_errno(ret);
                 goto out_commit;
         }
 
-        pos += written;
+        ret = ocfs2_write_cluster_by_desc(mapping, data_ac, meta_ac, wc, pos,
+                                          len);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+
+        if (data_ac)
+                ocfs2_free_alloc_context(data_ac);
+        if (meta_ac)
+                ocfs2_free_alloc_context(meta_ac);
+
+        *pagep = wc->w_target_page;
+        *fsdata = wc;
+        return 0;
+out_commit:
+        ocfs2_commit_trans(osb, handle);
+
+out:
+        ocfs2_free_write_ctxt(wc);
+
+        if (data_ac)
+                ocfs2_free_alloc_context(data_ac);
+        if (meta_ac)
+                ocfs2_free_alloc_context(meta_ac);
+        return ret;
+}
+
+int ocfs2_write_begin(struct file *file, struct address_space *mapping,
+                      loff_t pos, unsigned len, unsigned flags,
+                      struct page **pagep, void **fsdata)
+{
+        int ret;
+        struct buffer_head *di_bh = NULL;
+        struct inode *inode = mapping->host;
+
+        ret = ocfs2_meta_lock(inode, &di_bh, 1);
+        if (ret) {
+                mlog_errno(ret);
+                return ret;
+        }
+
+        /*
+         * Take alloc sem here to prevent concurrent lookups. That way
+         * the mapping, zeroing and tree manipulation within
+         * ocfs2_write() will be safe against ->readpage(). This
+         * should also serve to lock out allocation from a shared
+         * writeable region.
+         */
+        down_write(&OCFS2_I(inode)->ip_alloc_sem);
+
+        ret = ocfs2_data_lock(inode, 1);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_fail;
+        }
+
+        ret = ocfs2_write_begin_nolock(mapping, pos, len, flags, pagep,
+                                       fsdata, di_bh, NULL);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_fail_data;
+        }
+
+        brelse(di_bh);
+
+        return 0;
+
+out_fail_data:
+        ocfs2_data_unlock(inode, 1);
+out_fail:
+        up_write(&OCFS2_I(inode)->ip_alloc_sem);
+
+        brelse(di_bh);
+        ocfs2_meta_unlock(inode, 1);
+
+        return ret;
+}
+
+int ocfs2_write_end_nolock(struct address_space *mapping,
+                           loff_t pos, unsigned len, unsigned copied,
+                           struct page *page, void *fsdata)
+{
+        int i;
+        unsigned from, to, start = pos & (PAGE_CACHE_SIZE - 1);
+        struct inode *inode = mapping->host;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct ocfs2_write_ctxt *wc = fsdata;
+        struct ocfs2_dinode *di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
+        handle_t *handle = wc->w_handle;
+        struct page *tmppage;
+
+        if (unlikely(copied < len)) {
+                if (!PageUptodate(wc->w_target_page))
+                        copied = 0;
+
+                ocfs2_zero_new_buffers(wc->w_target_page, start+copied,
+                                       start+len);
+        }
+        flush_dcache_page(wc->w_target_page);
+
+        for(i = 0; i < wc->w_num_pages; i++) {
+                tmppage = wc->w_pages[i];
+
+                if (tmppage == wc->w_target_page) {
+                        from = wc->w_target_from;
+                        to = wc->w_target_to;
+
+                        BUG_ON(from > PAGE_CACHE_SIZE ||
+                               to > PAGE_CACHE_SIZE ||
+                               to < from);
+                } else {
+                        /*
+                         * Pages adjacent to the target (if any) imply
+                         * a hole-filling write in which case we want
+                         * to flush their entire range.
+                         */
+                        from = 0;
+                        to = PAGE_CACHE_SIZE;
+                }
+
+                if (ocfs2_should_order_data(inode))
+                        walk_page_buffers(wc->w_handle, page_buffers(tmppage),
+                                          from, to, NULL,
+                                          ocfs2_journal_dirty_data);
+
+                block_commit_write(tmppage, from, to);
+        }
+
+        pos += copied;
         if (pos > inode->i_size) {
                 i_size_write(inode, pos);
                 mark_inode_dirty(inode);
@@ -1283,29 +1582,31 @@ ssize_t ocfs2_buffered_write_cluster(struct file *file, loff_t pos,
         inode->i_mtime = inode->i_ctime = CURRENT_TIME;
         di->i_mtime = di->i_ctime = cpu_to_le64(inode->i_mtime.tv_sec);
         di->i_mtime_nsec = di->i_ctime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
+        ocfs2_journal_dirty(handle, wc->w_di_bh);
 
-        ret = ocfs2_journal_dirty(handle, di_bh);
-        if (ret)
-                mlog_errno(ret);
-
-out_commit:
         ocfs2_commit_trans(osb, handle);
 
-out_data:
-        ocfs2_data_unlock(inode, 1);
+        ocfs2_run_deallocs(osb, &wc->w_dealloc);
+
+        ocfs2_free_write_ctxt(wc);
+
+        return copied;
+}
+
+int ocfs2_write_end(struct file *file, struct address_space *mapping,
+                    loff_t pos, unsigned len, unsigned copied,
+                    struct page *page, void *fsdata)
+{
+        int ret;
+        struct inode *inode = mapping->host;
 
-out_meta:
+        ret = ocfs2_write_end_nolock(mapping, pos, len, copied, page, fsdata);
+
+        ocfs2_data_unlock(inode, 1);
         up_write(&OCFS2_I(inode)->ip_alloc_sem);
         ocfs2_meta_unlock(inode, 1);
 
-out:
-        brelse(di_bh);
-        if (data_ac)
-                ocfs2_free_alloc_context(data_ac);
-        if (meta_ac)
-                ocfs2_free_alloc_context(meta_ac);
-
-        return written ? written : ret;
+        return ret;
 }
 
 const struct address_space_operations ocfs2_aops = {
diff --git a/fs/ocfs2/aops.h b/fs/ocfs2/aops.h
index 45821d479b5..389579bd64e 100644
--- a/fs/ocfs2/aops.h
+++ b/fs/ocfs2/aops.h
@@ -42,57 +42,22 @@ int walk_page_buffers(	handle_t *handle,
                         int (*fn)(      handle_t *handle,
                                         struct buffer_head *bh));
 
-struct ocfs2_write_ctxt;
-typedef int (ocfs2_page_writer)(struct inode *, struct ocfs2_write_ctxt *,
-                                u64 *, unsigned int *, unsigned int *);
+int ocfs2_write_begin(struct file *file, struct address_space *mapping,
+                      loff_t pos, unsigned len, unsigned flags,
+                      struct page **pagep, void **fsdata);
 
-ssize_t ocfs2_buffered_write_cluster(struct file *file, loff_t pos,
-                                     size_t count, ocfs2_page_writer *actor,
-                                     void *priv);
+int ocfs2_write_end(struct file *file, struct address_space *mapping,
+                    loff_t pos, unsigned len, unsigned copied,
+                    struct page *page, void *fsdata);
 
-struct ocfs2_write_ctxt {
-        size_t                          w_count;
-        loff_t                          w_pos;
-        u32                             w_cpos;
-        unsigned int                    w_finished_copy;
+int ocfs2_write_end_nolock(struct address_space *mapping,
+                           loff_t pos, unsigned len, unsigned copied,
+                           struct page *page, void *fsdata);
 
-        /* This is true if page_size > cluster_size */
-        unsigned int                    w_large_pages;
-
-        /* Filler callback and private data */
-        ocfs2_page_writer               *w_write_data_page;
-        void                            *w_private;
-
-        /* Only valid for the filler callback */
-        struct page                     *w_this_page;
-        unsigned int                    w_this_page_new;
-};
-
-struct ocfs2_buffered_write_priv {
-        char                            *b_src_buf;
-        const struct iovec              *b_cur_iov; /* Current iovec */
-        size_t                          b_cur_off; /* Offset in the
-                                                    * current iovec */
-};
-int ocfs2_map_and_write_user_data(struct inode *inode,
-                                  struct ocfs2_write_ctxt *wc,
-                                  u64 *p_blkno,
-                                  unsigned int *ret_from,
-                                  unsigned int *ret_to);
-
-struct ocfs2_splice_write_priv {
-        struct splice_desc              *s_sd;
-        struct pipe_buffer              *s_buf;
-        struct pipe_inode_info          *s_pipe;
-        /* Neither offset value is ever larger than one page */
-        unsigned int                    s_offset;
-        unsigned int                    s_buf_offset;
-};
-int ocfs2_map_and_write_splice_data(struct inode *inode,
-                                    struct ocfs2_write_ctxt *wc,
-                                    u64 *p_blkno,
-                                    unsigned int *ret_from,
-                                    unsigned int *ret_to);
+int ocfs2_write_begin_nolock(struct address_space *mapping,
+                             loff_t pos, unsigned len, unsigned flags,
+                             struct page **pagep, void **fsdata,
+                             struct buffer_head *di_bh, struct page *mmap_page);
 
 /* all ocfs2_dio_end_io()'s fault */
 #define ocfs2_iocb_is_rw_locked(iocb) \
diff --git a/fs/ocfs2/cluster/heartbeat.c b/fs/ocfs2/cluster/heartbeat.c
index 979113479c6..2bd7f788cf3 100644
--- a/fs/ocfs2/cluster/heartbeat.c
+++ b/fs/ocfs2/cluster/heartbeat.c
@@ -1335,6 +1335,7 @@ static ssize_t o2hb_region_dev_write(struct o2hb_region *reg,
         ret = wait_event_interruptible(o2hb_steady_queue,
                                 atomic_read(&reg->hr_steady_iterations) == 0);
         if (ret) {
+                /* We got interrupted (hello ptrace!).  Clean up */
                 spin_lock(&o2hb_live_lock);
                 hb_task = reg->hr_task;
                 reg->hr_task = NULL;
@@ -1345,7 +1346,16 @@ static ssize_t o2hb_region_dev_write(struct o2hb_region *reg,
                 goto out;
         }
 
-        ret = count;
+        /* Ok, we were woken.  Make sure it wasn't by drop_item() */
+        spin_lock(&o2hb_live_lock);
+        hb_task = reg->hr_task;
+        spin_unlock(&o2hb_live_lock);
+
+        if (hb_task)
+                ret = count;
+        else
+                ret = -EIO;
+
 out:
         if (filp)
                 fput(filp);
@@ -1523,6 +1533,15 @@ static void o2hb_heartbeat_group_drop_item(struct config_group *group,
         if (hb_task)
                 kthread_stop(hb_task);
 
+        /*
+         * If we're racing a dev_write(), we need to wake them.  They will
+         * check reg->hr_task
+         */
+        if (atomic_read(&reg->hr_steady_iterations) != 0) {
+                atomic_set(&reg->hr_steady_iterations, 0);
+                wake_up(&o2hb_steady_queue);
+        }
+
         config_item_put(item);
 }
 
@@ -1665,7 +1684,67 @@ void o2hb_setup_callback(struct o2hb_callback_func *hc,
 }
 EXPORT_SYMBOL_GPL(o2hb_setup_callback);
 
-int o2hb_register_callback(struct o2hb_callback_func *hc)
+static struct o2hb_region *o2hb_find_region(const char *region_uuid)
+{
+        struct o2hb_region *p, *reg = NULL;
+
+        assert_spin_locked(&o2hb_live_lock);
+
+        list_for_each_entry(p, &o2hb_all_regions, hr_all_item) {
+                if (!strcmp(region_uuid, config_item_name(&p->hr_item))) {
+                        reg = p;
+                        break;
+                }
+        }
+
+        return reg;
+}
+
+static int o2hb_region_get(const char *region_uuid)
+{
+        int ret = 0;
+        struct o2hb_region *reg;
+
+        spin_lock(&o2hb_live_lock);
+
+        reg = o2hb_find_region(region_uuid);
+        if (!reg)
+                ret = -ENOENT;
+        spin_unlock(&o2hb_live_lock);
+
+        if (ret)
+                goto out;
+
+        ret = o2nm_depend_this_node();
+        if (ret)
+                goto out;
+
+        ret = o2nm_depend_item(&reg->hr_item);
+        if (ret)
+                o2nm_undepend_this_node();
+
+out:
+        return ret;
+}
+
+static void o2hb_region_put(const char *region_uuid)
+{
+        struct o2hb_region *reg;
+
+        spin_lock(&o2hb_live_lock);
+
+        reg = o2hb_find_region(region_uuid);
+
+        spin_unlock(&o2hb_live_lock);
+
+        if (reg) {
+                o2nm_undepend_item(&reg->hr_item);
+                o2nm_undepend_this_node();
+        }
+}
+
+int o2hb_register_callback(const char *region_uuid,
+                           struct o2hb_callback_func *hc)
 {
         struct o2hb_callback_func *tmp;
         struct list_head *iter;
@@ -1681,6 +1760,12 @@ int o2hb_register_callback(struct o2hb_callback_func *hc)
                 goto out;
         }
 
+        if (region_uuid) {
+                ret = o2hb_region_get(region_uuid);
+                if (ret)
+                        goto out;
+        }
+
         down_write(&o2hb_callback_sem);
 
         list_for_each(iter, &hbcall->list) {
@@ -1702,16 +1787,21 @@ out:
 }
 EXPORT_SYMBOL_GPL(o2hb_register_callback);
 
-void o2hb_unregister_callback(struct o2hb_callback_func *hc)
+void o2hb_unregister_callback(const char *region_uuid,
+                              struct o2hb_callback_func *hc)
 {
         BUG_ON(hc->hc_magic != O2HB_CB_MAGIC);
 
         mlog(ML_HEARTBEAT, "on behalf of %p for funcs %p\n",
              __builtin_return_address(0), hc);
 
+        /* XXX Can this happen _with_ a region reference? */
         if (list_empty(&hc->hc_item))
                 return;
 
+        if (region_uuid)
+                o2hb_region_put(region_uuid);
+
         down_write(&o2hb_callback_sem);
 
         list_del_init(&hc->hc_item);
diff --git a/fs/ocfs2/cluster/heartbeat.h b/fs/ocfs2/cluster/heartbeat.h
index cc6d40b3977..35397dd5ecd 100644
--- a/fs/ocfs2/cluster/heartbeat.h
+++ b/fs/ocfs2/cluster/heartbeat.h
@@ -69,8 +69,10 @@ void o2hb_setup_callback(struct o2hb_callback_func *hc,
                          o2hb_cb_func *func,
                          void *data,
                          int priority);
-int o2hb_register_callback(struct o2hb_callback_func *hc);
-void o2hb_unregister_callback(struct o2hb_callback_func *hc);
+int o2hb_register_callback(const char *region_uuid,
+                           struct o2hb_callback_func *hc);
+void o2hb_unregister_callback(const char *region_uuid,
+                              struct o2hb_callback_func *hc);
 void o2hb_fill_node_map(unsigned long *map,
                         unsigned bytes);
 void o2hb_init(void);
diff --git a/fs/ocfs2/cluster/masklog.c b/fs/ocfs2/cluster/masklog.c
index 2b205f5d579..e9e042b93db 100644
--- a/fs/ocfs2/cluster/masklog.c
+++ b/fs/ocfs2/cluster/masklog.c
@@ -74,7 +74,6 @@ struct mlog_attribute {
 #define define_mask(_name) {                    \
         .attr = {                               \
                 .name = #_name,                 \
-                .owner = THIS_MODULE,           \
                 .mode = S_IRUGO | S_IWUSR,      \
         },                                      \
         .mask = ML_##_name,                     \
diff --git a/fs/ocfs2/cluster/nodemanager.c b/fs/ocfs2/cluster/nodemanager.c
index 9f5ad0f01ce..af2070da308 100644
--- a/fs/ocfs2/cluster/nodemanager.c
+++ b/fs/ocfs2/cluster/nodemanager.c
@@ -900,6 +900,46 @@ static struct o2nm_cluster_group o2nm_cluster_group = {
         },
 };
 
+int o2nm_depend_item(struct config_item *item)
+{
+        return configfs_depend_item(&o2nm_cluster_group.cs_subsys, item);
+}
+
+void o2nm_undepend_item(struct config_item *item)
+{
+        configfs_undepend_item(&o2nm_cluster_group.cs_subsys, item);
+}
+
+int o2nm_depend_this_node(void)
+{
+        int ret = 0;
+        struct o2nm_node *local_node;
+
+        local_node = o2nm_get_node_by_num(o2nm_this_node());
+        if (!local_node) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        ret = o2nm_depend_item(&local_node->nd_item);
+        o2nm_node_put(local_node);
+
+out:
+        return ret;
+}
+
+void o2nm_undepend_this_node(void)
+{
+        struct o2nm_node *local_node;
+
+        local_node = o2nm_get_node_by_num(o2nm_this_node());
+        BUG_ON(!local_node);
+
+        o2nm_undepend_item(&local_node->nd_item);
+        o2nm_node_put(local_node);
+}
+
+
 static void __exit exit_o2nm(void)
 {
         if (ocfs2_table_header)
@@ -934,7 +974,7 @@ static int __init init_o2nm(void)
                 goto out_sysctl;
 
         config_group_init(&o2nm_cluster_group.cs_subsys.su_group);
-        init_MUTEX(&o2nm_cluster_group.cs_subsys.su_sem);
+        mutex_init(&o2nm_cluster_group.cs_subsys.su_mutex);
         ret = configfs_register_subsystem(&o2nm_cluster_group.cs_subsys);
         if (ret) {
                 printk(KERN_ERR "nodemanager: Registration returned %d\n", ret);
diff --git a/fs/ocfs2/cluster/nodemanager.h b/fs/ocfs2/cluster/nodemanager.h
index 070522138ae..7c860361b8d 100644
--- a/fs/ocfs2/cluster/nodemanager.h
+++ b/fs/ocfs2/cluster/nodemanager.h
@@ -77,4 +77,9 @@ struct o2nm_node *o2nm_get_node_by_ip(__be32 addr);
 void o2nm_node_get(struct o2nm_node *node);
 void o2nm_node_put(struct o2nm_node *node);
 
+int o2nm_depend_item(struct config_item *item);
+void o2nm_undepend_item(struct config_item *item);
+int o2nm_depend_this_node(void);
+void o2nm_undepend_this_node(void);
+
 #endif /* O2CLUSTER_NODEMANAGER_H */
diff --git a/fs/ocfs2/cluster/tcp.c b/fs/ocfs2/cluster/tcp.c
index 0b229a9c795..f0bdfd944c4 100644
--- a/fs/ocfs2/cluster/tcp.c
+++ b/fs/ocfs2/cluster/tcp.c
@@ -261,14 +261,12 @@ out:
 
 static void o2net_complete_nodes_nsw(struct o2net_node *nn)
 {
-        struct list_head *iter, *tmp;
+        struct o2net_status_wait *nsw, *tmp;
         unsigned int num_kills = 0;
-        struct o2net_status_wait *nsw;
 
         assert_spin_locked(&nn->nn_lock);
 
-        list_for_each_safe(iter, tmp, &nn->nn_status_list) {
-                nsw = list_entry(iter, struct o2net_status_wait, ns_node_item);
+        list_for_each_entry_safe(nsw, tmp, &nn->nn_status_list, ns_node_item) {
                 o2net_complete_nsw_locked(nn, nsw, O2NET_ERR_DIED, 0);
                 num_kills++;
         }
@@ -764,13 +762,10 @@ EXPORT_SYMBOL_GPL(o2net_register_handler);
 
 void o2net_unregister_handler_list(struct list_head *list)
 {
-        struct list_head *pos, *n;
-        struct o2net_msg_handler *nmh;
+        struct o2net_msg_handler *nmh, *n;
 
         write_lock(&o2net_handler_lock);
-        list_for_each_safe(pos, n, list) {
-                nmh = list_entry(pos, struct o2net_msg_handler,
-                                 nh_unregister_item);
+        list_for_each_entry_safe(nmh, n, list, nh_unregister_item) {
                 mlog(ML_TCP, "unregistering handler func %p type %u key %08x\n",
                      nmh->nh_func, nmh->nh_msg_type, nmh->nh_key);
                 rb_erase(&nmh->nh_node, &o2net_handler_tree);
@@ -1638,8 +1633,8 @@ static void o2net_hb_node_up_cb(struct o2nm_node *node, int node_num,
 
 void o2net_unregister_hb_callbacks(void)
 {
-        o2hb_unregister_callback(&o2net_hb_up);
-        o2hb_unregister_callback(&o2net_hb_down);
+        o2hb_unregister_callback(NULL, &o2net_hb_up);
+        o2hb_unregister_callback(NULL, &o2net_hb_down);
 }
 
 int o2net_register_hb_callbacks(void)
@@ -1651,9 +1646,9 @@ int o2net_register_hb_callbacks(void)
         o2hb_setup_callback(&o2net_hb_up, O2HB_NODE_UP_CB,
                             o2net_hb_node_up_cb, NULL, O2NET_HB_PRI);
 
-        ret = o2hb_register_callback(&o2net_hb_up);
+        ret = o2hb_register_callback(NULL, &o2net_hb_up);
         if (ret == 0)
-                ret = o2hb_register_callback(&o2net_hb_down);
+                ret = o2hb_register_callback(NULL, &o2net_hb_down);
 
         if (ret)
                 o2net_unregister_hb_callbacks();
diff --git a/fs/ocfs2/dir.c b/fs/ocfs2/dir.c
index c441ef1f2ba..0d5fdde959c 100644
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -368,7 +368,7 @@ int ocfs2_do_extend_dir(struct super_block *sb,
                 u32 offset = OCFS2_I(dir)->ip_clusters;
 
                 status = ocfs2_do_extend_allocation(OCFS2_SB(sb), dir, &offset,
-                                                    1, parent_fe_bh, handle,
+                                                    1, 0, parent_fe_bh, handle,
                                                     data_ac, meta_ac, NULL);
                 BUG_ON(status == -EAGAIN);
                 if (status < 0) {
diff --git a/fs/ocfs2/dlm/dlmdomain.c b/fs/ocfs2/dlm/dlmdomain.c
index d836b98dd99..6954565b8cc 100644
--- a/fs/ocfs2/dlm/dlmdomain.c
+++ b/fs/ocfs2/dlm/dlmdomain.c
@@ -1128,8 +1128,8 @@ bail:
 
 static void dlm_unregister_domain_handlers(struct dlm_ctxt *dlm)
 {
-        o2hb_unregister_callback(&dlm->dlm_hb_up);
-        o2hb_unregister_callback(&dlm->dlm_hb_down);
+        o2hb_unregister_callback(NULL, &dlm->dlm_hb_up);
+        o2hb_unregister_callback(NULL, &dlm->dlm_hb_down);
         o2net_unregister_handler_list(&dlm->dlm_domain_handlers);
 }
 
@@ -1141,13 +1141,13 @@ static int dlm_register_domain_handlers(struct dlm_ctxt *dlm)
 
         o2hb_setup_callback(&dlm->dlm_hb_down, O2HB_NODE_DOWN_CB,
                             dlm_hb_node_down_cb, dlm, DLM_HB_NODE_DOWN_PRI);
-        status = o2hb_register_callback(&dlm->dlm_hb_down);
+        status = o2hb_register_callback(NULL, &dlm->dlm_hb_down);
         if (status)
                 goto bail;
 
         o2hb_setup_callback(&dlm->dlm_hb_up, O2HB_NODE_UP_CB,
                             dlm_hb_node_up_cb, dlm, DLM_HB_NODE_UP_PRI);
-        status = o2hb_register_callback(&dlm->dlm_hb_up);
+        status = o2hb_register_callback(NULL, &dlm->dlm_hb_up);
         if (status)
                 goto bail;
 
diff --git a/fs/ocfs2/dlm/dlmmaster.c b/fs/ocfs2/dlm/dlmmaster.c
index 6edffca99d9..65b2b9b9268 100644
--- a/fs/ocfs2/dlm/dlmmaster.c
+++ b/fs/ocfs2/dlm/dlmmaster.c
@@ -192,25 +192,20 @@ static void dlm_print_one_mle(struct dlm_master_list_entry *mle)
 static void dlm_dump_mles(struct dlm_ctxt *dlm)
 {
         struct dlm_master_list_entry *mle;
-        struct list_head *iter;
         
         mlog(ML_NOTICE, "dumping all mles for domain %s:\n", dlm->name);
         spin_lock(&dlm->master_lock);
-        list_for_each(iter, &dlm->master_list) {
-                mle = list_entry(iter, struct dlm_master_list_entry, list);
+        list_for_each_entry(mle, &dlm->master_list, list)
                 dlm_print_one_mle(mle);
-        }
         spin_unlock(&dlm->master_lock);
 }
 
 int dlm_dump_all_mles(const char __user *data, unsigned int len)
 {
-        struct list_head *iter;
         struct dlm_ctxt *dlm;
 
         spin_lock(&dlm_domain_lock);
-        list_for_each(iter, &dlm_domains) {
-                dlm = list_entry (iter, struct dlm_ctxt, list);
+        list_for_each_entry(dlm, &dlm_domains, list) {
                 mlog(ML_NOTICE, "found dlm: %p, name=%s\n", dlm, dlm->name);
                 dlm_dump_mles(dlm);
         }
@@ -454,12 +449,10 @@ static int dlm_find_mle(struct dlm_ctxt *dlm,
                         char *name, unsigned int namelen)
 {
         struct dlm_master_list_entry *tmpmle;
-        struct list_head *iter;
 
         assert_spin_locked(&dlm->master_lock);
 
-        list_for_each(iter, &dlm->master_list) {
-                tmpmle = list_entry(iter, struct dlm_master_list_entry, list);
+        list_for_each_entry(tmpmle, &dlm->master_list, list) {
                 if (!dlm_mle_equal(dlm, tmpmle, name, namelen))
                         continue;
                 dlm_get_mle(tmpmle);
@@ -472,13 +465,10 @@ static int dlm_find_mle(struct dlm_ctxt *dlm,
 void dlm_hb_event_notify_attached(struct dlm_ctxt *dlm, int idx, int node_up)
 {
         struct dlm_master_list_entry *mle;
-        struct list_head *iter;
 
         assert_spin_locked(&dlm->spinlock);
         
-        list_for_each(iter, &dlm->mle_hb_events) {
-                mle = list_entry(iter, struct dlm_master_list_entry, 
-                                 hb_events);
+        list_for_each_entry(mle, &dlm->mle_hb_events, hb_events) {
                 if (node_up)
                         dlm_mle_node_up(dlm, mle, NULL, idx);
                 else
@@ -2434,7 +2424,7 @@ static int dlm_is_lockres_migrateable(struct dlm_ctxt *dlm,
         int ret;
         int i;
         int count = 0;
-        struct list_head *queue, *iter;
+        struct list_head *queue;
         struct dlm_lock *lock;
 
         assert_spin_locked(&res->spinlock);
@@ -2453,8 +2443,7 @@ static int dlm_is_lockres_migrateable(struct dlm_ctxt *dlm,
         ret = 0;
         queue = &res->granted;
         for (i = 0; i < 3; i++) {
-                list_for_each(iter, queue) {
-                        lock = list_entry(iter, struct dlm_lock, list);
+                list_for_each_entry(lock, queue, list) {
                         ++count;
                         if (lock->ml.node == dlm->node_num) {
                                 mlog(0, "found a lock owned by this node still "
@@ -2923,18 +2912,16 @@ again:
 static void dlm_remove_nonlocal_locks(struct dlm_ctxt *dlm,
                                       struct dlm_lock_resource *res)
 {
-        struct list_head *iter, *iter2;
         struct list_head *queue = &res->granted;
         int i, bit;
-        struct dlm_lock *lock;
+        struct dlm_lock *lock, *next;
 
         assert_spin_locked(&res->spinlock);
 
         BUG_ON(res->owner == dlm->node_num);
 
         for (i=0; i<3; i++) {
-                list_for_each_safe(iter, iter2, queue) {
-                        lock = list_entry (iter, struct dlm_lock, list);
+                list_for_each_entry_safe(lock, next, queue, list) {
                         if (lock->ml.node != dlm->node_num) {
                                 mlog(0, "putting lock for node %u\n",
                                      lock->ml.node);
@@ -2976,7 +2963,6 @@ static u8 dlm_pick_migration_target(struct dlm_ctxt *dlm,
 {
         int i;
         struct list_head *queue = &res->granted;
-        struct list_head *iter;
         struct dlm_lock *lock;
         int nodenum;
 
@@ -2984,10 +2970,9 @@ static u8 dlm_pick_migration_target(struct dlm_ctxt *dlm,
 
         spin_lock(&res->spinlock);
         for (i=0; i<3; i++) {
-                list_for_each(iter, queue) {
+                list_for_each_entry(lock, queue, list) {
                         /* up to the caller to make sure this node
                          * is alive */
-                        lock = list_entry (iter, struct dlm_lock, list);
                         if (lock->ml.node != dlm->node_num) {
                                 spin_unlock(&res->spinlock);
                                 return lock->ml.node;
@@ -3234,8 +3219,7 @@ static int dlm_add_migration_mle(struct dlm_ctxt *dlm,
 
 void dlm_clean_master_list(struct dlm_ctxt *dlm, u8 dead_node)
 {
-        struct list_head *iter, *iter2;
-        struct dlm_master_list_entry *mle;
+        struct dlm_master_list_entry *mle, *next;
         struct dlm_lock_resource *res;
         unsigned int hash;
 
@@ -3245,9 +3229,7 @@ top:
 
         /* clean the master list */
         spin_lock(&dlm->master_lock);
-        list_for_each_safe(iter, iter2, &dlm->master_list) {
-                mle = list_entry(iter, struct dlm_master_list_entry, list);
-
+        list_for_each_entry_safe(mle, next, &dlm->master_list, list) {
                 BUG_ON(mle->type != DLM_MLE_BLOCK &&
                        mle->type != DLM_MLE_MASTER &&
                        mle->type != DLM_MLE_MIGRATION);
diff --git a/fs/ocfs2/dlm/dlmrecovery.c b/fs/ocfs2/dlm/dlmrecovery.c
index 671c4ed58ee..a2c33160bfd 100644
--- a/fs/ocfs2/dlm/dlmrecovery.c
+++ b/fs/ocfs2/dlm/dlmrecovery.c
@@ -158,8 +158,7 @@ void dlm_dispatch_work(struct work_struct *work)
         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;
+        struct dlm_work_item *item, *next;
         dlm_workfunc_t *workfunc;
         int tot=0;
 
@@ -167,13 +166,12 @@ void dlm_dispatch_work(struct work_struct *work)
         list_splice_init(&dlm->work_list, &tmp_list);
         spin_unlock(&dlm->work_lock);
 
-        list_for_each_safe(iter, iter2, &tmp_list) {
+        list_for_each_entry(item, &tmp_list, list) {
                 tot++;
         }
         mlog(0, "%s: work thread has %d work items\n", dlm->name, tot);
 
-        list_for_each_safe(iter, iter2, &tmp_list) {
-                item = list_entry(iter, struct dlm_work_item, list);
+        list_for_each_entry_safe(item, next, &tmp_list, list) {
                 workfunc = item->func;
                 list_del_init(&item->list);
 
@@ -549,7 +547,6 @@ static int dlm_remaster_locks(struct dlm_ctxt *dlm, u8 dead_node)
 {
         int status = 0;
         struct dlm_reco_node_data *ndata;
-        struct list_head *iter;
         int all_nodes_done;
         int destroy = 0;
         int pass = 0;
@@ -567,8 +564,7 @@ static int dlm_remaster_locks(struct dlm_ctxt *dlm, u8 dead_node)
 
         /* safe to access the node data list without a lock, since this
          * process is the only one to change the list */
-        list_for_each(iter, &dlm->reco.node_data) {
-                ndata = list_entry (iter, struct dlm_reco_node_data, list);
+        list_for_each_entry(ndata, &dlm->reco.node_data, list) {
                 BUG_ON(ndata->state != DLM_RECO_NODE_DATA_INIT);
                 ndata->state = DLM_RECO_NODE_DATA_REQUESTING;
 
@@ -655,9 +651,7 @@ static int dlm_remaster_locks(struct dlm_ctxt *dlm, u8 dead_node)
                  * done, or if anyone died */
                 all_nodes_done = 1;
                 spin_lock(&dlm_reco_state_lock);
-                list_for_each(iter, &dlm->reco.node_data) {
-                        ndata = list_entry (iter, struct dlm_reco_node_data, list);
-
+                list_for_each_entry(ndata, &dlm->reco.node_data, list) {
                         mlog(0, "checking recovery state of node %u\n",
                              ndata->node_num);
                         switch (ndata->state) {
@@ -774,16 +768,14 @@ static int dlm_init_recovery_area(struct dlm_ctxt *dlm, u8 dead_node)
 
 static void dlm_destroy_recovery_area(struct dlm_ctxt *dlm, u8 dead_node)
 {
-        struct list_head *iter, *iter2;
-        struct dlm_reco_node_data *ndata;
+        struct dlm_reco_node_data *ndata, *next;
         LIST_HEAD(tmplist);
 
         spin_lock(&dlm_reco_state_lock);
         list_splice_init(&dlm->reco.node_data, &tmplist);
         spin_unlock(&dlm_reco_state_lock);
 
-        list_for_each_safe(iter, iter2, &tmplist) {
-                ndata = list_entry (iter, struct dlm_reco_node_data, list);
+        list_for_each_entry_safe(ndata, next, &tmplist, list) {
                 list_del_init(&ndata->list);
                 kfree(ndata);
         }
@@ -876,7 +868,6 @@ static void dlm_request_all_locks_worker(struct dlm_work_item *item, void *data)
         struct dlm_lock_resource *res;
         struct dlm_ctxt *dlm;
         LIST_HEAD(resources);
-        struct list_head *iter;
         int ret;
         u8 dead_node, reco_master;
         int skip_all_done = 0;
@@ -920,8 +911,7 @@ static void dlm_request_all_locks_worker(struct dlm_work_item *item, void *data)
 
         /* any errors returned will be due to the new_master dying,
          * the dlm_reco_thread should detect this */
-        list_for_each(iter, &resources) {
-                res = list_entry (iter, struct dlm_lock_resource, recovering);
+        list_for_each_entry(res, &resources, recovering) {
                 ret = dlm_send_one_lockres(dlm, res, mres, reco_master,
                                         DLM_MRES_RECOVERY);
                 if (ret < 0) {
@@ -983,7 +973,6 @@ int dlm_reco_data_done_handler(struct o2net_msg *msg, u32 len, void *data,
 {
         struct dlm_ctxt *dlm = data;
         struct dlm_reco_data_done *done = (struct dlm_reco_data_done *)msg->buf;
-        struct list_head *iter;
         struct dlm_reco_node_data *ndata = NULL;
         int ret = -EINVAL;
 
@@ -1000,8 +989,7 @@ int dlm_reco_data_done_handler(struct o2net_msg *msg, u32 len, void *data,
                         dlm->reco.dead_node, done->node_idx, dlm->node_num);
 
         spin_lock(&dlm_reco_state_lock);
-        list_for_each(iter, &dlm->reco.node_data) {
-                ndata = list_entry (iter, struct dlm_reco_node_data, list);
+        list_for_each_entry(ndata, &dlm->reco.node_data, list) {
                 if (ndata->node_num != done->node_idx)
                         continue;
 
@@ -1049,13 +1037,11 @@ static void dlm_move_reco_locks_to_list(struct dlm_ctxt *dlm,
                                         struct list_head *list,
                                         u8 dead_node)
 {
-        struct dlm_lock_resource *res;
-        struct list_head *iter, *iter2;
+        struct dlm_lock_resource *res, *next;
         struct dlm_lock *lock;
 
         spin_lock(&dlm->spinlock);
-        list_for_each_safe(iter, iter2, &dlm->reco.resources) {
-                res = list_entry (iter, struct dlm_lock_resource, recovering);
+        list_for_each_entry_safe(res, next, &dlm->reco.resources, recovering) {
                 /* always prune any $RECOVERY entries for dead nodes,
                  * otherwise hangs can occur during later recovery */
                 if (dlm_is_recovery_lock(res->lockname.name,
@@ -1169,7 +1155,7 @@ static void dlm_init_migratable_lockres(struct dlm_migratable_lockres *mres,
                                         u8 flags, u8 master)
 {
         /* mres here is one full page */
-        memset(mres, 0, PAGE_SIZE);
+        clear_page(mres);
         mres->lockname_len = namelen;
         memcpy(mres->lockname, lockname, namelen);
         mres->num_locks = 0;
@@ -1252,7 +1238,7 @@ int dlm_send_one_lockres(struct dlm_ctxt *dlm, struct dlm_lock_resource *res,
                          struct dlm_migratable_lockres *mres,
                          u8 send_to, u8 flags)
 {
-        struct list_head *queue, *iter;
+        struct list_head *queue;
         int total_locks, i;
         u64 mig_cookie = 0;
         struct dlm_lock *lock;
@@ -1278,9 +1264,7 @@ int dlm_send_one_lockres(struct dlm_ctxt *dlm, struct dlm_lock_resource *res,
         total_locks = 0;
         for (i=DLM_GRANTED_LIST; i<=DLM_BLOCKED_LIST; i++) {
                 queue = dlm_list_idx_to_ptr(res, i);
-                list_for_each(iter, queue) {
-                        lock = list_entry (iter, struct dlm_lock, list);
-
+                list_for_each_entry(lock, queue, list) {
                         /* add another lock. */
                         total_locks++;
                         if (!dlm_add_lock_to_array(lock, mres, i))
@@ -1717,7 +1701,6 @@ static int dlm_process_recovery_data(struct dlm_ctxt *dlm,
         struct dlm_lockstatus *lksb = NULL;
         int ret = 0;
         int i, j, bad;
-        struct list_head *iter;
         struct dlm_lock *lock = NULL;
         u8 from = O2NM_MAX_NODES;
         unsigned int added = 0;
@@ -1755,8 +1738,7 @@ static int dlm_process_recovery_data(struct dlm_ctxt *dlm,
                         spin_lock(&res->spinlock);
                         for (j = DLM_GRANTED_LIST; j <= DLM_BLOCKED_LIST; j++) {
                                 tmpq = dlm_list_idx_to_ptr(res, j);
-                                list_for_each(iter, tmpq) {
-                                        lock = list_entry (iter, struct dlm_lock, list);
+                                list_for_each_entry(lock, tmpq, list) {
                                         if (lock->ml.cookie != ml->cookie)
                                                 lock = NULL;
                                         else
@@ -1930,8 +1912,8 @@ void dlm_move_lockres_to_recovery_list(struct dlm_ctxt *dlm,
                                        struct dlm_lock_resource *res)
 {
         int i;
-        struct list_head *queue, *iter, *iter2;
-        struct dlm_lock *lock;
+        struct list_head *queue;
+        struct dlm_lock *lock, *next;
 
         res->state |= DLM_LOCK_RES_RECOVERING;
         if (!list_empty(&res->recovering)) {
@@ -1947,8 +1929,7 @@ void dlm_move_lockres_to_recovery_list(struct dlm_ctxt *dlm,
         /* find any pending locks and put them back on proper list */
         for (i=DLM_BLOCKED_LIST; i>=DLM_GRANTED_LIST; i--) {
                 queue = dlm_list_idx_to_ptr(res, i);
-                list_for_each_safe(iter, iter2, queue) {
-                        lock = list_entry (iter, struct dlm_lock, list);
+                list_for_each_entry_safe(lock, next, queue, list) {
                         dlm_lock_get(lock);
                         if (lock->convert_pending) {
                                 /* move converting lock back to granted */
@@ -2013,18 +1994,15 @@ static void dlm_finish_local_lockres_recovery(struct dlm_ctxt *dlm,
                                               u8 dead_node, u8 new_master)
 {
         int i;
-        struct list_head *iter, *iter2;
         struct hlist_node *hash_iter;
         struct hlist_head *bucket;
-
-        struct dlm_lock_resource *res;
+        struct dlm_lock_resource *res, *next;
 
         mlog_entry_void();
 
         assert_spin_locked(&dlm->spinlock);
 
-        list_for_each_safe(iter, iter2, &dlm->reco.resources) {
-                res = list_entry (iter, struct dlm_lock_resource, recovering);
+        list_for_each_entry_safe(res, next, &dlm->reco.resources, recovering) {
                 if (res->owner == dead_node) {
                         list_del_init(&res->recovering);
                         spin_lock(&res->spinlock);
@@ -2099,7 +2077,7 @@ static inline int dlm_lvb_needs_invalidation(struct dlm_lock *lock, int local)
 static void dlm_revalidate_lvb(struct dlm_ctxt *dlm,
                                struct dlm_lock_resource *res, u8 dead_node)
 {
-        struct list_head *iter, *queue;
+        struct list_head *queue;
         struct dlm_lock *lock;
         int blank_lvb = 0, local = 0;
         int i;
@@ -2121,8 +2099,7 @@ static void dlm_revalidate_lvb(struct dlm_ctxt *dlm,
 
         for (i=DLM_GRANTED_LIST; i<=DLM_CONVERTING_LIST; i++) {
                 queue = dlm_list_idx_to_ptr(res, i);
-                list_for_each(iter, queue) {
-                        lock = list_entry (iter, struct dlm_lock, list);
+                list_for_each_entry(lock, queue, list) {
                         if (lock->ml.node == search_node) {
                                 if (dlm_lvb_needs_invalidation(lock, local)) {
                                         /* zero the lksb lvb and lockres lvb */
@@ -2143,8 +2120,7 @@ static void dlm_revalidate_lvb(struct dlm_ctxt *dlm,
 static void dlm_free_dead_locks(struct dlm_ctxt *dlm,
                                 struct dlm_lock_resource *res, u8 dead_node)
 {
-        struct list_head *iter, *tmpiter;
-        struct dlm_lock *lock;
+        struct dlm_lock *lock, *next;
         unsigned int freed = 0;
 
         /* this node is the lockres master:
@@ -2155,24 +2131,21 @@ static void dlm_free_dead_locks(struct dlm_ctxt *dlm,
         assert_spin_locked(&res->spinlock);
 
         /* TODO: check pending_asts, pending_basts here */
-        list_for_each_safe(iter, tmpiter, &res->granted) {
-                lock = list_entry (iter, struct dlm_lock, list);
+        list_for_each_entry_safe(lock, next, &res->granted, list) {
                 if (lock->ml.node == dead_node) {
                         list_del_init(&lock->list);
                         dlm_lock_put(lock);
                         freed++;
                 }
         }
-        list_for_each_safe(iter, tmpiter, &res->converting) {
-                lock = list_entry (iter, struct dlm_lock, list);
+        list_for_each_entry_safe(lock, next, &res->converting, list) {
                 if (lock->ml.node == dead_node) {
                         list_del_init(&lock->list);
                         dlm_lock_put(lock);
                         freed++;
                 }
         }
-        list_for_each_safe(iter, tmpiter, &res->blocked) {
-                lock = list_entry (iter, struct dlm_lock, list);
+        list_for_each_entry_safe(lock, next, &res->blocked, list) {
                 if (lock->ml.node == dead_node) {
                         list_del_init(&lock->list);
                         dlm_lock_put(lock);
diff --git a/fs/ocfs2/dlmglue.c b/fs/ocfs2/dlmglue.c
index d1bd305ef0d..f71250ed166 100644
--- a/fs/ocfs2/dlmglue.c
+++ b/fs/ocfs2/dlmglue.c
@@ -600,15 +600,13 @@ static inline int ocfs2_highest_compat_lock_level(int level)
 static void lockres_set_flags(struct ocfs2_lock_res *lockres,
                               unsigned long newflags)
 {
-        struct list_head *pos, *tmp;
-        struct ocfs2_mask_waiter *mw;
+        struct ocfs2_mask_waiter *mw, *tmp;
 
         assert_spin_locked(&lockres->l_lock);
 
         lockres->l_flags = newflags;
 
-        list_for_each_safe(pos, tmp, &lockres->l_mask_waiters) {
-                mw = list_entry(pos, struct ocfs2_mask_waiter, mw_item);
+        list_for_each_entry_safe(mw, tmp, &lockres->l_mask_waiters, mw_item) {
                 if ((lockres->l_flags & mw->mw_mask) != mw->mw_goal)
                         continue;
 
diff --git a/fs/ocfs2/endian.h b/fs/ocfs2/endian.h
index f226b220762..ff257628af1 100644
--- a/fs/ocfs2/endian.h
+++ b/fs/ocfs2/endian.h
@@ -32,6 +32,11 @@ static inline void le32_add_cpu(__le32 *var, u32 val)
         *var = cpu_to_le32(le32_to_cpu(*var) + val);
 }
 
+static inline void le64_add_cpu(__le64 *var, u64 val)
+{
+        *var = cpu_to_le64(le64_to_cpu(*var) + val);
+}
+
 static inline void le32_and_cpu(__le32 *var, u32 val)
 {
         *var = cpu_to_le32(le32_to_cpu(*var) & val);
diff --git a/fs/ocfs2/extent_map.c b/fs/ocfs2/extent_map.c
index ba2b2ab1c6e..03c1d365c78 100644
--- a/fs/ocfs2/extent_map.c
+++ b/fs/ocfs2/extent_map.c
@@ -109,17 +109,14 @@ static int ocfs2_extent_map_lookup(struct inode *inode, unsigned int cpos,
  */
 void ocfs2_extent_map_trunc(struct inode *inode, unsigned int cpos)
 {
-        struct list_head *p, *n;
-        struct ocfs2_extent_map_item *emi;
+        struct ocfs2_extent_map_item *emi, *n;
         struct ocfs2_inode_info *oi = OCFS2_I(inode);
         struct ocfs2_extent_map *em = &oi->ip_extent_map;
         LIST_HEAD(tmp_list);
         unsigned int range;
 
         spin_lock(&oi->ip_lock);
-        list_for_each_safe(p, n, &em->em_list) {
-                emi = list_entry(p, struct ocfs2_extent_map_item, ei_list);
-
+        list_for_each_entry_safe(emi, n, &em->em_list, ei_list) {
                 if (emi->ei_cpos >= cpos) {
                         /* Full truncate of this record. */
                         list_move(&emi->ei_list, &tmp_list);
@@ -136,8 +133,7 @@ void ocfs2_extent_map_trunc(struct inode *inode, unsigned int cpos)
         }
         spin_unlock(&oi->ip_lock);
 
-        list_for_each_safe(p, n, &tmp_list) {
-                emi = list_entry(p, struct ocfs2_extent_map_item, ei_list);
+        list_for_each_entry_safe(emi, n, &tmp_list, ei_list) {
                 list_del(&emi->ei_list);
                 kfree(emi);
         }
@@ -377,37 +373,6 @@ out:
         return ret;
 }
 
-/*
- * Return the index of the extent record which contains cluster #v_cluster.
- * -1 is returned if it was not found.
- *
- * Should work fine on interior and exterior nodes.
- */
-static int ocfs2_search_extent_list(struct ocfs2_extent_list *el,
-                                    u32 v_cluster)
-{
-        int ret = -1;
-        int i;
-        struct ocfs2_extent_rec *rec;
-        u32 rec_end, rec_start, clusters;
-
-        for(i = 0; i < le16_to_cpu(el->l_next_free_rec); i++) {
-                rec = &el->l_recs[i];
-
-                rec_start = le32_to_cpu(rec->e_cpos);
-                clusters = ocfs2_rec_clusters(el, rec);
-
-                rec_end = rec_start + clusters;
-
-                if (v_cluster >= rec_start && v_cluster < rec_end) {
-                        ret = i;
-                        break;
-                }
-        }
-
-        return ret;
-}
-
 int ocfs2_get_clusters(struct inode *inode, u32 v_cluster,
                        u32 *p_cluster, u32 *num_clusters,
                        unsigned int *extent_flags)
diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
index 4979b667571..f04c7aa834c 100644
--- a/fs/ocfs2/file.c
+++ b/fs/ocfs2/file.c
@@ -263,6 +263,7 @@ static int ocfs2_orphan_for_truncate(struct ocfs2_super *osb,
         int status;
         handle_t *handle;
         struct ocfs2_dinode *di;
+        u64 cluster_bytes;
 
         mlog_entry_void();
 
@@ -286,7 +287,9 @@ static int ocfs2_orphan_for_truncate(struct ocfs2_super *osb,
         /*
          * Do this before setting i_size.
          */
-        status = ocfs2_zero_tail_for_truncate(inode, handle, new_i_size);
+        cluster_bytes = ocfs2_align_bytes_to_clusters(inode->i_sb, new_i_size);
+        status = ocfs2_zero_range_for_truncate(inode, handle, new_i_size,
+                                               cluster_bytes);
         if (status) {
                 mlog_errno(status);
                 goto out_commit;
@@ -326,9 +329,6 @@ static int ocfs2_truncate_file(struct inode *inode,
                    (unsigned long long)OCFS2_I(inode)->ip_blkno,
                    (unsigned long long)new_i_size);
 
-        unmap_mapping_range(inode->i_mapping, new_i_size + PAGE_SIZE - 1, 0, 1);
-        truncate_inode_pages(inode->i_mapping, new_i_size);
-
         fe = (struct ocfs2_dinode *) di_bh->b_data;
         if (!OCFS2_IS_VALID_DINODE(fe)) {
                 OCFS2_RO_ON_INVALID_DINODE(inode->i_sb, fe);
@@ -363,16 +363,23 @@ static int ocfs2_truncate_file(struct inode *inode,
         if (new_i_size == le64_to_cpu(fe->i_size))
                 goto bail;
 
+        down_write(&OCFS2_I(inode)->ip_alloc_sem);
+
         /* This forces other nodes to sync and drop their pages. Do
          * this even if we have a truncate without allocation change -
          * ocfs2 cluster sizes can be much greater than page size, so
          * we have to truncate them anyway.  */
         status = ocfs2_data_lock(inode, 1);
         if (status < 0) {
+                up_write(&OCFS2_I(inode)->ip_alloc_sem);
+
                 mlog_errno(status);
                 goto bail;
         }
 
+        unmap_mapping_range(inode->i_mapping, new_i_size + PAGE_SIZE - 1, 0, 1);
+        truncate_inode_pages(inode->i_mapping, new_i_size);
+
         /* alright, we're going to need to do a full blown alloc size
          * change. Orphan the inode so that recovery can complete the
          * truncate if necessary. This does the task of marking
@@ -399,6 +406,8 @@ static int ocfs2_truncate_file(struct inode *inode,
 bail_unlock_data:
         ocfs2_data_unlock(inode, 1);
 
+        up_write(&OCFS2_I(inode)->ip_alloc_sem);
+
 bail:
 
         mlog_exit(status);
@@ -419,6 +428,7 @@ int ocfs2_do_extend_allocation(struct ocfs2_super *osb,
                                struct inode *inode,
                                u32 *logical_offset,
                                u32 clusters_to_add,
+                               int mark_unwritten,
                                struct buffer_head *fe_bh,
                                handle_t *handle,
                                struct ocfs2_alloc_context *data_ac,
@@ -431,9 +441,13 @@ int ocfs2_do_extend_allocation(struct ocfs2_super *osb,
         enum ocfs2_alloc_restarted reason = RESTART_NONE;
         u32 bit_off, num_bits;
         u64 block;
+        u8 flags = 0;
 
         BUG_ON(!clusters_to_add);
 
+        if (mark_unwritten)
+                flags = OCFS2_EXT_UNWRITTEN;
+
         free_extents = ocfs2_num_free_extents(osb, inode, fe);
         if (free_extents < 0) {
                 status = free_extents;
@@ -483,7 +497,7 @@ int ocfs2_do_extend_allocation(struct ocfs2_super *osb,
              num_bits, bit_off, (unsigned long long)OCFS2_I(inode)->ip_blkno);
         status = ocfs2_insert_extent(osb, handle, inode, fe_bh,
                                      *logical_offset, block, num_bits,
-                                     meta_ac);
+                                     flags, meta_ac);
         if (status < 0) {
                 mlog_errno(status);
                 goto leave;
@@ -516,25 +530,31 @@ leave:
  * For a given allocation, determine which allocators will need to be
  * accessed, and lock them, reserving the appropriate number of bits.
  *
- * Called from ocfs2_extend_allocation() for file systems which don't
- * support holes, and from ocfs2_write() for file systems which
- * understand sparse inodes.
+ * Sparse file systems call this from ocfs2_write_begin_nolock()
+ * and ocfs2_allocate_unwritten_extents().
+ *
+ * File systems which don't support holes call this from
+ * ocfs2_extend_allocation().
  */
 int ocfs2_lock_allocators(struct inode *inode, struct ocfs2_dinode *di,
-                          u32 clusters_to_add,
+                          u32 clusters_to_add, u32 extents_to_split,
                           struct ocfs2_alloc_context **data_ac,
                           struct ocfs2_alloc_context **meta_ac)
 {
-        int ret, num_free_extents;
+        int ret = 0, num_free_extents;
+        unsigned int max_recs_needed = clusters_to_add + 2 * extents_to_split;
         struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
 
         *meta_ac = NULL;
-        *data_ac = NULL;
+        if (data_ac)
+                *data_ac = NULL;
+
+        BUG_ON(clusters_to_add != 0 && data_ac == NULL);
 
         mlog(0, "extend inode %llu, i_size = %lld, di->i_clusters = %u, "
-             "clusters_to_add = %u\n",
+             "clusters_to_add = %u, extents_to_split = %u\n",
              (unsigned long long)OCFS2_I(inode)->ip_blkno, i_size_read(inode),
-             le32_to_cpu(di->i_clusters), clusters_to_add);
+             le32_to_cpu(di->i_clusters), clusters_to_add, extents_to_split);
 
         num_free_extents = ocfs2_num_free_extents(osb, inode, di);
         if (num_free_extents < 0) {
@@ -552,9 +572,12 @@ int ocfs2_lock_allocators(struct inode *inode, struct ocfs2_dinode *di,
          *
          * Most of the time we'll only be seeing this 1 cluster at a time
          * anyway.
+         *
+         * Always lock for any unwritten extents - we might want to
+         * add blocks during a split.
          */
         if (!num_free_extents ||
-            (ocfs2_sparse_alloc(osb) && num_free_extents < clusters_to_add)) {
+            (ocfs2_sparse_alloc(osb) && num_free_extents < max_recs_needed)) {
                 ret = ocfs2_reserve_new_metadata(osb, di, meta_ac);
                 if (ret < 0) {
                         if (ret != -ENOSPC)
@@ -563,6 +586,9 @@ int ocfs2_lock_allocators(struct inode *inode, struct ocfs2_dinode *di,
                 }
         }
 
+        if (clusters_to_add == 0)
+                goto out;
+
         ret = ocfs2_reserve_clusters(osb, clusters_to_add, data_ac);
         if (ret < 0) {
                 if (ret != -ENOSPC)
@@ -585,14 +611,13 @@ out:
         return ret;
 }
 
-static int ocfs2_extend_allocation(struct inode *inode,
-                                   u32 clusters_to_add)
+static int __ocfs2_extend_allocation(struct inode *inode, u32 logical_start,
+                                     u32 clusters_to_add, int mark_unwritten)
 {
         int status = 0;
         int restart_func = 0;
-        int drop_alloc_sem = 0;
         int credits;
-        u32 prev_clusters, logical_start;
+        u32 prev_clusters;
         struct buffer_head *bh = NULL;
         struct ocfs2_dinode *fe = NULL;
         handle_t *handle = NULL;
@@ -607,7 +632,7 @@ static int ocfs2_extend_allocation(struct inode *inode,
          * This function only exists for file systems which don't
          * support holes.
          */
-        BUG_ON(ocfs2_sparse_alloc(osb));
+        BUG_ON(mark_unwritten && !ocfs2_sparse_alloc(osb));
 
         status = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno, &bh,
                                   OCFS2_BH_CACHED, inode);
@@ -623,19 +648,10 @@ static int ocfs2_extend_allocation(struct inode *inode,
                 goto leave;
         }
 
-        logical_start = OCFS2_I(inode)->ip_clusters;
-
 restart_all:
         BUG_ON(le32_to_cpu(fe->i_clusters) != OCFS2_I(inode)->ip_clusters);
 
-        /* blocks peope in read/write from reading our allocation
-         * until we're done changing it. We depend on i_mutex to block
-         * other extend/truncate calls while we're here. Ordering wrt
-         * start_trans is important here -- always do it before! */
-        down_write(&OCFS2_I(inode)->ip_alloc_sem);
-        drop_alloc_sem = 1;
-
-        status = ocfs2_lock_allocators(inode, fe, clusters_to_add, &data_ac,
+        status = ocfs2_lock_allocators(inode, fe, clusters_to_add, 0, &data_ac,
                                        &meta_ac);
         if (status) {
                 mlog_errno(status);
@@ -668,6 +684,7 @@ restarted_transaction:
                                             inode,
                                             &logical_start,
                                             clusters_to_add,
+                                            mark_unwritten,
                                             bh,
                                             handle,
                                             data_ac,
@@ -720,10 +737,6 @@ restarted_transaction:
              OCFS2_I(inode)->ip_clusters, i_size_read(inode));
 
 leave:
-        if (drop_alloc_sem) {
-                up_write(&OCFS2_I(inode)->ip_alloc_sem);
-                drop_alloc_sem = 0;
-        }
         if (handle) {
                 ocfs2_commit_trans(osb, handle);
                 handle = NULL;
@@ -749,6 +762,25 @@ leave:
         return status;
 }
 
+static int ocfs2_extend_allocation(struct inode *inode, u32 logical_start,
+                                   u32 clusters_to_add, int mark_unwritten)
+{
+        int ret;
+
+        /*
+         * The alloc sem blocks peope in read/write from reading our
+         * allocation until we're done changing it. We depend on
+         * i_mutex to block other extend/truncate calls while we're
+         * here.
+         */
+        down_write(&OCFS2_I(inode)->ip_alloc_sem);
+        ret = __ocfs2_extend_allocation(inode, logical_start, clusters_to_add,
+                                        mark_unwritten);
+        up_write(&OCFS2_I(inode)->ip_alloc_sem);
+
+        return ret;
+}
+
 /* Some parts of this taken from generic_cont_expand, which turned out
  * to be too fragile to do exactly what we need without us having to
  * worry about recursive locking in ->prepare_write() and
@@ -890,7 +922,9 @@ static int ocfs2_extend_file(struct inode *inode,
         }
 
         if (clusters_to_add) {
-                ret = ocfs2_extend_allocation(inode, clusters_to_add);
+                ret = ocfs2_extend_allocation(inode,
+                                              OCFS2_I(inode)->ip_clusters,
+                                              clusters_to_add, 0);
                 if (ret < 0) {
                         mlog_errno(ret);
                         goto out_unlock;
@@ -995,6 +1029,13 @@ int ocfs2_setattr(struct dentry *dentry, struct iattr *attr)
                 goto bail_unlock;
         }
 
+        /*
+         * This will intentionally not wind up calling vmtruncate(),
+         * since all the work for a size change has been done above.
+         * Otherwise, we could get into problems with truncate as
+         * ip_alloc_sem is used there to protect against i_size
+         * changes.
+         */
         status = inode_setattr(inode, attr);
         if (status < 0) {
                 mlog_errno(status);
@@ -1070,17 +1111,16 @@ out:
         return ret;
 }
 
-static int ocfs2_write_remove_suid(struct inode *inode)
+static int __ocfs2_write_remove_suid(struct inode *inode,
+                                     struct buffer_head *bh)
 {
         int ret;
-        struct buffer_head *bh = NULL;
-        struct ocfs2_inode_info *oi = OCFS2_I(inode);
         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);
+                   (unsigned long long)OCFS2_I(inode)->ip_blkno, inode->i_mode);
 
         handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
         if (handle == NULL) {
@@ -1089,17 +1129,11 @@ static int ocfs2_write_remove_suid(struct inode *inode)
                 goto out;
         }
 
-        ret = ocfs2_read_block(osb, oi->ip_blkno, &bh, OCFS2_BH_CACHED, inode);
-        if (ret < 0) {
-                mlog_errno(ret);
-                goto out_trans;
-        }
-
         ret = ocfs2_journal_access(handle, inode, bh,
                                    OCFS2_JOURNAL_ACCESS_WRITE);
         if (ret < 0) {
                 mlog_errno(ret);
-                goto out_bh;
+                goto out_trans;
         }
 
         inode->i_mode &= ~S_ISUID;
@@ -1112,8 +1146,7 @@ static int ocfs2_write_remove_suid(struct inode *inode)
         ret = ocfs2_journal_dirty(handle, bh);
         if (ret < 0)
                 mlog_errno(ret);
-out_bh:
-        brelse(bh);
+
 out_trans:
         ocfs2_commit_trans(osb, handle);
 out:
@@ -1159,6 +1192,460 @@ out:
         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);
+
+        ret = ocfs2_read_block(OCFS2_SB(inode->i_sb),
+                               oi->ip_blkno, &bh, OCFS2_BH_CACHED, inode);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        ret =  __ocfs2_write_remove_suid(inode, bh);
+out:
+        brelse(bh);
+        return ret;
+}
+
+/*
+ * Allocate enough extents to cover the region starting at byte offset
+ * start for len bytes. Existing extents are skipped, any extents
+ * added are marked as "unwritten".
+ */
+static int ocfs2_allocate_unwritten_extents(struct inode *inode,
+                                            u64 start, u64 len)
+{
+        int ret;
+        u32 cpos, phys_cpos, clusters, alloc_size;
+
+        /*
+         * We consider both start and len to be inclusive.
+         */
+        cpos = start >> OCFS2_SB(inode->i_sb)->s_clustersize_bits;
+        clusters = ocfs2_clusters_for_bytes(inode->i_sb, start + len);
+        clusters -= cpos;
+
+        while (clusters) {
+                ret = ocfs2_get_clusters(inode, cpos, &phys_cpos,
+                                         &alloc_size, NULL);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                /*
+                 * Hole or existing extent len can be arbitrary, so
+                 * cap it to our own allocation request.
+                 */
+                if (alloc_size > clusters)
+                        alloc_size = clusters;
+
+                if (phys_cpos) {
+                        /*
+                         * We already have an allocation at this
+                         * region so we can safely skip it.
+                         */
+                        goto next;
+                }
+
+                ret = __ocfs2_extend_allocation(inode, cpos, alloc_size, 1);
+                if (ret) {
+                        if (ret != -ENOSPC)
+                                mlog_errno(ret);
+                        goto out;
+                }
+
+next:
+                cpos += alloc_size;
+                clusters -= alloc_size;
+        }
+
+        ret = 0;
+out:
+        return ret;
+}
+
+static int __ocfs2_remove_inode_range(struct inode *inode,
+                                      struct buffer_head *di_bh,
+                                      u32 cpos, u32 phys_cpos, u32 len,
+                                      struct ocfs2_cached_dealloc_ctxt *dealloc)
+{
+        int ret;
+        u64 phys_blkno = ocfs2_clusters_to_blocks(inode->i_sb, phys_cpos);
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct inode *tl_inode = osb->osb_tl_inode;
+        handle_t *handle;
+        struct ocfs2_alloc_context *meta_ac = NULL;
+        struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
+
+        ret = ocfs2_lock_allocators(inode, di, 0, 1, NULL, &meta_ac);
+        if (ret) {
+                mlog_errno(ret);
+                return ret;
+        }
+
+        mutex_lock(&tl_inode->i_mutex);
+
+        if (ocfs2_truncate_log_needs_flush(osb)) {
+                ret = __ocfs2_flush_truncate_log(osb);
+                if (ret < 0) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+        }
+
+        handle = ocfs2_start_trans(osb, OCFS2_REMOVE_EXTENT_CREDITS);
+        if (handle == NULL) {
+                ret = -ENOMEM;
+                mlog_errno(ret);
+                goto out;
+        }
+
+        ret = ocfs2_journal_access(handle, inode, di_bh,
+                                   OCFS2_JOURNAL_ACCESS_WRITE);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        ret = ocfs2_remove_extent(inode, di_bh, cpos, len, handle, meta_ac,
+                                  dealloc);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+
+        OCFS2_I(inode)->ip_clusters -= len;
+        di->i_clusters = cpu_to_le32(OCFS2_I(inode)->ip_clusters);
+
+        ret = ocfs2_journal_dirty(handle, di_bh);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_commit;
+        }
+
+        ret = ocfs2_truncate_log_append(osb, handle, phys_blkno, len);
+        if (ret)
+                mlog_errno(ret);
+
+out_commit:
+        ocfs2_commit_trans(osb, handle);
+out:
+        mutex_unlock(&tl_inode->i_mutex);
+
+        if (meta_ac)
+                ocfs2_free_alloc_context(meta_ac);
+
+        return ret;
+}
+
+/*
+ * Truncate a byte range, avoiding pages within partial clusters. This
+ * preserves those pages for the zeroing code to write to.
+ */
+static void ocfs2_truncate_cluster_pages(struct inode *inode, u64 byte_start,
+                                         u64 byte_len)
+{
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        loff_t start, end;
+        struct address_space *mapping = inode->i_mapping;
+
+        start = (loff_t)ocfs2_align_bytes_to_clusters(inode->i_sb, byte_start);
+        end = byte_start + byte_len;
+        end = end & ~(osb->s_clustersize - 1);
+
+        if (start < end) {
+                unmap_mapping_range(mapping, start, end - start, 0);
+                truncate_inode_pages_range(mapping, start, end - 1);
+        }
+}
+
+static int ocfs2_zero_partial_clusters(struct inode *inode,
+                                       u64 start, u64 len)
+{
+        int ret = 0;
+        u64 tmpend, end = start + len;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        unsigned int csize = osb->s_clustersize;
+        handle_t *handle;
+
+        /*
+         * The "start" and "end" values are NOT necessarily part of
+         * the range whose allocation is being deleted. Rather, this
+         * is what the user passed in with the request. We must zero
+         * partial clusters here. There's no need to worry about
+         * physical allocation - the zeroing code knows to skip holes.
+         */
+        mlog(0, "byte start: %llu, end: %llu\n",
+             (unsigned long long)start, (unsigned long long)end);
+
+        /*
+         * If both edges are on a cluster boundary then there's no
+         * zeroing required as the region is part of the allocation to
+         * be truncated.
+         */
+        if ((start & (csize - 1)) == 0 && (end & (csize - 1)) == 0)
+                goto out;
+
+        handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
+        if (handle == NULL) {
+                ret = -ENOMEM;
+                mlog_errno(ret);
+                goto out;
+        }
+
+        /*
+         * We want to get the byte offset of the end of the 1st cluster.
+         */
+        tmpend = (u64)osb->s_clustersize + (start & ~(osb->s_clustersize - 1));
+        if (tmpend > end)
+                tmpend = end;
+
+        mlog(0, "1st range: start: %llu, tmpend: %llu\n",
+             (unsigned long long)start, (unsigned long long)tmpend);
+
+        ret = ocfs2_zero_range_for_truncate(inode, handle, start, tmpend);
+        if (ret)
+                mlog_errno(ret);
+
+        if (tmpend < end) {
+                /*
+                 * This may make start and end equal, but the zeroing
+                 * code will skip any work in that case so there's no
+                 * need to catch it up here.
+                 */
+                start = end & ~(osb->s_clustersize - 1);
+
+                mlog(0, "2nd range: start: %llu, end: %llu\n",
+                     (unsigned long long)start, (unsigned long long)end);
+
+                ret = ocfs2_zero_range_for_truncate(inode, handle, start, end);
+                if (ret)
+                        mlog_errno(ret);
+        }
+
+        ocfs2_commit_trans(osb, handle);
+out:
+        return ret;
+}
+
+static int ocfs2_remove_inode_range(struct inode *inode,
+                                    struct buffer_head *di_bh, u64 byte_start,
+                                    u64 byte_len)
+{
+        int ret = 0;
+        u32 trunc_start, trunc_len, cpos, phys_cpos, alloc_size;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct ocfs2_cached_dealloc_ctxt dealloc;
+
+        ocfs2_init_dealloc_ctxt(&dealloc);
+
+        if (byte_len == 0)
+                return 0;
+
+        trunc_start = ocfs2_clusters_for_bytes(osb->sb, byte_start);
+        trunc_len = (byte_start + byte_len) >> osb->s_clustersize_bits;
+        if (trunc_len >= trunc_start)
+                trunc_len -= trunc_start;
+        else
+                trunc_len = 0;
+
+        mlog(0, "Inode: %llu, start: %llu, len: %llu, cstart: %u, clen: %u\n",
+             (unsigned long long)OCFS2_I(inode)->ip_blkno,
+             (unsigned long long)byte_start,
+             (unsigned long long)byte_len, trunc_start, trunc_len);
+
+        ret = ocfs2_zero_partial_clusters(inode, byte_start, byte_len);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        cpos = trunc_start;
+        while (trunc_len) {
+                ret = ocfs2_get_clusters(inode, cpos, &phys_cpos,
+                                         &alloc_size, NULL);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
+
+                if (alloc_size > trunc_len)
+                        alloc_size = trunc_len;
+
+                /* Only do work for non-holes */
+                if (phys_cpos != 0) {
+                        ret = __ocfs2_remove_inode_range(inode, di_bh, cpos,
+                                                         phys_cpos, alloc_size,
+                                                         &dealloc);
+                        if (ret) {
+                                mlog_errno(ret);
+                                goto out;
+                        }
+                }
+
+                cpos += alloc_size;
+                trunc_len -= alloc_size;
+        }
+
+        ocfs2_truncate_cluster_pages(inode, byte_start, byte_len);
+
+out:
+        ocfs2_schedule_truncate_log_flush(osb, 1);
+        ocfs2_run_deallocs(osb, &dealloc);
+
+        return ret;
+}
+
+/*
+ * Parts of this function taken from xfs_change_file_space()
+ */
+int ocfs2_change_file_space(struct file *file, unsigned int cmd,
+                            struct ocfs2_space_resv *sr)
+{
+        int ret;
+        s64 llen;
+        struct inode *inode = file->f_path.dentry->d_inode;
+        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
+        struct buffer_head *di_bh = NULL;
+        handle_t *handle;
+        unsigned long long max_off = ocfs2_max_file_offset(inode->i_sb->s_blocksize_bits);
+
+        if ((cmd == OCFS2_IOC_RESVSP || cmd == OCFS2_IOC_RESVSP64) &&
+            !ocfs2_writes_unwritten_extents(osb))
+                return -ENOTTY;
+        else if ((cmd == OCFS2_IOC_UNRESVSP || cmd == OCFS2_IOC_UNRESVSP64) &&
+                 !ocfs2_sparse_alloc(osb))
+                return -ENOTTY;
+
+        if (!S_ISREG(inode->i_mode))
+                return -EINVAL;
+
+        if (!(file->f_mode & FMODE_WRITE))
+                return -EBADF;
+
+        if (ocfs2_is_hard_readonly(osb) || ocfs2_is_soft_readonly(osb))
+                return -EROFS;
+
+        mutex_lock(&inode->i_mutex);
+
+        /*
+         * This prevents concurrent writes on other nodes
+         */
+        ret = ocfs2_rw_lock(inode, 1);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
+
+        ret = ocfs2_meta_lock(inode, &di_bh, 1);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_rw_unlock;
+        }
+
+        if (inode->i_flags & (S_IMMUTABLE|S_APPEND)) {
+                ret = -EPERM;
+                goto out_meta_unlock;
+        }
+
+        switch (sr->l_whence) {
+        case 0: /*SEEK_SET*/
+                break;
+        case 1: /*SEEK_CUR*/
+                sr->l_start += file->f_pos;
+                break;
+        case 2: /*SEEK_END*/
+                sr->l_start += i_size_read(inode);
+                break;
+        default:
+                ret = -EINVAL;
+                goto out_meta_unlock;
+        }
+        sr->l_whence = 0;
+
+        llen = sr->l_len > 0 ? sr->l_len - 1 : sr->l_len;
+
+        if (sr->l_start < 0
+            || sr->l_start > max_off
+            || (sr->l_start + llen) < 0
+            || (sr->l_start + llen) > max_off) {
+                ret = -EINVAL;
+                goto out_meta_unlock;
+        }
+
+        if (cmd == OCFS2_IOC_RESVSP || cmd == OCFS2_IOC_RESVSP64) {
+                if (sr->l_len <= 0) {
+                        ret = -EINVAL;
+                        goto out_meta_unlock;
+                }
+        }
+
+        if (should_remove_suid(file->f_path.dentry)) {
+                ret = __ocfs2_write_remove_suid(inode, di_bh);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out_meta_unlock;
+                }
+        }
+
+        down_write(&OCFS2_I(inode)->ip_alloc_sem);
+        switch (cmd) {
+        case OCFS2_IOC_RESVSP:
+        case OCFS2_IOC_RESVSP64:
+                /*
+                 * This takes unsigned offsets, but the signed ones we
+                 * pass have been checked against overflow above.
+                 */
+                ret = ocfs2_allocate_unwritten_extents(inode, sr->l_start,
+                                                       sr->l_len);
+                break;
+        case OCFS2_IOC_UNRESVSP:
+        case OCFS2_IOC_UNRESVSP64:
+                ret = ocfs2_remove_inode_range(inode, di_bh, sr->l_start,
+                                               sr->l_len);
+                break;
+        default:
+                ret = -EINVAL;
+        }
+        up_write(&OCFS2_I(inode)->ip_alloc_sem);
+        if (ret) {
+                mlog_errno(ret);
+                goto out_meta_unlock;
+        }
+
+        /*
+         * We update c/mtime for these changes
+         */
+        handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
+        if (IS_ERR(handle)) {
+                ret = PTR_ERR(handle);
+                mlog_errno(ret);
+                goto out_meta_unlock;
+        }
+
+        inode->i_ctime = inode->i_mtime = CURRENT_TIME;
+        ret = ocfs2_mark_inode_dirty(handle, inode, di_bh);
+        if (ret < 0)
+                mlog_errno(ret);
+
+        ocfs2_commit_trans(osb, handle);
+
+out_meta_unlock:
+        brelse(di_bh);
+        ocfs2_meta_unlock(inode, 1);
+out_rw_unlock:
+        ocfs2_rw_unlock(inode, 1);
+
+        mutex_unlock(&inode->i_mutex);
+out:
+        return ret;
+}
+
 static int ocfs2_prepare_inode_for_write(struct dentry *dentry,
                                          loff_t *ppos,
                                          size_t count,
@@ -1329,15 +1816,16 @@ ocfs2_set_next_iovec(const struct iovec **iovp, size_t *basep, size_t bytes)
         *basep = base;
 }
 
-static struct page * ocfs2_get_write_source(struct ocfs2_buffered_write_priv *bp,
+static struct page * ocfs2_get_write_source(char **ret_src_buf,
                                             const struct iovec *cur_iov,
                                             size_t iov_offset)
 {
         int ret;
-        char *buf;
+        char *buf = cur_iov->iov_base + iov_offset;
         struct page *src_page = NULL;
+        unsigned long off;
 
-        buf = cur_iov->iov_base + iov_offset;
+        off = (unsigned long)(buf) & ~PAGE_CACHE_MASK;
 
         if (!segment_eq(get_fs(), KERNEL_DS)) {
                 /*
@@ -1349,18 +1837,17 @@ static struct page * ocfs2_get_write_source(struct ocfs2_buffered_write_priv *bp
                                      (unsigned long)buf & PAGE_CACHE_MASK, 1,
                                      0, 0, &src_page, NULL);
                 if (ret == 1)
-                        bp->b_src_buf = kmap(src_page);
+                        *ret_src_buf = kmap(src_page) + off;
                 else
                         src_page = ERR_PTR(-EFAULT);
         } else {
-                bp->b_src_buf = buf;
+                *ret_src_buf = buf;
         }
 
         return src_page;
 }
 
-static void ocfs2_put_write_source(struct ocfs2_buffered_write_priv *bp,
-                                   struct page *page)
+static void ocfs2_put_write_source(struct page *page)
 {
         if (page) {
                 kunmap(page);
@@ -1376,10 +1863,12 @@ static ssize_t ocfs2_file_buffered_write(struct file *file, loff_t *ppos,
 {
         int ret = 0;
         ssize_t copied, total = 0;
-        size_t iov_offset = 0;
+        size_t iov_offset = 0, bytes;
+        loff_t pos;
         const struct iovec *cur_iov = iov;
-        struct ocfs2_buffered_write_priv bp;
-        struct page *page;
+        struct page *user_page, *page;
+        char *buf, *dst;
+        void *fsdata;
 
         /*
          * handle partial DIO write.  Adjust cur_iov if needed.
@@ -1387,21 +1876,38 @@ static ssize_t ocfs2_file_buffered_write(struct file *file, loff_t *ppos,
         ocfs2_set_next_iovec(&cur_iov, &iov_offset, o_direct_written);
 
         do {
-                bp.b_cur_off = iov_offset;
-                bp.b_cur_iov = cur_iov;
+                pos = *ppos;
 
-                page = ocfs2_get_write_source(&bp, cur_iov, iov_offset);
-                if (IS_ERR(page)) {
-                        ret = PTR_ERR(page);
+                user_page = ocfs2_get_write_source(&buf, cur_iov, iov_offset);
+                if (IS_ERR(user_page)) {
+                        ret = PTR_ERR(user_page);
                         goto out;
                 }
 
-                copied = ocfs2_buffered_write_cluster(file, *ppos, count,
-                                                      ocfs2_map_and_write_user_data,
-                                                      &bp);
+                /* Stay within our page boundaries */
+                bytes = min((PAGE_CACHE_SIZE - ((unsigned long)pos & ~PAGE_CACHE_MASK)),
+                            (PAGE_CACHE_SIZE - ((unsigned long)buf & ~PAGE_CACHE_MASK)));
+                /* Stay within the vector boundary */
+                bytes = min_t(size_t, bytes, cur_iov->iov_len - iov_offset);
+                /* Stay within count */
+                bytes = min(bytes, count);
+
+                page = NULL;
+                ret = ocfs2_write_begin(file, file->f_mapping, pos, bytes, 0,
+                                        &page, &fsdata);
+                if (ret) {
+                        mlog_errno(ret);
+                        goto out;
+                }
 
-                ocfs2_put_write_source(&bp, page);
+                dst = kmap_atomic(page, KM_USER0);
+                memcpy(dst + (pos & (PAGE_CACHE_SIZE - 1)), buf, bytes);
+                kunmap_atomic(dst, KM_USER0);
+                flush_dcache_page(page);
+                ocfs2_put_write_source(user_page);
 
+                copied = ocfs2_write_end(file, file->f_mapping, pos, bytes,
+                                         bytes, page, fsdata);
                 if (copied < 0) {
                         mlog_errno(copied);
                         ret = copied;
@@ -1409,7 +1915,7 @@ static ssize_t ocfs2_file_buffered_write(struct file *file, loff_t *ppos,
                 }
 
                 total += copied;
-                *ppos = *ppos + copied;
+                *ppos = pos + copied;
                 count -= copied;
 
                 ocfs2_set_next_iovec(&cur_iov, &iov_offset, copied);
@@ -1579,52 +2085,46 @@ static int ocfs2_splice_write_actor(struct pipe_inode_info *pipe,
                                     struct pipe_buffer *buf,
                                     struct splice_desc *sd)
 {
-        int ret, count, total = 0;
+        int ret, count;
         ssize_t copied = 0;
-        struct ocfs2_splice_write_priv sp;
+        struct file *file = sd->u.file;
+        unsigned int offset;
+        struct page *page = NULL;
+        void *fsdata;
+        char *src, *dst;
 
         ret = buf->ops->confirm(pipe, buf);
         if (ret)
                 goto out;
 
-        sp.s_sd = sd;
-        sp.s_buf = buf;
-        sp.s_pipe = pipe;
-        sp.s_offset = sd->pos & ~PAGE_CACHE_MASK;
-        sp.s_buf_offset = buf->offset;
-
+        offset = sd->pos & ~PAGE_CACHE_MASK;
         count = sd->len;
-        if (count + sp.s_offset > PAGE_CACHE_SIZE)
-                count = PAGE_CACHE_SIZE - sp.s_offset;
+        if (count + offset > PAGE_CACHE_SIZE)
+                count = PAGE_CACHE_SIZE - offset;
 
-        do {
-                /*
-                 * splice wants us to copy up to one page at a
-                 * time. For pagesize > cluster size, this means we
-                 * might enter ocfs2_buffered_write_cluster() more
-                 * than once, so keep track of our progress here.
-                 */
-                copied = ocfs2_buffered_write_cluster(sd->u.file,
-                                                      (loff_t)sd->pos + total,
-                                                      count,
-                                                      ocfs2_map_and_write_splice_data,
-                                                      &sp);
-                if (copied < 0) {
-                        mlog_errno(copied);
-                        ret = copied;
-                        goto out;
-                }
+        ret = ocfs2_write_begin(file, file->f_mapping, sd->pos, count, 0,
+                                &page, &fsdata);
+        if (ret) {
+                mlog_errno(ret);
+                goto out;
+        }
 
-                count -= copied;
-                sp.s_offset += copied;
-                sp.s_buf_offset += copied;
-                total += copied;
-        } while (count);
+        src = buf->ops->map(pipe, buf, 1);
+        dst = kmap_atomic(page, KM_USER1);
+        memcpy(dst + offset, src + buf->offset, count);
+        kunmap_atomic(page, KM_USER1);
+        buf->ops->unmap(pipe, buf, src);
 
-        ret = 0;
+        copied = ocfs2_write_end(file, file->f_mapping, sd->pos, count, count,
+                                 page, fsdata);
+        if (copied < 0) {
+                mlog_errno(copied);
+                ret = copied;
+                goto out;
+        }
 out:
 
-        return total ? total : ret;
+        return copied ? copied : ret;
 }
 
 static ssize_t __ocfs2_file_splice_write(struct pipe_inode_info *pipe,
diff --git a/fs/ocfs2/file.h b/fs/ocfs2/file.h
index a4dd1fa1822..36fe27f268e 100644
--- a/fs/ocfs2/file.h
+++ b/fs/ocfs2/file.h
@@ -39,15 +39,16 @@ enum ocfs2_alloc_restarted {
 };
 int ocfs2_do_extend_allocation(struct ocfs2_super *osb,
                                struct inode *inode,
-                               u32 *cluster_start,
+                               u32 *logical_offset,
                                u32 clusters_to_add,
+                               int mark_unwritten,
                                struct buffer_head *fe_bh,
                                handle_t *handle,
                                struct ocfs2_alloc_context *data_ac,
                                struct ocfs2_alloc_context *meta_ac,
-                               enum ocfs2_alloc_restarted *reason);
+                               enum ocfs2_alloc_restarted *reason_ret);
 int ocfs2_lock_allocators(struct inode *inode, struct ocfs2_dinode *di,
-                          u32 clusters_to_add,
+                          u32 clusters_to_add, u32 extents_to_split,
                           struct ocfs2_alloc_context **data_ac,
                           struct ocfs2_alloc_context **meta_ac);
 int ocfs2_setattr(struct dentry *dentry, struct iattr *attr);
@@ -61,4 +62,7 @@ int ocfs2_should_update_atime(struct inode *inode,
 int ocfs2_update_inode_atime(struct inode *inode,
                              struct buffer_head *bh);
 
+int ocfs2_change_file_space(struct file *file, unsigned int cmd,
+                            struct ocfs2_space_resv *sr);
+
 #endif /* OCFS2_FILE_H */
diff --git a/fs/ocfs2/heartbeat.c b/fs/ocfs2/heartbeat.c
index b25ef63781b..352eb4a13f9 100644
--- a/fs/ocfs2/heartbeat.c
+++ b/fs/ocfs2/heartbeat.c
@@ -157,16 +157,16 @@ int ocfs2_register_hb_callbacks(struct ocfs2_super *osb)
         if (ocfs2_mount_local(osb))
                 return 0;
 
-        status = o2hb_register_callback(&osb->osb_hb_down);
+        status = o2hb_register_callback(osb->uuid_str, &osb->osb_hb_down);
         if (status < 0) {
                 mlog_errno(status);
                 goto bail;
         }
 
-        status = o2hb_register_callback(&osb->osb_hb_up);
+        status = o2hb_register_callback(osb->uuid_str, &osb->osb_hb_up);
         if (status < 0) {
                 mlog_errno(status);
-                o2hb_unregister_callback(&osb->osb_hb_down);
+                o2hb_unregister_callback(osb->uuid_str, &osb->osb_hb_down);
         }
 
 bail:
@@ -178,8 +178,8 @@ void ocfs2_clear_hb_callbacks(struct ocfs2_super *osb)
         if (ocfs2_mount_local(osb))
                 return;
 
-        o2hb_unregister_callback(&osb->osb_hb_down);
-        o2hb_unregister_callback(&osb->osb_hb_up);
+        o2hb_unregister_callback(osb->uuid_str, &osb->osb_hb_down);
+        o2hb_unregister_callback(osb->uuid_str, &osb->osb_hb_up);
 }
 
 void ocfs2_stop_heartbeat(struct ocfs2_super *osb)
diff --git a/fs/ocfs2/ioctl.c b/fs/ocfs2/ioctl.c
index f3ad21ad9ae..bd68c3f2afb 100644
--- a/fs/ocfs2/ioctl.c
+++ b/fs/ocfs2/ioctl.c
@@ -14,6 +14,7 @@
 #include "ocfs2.h"
 #include "alloc.h"
 #include "dlmglue.h"
+#include "file.h"
 #include "inode.h"
 #include "journal.h"
 
@@ -115,6 +116,7 @@ int ocfs2_ioctl(struct inode * inode, struct file * filp,
 {
         unsigned int flags;
         int status;
+        struct ocfs2_space_resv sr;
 
         switch (cmd) {
         case OCFS2_IOC_GETFLAGS:
@@ -130,6 +132,14 @@ int ocfs2_ioctl(struct inode * inode, struct file * filp,
 
                 return ocfs2_set_inode_attr(inode, flags,
                         OCFS2_FL_MODIFIABLE);
+        case OCFS2_IOC_RESVSP:
+        case OCFS2_IOC_RESVSP64:
+        case OCFS2_IOC_UNRESVSP:
+        case OCFS2_IOC_UNRESVSP64:
+                if (copy_from_user(&sr, (int __user *) arg, sizeof(sr)))
+                        return -EFAULT;
+
+                return ocfs2_change_file_space(filp, cmd, &sr);
         default:
                 return -ENOTTY;
         }
@@ -148,6 +158,11 @@ long ocfs2_compat_ioctl(struct file *file, unsigned cmd, unsigned long arg)
         case OCFS2_IOC32_SETFLAGS:
                 cmd = OCFS2_IOC_SETFLAGS;
                 break;
+        case OCFS2_IOC_RESVSP:
+        case OCFS2_IOC_RESVSP64:
+        case OCFS2_IOC_UNRESVSP:
+        case OCFS2_IOC_UNRESVSP64:
+                break;
         default:
                 return -ENOIOCTLCMD;
         }
diff --git a/fs/ocfs2/journal.c b/fs/ocfs2/journal.c
index dc118808172..dbfb20bb27e 100644
--- a/fs/ocfs2/journal.c
+++ b/fs/ocfs2/journal.c
@@ -722,8 +722,7 @@ void ocfs2_complete_recovery(struct work_struct *work)
                 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;
+        struct ocfs2_la_recovery_item *item, *n;
         LIST_HEAD(tmp_la_list);
 
         mlog_entry_void();
@@ -734,8 +733,7 @@ void ocfs2_complete_recovery(struct work_struct *work)
         list_splice_init(&journal->j_la_cleanups, &tmp_la_list);
         spin_unlock(&journal->j_lock);
 
-        list_for_each_safe(p, n, &tmp_la_list) {
-                item = list_entry(p, struct ocfs2_la_recovery_item, lri_list);
+        list_for_each_entry_safe(item, n, &tmp_la_list, lri_list) {
                 list_del_init(&item->lri_list);
 
                 mlog(0, "Complete recovery for slot %d\n", item->lri_slot);
diff --git a/fs/ocfs2/journal.h b/fs/ocfs2/journal.h
index 3db5de4506d..ce60aab013a 100644
--- a/fs/ocfs2/journal.h
+++ b/fs/ocfs2/journal.h
@@ -289,6 +289,8 @@ int                  ocfs2_journal_dirty_data(handle_t *handle,
 #define OCFS2_TRUNCATE_LOG_FLUSH_ONE_REC (OCFS2_SUBALLOC_FREE                 \
                                          + OCFS2_TRUNCATE_LOG_UPDATE)
 
+#define OCFS2_REMOVE_EXTENT_CREDITS (OCFS2_TRUNCATE_LOG_UPDATE + OCFS2_INODE_UPDATE_CREDITS)
+
 /* data block for new dir/symlink, 2 for bitmap updates (bitmap fe +
  * bitmap block for the new bit) */
 #define OCFS2_DIR_LINK_ADDITIONAL_CREDITS (1 + 2)
diff --git a/fs/ocfs2/mmap.c b/fs/ocfs2/mmap.c
index af01158b39f..d79aa12137d 100644
--- a/fs/ocfs2/mmap.c
+++ b/fs/ocfs2/mmap.c
@@ -37,11 +37,29 @@
 
 #include "ocfs2.h"
 
+#include "aops.h"
 #include "dlmglue.h"
 #include "file.h"
 #include "inode.h"
 #include "mmap.h"
 
+static inline int ocfs2_vm_op_block_sigs(sigset_t *blocked, sigset_t *oldset)
+{
+        /* The best way to deal with signals in the vm path is
+         * to block them upfront, rather than allowing the
+         * locking paths to return -ERESTARTSYS. */
+        sigfillset(blocked);
+
+        /* We should technically never get a bad return value
+         * from sigprocmask */
+        return sigprocmask(SIG_BLOCK, blocked, oldset);
+}
+
+static inline int ocfs2_vm_op_unblock_sigs(sigset_t *oldset)
+{
+        return sigprocmask(SIG_SETMASK, oldset, NULL);
+}
+
 static struct page *ocfs2_nopage(struct vm_area_struct * area,
                                  unsigned long address,
                                  int *type)
@@ -53,14 +71,7 @@ static struct page *ocfs2_nopage(struct vm_area_struct * area,
         mlog_entry("(area=%p, address=%lu, type=%p)\n", area, address,
                    type);
 
-        /* The best way to deal with signals in this path is
-         * to block them upfront, rather than allowing the
-         * locking paths to return -ERESTARTSYS. */
-        sigfillset(&blocked);
-
-        /* We should technically never get a bad ret return
-         * from sigprocmask */
-        ret = sigprocmask(SIG_BLOCK, &blocked, &oldset);
+        ret = ocfs2_vm_op_block_sigs(&blocked, &oldset);
         if (ret < 0) {
                 mlog_errno(ret);
                 goto out;
@@ -68,7 +79,7 @@ static struct page *ocfs2_nopage(struct vm_area_struct * area,
 
         page = filemap_nopage(area, address, type);
 
-        ret = sigprocmask(SIG_SETMASK, &oldset, NULL);
+        ret = ocfs2_vm_op_unblock_sigs(&oldset);
         if (ret < 0)
                 mlog_errno(ret);
 out:
@@ -76,28 +87,136 @@ out:
         return page;
 }
 
-static struct vm_operations_struct ocfs2_file_vm_ops = {
-        .nopage = ocfs2_nopage,
-};
+static int __ocfs2_page_mkwrite(struct inode *inode, struct buffer_head *di_bh,
+                                struct page *page)
+{
+        int ret;
+        struct address_space *mapping = inode->i_mapping;
+        loff_t pos = page->index << PAGE_CACHE_SHIFT;
+        unsigned int len = PAGE_CACHE_SIZE;
+        pgoff_t last_index;
+        struct page *locked_page = NULL;
+        void *fsdata;
+        loff_t size = i_size_read(inode);
 
-int ocfs2_mmap(struct file *file, struct vm_area_struct *vma)
+        /*
+         * Another node might have truncated while we were waiting on
+         * cluster locks.
+         */
+        last_index = size >> PAGE_CACHE_SHIFT;
+        if (page->index > last_index) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        /*
+         * The i_size check above doesn't catch the case where nodes
+         * truncated and then re-extended the file. We'll re-check the
+         * page mapping after taking the page lock inside of
+         * ocfs2_write_begin_nolock().
+         */
+        if (!PageUptodate(page) || page->mapping != inode->i_mapping) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        /*
+         * Call ocfs2_write_begin() and ocfs2_write_end() to take
+         * advantage of the allocation code there. We pass a write
+         * length of the whole page (chopped to i_size) to make sure
+         * the whole thing is allocated.
+         *
+         * Since we know the page is up to date, we don't have to
+         * worry about ocfs2_write_begin() skipping some buffer reads
+         * because the "write" would invalidate their data.
+         */
+        if (page->index == last_index)
+                len = size & ~PAGE_CACHE_MASK;
+
+        ret = ocfs2_write_begin_nolock(mapping, pos, len, 0, &locked_page,
+                                       &fsdata, di_bh, page);
+        if (ret) {
+                if (ret != -ENOSPC)
+                        mlog_errno(ret);
+                goto out;
+        }
+
+        ret = ocfs2_write_end_nolock(mapping, pos, len, len, locked_page,
+                                     fsdata);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto out;
+        }
+        BUG_ON(ret != len);
+        ret = 0;
+out:
+        return ret;
+}
+
+static int ocfs2_page_mkwrite(struct vm_area_struct *vma, struct page *page)
 {
-        int ret = 0, lock_level = 0;
-        struct ocfs2_super *osb = OCFS2_SB(file->f_dentry->d_inode->i_sb);
+        struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
+        struct buffer_head *di_bh = NULL;
+        sigset_t blocked, oldset;
+        int ret, ret2;
+
+        ret = ocfs2_vm_op_block_sigs(&blocked, &oldset);
+        if (ret < 0) {
+                mlog_errno(ret);
+                return ret;
+        }
+
+        /*
+         * The cluster locks taken will block a truncate from another
+         * node. Taking the data lock will also ensure that we don't
+         * attempt page truncation as part of a downconvert.
+         */
+        ret = ocfs2_meta_lock(inode, &di_bh, 1);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto out;
+        }
 
         /*
-         * Only support shared writeable mmap for local mounts which
-         * don't know about holes.
+         * The alloc sem should be enough to serialize with
+         * ocfs2_truncate_file() changing i_size as well as any thread
+         * modifying the inode btree.
          */
-        if ((!ocfs2_mount_local(osb) || ocfs2_sparse_alloc(osb)) &&
-            ((vma->vm_flags & VM_SHARED) || (vma->vm_flags & VM_MAYSHARE)) &&
-            ((vma->vm_flags & VM_WRITE) || (vma->vm_flags & VM_MAYWRITE))) {
-                mlog(0, "disallow shared writable mmaps %lx\n", vma->vm_flags);
-                /* This is -EINVAL because generic_file_readonly_mmap
-                 * returns it in a similar situation. */
-                return -EINVAL;
+        down_write(&OCFS2_I(inode)->ip_alloc_sem);
+
+        ret = ocfs2_data_lock(inode, 1);
+        if (ret < 0) {
+                mlog_errno(ret);
+                goto out_meta_unlock;
         }
 
+        ret = __ocfs2_page_mkwrite(inode, di_bh, page);
+
+        ocfs2_data_unlock(inode, 1);
+
+out_meta_unlock:
+        up_write(&OCFS2_I(inode)->ip_alloc_sem);
+
+        brelse(di_bh);
+        ocfs2_meta_unlock(inode, 1);
+
+out:
+        ret2 = ocfs2_vm_op_unblock_sigs(&oldset);
+        if (ret2 < 0)
+                mlog_errno(ret2);
+
+        return ret;
+}
+
+static struct vm_operations_struct ocfs2_file_vm_ops = {
+        .nopage         = ocfs2_nopage,
+        .page_mkwrite   = ocfs2_page_mkwrite,
+};
+
+int ocfs2_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        int ret = 0, lock_level = 0;
+
         ret = ocfs2_meta_lock_atime(file->f_dentry->d_inode,
                                     file->f_vfsmnt, &lock_level);
         if (ret < 0) {
diff --git a/fs/ocfs2/namei.c b/fs/ocfs2/namei.c
index 36289e6295c..d430fdab16e 100644
--- a/fs/ocfs2/namei.c
+++ b/fs/ocfs2/namei.c
@@ -1674,7 +1674,7 @@ static int ocfs2_symlink(struct inode *dir,
                 u32 offset = 0;
 
                 inode->i_op = &ocfs2_symlink_inode_operations;
-                status = ocfs2_do_extend_allocation(osb, inode, &offset, 1,
+                status = ocfs2_do_extend_allocation(osb, inode, &offset, 1, 0,
                                                     new_fe_bh,
                                                     handle, data_ac, NULL,
                                                     NULL);
diff --git a/fs/ocfs2/ocfs2.h b/fs/ocfs2/ocfs2.h
index a860633e833..5cc90a40b3c 100644
--- a/fs/ocfs2/ocfs2.h
+++ b/fs/ocfs2/ocfs2.h
@@ -219,6 +219,7 @@ struct ocfs2_super
         u16 max_slots;
         s16 node_num;
         s16 slot_num;
+        s16 preferred_slot;
         int s_sectsize_bits;
         int s_clustersize;
         int s_clustersize_bits;
@@ -305,6 +306,19 @@ static inline int ocfs2_sparse_alloc(struct ocfs2_super *osb)
         return 0;
 }
 
+static inline int ocfs2_writes_unwritten_extents(struct ocfs2_super *osb)
+{
+        /*
+         * Support for sparse files is a pre-requisite
+         */
+        if (!ocfs2_sparse_alloc(osb))
+                return 0;
+
+        if (osb->s_feature_ro_compat & OCFS2_FEATURE_RO_COMPAT_UNWRITTEN)
+                return 1;
+        return 0;
+}
+
 /* set / clear functions because cluster events can make these happen
  * in parallel so we want the transitions to be atomic. this also
  * means that any future flags osb_flags must be protected by spinlock
diff --git a/fs/ocfs2/ocfs2_fs.h b/fs/ocfs2/ocfs2_fs.h
index f0d9eb08547..82f8a75b207 100644
--- a/fs/ocfs2/ocfs2_fs.h
+++ b/fs/ocfs2/ocfs2_fs.h
@@ -88,7 +88,7 @@
 #define OCFS2_FEATURE_COMPAT_SUPP       OCFS2_FEATURE_COMPAT_BACKUP_SB
 #define OCFS2_FEATURE_INCOMPAT_SUPP     (OCFS2_FEATURE_INCOMPAT_LOCAL_MOUNT \
                                          | OCFS2_FEATURE_INCOMPAT_SPARSE_ALLOC)
-#define OCFS2_FEATURE_RO_COMPAT_SUPP    0
+#define OCFS2_FEATURE_RO_COMPAT_SUPP    OCFS2_FEATURE_RO_COMPAT_UNWRITTEN
 
 /*
  * Heartbeat-only devices are missing journals and other files.  The
@@ -116,6 +116,11 @@
  */
 #define OCFS2_FEATURE_COMPAT_BACKUP_SB          0x0001
 
+/*
+ * Unwritten extents support.
+ */
+#define OCFS2_FEATURE_RO_COMPAT_UNWRITTEN       0x0001
+
 /* The byte offset of the first backup block will be 1G.
  * The following will be 4G, 16G, 64G, 256G and 1T.
  */
@@ -170,6 +175,32 @@
 #define OCFS2_IOC32_SETFLAGS    _IOW('f', 2, int)
 
 /*
+ * Space reservation / allocation / free ioctls and argument structure
+ * are designed to be compatible with XFS.
+ *
+ * ALLOCSP* and FREESP* are not and will never be supported, but are
+ * included here for completeness.
+ */
+struct ocfs2_space_resv {
+        __s16           l_type;
+        __s16           l_whence;
+        __s64           l_start;
+        __s64           l_len;          /* len == 0 means until end of file */
+        __s32           l_sysid;
+        __u32           l_pid;
+        __s32           l_pad[4];       /* reserve area                     */
+};
+
+#define OCFS2_IOC_ALLOCSP               _IOW ('X', 10, struct ocfs2_space_resv)
+#define OCFS2_IOC_FREESP                _IOW ('X', 11, struct ocfs2_space_resv)
+#define OCFS2_IOC_RESVSP                _IOW ('X', 40, struct ocfs2_space_resv)
+#define OCFS2_IOC_UNRESVSP      _IOW ('X', 41, struct ocfs2_space_resv)
+#define OCFS2_IOC_ALLOCSP64     _IOW ('X', 36, struct ocfs2_space_resv)
+#define OCFS2_IOC_FREESP64      _IOW ('X', 37, struct ocfs2_space_resv)
+#define OCFS2_IOC_RESVSP64      _IOW ('X', 42, struct ocfs2_space_resv)
+#define OCFS2_IOC_UNRESVSP64    _IOW ('X', 43, struct ocfs2_space_resv)
+
+/*
  * Journal Flags (ocfs2_dinode.id1.journal1.i_flags)
  */
 #define OCFS2_JOURNAL_DIRTY_FL  (0x00000001)    /* Journal needs recovery */
diff --git a/fs/ocfs2/slot_map.c b/fs/ocfs2/slot_map.c
index d8b79067dc1..af4882b62cf 100644
--- a/fs/ocfs2/slot_map.c
+++ b/fs/ocfs2/slot_map.c
@@ -121,17 +121,25 @@ static s16 __ocfs2_node_num_to_slot(struct ocfs2_slot_info *si,
         return ret;
 }
 
-static s16 __ocfs2_find_empty_slot(struct ocfs2_slot_info *si)
+static s16 __ocfs2_find_empty_slot(struct ocfs2_slot_info *si, s16 preferred)
 {
         int i;
         s16 ret = OCFS2_INVALID_SLOT;
 
+        if (preferred >= 0 && preferred < si->si_num_slots) {
+                if (OCFS2_INVALID_SLOT == si->si_global_node_nums[preferred]) {
+                        ret = preferred;
+                        goto out;
+                }
+        }
+
         for(i = 0; i < si->si_num_slots; i++) {
                 if (OCFS2_INVALID_SLOT == si->si_global_node_nums[i]) {
                         ret = (s16) i;
                         break;
                 }
         }
+out:
         return ret;
 }
 
@@ -248,7 +256,7 @@ int ocfs2_find_slot(struct ocfs2_super *osb)
         if (slot == OCFS2_INVALID_SLOT) {
                 /* if no slot yet, then just take 1st available
                  * one. */
-                slot = __ocfs2_find_empty_slot(si);
+                slot = __ocfs2_find_empty_slot(si, osb->preferred_slot);
                 if (slot == OCFS2_INVALID_SLOT) {
                         spin_unlock(&si->si_lock);
                         mlog(ML_ERROR, "no free slots available!\n");
diff --git a/fs/ocfs2/suballoc.c b/fs/ocfs2/suballoc.c
index e3437626d18..d9c5c9fcb30 100644
--- a/fs/ocfs2/suballoc.c
+++ b/fs/ocfs2/suballoc.c
@@ -98,14 +98,6 @@ static int ocfs2_relink_block_group(handle_t *handle,
                                     u16 chain);
 static inline int ocfs2_block_group_reasonably_empty(struct ocfs2_group_desc *bg,
                                                      u32 wanted);
-static int ocfs2_free_suballoc_bits(handle_t *handle,
-                                    struct inode *alloc_inode,
-                                    struct buffer_head *alloc_bh,
-                                    unsigned int start_bit,
-                                    u64 bg_blkno,
-                                    unsigned int count);
-static inline u64 ocfs2_which_suballoc_group(u64 block,
-                                             unsigned int bit);
 static inline u32 ocfs2_desc_bitmap_to_cluster_off(struct inode *inode,
                                                    u64 bg_blkno,
                                                    u16 bg_bit_off);
@@ -496,13 +488,7 @@ int ocfs2_reserve_new_metadata(struct ocfs2_super *osb,
 
         (*ac)->ac_bits_wanted = ocfs2_extend_meta_needed(fe);
         (*ac)->ac_which = OCFS2_AC_USE_META;
-
-#ifndef OCFS2_USE_ALL_METADATA_SUBALLOCATORS
-        slot = 0;
-#else
         slot = osb->slot_num;
-#endif
-
         (*ac)->ac_group_search = ocfs2_block_group_search;
 
         status = ocfs2_reserve_suballoc_bits(osb, (*ac),
@@ -1626,12 +1612,12 @@ bail:
 /*
  * expects the suballoc inode to already be locked.
  */
-static int ocfs2_free_suballoc_bits(handle_t *handle,
-                                    struct inode *alloc_inode,
-                                    struct buffer_head *alloc_bh,
-                                    unsigned int start_bit,
-                                    u64 bg_blkno,
-                                    unsigned int count)
+int ocfs2_free_suballoc_bits(handle_t *handle,
+                             struct inode *alloc_inode,
+                             struct buffer_head *alloc_bh,
+                             unsigned int start_bit,
+                             u64 bg_blkno,
+                             unsigned int count)
 {
         int status = 0;
         u32 tmp_used;
@@ -1703,13 +1689,6 @@ bail:
         return status;
 }
 
-static inline u64 ocfs2_which_suballoc_group(u64 block, unsigned int bit)
-{
-        u64 group = block - (u64) bit;
-
-        return group;
-}
-
 int ocfs2_free_dinode(handle_t *handle,
                       struct inode *inode_alloc_inode,
                       struct buffer_head *inode_alloc_bh,
@@ -1723,19 +1702,6 @@ int ocfs2_free_dinode(handle_t *handle,
                                         inode_alloc_bh, bit, bg_blkno, 1);
 }
 
-int ocfs2_free_extent_block(handle_t *handle,
-                            struct inode *eb_alloc_inode,
-                            struct buffer_head *eb_alloc_bh,
-                            struct ocfs2_extent_block *eb)
-{
-        u64 blk = le64_to_cpu(eb->h_blkno);
-        u16 bit = le16_to_cpu(eb->h_suballoc_bit);
-        u64 bg_blkno = ocfs2_which_suballoc_group(blk, bit);
-
-        return ocfs2_free_suballoc_bits(handle, eb_alloc_inode, eb_alloc_bh,
-                                        bit, bg_blkno, 1);
-}
-
 int ocfs2_free_clusters(handle_t *handle,
                        struct inode *bitmap_inode,
                        struct buffer_head *bitmap_bh,
diff --git a/fs/ocfs2/suballoc.h b/fs/ocfs2/suballoc.h
index 1a3c94cb925..f212dc01a84 100644
--- a/fs/ocfs2/suballoc.h
+++ b/fs/ocfs2/suballoc.h
@@ -86,20 +86,29 @@ int ocfs2_claim_clusters(struct ocfs2_super *osb,
                          u32 *cluster_start,
                          u32 *num_clusters);
 
+int ocfs2_free_suballoc_bits(handle_t *handle,
+                             struct inode *alloc_inode,
+                             struct buffer_head *alloc_bh,
+                             unsigned int start_bit,
+                             u64 bg_blkno,
+                             unsigned int count);
 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(handle_t *handle,
-                            struct inode *eb_alloc_inode,
-                            struct buffer_head *eb_alloc_bh,
-                            struct ocfs2_extent_block *eb);
 int ocfs2_free_clusters(handle_t *handle,
                         struct inode *bitmap_inode,
                         struct buffer_head *bitmap_bh,
                         u64 start_blk,
                         unsigned int num_clusters);
 
+static inline u64 ocfs2_which_suballoc_group(u64 block, unsigned int bit)
+{
+        u64 group = block - (u64) bit;
+
+        return group;
+}
+
 static inline u32 ocfs2_cluster_from_desc(struct ocfs2_super *osb,
                                           u64 bg_blkno)
 {
diff --git a/fs/ocfs2/super.c b/fs/ocfs2/super.c
index 86b559c7dce..3a5a1ed09ac 100644
--- a/fs/ocfs2/super.c
+++ b/fs/ocfs2/super.c
@@ -82,7 +82,8 @@ MODULE_AUTHOR("Oracle");
 MODULE_LICENSE("GPL");
 
 static int ocfs2_parse_options(struct super_block *sb, char *options,
-                               unsigned long *mount_opt, int is_remount);
+                               unsigned long *mount_opt, s16 *slot,
+                               int is_remount);
 static void ocfs2_put_super(struct super_block *sb);
 static int ocfs2_mount_volume(struct super_block *sb);
 static int ocfs2_remount(struct super_block *sb, int *flags, char *data);
@@ -114,8 +115,6 @@ static void ocfs2_write_super(struct super_block *sb);
 static struct inode *ocfs2_alloc_inode(struct super_block *sb);
 static void ocfs2_destroy_inode(struct inode *inode);
 
-static unsigned long long ocfs2_max_file_offset(unsigned int blockshift);
-
 static const struct super_operations ocfs2_sops = {
         .statfs         = ocfs2_statfs,
         .alloc_inode    = ocfs2_alloc_inode,
@@ -140,6 +139,7 @@ enum {
         Opt_data_ordered,
         Opt_data_writeback,
         Opt_atime_quantum,
+        Opt_slot,
         Opt_err,
 };
 
@@ -154,6 +154,7 @@ static match_table_t tokens = {
         {Opt_data_ordered, "data=ordered"},
         {Opt_data_writeback, "data=writeback"},
         {Opt_atime_quantum, "atime_quantum=%u"},
+        {Opt_slot, "preferred_slot=%u"},
         {Opt_err, NULL}
 };
 
@@ -318,7 +319,7 @@ static void ocfs2_destroy_inode(struct inode *inode)
 /* From xfs_super.c:xfs_max_file_offset
  * Copyright (c) 2000-2004 Silicon Graphics, Inc.
  */
-static unsigned long long ocfs2_max_file_offset(unsigned int blockshift)
+unsigned long long ocfs2_max_file_offset(unsigned int blockshift)
 {
         unsigned int pagefactor = 1;
         unsigned int bitshift = BITS_PER_LONG - 1;
@@ -355,9 +356,10 @@ static int ocfs2_remount(struct super_block *sb, int *flags, char *data)
         int incompat_features;
         int ret = 0;
         unsigned long parsed_options;
+        s16 slot;
         struct ocfs2_super *osb = OCFS2_SB(sb);
 
-        if (!ocfs2_parse_options(sb, data, &parsed_options, 1)) {
+        if (!ocfs2_parse_options(sb, data, &parsed_options, &slot, 1)) {
                 ret = -EINVAL;
                 goto out;
         }
@@ -534,6 +536,7 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
         struct dentry *root;
         int status, sector_size;
         unsigned long parsed_opt;
+        s16 slot;
         struct inode *inode = NULL;
         struct ocfs2_super *osb = NULL;
         struct buffer_head *bh = NULL;
@@ -541,7 +544,7 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
 
         mlog_entry("%p, %p, %i", sb, data, silent);
 
-        if (!ocfs2_parse_options(sb, data, &parsed_opt, 0)) {
+        if (!ocfs2_parse_options(sb, data, &parsed_opt, &slot, 0)) {
                 status = -EINVAL;
                 goto read_super_error;
         }
@@ -571,6 +574,7 @@ static int ocfs2_fill_super(struct super_block *sb, void *data, int silent)
         brelse(bh);
         bh = NULL;
         osb->s_mount_opt = parsed_opt;
+        osb->preferred_slot = slot;
 
         sb->s_magic = OCFS2_SUPER_MAGIC;
 
@@ -713,6 +717,7 @@ static struct file_system_type ocfs2_fs_type = {
 static int ocfs2_parse_options(struct super_block *sb,
                                char *options,
                                unsigned long *mount_opt,
+                               s16 *slot,
                                int is_remount)
 {
         int status;
@@ -722,6 +727,7 @@ static int ocfs2_parse_options(struct super_block *sb,
                    options ? options : "(none)");
 
         *mount_opt = 0;
+        *slot = OCFS2_INVALID_SLOT;
 
         if (!options) {
                 status = 1;
@@ -782,6 +788,15 @@ static int ocfs2_parse_options(struct super_block *sb,
                         else
                                 osb->s_atime_quantum = OCFS2_DEFAULT_ATIME_QUANTUM;
                         break;
+                case Opt_slot:
+                        option = 0;
+                        if (match_int(&args[0], &option)) {
+                                status = 0;
+                                goto bail;
+                        }
+                        if (option)
+                                *slot = (s16)option;
+                        break;
                 default:
                         mlog(ML_ERROR,
                              "Unrecognized mount option \"%s\" "
diff --git a/fs/ocfs2/super.h b/fs/ocfs2/super.h
index 783f5270f2a..3b9cb3d0b00 100644
--- a/fs/ocfs2/super.h
+++ b/fs/ocfs2/super.h
@@ -45,4 +45,6 @@ void __ocfs2_abort(struct super_block *sb,
 
 #define ocfs2_abort(sb, fmt, args...) __ocfs2_abort(sb, __PRETTY_FUNCTION__, fmt, ##args)
 
+unsigned long long ocfs2_max_file_offset(unsigned int blockshift);
+
 #endif /* OCFS2_SUPER_H */
diff --git a/fs/open.c b/fs/open.c
index 0d515d16197..be6a457f422 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -855,7 +855,7 @@ EXPORT_SYMBOL(dentry_open);
 /*
  * Find an empty file descriptor entry, and mark it busy.
  */
-int get_unused_fd(void)
+int get_unused_fd_flags(int flags)
 {
         struct files_struct * files = current->files;
         int fd, error;
@@ -891,7 +891,10 @@ repeat:
         }
 
         FD_SET(fd, fdt->open_fds);
-        FD_CLR(fd, fdt->close_on_exec);
+        if (flags & O_CLOEXEC)
+                FD_SET(fd, fdt->close_on_exec);
+        else
+                FD_CLR(fd, fdt->close_on_exec);
         files->next_fd = fd + 1;
 #if 1
         /* Sanity check */
@@ -907,6 +910,11 @@ out:
         return error;
 }
 
+int get_unused_fd(void)
+{
+        return get_unused_fd_flags(0);
+}
+
 EXPORT_SYMBOL(get_unused_fd);
 
 static void __put_unused_fd(struct files_struct *files, unsigned int fd)
@@ -959,7 +967,7 @@ long do_sys_open(int dfd, const char __user *filename, int flags, int mode)
         int fd = PTR_ERR(tmp);
 
         if (!IS_ERR(tmp)) {
-                fd = get_unused_fd();
+                fd = get_unused_fd_flags(flags);
                 if (fd >= 0) {
                         struct file *f = do_filp_open(dfd, tmp, flags, mode);
                         if (IS_ERR(f)) {
diff --git a/fs/partitions/acorn.c b/fs/partitions/acorn.c
index e3491328596..3d3e1663147 100644
--- a/fs/partitions/acorn.c
+++ b/fs/partitions/acorn.c
@@ -25,6 +25,8 @@
 #define PARTITION_RISCIX_SCSI   2
 #define PARTITION_LINUX         9
 
+#if defined(CONFIG_ACORN_PARTITION_CUMANA) || \
+        defined(CONFIG_ACORN_PARTITION_ADFS)
 static struct adfs_discrecord *
 adfs_partition(struct parsed_partitions *state, char *name, char *data,
                unsigned long first_sector, int slot)
@@ -48,6 +50,7 @@ adfs_partition(struct parsed_partitions *state, char *name, char *data,
         put_partition(state, slot, first_sector, nr_sects);
         return dr;
 }
+#endif
 
 #ifdef CONFIG_ACORN_PARTITION_RISCIX
 
@@ -65,6 +68,8 @@ struct riscix_record {
         struct riscix_part part[8];
 };
 
+#if defined(CONFIG_ACORN_PARTITION_CUMANA) || \
+        defined(CONFIG_ACORN_PARTITION_ADFS)
 static int
 riscix_partition(struct parsed_partitions *state, struct block_device *bdev,
                 unsigned long first_sect, int slot, unsigned long nr_sects)
@@ -105,6 +110,7 @@ riscix_partition(struct parsed_partitions *state, struct block_device *bdev,
         return slot;
 }
 #endif
+#endif
 
 #define LINUX_NATIVE_MAGIC 0xdeafa1de
 #define LINUX_SWAP_MAGIC   0xdeafab1e
@@ -115,6 +121,8 @@ struct linux_part {
         __le32 nr_sects;
 };
 
+#if defined(CONFIG_ACORN_PARTITION_CUMANA) || \
+        defined(CONFIG_ACORN_PARTITION_ADFS)
 static int
 linux_partition(struct parsed_partitions *state, struct block_device *bdev,
                 unsigned long first_sect, int slot, unsigned long nr_sects)
@@ -146,6 +154,7 @@ linux_partition(struct parsed_partitions *state, struct block_device *bdev,
         put_dev_sector(sect);
         return slot;
 }
+#endif
 
 #ifdef CONFIG_ACORN_PARTITION_CUMANA
 int
diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index 9a3a058f355..98e0b85a9bb 100644
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -397,7 +397,6 @@ void add_partition(struct gendisk *disk, int part, sector_t start, sector_t len,
                 static struct attribute addpartattr = {
                         .name = "whole_disk",
                         .mode = S_IRUSR | S_IRGRP | S_IROTH,
-                        .owner = THIS_MODULE,
                 };
 
                 sysfs_create_file(&p->kobj, &addpartattr);
diff --git a/fs/partitions/ldm.c b/fs/partitions/ldm.c
index 99873a2b4cb..e7dd1d4e347 100644
--- a/fs/partitions/ldm.c
+++ b/fs/partitions/ldm.c
@@ -677,15 +677,24 @@ static bool ldm_create_data_partitions (struct parsed_partitions *pp,
  * Return:  -1 Error, the calculated offset exceeded the size of the buffer
  *           n OK, a range-checked offset into buffer
  */
-static int ldm_relative (const u8 *buffer, int buflen, int base, int offset)
+static int ldm_relative(const u8 *buffer, int buflen, int base, int offset)
 {
 
         base += offset;
-        if ((!buffer) || (offset < 0) || (base > buflen))
+        if (!buffer || offset < 0 || base > buflen) {
+                if (!buffer)
+                        ldm_error("!buffer");
+                if (offset < 0)
+                        ldm_error("offset (%d) < 0", offset);
+                if (base > buflen)
+                        ldm_error("base (%d) > buflen (%d)", base, buflen);
                 return -1;
-        if ((base + buffer[base]) >= buflen)
+        }
+        if (base + buffer[base] >= buflen) {
+                ldm_error("base (%d) + buffer[base] (%d) >= buflen (%d)", base,
+                                buffer[base], buflen);
                 return -1;
-
+        }
         return buffer[base] + offset + 1;
 }
 
@@ -1054,60 +1063,98 @@ static bool ldm_parse_prt3(const u8 *buffer, int buflen, struct vblk *vb)
  * Return:  'true'   @vb contains a Volume VBLK
  *          'false'  @vb contents are not defined
  */
-static bool ldm_parse_vol5 (const u8 *buffer, int buflen, struct vblk *vb)
+static bool ldm_parse_vol5(const u8 *buffer, int buflen, struct vblk *vb)
 {
-        int r_objid, r_name, r_vtype, r_child, r_size, r_id1, r_id2, r_size2;
-        int r_drive, len;
+        int r_objid, r_name, r_vtype, r_disable_drive_letter, r_child, r_size;
+        int r_id1, r_id2, r_size2, r_drive, len;
         struct vblk_volu *volu;
 
-        BUG_ON (!buffer || !vb);
-
-        r_objid  = ldm_relative (buffer, buflen, 0x18, 0);
-        r_name   = ldm_relative (buffer, buflen, 0x18, r_objid);
-        r_vtype  = ldm_relative (buffer, buflen, 0x18, r_name);
-        r_child  = ldm_relative (buffer, buflen, 0x2E, r_vtype);
-        r_size   = ldm_relative (buffer, buflen, 0x3E, r_child);
-
-        if (buffer[0x12] & VBLK_FLAG_VOLU_ID1)
-                r_id1 = ldm_relative (buffer, buflen, 0x53, r_size);
-        else
+        BUG_ON(!buffer || !vb);
+        r_objid = ldm_relative(buffer, buflen, 0x18, 0);
+        if (r_objid < 0) {
+                ldm_error("r_objid %d < 0", r_objid);
+                return false;
+        }
+        r_name = ldm_relative(buffer, buflen, 0x18, r_objid);
+        if (r_name < 0) {
+                ldm_error("r_name %d < 0", r_name);
+                return false;
+        }
+        r_vtype = ldm_relative(buffer, buflen, 0x18, r_name);
+        if (r_vtype < 0) {
+                ldm_error("r_vtype %d < 0", r_vtype);
+                return false;
+        }
+        r_disable_drive_letter = ldm_relative(buffer, buflen, 0x18, r_vtype);
+        if (r_disable_drive_letter < 0) {
+                ldm_error("r_disable_drive_letter %d < 0",
+                                r_disable_drive_letter);
+                return false;
+        }
+        r_child = ldm_relative(buffer, buflen, 0x2D, r_disable_drive_letter);
+        if (r_child < 0) {
+                ldm_error("r_child %d < 0", r_child);
+                return false;
+        }
+        r_size = ldm_relative(buffer, buflen, 0x3D, r_child);
+        if (r_size < 0) {
+                ldm_error("r_size %d < 0", r_size);
+                return false;
+        }
+        if (buffer[0x12] & VBLK_FLAG_VOLU_ID1) {
+                r_id1 = ldm_relative(buffer, buflen, 0x52, r_size);
+                if (r_id1 < 0) {
+                        ldm_error("r_id1 %d < 0", r_id1);
+                        return false;
+                }
+        } else
                 r_id1 = r_size;
-
-        if (buffer[0x12] & VBLK_FLAG_VOLU_ID2)
-                r_id2 = ldm_relative (buffer, buflen, 0x53, r_id1);
-        else
+        if (buffer[0x12] & VBLK_FLAG_VOLU_ID2) {
+                r_id2 = ldm_relative(buffer, buflen, 0x52, r_id1);
+                if (r_id2 < 0) {
+                        ldm_error("r_id2 %d < 0", r_id2);
+                        return false;
+                }
+        } else
                 r_id2 = r_id1;
-
-        if (buffer[0x12] & VBLK_FLAG_VOLU_SIZE)
-                r_size2 = ldm_relative (buffer, buflen, 0x53, r_id2);
-        else
+        if (buffer[0x12] & VBLK_FLAG_VOLU_SIZE) {
+                r_size2 = ldm_relative(buffer, buflen, 0x52, r_id2);
+                if (r_size2 < 0) {
+                        ldm_error("r_size2 %d < 0", r_size2);
+                        return false;
+                }
+        } else
                 r_size2 = r_id2;
-
-        if (buffer[0x12] & VBLK_FLAG_VOLU_DRIVE)
-                r_drive = ldm_relative (buffer, buflen, 0x53, r_size2);
-        else
+        if (buffer[0x12] & VBLK_FLAG_VOLU_DRIVE) {
+                r_drive = ldm_relative(buffer, buflen, 0x52, r_size2);
+                if (r_drive < 0) {
+                        ldm_error("r_drive %d < 0", r_drive);
+                        return false;
+                }
+        } else
                 r_drive = r_size2;
-
         len = r_drive;
-        if (len < 0)
+        if (len < 0) {
+                ldm_error("len %d < 0", len);
                 return false;
-
+        }
         len += VBLK_SIZE_VOL5;
-        if (len != BE32 (buffer + 0x14))
+        if (len > BE32(buffer + 0x14)) {
+                ldm_error("len %d > BE32(buffer + 0x14) %d", len,
+                                BE32(buffer + 0x14));
                 return false;
-
+        }
         volu = &vb->vblk.volu;
-
-        ldm_get_vstr (buffer + 0x18 + r_name,  volu->volume_type,
-                sizeof (volu->volume_type));
-        memcpy (volu->volume_state, buffer + 0x19 + r_vtype,
-                        sizeof (volu->volume_state));
-        volu->size = ldm_get_vnum (buffer + 0x3E + r_child);
-        volu->partition_type = buffer[0x42 + r_size];
-        memcpy (volu->guid, buffer + 0x43 + r_size,  sizeof (volu->guid));
+        ldm_get_vstr(buffer + 0x18 + r_name, volu->volume_type,
+                        sizeof(volu->volume_type));
+        memcpy(volu->volume_state, buffer + 0x18 + r_disable_drive_letter,
+                        sizeof(volu->volume_state));
+        volu->size = ldm_get_vnum(buffer + 0x3D + r_child);
+        volu->partition_type = buffer[0x41 + r_size];
+        memcpy(volu->guid, buffer + 0x42 + r_size, sizeof(volu->guid));
         if (buffer[0x12] & VBLK_FLAG_VOLU_DRIVE) {
-                ldm_get_vstr (buffer + 0x53 + r_size,  volu->drive_hint,
-                        sizeof (volu->drive_hint));
+                ldm_get_vstr(buffer + 0x52 + r_size, volu->drive_hint,
+                                sizeof(volu->drive_hint));
         }
         return true;
 }
diff --git a/fs/partitions/ldm.h b/fs/partitions/ldm.h
index d2e6a304693..80f63b5fdd9 100644
--- a/fs/partitions/ldm.h
+++ b/fs/partitions/ldm.h
@@ -68,7 +68,7 @@ struct parsed_partitions;
 #define VBLK_SIZE_DSK3          12
 #define VBLK_SIZE_DSK4          45
 #define VBLK_SIZE_PRT3          28
-#define VBLK_SIZE_VOL5          59
+#define VBLK_SIZE_VOL5          58
 
 /* component types */
 #define COMP_STRIPE             0x01            /* Stripe-set */
diff --git a/fs/proc/array.c b/fs/proc/array.c
index 98e78e2f18d..965625a0977 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -62,6 +62,8 @@
 #include <linux/mman.h>
 #include <linux/proc_fs.h>
 #include <linux/ioport.h>
+#include <linux/uaccess.h>
+#include <linux/io.h>
 #include <linux/mm.h>
 #include <linux/hugetlb.h>
 #include <linux/pagemap.h>
@@ -76,9 +78,7 @@
 #include <linux/rcupdate.h>
 #include <linux/delayacct.h>
 
-#include <asm/uaccess.h>
 #include <asm/pgtable.h>
-#include <asm/io.h>
 #include <asm/processor.h>
 #include "internal.h"
 
@@ -87,10 +87,10 @@
 do { memcpy(buffer, string, strlen(string)); \
      buffer += strlen(string); } while (0)
 
-static inline char * task_name(struct task_struct *p, char * buf)
+static inline char *task_name(struct task_struct *p, char *buf)
 {
         int i;
-        char * name;
+        char *name;
         char tcomm[sizeof(p->comm)];
 
         get_task_comm(tcomm, p);
@@ -138,7 +138,7 @@ static const char *task_state_array[] = {
         "X (dead)"              /* 32 */
 };
 
-static inline const char * get_task_state(struct task_struct *tsk)
+static inline const char *get_task_state(struct task_struct *tsk)
 {
         unsigned int state = (tsk->state & (TASK_RUNNING |
                                             TASK_INTERRUPTIBLE |
@@ -156,7 +156,7 @@ static inline const char * get_task_state(struct task_struct *tsk)
         return *p;
 }
 
-static inline char * task_state(struct task_struct *p, char *buffer)
+static inline char *task_state(struct task_struct *p, char *buffer)
 {
         struct group_info *group_info;
         int g;
@@ -172,8 +172,8 @@ static inline char * task_state(struct task_struct *p, char *buffer)
                 "Uid:\t%d\t%d\t%d\t%d\n"
                 "Gid:\t%d\t%d\t%d\t%d\n",
                 get_task_state(p),
-                p->tgid, p->pid,
-                pid_alive(p) ? rcu_dereference(p->real_parent)->tgid : 0,
+                p->tgid, p->pid,
+                pid_alive(p) ? rcu_dereference(p->real_parent)->tgid : 0,
                 pid_alive(p) && p->ptrace ? rcu_dereference(p->parent)->pid : 0,
                 p->uid, p->euid, p->suid, p->fsuid,
                 p->gid, p->egid, p->sgid, p->fsgid);
@@ -191,15 +191,15 @@ static inline char * task_state(struct task_struct *p, char *buffer)
         get_group_info(group_info);
         task_unlock(p);
 
-        for (g = 0; g < min(group_info->ngroups,NGROUPS_SMALL); g++)
-                buffer += sprintf(buffer, "%d ", GROUP_AT(group_info,g));
+        for (g = 0; g < min(group_info->ngroups, NGROUPS_SMALL); g++)
+                buffer += sprintf(buffer, "%d ", GROUP_AT(group_info, g));
         put_group_info(group_info);
 
         buffer += sprintf(buffer, "\n");
         return buffer;
 }
 
-static char * render_sigset_t(const char *header, sigset_t *set, char *buffer)
+static char *render_sigset_t(const char *header, sigset_t *set, char *buffer)
 {
         int i, len;
 
@@ -239,7 +239,7 @@ static void collect_sigign_sigcatch(struct task_struct *p, sigset_t *ign,
         }
 }
 
-static inline char * task_sig(struct task_struct *p, char *buffer)
+static inline char *task_sig(struct task_struct *p, char *buffer)
 {
         unsigned long flags;
         sigset_t pending, shpending, blocked, ignored, caught;
@@ -289,14 +289,23 @@ static inline char *task_cap(struct task_struct *p, char *buffer)
                             cap_t(p->cap_effective));
 }
 
-int proc_pid_status(struct task_struct *task, char * buffer)
+static inline char *task_context_switch_counts(struct task_struct *p,
+                                                char *buffer)
 {
-        char * orig = buffer;
+        return buffer + sprintf(buffer, "voluntary_ctxt_switches:\t%lu\n"
+                            "nonvoluntary_ctxt_switches:\t%lu\n",
+                            p->nvcsw,
+                            p->nivcsw);
+}
+
+int proc_pid_status(struct task_struct *task, char *buffer)
+{
+        char *orig = buffer;
         struct mm_struct *mm = get_task_mm(task);
 
         buffer = task_name(task, buffer);
         buffer = task_state(task, buffer);
- 
+
         if (mm) {
                 buffer = task_mem(mm, buffer);
                 mmput(mm);
@@ -307,6 +316,7 @@ int proc_pid_status(struct task_struct *task, char * buffer)
 #if defined(CONFIG_S390)
         buffer = task_show_regs(task, buffer);
 #endif
+        buffer = task_context_switch_counts(task, buffer);
         return buffer - orig;
 }
 
@@ -332,7 +342,7 @@ static clock_t task_utime(struct task_struct *p)
 
 static clock_t task_stime(struct task_struct *p)
 {
-        clock_t stime = cputime_to_clock_t(p->stime);
+        clock_t stime;
 
         /*
          * Use CFS's precise accounting. (we subtract utime from
@@ -344,8 +354,7 @@ static clock_t task_stime(struct task_struct *p)
         return stime;
 }
 
-
-static int do_task_stat(struct task_struct *task, char * buffer, int whole)
+static int do_task_stat(struct task_struct *task, char *buffer, int whole)
 {
         unsigned long vsize, eip, esp, wchan = ~0UL;
         long priority, nice;
@@ -353,7 +362,7 @@ static int do_task_stat(struct task_struct *task, char * buffer, int whole)
         sigset_t sigign, sigcatch;
         char state;
         int res;
-        pid_t ppid = 0, pgid = -1, sid = -1;
+        pid_t ppid = 0, pgid = -1, sid = -1;
         int num_threads = 0;
         struct mm_struct *mm;
         unsigned long long start_time;
@@ -424,7 +433,7 @@ static int do_task_stat(struct task_struct *task, char * buffer, int whole)
         }
         rcu_read_unlock();
 
-        if (!whole || num_threads<2)
+        if (!whole || num_threads < 2)
                 wchan = get_wchan(task);
         if (!whole) {
                 min_flt = task->min_flt;
@@ -440,12 +449,13 @@ static int do_task_stat(struct task_struct *task, char * buffer, int whole)
 
         /* Temporary variable needed for gcc-2.96 */
         /* convert timespec -> nsec*/
-        start_time = (unsigned long long)task->start_time.tv_sec * NSEC_PER_SEC
-                                + task->start_time.tv_nsec;
+        start_time =
+                (unsigned long long)task->real_start_time.tv_sec * NSEC_PER_SEC
+                                + task->real_start_time.tv_nsec;
         /* convert nsec -> ticks */
         start_time = nsec_to_clock_t(start_time);
 
-        res = sprintf(buffer,"%d (%s) %c %d %d %d %d %d %u %lu \
+        res = sprintf(buffer, "%d (%s) %c %d %d %d %d %d %u %lu \
 %lu %lu %lu %lu %lu %ld %ld %ld %ld %d 0 %llu %lu %ld %lu %lu %lu %lu %lu \
 %lu %lu %lu %lu %lu %lu %lu %lu %d %d %u %u %llu\n",
                 task->pid,
@@ -471,7 +481,7 @@ static int do_task_stat(struct task_struct *task, char * buffer, int whole)
                 start_time,
                 vsize,
                 mm ? get_mm_rss(mm) : 0,
-                rsslim,
+                rsslim,
                 mm ? mm->start_code : 0,
                 mm ? mm->end_code : 0,
                 mm ? mm->start_stack : 0,
@@ -493,17 +503,17 @@ static int do_task_stat(struct task_struct *task, char * buffer, int whole)
                 task->rt_priority,
                 task->policy,
                 (unsigned long long)delayacct_blkio_ticks(task));
-        if(mm)
+        if (mm)
                 mmput(mm);
         return res;
 }
 
-int proc_tid_stat(struct task_struct *task, char * buffer)
+int proc_tid_stat(struct task_struct *task, char *buffer)
 {
         return do_task_stat(task, buffer, 0);
 }
 
-int proc_tgid_stat(struct task_struct *task, char * buffer)
+int proc_tgid_stat(struct task_struct *task, char *buffer)
 {
         return do_task_stat(task, buffer, 1);
 }
@@ -512,12 +522,12 @@ int proc_pid_statm(struct task_struct *task, char *buffer)
 {
         int size = 0, resident = 0, shared = 0, text = 0, lib = 0, data = 0;
         struct mm_struct *mm = get_task_mm(task);
-        
+
         if (mm) {
                 size = task_statm(mm, &shared, &text, &data, &resident);
                 mmput(mm);
         }
 
-        return sprintf(buffer,"%d %d %d %d %d %d %d\n",
+        return sprintf(buffer, "%d %d %d %d %d %d %d\n",
                        size, resident, shared, text, lib, data, 0);
 }
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 46ea5d56e1b..ae3627337a9 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -67,7 +67,6 @@
 #include <linux/mount.h>
 #include <linux/security.h>
 #include <linux/ptrace.h>
-#include <linux/seccomp.h>
 #include <linux/cpuset.h>
 #include <linux/audit.h>
 #include <linux/poll.h>
@@ -204,12 +203,17 @@ static int proc_pid_environ(struct task_struct *task, char * buffer)
         int res = 0;
         struct mm_struct *mm = get_task_mm(task);
         if (mm) {
-                unsigned int len = mm->env_end - mm->env_start;
+                unsigned int len;
+
+                res = -ESRCH;
+                if (!ptrace_may_attach(task))
+                        goto out;
+
+                len  = mm->env_end - mm->env_start;
                 if (len > PAGE_SIZE)
                         len = PAGE_SIZE;
                 res = access_process_vm(task, mm->env_start, buffer, len, 0);
-                if (!ptrace_may_attach(task))
-                        res = -ESRCH;
+out:
                 mmput(mm);
         }
         return res;
@@ -812,71 +816,6 @@ static const struct file_operations proc_loginuid_operations = {
 };
 #endif
 
-#ifdef CONFIG_SECCOMP
-static ssize_t seccomp_read(struct file *file, char __user *buf,
-                            size_t count, loff_t *ppos)
-{
-        struct task_struct *tsk = get_proc_task(file->f_dentry->d_inode);
-        char __buf[20];
-        size_t len;
-
-        if (!tsk)
-                return -ESRCH;
-        /* no need to print the trailing zero, so use only len */
-        len = sprintf(__buf, "%u\n", tsk->seccomp.mode);
-        put_task_struct(tsk);
-
-        return simple_read_from_buffer(buf, count, ppos, __buf, len);
-}
-
-static ssize_t seccomp_write(struct file *file, const char __user *buf,
-                             size_t count, loff_t *ppos)
-{
-        struct task_struct *tsk = get_proc_task(file->f_dentry->d_inode);
-        char __buf[20], *end;
-        unsigned int seccomp_mode;
-        ssize_t result;
-
-        result = -ESRCH;
-        if (!tsk)
-                goto out_no_task;
-
-        /* can set it only once to be even more secure */
-        result = -EPERM;
-        if (unlikely(tsk->seccomp.mode))
-                goto out;
-
-        result = -EFAULT;
-        memset(__buf, 0, sizeof(__buf));
-        count = min(count, sizeof(__buf) - 1);
-        if (copy_from_user(__buf, buf, count))
-                goto out;
-
-        seccomp_mode = simple_strtoul(__buf, &end, 0);
-        if (*end == '\n')
-                end++;
-        result = -EINVAL;
-        if (seccomp_mode && seccomp_mode <= NR_SECCOMP_MODES) {
-                tsk->seccomp.mode = seccomp_mode;
-                set_tsk_thread_flag(tsk, TIF_SECCOMP);
-        } else
-                goto out;
-        result = -EIO;
-        if (unlikely(!(end - __buf)))
-                goto out;
-        result = end - __buf;
-out:
-        put_task_struct(tsk);
-out_no_task:
-        return result;
-}
-
-static const struct file_operations proc_seccomp_operations = {
-        .read           = seccomp_read,
-        .write          = seccomp_write,
-};
-#endif /* CONFIG_SECCOMP */
-
 #ifdef CONFIG_FAULT_INJECTION
 static ssize_t proc_fault_inject_read(struct file * file, char __user * buf,
                                       size_t count, loff_t *ppos)
@@ -2037,9 +1976,6 @@ static const struct pid_entry tgid_base_stuff[] = {
         REG("numa_maps",  S_IRUGO, numa_maps),
 #endif
         REG("mem",        S_IRUSR|S_IWUSR, mem),
-#ifdef CONFIG_SECCOMP
-        REG("seccomp",    S_IRUSR|S_IWUSR, seccomp),
-#endif
         LNK("cwd",        cwd),
         LNK("root",       root),
         LNK("exe",        exe),
@@ -2324,9 +2260,6 @@ static const struct pid_entry tid_base_stuff[] = {
         REG("numa_maps", S_IRUGO, numa_maps),
 #endif
         REG("mem",       S_IRUSR|S_IWUSR, mem),
-#ifdef CONFIG_SECCOMP
-        REG("seccomp",   S_IRUSR|S_IWUSR, seccomp),
-#endif
         LNK("cwd",       cwd),
         LNK("root",      root),
         LNK("exe",       exe),
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index 8a40e15f5ec..b5e7155d30d 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -20,6 +20,7 @@
 #include <linux/namei.h>
 #include <linux/bitops.h>
 #include <linux/spinlock.h>
+#include <linux/completion.h>
 #include <asm/uaccess.h>
 
 #include "internal.h"
@@ -529,12 +530,6 @@ static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp
                 return -EAGAIN;
         dp->low_ino = i;
 
-        spin_lock(&proc_subdir_lock);
-        dp->next = dir->subdir;
-        dp->parent = dir;
-        dir->subdir = dp;
-        spin_unlock(&proc_subdir_lock);
-
         if (S_ISDIR(dp->mode)) {
                 if (dp->proc_iops == NULL) {
                         dp->proc_fops = &proc_dir_operations;
@@ -550,6 +545,13 @@ static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp
                 if (dp->proc_iops == NULL)
                         dp->proc_iops = &proc_file_inode_operations;
         }
+
+        spin_lock(&proc_subdir_lock);
+        dp->next = dir->subdir;
+        dp->parent = dir;
+        dir->subdir = dp;
+        spin_unlock(&proc_subdir_lock);
+
         return 0;
 }
 
@@ -613,6 +615,9 @@ static struct proc_dir_entry *proc_create(struct proc_dir_entry **parent,
         ent->namelen = len;
         ent->mode = mode;
         ent->nlink = nlink;
+        ent->pde_users = 0;
+        spin_lock_init(&ent->pde_unload_lock);
+        ent->pde_unload_completion = NULL;
  out:
         return ent;
 }
@@ -649,9 +654,6 @@ struct proc_dir_entry *proc_mkdir_mode(const char *name, mode_t mode,
 
         ent = proc_create(&parent, name, S_IFDIR | mode, 2);
         if (ent) {
-                ent->proc_fops = &proc_dir_operations;
-                ent->proc_iops = &proc_dir_inode_operations;
-
                 if (proc_register(parent, ent) < 0) {
                         kfree(ent);
                         ent = NULL;
@@ -686,10 +688,6 @@ struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,
 
         ent = proc_create(&parent,name,mode,nlink);
         if (ent) {
-                if (S_ISDIR(mode)) {
-                        ent->proc_fops = &proc_dir_operations;
-                        ent->proc_iops = &proc_dir_inode_operations;
-                }
                 if (proc_register(parent, ent) < 0) {
                         kfree(ent);
                         ent = NULL;
@@ -734,9 +732,35 @@ void remove_proc_entry(const char *name, struct proc_dir_entry *parent)
                 de = *p;
                 *p = de->next;
                 de->next = NULL;
+
+                spin_lock(&de->pde_unload_lock);
+                /*
+                 * Stop accepting new callers into module. If you're
+                 * dynamically allocating ->proc_fops, save a pointer somewhere.
+                 */
+                de->proc_fops = NULL;
+                /* Wait until all existing callers into module are done. */
+                if (de->pde_users > 0) {
+                        DECLARE_COMPLETION_ONSTACK(c);
+
+                        if (!de->pde_unload_completion)
+                                de->pde_unload_completion = &c;
+
+                        spin_unlock(&de->pde_unload_lock);
+                        spin_unlock(&proc_subdir_lock);
+
+                        wait_for_completion(de->pde_unload_completion);
+
+                        spin_lock(&proc_subdir_lock);
+                        goto continue_removing;
+                }
+                spin_unlock(&de->pde_unload_lock);
+
+continue_removing:
                 if (S_ISDIR(de->mode))
                         parent->nlink--;
-                proc_kill_inodes(de);
+                if (!S_ISREG(de->mode))
+                        proc_kill_inodes(de);
                 de->nlink = 0;
                 WARN_ON(de->subdir);
                 if (!atomic_read(&de->count))
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index d5ce65c68d7..dd28e86ab42 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -10,6 +10,7 @@
 #include <linux/mm.h>
 #include <linux/string.h>
 #include <linux/stat.h>
+#include <linux/completion.h>
 #include <linux/file.h>
 #include <linux/limits.h>
 #include <linux/init.h>
@@ -140,6 +141,251 @@ static const struct super_operations proc_sops = {
         .remount_fs     = proc_remount,
 };
 
+static void pde_users_dec(struct proc_dir_entry *pde)
+{
+        spin_lock(&pde->pde_unload_lock);
+        pde->pde_users--;
+        if (pde->pde_unload_completion && pde->pde_users == 0)
+                complete(pde->pde_unload_completion);
+        spin_unlock(&pde->pde_unload_lock);
+}
+
+static loff_t proc_reg_llseek(struct file *file, loff_t offset, int whence)
+{
+        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        loff_t rv = -EINVAL;
+        loff_t (*llseek)(struct file *, loff_t, int);
+
+        spin_lock(&pde->pde_unload_lock);
+        /*
+         * remove_proc_entry() is going to delete PDE (as part of module
+         * cleanup sequence). No new callers into module allowed.
+         */
+        if (!pde->proc_fops) {
+                spin_unlock(&pde->pde_unload_lock);
+                return rv;
+        }
+        /*
+         * Bump refcount so that remove_proc_entry will wail for ->llseek to
+         * complete.
+         */
+        pde->pde_users++;
+        /*
+         * Save function pointer under lock, to protect against ->proc_fops
+         * NULL'ifying right after ->pde_unload_lock is dropped.
+         */
+        llseek = pde->proc_fops->llseek;
+        spin_unlock(&pde->pde_unload_lock);
+
+        if (!llseek)
+                llseek = default_llseek;
+        rv = llseek(file, offset, whence);
+
+        pde_users_dec(pde);
+        return rv;
+}
+
+static ssize_t proc_reg_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
+{
+        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        ssize_t rv = -EIO;
+        ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
+
+        spin_lock(&pde->pde_unload_lock);
+        if (!pde->proc_fops) {
+                spin_unlock(&pde->pde_unload_lock);
+                return rv;
+        }
+        pde->pde_users++;
+        read = pde->proc_fops->read;
+        spin_unlock(&pde->pde_unload_lock);
+
+        if (read)
+                rv = read(file, buf, count, ppos);
+
+        pde_users_dec(pde);
+        return rv;
+}
+
+static ssize_t proc_reg_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
+{
+        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        ssize_t rv = -EIO;
+        ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
+
+        spin_lock(&pde->pde_unload_lock);
+        if (!pde->proc_fops) {
+                spin_unlock(&pde->pde_unload_lock);
+                return rv;
+        }
+        pde->pde_users++;
+        write = pde->proc_fops->write;
+        spin_unlock(&pde->pde_unload_lock);
+
+        if (write)
+                rv = write(file, buf, count, ppos);
+
+        pde_users_dec(pde);
+        return rv;
+}
+
+static unsigned int proc_reg_poll(struct file *file, struct poll_table_struct *pts)
+{
+        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        unsigned int rv = 0;
+        unsigned int (*poll)(struct file *, struct poll_table_struct *);
+
+        spin_lock(&pde->pde_unload_lock);
+        if (!pde->proc_fops) {
+                spin_unlock(&pde->pde_unload_lock);
+                return rv;
+        }
+        pde->pde_users++;
+        poll = pde->proc_fops->poll;
+        spin_unlock(&pde->pde_unload_lock);
+
+        if (poll)
+                rv = poll(file, pts);
+
+        pde_users_dec(pde);
+        return rv;
+}
+
+static long proc_reg_unlocked_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        long rv = -ENOTTY;
+        long (*unlocked_ioctl)(struct file *, unsigned int, unsigned long);
+        int (*ioctl)(struct inode *, struct file *, unsigned int, unsigned long);
+
+        spin_lock(&pde->pde_unload_lock);
+        if (!pde->proc_fops) {
+                spin_unlock(&pde->pde_unload_lock);
+                return rv;
+        }
+        pde->pde_users++;
+        unlocked_ioctl = pde->proc_fops->unlocked_ioctl;
+        ioctl = pde->proc_fops->ioctl;
+        spin_unlock(&pde->pde_unload_lock);
+
+        if (unlocked_ioctl) {
+                rv = unlocked_ioctl(file, cmd, arg);
+                if (rv == -ENOIOCTLCMD)
+                        rv = -EINVAL;
+        } else if (ioctl) {
+                lock_kernel();
+                rv = ioctl(file->f_path.dentry->d_inode, file, cmd, arg);
+                unlock_kernel();
+        }
+
+        pde_users_dec(pde);
+        return rv;
+}
+
+#ifdef CONFIG_COMPAT
+static long proc_reg_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        long rv = -ENOTTY;
+        long (*compat_ioctl)(struct file *, unsigned int, unsigned long);
+
+        spin_lock(&pde->pde_unload_lock);
+        if (!pde->proc_fops) {
+                spin_unlock(&pde->pde_unload_lock);
+                return rv;
+        }
+        pde->pde_users++;
+        compat_ioctl = pde->proc_fops->compat_ioctl;
+        spin_unlock(&pde->pde_unload_lock);
+
+        if (compat_ioctl)
+                rv = compat_ioctl(file, cmd, arg);
+
+        pde_users_dec(pde);
+        return rv;
+}
+#endif
+
+static int proc_reg_mmap(struct file *file, struct vm_area_struct *vma)
+{
+        struct proc_dir_entry *pde = PDE(file->f_path.dentry->d_inode);
+        int rv = -EIO;
+        int (*mmap)(struct file *, struct vm_area_struct *);
+
+        spin_lock(&pde->pde_unload_lock);
+        if (!pde->proc_fops) {
+                spin_unlock(&pde->pde_unload_lock);
+                return rv;
+        }
+        pde->pde_users++;
+        mmap = pde->proc_fops->mmap;
+        spin_unlock(&pde->pde_unload_lock);
+
+        if (mmap)
+                rv = mmap(file, vma);
+
+        pde_users_dec(pde);
+        return rv;
+}
+
+static int proc_reg_open(struct inode *inode, struct file *file)
+{
+        struct proc_dir_entry *pde = PDE(inode);
+        int rv = 0;
+        int (*open)(struct inode *, struct file *);
+
+        spin_lock(&pde->pde_unload_lock);
+        if (!pde->proc_fops) {
+                spin_unlock(&pde->pde_unload_lock);
+                return rv;
+        }
+        pde->pde_users++;
+        open = pde->proc_fops->open;
+        spin_unlock(&pde->pde_unload_lock);
+
+        if (open)
+                rv = open(inode, file);
+
+        pde_users_dec(pde);
+        return rv;
+}
+
+static int proc_reg_release(struct inode *inode, struct file *file)
+{
+        struct proc_dir_entry *pde = PDE(inode);
+        int rv = 0;
+        int (*release)(struct inode *, struct file *);
+
+        spin_lock(&pde->pde_unload_lock);
+        if (!pde->proc_fops) {
+                spin_unlock(&pde->pde_unload_lock);
+                return rv;
+        }
+        pde->pde_users++;
+        release = pde->proc_fops->release;
+        spin_unlock(&pde->pde_unload_lock);
+
+        if (release)
+                rv = release(inode, file);
+
+        pde_users_dec(pde);
+        return rv;
+}
+
+static const struct file_operations proc_reg_file_ops = {
+        .llseek         = proc_reg_llseek,
+        .read           = proc_reg_read,
+        .write          = proc_reg_write,
+        .poll           = proc_reg_poll,
+        .unlocked_ioctl = proc_reg_unlocked_ioctl,
+#ifdef CONFIG_COMPAT
+        .compat_ioctl   = proc_reg_compat_ioctl,
+#endif
+        .mmap           = proc_reg_mmap,
+        .open           = proc_reg_open,
+        .release        = proc_reg_release,
+};
+
 struct inode *proc_get_inode(struct super_block *sb, unsigned int ino,
                                 struct proc_dir_entry *de)
 {
@@ -166,8 +412,12 @@ struct inode *proc_get_inode(struct super_block *sb, unsigned int ino,
                         inode->i_nlink = de->nlink;
                 if (de->proc_iops)
                         inode->i_op = de->proc_iops;
-                if (de->proc_fops)
-                        inode->i_fop = de->proc_fops;
+                if (de->proc_fops) {
+                        if (S_ISREG(inode->i_mode))
+                                inode->i_fop = &proc_reg_file_ops;
+                        else
+                                inode->i_fop = de->proc_fops;
+                }
         }
 
         return inode;
diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index 5fd49e47f83..d24b8d46059 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -105,6 +105,7 @@ static int uptime_read_proc(char *page, char **start, off_t off,
         cputime_t idletime = cputime_add(init_task.utime, init_task.stime);
 
         do_posix_clock_monotonic_gettime(&uptime);
+        monotonic_to_bootbased(&uptime);
         cputime_to_timespec(idletime, &idle);
         len = sprintf(page,"%lu.%02lu %lu.%02lu\n",
                         (unsigned long) uptime.tv_sec,
@@ -443,12 +444,12 @@ static int show_stat(struct seq_file *p, void *v)
         unsigned long jif;
         cputime64_t user, nice, system, idle, iowait, irq, softirq, steal;
         u64 sum = 0;
+        struct timespec boottime;
 
         user = nice = system = idle = iowait =
                 irq = softirq = steal = cputime64_zero;
-        jif = - wall_to_monotonic.tv_sec;
-        if (wall_to_monotonic.tv_nsec)
-                --jif;
+        getboottime(&boottime);
+        jif = boottime.tv_sec;
 
         for_each_possible_cpu(i) {
                 int j;
diff --git a/fs/proc/proc_tty.c b/fs/proc/proc_tty.c
index b3a473b0a19..22846225acf 100644
--- a/fs/proc/proc_tty.c
+++ b/fs/proc/proc_tty.c
@@ -69,7 +69,7 @@ static void show_tty_range(struct seq_file *m, struct tty_driver *p,
 
 static int show_tty_driver(struct seq_file *m, void *v)
 {
-        struct tty_driver *p = v;
+        struct tty_driver *p = list_entry(v, struct tty_driver, tty_drivers);
         dev_t from = MKDEV(p->major, p->minor_start);
         dev_t to = from + p->num;
 
@@ -106,22 +106,13 @@ static int show_tty_driver(struct seq_file *m, void *v)
 /* iterator */
 static void *t_start(struct seq_file *m, loff_t *pos)
 {
-        struct list_head *p;
-        loff_t l = *pos;
-
         mutex_lock(&tty_mutex);
-        list_for_each(p, &tty_drivers)
-                if (!l--)
-                        return list_entry(p, struct tty_driver, tty_drivers);
-        return NULL;
+        return seq_list_start(&tty_drivers, *pos);
 }
 
 static void *t_next(struct seq_file *m, void *v, loff_t *pos)
 {
-        struct list_head *p = ((struct tty_driver *)v)->tty_drivers.next;
-        (*pos)++;
-        return p==&tty_drivers ? NULL :
-                        list_entry(p, struct tty_driver, tty_drivers);
+        return seq_list_next(v, &tty_drivers, pos);
 }
 
 static void t_stop(struct seq_file *m, void *v)
diff --git a/fs/quota.c b/fs/quota.c
index 9f237d6182c..e6577ac15a6 100644
--- a/fs/quota.c
+++ b/fs/quota.c
@@ -10,12 +10,14 @@
 #include <linux/slab.h>
 #include <asm/current.h>
 #include <asm/uaccess.h>
+#include <linux/compat.h>
 #include <linux/kernel.h>
 #include <linux/security.h>
 #include <linux/syscalls.h>
 #include <linux/buffer_head.h>
 #include <linux/capability.h>
 #include <linux/quotaops.h>
+#include <linux/types.h>
 
 /* Check validity of generic quotactl commands */
 static int generic_quotactl_valid(struct super_block *sb, int type, int cmd, qid_t id)
@@ -384,3 +386,119 @@ asmlinkage long sys_quotactl(unsigned int cmd, const char __user *special, qid_t
 
         return ret;
 }
+
+#if defined(CONFIG_X86_64) || defined(CONFIG_IA64)
+/*
+ * This code works only for 32 bit quota tools over 64 bit OS (x86_64, ia64)
+ * and is necessary due to alignment problems.
+ */
+struct compat_if_dqblk {
+        compat_u64 dqb_bhardlimit;
+        compat_u64 dqb_bsoftlimit;
+        compat_u64 dqb_curspace;
+        compat_u64 dqb_ihardlimit;
+        compat_u64 dqb_isoftlimit;
+        compat_u64 dqb_curinodes;
+        compat_u64 dqb_btime;
+        compat_u64 dqb_itime;
+        compat_uint_t dqb_valid;
+};
+
+/* XFS structures */
+struct compat_fs_qfilestat {
+        compat_u64 dqb_bhardlimit;
+        compat_u64 qfs_nblks;
+        compat_uint_t qfs_nextents;
+};
+
+struct compat_fs_quota_stat {
+        __s8            qs_version;
+        __u16           qs_flags;
+        __s8            qs_pad;
+        struct compat_fs_qfilestat      qs_uquota;
+        struct compat_fs_qfilestat      qs_gquota;
+        compat_uint_t   qs_incoredqs;
+        compat_int_t    qs_btimelimit;
+        compat_int_t    qs_itimelimit;
+        compat_int_t    qs_rtbtimelimit;
+        __u16           qs_bwarnlimit;
+        __u16           qs_iwarnlimit;
+};
+
+asmlinkage long sys32_quotactl(unsigned int cmd, const char __user *special,
+                                                qid_t id, void __user *addr)
+{
+        unsigned int cmds;
+        struct if_dqblk __user *dqblk;
+        struct compat_if_dqblk __user *compat_dqblk;
+        struct fs_quota_stat __user *fsqstat;
+        struct compat_fs_quota_stat __user *compat_fsqstat;
+        compat_uint_t data;
+        u16 xdata;
+        long ret;
+
+        cmds = cmd >> SUBCMDSHIFT;
+
+        switch (cmds) {
+        case Q_GETQUOTA:
+                dqblk = compat_alloc_user_space(sizeof(struct if_dqblk));
+                compat_dqblk = addr;
+                ret = sys_quotactl(cmd, special, id, dqblk);
+                if (ret)
+                        break;
+                if (copy_in_user(compat_dqblk, dqblk, sizeof(*compat_dqblk)) ||
+                        get_user(data, &dqblk->dqb_valid) ||
+                        put_user(data, &compat_dqblk->dqb_valid))
+                        ret = -EFAULT;
+                break;
+        case Q_SETQUOTA:
+                dqblk = compat_alloc_user_space(sizeof(struct if_dqblk));
+                compat_dqblk = addr;
+                ret = -EFAULT;
+                if (copy_in_user(dqblk, compat_dqblk, sizeof(*compat_dqblk)) ||
+                        get_user(data, &compat_dqblk->dqb_valid) ||
+                        put_user(data, &dqblk->dqb_valid))
+                        break;
+                ret = sys_quotactl(cmd, special, id, dqblk);
+                break;
+        case Q_XGETQSTAT:
+                fsqstat = compat_alloc_user_space(sizeof(struct fs_quota_stat));
+                compat_fsqstat = addr;
+                ret = sys_quotactl(cmd, special, id, fsqstat);
+                if (ret)
+                        break;
+                ret = -EFAULT;
+                /* Copying qs_version, qs_flags, qs_pad */
+                if (copy_in_user(compat_fsqstat, fsqstat,
+                        offsetof(struct compat_fs_quota_stat, qs_uquota)))
+                        break;
+                /* Copying qs_uquota */
+                if (copy_in_user(&compat_fsqstat->qs_uquota,
+                        &fsqstat->qs_uquota,
+                        sizeof(compat_fsqstat->qs_uquota)) ||
+                        get_user(data, &fsqstat->qs_uquota.qfs_nextents) ||
+                        put_user(data, &compat_fsqstat->qs_uquota.qfs_nextents))
+                        break;
+                /* Copying qs_gquota */
+                if (copy_in_user(&compat_fsqstat->qs_gquota,
+                        &fsqstat->qs_gquota,
+                        sizeof(compat_fsqstat->qs_gquota)) ||
+                        get_user(data, &fsqstat->qs_gquota.qfs_nextents) ||
+                        put_user(data, &compat_fsqstat->qs_gquota.qfs_nextents))
+                        break;
+                /* Copying the rest */
+                if (copy_in_user(&compat_fsqstat->qs_incoredqs,
+                        &fsqstat->qs_incoredqs,
+                        sizeof(struct compat_fs_quota_stat) -
+                        offsetof(struct compat_fs_quota_stat, qs_incoredqs)) ||
+                        get_user(xdata, &fsqstat->qs_iwarnlimit) ||
+                        put_user(xdata, &compat_fsqstat->qs_iwarnlimit))
+                        break;
+                ret = 0;
+                break;
+        default:
+                ret = sys_quotactl(cmd, special, id, addr);
+        }
+        return ret;
+}
+#endif
diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index 30eebfb1b2d..2070aeee2a5 100644
--- a/fs/reiserfs/file.c
+++ b/fs/reiserfs/file.c
@@ -1305,7 +1305,6 @@ static ssize_t reiserfs_file_write(struct file *file,	/* the file we are going t
         if (get_inode_item_key_version (inode) == KEY_FORMAT_3_5 &&
             *ppos + count > MAX_NON_LFS) {
                 if (*ppos >= MAX_NON_LFS) {
-                        send_sig(SIGXFSZ, current, 0);
                         return -EFBIG;
                 }
                 if (count > MAX_NON_LFS - (unsigned long)*ppos)
diff --git a/fs/seq_file.c b/fs/seq_file.c
index 49194a4e6b9..bbb19be260c 100644
--- a/fs/seq_file.c
+++ b/fs/seq_file.c
@@ -177,21 +177,23 @@ EXPORT_SYMBOL(seq_read);
 
 static int traverse(struct seq_file *m, loff_t offset)
 {
-        loff_t pos = 0;
+        loff_t pos = 0, index;
         int error = 0;
         void *p;
 
         m->version = 0;
-        m->index = 0;
+        index = 0;
         m->count = m->from = 0;
-        if (!offset)
+        if (!offset) {
+                m->index = index;
                 return 0;
+        }
         if (!m->buf) {
                 m->buf = kmalloc(m->size = PAGE_SIZE, GFP_KERNEL);
                 if (!m->buf)
                         return -ENOMEM;
         }
-        p = m->op->start(m, &m->index);
+        p = m->op->start(m, &index);
         while (p) {
                 error = PTR_ERR(p);
                 if (IS_ERR(p))
@@ -204,15 +206,17 @@ static int traverse(struct seq_file *m, loff_t offset)
                 if (pos + m->count > offset) {
                         m->from = offset - pos;
                         m->count -= m->from;
+                        m->index = index;
                         break;
                 }
                 pos += m->count;
                 m->count = 0;
                 if (pos == offset) {
-                        m->index++;
+                        index++;
+                        m->index = index;
                         break;
                 }
-                p = m->op->next(m, p, &m->index);
+                p = m->op->next(m, p, &index);
         }
         m->op->stop(m, p);
         return error;
@@ -260,8 +264,8 @@ loff_t seq_lseek(struct file *file, loff_t offset, int origin)
                                 }
                         }
         }
-        mutex_unlock(&m->lock);
         file->f_version = m->version;
+        mutex_unlock(&m->lock);
         return retval;
 }
 EXPORT_SYMBOL(seq_lseek);
diff --git a/fs/splice.c b/fs/splice.c
index ed2ce995475..53fc2082a46 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -28,6 +28,7 @@
 #include <linux/module.h>
 #include <linux/syscalls.h>
 #include <linux/uio.h>
+#include <linux/security.h>
 
 /*
  * Attempt to steal a page from a pipe buffer. This should perhaps go into
@@ -491,7 +492,7 @@ ssize_t generic_file_splice_read(struct file *in, loff_t *ppos,
 
         ret = 0;
         spliced = 0;
-        while (len) {
+        while (len && !spliced) {
                 ret = __generic_file_splice_read(in, ppos, pipe, len, flags);
 
                 if (ret < 0)
@@ -961,6 +962,10 @@ static long do_splice_from(struct pipe_inode_info *pipe, struct file *out,
         if (unlikely(ret < 0))
                 return ret;
 
+        ret = security_file_permission(out, MAY_WRITE);
+        if (unlikely(ret < 0))
+                return ret;
+
         return out->f_op->splice_write(pipe, out, ppos, len, flags);
 }
 
@@ -983,6 +988,10 @@ static long do_splice_to(struct file *in, loff_t *ppos,
         if (unlikely(ret < 0))
                 return ret;
 
+        ret = security_file_permission(in, MAY_READ);
+        if (unlikely(ret < 0))
+                return ret;
+
         return in->f_op->splice_read(in, ppos, pipe, len, flags);
 }
 
@@ -1051,15 +1060,11 @@ ssize_t splice_direct_to_actor(struct file *in, struct splice_desc *sd,
         sd->flags &= ~SPLICE_F_NONBLOCK;
 
         while (len) {
-                size_t read_len, max_read_len;
-
-                /*
-                 * Do at most PIPE_BUFFERS pages worth of transfer:
-                 */
-                max_read_len = min(len, (size_t)(PIPE_BUFFERS*PAGE_SIZE));
+                size_t read_len;
+                loff_t pos = sd->pos;
 
-                ret = do_splice_to(in, &sd->pos, pipe, max_read_len, flags);
-                if (unlikely(ret < 0))
+                ret = do_splice_to(in, &pos, pipe, len, flags);
+                if (unlikely(ret <= 0))
                         goto out_release;
 
                 read_len = ret;
@@ -1071,26 +1076,18 @@ ssize_t splice_direct_to_actor(struct file *in, struct splice_desc *sd,
                  * could get stuck data in the internal pipe:
                  */
                 ret = actor(pipe, sd);
-                if (unlikely(ret < 0))
+                if (unlikely(ret <= 0))
                         goto out_release;
 
                 bytes += ret;
                 len -= ret;
+                sd->pos = pos;
 
-                /*
-                 * In nonblocking mode, if we got back a short read then
-                 * that was due to either an IO error or due to the
-                 * pagecache entry not being there. In the IO error case
-                 * the _next_ splice attempt will produce a clean IO error
-                 * return value (not a short read), so in both cases it's
-                 * correct to break out of the loop here:
-                 */
-                if ((flags & SPLICE_F_NONBLOCK) && (read_len < max_read_len))
-                        break;
+                if (ret < read_len)
+                        goto out_release;
         }
 
         pipe->nrbufs = pipe->curbuf = 0;
-
         return bytes;
 
 out_release:
@@ -1152,10 +1149,12 @@ long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
                 .pos            = *ppos,
                 .u.file         = out,
         };
-        size_t ret;
+        long ret;
 
         ret = splice_direct_to_actor(in, &sd, direct_splice_actor);
-        *ppos = sd.pos;
+        if (ret > 0)
+                *ppos += ret;
+
         return ret;
 }
 
diff --git a/fs/super.c b/fs/super.c
index 5260d620c55..fc8ebedc6be 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -884,6 +884,7 @@ vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void
         error = type->get_sb(type, flags, name, data, mnt);
         if (error < 0)
                 goto out_free_secdata;
+        BUG_ON(!mnt->mnt_sb);
 
         error = security_sb_kern_mount(mnt->mnt_sb, secdata);
         if (error)
diff --git a/fs/sysfs/bin.c b/fs/sysfs/bin.c
index d3b9f5f07db..135353f8a29 100644
--- a/fs/sysfs/bin.c
+++ b/fs/sysfs/bin.c
@@ -20,29 +20,41 @@
 
 #include "sysfs.h"
 
+struct bin_buffer {
+        struct mutex    mutex;
+        void            *buffer;
+        int             mmapped;
+};
+
 static int
 fill_read(struct dentry *dentry, char *buffer, loff_t off, size_t count)
 {
-        struct bin_attribute * attr = to_bin_attr(dentry);
-        struct kobject * kobj = to_kobj(dentry->d_parent);
+        struct sysfs_dirent *attr_sd = dentry->d_fsdata;
+        struct bin_attribute *attr = attr_sd->s_elem.bin_attr.bin_attr;
+        struct kobject *kobj = attr_sd->s_parent->s_elem.dir.kobj;
+        int rc;
+
+        /* need attr_sd for attr, its parent for kobj */
+        if (!sysfs_get_active_two(attr_sd))
+                return -ENODEV;
 
-        if (!attr->read)
-                return -EIO;
+        rc = -EIO;
+        if (attr->read)
+                rc = attr->read(kobj, attr, buffer, off, count);
 
-        return attr->read(kobj, buffer, off, count);
+        sysfs_put_active_two(attr_sd);
+
+        return rc;
 }
 
 static ssize_t
-read(struct file * file, char __user * userbuf, size_t count, loff_t * off)
+read(struct file *file, char __user *userbuf, size_t bytes, loff_t *off)
 {
-        char *buffer = file->private_data;
+        struct bin_buffer *bb = file->private_data;
         struct dentry *dentry = file->f_path.dentry;
         int size = dentry->d_inode->i_size;
         loff_t offs = *off;
-        int ret;
-
-        if (count > PAGE_SIZE)
-                count = PAGE_SIZE;
+        int count = min_t(size_t, bytes, PAGE_SIZE);
 
         if (size) {
                 if (offs > size)
@@ -51,43 +63,56 @@ read(struct file * file, char __user * userbuf, size_t count, loff_t * off)
                         count = size - offs;
         }
 
-        ret = fill_read(dentry, buffer, offs, count);
-        if (ret < 0) 
-                return ret;
-        count = ret;
+        mutex_lock(&bb->mutex);
+
+        count = fill_read(dentry, bb->buffer, offs, count);
+        if (count < 0)
+                goto out_unlock;
 
-        if (copy_to_user(userbuf, buffer, count))
-                return -EFAULT;
+        if (copy_to_user(userbuf, bb->buffer, count)) {
+                count = -EFAULT;
+                goto out_unlock;
+        }
 
-        pr_debug("offs = %lld, *off = %lld, count = %zd\n", offs, *off, count);
+        pr_debug("offs = %lld, *off = %lld, count = %d\n", offs, *off, count);
 
         *off = offs + count;
 
+ out_unlock:
+        mutex_unlock(&bb->mutex);
         return count;
 }
 
 static int
 flush_write(struct dentry *dentry, char *buffer, loff_t offset, size_t count)
 {
-        struct bin_attribute *attr = to_bin_attr(dentry);
-        struct kobject *kobj = to_kobj(dentry->d_parent);
+        struct sysfs_dirent *attr_sd = dentry->d_fsdata;
+        struct bin_attribute *attr = attr_sd->s_elem.bin_attr.bin_attr;
+        struct kobject *kobj = attr_sd->s_parent->s_elem.dir.kobj;
+        int rc;
+
+        /* need attr_sd for attr, its parent for kobj */
+        if (!sysfs_get_active_two(attr_sd))
+                return -ENODEV;
+
+        rc = -EIO;
+        if (attr->write)
+                rc = attr->write(kobj, attr, buffer, offset, count);
 
-        if (!attr->write)
-                return -EIO;
+        sysfs_put_active_two(attr_sd);
 
-        return attr->write(kobj, buffer, offset, count);
+        return rc;
 }
 
-static ssize_t write(struct file * file, const char __user * userbuf,
-                     size_t count, loff_t * off)
+static ssize_t write(struct file *file, const char __user *userbuf,
+                     size_t bytes, loff_t *off)
 {
-        char *buffer = file->private_data;
+        struct bin_buffer *bb = file->private_data;
         struct dentry *dentry = file->f_path.dentry;
         int size = dentry->d_inode->i_size;
         loff_t offs = *off;
+        int count = min_t(size_t, bytes, PAGE_SIZE);
 
-        if (count > PAGE_SIZE)
-                count = PAGE_SIZE;
         if (size) {
                 if (offs > size)
                         return 0;
@@ -95,72 +120,100 @@ static ssize_t write(struct file * file, const char __user * userbuf,
                         count = size - offs;
         }
 
-        if (copy_from_user(buffer, userbuf, count))
-                return -EFAULT;
+        mutex_lock(&bb->mutex);
 
-        count = flush_write(dentry, buffer, offs, count);
+        if (copy_from_user(bb->buffer, userbuf, count)) {
+                count = -EFAULT;
+                goto out_unlock;
+        }
+
+        count = flush_write(dentry, bb->buffer, offs, count);
         if (count > 0)
                 *off = offs + count;
+
+ out_unlock:
+        mutex_unlock(&bb->mutex);
         return count;
 }
 
 static int mmap(struct file *file, struct vm_area_struct *vma)
 {
-        struct dentry *dentry = file->f_path.dentry;
-        struct bin_attribute *attr = to_bin_attr(dentry);
-        struct kobject *kobj = to_kobj(dentry->d_parent);
+        struct bin_buffer *bb = file->private_data;
+        struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
+        struct bin_attribute *attr = attr_sd->s_elem.bin_attr.bin_attr;
+        struct kobject *kobj = attr_sd->s_parent->s_elem.dir.kobj;
+        int rc;
+
+        mutex_lock(&bb->mutex);
+
+        /* need attr_sd for attr, its parent for kobj */
+        if (!sysfs_get_active_two(attr_sd))
+                return -ENODEV;
 
-        if (!attr->mmap)
-                return -EINVAL;
+        rc = -EINVAL;
+        if (attr->mmap)
+                rc = attr->mmap(kobj, attr, vma);
 
-        return attr->mmap(kobj, attr, vma);
+        if (rc == 0 && !bb->mmapped)
+                bb->mmapped = 1;
+        else
+                sysfs_put_active_two(attr_sd);
+
+        mutex_unlock(&bb->mutex);
+
+        return rc;
 }
 
 static int open(struct inode * inode, struct file * file)
 {
-        struct kobject *kobj = sysfs_get_kobject(file->f_path.dentry->d_parent);
-        struct bin_attribute * attr = to_bin_attr(file->f_path.dentry);
-        int error = -EINVAL;
-
-        if (!kobj || !attr)
-                goto Done;
+        struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
+        struct bin_attribute *attr = attr_sd->s_elem.bin_attr.bin_attr;
+        struct bin_buffer *bb = NULL;
+        int error;
 
-        /* Grab the module reference for this attribute if we have one */
-        error = -ENODEV;
-        if (!try_module_get(attr->attr.owner)) 
-                goto Done;
+        /* need attr_sd for attr */
+        if (!sysfs_get_active(attr_sd))
+                return -ENODEV;
 
         error = -EACCES;
         if ((file->f_mode & FMODE_WRITE) && !(attr->write || attr->mmap))
-                goto Error;
+                goto err_out;
         if ((file->f_mode & FMODE_READ) && !(attr->read || attr->mmap))
-                goto Error;
+                goto err_out;
 
         error = -ENOMEM;
-        file->private_data = kmalloc(PAGE_SIZE, GFP_KERNEL);
-        if (!file->private_data)
-                goto Error;
-
-        error = 0;
-    goto Done;
-
- Error:
-        module_put(attr->attr.owner);
- Done:
-        if (error)
-                kobject_put(kobj);
+        bb = kzalloc(sizeof(*bb), GFP_KERNEL);
+        if (!bb)
+                goto err_out;
+
+        bb->buffer = kmalloc(PAGE_SIZE, GFP_KERNEL);
+        if (!bb->buffer)
+                goto err_out;
+
+        mutex_init(&bb->mutex);
+        file->private_data = bb;
+
+        /* open succeeded, put active reference and pin attr_sd */
+        sysfs_put_active(attr_sd);
+        sysfs_get(attr_sd);
+        return 0;
+
+ err_out:
+        sysfs_put_active(attr_sd);
+        kfree(bb);
         return error;
 }
 
 static int release(struct inode * inode, struct file * file)
 {
-        struct kobject * kobj = to_kobj(file->f_path.dentry->d_parent);
-        struct bin_attribute * attr = to_bin_attr(file->f_path.dentry);
-        u8 * buffer = file->private_data;
-
-        kobject_put(kobj);
-        module_put(attr->attr.owner);
-        kfree(buffer);
+        struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
+        struct bin_buffer *bb = file->private_data;
+
+        if (bb->mmapped)
+                sysfs_put_active_two(attr_sd);
+        sysfs_put(attr_sd);
+        kfree(bb->buffer);
+        kfree(bb);
         return 0;
 }
 
@@ -181,9 +234,9 @@ const struct file_operations bin_fops = {
 
 int sysfs_create_bin_file(struct kobject * kobj, struct bin_attribute * attr)
 {
-        BUG_ON(!kobj || !kobj->dentry || !attr);
+        BUG_ON(!kobj || !kobj->sd || !attr);
 
-        return sysfs_add_file(kobj->dentry, &attr->attr, SYSFS_KOBJ_BIN_ATTR);
+        return sysfs_add_file(kobj->sd, &attr->attr, SYSFS_KOBJ_BIN_ATTR);
 }
 
 
@@ -195,7 +248,7 @@ int sysfs_create_bin_file(struct kobject * kobj, struct bin_attribute * attr)
 
 void sysfs_remove_bin_file(struct kobject * kobj, struct bin_attribute * attr)
 {
-        if (sysfs_hash_and_remove(kobj->dentry, attr->attr.name) < 0) {
+        if (sysfs_hash_and_remove(kobj->sd, attr->attr.name) < 0) {
                 printk(KERN_ERR "%s: "
                         "bad dentry or inode or no such file: \"%s\"\n",
                         __FUNCTION__, attr->attr.name);
diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index c4342a01997..aee966c44aa 100644
--- a/fs/sysfs/dir.c
+++ b/fs/sysfs/dir.c
@@ -9,21 +9,337 @@
 #include <linux/module.h>
 #include <linux/kobject.h>
 #include <linux/namei.h>
+#include <linux/idr.h>
+#include <linux/completion.h>
 #include <asm/semaphore.h>
 #include "sysfs.h"
 
-DECLARE_RWSEM(sysfs_rename_sem);
-spinlock_t sysfs_lock = SPIN_LOCK_UNLOCKED;
+DEFINE_MUTEX(sysfs_mutex);
+spinlock_t sysfs_assoc_lock = SPIN_LOCK_UNLOCKED;
+
+static spinlock_t sysfs_ino_lock = SPIN_LOCK_UNLOCKED;
+static DEFINE_IDA(sysfs_ino_ida);
+
+/**
+ *      sysfs_link_sibling - link sysfs_dirent into sibling list
+ *      @sd: sysfs_dirent of interest
+ *
+ *      Link @sd into its sibling list which starts from
+ *      sd->s_parent->s_children.
+ *
+ *      Locking:
+ *      mutex_lock(sysfs_mutex)
+ */
+void sysfs_link_sibling(struct sysfs_dirent *sd)
+{
+        struct sysfs_dirent *parent_sd = sd->s_parent;
+
+        BUG_ON(sd->s_sibling);
+        sd->s_sibling = parent_sd->s_children;
+        parent_sd->s_children = sd;
+}
+
+/**
+ *      sysfs_unlink_sibling - unlink sysfs_dirent from sibling list
+ *      @sd: sysfs_dirent of interest
+ *
+ *      Unlink @sd from its sibling list which starts from
+ *      sd->s_parent->s_children.
+ *
+ *      Locking:
+ *      mutex_lock(sysfs_mutex)
+ */
+void sysfs_unlink_sibling(struct sysfs_dirent *sd)
+{
+        struct sysfs_dirent **pos;
+
+        for (pos = &sd->s_parent->s_children; *pos; pos = &(*pos)->s_sibling) {
+                if (*pos == sd) {
+                        *pos = sd->s_sibling;
+                        sd->s_sibling = NULL;
+                        break;
+                }
+        }
+}
+
+/**
+ *      sysfs_get_dentry - get dentry for the given sysfs_dirent
+ *      @sd: sysfs_dirent of interest
+ *
+ *      Get dentry for @sd.  Dentry is looked up if currently not
+ *      present.  This function climbs sysfs_dirent tree till it
+ *      reaches a sysfs_dirent with valid dentry attached and descends
+ *      down from there looking up dentry for each step.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep)
+ *
+ *      RETURNS:
+ *      Pointer to found dentry on success, ERR_PTR() value on error.
+ */
+struct dentry *sysfs_get_dentry(struct sysfs_dirent *sd)
+{
+        struct sysfs_dirent *cur;
+        struct dentry *parent_dentry, *dentry;
+        int i, depth;
+
+        /* Find the first parent which has valid s_dentry and get the
+         * dentry.
+         */
+        mutex_lock(&sysfs_mutex);
+ restart0:
+        spin_lock(&sysfs_assoc_lock);
+ restart1:
+        spin_lock(&dcache_lock);
+
+        dentry = NULL;
+        depth = 0;
+        cur = sd;
+        while (!cur->s_dentry || !cur->s_dentry->d_inode) {
+                if (cur->s_flags & SYSFS_FLAG_REMOVED) {
+                        dentry = ERR_PTR(-ENOENT);
+                        depth = 0;
+                        break;
+                }
+                cur = cur->s_parent;
+                depth++;
+        }
+        if (!IS_ERR(dentry))
+                dentry = dget_locked(cur->s_dentry);
+
+        spin_unlock(&dcache_lock);
+        spin_unlock(&sysfs_assoc_lock);
+
+        /* from the found dentry, look up depth times */
+        while (depth--) {
+                /* find and get depth'th ancestor */
+                for (cur = sd, i = 0; cur && i < depth; i++)
+                        cur = cur->s_parent;
+
+                /* This can happen if tree structure was modified due
+                 * to move/rename.  Restart.
+                 */
+                if (i != depth) {
+                        dput(dentry);
+                        goto restart0;
+                }
+
+                sysfs_get(cur);
+
+                mutex_unlock(&sysfs_mutex);
+
+                /* look it up */
+                parent_dentry = dentry;
+                dentry = lookup_one_len_kern(cur->s_name, parent_dentry,
+                                             strlen(cur->s_name));
+                dput(parent_dentry);
+
+                if (IS_ERR(dentry)) {
+                        sysfs_put(cur);
+                        return dentry;
+                }
+
+                mutex_lock(&sysfs_mutex);
+                spin_lock(&sysfs_assoc_lock);
+
+                /* This, again, can happen if tree structure has
+                 * changed and we looked up the wrong thing.  Restart.
+                 */
+                if (cur->s_dentry != dentry) {
+                        dput(dentry);
+                        sysfs_put(cur);
+                        goto restart1;
+                }
+
+                spin_unlock(&sysfs_assoc_lock);
+
+                sysfs_put(cur);
+        }
+
+        mutex_unlock(&sysfs_mutex);
+        return dentry;
+}
+
+/**
+ *      sysfs_get_active - get an active reference to sysfs_dirent
+ *      @sd: sysfs_dirent to get an active reference to
+ *
+ *      Get an active reference of @sd.  This function is noop if @sd
+ *      is NULL.
+ *
+ *      RETURNS:
+ *      Pointer to @sd on success, NULL on failure.
+ */
+struct sysfs_dirent *sysfs_get_active(struct sysfs_dirent *sd)
+{
+        if (unlikely(!sd))
+                return NULL;
+
+        while (1) {
+                int v, t;
+
+                v = atomic_read(&sd->s_active);
+                if (unlikely(v < 0))
+                        return NULL;
+
+                t = atomic_cmpxchg(&sd->s_active, v, v + 1);
+                if (likely(t == v))
+                        return sd;
+                if (t < 0)
+                        return NULL;
+
+                cpu_relax();
+        }
+}
+
+/**
+ *      sysfs_put_active - put an active reference to sysfs_dirent
+ *      @sd: sysfs_dirent to put an active reference to
+ *
+ *      Put an active reference to @sd.  This function is noop if @sd
+ *      is NULL.
+ */
+void sysfs_put_active(struct sysfs_dirent *sd)
+{
+        struct completion *cmpl;
+        int v;
+
+        if (unlikely(!sd))
+                return;
+
+        v = atomic_dec_return(&sd->s_active);
+        if (likely(v != SD_DEACTIVATED_BIAS))
+                return;
+
+        /* atomic_dec_return() is a mb(), we'll always see the updated
+         * sd->s_sibling.
+         */
+        cmpl = (void *)sd->s_sibling;
+        complete(cmpl);
+}
+
+/**
+ *      sysfs_get_active_two - get active references to sysfs_dirent and parent
+ *      @sd: sysfs_dirent of interest
+ *
+ *      Get active reference to @sd and its parent.  Parent's active
+ *      reference is grabbed first.  This function is noop if @sd is
+ *      NULL.
+ *
+ *      RETURNS:
+ *      Pointer to @sd on success, NULL on failure.
+ */
+struct sysfs_dirent *sysfs_get_active_two(struct sysfs_dirent *sd)
+{
+        if (sd) {
+                if (sd->s_parent && unlikely(!sysfs_get_active(sd->s_parent)))
+                        return NULL;
+                if (unlikely(!sysfs_get_active(sd))) {
+                        sysfs_put_active(sd->s_parent);
+                        return NULL;
+                }
+        }
+        return sd;
+}
+
+/**
+ *      sysfs_put_active_two - put active references to sysfs_dirent and parent
+ *      @sd: sysfs_dirent of interest
+ *
+ *      Put active references to @sd and its parent.  This function is
+ *      noop if @sd is NULL.
+ */
+void sysfs_put_active_two(struct sysfs_dirent *sd)
+{
+        if (sd) {
+                sysfs_put_active(sd);
+                sysfs_put_active(sd->s_parent);
+        }
+}
+
+/**
+ *      sysfs_deactivate - deactivate sysfs_dirent
+ *      @sd: sysfs_dirent to deactivate
+ *
+ *      Deny new active references and drain existing ones.
+ */
+static void sysfs_deactivate(struct sysfs_dirent *sd)
+{
+        DECLARE_COMPLETION_ONSTACK(wait);
+        int v;
+
+        BUG_ON(sd->s_sibling || !(sd->s_flags & SYSFS_FLAG_REMOVED));
+        sd->s_sibling = (void *)&wait;
+
+        /* atomic_add_return() is a mb(), put_active() will always see
+         * the updated sd->s_sibling.
+         */
+        v = atomic_add_return(SD_DEACTIVATED_BIAS, &sd->s_active);
+
+        if (v != SD_DEACTIVATED_BIAS)
+                wait_for_completion(&wait);
+
+        sd->s_sibling = NULL;
+}
+
+static int sysfs_alloc_ino(ino_t *pino)
+{
+        int ino, rc;
+
+ retry:
+        spin_lock(&sysfs_ino_lock);
+        rc = ida_get_new_above(&sysfs_ino_ida, 2, &ino);
+        spin_unlock(&sysfs_ino_lock);
+
+        if (rc == -EAGAIN) {
+                if (ida_pre_get(&sysfs_ino_ida, GFP_KERNEL))
+                        goto retry;
+                rc = -ENOMEM;
+        }
+
+        *pino = ino;
+        return rc;
+}
+
+static void sysfs_free_ino(ino_t ino)
+{
+        spin_lock(&sysfs_ino_lock);
+        ida_remove(&sysfs_ino_ida, ino);
+        spin_unlock(&sysfs_ino_lock);
+}
+
+void release_sysfs_dirent(struct sysfs_dirent * sd)
+{
+        struct sysfs_dirent *parent_sd;
+
+ repeat:
+        /* Moving/renaming is always done while holding reference.
+         * sd->s_parent won't change beneath us.
+         */
+        parent_sd = sd->s_parent;
+
+        if (sysfs_type(sd) == SYSFS_KOBJ_LINK)
+                sysfs_put(sd->s_elem.symlink.target_sd);
+        if (sysfs_type(sd) & SYSFS_COPY_NAME)
+                kfree(sd->s_name);
+        kfree(sd->s_iattr);
+        sysfs_free_ino(sd->s_ino);
+        kmem_cache_free(sysfs_dir_cachep, sd);
+
+        sd = parent_sd;
+        if (sd && atomic_dec_and_test(&sd->s_count))
+                goto repeat;
+}
 
 static void sysfs_d_iput(struct dentry * dentry, struct inode * inode)
 {
         struct sysfs_dirent * sd = dentry->d_fsdata;
 
         if (sd) {
-                /* sd->s_dentry is protected with sysfs_lock.  This
-                 * allows sysfs_drop_dentry() to dereference it.
+                /* sd->s_dentry is protected with sysfs_assoc_lock.
+                 * This allows sysfs_drop_dentry() to dereference it.
                  */
-                spin_lock(&sysfs_lock);
+                spin_lock(&sysfs_assoc_lock);
 
                 /* The dentry might have been deleted or another
                  * lookup could have happened updating sd->s_dentry to
@@ -32,7 +348,7 @@ static void sysfs_d_iput(struct dentry * dentry, struct inode * inode)
                  */
                 if (sd->s_dentry == dentry)
                         sd->s_dentry = NULL;
-                spin_unlock(&sysfs_lock);
+                spin_unlock(&sysfs_assoc_lock);
                 sysfs_put(sd);
         }
         iput(inode);
@@ -42,260 +358,402 @@ static struct dentry_operations sysfs_dentry_ops = {
         .d_iput         = sysfs_d_iput,
 };
 
-static unsigned int sysfs_inode_counter;
-ino_t sysfs_get_inum(void)
+struct sysfs_dirent *sysfs_new_dirent(const char *name, umode_t mode, int type)
 {
-        if (unlikely(sysfs_inode_counter < 3))
-                sysfs_inode_counter = 3;
-        return sysfs_inode_counter++;
-}
+        char *dup_name = NULL;
+        struct sysfs_dirent *sd = NULL;
 
-/*
- * Allocates a new sysfs_dirent and links it to the parent sysfs_dirent
- */
-static struct sysfs_dirent * __sysfs_new_dirent(void * element)
-{
-        struct sysfs_dirent * sd;
+        if (type & SYSFS_COPY_NAME) {
+                name = dup_name = kstrdup(name, GFP_KERNEL);
+                if (!name)
+                        goto err_out;
+        }
 
         sd = kmem_cache_zalloc(sysfs_dir_cachep, GFP_KERNEL);
         if (!sd)
-                return NULL;
+                goto err_out;
+
+        if (sysfs_alloc_ino(&sd->s_ino))
+                goto err_out;
 
-        sd->s_ino = sysfs_get_inum();
         atomic_set(&sd->s_count, 1);
+        atomic_set(&sd->s_active, 0);
         atomic_set(&sd->s_event, 1);
-        INIT_LIST_HEAD(&sd->s_children);
-        INIT_LIST_HEAD(&sd->s_sibling);
-        sd->s_element = element;
+
+        sd->s_name = name;
+        sd->s_mode = mode;
+        sd->s_flags = type;
 
         return sd;
+
+ err_out:
+        kfree(dup_name);
+        kmem_cache_free(sysfs_dir_cachep, sd);
+        return NULL;
 }
 
-static void __sysfs_list_dirent(struct sysfs_dirent *parent_sd,
-                              struct sysfs_dirent *sd)
+/**
+ *      sysfs_attach_dentry - associate sysfs_dirent with dentry
+ *      @sd: target sysfs_dirent
+ *      @dentry: dentry to associate
+ *
+ *      Associate @sd with @dentry.  This is protected by
+ *      sysfs_assoc_lock to avoid race with sysfs_d_iput().
+ *
+ *      LOCKING:
+ *      mutex_lock(sysfs_mutex)
+ */
+static void sysfs_attach_dentry(struct sysfs_dirent *sd, struct dentry *dentry)
 {
-        if (sd)
-                list_add(&sd->s_sibling, &parent_sd->s_children);
+        dentry->d_op = &sysfs_dentry_ops;
+        dentry->d_fsdata = sysfs_get(sd);
+
+        /* protect sd->s_dentry against sysfs_d_iput */
+        spin_lock(&sysfs_assoc_lock);
+        sd->s_dentry = dentry;
+        spin_unlock(&sysfs_assoc_lock);
+
+        d_rehash(dentry);
 }
 
-static struct sysfs_dirent * sysfs_new_dirent(struct sysfs_dirent *parent_sd,
-                                                void * element)
+static int sysfs_ilookup_test(struct inode *inode, void *arg)
 {
-        struct sysfs_dirent *sd;
-        sd = __sysfs_new_dirent(element);
-        __sysfs_list_dirent(parent_sd, sd);
-        return sd;
+        struct sysfs_dirent *sd = arg;
+        return inode->i_ino == sd->s_ino;
 }
 
-/*
+/**
+ *      sysfs_addrm_start - prepare for sysfs_dirent add/remove
+ *      @acxt: pointer to sysfs_addrm_cxt to be used
+ *      @parent_sd: parent sysfs_dirent
  *
- * Return -EEXIST if there is already a sysfs element with the same name for
- * the same parent.
+ *      This function is called when the caller is about to add or
+ *      remove sysfs_dirent under @parent_sd.  This function acquires
+ *      sysfs_mutex, grabs inode for @parent_sd if available and lock
+ *      i_mutex of it.  @acxt is used to keep and pass context to
+ *      other addrm functions.
  *
- * called with parent inode's i_mutex held
+ *      LOCKING:
+ *      Kernel thread context (may sleep).  sysfs_mutex is locked on
+ *      return.  i_mutex of parent inode is locked on return if
+ *      available.
  */
-int sysfs_dirent_exist(struct sysfs_dirent *parent_sd,
-                          const unsigned char *new)
+void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt,
+                       struct sysfs_dirent *parent_sd)
 {
-        struct sysfs_dirent * sd;
+        struct inode *inode;
 
-        list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
-                if (sd->s_element) {
-                        const unsigned char *existing = sysfs_get_name(sd);
-                        if (strcmp(existing, new))
-                                continue;
-                        else
-                                return -EEXIST;
-                }
-        }
+        memset(acxt, 0, sizeof(*acxt));
+        acxt->parent_sd = parent_sd;
 
-        return 0;
+        /* Lookup parent inode.  inode initialization and I_NEW
+         * clearing are protected by sysfs_mutex.  By grabbing it and
+         * looking up with _nowait variant, inode state can be
+         * determined reliably.
+         */
+        mutex_lock(&sysfs_mutex);
+
+        inode = ilookup5_nowait(sysfs_sb, parent_sd->s_ino, sysfs_ilookup_test,
+                                parent_sd);
+
+        if (inode && !(inode->i_state & I_NEW)) {
+                /* parent inode available */
+                acxt->parent_inode = inode;
+
+                /* sysfs_mutex is below i_mutex in lock hierarchy.
+                 * First, trylock i_mutex.  If fails, unlock
+                 * sysfs_mutex and lock them in order.
+                 */
+                if (!mutex_trylock(&inode->i_mutex)) {
+                        mutex_unlock(&sysfs_mutex);
+                        mutex_lock(&inode->i_mutex);
+                        mutex_lock(&sysfs_mutex);
+                }
+        } else
+                iput(inode);
 }
 
+/**
+ *      sysfs_add_one - add sysfs_dirent to parent
+ *      @acxt: addrm context to use
+ *      @sd: sysfs_dirent to be added
+ *
+ *      Get @acxt->parent_sd and set sd->s_parent to it and increment
+ *      nlink of parent inode if @sd is a directory.  @sd is NOT
+ *      linked into the children list of the parent.  The caller
+ *      should invoke sysfs_link_sibling() after this function
+ *      completes if @sd needs to be on the children list.
+ *
+ *      This function should be called between calls to
+ *      sysfs_addrm_start() and sysfs_addrm_finish() and should be
+ *      passed the same @acxt as passed to sysfs_addrm_start().
+ *
+ *      LOCKING:
+ *      Determined by sysfs_addrm_start().
+ */
+void sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
+{
+        sd->s_parent = sysfs_get(acxt->parent_sd);
+
+        if (sysfs_type(sd) == SYSFS_DIR && acxt->parent_inode)
+                inc_nlink(acxt->parent_inode);
+
+        acxt->cnt++;
+}
 
-static struct sysfs_dirent *
-__sysfs_make_dirent(struct dentry *dentry, void *element, mode_t mode, int type)
+/**
+ *      sysfs_remove_one - remove sysfs_dirent from parent
+ *      @acxt: addrm context to use
+ *      @sd: sysfs_dirent to be added
+ *
+ *      Mark @sd removed and drop nlink of parent inode if @sd is a
+ *      directory.  @sd is NOT unlinked from the children list of the
+ *      parent.  The caller is repsonsible for removing @sd from the
+ *      children list before calling this function.
+ *
+ *      This function should be called between calls to
+ *      sysfs_addrm_start() and sysfs_addrm_finish() and should be
+ *      passed the same @acxt as passed to sysfs_addrm_start().
+ *
+ *      LOCKING:
+ *      Determined by sysfs_addrm_start().
+ */
+void sysfs_remove_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
 {
-        struct sysfs_dirent * sd;
+        BUG_ON(sd->s_sibling || (sd->s_flags & SYSFS_FLAG_REMOVED));
 
-        sd = __sysfs_new_dirent(element);
-        if (!sd)
-                goto out;
+        sd->s_flags |= SYSFS_FLAG_REMOVED;
+        sd->s_sibling = acxt->removed;
+        acxt->removed = sd;
 
-        sd->s_mode = mode;
-        sd->s_type = type;
-        sd->s_dentry = dentry;
-        if (dentry) {
-                dentry->d_fsdata = sysfs_get(sd);
-                dentry->d_op = &sysfs_dentry_ops;
-        }
+        if (sysfs_type(sd) == SYSFS_DIR && acxt->parent_inode)
+                drop_nlink(acxt->parent_inode);
 
-out:
-        return sd;
+        acxt->cnt++;
 }
 
-int sysfs_make_dirent(struct sysfs_dirent * parent_sd, struct dentry * dentry,
-                        void * element, umode_t mode, int type)
+/**
+ *      sysfs_drop_dentry - drop dentry for the specified sysfs_dirent
+ *      @sd: target sysfs_dirent
+ *
+ *      Drop dentry for @sd.  @sd must have been unlinked from its
+ *      parent on entry to this function such that it can't be looked
+ *      up anymore.
+ *
+ *      @sd->s_dentry which is protected with sysfs_assoc_lock points
+ *      to the currently associated dentry but we're not holding a
+ *      reference to it and racing with dput().  Grab dcache_lock and
+ *      verify dentry before dropping it.  If @sd->s_dentry is NULL or
+ *      dput() beats us, no need to bother.
+ */
+static void sysfs_drop_dentry(struct sysfs_dirent *sd)
 {
-        struct sysfs_dirent *sd;
+        struct dentry *dentry = NULL;
+        struct inode *inode;
+
+        /* We're not holding a reference to ->s_dentry dentry but the
+         * field will stay valid as long as sysfs_assoc_lock is held.
+         */
+        spin_lock(&sysfs_assoc_lock);
+        spin_lock(&dcache_lock);
+
+        /* drop dentry if it's there and dput() didn't kill it yet */
+        if (sd->s_dentry && sd->s_dentry->d_inode) {
+                dentry = dget_locked(sd->s_dentry);
+                spin_lock(&dentry->d_lock);
+                __d_drop(dentry);
+                spin_unlock(&dentry->d_lock);
+        }
 
-        sd = __sysfs_make_dirent(dentry, element, mode, type);
-        __sysfs_list_dirent(parent_sd, sd);
+        spin_unlock(&dcache_lock);
+        spin_unlock(&sysfs_assoc_lock);
 
-        return sd ? 0 : -ENOMEM;
+        /* dentries for shadowed inodes are pinned, unpin */
+        if (dentry && sysfs_is_shadowed_inode(dentry->d_inode))
+                dput(dentry);
+        dput(dentry);
+
+        /* adjust nlink and update timestamp */
+        inode = ilookup(sysfs_sb, sd->s_ino);
+        if (inode) {
+                mutex_lock(&inode->i_mutex);
+
+                inode->i_ctime = CURRENT_TIME;
+                drop_nlink(inode);
+                if (sysfs_type(sd) == SYSFS_DIR)
+                        drop_nlink(inode);
+
+                mutex_unlock(&inode->i_mutex);
+                iput(inode);
+        }
 }
 
-static int init_dir(struct inode * inode)
+/**
+ *      sysfs_addrm_finish - finish up sysfs_dirent add/remove
+ *      @acxt: addrm context to finish up
+ *
+ *      Finish up sysfs_dirent add/remove.  Resources acquired by
+ *      sysfs_addrm_start() are released and removed sysfs_dirents are
+ *      cleaned up.  Timestamps on the parent inode are updated.
+ *
+ *      LOCKING:
+ *      All mutexes acquired by sysfs_addrm_start() are released.
+ *
+ *      RETURNS:
+ *      Number of added/removed sysfs_dirents since sysfs_addrm_start().
+ */
+int sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt)
 {
-        inode->i_op = &sysfs_dir_inode_operations;
-        inode->i_fop = &sysfs_dir_operations;
+        /* release resources acquired by sysfs_addrm_start() */
+        mutex_unlock(&sysfs_mutex);
+        if (acxt->parent_inode) {
+                struct inode *inode = acxt->parent_inode;
 
-        /* directory inodes start off with i_nlink == 2 (for "." entry) */
-        inc_nlink(inode);
-        return 0;
+                /* if added/removed, update timestamps on the parent */
+                if (acxt->cnt)
+                        inode->i_ctime = inode->i_mtime = CURRENT_TIME;
+
+                mutex_unlock(&inode->i_mutex);
+                iput(inode);
+        }
+
+        /* kill removed sysfs_dirents */
+        while (acxt->removed) {
+                struct sysfs_dirent *sd = acxt->removed;
+
+                acxt->removed = sd->s_sibling;
+                sd->s_sibling = NULL;
+
+                sysfs_drop_dentry(sd);
+                sysfs_deactivate(sd);
+                sysfs_put(sd);
+        }
+
+        return acxt->cnt;
 }
 
-static int init_file(struct inode * inode)
+/**
+ *      sysfs_find_dirent - find sysfs_dirent with the given name
+ *      @parent_sd: sysfs_dirent to search under
+ *      @name: name to look for
+ *
+ *      Look for sysfs_dirent with name @name under @parent_sd.
+ *
+ *      LOCKING:
+ *      mutex_lock(sysfs_mutex)
+ *
+ *      RETURNS:
+ *      Pointer to sysfs_dirent if found, NULL if not.
+ */
+struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
+                                       const unsigned char *name)
 {
-        inode->i_size = PAGE_SIZE;
-        inode->i_fop = &sysfs_file_operations;
-        return 0;
+        struct sysfs_dirent *sd;
+
+        for (sd = parent_sd->s_children; sd; sd = sd->s_sibling)
+                if (sysfs_type(sd) && !strcmp(sd->s_name, name))
+                        return sd;
+        return NULL;
 }
 
-static int init_symlink(struct inode * inode)
+/**
+ *      sysfs_get_dirent - find and get sysfs_dirent with the given name
+ *      @parent_sd: sysfs_dirent to search under
+ *      @name: name to look for
+ *
+ *      Look for sysfs_dirent with name @name under @parent_sd and get
+ *      it if found.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).  Grabs sysfs_mutex.
+ *
+ *      RETURNS:
+ *      Pointer to sysfs_dirent if found, NULL if not.
+ */
+struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
+                                      const unsigned char *name)
 {
-        inode->i_op = &sysfs_symlink_inode_operations;
-        return 0;
+        struct sysfs_dirent *sd;
+
+        mutex_lock(&sysfs_mutex);
+        sd = sysfs_find_dirent(parent_sd, name);
+        sysfs_get(sd);
+        mutex_unlock(&sysfs_mutex);
+
+        return sd;
 }
 
-static int create_dir(struct kobject * k, struct dentry * p,
-                      const char * n, struct dentry ** d)
+static int create_dir(struct kobject *kobj, struct sysfs_dirent *parent_sd,
+                      const char *name, struct sysfs_dirent **p_sd)
 {
-        int error;
         umode_t mode = S_IFDIR| S_IRWXU | S_IRUGO | S_IXUGO;
+        struct sysfs_addrm_cxt acxt;
+        struct sysfs_dirent *sd;
 
-        mutex_lock(&p->d_inode->i_mutex);
-        *d = lookup_one_len(n, p, strlen(n));
-        if (!IS_ERR(*d)) {
-                if (sysfs_dirent_exist(p->d_fsdata, n))
-                        error = -EEXIST;
-                else
-                        error = sysfs_make_dirent(p->d_fsdata, *d, k, mode,
-                                                                SYSFS_DIR);
-                if (!error) {
-                        error = sysfs_create(*d, mode, init_dir);
-                        if (!error) {
-                                inc_nlink(p->d_inode);
-                                (*d)->d_op = &sysfs_dentry_ops;
-                                d_rehash(*d);
-                        }
-                }
-                if (error && (error != -EEXIST)) {
-                        struct sysfs_dirent *sd = (*d)->d_fsdata;
-                        if (sd) {
-                                list_del_init(&sd->s_sibling);
-                                sysfs_put(sd);
-                        }
-                        d_drop(*d);
-                }
-                dput(*d);
-        } else
-                error = PTR_ERR(*d);
-        mutex_unlock(&p->d_inode->i_mutex);
-        return error;
-}
+        /* allocate */
+        sd = sysfs_new_dirent(name, mode, SYSFS_DIR);
+        if (!sd)
+                return -ENOMEM;
+        sd->s_elem.dir.kobj = kobj;
 
+        /* link in */
+        sysfs_addrm_start(&acxt, parent_sd);
+        if (!sysfs_find_dirent(parent_sd, name)) {
+                sysfs_add_one(&acxt, sd);
+                sysfs_link_sibling(sd);
+        }
+        if (sysfs_addrm_finish(&acxt)) {
+                *p_sd = sd;
+                return 0;
+        }
 
-int sysfs_create_subdir(struct kobject * k, const char * n, struct dentry ** d)
+        sysfs_put(sd);
+        return -EEXIST;
+}
+
+int sysfs_create_subdir(struct kobject *kobj, const char *name,
+                        struct sysfs_dirent **p_sd)
 {
-        return create_dir(k,k->dentry,n,d);
+        return create_dir(kobj, kobj->sd, name, p_sd);
 }
 
 /**
  *      sysfs_create_dir - create a directory for an object.
  *      @kobj:          object we're creating directory for. 
- *      @shadow_parent: parent parent object.
+ *      @shadow_parent: parent object.
  */
-
-int sysfs_create_dir(struct kobject * kobj, struct dentry *shadow_parent)
+int sysfs_create_dir(struct kobject *kobj,
+                     struct sysfs_dirent *shadow_parent_sd)
 {
-        struct dentry * dentry = NULL;
-        struct dentry * parent;
+        struct sysfs_dirent *parent_sd, *sd;
         int error = 0;
 
         BUG_ON(!kobj);
 
-        if (shadow_parent)
-                parent = shadow_parent;
+        if (shadow_parent_sd)
+                parent_sd = shadow_parent_sd;
         else if (kobj->parent)
-                parent = kobj->parent->dentry;
+                parent_sd = kobj->parent->sd;
         else if (sysfs_mount && sysfs_mount->mnt_sb)
-                parent = sysfs_mount->mnt_sb->s_root;
+                parent_sd = sysfs_mount->mnt_sb->s_root->d_fsdata;
         else
                 return -EFAULT;
 
-        error = create_dir(kobj,parent,kobject_name(kobj),&dentry);
+        error = create_dir(kobj, parent_sd, kobject_name(kobj), &sd);
         if (!error)
-                kobj->dentry = dentry;
+                kobj->sd = sd;
         return error;
 }
 
-/* attaches attribute's sysfs_dirent to the dentry corresponding to the
- * attribute file
- */
-static int sysfs_attach_attr(struct sysfs_dirent * sd, struct dentry * dentry)
+static int sysfs_count_nlink(struct sysfs_dirent *sd)
 {
-        struct attribute * attr = NULL;
-        struct bin_attribute * bin_attr = NULL;
-        int (* init) (struct inode *) = NULL;
-        int error = 0;
-
-        if (sd->s_type & SYSFS_KOBJ_BIN_ATTR) {
-                bin_attr = sd->s_element;
-                attr = &bin_attr->attr;
-        } else {
-                attr = sd->s_element;
-                init = init_file;
-        }
+        struct sysfs_dirent *child;
+        int nr = 0;
 
-        dentry->d_fsdata = sysfs_get(sd);
-        /* protect sd->s_dentry against sysfs_d_iput */
-        spin_lock(&sysfs_lock);
-        sd->s_dentry = dentry;
-        spin_unlock(&sysfs_lock);
-        error = sysfs_create(dentry, (attr->mode & S_IALLUGO) | S_IFREG, init);
-        if (error) {
-                sysfs_put(sd);
-                return error;
-        }
-
-        if (bin_attr) {
-                dentry->d_inode->i_size = bin_attr->size;
-                dentry->d_inode->i_fop = &bin_fops;
-        }
-        dentry->d_op = &sysfs_dentry_ops;
-        d_rehash(dentry);
-
-        return 0;
-}
-
-static int sysfs_attach_link(struct sysfs_dirent * sd, struct dentry * dentry)
-{
-        int err = 0;
-
-        dentry->d_fsdata = sysfs_get(sd);
-        /* protect sd->s_dentry against sysfs_d_iput */
-        spin_lock(&sysfs_lock);
-        sd->s_dentry = dentry;
-        spin_unlock(&sysfs_lock);
-        err = sysfs_create(dentry, S_IFLNK|S_IRWXUGO, init_symlink);
-        if (!err) {
-                dentry->d_op = &sysfs_dentry_ops;
-                d_rehash(dentry);
-        } else
-                sysfs_put(sd);
-
-        return err;
+        for (child = sd->s_children; child; child = child->s_sibling)
+                if (sysfs_type(child) == SYSFS_DIR)
+                        nr++;
+        return nr + 2;
 }
 
 static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
@@ -303,24 +761,60 @@ static struct dentry * sysfs_lookup(struct inode *dir, struct dentry *dentry,
 {
         struct sysfs_dirent * parent_sd = dentry->d_parent->d_fsdata;
         struct sysfs_dirent * sd;
-        int err = 0;
+        struct bin_attribute *bin_attr;
+        struct inode *inode;
+        int found = 0;
 
-        list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
-                if (sd->s_type & SYSFS_NOT_PINNED) {
-                        const unsigned char * name = sysfs_get_name(sd);
+        for (sd = parent_sd->s_children; sd; sd = sd->s_sibling) {
+                if (sysfs_type(sd) &&
+                    !strcmp(sd->s_name, dentry->d_name.name)) {
+                        found = 1;
+                        break;
+                }
+        }
 
-                        if (strcmp(name, dentry->d_name.name))
-                                continue;
+        /* no such entry */
+        if (!found)
+                return NULL;
 
-                        if (sd->s_type & SYSFS_KOBJ_LINK)
-                                err = sysfs_attach_link(sd, dentry);
-                        else
-                                err = sysfs_attach_attr(sd, dentry);
+        /* attach dentry and inode */
+        inode = sysfs_get_inode(sd);
+        if (!inode)
+                return ERR_PTR(-ENOMEM);
+
+        mutex_lock(&sysfs_mutex);
+
+        if (inode->i_state & I_NEW) {
+                /* initialize inode according to type */
+                switch (sysfs_type(sd)) {
+                case SYSFS_DIR:
+                        inode->i_op = &sysfs_dir_inode_operations;
+                        inode->i_fop = &sysfs_dir_operations;
+                        inode->i_nlink = sysfs_count_nlink(sd);
+                        break;
+                case SYSFS_KOBJ_ATTR:
+                        inode->i_size = PAGE_SIZE;
+                        inode->i_fop = &sysfs_file_operations;
+                        break;
+                case SYSFS_KOBJ_BIN_ATTR:
+                        bin_attr = sd->s_elem.bin_attr.bin_attr;
+                        inode->i_size = bin_attr->size;
+                        inode->i_fop = &bin_fops;
                         break;
+                case SYSFS_KOBJ_LINK:
+                        inode->i_op = &sysfs_symlink_inode_operations;
+                        break;
+                default:
+                        BUG();
                 }
         }
 
-        return ERR_PTR(err);
+        sysfs_instantiate(dentry, inode);
+        sysfs_attach_dentry(sd, dentry);
+
+        mutex_unlock(&sysfs_mutex);
+
+        return NULL;
 }
 
 const struct inode_operations sysfs_dir_inode_operations = {
@@ -328,58 +822,46 @@ const struct inode_operations sysfs_dir_inode_operations = {
         .setattr        = sysfs_setattr,
 };
 
-static void remove_dir(struct dentry * d)
+static void remove_dir(struct sysfs_dirent *sd)
 {
-        struct dentry * parent = dget(d->d_parent);
-        struct sysfs_dirent * sd;
-
-        mutex_lock(&parent->d_inode->i_mutex);
-        d_delete(d);
-        sd = d->d_fsdata;
-        list_del_init(&sd->s_sibling);
-        sysfs_put(sd);
-        if (d->d_inode)
-                simple_rmdir(parent->d_inode,d);
-
-        pr_debug(" o %s removing done (%d)\n",d->d_name.name,
-                 atomic_read(&d->d_count));
+        struct sysfs_addrm_cxt acxt;
 
-        mutex_unlock(&parent->d_inode->i_mutex);
-        dput(parent);
+        sysfs_addrm_start(&acxt, sd->s_parent);
+        sysfs_unlink_sibling(sd);
+        sysfs_remove_one(&acxt, sd);
+        sysfs_addrm_finish(&acxt);
 }
 
-void sysfs_remove_subdir(struct dentry * d)
+void sysfs_remove_subdir(struct sysfs_dirent *sd)
 {
-        remove_dir(d);
+        remove_dir(sd);
 }
 
 
-static void __sysfs_remove_dir(struct dentry *dentry)
+static void __sysfs_remove_dir(struct sysfs_dirent *dir_sd)
 {
-        struct sysfs_dirent * parent_sd;
-        struct sysfs_dirent * sd, * tmp;
+        struct sysfs_addrm_cxt acxt;
+        struct sysfs_dirent **pos;
 
-        dget(dentry);
-        if (!dentry)
+        if (!dir_sd)
                 return;
 
-        pr_debug("sysfs %s: removing dir\n",dentry->d_name.name);
-        mutex_lock(&dentry->d_inode->i_mutex);
-        parent_sd = dentry->d_fsdata;
-        list_for_each_entry_safe(sd, tmp, &parent_sd->s_children, s_sibling) {
-                if (!sd->s_element || !(sd->s_type & SYSFS_NOT_PINNED))
-                        continue;
-                list_del_init(&sd->s_sibling);
-                sysfs_drop_dentry(sd, dentry);
-                sysfs_put(sd);
+        pr_debug("sysfs %s: removing dir\n", dir_sd->s_name);
+        sysfs_addrm_start(&acxt, dir_sd);
+        pos = &dir_sd->s_children;
+        while (*pos) {
+                struct sysfs_dirent *sd = *pos;
+
+                if (sysfs_type(sd) && sysfs_type(sd) != SYSFS_DIR) {
+                        *pos = sd->s_sibling;
+                        sd->s_sibling = NULL;
+                        sysfs_remove_one(&acxt, sd);
+                } else
+                        pos = &(*pos)->s_sibling;
         }
-        mutex_unlock(&dentry->d_inode->i_mutex);
+        sysfs_addrm_finish(&acxt);
 
-        remove_dir(dentry);
-        /**
-         * Drop reference from dget() on entrance.
-         */
-        dput(dentry);
+        remove_dir(dir_sd);
 }
 
 /**
@@ -393,102 +875,166 @@ static void __sysfs_remove_dir(struct dentry *dentry)
 
 void sysfs_remove_dir(struct kobject * kobj)
 {
-        __sysfs_remove_dir(kobj->dentry);
-        kobj->dentry = NULL;
+        struct sysfs_dirent *sd = kobj->sd;
+
+        spin_lock(&sysfs_assoc_lock);
+        kobj->sd = NULL;
+        spin_unlock(&sysfs_assoc_lock);
+
+        __sysfs_remove_dir(sd);
 }
 
-int sysfs_rename_dir(struct kobject * kobj, struct dentry *new_parent,
+int sysfs_rename_dir(struct kobject *kobj, struct sysfs_dirent *new_parent_sd,
                      const char *new_name)
 {
-        int error = 0;
-        struct dentry * new_dentry;
+        struct sysfs_dirent *sd = kobj->sd;
+        struct dentry *new_parent = NULL;
+        struct dentry *old_dentry = NULL, *new_dentry = NULL;
+        const char *dup_name = NULL;
+        int error;
 
-        if (!new_parent)
-                return -EFAULT;
+        /* get dentries */
+        old_dentry = sysfs_get_dentry(sd);
+        if (IS_ERR(old_dentry)) {
+                error = PTR_ERR(old_dentry);
+                goto out_dput;
+        }
 
-        down_write(&sysfs_rename_sem);
+        new_parent = sysfs_get_dentry(new_parent_sd);
+        if (IS_ERR(new_parent)) {
+                error = PTR_ERR(new_parent);
+                goto out_dput;
+        }
+
+        /* lock new_parent and get dentry for new name */
         mutex_lock(&new_parent->d_inode->i_mutex);
 
         new_dentry = lookup_one_len(new_name, new_parent, strlen(new_name));
-        if (!IS_ERR(new_dentry)) {
-                /* By allowing two different directories with the
-                 * same d_parent we allow this routine to move
-                 * between different shadows of the same directory
-                 */
-                if (kobj->dentry->d_parent->d_inode != new_parent->d_inode)
-                        return -EINVAL;
-                else if (new_dentry->d_parent->d_inode != new_parent->d_inode)
-                        error = -EINVAL;
-                else if (new_dentry == kobj->dentry)
-                        error = -EINVAL;
-                else if (!new_dentry->d_inode) {
-                        error = kobject_set_name(kobj, "%s", new_name);
-                        if (!error) {
-                                struct sysfs_dirent *sd, *parent_sd;
-
-                                d_add(new_dentry, NULL);
-                                d_move(kobj->dentry, new_dentry);
-
-                                sd = kobj->dentry->d_fsdata;
-                                parent_sd = new_parent->d_fsdata;
-
-                                list_del_init(&sd->s_sibling);
-                                list_add(&sd->s_sibling, &parent_sd->s_children);
-                        }
-                        else
-                                d_drop(new_dentry);
-                } else
-                        error = -EEXIST;
-                dput(new_dentry);
+        if (IS_ERR(new_dentry)) {
+                error = PTR_ERR(new_dentry);
+                goto out_unlock;
         }
-        mutex_unlock(&new_parent->d_inode->i_mutex);
-        up_write(&sysfs_rename_sem);
 
+        /* By allowing two different directories with the same
+         * d_parent we allow this routine to move between different
+         * shadows of the same directory
+         */
+        error = -EINVAL;
+        if (old_dentry->d_parent->d_inode != new_parent->d_inode ||
+            new_dentry->d_parent->d_inode != new_parent->d_inode ||
+            old_dentry == new_dentry)
+                goto out_unlock;
+
+        error = -EEXIST;
+        if (new_dentry->d_inode)
+                goto out_unlock;
+
+        /* rename kobject and sysfs_dirent */
+        error = -ENOMEM;
+        new_name = dup_name = kstrdup(new_name, GFP_KERNEL);
+        if (!new_name)
+                goto out_drop;
+
+        error = kobject_set_name(kobj, "%s", new_name);
+        if (error)
+                goto out_drop;
+
+        dup_name = sd->s_name;
+        sd->s_name = new_name;
+
+        /* move under the new parent */
+        d_add(new_dentry, NULL);
+        d_move(sd->s_dentry, new_dentry);
+
+        mutex_lock(&sysfs_mutex);
+
+        sysfs_unlink_sibling(sd);
+        sysfs_get(new_parent_sd);
+        sysfs_put(sd->s_parent);
+        sd->s_parent = new_parent_sd;
+        sysfs_link_sibling(sd);
+
+        mutex_unlock(&sysfs_mutex);
+
+        error = 0;
+        goto out_unlock;
+
+ out_drop:
+        d_drop(new_dentry);
+ out_unlock:
+        mutex_unlock(&new_parent->d_inode->i_mutex);
+ out_dput:
+        kfree(dup_name);
+        dput(new_parent);
+        dput(old_dentry);
+        dput(new_dentry);
         return error;
 }
 
-int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent)
+int sysfs_move_dir(struct kobject *kobj, struct kobject *new_parent_kobj)
 {
-        struct dentry *old_parent_dentry, *new_parent_dentry, *new_dentry;
-        struct sysfs_dirent *new_parent_sd, *sd;
+        struct sysfs_dirent *sd = kobj->sd;
+        struct sysfs_dirent *new_parent_sd;
+        struct dentry *old_parent, *new_parent = NULL;
+        struct dentry *old_dentry = NULL, *new_dentry = NULL;
         int error;
 
-        old_parent_dentry = kobj->parent ?
-                kobj->parent->dentry : sysfs_mount->mnt_sb->s_root;
-        new_parent_dentry = new_parent ?
-                new_parent->dentry : sysfs_mount->mnt_sb->s_root;
+        BUG_ON(!sd->s_parent);
+        new_parent_sd = new_parent_kobj->sd ? new_parent_kobj->sd : &sysfs_root;
+
+        /* get dentries */
+        old_dentry = sysfs_get_dentry(sd);
+        if (IS_ERR(old_dentry)) {
+                error = PTR_ERR(old_dentry);
+                goto out_dput;
+        }
+        old_parent = sd->s_parent->s_dentry;
+
+        new_parent = sysfs_get_dentry(new_parent_sd);
+        if (IS_ERR(new_parent)) {
+                error = PTR_ERR(new_parent);
+                goto out_dput;
+        }
 
-        if (old_parent_dentry->d_inode == new_parent_dentry->d_inode)
-                return 0;       /* nothing to move */
+        if (old_parent->d_inode == new_parent->d_inode) {
+                error = 0;
+                goto out_dput;  /* nothing to move */
+        }
 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);
+        mutex_lock(&old_parent->d_inode->i_mutex);
+        if (!mutex_trylock(&new_parent->d_inode->i_mutex)) {
+                mutex_unlock(&old_parent->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));
+        new_dentry = lookup_one_len(kobj->name, new_parent, strlen(kobj->name));
         if (IS_ERR(new_dentry)) {
                 error = PTR_ERR(new_dentry);
-                goto out;
+                goto out_unlock;
         } else
                 error = 0;
         d_add(new_dentry, NULL);
-        d_move(kobj->dentry, new_dentry);
+        d_move(sd->s_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);
+        mutex_lock(&sysfs_mutex);
+
+        sysfs_unlink_sibling(sd);
+        sysfs_get(new_parent_sd);
+        sysfs_put(sd->s_parent);
+        sd->s_parent = new_parent_sd;
+        sysfs_link_sibling(sd);
 
-out:
-        mutex_unlock(&new_parent_dentry->d_inode->i_mutex);
-        mutex_unlock(&old_parent_dentry->d_inode->i_mutex);
+        mutex_unlock(&sysfs_mutex);
 
+ out_unlock:
+        mutex_unlock(&new_parent->d_inode->i_mutex);
+        mutex_unlock(&old_parent->d_inode->i_mutex);
+ out_dput:
+        dput(new_parent);
+        dput(old_dentry);
+        dput(new_dentry);
         return error;
 }
 
@@ -496,23 +1042,27 @@ static int sysfs_dir_open(struct inode *inode, struct file *file)
 {
         struct dentry * dentry = file->f_path.dentry;
         struct sysfs_dirent * parent_sd = dentry->d_fsdata;
+        struct sysfs_dirent * sd;
 
-        mutex_lock(&dentry->d_inode->i_mutex);
-        file->private_data = sysfs_new_dirent(parent_sd, NULL);
-        mutex_unlock(&dentry->d_inode->i_mutex);
-
-        return file->private_data ? 0 : -ENOMEM;
+        sd = sysfs_new_dirent("_DIR_", 0, 0);
+        if (sd) {
+                mutex_lock(&sysfs_mutex);
+                sd->s_parent = sysfs_get(parent_sd);
+                sysfs_link_sibling(sd);
+                mutex_unlock(&sysfs_mutex);
+        }
 
+        file->private_data = sd;
+        return sd ? 0 : -ENOMEM;
 }
 
 static int sysfs_dir_close(struct inode *inode, struct file *file)
 {
-        struct dentry * dentry = file->f_path.dentry;
         struct sysfs_dirent * cursor = file->private_data;
 
-        mutex_lock(&dentry->d_inode->i_mutex);
-        list_del_init(&cursor->s_sibling);
-        mutex_unlock(&dentry->d_inode->i_mutex);
+        mutex_lock(&sysfs_mutex);
+        sysfs_unlink_sibling(cursor);
+        mutex_unlock(&sysfs_mutex);
 
         release_sysfs_dirent(cursor);
 
@@ -530,7 +1080,7 @@ static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
         struct dentry *dentry = filp->f_path.dentry;
         struct sysfs_dirent * parent_sd = dentry->d_fsdata;
         struct sysfs_dirent *cursor = filp->private_data;
-        struct list_head *p, *q = &cursor->s_sibling;
+        struct sysfs_dirent **pos;
         ino_t ino;
         int i = filp->f_pos;
 
@@ -543,38 +1093,52 @@ static int sysfs_readdir(struct file * filp, void * dirent, filldir_t filldir)
                         i++;
                         /* fallthrough */
                 case 1:
-                        ino = parent_ino(dentry);
+                        if (parent_sd->s_parent)
+                                ino = parent_sd->s_parent->s_ino;
+                        else
+                                ino = parent_sd->s_ino;
                         if (filldir(dirent, "..", 2, i, ino, DT_DIR) < 0)
                                 break;
                         filp->f_pos++;
                         i++;
                         /* fallthrough */
                 default:
+                        mutex_lock(&sysfs_mutex);
+
+                        pos = &parent_sd->s_children;
+                        while (*pos != cursor)
+                                pos = &(*pos)->s_sibling;
+
+                        /* unlink cursor */
+                        *pos = cursor->s_sibling;
+
                         if (filp->f_pos == 2)
-                                list_move(q, &parent_sd->s_children);
+                                pos = &parent_sd->s_children;
 
-                        for (p=q->next; p!= &parent_sd->s_children; p=p->next) {
-                                struct sysfs_dirent *next;
+                        for ( ; *pos; pos = &(*pos)->s_sibling) {
+                                struct sysfs_dirent *next = *pos;
                                 const char * name;
                                 int len;
 
-                                next = list_entry(p, struct sysfs_dirent,
-                                                   s_sibling);
-                                if (!next->s_element)
+                                if (!sysfs_type(next))
                                         continue;
 
-                                name = sysfs_get_name(next);
+                                name = next->s_name;
                                 len = strlen(name);
                                 ino = next->s_ino;
 
                                 if (filldir(dirent, name, len, filp->f_pos, ino,
                                                  dt_type(next)) < 0)
-                                        return 0;
+                                        break;
 
-                                list_move(q, p);
-                                p = q;
                                 filp->f_pos++;
                         }
+
+                        /* put cursor back in */
+                        cursor->s_sibling = *pos;
+                        *pos = cursor;
+
+                        mutex_unlock(&sysfs_mutex);
         }
         return 0;
 }
@@ -583,7 +1147,6 @@ static loff_t sysfs_dir_lseek(struct file * file, loff_t offset, int origin)
 {
         struct dentry * dentry = file->f_path.dentry;
 
-        mutex_lock(&dentry->d_inode->i_mutex);
         switch (origin) {
                 case 1:
                         offset += file->f_pos;
@@ -591,31 +1154,35 @@ static loff_t sysfs_dir_lseek(struct file * file, loff_t offset, int origin)
                         if (offset >= 0)
                                 break;
                 default:
-                        mutex_unlock(&file->f_path.dentry->d_inode->i_mutex);
                         return -EINVAL;
         }
         if (offset != file->f_pos) {
+                mutex_lock(&sysfs_mutex);
+
                 file->f_pos = offset;
                 if (file->f_pos >= 2) {
                         struct sysfs_dirent *sd = dentry->d_fsdata;
                         struct sysfs_dirent *cursor = file->private_data;
-                        struct list_head *p;
+                        struct sysfs_dirent **pos;
                         loff_t n = file->f_pos - 2;
 
-                        list_del(&cursor->s_sibling);
-                        p = sd->s_children.next;
-                        while (n && p != &sd->s_children) {
-                                struct sysfs_dirent *next;
-                                next = list_entry(p, struct sysfs_dirent,
-                                                   s_sibling);
-                                if (next->s_element)
+                        sysfs_unlink_sibling(cursor);
+
+                        pos = &sd->s_children;
+                        while (n && *pos) {
+                                struct sysfs_dirent *next = *pos;
+                                if (sysfs_type(next))
                                         n--;
-                                p = p->next;
+                                pos = &(*pos)->s_sibling;
                         }
-                        list_add_tail(&cursor->s_sibling, p);
+
+                        cursor->s_sibling = *pos;
+                        *pos = cursor;
                 }
+
+                mutex_unlock(&sysfs_mutex);
         }
-        mutex_unlock(&dentry->d_inode->i_mutex);
+
         return offset;
 }
 
@@ -628,12 +1195,20 @@ static loff_t sysfs_dir_lseek(struct file * file, loff_t offset, int origin)
 int sysfs_make_shadowed_dir(struct kobject *kobj,
         void * (*follow_link)(struct dentry *, struct nameidata *))
 {
+        struct dentry *dentry;
         struct inode *inode;
         struct inode_operations *i_op;
 
-        inode = kobj->dentry->d_inode;
-        if (inode->i_op != &sysfs_dir_inode_operations)
+        /* get dentry for @kobj->sd, dentry of a shadowed dir is pinned */
+        dentry = sysfs_get_dentry(kobj->sd);
+        if (IS_ERR(dentry))
+                return PTR_ERR(dentry);
+
+        inode = dentry->d_inode;
+        if (inode->i_op != &sysfs_dir_inode_operations) {
+                dput(dentry);
                 return -EINVAL;
+        }
 
         i_op = kmalloc(sizeof(*i_op), GFP_KERNEL);
         if (!i_op)
@@ -658,54 +1233,72 @@ int sysfs_make_shadowed_dir(struct kobject *kobj,
  *      directory.
  */
 
-struct dentry *sysfs_create_shadow_dir(struct kobject *kobj)
+struct sysfs_dirent *sysfs_create_shadow_dir(struct kobject *kobj)
 {
-        struct sysfs_dirent *sd;
-        struct dentry *parent, *dir, *shadow;
+        struct sysfs_dirent *parent_sd = kobj->sd->s_parent;
+        struct dentry *dir, *parent, *shadow;
         struct inode *inode;
+        struct sysfs_dirent *sd;
+        struct sysfs_addrm_cxt acxt;
 
-        dir = kobj->dentry;
-        inode = dir->d_inode;
+        dir = sysfs_get_dentry(kobj->sd);
+        if (IS_ERR(dir)) {
+                sd = (void *)dir;
+                goto out;
+        }
         parent = dir->d_parent;
-        shadow = ERR_PTR(-EINVAL);
+
+        inode = dir->d_inode;
+        sd = ERR_PTR(-EINVAL);
         if (!sysfs_is_shadowed_inode(inode))
-                goto out;
+                goto out_dput;
 
         shadow = d_alloc(parent, &dir->d_name);
         if (!shadow)
                 goto nomem;
 
-        sd = __sysfs_make_dirent(shadow, kobj, inode->i_mode, SYSFS_DIR);
+        sd = sysfs_new_dirent("_SHADOW_", inode->i_mode, SYSFS_DIR);
         if (!sd)
                 goto nomem;
+        sd->s_elem.dir.kobj = kobj;
 
+        sysfs_addrm_start(&acxt, parent_sd);
+
+        /* add but don't link into children list */
+        sysfs_add_one(&acxt, sd);
+
+        /* attach and instantiate dentry */
+        sysfs_attach_dentry(sd, shadow);
         d_instantiate(shadow, igrab(inode));
-        inc_nlink(inode);
-        inc_nlink(parent->d_inode);
-        shadow->d_op = &sysfs_dentry_ops;
+        inc_nlink(inode);       /* tj: synchronization? */
+
+        sysfs_addrm_finish(&acxt);
 
         dget(shadow);           /* Extra count - pin the dentry in core */
 
-out:
-        return shadow;
-nomem:
+        goto out_dput;
+
+ nomem:
         dput(shadow);
-        shadow = ERR_PTR(-ENOMEM);
-        goto out;
+        sd = ERR_PTR(-ENOMEM);
+ out_dput:
+        dput(dir);
+ out:
+        return sd;
 }
 
 /**
  *      sysfs_remove_shadow_dir - remove an object's directory.
- *      @shadow: dentry of shadow directory
+ *      @shadow_sd: sysfs_dirent of shadow directory
  *
  *      The only thing special about this is that we remove any files in
  *      the directory before we remove the directory, and we've inlined
  *      what used to be sysfs_rmdir() below, instead of calling separately.
  */
 
-void sysfs_remove_shadow_dir(struct dentry *shadow)
+void sysfs_remove_shadow_dir(struct sysfs_dirent *shadow_sd)
 {
-        __sysfs_remove_dir(shadow);
+        __sysfs_remove_dir(shadow_sd);
 }
 
 const struct file_operations sysfs_dir_operations = {
diff --git a/fs/sysfs/file.c b/fs/sysfs/file.c
index b502c7197ec..cc497994b2a 100644
--- a/fs/sysfs/file.c
+++ b/fs/sysfs/file.c
@@ -50,29 +50,15 @@ static struct sysfs_ops subsys_sysfs_ops = {
         .store  = subsys_attr_store,
 };
 
-/**
- *      add_to_collection - add buffer to a collection
- *      @buffer:        buffer to be added
- *      @node:          inode of set to add to
- */
-
-static inline void
-add_to_collection(struct sysfs_buffer *buffer, struct inode *node)
-{
-        struct sysfs_buffer_collection *set = node->i_private;
-
-        mutex_lock(&node->i_mutex);
-        list_add(&buffer->associates, &set->associates);
-        mutex_unlock(&node->i_mutex);
-}
-
-static inline void
-remove_from_collection(struct sysfs_buffer *buffer, struct inode *node)
-{
-        mutex_lock(&node->i_mutex);
-        list_del(&buffer->associates);
-        mutex_unlock(&node->i_mutex);
-}
+struct sysfs_buffer {
+        size_t                  count;
+        loff_t                  pos;
+        char                    * page;
+        struct sysfs_ops        * ops;
+        struct semaphore        sem;
+        int                     needs_read_fill;
+        int                     event;
+};
 
 /**
  *      fill_read_buffer - allocate and fill buffer from object.
@@ -87,9 +73,8 @@ remove_from_collection(struct sysfs_buffer *buffer, struct inode *node)
  */
 static int fill_read_buffer(struct dentry * dentry, struct sysfs_buffer * buffer)
 {
-        struct sysfs_dirent * sd = dentry->d_fsdata;
-        struct attribute * attr = to_attr(dentry);
-        struct kobject * kobj = to_kobj(dentry->d_parent);
+        struct sysfs_dirent *attr_sd = dentry->d_fsdata;
+        struct kobject *kobj = attr_sd->s_parent->s_elem.dir.kobj;
         struct sysfs_ops * ops = buffer->ops;
         int ret = 0;
         ssize_t count;
@@ -99,8 +84,15 @@ static int fill_read_buffer(struct dentry * dentry, struct sysfs_buffer * buffer
         if (!buffer->page)
                 return -ENOMEM;
 
-        buffer->event = atomic_read(&sd->s_event);
-        count = ops->show(kobj,attr,buffer->page);
+        /* need attr_sd for attr and ops, its parent for kobj */
+        if (!sysfs_get_active_two(attr_sd))
+                return -ENODEV;
+
+        buffer->event = atomic_read(&attr_sd->s_event);
+        count = ops->show(kobj, attr_sd->s_elem.attr.attr, buffer->page);
+
+        sysfs_put_active_two(attr_sd);
+
         BUG_ON(count > (ssize_t)PAGE_SIZE);
         if (count >= 0) {
                 buffer->needs_read_fill = 0;
@@ -138,10 +130,7 @@ sysfs_read_file(struct file *file, char __user *buf, size_t count, loff_t *ppos)
 
         down(&buffer->sem);
         if (buffer->needs_read_fill) {
-                if (buffer->orphaned)
-                        retval = -ENODEV;
-                else
-                        retval = fill_read_buffer(file->f_path.dentry,buffer);
+                retval = fill_read_buffer(file->f_path.dentry,buffer);
                 if (retval)
                         goto out;
         }
@@ -196,14 +185,23 @@ fill_write_buffer(struct sysfs_buffer * buffer, const char __user * buf, size_t
  *      passing the buffer that we acquired in fill_write_buffer().
  */
 
-static int 
+static int
 flush_write_buffer(struct dentry * dentry, struct sysfs_buffer * buffer, size_t count)
 {
-        struct attribute * attr = to_attr(dentry);
-        struct kobject * kobj = to_kobj(dentry->d_parent);
+        struct sysfs_dirent *attr_sd = dentry->d_fsdata;
+        struct kobject *kobj = attr_sd->s_parent->s_elem.dir.kobj;
         struct sysfs_ops * ops = buffer->ops;
+        int rc;
+
+        /* need attr_sd for attr and ops, its parent for kobj */
+        if (!sysfs_get_active_two(attr_sd))
+                return -ENODEV;
+
+        rc = ops->store(kobj, attr_sd->s_elem.attr.attr, buffer->page, count);
 
-        return ops->store(kobj,attr,buffer->page,count);
+        sysfs_put_active_two(attr_sd);
+
+        return rc;
 }
 
 
@@ -231,37 +229,26 @@ sysfs_write_file(struct file *file, const char __user *buf, size_t count, loff_t
         ssize_t len;
 
         down(&buffer->sem);
-        if (buffer->orphaned) {
-                len = -ENODEV;
-                goto out;
-        }
         len = fill_write_buffer(buffer, buf, count);
         if (len > 0)
                 len = flush_write_buffer(file->f_path.dentry, buffer, len);
         if (len > 0)
                 *ppos += len;
-out:
         up(&buffer->sem);
         return len;
 }
 
 static int sysfs_open_file(struct inode *inode, struct file *file)
 {
-        struct kobject *kobj = sysfs_get_kobject(file->f_path.dentry->d_parent);
-        struct attribute * attr = to_attr(file->f_path.dentry);
-        struct sysfs_buffer_collection *set;
+        struct sysfs_dirent *attr_sd = file->f_path.dentry->d_fsdata;
+        struct kobject *kobj = attr_sd->s_parent->s_elem.dir.kobj;
         struct sysfs_buffer * buffer;
         struct sysfs_ops * ops = NULL;
-        int error = 0;
-
-        if (!kobj || !attr)
-                goto Einval;
+        int error;
 
-        /* Grab the module reference for this attribute if we have one */
-        if (!try_module_get(attr->owner)) {
-                error = -ENODEV;
-                goto Done;
-        }
+        /* need attr_sd for attr and ops, its parent for kobj */
+        if (!sysfs_get_active_two(attr_sd))
+                return -ENODEV;
 
         /* if the kobject has no ktype, then we assume that it is a subsystem
          * itself, and use ops for it.
@@ -273,33 +260,21 @@ static int sysfs_open_file(struct inode *inode, struct file *file)
         else
                 ops = &subsys_sysfs_ops;
 
+        error = -EACCES;
+
         /* No sysfs operations, either from having no subsystem,
          * or the subsystem have no operations.
          */
         if (!ops)
-                goto Eaccess;
-
-        /* make sure we have a collection to add our buffers to */
-        mutex_lock(&inode->i_mutex);
-        if (!(set = inode->i_private)) {
-                if (!(set = inode->i_private = kmalloc(sizeof(struct sysfs_buffer_collection), GFP_KERNEL))) {
-                        error = -ENOMEM;
-                        goto Done;
-                } else {
-                        INIT_LIST_HEAD(&set->associates);
-                }
-        }
-        mutex_unlock(&inode->i_mutex);
+                goto err_out;
 
         /* File needs write support.
          * The inode's perms must say it's ok, 
          * and we must have a store method.
          */
         if (file->f_mode & FMODE_WRITE) {
-
                 if (!(inode->i_mode & S_IWUGO) || !ops->store)
-                        goto Eaccess;
-
+                        goto err_out;
         }
 
         /* File needs read support.
@@ -308,48 +283,38 @@ static int sysfs_open_file(struct inode *inode, struct file *file)
          */
         if (file->f_mode & FMODE_READ) {
                 if (!(inode->i_mode & S_IRUGO) || !ops->show)
-                        goto Eaccess;
+                        goto err_out;
         }
 
         /* No error? Great, allocate a buffer for the file, and store it
          * it in file->private_data for easy access.
          */
+        error = -ENOMEM;
         buffer = kzalloc(sizeof(struct sysfs_buffer), GFP_KERNEL);
-        if (buffer) {
-                INIT_LIST_HEAD(&buffer->associates);
-                init_MUTEX(&buffer->sem);
-                buffer->needs_read_fill = 1;
-                buffer->ops = ops;
-                add_to_collection(buffer, inode);
-                file->private_data = buffer;
-        } else
-                error = -ENOMEM;
-        goto Done;
-
- Einval:
-        error = -EINVAL;
-        goto Done;
- Eaccess:
-        error = -EACCES;
-        module_put(attr->owner);
- Done:
-        if (error)
-                kobject_put(kobj);
+        if (!buffer)
+                goto err_out;
+
+        init_MUTEX(&buffer->sem);
+        buffer->needs_read_fill = 1;
+        buffer->ops = ops;
+        file->private_data = buffer;
+
+        /* open succeeded, put active references and pin attr_sd */
+        sysfs_put_active_two(attr_sd);
+        sysfs_get(attr_sd);
+        return 0;
+
+ err_out:
+        sysfs_put_active_two(attr_sd);
         return error;
 }
 
 static int sysfs_release(struct inode * inode, struct file * filp)
 {
-        struct kobject * kobj = to_kobj(filp->f_path.dentry->d_parent);
-        struct attribute * attr = to_attr(filp->f_path.dentry);
-        struct module * owner = attr->owner;
-        struct sysfs_buffer * buffer = filp->private_data;
+        struct sysfs_dirent *attr_sd = filp->f_path.dentry->d_fsdata;
+        struct sysfs_buffer *buffer = filp->private_data;
 
-        if (buffer)
-                remove_from_collection(buffer, inode);
-        kobject_put(kobj);
-        /* After this point, attr should not be accessed. */
-        module_put(owner);
+        sysfs_put(attr_sd);
 
         if (buffer) {
                 if (buffer->page)
@@ -376,57 +341,43 @@ static int sysfs_release(struct inode * inode, struct file * filp)
 static unsigned int sysfs_poll(struct file *filp, poll_table *wait)
 {
         struct sysfs_buffer * buffer = filp->private_data;
-        struct kobject * kobj = to_kobj(filp->f_path.dentry->d_parent);
-        struct sysfs_dirent * sd = filp->f_path.dentry->d_fsdata;
-        int res = 0;
+        struct sysfs_dirent *attr_sd = filp->f_path.dentry->d_fsdata;
+        struct kobject *kobj = attr_sd->s_parent->s_elem.dir.kobj;
+
+        /* need parent for the kobj, grab both */
+        if (!sysfs_get_active_two(attr_sd))
+                goto trigger;
 
         poll_wait(filp, &kobj->poll, wait);
 
-        if (buffer->event != atomic_read(&sd->s_event)) {
-                res = POLLERR|POLLPRI;
-                buffer->needs_read_fill = 1;
-        }
+        sysfs_put_active_two(attr_sd);
 
-        return res;
-}
+        if (buffer->event != atomic_read(&attr_sd->s_event))
+                goto trigger;
 
+        return 0;
 
-static struct dentry *step_down(struct dentry *dir, const char * name)
-{
-        struct dentry * de;
-
-        if (dir == NULL || dir->d_inode == NULL)
-                return NULL;
-
-        mutex_lock(&dir->d_inode->i_mutex);
-        de = lookup_one_len(name, dir, strlen(name));
-        mutex_unlock(&dir->d_inode->i_mutex);
-        dput(dir);
-        if (IS_ERR(de))
-                return NULL;
-        if (de->d_inode == NULL) {
-                dput(de);
-                return NULL;
-        }
-        return de;
+ trigger:
+        buffer->needs_read_fill = 1;
+        return POLLERR|POLLPRI;
 }
 
-void sysfs_notify(struct kobject * k, char *dir, char *attr)
+void sysfs_notify(struct kobject *k, char *dir, char *attr)
 {
-        struct dentry *de = k->dentry;
-        if (de)
-                dget(de);
-        if (de && dir)
-                de = step_down(de, dir);
-        if (de && attr)
-                de = step_down(de, attr);
-        if (de) {
-                struct sysfs_dirent * sd = de->d_fsdata;
-                if (sd)
-                        atomic_inc(&sd->s_event);
+        struct sysfs_dirent *sd = k->sd;
+
+        mutex_lock(&sysfs_mutex);
+
+        if (sd && dir)
+                sd = sysfs_find_dirent(sd, dir);
+        if (sd && attr)
+                sd = sysfs_find_dirent(sd, attr);
+        if (sd) {
+                atomic_inc(&sd->s_event);
                 wake_up_interruptible(&k->poll);
-                dput(de);
         }
+
+        mutex_unlock(&sysfs_mutex);
 }
 EXPORT_SYMBOL_GPL(sysfs_notify);
 
@@ -440,19 +391,30 @@ const struct file_operations sysfs_file_operations = {
 };
 
 
-int sysfs_add_file(struct dentry * dir, const struct attribute * attr, int type)
+int sysfs_add_file(struct sysfs_dirent *dir_sd, const struct attribute *attr,
+                   int type)
 {
-        struct sysfs_dirent * parent_sd = dir->d_fsdata;
         umode_t mode = (attr->mode & S_IALLUGO) | S_IFREG;
-        int error = -EEXIST;
+        struct sysfs_addrm_cxt acxt;
+        struct sysfs_dirent *sd;
 
-        mutex_lock(&dir->d_inode->i_mutex);
-        if (!sysfs_dirent_exist(parent_sd, attr->name))
-                error = sysfs_make_dirent(parent_sd, NULL, (void *)attr,
-                                          mode, type);
-        mutex_unlock(&dir->d_inode->i_mutex);
+        sd = sysfs_new_dirent(attr->name, mode, type);
+        if (!sd)
+                return -ENOMEM;
+        sd->s_elem.attr.attr = (void *)attr;
 
-        return error;
+        sysfs_addrm_start(&acxt, dir_sd);
+
+        if (!sysfs_find_dirent(dir_sd, attr->name)) {
+                sysfs_add_one(&acxt, sd);
+                sysfs_link_sibling(sd);
+        }
+
+        if (sysfs_addrm_finish(&acxt))
+                return 0;
+
+        sysfs_put(sd);
+        return -EEXIST;
 }
 
 
@@ -464,9 +426,9 @@ int sysfs_add_file(struct dentry * dir, const struct attribute * attr, int type)
 
 int sysfs_create_file(struct kobject * kobj, const struct attribute * attr)
 {
-        BUG_ON(!kobj || !kobj->dentry || !attr);
+        BUG_ON(!kobj || !kobj->sd || !attr);
 
-        return sysfs_add_file(kobj->dentry, attr, SYSFS_KOBJ_ATTR);
+        return sysfs_add_file(kobj->sd, attr, SYSFS_KOBJ_ATTR);
 
 }
 
@@ -480,16 +442,16 @@ int sysfs_create_file(struct kobject * kobj, const struct attribute * attr)
 int sysfs_add_file_to_group(struct kobject *kobj,
                 const struct attribute *attr, const char *group)
 {
-        struct dentry *dir;
+        struct sysfs_dirent *dir_sd;
         int error;
 
-        dir = lookup_one_len(group, kobj->dentry, strlen(group));
-        if (IS_ERR(dir))
-                error = PTR_ERR(dir);
-        else {
-                error = sysfs_add_file(dir, attr, SYSFS_KOBJ_ATTR);
-                dput(dir);
-        }
+        dir_sd = sysfs_get_dirent(kobj->sd, group);
+        if (!dir_sd)
+                return -ENOENT;
+
+        error = sysfs_add_file(dir_sd, attr, SYSFS_KOBJ_ATTR);
+        sysfs_put(dir_sd);
+
         return error;
 }
 EXPORT_SYMBOL_GPL(sysfs_add_file_to_group);
@@ -502,30 +464,31 @@ EXPORT_SYMBOL_GPL(sysfs_add_file_to_group);
  */
 int sysfs_update_file(struct kobject * kobj, const struct attribute * attr)
 {
-        struct dentry * dir = kobj->dentry;
-        struct dentry * victim;
-        int res = -ENOENT;
-
-        mutex_lock(&dir->d_inode->i_mutex);
-        victim = lookup_one_len(attr->name, dir, strlen(attr->name));
-        if (!IS_ERR(victim)) {
-                /* make sure dentry is really there */
-                if (victim->d_inode && 
-                    (victim->d_parent->d_inode == dir->d_inode)) {
-                        victim->d_inode->i_mtime = CURRENT_TIME;
-                        fsnotify_modify(victim);
-                        res = 0;
-                } else
-                        d_drop(victim);
-                
-                /**
-                 * Drop the reference acquired from lookup_one_len() above.
-                 */
-                dput(victim);
+        struct sysfs_dirent *victim_sd = NULL;
+        struct dentry *victim = NULL;
+        int rc;
+
+        rc = -ENOENT;
+        victim_sd = sysfs_get_dirent(kobj->sd, attr->name);
+        if (!victim_sd)
+                goto out;
+
+        victim = sysfs_get_dentry(victim_sd);
+        if (IS_ERR(victim)) {
+                rc = PTR_ERR(victim);
+                victim = NULL;
+                goto out;
         }
-        mutex_unlock(&dir->d_inode->i_mutex);
 
-        return res;
+        mutex_lock(&victim->d_inode->i_mutex);
+        victim->d_inode->i_mtime = CURRENT_TIME;
+        fsnotify_modify(victim);
+        mutex_unlock(&victim->d_inode->i_mutex);
+        rc = 0;
+ out:
+        dput(victim);
+        sysfs_put(victim_sd);
+        return rc;
 }
 
 
@@ -538,30 +501,34 @@ int sysfs_update_file(struct kobject * kobj, const struct attribute * attr)
  */
 int sysfs_chmod_file(struct kobject *kobj, struct attribute *attr, mode_t mode)
 {
-        struct dentry *dir = kobj->dentry;
-        struct dentry *victim;
+        struct sysfs_dirent *victim_sd = NULL;
+        struct dentry *victim = NULL;
         struct inode * inode;
         struct iattr newattrs;
-        int res = -ENOENT;
-
-        mutex_lock(&dir->d_inode->i_mutex);
-        victim = lookup_one_len(attr->name, dir, strlen(attr->name));
-        if (!IS_ERR(victim)) {
-                if (victim->d_inode &&
-                    (victim->d_parent->d_inode == dir->d_inode)) {
-                        inode = victim->d_inode;
-                        mutex_lock(&inode->i_mutex);
-                        newattrs.ia_mode = (mode & S_IALLUGO) |
-                                                (inode->i_mode & ~S_IALLUGO);
-                        newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
-                        res = notify_change(victim, &newattrs);
-                        mutex_unlock(&inode->i_mutex);
-                }
-                dput(victim);
+        int rc;
+
+        rc = -ENOENT;
+        victim_sd = sysfs_get_dirent(kobj->sd, attr->name);
+        if (!victim_sd)
+                goto out;
+
+        victim = sysfs_get_dentry(victim_sd);
+        if (IS_ERR(victim)) {
+                rc = PTR_ERR(victim);
+                victim = NULL;
+                goto out;
         }
-        mutex_unlock(&dir->d_inode->i_mutex);
 
-        return res;
+        inode = victim->d_inode;
+        mutex_lock(&inode->i_mutex);
+        newattrs.ia_mode = (mode & S_IALLUGO) | (inode->i_mode & ~S_IALLUGO);
+        newattrs.ia_valid = ATTR_MODE | ATTR_CTIME;
+        rc = notify_change(victim, &newattrs);
+        mutex_unlock(&inode->i_mutex);
+ out:
+        dput(victim);
+        sysfs_put(victim_sd);
+        return rc;
 }
 EXPORT_SYMBOL_GPL(sysfs_chmod_file);
 
@@ -576,7 +543,7 @@ EXPORT_SYMBOL_GPL(sysfs_chmod_file);
 
 void sysfs_remove_file(struct kobject * kobj, const struct attribute * attr)
 {
-        sysfs_hash_and_remove(kobj->dentry, attr->name);
+        sysfs_hash_and_remove(kobj->sd, attr->name);
 }
 
 
@@ -589,12 +556,12 @@ void sysfs_remove_file(struct kobject * kobj, const struct attribute * attr)
 void sysfs_remove_file_from_group(struct kobject *kobj,
                 const struct attribute *attr, const char *group)
 {
-        struct dentry *dir;
+        struct sysfs_dirent *dir_sd;
 
-        dir = lookup_one_len(group, kobj->dentry, strlen(group));
-        if (!IS_ERR(dir)) {
-                sysfs_hash_and_remove(dir, attr->name);
-                dput(dir);
+        dir_sd = sysfs_get_dirent(kobj->sd, group);
+        if (dir_sd) {
+                sysfs_hash_and_remove(dir_sd, attr->name);
+                sysfs_put(dir_sd);
         }
 }
 EXPORT_SYMBOL_GPL(sysfs_remove_file_from_group);
diff --git a/fs/sysfs/group.c b/fs/sysfs/group.c
index 52eed2a7a5e..f318b73c790 100644
--- a/fs/sysfs/group.c
+++ b/fs/sysfs/group.c
@@ -18,26 +18,25 @@
 #include "sysfs.h"
 
 
-static void remove_files(struct dentry * dir, 
-                         const struct attribute_group * grp)
+static void remove_files(struct sysfs_dirent *dir_sd,
+                         const struct attribute_group *grp)
 {
         struct attribute *const* attr;
 
         for (attr = grp->attrs; *attr; attr++)
-                sysfs_hash_and_remove(dir,(*attr)->name);
+                sysfs_hash_and_remove(dir_sd, (*attr)->name);
 }
 
-static int create_files(struct dentry * dir,
-                        const struct attribute_group * grp)
+static int create_files(struct sysfs_dirent *dir_sd,
+                        const struct attribute_group *grp)
 {
         struct attribute *const* attr;
         int error = 0;
 
-        for (attr = grp->attrs; *attr && !error; attr++) {
-                error = sysfs_add_file(dir, *attr, SYSFS_KOBJ_ATTR);
-        }
+        for (attr = grp->attrs; *attr && !error; attr++)
+                error = sysfs_add_file(dir_sd, *attr, SYSFS_KOBJ_ATTR);
         if (error)
-                remove_files(dir,grp);
+                remove_files(dir_sd, grp);
         return error;
 }
 
@@ -45,44 +44,44 @@ static int create_files(struct dentry * dir,
 int sysfs_create_group(struct kobject * kobj, 
                        const struct attribute_group * grp)
 {
-        struct dentry * dir;
+        struct sysfs_dirent *sd;
         int error;
 
-        BUG_ON(!kobj || !kobj->dentry);
+        BUG_ON(!kobj || !kobj->sd);
 
         if (grp->name) {
-                error = sysfs_create_subdir(kobj,grp->name,&dir);
+                error = sysfs_create_subdir(kobj, grp->name, &sd);
                 if (error)
                         return error;
         } else
-                dir = kobj->dentry;
-        dir = dget(dir);
-        if ((error = create_files(dir,grp))) {
+                sd = kobj->sd;
+        sysfs_get(sd);
+        error = create_files(sd, grp);
+        if (error) {
                 if (grp->name)
-                        sysfs_remove_subdir(dir);
+                        sysfs_remove_subdir(sd);
         }
-        dput(dir);
+        sysfs_put(sd);
         return error;
 }
 
 void sysfs_remove_group(struct kobject * kobj, 
                         const struct attribute_group * grp)
 {
-        struct dentry * dir;
+        struct sysfs_dirent *dir_sd = kobj->sd;
+        struct sysfs_dirent *sd;
 
         if (grp->name) {
-                dir = lookup_one_len_kern(grp->name, kobj->dentry,
-                                strlen(grp->name));
-                BUG_ON(IS_ERR(dir));
-        }
-        else
-                dir = dget(kobj->dentry);
+                sd = sysfs_get_dirent(dir_sd, grp->name);
+                BUG_ON(!sd);
+        } else
+                sd = sysfs_get(dir_sd);
 
-        remove_files(dir,grp);
+        remove_files(sd, grp);
         if (grp->name)
-                sysfs_remove_subdir(dir);
-        /* release the ref. taken in this routine */
-        dput(dir);
+                sysfs_remove_subdir(sd);
+
+        sysfs_put(sd);
 }
 
 
diff --git a/fs/sysfs/inode.c b/fs/sysfs/inode.c
index 5266eec15f6..3756e152285 100644
--- a/fs/sysfs/inode.c
+++ b/fs/sysfs/inode.c
@@ -133,187 +133,94 @@ static inline void set_inode_attr(struct inode * inode, struct iattr * iattr)
  */
 static struct lock_class_key sysfs_inode_imutex_key;
 
-struct inode * sysfs_new_inode(mode_t mode, struct sysfs_dirent * sd)
+void sysfs_init_inode(struct sysfs_dirent *sd, struct inode *inode)
 {
-        struct inode * inode = new_inode(sysfs_sb);
-        if (inode) {
-                inode->i_blocks = 0;
-                inode->i_mapping->a_ops = &sysfs_aops;
-                inode->i_mapping->backing_dev_info = &sysfs_backing_dev_info;
-                inode->i_op = &sysfs_inode_operations;
-                inode->i_ino = sd->s_ino;
-                lockdep_set_class(&inode->i_mutex, &sysfs_inode_imutex_key);
-
-                if (sd->s_iattr) {
-                        /* sysfs_dirent has non-default attributes
-                         * get them for the new inode from persistent copy
-                         * in sysfs_dirent
-                         */
-                        set_inode_attr(inode, sd->s_iattr);
-                } else
-                        set_default_inode_attr(inode, mode);
-        }
-        return inode;
-}
-
-int sysfs_create(struct dentry * dentry, int mode, int (*init)(struct inode *))
-{
-        int error = 0;
-        struct inode * inode = NULL;
-        if (dentry) {
-                if (!dentry->d_inode) {
-                        struct sysfs_dirent * sd = dentry->d_fsdata;
-                        if ((inode = sysfs_new_inode(mode, sd))) {
-                                if (dentry->d_parent && dentry->d_parent->d_inode) {
-                                        struct inode *p_inode = dentry->d_parent->d_inode;
-                                        p_inode->i_mtime = p_inode->i_ctime = CURRENT_TIME;
-                                }
-                                goto Proceed;
-                        }
-                        else 
-                                error = -ENOMEM;
-                } else
-                        error = -EEXIST;
-        } else 
-                error = -ENOENT;
-        goto Done;
-
- Proceed:
-        if (init)
-                error = init(inode);
-        if (!error) {
-                d_instantiate(dentry, inode);
-                if (S_ISDIR(mode))
-                        dget(dentry);  /* pin only directory dentry in core */
+        inode->i_blocks = 0;
+        inode->i_mapping->a_ops = &sysfs_aops;
+        inode->i_mapping->backing_dev_info = &sysfs_backing_dev_info;
+        inode->i_op = &sysfs_inode_operations;
+        inode->i_ino = sd->s_ino;
+        lockdep_set_class(&inode->i_mutex, &sysfs_inode_imutex_key);
+
+        if (sd->s_iattr) {
+                /* sysfs_dirent has non-default attributes
+                 * get them for the new inode from persistent copy
+                 * in sysfs_dirent
+                 */
+                set_inode_attr(inode, sd->s_iattr);
         } else
-                iput(inode);
- Done:
-        return error;
+                set_default_inode_attr(inode, sd->s_mode);
 }
 
-/*
- * Get the name for corresponding element represented by the given sysfs_dirent
+/**
+ *      sysfs_get_inode - get inode for sysfs_dirent
+ *      @sd: sysfs_dirent to allocate inode for
+ *
+ *      Get inode for @sd.  If such inode doesn't exist, a new inode
+ *      is allocated and basics are initialized.  New inode is
+ *      returned locked.
+ *
+ *      LOCKING:
+ *      Kernel thread context (may sleep).
+ *
+ *      RETURNS:
+ *      Pointer to allocated inode on success, NULL on failure.
  */
-const unsigned char * sysfs_get_name(struct sysfs_dirent *sd)
+struct inode * sysfs_get_inode(struct sysfs_dirent *sd)
 {
-        struct attribute * attr;
-        struct bin_attribute * bin_attr;
-        struct sysfs_symlink  * sl;
-
-        BUG_ON(!sd || !sd->s_element);
-
-        switch (sd->s_type) {
-                case SYSFS_DIR:
-                        /* Always have a dentry so use that */
-                        return sd->s_dentry->d_name.name;
-
-                case SYSFS_KOBJ_ATTR:
-                        attr = sd->s_element;
-                        return attr->name;
-
-                case SYSFS_KOBJ_BIN_ATTR:
-                        bin_attr = sd->s_element;
-                        return bin_attr->attr.name;
+        struct inode *inode;
 
-                case SYSFS_KOBJ_LINK:
-                        sl = sd->s_element;
-                        return sl->link_name;
-        }
-        return NULL;
-}
+        inode = iget_locked(sysfs_sb, sd->s_ino);
+        if (inode && (inode->i_state & I_NEW))
+                sysfs_init_inode(sd, inode);
 
-static inline void orphan_all_buffers(struct inode *node)
-{
-        struct sysfs_buffer_collection *set;
-        struct sysfs_buffer *buf;
-
-        mutex_lock_nested(&node->i_mutex, I_MUTEX_CHILD);
-        set = node->i_private;
-        if (set) {
-                list_for_each_entry(buf, &set->associates, associates) {
-                        down(&buf->sem);
-                        buf->orphaned = 1;
-                        up(&buf->sem);
-                }
-        }
-        mutex_unlock(&node->i_mutex);
+        return inode;
 }
 
-
-/*
- * Unhashes the dentry corresponding to given sysfs_dirent
- * Called with parent inode's i_mutex held.
+/**
+ *      sysfs_instantiate - instantiate dentry
+ *      @dentry: dentry to be instantiated
+ *      @inode: inode associated with @sd
+ *
+ *      Unlock @inode if locked and instantiate @dentry with @inode.
+ *
+ *      LOCKING:
+ *      None.
  */
-void sysfs_drop_dentry(struct sysfs_dirent * sd, struct dentry * parent)
+void sysfs_instantiate(struct dentry *dentry, struct inode *inode)
 {
-        struct dentry *dentry = NULL;
-        struct inode *inode;
+        BUG_ON(!dentry || dentry->d_inode);
 
-        /* We're not holding a reference to ->s_dentry dentry but the
-         * field will stay valid as long as sysfs_lock is held.
-         */
-        spin_lock(&sysfs_lock);
-        spin_lock(&dcache_lock);
-
-        /* dget dentry if it's still alive */
-        if (sd->s_dentry && sd->s_dentry->d_inode)
-                dentry = dget_locked(sd->s_dentry);
-
-        spin_unlock(&dcache_lock);
-        spin_unlock(&sysfs_lock);
-
-        /* drop dentry */
-        if (dentry) {
-                spin_lock(&dcache_lock);
-                spin_lock(&dentry->d_lock);
-                if (!d_unhashed(dentry) && dentry->d_inode) {
-                        inode = dentry->d_inode;
-                        spin_lock(&inode->i_lock);
-                        __iget(inode);
-                        spin_unlock(&inode->i_lock);
-                        dget_locked(dentry);
-                        __d_drop(dentry);
-                        spin_unlock(&dentry->d_lock);
-                        spin_unlock(&dcache_lock);
-                        simple_unlink(parent->d_inode, dentry);
-                        orphan_all_buffers(inode);
-                        iput(inode);
-                } else {
-                        spin_unlock(&dentry->d_lock);
-                        spin_unlock(&dcache_lock);
-                }
+        if (inode->i_state & I_NEW)
+                unlock_new_inode(inode);
 
-                dput(dentry);
-        }
+        d_instantiate(dentry, inode);
 }
 
-int sysfs_hash_and_remove(struct dentry * dir, const char * name)
+int sysfs_hash_and_remove(struct sysfs_dirent *dir_sd, const char *name)
 {
-        struct sysfs_dirent * sd;
-        struct sysfs_dirent * parent_sd;
-        int found = 0;
+        struct sysfs_addrm_cxt acxt;
+        struct sysfs_dirent **pos, *sd;
 
-        if (!dir)
+        if (!dir_sd)
                 return -ENOENT;
 
-        if (dir->d_inode == NULL)
-                /* no inode means this hasn't been made visible yet */
-                return -ENOENT;
+        sysfs_addrm_start(&acxt, dir_sd);
+
+        for (pos = &dir_sd->s_children; *pos; pos = &(*pos)->s_sibling) {
+                sd = *pos;
 
-        parent_sd = dir->d_fsdata;
-        mutex_lock_nested(&dir->d_inode->i_mutex, I_MUTEX_PARENT);
-        list_for_each_entry(sd, &parent_sd->s_children, s_sibling) {
-                if (!sd->s_element)
+                if (!sysfs_type(sd))
                         continue;
-                if (!strcmp(sysfs_get_name(sd), name)) {
-                        list_del_init(&sd->s_sibling);
-                        sysfs_drop_dentry(sd, dir);
-                        sysfs_put(sd);
-                        found = 1;
+                if (!strcmp(sd->s_name, name)) {
+                        *pos = sd->s_sibling;
+                        sd->s_sibling = NULL;
+                        sysfs_remove_one(&acxt, sd);
                         break;
                 }
         }
-        mutex_unlock(&dir->d_inode->i_mutex);
 
-        return found ? 0 : -ENOENT;
+        if (sysfs_addrm_finish(&acxt))
+                return 0;
+        return -ENOENT;
 }
diff --git a/fs/sysfs/mount.c b/fs/sysfs/mount.c
index 00ab9125d39..402cc356203 100644
--- a/fs/sysfs/mount.c
+++ b/fs/sysfs/mount.c
@@ -19,28 +19,18 @@ struct vfsmount *sysfs_mount;
 struct super_block * sysfs_sb = NULL;
 struct kmem_cache *sysfs_dir_cachep;
 
-static void sysfs_clear_inode(struct inode *inode);
-
 static const struct super_operations sysfs_ops = {
         .statfs         = simple_statfs,
         .drop_inode     = sysfs_delete_inode,
-        .clear_inode    = sysfs_clear_inode,
 };
 
-static struct sysfs_dirent sysfs_root = {
-        .s_sibling      = LIST_HEAD_INIT(sysfs_root.s_sibling),
-        .s_children     = LIST_HEAD_INIT(sysfs_root.s_children),
-        .s_element      = NULL,
-        .s_type         = SYSFS_ROOT,
-        .s_iattr        = NULL,
+struct sysfs_dirent sysfs_root = {
+        .s_count        = ATOMIC_INIT(1),
+        .s_flags        = SYSFS_ROOT,
+        .s_mode         = S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO,
         .s_ino          = 1,
 };
 
-static void sysfs_clear_inode(struct inode *inode)
-{
-        kfree(inode->i_private);
-}
-
 static int sysfs_fill_super(struct super_block *sb, void *data, int silent)
 {
         struct inode *inode;
@@ -53,24 +43,26 @@ static int sysfs_fill_super(struct super_block *sb, void *data, int silent)
         sb->s_time_gran = 1;
         sysfs_sb = sb;
 
-        inode = sysfs_new_inode(S_IFDIR | S_IRWXU | S_IRUGO | S_IXUGO,
-                                 &sysfs_root);
-        if (inode) {
-                inode->i_op = &sysfs_dir_inode_operations;
-                inode->i_fop = &sysfs_dir_operations;
-                /* directory inodes start off with i_nlink == 2 (for "." entry) */
-                inc_nlink(inode);
-        } else {
+        inode = new_inode(sysfs_sb);
+        if (!inode) {
                 pr_debug("sysfs: could not get root inode\n");
                 return -ENOMEM;
         }
 
+        sysfs_init_inode(&sysfs_root, inode);
+
+        inode->i_op = &sysfs_dir_inode_operations;
+        inode->i_fop = &sysfs_dir_operations;
+        /* directory inodes start off with i_nlink == 2 (for "." entry) */
+        inc_nlink(inode);
+
         root = d_alloc_root(inode);
         if (!root) {
                 pr_debug("%s: could not get root dentry!\n",__FUNCTION__);
                 iput(inode);
                 return -ENOMEM;
         }
+        sysfs_root.s_dentry = root;
         root->d_fsdata = &sysfs_root;
         sb->s_root = root;
         return 0;
diff --git a/fs/sysfs/symlink.c b/fs/sysfs/symlink.c
index 7b9c5bfde92..2f86e042229 100644
--- a/fs/sysfs/symlink.c
+++ b/fs/sysfs/symlink.c
@@ -11,71 +11,39 @@
 
 #include "sysfs.h"
 
-static int object_depth(struct kobject * kobj)
+static int object_depth(struct sysfs_dirent *sd)
 {
-        struct kobject * p = kobj;
         int depth = 0;
-        do { depth++; } while ((p = p->parent));
+
+        for (; sd->s_parent; sd = sd->s_parent)
+                depth++;
+
         return depth;
 }
 
-static int object_path_length(struct kobject * kobj)
+static int object_path_length(struct sysfs_dirent * sd)
 {
-        struct kobject * p = kobj;
         int length = 1;
-        do {
-                length += strlen(kobject_name(p)) + 1;
-                p = p->parent;
-        } while (p);
+
+        for (; sd->s_parent; sd = sd->s_parent)
+                length += strlen(sd->s_name) + 1;
+
         return length;
 }
 
-static void fill_object_path(struct kobject * kobj, char * buffer, int length)
+static void fill_object_path(struct sysfs_dirent *sd, char *buffer, int length)
 {
-        struct kobject * p;
-
         --length;
-        for (p = kobj; p; p = p->parent) {
-                int cur = strlen(kobject_name(p));
+        for (; sd->s_parent; sd = sd->s_parent) {
+                int cur = strlen(sd->s_name);
 
                 /* back up enough to print this bus id with '/' */
                 length -= cur;
-                strncpy(buffer + length,kobject_name(p),cur);
+                strncpy(buffer + length, sd->s_name, cur);
                 *(buffer + --length) = '/';
         }
 }
 
-static int sysfs_add_link(struct dentry * parent, const char * name, struct kobject * target)
-{
-        struct sysfs_dirent * parent_sd = parent->d_fsdata;
-        struct sysfs_symlink * sl;
-        int error = 0;
-
-        error = -ENOMEM;
-        sl = kmalloc(sizeof(*sl), GFP_KERNEL);
-        if (!sl)
-                goto exit1;
-
-        sl->link_name = kmalloc(strlen(name) + 1, GFP_KERNEL);
-        if (!sl->link_name)
-                goto exit2;
-
-        strcpy(sl->link_name, name);
-        sl->target_kobj = kobject_get(target);
-
-        error = sysfs_make_dirent(parent_sd, NULL, sl, S_IFLNK|S_IRWXUGO,
-                                SYSFS_KOBJ_LINK);
-        if (!error)
-                return 0;
-
-        kobject_put(target);
-        kfree(sl->link_name);
-exit2:
-        kfree(sl);
-exit1:
-        return error;
-}
-
 /**
  *      sysfs_create_link - create symlink between two objects.
  *      @kobj:  object whose directory we're creating the link in.
@@ -84,24 +52,57 @@ exit1:
  */
 int sysfs_create_link(struct kobject * kobj, struct kobject * target, const char * name)
 {
-        struct dentry *dentry = NULL;
-        int error = -EEXIST;
+        struct sysfs_dirent *parent_sd = NULL;
+        struct sysfs_dirent *target_sd = NULL;
+        struct sysfs_dirent *sd = NULL;
+        struct sysfs_addrm_cxt acxt;
+        int error;
 
         BUG_ON(!name);
 
         if (!kobj) {
                 if (sysfs_mount && sysfs_mount->mnt_sb)
-                        dentry = sysfs_mount->mnt_sb->s_root;
+                        parent_sd = sysfs_mount->mnt_sb->s_root->d_fsdata;
         } else
-                dentry = kobj->dentry;
+                parent_sd = kobj->sd;
+
+        error = -EFAULT;
+        if (!parent_sd)
+                goto out_put;
+
+        /* target->sd can go away beneath us but is protected with
+         * sysfs_assoc_lock.  Fetch target_sd from it.
+         */
+        spin_lock(&sysfs_assoc_lock);
+        if (target->sd)
+                target_sd = sysfs_get(target->sd);
+        spin_unlock(&sysfs_assoc_lock);
+
+        error = -ENOENT;
+        if (!target_sd)
+                goto out_put;
+
+        error = -ENOMEM;
+        sd = sysfs_new_dirent(name, S_IFLNK|S_IRWXUGO, SYSFS_KOBJ_LINK);
+        if (!sd)
+                goto out_put;
+        sd->s_elem.symlink.target_sd = target_sd;
 
-        if (!dentry)
-                return -EFAULT;
+        sysfs_addrm_start(&acxt, parent_sd);
 
-        mutex_lock(&dentry->d_inode->i_mutex);
-        if (!sysfs_dirent_exist(dentry->d_fsdata, name))
-                error = sysfs_add_link(dentry, name, target);
-        mutex_unlock(&dentry->d_inode->i_mutex);
+        if (!sysfs_find_dirent(parent_sd, name)) {
+                sysfs_add_one(&acxt, sd);
+                sysfs_link_sibling(sd);
+        }
+
+        if (sysfs_addrm_finish(&acxt))
+                return 0;
+
+        error = -EEXIST;
+        /* fall through */
+ out_put:
+        sysfs_put(target_sd);
+        sysfs_put(sd);
         return error;
 }
 
@@ -114,17 +115,17 @@ int sysfs_create_link(struct kobject * kobj, struct kobject * target, const char
 
 void sysfs_remove_link(struct kobject * kobj, const char * name)
 {
-        sysfs_hash_and_remove(kobj->dentry,name);
+        sysfs_hash_and_remove(kobj->sd, name);
 }
 
-static int sysfs_get_target_path(struct kobject * kobj, struct kobject * target,
-                                 char *path)
+static int sysfs_get_target_path(struct sysfs_dirent * parent_sd,
+                                 struct sysfs_dirent * target_sd, char *path)
 {
         char * s;
         int depth, size;
 
-        depth = object_depth(kobj);
-        size = object_path_length(target) + depth * 3 - 1;
+        depth = object_depth(parent_sd);
+        size = object_path_length(target_sd) + depth * 3 - 1;
         if (size > PATH_MAX)
                 return -ENAMETOOLONG;
 
@@ -133,7 +134,7 @@ static int sysfs_get_target_path(struct kobject * kobj, struct kobject * target,
         for (s = path; depth--; s += 3)
                 strcpy(s,"../");
 
-        fill_object_path(target, path, size);
+        fill_object_path(target_sd, path, size);
         pr_debug("%s: path = '%s'\n", __FUNCTION__, path);
 
         return 0;
@@ -141,27 +142,16 @@ static int sysfs_get_target_path(struct kobject * kobj, struct kobject * target,
 
 static int sysfs_getlink(struct dentry *dentry, char * path)
 {
-        struct kobject *kobj, *target_kobj;
-        int error = 0;
+        struct sysfs_dirent *sd = dentry->d_fsdata;
+        struct sysfs_dirent *parent_sd = sd->s_parent;
+        struct sysfs_dirent *target_sd = sd->s_elem.symlink.target_sd;
+        int error;
 
-        kobj = sysfs_get_kobject(dentry->d_parent);
-        if (!kobj)
-                return -EINVAL;
+        mutex_lock(&sysfs_mutex);
+        error = sysfs_get_target_path(parent_sd, target_sd, path);
+        mutex_unlock(&sysfs_mutex);
 
-        target_kobj = sysfs_get_kobject(dentry);
-        if (!target_kobj) {
-                kobject_put(kobj);
-                return -EINVAL;
-        }
-
-        down_read(&sysfs_rename_sem);
-        error = sysfs_get_target_path(kobj, target_kobj, path);
-        up_read(&sysfs_rename_sem);
-        
-        kobject_put(kobj);
-        kobject_put(target_kobj);
         return error;
-
 }
 
 static void *sysfs_follow_link(struct dentry *dentry, struct nameidata *nd)
diff --git a/fs/sysfs/sysfs.h b/fs/sysfs/sysfs.h
index 502c949c402..6a37f2386a8 100644
--- a/fs/sysfs/sysfs.h
+++ b/fs/sysfs/sysfs.h
@@ -1,9 +1,40 @@
+struct sysfs_elem_dir {
+        struct kobject          * kobj;
+};
+
+struct sysfs_elem_symlink {
+        struct sysfs_dirent     * target_sd;
+};
+
+struct sysfs_elem_attr {
+        struct attribute        * attr;
+};
+
+struct sysfs_elem_bin_attr {
+        struct bin_attribute    * bin_attr;
+};
+
+/*
+ * As long as s_count reference is held, the sysfs_dirent itself is
+ * accessible.  Dereferencing s_elem or any other outer entity
+ * requires s_active reference.
+ */
 struct sysfs_dirent {
         atomic_t                s_count;
-        struct list_head        s_sibling;
-        struct list_head        s_children;
-        void                    * s_element;
-        int                     s_type;
+        atomic_t                s_active;
+        struct sysfs_dirent     * s_parent;
+        struct sysfs_dirent     * s_sibling;
+        struct sysfs_dirent     * s_children;
+        const char              * s_name;
+
+        union {
+                struct sysfs_elem_dir           dir;
+                struct sysfs_elem_symlink       symlink;
+                struct sysfs_elem_attr          attr;
+                struct sysfs_elem_bin_attr      bin_attr;
+        }                       s_elem;
+
+        unsigned int            s_flags;
         umode_t                 s_mode;
         ino_t                   s_ino;
         struct dentry           * s_dentry;
@@ -11,30 +42,60 @@ struct sysfs_dirent {
         atomic_t                s_event;
 };
 
+#define SD_DEACTIVATED_BIAS     INT_MIN
+
+struct sysfs_addrm_cxt {
+        struct sysfs_dirent     *parent_sd;
+        struct inode            *parent_inode;
+        struct sysfs_dirent     *removed;
+        int                     cnt;
+};
+
 extern struct vfsmount * sysfs_mount;
+extern struct sysfs_dirent sysfs_root;
 extern struct kmem_cache *sysfs_dir_cachep;
 
-extern void sysfs_delete_inode(struct inode *inode);
-extern struct inode * sysfs_new_inode(mode_t mode, struct sysfs_dirent *);
-extern int sysfs_create(struct dentry *, int mode, int (*init)(struct inode *));
+extern struct dentry *sysfs_get_dentry(struct sysfs_dirent *sd);
+extern void sysfs_link_sibling(struct sysfs_dirent *sd);
+extern void sysfs_unlink_sibling(struct sysfs_dirent *sd);
+extern struct sysfs_dirent *sysfs_get_active(struct sysfs_dirent *sd);
+extern void sysfs_put_active(struct sysfs_dirent *sd);
+extern struct sysfs_dirent *sysfs_get_active_two(struct sysfs_dirent *sd);
+extern void sysfs_put_active_two(struct sysfs_dirent *sd);
+extern void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt,
+                              struct sysfs_dirent *parent_sd);
+extern void sysfs_add_one(struct sysfs_addrm_cxt *acxt,
+                          struct sysfs_dirent *sd);
+extern void sysfs_remove_one(struct sysfs_addrm_cxt *acxt,
+                             struct sysfs_dirent *sd);
+extern int sysfs_addrm_finish(struct sysfs_addrm_cxt *acxt);
 
-extern int sysfs_dirent_exist(struct sysfs_dirent *, const unsigned char *);
-extern int sysfs_make_dirent(struct sysfs_dirent *, struct dentry *, void *,
-                                umode_t, int);
-
-extern int sysfs_add_file(struct dentry *, const struct attribute *, int);
-extern int sysfs_hash_and_remove(struct dentry * dir, const char * name);
+extern void sysfs_delete_inode(struct inode *inode);
+extern void sysfs_init_inode(struct sysfs_dirent *sd, struct inode *inode);
+extern struct inode * sysfs_get_inode(struct sysfs_dirent *sd);
+extern void sysfs_instantiate(struct dentry *dentry, struct inode *inode);
+
+extern void release_sysfs_dirent(struct sysfs_dirent * sd);
+extern struct sysfs_dirent *sysfs_find_dirent(struct sysfs_dirent *parent_sd,
+                                              const unsigned char *name);
+extern struct sysfs_dirent *sysfs_get_dirent(struct sysfs_dirent *parent_sd,
+                                             const unsigned char *name);
+extern struct sysfs_dirent *sysfs_new_dirent(const char *name, umode_t mode,
+                                             int type);
+
+extern int sysfs_add_file(struct sysfs_dirent *dir_sd,
+                          const struct attribute *attr, int type);
+extern int sysfs_hash_and_remove(struct sysfs_dirent *dir_sd, const char *name);
 extern struct sysfs_dirent *sysfs_find(struct sysfs_dirent *dir, const char * name);
 
-extern int sysfs_create_subdir(struct kobject *, const char *, struct dentry **);
-extern void sysfs_remove_subdir(struct dentry *);
+extern int sysfs_create_subdir(struct kobject *kobj, const char *name,
+                               struct sysfs_dirent **p_sd);
+extern void sysfs_remove_subdir(struct sysfs_dirent *sd);
 
-extern const unsigned char * sysfs_get_name(struct sysfs_dirent *sd);
-extern void sysfs_drop_dentry(struct sysfs_dirent *sd, struct dentry *parent);
 extern int sysfs_setattr(struct dentry *dentry, struct iattr *iattr);
 
-extern spinlock_t sysfs_lock;
-extern struct rw_semaphore sysfs_rename_sem;
+extern spinlock_t sysfs_assoc_lock;
+extern struct mutex sysfs_mutex;
 extern struct super_block * sysfs_sb;
 extern const struct file_operations sysfs_dir_operations;
 extern const struct file_operations sysfs_file_operations;
@@ -42,73 +103,9 @@ extern const struct file_operations bin_fops;
 extern const struct inode_operations sysfs_dir_inode_operations;
 extern const struct inode_operations sysfs_symlink_inode_operations;
 
-struct sysfs_symlink {
-        char * link_name;
-        struct kobject * target_kobj;
-};
-
-struct sysfs_buffer {
-        struct list_head                associates;
-        size_t                          count;
-        loff_t                          pos;
-        char                            * page;
-        struct sysfs_ops                * ops;
-        struct semaphore                sem;
-        int                             orphaned;
-        int                             needs_read_fill;
-        int                             event;
-};
-
-struct sysfs_buffer_collection {
-        struct list_head        associates;
-};
-
-static inline struct kobject * to_kobj(struct dentry * dentry)
-{
-        struct sysfs_dirent * sd = dentry->d_fsdata;
-        return ((struct kobject *) sd->s_element);
-}
-
-static inline struct attribute * to_attr(struct dentry * dentry)
+static inline unsigned int sysfs_type(struct sysfs_dirent *sd)
 {
-        struct sysfs_dirent * sd = dentry->d_fsdata;
-        return ((struct attribute *) sd->s_element);
-}
-
-static inline struct bin_attribute * to_bin_attr(struct dentry * dentry)
-{
-        struct sysfs_dirent * sd = dentry->d_fsdata;
-        return ((struct bin_attribute *) sd->s_element);
-}
-
-static inline struct kobject *sysfs_get_kobject(struct dentry *dentry)
-{
-        struct kobject * kobj = NULL;
-
-        spin_lock(&dcache_lock);
-        if (!d_unhashed(dentry)) {
-                struct sysfs_dirent * sd = dentry->d_fsdata;
-                if (sd->s_type & SYSFS_KOBJ_LINK) {
-                        struct sysfs_symlink * sl = sd->s_element;
-                        kobj = kobject_get(sl->target_kobj);
-                } else
-                        kobj = kobject_get(sd->s_element);
-        }
-        spin_unlock(&dcache_lock);
-
-        return kobj;
-}
-
-static inline void release_sysfs_dirent(struct sysfs_dirent * sd)
-{
-        if (sd->s_type & SYSFS_KOBJ_LINK) {
-                struct sysfs_symlink * sl = sd->s_element;
-                kfree(sl->link_name);
-                kobject_put(sl->target_kobj);
-                kfree(sl);
-        }
-        kfree(sd->s_iattr);
-        kmem_cache_free(sysfs_dir_cachep, sd);
+        return sd->s_flags & SYSFS_TYPE_MASK;
 }
 
 static inline struct sysfs_dirent * sysfs_get(struct sysfs_dirent * sd)
@@ -122,7 +119,7 @@ static inline struct sysfs_dirent * sysfs_get(struct sysfs_dirent * sd)
 
 static inline void sysfs_put(struct sysfs_dirent * sd)
 {
-        if (atomic_dec_and_test(&sd->s_count))
+        if (sd && atomic_dec_and_test(&sd->s_count))
                 release_sysfs_dirent(sd);
 }
 
diff --git a/fs/udf/crc.c b/fs/udf/crc.c
index 1b82a4adc2f..ef2bfaa19d7 100644
--- a/fs/udf/crc.c
+++ b/fs/udf/crc.c
@@ -106,8 +106,8 @@ int main(void)
 {
         unsigned short x;
 
-        x = udf_crc16(bytes, sizeof bytes);
-        printf("udf_crc16: calculated = %4.4x, correct = %4.4x\n", x, 0x3299U);
+        x = udf_crc(bytes, sizeof bytes);
+        printf("udf_crc: calculated = %4.4x, correct = %4.4x\n", x, 0x3299U);
 
         return 0;
 }
diff --git a/fs/udf/ialloc.c b/fs/udf/ialloc.c
index 8206983f2eb..10f3188738a 100644
--- a/fs/udf/ialloc.c
+++ b/fs/udf/ialloc.c
@@ -50,7 +50,7 @@ void udf_free_inode(struct inode * inode)
                 else
                         UDF_SB_LVIDIU(sb)->numFiles =
                                 cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) - 1);
-                
+
                 mark_buffer_dirty(sbi->s_lvidbh);
         }
         mutex_unlock(&sbi->s_alloc_mutex);
@@ -136,6 +136,13 @@ struct inode * udf_new_inode (struct inode *dir, int mode, int * err)
                 UDF_I_EFE(inode) = 0;
                 UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize - sizeof(struct fileEntry), GFP_KERNEL);
         }
+        if (!UDF_I_DATA(inode))
+        {
+                iput(inode);
+                *err = -ENOMEM;
+                mutex_unlock(&sbi->s_alloc_mutex);
+                return NULL;
+        }
         if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_AD_IN_ICB))
                 UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
         else if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index bf7de0bdbab..5b82e489af7 100644
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -49,6 +49,7 @@ MODULE_LICENSE("GPL");
 static mode_t udf_convert_permissions(struct fileEntry *);
 static int udf_update_inode(struct inode *, int);
 static void udf_fill_inode(struct inode *, struct buffer_head *);
+static int udf_alloc_i_data(struct inode *inode, size_t size);
 static struct buffer_head *inode_getblk(struct inode *, sector_t, int *,
         long *, int *);
 static int8_t udf_insert_aext(struct inode *, struct extent_position,
@@ -734,7 +735,7 @@ static void udf_split_extents(struct inode *inode, int *c, int offset, int newbl
                         (*c) ++;
                         (*endnum) ++;
                 }
-                
+
                 laarr[curr].extLocation.logicalBlockNum = newblocknum;
                 if (etype == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
                         laarr[curr].extLocation.partitionReferenceNum =
@@ -836,7 +837,7 @@ static void udf_prealloc_extents(struct inode *inode, int c, int lastblock,
                                 {
                                         numalloc -= elen;
                                         if (*endnum > (i+1))
-                                                memmove(&laarr[i], &laarr[i+1], 
+                                                memmove(&laarr[i], &laarr[i+1],
                                                         sizeof(long_ad) * (*endnum - (i+1)));
                                         i --;
                                         (*endnum) --;
@@ -1024,7 +1025,7 @@ void udf_truncate(struct inode * inode)
         {
                 block_truncate_page(inode->i_mapping, inode->i_size, udf_get_block);
                 udf_truncate_extents(inode);
-        }       
+        }
 
         inode->i_mtime = inode->i_ctime = current_fs_time(inode->i_sb);
         if (IS_SYNC(inode))
@@ -1087,10 +1088,10 @@ __udf_read_inode(struct inode *inode)
                         {
                                 kernel_lb_addr loc;
                                 ie = (struct indirectEntry *)ibh->b_data;
-        
+
                                 loc = lelb_to_cpu(ie->indirectICB.extLocation);
-        
-                                if (ie->indirectICB.extLength && 
+
+                                if (ie->indirectICB.extLength &&
                                         (nbh = udf_read_ptagged(inode->i_sb, loc, 0, &ident)))
                                 {
                                         if (ident == TAG_IDENT_FE ||
@@ -1156,14 +1157,22 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
         {
                 UDF_I_EFE(inode) = 1;
                 UDF_I_USE(inode) = 0;
-                UDF_I_DATA(inode) = kmalloc(inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry), GFP_KERNEL);
+                if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry)))
+                {
+                        make_bad_inode(inode);
+                        return;
+                }
                 memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct extendedFileEntry), inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry));
         }
         else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_FE)
         {
                 UDF_I_EFE(inode) = 0;
                 UDF_I_USE(inode) = 0;
-                UDF_I_DATA(inode) = kmalloc(inode->i_sb->s_blocksize - sizeof(struct fileEntry), GFP_KERNEL);
+                if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - sizeof(struct fileEntry)))
+                {
+                        make_bad_inode(inode);
+                        return;
+                }
                 memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct fileEntry), inode->i_sb->s_blocksize - sizeof(struct fileEntry));
         }
         else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE)
@@ -1173,7 +1182,11 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
                 UDF_I_LENALLOC(inode) =
                         le32_to_cpu(
                                 ((struct unallocSpaceEntry *)bh->b_data)->lengthAllocDescs);
-                UDF_I_DATA(inode) = kmalloc(inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry), GFP_KERNEL);
+                if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry)))
+                {
+                        make_bad_inode(inode);
+                        return;
+                }
                 memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct unallocSpaceEntry), inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry));
                 return;
         }
@@ -1191,7 +1204,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
         inode->i_nlink = le16_to_cpu(fe->fileLinkCount);
         if (!inode->i_nlink)
                 inode->i_nlink = 1;
-        
+
         inode->i_size = le64_to_cpu(fe->informationLength);
         UDF_I_LENEXTENTS(inode) = inode->i_size;
 
@@ -1243,7 +1256,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
         }
         else
         {
-                inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) << 
+                inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
                         (inode->i_sb->s_blocksize_bits - 9);
 
                 if ( udf_stamp_to_time(&convtime, &convtime_usec,
@@ -1374,6 +1387,20 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
         }
 }
 
+static int udf_alloc_i_data(struct inode *inode, size_t size)
+{
+        UDF_I_DATA(inode) = kmalloc(size, GFP_KERNEL);
+
+        if (!UDF_I_DATA(inode))
+        {
+                printk(KERN_ERR "udf:udf_alloc_i_data (ino %ld) no free memory\n",
+                       inode->i_ino);
+                return -ENOMEM;
+        }
+
+        return 0;
+}
+
 static mode_t
 udf_convert_permissions(struct fileEntry *fe)
 {
@@ -2072,7 +2099,7 @@ int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
                         mark_buffer_dirty_inode(oepos.bh, inode);
                 }
         }
-        
+
         brelse(epos.bh);
         brelse(oepos.bh);
         return (elen >> 30);
diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index 22ff6ed55ce..2b3011689e8 100644
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -87,6 +87,7 @@
 #include <linux/smp_lock.h>
 #include <linux/buffer_head.h>
 #include <linux/vfs.h>
+#include <linux/log2.h>
 
 #include "swab.h"
 #include "util.h"
@@ -854,7 +855,7 @@ magic_found:
         uspi->s_fmask = fs32_to_cpu(sb, usb1->fs_fmask);
         uspi->s_fshift = fs32_to_cpu(sb, usb1->fs_fshift);
 
-        if (uspi->s_fsize & (uspi->s_fsize - 1)) {
+        if (!is_power_of_2(uspi->s_fsize)) {
                 printk(KERN_ERR "ufs_read_super: fragment size %u is not a power of 2\n",
                         uspi->s_fsize);
                         goto failed;
@@ -869,7 +870,7 @@ magic_found:
                         uspi->s_fsize);
                 goto failed;
         }
-        if (uspi->s_bsize & (uspi->s_bsize - 1)) {
+        if (!is_power_of_2(uspi->s_bsize)) {
                 printk(KERN_ERR "ufs_read_super: block size %u is not a power of 2\n",
                         uspi->s_bsize);
                 goto failed;
diff --git a/fs/utimes.c b/fs/utimes.c
index b3c88952465..83a7e69e706 100644
--- a/fs/utimes.c
+++ b/fs/utimes.c
@@ -106,7 +106,7 @@ long do_utimes(int dfd, char __user *filename, struct timespec *times, int flags
                 if (IS_IMMUTABLE(inode))
                         goto dput_and_out;
 
-                if (current->fsuid != inode->i_uid) {
+                if ((current->fsuid != inode->i_uid) && !capable(CAP_FOWNER)) {
                         if (f) {
                                 if (!(f->f_mode & FMODE_WRITE))
                                         goto dput_and_out;
diff --git a/fs/xfs/Makefile-linux-2.6 b/fs/xfs/Makefile-linux-2.6
index b49989bb89a..e7a9a83f008 100644
--- a/fs/xfs/Makefile-linux-2.6
+++ b/fs/xfs/Makefile-linux-2.6
@@ -64,6 +64,7 @@ xfs-y				+= xfs_alloc.o \
                                    xfs_dir2_sf.o \
                                    xfs_error.o \
                                    xfs_extfree_item.o \
+                                   xfs_filestream.o \
                                    xfs_fsops.o \
                                    xfs_ialloc.o \
                                    xfs_ialloc_btree.o \
@@ -77,6 +78,7 @@ xfs-y				+= xfs_alloc.o \
                                    xfs_log.o \
                                    xfs_log_recover.o \
                                    xfs_mount.o \
+                                   xfs_mru_cache.o \
                                    xfs_rename.o \
                                    xfs_trans.o \
                                    xfs_trans_ail.o \
diff --git a/fs/xfs/linux-2.6/kmem.h b/fs/xfs/linux-2.6/kmem.h
index 9ebabdf7829..4b6470cf87f 100644
--- a/fs/xfs/linux-2.6/kmem.h
+++ b/fs/xfs/linux-2.6/kmem.h
@@ -100,25 +100,6 @@ kmem_zone_destroy(kmem_zone_t *zone)
 extern void *kmem_zone_alloc(kmem_zone_t *, unsigned int __nocast);
 extern void *kmem_zone_zalloc(kmem_zone_t *, unsigned int __nocast);
 
-/*
- * Low memory cache shrinkers
- */
-
-typedef struct shrinker *kmem_shaker_t;
-typedef int (*kmem_shake_func_t)(int, gfp_t);
-
-static inline kmem_shaker_t
-kmem_shake_register(kmem_shake_func_t sfunc)
-{
-        return set_shrinker(DEFAULT_SEEKS, sfunc);
-}
-
-static inline void
-kmem_shake_deregister(kmem_shaker_t shrinker)
-{
-        remove_shrinker(shrinker);
-}
-
 static inline int
 kmem_shake_allow(gfp_t gfp_mask)
 {
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 7361861e3aa..fd4105d662e 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -108,14 +108,19 @@ xfs_page_trace(
 
 /*
  * Schedule IO completion handling on a xfsdatad if this was
- * the final hold on this ioend.
+ * the final hold on this ioend. If we are asked to wait,
+ * flush the workqueue.
  */
 STATIC void
 xfs_finish_ioend(
-        xfs_ioend_t             *ioend)
+        xfs_ioend_t     *ioend,
+        int             wait)
 {
-        if (atomic_dec_and_test(&ioend->io_remaining))
+        if (atomic_dec_and_test(&ioend->io_remaining)) {
                 queue_work(xfsdatad_workqueue, &ioend->io_work);
+                if (wait)
+                        flush_workqueue(xfsdatad_workqueue);
+        }
 }
 
 /*
@@ -156,6 +161,8 @@ xfs_setfilesize(
         xfs_fsize_t             bsize;
 
         ip = xfs_vtoi(ioend->io_vnode);
+        if (!ip)
+                return;
 
         ASSERT((ip->i_d.di_mode & S_IFMT) == S_IFREG);
         ASSERT(ioend->io_type != IOMAP_READ);
@@ -334,7 +341,7 @@ xfs_end_bio(
         bio->bi_end_io = NULL;
         bio_put(bio);
 
-        xfs_finish_ioend(ioend);
+        xfs_finish_ioend(ioend, 0);
         return 0;
 }
 
@@ -470,7 +477,7 @@ xfs_submit_ioend(
                 }
                 if (bio)
                         xfs_submit_ioend_bio(ioend, bio);
-                xfs_finish_ioend(ioend);
+                xfs_finish_ioend(ioend, 0);
         } while ((ioend = next) != NULL);
 }
 
@@ -1003,6 +1010,8 @@ xfs_page_state_convert(
                 if (buffer_unwritten(bh) || buffer_delay(bh) ||
                     ((buffer_uptodate(bh) || PageUptodate(page)) &&
                      !buffer_mapped(bh) && (unmapped || startio))) {
+                        int new_ioend = 0;
+
                         /*
                          * Make sure we don't use a read-only iomap
                          */
@@ -1021,6 +1030,15 @@ xfs_page_state_convert(
                         }
 
                         if (!iomap_valid) {
+                                /*
+                                 * if we didn't have a valid mapping then we
+                                 * need to ensure that we put the new mapping
+                                 * in a new ioend structure. This needs to be
+                                 * done to ensure that the ioends correctly
+                                 * reflect the block mappings at io completion
+                                 * for unwritten extent conversion.
+                                 */
+                                new_ioend = 1;
                                 if (type == IOMAP_NEW) {
                                         size = xfs_probe_cluster(inode,
                                                         page, bh, head, 0);
@@ -1040,7 +1058,7 @@ xfs_page_state_convert(
                                 if (startio) {
                                         xfs_add_to_ioend(inode, bh, offset,
                                                         type, &ioend,
-                                                        !iomap_valid);
+                                                        new_ioend);
                                 } else {
                                         set_buffer_dirty(bh);
                                         unlock_buffer(bh);
@@ -1416,6 +1434,13 @@ xfs_end_io_direct(
          * This is not necessary for synchronous direct I/O, but we do
          * it anyway to keep the code uniform and simpler.
          *
+         * Well, if only it were that simple. Because synchronous direct I/O
+         * requires extent conversion to occur *before* we return to userspace,
+         * we have to wait for extent conversion to complete. Look at the
+         * iocb that has been passed to us to determine if this is AIO or
+         * not. If it is synchronous, tell xfs_finish_ioend() to kick the
+         * workqueue and wait for it to complete.
+         *
          * The core direct I/O code might be changed to always call the
          * completion handler in the future, in which case all this can
          * go away.
@@ -1423,9 +1448,9 @@ xfs_end_io_direct(
         ioend->io_offset = offset;
         ioend->io_size = size;
         if (ioend->io_type == IOMAP_READ) {
-                xfs_finish_ioend(ioend);
+                xfs_finish_ioend(ioend, 0);
         } else if (private && size > 0) {
-                xfs_finish_ioend(ioend);
+                xfs_finish_ioend(ioend, is_sync_kiocb(iocb));
         } else {
                 /*
                  * A direct I/O write ioend starts it's life in unwritten
@@ -1434,7 +1459,7 @@ xfs_end_io_direct(
                  * handler.
                  */
                 INIT_WORK(&ioend->io_work, xfs_end_bio_written);
-                xfs_finish_ioend(ioend);
+                xfs_finish_ioend(ioend, 0);
         }
 
         /*
diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index fe4f66a5af1..2df63622354 100644
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -35,7 +35,7 @@
 #include <linux/freezer.h>
 
 static kmem_zone_t *xfs_buf_zone;
-static kmem_shaker_t xfs_buf_shake;
+static struct shrinker *xfs_buf_shake;
 STATIC int xfsbufd(void *);
 STATIC int xfsbufd_wakeup(int, gfp_t);
 STATIC void xfs_buf_delwri_queue(xfs_buf_t *, int);
@@ -314,7 +314,7 @@ xfs_buf_free(
 
         ASSERT(list_empty(&bp->b_hash_list));
 
-        if (bp->b_flags & _XBF_PAGE_CACHE) {
+        if (bp->b_flags & (_XBF_PAGE_CACHE|_XBF_PAGES)) {
                 uint            i;
 
                 if ((bp->b_flags & XBF_MAPPED) && (bp->b_page_count > 1))
@@ -323,18 +323,11 @@ xfs_buf_free(
                 for (i = 0; i < bp->b_page_count; i++) {
                         struct page     *page = bp->b_pages[i];
 
-                        ASSERT(!PagePrivate(page));
+                        if (bp->b_flags & _XBF_PAGE_CACHE)
+                                ASSERT(!PagePrivate(page));
                         page_cache_release(page);
                 }
                 _xfs_buf_free_pages(bp);
-        } else if (bp->b_flags & _XBF_KMEM_ALLOC) {
-                 /*
-                  * XXX(hch): bp->b_count_desired might be incorrect (see
-                  * xfs_buf_associate_memory for details), but fortunately
-                  * the Linux version of kmem_free ignores the len argument..
-                  */
-                kmem_free(bp->b_addr, bp->b_count_desired);
-                _xfs_buf_free_pages(bp);
         }
 
         xfs_buf_deallocate(bp);
@@ -764,43 +757,44 @@ xfs_buf_get_noaddr(
         size_t                  len,
         xfs_buftarg_t           *target)
 {
-        size_t                  malloc_len = len;
+        unsigned long           page_count = PAGE_ALIGN(len) >> PAGE_SHIFT;
+        int                     error, i;
         xfs_buf_t               *bp;
-        void                    *data;
-        int                     error;
 
         bp = xfs_buf_allocate(0);
         if (unlikely(bp == NULL))
                 goto fail;
         _xfs_buf_initialize(bp, target, 0, len, 0);
 
- try_again:
-        data = kmem_alloc(malloc_len, KM_SLEEP | KM_MAYFAIL | KM_LARGE);
-        if (unlikely(data == NULL))
+        error = _xfs_buf_get_pages(bp, page_count, 0);
+        if (error)
                 goto fail_free_buf;
 
-        /* check whether alignment matches.. */
-        if ((__psunsigned_t)data !=
-            ((__psunsigned_t)data & ~target->bt_smask)) {
-                /* .. else double the size and try again */
-                kmem_free(data, malloc_len);
-                malloc_len <<= 1;
-                goto try_again;
+        for (i = 0; i < page_count; i++) {
+                bp->b_pages[i] = alloc_page(GFP_KERNEL);
+                if (!bp->b_pages[i])
+                        goto fail_free_mem;
         }
+        bp->b_flags |= _XBF_PAGES;
 
-        error = xfs_buf_associate_memory(bp, data, len);
-        if (error)
+        error = _xfs_buf_map_pages(bp, XBF_MAPPED);
+        if (unlikely(error)) {
+                printk(KERN_WARNING "%s: failed to map pages\n",
+                                __FUNCTION__);
                 goto fail_free_mem;
-        bp->b_flags |= _XBF_KMEM_ALLOC;
+        }
 
         xfs_buf_unlock(bp);
 
-        XB_TRACE(bp, "no_daddr", data);
+        XB_TRACE(bp, "no_daddr", len);
         return bp;
+
  fail_free_mem:
-        kmem_free(data, malloc_len);
+        while (--i >= 0)
+                __free_page(bp->b_pages[i]);
+        _xfs_buf_free_pages(bp);
  fail_free_buf:
-        xfs_buf_free(bp);
+        xfs_buf_deallocate(bp);
  fail:
         return NULL;
 }
@@ -1453,6 +1447,7 @@ xfs_free_buftarg(
         int                     external)
 {
         xfs_flush_buftarg(btp, 1);
+        xfs_blkdev_issue_flush(btp);
         if (external)
                 xfs_blkdev_put(btp->bt_bdev);
         xfs_free_bufhash(btp);
@@ -1837,7 +1832,7 @@ xfs_buf_init(void)
         if (!xfsdatad_workqueue)
                 goto out_destroy_xfslogd_workqueue;
 
-        xfs_buf_shake = kmem_shake_register(xfsbufd_wakeup);
+        xfs_buf_shake = set_shrinker(DEFAULT_SEEKS, xfsbufd_wakeup);
         if (!xfs_buf_shake)
                 goto out_destroy_xfsdatad_workqueue;
 
@@ -1859,7 +1854,7 @@ xfs_buf_init(void)
 void
 xfs_buf_terminate(void)
 {
-        kmem_shake_deregister(xfs_buf_shake);
+        remove_shrinker(xfs_buf_shake);
         destroy_workqueue(xfsdatad_workqueue);
         destroy_workqueue(xfslogd_workqueue);
         kmem_zone_destroy(xfs_buf_zone);
diff --git a/fs/xfs/linux-2.6/xfs_buf.h b/fs/xfs/linux-2.6/xfs_buf.h
index b6241f6201a..b5908a34b15 100644
--- a/fs/xfs/linux-2.6/xfs_buf.h
+++ b/fs/xfs/linux-2.6/xfs_buf.h
@@ -63,7 +63,7 @@ typedef enum {
 
         /* flags used only internally */
         _XBF_PAGE_CACHE = (1 << 17),/* backed by pagecache                 */
-        _XBF_KMEM_ALLOC = (1 << 18),/* backed by kmem_alloc()              */
+        _XBF_PAGES = (1 << 18),     /* backed by refcounted pages          */
         _XBF_RUN_QUEUES = (1 << 19),/* run block device task queue         */
         _XBF_DELWRI_Q = (1 << 21),   /* buffer on delwri queue             */
 } xfs_buf_flags_t;
diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index 8c43cd2e237..cbcd40c8c2a 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -184,15 +184,6 @@ xfs_file_open(
 }
 
 STATIC int
-xfs_file_close(
-        struct file     *filp,
-        fl_owner_t      id)
-{
-        return -bhv_vop_close(vn_from_inode(filp->f_path.dentry->d_inode), 0,
-                                file_count(filp) > 1 ? L_FALSE : L_TRUE, NULL);
-}
-
-STATIC int
 xfs_file_release(
         struct inode    *inode,
         struct file     *filp)
@@ -436,7 +427,6 @@ const struct file_operations xfs_file_operations = {
 #endif
         .mmap           = xfs_file_mmap,
         .open           = xfs_file_open,
-        .flush          = xfs_file_close,
         .release        = xfs_file_release,
         .fsync          = xfs_file_fsync,
 #ifdef HAVE_FOP_OPEN_EXEC
@@ -458,7 +448,6 @@ const struct file_operations xfs_invis_file_operations = {
 #endif
         .mmap           = xfs_file_mmap,
         .open           = xfs_file_open,
-        .flush          = xfs_file_close,
         .release        = xfs_file_release,
         .fsync          = xfs_file_fsync,
 };
diff --git a/fs/xfs/linux-2.6/xfs_globals.c b/fs/xfs/linux-2.6/xfs_globals.c
index ed3a5e1b4b6..bb72c3d4141 100644
--- a/fs/xfs/linux-2.6/xfs_globals.c
+++ b/fs/xfs/linux-2.6/xfs_globals.c
@@ -46,6 +46,7 @@ xfs_param_t xfs_params = {
         .inherit_nosym  = {     0,              0,              1       },
         .rotorstep      = {     1,              1,              255     },
         .inherit_nodfrg = {     0,              1,              1       },
+        .fstrm_timer    = {     1,              50,             3600*100},
 };
 
 /*
diff --git a/fs/xfs/linux-2.6/xfs_ioctl.c b/fs/xfs/linux-2.6/xfs_ioctl.c
index ff5c41ff8d4..5917808abbd 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl.c
@@ -1019,7 +1019,7 @@ xfs_ioc_bulkstat(
 
         if (cmd == XFS_IOC_FSINUMBERS)
                 error = xfs_inumbers(mp, &inlast, &count,
-                                                bulkreq.ubuffer);
+                                        bulkreq.ubuffer, xfs_inumbers_fmt);
         else if (cmd == XFS_IOC_FSBULKSTAT_SINGLE)
                 error = xfs_bulkstat_single(mp, &inlast,
                                                 bulkreq.ubuffer, &done);
diff --git a/fs/xfs/linux-2.6/xfs_ioctl32.c b/fs/xfs/linux-2.6/xfs_ioctl32.c
index b83cebc165f..141cf15067c 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl32.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl32.c
@@ -23,10 +23,25 @@
 #include <linux/fs.h>
 #include <asm/uaccess.h>
 #include "xfs.h"
-#include "xfs_types.h"
 #include "xfs_fs.h"
+#include "xfs_bit.h"
+#include "xfs_log.h"
+#include "xfs_inum.h"
+#include "xfs_trans.h"
+#include "xfs_sb.h"
+#include "xfs_ag.h"
+#include "xfs_dir2.h"
+#include "xfs_dmapi.h"
+#include "xfs_mount.h"
+#include "xfs_bmap_btree.h"
+#include "xfs_attr_sf.h"
+#include "xfs_dir2_sf.h"
 #include "xfs_vfs.h"
 #include "xfs_vnode.h"
+#include "xfs_dinode.h"
+#include "xfs_inode.h"
+#include "xfs_itable.h"
+#include "xfs_error.h"
 #include "xfs_dfrag.h"
 
 #define  _NATIVE_IOC(cmd, type) \
@@ -34,6 +49,7 @@
 
 #if defined(CONFIG_IA64) || defined(CONFIG_X86_64)
 #define BROKEN_X86_ALIGNMENT
+#define _PACKED __attribute__((packed))
 /* on ia32 l_start is on a 32-bit boundary */
 typedef struct xfs_flock64_32 {
         __s16           l_type;
@@ -75,35 +91,276 @@ xfs_ioctl32_flock(
         return (unsigned long)p;
 }
 
+typedef struct compat_xfs_fsop_geom_v1 {
+        __u32           blocksize;      /* filesystem (data) block size */
+        __u32           rtextsize;      /* realtime extent size         */
+        __u32           agblocks;       /* fsblocks in an AG            */
+        __u32           agcount;        /* number of allocation groups  */
+        __u32           logblocks;      /* fsblocks in the log          */
+        __u32           sectsize;       /* (data) sector size, bytes    */
+        __u32           inodesize;      /* inode size in bytes          */
+        __u32           imaxpct;        /* max allowed inode space(%)   */
+        __u64           datablocks;     /* fsblocks in data subvolume   */
+        __u64           rtblocks;       /* fsblocks in realtime subvol  */
+        __u64           rtextents;      /* rt extents in realtime subvol*/
+        __u64           logstart;       /* starting fsblock of the log  */
+        unsigned char   uuid[16];       /* unique id of the filesystem  */
+        __u32           sunit;          /* stripe unit, fsblocks        */
+        __u32           swidth;         /* stripe width, fsblocks       */
+        __s32           version;        /* structure version            */
+        __u32           flags;          /* superblock version flags     */
+        __u32           logsectsize;    /* log sector size, bytes       */
+        __u32           rtsectsize;     /* realtime sector size, bytes  */
+        __u32           dirblocksize;   /* directory block size, bytes  */
+} __attribute__((packed)) compat_xfs_fsop_geom_v1_t;
+
+#define XFS_IOC_FSGEOMETRY_V1_32  \
+        _IOR ('X', 100, struct compat_xfs_fsop_geom_v1)
+
+STATIC unsigned long xfs_ioctl32_geom_v1(unsigned long arg)
+{
+        compat_xfs_fsop_geom_v1_t __user *p32 = (void __user *)arg;
+        xfs_fsop_geom_v1_t __user *p = compat_alloc_user_space(sizeof(*p));
+
+        if (copy_in_user(p, p32, sizeof(*p32)))
+                return -EFAULT;
+        return (unsigned long)p;
+}
+
+typedef struct compat_xfs_inogrp {
+        __u64           xi_startino;    /* starting inode number        */
+        __s32           xi_alloccount;  /* # bits set in allocmask      */
+        __u64           xi_allocmask;   /* mask of allocated inodes     */
+} __attribute__((packed)) compat_xfs_inogrp_t;
+
+STATIC int xfs_inumbers_fmt_compat(
+        void __user *ubuffer,
+        const xfs_inogrp_t *buffer,
+        long count,
+        long *written)
+{
+        compat_xfs_inogrp_t *p32 = ubuffer;
+        long i;
+
+        for (i = 0; i < count; i++) {
+                if (put_user(buffer[i].xi_startino,   &p32[i].xi_startino) ||
+                    put_user(buffer[i].xi_alloccount, &p32[i].xi_alloccount) ||
+                    put_user(buffer[i].xi_allocmask,  &p32[i].xi_allocmask))
+                        return -EFAULT;
+        }
+        *written = count * sizeof(*p32);
+        return 0;
+}
+
 #else
 
-typedef struct xfs_fsop_bulkreq32 {
+#define xfs_inumbers_fmt_compat xfs_inumbers_fmt
+#define _PACKED
+
+#endif
+
+/* XFS_IOC_FSBULKSTAT and friends */
+
+typedef struct compat_xfs_bstime {
+        __s32           tv_sec;         /* seconds              */
+        __s32           tv_nsec;        /* and nanoseconds      */
+} compat_xfs_bstime_t;
+
+STATIC int xfs_bstime_store_compat(
+        compat_xfs_bstime_t __user *p32,
+        const xfs_bstime_t *p)
+{
+        __s32 sec32;
+
+        sec32 = p->tv_sec;
+        if (put_user(sec32, &p32->tv_sec) ||
+            put_user(p->tv_nsec, &p32->tv_nsec))
+                return -EFAULT;
+        return 0;
+}
+
+typedef struct compat_xfs_bstat {
+        __u64           bs_ino;         /* inode number                 */
+        __u16           bs_mode;        /* type and mode                */
+        __u16           bs_nlink;       /* number of links              */
+        __u32           bs_uid;         /* user id                      */
+        __u32           bs_gid;         /* group id                     */
+        __u32           bs_rdev;        /* device value                 */
+        __s32           bs_blksize;     /* block size                   */
+        __s64           bs_size;        /* file size                    */
+        compat_xfs_bstime_t bs_atime;   /* access time                  */
+        compat_xfs_bstime_t bs_mtime;   /* modify time                  */
+        compat_xfs_bstime_t bs_ctime;   /* inode change time            */
+        int64_t         bs_blocks;      /* number of blocks             */
+        __u32           bs_xflags;      /* extended flags               */
+        __s32           bs_extsize;     /* extent size                  */
+        __s32           bs_extents;     /* number of extents            */
+        __u32           bs_gen;         /* generation count             */
+        __u16           bs_projid;      /* project id                   */
+        unsigned char   bs_pad[14];     /* pad space, unused            */
+        __u32           bs_dmevmask;    /* DMIG event mask              */
+        __u16           bs_dmstate;     /* DMIG state info              */
+        __u16           bs_aextents;    /* attribute number of extents  */
+} _PACKED compat_xfs_bstat_t;
+
+STATIC int xfs_bulkstat_one_fmt_compat(
+        void                    __user *ubuffer,
+        const xfs_bstat_t       *buffer)
+{
+        compat_xfs_bstat_t __user *p32 = ubuffer;
+
+        if (put_user(buffer->bs_ino, &p32->bs_ino) ||
+            put_user(buffer->bs_mode, &p32->bs_mode) ||
+            put_user(buffer->bs_nlink, &p32->bs_nlink) ||
+            put_user(buffer->bs_uid, &p32->bs_uid) ||
+            put_user(buffer->bs_gid, &p32->bs_gid) ||
+            put_user(buffer->bs_rdev, &p32->bs_rdev) ||
+            put_user(buffer->bs_blksize, &p32->bs_blksize) ||
+            put_user(buffer->bs_size, &p32->bs_size) ||
+            xfs_bstime_store_compat(&p32->bs_atime, &buffer->bs_atime) ||
+            xfs_bstime_store_compat(&p32->bs_mtime, &buffer->bs_mtime) ||
+            xfs_bstime_store_compat(&p32->bs_ctime, &buffer->bs_ctime) ||
+            put_user(buffer->bs_blocks, &p32->bs_blocks) ||
+            put_user(buffer->bs_xflags, &p32->bs_xflags) ||
+            put_user(buffer->bs_extsize, &p32->bs_extsize) ||
+            put_user(buffer->bs_extents, &p32->bs_extents) ||
+            put_user(buffer->bs_gen, &p32->bs_gen) ||
+            put_user(buffer->bs_projid, &p32->bs_projid) ||
+            put_user(buffer->bs_dmevmask, &p32->bs_dmevmask) ||
+            put_user(buffer->bs_dmstate, &p32->bs_dmstate) ||
+            put_user(buffer->bs_aextents, &p32->bs_aextents))
+                return -EFAULT;
+        return sizeof(*p32);
+}
+
+
+
+typedef struct compat_xfs_fsop_bulkreq {
         compat_uptr_t   lastip;         /* last inode # pointer         */
         __s32           icount;         /* count of entries in buffer   */
         compat_uptr_t   ubuffer;        /* user buffer for inode desc.  */
-        __s32           ocount;         /* output count pointer         */
-} xfs_fsop_bulkreq32_t;
+        compat_uptr_t   ocount;         /* output count pointer         */
+} compat_xfs_fsop_bulkreq_t;
 
-STATIC unsigned long
-xfs_ioctl32_bulkstat(
-        unsigned long           arg)
+#define XFS_IOC_FSBULKSTAT_32 \
+        _IOWR('X', 101, struct compat_xfs_fsop_bulkreq)
+#define XFS_IOC_FSBULKSTAT_SINGLE_32 \
+        _IOWR('X', 102, struct compat_xfs_fsop_bulkreq)
+#define XFS_IOC_FSINUMBERS_32 \
+        _IOWR('X', 103, struct compat_xfs_fsop_bulkreq)
+
+/* copied from xfs_ioctl.c */
+STATIC int
+xfs_ioc_bulkstat_compat(
+        xfs_mount_t             *mp,
+        unsigned int            cmd,
+        void                    __user *arg)
 {
-        xfs_fsop_bulkreq32_t    __user *p32 = (void __user *)arg;
-        xfs_fsop_bulkreq_t      __user *p = compat_alloc_user_space(sizeof(*p));
+        compat_xfs_fsop_bulkreq_t __user *p32 = (void __user *)arg;
         u32                     addr;
+        xfs_fsop_bulkreq_t      bulkreq;
+        int                     count;  /* # of records returned */
+        xfs_ino_t               inlast; /* last inode number */
+        int                     done;
+        int                     error;
+
+        /* done = 1 if there are more stats to get and if bulkstat */
+        /* should be called again (unused here, but used in dmapi) */
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
+
+        if (XFS_FORCED_SHUTDOWN(mp))
+                return -XFS_ERROR(EIO);
+
+        if (get_user(addr, &p32->lastip))
+                return -EFAULT;
+        bulkreq.lastip = compat_ptr(addr);
+        if (get_user(bulkreq.icount, &p32->icount) ||
+            get_user(addr, &p32->ubuffer))
+                return -EFAULT;
+        bulkreq.ubuffer = compat_ptr(addr);
+        if (get_user(addr, &p32->ocount))
+                return -EFAULT;
+        bulkreq.ocount = compat_ptr(addr);
+
+        if (copy_from_user(&inlast, bulkreq.lastip, sizeof(__s64)))
+                return -XFS_ERROR(EFAULT);
+
+        if ((count = bulkreq.icount) <= 0)
+                return -XFS_ERROR(EINVAL);
+
+        if (cmd == XFS_IOC_FSINUMBERS)
+                error = xfs_inumbers(mp, &inlast, &count,
+                                bulkreq.ubuffer, xfs_inumbers_fmt_compat);
+        else {
+                /* declare a var to get a warning in case the type changes */
+                bulkstat_one_fmt_pf formatter = xfs_bulkstat_one_fmt_compat;
+                error = xfs_bulkstat(mp, &inlast, &count,
+                        xfs_bulkstat_one, formatter,
+                        sizeof(compat_xfs_bstat_t), bulkreq.ubuffer,
+                        BULKSTAT_FG_QUICK, &done);
+        }
+        if (error)
+                return -error;
+
+        if (bulkreq.ocount != NULL) {
+                if (copy_to_user(bulkreq.lastip, &inlast,
+                                                sizeof(xfs_ino_t)))
+                        return -XFS_ERROR(EFAULT);
+
+                if (copy_to_user(bulkreq.ocount, &count, sizeof(count)))
+                        return -XFS_ERROR(EFAULT);
+        }
+
+        return 0;
+}
+
+
+
+typedef struct compat_xfs_fsop_handlereq {
+        __u32           fd;             /* fd for FD_TO_HANDLE          */
+        compat_uptr_t   path;           /* user pathname                */
+        __u32           oflags;         /* open flags                   */
+        compat_uptr_t   ihandle;        /* user supplied handle         */
+        __u32           ihandlen;       /* user supplied length         */
+        compat_uptr_t   ohandle;        /* user buffer for handle       */
+        compat_uptr_t   ohandlen;       /* user buffer length           */
+} compat_xfs_fsop_handlereq_t;
+
+#define XFS_IOC_PATH_TO_FSHANDLE_32 \
+        _IOWR('X', 104, struct compat_xfs_fsop_handlereq)
+#define XFS_IOC_PATH_TO_HANDLE_32 \
+        _IOWR('X', 105, struct compat_xfs_fsop_handlereq)
+#define XFS_IOC_FD_TO_HANDLE_32 \
+        _IOWR('X', 106, struct compat_xfs_fsop_handlereq)
+#define XFS_IOC_OPEN_BY_HANDLE_32 \
+        _IOWR('X', 107, struct compat_xfs_fsop_handlereq)
+#define XFS_IOC_READLINK_BY_HANDLE_32 \
+        _IOWR('X', 108, struct compat_xfs_fsop_handlereq)
+
+STATIC unsigned long xfs_ioctl32_fshandle(unsigned long arg)
+{
+        compat_xfs_fsop_handlereq_t __user *p32 = (void __user *)arg;
+        xfs_fsop_handlereq_t __user *p = compat_alloc_user_space(sizeof(*p));
+        u32 addr;
 
-        if (get_user(addr, &p32->lastip) ||
-            put_user(compat_ptr(addr), &p->lastip) ||
-            copy_in_user(&p->icount, &p32->icount, sizeof(s32)) ||
-            get_user(addr, &p32->ubuffer) ||
-            put_user(compat_ptr(addr), &p->ubuffer) ||
-            get_user(addr, &p32->ocount) ||
-            put_user(compat_ptr(addr), &p->ocount))
+        if (copy_in_user(&p->fd, &p32->fd, sizeof(__u32)) ||
+            get_user(addr, &p32->path) ||
+            put_user(compat_ptr(addr), &p->path) ||
+            copy_in_user(&p->oflags, &p32->oflags, sizeof(__u32)) ||
+            get_user(addr, &p32->ihandle) ||
+            put_user(compat_ptr(addr), &p->ihandle) ||
+            copy_in_user(&p->ihandlen, &p32->ihandlen, sizeof(__u32)) ||
+            get_user(addr, &p32->ohandle) ||
+            put_user(compat_ptr(addr), &p->ohandle) ||
+            get_user(addr, &p32->ohandlen) ||
+            put_user(compat_ptr(addr), &p->ohandlen))
                 return -EFAULT;
 
         return (unsigned long)p;
 }
-#endif
+
 
 STATIC long
 xfs_compat_ioctl(
@@ -118,7 +375,6 @@ xfs_compat_ioctl(
 
         switch (cmd) {
         case XFS_IOC_DIOINFO:
-        case XFS_IOC_FSGEOMETRY_V1:
         case XFS_IOC_FSGEOMETRY:
         case XFS_IOC_GETVERSION:
         case XFS_IOC_GETXFLAGS:
@@ -131,12 +387,7 @@ xfs_compat_ioctl(
         case XFS_IOC_GETBMAPA:
         case XFS_IOC_GETBMAPX:
 /* not handled
-        case XFS_IOC_FD_TO_HANDLE:
-        case XFS_IOC_PATH_TO_HANDLE:
-        case XFS_IOC_PATH_TO_FSHANDLE:
-        case XFS_IOC_OPEN_BY_HANDLE:
         case XFS_IOC_FSSETDM_BY_HANDLE:
-        case XFS_IOC_READLINK_BY_HANDLE:
         case XFS_IOC_ATTRLIST_BY_HANDLE:
         case XFS_IOC_ATTRMULTI_BY_HANDLE:
 */
@@ -166,6 +417,10 @@ xfs_compat_ioctl(
                 arg = xfs_ioctl32_flock(arg);
                 cmd = _NATIVE_IOC(cmd, struct xfs_flock64);
                 break;
+        case XFS_IOC_FSGEOMETRY_V1_32:
+                arg = xfs_ioctl32_geom_v1(arg);
+                cmd = _NATIVE_IOC(cmd, struct xfs_fsop_geom_v1);
+                break;
 
 #else /* These are handled fine if no alignment issues */
         case XFS_IOC_ALLOCSP:
@@ -176,18 +431,28 @@ xfs_compat_ioctl(
         case XFS_IOC_FREESP64:
         case XFS_IOC_RESVSP64:
         case XFS_IOC_UNRESVSP64:
+        case XFS_IOC_FSGEOMETRY_V1:
                 break;
 
         /* xfs_bstat_t still has wrong u32 vs u64 alignment */
         case XFS_IOC_SWAPEXT:
                 break;
 
-        case XFS_IOC_FSBULKSTAT_SINGLE:
-        case XFS_IOC_FSBULKSTAT:
-        case XFS_IOC_FSINUMBERS:
-                arg = xfs_ioctl32_bulkstat(arg);
-                break;
 #endif
+        case XFS_IOC_FSBULKSTAT_32:
+        case XFS_IOC_FSBULKSTAT_SINGLE_32:
+        case XFS_IOC_FSINUMBERS_32:
+                cmd = _NATIVE_IOC(cmd, struct xfs_fsop_bulkreq);
+                return xfs_ioc_bulkstat_compat(XFS_BHVTOI(VNHEAD(vp))->i_mount,
+                                cmd, (void*)arg);
+        case XFS_IOC_FD_TO_HANDLE_32:
+        case XFS_IOC_PATH_TO_HANDLE_32:
+        case XFS_IOC_PATH_TO_FSHANDLE_32:
+        case XFS_IOC_OPEN_BY_HANDLE_32:
+        case XFS_IOC_READLINK_BY_HANDLE_32:
+                arg = xfs_ioctl32_fshandle(arg);
+                cmd = _NATIVE_IOC(cmd, struct xfs_fsop_handlereq);
+                break;
         default:
                 return -ENOIOCTLCMD;
         }
diff --git a/fs/xfs/linux-2.6/xfs_linux.h b/fs/xfs/linux-2.6/xfs_linux.h
index af24a457d3a..330c4ba9d40 100644
--- a/fs/xfs/linux-2.6/xfs_linux.h
+++ b/fs/xfs/linux-2.6/xfs_linux.h
@@ -123,6 +123,7 @@
 #define xfs_inherit_nosymlinks  xfs_params.inherit_nosym.val
 #define xfs_rotorstep           xfs_params.rotorstep.val
 #define xfs_inherit_nodefrag    xfs_params.inherit_nodfrg.val
+#define xfs_fstrm_centisecs     xfs_params.fstrm_timer.val
 
 #define current_cpu()           (raw_smp_processor_id())
 #define current_pid()           (current->pid)
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index bf9a9d5909b..06894cf00b1 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -547,7 +547,8 @@ vfs_sync_worker(
 
         if (!(vfsp->vfs_flag & VFS_RDONLY))
                 error = bhv_vfs_sync(vfsp, SYNC_FSDATA | SYNC_BDFLUSH | \
-                                        SYNC_ATTR | SYNC_REFCACHE, NULL);
+                                        SYNC_ATTR | SYNC_REFCACHE | SYNC_SUPER,
+                                        NULL);
         vfsp->vfs_sync_seq++;
         wake_up(&vfsp->vfs_wait_single_sync_task);
 }
@@ -663,7 +664,7 @@ xfs_fs_sync_super(
                  * occur here so don't bother flushing the buftarg (i.e
                  * SYNC_QUIESCE) because it'll just get dirty again.
                  */
-                flags = SYNC_FSDATA | SYNC_DELWRI | SYNC_WAIT | SYNC_IOWAIT;
+                flags = SYNC_DATA_QUIESCE;
         } else
                 flags = SYNC_FSDATA | (wait ? SYNC_WAIT : 0);
 
diff --git a/fs/xfs/linux-2.6/xfs_sysctl.c b/fs/xfs/linux-2.6/xfs_sysctl.c
index cd6eaa44aa2..bb997d75c05 100644
--- a/fs/xfs/linux-2.6/xfs_sysctl.c
+++ b/fs/xfs/linux-2.6/xfs_sysctl.c
@@ -210,6 +210,17 @@ static ctl_table xfs_table[] = {
                 .extra1         = &xfs_params.inherit_nodfrg.min,
                 .extra2         = &xfs_params.inherit_nodfrg.max
         },
+        {
+                .ctl_name       = XFS_FILESTREAM_TIMER,
+                .procname       = "filestream_centisecs",
+                .data           = &xfs_params.fstrm_timer.val,
+                .maxlen         = sizeof(int),
+                .mode           = 0644,
+                .proc_handler   = &proc_dointvec_minmax,
+                .strategy       = &sysctl_intvec,
+                .extra1         = &xfs_params.fstrm_timer.min,
+                .extra2         = &xfs_params.fstrm_timer.max,
+        },
         /* please keep this the last entry */
 #ifdef CONFIG_PROC_FS
         {
diff --git a/fs/xfs/linux-2.6/xfs_sysctl.h b/fs/xfs/linux-2.6/xfs_sysctl.h
index a631fb8cc5a..98b97e399d6 100644
--- a/fs/xfs/linux-2.6/xfs_sysctl.h
+++ b/fs/xfs/linux-2.6/xfs_sysctl.h
@@ -47,6 +47,7 @@ typedef struct xfs_param {
         xfs_sysctl_val_t inherit_nosym; /* Inherit the "nosymlinks" flag. */
         xfs_sysctl_val_t rotorstep;     /* inode32 AG rotoring control knob */
         xfs_sysctl_val_t inherit_nodfrg;/* Inherit the "nodefrag" inode flag. */
+        xfs_sysctl_val_t fstrm_timer;   /* Filestream dir-AG assoc'n timeout. */
 } xfs_param_t;
 
 /*
@@ -86,6 +87,7 @@ enum {
         XFS_INHERIT_NOSYM = 19,
         XFS_ROTORSTEP = 20,
         XFS_INHERIT_NODFRG = 21,
+        XFS_FILESTREAM_TIMER = 22,
 };
 
 extern xfs_param_t      xfs_params;
diff --git a/fs/xfs/linux-2.6/xfs_vfs.h b/fs/xfs/linux-2.6/xfs_vfs.h
index e2c2ce98ab5..dca3481aaaf 100644
--- a/fs/xfs/linux-2.6/xfs_vfs.h
+++ b/fs/xfs/linux-2.6/xfs_vfs.h
@@ -92,6 +92,21 @@ typedef enum {
 #define SYNC_REFCACHE           0x0040  /* prune some of the nfs ref cache */
 #define SYNC_REMOUNT            0x0080  /* remount readonly, no dummy LRs */
 #define SYNC_IOWAIT             0x0100  /* wait for all I/O to complete */
+#define SYNC_SUPER              0x0200  /* flush superblock to disk */
+
+/*
+ * When remounting a filesystem read-only or freezing the filesystem,
+ * we have two phases to execute. This first phase is syncing the data
+ * before we quiesce the fielsystem, and the second is flushing all the
+ * inodes out after we've waited for all the transactions created by
+ * the first phase to complete. The second phase uses SYNC_INODE_QUIESCE
+ * to ensure that the inodes are written to their location on disk
+ * rather than just existing in transactions in the log. This means
+ * after a quiesce there is no log replay required to write the inodes
+ * to disk (this is the main difference between a sync and a quiesce).
+ */
+#define SYNC_DATA_QUIESCE       (SYNC_DELWRI|SYNC_FSDATA|SYNC_WAIT|SYNC_IOWAIT)
+#define SYNC_INODE_QUIESCE      (SYNC_REMOUNT|SYNC_ATTR|SYNC_WAIT)
 
 #define SHUTDOWN_META_IO_ERROR  0x0001  /* write attempt to metadata failed */
 #define SHUTDOWN_LOG_IO_ERROR   0x0002  /* write attempt to the log failed */
diff --git a/fs/xfs/linux-2.6/xfs_vnode.h b/fs/xfs/linux-2.6/xfs_vnode.h
index 013048a9264..5742d65f078 100644
--- a/fs/xfs/linux-2.6/xfs_vnode.h
+++ b/fs/xfs/linux-2.6/xfs_vnode.h
@@ -129,10 +129,7 @@ typedef enum bhv_vchange {
         VCHANGE_FLAGS_IOEXCL_COUNT      = 4
 } bhv_vchange_t;
 
-typedef enum { L_FALSE, L_TRUE } lastclose_t;
-
 typedef int     (*vop_open_t)(bhv_desc_t *, struct cred *);
-typedef int     (*vop_close_t)(bhv_desc_t *, int, lastclose_t, struct cred *);
 typedef ssize_t (*vop_read_t)(bhv_desc_t *, struct kiocb *,
                                 const struct iovec *, unsigned int,
                                 loff_t *, int, struct cred *);
@@ -200,7 +197,6 @@ typedef int	(*vop_iflush_t)(bhv_desc_t *, int);
 typedef struct bhv_vnodeops {
         bhv_position_t  vn_position;    /* position within behavior chain */
         vop_open_t              vop_open;
-        vop_close_t             vop_close;
         vop_read_t              vop_read;
         vop_write_t             vop_write;
         vop_splice_read_t       vop_splice_read;
@@ -245,7 +241,6 @@ typedef struct bhv_vnodeops {
 #define VNHEAD(vp)      ((vp)->v_bh.bh_first)
 #define VOP(op, vp)     (*((bhv_vnodeops_t *)VNHEAD(vp)->bd_ops)->op)
 #define bhv_vop_open(vp, cr)            VOP(vop_open, vp)(VNHEAD(vp),cr)
-#define bhv_vop_close(vp, f,last,cr)    VOP(vop_close, vp)(VNHEAD(vp),f,last,cr)
 #define bhv_vop_read(vp,file,iov,segs,offset,ioflags,cr)                \
                 VOP(vop_read, vp)(VNHEAD(vp),file,iov,segs,offset,ioflags,cr)
 #define bhv_vop_write(vp,file,iov,segs,offset,ioflags,cr)               \
diff --git a/fs/xfs/quota/xfs_qm.c b/fs/xfs/quota/xfs_qm.c
index 3e4a8ad8a34..7def4c69934 100644
--- a/fs/xfs/quota/xfs_qm.c
+++ b/fs/xfs/quota/xfs_qm.c
@@ -62,10 +62,9 @@ uint		ndquot;
 
 kmem_zone_t     *qm_dqzone;
 kmem_zone_t     *qm_dqtrxzone;
-static kmem_shaker_t    xfs_qm_shaker;
+static struct shrinker *xfs_qm_shaker;
 
 static cred_t   xfs_zerocr;
-static xfs_inode_t      xfs_zeroino;
 
 STATIC void     xfs_qm_list_init(xfs_dqlist_t *, char *, int);
 STATIC void     xfs_qm_list_destroy(xfs_dqlist_t *);
@@ -150,7 +149,7 @@ xfs_Gqm_init(void)
         } else
                 xqm->qm_dqzone = qm_dqzone;
 
-        xfs_qm_shaker = kmem_shake_register(xfs_qm_shake);
+        xfs_qm_shaker = set_shrinker(DEFAULT_SEEKS, xfs_qm_shake);
 
         /*
          * The t_dqinfo portion of transactions.
@@ -182,7 +181,7 @@ xfs_qm_destroy(
 
         ASSERT(xqm != NULL);
         ASSERT(xqm->qm_nrefs == 0);
-        kmem_shake_deregister(xfs_qm_shaker);
+        remove_shrinker(xfs_qm_shaker);
         hsize = xqm->qm_dqhashmask + 1;
         for (i = 0; i < hsize; i++) {
                 xfs_qm_list_destroy(&(xqm->qm_usr_dqhtable[i]));
@@ -1415,7 +1414,7 @@ xfs_qm_qino_alloc(
                 return error;
         }
 
-        if ((error = xfs_dir_ialloc(&tp, &xfs_zeroino, S_IFREG, 1, 0,
+        if ((error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0,
                                    &xfs_zerocr, 0, 1, ip, &committed))) {
                 xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
                                  XFS_TRANS_ABORT);
diff --git a/fs/xfs/xfs.h b/fs/xfs/xfs.h
index bf0a12040b1..b5a7d92c684 100644
--- a/fs/xfs/xfs.h
+++ b/fs/xfs/xfs.h
@@ -38,6 +38,7 @@
 #define XFS_RW_TRACE 1
 #define XFS_BUF_TRACE 1
 #define XFS_VNODE_TRACE 1
+#define XFS_FILESTREAMS_TRACE 1
 #endif
 
 #include <linux-2.6/xfs_linux.h>
diff --git a/fs/xfs/xfs_ag.h b/fs/xfs/xfs_ag.h
index 9ece7f87ec5..51c09c114a2 100644
--- a/fs/xfs/xfs_ag.h
+++ b/fs/xfs/xfs_ag.h
@@ -68,6 +68,7 @@ typedef struct xfs_agf {
         __be32          agf_flcount;    /* count of blocks in freelist */
         __be32          agf_freeblks;   /* total free blocks */
         __be32          agf_longest;    /* longest free space */
+        __be32          agf_btreeblks;  /* # of blocks held in AGF btrees */
 } xfs_agf_t;
 
 #define XFS_AGF_MAGICNUM        0x00000001
@@ -81,7 +82,8 @@ typedef struct xfs_agf {
 #define XFS_AGF_FLCOUNT         0x00000100
 #define XFS_AGF_FREEBLKS        0x00000200
 #define XFS_AGF_LONGEST         0x00000400
-#define XFS_AGF_NUM_BITS        11
+#define XFS_AGF_BTREEBLKS       0x00000800
+#define XFS_AGF_NUM_BITS        12
 #define XFS_AGF_ALL_BITS        ((1 << XFS_AGF_NUM_BITS) - 1)
 
 /* disk block (xfs_daddr_t) in the AG */
@@ -186,12 +188,15 @@ typedef struct xfs_perag
         __uint32_t      pagf_flcount;   /* count of blocks in freelist */
         xfs_extlen_t    pagf_freeblks;  /* total free blocks */
         xfs_extlen_t    pagf_longest;   /* longest free space */
+        __uint32_t      pagf_btreeblks; /* # of blocks held in AGF btrees */
         xfs_agino_t     pagi_freecount; /* number of free inodes */
+        xfs_agino_t     pagi_count;     /* number of allocated inodes */
+        int             pagb_count;     /* pagb slots in use */
 #ifdef __KERNEL__
         lock_t          pagb_lock;      /* lock for pagb_list */
 #endif
-        int             pagb_count;     /* pagb slots in use */
         xfs_perag_busy_t *pagb_list;    /* unstable blocks */
+        atomic_t        pagf_fstrms;    /* # of filestreams active in this AG */
 } xfs_perag_t;
 
 #define XFS_AG_MAXLEVELS(mp)            ((mp)->m_ag_maxlevels)
diff --git a/fs/xfs/xfs_alloc.c b/fs/xfs/xfs_alloc.c
index 8e9a40aa0cd..012a649a19c 100644
--- a/fs/xfs/xfs_alloc.c
+++ b/fs/xfs/xfs_alloc.c
@@ -55,17 +55,17 @@ xfs_alloc_search_busy(xfs_trans_t *tp,
 ktrace_t *xfs_alloc_trace_buf;
 
 #define TRACE_ALLOC(s,a)        \
-        xfs_alloc_trace_alloc(fname, s, a, __LINE__)
+        xfs_alloc_trace_alloc(__FUNCTION__, s, a, __LINE__)
 #define TRACE_FREE(s,a,b,x,f)   \
-        xfs_alloc_trace_free(fname, s, mp, a, b, x, f, __LINE__)
+        xfs_alloc_trace_free(__FUNCTION__, s, mp, a, b, x, f, __LINE__)
 #define TRACE_MODAGF(s,a,f)     \
-        xfs_alloc_trace_modagf(fname, s, mp, a, f, __LINE__)
-#define TRACE_BUSY(fname,s,ag,agb,l,sl,tp)      \
-        xfs_alloc_trace_busy(fname, s, mp, ag, agb, l, sl, tp, XFS_ALLOC_KTRACE_BUSY, __LINE__)
-#define TRACE_UNBUSY(fname,s,ag,sl,tp)  \
-        xfs_alloc_trace_busy(fname, s, mp, ag, -1, -1, sl, tp, XFS_ALLOC_KTRACE_UNBUSY, __LINE__)
-#define TRACE_BUSYSEARCH(fname,s,ag,agb,l,sl,tp)        \
-        xfs_alloc_trace_busy(fname, s, mp, ag, agb, l, sl, tp, XFS_ALLOC_KTRACE_BUSYSEARCH, __LINE__)
+        xfs_alloc_trace_modagf(__FUNCTION__, s, mp, a, f, __LINE__)
+#define TRACE_BUSY(__FUNCTION__,s,ag,agb,l,sl,tp)       \
+        xfs_alloc_trace_busy(__FUNCTION__, s, mp, ag, agb, l, sl, tp, XFS_ALLOC_KTRACE_BUSY, __LINE__)
+#define TRACE_UNBUSY(__FUNCTION__,s,ag,sl,tp)   \
+        xfs_alloc_trace_busy(__FUNCTION__, s, mp, ag, -1, -1, sl, tp, XFS_ALLOC_KTRACE_UNBUSY, __LINE__)
+#define TRACE_BUSYSEARCH(__FUNCTION__,s,ag,agb,l,sl,tp) \
+        xfs_alloc_trace_busy(__FUNCTION__, s, mp, ag, agb, l, sl, tp, XFS_ALLOC_KTRACE_BUSYSEARCH, __LINE__)
 #else
 #define TRACE_ALLOC(s,a)
 #define TRACE_FREE(s,a,b,x,f)
@@ -420,7 +420,7 @@ xfs_alloc_read_agfl(
  */
 STATIC void
 xfs_alloc_trace_alloc(
-        char            *name,          /* function tag string */
+        const char      *name,          /* function tag string */
         char            *str,           /* additional string */
         xfs_alloc_arg_t *args,          /* allocation argument structure */
         int             line)           /* source line number */
@@ -453,7 +453,7 @@ xfs_alloc_trace_alloc(
  */
 STATIC void
 xfs_alloc_trace_free(
-        char            *name,          /* function tag string */
+        const char      *name,          /* function tag string */
         char            *str,           /* additional string */
         xfs_mount_t     *mp,            /* file system mount point */
         xfs_agnumber_t  agno,           /* allocation group number */
@@ -479,7 +479,7 @@ xfs_alloc_trace_free(
  */
 STATIC void
 xfs_alloc_trace_modagf(
-        char            *name,          /* function tag string */
+        const char      *name,          /* function tag string */
         char            *str,           /* additional string */
         xfs_mount_t     *mp,            /* file system mount point */
         xfs_agf_t       *agf,           /* new agf value */
@@ -507,7 +507,7 @@ xfs_alloc_trace_modagf(
 
 STATIC void
 xfs_alloc_trace_busy(
-        char            *name,          /* function tag string */
+        const char      *name,          /* function tag string */
         char            *str,           /* additional string */
         xfs_mount_t     *mp,            /* file system mount point */
         xfs_agnumber_t  agno,           /* allocation group number */
@@ -549,9 +549,6 @@ xfs_alloc_ag_vextent(
         xfs_alloc_arg_t *args)  /* argument structure for allocation */
 {
         int             error=0;
-#ifdef XFS_ALLOC_TRACE
-        static char     fname[] = "xfs_alloc_ag_vextent";
-#endif
 
         ASSERT(args->minlen > 0);
         ASSERT(args->maxlen > 0);
@@ -635,9 +632,6 @@ xfs_alloc_ag_vextent_exact(
         xfs_agblock_t   fbno;   /* start block of found extent */
         xfs_agblock_t   fend;   /* end block of found extent */
         xfs_extlen_t    flen;   /* length of found extent */
-#ifdef XFS_ALLOC_TRACE
-        static char     fname[] = "xfs_alloc_ag_vextent_exact";
-#endif
         int             i;      /* success/failure of operation */
         xfs_agblock_t   maxend; /* end of maximal extent */
         xfs_agblock_t   minend; /* end of minimal extent */
@@ -737,9 +731,6 @@ xfs_alloc_ag_vextent_near(
         xfs_btree_cur_t *bno_cur_gt;    /* cursor for bno btree, right side */
         xfs_btree_cur_t *bno_cur_lt;    /* cursor for bno btree, left side */
         xfs_btree_cur_t *cnt_cur;       /* cursor for count btree */
-#ifdef XFS_ALLOC_TRACE
-        static char     fname[] = "xfs_alloc_ag_vextent_near";
-#endif
         xfs_agblock_t   gtbno;          /* start bno of right side entry */
         xfs_agblock_t   gtbnoa;         /* aligned ... */
         xfs_extlen_t    gtdiff;         /* difference to right side entry */
@@ -1270,9 +1261,6 @@ xfs_alloc_ag_vextent_size(
         int             error;          /* error result */
         xfs_agblock_t   fbno;           /* start of found freespace */
         xfs_extlen_t    flen;           /* length of found freespace */
-#ifdef XFS_ALLOC_TRACE
-        static char     fname[] = "xfs_alloc_ag_vextent_size";
-#endif
         int             i;              /* temp status variable */
         xfs_agblock_t   rbno;           /* returned block number */
         xfs_extlen_t    rlen;           /* length of returned extent */
@@ -1427,9 +1415,6 @@ xfs_alloc_ag_vextent_small(
         int             error;
         xfs_agblock_t   fbno;
         xfs_extlen_t    flen;
-#ifdef XFS_ALLOC_TRACE
-        static char     fname[] = "xfs_alloc_ag_vextent_small";
-#endif
         int             i;
 
         if ((error = xfs_alloc_decrement(ccur, 0, &i)))
@@ -1447,7 +1432,8 @@ xfs_alloc_ag_vextent_small(
         else if (args->minlen == 1 && args->alignment == 1 && !args->isfl &&
                  (be32_to_cpu(XFS_BUF_TO_AGF(args->agbp)->agf_flcount)
                   > args->minleft)) {
-                if ((error = xfs_alloc_get_freelist(args->tp, args->agbp, &fbno)))
+                error = xfs_alloc_get_freelist(args->tp, args->agbp, &fbno, 0);
+                if (error)
                         goto error0;
                 if (fbno != NULLAGBLOCK) {
                         if (args->userdata) {
@@ -1515,9 +1501,6 @@ xfs_free_ag_extent(
         xfs_btree_cur_t *bno_cur;       /* cursor for by-block btree */
         xfs_btree_cur_t *cnt_cur;       /* cursor for by-size btree */
         int             error;          /* error return value */
-#ifdef XFS_ALLOC_TRACE
-        static char     fname[] = "xfs_free_ag_extent";
-#endif
         xfs_agblock_t   gtbno;          /* start of right neighbor block */
         xfs_extlen_t    gtlen;          /* length of right neighbor block */
         int             haveleft;       /* have a left neighbor block */
@@ -1923,7 +1906,8 @@ xfs_alloc_fix_freelist(
         while (be32_to_cpu(agf->agf_flcount) > need) {
                 xfs_buf_t       *bp;
 
-                if ((error = xfs_alloc_get_freelist(tp, agbp, &bno)))
+                error = xfs_alloc_get_freelist(tp, agbp, &bno, 0);
+                if (error)
                         return error;
                 if ((error = xfs_free_ag_extent(tp, agbp, args->agno, bno, 1, 1)))
                         return error;
@@ -1973,8 +1957,9 @@ xfs_alloc_fix_freelist(
                  * Put each allocated block on the list.
                  */
                 for (bno = targs.agbno; bno < targs.agbno + targs.len; bno++) {
-                        if ((error = xfs_alloc_put_freelist(tp, agbp, agflbp,
-                                        bno)))
+                        error = xfs_alloc_put_freelist(tp, agbp,
+                                                        agflbp, bno, 0);
+                        if (error)
                                 return error;
                 }
         }
@@ -1991,16 +1976,15 @@ int				/* error */
 xfs_alloc_get_freelist(
         xfs_trans_t     *tp,    /* transaction pointer */
         xfs_buf_t       *agbp,  /* buffer containing the agf structure */
-        xfs_agblock_t   *bnop)  /* block address retrieved from freelist */
+        xfs_agblock_t   *bnop,  /* block address retrieved from freelist */
+        int             btreeblk) /* destination is a AGF btree */
 {
         xfs_agf_t       *agf;   /* a.g. freespace structure */
         xfs_agfl_t      *agfl;  /* a.g. freelist structure */
         xfs_buf_t       *agflbp;/* buffer for a.g. freelist structure */
         xfs_agblock_t   bno;    /* block number returned */
         int             error;
-#ifdef XFS_ALLOC_TRACE
-        static char     fname[] = "xfs_alloc_get_freelist";
-#endif
+        int             logflags;
         xfs_mount_t     *mp;    /* mount structure */
         xfs_perag_t     *pag;   /* per allocation group data */
 
@@ -2032,8 +2016,16 @@ xfs_alloc_get_freelist(
         be32_add(&agf->agf_flcount, -1);
         xfs_trans_agflist_delta(tp, -1);
         pag->pagf_flcount--;
-        TRACE_MODAGF(NULL, agf, XFS_AGF_FLFIRST | XFS_AGF_FLCOUNT);
-        xfs_alloc_log_agf(tp, agbp, XFS_AGF_FLFIRST | XFS_AGF_FLCOUNT);
+
+        logflags = XFS_AGF_FLFIRST | XFS_AGF_FLCOUNT;
+        if (btreeblk) {
+                be32_add(&agf->agf_btreeblks, 1);
+                pag->pagf_btreeblks++;
+                logflags |= XFS_AGF_BTREEBLKS;
+        }
+
+        TRACE_MODAGF(NULL, agf, logflags);
+        xfs_alloc_log_agf(tp, agbp, logflags);
         *bnop = bno;
 
         /*
@@ -2071,6 +2063,7 @@ xfs_alloc_log_agf(
                 offsetof(xfs_agf_t, agf_flcount),
                 offsetof(xfs_agf_t, agf_freeblks),
                 offsetof(xfs_agf_t, agf_longest),
+                offsetof(xfs_agf_t, agf_btreeblks),
                 sizeof(xfs_agf_t)
         };
 
@@ -2106,15 +2099,14 @@ xfs_alloc_put_freelist(
         xfs_trans_t             *tp,    /* transaction pointer */
         xfs_buf_t               *agbp,  /* buffer for a.g. freelist header */
         xfs_buf_t               *agflbp,/* buffer for a.g. free block array */
-        xfs_agblock_t           bno)    /* block being freed */
+        xfs_agblock_t           bno,    /* block being freed */
+        int                     btreeblk) /* block came from a AGF btree */
 {
         xfs_agf_t               *agf;   /* a.g. freespace structure */
         xfs_agfl_t              *agfl;  /* a.g. free block array */
         __be32                  *blockp;/* pointer to array entry */
         int                     error;
-#ifdef XFS_ALLOC_TRACE
-        static char             fname[] = "xfs_alloc_put_freelist";
-#endif
+        int                     logflags;
         xfs_mount_t             *mp;    /* mount structure */
         xfs_perag_t             *pag;   /* per allocation group data */
 
@@ -2132,11 +2124,22 @@ xfs_alloc_put_freelist(
         be32_add(&agf->agf_flcount, 1);
         xfs_trans_agflist_delta(tp, 1);
         pag->pagf_flcount++;
+
+        logflags = XFS_AGF_FLLAST | XFS_AGF_FLCOUNT;
+        if (btreeblk) {
+                be32_add(&agf->agf_btreeblks, -1);
+                pag->pagf_btreeblks--;
+                logflags |= XFS_AGF_BTREEBLKS;
+        }
+
+        TRACE_MODAGF(NULL, agf, logflags);
+        xfs_alloc_log_agf(tp, agbp, logflags);
+
         ASSERT(be32_to_cpu(agf->agf_flcount) <= XFS_AGFL_SIZE(mp));
         blockp = &agfl->agfl_bno[be32_to_cpu(agf->agf_fllast)];
         *blockp = cpu_to_be32(bno);
-        TRACE_MODAGF(NULL, agf, XFS_AGF_FLLAST | XFS_AGF_FLCOUNT);
-        xfs_alloc_log_agf(tp, agbp, XFS_AGF_FLLAST | XFS_AGF_FLCOUNT);
+        TRACE_MODAGF(NULL, agf, logflags);
+        xfs_alloc_log_agf(tp, agbp, logflags);
         xfs_trans_log_buf(tp, agflbp,
                 (int)((xfs_caddr_t)blockp - (xfs_caddr_t)agfl),
                 (int)((xfs_caddr_t)blockp - (xfs_caddr_t)agfl +
@@ -2196,6 +2199,7 @@ xfs_alloc_read_agf(
         pag = &mp->m_perag[agno];
         if (!pag->pagf_init) {
                 pag->pagf_freeblks = be32_to_cpu(agf->agf_freeblks);
+                pag->pagf_btreeblks = be32_to_cpu(agf->agf_btreeblks);
                 pag->pagf_flcount = be32_to_cpu(agf->agf_flcount);
                 pag->pagf_longest = be32_to_cpu(agf->agf_longest);
                 pag->pagf_levels[XFS_BTNUM_BNOi] =
@@ -2235,9 +2239,6 @@ xfs_alloc_vextent(
         xfs_agblock_t   agsize; /* allocation group size */
         int             error;
         int             flags;  /* XFS_ALLOC_FLAG_... locking flags */
-#ifdef XFS_ALLOC_TRACE
-        static char     fname[] = "xfs_alloc_vextent";
-#endif
         xfs_extlen_t    minleft;/* minimum left value, temp copy */
         xfs_mount_t     *mp;    /* mount structure pointer */
         xfs_agnumber_t  sagno;  /* starting allocation group number */
diff --git a/fs/xfs/xfs_alloc.h b/fs/xfs/xfs_alloc.h
index 5a4256120cc..5aec15d0651 100644
--- a/fs/xfs/xfs_alloc.h
+++ b/fs/xfs/xfs_alloc.h
@@ -136,7 +136,8 @@ int				/* error */
 xfs_alloc_get_freelist(
         struct xfs_trans *tp,   /* transaction pointer */
         struct xfs_buf  *agbp,  /* buffer containing the agf structure */
-        xfs_agblock_t   *bnop); /* block address retrieved from freelist */
+        xfs_agblock_t   *bnop,  /* block address retrieved from freelist */
+        int             btreeblk); /* destination is a AGF btree */
 
 /*
  * Log the given fields from the agf structure.
@@ -165,7 +166,8 @@ xfs_alloc_put_freelist(
         struct xfs_trans *tp,   /* transaction pointer */
         struct xfs_buf  *agbp,  /* buffer for a.g. freelist header */
         struct xfs_buf  *agflbp,/* buffer for a.g. free block array */
-        xfs_agblock_t   bno);   /* block being freed */
+        xfs_agblock_t   bno,    /* block being freed */
+        int             btreeblk); /* owner was a AGF btree */
 
 /*
  * Read in the allocation group header (free/alloc section).
diff --git a/fs/xfs/xfs_alloc_btree.c b/fs/xfs/xfs_alloc_btree.c
index 74cadf95d4e..1603ce59585 100644
--- a/fs/xfs/xfs_alloc_btree.c
+++ b/fs/xfs/xfs_alloc_btree.c
@@ -226,8 +226,9 @@ xfs_alloc_delrec(
                         /*
                          * Put this buffer/block on the ag's freelist.
                          */
-                        if ((error = xfs_alloc_put_freelist(cur->bc_tp,
-                                        cur->bc_private.a.agbp, NULL, bno)))
+                        error = xfs_alloc_put_freelist(cur->bc_tp,
+                                        cur->bc_private.a.agbp, NULL, bno, 1);
+                        if (error)
                                 return error;
                         /*
                          * Since blocks move to the free list without the
@@ -549,8 +550,9 @@ xfs_alloc_delrec(
         /*
          * Free the deleting block by putting it on the freelist.
          */
-        if ((error = xfs_alloc_put_freelist(cur->bc_tp, cur->bc_private.a.agbp,
-                        NULL, rbno)))
+        error = xfs_alloc_put_freelist(cur->bc_tp,
+                                         cur->bc_private.a.agbp, NULL, rbno, 1);
+        if (error)
                 return error;
         /*
          * Since blocks move to the free list without the coordination
@@ -1320,8 +1322,9 @@ xfs_alloc_newroot(
         /*
          * Get a buffer from the freelist blocks, for the new root.
          */
-        if ((error = xfs_alloc_get_freelist(cur->bc_tp, cur->bc_private.a.agbp,
-                        &nbno)))
+        error = xfs_alloc_get_freelist(cur->bc_tp,
+                                        cur->bc_private.a.agbp, &nbno, 1);
+        if (error)
                 return error;
         /*
          * None available, we fail.
@@ -1604,8 +1607,9 @@ xfs_alloc_split(
          * Allocate the new block from the freelist.
          * If we can't do it, we're toast.  Give up.
          */
-        if ((error = xfs_alloc_get_freelist(cur->bc_tp, cur->bc_private.a.agbp,
-                        &rbno)))
+        error = xfs_alloc_get_freelist(cur->bc_tp,
+                                         cur->bc_private.a.agbp, &rbno, 1);
+        if (error)
                 return error;
         if (rbno == NULLAGBLOCK) {
                 *stat = 0;
diff --git a/fs/xfs/xfs_bit.c b/fs/xfs/xfs_bit.c
index 1afe07f67e3..fab0b6d5a41 100644
--- a/fs/xfs/xfs_bit.c
+++ b/fs/xfs/xfs_bit.c
@@ -66,44 +66,6 @@ static const char xfs_highbit[256] = {
 #endif
 
 /*
- * Count of bits set in byte, 0..8.
- */
-static const char xfs_countbit[256] = {
-        0, 1, 1, 2, 1, 2, 2, 3,                 /* 00 .. 07 */
-        1, 2, 2, 3, 2, 3, 3, 4,                 /* 08 .. 0f */
-        1, 2, 2, 3, 2, 3, 3, 4,                 /* 10 .. 17 */
-        2, 3, 3, 4, 3, 4, 4, 5,                 /* 18 .. 1f */
-        1, 2, 2, 3, 2, 3, 3, 4,                 /* 20 .. 27 */
-        2, 3, 3, 4, 3, 4, 4, 5,                 /* 28 .. 2f */
-        2, 3, 3, 4, 3, 4, 4, 5,                 /* 30 .. 37 */
-        3, 4, 4, 5, 4, 5, 5, 6,                 /* 38 .. 3f */
-        1, 2, 2, 3, 2, 3, 3, 4,                 /* 40 .. 47 */
-        2, 3, 3, 4, 3, 4, 4, 5,                 /* 48 .. 4f */
-        2, 3, 3, 4, 3, 4, 4, 5,                 /* 50 .. 57 */
-        3, 4, 4, 5, 4, 5, 5, 6,                 /* 58 .. 5f */
-        2, 3, 3, 4, 3, 4, 4, 5,                 /* 60 .. 67 */
-        3, 4, 4, 5, 4, 5, 5, 6,                 /* 68 .. 6f */
-        3, 4, 4, 5, 4, 5, 5, 6,                 /* 70 .. 77 */
-        4, 5, 5, 6, 5, 6, 6, 7,                 /* 78 .. 7f */
-        1, 2, 2, 3, 2, 3, 3, 4,                 /* 80 .. 87 */
-        2, 3, 3, 4, 3, 4, 4, 5,                 /* 88 .. 8f */
-        2, 3, 3, 4, 3, 4, 4, 5,                 /* 90 .. 97 */
-        3, 4, 4, 5, 4, 5, 5, 6,                 /* 98 .. 9f */
-        2, 3, 3, 4, 3, 4, 4, 5,                 /* a0 .. a7 */
-        3, 4, 4, 5, 4, 5, 5, 6,                 /* a8 .. af */
-        3, 4, 4, 5, 4, 5, 5, 6,                 /* b0 .. b7 */
-        4, 5, 5, 6, 5, 6, 6, 7,                 /* b8 .. bf */
-        2, 3, 3, 4, 3, 4, 4, 5,                 /* c0 .. c7 */
-        3, 4, 4, 5, 4, 5, 5, 6,                 /* c8 .. cf */
-        3, 4, 4, 5, 4, 5, 5, 6,                 /* d0 .. d7 */
-        4, 5, 5, 6, 5, 6, 6, 7,                 /* d8 .. df */
-        3, 4, 4, 5, 4, 5, 5, 6,                 /* e0 .. e7 */
-        4, 5, 5, 6, 5, 6, 6, 7,                 /* e8 .. ef */
-        4, 5, 5, 6, 5, 6, 6, 7,                 /* f0 .. f7 */
-        5, 6, 6, 7, 6, 7, 7, 8,                 /* f8 .. ff */
-};
-
-/*
  * xfs_highbit32: get high bit set out of 32-bit argument, -1 if none set.
  */
 inline int
@@ -167,56 +129,21 @@ xfs_highbit64(
 
 
 /*
- * Count the number of bits set in the bitmap starting with bit
- * start_bit.  Size is the size of the bitmap in words.
- *
- * Do the counting by mapping a byte value to the number of set
- * bits for that value using the xfs_countbit array, i.e.
- * xfs_countbit[0] == 0, xfs_countbit[1] == 1, xfs_countbit[2] == 1,
- * xfs_countbit[3] == 2, etc.
+ * Return whether bitmap is empty.
+ * Size is number of words in the bitmap, which is padded to word boundary
+ * Returns 1 for empty, 0 for non-empty.
  */
 int
-xfs_count_bits(uint *map, uint size, uint start_bit)
+xfs_bitmap_empty(uint *map, uint size)
 {
-        register int    bits;
-        register unsigned char  *bytep;
-        register unsigned char  *end_map;
-        int             byte_bit;
-
-        bits = 0;
-        end_map = (char*)(map + size);
-        bytep = (char*)(map + (start_bit & ~0x7));
-        byte_bit = start_bit & 0x7;
-
-        /*
-         * If the caller fell off the end of the map, return 0.
-         */
-        if (bytep >= end_map) {
-                return (0);
-        }
-
-        /*
-         * If start_bit is not byte aligned, then process the
-         * first byte separately.
-         */
-        if (byte_bit != 0) {
-                /*
-                 * Shift off the bits we don't want to look at,
-                 * before indexing into xfs_countbit.
-                 */
-                bits += xfs_countbit[(*bytep >> byte_bit)];
-                bytep++;
-        }
+        uint i;
+        uint ret = 0;
 
-        /*
-         * Count the bits in each byte until the end of the bitmap.
-         */
-        while (bytep < end_map) {
-                bits += xfs_countbit[*bytep];
-                bytep++;
+        for (i = 0; i < size; i++) {
+                ret |= map[i];
         }
 
-        return (bits);
+        return (ret == 0);
 }
 
 /*
diff --git a/fs/xfs/xfs_bit.h b/fs/xfs/xfs_bit.h
index 0bbe5681754..082641a9782 100644
--- a/fs/xfs/xfs_bit.h
+++ b/fs/xfs/xfs_bit.h
@@ -55,8 +55,8 @@ extern int xfs_lowbit64(__uint64_t v);
 /* Get high bit set out of 64-bit argument, -1 if none set */
 extern int xfs_highbit64(__uint64_t);
 
-/* Count set bits in map starting with start_bit */
-extern int xfs_count_bits(uint *map, uint size, uint start_bit);
+/* Return whether bitmap is empty (1 == empty) */
+extern int xfs_bitmap_empty(uint *map, uint size);
 
 /* Count continuous one bits in map starting with start_bit */
 extern int xfs_contig_bits(uint *map, uint size, uint start_bit);
diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index b1ea26e40aa..94b5c5fe268 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -52,6 +52,7 @@
 #include "xfs_quota.h"
 #include "xfs_trans_space.h"
 #include "xfs_buf_item.h"
+#include "xfs_filestream.h"
 
 
 #ifdef DEBUG
@@ -277,7 +278,7 @@ xfs_bmap_isaeof(
 STATIC void
 xfs_bmap_trace_addentry(
         int             opcode,         /* operation */
-        char            *fname,         /* function name */
+        const char      *fname,         /* function name */
         char            *desc,          /* operation description */
         xfs_inode_t     *ip,            /* incore inode pointer */
         xfs_extnum_t    idx,            /* index of entry(ies) */
@@ -291,7 +292,7 @@ xfs_bmap_trace_addentry(
  */
 STATIC void
 xfs_bmap_trace_delete(
-        char            *fname,         /* function name */
+        const char      *fname,         /* function name */
         char            *desc,          /* operation description */
         xfs_inode_t     *ip,            /* incore inode pointer */
         xfs_extnum_t    idx,            /* index of entry(entries) deleted */
@@ -304,7 +305,7 @@ xfs_bmap_trace_delete(
  */
 STATIC void
 xfs_bmap_trace_insert(
-        char            *fname,         /* function name */
+        const char      *fname,         /* function name */
         char            *desc,          /* operation description */
         xfs_inode_t     *ip,            /* incore inode pointer */
         xfs_extnum_t    idx,            /* index of entry(entries) inserted */
@@ -318,7 +319,7 @@ xfs_bmap_trace_insert(
  */
 STATIC void
 xfs_bmap_trace_post_update(
-        char            *fname,         /* function name */
+        const char      *fname,         /* function name */
         char            *desc,          /* operation description */
         xfs_inode_t     *ip,            /* incore inode pointer */
         xfs_extnum_t    idx,            /* index of entry updated */
@@ -329,17 +330,25 @@ xfs_bmap_trace_post_update(
  */
 STATIC void
 xfs_bmap_trace_pre_update(
-        char            *fname,         /* function name */
+        const char      *fname,         /* function name */
         char            *desc,          /* operation description */
         xfs_inode_t     *ip,            /* incore inode pointer */
         xfs_extnum_t    idx,            /* index of entry to be updated */
         int             whichfork);     /* data or attr fork */
 
+#define XFS_BMAP_TRACE_DELETE(d,ip,i,c,w)       \
+        xfs_bmap_trace_delete(__FUNCTION__,d,ip,i,c,w)
+#define XFS_BMAP_TRACE_INSERT(d,ip,i,c,r1,r2,w) \
+        xfs_bmap_trace_insert(__FUNCTION__,d,ip,i,c,r1,r2,w)
+#define XFS_BMAP_TRACE_POST_UPDATE(d,ip,i,w)    \
+        xfs_bmap_trace_post_update(__FUNCTION__,d,ip,i,w)
+#define XFS_BMAP_TRACE_PRE_UPDATE(d,ip,i,w)     \
+        xfs_bmap_trace_pre_update(__FUNCTION__,d,ip,i,w)
 #else
-#define xfs_bmap_trace_delete(f,d,ip,i,c,w)
-#define xfs_bmap_trace_insert(f,d,ip,i,c,r1,r2,w)
-#define xfs_bmap_trace_post_update(f,d,ip,i,w)
-#define xfs_bmap_trace_pre_update(f,d,ip,i,w)
+#define XFS_BMAP_TRACE_DELETE(d,ip,i,c,w)
+#define XFS_BMAP_TRACE_INSERT(d,ip,i,c,r1,r2,w)
+#define XFS_BMAP_TRACE_POST_UPDATE(d,ip,i,w)
+#define XFS_BMAP_TRACE_PRE_UPDATE(d,ip,i,w)
 #endif  /* XFS_BMAP_TRACE */
 
 /*
@@ -531,9 +540,6 @@ xfs_bmap_add_extent(
         xfs_filblks_t           da_new; /* new count del alloc blocks used */
         xfs_filblks_t           da_old; /* old count del alloc blocks used */
         int                     error;  /* error return value */
-#ifdef XFS_BMAP_TRACE
-        static char             fname[] = "xfs_bmap_add_extent";
-#endif
         xfs_ifork_t             *ifp;   /* inode fork ptr */
         int                     logflags; /* returned value */
         xfs_extnum_t            nextents; /* number of extents in file now */
@@ -551,8 +557,8 @@ xfs_bmap_add_extent(
          * already extents in the list.
          */
         if (nextents == 0) {
-                xfs_bmap_trace_insert(fname, "insert empty", ip, 0, 1, new,
-                        NULL, whichfork);
+                XFS_BMAP_TRACE_INSERT("insert empty", ip, 0, 1, new, NULL,
+                        whichfork);
                 xfs_iext_insert(ifp, 0, 1, new);
                 ASSERT(cur == NULL);
                 ifp->if_lastex = 0;
@@ -710,9 +716,6 @@ xfs_bmap_add_extent_delay_real(
         int                     diff;   /* temp value */
         xfs_bmbt_rec_t          *ep;    /* extent entry for idx */
         int                     error;  /* error return value */
-#ifdef XFS_BMAP_TRACE
-        static char             fname[] = "xfs_bmap_add_extent_delay_real";
-#endif
         int                     i;      /* temp state */
         xfs_ifork_t             *ifp;   /* inode fork pointer */
         xfs_fileoff_t           new_endoff;     /* end offset of new entry */
@@ -808,15 +811,14 @@ xfs_bmap_add_extent_delay_real(
                  * Filling in all of a previously delayed allocation extent.
                  * The left and right neighbors are both contiguous with new.
                  */
-                xfs_bmap_trace_pre_update(fname, "LF|RF|LC|RC", ip, idx - 1,
+                XFS_BMAP_TRACE_PRE_UPDATE("LF|RF|LC|RC", ip, idx - 1,
                         XFS_DATA_FORK);
                 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, idx - 1),
                         LEFT.br_blockcount + PREV.br_blockcount +
                         RIGHT.br_blockcount);
-                xfs_bmap_trace_post_update(fname, "LF|RF|LC|RC", ip, idx - 1,
-                        XFS_DATA_FORK);
-                xfs_bmap_trace_delete(fname, "LF|RF|LC|RC", ip, idx, 2,
+                XFS_BMAP_TRACE_POST_UPDATE("LF|RF|LC|RC", ip, idx - 1,
                         XFS_DATA_FORK);
+                XFS_BMAP_TRACE_DELETE("LF|RF|LC|RC", ip, idx, 2, XFS_DATA_FORK);
                 xfs_iext_remove(ifp, idx, 2);
                 ip->i_df.if_lastex = idx - 1;
                 ip->i_d.di_nextents--;
@@ -855,15 +857,14 @@ xfs_bmap_add_extent_delay_real(
                  * Filling in all of a previously delayed allocation extent.
                  * The left neighbor is contiguous, the right is not.
                  */
-                xfs_bmap_trace_pre_update(fname, "LF|RF|LC", ip, idx - 1,
+                XFS_BMAP_TRACE_PRE_UPDATE("LF|RF|LC", ip, idx - 1,
                         XFS_DATA_FORK);
                 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, idx - 1),
                         LEFT.br_blockcount + PREV.br_blockcount);
-                xfs_bmap_trace_post_update(fname, "LF|RF|LC", ip, idx - 1,
+                XFS_BMAP_TRACE_POST_UPDATE("LF|RF|LC", ip, idx - 1,
                         XFS_DATA_FORK);
                 ip->i_df.if_lastex = idx - 1;
-                xfs_bmap_trace_delete(fname, "LF|RF|LC", ip, idx, 1,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_DELETE("LF|RF|LC", ip, idx, 1, XFS_DATA_FORK);
                 xfs_iext_remove(ifp, idx, 1);
                 if (cur == NULL)
                         rval = XFS_ILOG_DEXT;
@@ -892,16 +893,13 @@ xfs_bmap_add_extent_delay_real(
                  * Filling in all of a previously delayed allocation extent.
                  * The right neighbor is contiguous, the left is not.
                  */
-                xfs_bmap_trace_pre_update(fname, "LF|RF|RC", ip, idx,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_PRE_UPDATE("LF|RF|RC", ip, idx, XFS_DATA_FORK);
                 xfs_bmbt_set_startblock(ep, new->br_startblock);
                 xfs_bmbt_set_blockcount(ep,
                         PREV.br_blockcount + RIGHT.br_blockcount);
-                xfs_bmap_trace_post_update(fname, "LF|RF|RC", ip, idx,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_POST_UPDATE("LF|RF|RC", ip, idx, XFS_DATA_FORK);
                 ip->i_df.if_lastex = idx;
-                xfs_bmap_trace_delete(fname, "LF|RF|RC", ip, idx + 1, 1,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_DELETE("LF|RF|RC", ip, idx + 1, 1, XFS_DATA_FORK);
                 xfs_iext_remove(ifp, idx + 1, 1);
                 if (cur == NULL)
                         rval = XFS_ILOG_DEXT;
@@ -931,11 +929,9 @@ xfs_bmap_add_extent_delay_real(
                  * Neither the left nor right neighbors are contiguous with
                  * the new one.
                  */
-                xfs_bmap_trace_pre_update(fname, "LF|RF", ip, idx,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_PRE_UPDATE("LF|RF", ip, idx, XFS_DATA_FORK);
                 xfs_bmbt_set_startblock(ep, new->br_startblock);
-                xfs_bmap_trace_post_update(fname, "LF|RF", ip, idx,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_POST_UPDATE("LF|RF", ip, idx, XFS_DATA_FORK);
                 ip->i_df.if_lastex = idx;
                 ip->i_d.di_nextents++;
                 if (cur == NULL)
@@ -963,17 +959,14 @@ xfs_bmap_add_extent_delay_real(
                  * Filling in the first part of a previous delayed allocation.
                  * The left neighbor is contiguous.
                  */
-                xfs_bmap_trace_pre_update(fname, "LF|LC", ip, idx - 1,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_PRE_UPDATE("LF|LC", ip, idx - 1, XFS_DATA_FORK);
                 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, idx - 1),
                         LEFT.br_blockcount + new->br_blockcount);
                 xfs_bmbt_set_startoff(ep,
                         PREV.br_startoff + new->br_blockcount);
-                xfs_bmap_trace_post_update(fname, "LF|LC", ip, idx - 1,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_POST_UPDATE("LF|LC", ip, idx - 1, XFS_DATA_FORK);
                 temp = PREV.br_blockcount - new->br_blockcount;
-                xfs_bmap_trace_pre_update(fname, "LF|LC", ip, idx,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_PRE_UPDATE("LF|LC", ip, idx, XFS_DATA_FORK);
                 xfs_bmbt_set_blockcount(ep, temp);
                 ip->i_df.if_lastex = idx - 1;
                 if (cur == NULL)
@@ -995,8 +988,7 @@ xfs_bmap_add_extent_delay_real(
                 temp = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp),
                         STARTBLOCKVAL(PREV.br_startblock));
                 xfs_bmbt_set_startblock(ep, NULLSTARTBLOCK((int)temp));
-                xfs_bmap_trace_post_update(fname, "LF|LC", ip, idx,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_POST_UPDATE("LF|LC", ip, idx, XFS_DATA_FORK);
                 *dnew = temp;
                 /* DELTA: The boundary between two in-core extents moved. */
                 temp = LEFT.br_startoff;
@@ -1009,11 +1001,11 @@ xfs_bmap_add_extent_delay_real(
                  * Filling in the first part of a previous delayed allocation.
                  * The left neighbor is not contiguous.
                  */
-                xfs_bmap_trace_pre_update(fname, "LF", ip, idx, XFS_DATA_FORK);
+                XFS_BMAP_TRACE_PRE_UPDATE("LF", ip, idx, XFS_DATA_FORK);
                 xfs_bmbt_set_startoff(ep, new_endoff);
                 temp = PREV.br_blockcount - new->br_blockcount;
                 xfs_bmbt_set_blockcount(ep, temp);
-                xfs_bmap_trace_insert(fname, "LF", ip, idx, 1, new, NULL,
+                XFS_BMAP_TRACE_INSERT("LF", ip, idx, 1, new, NULL,
                         XFS_DATA_FORK);
                 xfs_iext_insert(ifp, idx, 1, new);
                 ip->i_df.if_lastex = idx;
@@ -1046,8 +1038,7 @@ xfs_bmap_add_extent_delay_real(
                         (cur ? cur->bc_private.b.allocated : 0));
                 ep = xfs_iext_get_ext(ifp, idx + 1);
                 xfs_bmbt_set_startblock(ep, NULLSTARTBLOCK((int)temp));
-                xfs_bmap_trace_post_update(fname, "LF", ip, idx + 1,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_POST_UPDATE("LF", ip, idx + 1, XFS_DATA_FORK);
                 *dnew = temp;
                 /* DELTA: One in-core extent is split in two. */
                 temp = PREV.br_startoff;
@@ -1060,17 +1051,14 @@ xfs_bmap_add_extent_delay_real(
                  * The right neighbor is contiguous with the new allocation.
                  */
                 temp = PREV.br_blockcount - new->br_blockcount;
-                xfs_bmap_trace_pre_update(fname, "RF|RC", ip, idx,
-                        XFS_DATA_FORK);
-                xfs_bmap_trace_pre_update(fname, "RF|RC", ip, idx + 1,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_PRE_UPDATE("RF|RC", ip, idx, XFS_DATA_FORK);
+                XFS_BMAP_TRACE_PRE_UPDATE("RF|RC", ip, idx + 1, XFS_DATA_FORK);
                 xfs_bmbt_set_blockcount(ep, temp);
                 xfs_bmbt_set_allf(xfs_iext_get_ext(ifp, idx + 1),
                         new->br_startoff, new->br_startblock,
                         new->br_blockcount + RIGHT.br_blockcount,
                         RIGHT.br_state);
-                xfs_bmap_trace_post_update(fname, "RF|RC", ip, idx + 1,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_POST_UPDATE("RF|RC", ip, idx + 1, XFS_DATA_FORK);
                 ip->i_df.if_lastex = idx + 1;
                 if (cur == NULL)
                         rval = XFS_ILOG_DEXT;
@@ -1091,8 +1079,7 @@ xfs_bmap_add_extent_delay_real(
                 temp = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp),
                         STARTBLOCKVAL(PREV.br_startblock));
                 xfs_bmbt_set_startblock(ep, NULLSTARTBLOCK((int)temp));
-                xfs_bmap_trace_post_update(fname, "RF|RC", ip, idx,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_POST_UPDATE("RF|RC", ip, idx, XFS_DATA_FORK);
                 *dnew = temp;
                 /* DELTA: The boundary between two in-core extents moved. */
                 temp = PREV.br_startoff;
@@ -1106,10 +1093,10 @@ xfs_bmap_add_extent_delay_real(
                  * The right neighbor is not contiguous.
                  */
                 temp = PREV.br_blockcount - new->br_blockcount;
-                xfs_bmap_trace_pre_update(fname, "RF", ip, idx, XFS_DATA_FORK);
+                XFS_BMAP_TRACE_PRE_UPDATE("RF", ip, idx, XFS_DATA_FORK);
                 xfs_bmbt_set_blockcount(ep, temp);
-                xfs_bmap_trace_insert(fname, "RF", ip, idx + 1, 1,
-                        new, NULL, XFS_DATA_FORK);
+                XFS_BMAP_TRACE_INSERT("RF", ip, idx + 1, 1, new, NULL,
+                        XFS_DATA_FORK);
                 xfs_iext_insert(ifp, idx + 1, 1, new);
                 ip->i_df.if_lastex = idx + 1;
                 ip->i_d.di_nextents++;
@@ -1141,7 +1128,7 @@ xfs_bmap_add_extent_delay_real(
                         (cur ? cur->bc_private.b.allocated : 0));
                 ep = xfs_iext_get_ext(ifp, idx);
                 xfs_bmbt_set_startblock(ep, NULLSTARTBLOCK((int)temp));
-                xfs_bmap_trace_post_update(fname, "RF", ip, idx, XFS_DATA_FORK);
+                XFS_BMAP_TRACE_POST_UPDATE("RF", ip, idx, XFS_DATA_FORK);
                 *dnew = temp;
                 /* DELTA: One in-core extent is split in two. */
                 temp = PREV.br_startoff;
@@ -1155,7 +1142,7 @@ xfs_bmap_add_extent_delay_real(
                  * This case is avoided almost all the time.
                  */
                 temp = new->br_startoff - PREV.br_startoff;
-                xfs_bmap_trace_pre_update(fname, "0", ip, idx, XFS_DATA_FORK);
+                XFS_BMAP_TRACE_PRE_UPDATE("0", ip, idx, XFS_DATA_FORK);
                 xfs_bmbt_set_blockcount(ep, temp);
                 r[0] = *new;
                 r[1].br_state = PREV.br_state;
@@ -1163,7 +1150,7 @@ xfs_bmap_add_extent_delay_real(
                 r[1].br_startoff = new_endoff;
                 temp2 = PREV.br_startoff + PREV.br_blockcount - new_endoff;
                 r[1].br_blockcount = temp2;
-                xfs_bmap_trace_insert(fname, "0", ip, idx + 1, 2, &r[0], &r[1],
+                XFS_BMAP_TRACE_INSERT("0", ip, idx + 1, 2, &r[0], &r[1],
                         XFS_DATA_FORK);
                 xfs_iext_insert(ifp, idx + 1, 2, &r[0]);
                 ip->i_df.if_lastex = idx + 1;
@@ -1222,13 +1209,11 @@ xfs_bmap_add_extent_delay_real(
                 }
                 ep = xfs_iext_get_ext(ifp, idx);
                 xfs_bmbt_set_startblock(ep, NULLSTARTBLOCK((int)temp));
-                xfs_bmap_trace_post_update(fname, "0", ip, idx, XFS_DATA_FORK);
-                xfs_bmap_trace_pre_update(fname, "0", ip, idx + 2,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_POST_UPDATE("0", ip, idx, XFS_DATA_FORK);
+                XFS_BMAP_TRACE_PRE_UPDATE("0", ip, idx + 2, XFS_DATA_FORK);
                 xfs_bmbt_set_startblock(xfs_iext_get_ext(ifp, idx + 2),
                         NULLSTARTBLOCK((int)temp2));
-                xfs_bmap_trace_post_update(fname, "0", ip, idx + 2,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_POST_UPDATE("0", ip, idx + 2, XFS_DATA_FORK);
                 *dnew = temp + temp2;
                 /* DELTA: One in-core extent is split in three. */
                 temp = PREV.br_startoff;
@@ -1287,9 +1272,6 @@ xfs_bmap_add_extent_unwritten_real(
         xfs_btree_cur_t         *cur;   /* btree cursor */
         xfs_bmbt_rec_t          *ep;    /* extent entry for idx */
         int                     error;  /* error return value */
-#ifdef XFS_BMAP_TRACE
-        static char             fname[] = "xfs_bmap_add_extent_unwritten_real";
-#endif
         int                     i;      /* temp state */
         xfs_ifork_t             *ifp;   /* inode fork pointer */
         xfs_fileoff_t           new_endoff;     /* end offset of new entry */
@@ -1390,15 +1372,14 @@ xfs_bmap_add_extent_unwritten_real(
                  * Setting all of a previous oldext extent to newext.
                  * The left and right neighbors are both contiguous with new.
                  */
-                xfs_bmap_trace_pre_update(fname, "LF|RF|LC|RC", ip, idx - 1,
+                XFS_BMAP_TRACE_PRE_UPDATE("LF|RF|LC|RC", ip, idx - 1,
                         XFS_DATA_FORK);
                 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, idx - 1),
                         LEFT.br_blockcount + PREV.br_blockcount +
                         RIGHT.br_blockcount);
-                xfs_bmap_trace_post_update(fname, "LF|RF|LC|RC", ip, idx - 1,
-                        XFS_DATA_FORK);
-                xfs_bmap_trace_delete(fname, "LF|RF|LC|RC", ip, idx, 2,
+                XFS_BMAP_TRACE_POST_UPDATE("LF|RF|LC|RC", ip, idx - 1,
                         XFS_DATA_FORK);
+                XFS_BMAP_TRACE_DELETE("LF|RF|LC|RC", ip, idx, 2, XFS_DATA_FORK);
                 xfs_iext_remove(ifp, idx, 2);
                 ip->i_df.if_lastex = idx - 1;
                 ip->i_d.di_nextents -= 2;
@@ -1441,15 +1422,14 @@ xfs_bmap_add_extent_unwritten_real(
                  * Setting all of a previous oldext extent to newext.
                  * The left neighbor is contiguous, the right is not.
                  */
-                xfs_bmap_trace_pre_update(fname, "LF|RF|LC", ip, idx - 1,
+                XFS_BMAP_TRACE_PRE_UPDATE("LF|RF|LC", ip, idx - 1,
                         XFS_DATA_FORK);
                 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, idx - 1),
                         LEFT.br_blockcount + PREV.br_blockcount);
-                xfs_bmap_trace_post_update(fname, "LF|RF|LC", ip, idx - 1,
+                XFS_BMAP_TRACE_POST_UPDATE("LF|RF|LC", ip, idx - 1,
                         XFS_DATA_FORK);
                 ip->i_df.if_lastex = idx - 1;
-                xfs_bmap_trace_delete(fname, "LF|RF|LC", ip, idx, 1,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_DELETE("LF|RF|LC", ip, idx, 1, XFS_DATA_FORK);
                 xfs_iext_remove(ifp, idx, 1);
                 ip->i_d.di_nextents--;
                 if (cur == NULL)
@@ -1484,16 +1464,15 @@ xfs_bmap_add_extent_unwritten_real(
                  * Setting all of a previous oldext extent to newext.
                  * The right neighbor is contiguous, the left is not.
                  */
-                xfs_bmap_trace_pre_update(fname, "LF|RF|RC", ip, idx,
+                XFS_BMAP_TRACE_PRE_UPDATE("LF|RF|RC", ip, idx,
                         XFS_DATA_FORK);
                 xfs_bmbt_set_blockcount(ep,
                         PREV.br_blockcount + RIGHT.br_blockcount);
                 xfs_bmbt_set_state(ep, newext);
-                xfs_bmap_trace_post_update(fname, "LF|RF|RC", ip, idx,
+                XFS_BMAP_TRACE_POST_UPDATE("LF|RF|RC", ip, idx,
                         XFS_DATA_FORK);
                 ip->i_df.if_lastex = idx;
-                xfs_bmap_trace_delete(fname, "LF|RF|RC", ip, idx + 1, 1,
-                        XFS_DATA_FORK);
+                XFS_BMAP_TRACE_DELETE("LF|RF|RC", ip, idx + 1, 1, XFS_DATA_FORK);
                 xfs_iext_remove(ifp, idx + 1, 1);
                 ip->i_d.di_nextents--;
                 if (cur == NULL)
@@ -1529,10 +1508,10 @@ xfs_bmap_add_extent_unwritten_real(
                  * Neither the left nor right neighbors are contiguous with
                  * the new one.
                  */
-                xfs_bmap_trace_pre_update(fname, "LF|RF", ip, idx,
+                XFS_BMAP_TRACE_PRE_UPDATE("LF|RF", ip, idx,
                         XFS_DATA_FORK);
                 xfs_bmbt_set_state(ep, newext);
-                xfs_bmap_trace_post_update(fname, "LF|RF", ip, idx,
+                XFS_BMAP_TRACE_POST_UPDATE("LF|RF", ip, idx,
                         XFS_DATA_FORK);
                 ip->i_df.if_lastex = idx;
                 if (cur == NULL)
@@ -1559,21 +1538,21 @@ xfs_bmap_add_extent_unwritten_real(
                  * Setting the first part of a previous oldext extent to newext.
                  * The left neighbor is contiguous.
                  */
-                xfs_bmap_trace_pre_update(fname, "LF|LC", ip, idx - 1,
+                XFS_BMAP_TRACE_PRE_UPDATE("LF|LC", ip, idx - 1,
                         XFS_DATA_FORK);
                 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, idx - 1),
                         LEFT.br_blockcount + new->br_blockcount);
                 xfs_bmbt_set_startoff(ep,
                         PREV.br_startoff + new->br_blockcount);
-                xfs_bmap_trace_post_update(fname, "LF|LC", ip, idx - 1,
+                XFS_BMAP_TRACE_POST_UPDATE("LF|LC", ip, idx - 1,
                         XFS_DATA_FORK);
-                xfs_bmap_trace_pre_update(fname, "LF|LC", ip, idx,
+                XFS_BMAP_TRACE_PRE_UPDATE("LF|LC", ip, idx,
                         XFS_DATA_FORK);
                 xfs_bmbt_set_startblock(ep,
                         new->br_startblock + new->br_blockcount);
                 xfs_bmbt_set_blockcount(ep,
                         PREV.br_blockcount - new->br_blockcount);
-                xfs_bmap_trace_post_update(fname, "LF|LC", ip, idx,
+                XFS_BMAP_TRACE_POST_UPDATE("LF|LC", ip, idx,
                         XFS_DATA_FORK);
                 ip->i_df.if_lastex = idx - 1;
                 if (cur == NULL)
@@ -1610,15 +1589,15 @@ xfs_bmap_add_extent_unwritten_real(
                  * Setting the first part of a previous oldext extent to newext.
                  * The left neighbor is not contiguous.
                  */
-                xfs_bmap_trace_pre_update(fname, "LF", ip, idx, XFS_DATA_FORK);
+                XFS_BMAP_TRACE_PRE_UPDATE("LF", ip, idx, XFS_DATA_FORK);
                 ASSERT(ep && xfs_bmbt_get_state(ep) == oldext);
                 xfs_bmbt_set_startoff(ep, new_endoff);
                 xfs_bmbt_set_blockcount(ep,
                         PREV.br_blockcount - new->br_blockcount);
                 xfs_bmbt_set_startblock(ep,
                         new->br_startblock + new->br_blockcount);
-                xfs_bmap_trace_post_update(fname, "LF", ip, idx, XFS_DATA_FORK);
-                xfs_bmap_trace_insert(fname, "LF", ip, idx, 1, new, NULL,
+                XFS_BMAP_TRACE_POST_UPDATE("LF", ip, idx, XFS_DATA_FORK);
+                XFS_BMAP_TRACE_INSERT("LF", ip, idx, 1, new, NULL,
                         XFS_DATA_FORK);
                 xfs_iext_insert(ifp, idx, 1, new);
                 ip->i_df.if_lastex = idx;
@@ -1653,18 +1632,18 @@ xfs_bmap_add_extent_unwritten_real(
                  * Setting the last part of a previous oldext extent to newext.
                  * The right neighbor is contiguous with the new allocation.
                  */
-                xfs_bmap_trace_pre_update(fname, "RF|RC", ip, idx,
+                XFS_BMAP_TRACE_PRE_UPDATE("RF|RC", ip, idx,
                         XFS_DATA_FORK);
-                xfs_bmap_trace_pre_update(fname, "RF|RC", ip, idx + 1,
+                XFS_BMAP_TRACE_PRE_UPDATE("RF|RC", ip, idx + 1,
                         XFS_DATA_FORK);
                 xfs_bmbt_set_blockcount(ep,
                         PREV.br_blockcount - new->br_blockcount);
-                xfs_bmap_trace_post_update(fname, "RF|RC", ip, idx,
+                XFS_BMAP_TRACE_POST_UPDATE("RF|RC", ip, idx,
                         XFS_DATA_FORK);
                 xfs_bmbt_set_allf(xfs_iext_get_ext(ifp, idx + 1),
                         new->br_startoff, new->br_startblock,
                         new->br_blockcount + RIGHT.br_blockcount, newext);
-                xfs_bmap_trace_post_update(fname, "RF|RC", ip, idx + 1,
+                XFS_BMAP_TRACE_POST_UPDATE("RF|RC", ip, idx + 1,
                         XFS_DATA_FORK);
                 ip->i_df.if_lastex = idx + 1;
                 if (cur == NULL)
@@ -1700,12 +1679,12 @@ xfs_bmap_add_extent_unwritten_real(
                  * Setting the last part of a previous oldext extent to newext.
                  * The right neighbor is not contiguous.
                  */
-                xfs_bmap_trace_pre_update(fname, "RF", ip, idx, XFS_DATA_FORK);
+                XFS_BMAP_TRACE_PRE_UPDATE("RF", ip, idx, XFS_DATA_FORK);
                 xfs_bmbt_set_blockcount(ep,
                         PREV.br_blockcount - new->br_blockcount);
-                xfs_bmap_trace_post_update(fname, "RF", ip, idx, XFS_DATA_FORK);
-                xfs_bmap_trace_insert(fname, "RF", ip, idx + 1, 1,
-                        new, NULL, XFS_DATA_FORK);
+                XFS_BMAP_TRACE_POST_UPDATE("RF", ip, idx, XFS_DATA_FORK);
+                XFS_BMAP_TRACE_INSERT("RF", ip, idx + 1, 1, new, NULL,
+                        XFS_DATA_FORK);
                 xfs_iext_insert(ifp, idx + 1, 1, new);
                 ip->i_df.if_lastex = idx + 1;
                 ip->i_d.di_nextents++;
@@ -1744,17 +1723,17 @@ xfs_bmap_add_extent_unwritten_real(
                  * newext.  Contiguity is impossible here.
                  * One extent becomes three extents.
                  */
-                xfs_bmap_trace_pre_update(fname, "0", ip, idx, XFS_DATA_FORK);
+                XFS_BMAP_TRACE_PRE_UPDATE("0", ip, idx, XFS_DATA_FORK);
                 xfs_bmbt_set_blockcount(ep,
                         new->br_startoff - PREV.br_startoff);
-                xfs_bmap_trace_post_update(fname, "0", ip, idx, XFS_DATA_FORK);
+                XFS_BMAP_TRACE_POST_UPDATE("0", ip, idx, XFS_DATA_FORK);
                 r[0] = *new;
                 r[1].br_startoff = new_endoff;
                 r[1].br_blockcount =
                         PREV.br_startoff + PREV.br_blockcount - new_endoff;
                 r[1].br_startblock = new->br_startblock + new->br_blockcount;
                 r[1].br_state = oldext;
-                xfs_bmap_trace_insert(fname, "0", ip, idx + 1, 2, &r[0], &r[1],
+                XFS_BMAP_TRACE_INSERT("0", ip, idx + 1, 2, &r[0], &r[1],
                         XFS_DATA_FORK);
                 xfs_iext_insert(ifp, idx + 1, 2, &r[0]);
                 ip->i_df.if_lastex = idx + 1;
@@ -1845,9 +1824,6 @@ xfs_bmap_add_extent_hole_delay(
         int                     rsvd)           /* OK to allocate reserved blocks */
 {
         xfs_bmbt_rec_t          *ep;    /* extent record for idx */
-#ifdef XFS_BMAP_TRACE
-        static char             fname[] = "xfs_bmap_add_extent_hole_delay";
-#endif
         xfs_ifork_t             *ifp;   /* inode fork pointer */
         xfs_bmbt_irec_t         left;   /* left neighbor extent entry */
         xfs_filblks_t           newlen=0;       /* new indirect size */
@@ -1919,7 +1895,7 @@ xfs_bmap_add_extent_hole_delay(
                  */
                 temp = left.br_blockcount + new->br_blockcount +
                         right.br_blockcount;
-                xfs_bmap_trace_pre_update(fname, "LC|RC", ip, idx - 1,
+                XFS_BMAP_TRACE_PRE_UPDATE("LC|RC", ip, idx - 1,
                         XFS_DATA_FORK);
                 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, idx - 1), temp);
                 oldlen = STARTBLOCKVAL(left.br_startblock) +
@@ -1928,10 +1904,9 @@ xfs_bmap_add_extent_hole_delay(
                 newlen = xfs_bmap_worst_indlen(ip, temp);
                 xfs_bmbt_set_startblock(xfs_iext_get_ext(ifp, idx - 1),
                         NULLSTARTBLOCK((int)newlen));
-                xfs_bmap_trace_post_update(fname, "LC|RC", ip, idx - 1,
-                        XFS_DATA_FORK);
-                xfs_bmap_trace_delete(fname, "LC|RC", ip, idx, 1,
+                XFS_BMAP_TRACE_POST_UPDATE("LC|RC", ip, idx - 1,
                         XFS_DATA_FORK);
+                XFS_BMAP_TRACE_DELETE("LC|RC", ip, idx, 1, XFS_DATA_FORK);
                 xfs_iext_remove(ifp, idx, 1);
                 ip->i_df.if_lastex = idx - 1;
                 /* DELTA: Two in-core extents were replaced by one. */
@@ -1946,7 +1921,7 @@ xfs_bmap_add_extent_hole_delay(
                  * Merge the new allocation with the left neighbor.
                  */
                 temp = left.br_blockcount + new->br_blockcount;
-                xfs_bmap_trace_pre_update(fname, "LC", ip, idx - 1,
+                XFS_BMAP_TRACE_PRE_UPDATE("LC", ip, idx - 1,
                         XFS_DATA_FORK);
                 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, idx - 1), temp);
                 oldlen = STARTBLOCKVAL(left.br_startblock) +
@@ -1954,7 +1929,7 @@ xfs_bmap_add_extent_hole_delay(
                 newlen = xfs_bmap_worst_indlen(ip, temp);
                 xfs_bmbt_set_startblock(xfs_iext_get_ext(ifp, idx - 1),
                         NULLSTARTBLOCK((int)newlen));
-                xfs_bmap_trace_post_update(fname, "LC", ip, idx - 1,
+                XFS_BMAP_TRACE_POST_UPDATE("LC", ip, idx - 1,
                         XFS_DATA_FORK);
                 ip->i_df.if_lastex = idx - 1;
                 /* DELTA: One in-core extent grew into a hole. */
@@ -1968,14 +1943,14 @@ xfs_bmap_add_extent_hole_delay(
                  * on the right.
                  * Merge the new allocation with the right neighbor.
                  */
-                xfs_bmap_trace_pre_update(fname, "RC", ip, idx, XFS_DATA_FORK);
+                XFS_BMAP_TRACE_PRE_UPDATE("RC", ip, idx, XFS_DATA_FORK);
                 temp = new->br_blockcount + right.br_blockcount;
                 oldlen = STARTBLOCKVAL(new->br_startblock) +
                         STARTBLOCKVAL(right.br_startblock);
                 newlen = xfs_bmap_worst_indlen(ip, temp);
                 xfs_bmbt_set_allf(ep, new->br_startoff,
                         NULLSTARTBLOCK((int)newlen), temp, right.br_state);
-                xfs_bmap_trace_post_update(fname, "RC", ip, idx, XFS_DATA_FORK);
+                XFS_BMAP_TRACE_POST_UPDATE("RC", ip, idx, XFS_DATA_FORK);
                 ip->i_df.if_lastex = idx;
                 /* DELTA: One in-core extent grew into a hole. */
                 temp2 = temp;
@@ -1989,7 +1964,7 @@ xfs_bmap_add_extent_hole_delay(
                  * Insert a new entry.
                  */
                 oldlen = newlen = 0;
-                xfs_bmap_trace_insert(fname, "0", ip, idx, 1, new, NULL,
+                XFS_BMAP_TRACE_INSERT("0", ip, idx, 1, new, NULL,
                         XFS_DATA_FORK);
                 xfs_iext_insert(ifp, idx, 1, new);
                 ip->i_df.if_lastex = idx;
@@ -2039,9 +2014,6 @@ xfs_bmap_add_extent_hole_real(
 {
         xfs_bmbt_rec_t          *ep;    /* pointer to extent entry ins. point */
         int                     error;  /* error return value */
-#ifdef XFS_BMAP_TRACE
-        static char             fname[] = "xfs_bmap_add_extent_hole_real";
-#endif
         int                     i;      /* temp state */
         xfs_ifork_t             *ifp;   /* inode fork pointer */
         xfs_bmbt_irec_t         left;   /* left neighbor extent entry */
@@ -2118,15 +2090,14 @@ xfs_bmap_add_extent_hole_real(
                  * left and on the right.
                  * Merge all three into a single extent record.
                  */
-                xfs_bmap_trace_pre_update(fname, "LC|RC", ip, idx - 1,
+                XFS_BMAP_TRACE_PRE_UPDATE("LC|RC", ip, idx - 1,
                         whichfork);
                 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, idx - 1),
                         left.br_blockcount + new->br_blockcount +
                         right.br_blockcount);
-                xfs_bmap_trace_post_update(fname, "LC|RC", ip, idx - 1,
+                XFS_BMAP_TRACE_POST_UPDATE("LC|RC", ip, idx - 1,
                         whichfork);
-                xfs_bmap_trace_delete(fname, "LC|RC", ip,
-                        idx, 1, whichfork);
+                XFS_BMAP_TRACE_DELETE("LC|RC", ip, idx, 1, whichfork);
                 xfs_iext_remove(ifp, idx, 1);
                 ifp->if_lastex = idx - 1;
                 XFS_IFORK_NEXT_SET(ip, whichfork,
@@ -2168,10 +2139,10 @@ xfs_bmap_add_extent_hole_real(
                  * on the left.
                  * Merge the new allocation with the left neighbor.
                  */
-                xfs_bmap_trace_pre_update(fname, "LC", ip, idx - 1, whichfork);
+                XFS_BMAP_TRACE_PRE_UPDATE("LC", ip, idx - 1, whichfork);
                 xfs_bmbt_set_blockcount(xfs_iext_get_ext(ifp, idx - 1),
                         left.br_blockcount + new->br_blockcount);
-                xfs_bmap_trace_post_update(fname, "LC", ip, idx - 1, whichfork);
+                XFS_BMAP_TRACE_POST_UPDATE("LC", ip, idx - 1, whichfork);
                 ifp->if_lastex = idx - 1;
                 if (cur == NULL) {
                         rval = XFS_ILOG_FEXT(whichfork);
@@ -2202,11 +2173,11 @@ xfs_bmap_add_extent_hole_real(
                  * on the right.
                  * Merge the new allocation with the right neighbor.
                  */
-                xfs_bmap_trace_pre_update(fname, "RC", ip, idx, whichfork);
+                XFS_BMAP_TRACE_PRE_UPDATE("RC", ip, idx, whichfork);
                 xfs_bmbt_set_allf(ep, new->br_startoff, new->br_startblock,
                         new->br_blockcount + right.br_blockcount,
                         right.br_state);
-                xfs_bmap_trace_post_update(fname, "RC", ip, idx, whichfork);
+                XFS_BMAP_TRACE_POST_UPDATE("RC", ip, idx, whichfork);
                 ifp->if_lastex = idx;
                 if (cur == NULL) {
                         rval = XFS_ILOG_FEXT(whichfork);
@@ -2237,8 +2208,7 @@ xfs_bmap_add_extent_hole_real(
                  * real allocation.
                  * Insert a new entry.
                  */
-                xfs_bmap_trace_insert(fname, "0", ip, idx, 1, new, NULL,
-                        whichfork);
+                XFS_BMAP_TRACE_INSERT("0", ip, idx, 1, new, NULL, whichfork);
                 xfs_iext_insert(ifp, idx, 1, new);
                 ifp->if_lastex = idx;
                 XFS_IFORK_NEXT_SET(ip, whichfork,
@@ -2605,12 +2575,10 @@ xfs_bmap_rtalloc(
         xfs_extlen_t    prod = 0;       /* product factor for allocators */
         xfs_extlen_t    ralen = 0;      /* realtime allocation length */
         xfs_extlen_t    align;          /* minimum allocation alignment */
-        xfs_rtblock_t   rtx;            /* realtime extent number */
         xfs_rtblock_t   rtb;
 
         mp = ap->ip->i_mount;
-        align = ap->ip->i_d.di_extsize ?
-                ap->ip->i_d.di_extsize : mp->m_sb.sb_rextsize;
+        align = xfs_get_extsz_hint(ap->ip);
         prod = align / mp->m_sb.sb_rextsize;
         error = xfs_bmap_extsize_align(mp, ap->gotp, ap->prevp,
                                         align, 1, ap->eof, 0,
@@ -2644,6 +2612,8 @@ xfs_bmap_rtalloc(
          * pick an extent that will space things out in the rt area.
          */
         if (ap->eof && ap->off == 0) {
+                xfs_rtblock_t uninitialized_var(rtx); /* realtime extent no */
+
                 error = xfs_rtpick_extent(mp, ap->tp, ralen, &rtx);
                 if (error)
                         return error;
@@ -2715,9 +2685,7 @@ xfs_bmap_btalloc(
         int             error;
 
         mp = ap->ip->i_mount;
-        align = (ap->userdata && ap->ip->i_d.di_extsize &&
-                (ap->ip->i_d.di_flags & XFS_DIFLAG_EXTSIZE)) ?
-                ap->ip->i_d.di_extsize : 0;
+        align = ap->userdata ? xfs_get_extsz_hint(ap->ip) : 0;
         if (unlikely(align)) {
                 error = xfs_bmap_extsize_align(mp, ap->gotp, ap->prevp,
                                                 align, 0, ap->eof, 0, ap->conv,
@@ -2727,9 +2695,15 @@ xfs_bmap_btalloc(
         }
         nullfb = ap->firstblock == NULLFSBLOCK;
         fb_agno = nullfb ? NULLAGNUMBER : XFS_FSB_TO_AGNO(mp, ap->firstblock);
-        if (nullfb)
-                ap->rval = XFS_INO_TO_FSB(mp, ap->ip->i_ino);
-        else
+        if (nullfb) {
+                if (ap->userdata && xfs_inode_is_filestream(ap->ip)) {
+                        ag = xfs_filestream_lookup_ag(ap->ip);
+                        ag = (ag != NULLAGNUMBER) ? ag : 0;
+                        ap->rval = XFS_AGB_TO_FSB(mp, ag, 0);
+                } else {
+                        ap->rval = XFS_INO_TO_FSB(mp, ap->ip->i_ino);
+                }
+        } else
                 ap->rval = ap->firstblock;
 
         xfs_bmap_adjacent(ap);
@@ -2753,13 +2727,22 @@ xfs_bmap_btalloc(
         args.firstblock = ap->firstblock;
         blen = 0;
         if (nullfb) {
-                args.type = XFS_ALLOCTYPE_START_BNO;
+                if (ap->userdata && xfs_inode_is_filestream(ap->ip))
+                        args.type = XFS_ALLOCTYPE_NEAR_BNO;
+                else
+                        args.type = XFS_ALLOCTYPE_START_BNO;
                 args.total = ap->total;
+
                 /*
-                 * Find the longest available space.
-                 * We're going to try for the whole allocation at once.
+                 * Search for an allocation group with a single extent
+                 * large enough for the request.
+                 *
+                 * If one isn't found, then adjust the minimum allocation
+                 * size to the largest space found.
                  */
                 startag = ag = XFS_FSB_TO_AGNO(mp, args.fsbno);
+                if (startag == NULLAGNUMBER)
+                        startag = ag = 0;
                 notinit = 0;
                 down_read(&mp->m_peraglock);
                 while (blen < ap->alen) {
@@ -2785,6 +2768,35 @@ xfs_bmap_btalloc(
                                         blen = longest;
                         } else
                                 notinit = 1;
+
+                        if (xfs_inode_is_filestream(ap->ip)) {
+                                if (blen >= ap->alen)
+                                        break;
+
+                                if (ap->userdata) {
+                                        /*
+                                         * If startag is an invalid AG, we've
+                                         * come here once before and
+                                         * xfs_filestream_new_ag picked the
+                                         * best currently available.
+                                         *
+                                         * Don't continue looping, since we
+                                         * could loop forever.
+                                         */
+                                        if (startag == NULLAGNUMBER)
+                                                break;
+
+                                        error = xfs_filestream_new_ag(ap, &ag);
+                                        if (error) {
+                                                up_read(&mp->m_peraglock);
+                                                return error;
+                                        }
+
+                                        /* loop again to set 'blen'*/
+                                        startag = NULLAGNUMBER;
+                                        continue;
+                                }
+                        }
                         if (++ag == mp->m_sb.sb_agcount)
                                 ag = 0;
                         if (ag == startag)
@@ -2809,17 +2821,27 @@ xfs_bmap_btalloc(
                  */
                 else
                         args.minlen = ap->alen;
+
+                /*
+                 * set the failure fallback case to look in the selected
+                 * AG as the stream may have moved.
+                 */
+                if (xfs_inode_is_filestream(ap->ip))
+                        ap->rval = args.fsbno = XFS_AGB_TO_FSB(mp, ag, 0);
         } else if (ap->low) {
-                args.type = XFS_ALLOCTYPE_START_BNO;
+                if (xfs_inode_is_filestream(ap->ip))
+                        args.type = XFS_ALLOCTYPE_FIRST_AG;
+                else
+                        args.type = XFS_ALLOCTYPE_START_BNO;
                 args.total = args.minlen = ap->minlen;
         } else {
                 args.type = XFS_ALLOCTYPE_NEAR_BNO;
                 args.total = ap->total;
                 args.minlen = ap->minlen;
         }
-        if (unlikely(ap->userdata && ap->ip->i_d.di_extsize &&
-                    (ap->ip->i_d.di_flags & XFS_DIFLAG_EXTSIZE))) {
-                args.prod = ap->ip->i_d.di_extsize;
+        /* apply extent size hints if obtained earlier */
+        if (unlikely(align)) {
+                args.prod = align;
                 if ((args.mod = (xfs_extlen_t)do_mod(ap->off, args.prod)))
                         args.mod = (xfs_extlen_t)(args.prod - args.mod);
         } else if (mp->m_sb.sb_blocksize >= NBPP) {
@@ -3051,9 +3073,6 @@ xfs_bmap_del_extent(
         xfs_bmbt_rec_t          *ep;    /* current extent entry pointer */
         int                     error;  /* error return value */
         int                     flags;  /* inode logging flags */
-#ifdef XFS_BMAP_TRACE
-        static char             fname[] = "xfs_bmap_del_extent";
-#endif
         xfs_bmbt_irec_t         got;    /* current extent entry */
         xfs_fileoff_t           got_endoff;     /* first offset past got */
         int                     i;      /* temp state */
@@ -3147,7 +3166,7 @@ xfs_bmap_del_extent(
                 /*
                  * Matches the whole extent.  Delete the entry.
                  */
-                xfs_bmap_trace_delete(fname, "3", ip, idx, 1, whichfork);
+                XFS_BMAP_TRACE_DELETE("3", ip, idx, 1, whichfork);
                 xfs_iext_remove(ifp, idx, 1);
                 ifp->if_lastex = idx;
                 if (delay)
@@ -3168,7 +3187,7 @@ xfs_bmap_del_extent(
                 /*
                  * Deleting the first part of the extent.
                  */
-                xfs_bmap_trace_pre_update(fname, "2", ip, idx, whichfork);
+                XFS_BMAP_TRACE_PRE_UPDATE("2", ip, idx, whichfork);
                 xfs_bmbt_set_startoff(ep, del_endoff);
                 temp = got.br_blockcount - del->br_blockcount;
                 xfs_bmbt_set_blockcount(ep, temp);
@@ -3177,13 +3196,13 @@ xfs_bmap_del_extent(
                         temp = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp),
                                 da_old);
                         xfs_bmbt_set_startblock(ep, NULLSTARTBLOCK((int)temp));
-                        xfs_bmap_trace_post_update(fname, "2", ip, idx,
+                        XFS_BMAP_TRACE_POST_UPDATE("2", ip, idx,
                                 whichfork);
                         da_new = temp;
                         break;
                 }
                 xfs_bmbt_set_startblock(ep, del_endblock);
-                xfs_bmap_trace_post_update(fname, "2", ip, idx, whichfork);
+                XFS_BMAP_TRACE_POST_UPDATE("2", ip, idx, whichfork);
                 if (!cur) {
                         flags |= XFS_ILOG_FEXT(whichfork);
                         break;
@@ -3199,19 +3218,19 @@ xfs_bmap_del_extent(
                  * Deleting the last part of the extent.
                  */
                 temp = got.br_blockcount - del->br_blockcount;
-                xfs_bmap_trace_pre_update(fname, "1", ip, idx, whichfork);
+                XFS_BMAP_TRACE_PRE_UPDATE("1", ip, idx, whichfork);
                 xfs_bmbt_set_blockcount(ep, temp);
                 ifp->if_lastex = idx;
                 if (delay) {
                         temp = XFS_FILBLKS_MIN(xfs_bmap_worst_indlen(ip, temp),
                                 da_old);
                         xfs_bmbt_set_startblock(ep, NULLSTARTBLOCK((int)temp));
-                        xfs_bmap_trace_post_update(fname, "1", ip, idx,
+                        XFS_BMAP_TRACE_POST_UPDATE("1", ip, idx,
                                 whichfork);
                         da_new = temp;
                         break;
                 }
-                xfs_bmap_trace_post_update(fname, "1", ip, idx, whichfork);
+                XFS_BMAP_TRACE_POST_UPDATE("1", ip, idx, whichfork);
                 if (!cur) {
                         flags |= XFS_ILOG_FEXT(whichfork);
                         break;
@@ -3228,7 +3247,7 @@ xfs_bmap_del_extent(
                  * Deleting the middle of the extent.
                  */
                 temp = del->br_startoff - got.br_startoff;
-                xfs_bmap_trace_pre_update(fname, "0", ip, idx, whichfork);
+                XFS_BMAP_TRACE_PRE_UPDATE("0", ip, idx, whichfork);
                 xfs_bmbt_set_blockcount(ep, temp);
                 new.br_startoff = del_endoff;
                 temp2 = got_endoff - del_endoff;
@@ -3315,8 +3334,8 @@ xfs_bmap_del_extent(
                                 }
                         }
                 }
-                xfs_bmap_trace_post_update(fname, "0", ip, idx, whichfork);
-                xfs_bmap_trace_insert(fname, "0", ip, idx + 1, 1, &new, NULL,
+                XFS_BMAP_TRACE_POST_UPDATE("0", ip, idx, whichfork);
+                XFS_BMAP_TRACE_INSERT("0", ip, idx + 1, 1, &new, NULL,
                         whichfork);
                 xfs_iext_insert(ifp, idx + 1, 1, &new);
                 ifp->if_lastex = idx + 1;
@@ -3556,9 +3575,6 @@ xfs_bmap_local_to_extents(
 {
         int             error;          /* error return value */
         int             flags;          /* logging flags returned */
-#ifdef XFS_BMAP_TRACE
-        static char     fname[] = "xfs_bmap_local_to_extents";
-#endif
         xfs_ifork_t     *ifp;           /* inode fork pointer */
 
         /*
@@ -3613,7 +3629,7 @@ xfs_bmap_local_to_extents(
                 xfs_iext_add(ifp, 0, 1);
                 ep = xfs_iext_get_ext(ifp, 0);
                 xfs_bmbt_set_allf(ep, 0, args.fsbno, 1, XFS_EXT_NORM);
-                xfs_bmap_trace_post_update(fname, "new", ip, 0, whichfork);
+                XFS_BMAP_TRACE_POST_UPDATE("new", ip, 0, whichfork);
                 XFS_IFORK_NEXT_SET(ip, whichfork, 1);
                 ip->i_d.di_nblocks = 1;
                 XFS_TRANS_MOD_DQUOT_BYINO(args.mp, tp, ip,
@@ -3736,7 +3752,7 @@ ktrace_t	*xfs_bmap_trace_buf;
 STATIC void
 xfs_bmap_trace_addentry(
         int             opcode,         /* operation */
-        char            *fname,         /* function name */
+        const char      *fname,         /* function name */
         char            *desc,          /* operation description */
         xfs_inode_t     *ip,            /* incore inode pointer */
         xfs_extnum_t    idx,            /* index of entry(ies) */
@@ -3795,7 +3811,7 @@ xfs_bmap_trace_addentry(
  */
 STATIC void
 xfs_bmap_trace_delete(
-        char            *fname,         /* function name */
+        const char      *fname,         /* function name */
         char            *desc,          /* operation description */
         xfs_inode_t     *ip,            /* incore inode pointer */
         xfs_extnum_t    idx,            /* index of entry(entries) deleted */
@@ -3817,7 +3833,7 @@ xfs_bmap_trace_delete(
  */
 STATIC void
 xfs_bmap_trace_insert(
-        char            *fname,         /* function name */
+        const char      *fname,         /* function name */
         char            *desc,          /* operation description */
         xfs_inode_t     *ip,            /* incore inode pointer */
         xfs_extnum_t    idx,            /* index of entry(entries) inserted */
@@ -3846,7 +3862,7 @@ xfs_bmap_trace_insert(
  */
 STATIC void
 xfs_bmap_trace_post_update(
-        char            *fname,         /* function name */
+        const char      *fname,         /* function name */
         char            *desc,          /* operation description */
         xfs_inode_t     *ip,            /* incore inode pointer */
         xfs_extnum_t    idx,            /* index of entry updated */
@@ -3864,7 +3880,7 @@ xfs_bmap_trace_post_update(
  */
 STATIC void
 xfs_bmap_trace_pre_update(
-        char            *fname,         /* function name */
+        const char      *fname,         /* function name */
         char            *desc,          /* operation description */
         xfs_inode_t     *ip,            /* incore inode pointer */
         xfs_extnum_t    idx,            /* index of entry to be updated */
@@ -4481,9 +4497,6 @@ xfs_bmap_read_extents(
         xfs_buf_t               *bp;    /* buffer for "block" */
         int                     error;  /* error return value */
         xfs_exntfmt_t           exntf;  /* XFS_EXTFMT_NOSTATE, if checking */
-#ifdef XFS_BMAP_TRACE
-        static char             fname[] = "xfs_bmap_read_extents";
-#endif
         xfs_extnum_t            i, j;   /* index into the extents list */
         xfs_ifork_t             *ifp;   /* fork structure */
         int                     level;  /* btree level, for checking */
@@ -4600,7 +4613,7 @@ xfs_bmap_read_extents(
         }
         ASSERT(i == (ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t)));
         ASSERT(i == XFS_IFORK_NEXTENTS(ip, whichfork));
-        xfs_bmap_trace_exlist(fname, ip, i, whichfork);
+        XFS_BMAP_TRACE_EXLIST(ip, i, whichfork);
         return 0;
 error0:
         xfs_trans_brelse(tp, bp);
@@ -4613,7 +4626,7 @@ error0:
  */
 void
 xfs_bmap_trace_exlist(
-        char            *fname,         /* function name */
+        const char      *fname,         /* function name */
         xfs_inode_t     *ip,            /* incore inode pointer */
         xfs_extnum_t    cnt,            /* count of entries in the list */
         int             whichfork)      /* data or attr fork */
@@ -4628,7 +4641,7 @@ xfs_bmap_trace_exlist(
         for (idx = 0; idx < cnt; idx++) {
                 ep = xfs_iext_get_ext(ifp, idx);
                 xfs_bmbt_get_all(ep, &s);
-                xfs_bmap_trace_insert(fname, "exlist", ip, idx, 1, &s, NULL,
+                XFS_BMAP_TRACE_INSERT("exlist", ip, idx, 1, &s, NULL,
                         whichfork);
         }
 }
@@ -4868,12 +4881,7 @@ xfs_bmapi(
                                 xfs_extlen_t    extsz;
 
                                 /* Figure out the extent size, adjust alen */
-                                if (rt) {
-                                        if (!(extsz = ip->i_d.di_extsize))
-                                                extsz = mp->m_sb.sb_rextsize;
-                                } else {
-                                        extsz = ip->i_d.di_extsize;
-                                }
+                                extsz = xfs_get_extsz_hint(ip);
                                 if (extsz) {
                                         error = xfs_bmap_extsize_align(mp,
                                                         &got, &prev, extsz,
@@ -5219,10 +5227,10 @@ xfs_bmapi(
                  * Else go on to the next record.
                  */
                 ep = xfs_iext_get_ext(ifp, ++lastx);
-                if (lastx >= nextents) {
+                prev = got;
+                if (lastx >= nextents)
                         eof = 1;
-                        prev = got;
-                } else
+                else
                         xfs_bmbt_get_all(ep, &got);
         }
         ifp->if_lastex = lastx;
@@ -5813,8 +5821,7 @@ xfs_getbmap(
                    ip->i_d.di_format != XFS_DINODE_FMT_LOCAL)
                 return XFS_ERROR(EINVAL);
         if (whichfork == XFS_DATA_FORK) {
-                if ((ip->i_d.di_extsize && (ip->i_d.di_flags &
-                                (XFS_DIFLAG_REALTIME|XFS_DIFLAG_EXTSIZE))) ||
+                if (xfs_get_extsz_hint(ip) ||
                     ip->i_d.di_flags & (XFS_DIFLAG_PREALLOC|XFS_DIFLAG_APPEND)){
                         prealloced = 1;
                         fixlen = XFS_MAXIOFFSET(mp);
diff --git a/fs/xfs/xfs_bmap.h b/fs/xfs/xfs_bmap.h
index 4f24c7e39b3..524b1c9d524 100644
--- a/fs/xfs/xfs_bmap.h
+++ b/fs/xfs/xfs_bmap.h
@@ -144,12 +144,14 @@ extern ktrace_t	*xfs_bmap_trace_buf;
  */
 void
 xfs_bmap_trace_exlist(
-        char                    *fname,         /* function name */
+        const char              *fname,         /* function name */
         struct xfs_inode        *ip,            /* incore inode pointer */
         xfs_extnum_t            cnt,            /* count of entries in list */
         int                     whichfork);     /* data or attr fork */
+#define XFS_BMAP_TRACE_EXLIST(ip,c,w)   \
+        xfs_bmap_trace_exlist(__FUNCTION__,ip,c,w)
 #else
-#define xfs_bmap_trace_exlist(f,ip,c,w)
+#define XFS_BMAP_TRACE_EXLIST(ip,c,w)
 #endif
 
 /*
diff --git a/fs/xfs/xfs_bmap_btree.c b/fs/xfs/xfs_bmap_btree.c
index 0bf192fea3e..89b891f51cf 100644
--- a/fs/xfs/xfs_bmap_btree.c
+++ b/fs/xfs/xfs_bmap_btree.c
@@ -76,7 +76,7 @@ static char	EXIT[] = "exit";
  */
 STATIC void
 xfs_bmbt_trace_enter(
-        char            *func,
+        const char      *func,
         xfs_btree_cur_t *cur,
         char            *s,
         int             type,
@@ -117,7 +117,7 @@ xfs_bmbt_trace_enter(
  */
 STATIC void
 xfs_bmbt_trace_argbi(
-        char            *func,
+        const char      *func,
         xfs_btree_cur_t *cur,
         xfs_buf_t       *b,
         int             i,
@@ -134,7 +134,7 @@ xfs_bmbt_trace_argbi(
  */
 STATIC void
 xfs_bmbt_trace_argbii(
-        char            *func,
+        const char      *func,
         xfs_btree_cur_t *cur,
         xfs_buf_t       *b,
         int             i0,
@@ -153,7 +153,7 @@ xfs_bmbt_trace_argbii(
  */
 STATIC void
 xfs_bmbt_trace_argfffi(
-        char                    *func,
+        const char              *func,
         xfs_btree_cur_t         *cur,
         xfs_dfiloff_t           o,
         xfs_dfsbno_t            b,
@@ -172,7 +172,7 @@ xfs_bmbt_trace_argfffi(
  */
 STATIC void
 xfs_bmbt_trace_argi(
-        char            *func,
+        const char      *func,
         xfs_btree_cur_t *cur,
         int             i,
         int             line)
@@ -188,7 +188,7 @@ xfs_bmbt_trace_argi(
  */
 STATIC void
 xfs_bmbt_trace_argifk(
-        char                    *func,
+        const char              *func,
         xfs_btree_cur_t         *cur,
         int                     i,
         xfs_fsblock_t           f,
@@ -206,7 +206,7 @@ xfs_bmbt_trace_argifk(
  */
 STATIC void
 xfs_bmbt_trace_argifr(
-        char                    *func,
+        const char              *func,
         xfs_btree_cur_t         *cur,
         int                     i,
         xfs_fsblock_t           f,
@@ -235,7 +235,7 @@ xfs_bmbt_trace_argifr(
  */
 STATIC void
 xfs_bmbt_trace_argik(
-        char                    *func,
+        const char              *func,
         xfs_btree_cur_t         *cur,
         int                     i,
         xfs_bmbt_key_t          *k,
@@ -255,7 +255,7 @@ xfs_bmbt_trace_argik(
  */
 STATIC void
 xfs_bmbt_trace_cursor(
-        char            *func,
+        const char      *func,
         xfs_btree_cur_t *cur,
         char            *s,
         int             line)
@@ -274,21 +274,21 @@ xfs_bmbt_trace_cursor(
 }
 
 #define XFS_BMBT_TRACE_ARGBI(c,b,i)     \
-        xfs_bmbt_trace_argbi(fname, c, b, i, __LINE__)
+        xfs_bmbt_trace_argbi(__FUNCTION__, c, b, i, __LINE__)
 #define XFS_BMBT_TRACE_ARGBII(c,b,i,j)  \
-        xfs_bmbt_trace_argbii(fname, c, b, i, j, __LINE__)
+        xfs_bmbt_trace_argbii(__FUNCTION__, c, b, i, j, __LINE__)
 #define XFS_BMBT_TRACE_ARGFFFI(c,o,b,i,j)       \
-        xfs_bmbt_trace_argfffi(fname, c, o, b, i, j, __LINE__)
+        xfs_bmbt_trace_argfffi(__FUNCTION__, c, o, b, i, j, __LINE__)
 #define XFS_BMBT_TRACE_ARGI(c,i)        \
-        xfs_bmbt_trace_argi(fname, c, i, __LINE__)
+        xfs_bmbt_trace_argi(__FUNCTION__, c, i, __LINE__)
 #define XFS_BMBT_TRACE_ARGIFK(c,i,f,s)  \
-        xfs_bmbt_trace_argifk(fname, c, i, f, s, __LINE__)
+        xfs_bmbt_trace_argifk(__FUNCTION__, c, i, f, s, __LINE__)
 #define XFS_BMBT_TRACE_ARGIFR(c,i,f,r)  \
-        xfs_bmbt_trace_argifr(fname, c, i, f, r, __LINE__)
+        xfs_bmbt_trace_argifr(__FUNCTION__, c, i, f, r, __LINE__)
 #define XFS_BMBT_TRACE_ARGIK(c,i,k)     \
-        xfs_bmbt_trace_argik(fname, c, i, k, __LINE__)
+        xfs_bmbt_trace_argik(__FUNCTION__, c, i, k, __LINE__)
 #define XFS_BMBT_TRACE_CURSOR(c,s)      \
-        xfs_bmbt_trace_cursor(fname, c, s, __LINE__)
+        xfs_bmbt_trace_cursor(__FUNCTION__, c, s, __LINE__)
 #else
 #define XFS_BMBT_TRACE_ARGBI(c,b,i)
 #define XFS_BMBT_TRACE_ARGBII(c,b,i,j)
@@ -318,9 +318,6 @@ xfs_bmbt_delrec(
         xfs_fsblock_t           bno;            /* fs-relative block number */
         xfs_buf_t               *bp;            /* buffer for block */
         int                     error;          /* error return value */
-#ifdef XFS_BMBT_TRACE
-        static char             fname[] = "xfs_bmbt_delrec";
-#endif
         int                     i;              /* loop counter */
         int                     j;              /* temp state */
         xfs_bmbt_key_t          key;            /* bmap btree key */
@@ -694,9 +691,6 @@ xfs_bmbt_insrec(
         xfs_bmbt_block_t        *block;         /* bmap btree block */
         xfs_buf_t               *bp;            /* buffer for block */
         int                     error;          /* error return value */
-#ifdef XFS_BMBT_TRACE
-        static char             fname[] = "xfs_bmbt_insrec";
-#endif
         int                     i;              /* loop index */
         xfs_bmbt_key_t          key;            /* bmap btree key */
         xfs_bmbt_key_t          *kp=NULL;       /* pointer to bmap btree key */
@@ -881,9 +875,6 @@ xfs_bmbt_killroot(
 #ifdef DEBUG
         int                     error;
 #endif
-#ifdef XFS_BMBT_TRACE
-        static char             fname[] = "xfs_bmbt_killroot";
-#endif
         int                     i;
         xfs_bmbt_key_t          *kp;
         xfs_inode_t             *ip;
@@ -973,9 +964,6 @@ xfs_bmbt_log_keys(
         int             kfirst,
         int             klast)
 {
-#ifdef XFS_BMBT_TRACE
-        static char     fname[] = "xfs_bmbt_log_keys";
-#endif
         xfs_trans_t     *tp;
 
         XFS_BMBT_TRACE_CURSOR(cur, ENTRY);
@@ -1012,9 +1000,6 @@ xfs_bmbt_log_ptrs(
         int             pfirst,
         int             plast)
 {
-#ifdef XFS_BMBT_TRACE
-        static char     fname[] = "xfs_bmbt_log_ptrs";
-#endif
         xfs_trans_t     *tp;
 
         XFS_BMBT_TRACE_CURSOR(cur, ENTRY);
@@ -1055,9 +1040,6 @@ xfs_bmbt_lookup(
         xfs_daddr_t             d;
         xfs_sfiloff_t           diff;
         int                     error;          /* error return value */
-#ifdef XFS_BMBT_TRACE
-        static char     fname[] = "xfs_bmbt_lookup";
-#endif
         xfs_fsblock_t           fsbno=0;
         int                     high;
         int                     i;
@@ -1195,9 +1177,6 @@ xfs_bmbt_lshift(
         int                     *stat)          /* success/failure */
 {
         int                     error;          /* error return value */
-#ifdef XFS_BMBT_TRACE
-        static char             fname[] = "xfs_bmbt_lshift";
-#endif
 #ifdef DEBUG
         int                     i;              /* loop counter */
 #endif
@@ -1331,9 +1310,6 @@ xfs_bmbt_rshift(
         int                     *stat)          /* success/failure */
 {
         int                     error;          /* error return value */
-#ifdef XFS_BMBT_TRACE
-        static char             fname[] = "xfs_bmbt_rshift";
-#endif
         int                     i;              /* loop counter */
         xfs_bmbt_key_t          key;            /* bmap btree key */
         xfs_buf_t               *lbp;           /* left buffer pointer */
@@ -1492,9 +1468,6 @@ xfs_bmbt_split(
 {
         xfs_alloc_arg_t         args;           /* block allocation args */
         int                     error;          /* error return value */
-#ifdef XFS_BMBT_TRACE
-        static char             fname[] = "xfs_bmbt_split";
-#endif
         int                     i;              /* loop counter */
         xfs_fsblock_t           lbno;           /* left sibling block number */
         xfs_buf_t               *lbp;           /* left buffer pointer */
@@ -1641,9 +1614,6 @@ xfs_bmbt_updkey(
 #ifdef DEBUG
         int                     error;
 #endif
-#ifdef XFS_BMBT_TRACE
-        static char             fname[] = "xfs_bmbt_updkey";
-#endif
         xfs_bmbt_key_t          *kp;
         int                     ptr;
 
@@ -1712,9 +1682,6 @@ xfs_bmbt_decrement(
         xfs_bmbt_block_t        *block;
         xfs_buf_t               *bp;
         int                     error;          /* error return value */
-#ifdef XFS_BMBT_TRACE
-        static char             fname[] = "xfs_bmbt_decrement";
-#endif
         xfs_fsblock_t           fsbno;
         int                     lev;
         xfs_mount_t             *mp;
@@ -1785,9 +1752,6 @@ xfs_bmbt_delete(
         int             *stat)          /* success/failure */
 {
         int             error;          /* error return value */
-#ifdef XFS_BMBT_TRACE
-        static char     fname[] = "xfs_bmbt_delete";
-#endif
         int             i;
         int             level;
 
@@ -2000,9 +1964,6 @@ xfs_bmbt_increment(
         xfs_bmbt_block_t        *block;
         xfs_buf_t               *bp;
         int                     error;          /* error return value */
-#ifdef XFS_BMBT_TRACE
-        static char             fname[] = "xfs_bmbt_increment";
-#endif
         xfs_fsblock_t           fsbno;
         int                     lev;
         xfs_mount_t             *mp;
@@ -2080,9 +2041,6 @@ xfs_bmbt_insert(
         int             *stat)          /* success/failure */
 {
         int             error;          /* error return value */
-#ifdef XFS_BMBT_TRACE
-        static char     fname[] = "xfs_bmbt_insert";
-#endif
         int             i;
         int             level;
         xfs_fsblock_t   nbno;
@@ -2142,9 +2100,6 @@ xfs_bmbt_log_block(
         int                     fields)
 {
         int                     first;
-#ifdef XFS_BMBT_TRACE
-        static char             fname[] = "xfs_bmbt_log_block";
-#endif
         int                     last;
         xfs_trans_t             *tp;
         static const short      offsets[] = {
@@ -2181,9 +2136,6 @@ xfs_bmbt_log_recs(
 {
         xfs_bmbt_block_t        *block;
         int                     first;
-#ifdef XFS_BMBT_TRACE
-        static char             fname[] = "xfs_bmbt_log_recs";
-#endif
         int                     last;
         xfs_bmbt_rec_t          *rp;
         xfs_trans_t             *tp;
@@ -2245,9 +2197,6 @@ xfs_bmbt_newroot(
         xfs_bmbt_key_t          *ckp;           /* child key pointer */
         xfs_bmbt_ptr_t          *cpp;           /* child ptr pointer */
         int                     error;          /* error return code */
-#ifdef XFS_BMBT_TRACE
-        static char             fname[] = "xfs_bmbt_newroot";
-#endif
 #ifdef DEBUG
         int                     i;              /* loop counter */
 #endif
@@ -2630,9 +2579,6 @@ xfs_bmbt_update(
         xfs_bmbt_block_t        *block;
         xfs_buf_t               *bp;
         int                     error;
-#ifdef XFS_BMBT_TRACE
-        static char             fname[] = "xfs_bmbt_update";
-#endif
         xfs_bmbt_key_t          key;
         int                     ptr;
         xfs_bmbt_rec_t          *rp;
diff --git a/fs/xfs/xfs_btree.h b/fs/xfs/xfs_btree.h
index 4e27d55a1e7..6e40a0a198f 100644
--- a/fs/xfs/xfs_btree.h
+++ b/fs/xfs/xfs_btree.h
@@ -444,30 +444,14 @@ xfs_btree_setbuf(
 /*
  * Min and max functions for extlen, agblock, fileoff, and filblks types.
  */
-#define XFS_EXTLEN_MIN(a,b)     \
-        ((xfs_extlen_t)(a) < (xfs_extlen_t)(b) ? \
-                (xfs_extlen_t)(a) : (xfs_extlen_t)(b))
-#define XFS_EXTLEN_MAX(a,b)     \
-        ((xfs_extlen_t)(a) > (xfs_extlen_t)(b) ? \
-                (xfs_extlen_t)(a) : (xfs_extlen_t)(b))
-#define XFS_AGBLOCK_MIN(a,b)    \
-        ((xfs_agblock_t)(a) < (xfs_agblock_t)(b) ? \
-                (xfs_agblock_t)(a) : (xfs_agblock_t)(b))
-#define XFS_AGBLOCK_MAX(a,b)    \
-        ((xfs_agblock_t)(a) > (xfs_agblock_t)(b) ? \
-                (xfs_agblock_t)(a) : (xfs_agblock_t)(b))
-#define XFS_FILEOFF_MIN(a,b)    \
-        ((xfs_fileoff_t)(a) < (xfs_fileoff_t)(b) ? \
-                (xfs_fileoff_t)(a) : (xfs_fileoff_t)(b))
-#define XFS_FILEOFF_MAX(a,b)    \
-        ((xfs_fileoff_t)(a) > (xfs_fileoff_t)(b) ? \
-                (xfs_fileoff_t)(a) : (xfs_fileoff_t)(b))
-#define XFS_FILBLKS_MIN(a,b)    \
-        ((xfs_filblks_t)(a) < (xfs_filblks_t)(b) ? \
-                (xfs_filblks_t)(a) : (xfs_filblks_t)(b))
-#define XFS_FILBLKS_MAX(a,b)    \
-        ((xfs_filblks_t)(a) > (xfs_filblks_t)(b) ? \
-                (xfs_filblks_t)(a) : (xfs_filblks_t)(b))
+#define XFS_EXTLEN_MIN(a,b)     min_t(xfs_extlen_t, (a), (b))
+#define XFS_EXTLEN_MAX(a,b)     max_t(xfs_extlen_t, (a), (b))
+#define XFS_AGBLOCK_MIN(a,b)    min_t(xfs_agblock_t, (a), (b))
+#define XFS_AGBLOCK_MAX(a,b)    max_t(xfs_agblock_t, (a), (b))
+#define XFS_FILEOFF_MIN(a,b)    min_t(xfs_fileoff_t, (a), (b))
+#define XFS_FILEOFF_MAX(a,b)    max_t(xfs_fileoff_t, (a), (b))
+#define XFS_FILBLKS_MIN(a,b)    min_t(xfs_filblks_t, (a), (b))
+#define XFS_FILBLKS_MAX(a,b)    max_t(xfs_filblks_t, (a), (b))
 
 #define XFS_FSB_SANITY_CHECK(mp,fsb)    \
         (XFS_FSB_TO_AGNO(mp, fsb) < mp->m_sb.sb_agcount && \
diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c
index 6c1bddc04e3..b0667cb27d6 100644
--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -580,8 +580,8 @@ xfs_buf_item_unlock(
          * If the buf item isn't tracking any data, free it.
          * Otherwise, if XFS_BLI_HOLD is set clear it.
          */
-        if (xfs_count_bits(bip->bli_format.blf_data_map,
-                              bip->bli_format.blf_map_size, 0) == 0) {
+        if (xfs_bitmap_empty(bip->bli_format.blf_data_map,
+                             bip->bli_format.blf_map_size)) {
                 xfs_buf_item_relse(bp);
         } else if (hold) {
                 bip->bli_flags &= ~XFS_BLI_HOLD;
diff --git a/fs/xfs/xfs_clnt.h b/fs/xfs/xfs_clnt.h
index 5b7eb81453b..f89196cb08d 100644
--- a/fs/xfs/xfs_clnt.h
+++ b/fs/xfs/xfs_clnt.h
@@ -99,5 +99,7 @@ struct xfs_mount_args {
  */
 #define XFSMNT2_COMPAT_IOSIZE   0x00000001      /* don't report large preferred
                                                  * I/O size in stat(2) */
+#define XFSMNT2_FILESTREAMS     0x00000002      /* enable the filestreams
+                                                 * allocator */
 
 #endif  /* __XFS_CLNT_H__ */
diff --git a/fs/xfs/xfs_dinode.h b/fs/xfs/xfs_dinode.h
index b33826961c4..fefd0116bac 100644
--- a/fs/xfs/xfs_dinode.h
+++ b/fs/xfs/xfs_dinode.h
@@ -257,6 +257,7 @@ typedef enum xfs_dinode_fmt
 #define XFS_DIFLAG_EXTSIZE_BIT      11  /* inode extent size allocator hint */
 #define XFS_DIFLAG_EXTSZINHERIT_BIT 12  /* inherit inode extent size */
 #define XFS_DIFLAG_NODEFRAG_BIT     13  /* do not reorganize/defragment */
+#define XFS_DIFLAG_FILESTREAM_BIT   14  /* use filestream allocator */
 #define XFS_DIFLAG_REALTIME      (1 << XFS_DIFLAG_REALTIME_BIT)
 #define XFS_DIFLAG_PREALLOC      (1 << XFS_DIFLAG_PREALLOC_BIT)
 #define XFS_DIFLAG_NEWRTBM       (1 << XFS_DIFLAG_NEWRTBM_BIT)
@@ -271,12 +272,13 @@ typedef enum xfs_dinode_fmt
 #define XFS_DIFLAG_EXTSIZE       (1 << XFS_DIFLAG_EXTSIZE_BIT)
 #define XFS_DIFLAG_EXTSZINHERIT  (1 << XFS_DIFLAG_EXTSZINHERIT_BIT)
 #define XFS_DIFLAG_NODEFRAG      (1 << XFS_DIFLAG_NODEFRAG_BIT)
+#define XFS_DIFLAG_FILESTREAM    (1 << XFS_DIFLAG_FILESTREAM_BIT)
 
 #define XFS_DIFLAG_ANY \
         (XFS_DIFLAG_REALTIME | XFS_DIFLAG_PREALLOC | XFS_DIFLAG_NEWRTBM | \
          XFS_DIFLAG_IMMUTABLE | XFS_DIFLAG_APPEND | XFS_DIFLAG_SYNC | \
          XFS_DIFLAG_NOATIME | XFS_DIFLAG_NODUMP | XFS_DIFLAG_RTINHERIT | \
          XFS_DIFLAG_PROJINHERIT | XFS_DIFLAG_NOSYMLINKS | XFS_DIFLAG_EXTSIZE | \
-         XFS_DIFLAG_EXTSZINHERIT | XFS_DIFLAG_NODEFRAG)
+         XFS_DIFLAG_EXTSZINHERIT | XFS_DIFLAG_NODEFRAG | XFS_DIFLAG_FILESTREAM)
 
 #endif  /* __XFS_DINODE_H__ */
diff --git a/fs/xfs/xfs_dir2.c b/fs/xfs/xfs_dir2.c
index 8e8e5279334..29e091914df 100644
--- a/fs/xfs/xfs_dir2.c
+++ b/fs/xfs/xfs_dir2.c
@@ -55,9 +55,9 @@ xfs_dir_mount(
                XFS_MAX_BLOCKSIZE);
         mp->m_dirblksize = 1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog);
         mp->m_dirblkfsbs = 1 << mp->m_sb.sb_dirblklog;
-        mp->m_dirdatablk = XFS_DIR2_DB_TO_DA(mp, XFS_DIR2_DATA_FIRSTDB(mp));
-        mp->m_dirleafblk = XFS_DIR2_DB_TO_DA(mp, XFS_DIR2_LEAF_FIRSTDB(mp));
-        mp->m_dirfreeblk = XFS_DIR2_DB_TO_DA(mp, XFS_DIR2_FREE_FIRSTDB(mp));
+        mp->m_dirdatablk = xfs_dir2_db_to_da(mp, XFS_DIR2_DATA_FIRSTDB(mp));
+        mp->m_dirleafblk = xfs_dir2_db_to_da(mp, XFS_DIR2_LEAF_FIRSTDB(mp));
+        mp->m_dirfreeblk = xfs_dir2_db_to_da(mp, XFS_DIR2_FREE_FIRSTDB(mp));
         mp->m_attr_node_ents =
                 (mp->m_sb.sb_blocksize - (uint)sizeof(xfs_da_node_hdr_t)) /
                 (uint)sizeof(xfs_da_node_entry_t);
@@ -554,7 +554,7 @@ xfs_dir2_grow_inode(
          */
         if (mapp != &map)
                 kmem_free(mapp, sizeof(*mapp) * count);
-        *dbp = XFS_DIR2_DA_TO_DB(mp, (xfs_dablk_t)bno);
+        *dbp = xfs_dir2_da_to_db(mp, (xfs_dablk_t)bno);
         /*
          * Update file's size if this is the data space and it grew.
          */
@@ -706,7 +706,7 @@ xfs_dir2_shrink_inode(
         dp = args->dp;
         mp = dp->i_mount;
         tp = args->trans;
-        da = XFS_DIR2_DB_TO_DA(mp, db);
+        da = xfs_dir2_db_to_da(mp, db);
         /*
          * Unmap the fsblock(s).
          */
@@ -742,7 +742,7 @@ xfs_dir2_shrink_inode(
         /*
          * If the block isn't the last one in the directory, we're done.
          */
-        if (dp->i_d.di_size > XFS_DIR2_DB_OFF_TO_BYTE(mp, db + 1, 0))
+        if (dp->i_d.di_size > xfs_dir2_db_off_to_byte(mp, db + 1, 0))
                 return 0;
         bno = da;
         if ((error = xfs_bmap_last_before(tp, dp, &bno, XFS_DATA_FORK))) {
diff --git a/fs/xfs/xfs_dir2_block.c b/fs/xfs/xfs_dir2_block.c
index 3accc1dcd6c..e4df1aaae2a 100644
--- a/fs/xfs/xfs_dir2_block.c
+++ b/fs/xfs/xfs_dir2_block.c
@@ -115,13 +115,13 @@ xfs_dir2_block_addname(
                 xfs_da_brelse(tp, bp);
                 return XFS_ERROR(EFSCORRUPTED);
         }
-        len = XFS_DIR2_DATA_ENTSIZE(args->namelen);
+        len = xfs_dir2_data_entsize(args->namelen);
         /*
          * Set up pointers to parts of the block.
          */
         bf = block->hdr.bestfree;
-        btp = XFS_DIR2_BLOCK_TAIL_P(mp, block);
-        blp = XFS_DIR2_BLOCK_LEAF_P(btp);
+        btp = xfs_dir2_block_tail_p(mp, block);
+        blp = xfs_dir2_block_leaf_p(btp);
         /*
          * No stale entries?  Need space for entry and new leaf.
          */
@@ -396,7 +396,7 @@ xfs_dir2_block_addname(
          * Fill in the leaf entry.
          */
         blp[mid].hashval = cpu_to_be32(args->hashval);
-        blp[mid].address = cpu_to_be32(XFS_DIR2_BYTE_TO_DATAPTR(mp,
+        blp[mid].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(mp,
                                 (char *)dep - (char *)block));
         xfs_dir2_block_log_leaf(tp, bp, lfloglow, lfloghigh);
         /*
@@ -411,7 +411,7 @@ xfs_dir2_block_addname(
         dep->inumber = cpu_to_be64(args->inumber);
         dep->namelen = args->namelen;
         memcpy(dep->name, args->name, args->namelen);
-        tagp = XFS_DIR2_DATA_ENTRY_TAG_P(dep);
+        tagp = xfs_dir2_data_entry_tag_p(dep);
         *tagp = cpu_to_be16((char *)dep - (char *)block);
         /*
          * Clean up the bestfree array and log the header, tail, and entry.
@@ -455,7 +455,7 @@ xfs_dir2_block_getdents(
         /*
          * If the block number in the offset is out of range, we're done.
          */
-        if (XFS_DIR2_DATAPTR_TO_DB(mp, uio->uio_offset) > mp->m_dirdatablk) {
+        if (xfs_dir2_dataptr_to_db(mp, uio->uio_offset) > mp->m_dirdatablk) {
                 *eofp = 1;
                 return 0;
         }
@@ -471,15 +471,15 @@ xfs_dir2_block_getdents(
          * Extract the byte offset we start at from the seek pointer.
          * We'll skip entries before this.
          */
-        wantoff = XFS_DIR2_DATAPTR_TO_OFF(mp, uio->uio_offset);
+        wantoff = xfs_dir2_dataptr_to_off(mp, uio->uio_offset);
         block = bp->data;
         xfs_dir2_data_check(dp, bp);
         /*
          * Set up values for the loop.
          */
-        btp = XFS_DIR2_BLOCK_TAIL_P(mp, block);
+        btp = xfs_dir2_block_tail_p(mp, block);
         ptr = (char *)block->u;
-        endptr = (char *)XFS_DIR2_BLOCK_LEAF_P(btp);
+        endptr = (char *)xfs_dir2_block_leaf_p(btp);
         p.dbp = dbp;
         p.put = put;
         p.uio = uio;
@@ -502,7 +502,7 @@ xfs_dir2_block_getdents(
                 /*
                  * Bump pointer for the next iteration.
                  */
-                ptr += XFS_DIR2_DATA_ENTSIZE(dep->namelen);
+                ptr += xfs_dir2_data_entsize(dep->namelen);
                 /*
                  * The entry is before the desired starting point, skip it.
                  */
@@ -513,7 +513,7 @@ xfs_dir2_block_getdents(
                  */
                 p.namelen = dep->namelen;
 
-                p.cook = XFS_DIR2_DB_OFF_TO_DATAPTR(mp, mp->m_dirdatablk,
+                p.cook = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
                                                     ptr - (char *)block);
                 p.ino = be64_to_cpu(dep->inumber);
 #if XFS_BIG_INUMS
@@ -531,7 +531,7 @@ xfs_dir2_block_getdents(
                  */
                 if (!p.done) {
                         uio->uio_offset =
-                                XFS_DIR2_DB_OFF_TO_DATAPTR(mp, mp->m_dirdatablk,
+                                xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
                                         (char *)dep - (char *)block);
                         xfs_da_brelse(tp, bp);
                         return error;
@@ -545,7 +545,7 @@ xfs_dir2_block_getdents(
         *eofp = 1;
 
         uio->uio_offset =
-                XFS_DIR2_DB_OFF_TO_DATAPTR(mp, mp->m_dirdatablk + 1, 0);
+                xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk + 1, 0);
 
         xfs_da_brelse(tp, bp);
 
@@ -569,8 +569,8 @@ xfs_dir2_block_log_leaf(
 
         mp = tp->t_mountp;
         block = bp->data;
-        btp = XFS_DIR2_BLOCK_TAIL_P(mp, block);
-        blp = XFS_DIR2_BLOCK_LEAF_P(btp);
+        btp = xfs_dir2_block_tail_p(mp, block);
+        blp = xfs_dir2_block_leaf_p(btp);
         xfs_da_log_buf(tp, bp, (uint)((char *)&blp[first] - (char *)block),
                 (uint)((char *)&blp[last + 1] - (char *)block - 1));
 }
@@ -589,7 +589,7 @@ xfs_dir2_block_log_tail(
 
         mp = tp->t_mountp;
         block = bp->data;
-        btp = XFS_DIR2_BLOCK_TAIL_P(mp, block);
+        btp = xfs_dir2_block_tail_p(mp, block);
         xfs_da_log_buf(tp, bp, (uint)((char *)btp - (char *)block),
                 (uint)((char *)(btp + 1) - (char *)block - 1));
 }
@@ -623,13 +623,13 @@ xfs_dir2_block_lookup(
         mp = dp->i_mount;
         block = bp->data;
         xfs_dir2_data_check(dp, bp);
-        btp = XFS_DIR2_BLOCK_TAIL_P(mp, block);
-        blp = XFS_DIR2_BLOCK_LEAF_P(btp);
+        btp = xfs_dir2_block_tail_p(mp, block);
+        blp = xfs_dir2_block_leaf_p(btp);
         /*
          * Get the offset from the leaf entry, to point to the data.
          */
         dep = (xfs_dir2_data_entry_t *)
-              ((char *)block + XFS_DIR2_DATAPTR_TO_OFF(mp, be32_to_cpu(blp[ent].address)));
+              ((char *)block + xfs_dir2_dataptr_to_off(mp, be32_to_cpu(blp[ent].address)));
         /*
          * Fill in inode number, release the block.
          */
@@ -675,8 +675,8 @@ xfs_dir2_block_lookup_int(
         ASSERT(bp != NULL);
         block = bp->data;
         xfs_dir2_data_check(dp, bp);
-        btp = XFS_DIR2_BLOCK_TAIL_P(mp, block);
-        blp = XFS_DIR2_BLOCK_LEAF_P(btp);
+        btp = xfs_dir2_block_tail_p(mp, block);
+        blp = xfs_dir2_block_leaf_p(btp);
         /*
          * Loop doing a binary search for our hash value.
          * Find our entry, ENOENT if it's not there.
@@ -713,7 +713,7 @@ xfs_dir2_block_lookup_int(
                  * Get pointer to the entry from the leaf.
                  */
                 dep = (xfs_dir2_data_entry_t *)
-                        ((char *)block + XFS_DIR2_DATAPTR_TO_OFF(mp, addr));
+                        ((char *)block + xfs_dir2_dataptr_to_off(mp, addr));
                 /*
                  * Compare, if it's right give back buffer & entry number.
                  */
@@ -768,20 +768,20 @@ xfs_dir2_block_removename(
         tp = args->trans;
         mp = dp->i_mount;
         block = bp->data;
-        btp = XFS_DIR2_BLOCK_TAIL_P(mp, block);
-        blp = XFS_DIR2_BLOCK_LEAF_P(btp);
+        btp = xfs_dir2_block_tail_p(mp, block);
+        blp = xfs_dir2_block_leaf_p(btp);
         /*
          * Point to the data entry using the leaf entry.
          */
         dep = (xfs_dir2_data_entry_t *)
-              ((char *)block + XFS_DIR2_DATAPTR_TO_OFF(mp, be32_to_cpu(blp[ent].address)));
+              ((char *)block + xfs_dir2_dataptr_to_off(mp, be32_to_cpu(blp[ent].address)));
         /*
          * Mark the data entry's space free.
          */
         needlog = needscan = 0;
         xfs_dir2_data_make_free(tp, bp,
                 (xfs_dir2_data_aoff_t)((char *)dep - (char *)block),
-                XFS_DIR2_DATA_ENTSIZE(dep->namelen), &needlog, &needscan);
+                xfs_dir2_data_entsize(dep->namelen), &needlog, &needscan);
         /*
          * Fix up the block tail.
          */
@@ -843,13 +843,13 @@ xfs_dir2_block_replace(
         dp = args->dp;
         mp = dp->i_mount;
         block = bp->data;
-        btp = XFS_DIR2_BLOCK_TAIL_P(mp, block);
-        blp = XFS_DIR2_BLOCK_LEAF_P(btp);
+        btp = xfs_dir2_block_tail_p(mp, block);
+        blp = xfs_dir2_block_leaf_p(btp);
         /*
          * Point to the data entry we need to change.
          */
         dep = (xfs_dir2_data_entry_t *)
-              ((char *)block + XFS_DIR2_DATAPTR_TO_OFF(mp, be32_to_cpu(blp[ent].address)));
+              ((char *)block + xfs_dir2_dataptr_to_off(mp, be32_to_cpu(blp[ent].address)));
         ASSERT(be64_to_cpu(dep->inumber) != args->inumber);
         /*
          * Change the inode number to the new value.
@@ -912,7 +912,7 @@ xfs_dir2_leaf_to_block(
         mp = dp->i_mount;
         leaf = lbp->data;
         ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR2_LEAF1_MAGIC);
-        ltp = XFS_DIR2_LEAF_TAIL_P(mp, leaf);
+        ltp = xfs_dir2_leaf_tail_p(mp, leaf);
         /*
          * If there are data blocks other than the first one, take this
          * opportunity to remove trailing empty data blocks that may have
@@ -920,7 +920,7 @@ xfs_dir2_leaf_to_block(
          * These will show up in the leaf bests table.
          */
         while (dp->i_d.di_size > mp->m_dirblksize) {
-                bestsp = XFS_DIR2_LEAF_BESTS_P(ltp);
+                bestsp = xfs_dir2_leaf_bests_p(ltp);
                 if (be16_to_cpu(bestsp[be32_to_cpu(ltp->bestcount) - 1]) ==
                     mp->m_dirblksize - (uint)sizeof(block->hdr)) {
                         if ((error =
@@ -974,14 +974,14 @@ xfs_dir2_leaf_to_block(
         /*
          * Initialize the block tail.
          */
-        btp = XFS_DIR2_BLOCK_TAIL_P(mp, block);
+        btp = xfs_dir2_block_tail_p(mp, block);
         btp->count = cpu_to_be32(be16_to_cpu(leaf->hdr.count) - be16_to_cpu(leaf->hdr.stale));
         btp->stale = 0;
         xfs_dir2_block_log_tail(tp, dbp);
         /*
          * Initialize the block leaf area.  We compact out stale entries.
          */
-        lep = XFS_DIR2_BLOCK_LEAF_P(btp);
+        lep = xfs_dir2_block_leaf_p(btp);
         for (from = to = 0; from < be16_to_cpu(leaf->hdr.count); from++) {
                 if (be32_to_cpu(leaf->ents[from].address) == XFS_DIR2_NULL_DATAPTR)
                         continue;
@@ -1067,7 +1067,7 @@ xfs_dir2_sf_to_block(
         ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
         ASSERT(dp->i_df.if_u1.if_data != NULL);
         sfp = (xfs_dir2_sf_t *)dp->i_df.if_u1.if_data;
-        ASSERT(dp->i_d.di_size >= XFS_DIR2_SF_HDR_SIZE(sfp->hdr.i8count));
+        ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(sfp->hdr.i8count));
         /*
          * Copy the directory into the stack buffer.
          * Then pitch the incore inode data so we can make extents.
@@ -1119,10 +1119,10 @@ xfs_dir2_sf_to_block(
         /*
          * Fill in the tail.
          */
-        btp = XFS_DIR2_BLOCK_TAIL_P(mp, block);
+        btp = xfs_dir2_block_tail_p(mp, block);
         btp->count = cpu_to_be32(sfp->hdr.count + 2);   /* ., .. */
         btp->stale = 0;
-        blp = XFS_DIR2_BLOCK_LEAF_P(btp);
+        blp = xfs_dir2_block_leaf_p(btp);
         endoffset = (uint)((char *)blp - (char *)block);
         /*
          * Remove the freespace, we'll manage it.
@@ -1138,25 +1138,25 @@ xfs_dir2_sf_to_block(
         dep->inumber = cpu_to_be64(dp->i_ino);
         dep->namelen = 1;
         dep->name[0] = '.';
-        tagp = XFS_DIR2_DATA_ENTRY_TAG_P(dep);
+        tagp = xfs_dir2_data_entry_tag_p(dep);
         *tagp = cpu_to_be16((char *)dep - (char *)block);
         xfs_dir2_data_log_entry(tp, bp, dep);
         blp[0].hashval = cpu_to_be32(xfs_dir_hash_dot);
-        blp[0].address = cpu_to_be32(XFS_DIR2_BYTE_TO_DATAPTR(mp,
+        blp[0].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(mp,
                                 (char *)dep - (char *)block));
         /*
          * Create entry for ..
          */
         dep = (xfs_dir2_data_entry_t *)
                 ((char *)block + XFS_DIR2_DATA_DOTDOT_OFFSET);
-        dep->inumber = cpu_to_be64(XFS_DIR2_SF_GET_INUMBER(sfp, &sfp->hdr.parent));
+        dep->inumber = cpu_to_be64(xfs_dir2_sf_get_inumber(sfp, &sfp->hdr.parent));
         dep->namelen = 2;
         dep->name[0] = dep->name[1] = '.';
-        tagp = XFS_DIR2_DATA_ENTRY_TAG_P(dep);
+        tagp = xfs_dir2_data_entry_tag_p(dep);
         *tagp = cpu_to_be16((char *)dep - (char *)block);
         xfs_dir2_data_log_entry(tp, bp, dep);
         blp[1].hashval = cpu_to_be32(xfs_dir_hash_dotdot);
-        blp[1].address = cpu_to_be32(XFS_DIR2_BYTE_TO_DATAPTR(mp,
+        blp[1].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(mp,
                                 (char *)dep - (char *)block));
         offset = XFS_DIR2_DATA_FIRST_OFFSET;
         /*
@@ -1165,7 +1165,7 @@ xfs_dir2_sf_to_block(
         if ((i = 0) == sfp->hdr.count)
                 sfep = NULL;
         else
-                sfep = XFS_DIR2_SF_FIRSTENTRY(sfp);
+                sfep = xfs_dir2_sf_firstentry(sfp);
         /*
          * Need to preserve the existing offset values in the sf directory.
          * Insert holes (unused entries) where necessary.
@@ -1177,7 +1177,7 @@ xfs_dir2_sf_to_block(
                 if (sfep == NULL)
                         newoffset = endoffset;
                 else
-                        newoffset = XFS_DIR2_SF_GET_OFFSET(sfep);
+                        newoffset = xfs_dir2_sf_get_offset(sfep);
                 /*
                  * There should be a hole here, make one.
                  */
@@ -1186,7 +1186,7 @@ xfs_dir2_sf_to_block(
                               ((char *)block + offset);
                         dup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
                         dup->length = cpu_to_be16(newoffset - offset);
-                        *XFS_DIR2_DATA_UNUSED_TAG_P(dup) = cpu_to_be16(
+                        *xfs_dir2_data_unused_tag_p(dup) = cpu_to_be16(
                                 ((char *)dup - (char *)block));
                         xfs_dir2_data_log_unused(tp, bp, dup);
                         (void)xfs_dir2_data_freeinsert((xfs_dir2_data_t *)block,
@@ -1198,22 +1198,22 @@ xfs_dir2_sf_to_block(
                  * Copy a real entry.
                  */
                 dep = (xfs_dir2_data_entry_t *)((char *)block + newoffset);
-                dep->inumber = cpu_to_be64(XFS_DIR2_SF_GET_INUMBER(sfp,
-                                XFS_DIR2_SF_INUMBERP(sfep)));
+                dep->inumber = cpu_to_be64(xfs_dir2_sf_get_inumber(sfp,
+                                xfs_dir2_sf_inumberp(sfep)));
                 dep->namelen = sfep->namelen;
                 memcpy(dep->name, sfep->name, dep->namelen);
-                tagp = XFS_DIR2_DATA_ENTRY_TAG_P(dep);
+                tagp = xfs_dir2_data_entry_tag_p(dep);
                 *tagp = cpu_to_be16((char *)dep - (char *)block);
                 xfs_dir2_data_log_entry(tp, bp, dep);
                 blp[2 + i].hashval = cpu_to_be32(xfs_da_hashname(
                                         (char *)sfep->name, sfep->namelen));
-                blp[2 + i].address = cpu_to_be32(XFS_DIR2_BYTE_TO_DATAPTR(mp,
+                blp[2 + i].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(mp,
                                                  (char *)dep - (char *)block));
                 offset = (int)((char *)(tagp + 1) - (char *)block);
                 if (++i == sfp->hdr.count)
                         sfep = NULL;
                 else
-                        sfep = XFS_DIR2_SF_NEXTENTRY(sfp, sfep);
+                        sfep = xfs_dir2_sf_nextentry(sfp, sfep);
         }
         /* Done with the temporary buffer */
         kmem_free(buf, buf_len);
diff --git a/fs/xfs/xfs_dir2_block.h b/fs/xfs/xfs_dir2_block.h
index 6722effd0b2..e7c2606161e 100644
--- a/fs/xfs/xfs_dir2_block.h
+++ b/fs/xfs/xfs_dir2_block.h
@@ -60,7 +60,6 @@ typedef struct xfs_dir2_block {
 /*
  * Pointer to the leaf header embedded in a data block (1-block format)
  */
-#define XFS_DIR2_BLOCK_TAIL_P(mp,block) xfs_dir2_block_tail_p(mp,block)
 static inline xfs_dir2_block_tail_t *
 xfs_dir2_block_tail_p(struct xfs_mount *mp, xfs_dir2_block_t *block)
 {
@@ -71,7 +70,6 @@ xfs_dir2_block_tail_p(struct xfs_mount *mp, xfs_dir2_block_t *block)
 /*
  * Pointer to the leaf entries embedded in a data block (1-block format)
  */
-#define XFS_DIR2_BLOCK_LEAF_P(btp)      xfs_dir2_block_leaf_p(btp)
 static inline struct xfs_dir2_leaf_entry *
 xfs_dir2_block_leaf_p(xfs_dir2_block_tail_t *btp)
 {
diff --git a/fs/xfs/xfs_dir2_data.c b/fs/xfs/xfs_dir2_data.c
index c211c37ef67..7ebe295bd6d 100644
--- a/fs/xfs/xfs_dir2_data.c
+++ b/fs/xfs/xfs_dir2_data.c
@@ -72,8 +72,8 @@ xfs_dir2_data_check(
         bf = d->hdr.bestfree;
         p = (char *)d->u;
         if (be32_to_cpu(d->hdr.magic) == XFS_DIR2_BLOCK_MAGIC) {
-                btp = XFS_DIR2_BLOCK_TAIL_P(mp, (xfs_dir2_block_t *)d);
-                lep = XFS_DIR2_BLOCK_LEAF_P(btp);
+                btp = xfs_dir2_block_tail_p(mp, (xfs_dir2_block_t *)d);
+                lep = xfs_dir2_block_leaf_p(btp);
                 endp = (char *)lep;
         } else
                 endp = (char *)d + mp->m_dirblksize;
@@ -107,7 +107,7 @@ xfs_dir2_data_check(
                  */
                 if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
                         ASSERT(lastfree == 0);
-                        ASSERT(be16_to_cpu(*XFS_DIR2_DATA_UNUSED_TAG_P(dup)) ==
+                        ASSERT(be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)) ==
                                (char *)dup - (char *)d);
                         dfp = xfs_dir2_data_freefind(d, dup);
                         if (dfp) {
@@ -131,12 +131,12 @@ xfs_dir2_data_check(
                 dep = (xfs_dir2_data_entry_t *)p;
                 ASSERT(dep->namelen != 0);
                 ASSERT(xfs_dir_ino_validate(mp, be64_to_cpu(dep->inumber)) == 0);
-                ASSERT(be16_to_cpu(*XFS_DIR2_DATA_ENTRY_TAG_P(dep)) ==
+                ASSERT(be16_to_cpu(*xfs_dir2_data_entry_tag_p(dep)) ==
                        (char *)dep - (char *)d);
                 count++;
                 lastfree = 0;
                 if (be32_to_cpu(d->hdr.magic) == XFS_DIR2_BLOCK_MAGIC) {
-                        addr = XFS_DIR2_DB_OFF_TO_DATAPTR(mp, mp->m_dirdatablk,
+                        addr = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
                                 (xfs_dir2_data_aoff_t)
                                 ((char *)dep - (char *)d));
                         hash = xfs_da_hashname((char *)dep->name, dep->namelen);
@@ -147,7 +147,7 @@ xfs_dir2_data_check(
                         }
                         ASSERT(i < be32_to_cpu(btp->count));
                 }
-                p += XFS_DIR2_DATA_ENTSIZE(dep->namelen);
+                p += xfs_dir2_data_entsize(dep->namelen);
         }
         /*
          * Need to have seen all the entries and all the bestfree slots.
@@ -346,8 +346,8 @@ xfs_dir2_data_freescan(
          */
         p = (char *)d->u;
         if (be32_to_cpu(d->hdr.magic) == XFS_DIR2_BLOCK_MAGIC) {
-                btp = XFS_DIR2_BLOCK_TAIL_P(mp, (xfs_dir2_block_t *)d);
-                endp = (char *)XFS_DIR2_BLOCK_LEAF_P(btp);
+                btp = xfs_dir2_block_tail_p(mp, (xfs_dir2_block_t *)d);
+                endp = (char *)xfs_dir2_block_leaf_p(btp);
         } else
                 endp = (char *)d + mp->m_dirblksize;
         /*
@@ -360,7 +360,7 @@ xfs_dir2_data_freescan(
                  */
                 if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
                         ASSERT((char *)dup - (char *)d ==
-                               be16_to_cpu(*XFS_DIR2_DATA_UNUSED_TAG_P(dup)));
+                               be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)));
                         xfs_dir2_data_freeinsert(d, dup, loghead);
                         p += be16_to_cpu(dup->length);
                 }
@@ -370,8 +370,8 @@ xfs_dir2_data_freescan(
                 else {
                         dep = (xfs_dir2_data_entry_t *)p;
                         ASSERT((char *)dep - (char *)d ==
-                               be16_to_cpu(*XFS_DIR2_DATA_ENTRY_TAG_P(dep)));
-                        p += XFS_DIR2_DATA_ENTSIZE(dep->namelen);
+                               be16_to_cpu(*xfs_dir2_data_entry_tag_p(dep)));
+                        p += xfs_dir2_data_entsize(dep->namelen);
                 }
         }
 }
@@ -402,7 +402,7 @@ xfs_dir2_data_init(
         /*
          * Get the buffer set up for the block.
          */
-        error = xfs_da_get_buf(tp, dp, XFS_DIR2_DB_TO_DA(mp, blkno), -1, &bp,
+        error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(mp, blkno), -1, &bp,
                 XFS_DATA_FORK);
         if (error) {
                 return error;
@@ -427,7 +427,7 @@ xfs_dir2_data_init(
         t=mp->m_dirblksize - (uint)sizeof(d->hdr);
         d->hdr.bestfree[0].length = cpu_to_be16(t);
         dup->length = cpu_to_be16(t);
-        *XFS_DIR2_DATA_UNUSED_TAG_P(dup) = cpu_to_be16((char *)dup - (char *)d);
+        *xfs_dir2_data_unused_tag_p(dup) = cpu_to_be16((char *)dup - (char *)d);
         /*
          * Log it and return it.
          */
@@ -452,7 +452,7 @@ xfs_dir2_data_log_entry(
         ASSERT(be32_to_cpu(d->hdr.magic) == XFS_DIR2_DATA_MAGIC ||
                be32_to_cpu(d->hdr.magic) == XFS_DIR2_BLOCK_MAGIC);
         xfs_da_log_buf(tp, bp, (uint)((char *)dep - (char *)d),
-                (uint)((char *)(XFS_DIR2_DATA_ENTRY_TAG_P(dep) + 1) -
+                (uint)((char *)(xfs_dir2_data_entry_tag_p(dep) + 1) -
                        (char *)d - 1));
 }
 
@@ -497,8 +497,8 @@ xfs_dir2_data_log_unused(
          * Log the end (tag) of the unused entry.
          */
         xfs_da_log_buf(tp, bp,
-                (uint)((char *)XFS_DIR2_DATA_UNUSED_TAG_P(dup) - (char *)d),
-                (uint)((char *)XFS_DIR2_DATA_UNUSED_TAG_P(dup) - (char *)d +
+                (uint)((char *)xfs_dir2_data_unused_tag_p(dup) - (char *)d),
+                (uint)((char *)xfs_dir2_data_unused_tag_p(dup) - (char *)d +
                        sizeof(xfs_dir2_data_off_t) - 1));
 }
 
@@ -535,8 +535,8 @@ xfs_dir2_data_make_free(
                 xfs_dir2_block_tail_t   *btp;   /* block tail */
 
                 ASSERT(be32_to_cpu(d->hdr.magic) == XFS_DIR2_BLOCK_MAGIC);
-                btp = XFS_DIR2_BLOCK_TAIL_P(mp, (xfs_dir2_block_t *)d);
-                endptr = (char *)XFS_DIR2_BLOCK_LEAF_P(btp);
+                btp = xfs_dir2_block_tail_p(mp, (xfs_dir2_block_t *)d);
+                endptr = (char *)xfs_dir2_block_leaf_p(btp);
         }
         /*
          * If this isn't the start of the block, then back up to
@@ -587,7 +587,7 @@ xfs_dir2_data_make_free(
                  * Fix up the new big freespace.
                  */
                 be16_add(&prevdup->length, len + be16_to_cpu(postdup->length));
-                *XFS_DIR2_DATA_UNUSED_TAG_P(prevdup) =
+                *xfs_dir2_data_unused_tag_p(prevdup) =
                         cpu_to_be16((char *)prevdup - (char *)d);
                 xfs_dir2_data_log_unused(tp, bp, prevdup);
                 if (!needscan) {
@@ -621,7 +621,7 @@ xfs_dir2_data_make_free(
         else if (prevdup) {
                 dfp = xfs_dir2_data_freefind(d, prevdup);
                 be16_add(&prevdup->length, len);
-                *XFS_DIR2_DATA_UNUSED_TAG_P(prevdup) =
+                *xfs_dir2_data_unused_tag_p(prevdup) =
                         cpu_to_be16((char *)prevdup - (char *)d);
                 xfs_dir2_data_log_unused(tp, bp, prevdup);
                 /*
@@ -649,7 +649,7 @@ xfs_dir2_data_make_free(
                 newdup = (xfs_dir2_data_unused_t *)((char *)d + offset);
                 newdup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
                 newdup->length = cpu_to_be16(len + be16_to_cpu(postdup->length));
-                *XFS_DIR2_DATA_UNUSED_TAG_P(newdup) =
+                *xfs_dir2_data_unused_tag_p(newdup) =
                         cpu_to_be16((char *)newdup - (char *)d);
                 xfs_dir2_data_log_unused(tp, bp, newdup);
                 /*
@@ -676,7 +676,7 @@ xfs_dir2_data_make_free(
                 newdup = (xfs_dir2_data_unused_t *)((char *)d + offset);
                 newdup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
                 newdup->length = cpu_to_be16(len);
-                *XFS_DIR2_DATA_UNUSED_TAG_P(newdup) =
+                *xfs_dir2_data_unused_tag_p(newdup) =
                         cpu_to_be16((char *)newdup - (char *)d);
                 xfs_dir2_data_log_unused(tp, bp, newdup);
                 (void)xfs_dir2_data_freeinsert(d, newdup, needlogp);
@@ -712,7 +712,7 @@ xfs_dir2_data_use_free(
         ASSERT(be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG);
         ASSERT(offset >= (char *)dup - (char *)d);
         ASSERT(offset + len <= (char *)dup + be16_to_cpu(dup->length) - (char *)d);
-        ASSERT((char *)dup - (char *)d == be16_to_cpu(*XFS_DIR2_DATA_UNUSED_TAG_P(dup)));
+        ASSERT((char *)dup - (char *)d == be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)));
         /*
          * Look up the entry in the bestfree table.
          */
@@ -745,7 +745,7 @@ xfs_dir2_data_use_free(
                 newdup = (xfs_dir2_data_unused_t *)((char *)d + offset + len);
                 newdup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
                 newdup->length = cpu_to_be16(oldlen - len);
-                *XFS_DIR2_DATA_UNUSED_TAG_P(newdup) =
+                *xfs_dir2_data_unused_tag_p(newdup) =
                         cpu_to_be16((char *)newdup - (char *)d);
                 xfs_dir2_data_log_unused(tp, bp, newdup);
                 /*
@@ -772,7 +772,7 @@ xfs_dir2_data_use_free(
         else if (matchback) {
                 newdup = dup;
                 newdup->length = cpu_to_be16(((char *)d + offset) - (char *)newdup);
-                *XFS_DIR2_DATA_UNUSED_TAG_P(newdup) =
+                *xfs_dir2_data_unused_tag_p(newdup) =
                         cpu_to_be16((char *)newdup - (char *)d);
                 xfs_dir2_data_log_unused(tp, bp, newdup);
                 /*
@@ -799,13 +799,13 @@ xfs_dir2_data_use_free(
         else {
                 newdup = dup;
                 newdup->length = cpu_to_be16(((char *)d + offset) - (char *)newdup);
-                *XFS_DIR2_DATA_UNUSED_TAG_P(newdup) =
+                *xfs_dir2_data_unused_tag_p(newdup) =
                         cpu_to_be16((char *)newdup - (char *)d);
                 xfs_dir2_data_log_unused(tp, bp, newdup);
                 newdup2 = (xfs_dir2_data_unused_t *)((char *)d + offset + len);
                 newdup2->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
                 newdup2->length = cpu_to_be16(oldlen - len - be16_to_cpu(newdup->length));
-                *XFS_DIR2_DATA_UNUSED_TAG_P(newdup2) =
+                *xfs_dir2_data_unused_tag_p(newdup2) =
                         cpu_to_be16((char *)newdup2 - (char *)d);
                 xfs_dir2_data_log_unused(tp, bp, newdup2);
                 /*
diff --git a/fs/xfs/xfs_dir2_data.h b/fs/xfs/xfs_dir2_data.h
index c94c9099cfb..b816e025273 100644
--- a/fs/xfs/xfs_dir2_data.h
+++ b/fs/xfs/xfs_dir2_data.h
@@ -44,7 +44,7 @@ struct xfs_trans;
 #define XFS_DIR2_DATA_SPACE     0
 #define XFS_DIR2_DATA_OFFSET    (XFS_DIR2_DATA_SPACE * XFS_DIR2_SPACE_SIZE)
 #define XFS_DIR2_DATA_FIRSTDB(mp)       \
-        XFS_DIR2_BYTE_TO_DB(mp, XFS_DIR2_DATA_OFFSET)
+        xfs_dir2_byte_to_db(mp, XFS_DIR2_DATA_OFFSET)
 
 /*
  * Offsets of . and .. in data space (always block 0)
@@ -52,9 +52,9 @@ struct xfs_trans;
 #define XFS_DIR2_DATA_DOT_OFFSET        \
         ((xfs_dir2_data_aoff_t)sizeof(xfs_dir2_data_hdr_t))
 #define XFS_DIR2_DATA_DOTDOT_OFFSET     \
-        (XFS_DIR2_DATA_DOT_OFFSET + XFS_DIR2_DATA_ENTSIZE(1))
+        (XFS_DIR2_DATA_DOT_OFFSET + xfs_dir2_data_entsize(1))
 #define XFS_DIR2_DATA_FIRST_OFFSET              \
-        (XFS_DIR2_DATA_DOTDOT_OFFSET + XFS_DIR2_DATA_ENTSIZE(2))
+        (XFS_DIR2_DATA_DOTDOT_OFFSET + xfs_dir2_data_entsize(2))
 
 /*
  * Structures.
@@ -123,7 +123,6 @@ typedef struct xfs_dir2_data {
 /*
  * Size of a data entry.
  */
-#define XFS_DIR2_DATA_ENTSIZE(n)        xfs_dir2_data_entsize(n)
 static inline int xfs_dir2_data_entsize(int n)
 {
         return (int)roundup(offsetof(xfs_dir2_data_entry_t, name[0]) + (n) + \
@@ -133,19 +132,16 @@ static inline int xfs_dir2_data_entsize(int n)
 /*
  * Pointer to an entry's tag word.
  */
-#define XFS_DIR2_DATA_ENTRY_TAG_P(dep)  xfs_dir2_data_entry_tag_p(dep)
 static inline __be16 *
 xfs_dir2_data_entry_tag_p(xfs_dir2_data_entry_t *dep)
 {
         return (__be16 *)((char *)dep +
-                XFS_DIR2_DATA_ENTSIZE(dep->namelen) - sizeof(__be16));
+                xfs_dir2_data_entsize(dep->namelen) - sizeof(__be16));
 }
 
 /*
  * Pointer to a freespace's tag word.
  */
-#define XFS_DIR2_DATA_UNUSED_TAG_P(dup) \
-        xfs_dir2_data_unused_tag_p(dup)
 static inline __be16 *
 xfs_dir2_data_unused_tag_p(xfs_dir2_data_unused_t *dup)
 {
diff --git a/fs/xfs/xfs_dir2_leaf.c b/fs/xfs/xfs_dir2_leaf.c
index db14ea71459..1b73c9ad646 100644
--- a/fs/xfs/xfs_dir2_leaf.c
+++ b/fs/xfs/xfs_dir2_leaf.c
@@ -92,7 +92,7 @@ xfs_dir2_block_to_leaf(
         if ((error = xfs_da_grow_inode(args, &blkno))) {
                 return error;
         }
-        ldb = XFS_DIR2_DA_TO_DB(mp, blkno);
+        ldb = xfs_dir2_da_to_db(mp, blkno);
         ASSERT(ldb == XFS_DIR2_LEAF_FIRSTDB(mp));
         /*
          * Initialize the leaf block, get a buffer for it.
@@ -104,8 +104,8 @@ xfs_dir2_block_to_leaf(
         leaf = lbp->data;
         block = dbp->data;
         xfs_dir2_data_check(dp, dbp);
-        btp = XFS_DIR2_BLOCK_TAIL_P(mp, block);
-        blp = XFS_DIR2_BLOCK_LEAF_P(btp);
+        btp = xfs_dir2_block_tail_p(mp, block);
+        blp = xfs_dir2_block_leaf_p(btp);
         /*
          * Set the counts in the leaf header.
          */
@@ -137,9 +137,9 @@ xfs_dir2_block_to_leaf(
         /*
          * Set up leaf tail and bests table.
          */
-        ltp = XFS_DIR2_LEAF_TAIL_P(mp, leaf);
+        ltp = xfs_dir2_leaf_tail_p(mp, leaf);
         ltp->bestcount = cpu_to_be32(1);
-        bestsp = XFS_DIR2_LEAF_BESTS_P(ltp);
+        bestsp = xfs_dir2_leaf_bests_p(ltp);
         bestsp[0] =  block->hdr.bestfree[0].length;
         /*
          * Log the data header and leaf bests table.
@@ -209,9 +209,9 @@ xfs_dir2_leaf_addname(
          */
         index = xfs_dir2_leaf_search_hash(args, lbp);
         leaf = lbp->data;
-        ltp = XFS_DIR2_LEAF_TAIL_P(mp, leaf);
-        bestsp = XFS_DIR2_LEAF_BESTS_P(ltp);
-        length = XFS_DIR2_DATA_ENTSIZE(args->namelen);
+        ltp = xfs_dir2_leaf_tail_p(mp, leaf);
+        bestsp = xfs_dir2_leaf_bests_p(ltp);
+        length = xfs_dir2_data_entsize(args->namelen);
         /*
          * See if there are any entries with the same hash value
          * and space in their block for the new entry.
@@ -223,7 +223,7 @@ xfs_dir2_leaf_addname(
              index++, lep++) {
                 if (be32_to_cpu(lep->address) == XFS_DIR2_NULL_DATAPTR)
                         continue;
-                i = XFS_DIR2_DATAPTR_TO_DB(mp, be32_to_cpu(lep->address));
+                i = xfs_dir2_dataptr_to_db(mp, be32_to_cpu(lep->address));
                 ASSERT(i < be32_to_cpu(ltp->bestcount));
                 ASSERT(be16_to_cpu(bestsp[i]) != NULLDATAOFF);
                 if (be16_to_cpu(bestsp[i]) >= length) {
@@ -378,7 +378,7 @@ xfs_dir2_leaf_addname(
          */
         else {
                 if ((error =
-                    xfs_da_read_buf(tp, dp, XFS_DIR2_DB_TO_DA(mp, use_block),
+                    xfs_da_read_buf(tp, dp, xfs_dir2_db_to_da(mp, use_block),
                             -1, &dbp, XFS_DATA_FORK))) {
                         xfs_da_brelse(tp, lbp);
                         return error;
@@ -407,7 +407,7 @@ xfs_dir2_leaf_addname(
         dep->inumber = cpu_to_be64(args->inumber);
         dep->namelen = args->namelen;
         memcpy(dep->name, args->name, dep->namelen);
-        tagp = XFS_DIR2_DATA_ENTRY_TAG_P(dep);
+        tagp = xfs_dir2_data_entry_tag_p(dep);
         *tagp = cpu_to_be16((char *)dep - (char *)data);
         /*
          * Need to scan fix up the bestfree table.
@@ -529,7 +529,7 @@ xfs_dir2_leaf_addname(
          * Fill in the new leaf entry.
          */
         lep->hashval = cpu_to_be32(args->hashval);
-        lep->address = cpu_to_be32(XFS_DIR2_DB_OFF_TO_DATAPTR(mp, use_block,
+        lep->address = cpu_to_be32(xfs_dir2_db_off_to_dataptr(mp, use_block,
                                 be16_to_cpu(*tagp)));
         /*
          * Log the leaf fields and give up the buffers.
@@ -567,13 +567,13 @@ xfs_dir2_leaf_check(
          * Should factor in the size of the bests table as well.
          * We can deduce a value for that from di_size.
          */
-        ASSERT(be16_to_cpu(leaf->hdr.count) <= XFS_DIR2_MAX_LEAF_ENTS(mp));
-        ltp = XFS_DIR2_LEAF_TAIL_P(mp, leaf);
+        ASSERT(be16_to_cpu(leaf->hdr.count) <= xfs_dir2_max_leaf_ents(mp));
+        ltp = xfs_dir2_leaf_tail_p(mp, leaf);
         /*
          * Leaves and bests don't overlap.
          */
         ASSERT((char *)&leaf->ents[be16_to_cpu(leaf->hdr.count)] <=
-               (char *)XFS_DIR2_LEAF_BESTS_P(ltp));
+               (char *)xfs_dir2_leaf_bests_p(ltp));
         /*
          * Check hash value order, count stale entries.
          */
@@ -815,12 +815,12 @@ xfs_dir2_leaf_getdents(
          * Inside the loop we keep the main offset value as a byte offset
          * in the directory file.
          */
-        curoff = XFS_DIR2_DATAPTR_TO_BYTE(mp, uio->uio_offset);
+        curoff = xfs_dir2_dataptr_to_byte(mp, uio->uio_offset);
         /*
          * Force this conversion through db so we truncate the offset
          * down to get the start of the data block.
          */
-        map_off = XFS_DIR2_DB_TO_DA(mp, XFS_DIR2_BYTE_TO_DB(mp, curoff));
+        map_off = xfs_dir2_db_to_da(mp, xfs_dir2_byte_to_db(mp, curoff));
         /*
          * Loop over directory entries until we reach the end offset.
          * Get more blocks and readahead as necessary.
@@ -870,7 +870,7 @@ xfs_dir2_leaf_getdents(
                          */
                         if (1 + ra_want > map_blocks &&
                             map_off <
-                            XFS_DIR2_BYTE_TO_DA(mp, XFS_DIR2_LEAF_OFFSET)) {
+                            xfs_dir2_byte_to_da(mp, XFS_DIR2_LEAF_OFFSET)) {
                                 /*
                                  * Get more bmaps, fill in after the ones
                                  * we already have in the table.
@@ -878,7 +878,7 @@ xfs_dir2_leaf_getdents(
                                 nmap = map_size - map_valid;
                                 error = xfs_bmapi(tp, dp,
                                         map_off,
-                                        XFS_DIR2_BYTE_TO_DA(mp,
+                                        xfs_dir2_byte_to_da(mp,
                                                 XFS_DIR2_LEAF_OFFSET) - map_off,
                                         XFS_BMAPI_METADATA, NULL, 0,
                                         &map[map_valid], &nmap, NULL, NULL);
@@ -903,7 +903,7 @@ xfs_dir2_leaf_getdents(
                                         map[map_valid + nmap - 1].br_blockcount;
                                 else
                                         map_off =
-                                                XFS_DIR2_BYTE_TO_DA(mp,
+                                                xfs_dir2_byte_to_da(mp,
                                                         XFS_DIR2_LEAF_OFFSET);
                                 /*
                                  * Look for holes in the mapping, and
@@ -931,14 +931,14 @@ xfs_dir2_leaf_getdents(
                          * No valid mappings, so no more data blocks.
                          */
                         if (!map_valid) {
-                                curoff = XFS_DIR2_DA_TO_BYTE(mp, map_off);
+                                curoff = xfs_dir2_da_to_byte(mp, map_off);
                                 break;
                         }
                         /*
                          * Read the directory block starting at the first
                          * mapping.
                          */
-                        curdb = XFS_DIR2_DA_TO_DB(mp, map->br_startoff);
+                        curdb = xfs_dir2_da_to_db(mp, map->br_startoff);
                         error = xfs_da_read_buf(tp, dp, map->br_startoff,
                                 map->br_blockcount >= mp->m_dirblkfsbs ?
                                     XFS_FSB_TO_DADDR(mp, map->br_startblock) :
@@ -1014,7 +1014,7 @@ xfs_dir2_leaf_getdents(
                         /*
                          * Having done a read, we need to set a new offset.
                          */
-                        newoff = XFS_DIR2_DB_OFF_TO_BYTE(mp, curdb, 0);
+                        newoff = xfs_dir2_db_off_to_byte(mp, curdb, 0);
                         /*
                          * Start of the current block.
                          */
@@ -1024,7 +1024,7 @@ xfs_dir2_leaf_getdents(
                          * Make sure we're in the right block.
                          */
                         else if (curoff > newoff)
-                                ASSERT(XFS_DIR2_BYTE_TO_DB(mp, curoff) ==
+                                ASSERT(xfs_dir2_byte_to_db(mp, curoff) ==
                                        curdb);
                         data = bp->data;
                         xfs_dir2_data_check(dp, bp);
@@ -1032,7 +1032,7 @@ xfs_dir2_leaf_getdents(
                          * Find our position in the block.
                          */
                         ptr = (char *)&data->u;
-                        byteoff = XFS_DIR2_BYTE_TO_OFF(mp, curoff);
+                        byteoff = xfs_dir2_byte_to_off(mp, curoff);
                         /*
                          * Skip past the header.
                          */
@@ -1054,15 +1054,15 @@ xfs_dir2_leaf_getdents(
                                         }
                                         dep = (xfs_dir2_data_entry_t *)ptr;
                                         length =
-                                           XFS_DIR2_DATA_ENTSIZE(dep->namelen);
+                                           xfs_dir2_data_entsize(dep->namelen);
                                         ptr += length;
                                 }
                                 /*
                                  * Now set our real offset.
                                  */
                                 curoff =
-                                        XFS_DIR2_DB_OFF_TO_BYTE(mp,
-                                            XFS_DIR2_BYTE_TO_DB(mp, curoff),
+                                        xfs_dir2_db_off_to_byte(mp,
+                                            xfs_dir2_byte_to_db(mp, curoff),
                                             (char *)ptr - (char *)data);
                                 if (ptr >= (char *)data + mp->m_dirblksize) {
                                         continue;
@@ -1091,9 +1091,9 @@ xfs_dir2_leaf_getdents(
 
                 p->namelen = dep->namelen;
 
-                length = XFS_DIR2_DATA_ENTSIZE(p->namelen);
+                length = xfs_dir2_data_entsize(p->namelen);
 
-                p->cook = XFS_DIR2_BYTE_TO_DATAPTR(mp, curoff + length);
+                p->cook = xfs_dir2_byte_to_dataptr(mp, curoff + length);
 
                 p->ino = be64_to_cpu(dep->inumber);
 #if XFS_BIG_INUMS
@@ -1121,10 +1121,10 @@ xfs_dir2_leaf_getdents(
          * All done.  Set output offset value to current offset.
          */
         *eofp = eof;
-        if (curoff > XFS_DIR2_DATAPTR_TO_BYTE(mp, XFS_DIR2_MAX_DATAPTR))
+        if (curoff > xfs_dir2_dataptr_to_byte(mp, XFS_DIR2_MAX_DATAPTR))
                 uio->uio_offset = XFS_DIR2_MAX_DATAPTR;
         else
-                uio->uio_offset = XFS_DIR2_BYTE_TO_DATAPTR(mp, curoff);
+                uio->uio_offset = xfs_dir2_byte_to_dataptr(mp, curoff);
         kmem_free(map, map_size * sizeof(*map));
         kmem_free(p, sizeof(*p));
         if (bp)
@@ -1159,7 +1159,7 @@ xfs_dir2_leaf_init(
         /*
          * Get the buffer for the block.
          */
-        error = xfs_da_get_buf(tp, dp, XFS_DIR2_DB_TO_DA(mp, bno), -1, &bp,
+        error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(mp, bno), -1, &bp,
                 XFS_DATA_FORK);
         if (error) {
                 return error;
@@ -1181,7 +1181,7 @@ xfs_dir2_leaf_init(
          * the block.
          */
         if (magic == XFS_DIR2_LEAF1_MAGIC) {
-                ltp = XFS_DIR2_LEAF_TAIL_P(mp, leaf);
+                ltp = xfs_dir2_leaf_tail_p(mp, leaf);
                 ltp->bestcount = 0;
                 xfs_dir2_leaf_log_tail(tp, bp);
         }
@@ -1206,9 +1206,9 @@ xfs_dir2_leaf_log_bests(
 
         leaf = bp->data;
         ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR2_LEAF1_MAGIC);
-        ltp = XFS_DIR2_LEAF_TAIL_P(tp->t_mountp, leaf);
-        firstb = XFS_DIR2_LEAF_BESTS_P(ltp) + first;
-        lastb = XFS_DIR2_LEAF_BESTS_P(ltp) + last;
+        ltp = xfs_dir2_leaf_tail_p(tp->t_mountp, leaf);
+        firstb = xfs_dir2_leaf_bests_p(ltp) + first;
+        lastb = xfs_dir2_leaf_bests_p(ltp) + last;
         xfs_da_log_buf(tp, bp, (uint)((char *)firstb - (char *)leaf),
                 (uint)((char *)lastb - (char *)leaf + sizeof(*lastb) - 1));
 }
@@ -1268,7 +1268,7 @@ xfs_dir2_leaf_log_tail(
         mp = tp->t_mountp;
         leaf = bp->data;
         ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR2_LEAF1_MAGIC);
-        ltp = XFS_DIR2_LEAF_TAIL_P(mp, leaf);
+        ltp = xfs_dir2_leaf_tail_p(mp, leaf);
         xfs_da_log_buf(tp, bp, (uint)((char *)ltp - (char *)leaf),
                 (uint)(mp->m_dirblksize - 1));
 }
@@ -1312,7 +1312,7 @@ xfs_dir2_leaf_lookup(
          */
         dep = (xfs_dir2_data_entry_t *)
               ((char *)dbp->data +
-               XFS_DIR2_DATAPTR_TO_OFF(dp->i_mount, be32_to_cpu(lep->address)));
+               xfs_dir2_dataptr_to_off(dp->i_mount, be32_to_cpu(lep->address)));
         /*
          * Return the found inode number.
          */
@@ -1381,7 +1381,7 @@ xfs_dir2_leaf_lookup_int(
                 /*
                  * Get the new data block number.
                  */
-                newdb = XFS_DIR2_DATAPTR_TO_DB(mp, be32_to_cpu(lep->address));
+                newdb = xfs_dir2_dataptr_to_db(mp, be32_to_cpu(lep->address));
                 /*
                  * If it's not the same as the old data block number,
                  * need to pitch the old one and read the new one.
@@ -1391,7 +1391,7 @@ xfs_dir2_leaf_lookup_int(
                                 xfs_da_brelse(tp, dbp);
                         if ((error =
                             xfs_da_read_buf(tp, dp,
-                                    XFS_DIR2_DB_TO_DA(mp, newdb), -1, &dbp,
+                                    xfs_dir2_db_to_da(mp, newdb), -1, &dbp,
                                     XFS_DATA_FORK))) {
                                 xfs_da_brelse(tp, lbp);
                                 return error;
@@ -1404,7 +1404,7 @@ xfs_dir2_leaf_lookup_int(
                  */
                 dep = (xfs_dir2_data_entry_t *)
                       ((char *)dbp->data +
-                       XFS_DIR2_DATAPTR_TO_OFF(mp, be32_to_cpu(lep->address)));
+                       xfs_dir2_dataptr_to_off(mp, be32_to_cpu(lep->address)));
                 /*
                  * If it matches then return it.
                  */
@@ -1469,20 +1469,20 @@ xfs_dir2_leaf_removename(
          * Point to the leaf entry, use that to point to the data entry.
          */
         lep = &leaf->ents[index];
-        db = XFS_DIR2_DATAPTR_TO_DB(mp, be32_to_cpu(lep->address));
+        db = xfs_dir2_dataptr_to_db(mp, be32_to_cpu(lep->address));
         dep = (xfs_dir2_data_entry_t *)
-              ((char *)data + XFS_DIR2_DATAPTR_TO_OFF(mp, be32_to_cpu(lep->address)));
+              ((char *)data + xfs_dir2_dataptr_to_off(mp, be32_to_cpu(lep->address)));
         needscan = needlog = 0;
         oldbest = be16_to_cpu(data->hdr.bestfree[0].length);
-        ltp = XFS_DIR2_LEAF_TAIL_P(mp, leaf);
-        bestsp = XFS_DIR2_LEAF_BESTS_P(ltp);
+        ltp = xfs_dir2_leaf_tail_p(mp, leaf);
+        bestsp = xfs_dir2_leaf_bests_p(ltp);
         ASSERT(be16_to_cpu(bestsp[db]) == oldbest);
         /*
          * Mark the former data entry unused.
          */
         xfs_dir2_data_make_free(tp, dbp,
                 (xfs_dir2_data_aoff_t)((char *)dep - (char *)data),
-                XFS_DIR2_DATA_ENTSIZE(dep->namelen), &needlog, &needscan);
+                xfs_dir2_data_entsize(dep->namelen), &needlog, &needscan);
         /*
          * We just mark the leaf entry stale by putting a null in it.
          */
@@ -1602,7 +1602,7 @@ xfs_dir2_leaf_replace(
          */
         dep = (xfs_dir2_data_entry_t *)
               ((char *)dbp->data +
-               XFS_DIR2_DATAPTR_TO_OFF(dp->i_mount, be32_to_cpu(lep->address)));
+               xfs_dir2_dataptr_to_off(dp->i_mount, be32_to_cpu(lep->address)));
         ASSERT(args->inumber != be64_to_cpu(dep->inumber));
         /*
          * Put the new inode number in, log it.
@@ -1698,7 +1698,7 @@ xfs_dir2_leaf_trim_data(
         /*
          * Read the offending data block.  We need its buffer.
          */
-        if ((error = xfs_da_read_buf(tp, dp, XFS_DIR2_DB_TO_DA(mp, db), -1, &dbp,
+        if ((error = xfs_da_read_buf(tp, dp, xfs_dir2_db_to_da(mp, db), -1, &dbp,
                         XFS_DATA_FORK))) {
                 return error;
         }
@@ -1712,7 +1712,7 @@ xfs_dir2_leaf_trim_data(
          */
 
         leaf = lbp->data;
-        ltp = XFS_DIR2_LEAF_TAIL_P(mp, leaf);
+        ltp = xfs_dir2_leaf_tail_p(mp, leaf);
         ASSERT(be16_to_cpu(data->hdr.bestfree[0].length) ==
                mp->m_dirblksize - (uint)sizeof(data->hdr));
         ASSERT(db == be32_to_cpu(ltp->bestcount) - 1);
@@ -1727,7 +1727,7 @@ xfs_dir2_leaf_trim_data(
         /*
          * Eliminate the last bests entry from the table.
          */
-        bestsp = XFS_DIR2_LEAF_BESTS_P(ltp);
+        bestsp = xfs_dir2_leaf_bests_p(ltp);
         be32_add(&ltp->bestcount, -1);
         memmove(&bestsp[1], &bestsp[0], be32_to_cpu(ltp->bestcount) * sizeof(*bestsp));
         xfs_dir2_leaf_log_tail(tp, lbp);
@@ -1838,12 +1838,12 @@ xfs_dir2_node_to_leaf(
         /*
          * Set up the leaf tail from the freespace block.
          */
-        ltp = XFS_DIR2_LEAF_TAIL_P(mp, leaf);
+        ltp = xfs_dir2_leaf_tail_p(mp, leaf);
         ltp->bestcount = free->hdr.nvalid;
         /*
          * Set up the leaf bests table.
          */
-        memcpy(XFS_DIR2_LEAF_BESTS_P(ltp), free->bests,
+        memcpy(xfs_dir2_leaf_bests_p(ltp), free->bests,
                 be32_to_cpu(ltp->bestcount) * sizeof(leaf->bests[0]));
         xfs_dir2_leaf_log_bests(tp, lbp, 0, be32_to_cpu(ltp->bestcount) - 1);
         xfs_dir2_leaf_log_tail(tp, lbp);
diff --git a/fs/xfs/xfs_dir2_leaf.h b/fs/xfs/xfs_dir2_leaf.h
index f57ca116241..70c97f3f815 100644
--- a/fs/xfs/xfs_dir2_leaf.h
+++ b/fs/xfs/xfs_dir2_leaf.h
@@ -32,7 +32,7 @@ struct xfs_trans;
 #define XFS_DIR2_LEAF_SPACE     1
 #define XFS_DIR2_LEAF_OFFSET    (XFS_DIR2_LEAF_SPACE * XFS_DIR2_SPACE_SIZE)
 #define XFS_DIR2_LEAF_FIRSTDB(mp)       \
-        XFS_DIR2_BYTE_TO_DB(mp, XFS_DIR2_LEAF_OFFSET)
+        xfs_dir2_byte_to_db(mp, XFS_DIR2_LEAF_OFFSET)
 
 /*
  * Offset in data space of a data entry.
@@ -82,7 +82,6 @@ typedef struct xfs_dir2_leaf {
  * DB blocks here are logical directory block numbers, not filesystem blocks.
  */
 
-#define XFS_DIR2_MAX_LEAF_ENTS(mp)      xfs_dir2_max_leaf_ents(mp)
 static inline int xfs_dir2_max_leaf_ents(struct xfs_mount *mp)
 {
         return (int)(((mp)->m_dirblksize - (uint)sizeof(xfs_dir2_leaf_hdr_t)) /
@@ -92,7 +91,6 @@ static inline int xfs_dir2_max_leaf_ents(struct xfs_mount *mp)
 /*
  * Get address of the bestcount field in the single-leaf block.
  */
-#define XFS_DIR2_LEAF_TAIL_P(mp,lp)     xfs_dir2_leaf_tail_p(mp, lp)
 static inline xfs_dir2_leaf_tail_t *
 xfs_dir2_leaf_tail_p(struct xfs_mount *mp, xfs_dir2_leaf_t *lp)
 {
@@ -104,7 +102,6 @@ xfs_dir2_leaf_tail_p(struct xfs_mount *mp, xfs_dir2_leaf_t *lp)
 /*
  * Get address of the bests array in the single-leaf block.
  */
-#define XFS_DIR2_LEAF_BESTS_P(ltp)      xfs_dir2_leaf_bests_p(ltp)
 static inline __be16 *
 xfs_dir2_leaf_bests_p(xfs_dir2_leaf_tail_t *ltp)
 {
@@ -114,7 +111,6 @@ xfs_dir2_leaf_bests_p(xfs_dir2_leaf_tail_t *ltp)
 /*
  * Convert dataptr to byte in file space
  */
-#define XFS_DIR2_DATAPTR_TO_BYTE(mp,dp) xfs_dir2_dataptr_to_byte(mp, dp)
 static inline xfs_dir2_off_t
 xfs_dir2_dataptr_to_byte(struct xfs_mount *mp, xfs_dir2_dataptr_t dp)
 {
@@ -124,7 +120,6 @@ xfs_dir2_dataptr_to_byte(struct xfs_mount *mp, xfs_dir2_dataptr_t dp)
 /*
  * Convert byte in file space to dataptr.  It had better be aligned.
  */
-#define XFS_DIR2_BYTE_TO_DATAPTR(mp,by) xfs_dir2_byte_to_dataptr(mp,by)
 static inline xfs_dir2_dataptr_t
 xfs_dir2_byte_to_dataptr(struct xfs_mount *mp, xfs_dir2_off_t by)
 {
@@ -134,7 +129,6 @@ xfs_dir2_byte_to_dataptr(struct xfs_mount *mp, xfs_dir2_off_t by)
 /*
  * Convert byte in space to (DB) block
  */
-#define XFS_DIR2_BYTE_TO_DB(mp,by)      xfs_dir2_byte_to_db(mp, by)
 static inline xfs_dir2_db_t
 xfs_dir2_byte_to_db(struct xfs_mount *mp, xfs_dir2_off_t by)
 {
@@ -145,17 +139,15 @@ xfs_dir2_byte_to_db(struct xfs_mount *mp, xfs_dir2_off_t by)
 /*
  * Convert dataptr to a block number
  */
-#define XFS_DIR2_DATAPTR_TO_DB(mp,dp)   xfs_dir2_dataptr_to_db(mp, dp)
 static inline xfs_dir2_db_t
 xfs_dir2_dataptr_to_db(struct xfs_mount *mp, xfs_dir2_dataptr_t dp)
 {
-        return XFS_DIR2_BYTE_TO_DB(mp, XFS_DIR2_DATAPTR_TO_BYTE(mp, dp));
+        return xfs_dir2_byte_to_db(mp, xfs_dir2_dataptr_to_byte(mp, dp));
 }
 
 /*
  * Convert byte in space to offset in a block
  */
-#define XFS_DIR2_BYTE_TO_OFF(mp,by)     xfs_dir2_byte_to_off(mp, by)
 static inline xfs_dir2_data_aoff_t
 xfs_dir2_byte_to_off(struct xfs_mount *mp, xfs_dir2_off_t by)
 {
@@ -166,18 +158,15 @@ xfs_dir2_byte_to_off(struct xfs_mount *mp, xfs_dir2_off_t by)
 /*
  * Convert dataptr to a byte offset in a block
  */
-#define XFS_DIR2_DATAPTR_TO_OFF(mp,dp)  xfs_dir2_dataptr_to_off(mp, dp)
 static inline xfs_dir2_data_aoff_t
 xfs_dir2_dataptr_to_off(struct xfs_mount *mp, xfs_dir2_dataptr_t dp)
 {
-        return XFS_DIR2_BYTE_TO_OFF(mp, XFS_DIR2_DATAPTR_TO_BYTE(mp, dp));
+        return xfs_dir2_byte_to_off(mp, xfs_dir2_dataptr_to_byte(mp, dp));
 }
 
 /*
  * Convert block and offset to byte in space
  */
-#define XFS_DIR2_DB_OFF_TO_BYTE(mp,db,o)        \
-        xfs_dir2_db_off_to_byte(mp, db, o)
 static inline xfs_dir2_off_t
 xfs_dir2_db_off_to_byte(struct xfs_mount *mp, xfs_dir2_db_t db,
                         xfs_dir2_data_aoff_t o)
@@ -189,7 +178,6 @@ xfs_dir2_db_off_to_byte(struct xfs_mount *mp, xfs_dir2_db_t db,
 /*
  * Convert block (DB) to block (dablk)
  */
-#define XFS_DIR2_DB_TO_DA(mp,db)        xfs_dir2_db_to_da(mp, db)
 static inline xfs_dablk_t
 xfs_dir2_db_to_da(struct xfs_mount *mp, xfs_dir2_db_t db)
 {
@@ -199,29 +187,25 @@ xfs_dir2_db_to_da(struct xfs_mount *mp, xfs_dir2_db_t db)
 /*
  * Convert byte in space to (DA) block
  */
-#define XFS_DIR2_BYTE_TO_DA(mp,by)      xfs_dir2_byte_to_da(mp, by)
 static inline xfs_dablk_t
 xfs_dir2_byte_to_da(struct xfs_mount *mp, xfs_dir2_off_t by)
 {
-        return XFS_DIR2_DB_TO_DA(mp, XFS_DIR2_BYTE_TO_DB(mp, by));
+        return xfs_dir2_db_to_da(mp, xfs_dir2_byte_to_db(mp, by));
 }
 
 /*
  * Convert block and offset to dataptr
  */
-#define XFS_DIR2_DB_OFF_TO_DATAPTR(mp,db,o)     \
-        xfs_dir2_db_off_to_dataptr(mp, db, o)
 static inline xfs_dir2_dataptr_t
 xfs_dir2_db_off_to_dataptr(struct xfs_mount *mp, xfs_dir2_db_t db,
                            xfs_dir2_data_aoff_t o)
 {
-        return XFS_DIR2_BYTE_TO_DATAPTR(mp, XFS_DIR2_DB_OFF_TO_BYTE(mp, db, o));
+        return xfs_dir2_byte_to_dataptr(mp, xfs_dir2_db_off_to_byte(mp, db, o));
 }
 
 /*
  * Convert block (dablk) to block (DB)
  */
-#define XFS_DIR2_DA_TO_DB(mp,da)        xfs_dir2_da_to_db(mp, da)
 static inline xfs_dir2_db_t
 xfs_dir2_da_to_db(struct xfs_mount *mp, xfs_dablk_t da)
 {
@@ -231,11 +215,10 @@ xfs_dir2_da_to_db(struct xfs_mount *mp, xfs_dablk_t da)
 /*
  * Convert block (dablk) to byte offset in space
  */
-#define XFS_DIR2_DA_TO_BYTE(mp,da)      xfs_dir2_da_to_byte(mp, da)
 static inline xfs_dir2_off_t
 xfs_dir2_da_to_byte(struct xfs_mount *mp, xfs_dablk_t da)
 {
-        return XFS_DIR2_DB_OFF_TO_BYTE(mp, XFS_DIR2_DA_TO_DB(mp, da), 0);
+        return xfs_dir2_db_off_to_byte(mp, xfs_dir2_da_to_db(mp, da), 0);
 }
 
 /*
diff --git a/fs/xfs/xfs_dir2_node.c b/fs/xfs/xfs_dir2_node.c
index d083c381993..91c61d9632c 100644
--- a/fs/xfs/xfs_dir2_node.c
+++ b/fs/xfs/xfs_dir2_node.c
@@ -136,14 +136,14 @@ xfs_dir2_leaf_to_node(
         /*
          * Get the buffer for the new freespace block.
          */
-        if ((error = xfs_da_get_buf(tp, dp, XFS_DIR2_DB_TO_DA(mp, fdb), -1, &fbp,
+        if ((error = xfs_da_get_buf(tp, dp, xfs_dir2_db_to_da(mp, fdb), -1, &fbp,
                         XFS_DATA_FORK))) {
                 return error;
         }
         ASSERT(fbp != NULL);
         free = fbp->data;
         leaf = lbp->data;
-        ltp = XFS_DIR2_LEAF_TAIL_P(mp, leaf);
+        ltp = xfs_dir2_leaf_tail_p(mp, leaf);
         /*
          * Initialize the freespace block header.
          */
@@ -155,7 +155,7 @@ xfs_dir2_leaf_to_node(
          * Copy freespace entries from the leaf block to the new block.
          * Count active entries.
          */
-        for (i = n = 0, from = XFS_DIR2_LEAF_BESTS_P(ltp), to = free->bests;
+        for (i = n = 0, from = xfs_dir2_leaf_bests_p(ltp), to = free->bests;
              i < be32_to_cpu(ltp->bestcount); i++, from++, to++) {
                 if ((off = be16_to_cpu(*from)) != NULLDATAOFF)
                         n++;
@@ -215,7 +215,7 @@ xfs_dir2_leafn_add(
          * a compact.
          */
 
-        if (be16_to_cpu(leaf->hdr.count) == XFS_DIR2_MAX_LEAF_ENTS(mp)) {
+        if (be16_to_cpu(leaf->hdr.count) == xfs_dir2_max_leaf_ents(mp)) {
                 if (!leaf->hdr.stale)
                         return XFS_ERROR(ENOSPC);
                 compact = be16_to_cpu(leaf->hdr.stale) > 1;
@@ -327,7 +327,7 @@ xfs_dir2_leafn_add(
          * Insert the new entry, log everything.
          */
         lep->hashval = cpu_to_be32(args->hashval);
-        lep->address = cpu_to_be32(XFS_DIR2_DB_OFF_TO_DATAPTR(mp,
+        lep->address = cpu_to_be32(xfs_dir2_db_off_to_dataptr(mp,
                                 args->blkno, args->index));
         xfs_dir2_leaf_log_header(tp, bp);
         xfs_dir2_leaf_log_ents(tp, bp, lfloglow, lfloghigh);
@@ -352,7 +352,7 @@ xfs_dir2_leafn_check(
         leaf = bp->data;
         mp = dp->i_mount;
         ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR2_LEAFN_MAGIC);
-        ASSERT(be16_to_cpu(leaf->hdr.count) <= XFS_DIR2_MAX_LEAF_ENTS(mp));
+        ASSERT(be16_to_cpu(leaf->hdr.count) <= xfs_dir2_max_leaf_ents(mp));
         for (i = stale = 0; i < be16_to_cpu(leaf->hdr.count); i++) {
                 if (i + 1 < be16_to_cpu(leaf->hdr.count)) {
                         ASSERT(be32_to_cpu(leaf->ents[i].hashval) <=
@@ -440,7 +440,7 @@ xfs_dir2_leafn_lookup_int(
         if (args->addname) {
                 curfdb = curbp ? state->extrablk.blkno : -1;
                 curdb = -1;
-                length = XFS_DIR2_DATA_ENTSIZE(args->namelen);
+                length = xfs_dir2_data_entsize(args->namelen);
                 if ((free = (curbp ? curbp->data : NULL)))
                         ASSERT(be32_to_cpu(free->hdr.magic) == XFS_DIR2_FREE_MAGIC);
         }
@@ -465,7 +465,7 @@ xfs_dir2_leafn_lookup_int(
                 /*
                  * Pull the data block number from the entry.
                  */
-                newdb = XFS_DIR2_DATAPTR_TO_DB(mp, be32_to_cpu(lep->address));
+                newdb = xfs_dir2_dataptr_to_db(mp, be32_to_cpu(lep->address));
                 /*
                  * For addname, we're looking for a place to put the new entry.
                  * We want to use a data block with an entry of equal
@@ -482,7 +482,7 @@ xfs_dir2_leafn_lookup_int(
                                  * Convert the data block to the free block
                                  * holding its freespace information.
                                  */
-                                newfdb = XFS_DIR2_DB_TO_FDB(mp, newdb);
+                                newfdb = xfs_dir2_db_to_fdb(mp, newdb);
                                 /*
                                  * If it's not the one we have in hand,
                                  * read it in.
@@ -497,7 +497,7 @@ xfs_dir2_leafn_lookup_int(
                                          * Read the free block.
                                          */
                                         if ((error = xfs_da_read_buf(tp, dp,
-                                                        XFS_DIR2_DB_TO_DA(mp,
+                                                        xfs_dir2_db_to_da(mp,
                                                                 newfdb),
                                                         -1, &curbp,
                                                         XFS_DATA_FORK))) {
@@ -517,7 +517,7 @@ xfs_dir2_leafn_lookup_int(
                                 /*
                                  * Get the index for our entry.
                                  */
-                                fi = XFS_DIR2_DB_TO_FDINDEX(mp, curdb);
+                                fi = xfs_dir2_db_to_fdindex(mp, curdb);
                                 /*
                                  * If it has room, return it.
                                  */
@@ -561,7 +561,7 @@ xfs_dir2_leafn_lookup_int(
                                  */
                                 if ((error =
                                     xfs_da_read_buf(tp, dp,
-                                            XFS_DIR2_DB_TO_DA(mp, newdb), -1,
+                                            xfs_dir2_db_to_da(mp, newdb), -1,
                                             &curbp, XFS_DATA_FORK))) {
                                         return error;
                                 }
@@ -573,7 +573,7 @@ xfs_dir2_leafn_lookup_int(
                          */
                         dep = (xfs_dir2_data_entry_t *)
                               ((char *)curbp->data +
-                               XFS_DIR2_DATAPTR_TO_OFF(mp, be32_to_cpu(lep->address)));
+                               xfs_dir2_dataptr_to_off(mp, be32_to_cpu(lep->address)));
                         /*
                          * Compare the entry, return it if it matches.
                          */
@@ -876,9 +876,9 @@ xfs_dir2_leafn_remove(
         /*
          * Extract the data block and offset from the entry.
          */
-        db = XFS_DIR2_DATAPTR_TO_DB(mp, be32_to_cpu(lep->address));
+        db = xfs_dir2_dataptr_to_db(mp, be32_to_cpu(lep->address));
         ASSERT(dblk->blkno == db);
-        off = XFS_DIR2_DATAPTR_TO_OFF(mp, be32_to_cpu(lep->address));
+        off = xfs_dir2_dataptr_to_off(mp, be32_to_cpu(lep->address));
         ASSERT(dblk->index == off);
         /*
          * Kill the leaf entry by marking it stale.
@@ -898,7 +898,7 @@ xfs_dir2_leafn_remove(
         longest = be16_to_cpu(data->hdr.bestfree[0].length);
         needlog = needscan = 0;
         xfs_dir2_data_make_free(tp, dbp, off,
-                XFS_DIR2_DATA_ENTSIZE(dep->namelen), &needlog, &needscan);
+                xfs_dir2_data_entsize(dep->namelen), &needlog, &needscan);
         /*
          * Rescan the data block freespaces for bestfree.
          * Log the data block header if needed.
@@ -924,8 +924,8 @@ xfs_dir2_leafn_remove(
                  * Convert the data block number to a free block,
                  * read in the free block.
                  */
-                fdb = XFS_DIR2_DB_TO_FDB(mp, db);
-                if ((error = xfs_da_read_buf(tp, dp, XFS_DIR2_DB_TO_DA(mp, fdb),
+                fdb = xfs_dir2_db_to_fdb(mp, db);
+                if ((error = xfs_da_read_buf(tp, dp, xfs_dir2_db_to_da(mp, fdb),
                                 -1, &fbp, XFS_DATA_FORK))) {
                         return error;
                 }
@@ -937,7 +937,7 @@ xfs_dir2_leafn_remove(
                 /*
                  * Calculate which entry we need to fix.
                  */
-                findex = XFS_DIR2_DB_TO_FDINDEX(mp, db);
+                findex = xfs_dir2_db_to_fdindex(mp, db);
                 longest = be16_to_cpu(data->hdr.bestfree[0].length);
                 /*
                  * If the data block is now empty we can get rid of it
@@ -1073,7 +1073,7 @@ xfs_dir2_leafn_split(
         /*
          * Initialize the new leaf block.
          */
-        error = xfs_dir2_leaf_init(args, XFS_DIR2_DA_TO_DB(mp, blkno),
+        error = xfs_dir2_leaf_init(args, xfs_dir2_da_to_db(mp, blkno),
                 &newblk->bp, XFS_DIR2_LEAFN_MAGIC);
         if (error) {
                 return error;
@@ -1385,7 +1385,7 @@ xfs_dir2_node_addname_int(
         dp = args->dp;
         mp = dp->i_mount;
         tp = args->trans;
-        length = XFS_DIR2_DATA_ENTSIZE(args->namelen);
+        length = xfs_dir2_data_entsize(args->namelen);
         /*
          * If we came in with a freespace block that means that lookup
          * found an entry with our hash value.  This is the freespace
@@ -1438,7 +1438,7 @@ xfs_dir2_node_addname_int(
 
                 if ((error = xfs_bmap_last_offset(tp, dp, &fo, XFS_DATA_FORK)))
                         return error;
-                lastfbno = XFS_DIR2_DA_TO_DB(mp, (xfs_dablk_t)fo);
+                lastfbno = xfs_dir2_da_to_db(mp, (xfs_dablk_t)fo);
                 fbno = ifbno;
         }
         /*
@@ -1474,7 +1474,7 @@ xfs_dir2_node_addname_int(
                          * to avoid it.
                          */
                         if ((error = xfs_da_read_buf(tp, dp,
-                                        XFS_DIR2_DB_TO_DA(mp, fbno), -2, &fbp,
+                                        xfs_dir2_db_to_da(mp, fbno), -2, &fbp,
                                         XFS_DATA_FORK))) {
                                 return error;
                         }
@@ -1550,9 +1550,9 @@ xfs_dir2_node_addname_int(
                  * Get the freespace block corresponding to the data block
                  * that was just allocated.
                  */
-                fbno = XFS_DIR2_DB_TO_FDB(mp, dbno);
+                fbno = xfs_dir2_db_to_fdb(mp, dbno);
                 if (unlikely(error = xfs_da_read_buf(tp, dp,
-                                XFS_DIR2_DB_TO_DA(mp, fbno), -2, &fbp,
+                                xfs_dir2_db_to_da(mp, fbno), -2, &fbp,
                                 XFS_DATA_FORK))) {
                         xfs_da_buf_done(dbp);
                         return error;
@@ -1567,14 +1567,14 @@ xfs_dir2_node_addname_int(
                                 return error;
                         }
 
-                        if (unlikely(XFS_DIR2_DB_TO_FDB(mp, dbno) != fbno)) {
+                        if (unlikely(xfs_dir2_db_to_fdb(mp, dbno) != fbno)) {
                                 cmn_err(CE_ALERT,
                                         "xfs_dir2_node_addname_int: dir ino "
                                         "%llu needed freesp block %lld for\n"
                                         "  data block %lld, got %lld\n"
                                         "  ifbno %llu lastfbno %d\n",
                                         (unsigned long long)dp->i_ino,
-                                        (long long)XFS_DIR2_DB_TO_FDB(mp, dbno),
+                                        (long long)xfs_dir2_db_to_fdb(mp, dbno),
                                         (long long)dbno, (long long)fbno,
                                         (unsigned long long)ifbno, lastfbno);
                                 if (fblk) {
@@ -1598,7 +1598,7 @@ xfs_dir2_node_addname_int(
                          * Get a buffer for the new block.
                          */
                         if ((error = xfs_da_get_buf(tp, dp,
-                                                   XFS_DIR2_DB_TO_DA(mp, fbno),
+                                                   xfs_dir2_db_to_da(mp, fbno),
                                                    -1, &fbp, XFS_DATA_FORK))) {
                                 return error;
                         }
@@ -1623,7 +1623,7 @@ xfs_dir2_node_addname_int(
                 /*
                  * Set the freespace block index from the data block number.
                  */
-                findex = XFS_DIR2_DB_TO_FDINDEX(mp, dbno);
+                findex = xfs_dir2_db_to_fdindex(mp, dbno);
                 /*
                  * If it's after the end of the current entries in the
                  * freespace block, extend that table.
@@ -1669,7 +1669,7 @@ xfs_dir2_node_addname_int(
                  * Read the data block in.
                  */
                 if (unlikely(
-                    error = xfs_da_read_buf(tp, dp, XFS_DIR2_DB_TO_DA(mp, dbno),
+                    error = xfs_da_read_buf(tp, dp, xfs_dir2_db_to_da(mp, dbno),
                                 -1, &dbp, XFS_DATA_FORK))) {
                         if ((fblk == NULL || fblk->bp == NULL) && fbp != NULL)
                                 xfs_da_buf_done(fbp);
@@ -1698,7 +1698,7 @@ xfs_dir2_node_addname_int(
         dep->inumber = cpu_to_be64(args->inumber);
         dep->namelen = args->namelen;
         memcpy(dep->name, args->name, dep->namelen);
-        tagp = XFS_DIR2_DATA_ENTRY_TAG_P(dep);
+        tagp = xfs_dir2_data_entry_tag_p(dep);
         *tagp = cpu_to_be16((char *)dep - (char *)data);
         xfs_dir2_data_log_entry(tp, dbp, dep);
         /*
@@ -1904,7 +1904,7 @@ xfs_dir2_node_replace(
                 ASSERT(be32_to_cpu(data->hdr.magic) == XFS_DIR2_DATA_MAGIC);
                 dep = (xfs_dir2_data_entry_t *)
                       ((char *)data +
-                       XFS_DIR2_DATAPTR_TO_OFF(state->mp, be32_to_cpu(lep->address)));
+                       xfs_dir2_dataptr_to_off(state->mp, be32_to_cpu(lep->address)));
                 ASSERT(inum != be64_to_cpu(dep->inumber));
                 /*
                  * Fill in the new inode number and log the entry.
@@ -1980,7 +1980,7 @@ xfs_dir2_node_trim_free(
          * Blow the block away.
          */
         if ((error =
-            xfs_dir2_shrink_inode(args, XFS_DIR2_DA_TO_DB(mp, (xfs_dablk_t)fo),
+            xfs_dir2_shrink_inode(args, xfs_dir2_da_to_db(mp, (xfs_dablk_t)fo),
                     bp))) {
                 /*
                  * Can't fail with ENOSPC since that only happens with no
diff --git a/fs/xfs/xfs_dir2_node.h b/fs/xfs/xfs_dir2_node.h
index c7c870ee785..dde72db3d69 100644
--- a/fs/xfs/xfs_dir2_node.h
+++ b/fs/xfs/xfs_dir2_node.h
@@ -36,7 +36,7 @@ struct xfs_trans;
 #define XFS_DIR2_FREE_SPACE     2
 #define XFS_DIR2_FREE_OFFSET    (XFS_DIR2_FREE_SPACE * XFS_DIR2_SPACE_SIZE)
 #define XFS_DIR2_FREE_FIRSTDB(mp)       \
-        XFS_DIR2_BYTE_TO_DB(mp, XFS_DIR2_FREE_OFFSET)
+        xfs_dir2_byte_to_db(mp, XFS_DIR2_FREE_OFFSET)
 
 #define XFS_DIR2_FREE_MAGIC     0x58443246      /* XD2F */
 
@@ -60,7 +60,6 @@ typedef struct xfs_dir2_free {
 /*
  * Convert data space db to the corresponding free db.
  */
-#define XFS_DIR2_DB_TO_FDB(mp,db)       xfs_dir2_db_to_fdb(mp, db)
 static inline xfs_dir2_db_t
 xfs_dir2_db_to_fdb(struct xfs_mount *mp, xfs_dir2_db_t db)
 {
@@ -70,7 +69,6 @@ xfs_dir2_db_to_fdb(struct xfs_mount *mp, xfs_dir2_db_t db)
 /*
  * Convert data space db to the corresponding index in a free db.
  */
-#define XFS_DIR2_DB_TO_FDINDEX(mp,db)   xfs_dir2_db_to_fdindex(mp, db)
 static inline int
 xfs_dir2_db_to_fdindex(struct xfs_mount *mp, xfs_dir2_db_t db)
 {
diff --git a/fs/xfs/xfs_dir2_sf.c b/fs/xfs/xfs_dir2_sf.c
index 0cd77b17bf9..38fc4f22b76 100644
--- a/fs/xfs/xfs_dir2_sf.c
+++ b/fs/xfs/xfs_dir2_sf.c
@@ -89,8 +89,8 @@ xfs_dir2_block_sfsize(
         mp = dp->i_mount;
 
         count = i8count = namelen = 0;
-        btp = XFS_DIR2_BLOCK_TAIL_P(mp, block);
-        blp = XFS_DIR2_BLOCK_LEAF_P(btp);
+        btp = xfs_dir2_block_tail_p(mp, block);
+        blp = xfs_dir2_block_leaf_p(btp);
 
         /*
          * Iterate over the block's data entries by using the leaf pointers.
@@ -102,7 +102,7 @@ xfs_dir2_block_sfsize(
                  * Calculate the pointer to the entry at hand.
                  */
                 dep = (xfs_dir2_data_entry_t *)
-                      ((char *)block + XFS_DIR2_DATAPTR_TO_OFF(mp, addr));
+                      ((char *)block + xfs_dir2_dataptr_to_off(mp, addr));
                 /*
                  * Detect . and .., so we can special-case them.
                  * . is not included in sf directories.
@@ -124,7 +124,7 @@ xfs_dir2_block_sfsize(
                 /*
                  * Calculate the new size, see if we should give up yet.
                  */
-                size = XFS_DIR2_SF_HDR_SIZE(i8count) +          /* header */
+                size = xfs_dir2_sf_hdr_size(i8count) +          /* header */
                        count +                                  /* namelen */
                        count * (uint)sizeof(xfs_dir2_sf_off_t) + /* offset */
                        namelen +                                /* name */
@@ -139,7 +139,7 @@ xfs_dir2_block_sfsize(
          */
         sfhp->count = count;
         sfhp->i8count = i8count;
-        XFS_DIR2_SF_PUT_INUMBER((xfs_dir2_sf_t *)sfhp, &parent, &sfhp->parent);
+        xfs_dir2_sf_put_inumber((xfs_dir2_sf_t *)sfhp, &parent, &sfhp->parent);
         return size;
 }
 
@@ -199,15 +199,15 @@ xfs_dir2_block_to_sf(
          * Copy the header into the newly allocate local space.
          */
         sfp = (xfs_dir2_sf_t *)dp->i_df.if_u1.if_data;
-        memcpy(sfp, sfhp, XFS_DIR2_SF_HDR_SIZE(sfhp->i8count));
+        memcpy(sfp, sfhp, xfs_dir2_sf_hdr_size(sfhp->i8count));
         dp->i_d.di_size = size;
         /*
          * Set up to loop over the block's entries.
          */
-        btp = XFS_DIR2_BLOCK_TAIL_P(mp, block);
+        btp = xfs_dir2_block_tail_p(mp, block);
         ptr = (char *)block->u;
-        endptr = (char *)XFS_DIR2_BLOCK_LEAF_P(btp);
-        sfep = XFS_DIR2_SF_FIRSTENTRY(sfp);
+        endptr = (char *)xfs_dir2_block_leaf_p(btp);
+        sfep = xfs_dir2_sf_firstentry(sfp);
         /*
          * Loop over the active and unused entries.
          * Stop when we reach the leaf/tail portion of the block.
@@ -233,22 +233,22 @@ xfs_dir2_block_to_sf(
                 else if (dep->namelen == 2 &&
                          dep->name[0] == '.' && dep->name[1] == '.')
                         ASSERT(be64_to_cpu(dep->inumber) ==
-                               XFS_DIR2_SF_GET_INUMBER(sfp, &sfp->hdr.parent));
+                               xfs_dir2_sf_get_inumber(sfp, &sfp->hdr.parent));
                 /*
                  * Normal entry, copy it into shortform.
                  */
                 else {
                         sfep->namelen = dep->namelen;
-                        XFS_DIR2_SF_PUT_OFFSET(sfep,
+                        xfs_dir2_sf_put_offset(sfep,
                                 (xfs_dir2_data_aoff_t)
                                 ((char *)dep - (char *)block));
                         memcpy(sfep->name, dep->name, dep->namelen);
                         temp = be64_to_cpu(dep->inumber);
-                        XFS_DIR2_SF_PUT_INUMBER(sfp, &temp,
-                                XFS_DIR2_SF_INUMBERP(sfep));
-                        sfep = XFS_DIR2_SF_NEXTENTRY(sfp, sfep);
+                        xfs_dir2_sf_put_inumber(sfp, &temp,
+                                xfs_dir2_sf_inumberp(sfep));
+                        sfep = xfs_dir2_sf_nextentry(sfp, sfep);
                 }
-                ptr += XFS_DIR2_DATA_ENTSIZE(dep->namelen);
+                ptr += xfs_dir2_data_entsize(dep->namelen);
         }
         ASSERT((char *)sfep - (char *)sfp == size);
         xfs_dir2_sf_check(args);
@@ -294,11 +294,11 @@ xfs_dir2_sf_addname(
         ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
         ASSERT(dp->i_df.if_u1.if_data != NULL);
         sfp = (xfs_dir2_sf_t *)dp->i_df.if_u1.if_data;
-        ASSERT(dp->i_d.di_size >= XFS_DIR2_SF_HDR_SIZE(sfp->hdr.i8count));
+        ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(sfp->hdr.i8count));
         /*
          * Compute entry (and change in) size.
          */
-        add_entsize = XFS_DIR2_SF_ENTSIZE_BYNAME(sfp, args->namelen);
+        add_entsize = xfs_dir2_sf_entsize_byname(sfp, args->namelen);
         incr_isize = add_entsize;
         objchange = 0;
 #if XFS_BIG_INUMS
@@ -392,7 +392,7 @@ xfs_dir2_sf_addname_easy(
         /*
          * Grow the in-inode space.
          */
-        xfs_idata_realloc(dp, XFS_DIR2_SF_ENTSIZE_BYNAME(sfp, args->namelen),
+        xfs_idata_realloc(dp, xfs_dir2_sf_entsize_byname(sfp, args->namelen),
                 XFS_DATA_FORK);
         /*
          * Need to set up again due to realloc of the inode data.
@@ -403,10 +403,10 @@ xfs_dir2_sf_addname_easy(
          * Fill in the new entry.
          */
         sfep->namelen = args->namelen;
-        XFS_DIR2_SF_PUT_OFFSET(sfep, offset);
+        xfs_dir2_sf_put_offset(sfep, offset);
         memcpy(sfep->name, args->name, sfep->namelen);
-        XFS_DIR2_SF_PUT_INUMBER(sfp, &args->inumber,
-                XFS_DIR2_SF_INUMBERP(sfep));
+        xfs_dir2_sf_put_inumber(sfp, &args->inumber,
+                xfs_dir2_sf_inumberp(sfep));
         /*
          * Update the header and inode.
          */
@@ -463,14 +463,14 @@ xfs_dir2_sf_addname_hard(
          * If it's going to end up at the end then oldsfep will point there.
          */
         for (offset = XFS_DIR2_DATA_FIRST_OFFSET,
-              oldsfep = XFS_DIR2_SF_FIRSTENTRY(oldsfp),
-              add_datasize = XFS_DIR2_DATA_ENTSIZE(args->namelen),
+              oldsfep = xfs_dir2_sf_firstentry(oldsfp),
+              add_datasize = xfs_dir2_data_entsize(args->namelen),
               eof = (char *)oldsfep == &buf[old_isize];
              !eof;
-             offset = new_offset + XFS_DIR2_DATA_ENTSIZE(oldsfep->namelen),
-              oldsfep = XFS_DIR2_SF_NEXTENTRY(oldsfp, oldsfep),
+             offset = new_offset + xfs_dir2_data_entsize(oldsfep->namelen),
+              oldsfep = xfs_dir2_sf_nextentry(oldsfp, oldsfep),
               eof = (char *)oldsfep == &buf[old_isize]) {
-                new_offset = XFS_DIR2_SF_GET_OFFSET(oldsfep);
+                new_offset = xfs_dir2_sf_get_offset(oldsfep);
                 if (offset + add_datasize <= new_offset)
                         break;
         }
@@ -495,10 +495,10 @@ xfs_dir2_sf_addname_hard(
          * Fill in the new entry, and update the header counts.
          */
         sfep->namelen = args->namelen;
-        XFS_DIR2_SF_PUT_OFFSET(sfep, offset);
+        xfs_dir2_sf_put_offset(sfep, offset);
         memcpy(sfep->name, args->name, sfep->namelen);
-        XFS_DIR2_SF_PUT_INUMBER(sfp, &args->inumber,
-                XFS_DIR2_SF_INUMBERP(sfep));
+        xfs_dir2_sf_put_inumber(sfp, &args->inumber,
+                xfs_dir2_sf_inumberp(sfep));
         sfp->hdr.count++;
 #if XFS_BIG_INUMS
         if (args->inumber > XFS_DIR2_MAX_SHORT_INUM && !objchange)
@@ -508,7 +508,7 @@ xfs_dir2_sf_addname_hard(
          * If there's more left to copy, do that.
          */
         if (!eof) {
-                sfep = XFS_DIR2_SF_NEXTENTRY(sfp, sfep);
+                sfep = xfs_dir2_sf_nextentry(sfp, sfep);
                 memcpy(sfep, oldsfep, old_isize - nbytes);
         }
         kmem_free(buf, old_isize);
@@ -544,9 +544,9 @@ xfs_dir2_sf_addname_pick(
         mp = dp->i_mount;
 
         sfp = (xfs_dir2_sf_t *)dp->i_df.if_u1.if_data;
-        size = XFS_DIR2_DATA_ENTSIZE(args->namelen);
+        size = xfs_dir2_data_entsize(args->namelen);
         offset = XFS_DIR2_DATA_FIRST_OFFSET;
-        sfep = XFS_DIR2_SF_FIRSTENTRY(sfp);
+        sfep = xfs_dir2_sf_firstentry(sfp);
         holefit = 0;
         /*
          * Loop over sf entries.
@@ -555,10 +555,10 @@ xfs_dir2_sf_addname_pick(
          */
         for (i = 0; i < sfp->hdr.count; i++) {
                 if (!holefit)
-                        holefit = offset + size <= XFS_DIR2_SF_GET_OFFSET(sfep);
-                offset = XFS_DIR2_SF_GET_OFFSET(sfep) +
-                         XFS_DIR2_DATA_ENTSIZE(sfep->namelen);
-                sfep = XFS_DIR2_SF_NEXTENTRY(sfp, sfep);
+                        holefit = offset + size <= xfs_dir2_sf_get_offset(sfep);
+                offset = xfs_dir2_sf_get_offset(sfep) +
+                         xfs_dir2_data_entsize(sfep->namelen);
+                sfep = xfs_dir2_sf_nextentry(sfp, sfep);
         }
         /*
          * Calculate data bytes used excluding the new entry, if this
@@ -617,18 +617,18 @@ xfs_dir2_sf_check(
 
         sfp = (xfs_dir2_sf_t *)dp->i_df.if_u1.if_data;
         offset = XFS_DIR2_DATA_FIRST_OFFSET;
-        ino = XFS_DIR2_SF_GET_INUMBER(sfp, &sfp->hdr.parent);
+        ino = xfs_dir2_sf_get_inumber(sfp, &sfp->hdr.parent);
         i8count = ino > XFS_DIR2_MAX_SHORT_INUM;
 
-        for (i = 0, sfep = XFS_DIR2_SF_FIRSTENTRY(sfp);
+        for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp);
              i < sfp->hdr.count;
-             i++, sfep = XFS_DIR2_SF_NEXTENTRY(sfp, sfep)) {
-                ASSERT(XFS_DIR2_SF_GET_OFFSET(sfep) >= offset);
-                ino = XFS_DIR2_SF_GET_INUMBER(sfp, XFS_DIR2_SF_INUMBERP(sfep));
+             i++, sfep = xfs_dir2_sf_nextentry(sfp, sfep)) {
+                ASSERT(xfs_dir2_sf_get_offset(sfep) >= offset);
+                ino = xfs_dir2_sf_get_inumber(sfp, xfs_dir2_sf_inumberp(sfep));
                 i8count += ino > XFS_DIR2_MAX_SHORT_INUM;
                 offset =
-                        XFS_DIR2_SF_GET_OFFSET(sfep) +
-                        XFS_DIR2_DATA_ENTSIZE(sfep->namelen);
+                        xfs_dir2_sf_get_offset(sfep) +
+                        xfs_dir2_data_entsize(sfep->namelen);
         }
         ASSERT(i8count == sfp->hdr.i8count);
         ASSERT(XFS_BIG_INUMS || i8count == 0);
@@ -671,7 +671,7 @@ xfs_dir2_sf_create(
         ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
         ASSERT(dp->i_df.if_bytes == 0);
         i8count = pino > XFS_DIR2_MAX_SHORT_INUM;
-        size = XFS_DIR2_SF_HDR_SIZE(i8count);
+        size = xfs_dir2_sf_hdr_size(i8count);
         /*
          * Make a buffer for the data.
          */
@@ -684,7 +684,7 @@ xfs_dir2_sf_create(
         /*
          * Now can put in the inode number, since i8count is set.
          */
-        XFS_DIR2_SF_PUT_INUMBER(sfp, &pino, &sfp->hdr.parent);
+        xfs_dir2_sf_put_inumber(sfp, &pino, &sfp->hdr.parent);
         sfp->hdr.count = 0;
         dp->i_d.di_size = size;
         xfs_dir2_sf_check(args);
@@ -727,12 +727,12 @@ xfs_dir2_sf_getdents(
 
         sfp = (xfs_dir2_sf_t *)dp->i_df.if_u1.if_data;
 
-        ASSERT(dp->i_d.di_size >= XFS_DIR2_SF_HDR_SIZE(sfp->hdr.i8count));
+        ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(sfp->hdr.i8count));
 
         /*
          * If the block number in the offset is out of range, we're done.
          */
-        if (XFS_DIR2_DATAPTR_TO_DB(mp, dir_offset) > mp->m_dirdatablk) {
+        if (xfs_dir2_dataptr_to_db(mp, dir_offset) > mp->m_dirdatablk) {
                 *eofp = 1;
                 return 0;
         }
@@ -747,9 +747,9 @@ xfs_dir2_sf_getdents(
          * Put . entry unless we're starting past it.
          */
         if (dir_offset <=
-                    XFS_DIR2_DB_OFF_TO_DATAPTR(mp, mp->m_dirdatablk,
+                    xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
                                                XFS_DIR2_DATA_DOT_OFFSET)) {
-                p.cook = XFS_DIR2_DB_OFF_TO_DATAPTR(mp, 0,
+                p.cook = xfs_dir2_db_off_to_dataptr(mp, 0,
                                                 XFS_DIR2_DATA_DOTDOT_OFFSET);
                 p.ino = dp->i_ino;
 #if XFS_BIG_INUMS
@@ -762,7 +762,7 @@ xfs_dir2_sf_getdents(
 
                 if (!p.done) {
                         uio->uio_offset =
-                                XFS_DIR2_DB_OFF_TO_DATAPTR(mp, mp->m_dirdatablk,
+                                xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
                                                 XFS_DIR2_DATA_DOT_OFFSET);
                         return error;
                 }
@@ -772,11 +772,11 @@ xfs_dir2_sf_getdents(
          * Put .. entry unless we're starting past it.
          */
         if (dir_offset <=
-                    XFS_DIR2_DB_OFF_TO_DATAPTR(mp, mp->m_dirdatablk,
+                    xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
                                                XFS_DIR2_DATA_DOTDOT_OFFSET)) {
-                p.cook = XFS_DIR2_DB_OFF_TO_DATAPTR(mp, mp->m_dirdatablk,
+                p.cook = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
                                                 XFS_DIR2_DATA_FIRST_OFFSET);
-                p.ino = XFS_DIR2_SF_GET_INUMBER(sfp, &sfp->hdr.parent);
+                p.ino = xfs_dir2_sf_get_inumber(sfp, &sfp->hdr.parent);
 #if XFS_BIG_INUMS
                 p.ino += mp->m_inoadd;
 #endif
@@ -787,7 +787,7 @@ xfs_dir2_sf_getdents(
 
                 if (!p.done) {
                         uio->uio_offset =
-                                XFS_DIR2_DB_OFF_TO_DATAPTR(mp, mp->m_dirdatablk,
+                                xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
                                         XFS_DIR2_DATA_DOTDOT_OFFSET);
                         return error;
                 }
@@ -796,23 +796,23 @@ xfs_dir2_sf_getdents(
         /*
          * Loop while there are more entries and put'ing works.
          */
-        for (i = 0, sfep = XFS_DIR2_SF_FIRSTENTRY(sfp);
+        for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp);
                      i < sfp->hdr.count;
-                             i++, sfep = XFS_DIR2_SF_NEXTENTRY(sfp, sfep)) {
+                             i++, sfep = xfs_dir2_sf_nextentry(sfp, sfep)) {
 
-                off = XFS_DIR2_DB_OFF_TO_DATAPTR(mp, mp->m_dirdatablk,
-                                XFS_DIR2_SF_GET_OFFSET(sfep));
+                off = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
+                                xfs_dir2_sf_get_offset(sfep));
 
                 if (dir_offset > off)
                         continue;
 
                 p.namelen = sfep->namelen;
 
-                p.cook = XFS_DIR2_DB_OFF_TO_DATAPTR(mp, mp->m_dirdatablk,
-                        XFS_DIR2_SF_GET_OFFSET(sfep) +
-                        XFS_DIR2_DATA_ENTSIZE(p.namelen));
+                p.cook = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
+                        xfs_dir2_sf_get_offset(sfep) +
+                        xfs_dir2_data_entsize(p.namelen));
 
-                p.ino = XFS_DIR2_SF_GET_INUMBER(sfp, XFS_DIR2_SF_INUMBERP(sfep));
+                p.ino = xfs_dir2_sf_get_inumber(sfp, xfs_dir2_sf_inumberp(sfep));
 #if XFS_BIG_INUMS
                 p.ino += mp->m_inoadd;
 #endif
@@ -832,7 +832,7 @@ xfs_dir2_sf_getdents(
         *eofp = 1;
 
         uio->uio_offset =
-                XFS_DIR2_DB_OFF_TO_DATAPTR(mp, mp->m_dirdatablk + 1, 0);
+                xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk + 1, 0);
 
         return 0;
 }
@@ -865,7 +865,7 @@ xfs_dir2_sf_lookup(
         ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
         ASSERT(dp->i_df.if_u1.if_data != NULL);
         sfp = (xfs_dir2_sf_t *)dp->i_df.if_u1.if_data;
-        ASSERT(dp->i_d.di_size >= XFS_DIR2_SF_HDR_SIZE(sfp->hdr.i8count));
+        ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(sfp->hdr.i8count));
         /*
          * Special case for .
          */
@@ -878,21 +878,21 @@ xfs_dir2_sf_lookup(
          */
         if (args->namelen == 2 &&
             args->name[0] == '.' && args->name[1] == '.') {
-                args->inumber = XFS_DIR2_SF_GET_INUMBER(sfp, &sfp->hdr.parent);
+                args->inumber = xfs_dir2_sf_get_inumber(sfp, &sfp->hdr.parent);
                 return XFS_ERROR(EEXIST);
         }
         /*
          * Loop over all the entries trying to match ours.
          */
-        for (i = 0, sfep = XFS_DIR2_SF_FIRSTENTRY(sfp);
+        for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp);
              i < sfp->hdr.count;
-             i++, sfep = XFS_DIR2_SF_NEXTENTRY(sfp, sfep)) {
+             i++, sfep = xfs_dir2_sf_nextentry(sfp, sfep)) {
                 if (sfep->namelen == args->namelen &&
                     sfep->name[0] == args->name[0] &&
                     memcmp(args->name, sfep->name, args->namelen) == 0) {
                         args->inumber =
-                                XFS_DIR2_SF_GET_INUMBER(sfp,
-                                        XFS_DIR2_SF_INUMBERP(sfep));
+                                xfs_dir2_sf_get_inumber(sfp,
+                                        xfs_dir2_sf_inumberp(sfep));
                         return XFS_ERROR(EEXIST);
                 }
         }
@@ -934,19 +934,19 @@ xfs_dir2_sf_removename(
         ASSERT(dp->i_df.if_bytes == oldsize);
         ASSERT(dp->i_df.if_u1.if_data != NULL);
         sfp = (xfs_dir2_sf_t *)dp->i_df.if_u1.if_data;
-        ASSERT(oldsize >= XFS_DIR2_SF_HDR_SIZE(sfp->hdr.i8count));
+        ASSERT(oldsize >= xfs_dir2_sf_hdr_size(sfp->hdr.i8count));
         /*
          * Loop over the old directory entries.
          * Find the one we're deleting.
          */
-        for (i = 0, sfep = XFS_DIR2_SF_FIRSTENTRY(sfp);
+        for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp);
              i < sfp->hdr.count;
-             i++, sfep = XFS_DIR2_SF_NEXTENTRY(sfp, sfep)) {
+             i++, sfep = xfs_dir2_sf_nextentry(sfp, sfep)) {
                 if (sfep->namelen == args->namelen &&
                     sfep->name[0] == args->name[0] &&
                     memcmp(sfep->name, args->name, args->namelen) == 0) {
-                        ASSERT(XFS_DIR2_SF_GET_INUMBER(sfp,
-                                        XFS_DIR2_SF_INUMBERP(sfep)) ==
+                        ASSERT(xfs_dir2_sf_get_inumber(sfp,
+                                        xfs_dir2_sf_inumberp(sfep)) ==
                                 args->inumber);
                         break;
                 }
@@ -961,7 +961,7 @@ xfs_dir2_sf_removename(
          * Calculate sizes.
          */
         byteoff = (int)((char *)sfep - (char *)sfp);
-        entsize = XFS_DIR2_SF_ENTSIZE_BYNAME(sfp, args->namelen);
+        entsize = xfs_dir2_sf_entsize_byname(sfp, args->namelen);
         newsize = oldsize - entsize;
         /*
          * Copy the part if any after the removed entry, sliding it down.
@@ -1027,7 +1027,7 @@ xfs_dir2_sf_replace(
         ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
         ASSERT(dp->i_df.if_u1.if_data != NULL);
         sfp = (xfs_dir2_sf_t *)dp->i_df.if_u1.if_data;
-        ASSERT(dp->i_d.di_size >= XFS_DIR2_SF_HDR_SIZE(sfp->hdr.i8count));
+        ASSERT(dp->i_d.di_size >= xfs_dir2_sf_hdr_size(sfp->hdr.i8count));
 #if XFS_BIG_INUMS
         /*
          * New inode number is large, and need to convert to 8-byte inodes.
@@ -1067,28 +1067,28 @@ xfs_dir2_sf_replace(
         if (args->namelen == 2 &&
             args->name[0] == '.' && args->name[1] == '.') {
 #if XFS_BIG_INUMS || defined(DEBUG)
-                ino = XFS_DIR2_SF_GET_INUMBER(sfp, &sfp->hdr.parent);
+                ino = xfs_dir2_sf_get_inumber(sfp, &sfp->hdr.parent);
                 ASSERT(args->inumber != ino);
 #endif
-                XFS_DIR2_SF_PUT_INUMBER(sfp, &args->inumber, &sfp->hdr.parent);
+                xfs_dir2_sf_put_inumber(sfp, &args->inumber, &sfp->hdr.parent);
         }
         /*
          * Normal entry, look for the name.
          */
         else {
-                for (i = 0, sfep = XFS_DIR2_SF_FIRSTENTRY(sfp);
+                for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp);
                      i < sfp->hdr.count;
-                     i++, sfep = XFS_DIR2_SF_NEXTENTRY(sfp, sfep)) {
+                     i++, sfep = xfs_dir2_sf_nextentry(sfp, sfep)) {
                         if (sfep->namelen == args->namelen &&
                             sfep->name[0] == args->name[0] &&
                             memcmp(args->name, sfep->name, args->namelen) == 0) {
 #if XFS_BIG_INUMS || defined(DEBUG)
-                                ino = XFS_DIR2_SF_GET_INUMBER(sfp,
-                                        XFS_DIR2_SF_INUMBERP(sfep));
+                                ino = xfs_dir2_sf_get_inumber(sfp,
+                                        xfs_dir2_sf_inumberp(sfep));
                                 ASSERT(args->inumber != ino);
 #endif
-                                XFS_DIR2_SF_PUT_INUMBER(sfp, &args->inumber,
-                                        XFS_DIR2_SF_INUMBERP(sfep));
+                                xfs_dir2_sf_put_inumber(sfp, &args->inumber,
+                                        xfs_dir2_sf_inumberp(sfep));
                                 break;
                         }
                 }
@@ -1189,22 +1189,22 @@ xfs_dir2_sf_toino4(
          */
         sfp->hdr.count = oldsfp->hdr.count;
         sfp->hdr.i8count = 0;
-        ino = XFS_DIR2_SF_GET_INUMBER(oldsfp, &oldsfp->hdr.parent);
-        XFS_DIR2_SF_PUT_INUMBER(sfp, &ino, &sfp->hdr.parent);
+        ino = xfs_dir2_sf_get_inumber(oldsfp, &oldsfp->hdr.parent);
+        xfs_dir2_sf_put_inumber(sfp, &ino, &sfp->hdr.parent);
         /*
          * Copy the entries field by field.
          */
-        for (i = 0, sfep = XFS_DIR2_SF_FIRSTENTRY(sfp),
-                    oldsfep = XFS_DIR2_SF_FIRSTENTRY(oldsfp);
+        for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp),
+                    oldsfep = xfs_dir2_sf_firstentry(oldsfp);
              i < sfp->hdr.count;
-             i++, sfep = XFS_DIR2_SF_NEXTENTRY(sfp, sfep),
-                  oldsfep = XFS_DIR2_SF_NEXTENTRY(oldsfp, oldsfep)) {
+             i++, sfep = xfs_dir2_sf_nextentry(sfp, sfep),
+                  oldsfep = xfs_dir2_sf_nextentry(oldsfp, oldsfep)) {
                 sfep->namelen = oldsfep->namelen;
                 sfep->offset = oldsfep->offset;
                 memcpy(sfep->name, oldsfep->name, sfep->namelen);
-                ino = XFS_DIR2_SF_GET_INUMBER(oldsfp,
-                        XFS_DIR2_SF_INUMBERP(oldsfep));
-                XFS_DIR2_SF_PUT_INUMBER(sfp, &ino, XFS_DIR2_SF_INUMBERP(sfep));
+                ino = xfs_dir2_sf_get_inumber(oldsfp,
+                        xfs_dir2_sf_inumberp(oldsfep));
+                xfs_dir2_sf_put_inumber(sfp, &ino, xfs_dir2_sf_inumberp(sfep));
         }
         /*
          * Clean up the inode.
@@ -1266,22 +1266,22 @@ xfs_dir2_sf_toino8(
          */
         sfp->hdr.count = oldsfp->hdr.count;
         sfp->hdr.i8count = 1;
-        ino = XFS_DIR2_SF_GET_INUMBER(oldsfp, &oldsfp->hdr.parent);
-        XFS_DIR2_SF_PUT_INUMBER(sfp, &ino, &sfp->hdr.parent);
+        ino = xfs_dir2_sf_get_inumber(oldsfp, &oldsfp->hdr.parent);
+        xfs_dir2_sf_put_inumber(sfp, &ino, &sfp->hdr.parent);
         /*
          * Copy the entries field by field.
          */
-        for (i = 0, sfep = XFS_DIR2_SF_FIRSTENTRY(sfp),
-                    oldsfep = XFS_DIR2_SF_FIRSTENTRY(oldsfp);
+        for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp),
+                    oldsfep = xfs_dir2_sf_firstentry(oldsfp);
              i < sfp->hdr.count;
-             i++, sfep = XFS_DIR2_SF_NEXTENTRY(sfp, sfep),
-                  oldsfep = XFS_DIR2_SF_NEXTENTRY(oldsfp, oldsfep)) {
+             i++, sfep = xfs_dir2_sf_nextentry(sfp, sfep),
+                  oldsfep = xfs_dir2_sf_nextentry(oldsfp, oldsfep)) {
                 sfep->namelen = oldsfep->namelen;
                 sfep->offset = oldsfep->offset;
                 memcpy(sfep->name, oldsfep->name, sfep->namelen);
-                ino = XFS_DIR2_SF_GET_INUMBER(oldsfp,
-                        XFS_DIR2_SF_INUMBERP(oldsfep));
-                XFS_DIR2_SF_PUT_INUMBER(sfp, &ino, XFS_DIR2_SF_INUMBERP(sfep));
+                ino = xfs_dir2_sf_get_inumber(oldsfp,
+                        xfs_dir2_sf_inumberp(oldsfep));
+                xfs_dir2_sf_put_inumber(sfp, &ino, xfs_dir2_sf_inumberp(sfep));
         }
         /*
          * Clean up the inode.
diff --git a/fs/xfs/xfs_dir2_sf.h b/fs/xfs/xfs_dir2_sf.h
index 42f015b7001..11e503209af 100644
--- a/fs/xfs/xfs_dir2_sf.h
+++ b/fs/xfs/xfs_dir2_sf.h
@@ -90,7 +90,6 @@ typedef struct xfs_dir2_sf {
         xfs_dir2_sf_entry_t     list[1];        /* shortform entries */
 } xfs_dir2_sf_t;
 
-#define XFS_DIR2_SF_HDR_SIZE(i8count)   xfs_dir2_sf_hdr_size(i8count)
 static inline int xfs_dir2_sf_hdr_size(int i8count)
 {
         return ((uint)sizeof(xfs_dir2_sf_hdr_t) - \
@@ -98,14 +97,11 @@ static inline int xfs_dir2_sf_hdr_size(int i8count)
                 ((uint)sizeof(xfs_dir2_ino8_t) - (uint)sizeof(xfs_dir2_ino4_t)));
 }
 
-#define XFS_DIR2_SF_INUMBERP(sfep)      xfs_dir2_sf_inumberp(sfep)
 static inline xfs_dir2_inou_t *xfs_dir2_sf_inumberp(xfs_dir2_sf_entry_t *sfep)
 {
         return (xfs_dir2_inou_t *)&(sfep)->name[(sfep)->namelen];
 }
 
-#define XFS_DIR2_SF_GET_INUMBER(sfp, from) \
-        xfs_dir2_sf_get_inumber(sfp, from)
 static inline xfs_intino_t
 xfs_dir2_sf_get_inumber(xfs_dir2_sf_t *sfp, xfs_dir2_inou_t *from)
 {
@@ -114,8 +110,6 @@ xfs_dir2_sf_get_inumber(xfs_dir2_sf_t *sfp, xfs_dir2_inou_t *from)
                 (xfs_intino_t)XFS_GET_DIR_INO8((from)->i8));
 }
 
-#define XFS_DIR2_SF_PUT_INUMBER(sfp,from,to) \
-        xfs_dir2_sf_put_inumber(sfp,from,to)
 static inline void xfs_dir2_sf_put_inumber(xfs_dir2_sf_t *sfp, xfs_ino_t *from,
                                                 xfs_dir2_inou_t *to)
 {
@@ -125,24 +119,18 @@ static inline void xfs_dir2_sf_put_inumber(xfs_dir2_sf_t *sfp, xfs_ino_t *from,
                 XFS_PUT_DIR_INO8(*(from), (to)->i8);
 }
 
-#define XFS_DIR2_SF_GET_OFFSET(sfep)    \
-        xfs_dir2_sf_get_offset(sfep)
 static inline xfs_dir2_data_aoff_t
 xfs_dir2_sf_get_offset(xfs_dir2_sf_entry_t *sfep)
 {
         return INT_GET_UNALIGNED_16_BE(&(sfep)->offset.i);
 }
 
-#define XFS_DIR2_SF_PUT_OFFSET(sfep,off) \
-        xfs_dir2_sf_put_offset(sfep,off)
 static inline void
 xfs_dir2_sf_put_offset(xfs_dir2_sf_entry_t *sfep, xfs_dir2_data_aoff_t off)
 {
         INT_SET_UNALIGNED_16_BE(&(sfep)->offset.i, off);
 }
 
-#define XFS_DIR2_SF_ENTSIZE_BYNAME(sfp,len)     \
-        xfs_dir2_sf_entsize_byname(sfp,len)
 static inline int xfs_dir2_sf_entsize_byname(xfs_dir2_sf_t *sfp, int len)
 {
         return ((uint)sizeof(xfs_dir2_sf_entry_t) - 1 + (len) - \
@@ -150,8 +138,6 @@ static inline int xfs_dir2_sf_entsize_byname(xfs_dir2_sf_t *sfp, int len)
                 ((uint)sizeof(xfs_dir2_ino8_t) - (uint)sizeof(xfs_dir2_ino4_t)));
 }
 
-#define XFS_DIR2_SF_ENTSIZE_BYENTRY(sfp,sfep)   \
-        xfs_dir2_sf_entsize_byentry(sfp,sfep)
 static inline int
 xfs_dir2_sf_entsize_byentry(xfs_dir2_sf_t *sfp, xfs_dir2_sf_entry_t *sfep)
 {
@@ -160,19 +146,17 @@ xfs_dir2_sf_entsize_byentry(xfs_dir2_sf_t *sfp, xfs_dir2_sf_entry_t *sfep)
                 ((uint)sizeof(xfs_dir2_ino8_t) - (uint)sizeof(xfs_dir2_ino4_t)));
 }
 
-#define XFS_DIR2_SF_FIRSTENTRY(sfp)     xfs_dir2_sf_firstentry(sfp)
 static inline xfs_dir2_sf_entry_t *xfs_dir2_sf_firstentry(xfs_dir2_sf_t *sfp)
 {
         return ((xfs_dir2_sf_entry_t *) \
-                ((char *)(sfp) + XFS_DIR2_SF_HDR_SIZE(sfp->hdr.i8count)));
+                ((char *)(sfp) + xfs_dir2_sf_hdr_size(sfp->hdr.i8count)));
 }
 
-#define XFS_DIR2_SF_NEXTENTRY(sfp,sfep) xfs_dir2_sf_nextentry(sfp,sfep)
 static inline xfs_dir2_sf_entry_t *
 xfs_dir2_sf_nextentry(xfs_dir2_sf_t *sfp, xfs_dir2_sf_entry_t *sfep)
 {
         return ((xfs_dir2_sf_entry_t *) \
-                ((char *)(sfep) + XFS_DIR2_SF_ENTSIZE_BYENTRY(sfp,sfep)));
+                ((char *)(sfep) + xfs_dir2_sf_entsize_byentry(sfp,sfep)));
 }
 
 /*
diff --git a/fs/xfs/xfs_filestream.c b/fs/xfs/xfs_filestream.c
new file mode 100644
index 00000000000..ce2278611bb
--- /dev/null
+++ b/fs/xfs/xfs_filestream.c
@@ -0,0 +1,771 @@
+/*
+ * Copyright (c) 2006-2007 Silicon Graphics, Inc.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write the Free Software Foundation,
+ * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "xfs.h"
+#include "xfs_bmap_btree.h"
+#include "xfs_inum.h"
+#include "xfs_dir2.h"
+#include "xfs_dir2_sf.h"
+#include "xfs_attr_sf.h"
+#include "xfs_dinode.h"
+#include "xfs_inode.h"
+#include "xfs_ag.h"
+#include "xfs_dmapi.h"
+#include "xfs_log.h"
+#include "xfs_trans.h"
+#include "xfs_sb.h"
+#include "xfs_mount.h"
+#include "xfs_bmap.h"
+#include "xfs_alloc.h"
+#include "xfs_utils.h"
+#include "xfs_mru_cache.h"
+#include "xfs_filestream.h"
+
+#ifdef XFS_FILESTREAMS_TRACE
+
+ktrace_t *xfs_filestreams_trace_buf;
+
+STATIC void
+xfs_filestreams_trace(
+        xfs_mount_t     *mp,    /* mount point */
+        int             type,   /* type of trace */
+        const char      *func,  /* source function */
+        int             line,   /* source line number */
+        __psunsigned_t  arg0,
+        __psunsigned_t  arg1,
+        __psunsigned_t  arg2,
+        __psunsigned_t  arg3,
+        __psunsigned_t  arg4,
+        __psunsigned_t  arg5)
+{
+        ktrace_enter(xfs_filestreams_trace_buf,
+                (void *)(__psint_t)(type | (line << 16)),
+                (void *)func,
+                (void *)(__psunsigned_t)current_pid(),
+                (void *)mp,
+                (void *)(__psunsigned_t)arg0,
+                (void *)(__psunsigned_t)arg1,
+                (void *)(__psunsigned_t)arg2,
+                (void *)(__psunsigned_t)arg3,
+                (void *)(__psunsigned_t)arg4,
+                (void *)(__psunsigned_t)arg5,
+                NULL, NULL, NULL, NULL, NULL, NULL);
+}
+
+#define TRACE0(mp,t)                    TRACE6(mp,t,0,0,0,0,0,0)
+#define TRACE1(mp,t,a0)                 TRACE6(mp,t,a0,0,0,0,0,0)
+#define TRACE2(mp,t,a0,a1)              TRACE6(mp,t,a0,a1,0,0,0,0)
+#define TRACE3(mp,t,a0,a1,a2)           TRACE6(mp,t,a0,a1,a2,0,0,0)
+#define TRACE4(mp,t,a0,a1,a2,a3)        TRACE6(mp,t,a0,a1,a2,a3,0,0)
+#define TRACE5(mp,t,a0,a1,a2,a3,a4)     TRACE6(mp,t,a0,a1,a2,a3,a4,0)
+#define TRACE6(mp,t,a0,a1,a2,a3,a4,a5) \
+        xfs_filestreams_trace(mp, t, __FUNCTION__, __LINE__, \
+                                (__psunsigned_t)a0, (__psunsigned_t)a1, \
+                                (__psunsigned_t)a2, (__psunsigned_t)a3, \
+                                (__psunsigned_t)a4, (__psunsigned_t)a5)
+
+#define TRACE_AG_SCAN(mp, ag, ag2) \
+                TRACE2(mp, XFS_FSTRM_KTRACE_AGSCAN, ag, ag2);
+#define TRACE_AG_PICK1(mp, max_ag, maxfree) \
+                TRACE2(mp, XFS_FSTRM_KTRACE_AGPICK1, max_ag, maxfree);
+#define TRACE_AG_PICK2(mp, ag, ag2, cnt, free, scan, flag) \
+                TRACE6(mp, XFS_FSTRM_KTRACE_AGPICK2, ag, ag2, \
+                         cnt, free, scan, flag)
+#define TRACE_UPDATE(mp, ip, ag, cnt, ag2, cnt2) \
+                TRACE5(mp, XFS_FSTRM_KTRACE_UPDATE, ip, ag, cnt, ag2, cnt2)
+#define TRACE_FREE(mp, ip, pip, ag, cnt) \
+                TRACE4(mp, XFS_FSTRM_KTRACE_FREE, ip, pip, ag, cnt)
+#define TRACE_LOOKUP(mp, ip, pip, ag, cnt) \
+                TRACE4(mp, XFS_FSTRM_KTRACE_ITEM_LOOKUP, ip, pip, ag, cnt)
+#define TRACE_ASSOCIATE(mp, ip, pip, ag, cnt) \
+                TRACE4(mp, XFS_FSTRM_KTRACE_ASSOCIATE, ip, pip, ag, cnt)
+#define TRACE_MOVEAG(mp, ip, pip, oag, ocnt, nag, ncnt) \
+                TRACE6(mp, XFS_FSTRM_KTRACE_MOVEAG, ip, pip, oag, ocnt, nag, ncnt)
+#define TRACE_ORPHAN(mp, ip, ag) \
+                TRACE2(mp, XFS_FSTRM_KTRACE_ORPHAN, ip, ag);
+
+
+#else
+#define TRACE_AG_SCAN(mp, ag, ag2)
+#define TRACE_AG_PICK1(mp, max_ag, maxfree)
+#define TRACE_AG_PICK2(mp, ag, ag2, cnt, free, scan, flag)
+#define TRACE_UPDATE(mp, ip, ag, cnt, ag2, cnt2)
+#define TRACE_FREE(mp, ip, pip, ag, cnt)
+#define TRACE_LOOKUP(mp, ip, pip, ag, cnt)
+#define TRACE_ASSOCIATE(mp, ip, pip, ag, cnt)
+#define TRACE_MOVEAG(mp, ip, pip, oag, ocnt, nag, ncnt)
+#define TRACE_ORPHAN(mp, ip, ag)
+#endif
+
+static kmem_zone_t *item_zone;
+
+/*
+ * Structure for associating a file or a directory with an allocation group.
+ * The parent directory pointer is only needed for files, but since there will
+ * generally be vastly more files than directories in the cache, using the same
+ * data structure simplifies the code with very little memory overhead.
+ */
+typedef struct fstrm_item
+{
+        xfs_agnumber_t  ag;     /* AG currently in use for the file/directory. */
+        xfs_inode_t     *ip;    /* inode self-pointer. */
+        xfs_inode_t     *pip;   /* Parent directory inode pointer. */
+} fstrm_item_t;
+
+
+/*
+ * Scan the AGs starting at startag looking for an AG that isn't in use and has
+ * at least minlen blocks free.
+ */
+static int
+_xfs_filestream_pick_ag(
+        xfs_mount_t     *mp,
+        xfs_agnumber_t  startag,
+        xfs_agnumber_t  *agp,
+        int             flags,
+        xfs_extlen_t    minlen)
+{
+        int             err, trylock, nscan;
+        xfs_extlen_t    delta, longest, need, free, minfree, maxfree = 0;
+        xfs_agnumber_t  ag, max_ag = NULLAGNUMBER;
+        struct xfs_perag *pag;
+
+        /* 2% of an AG's blocks must be free for it to be chosen. */
+        minfree = mp->m_sb.sb_agblocks / 50;
+
+        ag = startag;
+        *agp = NULLAGNUMBER;
+
+        /* For the first pass, don't sleep trying to init the per-AG. */
+        trylock = XFS_ALLOC_FLAG_TRYLOCK;
+
+        for (nscan = 0; 1; nscan++) {
+
+                TRACE_AG_SCAN(mp, ag, xfs_filestream_peek_ag(mp, ag));
+
+                pag = mp->m_perag + ag;
+
+                if (!pag->pagf_init) {
+                        err = xfs_alloc_pagf_init(mp, NULL, ag, trylock);
+                        if (err && !trylock)
+                                return err;
+                }
+
+                /* Might fail sometimes during the 1st pass with trylock set. */
+                if (!pag->pagf_init)
+                        goto next_ag;
+
+                /* Keep track of the AG with the most free blocks. */
+                if (pag->pagf_freeblks > maxfree) {
+                        maxfree = pag->pagf_freeblks;
+                        max_ag = ag;
+                }
+
+                /*
+                 * The AG reference count does two things: it enforces mutual
+                 * exclusion when examining the suitability of an AG in this
+                 * loop, and it guards against two filestreams being established
+                 * in the same AG as each other.
+                 */
+                if (xfs_filestream_get_ag(mp, ag) > 1) {
+                        xfs_filestream_put_ag(mp, ag);
+                        goto next_ag;
+                }
+
+                need = XFS_MIN_FREELIST_PAG(pag, mp);
+                delta = need > pag->pagf_flcount ? need - pag->pagf_flcount : 0;
+                longest = (pag->pagf_longest > delta) ?
+                          (pag->pagf_longest - delta) :
+                          (pag->pagf_flcount > 0 || pag->pagf_longest > 0);
+
+                if (((minlen && longest >= minlen) ||
+                     (!minlen && pag->pagf_freeblks >= minfree)) &&
+                    (!pag->pagf_metadata || !(flags & XFS_PICK_USERDATA) ||
+                     (flags & XFS_PICK_LOWSPACE))) {
+
+                        /* Break out, retaining the reference on the AG. */
+                        free = pag->pagf_freeblks;
+                        *agp = ag;
+                        break;
+                }
+
+                /* Drop the reference on this AG, it's not usable. */
+                xfs_filestream_put_ag(mp, ag);
+next_ag:
+                /* Move to the next AG, wrapping to AG 0 if necessary. */
+                if (++ag >= mp->m_sb.sb_agcount)
+                        ag = 0;
+
+                /* If a full pass of the AGs hasn't been done yet, continue. */
+                if (ag != startag)
+                        continue;
+
+                /* Allow sleeping in xfs_alloc_pagf_init() on the 2nd pass. */
+                if (trylock != 0) {
+                        trylock = 0;
+                        continue;
+                }
+
+                /* Finally, if lowspace wasn't set, set it for the 3rd pass. */
+                if (!(flags & XFS_PICK_LOWSPACE)) {
+                        flags |= XFS_PICK_LOWSPACE;
+                        continue;
+                }
+
+                /*
+                 * Take the AG with the most free space, regardless of whether
+                 * it's already in use by another filestream.
+                 */
+                if (max_ag != NULLAGNUMBER) {
+                        xfs_filestream_get_ag(mp, max_ag);
+                        TRACE_AG_PICK1(mp, max_ag, maxfree);
+                        free = maxfree;
+                        *agp = max_ag;
+                        break;
+                }
+
+                /* take AG 0 if none matched */
+                TRACE_AG_PICK1(mp, max_ag, maxfree);
+                *agp = 0;
+                return 0;
+        }
+
+        TRACE_AG_PICK2(mp, startag, *agp, xfs_filestream_peek_ag(mp, *agp),
+                        free, nscan, flags);
+
+        return 0;
+}
+
+/*
+ * Set the allocation group number for a file or a directory, updating inode
+ * references and per-AG references as appropriate.  Must be called with the
+ * m_peraglock held in read mode.
+ */
+static int
+_xfs_filestream_update_ag(
+        xfs_inode_t     *ip,
+        xfs_inode_t     *pip,
+        xfs_agnumber_t  ag)
+{
+        int             err = 0;
+        xfs_mount_t     *mp;
+        xfs_mru_cache_t *cache;
+        fstrm_item_t    *item;
+        xfs_agnumber_t  old_ag;
+        xfs_inode_t     *old_pip;
+
+        /*
+         * Either ip is a regular file and pip is a directory, or ip is a
+         * directory and pip is NULL.
+         */
+        ASSERT(ip && (((ip->i_d.di_mode & S_IFREG) && pip &&
+                       (pip->i_d.di_mode & S_IFDIR)) ||
+                      ((ip->i_d.di_mode & S_IFDIR) && !pip)));
+
+        mp = ip->i_mount;
+        cache = mp->m_filestream;
+
+        item = xfs_mru_cache_lookup(cache, ip->i_ino);
+        if (item) {
+                ASSERT(item->ip == ip);
+                old_ag = item->ag;
+                item->ag = ag;
+                old_pip = item->pip;
+                item->pip = pip;
+                xfs_mru_cache_done(cache);
+
+                /*
+                 * If the AG has changed, drop the old ref and take a new one,
+                 * effectively transferring the reference from old to new AG.
+                 */
+                if (ag != old_ag) {
+                        xfs_filestream_put_ag(mp, old_ag);
+                        xfs_filestream_get_ag(mp, ag);
+                }
+
+                /*
+                 * If ip is a file and its pip has changed, drop the old ref and
+                 * take a new one.
+                 */
+                if (pip && pip != old_pip) {
+                        IRELE(old_pip);
+                        IHOLD(pip);
+                }
+
+                TRACE_UPDATE(mp, ip, old_ag, xfs_filestream_peek_ag(mp, old_ag),
+                                ag, xfs_filestream_peek_ag(mp, ag));
+                return 0;
+        }
+
+        item = kmem_zone_zalloc(item_zone, KM_MAYFAIL);
+        if (!item)
+                return ENOMEM;
+
+        item->ag = ag;
+        item->ip = ip;
+        item->pip = pip;
+
+        err = xfs_mru_cache_insert(cache, ip->i_ino, item);
+        if (err) {
+                kmem_zone_free(item_zone, item);
+                return err;
+        }
+
+        /* Take a reference on the AG. */
+        xfs_filestream_get_ag(mp, ag);
+
+        /*
+         * Take a reference on the inode itself regardless of whether it's a
+         * regular file or a directory.
+         */
+        IHOLD(ip);
+
+        /*
+         * In the case of a regular file, take a reference on the parent inode
+         * as well to ensure it remains in-core.
+         */
+        if (pip)
+                IHOLD(pip);
+
+        TRACE_UPDATE(mp, ip, ag, xfs_filestream_peek_ag(mp, ag),
+                        ag, xfs_filestream_peek_ag(mp, ag));
+
+        return 0;
+}
+
+/* xfs_fstrm_free_func(): callback for freeing cached stream items. */
+void
+xfs_fstrm_free_func(
+        xfs_ino_t       ino,
+        fstrm_item_t    *item)
+{
+        xfs_inode_t     *ip = item->ip;
+        int ref;
+
+        ASSERT(ip->i_ino == ino);
+
+        xfs_iflags_clear(ip, XFS_IFILESTREAM);
+
+        /* Drop the reference taken on the AG when the item was added. */
+        ref = xfs_filestream_put_ag(ip->i_mount, item->ag);
+
+        ASSERT(ref >= 0);
+        TRACE_FREE(ip->i_mount, ip, item->pip, item->ag,
+                xfs_filestream_peek_ag(ip->i_mount, item->ag));
+
+        /*
+         * _xfs_filestream_update_ag() always takes a reference on the inode
+         * itself, whether it's a file or a directory.  Release it here.
+         * This can result in the inode being freed and so we must
+         * not hold any inode locks when freeing filesstreams objects
+         * otherwise we can deadlock here.
+         */
+        IRELE(ip);
+
+        /*
+         * In the case of a regular file, _xfs_filestream_update_ag() also
+         * takes a ref on the parent inode to keep it in-core.  Release that
+         * too.
+         */
+        if (item->pip)
+                IRELE(item->pip);
+
+        /* Finally, free the memory allocated for the item. */
+        kmem_zone_free(item_zone, item);
+}
+
+/*
+ * xfs_filestream_init() is called at xfs initialisation time to set up the
+ * memory zone that will be used for filestream data structure allocation.
+ */
+int
+xfs_filestream_init(void)
+{
+        item_zone = kmem_zone_init(sizeof(fstrm_item_t), "fstrm_item");
+#ifdef XFS_FILESTREAMS_TRACE
+        xfs_filestreams_trace_buf = ktrace_alloc(XFS_FSTRM_KTRACE_SIZE, KM_SLEEP);
+#endif
+        return item_zone ? 0 : -ENOMEM;
+}
+
+/*
+ * xfs_filestream_uninit() is called at xfs termination time to destroy the
+ * memory zone that was used for filestream data structure allocation.
+ */
+void
+xfs_filestream_uninit(void)
+{
+#ifdef XFS_FILESTREAMS_TRACE
+        ktrace_free(xfs_filestreams_trace_buf);
+#endif
+        kmem_zone_destroy(item_zone);
+}
+
+/*
+ * xfs_filestream_mount() is called when a file system is mounted with the
+ * filestream option.  It is responsible for allocating the data structures
+ * needed to track the new file system's file streams.
+ */
+int
+xfs_filestream_mount(
+        xfs_mount_t     *mp)
+{
+        int             err;
+        unsigned int    lifetime, grp_count;
+
+        /*
+         * The filestream timer tunable is currently fixed within the range of
+         * one second to four minutes, with five seconds being the default.  The
+         * group count is somewhat arbitrary, but it'd be nice to adhere to the
+         * timer tunable to within about 10 percent.  This requires at least 10
+         * groups.
+         */
+        lifetime  = xfs_fstrm_centisecs * 10;
+        grp_count = 10;
+
+        err = xfs_mru_cache_create(&mp->m_filestream, lifetime, grp_count,
+                             (xfs_mru_cache_free_func_t)xfs_fstrm_free_func);
+
+        return err;
+}
+
+/*
+ * xfs_filestream_unmount() is called when a file system that was mounted with
+ * the filestream option is unmounted.  It drains the data structures created
+ * to track the file system's file streams and frees all the memory that was
+ * allocated.
+ */
+void
+xfs_filestream_unmount(
+        xfs_mount_t     *mp)
+{
+        xfs_mru_cache_destroy(mp->m_filestream);
+}
+
+/*
+ * If the mount point's m_perag array is going to be reallocated, all
+ * outstanding cache entries must be flushed to avoid accessing reference count
+ * addresses that have been freed.  The call to xfs_filestream_flush() must be
+ * made inside the block that holds the m_peraglock in write mode to do the
+ * reallocation.
+ */
+void
+xfs_filestream_flush(
+        xfs_mount_t     *mp)
+{
+        /* point in time flush, so keep the reaper running */
+        xfs_mru_cache_flush(mp->m_filestream, 1);
+}
+
+/*
+ * Return the AG of the filestream the file or directory belongs to, or
+ * NULLAGNUMBER otherwise.
+ */
+xfs_agnumber_t
+xfs_filestream_lookup_ag(
+        xfs_inode_t     *ip)
+{
+        xfs_mru_cache_t *cache;
+        fstrm_item_t    *item;
+        xfs_agnumber_t  ag;
+        int             ref;
+
+        if (!(ip->i_d.di_mode & (S_IFREG | S_IFDIR))) {
+                ASSERT(0);
+                return NULLAGNUMBER;
+        }
+
+        cache = ip->i_mount->m_filestream;
+        item = xfs_mru_cache_lookup(cache, ip->i_ino);
+        if (!item) {
+                TRACE_LOOKUP(ip->i_mount, ip, NULL, NULLAGNUMBER, 0);
+                return NULLAGNUMBER;
+        }
+
+        ASSERT(ip == item->ip);
+        ag = item->ag;
+        ref = xfs_filestream_peek_ag(ip->i_mount, ag);
+        xfs_mru_cache_done(cache);
+
+        TRACE_LOOKUP(ip->i_mount, ip, item->pip, ag, ref);
+        return ag;
+}
+
+/*
+ * xfs_filestream_associate() should only be called to associate a regular file
+ * with its parent directory.  Calling it with a child directory isn't
+ * appropriate because filestreams don't apply to entire directory hierarchies.
+ * Creating a file in a child directory of an existing filestream directory
+ * starts a new filestream with its own allocation group association.
+ *
+ * Returns < 0 on error, 0 if successful association occurred, > 0 if
+ * we failed to get an association because of locking issues.
+ */
+int
+xfs_filestream_associate(
+        xfs_inode_t     *pip,
+        xfs_inode_t     *ip)
+{
+        xfs_mount_t     *mp;
+        xfs_mru_cache_t *cache;
+        fstrm_item_t    *item;
+        xfs_agnumber_t  ag, rotorstep, startag;
+        int             err = 0;
+
+        ASSERT(pip->i_d.di_mode & S_IFDIR);
+        ASSERT(ip->i_d.di_mode & S_IFREG);
+        if (!(pip->i_d.di_mode & S_IFDIR) || !(ip->i_d.di_mode & S_IFREG))
+                return -EINVAL;
+
+        mp = pip->i_mount;
+        cache = mp->m_filestream;
+        down_read(&mp->m_peraglock);
+
+        /*
+         * We have a problem, Houston.
+         *
+         * Taking the iolock here violates inode locking order - we already
+         * hold the ilock. Hence if we block getting this lock we may never
+         * wake. Unfortunately, that means if we can't get the lock, we're
+         * screwed in terms of getting a stream association - we can't spin
+         * waiting for the lock because someone else is waiting on the lock we
+         * hold and we cannot drop that as we are in a transaction here.
+         *
+         * Lucky for us, this inversion is rarely a problem because it's a
+         * directory inode that we are trying to lock here and that means the
+         * only place that matters is xfs_sync_inodes() and SYNC_DELWRI is
+         * used. i.e. freeze, remount-ro, quotasync or unmount.
+         *
+         * So, if we can't get the iolock without sleeping then just give up
+         */
+        if (!xfs_ilock_nowait(pip, XFS_IOLOCK_EXCL)) {
+                up_read(&mp->m_peraglock);
+                return 1;
+        }
+
+        /* If the parent directory is already in the cache, use its AG. */
+        item = xfs_mru_cache_lookup(cache, pip->i_ino);
+        if (item) {
+                ASSERT(item->ip == pip);
+                ag = item->ag;
+                xfs_mru_cache_done(cache);
+
+                TRACE_LOOKUP(mp, pip, pip, ag, xfs_filestream_peek_ag(mp, ag));
+                err = _xfs_filestream_update_ag(ip, pip, ag);
+
+                goto exit;
+        }
+
+        /*
+         * Set the starting AG using the rotor for inode32, otherwise
+         * use the directory inode's AG.
+         */
+        if (mp->m_flags & XFS_MOUNT_32BITINODES) {
+                rotorstep = xfs_rotorstep;
+                startag = (mp->m_agfrotor / rotorstep) % mp->m_sb.sb_agcount;
+                mp->m_agfrotor = (mp->m_agfrotor + 1) %
+                                 (mp->m_sb.sb_agcount * rotorstep);
+        } else
+                startag = XFS_INO_TO_AGNO(mp, pip->i_ino);
+
+        /* Pick a new AG for the parent inode starting at startag. */
+        err = _xfs_filestream_pick_ag(mp, startag, &ag, 0, 0);
+        if (err || ag == NULLAGNUMBER)
+                goto exit_did_pick;
+
+        /* Associate the parent inode with the AG. */
+        err = _xfs_filestream_update_ag(pip, NULL, ag);
+        if (err)
+                goto exit_did_pick;
+
+        /* Associate the file inode with the AG. */
+        err = _xfs_filestream_update_ag(ip, pip, ag);
+        if (err)
+                goto exit_did_pick;
+
+        TRACE_ASSOCIATE(mp, ip, pip, ag, xfs_filestream_peek_ag(mp, ag));
+
+exit_did_pick:
+        /*
+         * If _xfs_filestream_pick_ag() returned a valid AG, remove the
+         * reference it took on it, since the file and directory will have taken
+         * their own now if they were successfully cached.
+         */
+        if (ag != NULLAGNUMBER)
+                xfs_filestream_put_ag(mp, ag);
+
+exit:
+        xfs_iunlock(pip, XFS_IOLOCK_EXCL);
+        up_read(&mp->m_peraglock);
+        return -err;
+}
+
+/*
+ * Pick a new allocation group for the current file and its file stream.  This
+ * function is called by xfs_bmap_filestreams() with the mount point's per-ag
+ * lock held.
+ */
+int
+xfs_filestream_new_ag(
+        xfs_bmalloca_t  *ap,
+        xfs_agnumber_t  *agp)
+{
+        int             flags, err;
+        xfs_inode_t     *ip, *pip = NULL;
+        xfs_mount_t     *mp;
+        xfs_mru_cache_t *cache;
+        xfs_extlen_t    minlen;
+        fstrm_item_t    *dir, *file;
+        xfs_agnumber_t  ag = NULLAGNUMBER;
+
+        ip = ap->ip;
+        mp = ip->i_mount;
+        cache = mp->m_filestream;
+        minlen = ap->alen;
+        *agp = NULLAGNUMBER;
+
+        /*
+         * Look for the file in the cache, removing it if it's found.  Doing
+         * this allows it to be held across the dir lookup that follows.
+         */
+        file = xfs_mru_cache_remove(cache, ip->i_ino);
+        if (file) {
+                ASSERT(ip == file->ip);
+
+                /* Save the file's parent inode and old AG number for later. */
+                pip = file->pip;
+                ag = file->ag;
+
+                /* Look for the file's directory in the cache. */
+                dir = xfs_mru_cache_lookup(cache, pip->i_ino);
+                if (dir) {
+                        ASSERT(pip == dir->ip);
+
+                        /*
+                         * If the directory has already moved on to a new AG,
+                         * use that AG as the new AG for the file. Don't
+                         * forget to twiddle the AG refcounts to match the
+                         * movement.
+                         */
+                        if (dir->ag != file->ag) {
+                                xfs_filestream_put_ag(mp, file->ag);
+                                xfs_filestream_get_ag(mp, dir->ag);
+                                *agp = file->ag = dir->ag;
+                        }
+
+                        xfs_mru_cache_done(cache);
+                }
+
+                /*
+                 * Put the file back in the cache.  If this fails, the free
+                 * function needs to be called to tidy up in the same way as if
+                 * the item had simply expired from the cache.
+                 */
+                err = xfs_mru_cache_insert(cache, ip->i_ino, file);
+                if (err) {
+                        xfs_fstrm_free_func(ip->i_ino, file);
+                        return err;
+                }
+
+                /*
+                 * If the file's AG was moved to the directory's new AG, there's
+                 * nothing more to be done.
+                 */
+                if (*agp != NULLAGNUMBER) {
+                        TRACE_MOVEAG(mp, ip, pip,
+                                        ag, xfs_filestream_peek_ag(mp, ag),
+                                        *agp, xfs_filestream_peek_ag(mp, *agp));
+                        return 0;
+                }
+        }
+
+        /*
+         * If the file's parent directory is known, take its iolock in exclusive
+         * mode to prevent two sibling files from racing each other to migrate
+         * themselves and their parent to different AGs.
+         */
+        if (pip)
+                xfs_ilock(pip, XFS_IOLOCK_EXCL);
+
+        /*
+         * A new AG needs to be found for the file.  If the file's parent
+         * directory is also known, it will be moved to the new AG as well to
+         * ensure that files created inside it in future use the new AG.
+         */
+        ag = (ag == NULLAGNUMBER) ? 0 : (ag + 1) % mp->m_sb.sb_agcount;
+        flags = (ap->userdata ? XFS_PICK_USERDATA : 0) |
+                (ap->low ? XFS_PICK_LOWSPACE : 0);
+
+        err = _xfs_filestream_pick_ag(mp, ag, agp, flags, minlen);
+        if (err || *agp == NULLAGNUMBER)
+                goto exit;
+
+        /*
+         * If the file wasn't found in the file cache, then its parent directory
+         * inode isn't known.  For this to have happened, the file must either
+         * be pre-existing, or it was created long enough ago that its cache
+         * entry has expired.  This isn't the sort of usage that the filestreams
+         * allocator is trying to optimise, so there's no point trying to track
+         * its new AG somehow in the filestream data structures.
+         */
+        if (!pip) {
+                TRACE_ORPHAN(mp, ip, *agp);
+                goto exit;
+        }
+
+        /* Associate the parent inode with the AG. */
+        err = _xfs_filestream_update_ag(pip, NULL, *agp);
+        if (err)
+                goto exit;
+
+        /* Associate the file inode with the AG. */
+        err = _xfs_filestream_update_ag(ip, pip, *agp);
+        if (err)
+                goto exit;
+
+        TRACE_MOVEAG(mp, ip, pip, NULLAGNUMBER, 0,
+                        *agp, xfs_filestream_peek_ag(mp, *agp));
+
+exit:
+        /*
+         * If _xfs_filestream_pick_ag() returned a valid AG, remove the
+         * reference it took on it, since the file and directory will have taken
+         * their own now if they were successfully cached.
+         */
+        if (*agp != NULLAGNUMBER)
+                xfs_filestream_put_ag(mp, *agp);
+        else
+                *agp = 0;
+
+        if (pip)
+                xfs_iunlock(pip, XFS_IOLOCK_EXCL);
+
+        return err;
+}
+
+/*
+ * Remove an association between an inode and a filestream object.
+ * Typically this is done on last close of an unlinked file.
+ */
+void
+xfs_filestream_deassociate(
+        xfs_inode_t     *ip)
+{
+        xfs_mru_cache_t *cache = ip->i_mount->m_filestream;
+
+        xfs_mru_cache_delete(cache, ip->i_ino);
+}
diff --git a/fs/xfs/xfs_filestream.h b/fs/xfs/xfs_filestream.h
new file mode 100644
index 00000000000..f655f7dc334
--- /dev/null
+++ b/fs/xfs/xfs_filestream.h
@@ -0,0 +1,136 @@
+/*
+ * Copyright (c) 2006-2007 Silicon Graphics, Inc.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write the Free Software Foundation,
+ * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef __XFS_FILESTREAM_H__
+#define __XFS_FILESTREAM_H__
+
+#ifdef __KERNEL__
+
+struct xfs_mount;
+struct xfs_inode;
+struct xfs_perag;
+struct xfs_bmalloca;
+
+#ifdef XFS_FILESTREAMS_TRACE
+#define XFS_FSTRM_KTRACE_INFO           1
+#define XFS_FSTRM_KTRACE_AGSCAN         2
+#define XFS_FSTRM_KTRACE_AGPICK1        3
+#define XFS_FSTRM_KTRACE_AGPICK2        4
+#define XFS_FSTRM_KTRACE_UPDATE         5
+#define XFS_FSTRM_KTRACE_FREE           6
+#define XFS_FSTRM_KTRACE_ITEM_LOOKUP    7
+#define XFS_FSTRM_KTRACE_ASSOCIATE      8
+#define XFS_FSTRM_KTRACE_MOVEAG         9
+#define XFS_FSTRM_KTRACE_ORPHAN         10
+
+#define XFS_FSTRM_KTRACE_SIZE   16384
+extern ktrace_t *xfs_filestreams_trace_buf;
+
+#endif
+
+/*
+ * Allocation group filestream associations are tracked with per-ag atomic
+ * counters.  These counters allow _xfs_filestream_pick_ag() to tell whether a
+ * particular AG already has active filestreams associated with it. The mount
+ * point's m_peraglock is used to protect these counters from per-ag array
+ * re-allocation during a growfs operation.  When xfs_growfs_data_private() is
+ * about to reallocate the array, it calls xfs_filestream_flush() with the
+ * m_peraglock held in write mode.
+ *
+ * Since xfs_mru_cache_flush() guarantees that all the free functions for all
+ * the cache elements have finished executing before it returns, it's safe for
+ * the free functions to use the atomic counters without m_peraglock protection.
+ * This allows the implementation of xfs_fstrm_free_func() to be agnostic about
+ * whether it was called with the m_peraglock held in read mode, write mode or
+ * not held at all.  The race condition this addresses is the following:
+ *
+ *  - The work queue scheduler fires and pulls a filestream directory cache
+ *    element off the LRU end of the cache for deletion, then gets pre-empted.
+ *  - A growfs operation grabs the m_peraglock in write mode, flushes all the
+ *    remaining items from the cache and reallocates the mount point's per-ag
+ *    array, resetting all the counters to zero.
+ *  - The work queue thread resumes and calls the free function for the element
+ *    it started cleaning up earlier.  In the process it decrements the
+ *    filestreams counter for an AG that now has no references.
+ *
+ * With a shrinkfs feature, the above scenario could panic the system.
+ *
+ * All other uses of the following macros should be protected by either the
+ * m_peraglock held in read mode, or the cache's internal locking exposed by the
+ * interval between a call to xfs_mru_cache_lookup() and a call to
+ * xfs_mru_cache_done().  In addition, the m_peraglock must be held in read mode
+ * when new elements are added to the cache.
+ *
+ * Combined, these locking rules ensure that no associations will ever exist in
+ * the cache that reference per-ag array elements that have since been
+ * reallocated.
+ */
+STATIC_INLINE int
+xfs_filestream_peek_ag(
+        xfs_mount_t     *mp,
+        xfs_agnumber_t  agno)
+{
+        return atomic_read(&mp->m_perag[agno].pagf_fstrms);
+}
+
+STATIC_INLINE int
+xfs_filestream_get_ag(
+        xfs_mount_t     *mp,
+        xfs_agnumber_t  agno)
+{
+        return atomic_inc_return(&mp->m_perag[agno].pagf_fstrms);
+}
+
+STATIC_INLINE int
+xfs_filestream_put_ag(
+        xfs_mount_t     *mp,
+        xfs_agnumber_t  agno)
+{
+        return atomic_dec_return(&mp->m_perag[agno].pagf_fstrms);
+}
+
+/* allocation selection flags */
+typedef enum xfs_fstrm_alloc {
+        XFS_PICK_USERDATA = 1,
+        XFS_PICK_LOWSPACE = 2,
+} xfs_fstrm_alloc_t;
+
+/* prototypes for filestream.c */
+int xfs_filestream_init(void);
+void xfs_filestream_uninit(void);
+int xfs_filestream_mount(struct xfs_mount *mp);
+void xfs_filestream_unmount(struct xfs_mount *mp);
+void xfs_filestream_flush(struct xfs_mount *mp);
+xfs_agnumber_t xfs_filestream_lookup_ag(struct xfs_inode *ip);
+int xfs_filestream_associate(struct xfs_inode *dip, struct xfs_inode *ip);
+void xfs_filestream_deassociate(struct xfs_inode *ip);
+int xfs_filestream_new_ag(struct xfs_bmalloca *ap, xfs_agnumber_t *agp);
+
+
+/* filestreams for the inode? */
+STATIC_INLINE int
+xfs_inode_is_filestream(
+        struct xfs_inode        *ip)
+{
+        return (ip->i_mount->m_flags & XFS_MOUNT_FILESTREAMS) ||
+                xfs_iflags_test(ip, XFS_IFILESTREAM) ||
+                (ip->i_d.di_flags & XFS_DIFLAG_FILESTREAM);
+}
+
+#endif /* __KERNEL__ */
+
+#endif /* __XFS_FILESTREAM_H__ */
diff --git a/fs/xfs/xfs_fs.h b/fs/xfs/xfs_fs.h
index 1335449841c..ec3c9c27e0d 100644
--- a/fs/xfs/xfs_fs.h
+++ b/fs/xfs/xfs_fs.h
@@ -66,6 +66,7 @@ struct fsxattr {
 #define XFS_XFLAG_EXTSIZE       0x00000800      /* extent size allocator hint */
 #define XFS_XFLAG_EXTSZINHERIT  0x00001000      /* inherit inode extent size */
 #define XFS_XFLAG_NODEFRAG      0x00002000      /* do not defragment */
+#define XFS_XFLAG_FILESTREAM    0x00004000      /* use filestream allocator */
 #define XFS_XFLAG_HASATTR       0x80000000      /* no DIFLAG for this   */
 
 /*
@@ -238,6 +239,7 @@ typedef struct xfs_fsop_resblks {
 #define XFS_FSOP_GEOM_FLAGS_LOGV2       0x0100  /* log format version 2 */
 #define XFS_FSOP_GEOM_FLAGS_SECTOR      0x0200  /* sector sizes >1BB    */
 #define XFS_FSOP_GEOM_FLAGS_ATTR2       0x0400  /* inline attributes rework */
+#define XFS_FSOP_GEOM_FLAGS_LAZYSB      0x4000  /* lazy superblock counters */
 
 
 /*
diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index b599e6be9ec..432e82347ed 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -44,6 +44,7 @@
 #include "xfs_trans_space.h"
 #include "xfs_rtalloc.h"
 #include "xfs_rw.h"
+#include "xfs_filestream.h"
 
 /*
  * File system operations
@@ -94,6 +95,8 @@ xfs_fs_geometry(
                                 XFS_FSOP_GEOM_FLAGS_DIRV2 : 0) |
                         (XFS_SB_VERSION_HASSECTOR(&mp->m_sb) ?
                                 XFS_FSOP_GEOM_FLAGS_SECTOR : 0) |
+                        (xfs_sb_version_haslazysbcount(&mp->m_sb) ?
+                                XFS_FSOP_GEOM_FLAGS_LAZYSB : 0) |
                         (XFS_SB_VERSION_HASATTR2(&mp->m_sb) ?
                                 XFS_FSOP_GEOM_FLAGS_ATTR2 : 0);
                 geo->logsectsize = XFS_SB_VERSION_HASSECTOR(&mp->m_sb) ?
@@ -140,6 +143,8 @@ xfs_growfs_data_private(
         pct = in->imaxpct;
         if (nb < mp->m_sb.sb_dblocks || pct < 0 || pct > 100)
                 return XFS_ERROR(EINVAL);
+        if ((error = xfs_sb_validate_fsb_count(&mp->m_sb, nb)))
+                return error;
         dpct = pct - mp->m_sb.sb_imax_pct;
         error = xfs_read_buf(mp, mp->m_ddev_targp,
                         XFS_FSB_TO_BB(mp, nb) - XFS_FSS_TO_BB(mp, 1),
@@ -161,6 +166,7 @@ xfs_growfs_data_private(
         new = nb - mp->m_sb.sb_dblocks;
         oagcount = mp->m_sb.sb_agcount;
         if (nagcount > oagcount) {
+                xfs_filestream_flush(mp);
                 down_write(&mp->m_peraglock);
                 mp->m_perag = kmem_realloc(mp->m_perag,
                         sizeof(xfs_perag_t) * nagcount,
@@ -173,6 +179,7 @@ xfs_growfs_data_private(
                 up_write(&mp->m_peraglock);
         }
         tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFS);
+        tp->t_flags |= XFS_TRANS_RESERVE;
         if ((error = xfs_trans_reserve(tp, XFS_GROWFS_SPACE_RES(mp),
                         XFS_GROWDATA_LOG_RES(mp), 0, 0, 0))) {
                 xfs_trans_cancel(tp, 0);
@@ -328,6 +335,7 @@ xfs_growfs_data_private(
                 be32_add(&agf->agf_length, new);
                 ASSERT(be32_to_cpu(agf->agf_length) ==
                        be32_to_cpu(agi->agi_length));
+                xfs_alloc_log_agf(tp, bp, XFS_AGF_LENGTH);
                 /*
                  * Free the new space.
                  */
@@ -494,8 +502,9 @@ xfs_reserve_blocks(
         unsigned long           s;
 
         /* If inval is null, report current values and return */
-
         if (inval == (__uint64_t *)NULL) {
+                if (!outval)
+                        return EINVAL;
                 outval->resblks = mp->m_resblks;
                 outval->resblks_avail = mp->m_resblks_avail;
                 return 0;
@@ -558,8 +567,10 @@ retry:
                 }
         }
 out:
-        outval->resblks = mp->m_resblks;
-        outval->resblks_avail = mp->m_resblks_avail;
+        if (outval) {
+                outval->resblks = mp->m_resblks;
+                outval->resblks_avail = mp->m_resblks_avail;
+        }
         XFS_SB_UNLOCK(mp, s);
 
         if (fdblks_delta) {
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c
index b5feb3e7711..f943368c9b9 100644
--- a/fs/xfs/xfs_ialloc.c
+++ b/fs/xfs/xfs_ialloc.c
@@ -123,6 +123,7 @@ xfs_ialloc_ag_alloc(
         int             blks_per_cluster;  /* fs blocks per inode cluster */
         xfs_btree_cur_t *cur;           /* inode btree cursor */
         xfs_daddr_t     d;              /* disk addr of buffer */
+        xfs_agnumber_t  agno;
         int             error;
         xfs_buf_t       *fbuf;          /* new free inodes' buffer */
         xfs_dinode_t    *free;          /* new free inode structure */
@@ -302,15 +303,15 @@ xfs_ialloc_ag_alloc(
         }
         be32_add(&agi->agi_count, newlen);
         be32_add(&agi->agi_freecount, newlen);
+        agno = be32_to_cpu(agi->agi_seqno);
         down_read(&args.mp->m_peraglock);
-        args.mp->m_perag[be32_to_cpu(agi->agi_seqno)].pagi_freecount += newlen;
+        args.mp->m_perag[agno].pagi_freecount += newlen;
         up_read(&args.mp->m_peraglock);
         agi->agi_newino = cpu_to_be32(newino);
         /*
          * Insert records describing the new inode chunk into the btree.
          */
-        cur = xfs_btree_init_cursor(args.mp, tp, agbp,
-                        be32_to_cpu(agi->agi_seqno),
+        cur = xfs_btree_init_cursor(args.mp, tp, agbp, agno,
                         XFS_BTNUM_INO, (xfs_inode_t *)0, 0);
         for (thisino = newino;
              thisino < newino + newlen;
@@ -1387,6 +1388,7 @@ xfs_ialloc_read_agi(
         pag = &mp->m_perag[agno];
         if (!pag->pagi_init) {
                 pag->pagi_freecount = be32_to_cpu(agi->agi_freecount);
+                pag->pagi_count = be32_to_cpu(agi->agi_count);
                 pag->pagi_init = 1;
         } else {
                 /*
@@ -1410,3 +1412,23 @@ xfs_ialloc_read_agi(
         *bpp = bp;
         return 0;
 }
+
+/*
+ * Read in the agi to initialise the per-ag data in the mount structure
+ */
+int
+xfs_ialloc_pagi_init(
+        xfs_mount_t     *mp,            /* file system mount structure */
+        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_agnumber_t  agno)           /* allocation group number */
+{
+        xfs_buf_t       *bp = NULL;
+        int             error;
+
+        error = xfs_ialloc_read_agi(mp, tp, agno, &bp);
+        if (error)
+                return error;
+        if (bp)
+                xfs_trans_brelse(tp, bp);
+        return 0;
+}
diff --git a/fs/xfs/xfs_ialloc.h b/fs/xfs/xfs_ialloc.h
index 7f5debe1acb..97f4040931c 100644
--- a/fs/xfs/xfs_ialloc.h
+++ b/fs/xfs/xfs_ialloc.h
@@ -149,6 +149,16 @@ xfs_ialloc_read_agi(
         xfs_agnumber_t  agno,           /* allocation group number */
         struct xfs_buf  **bpp);         /* allocation group hdr buf */
 
+/*
+ * Read in the allocation group header to initialise the per-ag data
+ * in the mount structure
+ */
+int
+xfs_ialloc_pagi_init(
+        struct xfs_mount *mp,           /* file system mount structure */
+        struct xfs_trans *tp,           /* transaction pointer */
+        xfs_agnumber_t  agno);          /* allocation group number */
+
 #endif  /* __KERNEL__ */
 
 #endif  /* __XFS_IALLOC_H__ */
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 3ca5d43b834..cdc4c28926d 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -48,7 +48,9 @@
 #include "xfs_dir2_trace.h"
 #include "xfs_quota.h"
 #include "xfs_acl.h"
+#include "xfs_filestream.h"
 
+#include <linux/log2.h>
 
 kmem_zone_t *xfs_ifork_zone;
 kmem_zone_t *xfs_inode_zone;
@@ -643,8 +645,7 @@ xfs_iformat_extents(
                         ep->l1 = INT_GET(get_unaligned((__uint64_t*)&dp->l1),
                                                                 ARCH_CONVERT);
                 }
-                xfs_bmap_trace_exlist("xfs_iformat_extents", ip, nex,
-                        whichfork);
+                XFS_BMAP_TRACE_EXLIST(ip, nex, whichfork);
                 if (whichfork != XFS_DATA_FORK ||
                         XFS_EXTFMT_INODE(ip) == XFS_EXTFMT_NOSTATE)
                                 if (unlikely(xfs_check_nostate_extents(
@@ -817,6 +818,8 @@ _xfs_dic2xflags(
                         flags |= XFS_XFLAG_EXTSZINHERIT;
                 if (di_flags & XFS_DIFLAG_NODEFRAG)
                         flags |= XFS_XFLAG_NODEFRAG;
+                if (di_flags & XFS_DIFLAG_FILESTREAM)
+                        flags |= XFS_XFLAG_FILESTREAM;
         }
 
         return flags;
@@ -1074,6 +1077,11 @@ xfs_iread_extents(
  * also returns the [locked] bp pointing to the head of the freelist
  * as ialloc_context.  The caller should hold this buffer across
  * the commit and pass it back into this routine on the second call.
+ *
+ * If we are allocating quota inodes, we do not have a parent inode
+ * to attach to or associate with (i.e. pip == NULL) because they
+ * are not linked into the directory structure - they are attached
+ * directly to the superblock - and so have no parent.
  */
 int
 xfs_ialloc(
@@ -1099,7 +1107,7 @@ xfs_ialloc(
          * Call the space management code to pick
          * the on-disk inode to be allocated.
          */
-        error = xfs_dialloc(tp, pip->i_ino, mode, okalloc,
+        error = xfs_dialloc(tp, pip ? pip->i_ino : 0, mode, okalloc,
                             ialloc_context, call_again, &ino);
         if (error != 0) {
                 return error;
@@ -1150,10 +1158,10 @@ xfs_ialloc(
         /*
          * Project ids won't be stored on disk if we are using a version 1 inode.
          */
-        if ( (prid != 0) && (ip->i_d.di_version == XFS_DINODE_VERSION_1))
+        if ((prid != 0) && (ip->i_d.di_version == XFS_DINODE_VERSION_1))
                 xfs_bump_ino_vers2(tp, ip);
 
-        if (XFS_INHERIT_GID(pip, vp->v_vfsp)) {
+        if (pip && XFS_INHERIT_GID(pip, vp->v_vfsp)) {
                 ip->i_d.di_gid = pip->i_d.di_gid;
                 if ((pip->i_d.di_mode & S_ISGID) && (mode & S_IFMT) == S_IFDIR) {
                         ip->i_d.di_mode |= S_ISGID;
@@ -1195,8 +1203,16 @@ xfs_ialloc(
                 flags |= XFS_ILOG_DEV;
                 break;
         case S_IFREG:
+                if (pip && xfs_inode_is_filestream(pip)) {
+                        error = xfs_filestream_associate(pip, ip);
+                        if (error < 0)
+                                return -error;
+                        if (!error)
+                                xfs_iflags_set(ip, XFS_IFILESTREAM);
+                }
+                /* fall through */
         case S_IFDIR:
-                if (unlikely(pip->i_d.di_flags & XFS_DIFLAG_ANY)) {
+                if (pip && (pip->i_d.di_flags & XFS_DIFLAG_ANY)) {
                         uint    di_flags = 0;
 
                         if ((mode & S_IFMT) == S_IFDIR) {
@@ -1233,6 +1249,8 @@ xfs_ialloc(
                         if ((pip->i_d.di_flags & XFS_DIFLAG_NODEFRAG) &&
                             xfs_inherit_nodefrag)
                                 di_flags |= XFS_DIFLAG_NODEFRAG;
+                        if (pip->i_d.di_flags & XFS_DIFLAG_FILESTREAM)
+                                di_flags |= XFS_DIFLAG_FILESTREAM;
                         ip->i_d.di_flags |= di_flags;
                 }
                 /* FALLTHROUGH */
@@ -2875,9 +2893,6 @@ xfs_iextents_copy(
         int                     copied;
         xfs_bmbt_rec_t          *dest_ep;
         xfs_bmbt_rec_t          *ep;
-#ifdef XFS_BMAP_TRACE
-        static char             fname[] = "xfs_iextents_copy";
-#endif
         int                     i;
         xfs_ifork_t             *ifp;
         int                     nrecs;
@@ -2888,7 +2903,7 @@ xfs_iextents_copy(
         ASSERT(ifp->if_bytes > 0);
 
         nrecs = ifp->if_bytes / (uint)sizeof(xfs_bmbt_rec_t);
-        xfs_bmap_trace_exlist(fname, ip, nrecs, whichfork);
+        XFS_BMAP_TRACE_EXLIST(ip, nrecs, whichfork);
         ASSERT(nrecs > 0);
 
         /*
@@ -4184,7 +4199,7 @@ xfs_iext_realloc_direct(
                         ifp->if_bytes = new_size;
                         return;
                 }
-                if ((new_size & (new_size - 1)) != 0) {
+                if (!is_power_of_2(new_size)){
                         rnew_size = xfs_iroundup(new_size);
                 }
                 if (rnew_size != ifp->if_real_bytes) {
@@ -4207,7 +4222,7 @@ xfs_iext_realloc_direct(
          */
         else {
                 new_size += ifp->if_bytes;
-                if ((new_size & (new_size - 1)) != 0) {
+                if (!is_power_of_2(new_size)) {
                         rnew_size = xfs_iroundup(new_size);
                 }
                 xfs_iext_inline_to_direct(ifp, rnew_size);
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index f75afecef8e..012dfd4a958 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -379,6 +379,7 @@ xfs_iflags_test(xfs_inode_t *ip, unsigned short flags)
 #define XFS_ISTALE      0x0010  /* inode has been staled */
 #define XFS_IRECLAIMABLE 0x0020 /* inode can be reclaimed */
 #define XFS_INEW        0x0040
+#define XFS_IFILESTREAM 0x0080  /* inode is in a filestream directory */
 
 /*
  * Flags for inode locking.
@@ -414,19 +415,22 @@ xfs_iflags_test(xfs_inode_t *ip, unsigned short flags)
  * gets a lockdep subclass of 1 and the second lock will have a lockdep
  * subclass of 0.
  *
- * XFS_I[O]LOCK_INUMORDER - for locking several inodes at the some time
+ * XFS_LOCK_INUMORDER - for locking several inodes at the some time
  * with xfs_lock_inodes().  This flag is used as the starting subclass
  * and each subsequent lock acquired will increment the subclass by one.
  * So the first lock acquired will have a lockdep subclass of 2, the
- * second lock will have a lockdep subclass of 3, and so on.
+ * second lock will have a lockdep subclass of 3, and so on. It is
+ * the responsibility of the class builder to shift this to the correct
+ * portion of the lock_mode lockdep mask.
  */
+#define XFS_LOCK_PARENT         1
+#define XFS_LOCK_INUMORDER      2
+
 #define XFS_IOLOCK_SHIFT        16
-#define XFS_IOLOCK_PARENT       (1 << XFS_IOLOCK_SHIFT)
-#define XFS_IOLOCK_INUMORDER    (2 << XFS_IOLOCK_SHIFT)
+#define XFS_IOLOCK_PARENT       (XFS_LOCK_PARENT << XFS_IOLOCK_SHIFT)
 
 #define XFS_ILOCK_SHIFT         24
-#define XFS_ILOCK_PARENT        (1 << XFS_ILOCK_SHIFT)
-#define XFS_ILOCK_INUMORDER     (2 << XFS_ILOCK_SHIFT)
+#define XFS_ILOCK_PARENT        (XFS_LOCK_PARENT << XFS_ILOCK_SHIFT)
 
 #define XFS_IOLOCK_DEP_MASK     0x00ff0000
 #define XFS_ILOCK_DEP_MASK      0xff000000
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index 3f2b9f2a7b9..bf57b75acb9 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -451,19 +451,14 @@ xfs_iomap_write_direct(
                 return XFS_ERROR(error);
 
         rt = XFS_IS_REALTIME_INODE(ip);
-        if (unlikely(rt)) {
-                if (!(extsz = ip->i_d.di_extsize))
-                        extsz = mp->m_sb.sb_rextsize;
-        } else {
-                extsz = ip->i_d.di_extsize;
-        }
+        extsz = xfs_get_extsz_hint(ip);
 
         isize = ip->i_size;
         if (io->io_new_size > isize)
                 isize = io->io_new_size;
 
-        offset_fsb = XFS_B_TO_FSBT(mp, offset);
-        last_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)(offset + count)));
+        offset_fsb = XFS_B_TO_FSBT(mp, offset);
+        last_fsb = XFS_B_TO_FSB(mp, ((xfs_ufsize_t)(offset + count)));
         if ((offset + count) > isize) {
                 error = xfs_iomap_eof_align_last_fsb(mp, io, isize, extsz,
                                                         &last_fsb);
@@ -489,13 +484,13 @@ xfs_iomap_write_direct(
         if (unlikely(rt)) {
                 resrtextents = qblocks = resaligned;
                 resrtextents /= mp->m_sb.sb_rextsize;
-                resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
-                quota_flag = XFS_QMOPT_RES_RTBLKS;
-        } else {
-                resrtextents = 0;
+                resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
+                quota_flag = XFS_QMOPT_RES_RTBLKS;
+        } else {
+                resrtextents = 0;
                 resblks = qblocks = XFS_DIOSTRAT_SPACE_RES(mp, resaligned);
-                quota_flag = XFS_QMOPT_RES_REGBLKS;
-        }
+                quota_flag = XFS_QMOPT_RES_REGBLKS;
+        }
 
         /*
          * Allocate and setup the transaction
@@ -666,13 +661,7 @@ xfs_iomap_write_delay(
         if (error)
                 return XFS_ERROR(error);
 
-        if (XFS_IS_REALTIME_INODE(ip)) {
-                if (!(extsz = ip->i_d.di_extsize))
-                        extsz = mp->m_sb.sb_rextsize;
-        } else {
-                extsz = ip->i_d.di_extsize;
-        }
-
+        extsz = xfs_get_extsz_hint(ip);
         offset_fsb = XFS_B_TO_FSBT(mp, offset);
 
 retry:
@@ -788,18 +777,12 @@ xfs_iomap_write_allocate(
                 nimaps = 0;
                 while (nimaps == 0) {
                         tp = xfs_trans_alloc(mp, XFS_TRANS_STRAT_WRITE);
+                        tp->t_flags |= XFS_TRANS_RESERVE;
                         nres = XFS_EXTENTADD_SPACE_RES(mp, XFS_DATA_FORK);
                         error = xfs_trans_reserve(tp, nres,
                                         XFS_WRITE_LOG_RES(mp),
                                         0, XFS_TRANS_PERM_LOG_RES,
                                         XFS_WRITE_LOG_COUNT);
-                        if (error == ENOSPC) {
-                                error = xfs_trans_reserve(tp, 0,
-                                                XFS_WRITE_LOG_RES(mp),
-                                                0,
-                                                XFS_TRANS_PERM_LOG_RES,
-                                                XFS_WRITE_LOG_COUNT);
-                        }
                         if (error) {
                                 xfs_trans_cancel(tp, 0);
                                 return XFS_ERROR(error);
@@ -917,8 +900,8 @@ xfs_iomap_write_unwritten(
                  * from unwritten to real. Do allocations in a loop until
                  * we have covered the range passed in.
                  */
-
                 tp = xfs_trans_alloc(mp, XFS_TRANS_STRAT_WRITE);
+                tp->t_flags |= XFS_TRANS_RESERVE;
                 error = xfs_trans_reserve(tp, resblks,
                                 XFS_WRITE_LOG_RES(mp), 0,
                                 XFS_TRANS_PERM_LOG_RES,
diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c
index e725ddd3de5..4c2454bcc71 100644
--- a/fs/xfs/xfs_itable.c
+++ b/fs/xfs/xfs_itable.c
@@ -202,6 +202,16 @@ xfs_bulkstat_one_dinode(
         return 0;
 }
 
+STATIC int
+xfs_bulkstat_one_fmt(
+        void                    __user *ubuffer,
+        const xfs_bstat_t       *buffer)
+{
+        if (copy_to_user(ubuffer, buffer, sizeof(*buffer)))
+                return -EFAULT;
+        return sizeof(*buffer);
+}
+
 /*
  * Return stat information for one inode.
  * Return 0 if ok, else errno.
@@ -221,6 +231,7 @@ xfs_bulkstat_one(
         xfs_bstat_t     *buf;           /* return buffer */
         int             error = 0;      /* error value */
         xfs_dinode_t    *dip;           /* dinode inode pointer */
+        bulkstat_one_fmt_pf formatter = private_data ? : xfs_bulkstat_one_fmt;
 
         dip = (xfs_dinode_t *)dibuff;
         *stat = BULKSTAT_RV_NOTHING;
@@ -243,14 +254,15 @@ xfs_bulkstat_one(
                 xfs_bulkstat_one_dinode(mp, ino, dip, buf);
         }
 
-        if (copy_to_user(buffer, buf, sizeof(*buf)))  {
+        error = formatter(buffer, buf);
+        if (error < 0)  {
                 error = EFAULT;
                 goto out_free;
         }
 
         *stat = BULKSTAT_RV_DIDONE;
         if (ubused)
-                *ubused = sizeof(*buf);
+                *ubused = error;
 
  out_free:
         kmem_free(buf, sizeof(*buf));
@@ -748,6 +760,19 @@ xfs_bulkstat_single(
         return 0;
 }
 
+int
+xfs_inumbers_fmt(
+        void                    __user *ubuffer, /* buffer to write to */
+        const xfs_inogrp_t      *buffer,        /* buffer to read from */
+        long                    count,          /* # of elements to read */
+        long                    *written)       /* # of bytes written */
+{
+        if (copy_to_user(ubuffer, buffer, count * sizeof(*buffer)))
+                return -EFAULT;
+        *written = count * sizeof(*buffer);
+        return 0;
+}
+
 /*
  * Return inode number table for the filesystem.
  */
@@ -756,7 +781,8 @@ xfs_inumbers(
         xfs_mount_t     *mp,            /* mount point for filesystem */
         xfs_ino_t       *lastino,       /* last inode returned */
         int             *count,         /* size of buffer/count returned */
-        xfs_inogrp_t    __user *ubuffer)/* buffer with inode descriptions */
+        void            __user *ubuffer,/* buffer with inode descriptions */
+        inumbers_fmt_pf formatter)
 {
         xfs_buf_t       *agbp;
         xfs_agino_t     agino;
@@ -835,12 +861,12 @@ xfs_inumbers(
                 bufidx++;
                 left--;
                 if (bufidx == bcount) {
-                        if (copy_to_user(ubuffer, buffer,
-                                        bufidx * sizeof(*buffer))) {
+                        long written;
+                        if (formatter(ubuffer, buffer, bufidx, &written)) {
                                 error = XFS_ERROR(EFAULT);
                                 break;
                         }
-                        ubuffer += bufidx;
+                        ubuffer += written;
                         *count += bufidx;
                         bufidx = 0;
                 }
@@ -862,8 +888,8 @@ xfs_inumbers(
         }
         if (!error) {
                 if (bufidx) {
-                        if (copy_to_user(ubuffer, buffer,
-                                        bufidx * sizeof(*buffer)))
+                        long written;
+                        if (formatter(ubuffer, buffer, bufidx, &written))
                                 error = XFS_ERROR(EFAULT);
                         else
                                 *count += bufidx;
diff --git a/fs/xfs/xfs_itable.h b/fs/xfs/xfs_itable.h
index f25a28862a1..a1f18fce9b7 100644
--- a/fs/xfs/xfs_itable.h
+++ b/fs/xfs/xfs_itable.h
@@ -69,6 +69,10 @@ xfs_bulkstat_single(
         char                    __user *buffer,
         int                     *done);
 
+typedef int (*bulkstat_one_fmt_pf)(  /* used size in bytes or negative error */
+        void                    __user *ubuffer, /* buffer to write to */
+        const xfs_bstat_t       *buffer);        /* buffer to read from */
+
 int
 xfs_bulkstat_one(
         xfs_mount_t             *mp,
@@ -86,11 +90,25 @@ xfs_internal_inum(
         xfs_mount_t             *mp,
         xfs_ino_t               ino);
 
+typedef int (*inumbers_fmt_pf)(
+        void                    __user *ubuffer, /* buffer to write to */
+        const xfs_inogrp_t      *buffer,        /* buffer to read from */
+        long                    count,          /* # of elements to read */
+        long                    *written);      /* # of bytes written */
+
+int
+xfs_inumbers_fmt(
+        void                    __user *ubuffer, /* buffer to write to */
+        const xfs_inogrp_t      *buffer,        /* buffer to read from */
+        long                    count,          /* # of elements to read */
+        long                    *written);      /* # of bytes written */
+
 int                                     /* error status */
 xfs_inumbers(
         xfs_mount_t             *mp,    /* mount point for filesystem */
         xfs_ino_t               *last,  /* last inode returned */
         int                     *count, /* size of buffer/count returned */
-        xfs_inogrp_t            __user *buffer);/* buffer with inode info */
+        void                    __user *buffer, /* buffer with inode info */
+        inumbers_fmt_pf         formatter);
 
 #endif  /* __XFS_ITABLE_H__ */
diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index c48bf61f17b..9d4c4fbeb3e 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -817,10 +817,8 @@ xfs_log_need_covered(xfs_mount_t *mp)
         SPLDECL(s);
         int             needed = 0, gen;
         xlog_t          *log = mp->m_log;
-        bhv_vfs_t       *vfsp = XFS_MTOVFS(mp);
 
-        if (vfs_test_for_freeze(vfsp) || XFS_FORCED_SHUTDOWN(mp) ||
-            (vfsp->vfs_flag & VFS_RDONLY))
+        if (!xfs_fs_writable(mp))
                 return 0;
 
         s = LOG_LOCK(log);
@@ -967,14 +965,16 @@ xlog_iodone(xfs_buf_t *bp)
         } else if (iclog->ic_state & XLOG_STATE_IOERROR) {
                 aborted = XFS_LI_ABORTED;
         }
+
+        /* log I/O is always issued ASYNC */
+        ASSERT(XFS_BUF_ISASYNC(bp));
         xlog_state_done_syncing(iclog, aborted);
-        if (!(XFS_BUF_ISASYNC(bp))) {
-                /*
-                 * Corresponding psema() will be done in bwrite().  If we don't
-                 * vsema() here, panic.
-                 */
-                XFS_BUF_V_IODONESEMA(bp);
-        }
+        /*
+         * do not reference the buffer (bp) here as we could race
+         * with it being freed after writing the unmount record to the
+         * log.
+         */
+
 }       /* xlog_iodone */
 
 /*
@@ -1199,11 +1199,18 @@ xlog_alloc_log(xfs_mount_t	*mp,
                 *iclogp = (xlog_in_core_t *)
                           kmem_zalloc(sizeof(xlog_in_core_t), KM_SLEEP);
                 iclog = *iclogp;
-                iclog->hic_data = (xlog_in_core_2_t *)
-                          kmem_zalloc(iclogsize, KM_SLEEP | KM_LARGE);
-
                 iclog->ic_prev = prev_iclog;
                 prev_iclog = iclog;
+
+                bp = xfs_buf_get_noaddr(log->l_iclog_size, mp->m_logdev_targp);
+                if (!XFS_BUF_CPSEMA(bp))
+                        ASSERT(0);
+                XFS_BUF_SET_IODONE_FUNC(bp, xlog_iodone);
+                XFS_BUF_SET_BDSTRAT_FUNC(bp, xlog_bdstrat_cb);
+                XFS_BUF_SET_FSPRIVATE2(bp, (unsigned long)1);
+                iclog->ic_bp = bp;
+                iclog->hic_data = bp->b_addr;
+
                 log->l_iclog_bak[i] = (xfs_caddr_t)&(iclog->ic_header);
 
                 head = &iclog->ic_header;
@@ -1216,11 +1223,6 @@ xlog_alloc_log(xfs_mount_t	*mp,
                 INT_SET(head->h_fmt, ARCH_CONVERT, XLOG_FMT);
                 memcpy(&head->h_fs_uuid, &mp->m_sb.sb_uuid, sizeof(uuid_t));
 
-                bp = xfs_buf_get_empty(log->l_iclog_size, mp->m_logdev_targp);
-                XFS_BUF_SET_IODONE_FUNC(bp, xlog_iodone);
-                XFS_BUF_SET_BDSTRAT_FUNC(bp, xlog_bdstrat_cb);
-                XFS_BUF_SET_FSPRIVATE2(bp, (unsigned long)1);
-                iclog->ic_bp = bp;
 
                 iclog->ic_size = XFS_BUF_SIZE(bp) - log->l_iclog_hsize;
                 iclog->ic_state = XLOG_STATE_ACTIVE;
@@ -1432,7 +1434,7 @@ xlog_sync(xlog_t		*log,
         } else {
                 iclog->ic_bwritecnt = 1;
         }
-        XFS_BUF_SET_PTR(bp, (xfs_caddr_t) &(iclog->ic_header), count);
+        XFS_BUF_SET_COUNT(bp, count);
         XFS_BUF_SET_FSPRIVATE(bp, iclog);       /* save for later */
         XFS_BUF_ZEROFLAGS(bp);
         XFS_BUF_BUSY(bp);
@@ -1528,7 +1530,6 @@ xlog_dealloc_log(xlog_t *log)
                 }
 #endif
                 next_iclog = iclog->ic_next;
-                kmem_free(iclog->hic_data, log->l_iclog_size);
                 kmem_free(iclog, sizeof(xlog_in_core_t));
                 iclog = next_iclog;
         }
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 080fabf61c9..fddbb091a86 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -927,6 +927,14 @@ xlog_find_tail(
                         ASSIGN_ANY_LSN_HOST(log->l_last_sync_lsn, log->l_curr_cycle,
                                         after_umount_blk);
                         *tail_blk = after_umount_blk;
+
+                        /*
+                         * Note that the unmount was clean. If the unmount
+                         * was not clean, we need to know this to rebuild the
+                         * superblock counters from the perag headers if we
+                         * have a filesystem using non-persistent counters.
+                         */
+                        log->l_mp->m_flags |= XFS_MOUNT_WAS_CLEAN;
                 }
         }
 
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index a96bde6df96..a66b3980517 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -202,6 +202,27 @@ xfs_mount_free(
         kmem_free(mp, sizeof(xfs_mount_t));
 }
 
+/*
+ * Check size of device based on the (data/realtime) block count.
+ * Note: this check is used by the growfs code as well as mount.
+ */
+int
+xfs_sb_validate_fsb_count(
+        xfs_sb_t        *sbp,
+        __uint64_t      nblocks)
+{
+        ASSERT(PAGE_SHIFT >= sbp->sb_blocklog);
+        ASSERT(sbp->sb_blocklog >= BBSHIFT);
+
+#if XFS_BIG_BLKNOS     /* Limited by ULONG_MAX of page cache index */
+        if (nblocks >> (PAGE_CACHE_SHIFT - sbp->sb_blocklog) > ULONG_MAX)
+                return E2BIG;
+#else                  /* Limited by UINT_MAX of sectors */
+        if (nblocks << (sbp->sb_blocklog - BBSHIFT) > UINT_MAX)
+                return E2BIG;
+#endif
+        return 0;
+}
 
 /*
  * Check the validity of the SB found.
@@ -284,18 +305,8 @@ xfs_mount_validate_sb(
                 return XFS_ERROR(EFSCORRUPTED);
         }
 
-        ASSERT(PAGE_SHIFT >= sbp->sb_blocklog);
-        ASSERT(sbp->sb_blocklog >= BBSHIFT);
-
-#if XFS_BIG_BLKNOS     /* Limited by ULONG_MAX of page cache index */
-        if (unlikely(
-            (sbp->sb_dblocks >> (PAGE_SHIFT - sbp->sb_blocklog)) > ULONG_MAX ||
-            (sbp->sb_rblocks >> (PAGE_SHIFT - sbp->sb_blocklog)) > ULONG_MAX)) {
-#else                  /* Limited by UINT_MAX of sectors */
-        if (unlikely(
-            (sbp->sb_dblocks << (sbp->sb_blocklog - BBSHIFT)) > UINT_MAX ||
-            (sbp->sb_rblocks << (sbp->sb_blocklog - BBSHIFT)) > UINT_MAX)) {
-#endif
+        if (xfs_sb_validate_fsb_count(sbp, sbp->sb_dblocks) ||
+            xfs_sb_validate_fsb_count(sbp, sbp->sb_rblocks)) {
                 xfs_fs_mount_cmn_err(flags,
                         "file system too large to be mounted on this system.");
                 return XFS_ERROR(E2BIG);
@@ -632,6 +643,64 @@ xfs_mount_common(xfs_mount_t *mp, xfs_sb_t *sbp)
                                         sbp->sb_inopblock);
         mp->m_ialloc_blks = mp->m_ialloc_inos >> sbp->sb_inopblog;
 }
+
+/*
+ * xfs_initialize_perag_data
+ *
+ * Read in each per-ag structure so we can count up the number of
+ * allocated inodes, free inodes and used filesystem blocks as this
+ * information is no longer persistent in the superblock. Once we have
+ * this information, write it into the in-core superblock structure.
+ */
+STATIC int
+xfs_initialize_perag_data(xfs_mount_t *mp, xfs_agnumber_t agcount)
+{
+        xfs_agnumber_t  index;
+        xfs_perag_t     *pag;
+        xfs_sb_t        *sbp = &mp->m_sb;
+        uint64_t        ifree = 0;
+        uint64_t        ialloc = 0;
+        uint64_t        bfree = 0;
+        uint64_t        bfreelst = 0;
+        uint64_t        btree = 0;
+        int             error;
+        int             s;
+
+        for (index = 0; index < agcount; index++) {
+                /*
+                 * read the agf, then the agi. This gets us
+                 * all the inforamtion we need and populates the
+                 * per-ag structures for us.
+                 */
+                error = xfs_alloc_pagf_init(mp, NULL, index, 0);
+                if (error)
+                        return error;
+
+                error = xfs_ialloc_pagi_init(mp, NULL, index);
+                if (error)
+                        return error;
+                pag = &mp->m_perag[index];
+                ifree += pag->pagi_freecount;
+                ialloc += pag->pagi_count;
+                bfree += pag->pagf_freeblks;
+                bfreelst += pag->pagf_flcount;
+                btree += pag->pagf_btreeblks;
+        }
+        /*
+         * Overwrite incore superblock counters with just-read data
+         */
+        s = XFS_SB_LOCK(mp);
+        sbp->sb_ifree = ifree;
+        sbp->sb_icount = ialloc;
+        sbp->sb_fdblocks = bfree + bfreelst + btree;
+        XFS_SB_UNLOCK(mp, s);
+
+        /* Fixup the per-cpu counters as well. */
+        xfs_icsb_reinit_counters(mp);
+
+        return 0;
+}
+
 /*
  * xfs_mountfs
  *
@@ -656,7 +725,7 @@ xfs_mountfs(
         bhv_vnode_t     *rvp = NULL;
         int             readio_log, writeio_log;
         xfs_daddr_t     d;
-        __uint64_t      ret64;
+        __uint64_t      resblks;
         __int64_t       update_flags;
         uint            quotamount, quotaflags;
         int             agno;
@@ -773,6 +842,7 @@ xfs_mountfs(
          */
         if ((mfsi_flags & XFS_MFSI_SECOND) == 0 &&
             (mp->m_flags & XFS_MOUNT_NOUUID) == 0) {
+                __uint64_t      ret64;
                 if (xfs_uuid_mount(mp)) {
                         error = XFS_ERROR(EINVAL);
                         goto error1;
@@ -976,6 +1046,34 @@ xfs_mountfs(
         }
 
         /*
+         * Now the log is mounted, we know if it was an unclean shutdown or
+         * not. If it was, with the first phase of recovery has completed, we
+         * have consistent AG blocks on disk. We have not recovered EFIs yet,
+         * but they are recovered transactionally in the second recovery phase
+         * later.
+         *
+         * Hence we can safely re-initialise incore superblock counters from
+         * the per-ag data. These may not be correct if the filesystem was not
+         * cleanly unmounted, so we need to wait for recovery to finish before
+         * doing this.
+         *
+         * If the filesystem was cleanly unmounted, then we can trust the
+         * values in the superblock to be correct and we don't need to do
+         * anything here.
+         *
+         * If we are currently making the filesystem, the initialisation will
+         * fail as the perag data is in an undefined state.
+         */
+
+        if (xfs_sb_version_haslazysbcount(&mp->m_sb) &&
+            !XFS_LAST_UNMOUNT_WAS_CLEAN(mp) &&
+             !mp->m_sb.sb_inprogress) {
+                error = xfs_initialize_perag_data(mp, sbp->sb_agcount);
+                if (error) {
+                        goto error2;
+                }
+        }
+        /*
          * Get and sanity-check the root inode.
          * Save the pointer to it in the mount structure.
          */
@@ -1044,6 +1142,23 @@ xfs_mountfs(
         if ((error = XFS_QM_MOUNT(mp, quotamount, quotaflags, mfsi_flags)))
                 goto error4;
 
+        /*
+         * Now we are mounted, reserve a small amount of unused space for
+         * privileged transactions. This is needed so that transaction
+         * space required for critical operations can dip into this pool
+         * when at ENOSPC. This is needed for operations like create with
+         * attr, unwritten extent conversion at ENOSPC, etc. Data allocations
+         * are not allowed to use this reserved space.
+         *
+         * We default to 5% or 1024 fsbs of space reserved, whichever is smaller.
+         * This may drive us straight to ENOSPC on mount, but that implies
+         * we were already there on the last unmount.
+         */
+        resblks = mp->m_sb.sb_dblocks;
+        do_div(resblks, 20);
+        resblks = min_t(__uint64_t, resblks, 1024);
+        xfs_reserve_blocks(mp, &resblks, NULL);
+
         return 0;
 
  error4:
@@ -1083,7 +1198,19 @@ xfs_unmountfs(xfs_mount_t *mp, struct cred *cr)
 #if defined(DEBUG) || defined(INDUCE_IO_ERROR)
         int64_t         fsid;
 #endif
+        __uint64_t      resblks;
 
+        /*
+         * We can potentially deadlock here if we have an inode cluster
+         * that has been freed has it's buffer still pinned in memory because
+         * the transaction is still sitting in a iclog. The stale inodes
+         * on that buffer will have their flush locks held until the
+         * transaction hits the disk and the callbacks run. the inode
+         * flush takes the flush lock unconditionally and with nothing to
+         * push out the iclog we will never get that unlocked. hence we
+         * need to force the log first.
+         */
+        xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE | XFS_LOG_SYNC);
         xfs_iflush_all(mp);
 
         XFS_QM_DQPURGEALL(mp, XFS_QMOPT_QUOTALL | XFS_QMOPT_UMOUNTING);
@@ -1100,10 +1227,26 @@ xfs_unmountfs(xfs_mount_t *mp, struct cred *cr)
                 xfs_binval(mp->m_rtdev_targp);
         }
 
-        xfs_unmountfs_writesb(mp);
+        /*
+         * Unreserve any blocks we have so that when we unmount we don't account
+         * the reserved free space as used. This is really only necessary for
+         * lazy superblock counting because it trusts the incore superblock
+         * counters to be aboslutely correct on clean unmount.
+         *
+         * We don't bother correcting this elsewhere for lazy superblock
+         * counting because on mount of an unclean filesystem we reconstruct the
+         * correct counter value and this is irrelevant.
+         *
+         * For non-lazy counter filesystems, this doesn't matter at all because
+         * we only every apply deltas to the superblock and hence the incore
+         * value does not matter....
+         */
+        resblks = 0;
+        xfs_reserve_blocks(mp, &resblks, NULL);
 
+        xfs_log_sbcount(mp, 1);
+        xfs_unmountfs_writesb(mp);
         xfs_unmountfs_wait(mp);                 /* wait for async bufs */
-
         xfs_log_unmount(mp);                    /* Done! No more fs ops. */
 
         xfs_freesb(mp);
@@ -1150,6 +1293,62 @@ xfs_unmountfs_wait(xfs_mount_t *mp)
 }
 
 int
+xfs_fs_writable(xfs_mount_t *mp)
+{
+        bhv_vfs_t       *vfsp = XFS_MTOVFS(mp);
+
+        return !(vfs_test_for_freeze(vfsp) || XFS_FORCED_SHUTDOWN(mp) ||
+                (vfsp->vfs_flag & VFS_RDONLY));
+}
+
+/*
+ * xfs_log_sbcount
+ *
+ * Called either periodically to keep the on disk superblock values
+ * roughly up to date or from unmount to make sure the values are
+ * correct on a clean unmount.
+ *
+ * Note this code can be called during the process of freezing, so
+ * we may need to use the transaction allocator which does not not
+ * block when the transaction subsystem is in its frozen state.
+ */
+int
+xfs_log_sbcount(
+        xfs_mount_t     *mp,
+        uint            sync)
+{
+        xfs_trans_t     *tp;
+        int             error;
+
+        if (!xfs_fs_writable(mp))
+                return 0;
+
+        xfs_icsb_sync_counters(mp);
+
+        /*
+         * we don't need to do this if we are updating the superblock
+         * counters on every modification.
+         */
+        if (!xfs_sb_version_haslazysbcount(&mp->m_sb))
+                return 0;
+
+        tp = _xfs_trans_alloc(mp, XFS_TRANS_SB_COUNT);
+        error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
+                                        XFS_DEFAULT_LOG_COUNT);
+        if (error) {
+                xfs_trans_cancel(tp, 0);
+                return error;
+        }
+
+        xfs_mod_sb(tp, XFS_SB_IFREE | XFS_SB_ICOUNT | XFS_SB_FDBLOCKS);
+        if (sync)
+                xfs_trans_set_sync(tp);
+        xfs_trans_commit(tp, 0);
+
+        return 0;
+}
+
+int
 xfs_unmountfs_writesb(xfs_mount_t *mp)
 {
         xfs_buf_t       *sbp;
@@ -1160,16 +1359,15 @@ xfs_unmountfs_writesb(xfs_mount_t *mp)
          * skip superblock write if fs is read-only, or
          * if we are doing a forced umount.
          */
-        sbp = xfs_getsb(mp, 0);
         if (!(XFS_MTOVFS(mp)->vfs_flag & VFS_RDONLY ||
                 XFS_FORCED_SHUTDOWN(mp))) {
 
-                xfs_icsb_sync_counters(mp);
+                sbp = xfs_getsb(mp, 0);
+                sb = XFS_BUF_TO_SBP(sbp);
 
                 /*
                  * mark shared-readonly if desired
                  */
-                sb = XFS_BUF_TO_SBP(sbp);
                 if (mp->m_mk_sharedro) {
                         if (!(sb->sb_flags & XFS_SBF_READONLY))
                                 sb->sb_flags |= XFS_SBF_READONLY;
@@ -1178,6 +1376,7 @@ xfs_unmountfs_writesb(xfs_mount_t *mp)
                         xfs_fs_cmn_err(CE_NOTE, mp,
                                 "Unmounting, marking shared read-only");
                 }
+
                 XFS_BUF_UNDONE(sbp);
                 XFS_BUF_UNREAD(sbp);
                 XFS_BUF_UNDELAYWRITE(sbp);
@@ -1192,8 +1391,8 @@ xfs_unmountfs_writesb(xfs_mount_t *mp)
                                           mp, sbp, XFS_BUF_ADDR(sbp));
                 if (error && mp->m_mk_sharedro)
                         xfs_fs_cmn_err(CE_ALERT, mp, "Superblock write error detected while unmounting.  Filesystem may not be marked shared readonly");
+                xfs_buf_relse(sbp);
         }
-        xfs_buf_relse(sbp);
         return error;
 }
 
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index 82304b94646..76ad7475869 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -66,6 +66,7 @@ struct xfs_bmbt_irec;
 struct xfs_bmap_free;
 struct xfs_extdelta;
 struct xfs_swapext;
+struct xfs_mru_cache;
 
 extern struct bhv_vfsops xfs_vfsops;
 extern struct bhv_vnodeops xfs_vnodeops;
@@ -424,17 +425,18 @@ typedef struct xfs_mount {
         struct notifier_block   m_icsb_notifier; /* hotplug cpu notifier */
         struct mutex            m_icsb_mutex;   /* balancer sync lock */
 #endif
+        struct xfs_mru_cache    *m_filestream;  /* per-mount filestream data */
 } xfs_mount_t;
 
 /*
  * Flags for m_flags.
  */
-#define XFS_MOUNT_WSYNC         (1ULL << 0)     /* for nfs - all metadata ops
+#define XFS_MOUNT_WSYNC         (1ULL << 0)     /* for nfs - all metadata ops
                                                    must be synchronous except
                                                    for space allocations */
-#define XFS_MOUNT_INO64         (1ULL << 1)
+#define XFS_MOUNT_INO64         (1ULL << 1)
                              /* (1ULL << 2)     -- currently unused */
-                             /* (1ULL << 3)     -- currently unused */
+#define XFS_MOUNT_WAS_CLEAN     (1ULL << 3)
 #define XFS_MOUNT_FS_SHUTDOWN   (1ULL << 4)     /* atomic stop of all filesystem
                                                    operations, typically for
                                                    disk errors in metadata */
@@ -463,6 +465,8 @@ typedef struct xfs_mount {
                                                  * I/O size in stat() */
 #define XFS_MOUNT_NO_PERCPU_SB  (1ULL << 23)    /* don't use per-cpu superblock
                                                    counters */
+#define XFS_MOUNT_FILESTREAMS   (1ULL << 24)    /* enable the filestreams
+                                                   allocator */
 
 
 /*
@@ -511,6 +515,8 @@ xfs_preferred_iosize(xfs_mount_t *mp)
 
 #define XFS_MAXIOFFSET(mp)      ((mp)->m_maxioffset)
 
+#define XFS_LAST_UNMOUNT_WAS_CLEAN(mp)  \
+                                ((mp)->m_flags & XFS_MOUNT_WAS_CLEAN)
 #define XFS_FORCED_SHUTDOWN(mp) ((mp)->m_flags & XFS_MOUNT_FS_SHUTDOWN)
 #define xfs_force_shutdown(m,f) \
         bhv_vfs_force_shutdown((XFS_MTOVFS(m)), f, __FILE__, __LINE__)
@@ -602,6 +608,7 @@ typedef struct xfs_mod_sb {
 
 extern xfs_mount_t *xfs_mount_init(void);
 extern void     xfs_mod_sb(xfs_trans_t *, __int64_t);
+extern int      xfs_log_sbcount(xfs_mount_t *, uint);
 extern void     xfs_mount_free(xfs_mount_t *mp, int remove_bhv);
 extern int      xfs_mountfs(struct bhv_vfs *, xfs_mount_t *mp, int);
 extern void     xfs_mountfs_check_barriers(xfs_mount_t *mp);
@@ -618,12 +625,14 @@ extern int	xfs_mod_incore_sb_batch(xfs_mount_t *, xfs_mod_sb_t *,
 extern struct xfs_buf *xfs_getsb(xfs_mount_t *, int);
 extern int      xfs_readsb(xfs_mount_t *, int);
 extern void     xfs_freesb(xfs_mount_t *);
+extern int      xfs_fs_writable(xfs_mount_t *);
 extern void     xfs_do_force_shutdown(bhv_desc_t *, int, char *, int);
 extern int      xfs_syncsub(xfs_mount_t *, int, int *);
 extern int      xfs_sync_inodes(xfs_mount_t *, int, int *);
 extern xfs_agnumber_t   xfs_initialize_perag(struct bhv_vfs *, xfs_mount_t *,
                                                 xfs_agnumber_t);
 extern void     xfs_xlatesb(void *, struct xfs_sb *, int, __int64_t);
+extern int      xfs_sb_validate_fsb_count(struct xfs_sb *, __uint64_t);
 
 extern struct xfs_dmops xfs_dmcore_stub;
 extern struct xfs_qmops xfs_qmcore_stub;
diff --git a/fs/xfs/xfs_mru_cache.c b/fs/xfs/xfs_mru_cache.c
new file mode 100644
index 00000000000..7deb9e3cbbd
--- /dev/null
+++ b/fs/xfs/xfs_mru_cache.c
@@ -0,0 +1,608 @@
+/*
+ * Copyright (c) 2006-2007 Silicon Graphics, Inc.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write the Free Software Foundation,
+ * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#include "xfs.h"
+#include "xfs_mru_cache.h"
+
+/*
+ * The MRU Cache data structure consists of a data store, an array of lists and
+ * a lock to protect its internal state.  At initialisation time, the client
+ * supplies an element lifetime in milliseconds and a group count, as well as a
+ * function pointer to call when deleting elements.  A data structure for
+ * queueing up work in the form of timed callbacks is also included.
+ *
+ * The group count controls how many lists are created, and thereby how finely
+ * the elements are grouped in time.  When reaping occurs, all the elements in
+ * all the lists whose time has expired are deleted.
+ *
+ * To give an example of how this works in practice, consider a client that
+ * initialises an MRU Cache with a lifetime of ten seconds and a group count of
+ * five.  Five internal lists will be created, each representing a two second
+ * period in time.  When the first element is added, time zero for the data
+ * structure is initialised to the current time.
+ *
+ * All the elements added in the first two seconds are appended to the first
+ * list.  Elements added in the third second go into the second list, and so on.
+ * If an element is accessed at any point, it is removed from its list and
+ * inserted at the head of the current most-recently-used list.
+ *
+ * The reaper function will have nothing to do until at least twelve seconds
+ * have elapsed since the first element was added.  The reason for this is that
+ * if it were called at t=11s, there could be elements in the first list that
+ * have only been inactive for nine seconds, so it still does nothing.  If it is
+ * called anywhere between t=12 and t=14 seconds, it will delete all the
+ * elements that remain in the first list.  It's therefore possible for elements
+ * to remain in the data store even after they've been inactive for up to
+ * (t + t/g) seconds, where t is the inactive element lifetime and g is the
+ * number of groups.
+ *
+ * The above example assumes that the reaper function gets called at least once
+ * every (t/g) seconds.  If it is called less frequently, unused elements will
+ * accumulate in the reap list until the reaper function is eventually called.
+ * The current implementation uses work queue callbacks to carefully time the
+ * reaper function calls, so this should happen rarely, if at all.
+ *
+ * From a design perspective, the primary reason for the choice of a list array
+ * representing discrete time intervals is that it's only practical to reap
+ * expired elements in groups of some appreciable size.  This automatically
+ * introduces a granularity to element lifetimes, so there's no point storing an
+ * individual timeout with each element that specifies a more precise reap time.
+ * The bonus is a saving of sizeof(long) bytes of memory per element stored.
+ *
+ * The elements could have been stored in just one list, but an array of
+ * counters or pointers would need to be maintained to allow them to be divided
+ * up into discrete time groups.  More critically, the process of touching or
+ * removing an element would involve walking large portions of the entire list,
+ * which would have a detrimental effect on performance.  The additional memory
+ * requirement for the array of list heads is minimal.
+ *
+ * When an element is touched or deleted, it needs to be removed from its
+ * current list.  Doubly linked lists are used to make the list maintenance
+ * portion of these operations O(1).  Since reaper timing can be imprecise,
+ * inserts and lookups can occur when there are no free lists available.  When
+ * this happens, all the elements on the LRU list need to be migrated to the end
+ * of the reap list.  To keep the list maintenance portion of these operations
+ * O(1) also, list tails need to be accessible without walking the entire list.
+ * This is the reason why doubly linked list heads are used.
+ */
+
+/*
+ * An MRU Cache is a dynamic data structure that stores its elements in a way
+ * that allows efficient lookups, but also groups them into discrete time
+ * intervals based on insertion time.  This allows elements to be efficiently
+ * and automatically reaped after a fixed period of inactivity.
+ *
+ * When a client data pointer is stored in the MRU Cache it needs to be added to
+ * both the data store and to one of the lists.  It must also be possible to
+ * access each of these entries via the other, i.e. to:
+ *
+ *    a) Walk a list, removing the corresponding data store entry for each item.
+ *    b) Look up a data store entry, then access its list entry directly.
+ *
+ * To achieve both of these goals, each entry must contain both a list entry and
+ * a key, in addition to the user's data pointer.  Note that it's not a good
+ * idea to have the client embed one of these structures at the top of their own
+ * data structure, because inserting the same item more than once would most
+ * likely result in a loop in one of the lists.  That's a sure-fire recipe for
+ * an infinite loop in the code.
+ */
+typedef struct xfs_mru_cache_elem
+{
+        struct list_head list_node;
+        unsigned long   key;
+        void            *value;
+} xfs_mru_cache_elem_t;
+
+static kmem_zone_t              *xfs_mru_elem_zone;
+static struct workqueue_struct  *xfs_mru_reap_wq;
+
+/*
+ * When inserting, destroying or reaping, it's first necessary to update the
+ * lists relative to a particular time.  In the case of destroying, that time
+ * will be well in the future to ensure that all items are moved to the reap
+ * list.  In all other cases though, the time will be the current time.
+ *
+ * This function enters a loop, moving the contents of the LRU list to the reap
+ * list again and again until either a) the lists are all empty, or b) time zero
+ * has been advanced sufficiently to be within the immediate element lifetime.
+ *
+ * Case a) above is detected by counting how many groups are migrated and
+ * stopping when they've all been moved.  Case b) is detected by monitoring the
+ * time_zero field, which is updated as each group is migrated.
+ *
+ * The return value is the earliest time that more migration could be needed, or
+ * zero if there's no need to schedule more work because the lists are empty.
+ */
+STATIC unsigned long
+_xfs_mru_cache_migrate(
+        xfs_mru_cache_t *mru,
+        unsigned long   now)
+{
+        unsigned int    grp;
+        unsigned int    migrated = 0;
+        struct list_head *lru_list;
+
+        /* Nothing to do if the data store is empty. */
+        if (!mru->time_zero)
+                return 0;
+
+        /* While time zero is older than the time spanned by all the lists. */
+        while (mru->time_zero <= now - mru->grp_count * mru->grp_time) {
+
+                /*
+                 * If the LRU list isn't empty, migrate its elements to the tail
+                 * of the reap list.
+                 */
+                lru_list = mru->lists + mru->lru_grp;
+                if (!list_empty(lru_list))
+                        list_splice_init(lru_list, mru->reap_list.prev);
+
+                /*
+                 * Advance the LRU group number, freeing the old LRU list to
+                 * become the new MRU list; advance time zero accordingly.
+                 */
+                mru->lru_grp = (mru->lru_grp + 1) % mru->grp_count;
+                mru->time_zero += mru->grp_time;
+
+                /*
+                 * If reaping is so far behind that all the elements on all the
+                 * lists have been migrated to the reap list, it's now empty.
+                 */
+                if (++migrated == mru->grp_count) {
+                        mru->lru_grp = 0;
+                        mru->time_zero = 0;
+                        return 0;
+                }
+        }
+
+        /* Find the first non-empty list from the LRU end. */
+        for (grp = 0; grp < mru->grp_count; grp++) {
+
+                /* Check the grp'th list from the LRU end. */
+                lru_list = mru->lists + ((mru->lru_grp + grp) % mru->grp_count);
+                if (!list_empty(lru_list))
+                        return mru->time_zero +
+                               (mru->grp_count + grp) * mru->grp_time;
+        }
+
+        /* All the lists must be empty. */
+        mru->lru_grp = 0;
+        mru->time_zero = 0;
+        return 0;
+}
+
+/*
+ * When inserting or doing a lookup, an element needs to be inserted into the
+ * MRU list.  The lists must be migrated first to ensure that they're
+ * up-to-date, otherwise the new element could be given a shorter lifetime in
+ * the cache than it should.
+ */
+STATIC void
+_xfs_mru_cache_list_insert(
+        xfs_mru_cache_t         *mru,
+        xfs_mru_cache_elem_t    *elem)
+{
+        unsigned int    grp = 0;
+        unsigned long   now = jiffies;
+
+        /*
+         * If the data store is empty, initialise time zero, leave grp set to
+         * zero and start the work queue timer if necessary.  Otherwise, set grp
+         * to the number of group times that have elapsed since time zero.
+         */
+        if (!_xfs_mru_cache_migrate(mru, now)) {
+                mru->time_zero = now;
+                if (!mru->next_reap)
+                        mru->next_reap = mru->grp_count * mru->grp_time;
+        } else {
+                grp = (now - mru->time_zero) / mru->grp_time;
+                grp = (mru->lru_grp + grp) % mru->grp_count;
+        }
+
+        /* Insert the element at the tail of the corresponding list. */
+        list_add_tail(&elem->list_node, mru->lists + grp);
+}
+
+/*
+ * When destroying or reaping, all the elements that were migrated to the reap
+ * list need to be deleted.  For each element this involves removing it from the
+ * data store, removing it from the reap list, calling the client's free
+ * function and deleting the element from the element zone.
+ */
+STATIC void
+_xfs_mru_cache_clear_reap_list(
+        xfs_mru_cache_t         *mru)
+{
+        xfs_mru_cache_elem_t    *elem, *next;
+        struct list_head        tmp;
+
+        INIT_LIST_HEAD(&tmp);
+        list_for_each_entry_safe(elem, next, &mru->reap_list, list_node) {
+
+                /* Remove the element from the data store. */
+                radix_tree_delete(&mru->store, elem->key);
+
+                /*
+                 * remove to temp list so it can be freed without
+                 * needing to hold the lock
+                 */
+                list_move(&elem->list_node, &tmp);
+        }
+        mutex_spinunlock(&mru->lock, 0);
+
+        list_for_each_entry_safe(elem, next, &tmp, list_node) {
+
+                /* Remove the element from the reap list. */
+                list_del_init(&elem->list_node);
+
+                /* Call the client's free function with the key and value pointer. */
+                mru->free_func(elem->key, elem->value);
+
+                /* Free the element structure. */
+                kmem_zone_free(xfs_mru_elem_zone, elem);
+        }
+
+        mutex_spinlock(&mru->lock);
+}
+
+/*
+ * We fire the reap timer every group expiry interval so
+ * we always have a reaper ready to run. This makes shutdown
+ * and flushing of the reaper easy to do. Hence we need to
+ * keep when the next reap must occur so we can determine
+ * at each interval whether there is anything we need to do.
+ */
+STATIC void
+_xfs_mru_cache_reap(
+        struct work_struct      *work)
+{
+        xfs_mru_cache_t         *mru = container_of(work, xfs_mru_cache_t, work.work);
+        unsigned long           now;
+
+        ASSERT(mru && mru->lists);
+        if (!mru || !mru->lists)
+                return;
+
+        mutex_spinlock(&mru->lock);
+        now = jiffies;
+        if (mru->reap_all ||
+            (mru->next_reap && time_after(now, mru->next_reap))) {
+                if (mru->reap_all)
+                        now += mru->grp_count * mru->grp_time * 2;
+                mru->next_reap = _xfs_mru_cache_migrate(mru, now);
+                _xfs_mru_cache_clear_reap_list(mru);
+        }
+
+        /*
+         * the process that triggered the reap_all is responsible
+         * for restating the periodic reap if it is required.
+         */
+        if (!mru->reap_all)
+                queue_delayed_work(xfs_mru_reap_wq, &mru->work, mru->grp_time);
+        mru->reap_all = 0;
+        mutex_spinunlock(&mru->lock, 0);
+}
+
+int
+xfs_mru_cache_init(void)
+{
+        xfs_mru_elem_zone = kmem_zone_init(sizeof(xfs_mru_cache_elem_t),
+                                         "xfs_mru_cache_elem");
+        if (!xfs_mru_elem_zone)
+                return ENOMEM;
+
+        xfs_mru_reap_wq = create_singlethread_workqueue("xfs_mru_cache");
+        if (!xfs_mru_reap_wq) {
+                kmem_zone_destroy(xfs_mru_elem_zone);
+                return ENOMEM;
+        }
+
+        return 0;
+}
+
+void
+xfs_mru_cache_uninit(void)
+{
+        destroy_workqueue(xfs_mru_reap_wq);
+        kmem_zone_destroy(xfs_mru_elem_zone);
+}
+
+/*
+ * To initialise a struct xfs_mru_cache pointer, call xfs_mru_cache_create()
+ * with the address of the pointer, a lifetime value in milliseconds, a group
+ * count and a free function to use when deleting elements.  This function
+ * returns 0 if the initialisation was successful.
+ */
+int
+xfs_mru_cache_create(
+        xfs_mru_cache_t         **mrup,
+        unsigned int            lifetime_ms,
+        unsigned int            grp_count,
+        xfs_mru_cache_free_func_t free_func)
+{
+        xfs_mru_cache_t *mru = NULL;
+        int             err = 0, grp;
+        unsigned int    grp_time;
+
+        if (mrup)
+                *mrup = NULL;
+
+        if (!mrup || !grp_count || !lifetime_ms || !free_func)
+                return EINVAL;
+
+        if (!(grp_time = msecs_to_jiffies(lifetime_ms) / grp_count))
+                return EINVAL;
+
+        if (!(mru = kmem_zalloc(sizeof(*mru), KM_SLEEP)))
+                return ENOMEM;
+
+        /* An extra list is needed to avoid reaping up to a grp_time early. */
+        mru->grp_count = grp_count + 1;
+        mru->lists = kmem_alloc(mru->grp_count * sizeof(*mru->lists), KM_SLEEP);
+
+        if (!mru->lists) {
+                err = ENOMEM;
+                goto exit;
+        }
+
+        for (grp = 0; grp < mru->grp_count; grp++)
+                INIT_LIST_HEAD(mru->lists + grp);
+
+        /*
+         * We use GFP_KERNEL radix tree preload and do inserts under a
+         * spinlock so GFP_ATOMIC is appropriate for the radix tree itself.
+         */
+        INIT_RADIX_TREE(&mru->store, GFP_ATOMIC);
+        INIT_LIST_HEAD(&mru->reap_list);
+        spinlock_init(&mru->lock, "xfs_mru_cache");
+        INIT_DELAYED_WORK(&mru->work, _xfs_mru_cache_reap);
+
+        mru->grp_time  = grp_time;
+        mru->free_func = free_func;
+
+        /* start up the reaper event */
+        mru->next_reap = 0;
+        mru->reap_all = 0;
+        queue_delayed_work(xfs_mru_reap_wq, &mru->work, mru->grp_time);
+
+        *mrup = mru;
+
+exit:
+        if (err && mru && mru->lists)
+                kmem_free(mru->lists, mru->grp_count * sizeof(*mru->lists));
+        if (err && mru)
+                kmem_free(mru, sizeof(*mru));
+
+        return err;
+}
+
+/*
+ * Call xfs_mru_cache_flush() to flush out all cached entries, calling their
+ * free functions as they're deleted.  When this function returns, the caller is
+ * guaranteed that all the free functions for all the elements have finished
+ * executing.
+ *
+ * While we are flushing, we stop the periodic reaper event from triggering.
+ * Normally, we want to restart this periodic event, but if we are shutting
+ * down the cache we do not want it restarted. hence the restart parameter
+ * where 0 = do not restart reaper and 1 = restart reaper.
+ */
+void
+xfs_mru_cache_flush(
+        xfs_mru_cache_t         *mru,
+        int                     restart)
+{
+        if (!mru || !mru->lists)
+                return;
+
+        cancel_rearming_delayed_workqueue(xfs_mru_reap_wq, &mru->work);
+
+        mutex_spinlock(&mru->lock);
+        mru->reap_all = 1;
+        mutex_spinunlock(&mru->lock, 0);
+
+        queue_work(xfs_mru_reap_wq, &mru->work.work);
+        flush_workqueue(xfs_mru_reap_wq);
+
+        mutex_spinlock(&mru->lock);
+        WARN_ON_ONCE(mru->reap_all != 0);
+        mru->reap_all = 0;
+        if (restart)
+                queue_delayed_work(xfs_mru_reap_wq, &mru->work, mru->grp_time);
+        mutex_spinunlock(&mru->lock, 0);
+}
+
+void
+xfs_mru_cache_destroy(
+        xfs_mru_cache_t         *mru)
+{
+        if (!mru || !mru->lists)
+                return;
+
+        /* we don't want the reaper to restart here */
+        xfs_mru_cache_flush(mru, 0);
+
+        kmem_free(mru->lists, mru->grp_count * sizeof(*mru->lists));
+        kmem_free(mru, sizeof(*mru));
+}
+
+/*
+ * To insert an element, call xfs_mru_cache_insert() with the data store, the
+ * element's key and the client data pointer.  This function returns 0 on
+ * success or ENOMEM if memory for the data element couldn't be allocated.
+ */
+int
+xfs_mru_cache_insert(
+        xfs_mru_cache_t *mru,
+        unsigned long   key,
+        void            *value)
+{
+        xfs_mru_cache_elem_t *elem;
+
+        ASSERT(mru && mru->lists);
+        if (!mru || !mru->lists)
+                return EINVAL;
+
+        elem = kmem_zone_zalloc(xfs_mru_elem_zone, KM_SLEEP);
+        if (!elem)
+                return ENOMEM;
+
+        if (radix_tree_preload(GFP_KERNEL)) {
+                kmem_zone_free(xfs_mru_elem_zone, elem);
+                return ENOMEM;
+        }
+
+        INIT_LIST_HEAD(&elem->list_node);
+        elem->key = key;
+        elem->value = value;
+
+        mutex_spinlock(&mru->lock);
+
+        radix_tree_insert(&mru->store, key, elem);
+        radix_tree_preload_end();
+        _xfs_mru_cache_list_insert(mru, elem);
+
+        mutex_spinunlock(&mru->lock, 0);
+
+        return 0;
+}
+
+/*
+ * To remove an element without calling the free function, call
+ * xfs_mru_cache_remove() with the data store and the element's key.  On success
+ * the client data pointer for the removed element is returned, otherwise this
+ * function will return a NULL pointer.
+ */
+void *
+xfs_mru_cache_remove(
+        xfs_mru_cache_t *mru,
+        unsigned long   key)
+{
+        xfs_mru_cache_elem_t *elem;
+        void            *value = NULL;
+
+        ASSERT(mru && mru->lists);
+        if (!mru || !mru->lists)
+                return NULL;
+
+        mutex_spinlock(&mru->lock);
+        elem = radix_tree_delete(&mru->store, key);
+        if (elem) {
+                value = elem->value;
+                list_del(&elem->list_node);
+        }
+
+        mutex_spinunlock(&mru->lock, 0);
+
+        if (elem)
+                kmem_zone_free(xfs_mru_elem_zone, elem);
+
+        return value;
+}
+
+/*
+ * To remove and element and call the free function, call xfs_mru_cache_delete()
+ * with the data store and the element's key.
+ */
+void
+xfs_mru_cache_delete(
+        xfs_mru_cache_t *mru,
+        unsigned long   key)
+{
+        void            *value = xfs_mru_cache_remove(mru, key);
+
+        if (value)
+                mru->free_func(key, value);
+}
+
+/*
+ * To look up an element using its key, call xfs_mru_cache_lookup() with the
+ * data store and the element's key.  If found, the element will be moved to the
+ * head of the MRU list to indicate that it's been touched.
+ *
+ * The internal data structures are protected by a spinlock that is STILL HELD
+ * when this function returns.  Call xfs_mru_cache_done() to release it.  Note
+ * that it is not safe to call any function that might sleep in the interim.
+ *
+ * The implementation could have used reference counting to avoid this
+ * restriction, but since most clients simply want to get, set or test a member
+ * of the returned data structure, the extra per-element memory isn't warranted.
+ *
+ * If the element isn't found, this function returns NULL and the spinlock is
+ * released.  xfs_mru_cache_done() should NOT be called when this occurs.
+ */
+void *
+xfs_mru_cache_lookup(
+        xfs_mru_cache_t *mru,
+        unsigned long   key)
+{
+        xfs_mru_cache_elem_t *elem;
+
+        ASSERT(mru && mru->lists);
+        if (!mru || !mru->lists)
+                return NULL;
+
+        mutex_spinlock(&mru->lock);
+        elem = radix_tree_lookup(&mru->store, key);
+        if (elem) {
+                list_del(&elem->list_node);
+                _xfs_mru_cache_list_insert(mru, elem);
+        }
+        else
+                mutex_spinunlock(&mru->lock, 0);
+
+        return elem ? elem->value : NULL;
+}
+
+/*
+ * To look up an element using its key, but leave its location in the internal
+ * lists alone, call xfs_mru_cache_peek().  If the element isn't found, this
+ * function returns NULL.
+ *
+ * See the comments above the declaration of the xfs_mru_cache_lookup() function
+ * for important locking information pertaining to this call.
+ */
+void *
+xfs_mru_cache_peek(
+        xfs_mru_cache_t *mru,
+        unsigned long   key)
+{
+        xfs_mru_cache_elem_t *elem;
+
+        ASSERT(mru && mru->lists);
+        if (!mru || !mru->lists)
+                return NULL;
+
+        mutex_spinlock(&mru->lock);
+        elem = radix_tree_lookup(&mru->store, key);
+        if (!elem)
+                mutex_spinunlock(&mru->lock, 0);
+
+        return elem ? elem->value : NULL;
+}
+
+/*
+ * To release the internal data structure spinlock after having performed an
+ * xfs_mru_cache_lookup() or an xfs_mru_cache_peek(), call xfs_mru_cache_done()
+ * with the data store pointer.
+ */
+void
+xfs_mru_cache_done(
+        xfs_mru_cache_t *mru)
+{
+        mutex_spinunlock(&mru->lock, 0);
+}
diff --git a/fs/xfs/xfs_mru_cache.h b/fs/xfs/xfs_mru_cache.h
new file mode 100644
index 00000000000..624fd10ee8e
--- /dev/null
+++ b/fs/xfs/xfs_mru_cache.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2006-2007 Silicon Graphics, Inc.
+ * All Rights Reserved.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it would be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write the Free Software Foundation,
+ * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+#ifndef __XFS_MRU_CACHE_H__
+#define __XFS_MRU_CACHE_H__
+
+
+/* Function pointer type for callback to free a client's data pointer. */
+typedef void (*xfs_mru_cache_free_func_t)(unsigned long, void*);
+
+typedef struct xfs_mru_cache
+{
+        struct radix_tree_root  store;     /* Core storage data structure.  */
+        struct list_head        *lists;    /* Array of lists, one per grp.  */
+        struct list_head        reap_list; /* Elements overdue for reaping. */
+        spinlock_t              lock;      /* Lock to protect this struct.  */
+        unsigned int            grp_count; /* Number of discrete groups.    */
+        unsigned int            grp_time;  /* Time period spanned by grps.  */
+        unsigned int            lru_grp;   /* Group containing time zero.   */
+        unsigned long           time_zero; /* Time first element was added. */
+        unsigned long           next_reap; /* Time that the reaper should
+                                              next do something. */
+        unsigned int            reap_all;  /* if set, reap all lists */
+        xfs_mru_cache_free_func_t free_func; /* Function pointer for freeing. */
+        struct delayed_work     work;      /* Workqueue data for reaping.   */
+} xfs_mru_cache_t;
+
+int xfs_mru_cache_init(void);
+void xfs_mru_cache_uninit(void);
+int xfs_mru_cache_create(struct xfs_mru_cache **mrup, unsigned int lifetime_ms,
+                             unsigned int grp_count,
+                             xfs_mru_cache_free_func_t free_func);
+void xfs_mru_cache_flush(xfs_mru_cache_t *mru, int restart);
+void xfs_mru_cache_destroy(struct xfs_mru_cache *mru);
+int xfs_mru_cache_insert(struct xfs_mru_cache *mru, unsigned long key,
+                                void *value);
+void * xfs_mru_cache_remove(struct xfs_mru_cache *mru, unsigned long key);
+void xfs_mru_cache_delete(struct xfs_mru_cache *mru, unsigned long key);
+void *xfs_mru_cache_lookup(struct xfs_mru_cache *mru, unsigned long key);
+void *xfs_mru_cache_peek(struct xfs_mru_cache *mru, unsigned long key);
+void xfs_mru_cache_done(struct xfs_mru_cache *mru);
+
+#endif /* __XFS_MRU_CACHE_H__ */
diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index b3a5f07bd07..47082c01872 100644
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -1882,11 +1882,13 @@ xfs_growfs_rt(
             (nrblocks = in->newblocks) <= sbp->sb_rblocks ||
             (sbp->sb_rblocks && (in->extsize != sbp->sb_rextsize)))
                 return XFS_ERROR(EINVAL);
+        if ((error = xfs_sb_validate_fsb_count(sbp, nrblocks)))
+                return error;
         /*
          * Read in the last block of the device, make sure it exists.
          */
         error = xfs_read_buf(mp, mp->m_rtdev_targp,
-                        XFS_FSB_TO_BB(mp, in->newblocks - 1),
+                        XFS_FSB_TO_BB(mp, nrblocks - 1),
                         XFS_FSB_TO_BB(mp, 1), 0, &bp);
         if (error)
                 return error;
diff --git a/fs/xfs/xfs_rw.h b/fs/xfs/xfs_rw.h
index 188b296ff50..fcf28dbded7 100644
--- a/fs/xfs/xfs_rw.h
+++ b/fs/xfs/xfs_rw.h
@@ -72,6 +72,34 @@ xfs_fsb_to_db_io(struct xfs_iocore *io, xfs_fsblock_t fsb)
 }
 
 /*
+ * Flags for xfs_free_eofblocks
+ */
+#define XFS_FREE_EOF_LOCK       (1<<0)
+#define XFS_FREE_EOF_NOLOCK     (1<<1)
+
+
+/*
+ * helper function to extract extent size hint from inode
+ */
+STATIC_INLINE xfs_extlen_t
+xfs_get_extsz_hint(
+        xfs_inode_t     *ip)
+{
+        xfs_extlen_t    extsz;
+
+        if (unlikely(ip->i_d.di_flags & XFS_DIFLAG_REALTIME)) {
+                extsz = (ip->i_d.di_flags & XFS_DIFLAG_EXTSIZE)
+                                ? ip->i_d.di_extsize
+                                : ip->i_mount->m_sb.sb_rextsize;
+                ASSERT(extsz);
+        } else {
+                extsz = (ip->i_d.di_flags & XFS_DIFLAG_EXTSIZE)
+                                ? ip->i_d.di_extsize : 0;
+        }
+        return extsz;
+}
+
+/*
  * Prototypes for functions in xfs_rw.c.
  */
 extern int xfs_write_clear_setuid(struct xfs_inode *ip);
@@ -91,10 +119,12 @@ extern void xfs_ioerror_alert(char *func, struct xfs_mount *mp,
 extern int xfs_rwlock(bhv_desc_t *bdp, bhv_vrwlock_t write_lock);
 extern void xfs_rwunlock(bhv_desc_t *bdp, bhv_vrwlock_t write_lock);
 extern int xfs_setattr(bhv_desc_t *, bhv_vattr_t *vap, int flags,
-                       cred_t *credp);
+                        cred_t *credp);
 extern int xfs_change_file_space(bhv_desc_t *bdp, int cmd, xfs_flock64_t *bf,
-                                 xfs_off_t offset, cred_t *credp, int flags);
+                        xfs_off_t offset, cred_t *credp, int flags);
 extern int xfs_set_dmattrs(bhv_desc_t *bdp, u_int evmask, u_int16_t state,
-                           cred_t *credp);
+                        cred_t *credp);
+extern int xfs_free_eofblocks(struct xfs_mount *mp, struct xfs_inode *ip,
+                        int flags);
 
 #endif /* __XFS_RW_H__ */
diff --git a/fs/xfs/xfs_sb.h b/fs/xfs/xfs_sb.h
index 467854b45c8..ef42537a607 100644
--- a/fs/xfs/xfs_sb.h
+++ b/fs/xfs/xfs_sb.h
@@ -74,12 +74,13 @@ struct xfs_mount;
  */
 #define XFS_SB_VERSION2_REALFBITS       0x00ffffff      /* Mask: features */
 #define XFS_SB_VERSION2_RESERVED1BIT    0x00000001
-#define XFS_SB_VERSION2_RESERVED2BIT    0x00000002
+#define XFS_SB_VERSION2_LAZYSBCOUNTBIT  0x00000002      /* Superblk counters */
 #define XFS_SB_VERSION2_RESERVED4BIT    0x00000004
 #define XFS_SB_VERSION2_ATTR2BIT        0x00000008      /* Inline attr rework */
 
 #define XFS_SB_VERSION2_OKREALFBITS     \
-        (XFS_SB_VERSION2_ATTR2BIT)
+        (XFS_SB_VERSION2_LAZYSBCOUNTBIT | \
+         XFS_SB_VERSION2_ATTR2BIT)
 #define XFS_SB_VERSION2_OKSASHFBITS     \
         (0)
 #define XFS_SB_VERSION2_OKREALBITS      \
@@ -181,6 +182,9 @@ typedef enum {
 #define XFS_SB_SHARED_VN        XFS_SB_MVAL(SHARED_VN)
 #define XFS_SB_UNIT             XFS_SB_MVAL(UNIT)
 #define XFS_SB_WIDTH            XFS_SB_MVAL(WIDTH)
+#define XFS_SB_ICOUNT           XFS_SB_MVAL(ICOUNT)
+#define XFS_SB_IFREE            XFS_SB_MVAL(IFREE)
+#define XFS_SB_FDBLOCKS         XFS_SB_MVAL(FDBLOCKS)
 #define XFS_SB_FEATURES2        XFS_SB_MVAL(FEATURES2)
 #define XFS_SB_NUM_BITS         ((int)XFS_SBS_FIELDCOUNT)
 #define XFS_SB_ALL_BITS         ((1LL << XFS_SB_NUM_BITS) - 1)
@@ -188,7 +192,7 @@ typedef enum {
         (XFS_SB_UUID | XFS_SB_ROOTINO | XFS_SB_RBMINO | XFS_SB_RSUMINO | \
          XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO | XFS_SB_GQUOTINO | \
          XFS_SB_QFLAGS | XFS_SB_SHARED_VN | XFS_SB_UNIT | XFS_SB_WIDTH | \
-         XFS_SB_FEATURES2)
+         XFS_SB_ICOUNT | XFS_SB_IFREE | XFS_SB_FDBLOCKS | XFS_SB_FEATURES2)
 
 
 /*
@@ -414,6 +418,12 @@ static inline int xfs_sb_version_hasmorebits(xfs_sb_t *sbp)
  *       ((sbp)->sb_features2 & XFS_SB_VERSION2_FUNBIT)
  */
 
+static inline int xfs_sb_version_haslazysbcount(xfs_sb_t *sbp)
+{
+        return (XFS_SB_VERSION_HASMOREBITS(sbp) &&      \
+                ((sbp)->sb_features2 & XFS_SB_VERSION2_LAZYSBCOUNTBIT));
+}
+
 #define XFS_SB_VERSION_HASATTR2(sbp)    xfs_sb_version_hasattr2(sbp)
 static inline int xfs_sb_version_hasattr2(xfs_sb_t *sbp)
 {
diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
index cc2d60951e2..356d6627f58 100644
--- a/fs/xfs/xfs_trans.c
+++ b/fs/xfs/xfs_trans.c
@@ -427,6 +427,14 @@ undo_blocks:
  *
  * Mark the transaction structure to indicate that the superblock
  * needs to be updated before committing.
+ *
+ * Because we may not be keeping track of allocated/free inodes and
+ * used filesystem blocks in the superblock, we do not mark the
+ * superblock dirty in this transaction if we modify these fields.
+ * We still need to update the transaction deltas so that they get
+ * applied to the incore superblock, but we don't want them to
+ * cause the superblock to get locked and logged if these are the
+ * only fields in the superblock that the transaction modifies.
  */
 void
 xfs_trans_mod_sb(
@@ -434,13 +442,19 @@ xfs_trans_mod_sb(
         uint            field,
         int64_t         delta)
 {
+        uint32_t        flags = (XFS_TRANS_DIRTY|XFS_TRANS_SB_DIRTY);
+        xfs_mount_t     *mp = tp->t_mountp;
 
         switch (field) {
         case XFS_TRANS_SB_ICOUNT:
                 tp->t_icount_delta += delta;
+                if (xfs_sb_version_haslazysbcount(&mp->m_sb))
+                        flags &= ~XFS_TRANS_SB_DIRTY;
                 break;
         case XFS_TRANS_SB_IFREE:
                 tp->t_ifree_delta += delta;
+                if (xfs_sb_version_haslazysbcount(&mp->m_sb))
+                        flags &= ~XFS_TRANS_SB_DIRTY;
                 break;
         case XFS_TRANS_SB_FDBLOCKS:
                 /*
@@ -453,6 +467,8 @@ xfs_trans_mod_sb(
                         ASSERT(tp->t_blk_res_used <= tp->t_blk_res);
                 }
                 tp->t_fdblocks_delta += delta;
+                if (xfs_sb_version_haslazysbcount(&mp->m_sb))
+                        flags &= ~XFS_TRANS_SB_DIRTY;
                 break;
         case XFS_TRANS_SB_RES_FDBLOCKS:
                 /*
@@ -462,6 +478,8 @@ xfs_trans_mod_sb(
                  */
                 ASSERT(delta < 0);
                 tp->t_res_fdblocks_delta += delta;
+                if (xfs_sb_version_haslazysbcount(&mp->m_sb))
+                        flags &= ~XFS_TRANS_SB_DIRTY;
                 break;
         case XFS_TRANS_SB_FREXTENTS:
                 /*
@@ -515,7 +533,7 @@ xfs_trans_mod_sb(
                 return;
         }
 
-        tp->t_flags |= (XFS_TRANS_SB_DIRTY | XFS_TRANS_DIRTY);
+        tp->t_flags |= flags;
 }
 
 /*
@@ -544,18 +562,23 @@ xfs_trans_apply_sb_deltas(
                (tp->t_ag_freeblks_delta + tp->t_ag_flist_delta +
                 tp->t_ag_btree_delta));
 
-        if (tp->t_icount_delta != 0) {
-                INT_MOD(sbp->sb_icount, ARCH_CONVERT, tp->t_icount_delta);
-        }
-        if (tp->t_ifree_delta != 0) {
-                INT_MOD(sbp->sb_ifree, ARCH_CONVERT, tp->t_ifree_delta);
-        }
+        /*
+         * Only update the superblock counters if we are logging them
+         */
+        if (!xfs_sb_version_haslazysbcount(&(tp->t_mountp->m_sb))) {
+                if (tp->t_icount_delta != 0) {
+                        INT_MOD(sbp->sb_icount, ARCH_CONVERT, tp->t_icount_delta);
+                }
+                if (tp->t_ifree_delta != 0) {
+                        INT_MOD(sbp->sb_ifree, ARCH_CONVERT, tp->t_ifree_delta);
+                }
 
-        if (tp->t_fdblocks_delta != 0) {
-                INT_MOD(sbp->sb_fdblocks, ARCH_CONVERT, tp->t_fdblocks_delta);
-        }
-        if (tp->t_res_fdblocks_delta != 0) {
-                INT_MOD(sbp->sb_fdblocks, ARCH_CONVERT, tp->t_res_fdblocks_delta);
+                if (tp->t_fdblocks_delta != 0) {
+                        INT_MOD(sbp->sb_fdblocks, ARCH_CONVERT, tp->t_fdblocks_delta);
+                }
+                if (tp->t_res_fdblocks_delta != 0) {
+                        INT_MOD(sbp->sb_fdblocks, ARCH_CONVERT, tp->t_res_fdblocks_delta);
+                }
         }
 
         if (tp->t_frextents_delta != 0) {
@@ -615,11 +638,23 @@ xfs_trans_apply_sb_deltas(
 }
 
 /*
- * xfs_trans_unreserve_and_mod_sb() is called to release unused
- * reservations and apply superblock counter changes to the in-core
- * superblock.
+ * xfs_trans_unreserve_and_mod_sb() is called to release unused reservations
+ * and apply superblock counter changes to the in-core superblock.  The
+ * t_res_fdblocks_delta and t_res_frextents_delta fields are explicitly NOT
+ * applied to the in-core superblock.  The idea is that that has already been
+ * done.
  *
  * This is done efficiently with a single call to xfs_mod_incore_sb_batch().
+ * However, we have to ensure that we only modify each superblock field only
+ * once because the application of the delta values may not be atomic. That can
+ * lead to ENOSPC races occurring if we have two separate modifcations of the
+ * free space counter to put back the entire reservation and then take away
+ * what we used.
+ *
+ * If we are not logging superblock counters, then the inode allocated/free and
+ * used block counts are not updated in the on disk superblock. In this case,
+ * XFS_TRANS_SB_DIRTY will not be set when the transaction is updated but we
+ * still need to update the incore superblock with the changes.
  */
 STATIC void
 xfs_trans_unreserve_and_mod_sb(
@@ -627,40 +662,49 @@ xfs_trans_unreserve_and_mod_sb(
 {
         xfs_mod_sb_t    msb[14];        /* If you add cases, add entries */
         xfs_mod_sb_t    *msbp;
+        xfs_mount_t     *mp = tp->t_mountp;
         /* REFERENCED */
         int             error;
         int             rsvd;
+        int64_t         blkdelta = 0;
+        int64_t         rtxdelta = 0;
 
         msbp = msb;
         rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
 
-        /*
-         * Release any reserved blocks.  Any that were allocated
-         * will be taken back again by fdblocks_delta below.
-         */
-        if (tp->t_blk_res > 0) {
+        /* calculate free blocks delta */
+        if (tp->t_blk_res > 0)
+                blkdelta = tp->t_blk_res;
+
+        if ((tp->t_fdblocks_delta != 0) &&
+            (xfs_sb_version_haslazysbcount(&mp->m_sb) ||
+             (tp->t_flags & XFS_TRANS_SB_DIRTY)))
+                blkdelta += tp->t_fdblocks_delta;
+
+        if (blkdelta != 0) {
                 msbp->msb_field = XFS_SBS_FDBLOCKS;
-                msbp->msb_delta = tp->t_blk_res;
+                msbp->msb_delta = blkdelta;
                 msbp++;
         }
 
-        /*
-         * Release any reserved real time extents .  Any that were
-         * allocated will be taken back again by frextents_delta below.
-         */
-        if (tp->t_rtx_res > 0) {
+        /* calculate free realtime extents delta */
+        if (tp->t_rtx_res > 0)
+                rtxdelta = tp->t_rtx_res;
+
+        if ((tp->t_frextents_delta != 0) &&
+            (tp->t_flags & XFS_TRANS_SB_DIRTY))
+                rtxdelta += tp->t_frextents_delta;
+
+        if (rtxdelta != 0) {
                 msbp->msb_field = XFS_SBS_FREXTENTS;
-                msbp->msb_delta = tp->t_rtx_res;
+                msbp->msb_delta = rtxdelta;
                 msbp++;
         }
 
-        /*
-         * Apply any superblock modifications to the in-core version.
-         * The t_res_fdblocks_delta and t_res_frextents_delta fields are
-         * explicitly NOT applied to the in-core superblock.
-         * The idea is that that has already been done.
-         */
-        if (tp->t_flags & XFS_TRANS_SB_DIRTY) {
+        /* apply remaining deltas */
+
+        if (xfs_sb_version_haslazysbcount(&mp->m_sb) ||
+             (tp->t_flags & XFS_TRANS_SB_DIRTY)) {
                 if (tp->t_icount_delta != 0) {
                         msbp->msb_field = XFS_SBS_ICOUNT;
                         msbp->msb_delta = tp->t_icount_delta;
@@ -671,16 +715,9 @@ xfs_trans_unreserve_and_mod_sb(
                         msbp->msb_delta = tp->t_ifree_delta;
                         msbp++;
                 }
-                if (tp->t_fdblocks_delta != 0) {
-                        msbp->msb_field = XFS_SBS_FDBLOCKS;
-                        msbp->msb_delta = tp->t_fdblocks_delta;
-                        msbp++;
-                }
-                if (tp->t_frextents_delta != 0) {
-                        msbp->msb_field = XFS_SBS_FREXTENTS;
-                        msbp->msb_delta = tp->t_frextents_delta;
-                        msbp++;
-                }
+        }
+
+        if (tp->t_flags & XFS_TRANS_SB_DIRTY) {
                 if (tp->t_dblocks_delta != 0) {
                         msbp->msb_field = XFS_SBS_DBLOCKS;
                         msbp->msb_delta = tp->t_dblocks_delta;
diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
index 7dfcc450366..0e26e729023 100644
--- a/fs/xfs/xfs_trans.h
+++ b/fs/xfs/xfs_trans.h
@@ -94,7 +94,8 @@ typedef struct xfs_trans_header {
 #define XFS_TRANS_GROWFSRT_ZERO         38
 #define XFS_TRANS_GROWFSRT_FREE         39
 #define XFS_TRANS_SWAPEXT               40
-#define XFS_TRANS_TYPE_MAX              40
+#define XFS_TRANS_SB_COUNT              41
+#define XFS_TRANS_TYPE_MAX              41
 /* new transaction types need to be reflected in xfs_logprint(8) */
 
 
diff --git a/fs/xfs/xfs_vfsops.c b/fs/xfs/xfs_vfsops.c
index 65c561201cb..11f5ea29a03 100644
--- a/fs/xfs/xfs_vfsops.c
+++ b/fs/xfs/xfs_vfsops.c
@@ -51,6 +51,8 @@
 #include "xfs_acl.h"
 #include "xfs_attr.h"
 #include "xfs_clnt.h"
+#include "xfs_mru_cache.h"
+#include "xfs_filestream.h"
 #include "xfs_fsops.h"
 
 STATIC int      xfs_sync(bhv_desc_t *, int, cred_t *);
@@ -81,6 +83,8 @@ xfs_init(void)
         xfs_dabuf_zone = kmem_zone_init(sizeof(xfs_dabuf_t), "xfs_dabuf");
         xfs_ifork_zone = kmem_zone_init(sizeof(xfs_ifork_t), "xfs_ifork");
         xfs_acl_zone_init(xfs_acl_zone, "xfs_acl");
+        xfs_mru_cache_init();
+        xfs_filestream_init();
 
         /*
          * The size of the zone allocated buf log item is the maximum
@@ -164,6 +168,8 @@ xfs_cleanup(void)
         xfs_cleanup_procfs();
         xfs_sysctl_unregister();
         xfs_refcache_destroy();
+        xfs_filestream_uninit();
+        xfs_mru_cache_uninit();
         xfs_acl_zone_destroy(xfs_acl_zone);
 
 #ifdef XFS_DIR2_TRACE
@@ -320,6 +326,9 @@ xfs_start_flags(
         else
                 mp->m_flags &= ~XFS_MOUNT_BARRIER;
 
+        if (ap->flags2 & XFSMNT2_FILESTREAMS)
+                mp->m_flags |= XFS_MOUNT_FILESTREAMS;
+
         return 0;
 }
 
@@ -518,6 +527,9 @@ xfs_mount(
         if (mp->m_flags & XFS_MOUNT_BARRIER)
                 xfs_mountfs_check_barriers(mp);
 
+        if ((error = xfs_filestream_mount(mp)))
+                goto error2;
+
         error = XFS_IOINIT(vfsp, args, flags);
         if (error)
                 goto error2;
@@ -575,6 +587,13 @@ xfs_unmount(
          */
         xfs_refcache_purge_mp(mp);
 
+        /*
+         * Blow away any referenced inode in the filestreams cache.
+         * This can and will cause log traffic as inodes go inactive
+         * here.
+         */
+        xfs_filestream_unmount(mp);
+
         XFS_bflush(mp->m_ddev_targp);
         error = xfs_unmount_flush(mp, 0);
         if (error)
@@ -640,7 +659,7 @@ xfs_quiesce_fs(
          * we can write the unmount record.
          */
         do {
-                xfs_syncsub(mp, SYNC_REMOUNT|SYNC_ATTR|SYNC_WAIT, NULL);
+                xfs_syncsub(mp, SYNC_INODE_QUIESCE, NULL);
                 pincount = xfs_flush_buftarg(mp->m_ddev_targp, 1);
                 if (!pincount) {
                         delay(50);
@@ -651,6 +670,30 @@ xfs_quiesce_fs(
         return 0;
 }
 
+/*
+ * Second stage of a quiesce. The data is already synced, now we have to take
+ * care of the metadata. New transactions are already blocked, so we need to
+ * wait for any remaining transactions to drain out before proceding.
+ */
+STATIC void
+xfs_attr_quiesce(
+        xfs_mount_t     *mp)
+{
+        /* wait for all modifications to complete */
+        while (atomic_read(&mp->m_active_trans) > 0)
+                delay(100);
+
+        /* flush inodes and push all remaining buffers out to disk */
+        xfs_quiesce_fs(mp);
+
+        ASSERT_ALWAYS(atomic_read(&mp->m_active_trans) == 0);
+
+        /* Push the superblock and write an unmount record */
+        xfs_log_sbcount(mp, 1);
+        xfs_log_unmount_write(mp);
+        xfs_unmountfs_writesb(mp);
+}
+
 STATIC int
 xfs_mntupdate(
         bhv_desc_t                      *bdp,
@@ -670,10 +713,9 @@ xfs_mntupdate(
                         mp->m_flags &= ~XFS_MOUNT_BARRIER;
                 }
         } else if (!(vfsp->vfs_flag & VFS_RDONLY)) {    /* rw -> ro */
-                bhv_vfs_sync(vfsp, SYNC_FSDATA|SYNC_BDFLUSH|SYNC_ATTR, NULL);
-                xfs_quiesce_fs(mp);
-                xfs_log_unmount_write(mp);
-                xfs_unmountfs_writesb(mp);
+                xfs_filestream_flush(mp);
+                bhv_vfs_sync(vfsp, SYNC_DATA_QUIESCE, NULL);
+                xfs_attr_quiesce(mp);
                 vfsp->vfs_flag |= VFS_RDONLY;
         }
         return 0;
@@ -887,6 +929,9 @@ xfs_sync(
 {
         xfs_mount_t     *mp = XFS_BHVTOM(bdp);
 
+        if (flags & SYNC_IOWAIT)
+                xfs_filestream_flush(mp);
+
         return xfs_syncsub(mp, flags, NULL);
 }
 
@@ -1128,58 +1173,41 @@ xfs_sync_inodes(
                  * in the inode list.
                  */
 
-                if ((flags & SYNC_CLOSE)  && (vp != NULL)) {
-                        /*
-                         * This is the shutdown case.  We just need to
-                         * flush and invalidate all the pages associated
-                         * with the inode.  Drop the inode lock since
-                         * we can't hold it across calls to the buffer
-                         * cache.
-                         *
-                         * We don't set the VREMAPPING bit in the vnode
-                         * here, because we don't hold the vnode lock
-                         * exclusively.  It doesn't really matter, though,
-                         * because we only come here when we're shutting
-                         * down anyway.
-                         */
-                        xfs_iunlock(ip, XFS_ILOCK_SHARED);
-
-                        if (XFS_FORCED_SHUTDOWN(mp)) {
-                                bhv_vop_toss_pages(vp, 0, -1, FI_REMAPF);
-                        } else {
-                                error = bhv_vop_flushinval_pages(vp, 0, -1, FI_REMAPF);
+                /*
+                 * If we have to flush data or wait for I/O completion
+                 * we need to drop the ilock that we currently hold.
+                 * If we need to drop the lock, insert a marker if we
+                 * have not already done so.
+                 */
+                if ((flags & (SYNC_CLOSE|SYNC_IOWAIT)) ||
+                    ((flags & SYNC_DELWRI) && VN_DIRTY(vp))) {
+                        if (mount_locked) {
+                                IPOINTER_INSERT(ip, mp);
                         }
+                        xfs_iunlock(ip, XFS_ILOCK_SHARED);
 
-                        xfs_ilock(ip, XFS_ILOCK_SHARED);
-
-                } else if ((flags & SYNC_DELWRI) && (vp != NULL)) {
-                        if (VN_DIRTY(vp)) {
-                                /* We need to have dropped the lock here,
-                                 * so insert a marker if we have not already
-                                 * done so.
-                                 */
-                                if (mount_locked) {
-                                        IPOINTER_INSERT(ip, mp);
-                                }
-
-                                /*
-                                 * Drop the inode lock since we can't hold it
-                                 * across calls to the buffer cache.
-                                 */
-                                xfs_iunlock(ip, XFS_ILOCK_SHARED);
+                        if (flags & SYNC_CLOSE) {
+                                /* Shutdown case. Flush and invalidate. */
+                                if (XFS_FORCED_SHUTDOWN(mp))
+                                        bhv_vop_toss_pages(vp, 0, -1, FI_REMAPF);
+                                else
+                                        error = bhv_vop_flushinval_pages(vp, 0,
+                                                                -1, FI_REMAPF);
+                        } else if ((flags & SYNC_DELWRI) && VN_DIRTY(vp)) {
                                 error = bhv_vop_flush_pages(vp, (xfs_off_t)0,
                                                         -1, fflag, FI_NONE);
-                                xfs_ilock(ip, XFS_ILOCK_SHARED);
                         }
 
+                        /*
+                         * When freezing, we need to wait ensure all I/O (including direct
+                         * I/O) is complete to ensure no further data modification can take
+                         * place after this point
+                         */
+                        if (flags & SYNC_IOWAIT)
+                                vn_iowait(vp);
+
+                        xfs_ilock(ip, XFS_ILOCK_SHARED);
                 }
-                /*
-                 * When freezing, we need to wait ensure all I/O (including direct
-                 * I/O) is complete to ensure no further data modification can take
-                 * place after this point
-                 */
-                if (flags & SYNC_IOWAIT)
-                        vn_iowait(vp);
 
                 if (flags & SYNC_BDFLUSH) {
                         if ((flags & SYNC_ATTR) &&
@@ -1514,6 +1542,15 @@ xfs_syncsub(
         }
 
         /*
+         * If asked, update the disk superblock with incore counter values if we
+         * are using non-persistent counters so that they don't get too far out
+         * of sync if we crash or get a forced shutdown. We don't want to force
+         * this to disk, just get a transaction into the iclogs....
+         */
+        if (flags & SYNC_SUPER)
+                xfs_log_sbcount(mp, 0);
+
+        /*
          * Now check to see if the log needs a "dummy" transaction.
          */
 
@@ -1645,6 +1682,7 @@ xfs_vget(
                                          * in stat(). */
 #define MNTOPT_ATTR2    "attr2"         /* do use attr2 attribute format */
 #define MNTOPT_NOATTR2  "noattr2"       /* do not use attr2 attribute format */
+#define MNTOPT_FILESTREAM  "filestreams" /* use filestreams allocator */
 
 STATIC unsigned long
 suffix_strtoul(char *s, char **endp, unsigned int base)
@@ -1831,6 +1869,8 @@ xfs_parseargs(
                         args->flags |= XFSMNT_ATTR2;
                 } else if (!strcmp(this_char, MNTOPT_NOATTR2)) {
                         args->flags &= ~XFSMNT_ATTR2;
+                } else if (!strcmp(this_char, MNTOPT_FILESTREAM)) {
+                        args->flags2 |= XFSMNT2_FILESTREAMS;
                 } else if (!strcmp(this_char, "osyncisdsync")) {
                         /* no-op, this is now the default */
                         cmn_err(CE_WARN,
@@ -1959,9 +1999,9 @@ xfs_showargs(
 }
 
 /*
- * Second stage of a freeze. The data is already frozen, now we have to take
- * care of the metadata. New transactions are already blocked, so we need to
- * wait for any remaining transactions to drain out before proceding.
+ * Second stage of a freeze. The data is already frozen so we only
+ * need to take care of themetadata. Once that's done write a dummy
+ * record to dirty the log in case of a crash while frozen.
  */
 STATIC void
 xfs_freeze(
@@ -1969,18 +2009,7 @@ xfs_freeze(
 {
         xfs_mount_t     *mp = XFS_BHVTOM(bdp);
 
-        /* wait for all modifications to complete */
-        while (atomic_read(&mp->m_active_trans) > 0)
-                delay(100);
-
-        /* flush inodes and push all remaining buffers out to disk */
-        xfs_quiesce_fs(mp);
-
-        ASSERT_ALWAYS(atomic_read(&mp->m_active_trans) == 0);
-
-        /* Push the superblock and write an unmount record */
-        xfs_log_unmount_write(mp);
-        xfs_unmountfs_writesb(mp);
+        xfs_attr_quiesce(mp);
         xfs_fs_log_dummy(mp);
 }
 
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 70bc82f6531..79b522779aa 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -51,6 +51,7 @@
 #include "xfs_refcache.h"
 #include "xfs_trans_space.h"
 #include "xfs_log_priv.h"
+#include "xfs_filestream.h"
 
 STATIC int
 xfs_open(
@@ -77,36 +78,6 @@ xfs_open(
         return 0;
 }
 
-STATIC int
-xfs_close(
-        bhv_desc_t      *bdp,
-        int             flags,
-        lastclose_t     lastclose,
-        cred_t          *credp)
-{
-        bhv_vnode_t     *vp = BHV_TO_VNODE(bdp);
-        xfs_inode_t     *ip = XFS_BHVTOI(bdp);
-
-        if (XFS_FORCED_SHUTDOWN(ip->i_mount))
-                return XFS_ERROR(EIO);
-
-        if (lastclose != L_TRUE || !VN_ISREG(vp))
-                return 0;
-
-        /*
-         * If we previously truncated this file and removed old data in
-         * the process, we want to initiate "early" writeout on the last
-         * close.  This is an attempt to combat the notorious NULL files
-         * problem which is particularly noticable from a truncate down,
-         * buffered (re-)write (delalloc), followed by a crash.  What we
-         * are effectively doing here is significantly reducing the time
-         * window where we'd otherwise be exposed to that problem.
-         */
-        if (VUNTRUNCATE(vp) && VN_DIRTY(vp) && ip->i_delayed_blks > 0)
-                return bhv_vop_flush_pages(vp, 0, -1, XFS_B_ASYNC, FI_NONE);
-        return 0;
-}
-
 /*
  * xfs_getattr
  */
@@ -183,9 +154,8 @@ xfs_getattr(
                          * realtime extent size or the realtime volume's
                          * extent size.
                          */
-                        vap->va_blocksize = ip->i_d.di_extsize ?
-                                (ip->i_d.di_extsize << mp->m_sb.sb_blocklog) :
-                                (mp->m_sb.sb_rextsize << mp->m_sb.sb_blocklog);
+                        vap->va_blocksize =
+                                xfs_get_extsz_hint(ip) << mp->m_sb.sb_blocklog;
                 }
                 break;
         }
@@ -814,6 +784,8 @@ xfs_setattr(
                                 di_flags |= XFS_DIFLAG_PROJINHERIT;
                         if (vap->va_xflags & XFS_XFLAG_NODEFRAG)
                                 di_flags |= XFS_DIFLAG_NODEFRAG;
+                        if (vap->va_xflags & XFS_XFLAG_FILESTREAM)
+                                di_flags |= XFS_DIFLAG_FILESTREAM;
                         if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
                                 if (vap->va_xflags & XFS_XFLAG_RTINHERIT)
                                         di_flags |= XFS_DIFLAG_RTINHERIT;
@@ -1201,13 +1173,15 @@ xfs_fsync(
 }
 
 /*
- * This is called by xfs_inactive to free any blocks beyond eof,
- * when the link count isn't zero.
+ * This is called by xfs_inactive to free any blocks beyond eof
+ * when the link count isn't zero and by xfs_dm_punch_hole() when
+ * punching a hole to EOF.
  */
-STATIC int
-xfs_inactive_free_eofblocks(
+int
+xfs_free_eofblocks(
         xfs_mount_t     *mp,
-        xfs_inode_t     *ip)
+        xfs_inode_t     *ip,
+        int             flags)
 {
         xfs_trans_t     *tp;
         int             error;
@@ -1216,6 +1190,7 @@ xfs_inactive_free_eofblocks(
         xfs_filblks_t   map_len;
         int             nimaps;
         xfs_bmbt_irec_t imap;
+        int             use_iolock = (flags & XFS_FREE_EOF_LOCK);
 
         /*
          * Figure out if there are any blocks beyond the end
@@ -1256,11 +1231,14 @@ xfs_inactive_free_eofblocks(
                  * cache and we can't
                  * do that within a transaction.
                  */
-                xfs_ilock(ip, XFS_IOLOCK_EXCL);
+                if (use_iolock)
+                        xfs_ilock(ip, XFS_IOLOCK_EXCL);
                 error = xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE,
                                     ip->i_size);
                 if (error) {
-                        xfs_iunlock(ip, XFS_IOLOCK_EXCL);
+                        xfs_trans_cancel(tp, 0);
+                        if (use_iolock)
+                                xfs_iunlock(ip, XFS_IOLOCK_EXCL);
                         return error;
                 }
 
@@ -1297,7 +1275,8 @@ xfs_inactive_free_eofblocks(
                         error = xfs_trans_commit(tp,
                                                 XFS_TRANS_RELEASE_LOG_RES);
                 }
-                xfs_iunlock(ip, XFS_IOLOCK_EXCL | XFS_ILOCK_EXCL);
+                xfs_iunlock(ip, (use_iolock ? (XFS_IOLOCK_EXCL|XFS_ILOCK_EXCL)
+                                            : XFS_ILOCK_EXCL));
         }
         return error;
 }
@@ -1560,6 +1539,31 @@ xfs_release(
         if (vp->v_vfsp->vfs_flag & VFS_RDONLY)
                 return 0;
 
+        if (!XFS_FORCED_SHUTDOWN(mp)) {
+                /*
+                 * If we are using filestreams, and we have an unlinked
+                 * file that we are processing the last close on, then nothing
+                 * will be able to reopen and write to this file. Purge this
+                 * inode from the filestreams cache so that it doesn't delay
+                 * teardown of the inode.
+                 */
+                if ((ip->i_d.di_nlink == 0) && xfs_inode_is_filestream(ip))
+                        xfs_filestream_deassociate(ip);
+
+                /*
+                 * If we previously truncated this file and removed old data
+                 * in the process, we want to initiate "early" writeout on
+                 * the last close.  This is an attempt to combat the notorious
+                 * NULL files problem which is particularly noticable from a
+                 * truncate down, buffered (re-)write (delalloc), followed by
+                 * a crash.  What we are effectively doing here is
+                 * significantly reducing the time window where we'd otherwise
+                 * be exposed to that problem.
+                 */
+                if (VUNTRUNCATE(vp) && VN_DIRTY(vp) && ip->i_delayed_blks > 0)
+                        bhv_vop_flush_pages(vp, 0, -1, XFS_B_ASYNC, FI_NONE);
+        }
+
 #ifdef HAVE_REFCACHE
         /* If we are in the NFS reference cache then don't do this now */
         if (ip->i_refcache)
@@ -1573,7 +1577,8 @@ xfs_release(
                      (ip->i_df.if_flags & XFS_IFEXTENTS))  &&
                     (!(ip->i_d.di_flags &
                                 (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)))) {
-                        if ((error = xfs_inactive_free_eofblocks(mp, ip)))
+                        error = xfs_free_eofblocks(mp, ip, XFS_FREE_EOF_LOCK);
+                        if (error)
                                 return error;
                         /* Update linux inode block count after free above */
                         vn_to_inode(vp)->i_blocks = XFS_FSB_TO_BB(mp,
@@ -1654,7 +1659,8 @@ xfs_inactive(
                      (!(ip->i_d.di_flags &
                                 (XFS_DIFLAG_PREALLOC | XFS_DIFLAG_APPEND)) ||
                       (ip->i_delayed_blks != 0)))) {
-                        if ((error = xfs_inactive_free_eofblocks(mp, ip)))
+                        error = xfs_free_eofblocks(mp, ip, XFS_FREE_EOF_LOCK);
+                        if (error)
                                 return VN_INACTIVE_CACHE;
                         /* Update linux inode block count after free above */
                         vn_to_inode(vp)->i_blocks = XFS_FSB_TO_BB(mp,
@@ -1680,6 +1686,7 @@ xfs_inactive(
 
                 error = xfs_itruncate_start(ip, XFS_ITRUNC_DEFINITE, 0);
                 if (error) {
+                        xfs_trans_cancel(tp, 0);
                         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
                         return VN_INACTIVE_CACHE;
                 }
@@ -2217,9 +2224,9 @@ static inline int
 xfs_lock_inumorder(int lock_mode, int subclass)
 {
         if (lock_mode & (XFS_IOLOCK_SHARED|XFS_IOLOCK_EXCL))
-                lock_mode |= (subclass + XFS_IOLOCK_INUMORDER) << XFS_IOLOCK_SHIFT;
+                lock_mode |= (subclass + XFS_LOCK_INUMORDER) << XFS_IOLOCK_SHIFT;
         if (lock_mode & (XFS_ILOCK_SHARED|XFS_ILOCK_EXCL))
-                lock_mode |= (subclass + XFS_ILOCK_INUMORDER) << XFS_ILOCK_SHIFT;
+                lock_mode |= (subclass + XFS_LOCK_INUMORDER) << XFS_ILOCK_SHIFT;
 
         return lock_mode;
 }
@@ -2546,6 +2553,15 @@ xfs_remove(
          */
         xfs_refcache_purge_ip(ip);
 
+        /*
+         * If we are using filestreams, kill the stream association.
+         * If the file is still open it may get a new one but that
+         * will get killed on last close in xfs_close() so we don't
+         * have to worry about that.
+         */
+        if (link_zero && xfs_inode_is_filestream(ip))
+                xfs_filestream_deassociate(ip);
+
         vn_trace_exit(XFS_ITOV(ip), __FUNCTION__, (inst_t *)__return_address);
 
         /*
@@ -4047,22 +4063,16 @@ xfs_alloc_file_space(
         if (XFS_FORCED_SHUTDOWN(mp))
                 return XFS_ERROR(EIO);
 
-        rt = XFS_IS_REALTIME_INODE(ip);
-        if (unlikely(rt)) {
-                if (!(extsz = ip->i_d.di_extsize))
-                        extsz = mp->m_sb.sb_rextsize;
-        } else {
-                extsz = ip->i_d.di_extsize;
-        }
-
         if ((error = XFS_QM_DQATTACH(mp, ip, 0)))
                 return error;
 
         if (len <= 0)
                 return XFS_ERROR(EINVAL);
 
+        rt = XFS_IS_REALTIME_INODE(ip);
+        extsz = xfs_get_extsz_hint(ip);
+
         count = len;
-        error = 0;
         imapp = &imaps[0];
         nimaps = 1;
         bmapi_flag = XFS_BMAPI_WRITE | (alloc_type ? XFS_BMAPI_PREALLOC : 0);
@@ -4678,7 +4688,6 @@ xfs_change_file_space(
 bhv_vnodeops_t xfs_vnodeops = {
         BHV_IDENTITY_INIT(VN_BHV_XFS,VNODE_POSITION_XFS),
         .vop_open               = xfs_open,
-        .vop_close              = xfs_close,
         .vop_read               = xfs_read,
 #ifdef HAVE_SPLICE
         .vop_splice_read        = xfs_splice_read,