109 files changed, 2326 insertions, 6268 deletions
diff --git a/fs/xfs/Kconfig b/fs/xfs/Kconfig
index bac27d66151d..26b364c9d62c 100644
--- a/fs/xfs/Kconfig
+++ b/fs/xfs/Kconfig
@@ -1,6 +1,5 @@
 config XFS_FS
        tristate "XFS filesystem support"
-        select EXPORTFS if NFSD!=n
        help
          XFS is a high performance journaling filesystem which originated
          on the SGI IRIX platform.  It is completely multi-threaded, can
@@ -18,11 +17,6 @@ config XFS_FS
          system of your root partition is compiled as a module, you'll need
          to use an initial ramdisk (initrd) to boot.
-config XFS_EXPORT
-        bool
-        depends on XFS_FS && EXPORTFS
-        default y
 config XFS_QUOTA
        bool "XFS Quota support"
        depends on XFS_FS
@@ -65,18 +59,19 @@ config XFS_POSIX_ACL
          If you don't know what Access Control Lists are, say N.
 config XFS_RT
-        bool "XFS Realtime support (EXPERIMENTAL)"
+        bool "XFS Realtime subvolume support"
-        depends on XFS_FS && EXPERIMENTAL
+        depends on XFS_FS
        help
          If you say Y here you will be able to mount and use XFS filesystems
-          which contain a realtime subvolume. The realtime subvolume is a
+          which contain a realtime subvolume.  The realtime subvolume is a
-          separate area of disk space where only file data is stored. The
+          separate area of disk space where only file data is stored.  It was
-          realtime subvolume is designed to provide very deterministic
+          originally designed to provide deterministic data rates suitable
-          data rates suitable for media streaming applications.
+          for media streaming applications, but is also useful as a generic
+          mechanism for ensuring data and metadata/log I/Os are completely
-          See the xfs man page in section 5 for a bit more information.
+          separated.  Regular file I/Os are isolated to a separate device
+          from all other requests, and this can be done quite transparently
+          to applications via the inherit-realtime directory inode flag.
-          This feature is unsupported at this time, is not yet fully
+          See the xfs man page in section 5 for additional information.
-          functional, and may cause serious problems.
          If unsure, say N.
diff --git a/fs/xfs/Makefile-linux-2.6 b/fs/xfs/Makefile-linux-2.6
index 5d73eaa1971f..9e7f85986d0d 100644
--- a/fs/xfs/Makefile-linux-2.6
+++ b/fs/xfs/Makefile-linux-2.6
@@ -59,7 +59,6 @@ xfs-$(CONFIG_XFS_POSIX_ACL)	+= xfs_acl.o
 xfs-$(CONFIG_PROC_FS)           += $(XFS_LINUX)/xfs_stats.o
 xfs-$(CONFIG_SYSCTL)            += $(XFS_LINUX)/xfs_sysctl.o
 xfs-$(CONFIG_COMPAT)            += $(XFS_LINUX)/xfs_ioctl32.o
-xfs-$(CONFIG_XFS_EXPORT)        += $(XFS_LINUX)/xfs_export.o
 xfs-y                           += xfs_alloc.o \
@@ -73,14 +72,12 @@ xfs-y				+= xfs_alloc.o \
                                   xfs_btree.o \
                                   xfs_buf_item.o \
                                   xfs_da_btree.o \
-                                   xfs_dir.o \
                                   xfs_dir2.o \
                                   xfs_dir2_block.o \
                                   xfs_dir2_data.o \
                                   xfs_dir2_leaf.o \
                                   xfs_dir2_node.o \
                                   xfs_dir2_sf.o \
-                                   xfs_dir_leaf.o \
                                   xfs_error.o \
                                   xfs_extfree_item.o \
                                   xfs_fsops.o \
@@ -117,6 +114,7 @@ xfs-y				+= $(addprefix $(XFS_LINUX)/, \
                                   kmem.o \
                                   xfs_aops.o \
                                   xfs_buf.o \
+                                   xfs_export.o \
                                   xfs_file.o \
                                   xfs_fs_subr.o \
                                   xfs_globals.o \
diff --git a/fs/xfs/linux-2.6/kmem.h b/fs/xfs/linux-2.6/kmem.h
index 2cfd33d4d8aa..939bd84bc7ee 100644
--- a/fs/xfs/linux-2.6/kmem.h
+++ b/fs/xfs/linux-2.6/kmem.h
@@ -23,42 +23,6 @@
 #include <linux/mm.h>
 /*
- * Process flags handling
- */
-#define PFLAGS_TEST_NOIO()              (current->flags & PF_NOIO)
-#define PFLAGS_TEST_FSTRANS()           (current->flags & PF_FSTRANS)
-#define PFLAGS_SET_NOIO() do {          \
-        current->flags |= PF_NOIO;      \
-} while (0)
-#define PFLAGS_CLEAR_NOIO() do {        \
-        current->flags &= ~PF_NOIO;     \
-} while (0)
-/* these could be nested, so we save state */
-#define PFLAGS_SET_FSTRANS(STATEP) do { \
-        *(STATEP) = current->flags;     \
-        current->flags |= PF_FSTRANS;   \
-} while (0)
-#define PFLAGS_CLEAR_FSTRANS(STATEP) do { \
-        *(STATEP) = current->flags;     \
-        current->flags &= ~PF_FSTRANS;  \
-} while (0)
-/* Restore the PF_FSTRANS state to what was saved in STATEP */
-#define PFLAGS_RESTORE_FSTRANS(STATEP) do {                     \
-        current->flags = ((current->flags & ~PF_FSTRANS) |      \
-                          (*(STATEP) & PF_FSTRANS));            \
-} while (0)
-#define PFLAGS_DUP(OSTATEP, NSTATEP) do { \
-        *(NSTATEP) = *(OSTATEP);        \
-} while (0)
-/*
 * General memory allocation interfaces
 */
@@ -83,7 +47,7 @@ kmem_flags_convert(unsigned int __nocast flags)
                lflags = GFP_ATOMIC | __GFP_NOWARN;
        } else {
                lflags = GFP_KERNEL | __GFP_NOWARN;
-                if (PFLAGS_TEST_FSTRANS() || (flags & KM_NOFS))
+                if ((current->flags & PF_FSTRANS) || (flags & KM_NOFS))
                        lflags &= ~__GFP_FS;
        }
        return lflags;
diff --git a/fs/xfs/linux-2.6/mrlock.h b/fs/xfs/linux-2.6/mrlock.h
index 1b262b790d9c..32e1ce0f04c9 100644
--- a/fs/xfs/linux-2.6/mrlock.h
+++ b/fs/xfs/linux-2.6/mrlock.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2005 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
@@ -28,7 +28,7 @@ typedef struct {
 } mrlock_t;
 #define mrinit(mrp, name)       \
-        ( (mrp)->mr_writer = 0, init_rwsem(&(mrp)->mr_lock) )
+        do { (mrp)->mr_writer = 0; init_rwsem(&(mrp)->mr_lock); } while (0)
 #define mrlock_init(mrp, t,n,s) mrinit(mrp, n)
 #define mrfree(mrp)             do { } while (0)
 #define mraccess(mrp)           mraccessf(mrp, 0)
diff --git a/fs/xfs/linux-2.6/sema.h b/fs/xfs/linux-2.6/sema.h
index 194a84490bd1..b25090094cca 100644
--- a/fs/xfs/linux-2.6/sema.h
+++ b/fs/xfs/linux-2.6/sema.h
@@ -34,20 +34,21 @@ typedef struct semaphore sema_t;
 #define initnsema(sp, val, name)        sema_init(sp, val)
 #define psema(sp, b)                    down(sp)
 #define vsema(sp)                       up(sp)
-#define valusema(sp)                    (atomic_read(&(sp)->count))
+#define freesema(sema)                  do { } while (0)
-#define freesema(sema)
+static inline int issemalocked(sema_t *sp)
+{
+        return down_trylock(sp) || (up(sp), 0);
+}
 /*
 * Map cpsema (try to get the sema) to down_trylock. We need to switch
 * the return values since cpsema returns 1 (acquired) 0 (failed) and
 * down_trylock returns the reverse 0 (acquired) 1 (failed).
 */
+static inline int cpsema(sema_t *sp)
-#define cpsema(sp)                      (down_trylock(sp) ? 0 : 1)
+{
+        return down_trylock(sp) ? 0 : 1;
-/*
+}
- * Didn't do cvsema(sp). Not sure how to map this to up/down/...
- * It does a vsema if the values is < 0 other wise nothing.
- */
 #endif /* __XFS_SUPPORT_SEMA_H__ */
diff --git a/fs/xfs/linux-2.6/xfs_aops.c b/fs/xfs/linux-2.6/xfs_aops.c
index 4d191ef39b67..3e807b828e22 100644
--- a/fs/xfs/linux-2.6/xfs_aops.c
+++ b/fs/xfs/linux-2.6/xfs_aops.c
@@ -21,7 +21,6 @@
 #include "xfs_inum.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_trans.h"
 #include "xfs_dmapi.h"
@@ -29,7 +28,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -76,7 +74,7 @@ xfs_page_trace(
        int             mask)
 {
        xfs_inode_t     *ip;
-        vnode_t         *vp = vn_from_inode(inode);
+        bhv_vnode_t     *vp = vn_from_inode(inode);
        loff_t          isize = i_size_read(inode);
        loff_t          offset = page_offset(page);
        int             delalloc = -1, unmapped = -1, unwritten = -1;
@@ -136,9 +134,10 @@ xfs_destroy_ioend(
        for (bh = ioend->io_buffer_head; bh; bh = next) {
                next = bh->b_private;
-                bh->b_end_io(bh, ioend->io_uptodate);
+                bh->b_end_io(bh, !ioend->io_error);
        }
+        if (unlikely(ioend->io_error))
+                vn_ioerror(ioend->io_vnode, ioend->io_error, __FILE__,__LINE__);
        vn_iowake(ioend->io_vnode);
        mempool_free(ioend, xfs_ioend_pool);
 }
@@ -180,13 +179,12 @@ xfs_end_bio_unwritten(
        void                    *data)
 {
        xfs_ioend_t             *ioend = data;
-        vnode_t                 *vp = ioend->io_vnode;
+        bhv_vnode_t             *vp = ioend->io_vnode;
        xfs_off_t               offset = ioend->io_offset;
        size_t                  size = ioend->io_size;
-        int                     error;
-        if (ioend->io_uptodate)
+        if (likely(!ioend->io_error))
-                VOP_BMAP(vp, offset, size, BMAPI_UNWRITTEN, NULL, NULL, error);
+                bhv_vop_bmap(vp, offset, size, BMAPI_UNWRITTEN, NULL, NULL);
        xfs_destroy_ioend(ioend);
 }
@@ -211,7 +209,7 @@ xfs_alloc_ioend(
         * all the I/O from calling the completion routine too early.
         */
        atomic_set(&ioend->io_remaining, 1);
-        ioend->io_uptodate = 1; /* cleared if any I/O fails */
+        ioend->io_error = 0;
        ioend->io_list = NULL;
        ioend->io_type = type;
        ioend->io_vnode = vn_from_inode(inode);
@@ -239,10 +237,10 @@ xfs_map_blocks(
        xfs_iomap_t             *mapp,
        int                     flags)
 {
-        vnode_t                 *vp = vn_from_inode(inode);
+        bhv_vnode_t             *vp = vn_from_inode(inode);
        int                     error, nmaps = 1;
-        VOP_BMAP(vp, offset, count, flags, mapp, &nmaps, error);
+        error = bhv_vop_bmap(vp, offset, count, flags, mapp, &nmaps);
        if (!error && (flags & (BMAPI_WRITE|BMAPI_ALLOCATE)))
                VMODIFY(vp);
        return -error;
@@ -271,16 +269,14 @@ xfs_end_bio(
        if (bio->bi_size)
                return 1;
-        ASSERT(ioend);
        ASSERT(atomic_read(&bio->bi_cnt) >= 1);
+        ioend->io_error = test_bit(BIO_UPTODATE, &bio->bi_flags) ? 0 : error;
        /* Toss bio and pass work off to an xfsdatad thread */
-        if (!test_bit(BIO_UPTODATE, &bio->bi_flags))
-                ioend->io_uptodate = 0;
        bio->bi_private = NULL;
        bio->bi_end_io = NULL;
        bio_put(bio);
        xfs_finish_ioend(ioend);
        return 0;
 }
@@ -1127,7 +1123,7 @@ xfs_vm_writepage(
         * then mark the page dirty again and leave the page
         * as is.
         */
-        if (PFLAGS_TEST_FSTRANS() && need_trans)
+        if (current_test_flags(PF_FSTRANS) && need_trans)
                goto out_fail;
        /*
@@ -1158,6 +1154,18 @@ out_unlock:
        return error;
 }
+STATIC int
+xfs_vm_writepages(
+        struct address_space    *mapping,
+        struct writeback_control *wbc)
+{
+        struct bhv_vnode        *vp = vn_from_inode(mapping->host);
+        if (VN_TRUNC(vp))
+                VUNTRUNCATE(vp);
+        return generic_writepages(mapping, wbc);
+}
 /*
 * Called to move a page into cleanable state - and from there
 * to be released. Possibly the page is already clean. We always
@@ -1204,7 +1212,7 @@ xfs_vm_releasepage(
        /* If we are already inside a transaction or the thread cannot
         * do I/O, we cannot release this page.
         */
-        if (PFLAGS_TEST_FSTRANS())
+        if (current_test_flags(PF_FSTRANS))
                return 0;
        /*
@@ -1231,7 +1239,7 @@ __xfs_get_blocks(
        int                     direct,
        bmapi_flags_t           flags)
 {
-        vnode_t                 *vp = vn_from_inode(inode);
+        bhv_vnode_t             *vp = vn_from_inode(inode);
        xfs_iomap_t             iomap;
        xfs_off_t               offset;
        ssize_t                 size;
@@ -1241,8 +1249,8 @@ __xfs_get_blocks(
        offset = (xfs_off_t)iblock << inode->i_blkbits;
        ASSERT(bh_result->b_size >= (1 << inode->i_blkbits));
        size = bh_result->b_size;
-        VOP_BMAP(vp, offset, size,
+        error = bhv_vop_bmap(vp, offset, size,
-                create ? flags : BMAPI_READ, &iomap, &niomap, error);
+                             create ? flags : BMAPI_READ, &iomap, &niomap);
        if (error)
                return -error;
        if (niomap == 0)
@@ -1370,13 +1378,13 @@ xfs_vm_direct_IO(
 {
        struct file     *file = iocb->ki_filp;
        struct inode    *inode = file->f_mapping->host;
-        vnode_t         *vp = vn_from_inode(inode);
+        bhv_vnode_t     *vp = vn_from_inode(inode);
        xfs_iomap_t     iomap;
        int             maps = 1;
        int             error;
        ssize_t         ret;
-        VOP_BMAP(vp, offset, 0, BMAPI_DEVICE, &iomap, &maps, error);
+        error = bhv_vop_bmap(vp, offset, 0, BMAPI_DEVICE, &iomap, &maps);
        if (error)
                return -error;
@@ -1409,14 +1417,12 @@ xfs_vm_bmap(
        sector_t                block)
 {
        struct inode            *inode = (struct inode *)mapping->host;
-        vnode_t                 *vp = vn_from_inode(inode);
+        bhv_vnode_t             *vp = vn_from_inode(inode);
-        int                     error;
        vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
+        bhv_vop_rwlock(vp, VRWLOCK_READ);
-        VOP_RWLOCK(vp, VRWLOCK_READ);
+        bhv_vop_flush_pages(vp, (xfs_off_t)0, -1, 0, FI_REMAPF);
-        VOP_FLUSH_PAGES(vp, (xfs_off_t)0, -1, 0, FI_REMAPF, error);
+        bhv_vop_rwunlock(vp, VRWLOCK_READ);
-        VOP_RWUNLOCK(vp, VRWLOCK_READ);
        return generic_block_bmap(mapping, block, xfs_get_blocks);
 }
@@ -1452,6 +1458,7 @@ struct address_space_operations xfs_address_space_operations = {
        .readpage               = xfs_vm_readpage,
        .readpages              = xfs_vm_readpages,
        .writepage              = xfs_vm_writepage,
+        .writepages             = xfs_vm_writepages,
        .sync_page              = block_sync_page,
        .releasepage            = xfs_vm_releasepage,
        .invalidatepage         = xfs_vm_invalidatepage,
diff --git a/fs/xfs/linux-2.6/xfs_aops.h b/fs/xfs/linux-2.6/xfs_aops.h
index 60716543c68b..706d8c781b8a 100644
--- a/fs/xfs/linux-2.6/xfs_aops.h
+++ b/fs/xfs/linux-2.6/xfs_aops.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005 Silicon Graphics, Inc.
+ * Copyright (c) 2005-2006 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
@@ -30,9 +30,9 @@ typedef void (*xfs_ioend_func_t)(void *);
 typedef struct xfs_ioend {
        struct xfs_ioend        *io_list;       /* next ioend in chain */
        unsigned int            io_type;        /* delalloc / unwritten */
-        unsigned int            io_uptodate;    /* I/O status register */
+        int                     io_error;       /* I/O error code */
        atomic_t                io_remaining;   /* hold count */
-        struct vnode            *io_vnode;      /* file being written to */
+        struct bhv_vnode        *io_vnode;      /* file being written to */
        struct buffer_head      *io_buffer_head;/* buffer linked list head */
        struct buffer_head      *io_buffer_tail;/* buffer linked list tail */
        size_t                  io_size;        /* size of the extent */
@@ -43,4 +43,4 @@ typedef struct xfs_ioend {
 extern struct address_space_operations xfs_address_space_operations;
 extern int xfs_get_blocks(struct inode *, sector_t, struct buffer_head *, int);
-#endif /* __XFS_IOPS_H__ */
+#endif /* __XFS_AOPS_H__ */
diff --git a/fs/xfs/linux-2.6/xfs_export.c b/fs/xfs/linux-2.6/xfs_export.c
index b768ea910bbe..5fb75d9151f2 100644
--- a/fs/xfs/linux-2.6/xfs_export.c
+++ b/fs/xfs/linux-2.6/xfs_export.c
@@ -21,7 +21,6 @@
 #include "xfs_log.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
-#include "xfs_dir.h"
 #include "xfs_mount.h"
 #include "xfs_export.h"
@@ -97,7 +96,7 @@ xfs_fs_encode_fh(
        int                     len;
        int                     is64 = 0;
 #if XFS_BIG_INUMS
-        vfs_t                   *vfs = vfs_from_sb(inode->i_sb);
+        bhv_vfs_t               *vfs = vfs_from_sb(inode->i_sb);
        if (!(vfs->vfs_flag & VFS_32BITINODES)) {
                /* filesystem may contain 64bit inode numbers */
@@ -136,13 +135,13 @@ xfs_fs_get_dentry(
        struct super_block      *sb,
        void                    *data)
 {
-        vnode_t                 *vp;
+        bhv_vnode_t             *vp;
        struct inode            *inode;
        struct dentry           *result;
-        vfs_t                   *vfsp = vfs_from_sb(sb);
+        bhv_vfs_t               *vfsp = vfs_from_sb(sb);
        int                     error;
-        VFS_VGET(vfsp, &vp, (fid_t *)data, error);
+        error = bhv_vfs_vget(vfsp, &vp, (fid_t *)data);
        if (error || vp == NULL)
                return ERR_PTR(-ESTALE) ;
@@ -160,12 +159,12 @@ xfs_fs_get_parent(
        struct dentry           *child)
 {
        int                     error;
-        vnode_t                 *vp, *cvp;
+        bhv_vnode_t             *vp, *cvp;
        struct dentry           *parent;
        cvp = NULL;
        vp = vn_from_inode(child->d_inode);
-        VOP_LOOKUP(vp, &dotdot, &cvp, 0, NULL, NULL, error);
+        error = bhv_vop_lookup(vp, &dotdot, &cvp, 0, NULL, NULL);
        if (unlikely(error))
                return ERR_PTR(-error);
diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index c847416f6d10..70662371bb11 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -21,7 +21,6 @@
 #include "xfs_inum.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_trans.h"
 #include "xfs_dmapi.h"
@@ -32,7 +31,6 @@
 #include "xfs_alloc.h"
 #include "xfs_btree.h"
 #include "xfs_attr_sf.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
@@ -58,15 +56,12 @@ __xfs_file_read(
 {
        struct iovec            iov = {buf, count};
        struct file             *file = iocb->ki_filp;
-        vnode_t                 *vp = vn_from_inode(file->f_dentry->d_inode);
+        bhv_vnode_t             *vp = vn_from_inode(file->f_dentry->d_inode);
-        ssize_t                 rval;
        BUG_ON(iocb->ki_pos != pos);
        if (unlikely(file->f_flags & O_DIRECT))
                ioflags |= IO_ISDIRECT;
-        VOP_READ(vp, iocb, &iov, 1, &iocb->ki_pos, ioflags, NULL, rval);
+        return bhv_vop_read(vp, iocb, &iov, 1, &iocb->ki_pos, ioflags, NULL);
-        return rval;
 }
 STATIC ssize_t
@@ -100,15 +95,12 @@ __xfs_file_write(
        struct iovec    iov = {(void __user *)buf, count};
        struct file     *file = iocb->ki_filp;
        struct inode    *inode = file->f_mapping->host;
-        vnode_t         *vp = vn_from_inode(inode);
+        bhv_vnode_t     *vp = vn_from_inode(inode);
-        ssize_t         rval;
        BUG_ON(iocb->ki_pos != pos);
        if (unlikely(file->f_flags & O_DIRECT))
                ioflags |= IO_ISDIRECT;
+        return bhv_vop_write(vp, iocb, &iov, 1, &iocb->ki_pos, ioflags, NULL);
-        VOP_WRITE(vp, iocb, &iov, 1, &iocb->ki_pos, ioflags, NULL, rval);
-        return rval;
 }
 STATIC ssize_t
@@ -140,7 +132,7 @@ __xfs_file_readv(
        loff_t                  *ppos)
 {
        struct inode    *inode = file->f_mapping->host;
-        vnode_t         *vp = vn_from_inode(inode);
+        bhv_vnode_t     *vp = vn_from_inode(inode);
        struct kiocb    kiocb;
        ssize_t         rval;
@@ -149,7 +141,8 @@ __xfs_file_readv(
        if (unlikely(file->f_flags & O_DIRECT))
                ioflags |= IO_ISDIRECT;
-        VOP_READ(vp, &kiocb, iov, nr_segs, &kiocb.ki_pos, ioflags, NULL, rval);
+        rval = bhv_vop_read(vp, &kiocb, iov, nr_segs,
+                                &kiocb.ki_pos, ioflags, NULL);
        *ppos = kiocb.ki_pos;
        return rval;
@@ -184,7 +177,7 @@ __xfs_file_writev(
        loff_t                  *ppos)
 {
        struct inode    *inode = file->f_mapping->host;
-        vnode_t         *vp = vn_from_inode(inode);
+        bhv_vnode_t     *vp = vn_from_inode(inode);
        struct kiocb    kiocb;
        ssize_t         rval;
@@ -193,7 +186,8 @@ __xfs_file_writev(
        if (unlikely(file->f_flags & O_DIRECT))
                ioflags |= IO_ISDIRECT;
-        VOP_WRITE(vp, &kiocb, iov, nr_segs, &kiocb.ki_pos, ioflags, NULL, rval);
+        rval = bhv_vop_write(vp, &kiocb, iov, nr_segs,
+                                 &kiocb.ki_pos, ioflags, NULL);
        *ppos = kiocb.ki_pos;
        return rval;
@@ -227,11 +221,8 @@ xfs_file_sendfile(
        read_actor_t            actor,
        void                    *target)
 {
-        vnode_t                 *vp = vn_from_inode(filp->f_dentry->d_inode);
+        return bhv_vop_sendfile(vn_from_inode(filp->f_dentry->d_inode),
-        ssize_t                 rval;
+                                filp, pos, 0, count, actor, target, NULL);
-        VOP_SENDFILE(vp, filp, pos, 0, count, actor, target, NULL, rval);
-        return rval;
 }
 STATIC ssize_t
@@ -242,11 +233,8 @@ xfs_file_sendfile_invis(
        read_actor_t            actor,
        void                    *target)
 {
-        vnode_t                 *vp = vn_from_inode(filp->f_dentry->d_inode);
+        return bhv_vop_sendfile(vn_from_inode(filp->f_dentry->d_inode),
-        ssize_t                 rval;
+                                filp, pos, IO_INVIS, count, actor, target, NULL);
-        VOP_SENDFILE(vp, filp, pos, IO_INVIS, count, actor, target, NULL, rval);
-        return rval;
 }
 STATIC ssize_t
@@ -257,11 +245,8 @@ xfs_file_splice_read(
        size_t                  len,
        unsigned int            flags)
 {
-        vnode_t                 *vp = vn_from_inode(infilp->f_dentry->d_inode);
+        return bhv_vop_splice_read(vn_from_inode(infilp->f_dentry->d_inode),
-        ssize_t                 rval;
+                                   infilp, ppos, pipe, len, flags, 0, NULL);
-        VOP_SPLICE_READ(vp, infilp, ppos, pipe, len, flags, 0, NULL, rval);
-        return rval;
 }
 STATIC ssize_t
@@ -272,11 +257,9 @@ xfs_file_splice_read_invis(
        size_t                  len,
        unsigned int            flags)
 {
-        vnode_t                 *vp = vn_from_inode(infilp->f_dentry->d_inode);
+        return bhv_vop_splice_read(vn_from_inode(infilp->f_dentry->d_inode),
-        ssize_t                 rval;
+                                   infilp, ppos, pipe, len, flags, IO_INVIS,
+                                   NULL);
-        VOP_SPLICE_READ(vp, infilp, ppos, pipe, len, flags, IO_INVIS, NULL, rval);
-        return rval;
 }
 STATIC ssize_t
@@ -287,11 +270,8 @@ xfs_file_splice_write(
        size_t                  len,
        unsigned int            flags)
 {
-        vnode_t                 *vp = vn_from_inode(outfilp->f_dentry->d_inode);
+        return bhv_vop_splice_write(vn_from_inode(outfilp->f_dentry->d_inode),
-        ssize_t                 rval;
+                                    pipe, outfilp, ppos, len, flags, 0, NULL);
-        VOP_SPLICE_WRITE(vp, pipe, outfilp, ppos, len, flags, 0, NULL, rval);
-        return rval;
 }
 STATIC ssize_t
@@ -302,11 +282,9 @@ xfs_file_splice_write_invis(
        size_t                  len,
        unsigned int            flags)
 {
-        vnode_t                 *vp = vn_from_inode(outfilp->f_dentry->d_inode);
+        return bhv_vop_splice_write(vn_from_inode(outfilp->f_dentry->d_inode),
-        ssize_t                 rval;
+                                    pipe, outfilp, ppos, len, flags, IO_INVIS,
+                                    NULL);
-        VOP_SPLICE_WRITE(vp, pipe, outfilp, ppos, len, flags, IO_INVIS, NULL, rval);
-        return rval;
 }
 STATIC int
@@ -314,13 +292,17 @@ xfs_file_open(
        struct inode    *inode,
        struct file     *filp)
 {
-        vnode_t         *vp = vn_from_inode(inode);
-        int             error;
        if (!(filp->f_flags & O_LARGEFILE) && i_size_read(inode) > MAX_NON_LFS)
                return -EFBIG;
-        VOP_OPEN(vp, NULL, error);
+        return -bhv_vop_open(vn_from_inode(inode), NULL);
-        return -error;
+}
+STATIC int
+xfs_file_close(
+        struct file     *filp)
+{
+        return -bhv_vop_close(vn_from_inode(filp->f_dentry->d_inode), 0,
+                                file_count(filp) > 1 ? L_FALSE : L_TRUE, NULL);
 }
 STATIC int
@@ -328,12 +310,11 @@ xfs_file_release(
        struct inode    *inode,
        struct file     *filp)
 {
-        vnode_t         *vp = vn_from_inode(inode);
+        bhv_vnode_t     *vp = vn_from_inode(inode);
-        int             error = 0;
        if (vp)
-                VOP_RELEASE(vp, error);
+                return -bhv_vop_release(vp);
-        return -error;
+        return 0;
 }
 STATIC int
@@ -342,15 +323,14 @@ xfs_file_fsync(
        struct dentry   *dentry,
        int             datasync)
 {
-        struct inode    *inode = dentry->d_inode;
+        bhv_vnode_t     *vp = vn_from_inode(dentry->d_inode);
-        vnode_t         *vp = vn_from_inode(inode);
-        int             error;
        int             flags = FSYNC_WAIT;
        if (datasync)
                flags |= FSYNC_DATA;
-        VOP_FSYNC(vp, flags, NULL, (xfs_off_t)0, (xfs_off_t)-1, error);
+        if (VN_TRUNC(vp))
-        return -error;
+                VUNTRUNCATE(vp);
+        return -bhv_vop_fsync(vp, flags, NULL, (xfs_off_t)0, (xfs_off_t)-1);
 }
 #ifdef CONFIG_XFS_DMAPI
@@ -361,16 +341,11 @@ xfs_vm_nopage(
        int                     *type)
 {
        struct inode    *inode = area->vm_file->f_dentry->d_inode;
-        vnode_t         *vp = vn_from_inode(inode);
+        bhv_vnode_t     *vp = vn_from_inode(inode);
-        xfs_mount_t     *mp = XFS_VFSTOM(vp->v_vfsp);
-        int             error;
        ASSERT_ALWAYS(vp->v_vfsp->vfs_flag & VFS_DMI);
+        if (XFS_SEND_MMAP(XFS_VFSTOM(vp->v_vfsp), area, 0))
-        error = XFS_SEND_MMAP(mp, area, 0);
-        if (error)
                return NULL;
        return filemap_nopage(area, address, type);
 }
 #endif /* CONFIG_XFS_DMAPI */
@@ -382,7 +357,7 @@ xfs_file_readdir(
        filldir_t       filldir)
 {
        int             error = 0;
-        vnode_t         *vp = vn_from_inode(filp->f_dentry->d_inode);
+        bhv_vnode_t     *vp = vn_from_inode(filp->f_dentry->d_inode);
        uio_t           uio;
        iovec_t         iov;
        int             eof = 0;
@@ -417,7 +392,7 @@ xfs_file_readdir(
                start_offset = uio.uio_offset;
-                VOP_READDIR(vp, &uio, NULL, &eof, error);
+                error = bhv_vop_readdir(vp, &uio, NULL, &eof);
                if ((uio.uio_offset == start_offset) || error) {
                        size = 0;
                        break;
@@ -456,38 +431,28 @@ xfs_file_mmap(
        struct file     *filp,
        struct vm_area_struct *vma)
 {
-        struct inode    *ip = filp->f_dentry->d_inode;
-        vnode_t         *vp = vn_from_inode(ip);
-        vattr_t         vattr;
-        int             error;
        vma->vm_ops = &xfs_file_vm_ops;
 #ifdef CONFIG_XFS_DMAPI
-        if (vp->v_vfsp->vfs_flag & VFS_DMI) {
+        if (vn_from_inode(filp->f_dentry->d_inode)->v_vfsp->vfs_flag & VFS_DMI)
                vma->vm_ops = &xfs_dmapi_file_vm_ops;
-        }
 #endif /* CONFIG_XFS_DMAPI */
-        vattr.va_mask = XFS_AT_UPDATIME;
+        file_accessed(filp);
-        VOP_SETATTR(vp, &vattr, XFS_AT_UPDATIME, NULL, error);
-        if (likely(!error))
-                __vn_revalidate(vp, &vattr);    /* update flags */
        return 0;
 }
 STATIC long
 xfs_file_ioctl(
        struct file     *filp,
        unsigned int    cmd,
-        unsigned long   arg)
+        unsigned long   p)
 {
        int             error;
        struct inode    *inode = filp->f_dentry->d_inode;
-        vnode_t         *vp = vn_from_inode(inode);
+        bhv_vnode_t     *vp = vn_from_inode(inode);
-        VOP_IOCTL(vp, inode, filp, 0, cmd, (void __user *)arg, error);
+        error = bhv_vop_ioctl(vp, inode, filp, 0, cmd, (void __user *)p);
        VMODIFY(vp);
        /* NOTE:  some of the ioctl's return positive #'s as a
@@ -503,13 +468,13 @@ STATIC long
 xfs_file_ioctl_invis(
        struct file     *filp,
        unsigned int    cmd,
-        unsigned long   arg)
+        unsigned long   p)
 {
-        struct inode    *inode = filp->f_dentry->d_inode;
-        vnode_t         *vp = vn_from_inode(inode);
        int             error;
+        struct inode    *inode = filp->f_dentry->d_inode;
+        bhv_vnode_t     *vp = vn_from_inode(inode);
-        VOP_IOCTL(vp, inode, filp, IO_INVIS, cmd, (void __user *)arg, error);
+        error = bhv_vop_ioctl(vp, inode, filp, IO_INVIS, cmd, (void __user *)p);
        VMODIFY(vp);
        /* NOTE:  some of the ioctl's return positive #'s as a
@@ -528,7 +493,7 @@ xfs_vm_mprotect(
        struct vm_area_struct *vma,
        unsigned int    newflags)
 {
-        vnode_t         *vp = vn_from_inode(vma->vm_file->f_dentry->d_inode);
+        bhv_vnode_t     *vp = vn_from_inode(vma->vm_file->f_dentry->d_inode);
        int             error = 0;
        if (vp->v_vfsp->vfs_flag & VFS_DMI) {
@@ -554,24 +519,19 @@ STATIC int
 xfs_file_open_exec(
        struct inode    *inode)
 {
-        vnode_t         *vp = vn_from_inode(inode);
+        bhv_vnode_t     *vp = vn_from_inode(inode);
-        xfs_mount_t     *mp = XFS_VFSTOM(vp->v_vfsp);
-        int             error = 0;
-        xfs_inode_t     *ip;
-        if (vp->v_vfsp->vfs_flag & VFS_DMI) {
+        if (unlikely(vp->v_vfsp->vfs_flag & VFS_DMI)) {
-                ip = xfs_vtoi(vp);
+                xfs_mount_t     *mp = XFS_VFSTOM(vp->v_vfsp);
-                if (!ip) {
+                xfs_inode_t     *ip = xfs_vtoi(vp);
-                        error = -EINVAL;
-                        goto open_exec_out;
+                if (!ip)
-                }
+                        return -EINVAL;
-                if (DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_EVENT_READ)) {
+                if (DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_EVENT_READ))
-                        error = -XFS_SEND_DATA(mp, DM_EVENT_READ, vp,
+                        return -XFS_SEND_DATA(mp, DM_EVENT_READ, vp,
                                               0, 0, 0, NULL);
-                }
        }
-open_exec_out:
+        return 0;
-        return error;
 }
 #endif /* HAVE_FOP_OPEN_EXEC */
@@ -592,6 +552,7 @@ 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
@@ -616,6 +577,7 @@ 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_fs_subr.c b/fs/xfs/linux-2.6/xfs_fs_subr.c
index 575f2a790f31..dc0562828e76 100644
--- a/fs/xfs/linux-2.6/xfs_fs_subr.c
+++ b/fs/xfs/linux-2.6/xfs_fs_subr.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2002,2005-2006 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
@@ -15,40 +15,12 @@
 * 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"
-/*
+int  fs_noerr(void) { return 0; }
- * Stub for no-op vnode operations that return error status.
+int  fs_nosys(void) { return ENOSYS; }
- */
+void fs_noval(void) { return; }
-int
-fs_noerr(void)
-{
-        return 0;
-}
-/*
- * Operation unsupported under this file system.
- */
-int
-fs_nosys(void)
-{
-        return ENOSYS;
-}
-/*
- * Stub for inactive, strategy, and read/write lock/unlock.  Does nothing.
- */
-/* ARGSUSED */
-void
-fs_noval(void)
-{
-}
-/*
- * vnode pcache layer for vnode_tosspages.
- * 'last' parameter unused but left in for IRIX compatibility
- */
 void
 fs_tosspages(
        bhv_desc_t      *bdp,
@@ -56,18 +28,13 @@ fs_tosspages(
        xfs_off_t       last,
        int             fiopt)
 {
-        vnode_t         *vp = BHV_TO_VNODE(bdp);
+        bhv_vnode_t     *vp = BHV_TO_VNODE(bdp);
        struct inode    *ip = vn_to_inode(vp);
        if (VN_CACHED(vp))
                truncate_inode_pages(ip->i_mapping, first);
 }
-/*
- * vnode pcache layer for vnode_flushinval_pages.
- * 'last' parameter unused but left in for IRIX compatibility
- */
 void
 fs_flushinval_pages(
        bhv_desc_t      *bdp,
@@ -75,20 +42,17 @@ fs_flushinval_pages(
        xfs_off_t       last,
        int             fiopt)
 {
-        vnode_t         *vp = BHV_TO_VNODE(bdp);
+        bhv_vnode_t     *vp = BHV_TO_VNODE(bdp);
        struct inode    *ip = vn_to_inode(vp);
        if (VN_CACHED(vp)) {
+                if (VN_TRUNC(vp))
+                        VUNTRUNCATE(vp);
                filemap_write_and_wait(ip->i_mapping);
                truncate_inode_pages(ip->i_mapping, first);
        }
 }
-/*
- * vnode pcache layer for vnode_flush_pages.
- * 'last' parameter unused but left in for IRIX compatibility
- */
 int
 fs_flush_pages(
        bhv_desc_t      *bdp,
@@ -97,15 +61,16 @@ fs_flush_pages(
        uint64_t        flags,
        int             fiopt)
 {
-        vnode_t         *vp = BHV_TO_VNODE(bdp);
+        bhv_vnode_t     *vp = BHV_TO_VNODE(bdp);
        struct inode    *ip = vn_to_inode(vp);
-        if (VN_CACHED(vp)) {
+        if (VN_DIRTY(vp)) {
+                if (VN_TRUNC(vp))
+                        VUNTRUNCATE(vp);
                filemap_fdatawrite(ip->i_mapping);
                if (flags & XFS_B_ASYNC)
                        return 0;
                filemap_fdatawait(ip->i_mapping);
        }
        return 0;
 }
diff --git a/fs/xfs/linux-2.6/xfs_globals.c b/fs/xfs/linux-2.6/xfs_globals.c
index 6e8085f34635..6c162c3dde7e 100644
--- a/fs/xfs/linux-2.6/xfs_globals.c
+++ b/fs/xfs/linux-2.6/xfs_globals.c
@@ -45,6 +45,7 @@ xfs_param_t xfs_params = {
        .xfs_buf_age    = {     1*100,          15*100,         7200*100},
        .inherit_nosym  = {     0,              0,              1       },
        .rotorstep      = {     1,              1,              255     },
+        .inherit_nodfrg = {     0,              1,              1       },
 };
 /*
diff --git a/fs/xfs/linux-2.6/xfs_ioctl.c b/fs/xfs/linux-2.6/xfs_ioctl.c
index 84478491609b..6e52a5dd38d8 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl.c
@@ -23,7 +23,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
 #include "xfs_dmapi.h"
@@ -31,7 +30,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_dinode.h"
@@ -78,7 +76,7 @@ xfs_find_handle(
        xfs_handle_t            handle;
        xfs_fsop_handlereq_t    hreq;
        struct inode            *inode;
-        struct vnode            *vp;
+        bhv_vnode_t             *vp;
        if (copy_from_user(&hreq, arg, sizeof(hreq)))
                return -XFS_ERROR(EFAULT);
@@ -192,7 +190,7 @@ xfs_vget_fsop_handlereq(
        xfs_mount_t             *mp,
        struct inode            *parinode,      /* parent inode pointer    */
        xfs_fsop_handlereq_t    *hreq,
-        vnode_t                 **vp,
+        bhv_vnode_t             **vp,
        struct inode            **inode)
 {
        void                    __user *hanp;
@@ -202,7 +200,7 @@ xfs_vget_fsop_handlereq(
        xfs_handle_t            handle;
        xfs_inode_t             *ip;
        struct inode            *inodep;
-        vnode_t                 *vpp;
+        bhv_vnode_t             *vpp;
        xfs_ino_t               ino;
        __u32                   igen;
        int                     error;
@@ -277,7 +275,7 @@ xfs_open_by_handle(
        struct file             *filp;
        struct inode            *inode;
        struct dentry           *dentry;
-        vnode_t                 *vp;
+        bhv_vnode_t             *vp;
        xfs_fsop_handlereq_t    hreq;
        if (!capable(CAP_SYS_ADMIN))
@@ -362,7 +360,7 @@ xfs_readlink_by_handle(
        struct uio              auio;
        struct inode            *inode;
        xfs_fsop_handlereq_t    hreq;
-        vnode_t                 *vp;
+        bhv_vnode_t             *vp;
        __u32                   olen;
        if (!capable(CAP_SYS_ADMIN))
@@ -393,9 +391,11 @@ xfs_readlink_by_handle(
        auio.uio_segflg = UIO_USERSPACE;
        auio.uio_resid  = olen;
-        VOP_READLINK(vp, &auio, IO_INVIS, NULL, error);
+        error = bhv_vop_readlink(vp, &auio, IO_INVIS, NULL);
        VN_RELE(vp);
+        if (error)
+                return -error;
        return (olen - auio.uio_resid);
 }
@@ -411,7 +411,7 @@ xfs_fssetdm_by_handle(
        xfs_fsop_setdm_handlereq_t dmhreq;
        struct inode            *inode;
        bhv_desc_t              *bdp;
-        vnode_t                 *vp;
+        bhv_vnode_t             *vp;
        if (!capable(CAP_MKNOD))
                return -XFS_ERROR(EPERM);
@@ -452,7 +452,7 @@ xfs_attrlist_by_handle(
        attrlist_cursor_kern_t  *cursor;
        xfs_fsop_attrlist_handlereq_t al_hreq;
        struct inode            *inode;
-        vnode_t                 *vp;
+        bhv_vnode_t             *vp;
        char                    *kbuf;
        if (!capable(CAP_SYS_ADMIN))
@@ -472,8 +472,8 @@ xfs_attrlist_by_handle(
                goto out_vn_rele;
        cursor = (attrlist_cursor_kern_t *)&al_hreq.pos;
-        VOP_ATTR_LIST(vp, kbuf, al_hreq.buflen, al_hreq.flags,
+        error = bhv_vop_attr_list(vp, kbuf, al_hreq.buflen, al_hreq.flags,
-                        cursor, NULL, error);
+                                        cursor, NULL);
        if (error)
                goto out_kfree;
@@ -490,7 +490,7 @@ xfs_attrlist_by_handle(
 STATIC int
 xfs_attrmulti_attr_get(
-        struct vnode            *vp,
+        bhv_vnode_t             *vp,
        char                    *name,
        char                    __user *ubuf,
        __uint32_t              *len,
@@ -505,7 +505,7 @@ xfs_attrmulti_attr_get(
        if (!kbuf)
                return ENOMEM;
-        VOP_ATTR_GET(vp, name, kbuf, len, flags, NULL, error);
+        error = bhv_vop_attr_get(vp, name, kbuf, len, flags, NULL);
        if (error)
                goto out_kfree;
@@ -519,7 +519,7 @@ xfs_attrmulti_attr_get(
 STATIC int
 xfs_attrmulti_attr_set(
-        struct vnode            *vp,
+        bhv_vnode_t             *vp,
        char                    *name,
        const char              __user *ubuf,
        __uint32_t              len,
@@ -542,7 +542,7 @@ xfs_attrmulti_attr_set(
        if (copy_from_user(kbuf, ubuf, len))
                goto out_kfree;
                        
-        VOP_ATTR_SET(vp, name, kbuf, len, flags, NULL, error);
+        error = bhv_vop_attr_set(vp, name, kbuf, len, flags, NULL);
 out_kfree:
        kfree(kbuf);
@@ -551,20 +551,15 @@ xfs_attrmulti_attr_set(
 STATIC int
 xfs_attrmulti_attr_remove(
-        struct vnode            *vp,
+        bhv_vnode_t             *vp,
        char                    *name,
        __uint32_t              flags)
 {
-        int                     error;
        if (IS_RDONLY(&vp->v_inode))
                return -EROFS;
        if (IS_IMMUTABLE(&vp->v_inode) || IS_APPEND(&vp->v_inode))
                return EPERM;
+        return bhv_vop_attr_remove(vp, name, flags, NULL);
-        VOP_ATTR_REMOVE(vp, name, flags, NULL, error);
-        return error;
 }
 STATIC int
@@ -578,7 +573,7 @@ xfs_attrmulti_by_handle(
        xfs_attr_multiop_t      *ops;
        xfs_fsop_attrmulti_handlereq_t am_hreq;
        struct inode            *inode;
-        vnode_t                 *vp;
+        bhv_vnode_t             *vp;
        unsigned int            i, size;
        char                    *attr_name;
@@ -658,7 +653,7 @@ xfs_attrmulti_by_handle(
 STATIC int
 xfs_ioc_space(
        bhv_desc_t              *bdp,
-        vnode_t                 *vp,
+        bhv_vnode_t             *vp,
        struct file             *filp,
        int                     flags,
        unsigned int            cmd,
@@ -682,7 +677,7 @@ xfs_ioc_fsgeometry(
 STATIC int
 xfs_ioc_xattr(
-        vnode_t                 *vp,
+        bhv_vnode_t             *vp,
        xfs_inode_t             *ip,
        struct file             *filp,
        unsigned int            cmd,
@@ -711,7 +706,7 @@ xfs_ioctl(
        void                    __user *arg)
 {
        int                     error;
-        vnode_t                 *vp;
+        bhv_vnode_t             *vp;
        xfs_inode_t             *ip;
        xfs_mount_t             *mp;
@@ -962,7 +957,7 @@ xfs_ioctl(
 STATIC int
 xfs_ioc_space(
        bhv_desc_t              *bdp,
-        vnode_t                 *vp,
+        bhv_vnode_t             *vp,
        struct file             *filp,
        int                     ioflags,
        unsigned int            cmd,
@@ -1153,14 +1148,14 @@ xfs_di2lxflags(
 STATIC int
 xfs_ioc_xattr(
-        vnode_t                 *vp,
+        bhv_vnode_t             *vp,
        xfs_inode_t             *ip,
        struct file             *filp,
        unsigned int            cmd,
        void                    __user *arg)
 {
        struct fsxattr          fa;
-        struct vattr            *vattr;
+        struct bhv_vattr        *vattr;
        int                     error = 0;
        int                     attr_flags;
        unsigned int            flags;
@@ -1173,7 +1168,7 @@ xfs_ioc_xattr(
        case XFS_IOC_FSGETXATTR: {
                vattr->va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | \
                                 XFS_AT_NEXTENTS | XFS_AT_PROJID;
-                VOP_GETATTR(vp, vattr, 0, NULL, error);
+                error = bhv_vop_getattr(vp, vattr, 0, NULL);
                if (unlikely(error)) {
                        error = -error;
                        break;
@@ -1206,7 +1201,7 @@ xfs_ioc_xattr(
                vattr->va_extsize = fa.fsx_extsize;
                vattr->va_projid  = fa.fsx_projid;
-                VOP_SETATTR(vp, vattr, attr_flags, NULL, error);
+                error = bhv_vop_setattr(vp, vattr, attr_flags, NULL);
                if (likely(!error))
                        __vn_revalidate(vp, vattr);     /* update flags */
                error = -error;
@@ -1216,7 +1211,7 @@ xfs_ioc_xattr(
        case XFS_IOC_FSGETXATTRA: {
                vattr->va_mask = XFS_AT_XFLAGS | XFS_AT_EXTSIZE | \
                                 XFS_AT_ANEXTENTS | XFS_AT_PROJID;
-                VOP_GETATTR(vp, vattr, 0, NULL, error);
+                error = bhv_vop_getattr(vp, vattr, 0, NULL);
                if (unlikely(error)) {
                        error = -error;
                        break;
@@ -1262,7 +1257,7 @@ xfs_ioc_xattr(
                vattr->va_xflags = xfs_merge_ioc_xflags(flags,
                                                        xfs_ip2xflags(ip));
-                VOP_SETATTR(vp, vattr, attr_flags, NULL, error);
+                error = bhv_vop_setattr(vp, vattr, attr_flags, NULL);
                if (likely(!error))
                        __vn_revalidate(vp, vattr);     /* update flags */
                error = -error;
diff --git a/fs/xfs/linux-2.6/xfs_ioctl32.c b/fs/xfs/linux-2.6/xfs_ioctl32.c
index 251bfe451a3f..601f01c92f7f 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl32.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl32.c
@@ -114,7 +114,7 @@ xfs_compat_ioctl(
        unsigned long   arg)
 {
        struct inode    *inode = file->f_dentry->d_inode;
-        vnode_t         *vp = vn_from_inode(inode);
+        bhv_vnode_t     *vp = vn_from_inode(inode);
        int             error;
        switch (cmd) {
@@ -193,7 +193,7 @@ xfs_compat_ioctl(
                return -ENOIOCTLCMD;
        }
-        VOP_IOCTL(vp, inode, file, mode, cmd, (void __user *)arg, error);
+        error = bhv_vop_ioctl(vp, inode, file, mode, cmd, (void __user *)arg);
        VMODIFY(vp);
        return error;
diff --git a/fs/xfs/linux-2.6/xfs_iops.c b/fs/xfs/linux-2.6/xfs_iops.c
index 2e2e275c786f..12810baeb5d4 100644
--- a/fs/xfs/linux-2.6/xfs_iops.c
+++ b/fs/xfs/linux-2.6/xfs_iops.c
@@ -23,7 +23,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
 #include "xfs_dmapi.h"
@@ -32,7 +31,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -61,7 +59,7 @@
 */
 xfs_inode_t *
 xfs_vtoi(
-        struct vnode    *vp)
+        bhv_vnode_t     *vp)
 {
        bhv_desc_t      *bdp;
@@ -80,7 +78,7 @@ void
 xfs_synchronize_atime(
        xfs_inode_t     *ip)
 {
-        vnode_t         *vp;
+        bhv_vnode_t     *vp;
        vp = XFS_ITOV_NULL(ip);
        if (vp) {
@@ -200,14 +198,10 @@ xfs_ichgtime_fast(
 STATIC void
 xfs_validate_fields(
        struct inode    *ip,
-        struct vattr    *vattr)
+        bhv_vattr_t     *vattr)
 {
-        vnode_t         *vp = vn_from_inode(ip);
-        int             error;
        vattr->va_mask = XFS_AT_NLINK|XFS_AT_SIZE|XFS_AT_NBLOCKS;
-        VOP_GETATTR(vp, vattr, ATTR_LAZY, NULL, error);
+        if (!bhv_vop_getattr(vn_from_inode(ip), vattr, ATTR_LAZY, NULL)) {
-        if (likely(!error)) {
                ip->i_nlink = vattr->va_nlink;
                ip->i_blocks = vattr->va_nblocks;
@@ -225,7 +219,7 @@ xfs_validate_fields(
 */
 STATIC int
 xfs_init_security(
-        struct vnode    *vp,
+        bhv_vnode_t     *vp,
        struct inode    *dir)
 {
        struct inode    *ip = vn_to_inode(vp);
@@ -241,7 +235,7 @@ xfs_init_security(
                return -error;
        }
-        VOP_ATTR_SET(vp, name, value, length, ATTR_SECURE, NULL, error);
+        error = bhv_vop_attr_set(vp, name, value, length, ATTR_SECURE, NULL);
        if (!error)
                VMODIFY(vp);
@@ -264,13 +258,12 @@ xfs_has_fs_struct(struct task_struct *task)
 STATIC inline void
 xfs_cleanup_inode(
-        vnode_t         *dvp,
+        bhv_vnode_t     *dvp,
-        vnode_t         *vp,
+        bhv_vnode_t     *vp,
        struct dentry   *dentry,
        int             mode)
 {
        struct dentry   teardown = {};
-        int             error;
        /* Oh, the horror.
         * If we can't add the ACL or we fail in
@@ -281,9 +274,9 @@ xfs_cleanup_inode(
        teardown.d_name = dentry->d_name;
        if (S_ISDIR(mode))
-                VOP_RMDIR(dvp, &teardown, NULL, error);
+                bhv_vop_rmdir(dvp, &teardown, NULL);
        else
-                VOP_REMOVE(dvp, &teardown, NULL, error);
+                bhv_vop_remove(dvp, &teardown, NULL);
        VN_RELE(vp);
 }
@@ -295,8 +288,8 @@ xfs_vn_mknod(
        dev_t           rdev)
 {
        struct inode    *ip;
-        vattr_t         vattr = { 0 };
+        bhv_vattr_t     vattr = { 0 };
-        vnode_t         *vp = NULL, *dvp = vn_from_inode(dir);
+        bhv_vnode_t     *vp = NULL, *dvp = vn_from_inode(dir);
        xfs_acl_t       *default_acl = NULL;
        attrexists_t    test_default_acl = _ACL_DEFAULT_EXISTS;
        int             error;
@@ -330,10 +323,10 @@ xfs_vn_mknod(
                vattr.va_mask |= XFS_AT_RDEV;
                /*FALLTHROUGH*/
        case S_IFREG:
-                VOP_CREATE(dvp, dentry, &vattr, &vp, NULL, error);
+                error = bhv_vop_create(dvp, dentry, &vattr, &vp, NULL);
                break;
        case S_IFDIR:
-                VOP_MKDIR(dvp, dentry, &vattr, &vp, NULL, error);
+                error = bhv_vop_mkdir(dvp, dentry, &vattr, &vp, NULL);
                break;
        default:
                error = EINVAL;
@@ -396,14 +389,14 @@ xfs_vn_lookup(
        struct dentry   *dentry,
        struct nameidata *nd)
 {
-        struct vnode    *vp = vn_from_inode(dir), *cvp;
+        bhv_vnode_t     *vp = vn_from_inode(dir), *cvp;
        int             error;
        if (dentry->d_name.len >= MAXNAMELEN)
                return ERR_PTR(-ENAMETOOLONG);
-        VOP_LOOKUP(vp, dentry, &cvp, 0, NULL, NULL, error);
+        error = bhv_vop_lookup(vp, dentry, &cvp, 0, NULL, NULL);
-        if (error) {
+        if (unlikely(error)) {
                if (unlikely(error != ENOENT))
                        return ERR_PTR(-error);
                d_add(dentry, NULL);
@@ -420,9 +413,9 @@ xfs_vn_link(
        struct dentry   *dentry)
 {
        struct inode    *ip;    /* inode of guy being linked to */
-        vnode_t         *tdvp;  /* target directory for new name/link */
+        bhv_vnode_t     *tdvp;  /* target directory for new name/link */
-        vnode_t         *vp;    /* vp of name being linked */
+        bhv_vnode_t     *vp;    /* vp of name being linked */
-        vattr_t         vattr;
+        bhv_vattr_t     vattr;
        int             error;
        ip = old_dentry->d_inode;       /* inode being linked to */
@@ -432,7 +425,7 @@ xfs_vn_link(
        tdvp = vn_from_inode(dir);
        vp = vn_from_inode(ip);
-        VOP_LINK(tdvp, vp, dentry, NULL, error);
+        error = bhv_vop_link(tdvp, vp, dentry, NULL);
        if (likely(!error)) {
                VMODIFY(tdvp);
                VN_HOLD(vp);
@@ -448,14 +441,14 @@ xfs_vn_unlink(
        struct dentry   *dentry)
 {
        struct inode    *inode;
-        vnode_t         *dvp;   /* directory containing name to remove */
+        bhv_vnode_t     *dvp;   /* directory containing name to remove */
-        vattr_t         vattr;
+        bhv_vattr_t     vattr;
        int             error;
        inode = dentry->d_inode;
        dvp = vn_from_inode(dir);
-        VOP_REMOVE(dvp, dentry, NULL, error);
+        error = bhv_vop_remove(dvp, dentry, NULL);
        if (likely(!error)) {
                xfs_validate_fields(dir, &vattr);       /* size needs update */
                xfs_validate_fields(inode, &vattr);
@@ -470,27 +463,26 @@ xfs_vn_symlink(
        const char      *symname)
 {
        struct inode    *ip;
-        vattr_t         vattr = { 0 };
+        bhv_vattr_t     va = { 0 };
-        vnode_t         *dvp;   /* directory containing name of symlink */
+        bhv_vnode_t     *dvp;   /* directory containing name of symlink */
-        vnode_t         *cvp;   /* used to lookup symlink to put in dentry */
+        bhv_vnode_t     *cvp;   /* used to lookup symlink to put in dentry */
        int             error;
        dvp = vn_from_inode(dir);
        cvp = NULL;
-        vattr.va_mode = S_IFLNK |
+        va.va_mode = S_IFLNK |
                (irix_symlink_mode ? 0777 & ~current->fs->umask : S_IRWXUGO);
-        vattr.va_mask = XFS_AT_TYPE|XFS_AT_MODE;
+        va.va_mask = XFS_AT_TYPE|XFS_AT_MODE;
-        error = 0;
+        error = bhv_vop_symlink(dvp, dentry, &va, (char *)symname, &cvp, NULL);
-        VOP_SYMLINK(dvp, dentry, &vattr, (char *)symname, &cvp, NULL, error);
        if (likely(!error && cvp)) {
                error = xfs_init_security(cvp, dir);
                if (likely(!error)) {
                        ip = vn_to_inode(cvp);
                        d_instantiate(dentry, ip);
-                        xfs_validate_fields(dir, &vattr);
+                        xfs_validate_fields(dir, &va);
-                        xfs_validate_fields(ip, &vattr);
+                        xfs_validate_fields(ip, &va);
                } else {
                        xfs_cleanup_inode(dvp, cvp, dentry, 0);
                }
@@ -504,11 +496,11 @@ xfs_vn_rmdir(
        struct dentry   *dentry)
 {
        struct inode    *inode = dentry->d_inode;
-        vnode_t         *dvp = vn_from_inode(dir);
+        bhv_vnode_t     *dvp = vn_from_inode(dir);
-        vattr_t         vattr;
+        bhv_vattr_t     vattr;
        int             error;
-        VOP_RMDIR(dvp, dentry, NULL, error);
+        error = bhv_vop_rmdir(dvp, dentry, NULL);
        if (likely(!error)) {
                xfs_validate_fields(inode, &vattr);
                xfs_validate_fields(dir, &vattr);
@@ -524,15 +516,15 @@ xfs_vn_rename(
        struct dentry   *ndentry)
 {
        struct inode    *new_inode = ndentry->d_inode;
-        vnode_t         *fvp;   /* from directory */
+        bhv_vnode_t     *fvp;   /* from directory */
-        vnode_t         *tvp;   /* target directory */
+        bhv_vnode_t     *tvp;   /* target directory */
-        vattr_t         vattr;
+        bhv_vattr_t     vattr;
        int             error;
        fvp = vn_from_inode(odir);
        tvp = vn_from_inode(ndir);
-        VOP_RENAME(fvp, odentry, tvp, ndentry, NULL, error);
+        error = bhv_vop_rename(fvp, odentry, tvp, ndentry, NULL);
        if (likely(!error)) {
                if (new_inode)
                        xfs_validate_fields(new_inode, &vattr);
@@ -553,7 +545,7 @@ xfs_vn_follow_link(
        struct dentry           *dentry,
        struct nameidata        *nd)
 {
-        vnode_t                 *vp;
+        bhv_vnode_t             *vp;
        uio_t                   *uio;
        iovec_t                 iov;
        int                     error;
@@ -586,8 +578,8 @@ xfs_vn_follow_link(
        uio->uio_resid = MAXPATHLEN;
        uio->uio_iovcnt = 1;
-        VOP_READLINK(vp, uio, 0, NULL, error);
+        error = bhv_vop_readlink(vp, uio, 0, NULL);
-        if (error) {
+        if (unlikely(error)) {
                kfree(link);
                link = ERR_PTR(-error);
        } else {
@@ -618,12 +610,7 @@ xfs_vn_permission(
        int             mode,
        struct nameidata *nd)
 {
-        vnode_t         *vp = vn_from_inode(inode);
+        return -bhv_vop_access(vn_from_inode(inode), mode << 6, NULL);
-        int             error;
-        mode <<= 6;             /* convert from linux to vnode access bits */
-        VOP_ACCESS(vp, mode, NULL, error);
-        return -error;
 }
 #else
 #define xfs_vn_permission NULL
@@ -636,14 +623,14 @@ xfs_vn_getattr(
        struct kstat    *stat)
 {
        struct inode    *inode = dentry->d_inode;
-        vnode_t         *vp = vn_from_inode(inode);
+        bhv_vnode_t     *vp = vn_from_inode(inode);
        int             error = 0;
        if (unlikely(vp->v_flag & VMODIFIED))
                error = vn_revalidate(vp);
        if (!error)
                generic_fillattr(inode, stat);
-        return 0;
+        return -error;
 }
 STATIC int
@@ -653,8 +640,8 @@ xfs_vn_setattr(
 {
        struct inode    *inode = dentry->d_inode;
        unsigned int    ia_valid = attr->ia_valid;
-        vnode_t         *vp = vn_from_inode(inode);
+        bhv_vnode_t     *vp = vn_from_inode(inode);
-        vattr_t         vattr = { 0 };
+        bhv_vattr_t     vattr = { 0 };
        int             flags = 0;
        int             error;
@@ -697,7 +684,7 @@ xfs_vn_setattr(
                flags |= ATTR_NONBLOCK;
 #endif
-        VOP_SETATTR(vp, &vattr, flags, NULL, error);
+        error = bhv_vop_setattr(vp, &vattr, flags, NULL);
        if (likely(!error))
                __vn_revalidate(vp, &vattr);
        return -error;
@@ -718,7 +705,7 @@ xfs_vn_setxattr(
        size_t          size,
        int             flags)
 {
-        vnode_t         *vp = vn_from_inode(dentry->d_inode);
+        bhv_vnode_t     *vp = vn_from_inode(dentry->d_inode);
        char            *attr = (char *)name;
        attrnames_t     *namesp;
        int             xflags = 0;
@@ -748,7 +735,7 @@ xfs_vn_getxattr(
        void            *data,
        size_t          size)
 {
-        vnode_t         *vp = vn_from_inode(dentry->d_inode);
+        bhv_vnode_t     *vp = vn_from_inode(dentry->d_inode);
        char            *attr = (char *)name;
        attrnames_t     *namesp;
        int             xflags = 0;
@@ -777,7 +764,7 @@ xfs_vn_listxattr(
        char                    *data,
        size_t                  size)
 {
-        vnode_t                 *vp = vn_from_inode(dentry->d_inode);
+        bhv_vnode_t             *vp = vn_from_inode(dentry->d_inode);
        int                     error, xflags = ATTR_KERNAMELS;
        ssize_t                 result;
@@ -796,7 +783,7 @@ xfs_vn_removexattr(
        struct dentry   *dentry,
        const char      *name)
 {
-        vnode_t         *vp = vn_from_inode(dentry->d_inode);
+        bhv_vnode_t     *vp = vn_from_inode(dentry->d_inode);
        char            *attr = (char *)name;
        attrnames_t     *namesp;
        int             xflags = 0;
diff --git a/fs/xfs/linux-2.6/xfs_linux.h b/fs/xfs/linux-2.6/xfs_linux.h
index e9fe43d74768..aa26ab906c88 100644
--- a/fs/xfs/linux-2.6/xfs_linux.h
+++ b/fs/xfs/linux-2.6/xfs_linux.h
@@ -134,14 +134,21 @@ BUFFER_FNS(PrivateStart, unwritten);
 #define xfs_buf_age_centisecs   xfs_params.xfs_buf_age.val
 #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
-#ifndef raw_smp_processor_id
+#define current_cpu()           (raw_smp_processor_id())
-#define raw_smp_processor_id()  smp_processor_id()
-#endif
-#define current_cpu()           raw_smp_processor_id()
 #define current_pid()           (current->pid)
 #define current_fsuid(cred)     (current->fsuid)
 #define current_fsgid(cred)     (current->fsgid)
+#define current_set_flags(f)    (current->flags |= (f))
+#define current_test_flags(f)   (current->flags & (f))
+#define current_clear_flags(f)  (current->flags & ~(f))
+#define current_set_flags_nested(sp, f)         \
+                (*(sp) = current->flags, current->flags |= (f))
+#define current_clear_flags_nested(sp, f)       \
+                (*(sp) = current->flags, current->flags &= ~(f))
+#define current_restore_flags_nested(sp, f)     \
+                (current->flags = ((current->flags & ~(f)) | (*(sp) & (f))))
 #define NBPP            PAGE_SIZE
 #define DPPSHFT         (PAGE_SHIFT - 9)
@@ -187,25 +194,9 @@ BUFFER_FNS(PrivateStart, unwritten);
 /* bytes to clicks */
 #define btoc(x)         (((__psunsigned_t)(x)+(NBPC-1))>>BPCSHIFT)
-#ifndef ENOATTR
 #define ENOATTR         ENODATA         /* Attribute not found */
-#endif
+#define EWRONGFS        EINVAL          /* Mount with wrong filesystem type */
+#define EFSCORRUPTED    EUCLEAN         /* Filesystem is corrupted */
-/* Note: EWRONGFS never visible outside the kernel */
-#define EWRONGFS        EINVAL          /* Mount with wrong filesystem type */
-/*
- * XXX EFSCORRUPTED needs a real value in errno.h. asm-i386/errno.h won't
- *     return codes out of its known range in errno.
- * XXX Also note: needs to be < 1000 and fairly unique on Linux (mustn't
- *     conflict with any code we use already or any code a driver may use)
- * XXX Some options (currently we do #2):
- *      1/ New error code ["Filesystem is corrupted", _after_ glibc updated]
- *      2/ 990 ["Unknown error 990"]
- *      3/ EUCLEAN ["Structure needs cleaning"]
- *      4/ Convert EFSCORRUPTED to EIO [just prior to return into userspace]
- */
-#define EFSCORRUPTED    990             /* Filesystem is corrupted */
 #define SYNCHRONIZE()   barrier()
 #define __return_address __builtin_return_address(0)
diff --git a/fs/xfs/linux-2.6/xfs_lrw.c b/fs/xfs/linux-2.6/xfs_lrw.c
index 67efe3308980..5d9cfd91ad08 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.c
+++ b/fs/xfs/linux-2.6/xfs_lrw.c
@@ -23,7 +23,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
 #include "xfs_dmapi.h"
@@ -32,7 +31,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -206,7 +204,7 @@ xfs_read(
        xfs_fsize_t             n;
        xfs_inode_t             *ip;
        xfs_mount_t             *mp;
-        vnode_t                 *vp;
+        bhv_vnode_t             *vp;
        unsigned long           seg;
        ip = XFS_BHVTOI(bdp);
@@ -258,7 +256,7 @@ xfs_read(
        if (DM_EVENT_ENABLED(vp->v_vfsp, ip, DM_EVENT_READ) &&
            !(ioflags & IO_INVIS)) {
-                vrwlock_t locktype = VRWLOCK_READ;
+                bhv_vrwlock_t locktype = VRWLOCK_READ;
                int dmflags = FILP_DELAY_FLAG(file) | DM_SEM_FLAG_RD(ioflags);
                ret = -XFS_SEND_DATA(mp, DM_EVENT_READ,
@@ -271,7 +269,7 @@ xfs_read(
        }
        if (unlikely((ioflags & IO_ISDIRECT) && VN_CACHED(vp)))
-                VOP_FLUSHINVAL_PAGES(vp, ctooff(offtoct(*offset)),
+                bhv_vop_flushinval_pages(vp, ctooff(offtoct(*offset)),
                                                -1, FI_REMAPF_LOCKED);
        xfs_rw_enter_trace(XFS_READ_ENTER, &ip->i_iocore,
@@ -313,7 +311,7 @@ xfs_sendfile(
        if (DM_EVENT_ENABLED(BHV_TO_VNODE(bdp)->v_vfsp, ip, DM_EVENT_READ) &&
            (!(ioflags & IO_INVIS))) {
-                vrwlock_t locktype = VRWLOCK_READ;
+                bhv_vrwlock_t locktype = VRWLOCK_READ;
                int error;
                error = XFS_SEND_DATA(mp, DM_EVENT_READ, BHV_TO_VNODE(bdp),
@@ -357,7 +355,7 @@ xfs_splice_read(
        if (DM_EVENT_ENABLED(BHV_TO_VNODE(bdp)->v_vfsp, ip, DM_EVENT_READ) &&
            (!(ioflags & IO_INVIS))) {
-                vrwlock_t locktype = VRWLOCK_READ;
+                bhv_vrwlock_t locktype = VRWLOCK_READ;
                int error;
                error = XFS_SEND_DATA(mp, DM_EVENT_READ, BHV_TO_VNODE(bdp),
@@ -401,7 +399,7 @@ xfs_splice_write(
        if (DM_EVENT_ENABLED(BHV_TO_VNODE(bdp)->v_vfsp, ip, DM_EVENT_WRITE) &&
            (!(ioflags & IO_INVIS))) {
-                vrwlock_t locktype = VRWLOCK_WRITE;
+                bhv_vrwlock_t locktype = VRWLOCK_WRITE;
                int error;
                error = XFS_SEND_DATA(mp, DM_EVENT_WRITE, BHV_TO_VNODE(bdp),
@@ -458,7 +456,7 @@ xfs_zero_last_block(
        last_fsb = XFS_B_TO_FSBT(mp, isize);
        nimaps = 1;
        error = XFS_BMAPI(mp, NULL, io, last_fsb, 1, 0, NULL, 0, &imap,
-                          &nimaps, NULL);
+                          &nimaps, NULL, NULL);
        if (error) {
                return error;
        }
@@ -499,7 +497,7 @@ xfs_zero_last_block(
 int                                     /* error (positive) */
 xfs_zero_eof(
-        vnode_t         *vp,
+        bhv_vnode_t     *vp,
        xfs_iocore_t    *io,
        xfs_off_t       offset,         /* starting I/O offset */
        xfs_fsize_t     isize,          /* current inode size */
@@ -510,7 +508,6 @@ xfs_zero_eof(
        xfs_fileoff_t   end_zero_fsb;
        xfs_fileoff_t   zero_count_fsb;
        xfs_fileoff_t   last_fsb;
-        xfs_extlen_t    buf_len_fsb;
        xfs_mount_t     *mp = io->io_mount;
        int             nimaps;
        int             error = 0;
@@ -556,7 +553,7 @@ xfs_zero_eof(
                nimaps = 1;
                zero_count_fsb = end_zero_fsb - start_zero_fsb + 1;
                error = XFS_BMAPI(mp, NULL, io, start_zero_fsb, zero_count_fsb,
-                                  0, NULL, 0, &imap, &nimaps, NULL);
+                                  0, NULL, 0, &imap, &nimaps, NULL, NULL);
                if (error) {
                        ASSERT(ismrlocked(io->io_lock, MR_UPDATE));
                        ASSERT(ismrlocked(io->io_iolock, MR_UPDATE));
@@ -579,16 +576,7 @@ xfs_zero_eof(
                }
                /*
-                 * There are blocks in the range requested.
+                 * There are blocks we need to zero.
-                 * Zero them a single write at a time.  We actually
-                 * don't zero the entire range returned if it is
-                 * too big and simply loop around to get the rest.
-                 * That is not the most efficient thing to do, but it
-                 * is simple and this path should not be exercised often.
-                 */
-                buf_len_fsb = XFS_FILBLKS_MIN(imap.br_blockcount,
-                                              mp->m_writeio_blocks << 8);
-                /*
                 * Drop the inode lock while we're doing the I/O.
                 * We'll still have the iolock to protect us.
                 */
@@ -596,14 +584,13 @@ xfs_zero_eof(
                error = xfs_iozero(ip,
                                   XFS_FSB_TO_B(mp, start_zero_fsb),
-                                   XFS_FSB_TO_B(mp, buf_len_fsb),
+                                   XFS_FSB_TO_B(mp, imap.br_blockcount),
                                   end_size);
                if (error) {
                        goto out_lock;
                }
-                start_zero_fsb = imap.br_startoff + buf_len_fsb;
+                start_zero_fsb = imap.br_startoff + imap.br_blockcount;
                ASSERT(start_zero_fsb <= (end_zero_fsb + 1));
                XFS_ILOCK(mp, io, XFS_ILOCK_EXCL|XFS_EXTSIZE_RD);
@@ -637,11 +624,11 @@ xfs_write(
        ssize_t                 ret = 0, error = 0;
        xfs_fsize_t             isize, new_size;
        xfs_iocore_t            *io;
-        vnode_t                 *vp;
+        bhv_vnode_t             *vp;
        unsigned long           seg;
        int                     iolock;
        int                     eventsent = 0;
-        vrwlock_t               locktype;
+        bhv_vrwlock_t           locktype;
        size_t                  ocount = 0, count;
        loff_t                  pos;
        int                     need_i_mutex = 1, need_flush = 0;
@@ -679,11 +666,11 @@ xfs_write(
        io = &xip->i_iocore;
        mp = io->io_mount;
+        vfs_wait_for_freeze(vp->v_vfsp, SB_FREEZE_WRITE);
        if (XFS_FORCED_SHUTDOWN(mp))
                return -EIO;
-        fs_check_frozen(vp->v_vfsp, SB_FREEZE_WRITE);
        if (ioflags & IO_ISDIRECT) {
                xfs_buftarg_t   *target =
                        (xip->i_d.di_flags & XFS_DIFLAG_REALTIME) ?
@@ -814,7 +801,7 @@ retry:
                if (need_flush) {
                        xfs_inval_cached_trace(io, pos, -1,
                                        ctooff(offtoct(pos)), -1);
-                        VOP_FLUSHINVAL_PAGES(vp, ctooff(offtoct(pos)),
+                        bhv_vop_flushinval_pages(vp, ctooff(offtoct(pos)),
                                        -1, FI_REMAPF_LOCKED);
                }
@@ -903,79 +890,9 @@ retry:
        /* Handle various SYNC-type writes */
        if ((file->f_flags & O_SYNC) || IS_SYNC(inode)) {
-                /*
+                error = xfs_write_sync_logforce(mp, xip);
-                 * If we're treating this as O_DSYNC and we have not updated the
+                if (error)
-                 * size, force the log.
+                        goto out_unlock_internal;
-                 */
-                if (!(mp->m_flags & XFS_MOUNT_OSYNCISOSYNC) &&
-                    !(xip->i_update_size)) {
-                        xfs_inode_log_item_t    *iip = xip->i_itemp;
-                        /*
-                         * If an allocation transaction occurred
-                         * without extending the size, then we have to force
-                         * the log up the proper point to ensure that the
-                         * allocation is permanent.  We can't count on
-                         * the fact that buffered writes lock out direct I/O
-                         * writes - the direct I/O write could have extended
-                         * the size nontransactionally, then finished before
-                         * we started.  xfs_write_file will think that the file
-                         * didn't grow but the update isn't safe unless the
-                         * size change is logged.
-                         *
-                         * Force the log if we've committed a transaction
-                         * against the inode or if someone else has and
-                         * the commit record hasn't gone to disk (e.g.
-                         * the inode is pinned).  This guarantees that
-                         * all changes affecting the inode are permanent
-                         * when we return.
-                         */
-                        if (iip && iip->ili_last_lsn) {
-                                xfs_log_force(mp, iip->ili_last_lsn,
-                                                XFS_LOG_FORCE | XFS_LOG_SYNC);
-                        } else if (xfs_ipincount(xip) > 0) {
-                                xfs_log_force(mp, (xfs_lsn_t)0,
-                                                XFS_LOG_FORCE | XFS_LOG_SYNC);
-                        }
-                } else {
-                        xfs_trans_t     *tp;
-                        /*
-                         * O_SYNC or O_DSYNC _with_ a size update are handled
-                         * the same way.
-                         *
-                         * If the write was synchronous then we need to make
-                         * sure that the inode modification time is permanent.
-                         * We'll have updated the timestamp above, so here
-                         * we use a synchronous transaction to log the inode.
-                         * It's not fast, but it's necessary.
-                         *
-                         * If this a dsync write and the size got changed
-                         * non-transactionally, then we need to ensure that
-                         * the size change gets logged in a synchronous
-                         * transaction.
-                         */
-                        tp = xfs_trans_alloc(mp, XFS_TRANS_WRITE_SYNC);
-                        if ((error = xfs_trans_reserve(tp, 0,
-                                                      XFS_SWRITE_LOG_RES(mp),
-                                                      0, 0, 0))) {
-                                /* Transaction reserve failed */
-                                xfs_trans_cancel(tp, 0);
-                        } else {
-                                /* Transaction reserve successful */
-                                xfs_ilock(xip, XFS_ILOCK_EXCL);
-                                xfs_trans_ijoin(tp, xip, XFS_ILOCK_EXCL);
-                                xfs_trans_ihold(tp, xip);
-                                xfs_trans_log_inode(tp, xip, XFS_ILOG_CORE);
-                                xfs_trans_set_sync(tp);
-                                error = xfs_trans_commit(tp, 0, NULL);
-                                xfs_iunlock(xip, XFS_ILOCK_EXCL);
-                        }
-                        if (error)
-                                goto out_unlock_internal;
-                }
                xfs_rwunlock(bdp, locktype);
                if (need_i_mutex)
diff --git a/fs/xfs/linux-2.6/xfs_lrw.h b/fs/xfs/linux-2.6/xfs_lrw.h
index 8f4539952350..c77e62efb742 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.h
+++ b/fs/xfs/linux-2.6/xfs_lrw.h
@@ -18,8 +18,8 @@
 #ifndef __XFS_LRW_H__
 #define __XFS_LRW_H__
-struct vnode;
 struct bhv_desc;
+struct bhv_vnode;
 struct xfs_mount;
 struct xfs_iocore;
 struct xfs_inode;
@@ -49,7 +49,7 @@ struct xfs_iomap;
 #define XFS_CTRUNC4             14
 #define XFS_CTRUNC5             15
 #define XFS_CTRUNC6             16
-#define XFS_BUNMAPI             17
+#define XFS_BUNMAP              17
 #define XFS_INVAL_CACHED        18
 #define XFS_DIORD_ENTER         19
 #define XFS_DIOWR_ENTER         20
@@ -82,7 +82,7 @@ extern int xfsbdstrat(struct xfs_mount *, struct xfs_buf *);
 extern int xfs_bdstrat_cb(struct xfs_buf *);
 extern int xfs_dev_is_read_only(struct xfs_mount *, char *);
-extern int xfs_zero_eof(struct vnode *, struct xfs_iocore *, xfs_off_t,
+extern int xfs_zero_eof(struct bhv_vnode *, struct xfs_iocore *, xfs_off_t,
                                xfs_fsize_t, xfs_fsize_t);
 extern ssize_t xfs_read(struct bhv_desc *, struct kiocb *,
                                const struct iovec *, unsigned int,
diff --git a/fs/xfs/linux-2.6/xfs_stats.c b/fs/xfs/linux-2.6/xfs_stats.c
index 1f0589a05eca..e480b6102051 100644
--- a/fs/xfs/linux-2.6/xfs_stats.c
+++ b/fs/xfs/linux-2.6/xfs_stats.c
@@ -62,7 +62,7 @@ xfs_read_xfsstats(
                while (j < xstats[i].endpoint) {
                        val = 0;
                        /* sum over all cpus */
-                        for_each_cpu(c)
+                        for_each_possible_cpu(c)
                                val += *(((__u32*)&per_cpu(xfsstats, c) + j));
                        len += sprintf(buffer + len, " %u", val);
                        j++;
@@ -70,7 +70,7 @@ xfs_read_xfsstats(
                buffer[len++] = '\n';
        }
        /* extra precision counters */
-        for_each_cpu(i) {
+        for_each_possible_cpu(i) {
                xs_xstrat_bytes += per_cpu(xfsstats, i).xs_xstrat_bytes;
                xs_write_bytes += per_cpu(xfsstats, i).xs_write_bytes;
                xs_read_bytes += per_cpu(xfsstats, i).xs_read_bytes;
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 68f4793e8a11..9bdef9d51900 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2005 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
@@ -23,7 +23,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
 #include "xfs_dmapi.h"
@@ -32,7 +31,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -151,7 +149,7 @@ xfs_set_inodeops(
 STATIC __inline__ void
 xfs_revalidate_inode(
        xfs_mount_t             *mp,
-        vnode_t                 *vp,
+        bhv_vnode_t             *vp,
        xfs_inode_t             *ip)
 {
        struct inode            *inode = vn_to_inode(vp);
@@ -206,7 +204,7 @@ xfs_revalidate_inode(
 void
 xfs_initialize_vnode(
        bhv_desc_t              *bdp,
-        vnode_t                 *vp,
+        bhv_vnode_t             *vp,
        bhv_desc_t              *inode_bhv,
        int                     unlock)
 {
@@ -336,7 +334,7 @@ STATIC struct inode *
 xfs_fs_alloc_inode(
        struct super_block      *sb)
 {
-        vnode_t                 *vp;
+        bhv_vnode_t             *vp;
        vp = kmem_zone_alloc(xfs_vnode_zone, KM_SLEEP);
        if (unlikely(!vp))
@@ -359,13 +357,13 @@ xfs_fs_inode_init_once(
 {
        if ((flags & (SLAB_CTOR_VERIFY|SLAB_CTOR_CONSTRUCTOR)) ==
                      SLAB_CTOR_CONSTRUCTOR)
-                inode_init_once(vn_to_inode((vnode_t *)vnode));
+                inode_init_once(vn_to_inode((bhv_vnode_t *)vnode));
 }
 STATIC int
 xfs_init_zones(void)
 {
-        xfs_vnode_zone = kmem_zone_init_flags(sizeof(vnode_t), "xfs_vnode_t",
+        xfs_vnode_zone = kmem_zone_init_flags(sizeof(bhv_vnode_t), "xfs_vnode",
                                        KM_ZONE_HWALIGN | KM_ZONE_RECLAIM |
                                        KM_ZONE_SPREAD,
                                        xfs_fs_inode_init_once);
@@ -409,22 +407,17 @@ xfs_fs_write_inode(
        struct inode            *inode,
        int                     sync)
 {
-        vnode_t                 *vp = vn_from_inode(inode);
+        bhv_vnode_t             *vp = vn_from_inode(inode);
        int                     error = 0, flags = FLUSH_INODE;
        if (vp) {
                vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
                if (sync)
                        flags |= FLUSH_SYNC;
-                VOP_IFLUSH(vp, flags, error);
+                error = bhv_vop_iflush(vp, flags);
-                if (error == EAGAIN) {
+                if (error == EAGAIN)
-                        if (sync)
+                        error = sync? bhv_vop_iflush(vp, flags | FLUSH_LOG) : 0;
-                                VOP_IFLUSH(vp, flags | FLUSH_LOG, error);
-                        else
-                                error = 0;
-                }
        }
        return -error;
 }
@@ -432,8 +425,7 @@ STATIC void
 xfs_fs_clear_inode(
        struct inode            *inode)
 {
-        vnode_t                 *vp = vn_from_inode(inode);
+        bhv_vnode_t             *vp = vn_from_inode(inode);
-        int                     error, cache;
        vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
@@ -446,20 +438,18 @@ xfs_fs_clear_inode(
         * This can happen because xfs_iget_core calls xfs_idestroy if we
         * find an inode with di_mode == 0 but without IGET_CREATE set.
         */
-        if (vp->v_fbhv)
+        if (VNHEAD(vp))
-                VOP_INACTIVE(vp, NULL, cache);
+                bhv_vop_inactive(vp, NULL);
        VN_LOCK(vp);
        vp->v_flag &= ~VMODIFIED;
        VN_UNLOCK(vp, 0);
-        if (vp->v_fbhv) {
+        if (VNHEAD(vp))
-                VOP_RECLAIM(vp, error);
+                if (bhv_vop_reclaim(vp))
-                if (error)
+                        panic("%s: cannot reclaim 0x%p\n", __FUNCTION__, vp);
-                        panic("vn_purge: cannot reclaim");
-        }
-        ASSERT(vp->v_fbhv == NULL);
+        ASSERT(VNHEAD(vp) == NULL);
 #ifdef XFS_VNODE_TRACE
        ktrace_free(vp->v_trace);
@@ -475,13 +465,13 @@ xfs_fs_clear_inode(
 */
 STATIC void
 xfs_syncd_queue_work(
-        struct vfs      *vfs,
+        struct bhv_vfs  *vfs,
        void            *data,
-        void            (*syncer)(vfs_t *, void *))
+        void            (*syncer)(bhv_vfs_t *, void *))
 {
-        vfs_sync_work_t *work;
+        struct bhv_vfs_sync_work *work;
-        work = kmem_alloc(sizeof(struct vfs_sync_work), KM_SLEEP);
+        work = kmem_alloc(sizeof(struct bhv_vfs_sync_work), KM_SLEEP);
        INIT_LIST_HEAD(&work->w_list);
        work->w_syncer = syncer;
        work->w_data = data;
@@ -500,7 +490,7 @@ xfs_syncd_queue_work(
 */
 STATIC void
 xfs_flush_inode_work(
-        vfs_t           *vfs,
+        bhv_vfs_t       *vfs,
        void            *inode)
 {
        filemap_flush(((struct inode *)inode)->i_mapping);
@@ -512,7 +502,7 @@ xfs_flush_inode(
        xfs_inode_t     *ip)
 {
        struct inode    *inode = vn_to_inode(XFS_ITOV(ip));
-        struct vfs      *vfs = XFS_MTOVFS(ip->i_mount);
+        struct bhv_vfs  *vfs = XFS_MTOVFS(ip->i_mount);
        igrab(inode);
        xfs_syncd_queue_work(vfs, inode, xfs_flush_inode_work);
@@ -525,7 +515,7 @@ xfs_flush_inode(
 */
 STATIC void
 xfs_flush_device_work(
-        vfs_t           *vfs,
+        bhv_vfs_t       *vfs,
        void            *inode)
 {
        sync_blockdev(vfs->vfs_super->s_bdev);
@@ -537,7 +527,7 @@ xfs_flush_device(
        xfs_inode_t     *ip)
 {
        struct inode    *inode = vn_to_inode(XFS_ITOV(ip));
-        struct vfs      *vfs = XFS_MTOVFS(ip->i_mount);
+        struct bhv_vfs  *vfs = XFS_MTOVFS(ip->i_mount);
        igrab(inode);
        xfs_syncd_queue_work(vfs, inode, xfs_flush_device_work);
@@ -545,16 +535,16 @@ xfs_flush_device(
        xfs_log_force(ip->i_mount, (xfs_lsn_t)0, XFS_LOG_FORCE|XFS_LOG_SYNC);
 }
-#define SYNCD_FLAGS     (SYNC_FSDATA|SYNC_BDFLUSH|SYNC_ATTR|SYNC_REFCACHE)
 STATIC void
 vfs_sync_worker(
-        vfs_t           *vfsp,
+        bhv_vfs_t       *vfsp,
        void            *unused)
 {
        int             error;
        if (!(vfsp->vfs_flag & VFS_RDONLY))
-                VFS_SYNC(vfsp, SYNCD_FLAGS, NULL, error);
+                error = bhv_vfs_sync(vfsp, SYNC_FSDATA | SYNC_BDFLUSH | \
+                                        SYNC_ATTR | SYNC_REFCACHE, NULL);
        vfsp->vfs_sync_seq++;
        wmb();
        wake_up(&vfsp->vfs_wait_single_sync_task);
@@ -565,8 +555,8 @@ xfssyncd(
        void                    *arg)
 {
        long                    timeleft;
-        vfs_t                   *vfsp = (vfs_t *) arg;
+        bhv_vfs_t               *vfsp = (bhv_vfs_t *) arg;
-        struct vfs_sync_work    *work, *n;
+        bhv_vfs_sync_work_t     *work, *n;
        LIST_HEAD               (tmp);
        timeleft = xfs_syncd_centisecs * msecs_to_jiffies(10);
@@ -600,7 +590,7 @@ xfssyncd(
                        list_del(&work->w_list);
                        if (work == &vfsp->vfs_sync_work)
                                continue;
-                        kmem_free(work, sizeof(struct vfs_sync_work));
+                        kmem_free(work, sizeof(struct bhv_vfs_sync_work));
                }
        }
@@ -609,7 +599,7 @@ xfssyncd(
 STATIC int
 xfs_fs_start_syncd(
-        vfs_t                   *vfsp)
+        bhv_vfs_t               *vfsp)
 {
        vfsp->vfs_sync_work.w_syncer = vfs_sync_worker;
        vfsp->vfs_sync_work.w_vfs = vfsp;
@@ -621,7 +611,7 @@ xfs_fs_start_syncd(
 STATIC void
 xfs_fs_stop_syncd(
-        vfs_t                   *vfsp)
+        bhv_vfs_t               *vfsp)
 {
        kthread_stop(vfsp->vfs_sync_task);
 }
@@ -630,35 +620,26 @@ STATIC void
 xfs_fs_put_super(
        struct super_block      *sb)
 {
-        vfs_t                   *vfsp = vfs_from_sb(sb);
+        bhv_vfs_t               *vfsp = vfs_from_sb(sb);
        int                     error;
        xfs_fs_stop_syncd(vfsp);
-        VFS_SYNC(vfsp, SYNC_ATTR|SYNC_DELWRI, NULL, error);
+        bhv_vfs_sync(vfsp, SYNC_ATTR | SYNC_DELWRI, NULL);
-        if (!error)
+        error = bhv_vfs_unmount(vfsp, 0, NULL);
-                VFS_UNMOUNT(vfsp, 0, NULL, error);
        if (error) {
-                printk("XFS unmount got error %d\n", error);
+                printk("XFS: unmount got error=%d\n", error);
-                printk("%s: vfsp/0x%p left dangling!\n", __FUNCTION__, vfsp);
+                printk("%s: vfs=0x%p left dangling!\n", __FUNCTION__, vfsp);
-                return;
+        } else {
+                vfs_deallocate(vfsp);
        }
-        vfs_deallocate(vfsp);
 }
 STATIC void
 xfs_fs_write_super(
        struct super_block      *sb)
 {
-        vfs_t                   *vfsp = vfs_from_sb(sb);
+        if (!(sb->s_flags & MS_RDONLY))
-        int                     error;
+                bhv_vfs_sync(vfs_from_sb(sb), SYNC_FSDATA, NULL);
-        if (sb->s_flags & MS_RDONLY) {
-                sb->s_dirt = 0; /* paranoia */
-                return;
-        }
-        /* Push the log and superblock a little */
-        VFS_SYNC(vfsp, SYNC_FSDATA, NULL, error);
        sb->s_dirt = 0;
 }
@@ -667,16 +648,16 @@ xfs_fs_sync_super(
        struct super_block      *sb,
        int                     wait)
 {
-        vfs_t           *vfsp = vfs_from_sb(sb);
+        bhv_vfs_t               *vfsp = vfs_from_sb(sb);
-        int             error;
+        int                     error;
-        int             flags = SYNC_FSDATA;
+        int                     flags;
        if (unlikely(sb->s_frozen == SB_FREEZE_WRITE))
                flags = SYNC_QUIESCE;
        else
                flags = SYNC_FSDATA | (wait ? SYNC_WAIT : 0);
-        VFS_SYNC(vfsp, flags, NULL, error);
+        error = bhv_vfs_sync(vfsp, flags, NULL);
        sb->s_dirt = 0;
        if (unlikely(laptop_mode)) {
@@ -703,14 +684,11 @@ xfs_fs_sync_super(
 STATIC int
 xfs_fs_statfs(
-        struct super_block      *sb,
+        struct dentry           *dentry,
        struct kstatfs          *statp)
 {
-        vfs_t                   *vfsp = vfs_from_sb(sb);
+        return -bhv_vfs_statvfs(vfs_from_sb(dentry->d_sb), statp,
-        int                     error;
+                                vn_from_inode(dentry->d_inode));
-        VFS_STATVFS(vfsp, statp, NULL, error);
-        return -error;
 }
 STATIC int
@@ -719,13 +697,13 @@ xfs_fs_remount(
        int                     *flags,
        char                    *options)
 {
-        vfs_t                   *vfsp = vfs_from_sb(sb);
+        bhv_vfs_t               *vfsp = vfs_from_sb(sb);
        struct xfs_mount_args   *args = xfs_args_allocate(sb, 0);
        int                     error;
-        VFS_PARSEARGS(vfsp, options, args, 1, error);
+        error = bhv_vfs_parseargs(vfsp, options, args, 1);
        if (!error)
-                VFS_MNTUPDATE(vfsp, flags, args, error);
+                error = bhv_vfs_mntupdate(vfsp, flags, args);
        kmem_free(args, sizeof(*args));
        return -error;
 }
@@ -734,7 +712,7 @@ STATIC void
 xfs_fs_lockfs(
        struct super_block      *sb)
 {
-        VFS_FREEZE(vfs_from_sb(sb));
+        bhv_vfs_freeze(vfs_from_sb(sb));
 }
 STATIC int
@@ -742,11 +720,7 @@ xfs_fs_show_options(
        struct seq_file         *m,
        struct vfsmount         *mnt)
 {
-        struct vfs              *vfsp = vfs_from_sb(mnt->mnt_sb);
+        return -bhv_vfs_showargs(vfs_from_sb(mnt->mnt_sb), m);
-        int                     error;
-        VFS_SHOWARGS(vfsp, m, error);
-        return error;
 }
 STATIC int
@@ -754,11 +728,7 @@ xfs_fs_quotasync(
        struct super_block      *sb,
        int                     type)
 {
-        struct vfs              *vfsp = vfs_from_sb(sb);
+        return -bhv_vfs_quotactl(vfs_from_sb(sb), Q_XQUOTASYNC, 0, NULL);
-        int                     error;
-        VFS_QUOTACTL(vfsp, Q_XQUOTASYNC, 0, (caddr_t)NULL, error);
-        return -error;
 }
 STATIC int
@@ -766,11 +736,7 @@ xfs_fs_getxstate(
        struct super_block      *sb,
        struct fs_quota_stat    *fqs)
 {
-        struct vfs              *vfsp = vfs_from_sb(sb);
+        return -bhv_vfs_quotactl(vfs_from_sb(sb), Q_XGETQSTAT, 0, (caddr_t)fqs);
-        int                     error;
-        VFS_QUOTACTL(vfsp, Q_XGETQSTAT, 0, (caddr_t)fqs, error);
-        return -error;
 }
 STATIC int
@@ -779,11 +745,7 @@ xfs_fs_setxstate(
        unsigned int            flags,
        int                     op)
 {
-        struct vfs              *vfsp = vfs_from_sb(sb);
+        return -bhv_vfs_quotactl(vfs_from_sb(sb), op, 0, (caddr_t)&flags);
-        int                     error;
-        VFS_QUOTACTL(vfsp, op, 0, (caddr_t)&flags, error);
-        return -error;
 }
 STATIC int
@@ -793,13 +755,10 @@ xfs_fs_getxquota(
        qid_t                   id,
        struct fs_disk_quota    *fdq)
 {
-        struct vfs              *vfsp = vfs_from_sb(sb);
+        return -bhv_vfs_quotactl(vfs_from_sb(sb),
-        int                     error, getmode;
+                                 (type == USRQUOTA) ? Q_XGETQUOTA :
+                                  ((type == GRPQUOTA) ? Q_XGETGQUOTA :
-        getmode = (type == USRQUOTA) ? Q_XGETQUOTA :
+                                   Q_XGETPQUOTA), id, (caddr_t)fdq);
-                 ((type == GRPQUOTA) ? Q_XGETGQUOTA : Q_XGETPQUOTA);
-        VFS_QUOTACTL(vfsp, getmode, id, (caddr_t)fdq, error);
-        return -error;
 }
 STATIC int
@@ -809,13 +768,10 @@ xfs_fs_setxquota(
        qid_t                   id,
        struct fs_disk_quota    *fdq)
 {
-        struct vfs              *vfsp = vfs_from_sb(sb);
+        return -bhv_vfs_quotactl(vfs_from_sb(sb),
-        int                     error, setmode;
+                                 (type == USRQUOTA) ? Q_XSETQLIM :
+                                  ((type == GRPQUOTA) ? Q_XSETGQLIM :
-        setmode = (type == USRQUOTA) ? Q_XSETQLIM :
+                                   Q_XSETPQLIM), id, (caddr_t)fdq);
-                 ((type == GRPQUOTA) ? Q_XSETGQLIM : Q_XSETPQLIM);
-        VFS_QUOTACTL(vfsp, setmode, id, (caddr_t)fdq, error);
-        return -error;
 }
 STATIC int
@@ -824,34 +780,32 @@ xfs_fs_fill_super(
        void                    *data,
        int                     silent)
 {
-        vnode_t                 *rootvp;
+        struct bhv_vnode        *rootvp;
-        struct vfs              *vfsp = vfs_allocate(sb);
+        struct bhv_vfs          *vfsp = vfs_allocate(sb);
        struct xfs_mount_args   *args = xfs_args_allocate(sb, silent);
        struct kstatfs          statvfs;
-        int                     error, error2;
+        int                     error;
        bhv_insert_all_vfsops(vfsp);
-        VFS_PARSEARGS(vfsp, (char *)data, args, 0, error);
+        error = bhv_vfs_parseargs(vfsp, (char *)data, args, 0);
        if (error) {
                bhv_remove_all_vfsops(vfsp, 1);
                goto fail_vfsop;
        }
        sb_min_blocksize(sb, BBSIZE);
-#ifdef CONFIG_XFS_EXPORT
        sb->s_export_op = &xfs_export_operations;
-#endif
        sb->s_qcop = &xfs_quotactl_operations;
        sb->s_op = &xfs_super_operations;
-        VFS_MOUNT(vfsp, args, NULL, error);
+        error = bhv_vfs_mount(vfsp, args, NULL);
        if (error) {
                bhv_remove_all_vfsops(vfsp, 1);
                goto fail_vfsop;
        }
-        VFS_STATVFS(vfsp, &statvfs, NULL, error);
+        error = bhv_vfs_statvfs(vfsp, &statvfs, NULL);
        if (error)
                goto fail_unmount;
@@ -863,7 +817,7 @@ xfs_fs_fill_super(
        sb->s_time_gran = 1;
        set_posix_acl_flag(sb);
-        VFS_ROOT(vfsp, &rootvp, error);
+        error = bhv_vfs_root(vfsp, &rootvp);
        if (error)
                goto fail_unmount;
@@ -892,7 +846,7 @@ fail_vnrele:
        }
 fail_unmount:
-        VFS_UNMOUNT(vfsp, 0, NULL, error2);
+        bhv_vfs_unmount(vfsp, 0, NULL);
 fail_vfsop:
        vfs_deallocate(vfsp);
@@ -900,14 +854,16 @@ fail_vfsop:
        return -error;
 }
-STATIC struct super_block *
+STATIC int
 xfs_fs_get_sb(
        struct file_system_type *fs_type,
        int                     flags,
        const char              *dev_name,
-        void                    *data)
+        void                    *data,
+        struct vfsmount         *mnt)
 {
-        return get_sb_bdev(fs_type, flags, dev_name, data, xfs_fs_fill_super);
+        return get_sb_bdev(fs_type, flags, dev_name, data, xfs_fs_fill_super,
+                           mnt);
 }
 STATIC struct super_operations xfs_super_operations = {
diff --git a/fs/xfs/linux-2.6/xfs_super.h b/fs/xfs/linux-2.6/xfs_super.h
index 376b96cb513a..33dd1ca13245 100644
--- a/fs/xfs/linux-2.6/xfs_super.h
+++ b/fs/xfs/linux-2.6/xfs_super.h
@@ -105,7 +105,7 @@ struct block_device;
 extern __uint64_t xfs_max_file_offset(unsigned int);
-extern void xfs_initialize_vnode(bhv_desc_t *, vnode_t *, bhv_desc_t *, int);
+extern void xfs_initialize_vnode(bhv_desc_t *, bhv_vnode_t *, bhv_desc_t *, int);
 extern void xfs_flush_inode(struct xfs_inode *);
 extern void xfs_flush_device(struct xfs_inode *);
diff --git a/fs/xfs/linux-2.6/xfs_sysctl.c b/fs/xfs/linux-2.6/xfs_sysctl.c
index 7079cc837210..af246532fbfb 100644
--- a/fs/xfs/linux-2.6/xfs_sysctl.c
+++ b/fs/xfs/linux-2.6/xfs_sysctl.c
@@ -38,7 +38,7 @@ xfs_stats_clear_proc_handler(
        if (!ret && write && *valp) {
                printk("XFS Clearing xfsstats\n");
-                for_each_cpu(c) {
+                for_each_possible_cpu(c) {
                        preempt_disable();
                        /* save vn_active, it's a universal truth! */
                        vn_active = per_cpu(xfsstats, c).vn_active;
@@ -120,6 +120,11 @@ STATIC ctl_table xfs_table[] = {
        &sysctl_intvec, NULL,
        &xfs_params.rotorstep.min, &xfs_params.rotorstep.max},
+        {XFS_INHERIT_NODFRG, "inherit_nodefrag", &xfs_params.inherit_nodfrg.val,
+        sizeof(int), 0644, NULL, &proc_dointvec_minmax,
+        &sysctl_intvec, NULL,
+        &xfs_params.inherit_nodfrg.min, &xfs_params.inherit_nodfrg.max},
        /* please keep this the last entry */
 #ifdef CONFIG_PROC_FS
        {XFS_STATS_CLEAR, "stats_clear", &xfs_params.stats_clear.val,
diff --git a/fs/xfs/linux-2.6/xfs_sysctl.h b/fs/xfs/linux-2.6/xfs_sysctl.h
index bc8c11f13722..a631fb8cc5ac 100644
--- a/fs/xfs/linux-2.6/xfs_sysctl.h
+++ b/fs/xfs/linux-2.6/xfs_sysctl.h
@@ -46,6 +46,7 @@ typedef struct xfs_param {
        xfs_sysctl_val_t xfs_buf_age;   /* Metadata buffer age before flush. */
        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_param_t;
 /*
@@ -84,6 +85,7 @@ enum {
        /* XFS_IO_BYPASS = 18 */
        XFS_INHERIT_NOSYM = 19,
        XFS_ROTORSTEP = 20,
+        XFS_INHERIT_NODFRG = 21,
 };
 extern xfs_param_t      xfs_params;
diff --git a/fs/xfs/linux-2.6/xfs_vfs.c b/fs/xfs/linux-2.6/xfs_vfs.c
index 6f7c9f7a8624..6145e8bd0be2 100644
--- a/fs/xfs/linux-2.6/xfs_vfs.c
+++ b/fs/xfs/linux-2.6/xfs_vfs.c
@@ -23,7 +23,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_imap.h"
 #include "xfs_alloc.h"
@@ -104,7 +103,7 @@ vfs_mntupdate(
 int
 vfs_root(
        struct bhv_desc         *bdp,
-        struct vnode            **vpp)
+        struct bhv_vnode        **vpp)
 {
        struct bhv_desc         *next = bdp;
@@ -117,15 +116,15 @@ vfs_root(
 int
 vfs_statvfs(
        struct bhv_desc         *bdp,
-        xfs_statfs_t            *sp,
+        bhv_statvfs_t           *statp,
-        struct vnode            *vp)
+        struct bhv_vnode        *vp)
 {
        struct bhv_desc         *next = bdp;
        ASSERT(next);
        while (! (bhvtovfsops(next))->vfs_statvfs)
                next = BHV_NEXT(next);
-        return ((*bhvtovfsops(next)->vfs_statvfs)(next, sp, vp));
+        return ((*bhvtovfsops(next)->vfs_statvfs)(next, statp, vp));
 }
 int
@@ -145,7 +144,7 @@ vfs_sync(
 int
 vfs_vget(
        struct bhv_desc         *bdp,
-        struct vnode            **vpp,
+        struct bhv_vnode        **vpp,
        struct fid              *fidp)
 {
        struct bhv_desc         *next = bdp;
@@ -187,7 +186,7 @@ vfs_quotactl(
 void
 vfs_init_vnode(
        struct bhv_desc         *bdp,
-        struct vnode            *vp,
+        struct bhv_vnode        *vp,
        struct bhv_desc         *bp,
        int                     unlock)
 {
@@ -226,13 +225,13 @@ vfs_freeze(
        ((*bhvtovfsops(next)->vfs_freeze)(next));
 }
-vfs_t *
+bhv_vfs_t *
 vfs_allocate(
        struct super_block      *sb)
 {
-        struct vfs              *vfsp;
+        struct bhv_vfs          *vfsp;
-        vfsp = kmem_zalloc(sizeof(vfs_t), KM_SLEEP);
+        vfsp = kmem_zalloc(sizeof(bhv_vfs_t), KM_SLEEP);
        bhv_head_init(VFS_BHVHEAD(vfsp), "vfs");
        INIT_LIST_HEAD(&vfsp->vfs_sync_list);
        spin_lock_init(&vfsp->vfs_sync_lock);
@@ -247,25 +246,25 @@ vfs_allocate(
        return vfsp;
 }
-vfs_t *
+bhv_vfs_t *
 vfs_from_sb(
        struct super_block      *sb)
 {
-        return (vfs_t *)sb->s_fs_info;
+        return (bhv_vfs_t *)sb->s_fs_info;
 }
 void
 vfs_deallocate(
-        struct vfs              *vfsp)
+        struct bhv_vfs          *vfsp)
 {
        bhv_head_destroy(VFS_BHVHEAD(vfsp));
-        kmem_free(vfsp, sizeof(vfs_t));
+        kmem_free(vfsp, sizeof(bhv_vfs_t));
 }
 void
 vfs_insertops(
-        struct vfs              *vfsp,
+        struct bhv_vfs          *vfsp,
-        struct bhv_vfsops       *vfsops)
+        struct bhv_module_vfsops *vfsops)
 {
        struct bhv_desc         *bdp;
@@ -276,9 +275,9 @@ vfs_insertops(
 void
 vfs_insertbhv(
-        struct vfs              *vfsp,
+        struct bhv_vfs          *vfsp,
        struct bhv_desc         *bdp,
-        struct vfsops           *vfsops,
+        struct bhv_vfsops       *vfsops,
        void                    *mount)
 {
        bhv_desc_init(bdp, mount, vfsp, vfsops);
@@ -287,7 +286,7 @@ vfs_insertbhv(
 void
 bhv_remove_vfsops(
-        struct vfs              *vfsp,
+        struct bhv_vfs          *vfsp,
        int                     pos)
 {
        struct bhv_desc         *bhv;
@@ -301,7 +300,7 @@ bhv_remove_vfsops(
 void
 bhv_remove_all_vfsops(
-        struct vfs              *vfsp,
+        struct bhv_vfs          *vfsp,
        int                     freebase)
 {
        struct xfs_mount        *mp;
@@ -317,7 +316,7 @@ bhv_remove_all_vfsops(
 void
 bhv_insert_all_vfsops(
-        struct vfs              *vfsp)
+        struct bhv_vfs          *vfsp)
 {
        struct xfs_mount        *mp;
diff --git a/fs/xfs/linux-2.6/xfs_vfs.h b/fs/xfs/linux-2.6/xfs_vfs.h
index 841200c03092..91fc2c4b3353 100644
--- a/fs/xfs/linux-2.6/xfs_vfs.h
+++ b/fs/xfs/linux-2.6/xfs_vfs.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2005 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
@@ -21,42 +21,40 @@
 #include <linux/vfs.h>
 #include "xfs_fs.h"
+struct bhv_vfs;
+struct bhv_vnode;
 struct fid;
-struct vfs;
 struct cred;
-struct vnode;
-struct kstatfs;
 struct seq_file;
 struct super_block;
 struct xfs_mount_args;
-typedef struct kstatfs xfs_statfs_t;
+typedef struct kstatfs  bhv_statvfs_t;
-typedef struct vfs_sync_work {
+typedef struct bhv_vfs_sync_work {
        struct list_head        w_list;
-        struct vfs              *w_vfs;
+        struct bhv_vfs          *w_vfs;
        void                    *w_data;        /* syncer routine argument */
-        void                    (*w_syncer)(struct vfs *, void *);
+        void                    (*w_syncer)(struct bhv_vfs *, void *);
-} vfs_sync_work_t;
+} bhv_vfs_sync_work_t;
-typedef struct vfs {
+typedef struct bhv_vfs {
        u_int                   vfs_flag;       /* flags */
        xfs_fsid_t              vfs_fsid;       /* file system ID */
        xfs_fsid_t              *vfs_altfsid;   /* An ID fixed for life of FS */
        bhv_head_t              vfs_bh;         /* head of vfs behavior chain */
        struct super_block      *vfs_super;     /* generic superblock pointer */
        struct task_struct      *vfs_sync_task; /* generalised sync thread */
-        vfs_sync_work_t         vfs_sync_work;  /* work item for VFS_SYNC */
+        bhv_vfs_sync_work_t     vfs_sync_work;  /* work item for VFS_SYNC */
        struct list_head        vfs_sync_list;  /* sync thread work item list */
        spinlock_t              vfs_sync_lock;  /* work item list lock */
-        int                     vfs_sync_seq;   /* sync thread generation no. */
+        int                     vfs_sync_seq;   /* sync thread generation no. */
        wait_queue_head_t       vfs_wait_single_sync_task;
-} vfs_t;
+} bhv_vfs_t;
-#define vfs_fbhv                vfs_bh.bh_first /* 1st on vfs behavior chain */
-#define bhvtovfs(bdp)           ( (struct vfs *)BHV_VOBJ(bdp) )
+#define bhvtovfs(bdp)           ( (struct bhv_vfs *)BHV_VOBJ(bdp) )
-#define bhvtovfsops(bdp)        ( (struct vfsops *)BHV_OPS(bdp) )
+#define bhvtovfsops(bdp)        ( (struct bhv_vfsops *)BHV_OPS(bdp) )
 #define VFS_BHVHEAD(vfs)        ( &(vfs)->vfs_bh )
 #define VFS_REMOVEBHV(vfs, bdp) ( bhv_remove(VFS_BHVHEAD(vfs), bdp) )
@@ -71,7 +69,7 @@ typedef enum {
        VFS_BHV_QM,             /* quota manager */
        VFS_BHV_IO,             /* IO path */
        VFS_BHV_END             /* housekeeping end-of-range */
-} vfs_bhv_t;
+} bhv_vfs_type_t;
 #define VFS_POSITION_XFS        (BHV_POSITION_BASE)
 #define VFS_POSITION_DM         (VFS_POSITION_BASE+10)
@@ -81,8 +79,9 @@ typedef enum {
 #define VFS_RDONLY              0x0001  /* read-only vfs */
 #define VFS_GRPID               0x0002  /* group-ID assigned from directory */
 #define VFS_DMI                 0x0004  /* filesystem has the DMI enabled */
-#define VFS_32BITINODES         0x0008  /* do not use inums above 32 bits */
+#define VFS_UMOUNT              0x0008  /* unmount in progress */
-#define VFS_END                 0x0008  /* max flag */
+#define VFS_32BITINODES         0x0010  /* do not use inums above 32 bits */
+#define VFS_END                 0x0010  /* max flag */
 #define SYNC_ATTR               0x0001  /* sync attributes */
 #define SYNC_CLOSE              0x0002  /* close file system down */
@@ -92,7 +91,14 @@ typedef enum {
 #define SYNC_FSDATA             0x0020  /* flush fs data (e.g. superblocks) */
 #define SYNC_REFCACHE           0x0040  /* prune some of the nfs ref cache */
 #define SYNC_REMOUNT            0x0080  /* remount readonly, no dummy LRs */
-#define SYNC_QUIESCE            0x0100  /* quiesce filesystem for a snapshot */
+#define SYNC_QUIESCE            0x0100  /* quiesce fileystem for a snapshot */
+#define SHUTDOWN_META_IO_ERROR  0x0001  /* write attempt to metadata failed */
+#define SHUTDOWN_LOG_IO_ERROR   0x0002  /* write attempt to the log failed */
+#define SHUTDOWN_FORCE_UMOUNT   0x0004  /* shutdown from a forced unmount */
+#define SHUTDOWN_CORRUPT_INCORE 0x0008  /* corrupt in-memory data structures */
+#define SHUTDOWN_REMOTE_REQ     0x0010  /* shutdown came from remote cell */
+#define SHUTDOWN_DEVICE_REQ     0x0020  /* failed all paths to the device */
 typedef int     (*vfs_mount_t)(bhv_desc_t *,
                                struct xfs_mount_args *, struct cred *);
@@ -102,18 +108,19 @@ typedef	int	(*vfs_showargs_t)(bhv_desc_t *, struct seq_file *);
 typedef int     (*vfs_unmount_t)(bhv_desc_t *, int, struct cred *);
 typedef int     (*vfs_mntupdate_t)(bhv_desc_t *, int *,
                                struct xfs_mount_args *);
-typedef int     (*vfs_root_t)(bhv_desc_t *, struct vnode **);
+typedef int     (*vfs_root_t)(bhv_desc_t *, struct bhv_vnode **);
-typedef int     (*vfs_statvfs_t)(bhv_desc_t *, xfs_statfs_t *, struct vnode *);
+typedef int     (*vfs_statvfs_t)(bhv_desc_t *, bhv_statvfs_t *,
+                                struct bhv_vnode *);
 typedef int     (*vfs_sync_t)(bhv_desc_t *, int, struct cred *);
-typedef int     (*vfs_vget_t)(bhv_desc_t *, struct vnode **, struct fid *);
+typedef int     (*vfs_vget_t)(bhv_desc_t *, struct bhv_vnode **, struct fid *);
 typedef int     (*vfs_dmapiops_t)(bhv_desc_t *, caddr_t);
 typedef int     (*vfs_quotactl_t)(bhv_desc_t *, int, int, caddr_t);
 typedef void    (*vfs_init_vnode_t)(bhv_desc_t *,
-                                struct vnode *, bhv_desc_t *, int);
+                                struct bhv_vnode *, bhv_desc_t *, int);
 typedef void    (*vfs_force_shutdown_t)(bhv_desc_t *, int, char *, int);
 typedef void    (*vfs_freeze_t)(bhv_desc_t *);
-typedef struct vfsops {
+typedef struct bhv_vfsops {
        bhv_position_t          vf_position;    /* behavior chain position */
        vfs_mount_t             vfs_mount;      /* mount file system */
        vfs_parseargs_t         vfs_parseargs;  /* parse mount options */
@@ -129,82 +136,82 @@ typedef struct vfsops {
        vfs_init_vnode_t        vfs_init_vnode; /* initialize a new vnode */
        vfs_force_shutdown_t    vfs_force_shutdown;     /* crash and burn */
        vfs_freeze_t            vfs_freeze;     /* freeze fs for snapshot */
-} vfsops_t;
+} bhv_vfsops_t;
 /*
- * VFS's.  Operates on vfs structure pointers (starts at bhv head).
+ * Virtual filesystem operations, operating from head bhv.
 */
-#define VHEAD(v)                        ((v)->vfs_fbhv)
+#define VFSHEAD(v)                      ((v)->vfs_bh.bh_first)
-#define VFS_MOUNT(v, ma,cr, rv)         ((rv) = vfs_mount(VHEAD(v), ma,cr))
+#define bhv_vfs_mount(v, ma,cr)         vfs_mount(VFSHEAD(v), ma,cr)
-#define VFS_PARSEARGS(v, o,ma,f, rv)    ((rv) = vfs_parseargs(VHEAD(v), o,ma,f))
+#define bhv_vfs_parseargs(v, o,ma,f)    vfs_parseargs(VFSHEAD(v), o,ma,f)
-#define VFS_SHOWARGS(v, m, rv)          ((rv) = vfs_showargs(VHEAD(v), m))
+#define bhv_vfs_showargs(v, m)          vfs_showargs(VFSHEAD(v), m)
-#define VFS_UNMOUNT(v, f, cr, rv)       ((rv) = vfs_unmount(VHEAD(v), f,cr))
+#define bhv_vfs_unmount(v, f,cr)        vfs_unmount(VFSHEAD(v), f,cr)
-#define VFS_MNTUPDATE(v, fl, args, rv)  ((rv) = vfs_mntupdate(VHEAD(v), fl, args))
+#define bhv_vfs_mntupdate(v, fl,args)   vfs_mntupdate(VFSHEAD(v), fl,args)
-#define VFS_ROOT(v, vpp, rv)            ((rv) = vfs_root(VHEAD(v), vpp))
+#define bhv_vfs_root(v, vpp)            vfs_root(VFSHEAD(v), vpp)
-#define VFS_STATVFS(v, sp,vp, rv)       ((rv) = vfs_statvfs(VHEAD(v), sp,vp))
+#define bhv_vfs_statvfs(v, sp,vp)       vfs_statvfs(VFSHEAD(v), sp,vp)
-#define VFS_SYNC(v, flag,cr, rv)        ((rv) = vfs_sync(VHEAD(v), flag,cr))
+#define bhv_vfs_sync(v, flag,cr)        vfs_sync(VFSHEAD(v), flag,cr)
-#define VFS_VGET(v, vpp,fidp, rv)       ((rv) = vfs_vget(VHEAD(v), vpp,fidp))
+#define bhv_vfs_vget(v, vpp,fidp)       vfs_vget(VFSHEAD(v), vpp,fidp)
-#define VFS_DMAPIOPS(v, p, rv)          ((rv) = vfs_dmapiops(VHEAD(v), p))
+#define bhv_vfs_dmapiops(v, p)          vfs_dmapiops(VFSHEAD(v), p)
-#define VFS_QUOTACTL(v, c,id,p, rv)     ((rv) = vfs_quotactl(VHEAD(v), c,id,p))
+#define bhv_vfs_quotactl(v, c,id,p)     vfs_quotactl(VFSHEAD(v), c,id,p)
-#define VFS_INIT_VNODE(v, vp,b,ul)      ( vfs_init_vnode(VHEAD(v), vp,b,ul) )
+#define bhv_vfs_init_vnode(v, vp,b,ul)  vfs_init_vnode(VFSHEAD(v), vp,b,ul)
-#define VFS_FORCE_SHUTDOWN(v, fl,f,l)   ( vfs_force_shutdown(VHEAD(v), fl,f,l) )
+#define bhv_vfs_force_shutdown(v,u,f,l) vfs_force_shutdown(VFSHEAD(v), u,f,l)
-#define VFS_FREEZE(v)                   ( vfs_freeze(VHEAD(v)) )
+#define bhv_vfs_freeze(v)               vfs_freeze(VFSHEAD(v))
 /*
- * PVFS's.  Operates on behavior descriptor pointers.
+ * Virtual filesystem operations, operating from next bhv.
 */
-#define PVFS_MOUNT(b, ma,cr, rv)        ((rv) = vfs_mount(b, ma,cr))
+#define bhv_next_vfs_mount(b, ma,cr)            vfs_mount(b, ma,cr)
-#define PVFS_PARSEARGS(b, o,ma,f, rv)   ((rv) = vfs_parseargs(b, o,ma,f))
+#define bhv_next_vfs_parseargs(b, o,ma,f)       vfs_parseargs(b, o,ma,f)
-#define PVFS_SHOWARGS(b, m, rv)         ((rv) = vfs_showargs(b, m))
+#define bhv_next_vfs_showargs(b, m)             vfs_showargs(b, m)
-#define PVFS_UNMOUNT(b, f,cr, rv)       ((rv) = vfs_unmount(b, f,cr))
+#define bhv_next_vfs_unmount(b, f,cr)           vfs_unmount(b, f,cr)
-#define PVFS_MNTUPDATE(b, fl, args, rv) ((rv) = vfs_mntupdate(b, fl, args))
+#define bhv_next_vfs_mntupdate(b, fl,args)      vfs_mntupdate(b, fl, args)
-#define PVFS_ROOT(b, vpp, rv)           ((rv) = vfs_root(b, vpp))
+#define bhv_next_vfs_root(b, vpp)               vfs_root(b, vpp)
-#define PVFS_STATVFS(b, sp,vp, rv)      ((rv) = vfs_statvfs(b, sp,vp))
+#define bhv_next_vfs_statvfs(b, sp,vp)          vfs_statvfs(b, sp,vp)
-#define PVFS_SYNC(b, flag,cr, rv)       ((rv) = vfs_sync(b, flag,cr))
+#define bhv_next_vfs_sync(b, flag,cr)           vfs_sync(b, flag,cr)
-#define PVFS_VGET(b, vpp,fidp, rv)      ((rv) = vfs_vget(b, vpp,fidp))
+#define bhv_next_vfs_vget(b, vpp,fidp)          vfs_vget(b, vpp,fidp)
-#define PVFS_DMAPIOPS(b, p, rv)         ((rv) = vfs_dmapiops(b, p))
+#define bhv_next_vfs_dmapiops(b, p)             vfs_dmapiops(b, p)
-#define PVFS_QUOTACTL(b, c,id,p, rv)    ((rv) = vfs_quotactl(b, c,id,p))
+#define bhv_next_vfs_quotactl(b, c,id,p)        vfs_quotactl(b, c,id,p)
-#define PVFS_INIT_VNODE(b, vp,b2,ul)    ( vfs_init_vnode(b, vp,b2,ul) )
+#define bhv_next_vfs_init_vnode(b, vp,b2,ul)    vfs_init_vnode(b, vp,b2,ul)
-#define PVFS_FORCE_SHUTDOWN(b, fl,f,l)  ( vfs_force_shutdown(b, fl,f,l) )
+#define bhv_next_force_shutdown(b, fl,f,l)      vfs_force_shutdown(b, fl,f,l)
-#define PVFS_FREEZE(b)                  ( vfs_freeze(b) )
+#define bhv_next_vfs_freeze(b)                  vfs_freeze(b)
 extern int vfs_mount(bhv_desc_t *, struct xfs_mount_args *, struct cred *);
 extern int vfs_parseargs(bhv_desc_t *, char *, struct xfs_mount_args *, int);
 extern int vfs_showargs(bhv_desc_t *, struct seq_file *);
 extern int vfs_unmount(bhv_desc_t *, int, struct cred *);
 extern int vfs_mntupdate(bhv_desc_t *, int *, struct xfs_mount_args *);
-extern int vfs_root(bhv_desc_t *, struct vnode **);
+extern int vfs_root(bhv_desc_t *, struct bhv_vnode **);
-extern int vfs_statvfs(bhv_desc_t *, xfs_statfs_t *, struct vnode *);
+extern int vfs_statvfs(bhv_desc_t *, bhv_statvfs_t *, struct bhv_vnode *);
 extern int vfs_sync(bhv_desc_t *, int, struct cred *);
-extern int vfs_vget(bhv_desc_t *, struct vnode **, struct fid *);
+extern int vfs_vget(bhv_desc_t *, struct bhv_vnode **, struct fid *);
 extern int vfs_dmapiops(bhv_desc_t *, caddr_t);
 extern int vfs_quotactl(bhv_desc_t *, int, int, caddr_t);
-extern void vfs_init_vnode(bhv_desc_t *, struct vnode *, bhv_desc_t *, int);
+extern void vfs_init_vnode(bhv_desc_t *, struct bhv_vnode *, bhv_desc_t *, int);
 extern void vfs_force_shutdown(bhv_desc_t *, int, char *, int);
 extern void vfs_freeze(bhv_desc_t *);
-typedef struct bhv_vfsops {
+#define vfs_test_for_freeze(vfs)        ((vfs)->vfs_super->s_frozen)
-        struct vfsops           bhv_common;
+#define vfs_wait_for_freeze(vfs,l)      vfs_check_frozen((vfs)->vfs_super, (l))
+ 
+typedef struct bhv_module_vfsops {
+        struct bhv_vfsops       bhv_common;
        void *                  bhv_custom;
-} bhv_vfsops_t;
+} bhv_module_vfsops_t;
-#define vfs_bhv_lookup(v, id)   ( bhv_lookup_range(&(v)->vfs_bh, (id), (id)) )
+#define vfs_bhv_lookup(v, id)   (bhv_lookup_range(&(v)->vfs_bh, (id), (id)))
-#define vfs_bhv_custom(b)       ( ((bhv_vfsops_t *)BHV_OPS(b))->bhv_custom )
+#define vfs_bhv_custom(b)       (((bhv_module_vfsops_t*)BHV_OPS(b))->bhv_custom)
-#define vfs_bhv_set_custom(b,o) ( (b)->bhv_custom = (void *)(o))
+#define vfs_bhv_set_custom(b,o) ((b)->bhv_custom = (void *)(o))
-#define vfs_bhv_clr_custom(b)   ( (b)->bhv_custom = NULL )
+#define vfs_bhv_clr_custom(b)   ((b)->bhv_custom = NULL)
-extern vfs_t *vfs_allocate(struct super_block *);
+extern bhv_vfs_t *vfs_allocate(struct super_block *);
-extern vfs_t *vfs_from_sb(struct super_block *);
+extern bhv_vfs_t *vfs_from_sb(struct super_block *);
-extern void vfs_deallocate(vfs_t *);
+extern void vfs_deallocate(bhv_vfs_t *);
-extern void vfs_insertops(vfs_t *, bhv_vfsops_t *);
+extern void vfs_insertbhv(bhv_vfs_t *, bhv_desc_t *, bhv_vfsops_t *, void *);
-extern void vfs_insertbhv(vfs_t *, bhv_desc_t *, vfsops_t *, void *);
-extern void bhv_insert_all_vfsops(struct vfs *);
+extern void vfs_insertops(bhv_vfs_t *, bhv_module_vfsops_t *);
-extern void bhv_remove_all_vfsops(struct vfs *, int);
-extern void bhv_remove_vfsops(struct vfs *, int);
-#define fs_frozen(vfsp)         ((vfsp)->vfs_super->s_frozen)
+extern void bhv_insert_all_vfsops(struct bhv_vfs *);
-#define fs_check_frozen(vfsp, level) \
+extern void bhv_remove_all_vfsops(struct bhv_vfs *, int);
-        vfs_check_frozen(vfsp->vfs_super, level);
+extern void bhv_remove_vfsops(struct bhv_vfs *, int);
 #endif  /* __XFS_VFS_H__ */
diff --git a/fs/xfs/linux-2.6/xfs_vnode.c b/fs/xfs/linux-2.6/xfs_vnode.c
index d27c25b27ccd..6628d96b6fd6 100644
--- a/fs/xfs/linux-2.6/xfs_vnode.c
+++ b/fs/xfs/linux-2.6/xfs_vnode.c
@@ -39,7 +39,7 @@ vn_init(void)
 void
 vn_iowait(
-        struct vnode    *vp)
+        bhv_vnode_t     *vp)
 {
        wait_queue_head_t *wq = vptosync(vp);
@@ -48,17 +48,33 @@ vn_iowait(
 void
 vn_iowake(
-        struct vnode    *vp)
+        bhv_vnode_t     *vp)
 {
        if (atomic_dec_and_test(&vp->v_iocount))
                wake_up(vptosync(vp));
 }
-struct vnode *
+/*
+ * Volume managers supporting multiple paths can send back ENODEV when the
+ * final path disappears.  In this case continuing to fill the page cache
+ * with dirty data which cannot be written out is evil, so prevent that.
+ */
+void
+vn_ioerror(
+        bhv_vnode_t     *vp,
+        int             error,
+        char            *f,
+        int             l)
+{
+        if (unlikely(error == -ENODEV))
+                bhv_vfs_force_shutdown(vp->v_vfsp, SHUTDOWN_DEVICE_REQ, f, l);
+}
+bhv_vnode_t *
 vn_initialize(
        struct inode    *inode)
 {
-        struct vnode    *vp = vn_from_inode(inode);
+        bhv_vnode_t     *vp = vn_from_inode(inode);
        XFS_STATS_INC(vn_active);
        XFS_STATS_INC(vn_alloc);
@@ -94,8 +110,8 @@ vn_initialize(
 */
 void
 vn_revalidate_core(
-        struct vnode    *vp,
+        bhv_vnode_t     *vp,
-        vattr_t         *vap)
+        bhv_vattr_t     *vap)
 {
        struct inode    *inode = vn_to_inode(vp);
@@ -130,14 +146,14 @@ vn_revalidate_core(
 */
 int
 __vn_revalidate(
-        struct vnode    *vp,
+        bhv_vnode_t     *vp,
-        struct vattr    *vattr)
+        bhv_vattr_t     *vattr)
 {
        int             error;
        vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
        vattr->va_mask = XFS_AT_STAT | XFS_AT_XFLAGS;
-        VOP_GETATTR(vp, vattr, 0, NULL, error);
+        error = bhv_vop_getattr(vp, vattr, 0, NULL);
        if (likely(!error)) {
                vn_revalidate_core(vp, vattr);
                VUNMODIFY(vp);
@@ -147,9 +163,9 @@ __vn_revalidate(
 int
 vn_revalidate(
-        struct vnode    *vp)
+        bhv_vnode_t     *vp)
 {
-        vattr_t         vattr;
+        bhv_vattr_t     vattr;
        return __vn_revalidate(vp, &vattr);
 }
@@ -157,9 +173,9 @@ vn_revalidate(
 /*
 * Add a reference to a referenced vnode.
 */
-struct vnode *
+bhv_vnode_t *
 vn_hold(
-        struct vnode    *vp)
+        bhv_vnode_t     *vp)
 {
        struct inode    *inode;
@@ -192,31 +208,31 @@ vn_hold(
 * Vnode tracing code.
 */
 void
-vn_trace_entry(vnode_t *vp, const char *func, inst_t *ra)
+vn_trace_entry(bhv_vnode_t *vp, const char *func, inst_t *ra)
 {
        KTRACE_ENTER(vp, VNODE_KTRACE_ENTRY, func, 0, ra);
 }
 void
-vn_trace_exit(vnode_t *vp, const char *func, inst_t *ra)
+vn_trace_exit(bhv_vnode_t *vp, const char *func, inst_t *ra)
 {
        KTRACE_ENTER(vp, VNODE_KTRACE_EXIT, func, 0, ra);
 }
 void
-vn_trace_hold(vnode_t *vp, char *file, int line, inst_t *ra)
+vn_trace_hold(bhv_vnode_t *vp, char *file, int line, inst_t *ra)
 {
        KTRACE_ENTER(vp, VNODE_KTRACE_HOLD, file, line, ra);
 }
 void
-vn_trace_ref(vnode_t *vp, char *file, int line, inst_t *ra)
+vn_trace_ref(bhv_vnode_t *vp, char *file, int line, inst_t *ra)
 {
        KTRACE_ENTER(vp, VNODE_KTRACE_REF, file, line, ra);
 }
 void
-vn_trace_rele(vnode_t *vp, char *file, int line, inst_t *ra)
+vn_trace_rele(bhv_vnode_t *vp, char *file, int line, inst_t *ra)
 {
        KTRACE_ENTER(vp, VNODE_KTRACE_RELE, file, line, ra);
 }
diff --git a/fs/xfs/linux-2.6/xfs_vnode.h b/fs/xfs/linux-2.6/xfs_vnode.h
index 2a8e16c22353..35c6a01963a7 100644
--- a/fs/xfs/linux-2.6/xfs_vnode.h
+++ b/fs/xfs/linux-2.6/xfs_vnode.h
@@ -14,57 +14,35 @@
 * 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
- *
- * Portions Copyright (c) 1989, 1993
- *      The Regents of the University of California.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. Neither the name of the University nor the names of its contributors
- *    may be used to endorse or promote products derived from this software
- *    without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
 */
 #ifndef __XFS_VNODE_H__
 #define __XFS_VNODE_H__
 struct uio;
 struct file;
-struct vattr;
+struct bhv_vfs;
+struct bhv_vattr;
 struct xfs_iomap;
 struct attrlist_cursor_kern;
+typedef struct dentry   bhv_vname_t;
+typedef __u64           bhv_vnumber_t;
-typedef xfs_ino_t vnumber_t;
+typedef enum bhv_vflags {
-typedef struct dentry vname_t;
+        VMODIFIED       = 0x08, /* XFS inode state possibly differs */
-typedef bhv_head_t vn_bhv_head_t;
+                                /* to the Linux inode state. */
+        VTRUNCATED      = 0x40, /* truncated down so flush-on-close */
+} bhv_vflags_t;
 /*
 * MP locking protocols:
 *      v_flag, v_vfsp                          VN_LOCK/VN_UNLOCK
 */
-typedef struct vnode {
+typedef struct bhv_vnode {
-        __u32           v_flag;                 /* vnode flags (see below) */
+        bhv_vflags_t    v_flag;                 /* vnode flags (see above) */
-        struct vfs      *v_vfsp;                /* ptr to containing VFS */
+        bhv_vfs_t       *v_vfsp;                /* ptr to containing VFS */
-        vnumber_t       v_number;               /* in-core vnode number */
+        bhv_vnumber_t   v_number;               /* in-core vnode number */
-        vn_bhv_head_t   v_bh;                   /* behavior head */
+        bhv_head_t      v_bh;                   /* behavior head */
        spinlock_t      v_lock;                 /* VN_LOCK/VN_UNLOCK */
        atomic_t        v_iocount;              /* outstanding I/O count */
 #ifdef XFS_VNODE_TRACE
@@ -72,7 +50,7 @@ typedef struct vnode {
 #endif
        struct inode    v_inode;                /* Linux inode */
        /* inode MUST be last */
-} vnode_t;
+} bhv_vnode_t;
 #define VN_ISLNK(vp)    S_ISLNK((vp)->v_inode.i_mode)
 #define VN_ISREG(vp)    S_ISREG((vp)->v_inode.i_mode)
@@ -80,9 +58,6 @@ typedef struct vnode {
 #define VN_ISCHR(vp)    S_ISCHR((vp)->v_inode.i_mode)
 #define VN_ISBLK(vp)    S_ISBLK((vp)->v_inode.i_mode)
-#define v_fbhv                  v_bh.bh_first          /* first behavior */
-#define v_fops                  v_bh.bh_first->bd_ops  /* first behavior ops */
 #define VNODE_POSITION_BASE     BHV_POSITION_BASE       /* chain bottom */
 #define VNODE_POSITION_TOP      BHV_POSITION_TOP        /* chain top */
 #define VNODE_POSITION_INVALID  BHV_POSITION_INVALID    /* invalid pos. num */
@@ -104,8 +79,8 @@ typedef enum {
 /*
 * Macros for dealing with the behavior descriptor inside of the vnode.
 */
-#define BHV_TO_VNODE(bdp)       ((vnode_t *)BHV_VOBJ(bdp))
+#define BHV_TO_VNODE(bdp)       ((bhv_vnode_t *)BHV_VOBJ(bdp))
-#define BHV_TO_VNODE_NULL(bdp)  ((vnode_t *)BHV_VOBJNULL(bdp))
+#define BHV_TO_VNODE_NULL(bdp)  ((bhv_vnode_t *)BHV_VOBJNULL(bdp))
 #define VN_BHV_HEAD(vp)                 ((bhv_head_t *)(&((vp)->v_bh)))
 #define vn_bhv_head_init(bhp,name)      bhv_head_init(bhp,name)
@@ -116,35 +91,29 @@ typedef enum {
 /*
 * Vnode to Linux inode mapping.
 */
-static inline struct vnode *vn_from_inode(struct inode *inode)
+static inline struct bhv_vnode *vn_from_inode(struct inode *inode)
 {
-        return (vnode_t *)list_entry(inode, vnode_t, v_inode);
+        return (bhv_vnode_t *)list_entry(inode, bhv_vnode_t, v_inode);
 }
-static inline struct inode *vn_to_inode(struct vnode *vnode)
+static inline struct inode *vn_to_inode(struct bhv_vnode *vnode)
 {
        return &vnode->v_inode;
 }
 /*
- * Vnode flags.
+ * Values for the vop_rwlock/rwunlock flags parameter.
- */
-#define VMODIFIED              0x8      /* XFS inode state possibly differs */
-                                        /* to the Linux inode state.    */
-/*
- * Values for the VOP_RWLOCK and VOP_RWUNLOCK flags parameter.
 */
-typedef enum vrwlock {
+typedef enum bhv_vrwlock {
        VRWLOCK_NONE,
        VRWLOCK_READ,
        VRWLOCK_WRITE,
        VRWLOCK_WRITE_DIRECT,
        VRWLOCK_TRY_READ,
        VRWLOCK_TRY_WRITE
-} vrwlock_t;
+} bhv_vrwlock_t;
 /*
- * Return values for VOP_INACTIVE.  A return value of
+ * Return values for bhv_vop_inactive.  A return value of
 * VN_INACTIVE_NOCACHE implies that the file system behavior
 * has disassociated its state and bhv_desc_t from the vnode.
 */
@@ -152,18 +121,20 @@ typedef enum vrwlock {
 #define VN_INACTIVE_NOCACHE     1
 /*
- * Values for the cmd code given to VOP_VNODE_CHANGE.
+ * Values for the cmd code given to vop_vnode_change.
 */
-typedef enum vchange {
+typedef enum bhv_vchange {
        VCHANGE_FLAGS_FRLOCKS           = 0,
        VCHANGE_FLAGS_ENF_LOCKING       = 1,
        VCHANGE_FLAGS_TRUNCATED         = 2,
        VCHANGE_FLAGS_PAGE_DIRTY        = 3,
        VCHANGE_FLAGS_IOEXCL_COUNT      = 4
-} vchange_t;
+} 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 *);
@@ -181,27 +152,27 @@ typedef ssize_t (*vop_splice_write_t)(bhv_desc_t *, struct pipe_inode_info *,
                                struct cred *);
 typedef int     (*vop_ioctl_t)(bhv_desc_t *, struct inode *, struct file *,
                                int, unsigned int, void __user *);
-typedef int     (*vop_getattr_t)(bhv_desc_t *, struct vattr *, int,
+typedef int     (*vop_getattr_t)(bhv_desc_t *, struct bhv_vattr *, int,
                                struct cred *);
-typedef int     (*vop_setattr_t)(bhv_desc_t *, struct vattr *, int,
+typedef int     (*vop_setattr_t)(bhv_desc_t *, struct bhv_vattr *, int,
                                struct cred *);
 typedef int     (*vop_access_t)(bhv_desc_t *, int, struct cred *);
-typedef int     (*vop_lookup_t)(bhv_desc_t *, vname_t *, vnode_t **,
+typedef int     (*vop_lookup_t)(bhv_desc_t *, bhv_vname_t *, bhv_vnode_t **,
-                                int, vnode_t *, struct cred *);
+                                int, bhv_vnode_t *, struct cred *);
-typedef int     (*vop_create_t)(bhv_desc_t *, vname_t *, struct vattr *,
+typedef int     (*vop_create_t)(bhv_desc_t *, bhv_vname_t *, struct bhv_vattr *,
-                                vnode_t **, struct cred *);
+                                bhv_vnode_t **, struct cred *);
-typedef int     (*vop_remove_t)(bhv_desc_t *, vname_t *, struct cred *);
+typedef int     (*vop_remove_t)(bhv_desc_t *, bhv_vname_t *, struct cred *);
-typedef int     (*vop_link_t)(bhv_desc_t *, vnode_t *, vname_t *,
+typedef int     (*vop_link_t)(bhv_desc_t *, bhv_vnode_t *, bhv_vname_t *,
-                                struct cred *);
-typedef int     (*vop_rename_t)(bhv_desc_t *, vname_t *, vnode_t *, vname_t *,
                                struct cred *);
-typedef int     (*vop_mkdir_t)(bhv_desc_t *, vname_t *, struct vattr *,
+typedef int     (*vop_rename_t)(bhv_desc_t *, bhv_vname_t *, bhv_vnode_t *,
-                                vnode_t **, struct cred *);
+                                bhv_vname_t *, struct cred *);
-typedef int     (*vop_rmdir_t)(bhv_desc_t *, vname_t *, struct cred *);
+typedef int     (*vop_mkdir_t)(bhv_desc_t *, bhv_vname_t *, struct bhv_vattr *,
+                                bhv_vnode_t **, struct cred *);
+typedef int     (*vop_rmdir_t)(bhv_desc_t *, bhv_vname_t *, struct cred *);
 typedef int     (*vop_readdir_t)(bhv_desc_t *, struct uio *, struct cred *,
                                int *);
-typedef int     (*vop_symlink_t)(bhv_desc_t *, vname_t *, struct vattr *,
+typedef int     (*vop_symlink_t)(bhv_desc_t *, bhv_vname_t *, struct bhv_vattr*,
-                                char *, vnode_t **, struct cred *);
+                                char *, bhv_vnode_t **, struct cred *);
 typedef int     (*vop_readlink_t)(bhv_desc_t *, struct uio *, int,
                                struct cred *);
 typedef int     (*vop_fsync_t)(bhv_desc_t *, int, struct cred *,
@@ -209,8 +180,8 @@ typedef int	(*vop_fsync_t)(bhv_desc_t *, int, struct cred *,
 typedef int     (*vop_inactive_t)(bhv_desc_t *, struct cred *);
 typedef int     (*vop_fid2_t)(bhv_desc_t *, struct fid *);
 typedef int     (*vop_release_t)(bhv_desc_t *);
-typedef int     (*vop_rwlock_t)(bhv_desc_t *, vrwlock_t);
+typedef int     (*vop_rwlock_t)(bhv_desc_t *, bhv_vrwlock_t);
-typedef void    (*vop_rwunlock_t)(bhv_desc_t *, vrwlock_t);
+typedef void    (*vop_rwunlock_t)(bhv_desc_t *, bhv_vrwlock_t);
 typedef int     (*vop_bmap_t)(bhv_desc_t *, xfs_off_t, ssize_t, int,
                                struct xfs_iomap *, int *);
 typedef int     (*vop_reclaim_t)(bhv_desc_t *);
@@ -222,8 +193,8 @@ typedef	int	(*vop_attr_remove_t)(bhv_desc_t *, const char *,
                                int, struct cred *);
 typedef int     (*vop_attr_list_t)(bhv_desc_t *, char *, int, int,
                                struct attrlist_cursor_kern *, struct cred *);
-typedef void    (*vop_link_removed_t)(bhv_desc_t *, vnode_t *, int);
+typedef void    (*vop_link_removed_t)(bhv_desc_t *, bhv_vnode_t *, int);
-typedef void    (*vop_vnode_change_t)(bhv_desc_t *, vchange_t, __psint_t);
+typedef void    (*vop_vnode_change_t)(bhv_desc_t *, bhv_vchange_t, __psint_t);
 typedef void    (*vop_ptossvp_t)(bhv_desc_t *, xfs_off_t, xfs_off_t, int);
 typedef void    (*vop_pflushinvalvp_t)(bhv_desc_t *, xfs_off_t, xfs_off_t, int);
 typedef int     (*vop_pflushvp_t)(bhv_desc_t *, xfs_off_t, xfs_off_t,
@@ -231,9 +202,10 @@ typedef int	(*vop_pflushvp_t)(bhv_desc_t *, xfs_off_t, xfs_off_t,
 typedef int     (*vop_iflush_t)(bhv_desc_t *, int);
-typedef struct vnodeops {
+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_sendfile_t          vop_sendfile;
@@ -271,103 +243,80 @@ typedef struct vnodeops {
        vop_pflushvp_t          vop_flush_pages;
        vop_release_t           vop_release;
        vop_iflush_t            vop_iflush;
-} vnodeops_t;
+} bhv_vnodeops_t;
 /*
- * VOP's.
+ * Virtual node operations, operating from head bhv.
- */
-#define _VOP_(op, vp)   (*((vnodeops_t *)(vp)->v_fops)->op)
-#define VOP_READ(vp,file,iov,segs,offset,ioflags,cr,rv)                 \
-        rv = _VOP_(vop_read, vp)((vp)->v_fbhv,file,iov,segs,offset,ioflags,cr)
-#define VOP_WRITE(vp,file,iov,segs,offset,ioflags,cr,rv)                \
-        rv = _VOP_(vop_write, vp)((vp)->v_fbhv,file,iov,segs,offset,ioflags,cr)
-#define VOP_SENDFILE(vp,f,off,ioflags,cnt,act,targ,cr,rv)               \
-        rv = _VOP_(vop_sendfile, vp)((vp)->v_fbhv,f,off,ioflags,cnt,act,targ,cr)
-#define VOP_SPLICE_READ(vp,f,o,pipe,cnt,fl,iofl,cr,rv)                  \
-        rv = _VOP_(vop_splice_read, vp)((vp)->v_fbhv,f,o,pipe,cnt,fl,iofl,cr)
-#define VOP_SPLICE_WRITE(vp,f,o,pipe,cnt,fl,iofl,cr,rv)                 \
-        rv = _VOP_(vop_splice_write, vp)((vp)->v_fbhv,f,o,pipe,cnt,fl,iofl,cr)
-#define VOP_BMAP(vp,of,sz,rw,b,n,rv)                                    \
-        rv = _VOP_(vop_bmap, vp)((vp)->v_fbhv,of,sz,rw,b,n)
-#define VOP_OPEN(vp, cr, rv)                                            \
-        rv = _VOP_(vop_open, vp)((vp)->v_fbhv, cr)
-#define VOP_GETATTR(vp, vap, f, cr, rv)                                 \
-        rv = _VOP_(vop_getattr, vp)((vp)->v_fbhv, vap, f, cr)
-#define VOP_SETATTR(vp, vap, f, cr, rv)                                 \
-        rv = _VOP_(vop_setattr, vp)((vp)->v_fbhv, vap, f, cr)
-#define VOP_ACCESS(vp, mode, cr, rv)                                    \
-        rv = _VOP_(vop_access, vp)((vp)->v_fbhv, mode, cr)
-#define VOP_LOOKUP(vp,d,vpp,f,rdir,cr,rv)                               \
-        rv = _VOP_(vop_lookup, vp)((vp)->v_fbhv,d,vpp,f,rdir,cr)
-#define VOP_CREATE(dvp,d,vap,vpp,cr,rv)                                 \
-        rv = _VOP_(vop_create, dvp)((dvp)->v_fbhv,d,vap,vpp,cr)
-#define VOP_REMOVE(dvp,d,cr,rv)                                         \
-        rv = _VOP_(vop_remove, dvp)((dvp)->v_fbhv,d,cr)
-#define VOP_LINK(tdvp,fvp,d,cr,rv)                                      \
-        rv = _VOP_(vop_link, tdvp)((tdvp)->v_fbhv,fvp,d,cr)
-#define VOP_RENAME(fvp,fnm,tdvp,tnm,cr,rv)                              \
-        rv = _VOP_(vop_rename, fvp)((fvp)->v_fbhv,fnm,tdvp,tnm,cr)
-#define VOP_MKDIR(dp,d,vap,vpp,cr,rv)                                   \
-        rv = _VOP_(vop_mkdir, dp)((dp)->v_fbhv,d,vap,vpp,cr)
-#define VOP_RMDIR(dp,d,cr,rv)                                           \
-        rv = _VOP_(vop_rmdir, dp)((dp)->v_fbhv,d,cr)
-#define VOP_READDIR(vp,uiop,cr,eofp,rv)                                 \
-        rv = _VOP_(vop_readdir, vp)((vp)->v_fbhv,uiop,cr,eofp)
-#define VOP_SYMLINK(dvp,d,vap,tnm,vpp,cr,rv)                            \
-        rv = _VOP_(vop_symlink, dvp) ((dvp)->v_fbhv,d,vap,tnm,vpp,cr)
-#define VOP_READLINK(vp,uiop,fl,cr,rv)                                  \
-        rv = _VOP_(vop_readlink, vp)((vp)->v_fbhv,uiop,fl,cr)
-#define VOP_FSYNC(vp,f,cr,b,e,rv)                                       \
-        rv = _VOP_(vop_fsync, vp)((vp)->v_fbhv,f,cr,b,e)
-#define VOP_INACTIVE(vp, cr, rv)                                        \
-        rv = _VOP_(vop_inactive, vp)((vp)->v_fbhv, cr)
-#define VOP_RELEASE(vp, rv)                                             \
-        rv = _VOP_(vop_release, vp)((vp)->v_fbhv)
-#define VOP_FID2(vp, fidp, rv)                                          \
-        rv = _VOP_(vop_fid2, vp)((vp)->v_fbhv, fidp)
-#define VOP_RWLOCK(vp,i)                                                \
-        (void)_VOP_(vop_rwlock, vp)((vp)->v_fbhv, i)
-#define VOP_RWLOCK_TRY(vp,i)                                            \
-        _VOP_(vop_rwlock, vp)((vp)->v_fbhv, i)
-#define VOP_RWUNLOCK(vp,i)                                              \
-        (void)_VOP_(vop_rwunlock, vp)((vp)->v_fbhv, i)
-#define VOP_FRLOCK(vp,c,fl,flags,offset,fr,rv)                          \
-        rv = _VOP_(vop_frlock, vp)((vp)->v_fbhv,c,fl,flags,offset,fr)
-#define VOP_RECLAIM(vp, rv)                                             \
-        rv = _VOP_(vop_reclaim, vp)((vp)->v_fbhv)
-#define VOP_ATTR_GET(vp, name, val, vallenp, fl, cred, rv)              \
-        rv = _VOP_(vop_attr_get, vp)((vp)->v_fbhv,name,val,vallenp,fl,cred)
-#define VOP_ATTR_SET(vp, name, val, vallen, fl, cred, rv)               \
-        rv = _VOP_(vop_attr_set, vp)((vp)->v_fbhv,name,val,vallen,fl,cred)
-#define VOP_ATTR_REMOVE(vp, name, flags, cred, rv)                      \
-        rv = _VOP_(vop_attr_remove, vp)((vp)->v_fbhv,name,flags,cred)
-#define VOP_ATTR_LIST(vp, buf, buflen, fl, cursor, cred, rv)            \
-        rv = _VOP_(vop_attr_list, vp)((vp)->v_fbhv,buf,buflen,fl,cursor,cred)
-#define VOP_LINK_REMOVED(vp, dvp, linkzero)                             \
-        (void)_VOP_(vop_link_removed, vp)((vp)->v_fbhv, dvp, linkzero)
-#define VOP_VNODE_CHANGE(vp, cmd, val)                                  \
-        (void)_VOP_(vop_vnode_change, vp)((vp)->v_fbhv,cmd,val)
-/*
- * These are page cache functions that now go thru VOPs.
- * 'last' parameter is unused and left in for IRIX compatibility
 */
-#define VOP_TOSS_PAGES(vp, first, last, fiopt)                          \
+#define VNHEAD(vp)      ((vp)->v_bh.bh_first)
-        _VOP_(vop_tosspages, vp)((vp)->v_fbhv,first, last, fiopt)
+#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)
- * 'last' parameter is unused and left in for IRIX compatibility
+#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)                \
-#define VOP_FLUSHINVAL_PAGES(vp, first, last, fiopt)                    \
+                VOP(vop_read, vp)(VNHEAD(vp),file,iov,segs,offset,ioflags,cr)
-        _VOP_(vop_flushinval_pages, vp)((vp)->v_fbhv,first,last,fiopt)
+#define bhv_vop_write(vp,file,iov,segs,offset,ioflags,cr)               \
-/*
+                VOP(vop_write, vp)(VNHEAD(vp),file,iov,segs,offset,ioflags,cr)
- * 'last' parameter is unused and left in for IRIX compatibility
+#define bhv_vop_sendfile(vp,f,off,ioflags,cnt,act,targ,cr)              \
- */
+                VOP(vop_sendfile, vp)(VNHEAD(vp),f,off,ioflags,cnt,act,targ,cr)
-#define VOP_FLUSH_PAGES(vp, first, last, flags, fiopt, rv)              \
+#define bhv_vop_splice_read(vp,f,o,pipe,cnt,fl,iofl,cr)                 \
-        rv = _VOP_(vop_flush_pages, vp)((vp)->v_fbhv,first,last,flags,fiopt)
+                VOP(vop_splice_read, vp)(VNHEAD(vp),f,o,pipe,cnt,fl,iofl,cr)
-#define VOP_IOCTL(vp, inode, filp, fl, cmd, arg, rv)                    \
+#define bhv_vop_splice_write(vp,f,o,pipe,cnt,fl,iofl,cr)                \
-        rv = _VOP_(vop_ioctl, vp)((vp)->v_fbhv,inode,filp,fl,cmd,arg)
+                VOP(vop_splice_write, vp)(VNHEAD(vp),f,o,pipe,cnt,fl,iofl,cr)
-#define VOP_IFLUSH(vp, flags, rv)                                       \
+#define bhv_vop_bmap(vp,of,sz,rw,b,n)                                   \
-        rv = _VOP_(vop_iflush, vp)((vp)->v_fbhv, flags)
+                VOP(vop_bmap, vp)(VNHEAD(vp),of,sz,rw,b,n)
+#define bhv_vop_getattr(vp, vap,f,cr)                                   \
+                VOP(vop_getattr, vp)(VNHEAD(vp), vap,f,cr)
+#define bhv_vop_setattr(vp, vap,f,cr)                                   \
+                VOP(vop_setattr, vp)(VNHEAD(vp), vap,f,cr)
+#define bhv_vop_access(vp, mode,cr)     VOP(vop_access, vp)(VNHEAD(vp), mode,cr)
+#define bhv_vop_lookup(vp,d,vpp,f,rdir,cr)                              \
+                VOP(vop_lookup, vp)(VNHEAD(vp),d,vpp,f,rdir,cr)
+#define bhv_vop_create(dvp,d,vap,vpp,cr)                                \
+                VOP(vop_create, dvp)(VNHEAD(dvp),d,vap,vpp,cr)
+#define bhv_vop_remove(dvp,d,cr)        VOP(vop_remove, dvp)(VNHEAD(dvp),d,cr)
+#define bhv_vop_link(dvp,fvp,d,cr)      VOP(vop_link, dvp)(VNHEAD(dvp),fvp,d,cr)
+#define bhv_vop_rename(fvp,fnm,tdvp,tnm,cr)                             \
+                VOP(vop_rename, fvp)(VNHEAD(fvp),fnm,tdvp,tnm,cr)
+#define bhv_vop_mkdir(dp,d,vap,vpp,cr)                                  \
+                VOP(vop_mkdir, dp)(VNHEAD(dp),d,vap,vpp,cr)
+#define bhv_vop_rmdir(dp,d,cr)          VOP(vop_rmdir, dp)(VNHEAD(dp),d,cr)
+#define bhv_vop_readdir(vp,uiop,cr,eofp)                                \
+                VOP(vop_readdir, vp)(VNHEAD(vp),uiop,cr,eofp)
+#define bhv_vop_symlink(dvp,d,vap,tnm,vpp,cr)                           \
+                VOP(vop_symlink, dvp)(VNHEAD(dvp),d,vap,tnm,vpp,cr)
+#define bhv_vop_readlink(vp,uiop,fl,cr)                                 \
+                VOP(vop_readlink, vp)(VNHEAD(vp),uiop,fl,cr)
+#define bhv_vop_fsync(vp,f,cr,b,e)      VOP(vop_fsync, vp)(VNHEAD(vp),f,cr,b,e)
+#define bhv_vop_inactive(vp,cr)         VOP(vop_inactive, vp)(VNHEAD(vp),cr)
+#define bhv_vop_release(vp)             VOP(vop_release, vp)(VNHEAD(vp))
+#define bhv_vop_fid2(vp,fidp)           VOP(vop_fid2, vp)(VNHEAD(vp),fidp)
+#define bhv_vop_rwlock(vp,i)            VOP(vop_rwlock, vp)(VNHEAD(vp),i)
+#define bhv_vop_rwlock_try(vp,i)        VOP(vop_rwlock, vp)(VNHEAD(vp),i)
+#define bhv_vop_rwunlock(vp,i)          VOP(vop_rwunlock, vp)(VNHEAD(vp),i)
+#define bhv_vop_frlock(vp,c,fl,flags,offset,fr)                         \
+                VOP(vop_frlock, vp)(VNHEAD(vp),c,fl,flags,offset,fr)
+#define bhv_vop_reclaim(vp)             VOP(vop_reclaim, vp)(VNHEAD(vp))
+#define bhv_vop_attr_get(vp, name, val, vallenp, fl, cred)              \
+                VOP(vop_attr_get, vp)(VNHEAD(vp),name,val,vallenp,fl,cred)
+#define bhv_vop_attr_set(vp, name, val, vallen, fl, cred)               \
+                VOP(vop_attr_set, vp)(VNHEAD(vp),name,val,vallen,fl,cred)
+#define bhv_vop_attr_remove(vp, name, flags, cred)                      \
+                VOP(vop_attr_remove, vp)(VNHEAD(vp),name,flags,cred)
+#define bhv_vop_attr_list(vp, buf, buflen, fl, cursor, cred)            \
+                VOP(vop_attr_list, vp)(VNHEAD(vp),buf,buflen,fl,cursor,cred)
+#define bhv_vop_link_removed(vp, dvp, linkzero)                         \
+                VOP(vop_link_removed, vp)(VNHEAD(vp), dvp, linkzero)
+#define bhv_vop_vnode_change(vp, cmd, val)                              \
+                VOP(vop_vnode_change, vp)(VNHEAD(vp), cmd, val)
+#define bhv_vop_toss_pages(vp, first, last, fiopt)                      \
+                VOP(vop_tosspages, vp)(VNHEAD(vp), first, last, fiopt)
+#define bhv_vop_flushinval_pages(vp, first, last, fiopt)                \
+                VOP(vop_flushinval_pages, vp)(VNHEAD(vp),first,last,fiopt)
+#define bhv_vop_flush_pages(vp, first, last, flags, fiopt)              \
+                VOP(vop_flush_pages, vp)(VNHEAD(vp),first,last,flags,fiopt)
+#define bhv_vop_ioctl(vp, inode, filp, fl, cmd, arg)                    \
+                VOP(vop_ioctl, vp)(VNHEAD(vp),inode,filp,fl,cmd,arg)
+#define bhv_vop_iflush(vp, flags)       VOP(vop_iflush, vp)(VNHEAD(vp), flags)
 /*
 * Flags for read/write calls - same values as IRIX
@@ -377,7 +326,7 @@ typedef struct vnodeops {
 #define IO_INVIS        0x00020         /* don't update inode timestamps */
 /*
- * Flags for VOP_IFLUSH call
+ * Flags for vop_iflush call
 */
 #define FLUSH_SYNC              1       /* wait for flush to complete   */
 #define FLUSH_INODE             2       /* flush the inode itself       */
@@ -385,8 +334,7 @@ typedef struct vnodeops {
                                         * this inode out to disk       */
 /*
- * Flush/Invalidate options for VOP_TOSS_PAGES, VOP_FLUSHINVAL_PAGES and
+ * Flush/Invalidate options for vop_toss/flush/flushinval_pages.
- *      VOP_FLUSH_PAGES.
 */
 #define FI_NONE                 0       /* none */
 #define FI_REMAPF               1       /* Do a remapf prior to the operation */
@@ -398,7 +346,7 @@ typedef struct vnodeops {
 * Vnode attributes.  va_mask indicates those attributes the caller
 * wants to set or extract.
 */
-typedef struct vattr {
+typedef struct bhv_vattr {
        int             va_mask;        /* bit-mask of attributes present */
        mode_t          va_mode;        /* file access mode and type */
        xfs_nlink_t     va_nlink;       /* number of references to file */
@@ -418,7 +366,7 @@ typedef struct vattr {
        u_long          va_nextents;    /* number of extents in file */
        u_long          va_anextents;   /* number of attr extents in file */
        prid_t          va_projid;      /* project id */
-} vattr_t;
+} bhv_vattr_t;
 /*
 * setattr or getattr attributes
@@ -492,29 +440,17 @@ typedef struct vattr {
        (VN_ISREG(vp) && ((mode) & (VSGID|(VEXEC>>3))) == VSGID)
 extern void     vn_init(void);
-extern vnode_t  *vn_initialize(struct inode *);
+extern bhv_vnode_t      *vn_initialize(struct inode *);
+extern int      vn_revalidate(struct bhv_vnode *);
-/*
+extern int      __vn_revalidate(struct bhv_vnode *, bhv_vattr_t *);
- * vnode_map structures _must_ match vn_epoch and vnode structure sizes.
+extern void     vn_revalidate_core(struct bhv_vnode *, bhv_vattr_t *);
- */
-typedef struct vnode_map {
-        vfs_t           *v_vfsp;
-        vnumber_t       v_number;               /* in-core vnode number */
-        xfs_ino_t       v_ino;                  /* inode #      */
-} vmap_t;
-#define VMAP(vp, vmap)  {(vmap).v_vfsp   = (vp)->v_vfsp,        \
-                         (vmap).v_number = (vp)->v_number,      \
-                         (vmap).v_ino    = (vp)->v_inode.i_ino; }
-extern int      vn_revalidate(struct vnode *);
+extern void     vn_iowait(struct bhv_vnode *vp);
-extern int      __vn_revalidate(struct vnode *, vattr_t *);
+extern void     vn_iowake(struct bhv_vnode *vp);
-extern void     vn_revalidate_core(struct vnode *, vattr_t *);
-extern void     vn_iowait(struct vnode *vp);
+extern void     vn_ioerror(struct bhv_vnode *vp, int error, char *f, int l);
-extern void     vn_iowake(struct vnode *vp);
-static inline int vn_count(struct vnode *vp)
+static inline int vn_count(struct bhv_vnode *vp)
 {
        return atomic_read(&vn_to_inode(vp)->i_count);
 }
@@ -522,7 +458,7 @@ static inline int vn_count(struct vnode *vp)
 /*
 * Vnode reference counting functions (and macros for compatibility).
 */
-extern vnode_t  *vn_hold(struct vnode *);
+extern bhv_vnode_t      *vn_hold(struct bhv_vnode *);
 #if defined(XFS_VNODE_TRACE)
 #define VN_HOLD(vp)             \
@@ -536,7 +472,7 @@ extern vnode_t	*vn_hold(struct vnode *);
 #define VN_RELE(vp)             (iput(vn_to_inode(vp)))
 #endif
-static inline struct vnode *vn_grab(struct vnode *vp)
+static inline struct bhv_vnode *vn_grab(struct bhv_vnode *vp)
 {
        struct inode *inode = igrab(vn_to_inode(vp));
        return inode ? vn_from_inode(inode) : NULL;
@@ -554,32 +490,39 @@ static inline struct vnode *vn_grab(struct vnode *vp)
 */
 #define VN_LOCK(vp)             mutex_spinlock(&(vp)->v_lock)
 #define VN_UNLOCK(vp, s)        mutex_spinunlock(&(vp)->v_lock, s)
-#define VN_FLAGSET(vp,b)        vn_flagset(vp,b)
-#define VN_FLAGCLR(vp,b)        vn_flagclr(vp,b)
-static __inline__ void vn_flagset(struct vnode *vp, uint flag)
+static __inline__ void vn_flagset(struct bhv_vnode *vp, uint flag)
 {
        spin_lock(&vp->v_lock);
        vp->v_flag |= flag;
        spin_unlock(&vp->v_lock);
 }
-static __inline__ void vn_flagclr(struct vnode *vp, uint flag)
+static __inline__ uint vn_flagclr(struct bhv_vnode *vp, uint flag)
 {
+        uint    cleared;
        spin_lock(&vp->v_lock);
+        cleared = (vp->v_flag & flag);
        vp->v_flag &= ~flag;
        spin_unlock(&vp->v_lock);
+        return cleared;
 }
+#define VMODIFY(vp)     vn_flagset(vp, VMODIFIED)
+#define VUNMODIFY(vp)   vn_flagclr(vp, VMODIFIED)
+#define VTRUNCATE(vp)   vn_flagset(vp, VTRUNCATED)
+#define VUNTRUNCATE(vp) vn_flagclr(vp, VTRUNCATED)
 /*
 * Dealing with bad inodes
 */
-static inline void vn_mark_bad(struct vnode *vp)
+static inline void vn_mark_bad(struct bhv_vnode *vp)
 {
        make_bad_inode(vn_to_inode(vp));
 }
-static inline int VN_BAD(struct vnode *vp)
+static inline int VN_BAD(struct bhv_vnode *vp)
 {
        return is_bad_inode(vn_to_inode(vp));
 }
@@ -587,18 +530,18 @@ static inline int VN_BAD(struct vnode *vp)
 /*
 * Extracting atime values in various formats
 */
-static inline void vn_atime_to_bstime(struct vnode *vp, xfs_bstime_t *bs_atime)
+static inline void vn_atime_to_bstime(bhv_vnode_t *vp, xfs_bstime_t *bs_atime)
 {
        bs_atime->tv_sec = vp->v_inode.i_atime.tv_sec;
        bs_atime->tv_nsec = vp->v_inode.i_atime.tv_nsec;
 }
-static inline void vn_atime_to_timespec(struct vnode *vp, struct timespec *ts)
+static inline void vn_atime_to_timespec(bhv_vnode_t *vp, struct timespec *ts)
 {
        *ts = vp->v_inode.i_atime;
 }
-static inline void vn_atime_to_time_t(struct vnode *vp, time_t *tt)
+static inline void vn_atime_to_time_t(bhv_vnode_t *vp, time_t *tt)
 {
        *tt = vp->v_inode.i_atime.tv_sec;
 }
@@ -610,11 +553,10 @@ static inline void vn_atime_to_time_t(struct vnode *vp, time_t *tt)
 #define VN_CACHED(vp)   (vn_to_inode(vp)->i_mapping->nrpages)
 #define VN_DIRTY(vp)    mapping_tagged(vn_to_inode(vp)->i_mapping, \
                                        PAGECACHE_TAG_DIRTY)
-#define VMODIFY(vp)     VN_FLAGSET(vp, VMODIFIED)
+#define VN_TRUNC(vp)    ((vp)->v_flag & VTRUNCATED)
-#define VUNMODIFY(vp)   VN_FLAGCLR(vp, VMODIFIED)
 /*
- * Flags to VOP_SETATTR/VOP_GETATTR.
+ * Flags to vop_setattr/getattr.
 */
 #define ATTR_UTIME      0x01    /* non-default utime(2) request */
 #define ATTR_DMI        0x08    /* invocation from a DMI function */
@@ -624,7 +566,7 @@ static inline void vn_atime_to_time_t(struct vnode *vp, time_t *tt)
 #define ATTR_NOSIZETOK  0x400   /* Don't get the SIZE token */
 /*
- * Flags to VOP_FSYNC and VOP_RECLAIM.
+ * Flags to vop_fsync/reclaim.
 */
 #define FSYNC_NOWAIT    0       /* asynchronous flush */
 #define FSYNC_WAIT      0x1     /* synchronous fsync or forced reclaim */
@@ -643,11 +585,11 @@ static inline void vn_atime_to_time_t(struct vnode *vp, time_t *tt)
 #define VNODE_KTRACE_REF        4
 #define VNODE_KTRACE_RELE       5
-extern void vn_trace_entry(struct vnode *, const char *, inst_t *);
+extern void vn_trace_entry(struct bhv_vnode *, const char *, inst_t *);
-extern void vn_trace_exit(struct vnode *, const char *, inst_t *);
+extern void vn_trace_exit(struct bhv_vnode *, const char *, inst_t *);
-extern void vn_trace_hold(struct vnode *, char *, int, inst_t *);
+extern void vn_trace_hold(struct bhv_vnode *, char *, int, inst_t *);
-extern void vn_trace_ref(struct vnode *, char *, int, inst_t *);
+extern void vn_trace_ref(struct bhv_vnode *, char *, int, inst_t *);
-extern void vn_trace_rele(struct vnode *, char *, int, inst_t *);
+extern void vn_trace_rele(struct bhv_vnode *, char *, int, inst_t *);
 #define VN_TRACE(vp)            \
        vn_trace_ref(vp, __FILE__, __LINE__, (inst_t *)__return_address)
diff --git a/fs/xfs/quota/xfs_dquot.c b/fs/xfs/quota/xfs_dquot.c
index 772ac48329ea..3aa771531856 100644
--- a/fs/xfs/quota/xfs_dquot.c
+++ b/fs/xfs/quota/xfs_dquot.c
@@ -23,7 +23,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
 #include "xfs_dmapi.h"
@@ -32,7 +31,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -444,7 +442,7 @@ xfs_qm_dqalloc(
                              XFS_BMAPI_METADATA | XFS_BMAPI_WRITE,
                              &firstblock,
                              XFS_QM_DQALLOC_SPACE_RES(mp),
-                              &map, &nmaps, &flist))) {
+                              &map, &nmaps, &flist, NULL))) {
                goto error0;
        }
        ASSERT(map.br_blockcount == XFS_DQUOT_CLUSTER_SIZE_FSB);
@@ -559,7 +557,7 @@ xfs_qm_dqtobp(
                error = xfs_bmapi(NULL, quotip, dqp->q_fileoffset,
                                  XFS_DQUOT_CLUSTER_SIZE_FSB,
                                  XFS_BMAPI_METADATA,
-                                  NULL, 0, &map, &nmaps, NULL);
+                                  NULL, 0, &map, &nmaps, NULL, NULL);
                xfs_iunlock(quotip, XFS_ILOCK_SHARED);
                if (error)
@@ -1261,7 +1259,7 @@ xfs_qm_dqflush(
        if (xfs_qm_dqcheck(&dqp->q_core, be32_to_cpu(ddqp->d_id),
                           0, XFS_QMOPT_DOWARN, "dqflush (incore copy)")) {
-                xfs_force_shutdown(dqp->q_mount, XFS_CORRUPT_INCORE);
+                xfs_force_shutdown(dqp->q_mount, SHUTDOWN_CORRUPT_INCORE);
                return XFS_ERROR(EIO);
        }
diff --git a/fs/xfs/quota/xfs_dquot.h b/fs/xfs/quota/xfs_dquot.h
index c0c629663a5c..78d3ab95c5fd 100644
--- a/fs/xfs/quota/xfs_dquot.h
+++ b/fs/xfs/quota/xfs_dquot.h
@@ -119,7 +119,7 @@ XFS_DQ_IS_LOCKED(xfs_dquot_t *dqp)
 */
 #define xfs_dqflock(dqp)         { psema(&((dqp)->q_flock), PINOD | PRECALC);\
                                   (dqp)->dq_flags |= XFS_DQ_FLOCKED; }
-#define xfs_dqfunlock(dqp)       { ASSERT(valusema(&((dqp)->q_flock)) <= 0); \
+#define xfs_dqfunlock(dqp)       { ASSERT(issemalocked(&((dqp)->q_flock))); \
                                   vsema(&((dqp)->q_flock)); \
                                   (dqp)->dq_flags &= ~(XFS_DQ_FLOCKED); }
@@ -128,7 +128,7 @@ XFS_DQ_IS_LOCKED(xfs_dquot_t *dqp)
 #define XFS_DQ_PINUNLOCK(dqp, s)   mutex_spinunlock( \
                                     &(XFS_DQ_TO_QINF(dqp)->qi_pinlock), s)
-#define XFS_DQ_IS_FLUSH_LOCKED(dqp) (valusema(&((dqp)->q_flock)) <= 0)
+#define XFS_DQ_IS_FLUSH_LOCKED(dqp) (issemalocked(&((dqp)->q_flock)))
 #define XFS_DQ_IS_ON_FREELIST(dqp)  ((dqp)->dq_flnext != (dqp))
 #define XFS_DQ_IS_DIRTY(dqp)    ((dqp)->dq_flags & XFS_DQ_DIRTY)
 #define XFS_QM_ISUDQ(dqp)       ((dqp)->dq_flags & XFS_DQ_USER)
diff --git a/fs/xfs/quota/xfs_dquot_item.c b/fs/xfs/quota/xfs_dquot_item.c
index 546f48af882a..5b2dcc58b244 100644
--- a/fs/xfs/quota/xfs_dquot_item.c
+++ b/fs/xfs/quota/xfs_dquot_item.c
@@ -23,7 +23,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
 #include "xfs_dmapi.h"
@@ -32,7 +31,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -248,7 +246,7 @@ xfs_qm_dquot_logitem_pushbuf(
         * inode flush completed and the inode was taken off the AIL.
         * So, just get out.
         */
-        if ((valusema(&(dqp->q_flock)) > 0)  ||
+        if (!issemalocked(&(dqp->q_flock))  ||
            ((qip->qli_item.li_flags & XFS_LI_IN_AIL) == 0)) {
                qip->qli_pushbuf_flag = 0;
                xfs_dqunlock(dqp);
@@ -261,7 +259,7 @@ xfs_qm_dquot_logitem_pushbuf(
        if (bp != NULL) {
                if (XFS_BUF_ISDELAYWRITE(bp)) {
                        dopush = ((qip->qli_item.li_flags & XFS_LI_IN_AIL) &&
-                                  (valusema(&(dqp->q_flock)) <= 0));
+                                  issemalocked(&(dqp->q_flock)));
                        qip->qli_pushbuf_flag = 0;
                        xfs_dqunlock(dqp);
diff --git a/fs/xfs/quota/xfs_qm.c b/fs/xfs/quota/xfs_qm.c
index 7fb5eca9bd50..e23e45535c48 100644
--- a/fs/xfs/quota/xfs_qm.c
+++ b/fs/xfs/quota/xfs_qm.c
@@ -24,7 +24,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
 #include "xfs_dmapi.h"
@@ -33,7 +32,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -1603,7 +1601,7 @@ xfs_qm_dqiterate(
                                  maxlblkcnt - lblkno,
                                  XFS_BMAPI_METADATA,
                                  NULL,
-                                  0, map, &nmaps, NULL);
+                                  0, map, &nmaps, NULL, NULL);
                xfs_iunlock(qip, XFS_ILOCK_SHARED);
                if (error)
                        break;
@@ -1905,9 +1903,7 @@ xfs_qm_quotacheck(
                 */
                if ((error = xfs_bulkstat(mp, &lastino, &count,
                                     xfs_qm_dqusage_adjust, NULL,
-                                     structsz, NULL,
+                                     structsz, NULL, BULKSTAT_FG_IGET, &done)))
-                                     BULKSTAT_FG_IGET|BULKSTAT_FG_VFSLOCKED,
-                                     &done)))
                        break;
        } while (! done);
diff --git a/fs/xfs/quota/xfs_qm_bhv.c b/fs/xfs/quota/xfs_qm_bhv.c
index 6838b36d95a9..e95e99f7168f 100644
--- a/fs/xfs/quota/xfs_qm_bhv.c
+++ b/fs/xfs/quota/xfs_qm_bhv.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2005 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
@@ -24,7 +24,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
 #include "xfs_dmapi.h"
@@ -33,7 +32,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -129,7 +127,7 @@ xfs_qm_parseargs(
                return XFS_ERROR(EINVAL);
        }
-        PVFS_PARSEARGS(BHV_NEXT(bhv), options, args, update, error);
+        error = bhv_next_vfs_parseargs(BHV_NEXT(bhv), options, args, update);
        if (!error && !referenced)
                bhv_remove_vfsops(bhvtovfs(bhv), VFS_POSITION_QM);
        return error;
@@ -140,9 +138,8 @@ xfs_qm_showargs(
        struct bhv_desc         *bhv,
        struct seq_file         *m)
 {
-        struct vfs              *vfsp = bhvtovfs(bhv);
+        struct bhv_vfs          *vfsp = bhvtovfs(bhv);
        struct xfs_mount        *mp = XFS_VFSTOM(vfsp);
-        int                     error;
        if (mp->m_qflags & XFS_UQUOTA_ACCT) {
                (mp->m_qflags & XFS_UQUOTA_ENFD) ?
@@ -165,8 +162,7 @@ xfs_qm_showargs(
        if (!(mp->m_qflags & XFS_ALL_QUOTA_ACCT))
                seq_puts(m, "," MNTOPT_NOQUOTA);
-        PVFS_SHOWARGS(BHV_NEXT(bhv), m, error);
+        return bhv_next_vfs_showargs(BHV_NEXT(bhv), m);
-        return error;
 }
 STATIC int
@@ -175,14 +171,67 @@ xfs_qm_mount(
        struct xfs_mount_args   *args,
        struct cred             *cr)
 {
-        struct vfs              *vfsp = bhvtovfs(bhv);
+        struct bhv_vfs          *vfsp = bhvtovfs(bhv);
        struct xfs_mount        *mp = XFS_VFSTOM(vfsp);
-        int                     error;
        if (args->flags & (XFSMNT_UQUOTA | XFSMNT_GQUOTA | XFSMNT_PQUOTA))
                xfs_qm_mount_quotainit(mp, args->flags);
-        PVFS_MOUNT(BHV_NEXT(bhv), args, cr, error);
+        return bhv_next_vfs_mount(BHV_NEXT(bhv), args, cr);
-        return error;
+}
+/*
+ * Directory tree accounting is implemented using project quotas, where
+ * the project identifier is inherited from parent directories.
+ * A statvfs (df, etc.) of a directory that is using project quota should
+ * return a statvfs of the project, not the entire filesystem.
+ * This makes such trees appear as if they are filesystems in themselves.
+ */
+STATIC int
+xfs_qm_statvfs(
+        struct bhv_desc         *bhv,
+        bhv_statvfs_t           *statp,
+        struct bhv_vnode        *vnode)
+{
+        xfs_mount_t             *mp;
+        xfs_inode_t             *ip;
+        xfs_dquot_t             *dqp;
+        xfs_disk_dquot_t        *dp;
+        __uint64_t              limit;
+        int                     error;
+        error = bhv_next_vfs_statvfs(BHV_NEXT(bhv), statp, vnode);
+        if (error || !vnode)
+                return error;
+        mp = XFS_BHVTOM(bhv);
+        ip = xfs_vtoi(vnode);
+        if (!(ip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT))
+                return 0;
+        if (!(mp->m_qflags & XFS_PQUOTA_ACCT))
+                return 0;
+        if (!(mp->m_qflags & XFS_OQUOTA_ENFD))
+                return 0;
+        if (xfs_qm_dqget(mp, NULL, ip->i_d.di_projid, XFS_DQ_PROJ, 0, &dqp))
+                return 0;
+        dp = &dqp->q_core;
+        limit = dp->d_blk_softlimit ? dp->d_blk_softlimit : dp->d_blk_hardlimit;
+        if (limit && statp->f_blocks > limit) {
+                statp->f_blocks = limit;
+                statp->f_bfree = (statp->f_blocks > dp->d_bcount) ?
+                                        (statp->f_blocks - dp->d_bcount) : 0;
+        }
+        limit = dp->d_ino_softlimit ? dp->d_ino_softlimit : dp->d_ino_hardlimit;
+        if (limit && statp->f_files > limit) {
+                statp->f_files = limit;
+                statp->f_ffree = (statp->f_files > dp->d_icount) ?
+                                        (statp->f_ffree - dp->d_icount) : 0;
+        }
+        xfs_qm_dqput(dqp);
+        return 0;
 }
 STATIC int
@@ -191,7 +240,7 @@ xfs_qm_syncall(
        int                     flags,
        cred_t                  *credp)
 {
-        struct vfs              *vfsp = bhvtovfs(bhv);
+        struct bhv_vfs          *vfsp = bhvtovfs(bhv);
        struct xfs_mount        *mp = XFS_VFSTOM(vfsp);
        int                     error;
@@ -210,8 +259,7 @@ xfs_qm_syncall(
                        }
                }
        }
-        PVFS_SYNC(BHV_NEXT(bhv), flags, credp, error);
+        return bhv_next_vfs_sync(BHV_NEXT(bhv), flags, credp);
-        return error;
 }
 STATIC int
@@ -346,11 +394,12 @@ STATIC struct xfs_qmops xfs_qmcore_xfs = {
        .xfs_dqtrxops           = &xfs_trans_dquot_ops,
 };
-struct bhv_vfsops xfs_qmops = { {
+struct bhv_module_vfsops xfs_qmops = { {
        BHV_IDENTITY_INIT(VFS_BHV_QM, VFS_POSITION_QM),
        .vfs_parseargs          = xfs_qm_parseargs,
        .vfs_showargs           = xfs_qm_showargs,
        .vfs_mount              = xfs_qm_mount,
+        .vfs_statvfs            = xfs_qm_statvfs,
        .vfs_sync               = xfs_qm_syncall,
        .vfs_quotactl           = xfs_qm_quotactl, },
 };
diff --git a/fs/xfs/quota/xfs_qm_stats.c b/fs/xfs/quota/xfs_qm_stats.c
index 0570f7733550..6f858fb81a36 100644
--- a/fs/xfs/quota/xfs_qm_stats.c
+++ b/fs/xfs/quota/xfs_qm_stats.c
@@ -23,7 +23,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
 #include "xfs_dmapi.h"
@@ -32,7 +31,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
diff --git a/fs/xfs/quota/xfs_qm_syscalls.c b/fs/xfs/quota/xfs_qm_syscalls.c
index c55db463bbf2..ed620c4d1594 100644
--- a/fs/xfs/quota/xfs_qm_syscalls.c
+++ b/fs/xfs/quota/xfs_qm_syscalls.c
@@ -26,7 +26,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
 #include "xfs_dmapi.h"
@@ -35,7 +34,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -91,8 +89,8 @@ xfs_qm_quotactl(
        xfs_caddr_t     addr)
 {
        xfs_mount_t     *mp;
+        bhv_vfs_t       *vfsp;
        int             error;
-        struct vfs      *vfsp;
        vfsp = bhvtovfs(bdp);
        mp = XFS_VFSTOM(vfsp);
@@ -1035,7 +1033,7 @@ xfs_qm_dqrele_all_inodes(
 {
        xfs_inode_t     *ip, *topino;
        uint            ireclaims;
-        vnode_t         *vp;
+        bhv_vnode_t     *vp;
        boolean_t       vnode_refd;
        ASSERT(mp->m_quotainfo);
diff --git a/fs/xfs/quota/xfs_trans_dquot.c b/fs/xfs/quota/xfs_trans_dquot.c
index 9168918db252..0242e9666e8e 100644
--- a/fs/xfs/quota/xfs_trans_dquot.c
+++ b/fs/xfs/quota/xfs_trans_dquot.c
@@ -23,7 +23,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
 #include "xfs_dmapi.h"
@@ -33,7 +32,6 @@
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
 #include "xfs_attr_sf.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
diff --git a/fs/xfs/support/debug.c b/fs/xfs/support/debug.c
index b08b3d9345b7..36fbeccdc722 100644
--- a/fs/xfs/support/debug.c
+++ b/fs/xfs/support/debug.c
@@ -47,7 +47,7 @@ cmn_err(register int level, char *fmt, ...)
        va_start(ap, fmt);
        if (*fmt == '!') fp++;
        len = vsprintf(message, fp, ap);
-        if (message[len-1] != '\n')
+        if (level != CE_DEBUG && message[len-1] != '\n')
                strcat(message, "\n");
        printk("%s%s", err_level[level], message);
        va_end(ap);
@@ -68,7 +68,7 @@ icmn_err(register int level, char *fmt, va_list ap)
                level = XFS_MAX_ERR_LEVEL;
        spin_lock_irqsave(&xfs_err_lock,flags);
        len = vsprintf(message, fmt, ap);
-        if (message[len-1] != '\n')
+        if (level != CE_DEBUG && message[len-1] != '\n')
                strcat(message, "\n");
        spin_unlock_irqrestore(&xfs_err_lock,flags);
        printk("%s%s", err_level[level], message);
diff --git a/fs/xfs/support/debug.h b/fs/xfs/support/debug.h
index e3bf58112e7e..4f54dca662a8 100644
--- a/fs/xfs/support/debug.h
+++ b/fs/xfs/support/debug.h
@@ -33,9 +33,6 @@ extern void cmn_err(int, char *, ...)
        __attribute__ ((format (printf, 2, 3)));
 extern void assfail(char *expr, char *f, int l);
-#define prdev(fmt,targ,args...) \
-        printk("Device %s - " fmt "\n", XFS_BUFTARG_NAME(targ), ## args)
 #define ASSERT_ALWAYS(expr)     \
        (unlikely((expr) != 0) ? (void)0 : assfail(#expr, __FILE__, __LINE__))
diff --git a/fs/xfs/xfs_acl.c b/fs/xfs/xfs_acl.c
index 2539af34eb63..4b0cb474be4c 100644
--- a/fs/xfs/xfs_acl.c
+++ b/fs/xfs/xfs_acl.c
@@ -21,12 +21,10 @@
 #include "xfs_bit.h"
 #include "xfs_inum.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -39,15 +37,15 @@
 #include <linux/capability.h>
 #include <linux/posix_acl_xattr.h>
-STATIC int      xfs_acl_setmode(vnode_t *, xfs_acl_t *, int *);
+STATIC int      xfs_acl_setmode(bhv_vnode_t *, xfs_acl_t *, int *);
 STATIC void     xfs_acl_filter_mode(mode_t, xfs_acl_t *);
 STATIC void     xfs_acl_get_endian(xfs_acl_t *);
 STATIC int      xfs_acl_access(uid_t, gid_t, xfs_acl_t *, mode_t, cred_t *);
 STATIC int      xfs_acl_invalid(xfs_acl_t *);
 STATIC void     xfs_acl_sync_mode(mode_t, xfs_acl_t *);
-STATIC void     xfs_acl_get_attr(vnode_t *, xfs_acl_t *, int, int, int *);
+STATIC void     xfs_acl_get_attr(bhv_vnode_t *, xfs_acl_t *, int, int, int *);
-STATIC void     xfs_acl_set_attr(vnode_t *, xfs_acl_t *, int, int *);
+STATIC void     xfs_acl_set_attr(bhv_vnode_t *, xfs_acl_t *, int, int *);
-STATIC int      xfs_acl_allow_set(vnode_t *, int);
+STATIC int      xfs_acl_allow_set(bhv_vnode_t *, int);
 kmem_zone_t *xfs_acl_zone;
@@ -57,7 +55,7 @@ kmem_zone_t *xfs_acl_zone;
 */
 int
 xfs_acl_vhasacl_access(
-        vnode_t         *vp)
+        bhv_vnode_t     *vp)
 {
        int             error;
@@ -70,7 +68,7 @@ xfs_acl_vhasacl_access(
 */
 int
 xfs_acl_vhasacl_default(
-        vnode_t         *vp)
+        bhv_vnode_t     *vp)
 {
        int             error;
@@ -209,7 +207,7 @@ posix_acl_xfs_to_xattr(
 int
 xfs_acl_vget(
-        vnode_t         *vp,
+        bhv_vnode_t     *vp,
        void            *acl,
        size_t          size,
        int             kind)
@@ -241,10 +239,10 @@ xfs_acl_vget(
                        goto out;
                }
                if (kind == _ACL_TYPE_ACCESS) {
-                        vattr_t va;
+                        bhv_vattr_t     va;
                        va.va_mask = XFS_AT_MODE;
-                        VOP_GETATTR(vp, &va, 0, sys_cred, error);
+                        error = bhv_vop_getattr(vp, &va, 0, sys_cred);
                        if (error)
                                goto out;
                        xfs_acl_sync_mode(va.va_mode, xfs_acl);
@@ -260,7 +258,7 @@ out:
 int
 xfs_acl_vremove(
-        vnode_t         *vp,
+        bhv_vnode_t     *vp,
        int             kind)
 {
        int             error;
@@ -268,9 +266,9 @@ xfs_acl_vremove(
        VN_HOLD(vp);
        error = xfs_acl_allow_set(vp, kind);
        if (!error) {
-                VOP_ATTR_REMOVE(vp, kind == _ACL_TYPE_DEFAULT?
+                error = bhv_vop_attr_remove(vp, kind == _ACL_TYPE_DEFAULT?
-                                SGI_ACL_DEFAULT: SGI_ACL_FILE,
+                                                SGI_ACL_DEFAULT: SGI_ACL_FILE,
-                                ATTR_ROOT, sys_cred, error);
+                                                ATTR_ROOT, sys_cred);
                if (error == ENOATTR)
                        error = 0;      /* 'scool */
        }
@@ -280,7 +278,7 @@ xfs_acl_vremove(
 int
 xfs_acl_vset(
-        vnode_t                 *vp,
+        bhv_vnode_t             *vp,
        void                    *acl,
        size_t                  size,
        int                     kind)
@@ -370,10 +368,10 @@ xfs_acl_iaccess(
 STATIC int
 xfs_acl_allow_set(
-        vnode_t         *vp,
+        bhv_vnode_t     *vp,
        int             kind)
 {
-        vattr_t         va;
+        bhv_vattr_t     va;
        int             error;
        if (vp->v_inode.i_flags & (S_IMMUTABLE|S_APPEND))
@@ -383,7 +381,7 @@ xfs_acl_allow_set(
        if (vp->v_vfsp->vfs_flag & VFS_RDONLY)
                return EROFS;
        va.va_mask = XFS_AT_UID;
-        VOP_GETATTR(vp, &va, 0, NULL, error);
+        error = bhv_vop_getattr(vp, &va, 0, NULL);
        if (error)
                return error;
        if (va.va_uid != current->fsuid && !capable(CAP_FOWNER))
@@ -606,7 +604,7 @@ xfs_acl_get_endian(
 */
 STATIC void
 xfs_acl_get_attr(
-        vnode_t         *vp,
+        bhv_vnode_t     *vp,
        xfs_acl_t       *aclp,
        int             kind,
        int             flags,
@@ -616,9 +614,9 @@ xfs_acl_get_attr(
        ASSERT((flags & ATTR_KERNOVAL) ? (aclp == NULL) : 1);
        flags |= ATTR_ROOT;
-        VOP_ATTR_GET(vp,
+        *error = bhv_vop_attr_get(vp, kind == _ACL_TYPE_ACCESS ?
-                kind == _ACL_TYPE_ACCESS ? SGI_ACL_FILE : SGI_ACL_DEFAULT,
+                                        SGI_ACL_FILE : SGI_ACL_DEFAULT,
-                (char *)aclp, &len, flags, sys_cred, *error);
+                                        (char *)aclp, &len, flags, sys_cred);
        if (*error || (flags & ATTR_KERNOVAL))
                return;
        xfs_acl_get_endian(aclp);
@@ -629,7 +627,7 @@ xfs_acl_get_attr(
 */
 STATIC void
 xfs_acl_set_attr(
-        vnode_t         *vp,
+        bhv_vnode_t     *vp,
        xfs_acl_t       *aclp,
        int             kind,
        int             *error)
@@ -654,19 +652,19 @@ xfs_acl_set_attr(
                INT_SET(newace->ae_perm, ARCH_CONVERT, ace->ae_perm);
        }
        INT_SET(newacl->acl_cnt, ARCH_CONVERT, aclp->acl_cnt);
-        VOP_ATTR_SET(vp,
+        *error = bhv_vop_attr_set(vp, kind == _ACL_TYPE_ACCESS ?
-                kind == _ACL_TYPE_ACCESS ? SGI_ACL_FILE: SGI_ACL_DEFAULT,
+                                SGI_ACL_FILE: SGI_ACL_DEFAULT,
-                (char *)newacl, len, ATTR_ROOT, sys_cred, *error);
+                                (char *)newacl, len, ATTR_ROOT, sys_cred);
        _ACL_FREE(newacl);
 }
 int
 xfs_acl_vtoacl(
-        vnode_t         *vp,
+        bhv_vnode_t     *vp,
        xfs_acl_t       *access_acl,
        xfs_acl_t       *default_acl)
 {
-        vattr_t         va;
+        bhv_vattr_t     va;
        int             error = 0;
        if (access_acl) {
@@ -678,7 +676,7 @@ xfs_acl_vtoacl(
                if (!error) {
                        /* Got the ACL, need the mode... */
                        va.va_mask = XFS_AT_MODE;
-                        VOP_GETATTR(vp, &va, 0, sys_cred, error);
+                        error = bhv_vop_getattr(vp, &va, 0, sys_cred);
                }
                if (error)
@@ -701,8 +699,8 @@ xfs_acl_vtoacl(
 */
 int
 xfs_acl_inherit(
-        vnode_t         *vp,
+        bhv_vnode_t     *vp,
-        vattr_t         *vap,
+        bhv_vattr_t     *vap,
        xfs_acl_t       *pdaclp)
 {
        xfs_acl_t       *cacl;
@@ -757,11 +755,11 @@ xfs_acl_inherit(
 */
 STATIC int
 xfs_acl_setmode(
-        vnode_t         *vp,
+        bhv_vnode_t     *vp,
        xfs_acl_t       *acl,
        int             *basicperms)
 {
-        vattr_t         va;
+        bhv_vattr_t     va;
        xfs_acl_entry_t *ap;
        xfs_acl_entry_t *gap = NULL;
        int             i, error, nomask = 1;
@@ -776,7 +774,7 @@ xfs_acl_setmode(
         * mode.  The m:: bits take precedence over the g:: bits.
         */
        va.va_mask = XFS_AT_MODE;
-        VOP_GETATTR(vp, &va, 0, sys_cred, error);
+        error = bhv_vop_getattr(vp, &va, 0, sys_cred);
        if (error)
                return error;
@@ -810,8 +808,7 @@ xfs_acl_setmode(
        if (gap && nomask)
                va.va_mode |= gap->ae_perm << 3;
-        VOP_SETATTR(vp, &va, 0, sys_cred, error);
+        return bhv_vop_setattr(vp, &va, 0, sys_cred);
-        return error;
 }
 /*
diff --git a/fs/xfs/xfs_acl.h b/fs/xfs/xfs_acl.h
index 538d0d65b04c..f853cf1a6270 100644
--- a/fs/xfs/xfs_acl.h
+++ b/fs/xfs/xfs_acl.h
@@ -50,7 +50,7 @@ typedef struct xfs_acl {
 #ifdef CONFIG_XFS_POSIX_ACL
 struct vattr;
-struct vnode;
+struct bhv_vnode;
 struct xfs_inode;
 extern struct kmem_zone *xfs_acl_zone;
@@ -58,14 +58,14 @@ extern struct kmem_zone *xfs_acl_zone;
                (zone) = kmem_zone_init(sizeof(xfs_acl_t), (name))
 #define xfs_acl_zone_destroy(zone)      kmem_zone_destroy(zone)
-extern int xfs_acl_inherit(struct vnode *, struct vattr *, xfs_acl_t *);
+extern int xfs_acl_inherit(struct bhv_vnode *, struct bhv_vattr *, xfs_acl_t *);
 extern int xfs_acl_iaccess(struct xfs_inode *, mode_t, cred_t *);
-extern int xfs_acl_vtoacl(struct vnode *, xfs_acl_t *, xfs_acl_t *);
+extern int xfs_acl_vtoacl(struct bhv_vnode *, xfs_acl_t *, xfs_acl_t *);
-extern int xfs_acl_vhasacl_access(struct vnode *);
+extern int xfs_acl_vhasacl_access(struct bhv_vnode *);
-extern int xfs_acl_vhasacl_default(struct vnode *);
+extern int xfs_acl_vhasacl_default(struct bhv_vnode *);
-extern int xfs_acl_vset(struct vnode *, void *, size_t, int);
+extern int xfs_acl_vset(struct bhv_vnode *, void *, size_t, int);
-extern int xfs_acl_vget(struct vnode *, void *, size_t, int);
+extern int xfs_acl_vget(struct bhv_vnode *, void *, size_t, int);
-extern int xfs_acl_vremove(struct vnode *vp, int);
+extern int xfs_acl_vremove(struct bhv_vnode *, int);
 #define _ACL_TYPE_ACCESS        1
 #define _ACL_TYPE_DEFAULT       2
diff --git a/fs/xfs/xfs_alloc.c b/fs/xfs/xfs_alloc.c
index 8558226281c4..eef6763f3a67 100644
--- a/fs/xfs/xfs_alloc.c
+++ b/fs/xfs/xfs_alloc.c
@@ -24,14 +24,12 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -1862,7 +1860,7 @@ xfs_alloc_fix_freelist(
                (pag->pagf_longest - delta) :
                (pag->pagf_flcount > 0 || pag->pagf_longest > 0);
        if (args->minlen + args->alignment + args->minalignslop - 1 > longest ||
-            (args->minleft &&
+            (!(flags & XFS_ALLOC_FLAG_FREEING) &&
             (int)(pag->pagf_freeblks + pag->pagf_flcount -
                   need - args->total) <
             (int)args->minleft)) {
@@ -1898,7 +1896,7 @@ xfs_alloc_fix_freelist(
        longest = (longest > delta) ? (longest - delta) :
                (be32_to_cpu(agf->agf_flcount) > 0 || longest > 0);
        if (args->minlen + args->alignment + args->minalignslop - 1 > longest ||
-             (args->minleft &&
+             (!(flags & XFS_ALLOC_FLAG_FREEING) &&
                (int)(be32_to_cpu(agf->agf_freeblks) +
                   be32_to_cpu(agf->agf_flcount) - need - args->total) <
             (int)args->minleft)) {
@@ -1951,8 +1949,14 @@ xfs_alloc_fix_freelist(
                 * the restrictions correctly.  Can happen for free calls
                 * on a completely full ag.
                 */
-                if (targs.agbno == NULLAGBLOCK)
+                if (targs.agbno == NULLAGBLOCK) {
+                        if (!(flags & XFS_ALLOC_FLAG_FREEING)) {
+                                xfs_trans_brelse(tp, agflbp);
+                                args->agbp = NULL;
+                                return 0;
+                        }
                        break;
+                }
                /*
                 * Put each allocated block on the list.
                 */
@@ -2360,8 +2364,19 @@ xfs_alloc_vextent(
                        if (args->agno == sagno &&
                            type == XFS_ALLOCTYPE_START_BNO)
                                args->type = XFS_ALLOCTYPE_THIS_AG;
-                        if (++(args->agno) == mp->m_sb.sb_agcount)
+                        /*
-                                args->agno = 0;
+                        * For the first allocation, we can try any AG to get
+                        * space.  However, if we already have allocated a
+                        * block, we don't want to try AGs whose number is below
+                        * sagno. Otherwise, we may end up with out-of-order
+                        * locking of AGF, which might cause deadlock.
+                        */
+                        if (++(args->agno) == mp->m_sb.sb_agcount) {
+                                if (args->firstblock != NULLFSBLOCK)
+                                        args->agno = sagno;
+                                else
+                                        args->agno = 0;
+                        }
                        /*
                         * Reached the starting a.g., must either be done
                         * or switch to non-trylock mode.
@@ -2443,7 +2458,7 @@ xfs_free_extent(
        args.minlen = args.minleft = args.minalignslop = 0;
        down_read(&args.mp->m_peraglock);
        args.pag = &args.mp->m_perag[args.agno];
-        if ((error = xfs_alloc_fix_freelist(&args, 0)))
+        if ((error = xfs_alloc_fix_freelist(&args, XFS_ALLOC_FLAG_FREEING)))
                goto error0;
 #ifdef DEBUG
        ASSERT(args.agbp != NULL);
diff --git a/fs/xfs/xfs_alloc.h b/fs/xfs/xfs_alloc.h
index 2d1f8928b267..650591f999ae 100644
--- a/fs/xfs/xfs_alloc.h
+++ b/fs/xfs/xfs_alloc.h
@@ -41,6 +41,7 @@ typedef enum xfs_alloctype
 * Flags for xfs_alloc_fix_freelist.
 */
 #define XFS_ALLOC_FLAG_TRYLOCK  0x00000001  /* use trylock for buffer locking */
+#define XFS_ALLOC_FLAG_FREEING  0x00000002  /* indicate caller is freeing extents*/
 /*
 * Argument structure for xfs_alloc routines.
@@ -70,6 +71,7 @@ typedef struct xfs_alloc_arg {
        char            wasfromfl;      /* set if allocation is from freelist */
        char            isfl;           /* set if is freelist blocks - !acctg */
        char            userdata;       /* set if this is user data */
+        xfs_fsblock_t   firstblock;     /* io first block allocated */
 } xfs_alloc_arg_t;
 /*
diff --git a/fs/xfs/xfs_alloc_btree.c b/fs/xfs/xfs_alloc_btree.c
index a1d92da86ccd..7446556e8021 100644
--- a/fs/xfs/xfs_alloc_btree.c
+++ b/fs/xfs/xfs_alloc_btree.c
@@ -24,14 +24,12 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
diff --git a/fs/xfs/xfs_attr.c b/fs/xfs/xfs_attr.c
index b6e1e02bbb28..1a2101043275 100644
--- a/fs/xfs/xfs_attr.c
+++ b/fs/xfs/xfs_attr.c
@@ -27,7 +27,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
@@ -35,7 +34,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -1910,7 +1908,7 @@ xfs_attr_rmtval_get(xfs_da_args_t *args)
                error = xfs_bmapi(args->trans, args->dp, (xfs_fileoff_t)lblkno,
                                  args->rmtblkcnt,
                                  XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA,
-                                  NULL, 0, map, &nmap, NULL);
+                                  NULL, 0, map, &nmap, NULL, NULL);
                if (error)
                        return(error);
                ASSERT(nmap >= 1);
@@ -1988,7 +1986,7 @@ xfs_attr_rmtval_set(xfs_da_args_t *args)
                                  XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA |
                                                        XFS_BMAPI_WRITE,
                                  args->firstblock, args->total, &map, &nmap,
-                                  args->flist);
+                                  args->flist, NULL);
                if (!error) {
                        error = xfs_bmap_finish(&args->trans, args->flist,
                                                *args->firstblock, &committed);
@@ -2039,7 +2037,8 @@ xfs_attr_rmtval_set(xfs_da_args_t *args)
                error = xfs_bmapi(NULL, dp, (xfs_fileoff_t)lblkno,
                                  args->rmtblkcnt,
                                  XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA,
-                                  args->firstblock, 0, &map, &nmap, NULL);
+                                  args->firstblock, 0, &map, &nmap,
+                                  NULL, NULL);
                if (error) {
                        return(error);
                }
@@ -2104,7 +2103,7 @@ xfs_attr_rmtval_remove(xfs_da_args_t *args)
                                        args->rmtblkcnt,
                                        XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA,
                                        args->firstblock, 0, &map, &nmap,
-                                        args->flist);
+                                        args->flist, NULL);
                if (error) {
                        return(error);
                }
@@ -2142,7 +2141,8 @@ xfs_attr_rmtval_remove(xfs_da_args_t *args)
                XFS_BMAP_INIT(args->flist, args->firstblock);
                error = xfs_bunmapi(args->trans, args->dp, lblkno, blkcnt,
                                    XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA,
-                                    1, args->firstblock, args->flist, &done);
+                                    1, args->firstblock, args->flist,
+                                    NULL, &done);
                if (!error) {
                        error = xfs_bmap_finish(&args->trans, args->flist,
                                                *args->firstblock, &committed);
@@ -2322,56 +2322,56 @@ xfs_attr_trace_enter(int type, char *where,
 STATIC int
 posix_acl_access_set(
-        vnode_t *vp, char *name, void *data, size_t size, int xflags)
+        bhv_vnode_t *vp, char *name, void *data, size_t size, int xflags)
 {
        return xfs_acl_vset(vp, data, size, _ACL_TYPE_ACCESS);
 }
 STATIC int
 posix_acl_access_remove(
-        struct vnode *vp, char *name, int xflags)
+        bhv_vnode_t *vp, char *name, int xflags)
 {
        return xfs_acl_vremove(vp, _ACL_TYPE_ACCESS);
 }
 STATIC int
 posix_acl_access_get(
-        vnode_t *vp, char *name, void *data, size_t size, int xflags)
+        bhv_vnode_t *vp, char *name, void *data, size_t size, int xflags)
 {
        return xfs_acl_vget(vp, data, size, _ACL_TYPE_ACCESS);
 }
 STATIC int
 posix_acl_access_exists(
-        vnode_t *vp)
+        bhv_vnode_t *vp)
 {
        return xfs_acl_vhasacl_access(vp);
 }
 STATIC int
 posix_acl_default_set(
-        vnode_t *vp, char *name, void *data, size_t size, int xflags)
+        bhv_vnode_t *vp, char *name, void *data, size_t size, int xflags)
 {
        return xfs_acl_vset(vp, data, size, _ACL_TYPE_DEFAULT);
 }
 STATIC int
 posix_acl_default_get(
-        vnode_t *vp, char *name, void *data, size_t size, int xflags)
+        bhv_vnode_t *vp, char *name, void *data, size_t size, int xflags)
 {
        return xfs_acl_vget(vp, data, size, _ACL_TYPE_DEFAULT);
 }
 STATIC int
 posix_acl_default_remove(
-        struct vnode *vp, char *name, int xflags)
+        bhv_vnode_t *vp, char *name, int xflags)
 {
        return xfs_acl_vremove(vp, _ACL_TYPE_DEFAULT);
 }
 STATIC int
 posix_acl_default_exists(
-        vnode_t *vp)
+        bhv_vnode_t *vp)
 {
        return xfs_acl_vhasacl_default(vp);
 }
@@ -2404,21 +2404,18 @@ STATIC struct attrnames *attr_system_names[] =
 STATIC int
 attr_generic_set(
-        struct vnode *vp, char *name, void *data, size_t size, int xflags)
+        bhv_vnode_t *vp, char *name, void *data, size_t size, int xflags)
 {
-        int     error;
+        return -bhv_vop_attr_set(vp, name, data, size, xflags, NULL);
-        VOP_ATTR_SET(vp, name, data, size, xflags, NULL, error);
-        return -error;
 }
 STATIC int
 attr_generic_get(
-        struct vnode *vp, char *name, void *data, size_t size, int xflags)
+        bhv_vnode_t *vp, char *name, void *data, size_t size, int xflags)
 {
        int     error, asize = size;
-        VOP_ATTR_GET(vp, name, data, &asize, xflags, NULL, error);
+        error = bhv_vop_attr_get(vp, name, data, &asize, xflags, NULL);
        if (!error)
                return asize;
        return -error;
@@ -2426,12 +2423,9 @@ attr_generic_get(
 STATIC int
 attr_generic_remove(
-        struct vnode *vp, char *name, int xflags)
+        bhv_vnode_t *vp, char *name, int xflags)
 {
-        int     error;
+        return -bhv_vop_attr_remove(vp, name, xflags, NULL);
-        VOP_ATTR_REMOVE(vp, name, xflags, NULL, error);
-        return -error;
 }
 STATIC int
@@ -2459,7 +2453,7 @@ attr_generic_listadd(
 STATIC int
 attr_system_list(
-        struct vnode            *vp,
+        bhv_vnode_t             *vp,
        void                    *data,
        size_t                  size,
        ssize_t                 *result)
@@ -2481,12 +2475,12 @@ attr_system_list(
 int
 attr_generic_list(
-        struct vnode *vp, void *data, size_t size, int xflags, ssize_t *result)
+        bhv_vnode_t *vp, void *data, size_t size, int xflags, ssize_t *result)
 {
        attrlist_cursor_kern_t  cursor = { 0 };
        int                     error;
-        VOP_ATTR_LIST(vp, data, size, xflags, &cursor, NULL, error);
+        error = bhv_vop_attr_list(vp, data, size, xflags, &cursor, NULL);
        if (error > 0)
                return -error;
        *result = -error;
@@ -2514,7 +2508,7 @@ attr_lookup_namespace(
 */
 STATIC int
 attr_user_capable(
-        struct vnode    *vp,
+        bhv_vnode_t     *vp,
        cred_t          *cred)
 {
        struct inode    *inode = vn_to_inode(vp);
@@ -2532,7 +2526,7 @@ attr_user_capable(
 STATIC int
 attr_trusted_capable(
-        struct vnode    *vp,
+        bhv_vnode_t     *vp,
        cred_t          *cred)
 {
        struct inode    *inode = vn_to_inode(vp);
@@ -2546,7 +2540,7 @@ attr_trusted_capable(
 STATIC int
 attr_secure_capable(
-        struct vnode    *vp,
+        bhv_vnode_t     *vp,
        cred_t          *cred)
 {
        return -ENOSECURITY;
@@ -2554,7 +2548,7 @@ attr_secure_capable(
 STATIC int
 attr_system_set(
-        struct vnode *vp, char *name, void *data, size_t size, int xflags)
+        bhv_vnode_t *vp, char *name, void *data, size_t size, int xflags)
 {
        attrnames_t     *namesp;
        int             error;
@@ -2573,7 +2567,7 @@ attr_system_set(
 STATIC int
 attr_system_get(
-        struct vnode *vp, char *name, void *data, size_t size, int xflags)
+        bhv_vnode_t *vp, char *name, void *data, size_t size, int xflags)
 {
        attrnames_t     *namesp;
@@ -2585,7 +2579,7 @@ attr_system_get(
 STATIC int
 attr_system_remove(
-        struct vnode *vp, char *name, int xflags)
+        bhv_vnode_t *vp, char *name, int xflags)
 {
        attrnames_t     *namesp;
diff --git a/fs/xfs/xfs_attr.h b/fs/xfs/xfs_attr.h
index b2c7b9fcded3..981633f6c077 100644
--- a/fs/xfs/xfs_attr.h
+++ b/fs/xfs/xfs_attr.h
@@ -36,13 +36,13 @@
 *========================================================================*/
 struct cred;
-struct vnode;
+struct bhv_vnode;
-typedef int (*attrset_t)(struct vnode *, char *, void *, size_t, int);
+typedef int (*attrset_t)(struct bhv_vnode *, char *, void *, size_t, int);
-typedef int (*attrget_t)(struct vnode *, char *, void *, size_t, int);
+typedef int (*attrget_t)(struct bhv_vnode *, char *, void *, size_t, int);
-typedef int (*attrremove_t)(struct vnode *, char *, int);
+typedef int (*attrremove_t)(struct bhv_vnode *, char *, int);
-typedef int (*attrexists_t)(struct vnode *);
+typedef int (*attrexists_t)(struct bhv_vnode *);
-typedef int (*attrcapable_t)(struct vnode *, struct cred *);
+typedef int (*attrcapable_t)(struct bhv_vnode *, struct cred *);
 typedef struct attrnames {
        char *          attr_name;
@@ -63,7 +63,7 @@ extern struct attrnames attr_trusted;
 extern struct attrnames *attr_namespaces[ATTR_NAMECOUNT];
 extern attrnames_t *attr_lookup_namespace(char *, attrnames_t **, int);
-extern int attr_generic_list(struct vnode *, void *, size_t, int, ssize_t *);
+extern int attr_generic_list(struct bhv_vnode *, void *, size_t, int, ssize_t *);
 #define ATTR_DONTFOLLOW 0x0001  /* -- unused, from IRIX -- */
 #define ATTR_ROOT       0x0002  /* use attrs in root (trusted) namespace */
diff --git a/fs/xfs/xfs_attr_leaf.c b/fs/xfs/xfs_attr_leaf.c
index 9462be86aa14..9455051f0120 100644
--- a/fs/xfs/xfs_attr_leaf.c
+++ b/fs/xfs/xfs_attr_leaf.c
@@ -24,7 +24,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
@@ -34,7 +33,6 @@
 #include "xfs_ialloc_btree.h"
 #include "xfs_alloc.h"
 #include "xfs_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -2990,7 +2988,7 @@ xfs_attr_leaf_freextent(xfs_trans_t **trans, xfs_inode_t *dp,
                nmap = 1;
                error = xfs_bmapi(*trans, dp, (xfs_fileoff_t)tblkno, tblkcnt,
                                        XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA,
-                                        NULL, 0, &map, &nmap, NULL);
+                                        NULL, 0, &map, &nmap, NULL, NULL);
                if (error) {
                        return(error);
                }
diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index 26939d364bc4..3a6137539064 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2005 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
@@ -24,13 +24,11 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -40,13 +38,15 @@
 #include "xfs_mount.h"
 #include "xfs_ialloc.h"
 #include "xfs_itable.h"
+#include "xfs_dir2_data.h"
+#include "xfs_dir2_leaf.h"
+#include "xfs_dir2_block.h"
 #include "xfs_inode_item.h"
 #include "xfs_extfree_item.h"
 #include "xfs_alloc.h"
 #include "xfs_bmap.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
-#include "xfs_dir_leaf.h"
 #include "xfs_attr_leaf.h"
 #include "xfs_rw.h"
 #include "xfs_quota.h"
@@ -101,6 +101,7 @@ xfs_bmap_add_extent(
        xfs_fsblock_t           *first, /* pointer to firstblock variable */
        xfs_bmap_free_t         *flist, /* list of extents to be freed */
        int                     *logflagsp, /* inode logging flags */
+        xfs_extdelta_t          *delta, /* Change made to incore extents */
        int                     whichfork, /* data or attr fork */
        int                     rsvd);  /* OK to allocate reserved blocks */
@@ -118,6 +119,7 @@ xfs_bmap_add_extent_delay_real(
        xfs_fsblock_t           *first, /* pointer to firstblock variable */
        xfs_bmap_free_t         *flist, /* list of extents to be freed */
        int                     *logflagsp, /* inode logging flags */
+        xfs_extdelta_t          *delta, /* Change made to incore extents */
        int                     rsvd);  /* OK to allocate reserved blocks */
 /*
@@ -131,6 +133,7 @@ xfs_bmap_add_extent_hole_delay(
        xfs_btree_cur_t         *cur,   /* if null, not a btree */
        xfs_bmbt_irec_t         *new,   /* new data to add to file extents */
        int                     *logflagsp,/* inode logging flags */
+        xfs_extdelta_t          *delta, /* Change made to incore extents */
        int                     rsvd);  /* OK to allocate reserved blocks */
 /*
@@ -144,6 +147,7 @@ xfs_bmap_add_extent_hole_real(
        xfs_btree_cur_t         *cur,   /* if null, not a btree */
        xfs_bmbt_irec_t         *new,   /* new data to add to file extents */
        int                     *logflagsp, /* inode logging flags */
+        xfs_extdelta_t          *delta, /* Change made to incore extents */
        int                     whichfork); /* data or attr fork */
 /*
@@ -156,7 +160,8 @@ xfs_bmap_add_extent_unwritten_real(
        xfs_extnum_t            idx,    /* extent number to update/insert */
        xfs_btree_cur_t         **curp, /* if *curp is null, not a btree */
        xfs_bmbt_irec_t         *new,   /* new data to add to file extents */
-        int                     *logflagsp); /* inode logging flags */
+        int                     *logflagsp, /* inode logging flags */
+        xfs_extdelta_t          *delta); /* Change made to incore extents */
 /*
 * xfs_bmap_alloc is called by xfs_bmapi to allocate an extent for a file.
@@ -203,6 +208,7 @@ xfs_bmap_del_extent(
        xfs_btree_cur_t         *cur,   /* if null, not a btree */
        xfs_bmbt_irec_t         *new,   /* new data to add to file extents */
        int                     *logflagsp,/* inode logging flags */
+        xfs_extdelta_t          *delta, /* Change made to incore extents */
        int                     whichfork, /* data or attr fork */
        int                     rsvd);   /* OK to allocate reserved blocks */
@@ -510,7 +516,7 @@ xfs_bmap_add_attrfork_local(
                dargs.total = mp->m_dirblkfsbs;
                dargs.whichfork = XFS_DATA_FORK;
                dargs.trans = tp;
-                error = XFS_DIR_SHORTFORM_TO_SINGLE(mp, &dargs);
+                error = xfs_dir2_sf_to_block(&dargs);
        } else
                error = xfs_bmap_local_to_extents(tp, ip, firstblock, 1, flags,
                        XFS_DATA_FORK);
@@ -530,6 +536,7 @@ xfs_bmap_add_extent(
        xfs_fsblock_t           *first, /* pointer to firstblock variable */
        xfs_bmap_free_t         *flist, /* list of extents to be freed */
        int                     *logflagsp, /* inode logging flags */
+        xfs_extdelta_t          *delta, /* Change made to incore extents */
        int                     whichfork, /* data or attr fork */
        int                     rsvd)   /* OK to use reserved data blocks */
 {
@@ -567,6 +574,15 @@ xfs_bmap_add_extent(
                        logflags = XFS_ILOG_CORE | XFS_ILOG_FEXT(whichfork);
                } else
                        logflags = 0;
+                /* DELTA: single new extent */
+                if (delta) {
+                        if (delta->xed_startoff > new->br_startoff)
+                                delta->xed_startoff = new->br_startoff;
+                        if (delta->xed_blockcount <
+                                        new->br_startoff + new->br_blockcount)
+                                delta->xed_blockcount = new->br_startoff +
+                                                new->br_blockcount;
+                }
        }
        /*
         * Any kind of new delayed allocation goes here.
@@ -576,7 +592,7 @@ xfs_bmap_add_extent(
                        ASSERT((cur->bc_private.b.flags &
                                XFS_BTCUR_BPRV_WASDEL) == 0);
                if ((error = xfs_bmap_add_extent_hole_delay(ip, idx, cur, new,
-                                &logflags, rsvd)))
+                                &logflags, delta, rsvd)))
                        goto done;
        }
        /*
@@ -587,7 +603,7 @@ xfs_bmap_add_extent(
                        ASSERT((cur->bc_private.b.flags &
                                XFS_BTCUR_BPRV_WASDEL) == 0);
                if ((error = xfs_bmap_add_extent_hole_real(ip, idx, cur, new,
-                                &logflags, whichfork)))
+                                &logflags, delta, whichfork)))
                        goto done;
        } else {
                xfs_bmbt_irec_t prev;   /* old extent at offset idx */
@@ -612,17 +628,17 @@ xfs_bmap_add_extent(
                                                XFS_BTCUR_BPRV_WASDEL);
                                if ((error = xfs_bmap_add_extent_delay_real(ip,
                                        idx, &cur, new, &da_new, first, flist,
-                                        &logflags, rsvd)))
+                                        &logflags, delta, rsvd)))
                                        goto done;
                        } else if (new->br_state == XFS_EXT_NORM) {
                                ASSERT(new->br_state == XFS_EXT_NORM);
                                if ((error = xfs_bmap_add_extent_unwritten_real(
-                                        ip, idx, &cur, new, &logflags)))
+                                        ip, idx, &cur, new, &logflags, delta)))
                                        goto done;
                        } else {
                                ASSERT(new->br_state == XFS_EXT_UNWRITTEN);
                                if ((error = xfs_bmap_add_extent_unwritten_real(
-                                        ip, idx, &cur, new, &logflags)))
+                                        ip, idx, &cur, new, &logflags, delta)))
                                        goto done;
                        }
                        ASSERT(*curp == cur || *curp == NULL);
@@ -635,7 +651,7 @@ xfs_bmap_add_extent(
                                ASSERT((cur->bc_private.b.flags &
                                        XFS_BTCUR_BPRV_WASDEL) == 0);
                        if ((error = xfs_bmap_add_extent_hole_real(ip, idx, cur,
-                                        new, &logflags, whichfork)))
+                                        new, &logflags, delta, whichfork)))
                                goto done;
                }
        }
@@ -700,6 +716,7 @@ xfs_bmap_add_extent_delay_real(
        xfs_fsblock_t           *first, /* pointer to firstblock variable */
        xfs_bmap_free_t         *flist, /* list of extents to be freed */
        int                     *logflagsp, /* inode logging flags */
+        xfs_extdelta_t          *delta, /* Change made to incore extents */
        int                     rsvd)   /* OK to use reserved data block allocation */
 {
        xfs_btree_cur_t         *cur;   /* btree cursor */
@@ -716,8 +733,8 @@ xfs_bmap_add_extent_delay_real(
                                        /* left is 0, right is 1, prev is 2 */
        int                     rval=0; /* return value (logging flags) */
        int                     state = 0;/* state bits, accessed thru macros */
-        xfs_filblks_t           temp;   /* value for dnew calculations */
+        xfs_filblks_t           temp=0; /* value for dnew calculations */
-        xfs_filblks_t           temp2;  /* value for dnew calculations */
+        xfs_filblks_t           temp2=0;/* value for dnew calculations */
        int                     tmp_rval;       /* partial logging flags */
        enum {                          /* bit number definitions for state */
                LEFT_CONTIG,    RIGHT_CONTIG,
@@ -839,6 +856,11 @@ xfs_bmap_add_extent_delay_real(
                                goto done;
                }
                *dnew = 0;
+                /* DELTA: Three in-core extents are replaced by one. */
+                temp = LEFT.br_startoff;
+                temp2 = LEFT.br_blockcount +
+                        PREV.br_blockcount +
+                        RIGHT.br_blockcount;
                break;
        case MASK3(LEFT_FILLING, RIGHT_FILLING, LEFT_CONTIG):
@@ -872,6 +894,10 @@ xfs_bmap_add_extent_delay_real(
                                goto done;
                }
                *dnew = 0;
+                /* DELTA: Two in-core extents are replaced by one. */
+                temp = LEFT.br_startoff;
+                temp2 = LEFT.br_blockcount +
+                        PREV.br_blockcount;
                break;
        case MASK3(LEFT_FILLING, RIGHT_FILLING, RIGHT_CONTIG):
@@ -906,6 +932,10 @@ xfs_bmap_add_extent_delay_real(
                                goto done;
                }
                *dnew = 0;
+                /* DELTA: Two in-core extents are replaced by one. */
+                temp = PREV.br_startoff;
+                temp2 = PREV.br_blockcount +
+                        RIGHT.br_blockcount;
                break;
        case MASK2(LEFT_FILLING, RIGHT_FILLING):
@@ -936,6 +966,9 @@ xfs_bmap_add_extent_delay_real(
                        ASSERT(i == 1);
                }
                *dnew = 0;
+                /* DELTA: The in-core extent described by new changed type. */
+                temp = new->br_startoff;
+                temp2 = new->br_blockcount;
                break;
        case MASK2(LEFT_FILLING, LEFT_CONTIG):
@@ -978,6 +1011,10 @@ xfs_bmap_add_extent_delay_real(
                xfs_bmap_trace_post_update(fname, "LF|LC", ip, idx,
                        XFS_DATA_FORK);
                *dnew = temp;
+                /* DELTA: The boundary between two in-core extents moved. */
+                temp = LEFT.br_startoff;
+                temp2 = LEFT.br_blockcount +
+                        PREV.br_blockcount;
                break;
        case MASK(LEFT_FILLING):
@@ -1025,6 +1062,9 @@ xfs_bmap_add_extent_delay_real(
                xfs_bmap_trace_post_update(fname, "LF", ip, idx + 1,
                        XFS_DATA_FORK);
                *dnew = temp;
+                /* DELTA: One in-core extent is split in two. */
+                temp = PREV.br_startoff;
+                temp2 = PREV.br_blockcount;
                break;
        case MASK2(RIGHT_FILLING, RIGHT_CONTIG):
@@ -1067,6 +1107,10 @@ xfs_bmap_add_extent_delay_real(
                xfs_bmap_trace_post_update(fname, "RF|RC", ip, idx,
                        XFS_DATA_FORK);
                *dnew = temp;
+                /* DELTA: The boundary between two in-core extents moved. */
+                temp = PREV.br_startoff;
+                temp2 = PREV.br_blockcount +
+                        RIGHT.br_blockcount;
                break;
        case MASK(RIGHT_FILLING):
@@ -1112,6 +1156,9 @@ xfs_bmap_add_extent_delay_real(
                xfs_bmbt_set_startblock(ep, NULLSTARTBLOCK((int)temp));
                xfs_bmap_trace_post_update(fname, "RF", ip, idx, XFS_DATA_FORK);
                *dnew = temp;
+                /* DELTA: One in-core extent is split in two. */
+                temp = PREV.br_startoff;
+                temp2 = PREV.br_blockcount;
                break;
        case 0:
@@ -1194,6 +1241,9 @@ xfs_bmap_add_extent_delay_real(
                xfs_bmap_trace_post_update(fname, "0", ip, idx + 2,
                        XFS_DATA_FORK);
                *dnew = temp + temp2;
+                /* DELTA: One in-core extent is split in three. */
+                temp = PREV.br_startoff;
+                temp2 = PREV.br_blockcount;
                break;
        case MASK3(LEFT_FILLING, LEFT_CONTIG, RIGHT_CONTIG):
@@ -1209,6 +1259,13 @@ xfs_bmap_add_extent_delay_real(
                ASSERT(0);
        }
        *curp = cur;
+        if (delta) {
+                temp2 += temp;
+                if (delta->xed_startoff > temp)
+                        delta->xed_startoff = temp;
+                if (delta->xed_blockcount < temp2)
+                        delta->xed_blockcount = temp2;
+        }
 done:
        *logflagsp = rval;
        return error;
@@ -1235,7 +1292,8 @@ xfs_bmap_add_extent_unwritten_real(
        xfs_extnum_t            idx,    /* extent number to update/insert */
        xfs_btree_cur_t         **curp, /* if *curp is null, not a btree */
        xfs_bmbt_irec_t         *new,   /* new data to add to file extents */
-        int                     *logflagsp) /* inode logging flags */
+        int                     *logflagsp, /* inode logging flags */
+        xfs_extdelta_t          *delta) /* Change made to incore extents */
 {
        xfs_btree_cur_t         *cur;   /* btree cursor */
        xfs_bmbt_rec_t          *ep;    /* extent entry for idx */
@@ -1252,6 +1310,8 @@ xfs_bmap_add_extent_unwritten_real(
                                        /* left is 0, right is 1, prev is 2 */
        int                     rval=0; /* return value (logging flags) */
        int                     state = 0;/* state bits, accessed thru macros */
+        xfs_filblks_t           temp=0;
+        xfs_filblks_t           temp2=0;
        enum {                          /* bit number definitions for state */
                LEFT_CONTIG,    RIGHT_CONTIG,
                LEFT_FILLING,   RIGHT_FILLING,
@@ -1380,6 +1440,11 @@ xfs_bmap_add_extent_unwritten_real(
                                RIGHT.br_blockcount, LEFT.br_state)))
                                goto done;
                }
+                /* DELTA: Three in-core extents are replaced by one. */
+                temp = LEFT.br_startoff;
+                temp2 = LEFT.br_blockcount +
+                        PREV.br_blockcount +
+                        RIGHT.br_blockcount;
                break;
        case MASK3(LEFT_FILLING, RIGHT_FILLING, LEFT_CONTIG):
@@ -1419,6 +1484,10 @@ xfs_bmap_add_extent_unwritten_real(
                                LEFT.br_state)))
                                goto done;
                }
+                /* DELTA: Two in-core extents are replaced by one. */
+                temp = LEFT.br_startoff;
+                temp2 = LEFT.br_blockcount +
+                        PREV.br_blockcount;
                break;
        case MASK3(LEFT_FILLING, RIGHT_FILLING, RIGHT_CONTIG):
@@ -1459,6 +1528,10 @@ xfs_bmap_add_extent_unwritten_real(
                                newext)))
                                goto done;
                }
+                /* DELTA: Two in-core extents are replaced by one. */
+                temp = PREV.br_startoff;
+                temp2 = PREV.br_blockcount +
+                        RIGHT.br_blockcount;
                break;
        case MASK2(LEFT_FILLING, RIGHT_FILLING):
@@ -1487,6 +1560,9 @@ xfs_bmap_add_extent_unwritten_real(
                                newext)))
                                goto done;
                }
+                /* DELTA: The in-core extent described by new changed type. */
+                temp = new->br_startoff;
+                temp2 = new->br_blockcount;
                break;
        case MASK2(LEFT_FILLING, LEFT_CONTIG):
@@ -1534,6 +1610,10 @@ xfs_bmap_add_extent_unwritten_real(
                                LEFT.br_state))
                                goto done;
                }
+                /* DELTA: The boundary between two in-core extents moved. */
+                temp = LEFT.br_startoff;
+                temp2 = LEFT.br_blockcount +
+                        PREV.br_blockcount;
                break;
        case MASK(LEFT_FILLING):
@@ -1574,6 +1654,9 @@ xfs_bmap_add_extent_unwritten_real(
                                goto done;
                        ASSERT(i == 1);
                }
+                /* DELTA: One in-core extent is split in two. */
+                temp = PREV.br_startoff;
+                temp2 = PREV.br_blockcount;
                break;
        case MASK2(RIGHT_FILLING, RIGHT_CONTIG):
@@ -1617,6 +1700,10 @@ xfs_bmap_add_extent_unwritten_real(
                                newext)))
                                goto done;
                }
+                /* DELTA: The boundary between two in-core extents moved. */
+                temp = PREV.br_startoff;
+                temp2 = PREV.br_blockcount +
+                        RIGHT.br_blockcount;
                break;
        case MASK(RIGHT_FILLING):
@@ -1657,6 +1744,9 @@ xfs_bmap_add_extent_unwritten_real(
                                goto done;
                        ASSERT(i == 1);
                }
+                /* DELTA: One in-core extent is split in two. */
+                temp = PREV.br_startoff;
+                temp2 = PREV.br_blockcount;
                break;
        case 0:
@@ -1710,6 +1800,9 @@ xfs_bmap_add_extent_unwritten_real(
                                goto done;
                        ASSERT(i == 1);
                }
+                /* DELTA: One in-core extent is split in three. */
+                temp = PREV.br_startoff;
+                temp2 = PREV.br_blockcount;
                break;
        case MASK3(LEFT_FILLING, LEFT_CONTIG, RIGHT_CONTIG):
@@ -1725,6 +1818,13 @@ xfs_bmap_add_extent_unwritten_real(
                ASSERT(0);
        }
        *curp = cur;
+        if (delta) {
+                temp2 += temp;
+                if (delta->xed_startoff > temp)
+                        delta->xed_startoff = temp;
+                if (delta->xed_blockcount < temp2)
+                        delta->xed_blockcount = temp2;
+        }
 done:
        *logflagsp = rval;
        return error;
@@ -1753,6 +1853,7 @@ xfs_bmap_add_extent_hole_delay(
        xfs_btree_cur_t         *cur,   /* if null, not a btree */
        xfs_bmbt_irec_t         *new,   /* new data to add to file extents */
        int                     *logflagsp, /* inode logging flags */
+        xfs_extdelta_t          *delta, /* Change made to incore extents */
        int                     rsvd)           /* OK to allocate reserved blocks */
 {
        xfs_bmbt_rec_t          *ep;    /* extent record for idx */
@@ -1765,7 +1866,8 @@ xfs_bmap_add_extent_hole_delay(
        xfs_filblks_t           oldlen=0;       /* old indirect size */
        xfs_bmbt_irec_t         right;  /* right neighbor extent entry */
        int                     state;  /* state bits, accessed thru macros */
-        xfs_filblks_t           temp;   /* temp for indirect calculations */
+        xfs_filblks_t           temp=0; /* temp for indirect calculations */
+        xfs_filblks_t           temp2=0;
        enum {                          /* bit number definitions for state */
                LEFT_CONTIG,    RIGHT_CONTIG,
                LEFT_DELAY,     RIGHT_DELAY,
@@ -1844,6 +1946,9 @@ xfs_bmap_add_extent_hole_delay(
                        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. */
+                temp2 = temp;
+                temp = left.br_startoff;
                break;
        case MASK(LEFT_CONTIG):
@@ -1864,6 +1969,9 @@ xfs_bmap_add_extent_hole_delay(
                xfs_bmap_trace_post_update(fname, "LC", ip, idx - 1,
                        XFS_DATA_FORK);
                ip->i_df.if_lastex = idx - 1;
+                /* DELTA: One in-core extent grew into a hole. */
+                temp2 = temp;
+                temp = left.br_startoff;
                break;
        case MASK(RIGHT_CONTIG):
@@ -1881,6 +1989,9 @@ xfs_bmap_add_extent_hole_delay(
                        NULLSTARTBLOCK((int)newlen), temp, right.br_state);
                xfs_bmap_trace_post_update(fname, "RC", ip, idx, XFS_DATA_FORK);
                ip->i_df.if_lastex = idx;
+                /* DELTA: One in-core extent grew into a hole. */
+                temp2 = temp;
+                temp = new->br_startoff;
                break;
        case 0:
@@ -1894,6 +2005,9 @@ xfs_bmap_add_extent_hole_delay(
                        XFS_DATA_FORK);
                xfs_iext_insert(ifp, idx, 1, new);
                ip->i_df.if_lastex = idx;
+                /* DELTA: A new in-core extent was added in a hole. */
+                temp2 = new->br_blockcount;
+                temp = new->br_startoff;
                break;
        }
        if (oldlen != newlen) {
@@ -1904,6 +2018,13 @@ xfs_bmap_add_extent_hole_delay(
                 * Nothing to do for disk quota accounting here.
                 */
        }
+        if (delta) {
+                temp2 += temp;
+                if (delta->xed_startoff > temp)
+                        delta->xed_startoff = temp;
+                if (delta->xed_blockcount < temp2)
+                        delta->xed_blockcount = temp2;
+        }
        *logflagsp = 0;
        return 0;
 #undef  MASK
@@ -1925,6 +2046,7 @@ xfs_bmap_add_extent_hole_real(
        xfs_btree_cur_t         *cur,   /* if null, not a btree */
        xfs_bmbt_irec_t         *new,   /* new data to add to file extents */
        int                     *logflagsp, /* inode logging flags */
+        xfs_extdelta_t          *delta, /* Change made to incore extents */
        int                     whichfork) /* data or attr fork */
 {
        xfs_bmbt_rec_t          *ep;    /* pointer to extent entry ins. point */
@@ -1936,7 +2058,10 @@ xfs_bmap_add_extent_hole_real(
        xfs_ifork_t             *ifp;   /* inode fork pointer */
        xfs_bmbt_irec_t         left;   /* left neighbor extent entry */
        xfs_bmbt_irec_t         right;  /* right neighbor extent entry */
+        int                     rval=0; /* return value (logging flags) */
        int                     state;  /* state bits, accessed thru macros */
+        xfs_filblks_t           temp=0;
+        xfs_filblks_t           temp2=0;
        enum {                          /* bit number definitions for state */
                LEFT_CONTIG,    RIGHT_CONTIG,
                LEFT_DELAY,     RIGHT_DELAY,
@@ -1993,6 +2118,7 @@ xfs_bmap_add_extent_hole_real(
                 left.br_blockcount + new->br_blockcount +
                     right.br_blockcount <= MAXEXTLEN));
+        error = 0;
        /*
         * Select which case we're in here, and implement it.
         */
@@ -2018,25 +2144,35 @@ xfs_bmap_add_extent_hole_real(
                XFS_IFORK_NEXT_SET(ip, whichfork,
                        XFS_IFORK_NEXTENTS(ip, whichfork) - 1);
                if (cur == NULL) {
-                        *logflagsp = XFS_ILOG_CORE | XFS_ILOG_FEXT(whichfork);
+                        rval = XFS_ILOG_CORE | XFS_ILOG_FEXT(whichfork);
-                        return 0;
+                } else {
+                        rval = XFS_ILOG_CORE;
+                        if ((error = xfs_bmbt_lookup_eq(cur,
+                                        right.br_startoff,
+                                        right.br_startblock,
+                                        right.br_blockcount, &i)))
+                                goto done;
+                        ASSERT(i == 1);
+                        if ((error = xfs_bmbt_delete(cur, &i)))
+                                goto done;
+                        ASSERT(i == 1);
+                        if ((error = xfs_bmbt_decrement(cur, 0, &i)))
+                                goto done;
+                        ASSERT(i == 1);
+                        if ((error = xfs_bmbt_update(cur, left.br_startoff,
+                                        left.br_startblock,
+                                        left.br_blockcount +
+                                                new->br_blockcount +
+                                                right.br_blockcount,
+                                        left.br_state)))
+                                goto done;
                }
-                *logflagsp = XFS_ILOG_CORE;
+                /* DELTA: Two in-core extents were replaced by one. */
-                if ((error = xfs_bmbt_lookup_eq(cur, right.br_startoff,
+                temp = left.br_startoff;
-                                right.br_startblock, right.br_blockcount, &i)))
+                temp2 = left.br_blockcount +
-                        return error;
+                        new->br_blockcount +
-                ASSERT(i == 1);
+                        right.br_blockcount;
-                if ((error = xfs_bmbt_delete(cur, &i)))
+                break;
-                        return error;
-                ASSERT(i == 1);
-                if ((error = xfs_bmbt_decrement(cur, 0, &i)))
-                        return error;
-                ASSERT(i == 1);
-                error = xfs_bmbt_update(cur, left.br_startoff,
-                                left.br_startblock,
-                                left.br_blockcount + new->br_blockcount +
-                                right.br_blockcount, left.br_state);
-                return error;
        case MASK(LEFT_CONTIG):
                /*
@@ -2050,19 +2186,27 @@ xfs_bmap_add_extent_hole_real(
                xfs_bmap_trace_post_update(fname, "LC", ip, idx - 1, whichfork);
                ifp->if_lastex = idx - 1;
                if (cur == NULL) {
-                        *logflagsp = XFS_ILOG_FEXT(whichfork);
+                        rval = XFS_ILOG_FEXT(whichfork);
-                        return 0;
+                } else {
+                        rval = 0;
+                        if ((error = xfs_bmbt_lookup_eq(cur,
+                                        left.br_startoff,
+                                        left.br_startblock,
+                                        left.br_blockcount, &i)))
+                                goto done;
+                        ASSERT(i == 1);
+                        if ((error = xfs_bmbt_update(cur, left.br_startoff,
+                                        left.br_startblock,
+                                        left.br_blockcount +
+                                                new->br_blockcount,
+                                        left.br_state)))
+                                goto done;
                }
-                *logflagsp = 0;
+                /* DELTA: One in-core extent grew. */
-                if ((error = xfs_bmbt_lookup_eq(cur, left.br_startoff,
+                temp = left.br_startoff;
-                                left.br_startblock, left.br_blockcount, &i)))
+                temp2 = left.br_blockcount +
-                        return error;
+                        new->br_blockcount;
-                ASSERT(i == 1);
+                break;
-                error = xfs_bmbt_update(cur, left.br_startoff,
-                                left.br_startblock,
-                                left.br_blockcount + new->br_blockcount,
-                                left.br_state);
-                return error;
        case MASK(RIGHT_CONTIG):
                /*
@@ -2077,19 +2221,27 @@ xfs_bmap_add_extent_hole_real(
                xfs_bmap_trace_post_update(fname, "RC", ip, idx, whichfork);
                ifp->if_lastex = idx;
                if (cur == NULL) {
-                        *logflagsp = XFS_ILOG_FEXT(whichfork);
+                        rval = XFS_ILOG_FEXT(whichfork);
-                        return 0;
+                } else {
+                        rval = 0;
+                        if ((error = xfs_bmbt_lookup_eq(cur,
+                                        right.br_startoff,
+                                        right.br_startblock,
+                                        right.br_blockcount, &i)))
+                                goto done;
+                        ASSERT(i == 1);
+                        if ((error = xfs_bmbt_update(cur, new->br_startoff,
+                                        new->br_startblock,
+                                        new->br_blockcount +
+                                                right.br_blockcount,
+                                        right.br_state)))
+                                goto done;
                }
-                *logflagsp = 0;
+                /* DELTA: One in-core extent grew. */
-                if ((error = xfs_bmbt_lookup_eq(cur, right.br_startoff,
+                temp = new->br_startoff;
-                                right.br_startblock, right.br_blockcount, &i)))
+                temp2 = new->br_blockcount +
-                        return error;
+                        right.br_blockcount;
-                ASSERT(i == 1);
+                break;
-                error = xfs_bmbt_update(cur, new->br_startoff,
-                                new->br_startblock,
-                                new->br_blockcount + right.br_blockcount,
-                                right.br_state);
-                return error;
        case 0:
                /*
@@ -2104,29 +2256,41 @@ xfs_bmap_add_extent_hole_real(
                XFS_IFORK_NEXT_SET(ip, whichfork,
                        XFS_IFORK_NEXTENTS(ip, whichfork) + 1);
                if (cur == NULL) {
-                        *logflagsp = XFS_ILOG_CORE | XFS_ILOG_FEXT(whichfork);
+                        rval = XFS_ILOG_CORE | XFS_ILOG_FEXT(whichfork);
-                        return 0;
+                } else {
+                        rval = XFS_ILOG_CORE;
+                        if ((error = xfs_bmbt_lookup_eq(cur,
+                                        new->br_startoff,
+                                        new->br_startblock,
+                                        new->br_blockcount, &i)))
+                                goto done;
+                        ASSERT(i == 0);
+                        cur->bc_rec.b.br_state = new->br_state;
+                        if ((error = xfs_bmbt_insert(cur, &i)))
+                                goto done;
+                        ASSERT(i == 1);
                }
-                *logflagsp = XFS_ILOG_CORE;
+                /* DELTA: A new extent was added in a hole. */
-                if ((error = xfs_bmbt_lookup_eq(cur, new->br_startoff,
+                temp = new->br_startoff;
-                                new->br_startblock, new->br_blockcount, &i)))
+                temp2 = new->br_blockcount;
-                        return error;
+                break;
-                ASSERT(i == 0);
+        }
-                cur->bc_rec.b.br_state = new->br_state;
+        if (delta) {
-                if ((error = xfs_bmbt_insert(cur, &i)))
+                temp2 += temp;
-                        return error;
+                if (delta->xed_startoff > temp)
-                ASSERT(i == 1);
+                        delta->xed_startoff = temp;
-                return 0;
+                if (delta->xed_blockcount < temp2)
+                        delta->xed_blockcount = temp2;
        }
+done:
+        *logflagsp = rval;
+        return error;
 #undef  MASK
 #undef  MASK2
 #undef  STATE_SET
 #undef  STATE_TEST
 #undef  STATE_SET_TEST
 #undef  SWITCH_STATE
-        /* NOTREACHED */
-        ASSERT(0);
-        return 0; /* keep gcc quite */
 }
 /*
@@ -2598,6 +2762,7 @@ xfs_bmap_btalloc(
        args.mp = mp;
        args.fsbno = ap->rval;
        args.maxlen = MIN(ap->alen, mp->m_sb.sb_agblocks);
+        args.firstblock = ap->firstblock;
        blen = 0;
        if (nullfb) {
                args.type = XFS_ALLOCTYPE_START_BNO;
@@ -2657,7 +2822,7 @@ xfs_bmap_btalloc(
                else
                        args.minlen = ap->alen;
        } else if (ap->low) {
-                args.type = XFS_ALLOCTYPE_FIRST_AG;
+                args.type = XFS_ALLOCTYPE_START_BNO;
                args.total = args.minlen = ap->minlen;
        } else {
                args.type = XFS_ALLOCTYPE_NEAR_BNO;
@@ -2669,7 +2834,7 @@ xfs_bmap_btalloc(
                args.prod = ap->ip->i_d.di_extsize;
                if ((args.mod = (xfs_extlen_t)do_mod(ap->off, args.prod)))
                        args.mod = (xfs_extlen_t)(args.prod - args.mod);
-        } else if (unlikely(mp->m_sb.sb_blocksize >= NBPP)) {
+        } else if (mp->m_sb.sb_blocksize >= NBPP) {
                args.prod = 1;
                args.mod = 0;
        } else {
@@ -2885,6 +3050,7 @@ xfs_bmap_del_extent(
        xfs_btree_cur_t         *cur,   /* if null, not a btree */
        xfs_bmbt_irec_t         *del,   /* data to remove from extents */
        int                     *logflagsp, /* inode logging flags */
+        xfs_extdelta_t          *delta, /* Change made to incore extents */
        int                     whichfork, /* data or attr fork */
        int                     rsvd)   /* OK to allocate reserved blocks */
 {
@@ -3193,6 +3359,14 @@ xfs_bmap_del_extent(
        if (da_old > da_new)
                xfs_mod_incore_sb(mp, XFS_SBS_FDBLOCKS, (int)(da_old - da_new),
                        rsvd);
+        if (delta) {
+                /* DELTA: report the original extent. */
+                if (delta->xed_startoff > got.br_startoff)
+                        delta->xed_startoff = got.br_startoff;
+                if (delta->xed_blockcount < got.br_startoff+got.br_blockcount)
+                        delta->xed_blockcount = got.br_startoff +
+                                                        got.br_blockcount;
+        }
 done:
        *logflagsp = flags;
        return error;
@@ -3279,6 +3453,7 @@ xfs_bmap_extents_to_btree(
        XFS_IFORK_FMT_SET(ip, whichfork, XFS_DINODE_FMT_BTREE);
        args.tp = tp;
        args.mp = mp;
+        args.firstblock = *firstblock;
        if (*firstblock == NULLFSBLOCK) {
                args.type = XFS_ALLOCTYPE_START_BNO;
                args.fsbno = XFS_INO_TO_FSB(mp, ip->i_ino);
@@ -3414,6 +3589,7 @@ xfs_bmap_local_to_extents(
                args.tp = tp;
                args.mp = ip->i_mount;
+                args.firstblock = *firstblock;
                ASSERT((ifp->if_flags &
                        (XFS_IFINLINE|XFS_IFEXTENTS|XFS_IFEXTIREC)) == XFS_IFINLINE);
                /*
@@ -3753,7 +3929,7 @@ xfs_bunmap_trace(
        if (ip->i_rwtrace == NULL)
                return;
        ktrace_enter(ip->i_rwtrace,
-                (void *)(__psint_t)XFS_BUNMAPI,
+                (void *)(__psint_t)XFS_BUNMAP,
                (void *)ip,
                (void *)(__psint_t)((ip->i_d.di_size >> 32) & 0xffffffff),
                (void *)(__psint_t)(ip->i_d.di_size & 0xffffffff),
@@ -4087,8 +4263,8 @@ xfs_bmap_finish(
                        if (!XFS_FORCED_SHUTDOWN(mp))
                                xfs_force_shutdown(mp,
                                                   (error == EFSCORRUPTED) ?
-                                                   XFS_CORRUPT_INCORE :
+                                                   SHUTDOWN_CORRUPT_INCORE :
-                                                   XFS_METADATA_IO_ERROR);
+                                                   SHUTDOWN_META_IO_ERROR);
                        return error;
                }
                xfs_trans_log_efd_extent(ntp, efd, free->xbfi_startblock,
@@ -4538,7 +4714,8 @@ xfs_bmapi(
        xfs_extlen_t    total,          /* total blocks needed */
        xfs_bmbt_irec_t *mval,          /* output: map values */
        int             *nmap,          /* i/o: mval size/count */
-        xfs_bmap_free_t *flist)         /* i/o: list extents to free */
+        xfs_bmap_free_t *flist,         /* i/o: list extents to free */
+        xfs_extdelta_t  *delta)         /* o: change made to incore extents */
 {
        xfs_fsblock_t   abno;           /* allocated block number */
        xfs_extlen_t    alen;           /* allocated extent length */
@@ -4650,6 +4827,10 @@ xfs_bmapi(
        end = bno + len;
        obno = bno;
        bma.ip = NULL;
+        if (delta) {
+                delta->xed_startoff = NULLFILEOFF;
+                delta->xed_blockcount = 0;
+        }
        while (bno < end && n < *nmap) {
                /*
                 * Reading past eof, act as though there's a hole
@@ -4886,8 +5067,8 @@ xfs_bmapi(
                                        got.br_state = XFS_EXT_UNWRITTEN;
                        }
                        error = xfs_bmap_add_extent(ip, lastx, &cur, &got,
-                                firstblock, flist, &tmp_logflags, whichfork,
+                                firstblock, flist, &tmp_logflags, delta,
-                                (flags & XFS_BMAPI_RSVBLOCKS));
+                                whichfork, (flags & XFS_BMAPI_RSVBLOCKS));
                        logflags |= tmp_logflags;
                        if (error)
                                goto error0;
@@ -4983,8 +5164,8 @@ xfs_bmapi(
                        }
                        mval->br_state = XFS_EXT_NORM;
                        error = xfs_bmap_add_extent(ip, lastx, &cur, mval,
-                                firstblock, flist, &tmp_logflags, whichfork,
+                                firstblock, flist, &tmp_logflags, delta,
-                                (flags & XFS_BMAPI_RSVBLOCKS));
+                                whichfork, (flags & XFS_BMAPI_RSVBLOCKS));
                        logflags |= tmp_logflags;
                        if (error)
                                goto error0;
@@ -5073,7 +5254,14 @@ xfs_bmapi(
        ASSERT(XFS_IFORK_FORMAT(ip, whichfork) != XFS_DINODE_FMT_BTREE ||
               XFS_IFORK_NEXTENTS(ip, whichfork) > ifp->if_ext_max);
        error = 0;
+        if (delta && delta->xed_startoff != NULLFILEOFF) {
+                /* A change was actually made.
+                 * Note that delta->xed_blockount is an offset at this
+                 * point and needs to be converted to a block count.
+                 */
+                ASSERT(delta->xed_blockcount > delta->xed_startoff);
+                delta->xed_blockcount -= delta->xed_startoff;
+        }
 error0:
        /*
         * Log everything.  Do this after conversion, there's no point in
@@ -5185,6 +5373,8 @@ xfs_bunmapi(
        xfs_fsblock_t           *firstblock,    /* first allocated block
                                                   controls a.g. for allocs */
        xfs_bmap_free_t         *flist,         /* i/o: list extents to free */
+        xfs_extdelta_t          *delta,         /* o: change made to incore
+                                                   extents */
        int                     *done)          /* set if not done yet */
 {
        xfs_btree_cur_t         *cur;           /* bmap btree cursor */
@@ -5242,6 +5432,10 @@ xfs_bunmapi(
        bno = start + len - 1;
        ep = xfs_bmap_search_extents(ip, bno, whichfork, &eof, &lastx, &got,
                &prev);
+        if (delta) {
+                delta->xed_startoff = NULLFILEOFF;
+                delta->xed_blockcount = 0;
+        }
        /*
         * Check to see if the given block number is past the end of the
         * file, back up to the last block if so...
@@ -5340,7 +5534,8 @@ xfs_bunmapi(
                        }
                        del.br_state = XFS_EXT_UNWRITTEN;
                        error = xfs_bmap_add_extent(ip, lastx, &cur, &del,
-                                firstblock, flist, &logflags, XFS_DATA_FORK, 0);
+                                firstblock, flist, &logflags, delta,
+                                XFS_DATA_FORK, 0);
                        if (error)
                                goto error0;
                        goto nodelete;
@@ -5394,7 +5589,7 @@ xfs_bunmapi(
                                prev.br_state = XFS_EXT_UNWRITTEN;
                                error = xfs_bmap_add_extent(ip, lastx - 1, &cur,
                                        &prev, firstblock, flist, &logflags,
-                                        XFS_DATA_FORK, 0);
+                                        delta, XFS_DATA_FORK, 0);
                                if (error)
                                        goto error0;
                                goto nodelete;
@@ -5403,7 +5598,7 @@ xfs_bunmapi(
                                del.br_state = XFS_EXT_UNWRITTEN;
                                error = xfs_bmap_add_extent(ip, lastx, &cur,
                                        &del, firstblock, flist, &logflags,
-                                        XFS_DATA_FORK, 0);
+                                        delta, XFS_DATA_FORK, 0);
                                if (error)
                                        goto error0;
                                goto nodelete;
@@ -5456,7 +5651,7 @@ xfs_bunmapi(
                        goto error0;
                }
                error = xfs_bmap_del_extent(ip, tp, lastx, flist, cur, &del,
-                        &tmp_logflags, whichfork, rsvd);
+                                &tmp_logflags, delta, whichfork, rsvd);
                logflags |= tmp_logflags;
                if (error)
                        goto error0;
@@ -5513,6 +5708,14 @@ nodelete:
        ASSERT(ifp->if_ext_max ==
               XFS_IFORK_SIZE(ip, whichfork) / (uint)sizeof(xfs_bmbt_rec_t));
        error = 0;
+        if (delta && delta->xed_startoff != NULLFILEOFF) {
+                /* A change was actually made.
+                 * Note that delta->xed_blockount is an offset at this
+                 * point and needs to be converted to a block count.
+                 */
+                ASSERT(delta->xed_blockcount > delta->xed_startoff);
+                delta->xed_blockcount -= delta->xed_startoff;
+        }
 error0:
        /*
         * Log everything.  Do this after conversion, there's no point in
@@ -5556,7 +5759,7 @@ xfs_getbmap(
        __int64_t               fixlen;         /* length for -1 case */
        int                     i;              /* extent number */
        xfs_inode_t             *ip;            /* xfs incore inode pointer */
-        vnode_t                 *vp;            /* corresponding vnode */
+        bhv_vnode_t             *vp;            /* corresponding vnode */
        int                     lock;           /* lock state */
        xfs_bmbt_irec_t         *map;           /* buffer for user's data */
        xfs_mount_t             *mp;            /* file system mount point */
@@ -5653,7 +5856,7 @@ xfs_getbmap(
        if (whichfork == XFS_DATA_FORK && ip->i_delayed_blks) {
                /* xfs_fsize_t last_byte = xfs_file_last_byte(ip); */
-                VOP_FLUSH_PAGES(vp, (xfs_off_t)0, -1, 0, FI_REMAPF, error);
+                error = bhv_vop_flush_pages(vp, (xfs_off_t)0, -1, 0, FI_REMAPF);
        }
        ASSERT(whichfork == XFS_ATTR_FORK || ip->i_delayed_blks == 0);
@@ -5689,7 +5892,8 @@ xfs_getbmap(
                nmap = (nexleft > subnex) ? subnex : nexleft;
                error = xfs_bmapi(NULL, ip, XFS_BB_TO_FSBT(mp, bmv->bmv_offset),
                                  XFS_BB_TO_FSB(mp, bmv->bmv_length),
-                                  bmapi_flags, NULL, 0, map, &nmap, NULL);
+                                  bmapi_flags, NULL, 0, map, &nmap,
+                                  NULL, NULL);
                if (error)
                        goto unlock_and_return;
                ASSERT(nmap <= subnex);
diff --git a/fs/xfs/xfs_bmap.h b/fs/xfs/xfs_bmap.h
index 8e0d73d9ccc4..80e93409b78d 100644
--- a/fs/xfs/xfs_bmap.h
+++ b/fs/xfs/xfs_bmap.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
@@ -26,6 +26,20 @@ struct xfs_mount;
 struct xfs_trans;
 /*
+ * DELTA: describe a change to the in-core extent list.
+ *
+ * Internally the use of xed_blockount is somewhat funky.
+ * xed_blockcount contains an offset much of the time because this
+ * makes merging changes easier.  (xfs_fileoff_t and xfs_filblks_t are
+ * the same underlying type).
+ */
+typedef struct xfs_extdelta
+{
+        xfs_fileoff_t           xed_startoff;   /* offset of range */
+        xfs_filblks_t           xed_blockcount; /* blocks in range */
+} xfs_extdelta_t;
+/*
 * List of extents to be free "later".
 * The list is kept sorted on xbf_startblock.
 */
@@ -275,7 +289,9 @@ xfs_bmapi(
        xfs_extlen_t            total,          /* total blocks needed */
        struct xfs_bmbt_irec    *mval,          /* output: map values */
        int                     *nmap,          /* i/o: mval size/count */
-        xfs_bmap_free_t         *flist);        /* i/o: list extents to free */
+        xfs_bmap_free_t         *flist,         /* i/o: list extents to free */
+        xfs_extdelta_t          *delta);        /* o: change made to incore
+                                                   extents */
 /*
 * Map file blocks to filesystem blocks, simple version.
@@ -309,6 +325,8 @@ xfs_bunmapi(
        xfs_fsblock_t           *firstblock,    /* first allocated block
                                                   controls a.g. for allocs */
        xfs_bmap_free_t         *flist,         /* i/o: list extents to free */
+        xfs_extdelta_t          *delta,         /* o: change made to incore
+                                                   extents */
        int                     *done);         /* set if not done yet */
 /*
diff --git a/fs/xfs/xfs_bmap_btree.c b/fs/xfs/xfs_bmap_btree.c
index bea44709afbe..18fb7385d719 100644
--- a/fs/xfs/xfs_bmap_btree.c
+++ b/fs/xfs/xfs_bmap_btree.c
@@ -24,14 +24,12 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -1569,12 +1567,11 @@ xfs_bmbt_split(
        lbno = XFS_DADDR_TO_FSB(args.mp, XFS_BUF_ADDR(lbp));
        left = XFS_BUF_TO_BMBT_BLOCK(lbp);
        args.fsbno = cur->bc_private.b.firstblock;
+        args.firstblock = args.fsbno;
        if (args.fsbno == NULLFSBLOCK) {
                args.fsbno = lbno;
                args.type = XFS_ALLOCTYPE_START_BNO;
-        } else if (cur->bc_private.b.flist->xbf_low)
+        } else
-                args.type = XFS_ALLOCTYPE_FIRST_AG;
-        else
                args.type = XFS_ALLOCTYPE_NEAR_BNO;
        args.mod = args.minleft = args.alignment = args.total = args.isfl =
                args.userdata = args.minalignslop = 0;
@@ -2356,6 +2353,7 @@ xfs_bmbt_newroot(
                args.userdata = args.minalignslop = 0;
        args.minlen = args.maxlen = args.prod = 1;
        args.wasdel = cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL;
+        args.firstblock = args.fsbno;
        if (args.fsbno == NULLFSBLOCK) {
 #ifdef DEBUG
                if ((error = xfs_btree_check_lptr(cur, INT_GET(*pp, ARCH_CONVERT), level))) {
@@ -2365,9 +2363,7 @@ xfs_bmbt_newroot(
 #endif
                args.fsbno = INT_GET(*pp, ARCH_CONVERT);
                args.type = XFS_ALLOCTYPE_START_BNO;
-        } else if (args.wasdel)
+        } else
-                args.type = XFS_ALLOCTYPE_FIRST_AG;
-        else
                args.type = XFS_ALLOCTYPE_NEAR_BNO;
        if ((error = xfs_alloc_vextent(&args))) {
                XFS_BMBT_TRACE_CURSOR(cur, ERROR);
diff --git a/fs/xfs/xfs_btree.c b/fs/xfs/xfs_btree.c
index 52d5d095fc35..ee2255bd6562 100644
--- a/fs/xfs/xfs_btree.c
+++ b/fs/xfs/xfs_btree.c
@@ -24,14 +24,12 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c
index 5fed15682dda..a4aa53974f76 100644
--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -23,7 +23,6 @@
 #include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
-#include "xfs_dir.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_buf_item.h"
@@ -1030,9 +1029,9 @@ xfs_buf_iodone_callbacks(
                if ((XFS_BUF_TARGET(bp) != lasttarg) ||
                    (time_after(jiffies, (lasttime + 5*HZ)))) {
                        lasttime = jiffies;
-                        prdev("XFS write error in file system meta-data "
+                        cmn_err(CE_ALERT, "Device %s, XFS metadata write error"
-                              "block 0x%llx in %s",
+                                        " block 0x%llx in %s",
-                              XFS_BUF_TARGET(bp),
+                                XFS_BUFTARG_NAME(XFS_BUF_TARGET(bp)),
                              (__uint64_t)XFS_BUF_ADDR(bp), mp->m_fsname);
                }
                lasttarg = XFS_BUF_TARGET(bp);
@@ -1108,7 +1107,7 @@ xfs_buf_error_relse(
        XFS_BUF_ERROR(bp,0);
        xfs_buftrace("BUF_ERROR_RELSE", bp);
        if (! XFS_FORCED_SHUTDOWN(mp))
-                xfs_force_shutdown(mp, XFS_METADATA_IO_ERROR);
+                xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
        /*
         * We have to unpin the pinned buffers so do the
         * callbacks.
diff --git a/fs/xfs/xfs_cap.h b/fs/xfs/xfs_cap.h
index d0035c6e9514..7a0e482dd436 100644
--- a/fs/xfs/xfs_cap.h
+++ b/fs/xfs/xfs_cap.h
@@ -49,12 +49,12 @@ typedef struct xfs_cap_set {
 #include <linux/posix_cap_xattr.h>
-struct vnode;
+struct bhv_vnode;
-extern int xfs_cap_vhascap(struct vnode *);
+extern int xfs_cap_vhascap(struct bhv_vnode *);
-extern int xfs_cap_vset(struct vnode *, void *, size_t);
+extern int xfs_cap_vset(struct bhv_vnode *, void *, size_t);
-extern int xfs_cap_vget(struct vnode *, void *, size_t);
+extern int xfs_cap_vget(struct bhv_vnode *, void *, size_t);
-extern int xfs_cap_vremove(struct vnode *vp);
+extern int xfs_cap_vremove(struct bhv_vnode *);
 #define _CAP_EXISTS             xfs_cap_vhascap
diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c
index 8988b9051175..32ab61d17ace 100644
--- a/fs/xfs/xfs_da_btree.c
+++ b/fs/xfs/xfs_da_btree.c
@@ -24,7 +24,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
@@ -32,7 +31,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -43,7 +41,6 @@
 #include "xfs_bmap.h"
 #include "xfs_attr.h"
 #include "xfs_attr_leaf.h"
-#include "xfs_dir_leaf.h"
 #include "xfs_dir2_data.h"
 #include "xfs_dir2_leaf.h"
 #include "xfs_dir2_block.h"
@@ -159,7 +156,7 @@ xfs_da_split(xfs_da_state_t *state)
        max = state->path.active - 1;
        ASSERT((max >= 0) && (max < XFS_DA_NODE_MAXDEPTH));
        ASSERT(state->path.blk[max].magic == XFS_ATTR_LEAF_MAGIC ||
-               state->path.blk[max].magic == XFS_DIRX_LEAF_MAGIC(state->mp));
+               state->path.blk[max].magic == XFS_DIR2_LEAFN_MAGIC);
        addblk = &state->path.blk[max];         /* initial dummy value */
        for (i = max; (i >= 0) && addblk; state->path.active--, i--) {
@@ -199,38 +196,7 @@ xfs_da_split(xfs_da_state_t *state)
                                return(error);  /* GROT: attr inconsistent */
                        addblk = newblk;
                        break;
-                case XFS_DIR_LEAF_MAGIC:
-                        ASSERT(XFS_DIR_IS_V1(state->mp));
-                        error = xfs_dir_leaf_split(state, oldblk, newblk);
-                        if ((error != 0) && (error != ENOSPC)) {
-                                return(error);  /* GROT: dir is inconsistent */
-                        }
-                        if (!error) {
-                                addblk = newblk;
-                                break;
-                        }
-                        /*
-                         * Entry wouldn't fit, split the leaf again.
-                         */
-                        state->extravalid = 1;
-                        if (state->inleaf) {
-                                state->extraafter = 0;  /* before newblk */
-                                error = xfs_dir_leaf_split(state, oldblk,
-                                                           &state->extrablk);
-                                if (error)
-                                        return(error);  /* GROT: dir incon. */
-                                addblk = newblk;
-                        } else {
-                                state->extraafter = 1;  /* after newblk */
-                                error = xfs_dir_leaf_split(state, newblk,
-                                                           &state->extrablk);
-                                if (error)
-                                        return(error);  /* GROT: dir incon. */
-                                addblk = newblk;
-                        }
-                        break;
                case XFS_DIR2_LEAFN_MAGIC:
-                        ASSERT(XFS_DIR_IS_V2(state->mp));
                        error = xfs_dir2_leafn_split(state, oldblk, newblk);
                        if (error)
                                return error;
@@ -363,7 +329,6 @@ xfs_da_root_split(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
                size = (int)((char *)&oldroot->btree[be16_to_cpu(oldroot->hdr.count)] -
                             (char *)oldroot);
        } else {
-                ASSERT(XFS_DIR_IS_V2(mp));
                ASSERT(be16_to_cpu(oldroot->hdr.info.magic) == XFS_DIR2_LEAFN_MAGIC);
                leaf = (xfs_dir2_leaf_t *)oldroot;
                size = (int)((char *)&leaf->ents[be16_to_cpu(leaf->hdr.count)] -
@@ -379,8 +344,7 @@ xfs_da_root_split(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
         * Set up the new root node.
         */
        error = xfs_da_node_create(args,
-                args->whichfork == XFS_DATA_FORK &&
+                (args->whichfork == XFS_DATA_FORK) ? mp->m_dirleafblk : 0,
-                XFS_DIR_IS_V2(mp) ? mp->m_dirleafblk : 0,
                be16_to_cpu(node->hdr.level) + 1, &bp, args->whichfork);
        if (error)
                return(error);
@@ -427,10 +391,9 @@ xfs_da_node_split(xfs_da_state_t *state, xfs_da_state_blk_t *oldblk,
        ASSERT(be16_to_cpu(node->hdr.info.magic) == XFS_DA_NODE_MAGIC);
        /*
-         * With V2 the extra block is data or freespace.
+         * With V2 dirs the extra block is data or freespace.
         */
-        useextra = state->extravalid && (XFS_DIR_IS_V1(state->mp) ||
+        useextra = state->extravalid && state->args->whichfork == XFS_ATTR_FORK;
-                        state->args->whichfork == XFS_ATTR_FORK);
        newcount = 1 + useextra;
        /*
         * Do we have to split the node?
@@ -624,7 +587,7 @@ xfs_da_node_add(xfs_da_state_t *state, xfs_da_state_blk_t *oldblk,
        ASSERT(be16_to_cpu(node->hdr.info.magic) == XFS_DA_NODE_MAGIC);
        ASSERT((oldblk->index >= 0) && (oldblk->index <= be16_to_cpu(node->hdr.count)));
        ASSERT(newblk->blkno != 0);
-        if (state->args->whichfork == XFS_DATA_FORK && XFS_DIR_IS_V2(mp))
+        if (state->args->whichfork == XFS_DATA_FORK)
                ASSERT(newblk->blkno >= mp->m_dirleafblk &&
                       newblk->blkno < mp->m_dirfreeblk);
@@ -670,7 +633,7 @@ xfs_da_join(xfs_da_state_t *state)
        save_blk = &state->altpath.blk[ state->path.active-1 ];
        ASSERT(state->path.blk[0].magic == XFS_DA_NODE_MAGIC);
        ASSERT(drop_blk->magic == XFS_ATTR_LEAF_MAGIC ||
-               drop_blk->magic == XFS_DIRX_LEAF_MAGIC(state->mp));
+               drop_blk->magic == XFS_DIR2_LEAFN_MAGIC);
        /*
         * Walk back up the tree joining/deallocating as necessary.
@@ -693,17 +656,7 @@ xfs_da_join(xfs_da_state_t *state)
                                return(0);
                        xfs_attr_leaf_unbalance(state, drop_blk, save_blk);
                        break;
-                case XFS_DIR_LEAF_MAGIC:
-                        ASSERT(XFS_DIR_IS_V1(state->mp));
-                        error = xfs_dir_leaf_toosmall(state, &action);
-                        if (error)
-                                return(error);
-                        if (action == 0)
-                                return(0);
-                        xfs_dir_leaf_unbalance(state, drop_blk, save_blk);
-                        break;
                case XFS_DIR2_LEAFN_MAGIC:
-                        ASSERT(XFS_DIR_IS_V2(state->mp));
                        error = xfs_dir2_leafn_toosmall(state, &action);
                        if (error)
                                return error;
@@ -790,7 +743,7 @@ xfs_da_root_join(xfs_da_state_t *state, xfs_da_state_blk_t *root_blk)
        ASSERT(bp != NULL);
        blkinfo = bp->data;
        if (be16_to_cpu(oldroot->hdr.level) == 1) {
-                ASSERT(be16_to_cpu(blkinfo->magic) == XFS_DIRX_LEAF_MAGIC(state->mp) ||
+                ASSERT(be16_to_cpu(blkinfo->magic) == XFS_DIR2_LEAFN_MAGIC ||
                       be16_to_cpu(blkinfo->magic) == XFS_ATTR_LEAF_MAGIC);
        } else {
                ASSERT(be16_to_cpu(blkinfo->magic) == XFS_DA_NODE_MAGIC);
@@ -951,14 +904,7 @@ xfs_da_fixhashpath(xfs_da_state_t *state, xfs_da_state_path_t *path)
                if (count == 0)
                        return;
                break;
-        case XFS_DIR_LEAF_MAGIC:
-                ASSERT(XFS_DIR_IS_V1(state->mp));
-                lasthash = xfs_dir_leaf_lasthash(blk->bp, &count);
-                if (count == 0)
-                        return;
-                break;
        case XFS_DIR2_LEAFN_MAGIC:
-                ASSERT(XFS_DIR_IS_V2(state->mp));
                lasthash = xfs_dir2_leafn_lasthash(blk->bp, &count);
                if (count == 0)
                        return;
@@ -1117,10 +1063,7 @@ xfs_da_node_lookup_int(xfs_da_state_t *state, int *result)
         * Descend thru the B-tree searching each level for the right
         * node to use, until the right hashval is found.
         */
-        if (args->whichfork == XFS_DATA_FORK && XFS_DIR_IS_V2(state->mp))
+        blkno = (args->whichfork == XFS_DATA_FORK)? state->mp->m_dirleafblk : 0;
-                blkno = state->mp->m_dirleafblk;
-        else
-                blkno = 0;
        for (blk = &state->path.blk[0], state->path.active = 1;
                         state->path.active <= XFS_DA_NODE_MAXDEPTH;
                         blk++, state->path.active++) {
@@ -1137,7 +1080,7 @@ xfs_da_node_lookup_int(xfs_da_state_t *state, int *result)
                }
                curr = blk->bp->data;
                ASSERT(be16_to_cpu(curr->magic) == XFS_DA_NODE_MAGIC ||
-                       be16_to_cpu(curr->magic) == XFS_DIRX_LEAF_MAGIC(state->mp) ||
+                       be16_to_cpu(curr->magic) == XFS_DIR2_LEAFN_MAGIC ||
                       be16_to_cpu(curr->magic) == XFS_ATTR_LEAF_MAGIC);
                /*
@@ -1190,16 +1133,10 @@ xfs_da_node_lookup_int(xfs_da_state_t *state, int *result)
                                blk->index = probe;
                                blkno = be32_to_cpu(btree->before);
                        }
-                }
+                } else if (be16_to_cpu(curr->magic) == XFS_ATTR_LEAF_MAGIC) {
-                else if (be16_to_cpu(curr->magic) == XFS_ATTR_LEAF_MAGIC) {
                        blk->hashval = xfs_attr_leaf_lasthash(blk->bp, NULL);
                        break;
-                }
+                } else if (be16_to_cpu(curr->magic) == XFS_DIR2_LEAFN_MAGIC) {
-                else if (be16_to_cpu(curr->magic) == XFS_DIR_LEAF_MAGIC) {
-                        blk->hashval = xfs_dir_leaf_lasthash(blk->bp, NULL);
-                        break;
-                }
-                else if (be16_to_cpu(curr->magic) == XFS_DIR2_LEAFN_MAGIC) {
                        blk->hashval = xfs_dir2_leafn_lasthash(blk->bp, NULL);
                        break;
                }
@@ -1212,12 +1149,7 @@ xfs_da_node_lookup_int(xfs_da_state_t *state, int *result)
         * next leaf and keep searching.
         */
        for (;;) {
-                if (blk->magic == XFS_DIR_LEAF_MAGIC) {
+                if (blk->magic == XFS_DIR2_LEAFN_MAGIC) {
-                        ASSERT(XFS_DIR_IS_V1(state->mp));
-                        retval = xfs_dir_leaf_lookup_int(blk->bp, args,
-                                                                  &blk->index);
-                } else if (blk->magic == XFS_DIR2_LEAFN_MAGIC) {
-                        ASSERT(XFS_DIR_IS_V2(state->mp));
                        retval = xfs_dir2_leafn_lookup_int(blk->bp, args,
                                                        &blk->index, state);
                }
@@ -1270,7 +1202,7 @@ xfs_da_blk_link(xfs_da_state_t *state, xfs_da_state_blk_t *old_blk,
        old_info = old_blk->bp->data;
        new_info = new_blk->bp->data;
        ASSERT(old_blk->magic == XFS_DA_NODE_MAGIC ||
-               old_blk->magic == XFS_DIRX_LEAF_MAGIC(state->mp) ||
+               old_blk->magic == XFS_DIR2_LEAFN_MAGIC ||
               old_blk->magic == XFS_ATTR_LEAF_MAGIC);
        ASSERT(old_blk->magic == be16_to_cpu(old_info->magic));
        ASSERT(new_blk->magic == be16_to_cpu(new_info->magic));
@@ -1280,12 +1212,7 @@ xfs_da_blk_link(xfs_da_state_t *state, xfs_da_state_blk_t *old_blk,
        case XFS_ATTR_LEAF_MAGIC:
                before = xfs_attr_leaf_order(old_blk->bp, new_blk->bp);
                break;
-        case XFS_DIR_LEAF_MAGIC:
-                ASSERT(XFS_DIR_IS_V1(state->mp));
-                before = xfs_dir_leaf_order(old_blk->bp, new_blk->bp);
-                break;
        case XFS_DIR2_LEAFN_MAGIC:
-                ASSERT(XFS_DIR_IS_V2(state->mp));
                before = xfs_dir2_leafn_order(old_blk->bp, new_blk->bp);
                break;
        case XFS_DA_NODE_MAGIC:
@@ -1404,7 +1331,7 @@ xfs_da_blk_unlink(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
        save_info = save_blk->bp->data;
        drop_info = drop_blk->bp->data;
        ASSERT(save_blk->magic == XFS_DA_NODE_MAGIC ||
-               save_blk->magic == XFS_DIRX_LEAF_MAGIC(state->mp) ||
+               save_blk->magic == XFS_DIR2_LEAFN_MAGIC ||
               save_blk->magic == XFS_ATTR_LEAF_MAGIC);
        ASSERT(save_blk->magic == be16_to_cpu(save_info->magic));
        ASSERT(drop_blk->magic == be16_to_cpu(drop_info->magic));
@@ -1529,7 +1456,7 @@ xfs_da_path_shift(xfs_da_state_t *state, xfs_da_state_path_t *path,
                ASSERT(blk->bp != NULL);
                info = blk->bp->data;
                ASSERT(be16_to_cpu(info->magic) == XFS_DA_NODE_MAGIC ||
-                       be16_to_cpu(info->magic) == XFS_DIRX_LEAF_MAGIC(state->mp) ||
+                       be16_to_cpu(info->magic) == XFS_DIR2_LEAFN_MAGIC ||
                       be16_to_cpu(info->magic) == XFS_ATTR_LEAF_MAGIC);
                blk->magic = be16_to_cpu(info->magic);
                if (blk->magic == XFS_DA_NODE_MAGIC) {
@@ -1548,20 +1475,13 @@ xfs_da_path_shift(xfs_da_state_t *state, xfs_da_state_path_t *path,
                                blk->hashval = xfs_attr_leaf_lasthash(blk->bp,
                                                                      NULL);
                                break;
-                        case XFS_DIR_LEAF_MAGIC:
-                                ASSERT(XFS_DIR_IS_V1(state->mp));
-                                blk->hashval = xfs_dir_leaf_lasthash(blk->bp,
-                                                                     NULL);
-                                break;
                        case XFS_DIR2_LEAFN_MAGIC:
-                                ASSERT(XFS_DIR_IS_V2(state->mp));
                                blk->hashval = xfs_dir2_leafn_lasthash(blk->bp,
                                                                       NULL);
                                break;
                        default:
                                ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC ||
-                                       blk->magic ==
+                                       blk->magic == XFS_DIR2_LEAFN_MAGIC);
-                                       XFS_DIRX_LEAF_MAGIC(state->mp));
                                break;
                        }
                }
@@ -1620,7 +1540,6 @@ xfs_da_grow_inode(xfs_da_args_t *args, xfs_dablk_t *new_blkno)
        xfs_bmbt_irec_t *mapp;
        xfs_inode_t *dp;
        int nmap, error, w, count, c, got, i, mapi;
-        xfs_fsize_t size;
        xfs_trans_t *tp;
        xfs_mount_t *mp;
@@ -1631,7 +1550,7 @@ xfs_da_grow_inode(xfs_da_args_t *args, xfs_dablk_t *new_blkno)
        /*
         * For new directories adjust the file offset and block count.
         */
-        if (w == XFS_DATA_FORK && XFS_DIR_IS_V2(mp)) {
+        if (w == XFS_DATA_FORK) {
                bno = mp->m_dirleafblk;
                count = mp->m_dirblkfsbs;
        } else {
@@ -1641,10 +1560,9 @@ xfs_da_grow_inode(xfs_da_args_t *args, xfs_dablk_t *new_blkno)
        /*
         * Find a spot in the file space to put the new block.
         */
-        if ((error = xfs_bmap_first_unused(tp, dp, count, &bno, w))) {
+        if ((error = xfs_bmap_first_unused(tp, dp, count, &bno, w)))
                return error;
-        }
+        if (w == XFS_DATA_FORK)
-        if (w == XFS_DATA_FORK && XFS_DIR_IS_V2(mp))
                ASSERT(bno >= mp->m_dirleafblk && bno < mp->m_dirfreeblk);
        /*
         * Try mapping it in one filesystem block.
@@ -1655,7 +1573,7 @@ xfs_da_grow_inode(xfs_da_args_t *args, xfs_dablk_t *new_blkno)
                        XFS_BMAPI_AFLAG(w)|XFS_BMAPI_WRITE|XFS_BMAPI_METADATA|
                        XFS_BMAPI_CONTIG,
                        args->firstblock, args->total, &map, &nmap,
-                        args->flist))) {
+                        args->flist, NULL))) {
                return error;
        }
        ASSERT(nmap <= 1);
@@ -1676,7 +1594,8 @@ xfs_da_grow_inode(xfs_da_args_t *args, xfs_dablk_t *new_blkno)
                                        XFS_BMAPI_AFLAG(w)|XFS_BMAPI_WRITE|
                                        XFS_BMAPI_METADATA,
                                        args->firstblock, args->total,
-                                        &mapp[mapi], &nmap, args->flist))) {
+                                        &mapp[mapi], &nmap, args->flist,
+                                        NULL))) {
                                kmem_free(mapp, sizeof(*mapp) * count);
                                return error;
                        }
@@ -1705,19 +1624,6 @@ xfs_da_grow_inode(xfs_da_args_t *args, xfs_dablk_t *new_blkno)
        if (mapp != &map)
                kmem_free(mapp, sizeof(*mapp) * count);
        *new_blkno = (xfs_dablk_t)bno;
-        /*
-         * For version 1 directories, adjust the file size if it changed.
-         */
-        if (w == XFS_DATA_FORK && XFS_DIR_IS_V1(mp)) {
-                ASSERT(mapi == 1);
-                if ((error = xfs_bmap_last_offset(tp, dp, &bno, w)))
-                        return error;
-                size = XFS_FSB_TO_B(mp, bno);
-                if (size != dp->i_d.di_size) {
-                        dp->i_d.di_size = size;
-                        xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
-                }
-        }
        return 0;
 }
@@ -1742,7 +1648,6 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
        int error, w, entno, level, dead_level;
        xfs_da_blkinfo_t *dead_info, *sib_info;
        xfs_da_intnode_t *par_node, *dead_node;
-        xfs_dir_leafblock_t *dead_leaf;
        xfs_dir2_leaf_t *dead_leaf2;
        xfs_dahash_t dead_hash;
@@ -1753,11 +1658,8 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
        w = args->whichfork;
        ASSERT(w == XFS_DATA_FORK);
        mp = ip->i_mount;
-        if (XFS_DIR_IS_V2(mp)) {
+        lastoff = mp->m_dirfreeblk;
-                lastoff = mp->m_dirfreeblk;
+        error = xfs_bmap_last_before(tp, ip, &lastoff, w);
-                error = xfs_bmap_last_before(tp, ip, &lastoff, w);
-        } else
-                error = xfs_bmap_last_offset(tp, ip, &lastoff, w);
        if (error)
                return error;
        if (unlikely(lastoff == 0)) {
@@ -1780,14 +1682,7 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
        /*
         * Get values from the moved block.
         */
-        if (be16_to_cpu(dead_info->magic) == XFS_DIR_LEAF_MAGIC) {
+        if (be16_to_cpu(dead_info->magic) == XFS_DIR2_LEAFN_MAGIC) {
-                ASSERT(XFS_DIR_IS_V1(mp));
-                dead_leaf = (xfs_dir_leafblock_t *)dead_info;
-                dead_level = 0;
-                dead_hash =
-                        INT_GET(dead_leaf->entries[INT_GET(dead_leaf->hdr.count, ARCH_CONVERT) - 1].hashval, ARCH_CONVERT);
-        } else if (be16_to_cpu(dead_info->magic) == XFS_DIR2_LEAFN_MAGIC) {
-                ASSERT(XFS_DIR_IS_V2(mp));
                dead_leaf2 = (xfs_dir2_leaf_t *)dead_info;
                dead_level = 0;
                dead_hash = be32_to_cpu(dead_leaf2->ents[be16_to_cpu(dead_leaf2->hdr.count) - 1].hashval);
@@ -1842,7 +1737,7 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
                xfs_da_buf_done(sib_buf);
                sib_buf = NULL;
        }
-        par_blkno = XFS_DIR_IS_V1(mp) ? 0 : mp->m_dirleafblk;
+        par_blkno = mp->m_dirleafblk;
        level = -1;
        /*
         * Walk down the tree looking for the parent of the moved block.
@@ -1941,8 +1836,6 @@ xfs_da_shrink_inode(xfs_da_args_t *args, xfs_dablk_t dead_blkno,
 {
        xfs_inode_t *dp;
        int done, error, w, count;
-        xfs_fileoff_t bno;
-        xfs_fsize_t size;
        xfs_trans_t *tp;
        xfs_mount_t *mp;
@@ -1950,7 +1843,7 @@ xfs_da_shrink_inode(xfs_da_args_t *args, xfs_dablk_t dead_blkno,
        w = args->whichfork;
        tp = args->trans;
        mp = dp->i_mount;
-        if (w == XFS_DATA_FORK && XFS_DIR_IS_V2(mp))
+        if (w == XFS_DATA_FORK)
                count = mp->m_dirblkfsbs;
        else
                count = 1;
@@ -1961,34 +1854,17 @@ xfs_da_shrink_inode(xfs_da_args_t *args, xfs_dablk_t dead_blkno,
                 */
                if ((error = xfs_bunmapi(tp, dp, dead_blkno, count,
                                XFS_BMAPI_AFLAG(w)|XFS_BMAPI_METADATA,
-                                0, args->firstblock, args->flist,
+                                0, args->firstblock, args->flist, NULL,
                                &done)) == ENOSPC) {
                        if (w != XFS_DATA_FORK)
-                                goto done;
+                                break;
                        if ((error = xfs_da_swap_lastblock(args, &dead_blkno,
                                        &dead_buf)))
-                                goto done;
+                                break;
-                } else if (error)
+                } else {
-                        goto done;
-                else
                        break;
-        }
-        ASSERT(done);
-        xfs_da_binval(tp, dead_buf);
-        /*
-         * Adjust the directory size for version 1.
-         */
-        if (w == XFS_DATA_FORK && XFS_DIR_IS_V1(mp)) {
-                if ((error = xfs_bmap_last_offset(tp, dp, &bno, w)))
-                        return error;
-                size = XFS_FSB_TO_B(dp->i_mount, bno);
-                if (size != dp->i_d.di_size) {
-                        dp->i_d.di_size = size;
-                        xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
                }
        }
-        return 0;
-done:
        xfs_da_binval(tp, dead_buf);
        return error;
 }
@@ -2049,10 +1925,7 @@ xfs_da_do_buf(
        xfs_dabuf_t     *rbp;
        mp = dp->i_mount;
-        if (whichfork == XFS_DATA_FORK && XFS_DIR_IS_V2(mp))
+        nfsb = (whichfork == XFS_DATA_FORK) ? mp->m_dirblkfsbs : 1;
-                nfsb = mp->m_dirblkfsbs;
-        else
-                nfsb = 1;
        mappedbno = *mappedbnop;
        /*
         * Caller doesn't have a mapping.  -2 means don't complain
@@ -2086,7 +1959,7 @@ xfs_da_do_buf(
                                        nfsb,
                                        XFS_BMAPI_METADATA |
                                                XFS_BMAPI_AFLAG(whichfork),
-                                        NULL, 0, mapp, &nmap, NULL)))
+                                        NULL, 0, mapp, &nmap, NULL, NULL)))
                                goto exit0;
                }
        } else {
@@ -2198,7 +2071,6 @@ xfs_da_do_buf(
                magic1 = be32_to_cpu(data->hdr.magic);
                if (unlikely(
                    XFS_TEST_ERROR((magic != XFS_DA_NODE_MAGIC) &&
-                                   (magic != XFS_DIR_LEAF_MAGIC) &&
                                   (magic != XFS_ATTR_LEAF_MAGIC) &&
                                   (magic != XFS_DIR2_LEAF1_MAGIC) &&
                                   (magic != XFS_DIR2_LEAFN_MAGIC) &&
diff --git a/fs/xfs/xfs_da_btree.h b/fs/xfs/xfs_da_btree.h
index 243a730d5ec8..4ab865ec8b82 100644
--- a/fs/xfs/xfs_da_btree.h
+++ b/fs/xfs/xfs_da_btree.h
@@ -36,14 +36,10 @@ struct zone;
 * level in the Btree, and to identify which type of block this is.
 */
 #define XFS_DA_NODE_MAGIC       0xfebe  /* magic number: non-leaf blocks */
-#define XFS_DIR_LEAF_MAGIC      0xfeeb  /* magic number: directory leaf blks */
 #define XFS_ATTR_LEAF_MAGIC     0xfbee  /* magic number: attribute leaf blks */
 #define XFS_DIR2_LEAF1_MAGIC    0xd2f1  /* magic number: v2 dirlf single blks */
 #define XFS_DIR2_LEAFN_MAGIC    0xd2ff  /* magic number: v2 dirlf multi blks */
-#define XFS_DIRX_LEAF_MAGIC(mp) \
-        (XFS_DIR_IS_V1(mp) ? XFS_DIR_LEAF_MAGIC : XFS_DIR2_LEAFN_MAGIC)
 typedef struct xfs_da_blkinfo {
        __be32          forw;                   /* previous block in list */
        __be32          back;                   /* following block in list */
diff --git a/fs/xfs/xfs_dfrag.c b/fs/xfs/xfs_dfrag.c
index 4968a6358e61..80562b60fb95 100644
--- a/fs/xfs/xfs_dfrag.c
+++ b/fs/xfs/xfs_dfrag.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2002,2005 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
@@ -24,14 +24,12 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -54,24 +52,14 @@ xfs_swapext(
        xfs_swapext_t   __user *sxu)
 {
        xfs_swapext_t   *sxp;
-        xfs_inode_t     *ip=NULL, *tip=NULL, *ips[2];
+        xfs_inode_t     *ip=NULL, *tip=NULL;
-        xfs_trans_t     *tp;
        xfs_mount_t     *mp;
-        xfs_bstat_t     *sbp;
        struct file     *fp = NULL, *tfp = NULL;
-        vnode_t         *vp, *tvp;
+        bhv_vnode_t     *vp, *tvp;
-        static uint     lock_flags = XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL;
-        int             ilf_fields, tilf_fields;
        int             error = 0;
-        xfs_ifork_t     *tempifp, *ifp, *tifp;
-        __uint64_t      tmp;
-        int             aforkblks = 0;
-        int             taforkblks = 0;
-        char            locked = 0;
        sxp = kmem_alloc(sizeof(xfs_swapext_t), KM_MAYFAIL);
-        tempifp = kmem_alloc(sizeof(xfs_ifork_t), KM_MAYFAIL);
+        if (!sxp) {
-        if (!sxp || !tempifp) {
                error = XFS_ERROR(ENOMEM);
                goto error0;
        }
@@ -118,14 +106,56 @@ xfs_swapext(
        mp = ip->i_mount;
-        sbp = &sxp->sx_stat;
        if (XFS_FORCED_SHUTDOWN(mp)) {
                error =  XFS_ERROR(EIO);
                goto error0;
        }
-        locked = 1;
+        error = XFS_SWAP_EXTENTS(mp, &ip->i_iocore, &tip->i_iocore, sxp);
+ error0:
+        if (fp != NULL)
+                fput(fp);
+        if (tfp != NULL)
+                fput(tfp);
+        if (sxp != NULL)
+                kmem_free(sxp, sizeof(xfs_swapext_t));
+        return error;
+}
+int
+xfs_swap_extents(
+        xfs_inode_t     *ip,
+        xfs_inode_t     *tip,
+        xfs_swapext_t   *sxp)
+{
+        xfs_mount_t     *mp;
+        xfs_inode_t     *ips[2];
+        xfs_trans_t     *tp;
+        xfs_bstat_t     *sbp = &sxp->sx_stat;
+        bhv_vnode_t     *vp, *tvp;
+        xfs_ifork_t     *tempifp, *ifp, *tifp;
+        int             ilf_fields, tilf_fields;
+        static uint     lock_flags = XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL;
+        int             error = 0;
+        int             aforkblks = 0;
+        int             taforkblks = 0;
+        __uint64_t      tmp;
+        char            locked = 0;
+        mp = ip->i_mount;
+        tempifp = kmem_alloc(sizeof(xfs_ifork_t), KM_MAYFAIL);
+        if (!tempifp) {
+                error = XFS_ERROR(ENOMEM);
+                goto error0;
+        }
+        sbp = &sxp->sx_stat;
+        vp = XFS_ITOV(ip);
+        tvp = XFS_ITOV(tip);
        /* Lock in i_ino order */
        if (ip->i_ino < tip->i_ino) {
@@ -137,6 +167,7 @@ xfs_swapext(
        }
        xfs_lock_inodes(ips, 2, 0, lock_flags);
+        locked = 1;
        /* Check permissions */
        error = xfs_iaccess(ip, S_IWUSR, NULL);
@@ -169,7 +200,7 @@ xfs_swapext(
        if (VN_CACHED(tvp) != 0) {
                xfs_inval_cached_trace(&tip->i_iocore, 0, -1, 0, -1);
-                VOP_FLUSHINVAL_PAGES(tvp, 0, -1, FI_REMAPF_LOCKED);
+                bhv_vop_flushinval_pages(tvp, 0, -1, FI_REMAPF_LOCKED);
        }
        /* Verify O_DIRECT for ftmp */
@@ -214,7 +245,7 @@ xfs_swapext(
        /* We need to fail if the file is memory mapped.  Once we have tossed
         * all existing pages, the page fault will have no option
         * but to go to the filesystem for pages. By making the page fault call
-         * VOP_READ (or write in the case of autogrow) they block on the iolock
+         * vop_read (or write in the case of autogrow) they block on the iolock
         * until we have switched the extents.
         */
        if (VN_MAPPED(vp)) {
@@ -233,7 +264,7 @@ xfs_swapext(
         * fields change.
         */
-        VOP_TOSS_PAGES(vp, 0, -1, FI_REMAPF);
+        bhv_vop_toss_pages(vp, 0, -1, FI_REMAPF);
        tp = xfs_trans_alloc(mp, XFS_TRANS_SWAPEXT);
        if ((error = xfs_trans_reserve(tp, 0,
@@ -360,16 +391,7 @@ xfs_swapext(
                xfs_iunlock(ip,  lock_flags);
                xfs_iunlock(tip, lock_flags);
        }
-        if (fp != NULL)
-                fput(fp);
-        if (tfp != NULL)
-                fput(tfp);
-        if (sxp != NULL)
-                kmem_free(sxp, sizeof(xfs_swapext_t));
        if (tempifp != NULL)
                kmem_free(tempifp, sizeof(xfs_ifork_t));
        return error;
 }
diff --git a/fs/xfs/xfs_dfrag.h b/fs/xfs/xfs_dfrag.h
index f678559abc45..da178205be68 100644
--- a/fs/xfs/xfs_dfrag.h
+++ b/fs/xfs/xfs_dfrag.h
@@ -48,6 +48,9 @@ typedef struct xfs_swapext
 */
 int     xfs_swapext(struct xfs_swapext __user *sx);
+int     xfs_swap_extents(struct xfs_inode *ip, struct xfs_inode *tip,
+                struct xfs_swapext *sxp);
 #endif  /* __KERNEL__ */
 #endif  /* __XFS_DFRAG_H__ */
diff --git a/fs/xfs/xfs_dinode.h b/fs/xfs/xfs_dinode.h
index 79d0d9e1fbab..b33826961c45 100644
--- a/fs/xfs/xfs_dinode.h
+++ b/fs/xfs/xfs_dinode.h
@@ -85,7 +85,6 @@ typedef struct xfs_dinode
        union {
                xfs_bmdr_block_t di_bmbt;       /* btree root block */
                xfs_bmbt_rec_32_t di_bmx[1];    /* extent list */
-                xfs_dir_shortform_t di_dirsf;   /* shortform directory */
                xfs_dir2_sf_t   di_dir2sf;      /* shortform directory v2 */
                char            di_c[1];        /* local contents */
                xfs_dev_t       di_dev;         /* device for S_IFCHR/S_IFBLK */
@@ -257,6 +256,7 @@ typedef enum xfs_dinode_fmt
 #define XFS_DIFLAG_NOSYMLINKS_BIT   10  /* disallow symlink creation */
 #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_REALTIME      (1 << XFS_DIFLAG_REALTIME_BIT)
 #define XFS_DIFLAG_PREALLOC      (1 << XFS_DIFLAG_PREALLOC_BIT)
 #define XFS_DIFLAG_NEWRTBM       (1 << XFS_DIFLAG_NEWRTBM_BIT)
@@ -270,12 +270,13 @@ typedef enum xfs_dinode_fmt
 #define XFS_DIFLAG_NOSYMLINKS    (1 << XFS_DIFLAG_NOSYMLINKS_BIT)
 #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_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_EXTSZINHERIT | XFS_DIFLAG_NODEFRAG)
 #endif  /* __XFS_DINODE_H__ */
diff --git a/fs/xfs/xfs_dir.c b/fs/xfs/xfs_dir.c
deleted file mode 100644
index 9cc702a839a3..000000000000
--- a/fs/xfs/xfs_dir.c
+++ /dev/null
@@ -1,1217 +0,0 @@
-/*
- * Copyright (c) 2000-2001,2005 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_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_inum.h"
-#include "xfs_trans.h"
-#include "xfs_sb.h"
-#include "xfs_dir.h"
-#include "xfs_dir2.h"
-#include "xfs_dmapi.h"
-#include "xfs_mount.h"
-#include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_alloc.h"
-#include "xfs_btree.h"
-#include "xfs_dir_sf.h"
-#include "xfs_dir2_sf.h"
-#include "xfs_attr_sf.h"
-#include "xfs_dinode.h"
-#include "xfs_inode.h"
-#include "xfs_bmap.h"
-#include "xfs_dir_leaf.h"
-#include "xfs_error.h"
-/*
- * xfs_dir.c
- *
- * Provide the external interfaces to manage directories.
- */
-/*========================================================================
- * Function prototypes for the kernel.
- *========================================================================*/
-/*
- * Functions for the dirops interfaces.
- */
-static void     xfs_dir_mount(struct xfs_mount *mp);
-static int      xfs_dir_isempty(struct xfs_inode *dp);
-static int      xfs_dir_init(struct xfs_trans *trans,
-                             struct xfs_inode *dir,
-                             struct xfs_inode *parent_dir);
-static int      xfs_dir_createname(struct xfs_trans *trans,
-                                   struct xfs_inode *dp,
-                                   char *name_string,
-                                   int name_len,
-                                   xfs_ino_t inode_number,
-                                   xfs_fsblock_t *firstblock,
-                                   xfs_bmap_free_t *flist,
-                                   xfs_extlen_t total);
-static int      xfs_dir_lookup(struct xfs_trans *tp,
-                               struct xfs_inode *dp,
-                               char *name_string,
-                               int name_length,
-                               xfs_ino_t *inode_number);
-static int      xfs_dir_removename(struct xfs_trans *trans,
-                                   struct xfs_inode *dp,
-                                   char *name_string,
-                                   int name_length,
-                                   xfs_ino_t ino,
-                                   xfs_fsblock_t *firstblock,
-                                   xfs_bmap_free_t *flist,
-                                   xfs_extlen_t total);
-static int      xfs_dir_getdents(struct xfs_trans *tp,
-                                 struct xfs_inode *dp,
-                                 struct uio *uiop,
-                                 int *eofp);
-static int      xfs_dir_replace(struct xfs_trans *tp,
-                                struct xfs_inode *dp,
-                                char *name_string,
-                                int name_length,
-                                xfs_ino_t inode_number,
-                                xfs_fsblock_t *firstblock,
-                                xfs_bmap_free_t *flist,
-                                xfs_extlen_t total);
-static int      xfs_dir_canenter(struct xfs_trans *tp,
-                                 struct xfs_inode *dp,
-                                 char *name_string,
-                                 int name_length);
-static int      xfs_dir_shortform_validate_ondisk(xfs_mount_t *mp,
-                                                  xfs_dinode_t *dip);
-xfs_dirops_t xfsv1_dirops = {
-        .xd_mount                       = xfs_dir_mount,
-        .xd_isempty                     = xfs_dir_isempty,
-        .xd_init                        = xfs_dir_init,
-        .xd_createname                  = xfs_dir_createname,
-        .xd_lookup                      = xfs_dir_lookup,
-        .xd_removename                  = xfs_dir_removename,
-        .xd_getdents                    = xfs_dir_getdents,
-        .xd_replace                     = xfs_dir_replace,
-        .xd_canenter                    = xfs_dir_canenter,
-        .xd_shortform_validate_ondisk   = xfs_dir_shortform_validate_ondisk,
-        .xd_shortform_to_single         = xfs_dir_shortform_to_leaf,
-};
-/*
- * Internal routines when dirsize == XFS_LBSIZE(mp).
- */
-STATIC int xfs_dir_leaf_lookup(xfs_da_args_t *args);
-STATIC int xfs_dir_leaf_removename(xfs_da_args_t *args, int *number_entries,
-                                                 int *total_namebytes);
-STATIC int xfs_dir_leaf_getdents(xfs_trans_t *trans, xfs_inode_t *dp,
-                                             uio_t *uio, int *eofp,
-                                             xfs_dirent_t *dbp,
-                                             xfs_dir_put_t put);
-STATIC int xfs_dir_leaf_replace(xfs_da_args_t *args);
-/*
- * Internal routines when dirsize > XFS_LBSIZE(mp).
- */
-STATIC int xfs_dir_node_addname(xfs_da_args_t *args);
-STATIC int xfs_dir_node_lookup(xfs_da_args_t *args);
-STATIC int xfs_dir_node_removename(xfs_da_args_t *args);
-STATIC int xfs_dir_node_getdents(xfs_trans_t *trans, xfs_inode_t *dp,
-                                             uio_t *uio, int *eofp,
-                                             xfs_dirent_t *dbp,
-                                             xfs_dir_put_t put);
-STATIC int xfs_dir_node_replace(xfs_da_args_t *args);
-#if defined(XFS_DIR_TRACE)
-ktrace_t *xfs_dir_trace_buf;
-#endif
-/*========================================================================
- * Overall external interface routines.
- *========================================================================*/
-xfs_dahash_t    xfs_dir_hash_dot, xfs_dir_hash_dotdot;
-/*
- * One-time startup routine called from xfs_init().
- */
-void
-xfs_dir_startup(void)
-{
-        xfs_dir_hash_dot = xfs_da_hashname(".", 1);
-        xfs_dir_hash_dotdot = xfs_da_hashname("..", 2);
-}
-/*
- * Initialize directory-related fields in the mount structure.
- */
-static void
-xfs_dir_mount(xfs_mount_t *mp)
-{
-        uint shortcount, leafcount, count;
-        mp->m_dirversion = 1;
-        if (!(mp->m_flags & XFS_MOUNT_ATTR2)) {
-                shortcount = (mp->m_attroffset -
-                                (uint)sizeof(xfs_dir_sf_hdr_t)) /
-                                 (uint)sizeof(xfs_dir_sf_entry_t);
-                leafcount = (XFS_LBSIZE(mp) -
-                                (uint)sizeof(xfs_dir_leaf_hdr_t)) /
-                                 ((uint)sizeof(xfs_dir_leaf_entry_t) +
-                                  (uint)sizeof(xfs_dir_leaf_name_t));
-        } else {
-                shortcount = (XFS_BMDR_SPACE_CALC(MINABTPTRS) -
-                              (uint)sizeof(xfs_dir_sf_hdr_t)) /
-                               (uint)sizeof(xfs_dir_sf_entry_t);
-                leafcount = (XFS_LBSIZE(mp) -
-                            (uint)sizeof(xfs_dir_leaf_hdr_t)) /
-                             ((uint)sizeof(xfs_dir_leaf_entry_t) +
-                              (uint)sizeof(xfs_dir_leaf_name_t));
-        }
-        count = shortcount > leafcount ? shortcount : leafcount;
-        mp->m_dircook_elog = xfs_da_log2_roundup(count + 1);
-        ASSERT(mp->m_dircook_elog <= mp->m_sb.sb_blocklog);
-        mp->m_dir_node_ents = mp->m_attr_node_ents =
-                (XFS_LBSIZE(mp) - (uint)sizeof(xfs_da_node_hdr_t)) /
-                (uint)sizeof(xfs_da_node_entry_t);
-        mp->m_dir_magicpct = (XFS_LBSIZE(mp) * 37) / 100;
-        mp->m_dirblksize = mp->m_sb.sb_blocksize;
-        mp->m_dirblkfsbs = 1;
-}
-/*
- * Return 1 if directory contains only "." and "..".
- */
-static int
-xfs_dir_isempty(xfs_inode_t *dp)
-{
-        xfs_dir_sf_hdr_t *hdr;
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
-        if (dp->i_d.di_size == 0)
-                return(1);
-        if (dp->i_d.di_size > XFS_IFORK_DSIZE(dp))
-                return(0);
-        hdr = (xfs_dir_sf_hdr_t *)dp->i_df.if_u1.if_data;
-        return(hdr->count == 0);
-}
-/*
- * Initialize a directory with its "." and ".." entries.
- */
-static int
-xfs_dir_init(xfs_trans_t *trans, xfs_inode_t *dir, xfs_inode_t *parent_dir)
-{
-        xfs_da_args_t args;
-        int error;
-        memset((char *)&args, 0, sizeof(args));
-        args.dp = dir;
-        args.trans = trans;
-        ASSERT((dir->i_d.di_mode & S_IFMT) == S_IFDIR);
-        if ((error = xfs_dir_ino_validate(trans->t_mountp, parent_dir->i_ino)))
-                return error;
-        return(xfs_dir_shortform_create(&args, parent_dir->i_ino));
-}
-/*
- * Generic handler routine to add a name to a directory.
- * Transitions directory from shortform to Btree as necessary.
- */
-static int                                                      /* error */
-xfs_dir_createname(xfs_trans_t *trans, xfs_inode_t *dp, char *name,
-                   int namelen, xfs_ino_t inum, xfs_fsblock_t *firstblock,
-                   xfs_bmap_free_t *flist, xfs_extlen_t total)
-{
-        xfs_da_args_t args;
-        int retval, newsize, done;
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
-        if ((retval = xfs_dir_ino_validate(trans->t_mountp, inum)))
-                return (retval);
-        XFS_STATS_INC(xs_dir_create);
-        /*
-         * Fill in the arg structure for this request.
-         */
-        args.name = name;
-        args.namelen = namelen;
-        args.hashval = xfs_da_hashname(name, namelen);
-        args.inumber = inum;
-        args.dp = dp;
-        args.firstblock = firstblock;
-        args.flist = flist;
-        args.total = total;
-        args.whichfork = XFS_DATA_FORK;
-        args.trans = trans;
-        args.justcheck = 0;
-        args.addname = args.oknoent = 1;
-        /*
-         * Decide on what work routines to call based on the inode size.
-         */
-        done = 0;
-        if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) {
-                newsize = XFS_DIR_SF_ENTSIZE_BYNAME(args.namelen);
-                if ((dp->i_d.di_size + newsize) <= XFS_IFORK_DSIZE(dp)) {
-                        retval = xfs_dir_shortform_addname(&args);
-                        done = 1;
-                } else {
-                        if (total == 0)
-                                return XFS_ERROR(ENOSPC);
-                        retval = xfs_dir_shortform_to_leaf(&args);
-                        done = retval != 0;
-                }
-        }
-        if (!done && xfs_bmap_one_block(dp, XFS_DATA_FORK)) {
-                retval = xfs_dir_leaf_addname(&args);
-                done = retval != ENOSPC;
-                if (!done) {
-                        if (total == 0)
-                                return XFS_ERROR(ENOSPC);
-                        retval = xfs_dir_leaf_to_node(&args);
-                        done = retval != 0;
-                }
-        }
-        if (!done) {
-                retval = xfs_dir_node_addname(&args);
-        }
-        return(retval);
-}
-/*
- * Generic handler routine to check if a name can be added to a directory,
- * without adding any blocks to the directory.
- */
-static int                                                      /* error */
-xfs_dir_canenter(xfs_trans_t *trans, xfs_inode_t *dp, char *name, int namelen)
-{
-        xfs_da_args_t args;
-        int retval, newsize;
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
-        /*
-         * Fill in the arg structure for this request.
-         */
-        args.name = name;
-        args.namelen = namelen;
-        args.hashval = xfs_da_hashname(name, namelen);
-        args.inumber = 0;
-        args.dp = dp;
-        args.firstblock = NULL;
-        args.flist = NULL;
-        args.total = 0;
-        args.whichfork = XFS_DATA_FORK;
-        args.trans = trans;
-        args.justcheck = args.addname = args.oknoent = 1;
-        /*
-         * Decide on what work routines to call based on the inode size.
-         */
-        if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) {
-                newsize = XFS_DIR_SF_ENTSIZE_BYNAME(args.namelen);
-                if ((dp->i_d.di_size + newsize) <= XFS_IFORK_DSIZE(dp))
-                        retval = 0;
-                else
-                        retval = XFS_ERROR(ENOSPC);
-        } else if (xfs_bmap_one_block(dp, XFS_DATA_FORK)) {
-                retval = xfs_dir_leaf_addname(&args);
-        } else {
-                retval = xfs_dir_node_addname(&args);
-        }
-        return(retval);
-}
-/*
- * Generic handler routine to remove a name from a directory.
- * Transitions directory from Btree to shortform as necessary.
- */
-static int                                                      /* error */
-xfs_dir_removename(xfs_trans_t *trans, xfs_inode_t *dp, char *name,
-                   int namelen, xfs_ino_t ino, xfs_fsblock_t *firstblock,
-                   xfs_bmap_free_t *flist, xfs_extlen_t total)
-{
-        xfs_da_args_t args;
-        int count, totallen, newsize, retval;
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
-        XFS_STATS_INC(xs_dir_remove);
-        /*
-         * Fill in the arg structure for this request.
-         */
-        args.name = name;
-        args.namelen = namelen;
-        args.hashval = xfs_da_hashname(name, namelen);
-        args.inumber = ino;
-        args.dp = dp;
-        args.firstblock = firstblock;
-        args.flist = flist;
-        args.total = total;
-        args.whichfork = XFS_DATA_FORK;
-        args.trans = trans;
-        args.justcheck = args.addname = args.oknoent = 0;
-        /*
-         * Decide on what work routines to call based on the inode size.
-         */
-        if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) {
-                retval = xfs_dir_shortform_removename(&args);
-        } else if (xfs_bmap_one_block(dp, XFS_DATA_FORK)) {
-                retval = xfs_dir_leaf_removename(&args, &count, &totallen);
-                if (retval == 0) {
-                        newsize = XFS_DIR_SF_ALLFIT(count, totallen);
-                        if (newsize <= XFS_IFORK_DSIZE(dp)) {
-                                retval = xfs_dir_leaf_to_shortform(&args);
-                        }
-                }
-        } else {
-                retval = xfs_dir_node_removename(&args);
-        }
-        return(retval);
-}
-static int                                                      /* error */
-xfs_dir_lookup(xfs_trans_t *trans, xfs_inode_t *dp, char *name, int namelen,
-                                   xfs_ino_t *inum)
-{
-        xfs_da_args_t args;
-        int retval;
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
-        XFS_STATS_INC(xs_dir_lookup);
-        /*
-         * Fill in the arg structure for this request.
-         */
-        args.name = name;
-        args.namelen = namelen;
-        args.hashval = xfs_da_hashname(name, namelen);
-        args.inumber = 0;
-        args.dp = dp;
-        args.firstblock = NULL;
-        args.flist = NULL;
-        args.total = 0;
-        args.whichfork = XFS_DATA_FORK;
-        args.trans = trans;
-        args.justcheck = args.addname = 0;
-        args.oknoent = 1;
-        /*
-         * Decide on what work routines to call based on the inode size.
-         */
-        if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) {
-                retval = xfs_dir_shortform_lookup(&args);
-        } else if (xfs_bmap_one_block(dp, XFS_DATA_FORK)) {
-                retval = xfs_dir_leaf_lookup(&args);
-        } else {
-                retval = xfs_dir_node_lookup(&args);
-        }
-        if (retval == EEXIST)
-                retval = 0;
-        *inum = args.inumber;
-        return(retval);
-}
-/*
- * Implement readdir.
- */
-static int                                                      /* error */
-xfs_dir_getdents(xfs_trans_t *trans, xfs_inode_t *dp, uio_t *uio, int *eofp)
-{
-        xfs_dirent_t *dbp;
-        int  alignment, retval;
-        xfs_dir_put_t put;
-        XFS_STATS_INC(xs_dir_getdents);
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
-        /*
-         * If our caller has given us a single contiguous memory buffer,
-         * just work directly within that buffer.  If it's in user memory,
-         * lock it down first.
-         */
-        alignment = sizeof(xfs_off_t) - 1;
-        if ((uio->uio_iovcnt == 1) &&
-            (((__psint_t)uio->uio_iov[0].iov_base & alignment) == 0) &&
-            ((uio->uio_iov[0].iov_len & alignment) == 0)) {
-                dbp = NULL;
-                put = xfs_dir_put_dirent64_direct;
-        } else {
-                dbp = kmem_alloc(sizeof(*dbp) + MAXNAMELEN, KM_SLEEP);
-                put = xfs_dir_put_dirent64_uio;
-        }
-        /*
-         * Decide on what work routines to call based on the inode size.
-         */
-        *eofp = 0;
-        if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) {
-                retval = xfs_dir_shortform_getdents(dp, uio, eofp, dbp, put);
-        } else if (xfs_bmap_one_block(dp, XFS_DATA_FORK)) {
-                retval = xfs_dir_leaf_getdents(trans, dp, uio, eofp, dbp, put);
-        } else {
-                retval = xfs_dir_node_getdents(trans, dp, uio, eofp, dbp, put);
-        }
-        if (dbp != NULL)
-                kmem_free(dbp, sizeof(*dbp) + MAXNAMELEN);
-        return(retval);
-}
-static int                                                      /* error */
-xfs_dir_replace(xfs_trans_t *trans, xfs_inode_t *dp, char *name, int namelen,
-                                    xfs_ino_t inum, xfs_fsblock_t *firstblock,
-                                    xfs_bmap_free_t *flist, xfs_extlen_t total)
-{
-        xfs_da_args_t args;
-        int retval;
-        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
-        if ((retval = xfs_dir_ino_validate(trans->t_mountp, inum)))
-                return retval;
-        /*
-         * Fill in the arg structure for this request.
-         */
-        args.name = name;
-        args.namelen = namelen;
-        args.hashval = xfs_da_hashname(name, namelen);
-        args.inumber = inum;
-        args.dp = dp;
-        args.firstblock = firstblock;
-        args.flist = flist;
-        args.total = total;
-        args.whichfork = XFS_DATA_FORK;
-        args.trans = trans;
-        args.justcheck = args.addname = args.oknoent = 0;
-        /*
-         * Decide on what work routines to call based on the inode size.
-         */
-        if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL) {
-                retval = xfs_dir_shortform_replace(&args);
-        } else if (xfs_bmap_one_block(dp, XFS_DATA_FORK)) {
-                retval = xfs_dir_leaf_replace(&args);
-        } else {
-                retval = xfs_dir_node_replace(&args);
-        }
-        return(retval);
-}
-static int
-xfs_dir_shortform_validate_ondisk(xfs_mount_t *mp, xfs_dinode_t *dp)
-{
-        xfs_ino_t               ino;
-        int                     namelen_sum;
-        int                     count;
-        xfs_dir_shortform_t     *sf;
-        xfs_dir_sf_entry_t      *sfe;
-        int                     i;
-        if ((INT_GET(dp->di_core.di_mode, ARCH_CONVERT) & S_IFMT) != S_IFDIR) {
-                return 0;
-        }
-        if (INT_GET(dp->di_core.di_format, ARCH_CONVERT) != XFS_DINODE_FMT_LOCAL) {
-                return 0;
-        }
-        if (INT_GET(dp->di_core.di_size, ARCH_CONVERT) < sizeof(sf->hdr)) {
-                xfs_fs_cmn_err(CE_WARN, mp, "Invalid shortform size: dp 0x%p",
-                        dp);
-                return 1;
-        }
-        sf = (xfs_dir_shortform_t *)(&dp->di_u.di_dirsf);
-        ino = XFS_GET_DIR_INO8(sf->hdr.parent);
-        if (xfs_dir_ino_validate(mp, ino))
-                return 1;
-        count = sf->hdr.count;
-        if ((count < 0) || ((count * 10) > XFS_LITINO(mp))) {
-                xfs_fs_cmn_err(CE_WARN, mp,
-                        "Invalid shortform count: dp 0x%p", dp);
-                return(1);
-        }
-        if (count == 0) {
-                return 0;
-        }
-        namelen_sum = 0;
-        sfe = &sf->list[0];
-        for (i = sf->hdr.count - 1; i >= 0; i--) {
-                ino = XFS_GET_DIR_INO8(sfe->inumber);
-                xfs_dir_ino_validate(mp, ino);
-                if (sfe->namelen >= XFS_LITINO(mp)) {
-                        xfs_fs_cmn_err(CE_WARN, mp,
-                                "Invalid shortform namelen: dp 0x%p", dp);
-                        return 1;
-                }
-                namelen_sum += sfe->namelen;
-                sfe = XFS_DIR_SF_NEXTENTRY(sfe);
-        }
-        if (namelen_sum >= XFS_LITINO(mp)) {
-                xfs_fs_cmn_err(CE_WARN, mp,
-                        "Invalid shortform namelen: dp 0x%p", dp);
-                return 1;
-        }
-        return 0;
-}
-/*========================================================================
- * External routines when dirsize == XFS_LBSIZE(dp->i_mount).
- *========================================================================*/
-/*
- * Add a name to the leaf directory structure
- * This is the external routine.
- */
-int
-xfs_dir_leaf_addname(xfs_da_args_t *args)
-{
-        int index, retval;
-        xfs_dabuf_t *bp;
-        retval = xfs_da_read_buf(args->trans, args->dp, 0, -1, &bp,
-                                              XFS_DATA_FORK);
-        if (retval)
-                return(retval);
-        ASSERT(bp != NULL);
-        retval = xfs_dir_leaf_lookup_int(bp, args, &index);
-        if (retval == ENOENT)
-                retval = xfs_dir_leaf_add(bp, args, index);
-        xfs_da_buf_done(bp);
-        return(retval);
-}
-/*
- * Remove a name from the leaf directory structure
- * This is the external routine.
- */
-STATIC int
-xfs_dir_leaf_removename(xfs_da_args_t *args, int *count, int *totallen)
-{
-        xfs_dir_leafblock_t *leaf;
-        int index, retval;
-        xfs_dabuf_t *bp;
-        retval = xfs_da_read_buf(args->trans, args->dp, 0, -1, &bp,
-                                              XFS_DATA_FORK);
-        if (retval)
-                return(retval);
-        ASSERT(bp != NULL);
-        leaf = bp->data;
-        ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR_LEAF_MAGIC);
-        retval = xfs_dir_leaf_lookup_int(bp, args, &index);
-        if (retval == EEXIST) {
-                (void)xfs_dir_leaf_remove(args->trans, bp, index);
-                *count = INT_GET(leaf->hdr.count, ARCH_CONVERT);
-                *totallen = INT_GET(leaf->hdr.namebytes, ARCH_CONVERT);
-                retval = 0;
-        }
-        xfs_da_buf_done(bp);
-        return(retval);
-}
-/*
- * Look up a name in a leaf directory structure.
- * This is the external routine.
- */
-STATIC int
-xfs_dir_leaf_lookup(xfs_da_args_t *args)
-{
-        int index, retval;
-        xfs_dabuf_t *bp;
-        retval = xfs_da_read_buf(args->trans, args->dp, 0, -1, &bp,
-                                              XFS_DATA_FORK);
-        if (retval)
-                return(retval);
-        ASSERT(bp != NULL);
-        retval = xfs_dir_leaf_lookup_int(bp, args, &index);
-        xfs_da_brelse(args->trans, bp);
-        return(retval);
-}
-/*
- * Copy out directory entries for getdents(), for leaf directories.
- */
-STATIC int
-xfs_dir_leaf_getdents(xfs_trans_t *trans, xfs_inode_t *dp, uio_t *uio,
-                                  int *eofp, xfs_dirent_t *dbp, xfs_dir_put_t put)
-{
-        xfs_dabuf_t *bp;
-        int retval, eob;
-        retval = xfs_da_read_buf(dp->i_transp, dp, 0, -1, &bp, XFS_DATA_FORK);
-        if (retval)
-                return(retval);
-        ASSERT(bp != NULL);
-        retval = xfs_dir_leaf_getdents_int(bp, dp, 0, uio, &eob, dbp, put, -1);
-        xfs_da_brelse(trans, bp);
-        *eofp = (eob == 0);
-        return(retval);
-}
-/*
- * Look up a name in a leaf directory structure, replace the inode number.
- * This is the external routine.
- */
-STATIC int
-xfs_dir_leaf_replace(xfs_da_args_t *args)
-{
-        int index, retval;
-        xfs_dabuf_t *bp;
-        xfs_ino_t inum;
-        xfs_dir_leafblock_t *leaf;
-        xfs_dir_leaf_entry_t *entry;
-        xfs_dir_leaf_name_t *namest;
-        inum = args->inumber;
-        retval = xfs_da_read_buf(args->trans, args->dp, 0, -1, &bp,
-                                              XFS_DATA_FORK);
-        if (retval)
-                return(retval);
-        ASSERT(bp != NULL);
-        retval = xfs_dir_leaf_lookup_int(bp, args, &index);
-        if (retval == EEXIST) {
-                leaf = bp->data;
-                entry = &leaf->entries[index];
-                namest = XFS_DIR_LEAF_NAMESTRUCT(leaf, INT_GET(entry->nameidx, ARCH_CONVERT));
-                /* XXX - replace assert? */
-                XFS_DIR_SF_PUT_DIRINO(&inum, &namest->inumber);
-                xfs_da_log_buf(args->trans, bp,
-                    XFS_DA_LOGRANGE(leaf, namest, sizeof(namest->inumber)));
-                xfs_da_buf_done(bp);
-                retval = 0;
-        } else
-                xfs_da_brelse(args->trans, bp);
-        return(retval);
-}
-/*========================================================================
- * External routines when dirsize > XFS_LBSIZE(mp).
- *========================================================================*/
-/*
- * Add a name to a Btree-format directory.
- *
- * This will involve walking down the Btree, and may involve splitting
- * leaf nodes and even splitting intermediate nodes up to and including
- * the root node (a special case of an intermediate node).
- */
-STATIC int
-xfs_dir_node_addname(xfs_da_args_t *args)
-{
-        xfs_da_state_t *state;
-        xfs_da_state_blk_t *blk;
-        int retval, error;
-        /*
-         * Fill in bucket of arguments/results/context to carry around.
-         */
-        state = xfs_da_state_alloc();
-        state->args = args;
-        state->mp = args->dp->i_mount;
-        state->blocksize = state->mp->m_sb.sb_blocksize;
-        state->node_ents = state->mp->m_dir_node_ents;
-        /*
-         * Search to see if name already exists, and get back a pointer
-         * to where it should go.
-         */
-        error = xfs_da_node_lookup_int(state, &retval);
-        if (error)
-                retval = error;
-        if (retval != ENOENT)
-                goto error;
-        blk = &state->path.blk[ state->path.active-1 ];
-        ASSERT(blk->magic == XFS_DIR_LEAF_MAGIC);
-        retval = xfs_dir_leaf_add(blk->bp, args, blk->index);
-        if (retval == 0) {
-                /*
-                 * Addition succeeded, update Btree hashvals.
-                 */
-                if (!args->justcheck)
-                        xfs_da_fixhashpath(state, &state->path);
-        } else {
-                /*
-                 * Addition failed, split as many Btree elements as required.
-                 */
-                if (args->total == 0) {
-                        ASSERT(retval == ENOSPC);
-                        goto error;
-                }
-                retval = xfs_da_split(state);
-        }
-error:
-        xfs_da_state_free(state);
-        return(retval);
-}
-/*
- * Remove a name from a B-tree directory.
- *
- * This will involve walking down the Btree, and may involve joining
- * leaf nodes and even joining intermediate nodes up to and including
- * the root node (a special case of an intermediate node).
- */
-STATIC int
-xfs_dir_node_removename(xfs_da_args_t *args)
-{
-        xfs_da_state_t *state;
-        xfs_da_state_blk_t *blk;
-        int retval, error;
-        state = xfs_da_state_alloc();
-        state->args = args;
-        state->mp = args->dp->i_mount;
-        state->blocksize = state->mp->m_sb.sb_blocksize;
-        state->node_ents = state->mp->m_dir_node_ents;
-        /*
-         * Search to see if name exists, and get back a pointer to it.
-         */
-        error = xfs_da_node_lookup_int(state, &retval);
-        if (error)
-                retval = error;
-        if (retval != EEXIST) {
-                xfs_da_state_free(state);
-                return(retval);
-        }
-        /*
-         * Remove the name and update the hashvals in the tree.
-         */
-        blk = &state->path.blk[ state->path.active-1 ];
-        ASSERT(blk->magic == XFS_DIR_LEAF_MAGIC);
-        retval = xfs_dir_leaf_remove(args->trans, blk->bp, blk->index);
-        xfs_da_fixhashpath(state, &state->path);
-        /*
-         * Check to see if the tree needs to be collapsed.
-         */
-        error = 0;
-        if (retval) {
-                error = xfs_da_join(state);
-        }
-        xfs_da_state_free(state);
-        if (error)
-                return(error);
-        return(0);
-}
-/*
- * Look up a filename in a int directory.
- * Use an internal routine to actually do all the work.
- */
-STATIC int
-xfs_dir_node_lookup(xfs_da_args_t *args)
-{
-        xfs_da_state_t *state;
-        int retval, error, i;
-        state = xfs_da_state_alloc();
-        state->args = args;
-        state->mp = args->dp->i_mount;
-        state->blocksize = state->mp->m_sb.sb_blocksize;
-        state->node_ents = state->mp->m_dir_node_ents;
-        /*
-         * Search to see if name exists,
-         * and get back a pointer to it.
-         */
-        error = xfs_da_node_lookup_int(state, &retval);
-        if (error) {
-                retval = error;
-        }
-        /*
-         * If not in a transaction, we have to release all the buffers.
-         */
-        for (i = 0; i < state->path.active; i++) {
-                xfs_da_brelse(args->trans, state->path.blk[i].bp);
-                state->path.blk[i].bp = NULL;
-        }
-        xfs_da_state_free(state);
-        return(retval);
-}
-STATIC int
-xfs_dir_node_getdents(xfs_trans_t *trans, xfs_inode_t *dp, uio_t *uio,
-                                  int *eofp, xfs_dirent_t *dbp, xfs_dir_put_t put)
-{
-        xfs_da_intnode_t *node;
-        xfs_da_node_entry_t *btree;
-        xfs_dir_leafblock_t *leaf = NULL;
-        xfs_dablk_t bno, nextbno;
-        xfs_dahash_t cookhash;
-        xfs_mount_t *mp;
-        int error, eob, i;
-        xfs_dabuf_t *bp;
-        xfs_daddr_t nextda;
-        /*
-         * Pick up our context.
-         */
-        mp = dp->i_mount;
-        bp = NULL;
-        bno = XFS_DA_COOKIE_BNO(mp, uio->uio_offset);
-        cookhash = XFS_DA_COOKIE_HASH(mp, uio->uio_offset);
-        xfs_dir_trace_g_du("node: start", dp, uio);
-        /*
-         * Re-find our place, even if we're confused about what our place is.
-         *
-         * First we check the block number from the magic cookie, it is a
-         * cache of where we ended last time.  If we find a leaf block, and
-         * the starting hashval in that block is less than our desired
-         * hashval, then we run with it.
-         */
-        if (bno > 0) {
-                error = xfs_da_read_buf(trans, dp, bno, -2, &bp, XFS_DATA_FORK);
-                if ((error != 0) && (error != EFSCORRUPTED))
-                        return(error);
-                if (bp)
-                        leaf = bp->data;
-                if (bp && be16_to_cpu(leaf->hdr.info.magic) != XFS_DIR_LEAF_MAGIC) {
-                        xfs_dir_trace_g_dub("node: block not a leaf",
-                                                   dp, uio, bno);
-                        xfs_da_brelse(trans, bp);
-                        bp = NULL;
-                }
-                if (bp && INT_GET(leaf->entries[0].hashval, ARCH_CONVERT) > cookhash) {
-                        xfs_dir_trace_g_dub("node: leaf hash too large",
-                                                   dp, uio, bno);
-                        xfs_da_brelse(trans, bp);
-                        bp = NULL;
-                }
-                if (bp &&
-                    cookhash > INT_GET(leaf->entries[INT_GET(leaf->hdr.count, ARCH_CONVERT) - 1].hashval, ARCH_CONVERT)) {
-                        xfs_dir_trace_g_dub("node: leaf hash too small",
-                                                   dp, uio, bno);
-                        xfs_da_brelse(trans, bp);
-                        bp = NULL;
-                }
-        }
-        /*
-         * If we did not find a leaf block from the blockno in the cookie,
-         * or we there was no blockno in the cookie (eg: first time thru),
-         * the we start at the top of the Btree and re-find our hashval.
-         */
-        if (bp == NULL) {
-                xfs_dir_trace_g_du("node: start at root" , dp, uio);
-                bno = 0;
-                for (;;) {
-                        error = xfs_da_read_buf(trans, dp, bno, -1, &bp,
-                                                       XFS_DATA_FORK);
-                        if (error)
-                                return(error);
-                        if (bp == NULL)
-                                return(XFS_ERROR(EFSCORRUPTED));
-                        node = bp->data;
-                        if (be16_to_cpu(node->hdr.info.magic) != XFS_DA_NODE_MAGIC)
-                                break;
-                        btree = &node->btree[0];
-                        xfs_dir_trace_g_dun("node: node detail", dp, uio, node);
-                        for (i = 0; i < be16_to_cpu(node->hdr.count); btree++, i++) {
-                                if (be32_to_cpu(btree->hashval) >= cookhash) {
-                                        bno = be32_to_cpu(btree->before);
-                                        break;
-                                }
-                        }
-                        if (i == be16_to_cpu(node->hdr.count)) {
-                                xfs_da_brelse(trans, bp);
-                                xfs_dir_trace_g_du("node: hash beyond EOF",
-                                                          dp, uio);
-                                uio->uio_offset = XFS_DA_MAKE_COOKIE(mp, 0, 0,
-                                                             XFS_DA_MAXHASH);
-                                *eofp = 1;
-                                return(0);
-                        }
-                        xfs_dir_trace_g_dub("node: going to block",
-                                                   dp, uio, bno);
-                        xfs_da_brelse(trans, bp);
-                }
-        }
-        ASSERT(cookhash != XFS_DA_MAXHASH);
-        /*
-         * We've dropped down to the (first) leaf block that contains the
-         * hashval we are interested in.  Continue rolling upward thru the
-         * leaf blocks until we fill up our buffer.
-         */
-        for (;;) {
-                leaf = bp->data;
-                if (unlikely(be16_to_cpu(leaf->hdr.info.magic) != XFS_DIR_LEAF_MAGIC)) {
-                        xfs_dir_trace_g_dul("node: not a leaf", dp, uio, leaf);
-                        xfs_da_brelse(trans, bp);
-                        XFS_CORRUPTION_ERROR("xfs_dir_node_getdents(1)",
-                                             XFS_ERRLEVEL_LOW, mp, leaf);
-                        return XFS_ERROR(EFSCORRUPTED);
-                }
-                xfs_dir_trace_g_dul("node: leaf detail", dp, uio, leaf);
-                if ((nextbno = be32_to_cpu(leaf->hdr.info.forw))) {
-                        nextda = xfs_da_reada_buf(trans, dp, nextbno,
-                                                  XFS_DATA_FORK);
-                } else
-                        nextda = -1;
-                error = xfs_dir_leaf_getdents_int(bp, dp, bno, uio, &eob, dbp,
-                                                  put, nextda);
-                xfs_da_brelse(trans, bp);
-                bno = nextbno;
-                if (eob) {
-                        xfs_dir_trace_g_dub("node: E-O-B", dp, uio, bno);
-                        *eofp = 0;
-                        return(error);
-                }
-                if (bno == 0)
-                        break;
-                error = xfs_da_read_buf(trans, dp, bno, nextda, &bp,
-                                        XFS_DATA_FORK);
-                if (error)
-                        return(error);
-                if (unlikely(bp == NULL)) {
-                        XFS_ERROR_REPORT("xfs_dir_node_getdents(2)",
-                                         XFS_ERRLEVEL_LOW, mp);
-                        return(XFS_ERROR(EFSCORRUPTED));
-                }
-        }
-        *eofp = 1;
-        xfs_dir_trace_g_du("node: E-O-F", dp, uio);
-        return(0);
-}
-/*
- * Look up a filename in an int directory, replace the inode number.
- * Use an internal routine to actually do the lookup.
- */
-STATIC int
-xfs_dir_node_replace(xfs_da_args_t *args)
-{
-        xfs_da_state_t *state;
-        xfs_da_state_blk_t *blk;
-        xfs_dir_leafblock_t *leaf;
-        xfs_dir_leaf_entry_t *entry;
-        xfs_dir_leaf_name_t *namest;
-        xfs_ino_t inum;
-        int retval, error, i;
-        xfs_dabuf_t *bp;
-        state = xfs_da_state_alloc();
-        state->args = args;
-        state->mp = args->dp->i_mount;
-        state->blocksize = state->mp->m_sb.sb_blocksize;
-        state->node_ents = state->mp->m_dir_node_ents;
-        inum = args->inumber;
-        /*
-         * Search to see if name exists,
-         * and get back a pointer to it.
-         */
-        error = xfs_da_node_lookup_int(state, &retval);
-        if (error) {
-                retval = error;
-        }
-        if (retval == EEXIST) {
-                blk = &state->path.blk[state->path.active - 1];
-                ASSERT(blk->magic == XFS_DIR_LEAF_MAGIC);
-                bp = blk->bp;
-                leaf = bp->data;
-                entry = &leaf->entries[blk->index];
-                namest = XFS_DIR_LEAF_NAMESTRUCT(leaf, INT_GET(entry->nameidx, ARCH_CONVERT));
-                /* XXX - replace assert ? */
-                XFS_DIR_SF_PUT_DIRINO(&inum, &namest->inumber);
-                xfs_da_log_buf(args->trans, bp,
-                    XFS_DA_LOGRANGE(leaf, namest, sizeof(namest->inumber)));
-                xfs_da_buf_done(bp);
-                blk->bp = NULL;
-                retval = 0;
-        } else {
-                i = state->path.active - 1;
-                xfs_da_brelse(args->trans, state->path.blk[i].bp);
-                state->path.blk[i].bp = NULL;
-        }
-        for (i = 0; i < state->path.active - 1; i++) {
-                xfs_da_brelse(args->trans, state->path.blk[i].bp);
-                state->path.blk[i].bp = NULL;
-        }
-        xfs_da_state_free(state);
-        return(retval);
-}
-#if defined(XFS_DIR_TRACE)
-/*
- * Add a trace buffer entry for an inode and a uio.
- */
-void
-xfs_dir_trace_g_du(char *where, xfs_inode_t *dp, uio_t *uio)
-{
-        xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DU, where,
-                     (void *)dp, (void *)dp->i_mount,
-                     (void *)((unsigned long)(uio->uio_offset >> 32)),
-                     (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)),
-                     (void *)(unsigned long)uio->uio_resid,
-                     NULL, NULL, NULL, NULL, NULL, NULL, NULL);
-}
-/*
- * Add a trace buffer entry for an inode and a uio.
- */
-void
-xfs_dir_trace_g_dub(char *where, xfs_inode_t *dp, uio_t *uio, xfs_dablk_t bno)
-{
-        xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DUB, where,
-                     (void *)dp, (void *)dp->i_mount,
-                     (void *)((unsigned long)(uio->uio_offset >> 32)),
-                     (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)),
-                     (void *)(unsigned long)uio->uio_resid,
-                     (void *)(unsigned long)bno,
-                     NULL, NULL, NULL, NULL, NULL, NULL);
-}
-/*
- * Add a trace buffer entry for an inode and a uio.
- */
-void
-xfs_dir_trace_g_dun(char *where, xfs_inode_t *dp, uio_t *uio,
-                        xfs_da_intnode_t *node)
-{
-        int     last = be16_to_cpu(node->hdr.count) - 1;
-        xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DUN, where,
-                     (void *)dp, (void *)dp->i_mount,
-                     (void *)((unsigned long)(uio->uio_offset >> 32)),
-                     (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)),
-                     (void *)(unsigned long)uio->uio_resid,
-                     (void *)(unsigned long)be32_to_cpu(node->hdr.info.forw),
-                     (void *)(unsigned long)
-                        be16_to_cpu(node->hdr.count),
-                     (void *)(unsigned long)
-                        be32_to_cpu(node->btree[0].hashval),
-                     (void *)(unsigned long)
-                        be32_to_cpu(node->btree[last].hashval),
-                     NULL, NULL, NULL);
-}
-/*
- * Add a trace buffer entry for an inode and a uio.
- */
-void
-xfs_dir_trace_g_dul(char *where, xfs_inode_t *dp, uio_t *uio,
-                        xfs_dir_leafblock_t *leaf)
-{
-        int     last = INT_GET(leaf->hdr.count, ARCH_CONVERT) - 1;
-        xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DUL, where,
-                     (void *)dp, (void *)dp->i_mount,
-                     (void *)((unsigned long)(uio->uio_offset >> 32)),
-                     (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)),
-                     (void *)(unsigned long)uio->uio_resid,
-                     (void *)(unsigned long)be32_to_cpu(leaf->hdr.info.forw),
-                     (void *)(unsigned long)
-                        INT_GET(leaf->hdr.count, ARCH_CONVERT),
-                     (void *)(unsigned long)
-                        INT_GET(leaf->entries[0].hashval, ARCH_CONVERT),
-                     (void *)(unsigned long)
-                        INT_GET(leaf->entries[last].hashval, ARCH_CONVERT),
-                     NULL, NULL, NULL);
-}
-/*
- * Add a trace buffer entry for an inode and a uio.
- */
-void
-xfs_dir_trace_g_due(char *where, xfs_inode_t *dp, uio_t *uio,
-                        xfs_dir_leaf_entry_t *entry)
-{
-        xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DUE, where,
-                     (void *)dp, (void *)dp->i_mount,
-                     (void *)((unsigned long)(uio->uio_offset >> 32)),
-                     (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)),
-                     (void *)(unsigned long)uio->uio_resid,
-                     (void *)(unsigned long)
-                        INT_GET(entry->hashval, ARCH_CONVERT),
-                     NULL, NULL, NULL, NULL, NULL, NULL);
-}
-/*
- * Add a trace buffer entry for an inode and a uio.
- */
-void
-xfs_dir_trace_g_duc(char *where, xfs_inode_t *dp, uio_t *uio, xfs_off_t cookie)
-{
-        xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DUC, where,
-                     (void *)dp, (void *)dp->i_mount,
-                     (void *)((unsigned long)(uio->uio_offset >> 32)),
-                     (void *)((unsigned long)(uio->uio_offset & 0xFFFFFFFF)),
-                     (void *)(unsigned long)uio->uio_resid,
-                     (void *)((unsigned long)(cookie >> 32)),
-                     (void *)((unsigned long)(cookie & 0xFFFFFFFF)),
-                     NULL, NULL, NULL, NULL, NULL);
-}
-/*
- * Add a trace buffer entry for the arguments given to the routine,
- * generic form.
- */
-void
-xfs_dir_trace_enter(int type, char *where,
-                        void * a0, void * a1,
-                        void * a2, void * a3,
-                        void * a4, void * a5,
-                        void * a6, void * a7,
-                        void * a8, void * a9,
-                        void * a10, void * a11)
-{
-        ASSERT(xfs_dir_trace_buf);
-        ktrace_enter(xfs_dir_trace_buf, (void *)(unsigned long)type,
-                                        (void *)where,
-                                        (void *)a0, (void *)a1, (void *)a2,
-                                        (void *)a3, (void *)a4, (void *)a5,
-                                        (void *)a6, (void *)a7, (void *)a8,
-                                        (void *)a9, (void *)a10, (void *)a11,
-                                        NULL, NULL);
-}
-#endif  /* XFS_DIR_TRACE */
diff --git a/fs/xfs/xfs_dir.h b/fs/xfs/xfs_dir.h
deleted file mode 100644
index 8cc8afb9f6c0..000000000000
--- a/fs/xfs/xfs_dir.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/*
- * Copyright (c) 2000,2005 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_DIR_H__
-#define __XFS_DIR_H__
-/*
- * Large directories are structured around Btrees where all the data
- * elements are in the leaf nodes.  Filenames are hashed into an int,
- * then that int is used as the index into the Btree.  Since the hashval
- * of a filename may not be unique, we may have duplicate keys.  The
- * internal links in the Btree are logical block offsets into the file.
- *
- * Small directories use a different format and are packed as tightly
- * as possible so as to fit into the literal area of the inode.
- */
-/*========================================================================
- * Function prototypes for the kernel.
- *========================================================================*/
-struct uio;
-struct xfs_bmap_free;
-struct xfs_da_args;
-struct xfs_dinode;
-struct xfs_inode;
-struct xfs_mount;
-struct xfs_trans;
-/*
- * Directory function types.
- * Put in structures (xfs_dirops_t) for v1 and v2 directories.
- */
-typedef void    (*xfs_dir_mount_t)(struct xfs_mount *mp);
-typedef int     (*xfs_dir_isempty_t)(struct xfs_inode *dp);
-typedef int     (*xfs_dir_init_t)(struct xfs_trans *tp,
-                                  struct xfs_inode *dp,
-                                  struct xfs_inode *pdp);
-typedef int     (*xfs_dir_createname_t)(struct xfs_trans *tp,
-                                        struct xfs_inode *dp,
-                                        char *name,
-                                        int namelen,
-                                        xfs_ino_t inum,
-                                        xfs_fsblock_t *first,
-                                        struct xfs_bmap_free *flist,
-                                        xfs_extlen_t total);
-typedef int     (*xfs_dir_lookup_t)(struct xfs_trans *tp,
-                                    struct xfs_inode *dp,
-                                    char *name,
-                                    int namelen,
-                                    xfs_ino_t *inum);
-typedef int     (*xfs_dir_removename_t)(struct xfs_trans *tp,
-                                        struct xfs_inode *dp,
-                                        char *name,
-                                        int namelen,
-                                        xfs_ino_t ino,
-                                        xfs_fsblock_t *first,
-                                        struct xfs_bmap_free *flist,
-                                        xfs_extlen_t total);
-typedef int     (*xfs_dir_getdents_t)(struct xfs_trans *tp,
-                                      struct xfs_inode *dp,
-                                      struct uio *uio,
-                                      int *eofp);
-typedef int     (*xfs_dir_replace_t)(struct xfs_trans *tp,
-                                     struct xfs_inode *dp,
-                                     char *name,
-                                     int namelen,
-                                     xfs_ino_t inum,
-                                     xfs_fsblock_t *first,
-                                     struct xfs_bmap_free *flist,
-                                     xfs_extlen_t total);
-typedef int     (*xfs_dir_canenter_t)(struct xfs_trans *tp,
-                                      struct xfs_inode *dp,
-                                      char *name,
-                                      int namelen);
-typedef int     (*xfs_dir_shortform_validate_ondisk_t)(struct xfs_mount *mp,
-                                                       struct xfs_dinode *dip);
-typedef int     (*xfs_dir_shortform_to_single_t)(struct xfs_da_args *args);
-typedef struct xfs_dirops {
-        xfs_dir_mount_t                         xd_mount;
-        xfs_dir_isempty_t                       xd_isempty;
-        xfs_dir_init_t                          xd_init;
-        xfs_dir_createname_t                    xd_createname;
-        xfs_dir_lookup_t                        xd_lookup;
-        xfs_dir_removename_t                    xd_removename;
-        xfs_dir_getdents_t                      xd_getdents;
-        xfs_dir_replace_t                       xd_replace;
-        xfs_dir_canenter_t                      xd_canenter;
-        xfs_dir_shortform_validate_ondisk_t     xd_shortform_validate_ondisk;
-        xfs_dir_shortform_to_single_t           xd_shortform_to_single;
-} xfs_dirops_t;
-/*
- * Overall external interface routines.
- */
-void    xfs_dir_startup(void);  /* called exactly once */
-#define XFS_DIR_MOUNT(mp)       \
-        ((mp)->m_dirops.xd_mount(mp))
-#define XFS_DIR_ISEMPTY(mp,dp)  \
-        ((mp)->m_dirops.xd_isempty(dp))
-#define XFS_DIR_INIT(mp,tp,dp,pdp)      \
-        ((mp)->m_dirops.xd_init(tp,dp,pdp))
-#define XFS_DIR_CREATENAME(mp,tp,dp,name,namelen,inum,first,flist,total) \
-        ((mp)->m_dirops.xd_createname(tp,dp,name,namelen,inum,first,flist,\
-                                      total))
-#define XFS_DIR_LOOKUP(mp,tp,dp,name,namelen,inum)      \
-        ((mp)->m_dirops.xd_lookup(tp,dp,name,namelen,inum))
-#define XFS_DIR_REMOVENAME(mp,tp,dp,name,namelen,ino,first,flist,total) \
-        ((mp)->m_dirops.xd_removename(tp,dp,name,namelen,ino,first,flist,total))
-#define XFS_DIR_GETDENTS(mp,tp,dp,uio,eofp)     \
-        ((mp)->m_dirops.xd_getdents(tp,dp,uio,eofp))
-#define XFS_DIR_REPLACE(mp,tp,dp,name,namelen,inum,first,flist,total)   \
-        ((mp)->m_dirops.xd_replace(tp,dp,name,namelen,inum,first,flist,total))
-#define XFS_DIR_CANENTER(mp,tp,dp,name,namelen) \
-        ((mp)->m_dirops.xd_canenter(tp,dp,name,namelen))
-#define XFS_DIR_SHORTFORM_VALIDATE_ONDISK(mp,dip)       \
-        ((mp)->m_dirops.xd_shortform_validate_ondisk(mp,dip))
-#define XFS_DIR_SHORTFORM_TO_SINGLE(mp,args)    \
-        ((mp)->m_dirops.xd_shortform_to_single(args))
-#define XFS_DIR_IS_V1(mp)       ((mp)->m_dirversion == 1)
-#define XFS_DIR_IS_V2(mp)       ((mp)->m_dirversion == 2)
-extern xfs_dirops_t xfsv1_dirops;
-extern xfs_dirops_t xfsv2_dirops;
-#endif  /* __XFS_DIR_H__ */
diff --git a/fs/xfs/xfs_dir2.c b/fs/xfs/xfs_dir2.c
index 022c8398ab62..8edbe1adb95b 100644
--- a/fs/xfs/xfs_dir2.c
+++ b/fs/xfs/xfs_dir2.c
@@ -24,21 +24,18 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_inode_item.h"
 #include "xfs_bmap.h"
-#include "xfs_dir_leaf.h"
 #include "xfs_dir2_data.h"
 #include "xfs_dir2_leaf.h"
 #include "xfs_dir2_block.h"
@@ -46,69 +43,14 @@
 #include "xfs_dir2_trace.h"
 #include "xfs_error.h"
-/*
- * Declarations for interface routines.
- */
-static void     xfs_dir2_mount(xfs_mount_t *mp);
-static int      xfs_dir2_isempty(xfs_inode_t *dp);
-static int      xfs_dir2_init(xfs_trans_t *tp, xfs_inode_t *dp,
-                              xfs_inode_t *pdp);
-static int      xfs_dir2_createname(xfs_trans_t *tp, xfs_inode_t *dp,
-                                    char *name, int namelen, xfs_ino_t inum,
-                                    xfs_fsblock_t *first,
-                                    xfs_bmap_free_t *flist, xfs_extlen_t total);
-static int      xfs_dir2_lookup(xfs_trans_t *tp, xfs_inode_t *dp, char *name,
-                                int namelen, xfs_ino_t *inum);
-static int      xfs_dir2_removename(xfs_trans_t *tp, xfs_inode_t *dp,
-                                    char *name, int namelen, xfs_ino_t ino,
-                                    xfs_fsblock_t *first,
-                                    xfs_bmap_free_t *flist, xfs_extlen_t total);
-static int      xfs_dir2_getdents(xfs_trans_t *tp, xfs_inode_t *dp, uio_t *uio,
-                                  int *eofp);
-static int      xfs_dir2_replace(xfs_trans_t *tp, xfs_inode_t *dp, char *name,
-                                 int namelen, xfs_ino_t inum,
-                                 xfs_fsblock_t *first, xfs_bmap_free_t *flist,
-                                 xfs_extlen_t total);
-static int      xfs_dir2_canenter(xfs_trans_t *tp, xfs_inode_t *dp, char *name,
-                                  int namelen);
-static int      xfs_dir2_shortform_validate_ondisk(xfs_mount_t *mp,
-                                                   xfs_dinode_t *dip);
-/*
- * Utility routine declarations.
- */
 static int      xfs_dir2_put_dirent64_direct(xfs_dir2_put_args_t *pa);
 static int      xfs_dir2_put_dirent64_uio(xfs_dir2_put_args_t *pa);
-/*
+void
- * Directory operations vector.
+xfs_dir_mount(
- */
+        xfs_mount_t     *mp)
-xfs_dirops_t    xfsv2_dirops = {
-        .xd_mount                       = xfs_dir2_mount,
-        .xd_isempty                     = xfs_dir2_isempty,
-        .xd_init                        = xfs_dir2_init,
-        .xd_createname                  = xfs_dir2_createname,
-        .xd_lookup                      = xfs_dir2_lookup,
-        .xd_removename                  = xfs_dir2_removename,
-        .xd_getdents                    = xfs_dir2_getdents,
-        .xd_replace                     = xfs_dir2_replace,
-        .xd_canenter                    = xfs_dir2_canenter,
-        .xd_shortform_validate_ondisk   = xfs_dir2_shortform_validate_ondisk,
-        .xd_shortform_to_single         = xfs_dir2_sf_to_block,
-};
-/*
- * Interface routines.
- */
-/*
- * Initialize directory-related fields in the mount structure.
- */
-static void
-xfs_dir2_mount(
-        xfs_mount_t     *mp)            /* filesystem mount point */
 {
-        mp->m_dirversion = 2;
+        ASSERT(XFS_SB_VERSION_HASDIRV2(&mp->m_sb));
        ASSERT((1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog)) <=
               XFS_MAX_BLOCKSIZE);
        mp->m_dirblksize = 1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog);
@@ -128,19 +70,15 @@ xfs_dir2_mount(
 /*
 * Return 1 if directory contains only "." and "..".
 */
-static int                              /* return code */
+int
-xfs_dir2_isempty(
+xfs_dir_isempty(
-        xfs_inode_t     *dp)            /* incore inode structure */
+        xfs_inode_t     *dp)
 {
-        xfs_dir2_sf_t   *sfp;           /* shortform directory structure */
+        xfs_dir2_sf_t   *sfp;
        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
-        /*
+        if (dp->i_d.di_size == 0)       /* might happen during shutdown. */
-         * Might happen during shutdown.
-         */
-        if (dp->i_d.di_size == 0) {
                return 1;
-        }
        if (dp->i_d.di_size > XFS_IFORK_DSIZE(dp))
                return 0;
        sfp = (xfs_dir2_sf_t *)dp->i_df.if_u1.if_data;
@@ -148,53 +86,83 @@ xfs_dir2_isempty(
 }
 /*
+ * Validate a given inode number.
+ */
+int
+xfs_dir_ino_validate(
+        xfs_mount_t     *mp,
+        xfs_ino_t       ino)
+{
+        xfs_agblock_t   agblkno;
+        xfs_agino_t     agino;
+        xfs_agnumber_t  agno;
+        int             ino_ok;
+        int             ioff;
+        agno = XFS_INO_TO_AGNO(mp, ino);
+        agblkno = XFS_INO_TO_AGBNO(mp, ino);
+        ioff = XFS_INO_TO_OFFSET(mp, ino);
+        agino = XFS_OFFBNO_TO_AGINO(mp, agblkno, ioff);
+        ino_ok =
+                agno < mp->m_sb.sb_agcount &&
+                agblkno < mp->m_sb.sb_agblocks &&
+                agblkno != 0 &&
+                ioff < (1 << mp->m_sb.sb_inopblog) &&
+                XFS_AGINO_TO_INO(mp, agno, agino) == ino;
+        if (unlikely(XFS_TEST_ERROR(!ino_ok, mp, XFS_ERRTAG_DIR_INO_VALIDATE,
+                        XFS_RANDOM_DIR_INO_VALIDATE))) {
+                xfs_fs_cmn_err(CE_WARN, mp, "Invalid inode number 0x%Lx",
+                                (unsigned long long) ino);
+                XFS_ERROR_REPORT("xfs_dir_ino_validate", XFS_ERRLEVEL_LOW, mp);
+                return XFS_ERROR(EFSCORRUPTED);
+        }
+        return 0;
+}
+/*
 * Initialize a directory with its "." and ".." entries.
 */
-static int                              /* error */
+int
-xfs_dir2_init(
+xfs_dir_init(
-        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_trans_t     *tp,
-        xfs_inode_t     *dp,            /* incore directory inode */
+        xfs_inode_t     *dp,
-        xfs_inode_t     *pdp)           /* incore parent directory inode */
+        xfs_inode_t     *pdp)
 {
-        xfs_da_args_t   args;           /* operation arguments */
+        xfs_da_args_t   args;
-        int             error;          /* error return value */
+        int             error;
        memset((char *)&args, 0, sizeof(args));
        args.dp = dp;
        args.trans = tp;
        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
-        if ((error = xfs_dir_ino_validate(tp->t_mountp, pdp->i_ino))) {
+        if ((error = xfs_dir_ino_validate(tp->t_mountp, pdp->i_ino)))
                return error;
-        }
        return xfs_dir2_sf_create(&args, pdp->i_ino);
 }
 /*
  Enter a name in a directory.
 */
-static int                                      /* error */
+int
-xfs_dir2_createname(
+xfs_dir_createname(
-        xfs_trans_t             *tp,            /* transaction pointer */
+        xfs_trans_t             *tp,
-        xfs_inode_t             *dp,            /* incore directory inode */
+        xfs_inode_t             *dp,
-        char                    *name,          /* new entry name */
+        char                    *name,
-        int                     namelen,        /* new entry name length */
+        int                     namelen,
        xfs_ino_t               inum,           /* new entry inode number */
        xfs_fsblock_t           *first,         /* bmap's firstblock */
        xfs_bmap_free_t         *flist,         /* bmap's freeblock list */
        xfs_extlen_t            total)          /* bmap's total block count */
 {
-        xfs_da_args_t           args;           /* operation arguments */
+        xfs_da_args_t           args;
-        int                     rval;           /* return value */
+        int                     rval;
        int                     v;              /* type-checking value */
        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
-        if ((rval = xfs_dir_ino_validate(tp->t_mountp, inum))) {
+        if ((rval = xfs_dir_ino_validate(tp->t_mountp, inum)))
                return rval;
-        }
        XFS_STATS_INC(xs_dir_create);
-        /*
-         * Fill in the arg structure for this request.
-         */
        args.name = name;
        args.namelen = namelen;
        args.hashval = xfs_da_hashname(name, namelen);
@@ -207,18 +175,16 @@ xfs_dir2_createname(
        args.trans = tp;
        args.justcheck = 0;
        args.addname = args.oknoent = 1;
-        /*
-         * Decide on what work routines to call based on the inode size.
-         */
        if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
                rval = xfs_dir2_sf_addname(&args);
-        else if ((rval = xfs_dir2_isblock(tp, dp, &v))) {
+        else if ((rval = xfs_dir2_isblock(tp, dp, &v)))
                return rval;
-        } else if (v)
+        else if (v)
                rval = xfs_dir2_block_addname(&args);
-        else if ((rval = xfs_dir2_isleaf(tp, dp, &v))) {
+        else if ((rval = xfs_dir2_isleaf(tp, dp, &v)))
                return rval;
-        } else if (v)
+        else if (v)
                rval = xfs_dir2_leaf_addname(&args);
        else
                rval = xfs_dir2_node_addname(&args);
@@ -228,24 +194,21 @@ xfs_dir2_createname(
 /*
 * Lookup a name in a directory, give back the inode number.
 */
-static int                              /* error */
+int
-xfs_dir2_lookup(
+xfs_dir_lookup(
-        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_trans_t     *tp,
-        xfs_inode_t     *dp,            /* incore directory inode */
+        xfs_inode_t     *dp,
-        char            *name,          /* lookup name */
+        char            *name,
-        int             namelen,        /* lookup name length */
+        int             namelen,
        xfs_ino_t       *inum)          /* out: inode number */
 {
-        xfs_da_args_t   args;           /* operation arguments */
+        xfs_da_args_t   args;
-        int             rval;           /* return value */
+        int             rval;
        int             v;              /* type-checking value */
        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
        XFS_STATS_INC(xs_dir_lookup);
-        /*
-         * Fill in the arg structure for this request.
-         */
        args.name = name;
        args.namelen = namelen;
        args.hashval = xfs_da_hashname(name, namelen);
@@ -258,18 +221,16 @@ xfs_dir2_lookup(
        args.trans = tp;
        args.justcheck = args.addname = 0;
        args.oknoent = 1;
-        /*
-         * Decide on what work routines to call based on the inode size.
-         */
        if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
                rval = xfs_dir2_sf_lookup(&args);
-        else if ((rval = xfs_dir2_isblock(tp, dp, &v))) {
+        else if ((rval = xfs_dir2_isblock(tp, dp, &v)))
                return rval;
-        } else if (v)
+        else if (v)
                rval = xfs_dir2_block_lookup(&args);
-        else if ((rval = xfs_dir2_isleaf(tp, dp, &v))) {
+        else if ((rval = xfs_dir2_isleaf(tp, dp, &v)))
                return rval;
-        } else if (v)
+        else if (v)
                rval = xfs_dir2_leaf_lookup(&args);
        else
                rval = xfs_dir2_node_lookup(&args);
@@ -283,26 +244,24 @@ xfs_dir2_lookup(
 /*
 * Remove an entry from a directory.
 */
-static int                              /* error */
+int
-xfs_dir2_removename(
+xfs_dir_removename(
-        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_trans_t     *tp,
-        xfs_inode_t     *dp,            /* incore directory inode */
+        xfs_inode_t     *dp,
-        char            *name,          /* name of entry to remove */
+        char            *name,
-        int             namelen,        /* name length of entry to remove */
+        int             namelen,
-        xfs_ino_t       ino,            /* inode number of entry to remove */
+        xfs_ino_t       ino,
        xfs_fsblock_t   *first,         /* bmap's firstblock */
        xfs_bmap_free_t *flist,         /* bmap's freeblock list */
        xfs_extlen_t    total)          /* bmap's total block count */
 {
-        xfs_da_args_t   args;           /* operation arguments */
+        xfs_da_args_t   args;
-        int             rval;           /* return value */
+        int             rval;
        int             v;              /* type-checking value */
        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
        XFS_STATS_INC(xs_dir_remove);
-        /*
-         * Fill in the arg structure for this request.
-         */
        args.name = name;
        args.namelen = namelen;
        args.hashval = xfs_da_hashname(name, namelen);
@@ -314,18 +273,16 @@ xfs_dir2_removename(
        args.whichfork = XFS_DATA_FORK;
        args.trans = tp;
        args.justcheck = args.addname = args.oknoent = 0;
-        /*
-         * Decide on what work routines to call based on the inode size.
-         */
        if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
                rval = xfs_dir2_sf_removename(&args);
-        else if ((rval = xfs_dir2_isblock(tp, dp, &v))) {
+        else if ((rval = xfs_dir2_isblock(tp, dp, &v)))
                return rval;
-        } else if (v)
+        else if (v)
                rval = xfs_dir2_block_removename(&args);
-        else if ((rval = xfs_dir2_isleaf(tp, dp, &v))) {
+        else if ((rval = xfs_dir2_isleaf(tp, dp, &v)))
                return rval;
-        } else if (v)
+        else if (v)
                rval = xfs_dir2_leaf_removename(&args);
        else
                rval = xfs_dir2_node_removename(&args);
@@ -335,10 +292,10 @@ xfs_dir2_removename(
 /*
 * Read a directory.
 */
-static int                              /* error */
+int
-xfs_dir2_getdents(
+xfs_dir_getdents(
-        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_trans_t     *tp,
-        xfs_inode_t     *dp,            /* incore directory inode */
+        xfs_inode_t     *dp,
        uio_t           *uio,           /* caller's buffer control */
        int             *eofp)          /* out: eof reached */
 {
@@ -367,14 +324,11 @@ xfs_dir2_getdents(
        }
        *eofp = 0;
-        /*
-         * Decide on what work routines to call based on the inode size.
-         */
        if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
                rval = xfs_dir2_sf_getdents(dp, uio, eofp, dbp, put);
-        else if ((rval = xfs_dir2_isblock(tp, dp, &v))) {
+        else if ((rval = xfs_dir2_isblock(tp, dp, &v)))
                ;
-        } else if (v)
+        else if (v)
                rval = xfs_dir2_block_getdents(tp, dp, uio, eofp, dbp, put);
        else
                rval = xfs_dir2_leaf_getdents(tp, dp, uio, eofp, dbp, put);
@@ -386,29 +340,26 @@ xfs_dir2_getdents(
 /*
 * Replace the inode number of a directory entry.
 */
-static int                              /* error */
+int
-xfs_dir2_replace(
+xfs_dir_replace(
-        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_trans_t     *tp,
-        xfs_inode_t     *dp,            /* incore directory inode */
+        xfs_inode_t     *dp,
        char            *name,          /* name of entry to replace */
-        int             namelen,        /* name length of entry to replace */
+        int             namelen,
        xfs_ino_t       inum,           /* new inode number */
        xfs_fsblock_t   *first,         /* bmap's firstblock */
        xfs_bmap_free_t *flist,         /* bmap's freeblock list */
        xfs_extlen_t    total)          /* bmap's total block count */
 {
-        xfs_da_args_t   args;           /* operation arguments */
+        xfs_da_args_t   args;
-        int             rval;           /* return value */
+        int             rval;
        int             v;              /* type-checking value */
        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
-        if ((rval = xfs_dir_ino_validate(tp->t_mountp, inum))) {
+        if ((rval = xfs_dir_ino_validate(tp->t_mountp, inum)))
                return rval;
-        }
-        /*
-         * Fill in the arg structure for this request.
-         */
        args.name = name;
        args.namelen = namelen;
        args.hashval = xfs_da_hashname(name, namelen);
@@ -420,18 +371,16 @@ xfs_dir2_replace(
        args.whichfork = XFS_DATA_FORK;
        args.trans = tp;
        args.justcheck = args.addname = args.oknoent = 0;
-        /*
-         * Decide on what work routines to call based on the inode size.
-         */
        if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
                rval = xfs_dir2_sf_replace(&args);
-        else if ((rval = xfs_dir2_isblock(tp, dp, &v))) {
+        else if ((rval = xfs_dir2_isblock(tp, dp, &v)))
                return rval;
-        } else if (v)
+        else if (v)
                rval = xfs_dir2_block_replace(&args);
-        else if ((rval = xfs_dir2_isleaf(tp, dp, &v))) {
+        else if ((rval = xfs_dir2_isleaf(tp, dp, &v)))
                return rval;
-        } else if (v)
+        else if (v)
                rval = xfs_dir2_leaf_replace(&args);
        else
                rval = xfs_dir2_node_replace(&args);
@@ -441,21 +390,19 @@ xfs_dir2_replace(
 /*
 * See if this entry can be added to the directory without allocating space.
 */
-static int                              /* error */
+int
-xfs_dir2_canenter(
+xfs_dir_canenter(
-        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_trans_t     *tp,
-        xfs_inode_t     *dp,            /* incore directory inode */
+        xfs_inode_t     *dp,
        char            *name,          /* name of entry to add */
-        int             namelen)        /* name length of entry to add */
+        int             namelen)
 {
-        xfs_da_args_t   args;           /* operation arguments */
+        xfs_da_args_t   args;
-        int             rval;           /* return value */
+        int             rval;
        int             v;              /* type-checking value */
        ASSERT((dp->i_d.di_mode & S_IFMT) == S_IFDIR);
-        /*
-         * Fill in the arg structure for this request.
-         */
        args.name = name;
        args.namelen = namelen;
        args.hashval = xfs_da_hashname(name, namelen);
@@ -467,18 +414,16 @@ xfs_dir2_canenter(
        args.whichfork = XFS_DATA_FORK;
        args.trans = tp;
        args.justcheck = args.addname = args.oknoent = 1;
-        /*
-         * Decide on what work routines to call based on the inode size.
-         */
        if (dp->i_d.di_format == XFS_DINODE_FMT_LOCAL)
                rval = xfs_dir2_sf_addname(&args);
-        else if ((rval = xfs_dir2_isblock(tp, dp, &v))) {
+        else if ((rval = xfs_dir2_isblock(tp, dp, &v)))
                return rval;
-        } else if (v)
+        else if (v)
                rval = xfs_dir2_block_addname(&args);
-        else if ((rval = xfs_dir2_isleaf(tp, dp, &v))) {
+        else if ((rval = xfs_dir2_isleaf(tp, dp, &v)))
                return rval;
-        } else if (v)
+        else if (v)
                rval = xfs_dir2_leaf_addname(&args);
        else
                rval = xfs_dir2_node_addname(&args);
@@ -486,19 +431,6 @@ xfs_dir2_canenter(
 }
 /*
- * Dummy routine for shortform inode validation.
- * Can't really do this.
- */
-/* ARGSUSED */
-static int                              /* error */
-xfs_dir2_shortform_validate_ondisk(
-        xfs_mount_t     *mp,            /* filesystem mount point */
-        xfs_dinode_t    *dip)           /* ondisk inode */
-{
-        return 0;
-}
-/*
 * Utility routines.
 */
@@ -507,24 +439,24 @@ xfs_dir2_shortform_validate_ondisk(
 * This routine is for data and free blocks, not leaf/node blocks
 * which are handled by xfs_da_grow_inode.
 */
-int                                     /* error */
+int
 xfs_dir2_grow_inode(
-        xfs_da_args_t   *args,          /* operation arguments */
+        xfs_da_args_t   *args,
        int             space,          /* v2 dir's space XFS_DIR2_xxx_SPACE */
        xfs_dir2_db_t   *dbp)           /* out: block number added */
 {
        xfs_fileoff_t   bno;            /* directory offset of new block */
        int             count;          /* count of filesystem blocks */
        xfs_inode_t     *dp;            /* incore directory inode */
-        int             error;          /* error return value */
+        int             error;
        int             got;            /* blocks actually mapped */
-        int             i;              /* temp mapping index */
+        int             i;
        xfs_bmbt_irec_t map;            /* single structure for bmap */
        int             mapi;           /* mapping index */
        xfs_bmbt_irec_t *mapp;          /* bmap mapping structure(s) */
-        xfs_mount_t     *mp;            /* filesystem mount point */
+        xfs_mount_t     *mp;
        int             nmap;           /* number of bmap entries */
-        xfs_trans_t     *tp;            /* transaction pointer */
+        xfs_trans_t     *tp;
        xfs_dir2_trace_args_s("grow_inode", args, space);
        dp = args->dp;
@@ -538,9 +470,8 @@ xfs_dir2_grow_inode(
        /*
         * Find the first hole for our block.
         */
-        if ((error = xfs_bmap_first_unused(tp, dp, count, &bno, XFS_DATA_FORK))) {
+        if ((error = xfs_bmap_first_unused(tp, dp, count, &bno, XFS_DATA_FORK)))
                return error;
-        }
        nmap = 1;
        ASSERT(args->firstblock != NULL);
        /*
@@ -549,13 +480,9 @@ xfs_dir2_grow_inode(
        if ((error = xfs_bmapi(tp, dp, bno, count,
                        XFS_BMAPI_WRITE|XFS_BMAPI_METADATA|XFS_BMAPI_CONTIG,
                        args->firstblock, args->total, &map, &nmap,
-                        args->flist))) {
+                        args->flist, NULL)))
                return error;
-        }
        ASSERT(nmap <= 1);
-        /*
-         * Got it in 1.
-         */
        if (nmap == 1) {
                mapp = &map;
                mapi = 1;
@@ -585,7 +512,8 @@ xfs_dir2_grow_inode(
                        if ((error = xfs_bmapi(tp, dp, b, c,
                                        XFS_BMAPI_WRITE|XFS_BMAPI_METADATA,
                                        args->firstblock, args->total,
-                                        &mapp[mapi], &nmap, args->flist))) {
+                                        &mapp[mapi], &nmap, args->flist,
+                                        NULL))) {
                                kmem_free(mapp, sizeof(*mapp) * count);
                                return error;
                        }
@@ -645,20 +573,19 @@ xfs_dir2_grow_inode(
 /*
 * See if the directory is a single-block form directory.
 */
-int                                     /* error */
+int
 xfs_dir2_isblock(
-        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_trans_t     *tp,
-        xfs_inode_t     *dp,            /* incore directory inode */
+        xfs_inode_t     *dp,
        int             *vp)            /* out: 1 is block, 0 is not block */
 {
        xfs_fileoff_t   last;           /* last file offset */
-        xfs_mount_t     *mp;            /* filesystem mount point */
+        xfs_mount_t     *mp;
-        int             rval;           /* return value */
+        int             rval;
        mp = dp->i_mount;
-        if ((rval = xfs_bmap_last_offset(tp, dp, &last, XFS_DATA_FORK))) {
+        if ((rval = xfs_bmap_last_offset(tp, dp, &last, XFS_DATA_FORK)))
                return rval;
-        }
        rval = XFS_FSB_TO_B(mp, last) == mp->m_dirblksize;
        ASSERT(rval == 0 || dp->i_d.di_size == mp->m_dirblksize);
        *vp = rval;
@@ -668,20 +595,19 @@ xfs_dir2_isblock(
 /*
 * See if the directory is a single-leaf form directory.
 */
-int                                     /* error */
+int
 xfs_dir2_isleaf(
-        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_trans_t     *tp,
-        xfs_inode_t     *dp,            /* incore directory inode */
+        xfs_inode_t     *dp,
        int             *vp)            /* out: 1 is leaf, 0 is not leaf */
 {
        xfs_fileoff_t   last;           /* last file offset */
-        xfs_mount_t     *mp;            /* filesystem mount point */
+        xfs_mount_t     *mp;
-        int             rval;           /* return value */
+        int             rval;
        mp = dp->i_mount;
-        if ((rval = xfs_bmap_last_offset(tp, dp, &last, XFS_DATA_FORK))) {
+        if ((rval = xfs_bmap_last_offset(tp, dp, &last, XFS_DATA_FORK)))
                return rval;
-        }
        *vp = last == mp->m_dirleafblk + (1 << mp->m_sb.sb_dirblklog);
        return 0;
 }
@@ -689,9 +615,9 @@ xfs_dir2_isleaf(
 /*
 * Getdents put routine for 64-bit ABI, direct form.
 */
-static int                                      /* error */
+static int
 xfs_dir2_put_dirent64_direct(
-        xfs_dir2_put_args_t     *pa)            /* argument bundle */
+        xfs_dir2_put_args_t     *pa)
 {
        xfs_dirent_t            *idbp;          /* dirent pointer */
        iovec_t                 *iovp;          /* io vector */
@@ -726,9 +652,9 @@ xfs_dir2_put_dirent64_direct(
 /*
 * Getdents put routine for 64-bit ABI, uio form.
 */
-static int                                      /* error */
+static int
 xfs_dir2_put_dirent64_uio(
-        xfs_dir2_put_args_t     *pa)            /* argument bundle */
+        xfs_dir2_put_args_t     *pa)
 {
        xfs_dirent_t            *idbp;          /* dirent pointer */
        int                     namelen;        /* entry name length */
@@ -764,17 +690,17 @@ xfs_dir2_put_dirent64_uio(
 */
 int
 xfs_dir2_shrink_inode(
-        xfs_da_args_t   *args,          /* operation arguments */
+        xfs_da_args_t   *args,
-        xfs_dir2_db_t   db,             /* directory block number */
+        xfs_dir2_db_t   db,
-        xfs_dabuf_t     *bp)            /* block's buffer */
+        xfs_dabuf_t     *bp)
 {
        xfs_fileoff_t   bno;            /* directory file offset */
        xfs_dablk_t     da;             /* directory file offset */
        int             done;           /* bunmap is finished */
-        xfs_inode_t     *dp;            /* incore directory inode */
+        xfs_inode_t     *dp;
-        int             error;          /* error return value */
+        int             error;
-        xfs_mount_t     *mp;            /* filesystem mount point */
+        xfs_mount_t     *mp;
-        xfs_trans_t     *tp;            /* transaction pointer */
+        xfs_trans_t     *tp;
        xfs_dir2_trace_args_db("shrink_inode", args, db, bp);
        dp = args->dp;
@@ -786,7 +712,7 @@ xfs_dir2_shrink_inode(
         */
        if ((error = xfs_bunmapi(tp, dp, da, mp->m_dirblkfsbs,
                        XFS_BMAPI_METADATA, 0, args->firstblock, args->flist,
-                        &done))) {
+                        NULL, &done))) {
                /*
                 * ENOSPC actually can happen if we're in a removename with
                 * no space reservation, and the resulting block removal
diff --git a/fs/xfs/xfs_dir2.h b/fs/xfs/xfs_dir2.h
index 7dd364b1e038..86560b6f794c 100644
--- a/fs/xfs/xfs_dir2.h
+++ b/fs/xfs/xfs_dir2.h
@@ -22,7 +22,9 @@ struct uio;
 struct xfs_dabuf;
 struct xfs_da_args;
 struct xfs_dir2_put_args;
+struct xfs_bmap_free;
 struct xfs_inode;
+struct xfs_mount;
 struct xfs_trans;
 /*
@@ -73,7 +75,35 @@ typedef struct xfs_dir2_put_args {
 } xfs_dir2_put_args_t;
 /*
- * Other interfaces used by the rest of the dir v2 code.
+ * Generic directory interface routines
+ */
+extern void xfs_dir_startup(void);
+extern void xfs_dir_mount(struct xfs_mount *mp);
+extern int xfs_dir_isempty(struct xfs_inode *dp);
+extern int xfs_dir_init(struct xfs_trans *tp, struct xfs_inode *dp,
+                                struct xfs_inode *pdp);
+extern int xfs_dir_createname(struct xfs_trans *tp, struct xfs_inode *dp,
+                                char *name, int namelen, xfs_ino_t inum,
+                                xfs_fsblock_t *first,
+                                struct xfs_bmap_free *flist, xfs_extlen_t tot);
+extern int xfs_dir_lookup(struct xfs_trans *tp, struct xfs_inode *dp,
+                                char *name, int namelen, xfs_ino_t *inum);
+extern int xfs_dir_removename(struct xfs_trans *tp, struct xfs_inode *dp,
+                                char *name, int namelen, xfs_ino_t ino,
+                                xfs_fsblock_t *first,
+                                struct xfs_bmap_free *flist, xfs_extlen_t tot);
+extern int xfs_dir_getdents(struct xfs_trans *tp, struct xfs_inode *dp,
+                                uio_t *uio, int *eofp);
+extern int xfs_dir_replace(struct xfs_trans *tp, struct xfs_inode *dp,
+                                char *name, int namelen, xfs_ino_t inum,
+                                xfs_fsblock_t *first,
+                                struct xfs_bmap_free *flist, xfs_extlen_t tot);
+extern int xfs_dir_canenter(struct xfs_trans *tp, struct xfs_inode *dp,
+                                char *name, int namelen);
+extern int xfs_dir_ino_validate(struct xfs_mount *mp, xfs_ino_t ino);
+/*
+ * Utility routines for v2 directories.
 */
 extern int xfs_dir2_grow_inode(struct xfs_da_args *args, int space,
                                xfs_dir2_db_t *dbp);
diff --git a/fs/xfs/xfs_dir2_block.c b/fs/xfs/xfs_dir2_block.c
index 972ded595476..9d7438bba30d 100644
--- a/fs/xfs/xfs_dir2_block.c
+++ b/fs/xfs/xfs_dir2_block.c
@@ -22,19 +22,16 @@
 #include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_inode_item.h"
-#include "xfs_dir_leaf.h"
 #include "xfs_dir2_data.h"
 #include "xfs_dir2_leaf.h"
 #include "xfs_dir2_block.h"
@@ -51,6 +48,18 @@ static int xfs_dir2_block_lookup_int(xfs_da_args_t *args, xfs_dabuf_t **bpp,
                                     int *entno);
 static int xfs_dir2_block_sort(const void *a, const void *b);
+static xfs_dahash_t xfs_dir_hash_dot, xfs_dir_hash_dotdot;
+/*
+ * One-time startup routine called from xfs_init().
+ */
+void
+xfs_dir_startup(void)
+{
+        xfs_dir_hash_dot = xfs_da_hashname(".", 1);
+        xfs_dir_hash_dotdot = xfs_da_hashname("..", 2);
+}
 /*
 * Add an entry to a block directory.
 */
@@ -400,7 +409,7 @@ xfs_dir2_block_addname(
        /*
         * Create the new data entry.
         */
-        INT_SET(dep->inumber, ARCH_CONVERT, args->inumber);
+        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);
@@ -508,7 +517,7 @@ xfs_dir2_block_getdents(
                p.cook = XFS_DIR2_DB_OFF_TO_DATAPTR(mp, mp->m_dirdatablk,
                                                    ptr - (char *)block);
-                p.ino = INT_GET(dep->inumber, ARCH_CONVERT);
+                p.ino = be64_to_cpu(dep->inumber);
 #if XFS_BIG_INUMS
                p.ino += mp->m_inoadd;
 #endif
@@ -626,7 +635,7 @@ xfs_dir2_block_lookup(
        /*
         * Fill in inode number, release the block.
         */
-        args->inumber = INT_GET(dep->inumber, ARCH_CONVERT);
+        args->inumber = be64_to_cpu(dep->inumber);
        xfs_da_brelse(args->trans, bp);
        return XFS_ERROR(EEXIST);
 }
@@ -844,11 +853,11 @@ xfs_dir2_block_replace(
         */
        dep = (xfs_dir2_data_entry_t *)
              ((char *)block + XFS_DIR2_DATAPTR_TO_OFF(mp, be32_to_cpu(blp[ent].address)));
-        ASSERT(INT_GET(dep->inumber, ARCH_CONVERT) != args->inumber);
+        ASSERT(be64_to_cpu(dep->inumber) != args->inumber);
        /*
         * Change the inode number to the new value.
         */
-        INT_SET(dep->inumber, ARCH_CONVERT, args->inumber);
+        dep->inumber = cpu_to_be64(args->inumber);
        xfs_dir2_data_log_entry(args->trans, bp, dep);
        xfs_dir2_data_check(dp, bp);
        xfs_da_buf_done(bp);
@@ -1130,7 +1139,7 @@ xfs_dir2_sf_to_block(
         */
        dep = (xfs_dir2_data_entry_t *)
              ((char *)block + XFS_DIR2_DATA_DOT_OFFSET);
-        INT_SET(dep->inumber, ARCH_CONVERT, dp->i_ino);
+        dep->inumber = cpu_to_be64(dp->i_ino);
        dep->namelen = 1;
        dep->name[0] = '.';
        tagp = XFS_DIR2_DATA_ENTRY_TAG_P(dep);
@@ -1144,7 +1153,7 @@ xfs_dir2_sf_to_block(
         */
        dep = (xfs_dir2_data_entry_t *)
                ((char *)block + XFS_DIR2_DATA_DOTDOT_OFFSET);
-        INT_SET(dep->inumber, ARCH_CONVERT, 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);
@@ -1193,7 +1202,7 @@ xfs_dir2_sf_to_block(
                 * Copy a real entry.
                 */
                dep = (xfs_dir2_data_entry_t *)((char *)block + newoffset);
-                INT_SET(dep->inumber, ARCH_CONVERT, XFS_DIR2_SF_GET_INUMBER(sfp,
+                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);
diff --git a/fs/xfs/xfs_dir2_data.c b/fs/xfs/xfs_dir2_data.c
index bb3d03ff002b..f7c799217072 100644
--- a/fs/xfs/xfs_dir2_data.c
+++ b/fs/xfs/xfs_dir2_data.c
@@ -22,18 +22,15 @@
 #include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
-#include "xfs_dir_leaf.h"
 #include "xfs_dir2_data.h"
 #include "xfs_dir2_leaf.h"
 #include "xfs_dir2_block.h"
@@ -133,7 +130,7 @@ xfs_dir2_data_check(
                 */
                dep = (xfs_dir2_data_entry_t *)p;
                ASSERT(dep->namelen != 0);
-                ASSERT(xfs_dir_ino_validate(mp, INT_GET(dep->inumber, ARCH_CONVERT)) == 0);
+                ASSERT(xfs_dir_ino_validate(mp, be64_to_cpu(dep->inumber)) == 0);
                ASSERT(be16_to_cpu(*XFS_DIR2_DATA_ENTRY_TAG_P(dep)) ==
                       (char *)dep - (char *)d);
                count++;
diff --git a/fs/xfs/xfs_dir2_data.h b/fs/xfs/xfs_dir2_data.h
index 0847cbb53e17..a6ae2d21c40a 100644
--- a/fs/xfs/xfs_dir2_data.h
+++ b/fs/xfs/xfs_dir2_data.h
@@ -85,11 +85,11 @@ typedef struct xfs_dir2_data_hdr {
 * Tag appears as the last 2 bytes.
 */
 typedef struct xfs_dir2_data_entry {
-        xfs_ino_t               inumber;        /* inode number */
+        __be64                  inumber;        /* inode number */
-        __uint8_t               namelen;        /* name length */
+        __u8                    namelen;        /* name length */
-        __uint8_t               name[1];        /* name bytes, no null */
+        __u8                    name[1];        /* name bytes, no null */
                                                /* variable offset */
-        xfs_dir2_data_off_t     tag;            /* starting offset of us */
+        __be16                  tag;            /* starting offset of us */
 } xfs_dir2_data_entry_t;
 /*
diff --git a/fs/xfs/xfs_dir2_leaf.c b/fs/xfs/xfs_dir2_leaf.c
index 0f5e2f2ce6ec..b1cf1fbf423d 100644
--- a/fs/xfs/xfs_dir2_leaf.c
+++ b/fs/xfs/xfs_dir2_leaf.c
@@ -24,14 +24,12 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_attr_sf.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
@@ -407,7 +405,7 @@ xfs_dir2_leaf_addname(
         * Initialize our new entry (at last).
         */
        dep = (xfs_dir2_data_entry_t *)dup;
-        INT_SET(dep->inumber, ARCH_CONVERT, args->inumber);
+        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);
@@ -884,7 +882,7 @@ xfs_dir2_leaf_getdents(
                                        XFS_DIR2_BYTE_TO_DA(mp,
                                                XFS_DIR2_LEAF_OFFSET) - map_off,
                                        XFS_BMAPI_METADATA, NULL, 0,
-                                        &map[map_valid], &nmap, NULL);
+                                        &map[map_valid], &nmap, NULL, NULL);
                                /*
                                 * Don't know if we should ignore this or
                                 * try to return an error.
@@ -1098,7 +1096,7 @@ xfs_dir2_leaf_getdents(
                p->cook = XFS_DIR2_BYTE_TO_DATAPTR(mp, curoff + length);
-                p->ino = INT_GET(dep->inumber, ARCH_CONVERT);
+                p->ino = be64_to_cpu(dep->inumber);
 #if XFS_BIG_INUMS
                p->ino += mp->m_inoadd;
 #endif
@@ -1319,7 +1317,7 @@ xfs_dir2_leaf_lookup(
        /*
         * Return the found inode number.
         */
-        args->inumber = INT_GET(dep->inumber, ARCH_CONVERT);
+        args->inumber = be64_to_cpu(dep->inumber);
        xfs_da_brelse(tp, dbp);
        xfs_da_brelse(tp, lbp);
        return XFS_ERROR(EEXIST);
@@ -1606,11 +1604,11 @@ 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)));
-        ASSERT(args->inumber != INT_GET(dep->inumber, ARCH_CONVERT));
+        ASSERT(args->inumber != be64_to_cpu(dep->inumber));
        /*
         * Put the new inode number in, log it.
         */
-        INT_SET(dep->inumber, ARCH_CONVERT, args->inumber);
+        dep->inumber = cpu_to_be64(args->inumber);
        tp = args->trans;
        xfs_dir2_data_log_entry(tp, dbp, dep);
        xfs_da_buf_done(dbp);
diff --git a/fs/xfs/xfs_dir2_node.c b/fs/xfs/xfs_dir2_node.c
index ac511ab9c52d..9ca71719b683 100644
--- a/fs/xfs/xfs_dir2_node.c
+++ b/fs/xfs/xfs_dir2_node.c
@@ -22,13 +22,11 @@
 #include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -505,7 +503,6 @@ xfs_dir2_leafn_lookup_int(
                                                        XFS_DATA_FORK))) {
                                                return error;
                                        }
-                                        curfdb = newfdb;
                                        free = curbp->data;
                                        ASSERT(be32_to_cpu(free->hdr.magic) ==
                                               XFS_DIR2_FREE_MAGIC);
@@ -527,8 +524,11 @@ xfs_dir2_leafn_lookup_int(
                                if (unlikely(be16_to_cpu(free->bests[fi]) == NULLDATAOFF)) {
                                        XFS_ERROR_REPORT("xfs_dir2_leafn_lookup_int",
                                                         XFS_ERRLEVEL_LOW, mp);
+                                        if (curfdb != newfdb)
+                                                xfs_da_brelse(tp, curbp);
                                        return XFS_ERROR(EFSCORRUPTED);
                                }
+                                curfdb = newfdb;
                                if (be16_to_cpu(free->bests[fi]) >= length) {
                                        *indexp = index;
                                        state->extravalid = 1;
@@ -580,7 +580,7 @@ xfs_dir2_leafn_lookup_int(
                        if (dep->namelen == args->namelen &&
                            dep->name[0] == args->name[0] &&
                            memcmp(dep->name, args->name, args->namelen) == 0) {
-                                args->inumber = INT_GET(dep->inumber, ARCH_CONVERT);
+                                args->inumber = be64_to_cpu(dep->inumber);
                                *indexp = index;
                                state->extravalid = 1;
                                state->extrablk.bp = curbp;
@@ -970,7 +970,7 @@ xfs_dir2_leafn_remove(
                        /*
                         * One less used entry in the free table.
                         */
-                        free->hdr.nused = cpu_to_be32(-1);
+                        be32_add(&free->hdr.nused, -1);
                        xfs_dir2_free_log_header(tp, fbp);
                        /*
                         * If this was the last entry in the table, we can
@@ -1695,7 +1695,7 @@ xfs_dir2_node_addname_int(
         * Fill in the new entry and log it.
         */
        dep = (xfs_dir2_data_entry_t *)dup;
-        INT_SET(dep->inumber, ARCH_CONVERT, args->inumber);
+        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);
@@ -1905,11 +1905,11 @@ xfs_dir2_node_replace(
                dep = (xfs_dir2_data_entry_t *)
                      ((char *)data +
                       XFS_DIR2_DATAPTR_TO_OFF(state->mp, be32_to_cpu(lep->address)));
-                ASSERT(inum != INT_GET(dep->inumber, ARCH_CONVERT));
+                ASSERT(inum != be64_to_cpu(dep->inumber));
                /*
                 * Fill in the new inode number and log the entry.
                 */
-                INT_SET(dep->inumber, ARCH_CONVERT, inum);
+                dep->inumber = cpu_to_be64(inum);
                xfs_dir2_data_log_entry(args->trans, state->extrablk.bp, dep);
                rval = 0;
        }
diff --git a/fs/xfs/xfs_dir2_sf.c b/fs/xfs/xfs_dir2_sf.c
index d98a41d1fe63..0cd77b17bf92 100644
--- a/fs/xfs/xfs_dir2_sf.c
+++ b/fs/xfs/xfs_dir2_sf.c
@@ -22,19 +22,16 @@
 #include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_inode_item.h"
-#include "xfs_dir_leaf.h"
 #include "xfs_error.h"
 #include "xfs_dir2_data.h"
 #include "xfs_dir2_leaf.h"
@@ -117,13 +114,13 @@ xfs_dir2_block_sfsize(
                        dep->name[0] == '.' && dep->name[1] == '.';
 #if XFS_BIG_INUMS
                if (!isdot)
-                        i8count += INT_GET(dep->inumber, ARCH_CONVERT) > XFS_DIR2_MAX_SHORT_INUM;
+                        i8count += be64_to_cpu(dep->inumber) > XFS_DIR2_MAX_SHORT_INUM;
 #endif
                if (!isdot && !isdotdot) {
                        count++;
                        namelen += dep->namelen;
                } else if (isdotdot)
-                        parent = INT_GET(dep->inumber, ARCH_CONVERT);
+                        parent = be64_to_cpu(dep->inumber);
                /*
                 * Calculate the new size, see if we should give up yet.
                 */
@@ -229,13 +226,13 @@ xfs_dir2_block_to_sf(
                 * Skip .
                 */
                if (dep->namelen == 1 && dep->name[0] == '.')
-                        ASSERT(INT_GET(dep->inumber, ARCH_CONVERT) == dp->i_ino);
+                        ASSERT(be64_to_cpu(dep->inumber) == dp->i_ino);
                /*
                 * Skip .., but make sure the inode number is right.
                 */
                else if (dep->namelen == 2 &&
                         dep->name[0] == '.' && dep->name[1] == '.')
-                        ASSERT(INT_GET(dep->inumber, ARCH_CONVERT) ==
+                        ASSERT(be64_to_cpu(dep->inumber) ==
                               XFS_DIR2_SF_GET_INUMBER(sfp, &sfp->hdr.parent));
                /*
                 * Normal entry, copy it into shortform.
@@ -246,7 +243,7 @@ xfs_dir2_block_to_sf(
                                (xfs_dir2_data_aoff_t)
                                ((char *)dep - (char *)block));
                        memcpy(sfep->name, dep->name, dep->namelen);
-                        temp=INT_GET(dep->inumber, ARCH_CONVERT);
+                        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);
diff --git a/fs/xfs/xfs_dir2_trace.c b/fs/xfs/xfs_dir2_trace.c
index c626943b4112..f3fb2ffd6f5c 100644
--- a/fs/xfs/xfs_dir2_trace.c
+++ b/fs/xfs/xfs_dir2_trace.c
@@ -19,11 +19,9 @@
 #include "xfs_fs.h"
 #include "xfs_types.h"
 #include "xfs_inum.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
diff --git a/fs/xfs/xfs_dir_leaf.c b/fs/xfs/xfs_dir_leaf.c
deleted file mode 100644
index 6d711869262f..000000000000
--- a/fs/xfs/xfs_dir_leaf.c
+++ /dev/null
@@ -1,2213 +0,0 @@
-/*
- * Copyright (c) 2000-2003,2005 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_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_inum.h"
-#include "xfs_trans.h"
-#include "xfs_sb.h"
-#include "xfs_dir.h"
-#include "xfs_dir2.h"
-#include "xfs_dmapi.h"
-#include "xfs_mount.h"
-#include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
-#include "xfs_dir2_sf.h"
-#include "xfs_attr_sf.h"
-#include "xfs_dinode.h"
-#include "xfs_inode.h"
-#include "xfs_inode_item.h"
-#include "xfs_alloc.h"
-#include "xfs_btree.h"
-#include "xfs_bmap.h"
-#include "xfs_dir_leaf.h"
-#include "xfs_error.h"
-/*
- * xfs_dir_leaf.c
- *
- * Routines to implement leaf blocks of directories as Btrees of hashed names.
- */
-/*========================================================================
- * Function prototypes for the kernel.
- *========================================================================*/
-/*
- * Routines used for growing the Btree.
- */
-STATIC void xfs_dir_leaf_add_work(xfs_dabuf_t *leaf_buffer, xfs_da_args_t *args,
-                                              int insertion_index,
-                                              int freemap_index);
-STATIC int xfs_dir_leaf_compact(xfs_trans_t *trans, xfs_dabuf_t *leaf_buffer,
-                                            int musthave, int justcheck);
-STATIC void xfs_dir_leaf_rebalance(xfs_da_state_t *state,
-                                                  xfs_da_state_blk_t *blk1,
-                                                  xfs_da_state_blk_t *blk2);
-STATIC int xfs_dir_leaf_figure_balance(xfs_da_state_t *state,
-                                          xfs_da_state_blk_t *leaf_blk_1,
-                                          xfs_da_state_blk_t *leaf_blk_2,
-                                          int *number_entries_in_blk1,
-                                          int *number_namebytes_in_blk1);
-STATIC int xfs_dir_leaf_create(struct xfs_da_args *args,
-                                xfs_dablk_t which_block,
-                                struct xfs_dabuf **bpp);
-/*
- * Utility routines.
- */
-STATIC void xfs_dir_leaf_moveents(xfs_dir_leafblock_t *src_leaf,
-                                              int src_start,
-                                              xfs_dir_leafblock_t *dst_leaf,
-                                              int dst_start, int move_count,
-                                              xfs_mount_t *mp);
-/*========================================================================
- * External routines when dirsize < XFS_IFORK_DSIZE(dp).
- *========================================================================*/
-/*
- * Validate a given inode number.
- */
-int
-xfs_dir_ino_validate(xfs_mount_t *mp, xfs_ino_t ino)
-{
-        xfs_agblock_t   agblkno;
-        xfs_agino_t     agino;
-        xfs_agnumber_t  agno;
-        int             ino_ok;
-        int             ioff;
-        agno = XFS_INO_TO_AGNO(mp, ino);
-        agblkno = XFS_INO_TO_AGBNO(mp, ino);
-        ioff = XFS_INO_TO_OFFSET(mp, ino);
-        agino = XFS_OFFBNO_TO_AGINO(mp, agblkno, ioff);
-        ino_ok =
-                agno < mp->m_sb.sb_agcount &&
-                agblkno < mp->m_sb.sb_agblocks &&
-                agblkno != 0 &&
-                ioff < (1 << mp->m_sb.sb_inopblog) &&
-                XFS_AGINO_TO_INO(mp, agno, agino) == ino;
-        if (unlikely(XFS_TEST_ERROR(!ino_ok, mp, XFS_ERRTAG_DIR_INO_VALIDATE,
-                        XFS_RANDOM_DIR_INO_VALIDATE))) {
-                xfs_fs_cmn_err(CE_WARN, mp, "Invalid inode number 0x%Lx",
-                                (unsigned long long) ino);
-                XFS_ERROR_REPORT("xfs_dir_ino_validate", XFS_ERRLEVEL_LOW, mp);
-                return XFS_ERROR(EFSCORRUPTED);
-        }
-        return 0;
-}
-/*
- * Create the initial contents of a shortform directory.
- */
-int
-xfs_dir_shortform_create(xfs_da_args_t *args, xfs_ino_t parent)
-{
-        xfs_dir_sf_hdr_t *hdr;
-        xfs_inode_t *dp;
-        dp = args->dp;
-        ASSERT(dp != NULL);
-        ASSERT(dp->i_d.di_size == 0);
-        if (dp->i_d.di_format == XFS_DINODE_FMT_EXTENTS) {
-                dp->i_df.if_flags &= ~XFS_IFEXTENTS;    /* just in case */
-                dp->i_d.di_format = XFS_DINODE_FMT_LOCAL;
-                xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE);
-                dp->i_df.if_flags |= XFS_IFINLINE;
-        }
-        ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
-        ASSERT(dp->i_df.if_bytes == 0);
-        xfs_idata_realloc(dp, sizeof(*hdr), XFS_DATA_FORK);
-        hdr = (xfs_dir_sf_hdr_t *)dp->i_df.if_u1.if_data;
-        XFS_DIR_SF_PUT_DIRINO(&parent, &hdr->parent);
-        hdr->count = 0;
-        dp->i_d.di_size = sizeof(*hdr);
-        xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA);
-        return 0;
-}
-/*
- * Add a name to the shortform directory structure.
- * Overflow from the inode has already been checked for.
- */
-int
-xfs_dir_shortform_addname(xfs_da_args_t *args)
-{
-        xfs_dir_shortform_t *sf;
-        xfs_dir_sf_entry_t *sfe;
-        int i, offset, size;
-        xfs_inode_t *dp;
-        dp = args->dp;
-        ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
-        /*
-         * Catch the case where the conversion from shortform to leaf
-         * failed part way through.
-         */
-        if (dp->i_d.di_size < sizeof(xfs_dir_sf_hdr_t)) {
-                ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
-                return XFS_ERROR(EIO);
-        }
-        ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
-        ASSERT(dp->i_df.if_u1.if_data != NULL);
-        sf = (xfs_dir_shortform_t *)dp->i_df.if_u1.if_data;
-        sfe = &sf->list[0];
-        for (i = sf->hdr.count-1; i >= 0; i--) {
-                if (sfe->namelen == args->namelen &&
-                    args->name[0] == sfe->name[0] &&
-                    memcmp(args->name, sfe->name, args->namelen) == 0)
-                        return XFS_ERROR(EEXIST);
-                sfe = XFS_DIR_SF_NEXTENTRY(sfe);
-        }
-        offset = (int)((char *)sfe - (char *)sf);
-        size = XFS_DIR_SF_ENTSIZE_BYNAME(args->namelen);
-        xfs_idata_realloc(dp, size, XFS_DATA_FORK);
-        sf = (xfs_dir_shortform_t *)dp->i_df.if_u1.if_data;
-        sfe = (xfs_dir_sf_entry_t *)((char *)sf + offset);
-        XFS_DIR_SF_PUT_DIRINO(&args->inumber, &sfe->inumber);
-        sfe->namelen = args->namelen;
-        memcpy(sfe->name, args->name, sfe->namelen);
-        sf->hdr.count++;
-        dp->i_d.di_size += size;
-        xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA);
-        return 0;
-}
-/*
- * Remove a name from the shortform directory structure.
- */
-int
-xfs_dir_shortform_removename(xfs_da_args_t *args)
-{
-        xfs_dir_shortform_t *sf;
-        xfs_dir_sf_entry_t *sfe;
-        int base, size = 0, i;
-        xfs_inode_t *dp;
-        dp = args->dp;
-        ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
-        /*
-         * Catch the case where the conversion from shortform to leaf
-         * failed part way through.
-         */
-        if (dp->i_d.di_size < sizeof(xfs_dir_sf_hdr_t)) {
-                ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
-                return XFS_ERROR(EIO);
-        }
-        ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
-        ASSERT(dp->i_df.if_u1.if_data != NULL);
-        base = sizeof(xfs_dir_sf_hdr_t);
-        sf = (xfs_dir_shortform_t *)dp->i_df.if_u1.if_data;
-        sfe = &sf->list[0];
-        for (i = sf->hdr.count-1; i >= 0; i--) {
-                size = XFS_DIR_SF_ENTSIZE_BYENTRY(sfe);
-                if (sfe->namelen == args->namelen &&
-                    sfe->name[0] == args->name[0] &&
-                    memcmp(sfe->name, args->name, args->namelen) == 0)
-                        break;
-                base += size;
-                sfe = XFS_DIR_SF_NEXTENTRY(sfe);
-        }
-        if (i < 0) {
-                ASSERT(args->oknoent);
-                return XFS_ERROR(ENOENT);
-        }
-        if ((base + size) != dp->i_d.di_size) {
-                memmove(&((char *)sf)[base], &((char *)sf)[base+size],
-                                              dp->i_d.di_size - (base+size));
-        }
-        sf->hdr.count--;
-        xfs_idata_realloc(dp, -size, XFS_DATA_FORK);
-        dp->i_d.di_size -= size;
-        xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_DDATA);
-        return 0;
-}
-/*
- * Look up a name in a shortform directory structure.
- */
-int
-xfs_dir_shortform_lookup(xfs_da_args_t *args)
-{
-        xfs_dir_shortform_t *sf;
-        xfs_dir_sf_entry_t *sfe;
-        int i;
-        xfs_inode_t *dp;
-        dp = args->dp;
-        ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
-        /*
-         * Catch the case where the conversion from shortform to leaf
-         * failed part way through.
-         */
-        if (dp->i_d.di_size < sizeof(xfs_dir_sf_hdr_t)) {
-                ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
-                return XFS_ERROR(EIO);
-        }
-        ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
-        ASSERT(dp->i_df.if_u1.if_data != NULL);
-        sf = (xfs_dir_shortform_t *)dp->i_df.if_u1.if_data;
-        if (args->namelen == 2 &&
-            args->name[0] == '.' && args->name[1] == '.') {
-                XFS_DIR_SF_GET_DIRINO(&sf->hdr.parent, &args->inumber);
-                return(XFS_ERROR(EEXIST));
-        }
-        if (args->namelen == 1 && args->name[0] == '.') {
-                args->inumber = dp->i_ino;
-                return(XFS_ERROR(EEXIST));
-        }
-        sfe = &sf->list[0];
-        for (i = sf->hdr.count-1; i >= 0; i--) {
-                if (sfe->namelen == args->namelen &&
-                    sfe->name[0] == args->name[0] &&
-                    memcmp(args->name, sfe->name, args->namelen) == 0) {
-                        XFS_DIR_SF_GET_DIRINO(&sfe->inumber, &args->inumber);
-                        return(XFS_ERROR(EEXIST));
-                }
-                sfe = XFS_DIR_SF_NEXTENTRY(sfe);
-        }
-        ASSERT(args->oknoent);
-        return(XFS_ERROR(ENOENT));
-}
-/*
- * Convert from using the shortform to the leaf.
- */
-int
-xfs_dir_shortform_to_leaf(xfs_da_args_t *iargs)
-{
-        xfs_inode_t *dp;
-        xfs_dir_shortform_t *sf;
-        xfs_dir_sf_entry_t *sfe;
-        xfs_da_args_t args;
-        xfs_ino_t inumber;
-        char *tmpbuffer;
-        int retval, i, size;
-        xfs_dablk_t blkno;
-        xfs_dabuf_t *bp;
-        dp = iargs->dp;
-        /*
-         * Catch the case where the conversion from shortform to leaf
-         * failed part way through.
-         */
-        if (dp->i_d.di_size < sizeof(xfs_dir_sf_hdr_t)) {
-                ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
-                return XFS_ERROR(EIO);
-        }
-        ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
-        ASSERT(dp->i_df.if_u1.if_data != NULL);
-        size = dp->i_df.if_bytes;
-        tmpbuffer = kmem_alloc(size, KM_SLEEP);
-        ASSERT(tmpbuffer != NULL);
-        memcpy(tmpbuffer, dp->i_df.if_u1.if_data, size);
-        sf = (xfs_dir_shortform_t *)tmpbuffer;
-        XFS_DIR_SF_GET_DIRINO(&sf->hdr.parent, &inumber);
-        xfs_idata_realloc(dp, -size, XFS_DATA_FORK);
-        dp->i_d.di_size = 0;
-        xfs_trans_log_inode(iargs->trans, dp, XFS_ILOG_CORE);
-        retval = xfs_da_grow_inode(iargs, &blkno);
-        if (retval)
-                goto out;
-        ASSERT(blkno == 0);
-        retval = xfs_dir_leaf_create(iargs, blkno, &bp);
-        if (retval)
-                goto out;
-        xfs_da_buf_done(bp);
-        args.name = ".";
-        args.namelen = 1;
-        args.hashval = xfs_dir_hash_dot;
-        args.inumber = dp->i_ino;
-        args.dp = dp;
-        args.firstblock = iargs->firstblock;
-        args.flist = iargs->flist;
-        args.total = iargs->total;
-        args.whichfork = XFS_DATA_FORK;
-        args.trans = iargs->trans;
-        args.justcheck = 0;
-        args.addname = args.oknoent = 1;
-        retval = xfs_dir_leaf_addname(&args);
-        if (retval)
-                goto out;
-        args.name = "..";
-        args.namelen = 2;
-        args.hashval = xfs_dir_hash_dotdot;
-        args.inumber = inumber;
-        retval = xfs_dir_leaf_addname(&args);
-        if (retval)
-                goto out;
-        sfe = &sf->list[0];
-        for (i = 0; i < sf->hdr.count; i++) {
-                args.name = (char *)(sfe->name);
-                args.namelen = sfe->namelen;
-                args.hashval = xfs_da_hashname((char *)(sfe->name),
-                                               sfe->namelen);
-                XFS_DIR_SF_GET_DIRINO(&sfe->inumber, &args.inumber);
-                retval = xfs_dir_leaf_addname(&args);
-                if (retval)
-                        goto out;
-                sfe = XFS_DIR_SF_NEXTENTRY(sfe);
-        }
-        retval = 0;
-out:
-        kmem_free(tmpbuffer, size);
-        return retval;
-}
-STATIC int
-xfs_dir_shortform_compare(const void *a, const void *b)
-{
-        xfs_dir_sf_sort_t *sa, *sb;
-        sa = (xfs_dir_sf_sort_t *)a;
-        sb = (xfs_dir_sf_sort_t *)b;
-        if (sa->hash < sb->hash)
-                return -1;
-        else if (sa->hash > sb->hash)
-                return 1;
-        else
-                return sa->entno - sb->entno;
-}
-/*
- * Copy out directory entries for getdents(), for shortform directories.
- */
-/*ARGSUSED*/
-int
-xfs_dir_shortform_getdents(xfs_inode_t *dp, uio_t *uio, int *eofp,
-                                       xfs_dirent_t *dbp, xfs_dir_put_t put)
-{
-        xfs_dir_shortform_t *sf;
-        xfs_dir_sf_entry_t *sfe;
-        int retval, i, sbsize, nsbuf, lastresid=0, want_entno;
-        xfs_mount_t *mp;
-        xfs_dahash_t cookhash, hash;
-        xfs_dir_put_args_t p;
-        xfs_dir_sf_sort_t *sbuf, *sbp;
-        mp = dp->i_mount;
-        sf = (xfs_dir_shortform_t *)dp->i_df.if_u1.if_data;
-        cookhash = XFS_DA_COOKIE_HASH(mp, uio->uio_offset);
-        want_entno = XFS_DA_COOKIE_ENTRY(mp, uio->uio_offset);
-        nsbuf = sf->hdr.count + 2;
-        sbsize = (nsbuf + 1) * sizeof(*sbuf);
-        sbp = sbuf = kmem_alloc(sbsize, KM_SLEEP);
-        xfs_dir_trace_g_du("sf: start", dp, uio);
-        /*
-         * Collect all the entries into the buffer.
-         * Entry 0 is .
-         */
-        sbp->entno = 0;
-        sbp->seqno = 0;
-        sbp->hash = xfs_dir_hash_dot;
-        sbp->ino = dp->i_ino;
-        sbp->name = ".";
-        sbp->namelen = 1;
-        sbp++;
-        /*
-         * Entry 1 is ..
-         */
-        sbp->entno = 1;
-        sbp->seqno = 0;
-        sbp->hash = xfs_dir_hash_dotdot;
-        sbp->ino = XFS_GET_DIR_INO8(sf->hdr.parent);
-        sbp->name = "..";
-        sbp->namelen = 2;
-        sbp++;
-        /*
-         * Scan the directory data for the rest of the entries.
-         */
-        for (i = 0, sfe = &sf->list[0]; i < sf->hdr.count; i++) {
-                if (unlikely(
-                    ((char *)sfe < (char *)sf) ||
-                    ((char *)sfe >= ((char *)sf + dp->i_df.if_bytes)))) {
-                        xfs_dir_trace_g_du("sf: corrupted", dp, uio);
-                        XFS_CORRUPTION_ERROR("xfs_dir_shortform_getdents",
-                                             XFS_ERRLEVEL_LOW, mp, sfe);
-                        kmem_free(sbuf, sbsize);
-                        return XFS_ERROR(EFSCORRUPTED);
-                }
-                sbp->entno = i + 2;
-                sbp->seqno = 0;
-                sbp->hash = xfs_da_hashname((char *)sfe->name, sfe->namelen);
-                sbp->ino = XFS_GET_DIR_INO8(sfe->inumber);
-                sbp->name = (char *)sfe->name;
-                sbp->namelen = sfe->namelen;
-                sfe = XFS_DIR_SF_NEXTENTRY(sfe);
-                sbp++;
-        }
-        /*
-         * Sort the entries on hash then entno.
-         */
-        xfs_sort(sbuf, nsbuf, sizeof(*sbuf), xfs_dir_shortform_compare);
-        /*
-         * Stuff in last entry.
-         */
-        sbp->entno = nsbuf;
-        sbp->hash = XFS_DA_MAXHASH;
-        sbp->seqno = 0;
-        /*
-         * Figure out the sequence numbers in case there's a hash duplicate.
-         */
-        for (hash = sbuf->hash, sbp = sbuf + 1;
-                                sbp < &sbuf[nsbuf + 1]; sbp++) {
-                if (sbp->hash == hash)
-                        sbp->seqno = sbp[-1].seqno + 1;
-                else
-                        hash = sbp->hash;
-        }
-        /*
-         * Set up put routine.
-         */
-        p.dbp = dbp;
-        p.put = put;
-        p.uio = uio;
-        /*
-         * Find our place.
-         */
-        for (sbp = sbuf; sbp < &sbuf[nsbuf + 1]; sbp++) {
-                if (sbp->hash > cookhash ||
-                    (sbp->hash == cookhash && sbp->seqno >= want_entno))
-                        break;
-        }
-        /*
-         * Did we fail to find anything?  We stop at the last entry,
-         * the one we put maxhash into.
-         */
-        if (sbp == &sbuf[nsbuf]) {
-                kmem_free(sbuf, sbsize);
-                xfs_dir_trace_g_du("sf: hash beyond end", dp, uio);
-                uio->uio_offset = XFS_DA_MAKE_COOKIE(mp, 0, 0, XFS_DA_MAXHASH);
-                *eofp = 1;
-                return 0;
-        }
-        /*
-         * Loop putting entries into the user buffer.
-         */
-        while (sbp < &sbuf[nsbuf]) {
-                /*
-                 * Save the first resid in a run of equal-hashval entries
-                 * so that we can back them out if they don't all fit.
-                 */
-                if (sbp->seqno == 0 || sbp == sbuf)
-                        lastresid = uio->uio_resid;
-                XFS_PUT_COOKIE(p.cook, mp, 0, sbp[1].seqno, sbp[1].hash);
-                p.ino = sbp->ino;
-#if XFS_BIG_INUMS
-                p.ino += mp->m_inoadd;
-#endif
-                p.name = sbp->name;
-                p.namelen = sbp->namelen;
-                retval = p.put(&p);
-                if (!p.done) {
-                        uio->uio_offset =
-                                XFS_DA_MAKE_COOKIE(mp, 0, 0, sbp->hash);
-                        kmem_free(sbuf, sbsize);
-                        uio->uio_resid = lastresid;
-                        xfs_dir_trace_g_du("sf: E-O-B", dp, uio);
-                        return retval;
-                }
-                sbp++;
-        }
-        kmem_free(sbuf, sbsize);
-        uio->uio_offset = p.cook.o;
-        *eofp = 1;
-        xfs_dir_trace_g_du("sf: E-O-F", dp, uio);
-        return 0;
-}
-/*
- * Look up a name in a shortform directory structure, replace the inode number.
- */
-int
-xfs_dir_shortform_replace(xfs_da_args_t *args)
-{
-        xfs_dir_shortform_t *sf;
-        xfs_dir_sf_entry_t *sfe;
-        xfs_inode_t *dp;
-        int i;
-        dp = args->dp;
-        ASSERT(dp->i_df.if_flags & XFS_IFINLINE);
-        /*
-         * Catch the case where the conversion from shortform to leaf
-         * failed part way through.
-         */
-        if (dp->i_d.di_size < sizeof(xfs_dir_sf_hdr_t)) {
-                ASSERT(XFS_FORCED_SHUTDOWN(dp->i_mount));
-                return XFS_ERROR(EIO);
-        }
-        ASSERT(dp->i_df.if_bytes == dp->i_d.di_size);
-        ASSERT(dp->i_df.if_u1.if_data != NULL);
-        sf = (xfs_dir_shortform_t *)dp->i_df.if_u1.if_data;
-        if (args->namelen == 2 &&
-            args->name[0] == '.' && args->name[1] == '.') {
-                /* XXX - replace assert? */
-                XFS_DIR_SF_PUT_DIRINO(&args->inumber, &sf->hdr.parent);
-                xfs_trans_log_inode(args->trans, dp, XFS_ILOG_DDATA);
-                return 0;
-        }
-        ASSERT(args->namelen != 1 || args->name[0] != '.');
-        sfe = &sf->list[0];
-        for (i = sf->hdr.count-1; i >= 0; i--) {
-                if (sfe->namelen == args->namelen &&
-                    sfe->name[0] == args->name[0] &&
-                    memcmp(args->name, sfe->name, args->namelen) == 0) {
-                        ASSERT(memcmp((char *)&args->inumber,
-                                (char *)&sfe->inumber, sizeof(xfs_ino_t)));
-                        XFS_DIR_SF_PUT_DIRINO(&args->inumber, &sfe->inumber);
-                        xfs_trans_log_inode(args->trans, dp, XFS_ILOG_DDATA);
-                        return 0;
-                }
-                sfe = XFS_DIR_SF_NEXTENTRY(sfe);
-        }
-        ASSERT(args->oknoent);
-        return XFS_ERROR(ENOENT);
-}
-/*
- * Convert a leaf directory to shortform structure
- */
-int
-xfs_dir_leaf_to_shortform(xfs_da_args_t *iargs)
-{
-        xfs_dir_leafblock_t *leaf;
-        xfs_dir_leaf_hdr_t *hdr;
-        xfs_dir_leaf_entry_t *entry;
-        xfs_dir_leaf_name_t *namest;
-        xfs_da_args_t args;
-        xfs_inode_t *dp;
-        xfs_ino_t parent = 0;
-        char *tmpbuffer;
-        int retval, i;
-        xfs_dabuf_t *bp;
-        dp = iargs->dp;
-        tmpbuffer = kmem_alloc(XFS_LBSIZE(dp->i_mount), KM_SLEEP);
-        ASSERT(tmpbuffer != NULL);
-        retval = xfs_da_read_buf(iargs->trans, iargs->dp, 0, -1, &bp,
-                                               XFS_DATA_FORK);
-        if (retval)
-                goto out;
-        ASSERT(bp != NULL);
-        memcpy(tmpbuffer, bp->data, XFS_LBSIZE(dp->i_mount));
-        leaf = (xfs_dir_leafblock_t *)tmpbuffer;
-        ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR_LEAF_MAGIC);
-        memset(bp->data, 0, XFS_LBSIZE(dp->i_mount));
-        /*
-         * Find and special case the parent inode number
-         */
-        hdr = &leaf->hdr;
-        entry = &leaf->entries[0];
-        for (i = INT_GET(hdr->count, ARCH_CONVERT)-1; i >= 0; entry++, i--) {
-                namest = XFS_DIR_LEAF_NAMESTRUCT(leaf, INT_GET(entry->nameidx, ARCH_CONVERT));
-                if ((entry->namelen == 2) &&
-                    (namest->name[0] == '.') &&
-                    (namest->name[1] == '.')) {
-                        XFS_DIR_SF_GET_DIRINO(&namest->inumber, &parent);
-                        entry->nameidx = 0;
-                } else if ((entry->namelen == 1) && (namest->name[0] == '.')) {
-                        entry->nameidx = 0;
-                }
-        }
-        retval = xfs_da_shrink_inode(iargs, 0, bp);
-        if (retval)
-                goto out;
-        retval = xfs_dir_shortform_create(iargs, parent);
-        if (retval)
-                goto out;
-        /*
-         * Copy the rest of the filenames
-         */
-        entry = &leaf->entries[0];
-        args.dp = dp;
-        args.firstblock = iargs->firstblock;
-        args.flist = iargs->flist;
-        args.total = iargs->total;
-        args.whichfork = XFS_DATA_FORK;
-        args.trans = iargs->trans;
-        args.justcheck = 0;
-        args.addname = args.oknoent = 1;
-        for (i = 0; i < INT_GET(hdr->count, ARCH_CONVERT); entry++, i++) {
-                if (!entry->nameidx)
-                        continue;
-                namest = XFS_DIR_LEAF_NAMESTRUCT(leaf, INT_GET(entry->nameidx, ARCH_CONVERT));
-                args.name = (char *)(namest->name);
-                args.namelen = entry->namelen;
-                args.hashval = INT_GET(entry->hashval, ARCH_CONVERT);
-                XFS_DIR_SF_GET_DIRINO(&namest->inumber, &args.inumber);
-                xfs_dir_shortform_addname(&args);
-        }
-out:
-        kmem_free(tmpbuffer, XFS_LBSIZE(dp->i_mount));
-        return retval;
-}
-/*
- * Convert from using a single leaf to a root node and a leaf.
- */
-int
-xfs_dir_leaf_to_node(xfs_da_args_t *args)
-{
-        xfs_dir_leafblock_t *leaf;
-        xfs_da_intnode_t *node;
-        xfs_inode_t *dp;
-        xfs_dabuf_t *bp1, *bp2;
-        xfs_dablk_t blkno;
-        int retval;
-        dp = args->dp;
-        retval = xfs_da_grow_inode(args, &blkno);
-        ASSERT(blkno == 1);
-        if (retval)
-                return retval;
-        retval = xfs_da_read_buf(args->trans, args->dp, 0, -1, &bp1,
-                                              XFS_DATA_FORK);
-        if (retval)
-                return retval;
-        ASSERT(bp1 != NULL);
-        retval = xfs_da_get_buf(args->trans, args->dp, 1, -1, &bp2,
-                                             XFS_DATA_FORK);
-        if (retval) {
-                xfs_da_buf_done(bp1);
-                return retval;
-        }
-        ASSERT(bp2 != NULL);
-        memcpy(bp2->data, bp1->data, XFS_LBSIZE(dp->i_mount));
-        xfs_da_buf_done(bp1);
-        xfs_da_log_buf(args->trans, bp2, 0, XFS_LBSIZE(dp->i_mount) - 1);
-        /*
-         * Set up the new root node.
-         */
-        retval = xfs_da_node_create(args, 0, 1, &bp1, XFS_DATA_FORK);
-        if (retval) {
-                xfs_da_buf_done(bp2);
-                return retval;
-        }
-        node = bp1->data;
-        leaf = bp2->data;
-        ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR_LEAF_MAGIC);
-        node->btree[0].hashval = cpu_to_be32(
-                INT_GET(leaf->entries[
-                        INT_GET(leaf->hdr.count, ARCH_CONVERT)-1].hashval, ARCH_CONVERT));
-        xfs_da_buf_done(bp2);
-        node->btree[0].before = cpu_to_be32(blkno);
-        node->hdr.count = cpu_to_be16(1);
-        xfs_da_log_buf(args->trans, bp1,
-                XFS_DA_LOGRANGE(node, &node->btree[0], sizeof(node->btree[0])));
-        xfs_da_buf_done(bp1);
-        return retval;
-}
-/*========================================================================
- * Routines used for growing the Btree.
- *========================================================================*/
-/*
- * Create the initial contents of a leaf directory
- * or a leaf in a node directory.
- */
-STATIC int
-xfs_dir_leaf_create(xfs_da_args_t *args, xfs_dablk_t blkno, xfs_dabuf_t **bpp)
-{
-        xfs_dir_leafblock_t *leaf;
-        xfs_dir_leaf_hdr_t *hdr;
-        xfs_inode_t *dp;
-        xfs_dabuf_t *bp;
-        int retval;
-        dp = args->dp;
-        ASSERT(dp != NULL);
-        retval = xfs_da_get_buf(args->trans, dp, blkno, -1, &bp, XFS_DATA_FORK);
-        if (retval)
-                return retval;
-        ASSERT(bp != NULL);
-        leaf = bp->data;
-        memset((char *)leaf, 0, XFS_LBSIZE(dp->i_mount));
-        hdr = &leaf->hdr;
-        hdr->info.magic = cpu_to_be16(XFS_DIR_LEAF_MAGIC);
-        INT_SET(hdr->firstused, ARCH_CONVERT, XFS_LBSIZE(dp->i_mount));
-        if (!hdr->firstused)
-                INT_SET(hdr->firstused, ARCH_CONVERT, XFS_LBSIZE(dp->i_mount) - 1);
-        INT_SET(hdr->freemap[0].base, ARCH_CONVERT, sizeof(xfs_dir_leaf_hdr_t));
-        INT_SET(hdr->freemap[0].size, ARCH_CONVERT, INT_GET(hdr->firstused, ARCH_CONVERT) - INT_GET(hdr->freemap[0].base, ARCH_CONVERT));
-        xfs_da_log_buf(args->trans, bp, 0, XFS_LBSIZE(dp->i_mount) - 1);
-        *bpp = bp;
-        return 0;
-}
-/*
- * Split the leaf node, rebalance, then add the new entry.
- */
-int
-xfs_dir_leaf_split(xfs_da_state_t *state, xfs_da_state_blk_t *oldblk,
-                                  xfs_da_state_blk_t *newblk)
-{
-        xfs_dablk_t blkno;
-        xfs_da_args_t *args;
-        int error;
-        /*
-         * Allocate space for a new leaf node.
-         */
-        args = state->args;
-        ASSERT(args != NULL);
-        ASSERT(oldblk->magic == XFS_DIR_LEAF_MAGIC);
-        error = xfs_da_grow_inode(args, &blkno);
-        if (error)
-                return error;
-        error = xfs_dir_leaf_create(args, blkno, &newblk->bp);
-        if (error)
-                return error;
-        newblk->blkno = blkno;
-        newblk->magic = XFS_DIR_LEAF_MAGIC;
-        /*
-         * Rebalance the entries across the two leaves.
-         */
-        xfs_dir_leaf_rebalance(state, oldblk, newblk);
-        error = xfs_da_blk_link(state, oldblk, newblk);
-        if (error)
-                return error;
-        /*
-         * Insert the new entry in the correct block.
-         */
-        if (state->inleaf) {
-                error = xfs_dir_leaf_add(oldblk->bp, args, oldblk->index);
-        } else {
-                error = xfs_dir_leaf_add(newblk->bp, args, newblk->index);
-        }
-        /*
-         * Update last hashval in each block since we added the name.
-         */
-        oldblk->hashval = xfs_dir_leaf_lasthash(oldblk->bp, NULL);
-        newblk->hashval = xfs_dir_leaf_lasthash(newblk->bp, NULL);
-        return error;
-}
-/*
- * Add a name to the leaf directory structure.
- *
- * Must take into account fragmented leaves and leaves where spacemap has
- * lost some freespace information (ie: holes).
- */
-int
-xfs_dir_leaf_add(xfs_dabuf_t *bp, xfs_da_args_t *args, int index)
-{
-        xfs_dir_leafblock_t *leaf;
-        xfs_dir_leaf_hdr_t *hdr;
-        xfs_dir_leaf_map_t *map;
-        int tablesize, entsize, sum, i, tmp, error;
-        leaf = bp->data;
-        ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR_LEAF_MAGIC);
-        ASSERT((index >= 0) && (index <= INT_GET(leaf->hdr.count, ARCH_CONVERT)));
-        hdr = &leaf->hdr;
-        entsize = XFS_DIR_LEAF_ENTSIZE_BYNAME(args->namelen);
-        /*
-         * Search through freemap for first-fit on new name length.
-         * (may need to figure in size of entry struct too)
-         */
-        tablesize = (INT_GET(hdr->count, ARCH_CONVERT) + 1) * (uint)sizeof(xfs_dir_leaf_entry_t)
-                        + (uint)sizeof(xfs_dir_leaf_hdr_t);
-        map = &hdr->freemap[XFS_DIR_LEAF_MAPSIZE-1];
-        for (sum = 0, i = XFS_DIR_LEAF_MAPSIZE-1; i >= 0; map--, i--) {
-                if (tablesize > INT_GET(hdr->firstused, ARCH_CONVERT)) {
-                        sum += INT_GET(map->size, ARCH_CONVERT);
-                        continue;
-                }
-                if (!map->size)
-                        continue;       /* no space in this map */
-                tmp = entsize;
-                if (INT_GET(map->base, ARCH_CONVERT) < INT_GET(hdr->firstused, ARCH_CONVERT))
-                        tmp += (uint)sizeof(xfs_dir_leaf_entry_t);
-                if (INT_GET(map->size, ARCH_CONVERT) >= tmp) {
-                        if (!args->justcheck)
-                                xfs_dir_leaf_add_work(bp, args, index, i);
-                        return 0;
-                }
-                sum += INT_GET(map->size, ARCH_CONVERT);
-        }
-        /*
-         * If there are no holes in the address space of the block,
-         * and we don't have enough freespace, then compaction will do us
-         * no good and we should just give up.
-         */
-        if (!hdr->holes && (sum < entsize))
-                return XFS_ERROR(ENOSPC);
-        /*
-         * Compact the entries to coalesce free space.
-         * Pass the justcheck flag so the checking pass can return
-         * an error, without changing anything, if it won't fit.
-         */
-        error = xfs_dir_leaf_compact(args->trans, bp,
-                        args->total == 0 ?
-                                entsize +
-                                (uint)sizeof(xfs_dir_leaf_entry_t) : 0,
-                        args->justcheck);
-        if (error)
-                return error;
-        /*
-         * After compaction, the block is guaranteed to have only one
-         * free region, in freemap[0].  If it is not big enough, give up.
-         */
-        if (INT_GET(hdr->freemap[0].size, ARCH_CONVERT) <
-            (entsize + (uint)sizeof(xfs_dir_leaf_entry_t)))
-                return XFS_ERROR(ENOSPC);
-        if (!args->justcheck)
-                xfs_dir_leaf_add_work(bp, args, index, 0);
-        return 0;
-}
-/*
- * Add a name to a leaf directory structure.
- */
-STATIC void
-xfs_dir_leaf_add_work(xfs_dabuf_t *bp, xfs_da_args_t *args, int index,
-                      int mapindex)
-{
-        xfs_dir_leafblock_t *leaf;
-        xfs_dir_leaf_hdr_t *hdr;
-        xfs_dir_leaf_entry_t *entry;
-        xfs_dir_leaf_name_t *namest;
-        xfs_dir_leaf_map_t *map;
-        /* REFERENCED */
-        xfs_mount_t *mp;
-        int tmp, i;
-        leaf = bp->data;
-        ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR_LEAF_MAGIC);
-        hdr = &leaf->hdr;
-        ASSERT((mapindex >= 0) && (mapindex < XFS_DIR_LEAF_MAPSIZE));
-        ASSERT((index >= 0) && (index <= INT_GET(hdr->count, ARCH_CONVERT)));
-        /*
-         * Force open some space in the entry array and fill it in.
-         */
-        entry = &leaf->entries[index];
-        if (index < INT_GET(hdr->count, ARCH_CONVERT)) {
-                tmp  = INT_GET(hdr->count, ARCH_CONVERT) - index;
-                tmp *= (uint)sizeof(xfs_dir_leaf_entry_t);
-                memmove(entry + 1, entry, tmp);
-                xfs_da_log_buf(args->trans, bp,
-                    XFS_DA_LOGRANGE(leaf, entry, tmp + (uint)sizeof(*entry)));
-        }
-        INT_MOD(hdr->count, ARCH_CONVERT, +1);
-        /*
-         * Allocate space for the new string (at the end of the run).
-         */
-        map = &hdr->freemap[mapindex];
-        mp = args->trans->t_mountp;
-        ASSERT(INT_GET(map->base, ARCH_CONVERT) < XFS_LBSIZE(mp));
-        ASSERT(INT_GET(map->size, ARCH_CONVERT) >= XFS_DIR_LEAF_ENTSIZE_BYNAME(args->namelen));
-        ASSERT(INT_GET(map->size, ARCH_CONVERT) < XFS_LBSIZE(mp));
-        INT_MOD(map->size, ARCH_CONVERT, -(XFS_DIR_LEAF_ENTSIZE_BYNAME(args->namelen)));
-        INT_SET(entry->nameidx, ARCH_CONVERT, INT_GET(map->base, ARCH_CONVERT) + INT_GET(map->size, ARCH_CONVERT));
-        INT_SET(entry->hashval, ARCH_CONVERT, args->hashval);
-        entry->namelen = args->namelen;
-        xfs_da_log_buf(args->trans, bp,
-            XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
-        /*
-         * Copy the string and inode number into the new space.
-         */
-        namest = XFS_DIR_LEAF_NAMESTRUCT(leaf, INT_GET(entry->nameidx, ARCH_CONVERT));
-        XFS_DIR_SF_PUT_DIRINO(&args->inumber, &namest->inumber);
-        memcpy(namest->name, args->name, args->namelen);
-        xfs_da_log_buf(args->trans, bp,
-            XFS_DA_LOGRANGE(leaf, namest, XFS_DIR_LEAF_ENTSIZE_BYENTRY(entry)));
-        /*
-         * Update the control info for this leaf node
-         */
-        if (INT_GET(entry->nameidx, ARCH_CONVERT) < INT_GET(hdr->firstused, ARCH_CONVERT))
-                INT_COPY(hdr->firstused, entry->nameidx, ARCH_CONVERT);
-        ASSERT(INT_GET(hdr->firstused, ARCH_CONVERT) >= ((INT_GET(hdr->count, ARCH_CONVERT)*sizeof(*entry))+sizeof(*hdr)));
-        tmp = (INT_GET(hdr->count, ARCH_CONVERT)-1) * (uint)sizeof(xfs_dir_leaf_entry_t)
-                        + (uint)sizeof(xfs_dir_leaf_hdr_t);
-        map = &hdr->freemap[0];
-        for (i = 0; i < XFS_DIR_LEAF_MAPSIZE; map++, i++) {
-                if (INT_GET(map->base, ARCH_CONVERT) == tmp) {
-                        INT_MOD(map->base, ARCH_CONVERT, (uint)sizeof(xfs_dir_leaf_entry_t));
-                        INT_MOD(map->size, ARCH_CONVERT, -((uint)sizeof(xfs_dir_leaf_entry_t)));
-                }
-        }
-        INT_MOD(hdr->namebytes, ARCH_CONVERT, args->namelen);
-        xfs_da_log_buf(args->trans, bp,
-                XFS_DA_LOGRANGE(leaf, hdr, sizeof(*hdr)));
-}
-/*
- * Garbage collect a leaf directory block by copying it to a new buffer.
- */
-STATIC int
-xfs_dir_leaf_compact(xfs_trans_t *trans, xfs_dabuf_t *bp, int musthave,
-                     int justcheck)
-{
-        xfs_dir_leafblock_t *leaf_s, *leaf_d;
-        xfs_dir_leaf_hdr_t *hdr_s, *hdr_d;
-        xfs_mount_t *mp;
-        char *tmpbuffer;
-        char *tmpbuffer2=NULL;
-        int rval;
-        int lbsize;
-        mp = trans->t_mountp;
-        lbsize = XFS_LBSIZE(mp);
-        tmpbuffer = kmem_alloc(lbsize, KM_SLEEP);
-        ASSERT(tmpbuffer != NULL);
-        memcpy(tmpbuffer, bp->data, lbsize);
-        /*
-         * Make a second copy in case xfs_dir_leaf_moveents()
-         * below destroys the original.
-         */
-        if (musthave || justcheck) {
-                tmpbuffer2 = kmem_alloc(lbsize, KM_SLEEP);
-                memcpy(tmpbuffer2, bp->data, lbsize);
-        }
-        memset(bp->data, 0, lbsize);
-        /*
-         * Copy basic information
-         */
-        leaf_s = (xfs_dir_leafblock_t *)tmpbuffer;
-        leaf_d = bp->data;
-        hdr_s = &leaf_s->hdr;
-        hdr_d = &leaf_d->hdr;
-        hdr_d->info = hdr_s->info;      /* struct copy */
-        INT_SET(hdr_d->firstused, ARCH_CONVERT, lbsize);
-        if (!hdr_d->firstused)
-                INT_SET(hdr_d->firstused, ARCH_CONVERT, lbsize - 1);
-        hdr_d->namebytes = 0;
-        hdr_d->count = 0;
-        hdr_d->holes = 0;
-        INT_SET(hdr_d->freemap[0].base, ARCH_CONVERT, sizeof(xfs_dir_leaf_hdr_t));
-        INT_SET(hdr_d->freemap[0].size, ARCH_CONVERT, INT_GET(hdr_d->firstused, ARCH_CONVERT) - INT_GET(hdr_d->freemap[0].base, ARCH_CONVERT));
-        /*
-         * Copy all entry's in the same (sorted) order,
-         * but allocate filenames packed and in sequence.
-         * This changes the source (leaf_s) as well.
-         */
-        xfs_dir_leaf_moveents(leaf_s, 0, leaf_d, 0, (int)INT_GET(hdr_s->count, ARCH_CONVERT), mp);
-        if (musthave && INT_GET(hdr_d->freemap[0].size, ARCH_CONVERT) < musthave)
-                rval = XFS_ERROR(ENOSPC);
-        else
-                rval = 0;
-        if (justcheck || rval == ENOSPC) {
-                ASSERT(tmpbuffer2);
-                memcpy(bp->data, tmpbuffer2, lbsize);
-        } else {
-                xfs_da_log_buf(trans, bp, 0, lbsize - 1);
-        }
-        kmem_free(tmpbuffer, lbsize);
-        if (musthave || justcheck)
-                kmem_free(tmpbuffer2, lbsize);
-        return rval;
-}
-/*
- * Redistribute the directory entries between two leaf nodes,
- * taking into account the size of the new entry.
- *
- * NOTE: if new block is empty, then it will get the upper half of old block.
- */
-STATIC void
-xfs_dir_leaf_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
-                                      xfs_da_state_blk_t *blk2)
-{
-        xfs_da_state_blk_t *tmp_blk;
-        xfs_dir_leafblock_t *leaf1, *leaf2;
-        xfs_dir_leaf_hdr_t *hdr1, *hdr2;
-        int count, totallen, max, space, swap;
-        /*
-         * Set up environment.
-         */
-        ASSERT(blk1->magic == XFS_DIR_LEAF_MAGIC);
-        ASSERT(blk2->magic == XFS_DIR_LEAF_MAGIC);
-        leaf1 = blk1->bp->data;
-        leaf2 = blk2->bp->data;
-        ASSERT(be16_to_cpu(leaf1->hdr.info.magic) == XFS_DIR_LEAF_MAGIC);
-        ASSERT(be16_to_cpu(leaf2->hdr.info.magic) == XFS_DIR_LEAF_MAGIC);
-        /*
-         * Check ordering of blocks, reverse if it makes things simpler.
-         */
-        swap = 0;
-        if (xfs_dir_leaf_order(blk1->bp, blk2->bp)) {
-                tmp_blk = blk1;
-                blk1 = blk2;
-                blk2 = tmp_blk;
-                leaf1 = blk1->bp->data;
-                leaf2 = blk2->bp->data;
-                swap = 1;
-        }
-        hdr1 = &leaf1->hdr;
-        hdr2 = &leaf2->hdr;
-        /*
-         * Examine entries until we reduce the absolute difference in
-         * byte usage between the two blocks to a minimum.  Then get
-         * the direction to copy and the number of elements to move.
-         */
-        state->inleaf = xfs_dir_leaf_figure_balance(state, blk1, blk2,
-                                                           &count, &totallen);
-        if (swap)
-                state->inleaf = !state->inleaf;
-        /*
-         * Move any entries required from leaf to leaf:
-         */
-        if (count < INT_GET(hdr1->count, ARCH_CONVERT)) {
-                /*
-                 * Figure the total bytes to be added to the destination leaf.
-                 */
-                count = INT_GET(hdr1->count, ARCH_CONVERT) - count;     /* number entries being moved */
-                space  = INT_GET(hdr1->namebytes, ARCH_CONVERT) - totallen;
-                space += count * ((uint)sizeof(xfs_dir_leaf_name_t)-1);
-                space += count * (uint)sizeof(xfs_dir_leaf_entry_t);
-                /*
-                 * leaf2 is the destination, compact it if it looks tight.
-                 */
-                max  = INT_GET(hdr2->firstused, ARCH_CONVERT) - (uint)sizeof(xfs_dir_leaf_hdr_t);
-                max -= INT_GET(hdr2->count, ARCH_CONVERT) * (uint)sizeof(xfs_dir_leaf_entry_t);
-                if (space > max) {
-                        xfs_dir_leaf_compact(state->args->trans, blk2->bp,
-                                                                 0, 0);
-                }
-                /*
-                 * Move high entries from leaf1 to low end of leaf2.
-                 */
-                xfs_dir_leaf_moveents(leaf1, INT_GET(hdr1->count, ARCH_CONVERT) - count,
-                                             leaf2, 0, count, state->mp);
-                xfs_da_log_buf(state->args->trans, blk1->bp, 0,
-                                                   state->blocksize-1);
-                xfs_da_log_buf(state->args->trans, blk2->bp, 0,
-                                                   state->blocksize-1);
-        } else if (count > INT_GET(hdr1->count, ARCH_CONVERT)) {
-                /*
-                 * Figure the total bytes to be added to the destination leaf.
-                 */
-                count -= INT_GET(hdr1->count, ARCH_CONVERT);            /* number entries being moved */
-                space  = totallen - INT_GET(hdr1->namebytes, ARCH_CONVERT);
-                space += count * ((uint)sizeof(xfs_dir_leaf_name_t)-1);
-                space += count * (uint)sizeof(xfs_dir_leaf_entry_t);
-                /*
-                 * leaf1 is the destination, compact it if it looks tight.
-                 */
-                max  = INT_GET(hdr1->firstused, ARCH_CONVERT) - (uint)sizeof(xfs_dir_leaf_hdr_t);
-                max -= INT_GET(hdr1->count, ARCH_CONVERT) * (uint)sizeof(xfs_dir_leaf_entry_t);
-                if (space > max) {
-                        xfs_dir_leaf_compact(state->args->trans, blk1->bp,
-                                                                 0, 0);
-                }
-                /*
-                 * Move low entries from leaf2 to high end of leaf1.
-                 */
-                xfs_dir_leaf_moveents(leaf2, 0, leaf1, (int)INT_GET(hdr1->count, ARCH_CONVERT),
-                                             count, state->mp);
-                xfs_da_log_buf(state->args->trans, blk1->bp, 0,
-                                                   state->blocksize-1);
-                xfs_da_log_buf(state->args->trans, blk2->bp, 0,
-                                                   state->blocksize-1);
-        }
-        /*
-         * Copy out last hashval in each block for B-tree code.
-         */
-        blk1->hashval = INT_GET(leaf1->entries[ INT_GET(leaf1->hdr.count, ARCH_CONVERT)-1 ].hashval, ARCH_CONVERT);
-        blk2->hashval = INT_GET(leaf2->entries[ INT_GET(leaf2->hdr.count, ARCH_CONVERT)-1 ].hashval, ARCH_CONVERT);
-        /*
-         * Adjust the expected index for insertion.
-         * GROT: this doesn't work unless blk2 was originally empty.
-         */
-        if (!state->inleaf) {
-                blk2->index = blk1->index - INT_GET(leaf1->hdr.count, ARCH_CONVERT);
-        }
-}
-/*
- * Examine entries until we reduce the absolute difference in
- * byte usage between the two blocks to a minimum.
- * GROT: Is this really necessary?  With other than a 512 byte blocksize,
- * GROT: there will always be enough room in either block for a new entry.
- * GROT: Do a double-split for this case?
- */
-STATIC int
-xfs_dir_leaf_figure_balance(xfs_da_state_t *state,
-                                           xfs_da_state_blk_t *blk1,
-                                           xfs_da_state_blk_t *blk2,
-                                           int *countarg, int *namebytesarg)
-{
-        xfs_dir_leafblock_t *leaf1, *leaf2;
-        xfs_dir_leaf_hdr_t *hdr1, *hdr2;
-        xfs_dir_leaf_entry_t *entry;
-        int count, max, totallen, half;
-        int lastdelta, foundit, tmp;
-        /*
-         * Set up environment.
-         */
-        leaf1 = blk1->bp->data;
-        leaf2 = blk2->bp->data;
-        hdr1 = &leaf1->hdr;
-        hdr2 = &leaf2->hdr;
-        foundit = 0;
-        totallen = 0;
-        /*
-         * Examine entries until we reduce the absolute difference in
-         * byte usage between the two blocks to a minimum.
-         */
-        max = INT_GET(hdr1->count, ARCH_CONVERT) + INT_GET(hdr2->count, ARCH_CONVERT);
-        half  = (max+1) * (uint)(sizeof(*entry)+sizeof(xfs_dir_leaf_entry_t)-1);
-        half += INT_GET(hdr1->namebytes, ARCH_CONVERT) + INT_GET(hdr2->namebytes, ARCH_CONVERT) + state->args->namelen;
-        half /= 2;
-        lastdelta = state->blocksize;
-        entry = &leaf1->entries[0];
-        for (count = 0; count < max; entry++, count++) {
-#define XFS_DIR_ABS(A)  (((A) < 0) ? -(A) : (A))
-                /*
-                 * The new entry is in the first block, account for it.
-                 */
-                if (count == blk1->index) {
-                        tmp = totallen + (uint)sizeof(*entry)
-                                + XFS_DIR_LEAF_ENTSIZE_BYNAME(state->args->namelen);
-                        if (XFS_DIR_ABS(half - tmp) > lastdelta)
-                                break;
-                        lastdelta = XFS_DIR_ABS(half - tmp);
-                        totallen = tmp;
-                        foundit = 1;
-                }
-                /*
-                 * Wrap around into the second block if necessary.
-                 */
-                if (count == INT_GET(hdr1->count, ARCH_CONVERT)) {
-                        leaf1 = leaf2;
-                        entry = &leaf1->entries[0];
-                }
-                /*
-                 * Figure out if next leaf entry would be too much.
-                 */
-                tmp = totallen + (uint)sizeof(*entry)
-                                + XFS_DIR_LEAF_ENTSIZE_BYENTRY(entry);
-                if (XFS_DIR_ABS(half - tmp) > lastdelta)
-                        break;
-                lastdelta = XFS_DIR_ABS(half - tmp);
-                totallen = tmp;
-#undef XFS_DIR_ABS
-        }
-        /*
-         * Calculate the number of namebytes that will end up in lower block.
-         * If new entry not in lower block, fix up the count.
-         */
-        totallen -=
-                count * (uint)(sizeof(*entry)+sizeof(xfs_dir_leaf_entry_t)-1);
-        if (foundit) {
-                totallen -= (sizeof(*entry)+sizeof(xfs_dir_leaf_entry_t)-1) +
-                            state->args->namelen;
-        }
-        *countarg = count;
-        *namebytesarg = totallen;
-        return foundit;
-}
-/*========================================================================
- * Routines used for shrinking the Btree.
- *========================================================================*/
-/*
- * Check a leaf block and its neighbors to see if the block should be
- * collapsed into one or the other neighbor.  Always keep the block
- * with the smaller block number.
- * If the current block is over 50% full, don't try to join it, return 0.
- * If the block is empty, fill in the state structure and return 2.
- * If it can be collapsed, fill in the state structure and return 1.
- * If nothing can be done, return 0.
- */
-int
-xfs_dir_leaf_toosmall(xfs_da_state_t *state, int *action)
-{
-        xfs_dir_leafblock_t *leaf;
-        xfs_da_state_blk_t *blk;
-        xfs_da_blkinfo_t *info;
-        int count, bytes, forward, error, retval, i;
-        xfs_dablk_t blkno;
-        xfs_dabuf_t *bp;
-        /*
-         * Check for the degenerate case of the block being over 50% full.
-         * If so, it's not worth even looking to see if we might be able
-         * to coalesce with a sibling.
-         */
-        blk = &state->path.blk[ state->path.active-1 ];
-        info = blk->bp->data;
-        ASSERT(be16_to_cpu(info->magic) == XFS_DIR_LEAF_MAGIC);
-        leaf = (xfs_dir_leafblock_t *)info;
-        count = INT_GET(leaf->hdr.count, ARCH_CONVERT);
-        bytes = (uint)sizeof(xfs_dir_leaf_hdr_t) +
-                count * (uint)sizeof(xfs_dir_leaf_entry_t) +
-                count * ((uint)sizeof(xfs_dir_leaf_name_t)-1) +
-                INT_GET(leaf->hdr.namebytes, ARCH_CONVERT);
-        if (bytes > (state->blocksize >> 1)) {
-                *action = 0;    /* blk over 50%, don't try to join */
-                return 0;
-        }
-        /*
-         * Check for the degenerate case of the block being empty.
-         * If the block is empty, we'll simply delete it, no need to
-         * coalesce it with a sibling block.  We choose (arbitrarily)
-         * to merge with the forward block unless it is NULL.
-         */
-        if (count == 0) {
-                /*
-                 * Make altpath point to the block we want to keep and
-                 * path point to the block we want to drop (this one).
-                 */
-                forward = (info->forw != 0);
-                memcpy(&state->altpath, &state->path, sizeof(state->path));
-                error = xfs_da_path_shift(state, &state->altpath, forward,
-                                                 0, &retval);
-                if (error)
-                        return error;
-                if (retval) {
-                        *action = 0;
-                } else {
-                        *action = 2;
-                }
-                return 0;
-        }
-        /*
-         * Examine each sibling block to see if we can coalesce with
-         * at least 25% free space to spare.  We need to figure out
-         * whether to merge with the forward or the backward block.
-         * We prefer coalescing with the lower numbered sibling so as
-         * to shrink a directory over time.
-         */
-        forward = (be32_to_cpu(info->forw) < be32_to_cpu(info->back));  /* start with smaller blk num */
-        for (i = 0; i < 2; forward = !forward, i++) {
-                if (forward)
-                        blkno = be32_to_cpu(info->forw);
-                else
-                        blkno = be32_to_cpu(info->back);
-                if (blkno == 0)
-                        continue;
-                error = xfs_da_read_buf(state->args->trans, state->args->dp,
-                                                            blkno, -1, &bp,
-                                                            XFS_DATA_FORK);
-                if (error)
-                        return error;
-                ASSERT(bp != NULL);
-                leaf = (xfs_dir_leafblock_t *)info;
-                count  = INT_GET(leaf->hdr.count, ARCH_CONVERT);
-                bytes  = state->blocksize - (state->blocksize>>2);
-                bytes -= INT_GET(leaf->hdr.namebytes, ARCH_CONVERT);
-                leaf = bp->data;
-                ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR_LEAF_MAGIC);
-                count += INT_GET(leaf->hdr.count, ARCH_CONVERT);
-                bytes -= INT_GET(leaf->hdr.namebytes, ARCH_CONVERT);
-                bytes -= count * ((uint)sizeof(xfs_dir_leaf_name_t) - 1);
-                bytes -= count * (uint)sizeof(xfs_dir_leaf_entry_t);
-                bytes -= (uint)sizeof(xfs_dir_leaf_hdr_t);
-                if (bytes >= 0)
-                        break;  /* fits with at least 25% to spare */
-                xfs_da_brelse(state->args->trans, bp);
-        }
-        if (i >= 2) {
-                *action = 0;
-                return 0;
-        }
-        xfs_da_buf_done(bp);
-        /*
-         * Make altpath point to the block we want to keep (the lower
-         * numbered block) and path point to the block we want to drop.
-         */
-        memcpy(&state->altpath, &state->path, sizeof(state->path));
-        if (blkno < blk->blkno) {
-                error = xfs_da_path_shift(state, &state->altpath, forward,
-                                                 0, &retval);
-        } else {
-                error = xfs_da_path_shift(state, &state->path, forward,
-                                                 0, &retval);
-        }
-        if (error)
-                return error;
-        if (retval) {
-                *action = 0;
-        } else {
-                *action = 1;
-        }
-        return 0;
-}
-/*
- * Remove a name from the leaf directory structure.
- *
- * Return 1 if leaf is less than 37% full, 0 if >= 37% full.
- * If two leaves are 37% full, when combined they will leave 25% free.
- */
-int
-xfs_dir_leaf_remove(xfs_trans_t *trans, xfs_dabuf_t *bp, int index)
-{
-        xfs_dir_leafblock_t *leaf;
-        xfs_dir_leaf_hdr_t *hdr;
-        xfs_dir_leaf_map_t *map;
-        xfs_dir_leaf_entry_t *entry;
-        xfs_dir_leaf_name_t *namest;
-        int before, after, smallest, entsize;
-        int tablesize, tmp, i;
-        xfs_mount_t *mp;
-        leaf = bp->data;
-        ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR_LEAF_MAGIC);
-        hdr = &leaf->hdr;
-        mp = trans->t_mountp;
-        ASSERT((INT_GET(hdr->count, ARCH_CONVERT) > 0) && (INT_GET(hdr->count, ARCH_CONVERT) < (XFS_LBSIZE(mp)/8)));
-        ASSERT((index >= 0) && (index < INT_GET(hdr->count, ARCH_CONVERT)));
-        ASSERT(INT_GET(hdr->firstused, ARCH_CONVERT) >= ((INT_GET(hdr->count, ARCH_CONVERT)*sizeof(*entry))+sizeof(*hdr)));
-        entry = &leaf->entries[index];
-        ASSERT(INT_GET(entry->nameidx, ARCH_CONVERT) >= INT_GET(hdr->firstused, ARCH_CONVERT));
-        ASSERT(INT_GET(entry->nameidx, ARCH_CONVERT) < XFS_LBSIZE(mp));
-        /*
-         * Scan through free region table:
-         *    check for adjacency of free'd entry with an existing one,
-         *    find smallest free region in case we need to replace it,
-         *    adjust any map that borders the entry table,
-         */
-        tablesize = INT_GET(hdr->count, ARCH_CONVERT) * (uint)sizeof(xfs_dir_leaf_entry_t)
-                        + (uint)sizeof(xfs_dir_leaf_hdr_t);
-        map = &hdr->freemap[0];
-        tmp = INT_GET(map->size, ARCH_CONVERT);
-        before = after = -1;
-        smallest = XFS_DIR_LEAF_MAPSIZE - 1;
-        entsize = XFS_DIR_LEAF_ENTSIZE_BYENTRY(entry);
-        for (i = 0; i < XFS_DIR_LEAF_MAPSIZE; map++, i++) {
-                ASSERT(INT_GET(map->base, ARCH_CONVERT) < XFS_LBSIZE(mp));
-                ASSERT(INT_GET(map->size, ARCH_CONVERT) < XFS_LBSIZE(mp));
-                if (INT_GET(map->base, ARCH_CONVERT) == tablesize) {
-                        INT_MOD(map->base, ARCH_CONVERT, -((uint)sizeof(xfs_dir_leaf_entry_t)));
-                        INT_MOD(map->size, ARCH_CONVERT, (uint)sizeof(xfs_dir_leaf_entry_t));
-                }
-                if ((INT_GET(map->base, ARCH_CONVERT) + INT_GET(map->size, ARCH_CONVERT)) == INT_GET(entry->nameidx, ARCH_CONVERT)) {
-                        before = i;
-                } else if (INT_GET(map->base, ARCH_CONVERT) == (INT_GET(entry->nameidx, ARCH_CONVERT) + entsize)) {
-                        after = i;
-                } else if (INT_GET(map->size, ARCH_CONVERT) < tmp) {
-                        tmp = INT_GET(map->size, ARCH_CONVERT);
-                        smallest = i;
-                }
-        }
-        /*
-         * Coalesce adjacent freemap regions,
-         * or replace the smallest region.
-         */
-        if ((before >= 0) || (after >= 0)) {
-                if ((before >= 0) && (after >= 0)) {
-                        map = &hdr->freemap[before];
-                        INT_MOD(map->size, ARCH_CONVERT, entsize);
-                        INT_MOD(map->size, ARCH_CONVERT, INT_GET(hdr->freemap[after].size, ARCH_CONVERT));
-                        hdr->freemap[after].base = 0;
-                        hdr->freemap[after].size = 0;
-                } else if (before >= 0) {
-                        map = &hdr->freemap[before];
-                        INT_MOD(map->size, ARCH_CONVERT, entsize);
-                } else {
-                        map = &hdr->freemap[after];
-                        INT_COPY(map->base, entry->nameidx, ARCH_CONVERT);
-                        INT_MOD(map->size, ARCH_CONVERT, entsize);
-                }
-        } else {
-                /*
-                 * Replace smallest region (if it is smaller than free'd entry)
-                 */
-                map = &hdr->freemap[smallest];
-                if (INT_GET(map->size, ARCH_CONVERT) < entsize) {
-                        INT_COPY(map->base, entry->nameidx, ARCH_CONVERT);
-                        INT_SET(map->size, ARCH_CONVERT, entsize);
-                }
-        }
-        /*
-         * Did we remove the first entry?
-         */
-        if (INT_GET(entry->nameidx, ARCH_CONVERT) == INT_GET(hdr->firstused, ARCH_CONVERT))
-                smallest = 1;
-        else
-                smallest = 0;
-        /*
-         * Compress the remaining entries and zero out the removed stuff.
-         */
-        namest = XFS_DIR_LEAF_NAMESTRUCT(leaf, INT_GET(entry->nameidx, ARCH_CONVERT));
-        memset((char *)namest, 0, entsize);
-        xfs_da_log_buf(trans, bp, XFS_DA_LOGRANGE(leaf, namest, entsize));
-        INT_MOD(hdr->namebytes, ARCH_CONVERT, -(entry->namelen));
-        tmp = (INT_GET(hdr->count, ARCH_CONVERT) - index) * (uint)sizeof(xfs_dir_leaf_entry_t);
-        memmove(entry, entry + 1, tmp);
-        INT_MOD(hdr->count, ARCH_CONVERT, -1);
-        xfs_da_log_buf(trans, bp,
-            XFS_DA_LOGRANGE(leaf, entry, tmp + (uint)sizeof(*entry)));
-        entry = &leaf->entries[INT_GET(hdr->count, ARCH_CONVERT)];
-        memset((char *)entry, 0, sizeof(xfs_dir_leaf_entry_t));
-        /*
-         * If we removed the first entry, re-find the first used byte
-         * in the name area.  Note that if the entry was the "firstused",
-         * then we don't have a "hole" in our block resulting from
-         * removing the name.
-         */
-        if (smallest) {
-                tmp = XFS_LBSIZE(mp);
-                entry = &leaf->entries[0];
-                for (i = INT_GET(hdr->count, ARCH_CONVERT)-1; i >= 0; entry++, i--) {
-                        ASSERT(INT_GET(entry->nameidx, ARCH_CONVERT) >= INT_GET(hdr->firstused, ARCH_CONVERT));
-                        ASSERT(INT_GET(entry->nameidx, ARCH_CONVERT) < XFS_LBSIZE(mp));
-                        if (INT_GET(entry->nameidx, ARCH_CONVERT) < tmp)
-                                tmp = INT_GET(entry->nameidx, ARCH_CONVERT);
-                }
-                INT_SET(hdr->firstused, ARCH_CONVERT, tmp);
-                if (!hdr->firstused)
-                        INT_SET(hdr->firstused, ARCH_CONVERT, tmp - 1);
-        } else {
-                hdr->holes = 1;         /* mark as needing compaction */
-        }
-        xfs_da_log_buf(trans, bp, XFS_DA_LOGRANGE(leaf, hdr, sizeof(*hdr)));
-        /*
-         * Check if leaf is less than 50% full, caller may want to
-         * "join" the leaf with a sibling if so.
-         */
-        tmp  = (uint)sizeof(xfs_dir_leaf_hdr_t);
-        tmp += INT_GET(leaf->hdr.count, ARCH_CONVERT) * (uint)sizeof(xfs_dir_leaf_entry_t);
-        tmp += INT_GET(leaf->hdr.count, ARCH_CONVERT) * ((uint)sizeof(xfs_dir_leaf_name_t) - 1);
-        tmp += INT_GET(leaf->hdr.namebytes, ARCH_CONVERT);
-        if (tmp < mp->m_dir_magicpct)
-                return 1;                       /* leaf is < 37% full */
-        return 0;
-}
-/*
- * Move all the directory entries from drop_leaf into save_leaf.
- */
-void
-xfs_dir_leaf_unbalance(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
-                                      xfs_da_state_blk_t *save_blk)
-{
-        xfs_dir_leafblock_t *drop_leaf, *save_leaf, *tmp_leaf;
-        xfs_dir_leaf_hdr_t *drop_hdr, *save_hdr, *tmp_hdr;
-        xfs_mount_t *mp;
-        char *tmpbuffer;
-        /*
-         * Set up environment.
-         */
-        mp = state->mp;
-        ASSERT(drop_blk->magic == XFS_DIR_LEAF_MAGIC);
-        ASSERT(save_blk->magic == XFS_DIR_LEAF_MAGIC);
-        drop_leaf = drop_blk->bp->data;
-        save_leaf = save_blk->bp->data;
-        ASSERT(be16_to_cpu(drop_leaf->hdr.info.magic) == XFS_DIR_LEAF_MAGIC);
-        ASSERT(be16_to_cpu(save_leaf->hdr.info.magic) == XFS_DIR_LEAF_MAGIC);
-        drop_hdr = &drop_leaf->hdr;
-        save_hdr = &save_leaf->hdr;
-        /*
-         * Save last hashval from dying block for later Btree fixup.
-         */
-        drop_blk->hashval = INT_GET(drop_leaf->entries[ drop_leaf->hdr.count-1 ].hashval, ARCH_CONVERT);
-        /*
-         * Check if we need a temp buffer, or can we do it in place.
-         * Note that we don't check "leaf" for holes because we will
-         * always be dropping it, toosmall() decided that for us already.
-         */
-        if (save_hdr->holes == 0) {
-                /*
-                 * dest leaf has no holes, so we add there.  May need
-                 * to make some room in the entry array.
-                 */
-                if (xfs_dir_leaf_order(save_blk->bp, drop_blk->bp)) {
-                        xfs_dir_leaf_moveents(drop_leaf, 0, save_leaf, 0,
-                                                 (int)INT_GET(drop_hdr->count, ARCH_CONVERT), mp);
-                } else {
-                        xfs_dir_leaf_moveents(drop_leaf, 0,
-                                              save_leaf, INT_GET(save_hdr->count, ARCH_CONVERT),
-                                              (int)INT_GET(drop_hdr->count, ARCH_CONVERT), mp);
-                }
-        } else {
-                /*
-                 * Destination has holes, so we make a temporary copy
-                 * of the leaf and add them both to that.
-                 */
-                tmpbuffer = kmem_alloc(state->blocksize, KM_SLEEP);
-                ASSERT(tmpbuffer != NULL);
-                memset(tmpbuffer, 0, state->blocksize);
-                tmp_leaf = (xfs_dir_leafblock_t *)tmpbuffer;
-                tmp_hdr = &tmp_leaf->hdr;
-                tmp_hdr->info = save_hdr->info; /* struct copy */
-                tmp_hdr->count = 0;
-                INT_SET(tmp_hdr->firstused, ARCH_CONVERT, state->blocksize);
-                if (!tmp_hdr->firstused)
-                        INT_SET(tmp_hdr->firstused, ARCH_CONVERT, state->blocksize - 1);
-                tmp_hdr->namebytes = 0;
-                if (xfs_dir_leaf_order(save_blk->bp, drop_blk->bp)) {
-                        xfs_dir_leaf_moveents(drop_leaf, 0, tmp_leaf, 0,
-                                                 (int)INT_GET(drop_hdr->count, ARCH_CONVERT), mp);
-                        xfs_dir_leaf_moveents(save_leaf, 0,
-                                              tmp_leaf, INT_GET(tmp_leaf->hdr.count, ARCH_CONVERT),
-                                              (int)INT_GET(save_hdr->count, ARCH_CONVERT), mp);
-                } else {
-                        xfs_dir_leaf_moveents(save_leaf, 0, tmp_leaf, 0,
-                                                 (int)INT_GET(save_hdr->count, ARCH_CONVERT), mp);
-                        xfs_dir_leaf_moveents(drop_leaf, 0,
-                                              tmp_leaf, INT_GET(tmp_leaf->hdr.count, ARCH_CONVERT),
-                                              (int)INT_GET(drop_hdr->count, ARCH_CONVERT), mp);
-                }
-                memcpy(save_leaf, tmp_leaf, state->blocksize);
-                kmem_free(tmpbuffer, state->blocksize);
-        }
-        xfs_da_log_buf(state->args->trans, save_blk->bp, 0,
-                                           state->blocksize - 1);
-        /*
-         * Copy out last hashval in each block for B-tree code.
-         */
-        save_blk->hashval = INT_GET(save_leaf->entries[ INT_GET(save_leaf->hdr.count, ARCH_CONVERT)-1 ].hashval, ARCH_CONVERT);
-}
-/*========================================================================
- * Routines used for finding things in the Btree.
- *========================================================================*/
-/*
- * Look up a name in a leaf directory structure.
- * This is the internal routine, it uses the caller's buffer.
- *
- * Note that duplicate keys are allowed, but only check within the
- * current leaf node.  The Btree code must check in adjacent leaf nodes.
- *
- * Return in *index the index into the entry[] array of either the found
- * entry, or where the entry should have been (insert before that entry).
- *
- * Don't change the args->inumber unless we find the filename.
- */
-int
-xfs_dir_leaf_lookup_int(xfs_dabuf_t *bp, xfs_da_args_t *args, int *index)
-{
-        xfs_dir_leafblock_t *leaf;
-        xfs_dir_leaf_entry_t *entry;
-        xfs_dir_leaf_name_t *namest;
-        int probe, span;
-        xfs_dahash_t hashval;
-        leaf = bp->data;
-        ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR_LEAF_MAGIC);
-        ASSERT(INT_GET(leaf->hdr.count, ARCH_CONVERT) < (XFS_LBSIZE(args->dp->i_mount)/8));
-        /*
-         * Binary search.  (note: small blocks will skip this loop)
-         */
-        hashval = args->hashval;
-        probe = span = INT_GET(leaf->hdr.count, ARCH_CONVERT) / 2;
-        for (entry = &leaf->entries[probe]; span > 4;
-                   entry = &leaf->entries[probe]) {
-                span /= 2;
-                if (INT_GET(entry->hashval, ARCH_CONVERT) < hashval)
-                        probe += span;
-                else if (INT_GET(entry->hashval, ARCH_CONVERT) > hashval)
-                        probe -= span;
-                else
-                        break;
-        }
-        ASSERT((probe >= 0) && \
-               ((!leaf->hdr.count) || (probe < INT_GET(leaf->hdr.count, ARCH_CONVERT))));
-        ASSERT((span <= 4) || (INT_GET(entry->hashval, ARCH_CONVERT) == hashval));
-        /*
-         * Since we may have duplicate hashval's, find the first matching
-         * hashval in the leaf.
-         */
-        while ((probe > 0) && (INT_GET(entry->hashval, ARCH_CONVERT) >= hashval)) {
-                entry--;
-                probe--;
-        }
-        while ((probe < INT_GET(leaf->hdr.count, ARCH_CONVERT)) && (INT_GET(entry->hashval, ARCH_CONVERT) < hashval)) {
-                entry++;
-                probe++;
-        }
-        if ((probe == INT_GET(leaf->hdr.count, ARCH_CONVERT)) || (INT_GET(entry->hashval, ARCH_CONVERT) != hashval)) {
-                *index = probe;
-                ASSERT(args->oknoent);
-                return XFS_ERROR(ENOENT);
-        }
-        /*
-         * Duplicate keys may be present, so search all of them for a match.
-         */
-        while ((probe < INT_GET(leaf->hdr.count, ARCH_CONVERT)) && (INT_GET(entry->hashval, ARCH_CONVERT) == hashval)) {
-                namest = XFS_DIR_LEAF_NAMESTRUCT(leaf, INT_GET(entry->nameidx, ARCH_CONVERT));
-                if (entry->namelen == args->namelen &&
-                    namest->name[0] == args->name[0] &&
-                    memcmp(args->name, namest->name, args->namelen) == 0) {
-                        XFS_DIR_SF_GET_DIRINO(&namest->inumber, &args->inumber);
-                        *index = probe;
-                        return XFS_ERROR(EEXIST);
-                }
-                entry++;
-                probe++;
-        }
-        *index = probe;
-        ASSERT(probe == INT_GET(leaf->hdr.count, ARCH_CONVERT) || args->oknoent);
-        return XFS_ERROR(ENOENT);
-}
-/*========================================================================
- * Utility routines.
- *========================================================================*/
-/*
- * Move the indicated entries from one leaf to another.
- * NOTE: this routine modifies both source and destination leaves.
- */
-/* ARGSUSED */
-STATIC void
-xfs_dir_leaf_moveents(xfs_dir_leafblock_t *leaf_s, int start_s,
-                      xfs_dir_leafblock_t *leaf_d, int start_d,
-                      int count, xfs_mount_t *mp)
-{
-        xfs_dir_leaf_hdr_t *hdr_s, *hdr_d;
-        xfs_dir_leaf_entry_t *entry_s, *entry_d;
-        int tmp, i;
-        /*
-         * Check for nothing to do.
-         */
-        if (count == 0)
-                return;
-        /*
-         * Set up environment.
-         */
-        ASSERT(be16_to_cpu(leaf_s->hdr.info.magic) == XFS_DIR_LEAF_MAGIC);
-        ASSERT(be16_to_cpu(leaf_d->hdr.info.magic) == XFS_DIR_LEAF_MAGIC);
-        hdr_s = &leaf_s->hdr;
-        hdr_d = &leaf_d->hdr;
-        ASSERT((INT_GET(hdr_s->count, ARCH_CONVERT) > 0) && (INT_GET(hdr_s->count, ARCH_CONVERT) < (XFS_LBSIZE(mp)/8)));
-        ASSERT(INT_GET(hdr_s->firstused, ARCH_CONVERT) >=
-                ((INT_GET(hdr_s->count, ARCH_CONVERT)*sizeof(*entry_s))+sizeof(*hdr_s)));
-        ASSERT(INT_GET(hdr_d->count, ARCH_CONVERT) < (XFS_LBSIZE(mp)/8));
-        ASSERT(INT_GET(hdr_d->firstused, ARCH_CONVERT) >=
-                ((INT_GET(hdr_d->count, ARCH_CONVERT)*sizeof(*entry_d))+sizeof(*hdr_d)));
-        ASSERT(start_s < INT_GET(hdr_s->count, ARCH_CONVERT));
-        ASSERT(start_d <= INT_GET(hdr_d->count, ARCH_CONVERT));
-        ASSERT(count <= INT_GET(hdr_s->count, ARCH_CONVERT));
-        /*
-         * Move the entries in the destination leaf up to make a hole?
-         */
-        if (start_d < INT_GET(hdr_d->count, ARCH_CONVERT)) {
-                tmp  = INT_GET(hdr_d->count, ARCH_CONVERT) - start_d;
-                tmp *= (uint)sizeof(xfs_dir_leaf_entry_t);
-                entry_s = &leaf_d->entries[start_d];
-                entry_d = &leaf_d->entries[start_d + count];
-                memcpy(entry_d, entry_s, tmp);
-        }
-        /*
-         * Copy all entry's in the same (sorted) order,
-         * but allocate filenames packed and in sequence.
-         */
-        entry_s = &leaf_s->entries[start_s];
-        entry_d = &leaf_d->entries[start_d];
-        for (i = 0; i < count; entry_s++, entry_d++, i++) {
-                ASSERT(INT_GET(entry_s->nameidx, ARCH_CONVERT) >= INT_GET(hdr_s->firstused, ARCH_CONVERT));
-                tmp = XFS_DIR_LEAF_ENTSIZE_BYENTRY(entry_s);
-                INT_MOD(hdr_d->firstused, ARCH_CONVERT, -(tmp));
-                entry_d->hashval = entry_s->hashval; /* INT_: direct copy */
-                INT_COPY(entry_d->nameidx, hdr_d->firstused, ARCH_CONVERT);
-                entry_d->namelen = entry_s->namelen;
-                ASSERT(INT_GET(entry_d->nameidx, ARCH_CONVERT) + tmp <= XFS_LBSIZE(mp));
-                memcpy(XFS_DIR_LEAF_NAMESTRUCT(leaf_d, INT_GET(entry_d->nameidx, ARCH_CONVERT)),
-                       XFS_DIR_LEAF_NAMESTRUCT(leaf_s, INT_GET(entry_s->nameidx, ARCH_CONVERT)), tmp);
-                ASSERT(INT_GET(entry_s->nameidx, ARCH_CONVERT) + tmp <= XFS_LBSIZE(mp));
-                memset((char *)XFS_DIR_LEAF_NAMESTRUCT(leaf_s, INT_GET(entry_s->nameidx, ARCH_CONVERT)),
-                      0, tmp);
-                INT_MOD(hdr_s->namebytes, ARCH_CONVERT, -(entry_d->namelen));
-                INT_MOD(hdr_d->namebytes, ARCH_CONVERT, entry_d->namelen);
-                INT_MOD(hdr_s->count, ARCH_CONVERT, -1);
-                INT_MOD(hdr_d->count, ARCH_CONVERT, +1);
-                tmp  = INT_GET(hdr_d->count, ARCH_CONVERT) * (uint)sizeof(xfs_dir_leaf_entry_t)
-                                + (uint)sizeof(xfs_dir_leaf_hdr_t);
-                ASSERT(INT_GET(hdr_d->firstused, ARCH_CONVERT) >= tmp);
-        }
-        /*
-         * Zero out the entries we just copied.
-         */
-        if (start_s == INT_GET(hdr_s->count, ARCH_CONVERT)) {
-                tmp = count * (uint)sizeof(xfs_dir_leaf_entry_t);
-                entry_s = &leaf_s->entries[start_s];
-                ASSERT((char *)entry_s + tmp <= (char *)leaf_s + XFS_LBSIZE(mp));
-                memset((char *)entry_s, 0, tmp);
-        } else {
-                /*
-                 * Move the remaining entries down to fill the hole,
-                 * then zero the entries at the top.
-                 */
-                tmp  = INT_GET(hdr_s->count, ARCH_CONVERT) - count;
-                tmp *= (uint)sizeof(xfs_dir_leaf_entry_t);
-                entry_s = &leaf_s->entries[start_s + count];
-                entry_d = &leaf_s->entries[start_s];
-                memcpy(entry_d, entry_s, tmp);
-                tmp = count * (uint)sizeof(xfs_dir_leaf_entry_t);
-                entry_s = &leaf_s->entries[INT_GET(hdr_s->count, ARCH_CONVERT)];
-                ASSERT((char *)entry_s + tmp <= (char *)leaf_s + XFS_LBSIZE(mp));
-                memset((char *)entry_s, 0, tmp);
-        }
-        /*
-         * Fill in the freemap information
-         */
-        INT_SET(hdr_d->freemap[0].base, ARCH_CONVERT, (uint)sizeof(xfs_dir_leaf_hdr_t));
-        INT_MOD(hdr_d->freemap[0].base, ARCH_CONVERT, INT_GET(hdr_d->count, ARCH_CONVERT) * (uint)sizeof(xfs_dir_leaf_entry_t));
-        INT_SET(hdr_d->freemap[0].size, ARCH_CONVERT, INT_GET(hdr_d->firstused, ARCH_CONVERT) - INT_GET(hdr_d->freemap[0].base, ARCH_CONVERT));
-        INT_SET(hdr_d->freemap[1].base, ARCH_CONVERT, (hdr_d->freemap[2].base = 0));
-        INT_SET(hdr_d->freemap[1].size, ARCH_CONVERT, (hdr_d->freemap[2].size = 0));
-        hdr_s->holes = 1;       /* leaf may not be compact */
-}
-/*
- * Compare two leaf blocks "order".
- */
-int
-xfs_dir_leaf_order(xfs_dabuf_t *leaf1_bp, xfs_dabuf_t *leaf2_bp)
-{
-        xfs_dir_leafblock_t *leaf1, *leaf2;
-        leaf1 = leaf1_bp->data;
-        leaf2 = leaf2_bp->data;
-        ASSERT((be16_to_cpu(leaf1->hdr.info.magic) == XFS_DIR_LEAF_MAGIC) &&
-               (be16_to_cpu(leaf2->hdr.info.magic) == XFS_DIR_LEAF_MAGIC));
-        if ((INT_GET(leaf1->hdr.count, ARCH_CONVERT) > 0) && (INT_GET(leaf2->hdr.count, ARCH_CONVERT) > 0) &&
-            ((INT_GET(leaf2->entries[ 0 ].hashval, ARCH_CONVERT) <
-              INT_GET(leaf1->entries[ 0 ].hashval, ARCH_CONVERT)) ||
-             (INT_GET(leaf2->entries[ INT_GET(leaf2->hdr.count, ARCH_CONVERT)-1 ].hashval, ARCH_CONVERT) <
-              INT_GET(leaf1->entries[ INT_GET(leaf1->hdr.count, ARCH_CONVERT)-1 ].hashval, ARCH_CONVERT)))) {
-                return 1;
-        }
-        return 0;
-}
-/*
- * Pick up the last hashvalue from a leaf block.
- */
-xfs_dahash_t
-xfs_dir_leaf_lasthash(xfs_dabuf_t *bp, int *count)
-{
-        xfs_dir_leafblock_t *leaf;
-        leaf = bp->data;
-        ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR_LEAF_MAGIC);
-        if (count)
-                *count = INT_GET(leaf->hdr.count, ARCH_CONVERT);
-        if (!leaf->hdr.count)
-                return(0);
-        return(INT_GET(leaf->entries[ INT_GET(leaf->hdr.count, ARCH_CONVERT)-1 ].hashval, ARCH_CONVERT));
-}
-/*
- * Copy out directory entries for getdents(), for leaf directories.
- */
-int
-xfs_dir_leaf_getdents_int(
-        xfs_dabuf_t     *bp,
-        xfs_inode_t     *dp,
-        xfs_dablk_t     bno,
-        uio_t           *uio,
-        int             *eobp,
-        xfs_dirent_t    *dbp,
-        xfs_dir_put_t   put,
-        xfs_daddr_t             nextda)
-{
-        xfs_dir_leafblock_t     *leaf;
-        xfs_dir_leaf_entry_t    *entry;
-        xfs_dir_leaf_name_t     *namest;
-        int                     entno, want_entno, i, nextentno;
-        xfs_mount_t             *mp;
-        xfs_dahash_t            cookhash;
-        xfs_dahash_t            nexthash = 0;
-#if (BITS_PER_LONG == 32)
-        xfs_dahash_t            lasthash = XFS_DA_MAXHASH;
-#endif
-        xfs_dir_put_args_t      p;
-        mp = dp->i_mount;
-        leaf = bp->data;
-        if (be16_to_cpu(leaf->hdr.info.magic) != XFS_DIR_LEAF_MAGIC) {
-                *eobp = 1;
-                return XFS_ERROR(ENOENT);       /* XXX wrong code */
-        }
-        want_entno = XFS_DA_COOKIE_ENTRY(mp, uio->uio_offset);
-        cookhash = XFS_DA_COOKIE_HASH(mp, uio->uio_offset);
-        xfs_dir_trace_g_dul("leaf: start", dp, uio, leaf);
-        /*
-         * Re-find our place.
-         */
-        for (i = entno = 0, entry = &leaf->entries[0];
-                     i < INT_GET(leaf->hdr.count, ARCH_CONVERT);
-                             entry++, i++) {
-                namest = XFS_DIR_LEAF_NAMESTRUCT(leaf,
-                                    INT_GET(entry->nameidx, ARCH_CONVERT));
-                if (unlikely(
-                    ((char *)namest < (char *)leaf) ||
-                    ((char *)namest >= (char *)leaf + XFS_LBSIZE(mp)))) {
-                        XFS_CORRUPTION_ERROR("xfs_dir_leaf_getdents_int(1)",
-                                             XFS_ERRLEVEL_LOW, mp, leaf);
-                        xfs_dir_trace_g_du("leaf: corrupted", dp, uio);
-                        return XFS_ERROR(EFSCORRUPTED);
-                }
-                if (INT_GET(entry->hashval, ARCH_CONVERT) >= cookhash) {
-                        if (   entno < want_entno
-                            && INT_GET(entry->hashval, ARCH_CONVERT)
-                                                        == cookhash) {
-                                /*
-                                 * Trying to get to a particular offset in a
-                                 * run of equal-hashval entries.
-                                 */
-                                entno++;
-                        } else if (   want_entno > 0
-                                   && entno == want_entno
-                                   && INT_GET(entry->hashval, ARCH_CONVERT)
-                                                        == cookhash) {
-                                break;
-                        } else {
-                                entno = 0;
-                                break;
-                        }
-                }
-        }
-        if (i == INT_GET(leaf->hdr.count, ARCH_CONVERT)) {
-                xfs_dir_trace_g_du("leaf: hash not found", dp, uio);
-                if (!leaf->hdr.info.forw)
-                        uio->uio_offset =
-                                XFS_DA_MAKE_COOKIE(mp, 0, 0, XFS_DA_MAXHASH);
-                /*
-                 * Don't set uio_offset if there's another block:
-                 * the node code will be setting uio_offset anyway.
-                 */
-                *eobp = 0;
-                return 0;
-        }
-        xfs_dir_trace_g_due("leaf: hash found", dp, uio, entry);
-        p.dbp = dbp;
-        p.put = put;
-        p.uio = uio;
-        /*
-         * We're synchronized, start copying entries out to the user.
-         */
-        for (; entno >= 0 && i < INT_GET(leaf->hdr.count, ARCH_CONVERT);
-                             entry++, i++, (entno = nextentno)) {
-                int lastresid=0, retval;
-                xfs_dircook_t lastoffset;
-                xfs_dahash_t thishash;
-                /*
-                 * Check for a damaged directory leaf block and pick up
-                 * the inode number from this entry.
-                 */
-                namest = XFS_DIR_LEAF_NAMESTRUCT(leaf,
-                                    INT_GET(entry->nameidx, ARCH_CONVERT));
-                if (unlikely(
-                    ((char *)namest < (char *)leaf) ||
-                    ((char *)namest >= (char *)leaf + XFS_LBSIZE(mp)))) {
-                        XFS_CORRUPTION_ERROR("xfs_dir_leaf_getdents_int(2)",
-                                             XFS_ERRLEVEL_LOW, mp, leaf);
-                        xfs_dir_trace_g_du("leaf: corrupted", dp, uio);
-                        return XFS_ERROR(EFSCORRUPTED);
-                }
-                xfs_dir_trace_g_duc("leaf: middle cookie  ",
-                                                   dp, uio, p.cook.o);
-                if (i < (INT_GET(leaf->hdr.count, ARCH_CONVERT) - 1)) {
-                        nexthash = INT_GET(entry[1].hashval, ARCH_CONVERT);
-                        if (nexthash == INT_GET(entry->hashval, ARCH_CONVERT))
-                                nextentno = entno + 1;
-                        else
-                                nextentno = 0;
-                        XFS_PUT_COOKIE(p.cook, mp, bno, nextentno, nexthash);
-                        xfs_dir_trace_g_duc("leaf: middle cookie  ",
-                                                   dp, uio, p.cook.o);
-                } else if ((thishash = be32_to_cpu(leaf->hdr.info.forw))) {
-                        xfs_dabuf_t *bp2;
-                        xfs_dir_leafblock_t *leaf2;
-                        ASSERT(nextda != -1);
-                        retval = xfs_da_read_buf(dp->i_transp, dp, thishash,
-                                                 nextda, &bp2, XFS_DATA_FORK);
-                        if (retval)
-                                return retval;
-                        ASSERT(bp2 != NULL);
-                        leaf2 = bp2->data;
-                        if (unlikely(
-                               (be16_to_cpu(leaf2->hdr.info.magic)
-                                                != XFS_DIR_LEAF_MAGIC)
-                            || (be32_to_cpu(leaf2->hdr.info.back)
-                                                != bno))) {     /* GROT */
-                                XFS_CORRUPTION_ERROR("xfs_dir_leaf_getdents_int(3)",
-                                                     XFS_ERRLEVEL_LOW, mp,
-                                                     leaf2);
-                                xfs_da_brelse(dp->i_transp, bp2);
-                                return XFS_ERROR(EFSCORRUPTED);
-                        }
-                        nexthash = INT_GET(leaf2->entries[0].hashval,
-                                                                ARCH_CONVERT);
-                        nextentno = -1;
-                        XFS_PUT_COOKIE(p.cook, mp, thishash, 0, nexthash);
-                        xfs_da_brelse(dp->i_transp, bp2);
-                        xfs_dir_trace_g_duc("leaf: next blk cookie",
-                                                   dp, uio, p.cook.o);
-                } else {
-                        nextentno = -1;
-                        XFS_PUT_COOKIE(p.cook, mp, 0, 0, XFS_DA_MAXHASH);
-                }
-                /*
-                 * Save off the cookie so we can fall back should the
-                 * 'put' into the outgoing buffer fails.  To handle a run
-                 * of equal-hashvals, the off_t structure on 64bit
-                 * builds has entno built into the cookie to ID the
-                 * entry.  On 32bit builds, we only have space for the
-                 * hashval so we can't ID specific entries within a group
-                 * of same hashval entries.   For this, lastoffset is set
-                 * to the first in the run of equal hashvals so we don't
-                 * include any entries unless we can include all entries
-                 * that share the same hashval.  Hopefully the buffer
-                 * provided is big enough to handle it (see pv763517).
-                 */
-#if (BITS_PER_LONG == 32)
-                if ((thishash = INT_GET(entry->hashval, ARCH_CONVERT))
-                                                                != lasthash) {
-                        XFS_PUT_COOKIE(lastoffset, mp, bno, entno, thishash);
-                        lastresid = uio->uio_resid;
-                        lasthash = thishash;
-                } else {
-                        xfs_dir_trace_g_duc("leaf: DUP COOKIES, skipped",
-                                                   dp, uio, p.cook.o);
-                }
-#else
-                thishash = INT_GET(entry->hashval, ARCH_CONVERT);
-                XFS_PUT_COOKIE(lastoffset, mp, bno, entno, thishash);
-                lastresid = uio->uio_resid;
-#endif /* BITS_PER_LONG == 32 */
-                /*
-                 * Put the current entry into the outgoing buffer.  If we fail
-                 * then restore the UIO to the first entry in the current
-                 * run of equal-hashval entries (probably one 1 entry long).
-                 */
-                p.ino = XFS_GET_DIR_INO8(namest->inumber);
-#if XFS_BIG_INUMS
-                p.ino += mp->m_inoadd;
-#endif
-                p.name = (char *)namest->name;
-                p.namelen = entry->namelen;
-                retval = p.put(&p);
-                if (!p.done) {
-                        uio->uio_offset = lastoffset.o;
-                        uio->uio_resid = lastresid;
-                        *eobp = 1;
-                        xfs_dir_trace_g_du("leaf: E-O-B", dp, uio);
-                        return retval;
-                }
-        }
-        uio->uio_offset = p.cook.o;
-        *eobp = 0;
-        xfs_dir_trace_g_du("leaf: E-O-F", dp, uio);
-        return 0;
-}
-/*
- * Format a dirent64 structure and copy it out the the user's buffer.
- */
-int
-xfs_dir_put_dirent64_direct(xfs_dir_put_args_t *pa)
-{
-        iovec_t *iovp;
-        int reclen, namelen;
-        xfs_dirent_t *idbp;
-        uio_t *uio;
-        namelen = pa->namelen;
-        reclen = DIRENTSIZE(namelen);
-        uio = pa->uio;
-        if (reclen > uio->uio_resid) {
-                pa->done = 0;
-                return 0;
-        }
-        iovp = uio->uio_iov;
-        idbp = (xfs_dirent_t *)iovp->iov_base;
-        iovp->iov_base = (char *)idbp + reclen;
-        iovp->iov_len -= reclen;
-        uio->uio_resid -= reclen;
-        idbp->d_reclen = reclen;
-        idbp->d_ino = pa->ino;
-        idbp->d_off = pa->cook.o;
-        idbp->d_name[namelen] = '\0';
-        pa->done = 1;
-        memcpy(idbp->d_name, pa->name, namelen);
-        return 0;
-}
-/*
- * Format a dirent64 structure and copy it out the the user's buffer.
- */
-int
-xfs_dir_put_dirent64_uio(xfs_dir_put_args_t *pa)
-{
-        int             retval, reclen, namelen;
-        xfs_dirent_t    *idbp;
-        uio_t           *uio;
-        namelen = pa->namelen;
-        reclen = DIRENTSIZE(namelen);
-        uio = pa->uio;
-        if (reclen > uio->uio_resid) {
-                pa->done = 0;
-                return 0;
-        }
-        idbp = pa->dbp;
-        idbp->d_reclen = reclen;
-        idbp->d_ino = pa->ino;
-        idbp->d_off = pa->cook.o;
-        idbp->d_name[namelen] = '\0';
-        memcpy(idbp->d_name, pa->name, namelen);
-        retval = uio_read((caddr_t)idbp, reclen, uio);
-        pa->done = (retval == 0);
-        return retval;
-}
diff --git a/fs/xfs/xfs_dir_leaf.h b/fs/xfs/xfs_dir_leaf.h
deleted file mode 100644
index eb8cd9a4667f..000000000000
--- a/fs/xfs/xfs_dir_leaf.h
+++ /dev/null
@@ -1,231 +0,0 @@
-/*
- * Copyright (c) 2000-2001,2005 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_DIR_LEAF_H__
-#define __XFS_DIR_LEAF_H__
-/*
- * Directory layout, internal structure, access macros, etc.
- *
- * Large directories are structured around Btrees where all the data
- * elements are in the leaf nodes.  Filenames are hashed into an int,
- * then that int is used as the index into the Btree.  Since the hashval
- * of a filename may not be unique, we may have duplicate keys.  The
- * internal links in the Btree are logical block offsets into the file.
- */
-struct uio;
-struct xfs_bmap_free;
-struct xfs_dabuf;
-struct xfs_da_args;
-struct xfs_da_state;
-struct xfs_da_state_blk;
-struct xfs_dir_put_args;
-struct xfs_inode;
-struct xfs_mount;
-struct xfs_trans;
-/*========================================================================
- * Directory Structure when equal to XFS_LBSIZE(mp) bytes.
- *========================================================================*/
-/*
- * This is the structure of the leaf nodes in the Btree.
- *
- * Struct leaf_entry's are packed from the top.  Names grow from the bottom
- * but are not packed.  The freemap contains run-length-encoded entries
- * for the free bytes after the leaf_entry's, but only the N largest such,
- * smaller runs are dropped.  When the freemap doesn't show enough space
- * for an allocation, we compact the namelist area and try again.  If we
- * still don't have enough space, then we have to split the block.
- *
- * Since we have duplicate hash keys, for each key that matches, compare
- * the actual string.  The root and intermediate node search always takes
- * the first-in-the-block key match found, so we should only have to work
- * "forw"ard.  If none matches, continue with the "forw"ard leaf nodes
- * until the hash key changes or the filename is found.
- *
- * The parent directory and the self-pointer are explicitly represented
- * (ie: there are entries for "." and "..").
- *
- * Note that the count being a __uint16_t limits us to something like a
- * blocksize of 1.3MB in the face of worst case (short) filenames.
- */
-#define XFS_DIR_LEAF_MAPSIZE    3       /* how many freespace slots */
-typedef struct xfs_dir_leaf_map {       /* RLE map of free bytes */
-        __uint16_t      base;           /* base of free region */
-        __uint16_t      size;           /* run length of free region */
-} xfs_dir_leaf_map_t;
-typedef struct xfs_dir_leaf_hdr {       /* constant-structure header block */
-        xfs_da_blkinfo_t info;          /* block type, links, etc. */
-        __uint16_t      count;          /* count of active leaf_entry's */
-        __uint16_t      namebytes;      /* num bytes of name strings stored */
-        __uint16_t      firstused;      /* first used byte in name area */
-        __uint8_t       holes;          /* != 0 if blk needs compaction */
-        __uint8_t       pad1;
-        xfs_dir_leaf_map_t freemap[XFS_DIR_LEAF_MAPSIZE];
-} xfs_dir_leaf_hdr_t;
-typedef struct xfs_dir_leaf_entry {     /* sorted on key, not name */
-        xfs_dahash_t    hashval;        /* hash value of name */
-        __uint16_t      nameidx;        /* index into buffer of name */
-        __uint8_t       namelen;        /* length of name string */
-        __uint8_t       pad2;
-} xfs_dir_leaf_entry_t;
-typedef struct xfs_dir_leaf_name {
-        xfs_dir_ino_t   inumber;        /* inode number for this key */
-        __uint8_t       name[1];        /* name string itself */
-} xfs_dir_leaf_name_t;
-typedef struct xfs_dir_leafblock {
-        xfs_dir_leaf_hdr_t      hdr;    /* constant-structure header block */
-        xfs_dir_leaf_entry_t    entries[1];     /* var sized array */
-        xfs_dir_leaf_name_t     namelist[1];    /* grows from bottom of buf */
-} xfs_dir_leafblock_t;
-/*
- * Length of name for which a 512-byte block filesystem
- * can get a double split.
- */
-#define XFS_DIR_LEAF_CAN_DOUBLE_SPLIT_LEN       \
-        (512 - (uint)sizeof(xfs_dir_leaf_hdr_t) - \
-         (uint)sizeof(xfs_dir_leaf_entry_t) * 2 - \
-         (uint)sizeof(xfs_dir_leaf_name_t) * 2 - (MAXNAMELEN - 2) + 1 + 1)
-typedef int (*xfs_dir_put_t)(struct xfs_dir_put_args *pa);
-typedef union {
-        xfs_off_t               o;              /* offset (cookie) */
-        /*
-         * Watch the order here (endian-ness dependent).
-         */
-        struct {
-#ifndef XFS_NATIVE_HOST
-                xfs_dahash_t    h;      /* hash value */
-                __uint32_t      be;     /* block and entry */
-#else
-                __uint32_t      be;     /* block and entry */
-                xfs_dahash_t    h;      /* hash value */
-#endif /* XFS_NATIVE_HOST */
-        } s;
-} xfs_dircook_t;
-#define XFS_PUT_COOKIE(c,mp,bno,entry,hash)     \
-        ((c).s.be = XFS_DA_MAKE_BNOENTRY(mp, bno, entry), (c).s.h = (hash))
-typedef struct xfs_dir_put_args {
-        xfs_dircook_t   cook;           /* cookie of (next) entry */
-        xfs_intino_t    ino;            /* inode number */
-        struct xfs_dirent *dbp;         /* buffer pointer */
-        char            *name;          /* directory entry name */
-        int             namelen;        /* length of name */
-        int             done;           /* output: set if value was stored */
-        xfs_dir_put_t   put;            /* put function ptr (i/o) */
-        struct uio      *uio;           /* uio control structure */
-} xfs_dir_put_args_t;
-#define XFS_DIR_LEAF_ENTSIZE_BYNAME(len)        \
-        xfs_dir_leaf_entsize_byname(len)
-static inline int xfs_dir_leaf_entsize_byname(int len)
-{
-        return (uint)sizeof(xfs_dir_leaf_name_t)-1 + len;
-}
-#define XFS_DIR_LEAF_ENTSIZE_BYENTRY(entry)     \
-        xfs_dir_leaf_entsize_byentry(entry)
-static inline int xfs_dir_leaf_entsize_byentry(xfs_dir_leaf_entry_t *entry)
-{
-        return (uint)sizeof(xfs_dir_leaf_name_t)-1 + (entry)->namelen;
-}
-#define XFS_DIR_LEAF_NAMESTRUCT(leafp,offset)   \
-        xfs_dir_leaf_namestruct(leafp,offset)
-static inline xfs_dir_leaf_name_t *
-xfs_dir_leaf_namestruct(xfs_dir_leafblock_t *leafp, int offset)
-{
-        return (xfs_dir_leaf_name_t *)&((char *)(leafp))[offset];
-}
-/*========================================================================
- * Function prototypes for the kernel.
- *========================================================================*/
-/*
- * Internal routines when dirsize < XFS_LITINO(mp).
- */
-int xfs_dir_shortform_create(struct xfs_da_args *args, xfs_ino_t parent);
-int xfs_dir_shortform_addname(struct xfs_da_args *args);
-int xfs_dir_shortform_lookup(struct xfs_da_args *args);
-int xfs_dir_shortform_to_leaf(struct xfs_da_args *args);
-int xfs_dir_shortform_removename(struct xfs_da_args *args);
-int xfs_dir_shortform_getdents(struct xfs_inode *dp, struct uio *uio, int *eofp,
-                               struct xfs_dirent *dbp, xfs_dir_put_t put);
-int xfs_dir_shortform_replace(struct xfs_da_args *args);
-/*
- * Internal routines when dirsize == XFS_LBSIZE(mp).
- */
-int xfs_dir_leaf_to_node(struct xfs_da_args *args);
-int xfs_dir_leaf_to_shortform(struct xfs_da_args *args);
-/*
- * Routines used for growing the Btree.
- */
-int     xfs_dir_leaf_split(struct xfs_da_state *state,
-                                  struct xfs_da_state_blk *oldblk,
-                                  struct xfs_da_state_blk *newblk);
-int     xfs_dir_leaf_add(struct xfs_dabuf *leaf_buffer,
-                                struct xfs_da_args *args, int insertion_index);
-int     xfs_dir_leaf_addname(struct xfs_da_args *args);
-int     xfs_dir_leaf_lookup_int(struct xfs_dabuf *leaf_buffer,
-                                       struct xfs_da_args *args,
-                                       int *index_found_at);
-int     xfs_dir_leaf_remove(struct xfs_trans *trans,
-                                   struct xfs_dabuf *leaf_buffer,
-                                   int index_to_remove);
-int     xfs_dir_leaf_getdents_int(struct xfs_dabuf *bp, struct xfs_inode *dp,
-                                         xfs_dablk_t bno, struct uio *uio,
-                                         int *eobp, struct xfs_dirent *dbp,
-                                         xfs_dir_put_t put, xfs_daddr_t nextda);
-/*
- * Routines used for shrinking the Btree.
- */
-int     xfs_dir_leaf_toosmall(struct xfs_da_state *state, int *retval);
-void    xfs_dir_leaf_unbalance(struct xfs_da_state *state,
-                                             struct xfs_da_state_blk *drop_blk,
-                                             struct xfs_da_state_blk *save_blk);
-/*
- * Utility routines.
- */
-uint    xfs_dir_leaf_lasthash(struct xfs_dabuf *bp, int *count);
-int     xfs_dir_leaf_order(struct xfs_dabuf *leaf1_bp,
-                                  struct xfs_dabuf *leaf2_bp);
-int     xfs_dir_put_dirent64_direct(xfs_dir_put_args_t *pa);
-int     xfs_dir_put_dirent64_uio(xfs_dir_put_args_t *pa);
-int     xfs_dir_ino_validate(struct xfs_mount *mp, xfs_ino_t ino);
-/*
- * Global data.
- */
-extern xfs_dahash_t     xfs_dir_hash_dot, xfs_dir_hash_dotdot;
-#endif /* __XFS_DIR_LEAF_H__ */
diff --git a/fs/xfs/xfs_dir_sf.h b/fs/xfs/xfs_dir_sf.h
deleted file mode 100644
index 5b20b4d3f57d..000000000000
--- a/fs/xfs/xfs_dir_sf.h
+++ /dev/null
@@ -1,155 +0,0 @@
-/*
- * Copyright (c) 2000,2005 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_DIR_SF_H__
-#define __XFS_DIR_SF_H__
-/*
- * Directory layout when stored internal to an inode.
- *
- * Small directories are packed as tightly as possible so as to
- * fit into the literal area of the inode.
- */
-typedef struct { __uint8_t i[sizeof(xfs_ino_t)]; } xfs_dir_ino_t;
-/*
- * The parent directory has a dedicated field, and the self-pointer must
- * be calculated on the fly.
- *
- * Entries are packed toward the top as tight as possible.  The header
- * and the elements much be memcpy'd out into a work area to get correct
- * alignment for the inode number fields.
- */
-typedef struct xfs_dir_sf_hdr {         /* constant-structure header block */
-        xfs_dir_ino_t   parent;         /* parent dir inode number */
-        __uint8_t       count;          /* count of active entries */
-} xfs_dir_sf_hdr_t;
-typedef struct xfs_dir_sf_entry {
-        xfs_dir_ino_t   inumber;        /* referenced inode number */
-        __uint8_t       namelen;        /* actual length of name (no NULL) */
-        __uint8_t       name[1];        /* name */
-} xfs_dir_sf_entry_t;
-typedef struct xfs_dir_shortform {
-        xfs_dir_sf_hdr_t        hdr;
-        xfs_dir_sf_entry_t      list[1];        /* variable sized array */
-} xfs_dir_shortform_t;
-/*
- * We generate this then sort it, so that readdirs are returned in
- * hash-order.  Else seekdir won't work.
- */
-typedef struct xfs_dir_sf_sort {
-        __uint8_t       entno;          /* .=0, ..=1, else entry# + 2 */
-        __uint8_t       seqno;          /* sequence # with same hash value */
-        __uint8_t       namelen;        /* length of name value (no null) */
-        xfs_dahash_t    hash;           /* this entry's hash value */
-        xfs_intino_t    ino;            /* this entry's inode number */
-        char            *name;          /* name value, pointer into buffer */
-} xfs_dir_sf_sort_t;
-#define XFS_DIR_SF_GET_DIRINO(from,to)  xfs_dir_sf_get_dirino(from, to)
-static inline void xfs_dir_sf_get_dirino(xfs_dir_ino_t *from, xfs_ino_t *to)
-{
-        *(to) = XFS_GET_DIR_INO8(*from);
-}
-#define XFS_DIR_SF_PUT_DIRINO(from,to)  xfs_dir_sf_put_dirino(from, to)
-static inline void xfs_dir_sf_put_dirino(xfs_ino_t *from, xfs_dir_ino_t *to)
-{
-        XFS_PUT_DIR_INO8(*(from), *(to));
-}
-#define XFS_DIR_SF_ENTSIZE_BYNAME(len)  xfs_dir_sf_entsize_byname(len)
-static inline int xfs_dir_sf_entsize_byname(int len)
-{
-        return (uint)sizeof(xfs_dir_sf_entry_t)-1 + (len);
-}
-#define XFS_DIR_SF_ENTSIZE_BYENTRY(sfep)        xfs_dir_sf_entsize_byentry(sfep)
-static inline int xfs_dir_sf_entsize_byentry(xfs_dir_sf_entry_t *sfep)
-{
-        return (uint)sizeof(xfs_dir_sf_entry_t)-1 + (sfep)->namelen;
-}
-#define XFS_DIR_SF_NEXTENTRY(sfep)              xfs_dir_sf_nextentry(sfep)
-static inline xfs_dir_sf_entry_t *xfs_dir_sf_nextentry(xfs_dir_sf_entry_t *sfep)
-{
-        return (xfs_dir_sf_entry_t *) \
-                ((char *)(sfep) + XFS_DIR_SF_ENTSIZE_BYENTRY(sfep));
-}
-#define XFS_DIR_SF_ALLFIT(count,totallen)       \
-        xfs_dir_sf_allfit(count,totallen)
-static inline int xfs_dir_sf_allfit(int count, int totallen)
-{
-        return ((uint)sizeof(xfs_dir_sf_hdr_t) + \
-               ((uint)sizeof(xfs_dir_sf_entry_t)-1)*(count) + (totallen));
-}
-#if defined(XFS_DIR_TRACE)
-/*
- * Kernel tracing support for directories.
- */
-struct uio;
-struct xfs_inode;
-struct xfs_da_intnode;
-struct xfs_dinode;
-struct xfs_dir_leafblock;
-struct xfs_dir_leaf_entry;
-#define XFS_DIR_TRACE_SIZE      4096    /* size of global trace buffer */
-extern ktrace_t *xfs_dir_trace_buf;
-/*
- * Trace record types.
- */
-#define XFS_DIR_KTRACE_G_DU     1       /* dp, uio */
-#define XFS_DIR_KTRACE_G_DUB    2       /* dp, uio, bno */
-#define XFS_DIR_KTRACE_G_DUN    3       /* dp, uio, node */
-#define XFS_DIR_KTRACE_G_DUL    4       /* dp, uio, leaf */
-#define XFS_DIR_KTRACE_G_DUE    5       /* dp, uio, leaf entry */
-#define XFS_DIR_KTRACE_G_DUC    6       /* dp, uio, cookie */
-void xfs_dir_trace_g_du(char *where, struct xfs_inode *dp, struct uio *uio);
-void xfs_dir_trace_g_dub(char *where, struct xfs_inode *dp, struct uio *uio,
-                              xfs_dablk_t bno);
-void xfs_dir_trace_g_dun(char *where, struct xfs_inode *dp, struct uio *uio,
-                              struct xfs_da_intnode *node);
-void xfs_dir_trace_g_dul(char *where, struct xfs_inode *dp, struct uio *uio,
-                              struct xfs_dir_leafblock *leaf);
-void xfs_dir_trace_g_due(char *where, struct xfs_inode *dp, struct uio *uio,
-                              struct xfs_dir_leaf_entry *entry);
-void xfs_dir_trace_g_duc(char *where, struct xfs_inode *dp, struct uio *uio,
-                              xfs_off_t cookie);
-void xfs_dir_trace_enter(int type, char *where,
-                             void *a0, void *a1, void *a2, void *a3,
-                             void *a4, void *a5, void *a6, void *a7,
-                             void *a8, void *a9, void *a10, void *a11);
-#else
-#define xfs_dir_trace_g_du(w,d,u)
-#define xfs_dir_trace_g_dub(w,d,u,b)
-#define xfs_dir_trace_g_dun(w,d,u,n)
-#define xfs_dir_trace_g_dul(w,d,u,l)
-#define xfs_dir_trace_g_due(w,d,u,e)
-#define xfs_dir_trace_g_duc(w,d,u,c)
-#endif /* DEBUG */
-#endif  /* __XFS_DIR_SF_H__ */
diff --git a/fs/xfs/xfs_dmapi.h b/fs/xfs/xfs_dmapi.h
index 00b1540f8108..4e7865ad6f0e 100644
--- a/fs/xfs/xfs_dmapi.h
+++ b/fs/xfs/xfs_dmapi.h
@@ -189,6 +189,6 @@ typedef enum {
 #define AT_DELAY_FLAG(f) ((f&ATTR_NONBLOCK) ? DM_FLAGS_NDELAY : 0)
-extern struct bhv_vfsops xfs_dmops;
+extern struct bhv_module_vfsops xfs_dmops;
 #endif  /* __XFS_DMAPI_H__ */
diff --git a/fs/xfs/xfs_dmops.c b/fs/xfs/xfs_dmops.c
index 629795b3b3d5..1e4a35ddf7f9 100644
--- a/fs/xfs/xfs_dmops.c
+++ b/fs/xfs/xfs_dmops.c
@@ -23,7 +23,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
diff --git a/fs/xfs/xfs_error.c b/fs/xfs/xfs_error.c
index 2a21c5024017..b95681b03d81 100644
--- a/fs/xfs/xfs_error.c
+++ b/fs/xfs/xfs_error.c
@@ -22,12 +22,10 @@
 #include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
diff --git a/fs/xfs/xfs_extfree_item.c b/fs/xfs/xfs_extfree_item.c
index f19282ec8549..6cf6d8769b97 100644
--- a/fs/xfs/xfs_extfree_item.c
+++ b/fs/xfs/xfs_extfree_item.c
@@ -23,7 +23,6 @@
 #include "xfs_trans.h"
 #include "xfs_buf_item.h"
 #include "xfs_sb.h"
-#include "xfs_dir.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_trans_priv.h"
@@ -294,6 +293,62 @@ xfs_efi_init(xfs_mount_t	*mp,
 }
 /*
+ * Copy an EFI format buffer from the given buf, and into the destination
+ * EFI format structure.
+ * The given buffer can be in 32 bit or 64 bit form (which has different padding),
+ * one of which will be the native format for this kernel.
+ * It will handle the conversion of formats if necessary.
+ */
+int
+xfs_efi_copy_format(xfs_log_iovec_t *buf, xfs_efi_log_format_t *dst_efi_fmt)
+{
+        xfs_efi_log_format_t *src_efi_fmt = (xfs_efi_log_format_t *)buf->i_addr;
+        uint i;
+        uint len = sizeof(xfs_efi_log_format_t) + 
+                (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_t);  
+        uint len32 = sizeof(xfs_efi_log_format_32_t) + 
+                (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_32_t);  
+        uint len64 = sizeof(xfs_efi_log_format_64_t) + 
+                (src_efi_fmt->efi_nextents - 1) * sizeof(xfs_extent_64_t);  
+        if (buf->i_len == len) {
+                memcpy((char *)dst_efi_fmt, (char*)src_efi_fmt, len);
+                return 0;
+        } else if (buf->i_len == len32) {
+                xfs_efi_log_format_32_t *src_efi_fmt_32 =
+                        (xfs_efi_log_format_32_t *)buf->i_addr;
+                dst_efi_fmt->efi_type     = src_efi_fmt_32->efi_type;
+                dst_efi_fmt->efi_size     = src_efi_fmt_32->efi_size;
+                dst_efi_fmt->efi_nextents = src_efi_fmt_32->efi_nextents;
+                dst_efi_fmt->efi_id       = src_efi_fmt_32->efi_id;
+                for (i = 0; i < dst_efi_fmt->efi_nextents; i++) {
+                        dst_efi_fmt->efi_extents[i].ext_start =
+                                src_efi_fmt_32->efi_extents[i].ext_start;
+                        dst_efi_fmt->efi_extents[i].ext_len =
+                                src_efi_fmt_32->efi_extents[i].ext_len;
+                }
+                return 0;
+        } else if (buf->i_len == len64) {
+                xfs_efi_log_format_64_t *src_efi_fmt_64 =
+                        (xfs_efi_log_format_64_t *)buf->i_addr;
+                dst_efi_fmt->efi_type     = src_efi_fmt_64->efi_type;
+                dst_efi_fmt->efi_size     = src_efi_fmt_64->efi_size;
+                dst_efi_fmt->efi_nextents = src_efi_fmt_64->efi_nextents;
+                dst_efi_fmt->efi_id       = src_efi_fmt_64->efi_id;
+                for (i = 0; i < dst_efi_fmt->efi_nextents; i++) {
+                        dst_efi_fmt->efi_extents[i].ext_start =
+                                src_efi_fmt_64->efi_extents[i].ext_start;
+                        dst_efi_fmt->efi_extents[i].ext_len =
+                                src_efi_fmt_64->efi_extents[i].ext_len;
+                }
+                return 0;
+        }
+        return EFSCORRUPTED;
+}
+/*
 * This is called by the efd item code below to release references to
 * the given efi item.  Each efd calls this with the number of
 * extents that it has logged, and when the sum of these reaches
diff --git a/fs/xfs/xfs_extfree_item.h b/fs/xfs/xfs_extfree_item.h
index 5bf681708fec..0ea45edaab03 100644
--- a/fs/xfs/xfs_extfree_item.h
+++ b/fs/xfs/xfs_extfree_item.h
@@ -27,6 +27,24 @@ typedef struct xfs_extent {
 } xfs_extent_t;
 /*
+ * Since an xfs_extent_t has types (start:64, len: 32)
+ * there are different alignments on 32 bit and 64 bit kernels.
+ * So we provide the different variants for use by a
+ * conversion routine.
+ */
+typedef struct xfs_extent_32 {
+        xfs_dfsbno_t    ext_start;
+        xfs_extlen_t    ext_len;
+} __attribute__((packed)) xfs_extent_32_t;
+typedef struct xfs_extent_64 {
+        xfs_dfsbno_t    ext_start;
+        xfs_extlen_t    ext_len;
+        __uint32_t      ext_pad;
+} xfs_extent_64_t;
+/*
 * This is the structure used to lay out an efi log item in the
 * log.  The efi_extents field is a variable size array whose
 * size is given by efi_nextents.
@@ -39,6 +57,22 @@ typedef struct xfs_efi_log_format {
        xfs_extent_t            efi_extents[1]; /* array of extents to free */
 } xfs_efi_log_format_t;
+typedef struct xfs_efi_log_format_32 {
+        unsigned short          efi_type;       /* efi log item type */
+        unsigned short          efi_size;       /* size of this item */
+        uint                    efi_nextents;   /* # extents to free */
+        __uint64_t              efi_id;         /* efi identifier */
+        xfs_extent_32_t         efi_extents[1]; /* array of extents to free */
+} __attribute__((packed)) xfs_efi_log_format_32_t;
+typedef struct xfs_efi_log_format_64 {
+        unsigned short          efi_type;       /* efi log item type */
+        unsigned short          efi_size;       /* size of this item */
+        uint                    efi_nextents;   /* # extents to free */
+        __uint64_t              efi_id;         /* efi identifier */
+        xfs_extent_64_t         efi_extents[1]; /* array of extents to free */
+} xfs_efi_log_format_64_t;
 /*
 * This is the structure used to lay out an efd log item in the
 * log.  The efd_extents array is a variable size array whose
@@ -52,6 +86,22 @@ typedef struct xfs_efd_log_format {
        xfs_extent_t            efd_extents[1]; /* array of extents freed */
 } xfs_efd_log_format_t;
+typedef struct xfs_efd_log_format_32 {
+        unsigned short          efd_type;       /* efd log item type */
+        unsigned short          efd_size;       /* size of this item */
+        uint                    efd_nextents;   /* # of extents freed */
+        __uint64_t              efd_efi_id;     /* id of corresponding efi */
+        xfs_extent_32_t         efd_extents[1]; /* array of extents freed */
+} __attribute__((packed)) xfs_efd_log_format_32_t;
+typedef struct xfs_efd_log_format_64 {
+        unsigned short          efd_type;       /* efd log item type */
+        unsigned short          efd_size;       /* size of this item */
+        uint                    efd_nextents;   /* # of extents freed */
+        __uint64_t              efd_efi_id;     /* id of corresponding efi */
+        xfs_extent_64_t         efd_extents[1]; /* array of extents freed */
+} xfs_efd_log_format_64_t;
 #ifdef __KERNEL__
@@ -103,7 +153,8 @@ extern struct kmem_zone	*xfs_efd_zone;
 xfs_efi_log_item_t      *xfs_efi_init(struct xfs_mount *, uint);
 xfs_efd_log_item_t      *xfs_efd_init(struct xfs_mount *, xfs_efi_log_item_t *,
                                      uint);
+int                     xfs_efi_copy_format(xfs_log_iovec_t *buf,
+                                            xfs_efi_log_format_t *dst_efi_fmt);
 void                    xfs_efi_item_free(xfs_efi_log_item_t *);
 #endif  /* __KERNEL__ */
diff --git a/fs/xfs/xfs_fs.h b/fs/xfs/xfs_fs.h
index 14010f1fa82f..0f0ad1535951 100644
--- a/fs/xfs/xfs_fs.h
+++ b/fs/xfs/xfs_fs.h
@@ -67,14 +67,15 @@ struct fsxattr {
 #define XFS_XFLAG_NOSYMLINKS    0x00000400      /* disallow symlink creation */
 #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_HASATTR       0x80000000      /* no DIFLAG for this   */
 /*
 * Structure for XFS_IOC_GETBMAP.
 * On input, fill in bmv_offset and bmv_length of the first structure
- * to indicate the area of interest in the file, and bmv_entry with the
+ * to indicate the area of interest in the file, and bmv_entries with
- * number of array elements given.  The first structure is updated on
+ * the number of array elements given back.  The first structure is
- * return to give the offset and length for the next call.
+ * updated on return to give the offset and length for the next call.
 */
 #ifndef HAVE_GETBMAP
 struct getbmap {
diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index dfa3527b20a7..077629bab532 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -24,14 +24,12 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -542,14 +540,13 @@ xfs_reserve_blocks(
 }
 void
-xfs_fs_log_dummy(xfs_mount_t *mp)
+xfs_fs_log_dummy(
+        xfs_mount_t     *mp)
 {
-        xfs_trans_t *tp;
+        xfs_trans_t     *tp;
-        xfs_inode_t *ip;
+        xfs_inode_t     *ip;
        tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1);
-        atomic_inc(&mp->m_active_trans);
        if (xfs_trans_reserve(tp, 0, XFS_ICHANGE_LOG_RES(mp), 0, 0, 0)) {
                xfs_trans_cancel(tp, 0);
                return;
@@ -574,21 +571,22 @@ xfs_fs_goingdown(
 {
        switch (inflags) {
        case XFS_FSOP_GOING_FLAGS_DEFAULT: {
-                struct vfs *vfsp = XFS_MTOVFS(mp);
+                struct bhv_vfs *vfsp = XFS_MTOVFS(mp);
                struct super_block *sb = freeze_bdev(vfsp->vfs_super->s_bdev);
                if (sb && !IS_ERR(sb)) {
-                        xfs_force_shutdown(mp, XFS_FORCE_UMOUNT);
+                        xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
                        thaw_bdev(sb->s_bdev, sb);
                }
        
                break;
        }
        case XFS_FSOP_GOING_FLAGS_LOGFLUSH:
-                xfs_force_shutdown(mp, XFS_FORCE_UMOUNT);
+                xfs_force_shutdown(mp, SHUTDOWN_FORCE_UMOUNT);
                break;
        case XFS_FSOP_GOING_FLAGS_NOLOGFLUSH:
-                xfs_force_shutdown(mp, XFS_FORCE_UMOUNT|XFS_LOG_IO_ERROR);
+                xfs_force_shutdown(mp,
+                                SHUTDOWN_FORCE_UMOUNT | SHUTDOWN_LOG_IO_ERROR);
                break;
        default:
                return XFS_ERROR(EINVAL);
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c
index deddbd03c166..33164a85aa9d 100644
--- a/fs/xfs/xfs_ialloc.c
+++ b/fs/xfs/xfs_ialloc.c
@@ -24,14 +24,12 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -1174,6 +1172,9 @@ xfs_dilocate(
        if (agno >= mp->m_sb.sb_agcount || agbno >= mp->m_sb.sb_agblocks ||
            ino != XFS_AGINO_TO_INO(mp, agno, agino)) {
 #ifdef DEBUG
+                /* no diagnostics for bulkstat, ino comes from userspace */
+                if (flags & XFS_IMAP_BULKSTAT)
+                        return XFS_ERROR(EINVAL);
                if (agno >= mp->m_sb.sb_agcount) {
                        xfs_fs_cmn_err(CE_ALERT, mp,
                                        "xfs_dilocate: agno (%d) >= "
diff --git a/fs/xfs/xfs_ialloc_btree.c b/fs/xfs/xfs_ialloc_btree.c
index 60c65683462d..616eeeb6953e 100644
--- a/fs/xfs/xfs_ialloc_btree.c
+++ b/fs/xfs/xfs_ialloc_btree.c
@@ -24,14 +24,12 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
diff --git a/fs/xfs/xfs_iget.c b/fs/xfs/xfs_iget.c
index b53854325266..0724df7fabb7 100644
--- a/fs/xfs/xfs_iget.c
+++ b/fs/xfs/xfs_iget.c
@@ -24,14 +24,12 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -186,7 +184,7 @@ xfs_ihash_promote(
 */
 STATIC int
 xfs_iget_core(
-        vnode_t         *vp,
+        bhv_vnode_t     *vp,
        xfs_mount_t     *mp,
        xfs_trans_t     *tp,
        xfs_ino_t       ino,
@@ -198,7 +196,7 @@ xfs_iget_core(
        xfs_ihash_t     *ih;
        xfs_inode_t     *ip;
        xfs_inode_t     *iq;
-        vnode_t         *inode_vp;
+        bhv_vnode_t     *inode_vp;
        ulong           version;
        int             error;
        /* REFERENCED */
@@ -468,7 +466,7 @@ finish_inode:
         * If we have a real type for an on-disk inode, we can set ops(&unlock)
         * now.  If it's a new inode being created, xfs_ialloc will handle it.
         */
-        VFS_INIT_VNODE(XFS_MTOVFS(mp), vp, XFS_ITOBHV(ip), 1);
+        bhv_vfs_init_vnode(XFS_MTOVFS(mp), vp, XFS_ITOBHV(ip), 1);
        return 0;
 }
@@ -489,7 +487,7 @@ xfs_iget(
        xfs_daddr_t     bno)
 {
        struct inode    *inode;
-        vnode_t         *vp = NULL;
+        bhv_vnode_t     *vp = NULL;
        int             error;
        XFS_STATS_INC(xs_ig_attempts);
@@ -543,7 +541,7 @@ retry:
 void
 xfs_inode_lock_init(
        xfs_inode_t     *ip,
-        vnode_t         *vp)
+        bhv_vnode_t     *vp)
 {
        mrlock_init(&ip->i_lock, MRLOCK_ALLOW_EQUAL_PRI|MRLOCK_BARRIER,
                     "xfsino", (long)vp->v_number);
@@ -603,12 +601,10 @@ void
 xfs_iput(xfs_inode_t    *ip,
         uint           lock_flags)
 {
-        vnode_t *vp = XFS_ITOV(ip);
+        bhv_vnode_t     *vp = XFS_ITOV(ip);
        vn_trace_entry(vp, "xfs_iput", (inst_t *)__return_address);
        xfs_iunlock(ip, lock_flags);
        VN_RELE(vp);
 }
@@ -619,7 +615,7 @@ void
 xfs_iput_new(xfs_inode_t        *ip,
             uint               lock_flags)
 {
-        vnode_t         *vp = XFS_ITOV(ip);
+        bhv_vnode_t     *vp = XFS_ITOV(ip);
        struct inode    *inode = vn_to_inode(vp);
        vn_trace_entry(vp, "xfs_iput_new", (inst_t *)__return_address);
@@ -645,7 +641,7 @@ xfs_iput_new(xfs_inode_t	*ip,
 void
 xfs_ireclaim(xfs_inode_t *ip)
 {
-        vnode_t         *vp;
+        bhv_vnode_t     *vp;
        /*
         * Remove from old hash list and mount list.
@@ -1033,6 +1029,6 @@ xfs_iflock_nowait(xfs_inode_t *ip)
 void
 xfs_ifunlock(xfs_inode_t *ip)
 {
-        ASSERT(valusema(&(ip->i_flock)) <= 0);
+        ASSERT(issemalocked(&(ip->i_flock)));
        vsema(&(ip->i_flock));
 }
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 94b60dd03801..5fa0adb7e173 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
@@ -26,14 +26,12 @@
 #include "xfs_trans_priv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -256,13 +254,11 @@ xfs_itobp(
        xfs_daddr_t     bno,
        uint            imap_flags)
 {
+        xfs_imap_t      imap;
        xfs_buf_t       *bp;
        int             error;
-        xfs_imap_t      imap;
-#ifdef __KERNEL__
        int             i;
        int             ni;
-#endif
        if (ip->i_blkno == (xfs_daddr_t)0) {
                /*
@@ -319,7 +315,6 @@ xfs_itobp(
         */
        error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp, imap.im_blkno,
                                   (int)imap.im_len, XFS_BUF_LOCK, &bp);
        if (error) {
 #ifdef DEBUG
                xfs_fs_cmn_err(CE_ALERT, mp, "xfs_itobp: "
@@ -330,17 +325,21 @@ xfs_itobp(
 #endif /* DEBUG */
                return error;
        }
-#ifdef __KERNEL__
        /*
         * Validate the magic number and version of every inode in the buffer
         * (if DEBUG kernel) or the first inode in the buffer, otherwise.
+         * No validation is done here in userspace (xfs_repair).
         */
-#ifdef DEBUG
+#if !defined(__KERNEL__)
+        ni = 0;
+#elif defined(DEBUG)
        ni = (imap_flags & XFS_IMAP_BULKSTAT) ? 0 :
                (BBTOB(imap.im_len) >> mp->m_sb.sb_inodelog);
-#else
+#else   /* usual case */
        ni = (imap_flags & XFS_IMAP_BULKSTAT) ? 0 : 1;
 #endif
        for (i = 0; i < ni; i++) {
                int             di_ok;
                xfs_dinode_t    *dip;
@@ -352,8 +351,11 @@ xfs_itobp(
                if (unlikely(XFS_TEST_ERROR(!di_ok, mp, XFS_ERRTAG_ITOBP_INOTOBP,
                                 XFS_RANDOM_ITOBP_INOTOBP))) {
 #ifdef DEBUG
-                        prdev("bad inode magic/vsn daddr %lld #%d (magic=%x)",
+                        if (!(imap_flags & XFS_IMAP_BULKSTAT))
-                                mp->m_ddev_targp,
+                                cmn_err(CE_ALERT,
+                                        "Device %s - bad inode magic/vsn "
+                                        "daddr %lld #%d (magic=%x)",
+                                XFS_BUFTARG_NAME(mp->m_ddev_targp),
                                (unsigned long long)imap.im_blkno, i,
                                INT_GET(dip->di_core.di_magic, ARCH_CONVERT));
 #endif
@@ -363,7 +365,6 @@ xfs_itobp(
                        return XFS_ERROR(EFSCORRUPTED);
                }
        }
-#endif  /* __KERNEL__ */
        xfs_inobp_check(mp, bp);
@@ -782,7 +783,6 @@ xfs_xlate_dinode_core(
 STATIC uint
 _xfs_dic2xflags(
-        xfs_dinode_core_t       *dic,
        __uint16_t              di_flags)
 {
        uint                    flags = 0;
@@ -812,6 +812,8 @@ _xfs_dic2xflags(
                        flags |= XFS_XFLAG_EXTSIZE;
                if (di_flags & XFS_DIFLAG_EXTSZINHERIT)
                        flags |= XFS_XFLAG_EXTSZINHERIT;
+                if (di_flags & XFS_DIFLAG_NODEFRAG)
+                        flags |= XFS_XFLAG_NODEFRAG;
        }
        return flags;
@@ -823,16 +825,16 @@ xfs_ip2xflags(
 {
        xfs_dinode_core_t       *dic = &ip->i_d;
-        return _xfs_dic2xflags(dic, dic->di_flags) |
+        return _xfs_dic2xflags(dic->di_flags) |
-                (XFS_CFORK_Q(dic) ? XFS_XFLAG_HASATTR : 0);
+                                (XFS_CFORK_Q(dic) ? XFS_XFLAG_HASATTR : 0);
 }
 uint
 xfs_dic2xflags(
        xfs_dinode_core_t       *dic)
 {
-        return _xfs_dic2xflags(dic, INT_GET(dic->di_flags, ARCH_CONVERT)) |
+        return _xfs_dic2xflags(INT_GET(dic->di_flags, ARCH_CONVERT)) |
-                (XFS_CFORK_Q_DISK(dic) ? XFS_XFLAG_HASATTR : 0);
+                                (XFS_CFORK_Q_DISK(dic) ? XFS_XFLAG_HASATTR : 0);
 }
 /*
@@ -1083,7 +1085,7 @@ xfs_ialloc(
 {
        xfs_ino_t       ino;
        xfs_inode_t     *ip;
-        vnode_t         *vp;
+        bhv_vnode_t     *vp;
        uint            flags;
        int             error;
@@ -1221,6 +1223,9 @@ xfs_ialloc(
                                di_flags |= XFS_DIFLAG_NOSYMLINKS;
                        if (pip->i_d.di_flags & XFS_DIFLAG_PROJINHERIT)
                                di_flags |= XFS_DIFLAG_PROJINHERIT;
+                        if ((pip->i_d.di_flags & XFS_DIFLAG_NODEFRAG) &&
+                            xfs_inherit_nodefrag)
+                                di_flags |= XFS_DIFLAG_NODEFRAG;
                        ip->i_d.di_flags |= di_flags;
                }
                /* FALLTHROUGH */
@@ -1244,8 +1249,8 @@ xfs_ialloc(
         */
        xfs_trans_log_inode(tp, ip, flags);
-        /* now that we have an i_mode  we can set Linux inode ops (& unlock) */
+        /* now that we have an i_mode we can setup inode ops and unlock */
-        VFS_INIT_VNODE(XFS_MTOVFS(tp->t_mountp), vp, XFS_ITOBHV(ip), 1);
+        bhv_vfs_init_vnode(XFS_MTOVFS(tp->t_mountp), vp, XFS_ITOBHV(ip), 1);
        *ipp = ip;
        return 0;
@@ -1285,7 +1290,7 @@ xfs_isize_check(
                                       (xfs_ufsize_t)XFS_MAXIOFFSET(mp)) -
                          map_first),
                         XFS_BMAPI_ENTIRE, NULL, 0, imaps, &nimaps,
-                         NULL))
+                         NULL, NULL))
            return;
        ASSERT(nimaps == 1);
        ASSERT(imaps[0].br_startblock == HOLESTARTBLOCK);
@@ -1421,7 +1426,7 @@ xfs_itruncate_start(
        xfs_fsize_t     last_byte;
        xfs_off_t       toss_start;
        xfs_mount_t     *mp;
-        vnode_t         *vp;
+        bhv_vnode_t     *vp;
        ASSERT(ismrlocked(&ip->i_iolock, MR_UPDATE) != 0);
        ASSERT((new_size == 0) || (new_size <= ip->i_d.di_size));
@@ -1434,9 +1439,9 @@ xfs_itruncate_start(
        vn_iowait(vp);  /* wait for the completion of any pending DIOs */
        
        /*
-         * Call VOP_TOSS_PAGES() or VOP_FLUSHINVAL_PAGES() to get rid of pages and buffers
+         * Call toss_pages or flushinval_pages to get rid of pages
         * overlapping the region being removed.  We have to use
-         * the less efficient VOP_FLUSHINVAL_PAGES() in the case that the
+         * the less efficient flushinval_pages in the case that the
         * caller may not be able to finish the truncate without
         * dropping the inode's I/O lock.  Make sure
         * to catch any pages brought in by buffers overlapping
@@ -1445,10 +1450,10 @@ xfs_itruncate_start(
         * so that we don't toss things on the same block as
         * new_size but before it.
         *
-         * Before calling VOP_TOSS_PAGES() or VOP_FLUSHINVAL_PAGES(), make sure to
+         * Before calling toss_page or flushinval_pages, make sure to
         * call remapf() over the same region if the file is mapped.
         * This frees up mapped file references to the pages in the
-         * given range and for the VOP_FLUSHINVAL_PAGES() case it ensures
+         * given range and for the flushinval_pages case it ensures
         * that we get the latest mapped changes flushed out.
         */
        toss_start = XFS_B_TO_FSB(mp, (xfs_ufsize_t)new_size);
@@ -1466,9 +1471,9 @@ xfs_itruncate_start(
                         last_byte);
        if (last_byte > toss_start) {
                if (flags & XFS_ITRUNC_DEFINITE) {
-                        VOP_TOSS_PAGES(vp, toss_start, -1, FI_REMAPF_LOCKED);
+                        bhv_vop_toss_pages(vp, toss_start, -1, FI_REMAPF_LOCKED);
                } else {
-                        VOP_FLUSHINVAL_PAGES(vp, toss_start, -1, FI_REMAPF_LOCKED);
+                        bhv_vop_flushinval_pages(vp, toss_start, -1, FI_REMAPF_LOCKED);
                }
        }
@@ -1666,12 +1671,13 @@ xfs_itruncate_finish(
                 * runs.
                 */
                XFS_BMAP_INIT(&free_list, &first_block);
-                error = xfs_bunmapi(ntp, ip, first_unmap_block,
+                error = XFS_BUNMAPI(mp, ntp, &ip->i_iocore,
-                                    unmap_len,
+                                    first_unmap_block, unmap_len,
                                    XFS_BMAPI_AFLAG(fork) |
                                      (sync ? 0 : XFS_BMAPI_ASYNC),
                                    XFS_ITRUNC_MAX_EXTENTS,
-                                    &first_block, &free_list, &done);
+                                    &first_block, &free_list,
+                                    NULL, &done);
                if (error) {
                        /*
                         * If the bunmapi call encounters an error,
@@ -2745,13 +2751,14 @@ xfs_iunpin(
                 * the inode to become unpinned.
                 */
                if (!(ip->i_flags & (XFS_IRECLAIM|XFS_IRECLAIMABLE))) {
-                        vnode_t *vp = XFS_ITOV_NULL(ip);
+                        bhv_vnode_t     *vp = XFS_ITOV_NULL(ip);
                        /* make sync come back and flush this inode */
                        if (vp) {
                                struct inode    *inode = vn_to_inode(vp);
-                                if (!(inode->i_state & I_NEW))
+                                if (!(inode->i_state &
+                                                (I_NEW|I_FREEING|I_CLEAR)))
                                        mark_inode_dirty_sync(inode);
                        }
                }
@@ -2916,13 +2923,6 @@ xfs_iflush_fork(
                        ASSERT(ifp->if_bytes <= XFS_IFORK_SIZE(ip, whichfork));
                        memcpy(cp, ifp->if_u1.if_data, ifp->if_bytes);
                }
-                if (whichfork == XFS_DATA_FORK) {
-                        if (unlikely(XFS_DIR_SHORTFORM_VALIDATE_ONDISK(mp, dip))) {
-                                XFS_ERROR_REPORT("xfs_iflush_fork",
-                                                 XFS_ERRLEVEL_LOW, mp);
-                                return XFS_ERROR(EFSCORRUPTED);
-                        }
-                }
                break;
        case XFS_DINODE_FMT_EXTENTS:
@@ -3006,7 +3006,7 @@ xfs_iflush(
        XFS_STATS_INC(xs_iflush_count);
        ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE|MR_ACCESS));
-        ASSERT(valusema(&ip->i_flock) <= 0);
+        ASSERT(issemalocked(&(ip->i_flock)));
        ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
               ip->i_d.di_nextents > ip->i_df.if_ext_max);
@@ -3199,7 +3199,7 @@ xfs_iflush(
 corrupt_out:
        xfs_buf_relse(bp);
-        xfs_force_shutdown(mp, XFS_CORRUPT_INCORE);
+        xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
        xfs_iflush_abort(ip);
        /*
         * Unlocks the flush lock
@@ -3221,7 +3221,7 @@ cluster_corrupt_out:
                xfs_buf_relse(bp);
        }
-        xfs_force_shutdown(mp, XFS_CORRUPT_INCORE);
+        xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
        if(!bufwasdelwri)  {
                /*
@@ -3264,7 +3264,7 @@ xfs_iflush_int(
        SPLDECL(s);
        ASSERT(ismrlocked(&ip->i_lock, MR_UPDATE|MR_ACCESS));
-        ASSERT(valusema(&ip->i_flock) <= 0);
+        ASSERT(issemalocked(&(ip->i_flock)));
        ASSERT(ip->i_d.di_format != XFS_DINODE_FMT_BTREE ||
               ip->i_d.di_nextents > ip->i_df.if_ext_max);
@@ -3504,7 +3504,7 @@ xfs_iflush_all(
        xfs_mount_t     *mp)
 {
        xfs_inode_t     *ip;
-        vnode_t         *vp;
+        bhv_vnode_t     *vp;
 again:
        XFS_MOUNT_ILOCK(mp);
@@ -4180,7 +4180,7 @@ xfs_iext_direct_to_inline(
         */
        memcpy(ifp->if_u2.if_inline_ext, ifp->if_u1.if_extents,
                nextents * sizeof(xfs_bmbt_rec_t));
-        kmem_free(ifp->if_u1.if_extents, KM_SLEEP);
+        kmem_free(ifp->if_u1.if_extents, ifp->if_real_bytes);
        ifp->if_u1.if_extents = ifp->if_u2.if_inline_ext;
        ifp->if_real_bytes = 0;
 }
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index 3b544db1790b..d10b76ed1e5b 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -102,9 +102,9 @@ typedef struct xfs_ifork {
 #ifdef __KERNEL__
 struct bhv_desc;
+struct bhv_vnode;
 struct cred;
 struct ktrace;
-struct vnode;
 struct xfs_buf;
 struct xfs_bmap_free;
 struct xfs_bmbt_irec;
@@ -400,7 +400,7 @@ void		xfs_chash_init(struct xfs_mount *);
 void            xfs_chash_free(struct xfs_mount *);
 xfs_inode_t     *xfs_inode_incore(struct xfs_mount *, xfs_ino_t,
                                  struct xfs_trans *);
-void            xfs_inode_lock_init(xfs_inode_t *, struct vnode *);
+void            xfs_inode_lock_init(xfs_inode_t *, struct bhv_vnode *);
 int             xfs_iget(struct xfs_mount *, struct xfs_trans *, xfs_ino_t,
                         uint, uint, xfs_inode_t **, xfs_daddr_t);
 void            xfs_iput(xfs_inode_t *, uint);
@@ -461,7 +461,7 @@ void		xfs_ichgtime(xfs_inode_t *, int);
 xfs_fsize_t     xfs_file_last_byte(xfs_inode_t *);
 void            xfs_lock_inodes(xfs_inode_t **, int, int, uint);
-xfs_inode_t     *xfs_vtoi(struct vnode *vp);
+xfs_inode_t     *xfs_vtoi(struct bhv_vnode *vp);
 void            xfs_synchronize_atime(xfs_inode_t *);
@@ -509,7 +509,6 @@ extern struct kmem_zone	*xfs_chashlist_zone;
 extern struct kmem_zone *xfs_ifork_zone;
 extern struct kmem_zone *xfs_inode_zone;
 extern struct kmem_zone *xfs_ili_zone;
-extern struct vnodeops  xfs_vnodeops;
 #endif  /* __KERNEL__ */
diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c
index 7497a481b2f5..f8e80d8e7237 100644
--- a/fs/xfs/xfs_inode_item.c
+++ b/fs/xfs/xfs_inode_item.c
@@ -25,7 +25,6 @@
 #include "xfs_buf_item.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
@@ -33,7 +32,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -794,7 +792,7 @@ xfs_inode_item_pushbuf(
         * inode flush completed and the inode was taken off the AIL.
         * So, just get out.
         */
-        if ((valusema(&(ip->i_flock)) > 0)  ||
+        if (!issemalocked(&(ip->i_flock)) ||
            ((iip->ili_item.li_flags & XFS_LI_IN_AIL) == 0)) {
                iip->ili_pushbuf_flag = 0;
                xfs_iunlock(ip, XFS_ILOCK_SHARED);
@@ -816,7 +814,7 @@ xfs_inode_item_pushbuf(
                         * If not, we can flush it async.
                         */
                        dopush = ((iip->ili_item.li_flags & XFS_LI_IN_AIL) &&
-                                  (valusema(&(ip->i_flock)) <= 0));
+                                  issemalocked(&(ip->i_flock)));
                        iip->ili_pushbuf_flag = 0;
                        xfs_iunlock(ip, XFS_ILOCK_SHARED);
                        xfs_buftrace("INODE ITEM PUSH", bp);
@@ -864,7 +862,7 @@ xfs_inode_item_push(
        ip = iip->ili_inode;
        ASSERT(ismrlocked(&(ip->i_lock), MR_ACCESS));
-        ASSERT(valusema(&(ip->i_flock)) <= 0);
+        ASSERT(issemalocked(&(ip->i_flock)));
        /*
         * Since we were able to lock the inode's flush lock and
         * we found it on the AIL, the inode must be dirty.  This
@@ -1084,3 +1082,52 @@ xfs_istale_done(
 {
        xfs_iflush_abort(iip->ili_inode);
 }
+/*
+ * convert an xfs_inode_log_format struct from either 32 or 64 bit versions
+ * (which can have different field alignments) to the native version
+ */
+int
+xfs_inode_item_format_convert(
+        xfs_log_iovec_t         *buf,
+        xfs_inode_log_format_t  *in_f)
+{
+        if (buf->i_len == sizeof(xfs_inode_log_format_32_t)) {
+                xfs_inode_log_format_32_t *in_f32;
+                in_f32 = (xfs_inode_log_format_32_t *)buf->i_addr;
+                in_f->ilf_type = in_f32->ilf_type;
+                in_f->ilf_size = in_f32->ilf_size;
+                in_f->ilf_fields = in_f32->ilf_fields;
+                in_f->ilf_asize = in_f32->ilf_asize;
+                in_f->ilf_dsize = in_f32->ilf_dsize;
+                in_f->ilf_ino = in_f32->ilf_ino;
+                /* copy biggest field of ilf_u */
+                memcpy(in_f->ilf_u.ilfu_uuid.__u_bits,
+                       in_f32->ilf_u.ilfu_uuid.__u_bits,
+                       sizeof(uuid_t));
+                in_f->ilf_blkno = in_f32->ilf_blkno;
+                in_f->ilf_len = in_f32->ilf_len;
+                in_f->ilf_boffset = in_f32->ilf_boffset;
+                return 0;
+        } else if (buf->i_len == sizeof(xfs_inode_log_format_64_t)){
+                xfs_inode_log_format_64_t *in_f64;
+                in_f64 = (xfs_inode_log_format_64_t *)buf->i_addr;
+                in_f->ilf_type = in_f64->ilf_type;
+                in_f->ilf_size = in_f64->ilf_size;
+                in_f->ilf_fields = in_f64->ilf_fields;
+                in_f->ilf_asize = in_f64->ilf_asize;
+                in_f->ilf_dsize = in_f64->ilf_dsize;
+                in_f->ilf_ino = in_f64->ilf_ino;
+                /* copy biggest field of ilf_u */
+                memcpy(in_f->ilf_u.ilfu_uuid.__u_bits,
+                       in_f64->ilf_u.ilfu_uuid.__u_bits,
+                       sizeof(uuid_t));
+                in_f->ilf_blkno = in_f64->ilf_blkno;
+                in_f->ilf_len = in_f64->ilf_len;
+                in_f->ilf_boffset = in_f64->ilf_boffset;
+                return 0;
+        }
+        return EFSCORRUPTED;
+}
diff --git a/fs/xfs/xfs_inode_item.h b/fs/xfs/xfs_inode_item.h
index c5dbf93b6661..5db6cd1b4cf3 100644
--- a/fs/xfs/xfs_inode_item.h
+++ b/fs/xfs/xfs_inode_item.h
@@ -23,25 +23,6 @@
 * log.  The size of the inline data/extents/b-tree root to be logged
 * (if any) is indicated in the ilf_dsize field.  Changes to this structure
 * must be added on to the end.
- *
- * Convention for naming inode log item versions :  The current version
- * is always named XFS_LI_INODE.  When an inode log item gets superseded,
- * add the latest version of IRIX that will generate logs with that item
- * to the version name.
- *
- * -Version 1 of this structure (XFS_LI_5_3_INODE) included up to the first
- *      union (ilf_u) field.  This was released with IRIX 5.3-XFS.
- * -Version 2 of this structure (XFS_LI_6_1_INODE) is currently the entire
- *      structure.  This was released with IRIX 6.0.1-XFS and IRIX 6.1.
- * -Version 3 of this structure (XFS_LI_INODE) is the same as version 2
- *      so a new structure definition wasn't necessary.  However, we had
- *      to add a new type because the inode cluster size changed from 4K
- *      to 8K and the version number had to be rev'ved to keep older kernels
- *      from trying to recover logs with the 8K buffers in them.  The logging
- *      code can handle recovery on different-sized clusters now so hopefully
- *      this'll be the last time we need to change the inode log item just
- *      for a change in the inode cluster size.  This new version was
- *      released with IRIX 6.2.
 */
 typedef struct xfs_inode_log_format {
        unsigned short          ilf_type;       /* inode log item type */
@@ -59,18 +40,38 @@ typedef struct xfs_inode_log_format {
        int                     ilf_boffset;    /* off of inode in buffer */
 } xfs_inode_log_format_t;
-/* Initial version shipped with IRIX 5.3-XFS */
+typedef struct xfs_inode_log_format_32 {
-typedef struct xfs_inode_log_format_v1 {
+        unsigned short          ilf_type;       /* 16: inode log item type */
-        unsigned short          ilf_type;       /* inode log item type */
+        unsigned short          ilf_size;       /* 16: size of this item */
-        unsigned short          ilf_size;       /* size of this item */
+        uint                    ilf_fields;     /* 32: flags for fields logged */
-        uint                    ilf_fields;     /* flags for fields logged */
+        ushort                  ilf_asize;      /* 32: size of attr d/ext/root */
-        uint                    ilf_dsize;      /* size of data/ext/root */
+        ushort                  ilf_dsize;      /* 32: size of data/ext/root */
-        xfs_ino_t               ilf_ino;        /* inode number */
+        xfs_ino_t               ilf_ino;        /* 64: inode number */
        union {
-                xfs_dev_t       ilfu_rdev;      /* rdev value for dev inode*/
+                xfs_dev_t       ilfu_rdev;      /* 32: rdev value for dev inode*/
-                uuid_t          ilfu_uuid;      /* mount point value */
+                uuid_t          ilfu_uuid;      /* 128: mount point value */
+        } ilf_u;
+        __int64_t               ilf_blkno;      /* 64: blkno of inode buffer */
+        int                     ilf_len;        /* 32: len of inode buffer */
+        int                     ilf_boffset;    /* 32: off of inode in buffer */
+} __attribute__((packed)) xfs_inode_log_format_32_t;
+typedef struct xfs_inode_log_format_64 {
+        unsigned short          ilf_type;       /* 16: inode log item type */
+        unsigned short          ilf_size;       /* 16: size of this item */
+        uint                    ilf_fields;     /* 32: flags for fields logged */
+        ushort                  ilf_asize;      /* 32: size of attr d/ext/root */
+        ushort                  ilf_dsize;      /* 32: size of data/ext/root */
+        __uint32_t              ilf_pad;        /* 32: pad for 64 bit boundary */
+        xfs_ino_t               ilf_ino;        /* 64: inode number */
+        union {
+                xfs_dev_t       ilfu_rdev;      /* 32: rdev value for dev inode*/
+                uuid_t          ilfu_uuid;      /* 128: mount point value */
        } ilf_u;
-} xfs_inode_log_format_t_v1;
+        __int64_t               ilf_blkno;      /* 64: blkno of inode buffer */
+        int                     ilf_len;        /* 32: len of inode buffer */
+        int                     ilf_boffset;    /* 32: off of inode in buffer */
+} xfs_inode_log_format_64_t;
 /*
 * Flags for xfs_trans_log_inode flags field.
@@ -172,6 +173,8 @@ extern void xfs_inode_item_destroy(struct xfs_inode *);
 extern void xfs_iflush_done(struct xfs_buf *, xfs_inode_log_item_t *);
 extern void xfs_istale_done(struct xfs_buf *, xfs_inode_log_item_t *);
 extern void xfs_iflush_abort(struct xfs_inode *);
+extern int xfs_inode_item_format_convert(xfs_log_iovec_t *,
+                                         xfs_inode_log_format_t *);
 #endif  /* __KERNEL__ */
diff --git a/fs/xfs/xfs_iocore.c b/fs/xfs/xfs_iocore.c
index a07815661a8c..06d710c9ce4b 100644
--- a/fs/xfs/xfs_iocore.c
+++ b/fs/xfs/xfs_iocore.c
@@ -24,14 +24,13 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
+#include "xfs_dfrag.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -58,7 +57,7 @@ xfs_size_fn(
 STATIC int
 xfs_ioinit(
-        struct vfs              *vfsp,
+        struct bhv_vfs          *vfsp,
        struct xfs_mount_args   *mntargs,
        int                     flags)
 {
@@ -68,6 +67,7 @@ xfs_ioinit(
 xfs_ioops_t     xfs_iocore_xfs = {
        .xfs_ioinit             = (xfs_ioinit_t) xfs_ioinit,
        .xfs_bmapi_func         = (xfs_bmapi_t) xfs_bmapi,
+        .xfs_bunmapi_func       = (xfs_bunmapi_t) xfs_bunmapi,
        .xfs_bmap_eof_func      = (xfs_bmap_eof_t) xfs_bmap_eof,
        .xfs_iomap_write_direct =
                        (xfs_iomap_write_direct_t) xfs_iomap_write_direct,
@@ -84,6 +84,7 @@ xfs_ioops_t	xfs_iocore_xfs = {
        .xfs_unlock             = (xfs_unlk_t) xfs_iunlock,
        .xfs_size_func          = (xfs_size_t) xfs_size_fn,
        .xfs_iodone             = (xfs_iodone_t) fs_noerr,
+        .xfs_swap_extents_func  = (xfs_swap_extents_t) xfs_swap_extents,
 };
 void
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index d5dfedcb8922..f1949c16df15 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2005 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
@@ -23,7 +23,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_alloc.h"
 #include "xfs_dmapi.h"
@@ -32,7 +31,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -252,7 +250,7 @@ xfs_iomap(
        error = XFS_BMAPI(mp, NULL, io, offset_fsb,
                        (xfs_filblks_t)(end_fsb - offset_fsb),
                        bmapi_flags,  NULL, 0, &imap,
-                        &nimaps, NULL);
+                        &nimaps, NULL, NULL);
        if (error)
                goto out;
@@ -519,8 +517,8 @@ xfs_iomap_write_direct(
         */
        XFS_BMAP_INIT(&free_list, &firstfsb);
        nimaps = 1;
-        error = xfs_bmapi(tp, ip, offset_fsb, count_fsb,
+        error = XFS_BMAPI(mp, tp, io, offset_fsb, count_fsb, bmapi_flag,
-                bmapi_flag, &firstfsb, 0, &imap, &nimaps, &free_list);
+                &firstfsb, 0, &imap, &nimaps, &free_list, NULL);
        if (error)
                goto error0;
@@ -610,8 +608,8 @@ xfs_iomap_eof_want_preallocate(
        while (count_fsb > 0) {
                imaps = nimaps;
                firstblock = NULLFSBLOCK;
-                error = XFS_BMAPI(mp, NULL, io, start_fsb, count_fsb,
+                error = XFS_BMAPI(mp, NULL, io, start_fsb, count_fsb, 0,
-                                  0, &firstblock, 0, imap, &imaps, NULL);
+                                  &firstblock, 0, imap, &imaps, NULL, NULL);
                if (error)
                        return error;
                for (n = 0; n < imaps; n++) {
@@ -695,11 +693,11 @@ retry:
        nimaps = XFS_WRITE_IMAPS;
        firstblock = NULLFSBLOCK;
-        error = xfs_bmapi(NULL, ip, offset_fsb,
+        error = XFS_BMAPI(mp, NULL, io, offset_fsb,
                          (xfs_filblks_t)(last_fsb - offset_fsb),
                          XFS_BMAPI_DELAY | XFS_BMAPI_WRITE |
                          XFS_BMAPI_ENTIRE, &firstblock, 1, imap,
-                          &nimaps, NULL);
+                          &nimaps, NULL, NULL);
        if (error && (error != ENOSPC))
                return XFS_ERROR(error);
@@ -832,9 +830,9 @@ xfs_iomap_write_allocate(
                        }
                        /* Go get the actual blocks */
-                        error = xfs_bmapi(tp, ip, map_start_fsb, count_fsb,
+                        error = XFS_BMAPI(mp, tp, io, map_start_fsb, count_fsb,
                                        XFS_BMAPI_WRITE, &first_block, 1,
-                                        imap, &nimaps, &free_list);
+                                        imap, &nimaps, &free_list, NULL);
                        if (error)
                                goto trans_cancel;
@@ -955,9 +953,9 @@ xfs_iomap_write_unwritten(
                 */
                XFS_BMAP_INIT(&free_list, &firstfsb);
                nimaps = 1;
-                error = xfs_bmapi(tp, ip, offset_fsb, count_fsb,
+                error = XFS_BMAPI(mp, tp, io, offset_fsb, count_fsb,
                                  XFS_BMAPI_WRITE|XFS_BMAPI_CONVERT, &firstfsb,
-                                  1, &imap, &nimaps, &free_list);
+                                  1, &imap, &nimaps, &free_list, NULL);
                if (error)
                        goto error_on_bmapi_transaction;
diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c
index 94068d014f27..46249e4d1fea 100644
--- a/fs/xfs/xfs_itable.c
+++ b/fs/xfs/xfs_itable.c
@@ -24,14 +24,12 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -41,11 +39,6 @@
 #include "xfs_error.h"
 #include "xfs_btree.h"
-#ifndef HAVE_USERACC
-#define useracc(ubuffer, size, flags, foo) (0)
-#define unuseracc(ubuffer, size, flags)
-#endif
 STATIC int
 xfs_bulkstat_one_iget(
        xfs_mount_t     *mp,            /* mount point for filesystem */
@@ -56,7 +49,7 @@ xfs_bulkstat_one_iget(
 {
        xfs_dinode_core_t *dic;         /* dinode core info pointer */
        xfs_inode_t     *ip;            /* incore inode pointer */
-        vnode_t         *vp;
+        bhv_vnode_t     *vp;
        int             error;
        error = xfs_iget(mp, NULL, ino, 0, XFS_ILOCK_SHARED, &ip, bno);
@@ -336,15 +329,6 @@ xfs_bulkstat(
        nimask = ~(nicluster - 1);
        nbcluster = nicluster >> mp->m_sb.sb_inopblog;
        /*
-         * Lock down the user's buffer. If a buffer was not sent, as in the case
-         * disk quota code calls here, we skip this.
-         */
-        if (ubuffer &&
-            (error = useracc(ubuffer, ubcount * statstruct_size,
-                        (B_READ|B_PHYS), NULL))) {
-                return error;
-        }
-        /*
         * Allocate a page-sized buffer for inode btree records.
         * We could try allocating something smaller, but for normal
         * calls we'll always (potentially) need the whole page.
@@ -650,8 +634,6 @@ xfs_bulkstat(
         * Done, we're either out of filesystem or space to put the data.
         */
        kmem_free(irbuf, NBPC);
-        if (ubuffer)
-                unuseracc(ubuffer, ubcount * statstruct_size, (B_READ|B_PHYS));
        *ubcountp = ubelem;
        if (agno >= mp->m_sb.sb_agcount) {
                /*
diff --git a/fs/xfs/xfs_itable.h b/fs/xfs/xfs_itable.h
index 11eb4e1b18c4..be5f12e07d22 100644
--- a/fs/xfs/xfs_itable.h
+++ b/fs/xfs/xfs_itable.h
@@ -45,7 +45,6 @@ typedef int (*bulkstat_one_pf)(struct xfs_mount	*mp,
 */
 #define BULKSTAT_FG_IGET        0x1     /* Go through the buffer cache */
 #define BULKSTAT_FG_QUICK       0x2     /* No iget, walk the dinode cluster */
-#define BULKSTAT_FG_VFSLOCKED   0x4     /* Already have vfs lock */
 /*
 * Return stat information in bulk (by-inode) for the filesystem.
diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index 32e841d2f26d..d8f5d4cbe8b7 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -24,7 +24,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
@@ -36,7 +35,6 @@
 #include "xfs_ialloc_btree.h"
 #include "xfs_log_recover.h"
 #include "xfs_trans_priv.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -402,7 +400,7 @@ xfs_log_release_iclog(xfs_mount_t *mp,
        xlog_in_core_t    *iclog = (xlog_in_core_t *)iclog_hndl;
        if (xlog_state_release_iclog(log, iclog)) {
-                xfs_force_shutdown(mp, XFS_LOG_IO_ERROR);
+                xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
                return EIO;
        }
@@ -498,9 +496,8 @@ xfs_log_mount(xfs_mount_t	*mp,
         * just worked.
         */
        if (!(mp->m_flags & XFS_MOUNT_NORECOVERY)) {
-                int     error;
+                bhv_vfs_t       *vfsp = XFS_MTOVFS(mp);
-                vfs_t   *vfsp = XFS_MTOVFS(mp);
+                int             error, readonly = (vfsp->vfs_flag & VFS_RDONLY);
-                int     readonly = (vfsp->vfs_flag & VFS_RDONLY);
                if (readonly)
                        vfsp->vfs_flag &= ~VFS_RDONLY;
@@ -726,7 +723,7 @@ xfs_log_write(xfs_mount_t *	mp,
                return XFS_ERROR(EIO);
        if ((error = xlog_write(mp, reg, nentries, tic, start_lsn, NULL, 0))) {
-                xfs_force_shutdown(mp, XFS_LOG_IO_ERROR);
+                xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
        }
        return error;
 }       /* xfs_log_write */
@@ -816,9 +813,9 @@ xfs_log_need_covered(xfs_mount_t *mp)
        SPLDECL(s);
        int             needed = 0, gen;
        xlog_t          *log = mp->m_log;
-        vfs_t           *vfsp = XFS_MTOVFS(mp);
+        bhv_vfs_t       *vfsp = XFS_MTOVFS(mp);
-        if (fs_frozen(vfsp) || XFS_FORCED_SHUTDOWN(mp) ||
+        if (vfs_test_for_freeze(vfsp) || XFS_FORCED_SHUTDOWN(mp) ||
            (vfsp->vfs_flag & VFS_RDONLY))
                return 0;
@@ -956,7 +953,7 @@ xlog_iodone(xfs_buf_t *bp)
                        XFS_ERRTAG_IODONE_IOERR, XFS_RANDOM_IODONE_IOERR)) {
                xfs_ioerror_alert("xlog_iodone", l->l_mp, bp, XFS_BUF_ADDR(bp));
                XFS_BUF_STALE(bp);
-                xfs_force_shutdown(l->l_mp, XFS_LOG_IO_ERROR);
+                xfs_force_shutdown(l->l_mp, SHUTDOWN_LOG_IO_ERROR);
                /*
                 * This flag will be propagated to the trans-committed
                 * callback routines to let them know that the log-commit
@@ -1261,7 +1258,7 @@ xlog_commit_record(xfs_mount_t  *mp,
        ASSERT_ALWAYS(iclog);
        if ((error = xlog_write(mp, reg, 1, ticket, commitlsnp,
                               iclog, XLOG_COMMIT_TRANS))) {
-                xfs_force_shutdown(mp, XFS_LOG_IO_ERROR);
+                xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
        }
        return error;
 }       /* xlog_commit_record */
@@ -1790,7 +1787,7 @@ xlog_write(xfs_mount_t *	mp,
        xfs_cmn_err(XFS_PTAG_LOGRES, CE_ALERT, mp,
                "xfs_log_write: reservation ran out. Need to up reservation");
        /* If we did not panic, shutdown the filesystem */
-        xfs_force_shutdown(mp, XFS_CORRUPT_INCORE);
+        xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
 #endif
    } else
        ticket->t_curr_res -= len;
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 1f0016b0b4ec..55b4237c2153 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
@@ -24,7 +24,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
@@ -32,7 +31,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -193,14 +191,14 @@ xlog_header_check_dump(
 {
        int                     b;
-        printk("%s:  SB : uuid = ", __FUNCTION__);
+        cmn_err(CE_DEBUG, "%s:  SB : uuid = ", __FUNCTION__);
        for (b = 0; b < 16; b++)
-                printk("%02x",((unsigned char *)&mp->m_sb.sb_uuid)[b]);
+                cmn_err(CE_DEBUG, "%02x", ((uchar_t *)&mp->m_sb.sb_uuid)[b]);
-        printk(", fmt = %d\n", XLOG_FMT);
+        cmn_err(CE_DEBUG, ", fmt = %d\n", XLOG_FMT);
-        printk("    log : uuid = ");
+        cmn_err(CE_DEBUG, "    log : uuid = ");
        for (b = 0; b < 16; b++)
-                printk("%02x",((unsigned char *)&head->h_fs_uuid)[b]);
+                cmn_err(CE_DEBUG, "%02x",((uchar_t *)&head->h_fs_uuid)[b]);
-        printk(", fmt = %d\n", INT_GET(head->h_fmt, ARCH_CONVERT));
+        cmn_err(CE_DEBUG, ", fmt = %d\n", INT_GET(head->h_fmt, ARCH_CONVERT));
 }
 #else
 #define xlog_header_check_dump(mp, head)
@@ -282,7 +280,7 @@ xlog_recover_iodone(
                mp = XFS_BUF_FSPRIVATE(bp, xfs_mount_t *);
                xfs_ioerror_alert("xlog_recover_iodone",
                                  mp, bp, XFS_BUF_ADDR(bp));
-                xfs_force_shutdown(mp, XFS_METADATA_IO_ERROR);
+                xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
        }
        XFS_BUF_SET_FSPRIVATE(bp, NULL);
        XFS_BUF_CLR_IODONE_FUNC(bp);
@@ -1889,7 +1887,7 @@ xlog_recover_do_inode_buffer(
                buffer_nextp = (xfs_agino_t *)xfs_buf_offset(bp,
                                              next_unlinked_offset);
-                INT_SET(*buffer_nextp, ARCH_CONVERT, *logged_nextp);
+                *buffer_nextp = *logged_nextp;
        }
        return 0;
@@ -2292,12 +2290,22 @@ xlog_recover_do_inode_trans(
        int                     attr_index;
        uint                    fields;
        xfs_dinode_core_t       *dicp;
+        int                     need_free = 0;
        if (pass == XLOG_RECOVER_PASS1) {
                return 0;
        }
-        in_f = (xfs_inode_log_format_t *)item->ri_buf[0].i_addr;
+        if (item->ri_buf[0].i_len == sizeof(xfs_inode_log_format_t)) {
+                in_f = (xfs_inode_log_format_t *)item->ri_buf[0].i_addr;
+        } else {
+                in_f = (xfs_inode_log_format_t *)kmem_alloc(
+                        sizeof(xfs_inode_log_format_t), KM_SLEEP);
+                need_free = 1;
+                error = xfs_inode_item_format_convert(&item->ri_buf[0], in_f);
+                if (error)
+                        goto error;
+        }
        ino = in_f->ilf_ino;
        mp = log->l_mp;
        if (ITEM_TYPE(item) == XFS_LI_INODE) {
@@ -2323,8 +2331,10 @@ xlog_recover_do_inode_trans(
         * Inode buffers can be freed, look out for it,
         * and do not replay the inode.
         */
-        if (xlog_check_buffer_cancelled(log, imap.im_blkno, imap.im_len, 0))
+        if (xlog_check_buffer_cancelled(log, imap.im_blkno, imap.im_len, 0)) {
-                return 0;
+                error = 0;
+                goto error;
+        }
        bp = xfs_buf_read_flags(mp->m_ddev_targp, imap.im_blkno, imap.im_len,
                                                                XFS_BUF_LOCK);
@@ -2333,7 +2343,7 @@ xlog_recover_do_inode_trans(
                                  bp, imap.im_blkno);
                error = XFS_BUF_GETERROR(bp);
                xfs_buf_relse(bp);
-                return error;
+                goto error;
        }
        error = 0;
        ASSERT(in_f->ilf_fields & XFS_ILOG_CORE);
@@ -2350,7 +2360,8 @@ xlog_recover_do_inode_trans(
                        dip, bp, ino);
                XFS_ERROR_REPORT("xlog_recover_do_inode_trans(1)",
                                 XFS_ERRLEVEL_LOW, mp);
-                return XFS_ERROR(EFSCORRUPTED);
+                error = EFSCORRUPTED;
+                goto error;
        }
        dicp = (xfs_dinode_core_t*)(item->ri_buf[1].i_addr);
        if (unlikely(dicp->di_magic != XFS_DINODE_MAGIC)) {
@@ -2360,7 +2371,8 @@ xlog_recover_do_inode_trans(
                        item, ino);
                XFS_ERROR_REPORT("xlog_recover_do_inode_trans(2)",
                                 XFS_ERRLEVEL_LOW, mp);
-                return XFS_ERROR(EFSCORRUPTED);
+                error = EFSCORRUPTED;
+                goto error;
        }
        /* Skip replay when the on disk inode is newer than the log one */
@@ -2376,7 +2388,8 @@ xlog_recover_do_inode_trans(
                        /* do nothing */
                } else {
                        xfs_buf_relse(bp);
-                        return 0;
+                        error = 0;
+                        goto error;
                }
        }
        /* Take the opportunity to reset the flush iteration count */
@@ -2391,7 +2404,8 @@ xlog_recover_do_inode_trans(
                        xfs_fs_cmn_err(CE_ALERT, mp,
                                "xfs_inode_recover: Bad regular inode log record, rec ptr 0x%p, ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
                                item, dip, bp, ino);
-                        return XFS_ERROR(EFSCORRUPTED);
+                        error = EFSCORRUPTED;
+                        goto error;
                }
        } else if (unlikely((dicp->di_mode & S_IFMT) == S_IFDIR)) {
                if ((dicp->di_format != XFS_DINODE_FMT_EXTENTS) &&
@@ -2403,7 +2417,8 @@ xlog_recover_do_inode_trans(
                        xfs_fs_cmn_err(CE_ALERT, mp,
                                "xfs_inode_recover: Bad dir inode log record, rec ptr 0x%p, ino ptr = 0x%p, ino bp = 0x%p, ino %Ld",
                                item, dip, bp, ino);
-                        return XFS_ERROR(EFSCORRUPTED);
+                        error = EFSCORRUPTED;
+                        goto error;
                }
        }
        if (unlikely(dicp->di_nextents + dicp->di_anextents > dicp->di_nblocks)){
@@ -2415,7 +2430,8 @@ xlog_recover_do_inode_trans(
                        item, dip, bp, ino,
                        dicp->di_nextents + dicp->di_anextents,
                        dicp->di_nblocks);
-                return XFS_ERROR(EFSCORRUPTED);
+                error = EFSCORRUPTED;
+                goto error;
        }
        if (unlikely(dicp->di_forkoff > mp->m_sb.sb_inodesize)) {
                XFS_CORRUPTION_ERROR("xlog_recover_do_inode_trans(6)",
@@ -2424,7 +2440,8 @@ xlog_recover_do_inode_trans(
                xfs_fs_cmn_err(CE_ALERT, mp,
                        "xfs_inode_recover: Bad inode log rec ptr 0x%p, dino ptr 0x%p, dino bp 0x%p, ino %Ld, forkoff 0x%x",
                        item, dip, bp, ino, dicp->di_forkoff);
-                return XFS_ERROR(EFSCORRUPTED);
+                error = EFSCORRUPTED;
+                goto error;
        }
        if (unlikely(item->ri_buf[1].i_len > sizeof(xfs_dinode_core_t))) {
                XFS_CORRUPTION_ERROR("xlog_recover_do_inode_trans(7)",
@@ -2433,7 +2450,8 @@ xlog_recover_do_inode_trans(
                xfs_fs_cmn_err(CE_ALERT, mp,
                        "xfs_inode_recover: Bad inode log record length %d, rec ptr 0x%p",
                        item->ri_buf[1].i_len, item);
-                return XFS_ERROR(EFSCORRUPTED);
+                error = EFSCORRUPTED;
+                goto error;
        }
        /* The core is in in-core format */
@@ -2521,7 +2539,8 @@ xlog_recover_do_inode_trans(
                        xlog_warn("XFS: xlog_recover_do_inode_trans: Invalid flag");
                        ASSERT(0);
                        xfs_buf_relse(bp);
-                        return XFS_ERROR(EIO);
+                        error = EIO;
+                        goto error;
                }
        }
@@ -2537,7 +2556,10 @@ write_inode_buffer:
                error = xfs_bwrite(mp, bp);
        }
-        return (error);
+error:
+        if (need_free)
+                kmem_free(in_f, sizeof(*in_f));
+        return XFS_ERROR(error);
 }
 /*
@@ -2674,32 +2696,32 @@ xlog_recover_do_dquot_trans(
 * structure into it, and adds the efi to the AIL with the given
 * LSN.
 */
-STATIC void
+STATIC int
 xlog_recover_do_efi_trans(
        xlog_t                  *log,
        xlog_recover_item_t     *item,
        xfs_lsn_t               lsn,
        int                     pass)
 {
+        int                     error;
        xfs_mount_t             *mp;
        xfs_efi_log_item_t      *efip;
        xfs_efi_log_format_t    *efi_formatp;
        SPLDECL(s);
        if (pass == XLOG_RECOVER_PASS1) {
-                return;
+                return 0;
        }
        efi_formatp = (xfs_efi_log_format_t *)item->ri_buf[0].i_addr;
-        ASSERT(item->ri_buf[0].i_len ==
-               (sizeof(xfs_efi_log_format_t) +
-                ((efi_formatp->efi_nextents - 1) * sizeof(xfs_extent_t))));
        mp = log->l_mp;
        efip = xfs_efi_init(mp, efi_formatp->efi_nextents);
-        memcpy((char *)&(efip->efi_format), (char *)efi_formatp,
+        if ((error = xfs_efi_copy_format(&(item->ri_buf[0]),
-              sizeof(xfs_efi_log_format_t) +
+                                         &(efip->efi_format)))) {
-              ((efi_formatp->efi_nextents - 1) * sizeof(xfs_extent_t)));
+                xfs_efi_item_free(efip);
+                return error;
+        }
        efip->efi_next_extent = efi_formatp->efi_nextents;
        efip->efi_flags |= XFS_EFI_COMMITTED;
@@ -2708,6 +2730,7 @@ xlog_recover_do_efi_trans(
         * xfs_trans_update_ail() drops the AIL lock.
         */
        xfs_trans_update_ail(mp, (xfs_log_item_t *)efip, lsn, s);
+        return 0;
 }
@@ -2738,9 +2761,10 @@ xlog_recover_do_efd_trans(
        }
        efd_formatp = (xfs_efd_log_format_t *)item->ri_buf[0].i_addr;
-        ASSERT(item->ri_buf[0].i_len ==
+        ASSERT((item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_32_t) +
-               (sizeof(xfs_efd_log_format_t) +
+                ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_32_t)))) ||
-                ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_t))));
+               (item->ri_buf[0].i_len == (sizeof(xfs_efd_log_format_64_t) +
+                ((efd_formatp->efd_nextents - 1) * sizeof(xfs_extent_64_t)))));
        efi_id = efd_formatp->efd_efi_id;
        /*
@@ -2810,15 +2834,14 @@ xlog_recover_do_trans(
                        if  ((error = xlog_recover_do_buffer_trans(log, item,
                                                                 pass)))
                                break;
-                } else if ((ITEM_TYPE(item) == XFS_LI_INODE) ||
+                } else if ((ITEM_TYPE(item) == XFS_LI_INODE)) {
-                           (ITEM_TYPE(item) == XFS_LI_6_1_INODE) ||
-                           (ITEM_TYPE(item) == XFS_LI_5_3_INODE)) {
                        if ((error = xlog_recover_do_inode_trans(log, item,
                                                                pass)))
                                break;
                } else if (ITEM_TYPE(item) == XFS_LI_EFI) {
-                        xlog_recover_do_efi_trans(log, item, trans->r_lsn,
+                        if ((error = xlog_recover_do_efi_trans(log, item, trans->r_lsn,
-                                                  pass);
+                                                  pass)))
+                                break;
                } else if (ITEM_TYPE(item) == XFS_LI_EFD) {
                        xlog_recover_do_efd_trans(log, item, pass);
                } else if (ITEM_TYPE(item) == XFS_LI_DQUOT) {
@@ -3419,13 +3442,13 @@ xlog_unpack_data_checksum(
            if (rhead->h_chksum ||
                ((log->l_flags & XLOG_CHKSUM_MISMATCH) == 0)) {
                    cmn_err(CE_DEBUG,
-                        "XFS: LogR chksum mismatch: was (0x%x) is (0x%x)",
+                        "XFS: LogR chksum mismatch: was (0x%x) is (0x%x)\n",
                            INT_GET(rhead->h_chksum, ARCH_CONVERT), chksum);
                    cmn_err(CE_DEBUG,
 "XFS: Disregard message if filesystem was created with non-DEBUG kernel");
                    if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
                            cmn_err(CE_DEBUG,
-                                "XFS: LogR this is a LogV2 filesystem");
+                                "XFS: LogR this is a LogV2 filesystem\n");
                    }
                    log->l_flags |= XLOG_CHKSUM_MISMATCH;
            }
@@ -3798,7 +3821,7 @@ xlog_do_log_recovery(
        error = xlog_do_recovery_pass(log, head_blk, tail_blk,
                                      XLOG_RECOVER_PASS2);
 #ifdef DEBUG
-        {
+        if (!error) {
                int     i;
                for (i = 0; i < XLOG_BC_TABLE_SIZE; i++)
@@ -3974,7 +3997,7 @@ xlog_recover_finish(
                log->l_flags &= ~XLOG_RECOVERY_NEEDED;
        } else {
                cmn_err(CE_DEBUG,
-                        "!Ending clean XFS mount for filesystem: %s",
+                        "!Ending clean XFS mount for filesystem: %s\n",
                        log->l_mp->m_fsname);
        }
        return 0;
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index c0b1c2906880..10dbf203c62f 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -24,14 +24,12 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -196,7 +194,7 @@ xfs_mount_free(
                kmem_free(mp->m_logname, strlen(mp->m_logname) + 1);
        if (remove_bhv) {
-                struct vfs      *vfsp = XFS_MTOVFS(mp);
+                struct bhv_vfs  *vfsp = XFS_MTOVFS(mp);
                bhv_remove_all_vfsops(vfsp, 0);
                VFS_REMOVEBHV(vfsp, &mp->m_bhv);
@@ -337,7 +335,7 @@ xfs_mount_validate_sb(
 xfs_agnumber_t
 xfs_initialize_perag(
-        struct vfs      *vfs,
+        bhv_vfs_t       *vfs,
        xfs_mount_t     *mp,
        xfs_agnumber_t  agcount)
 {
@@ -651,14 +649,14 @@ xfs_mount_common(xfs_mount_t *mp, xfs_sb_t *sbp)
 */
 int
 xfs_mountfs(
-        vfs_t           *vfsp,
+        bhv_vfs_t       *vfsp,
        xfs_mount_t     *mp,
        int             mfsi_flags)
 {
        xfs_buf_t       *bp;
        xfs_sb_t        *sbp = &(mp->m_sb);
        xfs_inode_t     *rip;
-        vnode_t         *rvp = NULL;
+        bhv_vnode_t     *rvp = NULL;
        int             readio_log, writeio_log;
        xfs_daddr_t     d;
        __uint64_t      ret64;
@@ -934,18 +932,7 @@ xfs_mountfs(
        vfsp->vfs_altfsid = (xfs_fsid_t *)mp->m_fixedfsid;
        mp->m_dmevmask = 0;     /* not persistent; set after each mount */
-        /*
+        xfs_dir_mount(mp);
-         * Select the right directory manager.
-         */
-        mp->m_dirops =
-                XFS_SB_VERSION_HASDIRV2(&mp->m_sb) ?
-                        xfsv2_dirops :
-                        xfsv1_dirops;
-        /*
-         * Initialize directory manager's entries.
-         */
-        XFS_DIR_MOUNT(mp);
        /*
         * Initialize the attribute manager's entries.
@@ -1006,8 +993,9 @@ xfs_mountfs(
        if (unlikely((rip->i_d.di_mode & S_IFMT) != S_IFDIR)) {
                cmn_err(CE_WARN, "XFS: corrupted root inode");
-                prdev("Root inode %llu is not a directory",
+                cmn_err(CE_WARN, "Device %s - root %llu is not a directory",
-                      mp->m_ddev_targp, (unsigned long long)rip->i_ino);
+                        XFS_BUFTARG_NAME(mp->m_ddev_targp),
+                        (unsigned long long)rip->i_ino);
                xfs_iunlock(rip, XFS_ILOCK_EXCL);
                XFS_ERROR_REPORT("xfs_mountfs_int(2)", XFS_ERRLEVEL_LOW,
                                 mp);
@@ -1094,7 +1082,7 @@ xfs_mountfs(
 int
 xfs_unmountfs(xfs_mount_t *mp, struct cred *cr)
 {
-        struct vfs      *vfsp = XFS_MTOVFS(mp);
+        struct bhv_vfs  *vfsp = XFS_MTOVFS(mp);
 #if defined(DEBUG) || defined(INDUCE_IO_ERROR)
        int64_t         fsid;
 #endif
@@ -1254,6 +1242,26 @@ xfs_mod_sb(xfs_trans_t *tp, __int64_t fields)
        xfs_trans_log_buf(tp, bp, first, last);
 }
+/*
+ * In order to avoid ENOSPC-related deadlock caused by
+ * out-of-order locking of AGF buffer (PV 947395), we place
+ * constraints on the relationship among actual allocations for
+ * data blocks, freelist blocks, and potential file data bmap
+ * btree blocks. However, these restrictions may result in no
+ * actual space allocated for a delayed extent, for example, a data
+ * block in a certain AG is allocated but there is no additional
+ * block for the additional bmap btree block due to a split of the
+ * bmap btree of the file. The result of this may lead to an
+ * infinite loop in xfssyncd when the file gets flushed to disk and
+ * all delayed extents need to be actually allocated. To get around
+ * this, we explicitly set aside a few blocks which will not be
+ * reserved in delayed allocation. Considering the minimum number of
+ * needed freelist blocks is 4 fsbs, a potential split of file's bmap
+ * btree requires 1 fsb, so we set the number of set-aside blocks to 8.
+*/
+#define SET_ASIDE_BLOCKS 8
 /*
 * xfs_mod_incore_sb_unlocked() is a utility routine common used to apply
 * a delta to a specified field in the in-core superblock.  Simply
@@ -1298,7 +1306,7 @@ xfs_mod_incore_sb_unlocked(xfs_mount_t *mp, xfs_sb_field_t field,
                return 0;
        case XFS_SBS_FDBLOCKS:
-                lcounter = (long long)mp->m_sb.sb_fdblocks;
+                lcounter = (long long)mp->m_sb.sb_fdblocks - SET_ASIDE_BLOCKS;
                res_used = (long long)(mp->m_resblks - mp->m_resblks_avail);
                if (delta > 0) {                /* Putting blocks back */
@@ -1332,7 +1340,7 @@ xfs_mod_incore_sb_unlocked(xfs_mount_t *mp, xfs_sb_field_t field,
                        }
                }
-                mp->m_sb.sb_fdblocks = lcounter;
+                mp->m_sb.sb_fdblocks = lcounter + SET_ASIDE_BLOCKS;
                return 0;
        case XFS_SBS_FREXTENTS:
                lcounter = (long long)mp->m_sb.sb_frextents;
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index 668ad23fd37c..b2bd4be4200a 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -53,8 +53,8 @@ typedef struct xfs_trans_reservations {
 #else
 struct cred;
 struct log;
-struct vfs;
+struct bhv_vfs;
-struct vnode;
+struct bhv_vnode;
 struct xfs_mount_args;
 struct xfs_ihash;
 struct xfs_chash;
@@ -63,9 +63,11 @@ struct xfs_perag;
 struct xfs_iocore;
 struct xfs_bmbt_irec;
 struct xfs_bmap_free;
+struct xfs_extdelta;
+struct xfs_swapext;
-extern struct vfsops xfs_vfsops;
+extern struct bhv_vfsops xfs_vfsops;
-extern struct vnodeops xfs_vnodeops;
+extern struct bhv_vnodeops xfs_vnodeops;
 #define AIL_LOCK_T              lock_t
 #define AIL_LOCKINIT(x,y)       spinlock_init(x,y)
@@ -78,15 +80,15 @@ extern struct vnodeops xfs_vnodeops;
 * Prototypes and functions for the Data Migration subsystem.
 */
-typedef int     (*xfs_send_data_t)(int, struct vnode *,
+typedef int     (*xfs_send_data_t)(int, struct bhv_vnode *,
-                        xfs_off_t, size_t, int, vrwlock_t *);
+                        xfs_off_t, size_t, int, bhv_vrwlock_t *);
 typedef int     (*xfs_send_mmap_t)(struct vm_area_struct *, uint);
-typedef int     (*xfs_send_destroy_t)(struct vnode *, dm_right_t);
+typedef int     (*xfs_send_destroy_t)(struct bhv_vnode *, dm_right_t);
-typedef int     (*xfs_send_namesp_t)(dm_eventtype_t, struct vfs *,
+typedef int     (*xfs_send_namesp_t)(dm_eventtype_t, struct bhv_vfs *,
-                        struct vnode *,
+                        struct bhv_vnode *,
-                        dm_right_t, struct vnode *, dm_right_t,
+                        dm_right_t, struct bhv_vnode *, dm_right_t,
                        char *, char *, mode_t, int, int);
-typedef void    (*xfs_send_unmount_t)(struct vfs *, struct vnode *,
+typedef void    (*xfs_send_unmount_t)(struct bhv_vfs *, struct bhv_vnode *,
                        dm_right_t, mode_t, int, int);
 typedef struct xfs_dmops {
@@ -188,13 +190,18 @@ typedef struct xfs_qmops {
 * Prototypes and functions for I/O core modularization.
 */
-typedef int             (*xfs_ioinit_t)(struct vfs *,
+typedef int             (*xfs_ioinit_t)(struct bhv_vfs *,
                                struct xfs_mount_args *, int);
 typedef int             (*xfs_bmapi_t)(struct xfs_trans *, void *,
                                xfs_fileoff_t, xfs_filblks_t, int,
                                xfs_fsblock_t *, xfs_extlen_t,
                                struct xfs_bmbt_irec *, int *,
-                                struct xfs_bmap_free *);
+                                struct xfs_bmap_free *, struct xfs_extdelta *);
+typedef int             (*xfs_bunmapi_t)(struct xfs_trans *,
+                                void *, xfs_fileoff_t,
+                                xfs_filblks_t, int, xfs_extnum_t,
+                                xfs_fsblock_t *, struct xfs_bmap_free *,
+                                struct xfs_extdelta *, int *);
 typedef int             (*xfs_bmap_eof_t)(void *, xfs_fileoff_t, int, int *);
 typedef int             (*xfs_iomap_write_direct_t)(
                                void *, xfs_off_t, size_t, int,
@@ -213,11 +220,14 @@ typedef void		(*xfs_lock_demote_t)(void *, uint);
 typedef int             (*xfs_lock_nowait_t)(void *, uint);
 typedef void            (*xfs_unlk_t)(void *, unsigned int);
 typedef xfs_fsize_t     (*xfs_size_t)(void *);
-typedef xfs_fsize_t     (*xfs_iodone_t)(struct vfs *);
+typedef xfs_fsize_t     (*xfs_iodone_t)(struct bhv_vfs *);
+typedef int             (*xfs_swap_extents_t)(void *, void *,
+                                struct xfs_swapext*);
 typedef struct xfs_ioops {
        xfs_ioinit_t                    xfs_ioinit;
        xfs_bmapi_t                     xfs_bmapi_func;
+        xfs_bunmapi_t                   xfs_bunmapi_func;
        xfs_bmap_eof_t                  xfs_bmap_eof_func;
        xfs_iomap_write_direct_t        xfs_iomap_write_direct;
        xfs_iomap_write_delay_t         xfs_iomap_write_delay;
@@ -230,13 +240,17 @@ typedef struct xfs_ioops {
        xfs_unlk_t                      xfs_unlock;
        xfs_size_t                      xfs_size_func;
        xfs_iodone_t                    xfs_iodone;
+        xfs_swap_extents_t              xfs_swap_extents_func;
 } xfs_ioops_t;
 #define XFS_IOINIT(vfsp, args, flags) \
        (*(mp)->m_io_ops.xfs_ioinit)(vfsp, args, flags)
-#define XFS_BMAPI(mp, trans,io,bno,len,f,first,tot,mval,nmap,flist)     \
+#define XFS_BMAPI(mp, trans,io,bno,len,f,first,tot,mval,nmap,flist,delta) \
        (*(mp)->m_io_ops.xfs_bmapi_func) \
-                (trans,(io)->io_obj,bno,len,f,first,tot,mval,nmap,flist)
+                (trans,(io)->io_obj,bno,len,f,first,tot,mval,nmap,flist,delta)
+#define XFS_BUNMAPI(mp, trans,io,bno,len,f,nexts,first,flist,delta,done) \
+        (*(mp)->m_io_ops.xfs_bunmapi_func) \
+                (trans,(io)->io_obj,bno,len,f,nexts,first,flist,delta,done)
 #define XFS_BMAP_EOF(mp, io, endoff, whichfork, eof) \
        (*(mp)->m_io_ops.xfs_bmap_eof_func) \
                ((io)->io_obj, endoff, whichfork, eof)
@@ -266,6 +280,9 @@ typedef struct xfs_ioops {
        (*(mp)->m_io_ops.xfs_size_func)((io)->io_obj)
 #define XFS_IODONE(vfsp) \
        (*(mp)->m_io_ops.xfs_iodone)(vfsp)
+#define XFS_SWAP_EXTENTS(mp, io, tio, sxp) \
+        (*(mp)->m_io_ops.xfs_swap_extents_func) \
+                ((io)->io_obj, (tio)->io_obj, sxp)
 #ifdef HAVE_PERCPU_SB
@@ -386,8 +403,6 @@ typedef struct xfs_mount {
        __uint8_t               m_inode_quiesce;/* call quiesce on new inodes.
                                                   field governed by m_ilock */
        __uint8_t               m_sectbb_log;   /* sectlog - BBSHIFT */
-        __uint8_t               m_dirversion;   /* 1 or 2 */
-        xfs_dirops_t            m_dirops;       /* table of dir funcs */
        int                     m_dirblksize;   /* directory block sz--bytes */
        int                     m_dirblkfsbs;   /* directory block sz--fsbs */
        xfs_dablk_t             m_dirdatablk;   /* blockno of dir data v2 */
@@ -494,16 +509,7 @@ xfs_preferred_iosize(xfs_mount_t *mp)
 #define XFS_FORCED_SHUTDOWN(mp) ((mp)->m_flags & XFS_MOUNT_FS_SHUTDOWN)
 #define xfs_force_shutdown(m,f) \
-        VFS_FORCE_SHUTDOWN((XFS_MTOVFS(m)), f, __FILE__, __LINE__)
+        bhv_vfs_force_shutdown((XFS_MTOVFS(m)), f, __FILE__, __LINE__)
-/*
- * Flags sent to xfs_force_shutdown.
- */
-#define XFS_METADATA_IO_ERROR   0x1
-#define XFS_LOG_IO_ERROR        0x2
-#define XFS_FORCE_UMOUNT        0x4
-#define XFS_CORRUPT_INCORE      0x8     /* Corrupt in-memory data structures */
-#define XFS_SHUTDOWN_REMOTE_REQ 0x10    /* Shutdown came from remote cell */
 /*
 * Flags for xfs_mountfs
@@ -521,7 +527,7 @@ xfs_preferred_iosize(xfs_mount_t *mp)
 * Macros for getting from mount to vfs and back.
 */
 #define XFS_MTOVFS(mp)          xfs_mtovfs(mp)
-static inline struct vfs *xfs_mtovfs(xfs_mount_t *mp)
+static inline struct bhv_vfs *xfs_mtovfs(xfs_mount_t *mp)
 {
        return bhvtovfs(&mp->m_bhv);
 }
@@ -533,7 +539,7 @@ static inline xfs_mount_t *xfs_bhvtom(bhv_desc_t *bdp)
 }
 #define XFS_VFSTOM(vfs) xfs_vfstom(vfs)
-static inline xfs_mount_t *xfs_vfstom(vfs_t *vfs)
+static inline xfs_mount_t *xfs_vfstom(bhv_vfs_t *vfs)
 {
        return XFS_BHVTOM(bhv_lookup(VFS_BHVHEAD(vfs), &xfs_vfsops));
 }
@@ -571,7 +577,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 void     xfs_mount_free(xfs_mount_t *mp, int remove_bhv);
-extern int      xfs_mountfs(struct vfs *, xfs_mount_t *mp, int);
+extern int      xfs_mountfs(struct bhv_vfs *, xfs_mount_t *mp, int);
 extern void     xfs_mountfs_check_barriers(xfs_mount_t *mp);
 extern int      xfs_unmountfs(xfs_mount_t *, struct cred *);
@@ -589,7 +595,7 @@ extern void	xfs_freesb(xfs_mount_t *);
 extern void     xfs_do_force_shutdown(bhv_desc_t *, int, char *, int);
 extern int      xfs_syncsub(xfs_mount_t *, int, int, int *);
 extern int      xfs_sync_inodes(xfs_mount_t *, int, int, int *);
-extern xfs_agnumber_t   xfs_initialize_perag(struct vfs *, xfs_mount_t *,
+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);
diff --git a/fs/xfs/xfs_qmops.c b/fs/xfs/xfs_qmops.c
index 1408a32eef88..320d63ff9ca2 100644
--- a/fs/xfs/xfs_qmops.c
+++ b/fs/xfs/xfs_qmops.c
@@ -23,7 +23,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
diff --git a/fs/xfs/xfs_quota.h b/fs/xfs/xfs_quota.h
index 7fbef974bce6..acb853b33ebb 100644
--- a/fs/xfs/xfs_quota.h
+++ b/fs/xfs/xfs_quota.h
@@ -365,7 +365,7 @@ typedef struct xfs_dqtrxops {
 extern int xfs_qm_dqcheck(xfs_disk_dquot_t *, xfs_dqid_t, uint, uint, char *);
 extern int xfs_mount_reset_sbqflags(struct xfs_mount *);
-extern struct bhv_vfsops xfs_qmops;
+extern struct bhv_module_vfsops xfs_qmops;
 #endif  /* __KERNEL__ */
diff --git a/fs/xfs/xfs_rename.c b/fs/xfs/xfs_rename.c
index 1f148762eb28..d98171deaa1c 100644
--- a/fs/xfs/xfs_rename.c
+++ b/fs/xfs/xfs_rename.c
@@ -22,13 +22,11 @@
 #include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_da_btree.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -40,7 +38,6 @@
 #include "xfs_refcache.h"
 #include "xfs_utils.h"
 #include "xfs_trans_space.h"
-#include "xfs_dir_leaf.h"
 /*
@@ -87,8 +84,8 @@ STATIC int
 xfs_lock_for_rename(
        xfs_inode_t     *dp1,   /* old (source) directory inode */
        xfs_inode_t     *dp2,   /* new (target) directory inode */
-        vname_t         *vname1,/* old entry name */
+        bhv_vname_t     *vname1,/* old entry name */
-        vname_t         *vname2,/* new entry name */
+        bhv_vname_t     *vname2,/* new entry name */
        xfs_inode_t     **ipp1, /* inode of old entry */
        xfs_inode_t     **ipp2, /* inode of new entry, if it
                                   already exists, NULL otherwise. */
@@ -225,9 +222,9 @@ xfs_lock_for_rename(
 int
 xfs_rename(
        bhv_desc_t      *src_dir_bdp,
-        vname_t         *src_vname,
+        bhv_vname_t     *src_vname,
-        vnode_t         *target_dir_vp,
+        bhv_vnode_t     *target_dir_vp,
-        vname_t         *target_vname,
+        bhv_vname_t     *target_vname,
        cred_t          *credp)
 {
        xfs_trans_t     *tp;
@@ -242,7 +239,7 @@ xfs_rename(
        int             committed;
        xfs_inode_t     *inodes[4];
        int             target_ip_dropped = 0;  /* dropped target_ip link? */
-        vnode_t         *src_dir_vp;
+        bhv_vnode_t     *src_dir_vp;
        int             spaceres;
        int             target_link_zero = 0;
        int             num_inodes;
@@ -398,34 +395,29 @@ xfs_rename(
                 * fit before actually inserting it.
                 */
                if (spaceres == 0 &&
-                    (error = XFS_DIR_CANENTER(mp, tp, target_dp, target_name,
+                    (error = xfs_dir_canenter(tp, target_dp, target_name,
-                                target_namelen))) {
+                                                target_namelen)))
                        goto error_return;
-                }
                /*
                 * If target does not exist and the rename crosses
                 * directories, adjust the target directory link count
                 * to account for the ".." reference from the new entry.
                 */
-                error = XFS_DIR_CREATENAME(mp, tp, target_dp, target_name,
+                error = xfs_dir_createname(tp, target_dp, target_name,
                                           target_namelen, src_ip->i_ino,
                                           &first_block, &free_list, spaceres);
-                if (error == ENOSPC) {
+                if (error == ENOSPC)
                        goto error_return;
-                }
+                if (error)
-                if (error) {
                        goto abort_return;
-                }
                xfs_ichgtime(target_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
                if (new_parent && src_is_directory) {
                        error = xfs_bumplink(tp, target_dp);
-                        if (error) {
+                        if (error)
                                goto abort_return;
-                        }
                }
        } else { /* target_ip != NULL */
                /*
                 * If target exists and it's a directory, check that both
                 * target and source are directories and that target can be
@@ -435,7 +427,7 @@ xfs_rename(
                        /*
                         * Make sure target dir is empty.
                         */
-                        if (!(XFS_DIR_ISEMPTY(target_ip->i_mount, target_ip)) ||
+                        if (!(xfs_dir_isempty(target_ip)) ||
                            (target_ip->i_d.di_nlink > 2)) {
                                error = XFS_ERROR(EEXIST);
                                goto error_return;
@@ -451,12 +443,11 @@ xfs_rename(
                 * In case there is already an entry with the same
                 * name at the destination directory, remove it first.
                 */
-                error = XFS_DIR_REPLACE(mp, tp, target_dp, target_name,
+                error = xfs_dir_replace(tp, target_dp, target_name,
-                        target_namelen, src_ip->i_ino, &first_block,
+                                        target_namelen, src_ip->i_ino,
-                        &free_list, spaceres);
+                                        &first_block, &free_list, spaceres);
-                if (error) {
+                if (error)
                        goto abort_return;
-                }
                xfs_ichgtime(target_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
                /*
@@ -464,9 +455,8 @@ xfs_rename(
                 * dir no longer points to it.
                 */
                error = xfs_droplink(tp, target_ip);
-                if (error) {
+                if (error)
                        goto abort_return;
-                }
                target_ip_dropped = 1;
                if (src_is_directory) {
@@ -474,9 +464,8 @@ xfs_rename(
                         * Drop the link from the old "." entry.
                         */
                        error = xfs_droplink(tp, target_ip);
-                        if (error) {
+                        if (error)
                                goto abort_return;
-                        }
                }
                /* Do this test while we still hold the locks */
@@ -488,18 +477,15 @@ xfs_rename(
         * Remove the source.
         */
        if (new_parent && src_is_directory) {
                /*
                 * Rewrite the ".." entry to point to the new
                 * directory.
                 */
-                error = XFS_DIR_REPLACE(mp, tp, src_ip, "..", 2,
+                error = xfs_dir_replace(tp, src_ip, "..", 2, target_dp->i_ino,
-                                        target_dp->i_ino, &first_block,
+                                        &first_block, &free_list, spaceres);
-                                        &free_list, spaceres);
                ASSERT(error != EEXIST);
-                if (error) {
+                if (error)
                        goto abort_return;
-                }
                xfs_ichgtime(src_ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
        } else {
@@ -527,16 +513,14 @@ xfs_rename(
                 * entry that's moved no longer points to it.
                 */
                error = xfs_droplink(tp, src_dp);
-                if (error) {
+                if (error)
                        goto abort_return;
-                }
        }
-        error = XFS_DIR_REMOVENAME(mp, tp, src_dp, src_name, src_namelen,
+        error = xfs_dir_removename(tp, src_dp, src_name, src_namelen,
                        src_ip->i_ino, &first_block, &free_list, spaceres);
-        if (error) {
+        if (error)
                goto abort_return;
-        }
        xfs_ichgtime(src_dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
        /*
@@ -609,7 +593,7 @@ xfs_rename(
         * Let interposed file systems know about removed links.
         */
        if (target_ip_dropped) {
-                VOP_LINK_REMOVED(XFS_ITOV(target_ip), target_dir_vp,
+                bhv_vop_link_removed(XFS_ITOV(target_ip), target_dir_vp,
                                        target_link_zero);
                IRELE(target_ip);
        }
diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index 5b413946b1c5..0c1e42b037ef 100644
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -24,14 +24,12 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -141,7 +139,7 @@ xfs_growfs_rt_alloc(
                cancelflags |= XFS_TRANS_ABORT;
                error = xfs_bmapi(tp, ip, oblocks, nblocks - oblocks,
                        XFS_BMAPI_WRITE | XFS_BMAPI_METADATA, &firstblock,
-                        resblks, &map, &nmap, &flist);
+                        resblks, &map, &nmap, &flist, NULL);
                if (!error && nmap < 1)
                        error = XFS_ERROR(ENOSPC);
                if (error)
@@ -2404,10 +2402,10 @@ xfs_rtprint_range(
 {
        xfs_extlen_t    i;              /* block number in the extent */
-        printk("%Ld: ", (long long)start);
+        cmn_err(CE_DEBUG, "%Ld: ", (long long)start);
        for (i = 0; i < len; i++)
-                printk("%d", xfs_rtcheck_bit(mp, tp, start + i, 1));
+                cmn_err(CE_DEBUG, "%d", xfs_rtcheck_bit(mp, tp, start + i, 1));
-        printk("\n");
+        cmn_err(CE_DEBUG, "\n");
 }
 /*
@@ -2431,17 +2429,17 @@ xfs_rtprint_summary(
                        (void)xfs_rtget_summary(mp, tp, l, i, &sumbp, &sb, &c);
                        if (c) {
                                if (!p) {
-                                        printk("%Ld-%Ld:", 1LL << l,
+                                        cmn_err(CE_DEBUG, "%Ld-%Ld:", 1LL << l,
                                                XFS_RTMIN((1LL << l) +
                                                          ((1LL << l) - 1LL),
                                                         mp->m_sb.sb_rextents));
                                        p = 1;
                                }
-                                printk(" %Ld:%d", (long long)i, c);
+                                cmn_err(CE_DEBUG, " %Ld:%d", (long long)i, c);
                        }
                }
                if (p)
-                        printk("\n");
+                        cmn_err(CE_DEBUG, "\n");
        }
        if (sumbp)
                xfs_trans_brelse(tp, sumbp);
diff --git a/fs/xfs/xfs_rw.c b/fs/xfs/xfs_rw.c
index a59c102cf214..defb2febaaf5 100644
--- a/fs/xfs/xfs_rw.c
+++ b/fs/xfs/xfs_rw.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
@@ -24,14 +24,12 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -92,6 +90,90 @@ xfs_write_clear_setuid(
 }
 /*
+ * Handle logging requirements of various synchronous types of write.
+ */
+int
+xfs_write_sync_logforce(
+        xfs_mount_t     *mp,
+        xfs_inode_t     *ip)
+{
+        int             error = 0;
+        /*
+         * If we're treating this as O_DSYNC and we have not updated the
+         * size, force the log.
+         */
+        if (!(mp->m_flags & XFS_MOUNT_OSYNCISOSYNC) &&
+            !(ip->i_update_size)) {
+                xfs_inode_log_item_t    *iip = ip->i_itemp;
+                /*
+                 * If an allocation transaction occurred
+                 * without extending the size, then we have to force
+                 * the log up the proper point to ensure that the
+                 * allocation is permanent.  We can't count on
+                 * the fact that buffered writes lock out direct I/O
+                 * writes - the direct I/O write could have extended
+                 * the size nontransactionally, then finished before
+                 * we started.  xfs_write_file will think that the file
+                 * didn't grow but the update isn't safe unless the
+                 * size change is logged.
+                 *
+                 * Force the log if we've committed a transaction
+                 * against the inode or if someone else has and
+                 * the commit record hasn't gone to disk (e.g.
+                 * the inode is pinned).  This guarantees that
+                 * all changes affecting the inode are permanent
+                 * when we return.
+                 */
+                if (iip && iip->ili_last_lsn) {
+                        xfs_log_force(mp, iip->ili_last_lsn,
+                                        XFS_LOG_FORCE | XFS_LOG_SYNC);
+                } else if (xfs_ipincount(ip) > 0) {
+                        xfs_log_force(mp, (xfs_lsn_t)0,
+                                        XFS_LOG_FORCE | XFS_LOG_SYNC);
+                }
+        } else {
+                xfs_trans_t     *tp;
+                /*
+                 * O_SYNC or O_DSYNC _with_ a size update are handled
+                 * the same way.
+                 *
+                 * If the write was synchronous then we need to make
+                 * sure that the inode modification time is permanent.
+                 * We'll have updated the timestamp above, so here
+                 * we use a synchronous transaction to log the inode.
+                 * It's not fast, but it's necessary.
+                 *
+                 * If this a dsync write and the size got changed
+                 * non-transactionally, then we need to ensure that
+                 * the size change gets logged in a synchronous
+                 * transaction.
+                 */
+                tp = xfs_trans_alloc(mp, XFS_TRANS_WRITE_SYNC);
+                if ((error = xfs_trans_reserve(tp, 0,
+                                                XFS_SWRITE_LOG_RES(mp),
+                                                0, 0, 0))) {
+                        /* Transaction reserve failed */
+                        xfs_trans_cancel(tp, 0);
+                } else {
+                        /* Transaction reserve successful */
+                        xfs_ilock(ip, XFS_ILOCK_EXCL);
+                        xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
+                        xfs_trans_ihold(tp, ip);
+                        xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
+                        xfs_trans_set_sync(tp);
+                        error = xfs_trans_commit(tp, 0, NULL);
+                        xfs_iunlock(ip, XFS_ILOCK_EXCL);
+                }
+        }
+        return error;
+}
+/*
 * Force a shutdown of the filesystem instantly while keeping
 * the filesystem consistent. We don't do an unmount here; just shutdown
 * the shop, make sure that absolutely nothing persistent happens to
@@ -109,12 +191,12 @@ xfs_do_force_shutdown(
        xfs_mount_t     *mp;
        mp = XFS_BHVTOM(bdp);
-        logerror = flags & XFS_LOG_IO_ERROR;
+        logerror = flags & SHUTDOWN_LOG_IO_ERROR;
-        if (!(flags & XFS_FORCE_UMOUNT)) {
+        if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
-                cmn_err(CE_NOTE,
+                cmn_err(CE_NOTE, "xfs_force_shutdown(%s,0x%x) called from "
-                "xfs_force_shutdown(%s,0x%x) called from line %d of file %s.  Return address = 0x%p",
+                                 "line %d of file %s.  Return address = 0x%p",
-                        mp->m_fsname,flags,lnnum,fname,__return_address);
+                        mp->m_fsname, flags, lnnum, fname, __return_address);
        }
        /*
         * No need to duplicate efforts.
@@ -125,33 +207,37 @@ xfs_do_force_shutdown(
        /*
         * This flags XFS_MOUNT_FS_SHUTDOWN, makes sure that we don't
         * queue up anybody new on the log reservations, and wakes up
-         * everybody who's sleeping on log reservations and tells
+         * everybody who's sleeping on log reservations to tell them
-         * them the bad news.
+         * the bad news.
         */
        if (xfs_log_force_umount(mp, logerror))
                return;
-        if (flags & XFS_CORRUPT_INCORE) {
+        if (flags & SHUTDOWN_CORRUPT_INCORE) {
                xfs_cmn_err(XFS_PTAG_SHUTDOWN_CORRUPT, CE_ALERT, mp,
    "Corruption of in-memory data detected.  Shutting down filesystem: %s",
                        mp->m_fsname);
                if (XFS_ERRLEVEL_HIGH <= xfs_error_level) {
                        xfs_stack_trace();
                }
-        } else if (!(flags & XFS_FORCE_UMOUNT)) {
+        } else if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
                if (logerror) {
                        xfs_cmn_err(XFS_PTAG_SHUTDOWN_LOGERROR, CE_ALERT, mp,
-                        "Log I/O Error Detected.  Shutting down filesystem: %s",
+                "Log I/O Error Detected.  Shutting down filesystem: %s",
+                                mp->m_fsname);
+                } else if (flags & SHUTDOWN_DEVICE_REQ) {
+                        xfs_cmn_err(XFS_PTAG_SHUTDOWN_IOERROR, CE_ALERT, mp,
+                "All device paths lost.  Shutting down filesystem: %s",
                                mp->m_fsname);
-                } else if (!(flags & XFS_SHUTDOWN_REMOTE_REQ)) {
+                } else if (!(flags & SHUTDOWN_REMOTE_REQ)) {
                        xfs_cmn_err(XFS_PTAG_SHUTDOWN_IOERROR, CE_ALERT, mp,
-                                "I/O Error Detected.  Shutting down filesystem: %s",
+                "I/O Error Detected.  Shutting down filesystem: %s",
                                mp->m_fsname);
                }
        }
-        if (!(flags & XFS_FORCE_UMOUNT)) {
+        if (!(flags & SHUTDOWN_FORCE_UMOUNT)) {
-                cmn_err(CE_ALERT,
+                cmn_err(CE_ALERT, "Please umount the filesystem, "
-                "Please umount the filesystem, and rectify the problem(s)");
+                                  "and rectify the problem(s)");
        }
 }
@@ -335,7 +421,7 @@ xfs_bwrite(
                 * from bwrite and we could be tracing a buffer that has
                 * been reused.
                 */
-                xfs_force_shutdown(mp, XFS_METADATA_IO_ERROR);
+                xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
        }
        return (error);
 }
diff --git a/fs/xfs/xfs_rw.h b/fs/xfs/xfs_rw.h
index e63795644478..188b296ff50c 100644
--- a/fs/xfs/xfs_rw.h
+++ b/fs/xfs/xfs_rw.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2003,2005 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
@@ -75,6 +75,7 @@ xfs_fsb_to_db_io(struct xfs_iocore *io, xfs_fsblock_t fsb)
 * Prototypes for functions in xfs_rw.c.
 */
 extern int xfs_write_clear_setuid(struct xfs_inode *ip);
+extern int xfs_write_sync_logforce(struct xfs_mount *mp, struct xfs_inode *ip);
 extern int xfs_bwrite(struct xfs_mount *mp, struct xfs_buf *bp);
 extern int xfs_bioerror(struct xfs_buf *bp);
 extern int xfs_bioerror_relse(struct xfs_buf *bp);
@@ -87,9 +88,10 @@ extern void xfs_ioerror_alert(char *func, struct xfs_mount *mp,
 /*
 * Prototypes for functions in xfs_vnodeops.c.
 */
-extern int xfs_rwlock(bhv_desc_t *bdp, vrwlock_t write_lock);
+extern int xfs_rwlock(bhv_desc_t *bdp, bhv_vrwlock_t write_lock);
-extern void xfs_rwunlock(bhv_desc_t *bdp, vrwlock_t write_lock);
+extern void xfs_rwunlock(bhv_desc_t *bdp, bhv_vrwlock_t write_lock);
-extern int xfs_setattr(bhv_desc_t *bdp, vattr_t *vap, int flags, cred_t *credp);
+extern int xfs_setattr(bhv_desc_t *, bhv_vattr_t *vap, int flags,
+                       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);
 extern int xfs_set_dmattrs(bhv_desc_t *bdp, u_int evmask, u_int16_t state,
diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
index 8d056cef5d1f..ee2721e0de4d 100644
--- a/fs/xfs/xfs_trans.c
+++ b/fs/xfs/xfs_trans.c
@@ -24,7 +24,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
@@ -33,7 +32,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -236,11 +234,8 @@ xfs_trans_alloc(
        xfs_mount_t     *mp,
        uint            type)
 {
-        fs_check_frozen(XFS_MTOVFS(mp), SB_FREEZE_TRANS);
+        vfs_wait_for_freeze(XFS_MTOVFS(mp), SB_FREEZE_TRANS);
-        atomic_inc(&mp->m_active_trans);
+        return _xfs_trans_alloc(mp, type);
-        return (_xfs_trans_alloc(mp, type));
 }
 xfs_trans_t *
@@ -250,12 +245,9 @@ _xfs_trans_alloc(
 {
        xfs_trans_t     *tp;
-        ASSERT(xfs_trans_zone != NULL);
+        atomic_inc(&mp->m_active_trans);
-        tp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);
-        /*
+        tp = kmem_zone_zalloc(xfs_trans_zone, KM_SLEEP);
-         * Initialize the transaction structure.
-         */
        tp->t_magic = XFS_TRANS_MAGIC;
        tp->t_type = type;
        tp->t_mountp = mp;
@@ -263,8 +255,7 @@ _xfs_trans_alloc(
        tp->t_busy_free = XFS_LBC_NUM_SLOTS;
        XFS_LIC_INIT(&(tp->t_items));
        XFS_LBC_INIT(&(tp->t_busy));
+        return tp;
-        return (tp);
 }
 /*
@@ -303,7 +294,7 @@ xfs_trans_dup(
        tp->t_blk_res = tp->t_blk_res_used;
        ntp->t_rtx_res = tp->t_rtx_res - tp->t_rtx_res_used;
        tp->t_rtx_res = tp->t_rtx_res_used;
-        PFLAGS_DUP(&tp->t_pflags, &ntp->t_pflags);
+        ntp->t_pflags = tp->t_pflags;
        XFS_TRANS_DUP_DQINFO(tp->t_mountp, tp, ntp);
@@ -335,14 +326,11 @@ xfs_trans_reserve(
        uint            logcount)
 {
        int             log_flags;
-        int             error;
+        int             error = 0;
-        int     rsvd;
+        int             rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
-        error = 0;
-        rsvd = (tp->t_flags & XFS_TRANS_RESERVE) != 0;
        /* Mark this thread as being in a transaction */
-        PFLAGS_SET_FSTRANS(&tp->t_pflags);
+        current_set_flags_nested(&tp->t_pflags, PF_FSTRANS);
        /*
         * Attempt to reserve the needed disk blocks by decrementing
@@ -353,7 +341,7 @@ xfs_trans_reserve(
                error = xfs_mod_incore_sb(tp->t_mountp, XFS_SBS_FDBLOCKS,
                                          -blocks, rsvd);
                if (error != 0) {
-                        PFLAGS_RESTORE_FSTRANS(&tp->t_pflags);
+                        current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
                        return (XFS_ERROR(ENOSPC));
                }
                tp->t_blk_res += blocks;
@@ -426,9 +414,9 @@ undo_blocks:
                tp->t_blk_res = 0;
        }
-        PFLAGS_RESTORE_FSTRANS(&tp->t_pflags);
+        current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
-        return (error);
+        return error;
 }
@@ -819,7 +807,7 @@ shut_us_down:
                        if (commit_lsn == -1 && !shutdown)
                                shutdown = XFS_ERROR(EIO);
                }
-                PFLAGS_RESTORE_FSTRANS(&tp->t_pflags);
+                current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
                xfs_trans_free_items(tp, shutdown? XFS_TRANS_ABORT : 0);
                xfs_trans_free_busy(tp);
                xfs_trans_free(tp);
@@ -846,7 +834,7 @@ shut_us_down:
         */
        nvec = xfs_trans_count_vecs(tp);
        if (nvec == 0) {
-                xfs_force_shutdown(mp, XFS_LOG_IO_ERROR);
+                xfs_force_shutdown(mp, SHUTDOWN_LOG_IO_ERROR);
                goto shut_us_down;
        } else if (nvec <= XFS_TRANS_LOGVEC_COUNT) {
                log_vector = log_vector_fast;
@@ -884,7 +872,7 @@ shut_us_down:
         * had pinned, clean up, free trans structure, and return error.
         */
        if (error || commit_lsn == -1) {
-                PFLAGS_RESTORE_FSTRANS(&tp->t_pflags);
+                current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
                xfs_trans_uncommit(tp, flags|XFS_TRANS_ABORT);
                return XFS_ERROR(EIO);
        }
@@ -926,7 +914,7 @@ shut_us_down:
        /*
         * Mark this thread as no longer being in a transaction
         */
-        PFLAGS_RESTORE_FSTRANS(&tp->t_pflags);
+        current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
        /*
         * Once all the items of the transaction have been copied
@@ -1148,7 +1136,7 @@ xfs_trans_cancel(
         */
        if ((tp->t_flags & XFS_TRANS_DIRTY) && !XFS_FORCED_SHUTDOWN(mp)) {
                XFS_ERROR_REPORT("xfs_trans_cancel", XFS_ERRLEVEL_LOW, mp);
-                xfs_force_shutdown(mp, XFS_CORRUPT_INCORE);
+                xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
        }
 #ifdef DEBUG
        if (!(flags & XFS_TRANS_ABORT)) {
@@ -1182,7 +1170,7 @@ xfs_trans_cancel(
        }
        /* mark this thread as no longer being in a transaction */
-        PFLAGS_RESTORE_FSTRANS(&tp->t_pflags);
+        current_restore_flags_nested(&tp->t_pflags, PF_FSTRANS);
        xfs_trans_free_items(tp, flags);
        xfs_trans_free_busy(tp);
diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
index 100d9a4b38ee..cb65c3a603f5 100644
--- a/fs/xfs/xfs_trans.h
+++ b/fs/xfs/xfs_trans.h
@@ -805,12 +805,9 @@ typedef struct xfs_trans {
        ((mp)->m_sb.sb_inodesize + \
         (mp)->m_sb.sb_sectsize * 2 + \
         (mp)->m_dirblksize + \
-         (XFS_DIR_IS_V1(mp) ? 0 : \
+         XFS_FSB_TO_B(mp, (XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1)) + \
-            XFS_FSB_TO_B(mp, (XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1))) + \
         XFS_ALLOCFREE_LOG_RES(mp, 1) + \
-         (128 * (4 + \
+         (128 * (4 + (XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1) + \
-                 (XFS_DIR_IS_V1(mp) ? 0 : \
-                         XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1) + \
                 XFS_ALLOCFREE_LOG_COUNT(mp, 1))))
 #define XFS_ADDAFORK_LOG_RES(mp)        ((mp)->m_reservations.tr_addafork)
diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c
index 19ab24af1c1c..558c87ff0c41 100644
--- a/fs/xfs/xfs_trans_ail.c
+++ b/fs/xfs/xfs_trans_ail.c
@@ -22,7 +22,6 @@
 #include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
-#include "xfs_dir.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_trans_priv.h"
@@ -363,9 +362,10 @@ xfs_trans_delete_ail(
                        AIL_UNLOCK(mp, s);
                else {
                        xfs_cmn_err(XFS_PTAG_AILDELETE, CE_ALERT, mp,
-                                "xfs_trans_delete_ail: attempting to delete a log item that is not in the AIL");
+                "%s: attempting to delete a log item that is not in the AIL",
+                                        __FUNCTION__);
                        AIL_UNLOCK(mp, s);
-                        xfs_force_shutdown(mp, XFS_CORRUPT_INCORE);
+                        xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
                }
        }
 }
diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index c74c31ebc81c..60b6b898022b 100644
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -24,14 +24,12 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -320,7 +318,7 @@ xfs_trans_read_buf(
                        if (xfs_error_target == target) {
                                if (((xfs_req_num++) % xfs_error_mod) == 0) {
                                        xfs_buf_relse(bp);
-                                        printk("Returning error!\n");
+                                        cmn_err(CE_DEBUG, "Returning error!\n");
                                        return XFS_ERROR(EIO);
                                }
                        }
@@ -369,7 +367,7 @@ xfs_trans_read_buf(
                                 */
                                if (tp->t_flags & XFS_TRANS_DIRTY)
                                        xfs_force_shutdown(tp->t_mountp,
-                                                           XFS_METADATA_IO_ERROR);
+                                                        SHUTDOWN_META_IO_ERROR);
                                return error;
                        }
                }
@@ -414,7 +412,7 @@ xfs_trans_read_buf(
                xfs_ioerror_alert("xfs_trans_read_buf", mp,
                                  bp, blkno);
                if (tp->t_flags & XFS_TRANS_DIRTY)
-                        xfs_force_shutdown(tp->t_mountp, XFS_METADATA_IO_ERROR);
+                        xfs_force_shutdown(tp->t_mountp, SHUTDOWN_META_IO_ERROR);
                xfs_buf_relse(bp);
                return error;
        }
@@ -423,9 +421,9 @@ xfs_trans_read_buf(
                if (xfs_error_target == target) {
                        if (((xfs_req_num++) % xfs_error_mod) == 0) {
                                xfs_force_shutdown(tp->t_mountp,
-                                                   XFS_METADATA_IO_ERROR);
+                                                   SHUTDOWN_META_IO_ERROR);
                                xfs_buf_relse(bp);
-                                printk("Returning error in trans!\n");
+                                cmn_err(CE_DEBUG, "Returning trans error!\n");
                                return XFS_ERROR(EIO);
                        }
                }
diff --git a/fs/xfs/xfs_trans_extfree.c b/fs/xfs/xfs_trans_extfree.c
index 7d7d627f25df..b290270dd4a6 100644
--- a/fs/xfs/xfs_trans_extfree.c
+++ b/fs/xfs/xfs_trans_extfree.c
@@ -22,7 +22,6 @@
 #include "xfs_inum.h"
 #include "xfs_trans.h"
 #include "xfs_sb.h"
-#include "xfs_dir.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_trans_priv.h"
diff --git a/fs/xfs/xfs_trans_inode.c b/fs/xfs/xfs_trans_inode.c
index 7c5894d59f81..b8db1d5cde5a 100644
--- a/fs/xfs/xfs_trans_inode.c
+++ b/fs/xfs/xfs_trans_inode.c
@@ -24,14 +24,12 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
diff --git a/fs/xfs/xfs_trans_item.c b/fs/xfs/xfs_trans_item.c
index 1117d600d741..2912aac07c7b 100644
--- a/fs/xfs/xfs_trans_item.c
+++ b/fs/xfs/xfs_trans_item.c
@@ -493,7 +493,7 @@ xfs_trans_add_busy(xfs_trans_t *tp, xfs_agnumber_t ag, xfs_extlen_t idx)
                                break;
                        } else {
                                /* out-of-order vacancy */
-                                printk("OOO vacancy lbcp 0x%p\n", lbcp);
+                                cmn_err(CE_DEBUG, "OOO vacancy lbcp 0x%p\n", lbcp);
                                ASSERT(0);
                        }
                }
diff --git a/fs/xfs/xfs_trans_space.h b/fs/xfs/xfs_trans_space.h
index 7fe3792b18df..4ea2e5074bdd 100644
--- a/fs/xfs/xfs_trans_space.h
+++ b/fs/xfs/xfs_trans_space.h
@@ -30,8 +30,7 @@
          XFS_EXTENTADD_SPACE_RES(mp,w))
 #define XFS_DAENTER_1B(mp,w)    ((w) == XFS_DATA_FORK ? (mp)->m_dirblkfsbs : 1)
 #define XFS_DAENTER_DBS(mp,w)   \
-        (XFS_DA_NODE_MAXDEPTH + \
+        (XFS_DA_NODE_MAXDEPTH + (((w) == XFS_DATA_FORK) ? 2 : 0))
-         ((XFS_DIR_IS_V2(mp) && (w) == XFS_DATA_FORK) ? 2 : 0))
 #define XFS_DAENTER_BLOCKS(mp,w)        \
        (XFS_DAENTER_1B(mp,w) * XFS_DAENTER_DBS(mp,w))
 #define XFS_DAENTER_BMAP1B(mp,w)        \
@@ -41,10 +40,7 @@
 #define XFS_DAENTER_SPACE_RES(mp,w)     \
        (XFS_DAENTER_BLOCKS(mp,w) + XFS_DAENTER_BMAPS(mp,w))
 #define XFS_DAREMOVE_SPACE_RES(mp,w)    XFS_DAENTER_BMAPS(mp,w)
-#define XFS_DIRENTER_MAX_SPLIT(mp,nl)   \
+#define XFS_DIRENTER_MAX_SPLIT(mp,nl)   1
-        (((mp)->m_sb.sb_blocksize == 512 && \
-          XFS_DIR_IS_V1(mp) && \
-          (nl) >= XFS_DIR_LEAF_CAN_DOUBLE_SPLIT_LEN) ? 2 : 1)
 #define XFS_DIRENTER_SPACE_RES(mp,nl)   \
        (XFS_DAENTER_SPACE_RES(mp, XFS_DATA_FORK) * \
         XFS_DIRENTER_MAX_SPLIT(mp,nl))
@@ -57,8 +53,7 @@
 * Space reservation values for various transactions.
 */
 #define XFS_ADDAFORK_SPACE_RES(mp)      \
-        ((mp)->m_dirblkfsbs + \
+        ((mp)->m_dirblkfsbs + XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK))
-         (XFS_DIR_IS_V1(mp) ? 0 : XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK)))
 #define XFS_ATTRRM_SPACE_RES(mp)        \
        XFS_DAREMOVE_SPACE_RES(mp, XFS_ATTR_FORK)
 /* This macro is not used - see inline code in xfs_attr_set */
diff --git a/fs/xfs/xfs_utils.c b/fs/xfs/xfs_utils.c
index 34654ec6ae10..9014d7e44488 100644
--- a/fs/xfs/xfs_utils.c
+++ b/fs/xfs/xfs_utils.c
@@ -24,12 +24,10 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
 #include "xfs_bmap_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -51,10 +49,10 @@
 */
 int
 xfs_get_dir_entry(
-        vname_t         *dentry,
+        bhv_vname_t     *dentry,
        xfs_inode_t     **ipp)
 {
-        vnode_t         *vp;
+        bhv_vnode_t     *vp;
        vp = VNAME_TO_VNODE(dentry);
@@ -69,11 +67,11 @@ int
 xfs_dir_lookup_int(
        bhv_desc_t      *dir_bdp,
        uint            lock_mode,
-        vname_t         *dentry,
+        bhv_vname_t     *dentry,
        xfs_ino_t       *inum,
        xfs_inode_t     **ipp)
 {
-        vnode_t         *dir_vp;
+        bhv_vnode_t     *dir_vp;
        xfs_inode_t     *dp;
        int             error;
@@ -82,8 +80,7 @@ xfs_dir_lookup_int(
        dp = XFS_BHVTOI(dir_bdp);
-        error = XFS_DIR_LOOKUP(dp->i_mount, NULL, dp,
+        error = xfs_dir_lookup(NULL, dp, VNAME(dentry), VNAMELEN(dentry), inum);
-                                VNAME(dentry), VNAMELEN(dentry), inum);
        if (!error) {
                /*
                 * Unlock the directory. We do this because we can't
diff --git a/fs/xfs/xfs_utils.h b/fs/xfs/xfs_utils.h
index 472661a3b6d8..fe953e98afa7 100644
--- a/fs/xfs/xfs_utils.h
+++ b/fs/xfs/xfs_utils.h
@@ -23,9 +23,10 @@
 #define ITRACE(ip)      vn_trace_ref(XFS_ITOV(ip), __FILE__, __LINE__, \
                                (inst_t *)__return_address)
-extern int xfs_rename (bhv_desc_t *, vname_t *, vnode_t *, vname_t *, cred_t *);
+extern int xfs_rename (bhv_desc_t *, bhv_vname_t *, bhv_vnode_t *,
-extern int xfs_get_dir_entry (vname_t *, xfs_inode_t **);
+                        bhv_vname_t *, cred_t *);
-extern int xfs_dir_lookup_int (bhv_desc_t *, uint, vname_t *, xfs_ino_t *,
+extern int xfs_get_dir_entry (bhv_vname_t *, xfs_inode_t **);
+extern int xfs_dir_lookup_int (bhv_desc_t *, uint, bhv_vname_t *, xfs_ino_t *,
                                xfs_inode_t **);
 extern int xfs_truncate_file (xfs_mount_t *, xfs_inode_t *);
 extern int xfs_dir_ialloc (xfs_trans_t **, xfs_inode_t *, mode_t, xfs_nlink_t,
diff --git a/fs/xfs/xfs_vfsops.c b/fs/xfs/xfs_vfsops.c
index 36ea1b2094f2..6c96391f3f1a 100644
--- a/fs/xfs/xfs_vfsops.c
+++ b/fs/xfs/xfs_vfsops.c
@@ -24,7 +24,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
@@ -32,7 +31,6 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_ialloc_btree.h"
 #include "xfs_alloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
@@ -131,9 +129,6 @@ xfs_init(void)
 #ifdef XFS_BMBT_TRACE
        xfs_bmbt_trace_buf = ktrace_alloc(XFS_BMBT_TRACE_SIZE, KM_SLEEP);
 #endif
-#ifdef XFS_DIR_TRACE
-        xfs_dir_trace_buf = ktrace_alloc(XFS_DIR_TRACE_SIZE, KM_SLEEP);
-#endif
 #ifdef XFS_ATTR_TRACE
        xfs_attr_trace_buf = ktrace_alloc(XFS_ATTR_TRACE_SIZE, KM_SLEEP);
 #endif
@@ -177,9 +172,6 @@ xfs_cleanup(void)
 #ifdef XFS_ATTR_TRACE
        ktrace_free(xfs_attr_trace_buf);
 #endif
-#ifdef XFS_DIR_TRACE
-        ktrace_free(xfs_dir_trace_buf);
-#endif
 #ifdef XFS_BMBT_TRACE
        ktrace_free(xfs_bmbt_trace_buf);
 #endif
@@ -212,7 +204,7 @@ xfs_cleanup(void)
 */
 STATIC int
 xfs_start_flags(
-        struct vfs              *vfs,
+        struct bhv_vfs          *vfs,
        struct xfs_mount_args   *ap,
        struct xfs_mount        *mp)
 {
@@ -337,7 +329,7 @@ xfs_start_flags(
 */
 STATIC int
 xfs_finish_flags(
-        struct vfs              *vfs,
+        struct bhv_vfs          *vfs,
        struct xfs_mount_args   *ap,
        struct xfs_mount        *mp)
 {
@@ -423,7 +415,7 @@ xfs_mount(
        struct xfs_mount_args   *args,
        cred_t                  *credp)
 {
-        struct vfs              *vfsp = bhvtovfs(bhvp);
+        struct bhv_vfs          *vfsp = bhvtovfs(bhvp);
        struct bhv_desc         *p;
        struct xfs_mount        *mp = XFS_BHVTOM(bhvp);
        struct block_device     *ddev, *logdev, *rtdev;
@@ -552,10 +544,10 @@ xfs_unmount(
        int             flags,
        cred_t          *credp)
 {
-        struct vfs      *vfsp = bhvtovfs(bdp);
+        bhv_vfs_t       *vfsp = bhvtovfs(bdp);
        xfs_mount_t     *mp = XFS_BHVTOM(bdp);
        xfs_inode_t     *rip;
-        vnode_t         *rvp;
+        bhv_vnode_t     *rvp;
        int             unmount_event_wanted = 0;
        int             unmount_event_flags = 0;
        int             xfs_unmountfs_needed = 0;
@@ -665,9 +657,8 @@ xfs_mntupdate(
        int                             *flags,
        struct xfs_mount_args           *args)
 {
-        struct vfs      *vfsp = bhvtovfs(bdp);
+        bhv_vfs_t       *vfsp = bhvtovfs(bdp);
        xfs_mount_t     *mp = XFS_BHVTOM(bdp);
-        int             error;
        if (!(*flags & MS_RDONLY)) {                    /* rw/ro -> rw */
                if (vfsp->vfs_flag & VFS_RDONLY)
@@ -679,7 +670,7 @@ xfs_mntupdate(
                        mp->m_flags &= ~XFS_MOUNT_BARRIER;
                }
        } else if (!(vfsp->vfs_flag & VFS_RDONLY)) {    /* rw -> ro */
-                VFS_SYNC(vfsp, SYNC_FSDATA|SYNC_BDFLUSH|SYNC_ATTR, NULL, error);
+                bhv_vfs_sync(vfsp, SYNC_FSDATA|SYNC_BDFLUSH|SYNC_ATTR, NULL);
                xfs_quiesce_fs(mp);
                xfs_log_unmount_write(mp);
                xfs_unmountfs_writesb(mp);
@@ -702,7 +693,7 @@ xfs_unmount_flush(
        xfs_inode_t     *rip = mp->m_rootip;
        xfs_inode_t     *rbmip;
        xfs_inode_t     *rsumip = NULL;
-        vnode_t         *rvp = XFS_ITOV(rip);
+        bhv_vnode_t     *rvp = XFS_ITOV(rip);
        int             error;
        xfs_ilock(rip, XFS_ILOCK_EXCL);
@@ -781,9 +772,9 @@ fscorrupt_out2:
 STATIC int
 xfs_root(
        bhv_desc_t      *bdp,
-        vnode_t         **vpp)
+        bhv_vnode_t     **vpp)
 {
-        vnode_t         *vp;
+        bhv_vnode_t     *vp;
        vp = XFS_ITOV((XFS_BHVTOM(bdp))->m_rootip);
        VN_HOLD(vp);
@@ -801,8 +792,8 @@ xfs_root(
 STATIC int
 xfs_statvfs(
        bhv_desc_t      *bdp,
-        xfs_statfs_t    *statp,
+        bhv_statvfs_t   *statp,
-        vnode_t         *vp)
+        bhv_vnode_t     *vp)
 {
        __uint64_t      fakeinos;
        xfs_extlen_t    lsize;
@@ -900,7 +891,7 @@ xfs_sync(
 /*
 * xfs sync routine for internal use
 *
- * This routine supports all of the flags defined for the generic VFS_SYNC
+ * This routine supports all of the flags defined for the generic vfs_sync
 * interface as explained above under xfs_sync.  In the interests of not
 * changing interfaces within the 6.5 family, additional internally-
 * required functions are specified within a separate xflags parameter,
@@ -917,7 +908,7 @@ xfs_sync_inodes(
        xfs_inode_t     *ip = NULL;
        xfs_inode_t     *ip_next;
        xfs_buf_t       *bp;
-        vnode_t         *vp = NULL;
+        bhv_vnode_t     *vp = NULL;
        int             error;
        int             last_error;
        uint64_t        fflag;
@@ -1156,9 +1147,9 @@ xfs_sync_inodes(
                        xfs_iunlock(ip, XFS_ILOCK_SHARED);
                        if (XFS_FORCED_SHUTDOWN(mp)) {
-                                VOP_TOSS_PAGES(vp, 0, -1, FI_REMAPF);
+                                bhv_vop_toss_pages(vp, 0, -1, FI_REMAPF);
                        } else {
-                                VOP_FLUSHINVAL_PAGES(vp, 0, -1, FI_REMAPF);
+                                bhv_vop_flushinval_pages(vp, 0, -1, FI_REMAPF);
                        }
                        xfs_ilock(ip, XFS_ILOCK_SHARED);
@@ -1178,8 +1169,8 @@ xfs_sync_inodes(
                                 * across calls to the buffer cache.
                                 */
                                xfs_iunlock(ip, XFS_ILOCK_SHARED);
-                                VOP_FLUSH_PAGES(vp, (xfs_off_t)0, -1,
+                                error = bhv_vop_flush_pages(vp, (xfs_off_t)0,
-                                                        fflag, FI_NONE, error);
+                                                        -1, fflag, FI_NONE);
                                xfs_ilock(ip, XFS_ILOCK_SHARED);
                        }
@@ -1231,9 +1222,7 @@ xfs_sync_inodes(
                                                 * marker and free it.
                                                 */
                                                XFS_MOUNT_ILOCK(mp);
                                                IPOINTER_REMOVE(ip, mp);
                                                XFS_MOUNT_IUNLOCK(mp);
                                                ASSERT(!(lock_flags &
@@ -1421,7 +1410,7 @@ xfs_sync_inodes(
 /*
 * xfs sync routine for internal use
 *
- * This routine supports all of the flags defined for the generic VFS_SYNC
+ * This routine supports all of the flags defined for the generic vfs_sync
 * interface as explained above under xfs_sync.  In the interests of not
 * changing interfaces within the 6.5 family, additional internally-
 * required functions are specified within a separate xflags parameter,
@@ -1574,7 +1563,7 @@ xfs_syncsub(
 STATIC int
 xfs_vget(
        bhv_desc_t      *bdp,
-        vnode_t         **vpp,
+        bhv_vnode_t     **vpp,
        fid_t           *fidp)
 {
        xfs_mount_t     *mp = XFS_BHVTOM(bdp);
@@ -1657,10 +1646,10 @@ xfs_vget(
 #define MNTOPT_NOATTR2  "noattr2"       /* do not use attr2 attribute format */
 STATIC unsigned long
-suffix_strtoul(const char *cp, char **endp, unsigned int base)
+suffix_strtoul(char *s, char **endp, unsigned int base)
 {
        int     last, shift_left_factor = 0;
-        char    *value = (char *)cp;
+        char    *value = s;
        last = strlen(value) - 1;
        if (value[last] == 'K' || value[last] == 'k') {
@@ -1676,7 +1665,7 @@ suffix_strtoul(const char *cp, char **endp, unsigned int base)
                value[last] = '\0';
        }
-        return simple_strtoul(cp, endp, base) << shift_left_factor;
+        return simple_strtoul((const char *)s, endp, base) << shift_left_factor;
 }
 STATIC int
@@ -1686,7 +1675,7 @@ xfs_parseargs(
        struct xfs_mount_args   *args,
        int                     update)
 {
-        struct vfs              *vfsp = bhvtovfs(bhv);
+        bhv_vfs_t               *vfsp = bhvtovfs(bhv);
        char                    *this_char, *value, *eov;
        int                     dsunit, dswidth, vol_dsunit, vol_dswidth;
        int                     iosize;
@@ -1708,42 +1697,48 @@ xfs_parseargs(
                if (!strcmp(this_char, MNTOPT_LOGBUFS)) {
                        if (!value || !*value) {
-                                printk("XFS: %s option requires an argument\n",
+                                cmn_err(CE_WARN,
+                                        "XFS: %s option requires an argument",
                                        this_char);
                                return EINVAL;
                        }
                        args->logbufs = simple_strtoul(value, &eov, 10);
                } else if (!strcmp(this_char, MNTOPT_LOGBSIZE)) {
                        if (!value || !*value) {
-                                printk("XFS: %s option requires an argument\n",
+                                cmn_err(CE_WARN,
+                                        "XFS: %s option requires an argument",
                                        this_char);
                                return EINVAL;
                        }
                        args->logbufsize = suffix_strtoul(value, &eov, 10);
                } else if (!strcmp(this_char, MNTOPT_LOGDEV)) {
                        if (!value || !*value) {
-                                printk("XFS: %s option requires an argument\n",
+                                cmn_err(CE_WARN,
+                                        "XFS: %s option requires an argument",
                                        this_char);
                                return EINVAL;
                        }
                        strncpy(args->logname, value, MAXNAMELEN);
                } else if (!strcmp(this_char, MNTOPT_MTPT)) {
                        if (!value || !*value) {
-                                printk("XFS: %s option requires an argument\n",
+                                cmn_err(CE_WARN,
+                                        "XFS: %s option requires an argument",
                                        this_char);
                                return EINVAL;
                        }
                        strncpy(args->mtpt, value, MAXNAMELEN);
                } else if (!strcmp(this_char, MNTOPT_RTDEV)) {
                        if (!value || !*value) {
-                                printk("XFS: %s option requires an argument\n",
+                                cmn_err(CE_WARN,
+                                        "XFS: %s option requires an argument",
                                        this_char);
                                return EINVAL;
                        }
                        strncpy(args->rtname, value, MAXNAMELEN);
                } else if (!strcmp(this_char, MNTOPT_BIOSIZE)) {
                        if (!value || !*value) {
-                                printk("XFS: %s option requires an argument\n",
+                                cmn_err(CE_WARN,
+                                        "XFS: %s option requires an argument",
                                        this_char);
                                return EINVAL;
                        }
@@ -1752,7 +1747,8 @@ xfs_parseargs(
                        args->iosizelog = (uint8_t) iosize;
                } else if (!strcmp(this_char, MNTOPT_ALLOCSIZE)) {
                        if (!value || !*value) {
-                                printk("XFS: %s option requires an argument\n",
+                                cmn_err(CE_WARN,
+                                        "XFS: %s option requires an argument",
                                        this_char);
                                return EINVAL;
                        }
@@ -1761,7 +1757,8 @@ xfs_parseargs(
                        args->iosizelog = ffs(iosize) - 1;
                } else if (!strcmp(this_char, MNTOPT_IHASHSIZE)) {
                        if (!value || !*value) {
-                                printk("XFS: %s option requires an argument\n",
+                                cmn_err(CE_WARN,
+                                        "XFS: %s option requires an argument",
                                        this_char);
                                return EINVAL;
                        }
@@ -1782,7 +1779,8 @@ xfs_parseargs(
                } else if (!strcmp(this_char, MNTOPT_INO64)) {
                        args->flags |= XFSMNT_INO64;
 #if !XFS_BIG_INUMS
-                        printk("XFS: %s option not allowed on this system\n",
+                        cmn_err(CE_WARN,
+                                "XFS: %s option not allowed on this system",
                                this_char);
                        return EINVAL;
 #endif
@@ -1792,14 +1790,16 @@ xfs_parseargs(
                        args->flags |= XFSMNT_SWALLOC;
                } else if (!strcmp(this_char, MNTOPT_SUNIT)) {
                        if (!value || !*value) {
-                                printk("XFS: %s option requires an argument\n",
+                                cmn_err(CE_WARN,
+                                        "XFS: %s option requires an argument",
                                        this_char);
                                return EINVAL;
                        }
                        dsunit = simple_strtoul(value, &eov, 10);
                } else if (!strcmp(this_char, MNTOPT_SWIDTH)) {
                        if (!value || !*value) {
-                                printk("XFS: %s option requires an argument\n",
+                                cmn_err(CE_WARN,
+                                        "XFS: %s option requires an argument",
                                        this_char);
                                return EINVAL;
                        }
@@ -1807,7 +1807,8 @@ xfs_parseargs(
                } else if (!strcmp(this_char, MNTOPT_64BITINODE)) {
                        args->flags &= ~XFSMNT_32BITINODES;
 #if !XFS_BIG_INUMS
-                        printk("XFS: %s option not allowed on this system\n",
+                        cmn_err(CE_WARN,
+                                "XFS: %s option not allowed on this system",
                                this_char);
                        return EINVAL;
 #endif
@@ -1831,36 +1832,41 @@ xfs_parseargs(
                        args->flags &= ~XFSMNT_ATTR2;
                } else if (!strcmp(this_char, "osyncisdsync")) {
                        /* no-op, this is now the default */
-printk("XFS: osyncisdsync is now the default, option is deprecated.\n");
+                        cmn_err(CE_WARN,
+        "XFS: osyncisdsync is now the default, option is deprecated.");
                } else if (!strcmp(this_char, "irixsgid")) {
-printk("XFS: irixsgid is now a sysctl(2) variable, option is deprecated.\n");
+                        cmn_err(CE_WARN,
+        "XFS: irixsgid is now a sysctl(2) variable, option is deprecated.");
                } else {
-                        printk("XFS: unknown mount option [%s].\n", this_char);
+                        cmn_err(CE_WARN,
+                                "XFS: unknown mount option [%s].", this_char);
                        return EINVAL;
                }
        }
        if (args->flags & XFSMNT_NORECOVERY) {
                if ((vfsp->vfs_flag & VFS_RDONLY) == 0) {
-                        printk("XFS: no-recovery mounts must be read-only.\n");
+                        cmn_err(CE_WARN,
+                                "XFS: no-recovery mounts must be read-only.");
                        return EINVAL;
                }
        }
        if ((args->flags & XFSMNT_NOALIGN) && (dsunit || dswidth)) {
-                printk(
+                cmn_err(CE_WARN,
-        "XFS: sunit and swidth options incompatible with the noalign option\n");
+        "XFS: sunit and swidth options incompatible with the noalign option");
                return EINVAL;
        }
        if ((dsunit && !dswidth) || (!dsunit && dswidth)) {
-                printk("XFS: sunit and swidth must be specified together\n");
+                cmn_err(CE_WARN,
+                        "XFS: sunit and swidth must be specified together");
                return EINVAL;
        }
        if (dsunit && (dswidth % dsunit != 0)) {
-                printk(
+                cmn_err(CE_WARN,
-        "XFS: stripe width (%d) must be a multiple of the stripe unit (%d)\n",
+        "XFS: stripe width (%d) must be a multiple of the stripe unit (%d)",
                        dswidth, dsunit);
                return EINVAL;
        }
@@ -1907,7 +1913,7 @@ xfs_showargs(
        };
        struct proc_xfs_info    *xfs_infop;
        struct xfs_mount        *mp = XFS_BHVTOM(bhv);
-        struct vfs              *vfsp = XFS_MTOVFS(mp);
+        struct bhv_vfs          *vfsp = XFS_MTOVFS(mp);
        for (xfs_infop = xfs_info; xfs_infop->flag; xfs_infop++) {
                if (mp->m_flags & xfs_infop->flag)
@@ -1967,7 +1973,7 @@ xfs_freeze(
 }
-vfsops_t xfs_vfsops = {
+bhv_vfsops_t xfs_vfsops = {
        BHV_IDENTITY_INIT(VFS_BHV_XFS,VFS_POSITION_XFS),
        .vfs_parseargs          = xfs_parseargs,
        .vfs_showargs           = xfs_showargs,
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 7027ae68ee38..00a6b7dc24a0 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2000-2005 Silicon Graphics, Inc.
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
@@ -16,8 +16,6 @@
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
-#include <linux/capability.h>
 #include "xfs.h"
 #include "xfs_fs.h"
 #include "xfs_types.h"
@@ -27,7 +25,6 @@
 #include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_dir.h"
 #include "xfs_dir2.h"
 #include "xfs_dmapi.h"
 #include "xfs_mount.h"
@@ -35,13 +32,11 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
-#include "xfs_dir_sf.h"
 #include "xfs_dir2_sf.h"
 #include "xfs_attr_sf.h"
 #include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_inode_item.h"
-#include "xfs_dir_leaf.h"
 #include "xfs_itable.h"
 #include "xfs_btree.h"
 #include "xfs_ialloc.h"
@@ -58,32 +53,14 @@
 #include "xfs_log_priv.h"
 #include "xfs_mac.h"
-/*
- * The maximum pathlen is 1024 bytes. Since the minimum file system
- * blocksize is 512 bytes, we can get a max of 2 extents back from
- * bmapi.
- */
-#define SYMLINK_MAPS 2
-/*
- * For xfs, we check that the file isn't too big to be opened by this kernel.
- * No other open action is required for regular files.  Devices are handled
- * through the specfs file system, pipes through fifofs.  Device and
- * fifo vnodes are "wrapped" by specfs and fifofs vnodes, respectively,
- * when a new vnode is first looked up or created.
- */
 STATIC int
 xfs_open(
        bhv_desc_t      *bdp,
        cred_t          *credp)
 {
        int             mode;
-        vnode_t         *vp;
+        bhv_vnode_t     *vp = BHV_TO_VNODE(bdp);
-        xfs_inode_t     *ip;
+        xfs_inode_t     *ip = XFS_BHVTOI(bdp);
-        vp = BHV_TO_VNODE(bdp);
-        ip = XFS_BHVTOI(bdp);
        if (XFS_FORCED_SHUTDOWN(ip->i_mount))
                return XFS_ERROR(EIO);
@@ -101,6 +78,35 @@ 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
@@ -108,13 +114,13 @@ xfs_open(
 STATIC int
 xfs_getattr(
        bhv_desc_t      *bdp,
-        vattr_t         *vap,
+        bhv_vattr_t     *vap,
        int             flags,
        cred_t          *credp)
 {
        xfs_inode_t     *ip;
        xfs_mount_t     *mp;
-        vnode_t         *vp;
+        bhv_vnode_t     *vp;
        vp  = BHV_TO_VNODE(bdp);
        vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
@@ -241,7 +247,7 @@ xfs_getattr(
 int
 xfs_setattr(
        bhv_desc_t              *bdp,
-        vattr_t                 *vap,
+        bhv_vattr_t             *vap,
        int                     flags,
        cred_t                  *credp)
 {
@@ -255,7 +261,7 @@ xfs_setattr(
        uid_t                   uid=0, iuid=0;
        gid_t                   gid=0, igid=0;
        int                     timeflags = 0;
-        vnode_t                 *vp;
+        bhv_vnode_t             *vp;
        xfs_prid_t              projid=0, iprojid=0;
        int                     mandlock_before, mandlock_after;
        struct xfs_dquot        *udqp, *gdqp, *olddquot1, *olddquot2;
@@ -347,7 +353,6 @@ xfs_setattr(
         */
        tp = NULL;
        lock_flags = XFS_ILOCK_EXCL;
-        ASSERT(flags & ATTR_NOLOCK ? flags & ATTR_DMI : 1);
        if (flags & ATTR_NOLOCK)
                need_iolock = 0;
        if (!(mask & XFS_AT_SIZE)) {
@@ -666,9 +671,17 @@ xfs_setattr(
                                            ((ip->i_d.di_nlink != 0 ||
                                              !(mp->m_flags & XFS_MOUNT_WSYNC))
                                             ? 1 : 0));
-                        if (code) {
+                        if (code)
                                goto abort_return;
-                        }
+                        /*
+                         * Truncated "down", so we're removing references
+                         * to old data here - if we now delay flushing for
+                         * a long time, we expose ourselves unduly to the
+                         * notorious NULL files problem.  So, we mark this
+                         * vnode and flush it when the file is closed, and
+                         * do not wait the usual (long) time for writeout.
+                         */
+                        VTRUNCATE(vp);
                }
                /*
                 * Have to do this even if the file's size doesn't change.
@@ -800,6 +813,8 @@ xfs_setattr(
                                di_flags |= XFS_DIFLAG_NODUMP;
                        if (vap->va_xflags & XFS_XFLAG_PROJINHERIT)
                                di_flags |= XFS_DIFLAG_PROJINHERIT;
+                        if (vap->va_xflags & XFS_XFLAG_NODEFRAG)
+                                di_flags |= XFS_DIFLAG_NODEFRAG;
                        if ((ip->i_d.di_mode & S_IFMT) == S_IFDIR) {
                                if (vap->va_xflags & XFS_XFLAG_RTINHERIT)
                                        di_flags |= XFS_DIFLAG_RTINHERIT;
@@ -869,7 +884,7 @@ xfs_setattr(
         */
        mandlock_after = MANDLOCK(vp, ip->i_d.di_mode);
        if (mandlock_before != mandlock_after) {
-                VOP_VNODE_CHANGE(vp, VCHANGE_FLAGS_ENF_LOCKING,
+                bhv_vop_vnode_change(vp, VCHANGE_FLAGS_ENF_LOCKING,
                                 mandlock_after);
        }
@@ -936,6 +951,13 @@ xfs_access(
 /*
+ * The maximum pathlen is 1024 bytes. Since the minimum file system
+ * blocksize is 512 bytes, we can get a max of 2 extents back from
+ * bmapi.
+ */
+#define SYMLINK_MAPS 2
+/*
 * xfs_readlink
 *
 */
@@ -950,7 +972,7 @@ xfs_readlink(
        int             count;
        xfs_off_t       offset;
        int             pathlen;
-        vnode_t         *vp;
+        bhv_vnode_t     *vp;
        int             error = 0;
        xfs_mount_t     *mp;
        int             nmaps;
@@ -1000,7 +1022,7 @@ xfs_readlink(
                nmaps = SYMLINK_MAPS;
                error = xfs_bmapi(NULL, ip, 0, XFS_B_TO_FSB(mp, pathlen),
-                                  0, NULL, 0, mval, &nmaps, NULL);
+                                  0, NULL, 0, mval, &nmaps, NULL, NULL);
                if (error) {
                        goto error_return;
@@ -1208,8 +1230,8 @@ xfs_inactive_free_eofblocks(
        nimaps = 1;
        xfs_ilock(ip, XFS_ILOCK_SHARED);
-        error = xfs_bmapi(NULL, ip, end_fsb, map_len, 0,
+        error = XFS_BMAPI(mp, NULL, &ip->i_iocore, end_fsb, map_len, 0,
-                          NULL, 0, &imap, &nimaps, NULL);
+                          NULL, 0, &imap, &nimaps, NULL, NULL);
        xfs_iunlock(ip, XFS_ILOCK_SHARED);
        if (!error && (nimaps != 0) &&
@@ -1338,7 +1360,7 @@ xfs_inactive_symlink_rmt(
        nmaps = ARRAY_SIZE(mval);
        if ((error = xfs_bmapi(tp, ip, 0, XFS_B_TO_FSB(mp, size),
                        XFS_BMAPI_METADATA, &first_block, 0, mval, &nmaps,
-                        &free_list)))
+                        &free_list, NULL)))
                goto error0;
        /*
         * Invalidate the block(s).
@@ -1353,7 +1375,7 @@ xfs_inactive_symlink_rmt(
         * Unmap the dead block(s) to the free_list.
         */
        if ((error = xfs_bunmapi(tp, ip, 0, size, XFS_BMAPI_METADATA, nmaps,
-                        &first_block, &free_list, &done)))
+                        &first_block, &free_list, NULL, &done)))
                goto error1;
        ASSERT(done);
        /*
@@ -1469,9 +1491,6 @@ xfs_inactive_symlink_local(
        return 0;
 }
-/*
- *
- */
 STATIC int
 xfs_inactive_attrs(
        xfs_inode_t     *ip,
@@ -1524,16 +1543,16 @@ xfs_release(
        bhv_desc_t      *bdp)
 {
        xfs_inode_t     *ip;
-        vnode_t         *vp;
+        bhv_vnode_t     *vp;
        xfs_mount_t     *mp;
        int             error;
        vp = BHV_TO_VNODE(bdp);
        ip = XFS_BHVTOI(bdp);
+        mp = ip->i_mount;
-        if (!VN_ISREG(vp) || (ip->i_d.di_mode == 0)) {
+        if (!VN_ISREG(vp) || (ip->i_d.di_mode == 0))
                return 0;
-        }
        /* If this is a read-only mount, don't do this (would generate I/O) */
        if (vp->v_vfsp->vfs_flag & VFS_RDONLY)
@@ -1545,8 +1564,6 @@ xfs_release(
                return 0;
 #endif
-        mp = ip->i_mount;
        if (ip->i_d.di_nlink != 0) {
                if ((((ip->i_d.di_mode & S_IFMT) == S_IFREG) &&
                     ((ip->i_d.di_size > 0) || (VN_CACHED(vp) > 0 ||
@@ -1579,8 +1596,8 @@ xfs_inactive(
        cred_t          *credp)
 {
        xfs_inode_t     *ip;
-        vnode_t         *vp;
+        bhv_vnode_t     *vp;
-        xfs_bmap_free_t free_list; 
+        xfs_bmap_free_t free_list;
        xfs_fsblock_t   first_block;
        int             committed;
        xfs_trans_t     *tp;
@@ -1760,7 +1777,7 @@ xfs_inactive(
                        cmn_err(CE_NOTE,
                "xfs_inactive:  xfs_ifree() returned an error = %d on %s",
                                error, mp->m_fsname);
-                        xfs_force_shutdown(mp, XFS_METADATA_IO_ERROR);
+                        xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
                }
                xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
        } else {
@@ -1795,17 +1812,17 @@ xfs_inactive(
 STATIC int
 xfs_lookup(
        bhv_desc_t              *dir_bdp,
-        vname_t                 *dentry,
+        bhv_vname_t             *dentry,
-        vnode_t                 **vpp,
+        bhv_vnode_t             **vpp,
        int                     flags,
-        vnode_t                 *rdir,
+        bhv_vnode_t             *rdir,
        cred_t                  *credp)
 {
        xfs_inode_t             *dp, *ip;
        xfs_ino_t               e_inum;
        int                     error;
        uint                    lock_mode;
-        vnode_t                 *dir_vp;
+        bhv_vnode_t             *dir_vp;
        dir_vp = BHV_TO_VNODE(dir_bdp);
        vn_trace_entry(dir_vp, __FUNCTION__, (inst_t *)__return_address);
@@ -1832,15 +1849,15 @@ xfs_lookup(
 STATIC int
 xfs_create(
        bhv_desc_t              *dir_bdp,
-        vname_t                 *dentry,
+        bhv_vname_t             *dentry,
-        vattr_t                 *vap,
+        bhv_vattr_t             *vap,
-        vnode_t                 **vpp,
+        bhv_vnode_t             **vpp,
        cred_t                  *credp)
 {
        char                    *name = VNAME(dentry);
-        vnode_t                 *dir_vp;
+        bhv_vnode_t             *dir_vp;
        xfs_inode_t             *dp, *ip;
-        vnode_t                 *vp=NULL;
+        bhv_vnode_t             *vp = NULL;
        xfs_trans_t             *tp;
        xfs_mount_t             *mp;
        xfs_dev_t               rdev;
@@ -1938,8 +1955,7 @@ xfs_create(
        if (error)
                goto error_return;
-        if (resblks == 0 &&
+        if (resblks == 0 && (error = xfs_dir_canenter(tp, dp, name, namelen)))
-            (error = XFS_DIR_CANENTER(mp, tp, dp, name, namelen)))
                goto error_return;
        rdev = (vap->va_mask & XFS_AT_RDEV) ? vap->va_rdev : 0;
        error = xfs_dir_ialloc(&tp, dp, vap->va_mode, 1,
@@ -1970,9 +1986,9 @@ xfs_create(
        xfs_trans_ijoin(tp, dp, XFS_ILOCK_EXCL);
        dp_joined_to_trans = B_TRUE;
-        error = XFS_DIR_CREATENAME(mp, tp, dp, name, namelen, ip->i_ino,
+        error = xfs_dir_createname(tp, dp, name, namelen, ip->i_ino,
-                &first_block, &free_list,
+                                        &first_block, &free_list, resblks ?
-                resblks ? resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
+                                        resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
        if (error) {
                ASSERT(error != ENOSPC);
                goto abort_return;
@@ -2026,7 +2042,7 @@ xfs_create(
         * Propagate the fact that the vnode changed after the
         * xfs_inode locks have been released.
         */
-        VOP_VNODE_CHANGE(vp, VCHANGE_FLAGS_TRUNCATED, 3);
+        bhv_vop_vnode_change(vp, VCHANGE_FLAGS_TRUNCATED, 3);
        *vpp = vp;
@@ -2107,7 +2123,7 @@ int xfs_rm_attempts;
 STATIC int
 xfs_lock_dir_and_entry(
        xfs_inode_t     *dp,
-        vname_t         *dentry,
+        bhv_vname_t     *dentry,
        xfs_inode_t     *ip)    /* inode of entry 'name' */
 {
        int             attempts;
@@ -2321,10 +2337,10 @@ int remove_which_error_return = 0;
 STATIC int
 xfs_remove(
        bhv_desc_t              *dir_bdp,
-        vname_t                 *dentry,
+        bhv_vname_t             *dentry,
        cred_t                  *credp)
 {
-        vnode_t                 *dir_vp;
+        bhv_vnode_t             *dir_vp;
        char                    *name = VNAME(dentry);
        xfs_inode_t             *dp, *ip;
        xfs_trans_t             *tp = NULL;
@@ -2448,8 +2464,8 @@ xfs_remove(
         * Entry must exist since we did a lookup in xfs_lock_dir_and_entry.
         */
        XFS_BMAP_INIT(&free_list, &first_block);
-        error = XFS_DIR_REMOVENAME(mp, tp, dp, name, namelen, ip->i_ino,
+        error = xfs_dir_removename(tp, dp, name, namelen, ip->i_ino,
-                &first_block, &free_list, 0);
+                                        &first_block, &free_list, 0);
        if (error) {
                ASSERT(error != ENOENT);
                REMOVE_DEBUG_TRACE(__LINE__);
@@ -2511,7 +2527,7 @@ xfs_remove(
        /*
         * Let interposed file systems know about removed links.
         */
-        VOP_LINK_REMOVED(XFS_ITOV(ip), dir_vp, link_zero);
+        bhv_vop_link_removed(XFS_ITOV(ip), dir_vp, link_zero);
        IRELE(ip);
@@ -2564,8 +2580,8 @@ xfs_remove(
 STATIC int
 xfs_link(
        bhv_desc_t              *target_dir_bdp,
-        vnode_t                 *src_vp,
+        bhv_vnode_t             *src_vp,
-        vname_t                 *dentry,
+        bhv_vname_t             *dentry,
        cred_t                  *credp)
 {
        xfs_inode_t             *tdp, *sip;
@@ -2577,7 +2593,7 @@ xfs_link(
        xfs_fsblock_t           first_block;
        int                     cancel_flags;
        int                     committed;
-        vnode_t                 *target_dir_vp;
+        bhv_vnode_t             *target_dir_vp;
        int                     resblks;
        char                    *target_name = VNAME(dentry);
        int                     target_namelen;
@@ -2668,13 +2684,12 @@ xfs_link(
        }
        if (resblks == 0 &&
-            (error = XFS_DIR_CANENTER(mp, tp, tdp, target_name,
+            (error = xfs_dir_canenter(tp, tdp, target_name, target_namelen)))
-                        target_namelen)))
                goto error_return;
        XFS_BMAP_INIT(&free_list, &first_block);
-        error = XFS_DIR_CREATENAME(mp, tp, tdp, target_name, target_namelen,
+        error = xfs_dir_createname(tp, tdp, target_name, target_namelen,
                                   sip->i_ino, &first_block, &free_list,
                                   resblks);
        if (error)
@@ -2734,15 +2749,15 @@ std_return:
 STATIC int
 xfs_mkdir(
        bhv_desc_t              *dir_bdp,
-        vname_t                 *dentry,
+        bhv_vname_t             *dentry,
-        vattr_t                 *vap,
+        bhv_vattr_t             *vap,
-        vnode_t                 **vpp,
+        bhv_vnode_t             **vpp,
        cred_t                  *credp)
 {
        char                    *dir_name = VNAME(dentry);
        xfs_inode_t             *dp;
        xfs_inode_t             *cdp;   /* inode of created dir */
-        vnode_t                 *cvp;   /* vnode of created dir */
+        bhv_vnode_t             *cvp;   /* vnode of created dir */
        xfs_trans_t             *tp;
        xfs_mount_t             *mp;
        int                     cancel_flags;
@@ -2750,7 +2765,7 @@ xfs_mkdir(
        int                     committed;
        xfs_bmap_free_t         free_list;
        xfs_fsblock_t           first_block;
-        vnode_t                 *dir_vp;
+        bhv_vnode_t             *dir_vp;
        boolean_t               dp_joined_to_trans;
        boolean_t               created = B_FALSE;
        int                     dm_event_sent = 0;
@@ -2840,7 +2855,7 @@ xfs_mkdir(
                goto error_return;
        if (resblks == 0 &&
-            (error = XFS_DIR_CANENTER(mp, tp, dp, dir_name, dir_namelen)))
+            (error = xfs_dir_canenter(tp, dp, dir_name, dir_namelen)))
                goto error_return;
        /*
         * create the directory inode.
@@ -2867,9 +2882,9 @@ xfs_mkdir(
        XFS_BMAP_INIT(&free_list, &first_block);
-        error = XFS_DIR_CREATENAME(mp, tp, dp, dir_name, dir_namelen,
+        error = xfs_dir_createname(tp, dp, dir_name, dir_namelen, cdp->i_ino,
-                        cdp->i_ino, &first_block, &free_list,
+                                   &first_block, &free_list, resblks ?
-                        resblks ? resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
+                                   resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
        if (error) {
                ASSERT(error != ENOSPC);
                goto error1;
@@ -2883,16 +2898,14 @@ xfs_mkdir(
         */
        dp->i_gen++;
-        error = XFS_DIR_INIT(mp, tp, cdp, dp);
+        error = xfs_dir_init(tp, cdp, dp);
-        if (error) {
+        if (error)
                goto error2;
-        }
        cdp->i_gen = 1;
        error = xfs_bumplink(tp, dp);
-        if (error) {
+        if (error)
                goto error2;
-        }
        cvp = XFS_ITOV(cdp);
@@ -2969,7 +2982,7 @@ std_return:
 STATIC int
 xfs_rmdir(
        bhv_desc_t              *dir_bdp,
-        vname_t                 *dentry,
+        bhv_vname_t             *dentry,
        cred_t                  *credp)
 {
        char                    *name = VNAME(dentry);
@@ -2982,7 +2995,7 @@ xfs_rmdir(
        xfs_fsblock_t           first_block;
        int                     cancel_flags;
        int                     committed;
-        vnode_t                 *dir_vp;
+        bhv_vnode_t             *dir_vp;
        int                     dm_di_mode = 0;
        int                     last_cdp_link;
        int                     namelen;
@@ -3101,16 +3114,15 @@ xfs_rmdir(
                error = XFS_ERROR(ENOTEMPTY);
                goto error_return;
        }
-        if (!XFS_DIR_ISEMPTY(mp, cdp)) {
+        if (!xfs_dir_isempty(cdp)) {
                error = XFS_ERROR(ENOTEMPTY);
                goto error_return;
        }
-        error = XFS_DIR_REMOVENAME(mp, tp, dp, name, namelen, cdp->i_ino,
+        error = xfs_dir_removename(tp, dp, name, namelen, cdp->i_ino,
-                &first_block, &free_list, resblks);
+                                        &first_block, &free_list, resblks);
-        if (error) {
+        if (error)
                goto error1;
-        }
        xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
@@ -3181,7 +3193,7 @@ xfs_rmdir(
        /*
         * Let interposed file systems know about removed links.
         */
-        VOP_LINK_REMOVED(XFS_ITOV(cdp), dir_vp, last_cdp_link);
+        bhv_vop_link_removed(XFS_ITOV(cdp), dir_vp, last_cdp_link);
        IRELE(cdp);
@@ -3209,8 +3221,6 @@ xfs_rmdir(
 /*
- * xfs_readdir
- *
 * Read dp's entries starting at uiop->uio_offset and translate them into
 * bufsize bytes worth of struct dirents starting at bufbase.
 */
@@ -3230,28 +3240,23 @@ xfs_readdir(
                                               (inst_t *)__return_address);
        dp = XFS_BHVTOI(dir_bdp);
-        if (XFS_FORCED_SHUTDOWN(dp->i_mount)) {
+        if (XFS_FORCED_SHUTDOWN(dp->i_mount))
                return XFS_ERROR(EIO);
-        }
        lock_mode = xfs_ilock_map_shared(dp);
-        error = XFS_DIR_GETDENTS(dp->i_mount, tp, dp, uiop, eofp);
+        error = xfs_dir_getdents(tp, dp, uiop, eofp);
        xfs_iunlock_map_shared(dp, lock_mode);
        return error;
 }
-/*
- * xfs_symlink
- *
- */
 STATIC int
 xfs_symlink(
        bhv_desc_t              *dir_bdp,
-        vname_t                 *dentry,
+        bhv_vname_t             *dentry,
-        vattr_t                 *vap,
+        bhv_vattr_t             *vap,
        char                    *target_path,
-        vnode_t                 **vpp,
+        bhv_vnode_t             **vpp,
        cred_t                  *credp)
 {
        xfs_trans_t             *tp;
@@ -3263,7 +3268,7 @@ xfs_symlink(
        xfs_bmap_free_t         free_list;
        xfs_fsblock_t           first_block;
        boolean_t               dp_joined_to_trans;
-        vnode_t                 *dir_vp;
+        bhv_vnode_t             *dir_vp;
        uint                    cancel_flags;
        int                     committed;
        xfs_fileoff_t           first_fsb;
@@ -3308,7 +3313,7 @@ xfs_symlink(
                int len, total;
                char *path;
-                for(total = 0, path = target_path; total < pathlen;) {
+                for (total = 0, path = target_path; total < pathlen;) {
                        /*
                         * Skip any slashes.
                         */
@@ -3402,7 +3407,7 @@ xfs_symlink(
         * Check for ability to enter directory entry, if no space reserved.
         */
        if (resblks == 0 &&
-            (error = XFS_DIR_CANENTER(mp, tp, dp, link_name, link_namelen)))
+            (error = xfs_dir_canenter(tp, dp, link_name, link_namelen)))
                goto error_return;
        /*
         * Initialize the bmap freelist prior to calling either
@@ -3457,7 +3462,7 @@ xfs_symlink(
                error = xfs_bmapi(tp, ip, first_fsb, fs_blocks,
                                  XFS_BMAPI_WRITE | XFS_BMAPI_METADATA,
                                  &first_block, resblks, mval, &nmaps,
-                                  &free_list);
+                                  &free_list, NULL);
                if (error) {
                        goto error1;
                }
@@ -3489,11 +3494,10 @@ xfs_symlink(
        /*
         * Create the directory entry for the symlink.
         */
-        error = XFS_DIR_CREATENAME(mp, tp, dp, link_name, link_namelen,
+        error = xfs_dir_createname(tp, dp, link_name, link_namelen, ip->i_ino,
-                        ip->i_ino, &first_block, &free_list, resblks);
+                                   &first_block, &free_list, resblks);
-        if (error) {
+        if (error)
                goto error1;
-        }
        xfs_ichgtime(dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
        xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
@@ -3541,7 +3545,7 @@ std_return:
        }
        if (!error) {
-                vnode_t *vp;
+                bhv_vnode_t *vp;
                ASSERT(ip);
                vp = XFS_ITOV(ip);
@@ -3606,10 +3610,10 @@ xfs_fid2(
 int
 xfs_rwlock(
        bhv_desc_t      *bdp,
-        vrwlock_t       locktype)
+        bhv_vrwlock_t   locktype)
 {
        xfs_inode_t     *ip;
-        vnode_t         *vp;
+        bhv_vnode_t     *vp;
        vp = BHV_TO_VNODE(bdp);
        if (VN_ISDIR(vp))
@@ -3637,10 +3641,10 @@ xfs_rwlock(
 void
 xfs_rwunlock(
        bhv_desc_t      *bdp,
-        vrwlock_t       locktype)
+        bhv_vrwlock_t   locktype)
 {
        xfs_inode_t     *ip;
-        vnode_t         *vp;
+        bhv_vnode_t     *vp;
        vp = BHV_TO_VNODE(bdp);
        if (VN_ISDIR(vp))
@@ -3744,7 +3748,6 @@ xfs_inode_flush(
        return error;
 }
 int
 xfs_set_dmattrs (
        bhv_desc_t      *bdp,
@@ -3785,16 +3788,12 @@ xfs_set_dmattrs (
        return error;
 }
-/*
- * xfs_reclaim
- */
 STATIC int
 xfs_reclaim(
        bhv_desc_t      *bdp)
 {
        xfs_inode_t     *ip;
-        vnode_t         *vp;
+        bhv_vnode_t     *vp;
        vp = BHV_TO_VNODE(bdp);
        ip = XFS_BHVTOI(bdp);
@@ -3849,7 +3848,7 @@ xfs_finish_reclaim(
        int             sync_mode)
 {
        xfs_ihash_t     *ih = ip->i_hash;
-        vnode_t         *vp = XFS_ITOV_NULL(ip);
+        bhv_vnode_t     *vp = XFS_ITOV_NULL(ip);
        int             error;
        if (vp && VN_BAD(vp))
@@ -4116,10 +4115,10 @@ retry:
                 * Issue the xfs_bmapi() call to allocate the blocks
                 */
                XFS_BMAP_INIT(&free_list, &firstfsb);
-                error = xfs_bmapi(tp, ip, startoffset_fsb,
+                error = XFS_BMAPI(mp, tp, &ip->i_iocore, startoffset_fsb,
                                  allocatesize_fsb, bmapi_flag,
                                  &firstfsb, 0, imapp, &nimaps,
-                                  &free_list);
+                                  &free_list, NULL);
                if (error) {
                        goto error0;
                }
@@ -4199,8 +4198,8 @@ xfs_zero_remaining_bytes(
        for (offset = startoff; offset <= endoff; offset = lastoffset + 1) {
                offset_fsb = XFS_B_TO_FSBT(mp, offset);
                nimap = 1;
-                error = xfs_bmapi(NULL, ip, offset_fsb, 1, 0, NULL, 0, &imap,
+                error = XFS_BMAPI(mp, NULL, &ip->i_iocore, offset_fsb, 1, 0,
-                        &nimap, NULL);
+                        NULL, 0, &imap, &nimap, NULL, NULL);
                if (error || nimap < 1)
                        break;
                ASSERT(imap.br_blockcount >= 1);
@@ -4259,7 +4258,7 @@ xfs_free_file_space(
        xfs_off_t               len,
        int                     attr_flags)
 {
-        vnode_t                 *vp;
+        bhv_vnode_t             *vp;
        int                     committed;
        int                     done;
        xfs_off_t               end_dmi_offset;
@@ -4308,7 +4307,6 @@ xfs_free_file_space(
                        return error;
        }
-        ASSERT(attr_flags & ATTR_NOLOCK ? attr_flags & ATTR_DMI : 1);
        if (attr_flags & ATTR_NOLOCK)
                need_iolock = 0;
        if (need_iolock) {
@@ -4326,7 +4324,7 @@ xfs_free_file_space(
        if (VN_CACHED(vp) != 0) {
                xfs_inval_cached_trace(&ip->i_iocore, ioffset, -1,
                                ctooff(offtoct(ioffset)), -1);
-                VOP_FLUSHINVAL_PAGES(vp, ctooff(offtoct(ioffset)),
+                bhv_vop_flushinval_pages(vp, ctooff(offtoct(ioffset)),
                                -1, FI_REMAPF_LOCKED);
        }
@@ -4338,8 +4336,8 @@ xfs_free_file_space(
         */
        if (rt && !XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb)) {
                nimap = 1;
-                error = xfs_bmapi(NULL, ip, startoffset_fsb, 1, 0, NULL, 0,
+                error = XFS_BMAPI(mp, NULL, &ip->i_iocore, startoffset_fsb,
-                        &imap, &nimap, NULL);
+                        1, 0, NULL, 0, &imap, &nimap, NULL, NULL);
                if (error)
                        goto out_unlock_iolock;
                ASSERT(nimap == 0 || nimap == 1);
@@ -4353,8 +4351,8 @@ xfs_free_file_space(
                                startoffset_fsb += mp->m_sb.sb_rextsize - mod;
                }
                nimap = 1;
-                error = xfs_bmapi(NULL, ip, endoffset_fsb - 1, 1, 0, NULL, 0,
+                error = XFS_BMAPI(mp, NULL, &ip->i_iocore, endoffset_fsb - 1,
-                        &imap, &nimap, NULL);
+                        1, 0, NULL, 0, &imap, &nimap, NULL, NULL);
                if (error)
                        goto out_unlock_iolock;
                ASSERT(nimap == 0 || nimap == 1);
@@ -4426,9 +4424,9 @@ xfs_free_file_space(
                 * issue the bunmapi() call to free the blocks
                 */
                XFS_BMAP_INIT(&free_list, &firstfsb);
-                error = xfs_bunmapi(tp, ip, startoffset_fsb,
+                error = XFS_BUNMAPI(mp, tp, &ip->i_iocore, startoffset_fsb,
                                  endoffset_fsb - startoffset_fsb,
-                                  0, 2, &firstfsb, &free_list, &done);
+                                  0, 2, &firstfsb, &free_list, NULL, &done);
                if (error) {
                        goto error0;
                }
@@ -4488,8 +4486,8 @@ xfs_change_file_space(
        xfs_off_t       startoffset;
        xfs_off_t       llen;
        xfs_trans_t     *tp;
-        vattr_t         va;
+        bhv_vattr_t     va;
-        vnode_t         *vp;
+        bhv_vnode_t     *vp;
        vp = BHV_TO_VNODE(bdp);
        vn_trace_entry(vp, __FUNCTION__, (inst_t *)__return_address);
@@ -4642,9 +4640,10 @@ xfs_change_file_space(
        return error;
 }
-vnodeops_t xfs_vnodeops = {
+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_SENDFILE
        .vop_sendfile           = xfs_sendfile,