116 files changed, 5294 insertions, 4717 deletions

diff --git a/fs/xfs/Makefile b/fs/xfs/Makefile
index 0719e4db93f2..c21f43506661 100644
--- a/fs/xfs/Makefile
+++ b/fs/xfs/Makefile
@@ -66,12 +66,14 @@ xfs-y				+= xfs_alloc.o \
                                    xfs_bmap_btree.o \
                                    xfs_btree.o \
                                    xfs_da_btree.o \
+                                   xfs_da_format.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_dquot_buf.o \
                                    xfs_ialloc.o \
                                    xfs_ialloc_btree.o \
                                    xfs_icreate_item.o \
@@ -103,7 +105,11 @@ xfs-$(CONFIG_XFS_QUOTA)		+= xfs_dquot.o \
                                    xfs_qm_bhv.o \
                                    xfs_qm.o \
                                    xfs_quotaops.o
-xfs-$(CONFIG_XFS_RT)            += xfs_rtalloc.o
+
+# xfs_rtbitmap is shared with libxfs
+xfs-$(CONFIG_XFS_RT)            += xfs_rtalloc.o \
+                                   xfs_rtbitmap.o
+
 xfs-$(CONFIG_XFS_POSIX_ACL)     += xfs_acl.o
 xfs-$(CONFIG_PROC_FS)           += xfs_stats.o
 xfs-$(CONFIG_SYSCTL)            += xfs_sysctl.o
diff --git a/fs/xfs/kmem.c b/fs/xfs/kmem.c
index a02cfb9e3bce..66a36befc5c0 100644
--- a/fs/xfs/kmem.c
+++ b/fs/xfs/kmem.c
@@ -63,17 +63,6 @@ kmem_alloc(size_t size, xfs_km_flags_t flags)
 }
 
 void *
-kmem_zalloc(size_t size, xfs_km_flags_t flags)
-{
-        void    *ptr;
-
-        ptr = kmem_alloc(size, flags);
-        if (ptr)
-                memset((char *)ptr, 0, (int)size);
-        return ptr;
-}
-
-void *
 kmem_zalloc_large(size_t size, xfs_km_flags_t flags)
 {
         void    *ptr;
@@ -128,14 +117,3 @@ kmem_zone_alloc(kmem_zone_t *zone, xfs_km_flags_t flags)
                 congestion_wait(BLK_RW_ASYNC, HZ/50);
         } while (1);
 }
-
-void *
-kmem_zone_zalloc(kmem_zone_t *zone, xfs_km_flags_t flags)
-{
-        void    *ptr;
-
-        ptr = kmem_zone_alloc(zone, flags);
-        if (ptr)
-                memset((char *)ptr, 0, kmem_cache_size(zone));
-        return ptr;
-}
diff --git a/fs/xfs/kmem.h b/fs/xfs/kmem.h
index 3a7371cab508..64db0e53edea 100644
--- a/fs/xfs/kmem.h
+++ b/fs/xfs/kmem.h
@@ -32,6 +32,7 @@ typedef unsigned __bitwise xfs_km_flags_t;
 #define KM_NOSLEEP      ((__force xfs_km_flags_t)0x0002u)
 #define KM_NOFS         ((__force xfs_km_flags_t)0x0004u)
 #define KM_MAYFAIL      ((__force xfs_km_flags_t)0x0008u)
+#define KM_ZERO         ((__force xfs_km_flags_t)0x0010u)
 
 /*
  * We use a special process flag to avoid recursive callbacks into
@@ -43,7 +44,7 @@ kmem_flags_convert(xfs_km_flags_t flags)
 {
         gfp_t   lflags;
 
-        BUG_ON(flags & ~(KM_SLEEP|KM_NOSLEEP|KM_NOFS|KM_MAYFAIL));
+        BUG_ON(flags & ~(KM_SLEEP|KM_NOSLEEP|KM_NOFS|KM_MAYFAIL|KM_ZERO));
 
         if (flags & KM_NOSLEEP) {
                 lflags = GFP_ATOMIC | __GFP_NOWARN;
@@ -52,11 +53,14 @@ kmem_flags_convert(xfs_km_flags_t flags)
                 if ((current->flags & PF_FSTRANS) || (flags & KM_NOFS))
                         lflags &= ~__GFP_FS;
         }
+
+        if (flags & KM_ZERO)
+                lflags |= __GFP_ZERO;
+
         return lflags;
 }
 
 extern void *kmem_alloc(size_t, xfs_km_flags_t);
-extern void *kmem_zalloc(size_t, xfs_km_flags_t);
 extern void *kmem_zalloc_large(size_t size, xfs_km_flags_t);
 extern void *kmem_realloc(const void *, size_t, size_t, xfs_km_flags_t);
 extern void  kmem_free(const void *);
@@ -64,6 +68,12 @@ extern void  kmem_free(const void *);
 
 extern void *kmem_zalloc_greedy(size_t *, size_t, size_t);
 
+static inline void *
+kmem_zalloc(size_t size, xfs_km_flags_t flags)
+{
+        return kmem_alloc(size, flags | KM_ZERO);
+}
+
 /*
  * Zone interfaces
  */
@@ -102,6 +112,11 @@ kmem_zone_destroy(kmem_zone_t *zone)
 }
 
 extern void *kmem_zone_alloc(kmem_zone_t *, xfs_km_flags_t);
-extern void *kmem_zone_zalloc(kmem_zone_t *, xfs_km_flags_t);
+
+static inline void *
+kmem_zone_zalloc(kmem_zone_t *zone, xfs_km_flags_t flags)
+{
+        return kmem_zone_alloc(zone, flags | KM_ZERO);
+}
 
 #endif /* __XFS_SUPPORT_KMEM_H__ */
diff --git a/fs/xfs/xfs_acl.c b/fs/xfs/xfs_acl.c
index 0e2f37efedd0..370eb3e121d1 100644
--- a/fs/xfs/xfs_acl.c
+++ b/fs/xfs/xfs_acl.c
@@ -16,15 +16,15 @@
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "xfs.h"
+#include "xfs_format.h"
 #include "xfs_log_format.h"
 #include "xfs_trans_resv.h"
-#include "xfs_acl.h"
-#include "xfs_attr.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_inode.h"
 #include "xfs_ag.h"
 #include "xfs_sb.h"
 #include "xfs_mount.h"
+#include "xfs_inode.h"
+#include "xfs_acl.h"
+#include "xfs_attr.h"
 #include "xfs_trace.h"
 #include <linux/slab.h>
 #include <linux/xattr.h>
diff --git a/fs/xfs/xfs_ag.h b/fs/xfs/xfs_ag.h
index 1cb740afd674..3fc109819c34 100644
--- a/fs/xfs/xfs_ag.h
+++ b/fs/xfs/xfs_ag.h
@@ -128,8 +128,6 @@ typedef struct xfs_agf {
 extern int xfs_read_agf(struct xfs_mount *mp, struct xfs_trans *tp,
                         xfs_agnumber_t agno, int flags, struct xfs_buf **bpp);
 
-extern const struct xfs_buf_ops xfs_agf_buf_ops;
-
 /*
  * Size of the unlinked inode hash table in the agi.
  */
@@ -191,8 +189,6 @@ typedef struct xfs_agi {
 extern int xfs_read_agi(struct xfs_mount *mp, struct xfs_trans *tp,
                                 xfs_agnumber_t agno, struct xfs_buf **bpp);
 
-extern const struct xfs_buf_ops xfs_agi_buf_ops;
-
 /*
  * The third a.g. block contains the a.g. freelist, an array
  * of block pointers to blocks owned by the allocation btree code.
diff --git a/fs/xfs/xfs_alloc.c b/fs/xfs/xfs_alloc.c
index 5a1393f5e020..9eab2dfdcbb5 100644
--- a/fs/xfs/xfs_alloc.c
+++ b/fs/xfs/xfs_alloc.c
@@ -17,25 +17,25 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_shared.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_alloc.h"
 #include "xfs_extent_busy.h"
 #include "xfs_error.h"
 #include "xfs_cksum.h"
 #include "xfs_trace.h"
+#include "xfs_trans.h"
 #include "xfs_buf_item.h"
+#include "xfs_log.h"
 
 struct workqueue_struct *xfs_alloc_wq;
 
@@ -2294,6 +2294,8 @@ xfs_read_agf(
 {
         int             error;
 
+        trace_xfs_read_agf(mp, agno);
+
         ASSERT(agno != NULLAGNUMBER);
         error = xfs_trans_read_buf(
                         mp, tp, mp->m_ddev_targp,
@@ -2324,8 +2326,9 @@ xfs_alloc_read_agf(
         struct xfs_perag        *pag;           /* per allocation group data */
         int                     error;
 
-        ASSERT(agno != NULLAGNUMBER);
+        trace_xfs_alloc_read_agf(mp, agno);
 
+        ASSERT(agno != NULLAGNUMBER);
         error = xfs_read_agf(mp, tp, agno,
                         (flags & XFS_ALLOC_FLAG_TRYLOCK) ? XBF_TRYLOCK : 0,
                         bpp);
diff --git a/fs/xfs/xfs_alloc.h b/fs/xfs/xfs_alloc.h
index 99d0a6101558..feacb061bab7 100644
--- a/fs/xfs/xfs_alloc.h
+++ b/fs/xfs/xfs_alloc.h
@@ -231,7 +231,4 @@ xfs_alloc_get_rec(
         xfs_extlen_t            *len,   /* output: length of extent */
         int                     *stat); /* output: success/failure */
 
-extern const struct xfs_buf_ops xfs_agf_buf_ops;
-extern const struct xfs_buf_ops xfs_agfl_buf_ops;
-
 #endif  /* __XFS_ALLOC_H__ */
diff --git a/fs/xfs/xfs_alloc_btree.c b/fs/xfs/xfs_alloc_btree.c
index cafc90251d19..13085429e523 100644
--- a/fs/xfs/xfs_alloc_btree.c
+++ b/fs/xfs/xfs_alloc_btree.c
@@ -17,23 +17,21 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
-#include "xfs_inode.h"
 #include "xfs_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_alloc.h"
 #include "xfs_extent_busy.h"
 #include "xfs_error.h"
 #include "xfs_trace.h"
 #include "xfs_cksum.h"
+#include "xfs_trans.h"
 
 
 STATIC struct xfs_btree_cur *
diff --git a/fs/xfs/xfs_alloc_btree.h b/fs/xfs/xfs_alloc_btree.h
index e3a3f7424192..45e189e7e81c 100644
--- a/fs/xfs/xfs_alloc_btree.h
+++ b/fs/xfs/xfs_alloc_btree.h
@@ -27,39 +27,6 @@ struct xfs_btree_cur;
 struct xfs_mount;
 
 /*
- * There are two on-disk btrees, one sorted by blockno and one sorted
- * by blockcount and blockno.  All blocks look the same to make the code
- * simpler; if we have time later, we'll make the optimizations.
- */
-#define XFS_ABTB_MAGIC          0x41425442      /* 'ABTB' for bno tree */
-#define XFS_ABTB_CRC_MAGIC      0x41423342      /* 'AB3B' */
-#define XFS_ABTC_MAGIC          0x41425443      /* 'ABTC' for cnt tree */
-#define XFS_ABTC_CRC_MAGIC      0x41423343      /* 'AB3C' */
-
-/*
- * Data record/key structure
- */
-typedef struct xfs_alloc_rec {
-        __be32          ar_startblock;  /* starting block number */
-        __be32          ar_blockcount;  /* count of free blocks */
-} xfs_alloc_rec_t, xfs_alloc_key_t;
-
-typedef struct xfs_alloc_rec_incore {
-        xfs_agblock_t   ar_startblock;  /* starting block number */
-        xfs_extlen_t    ar_blockcount;  /* count of free blocks */
-} xfs_alloc_rec_incore_t;
-
-/* btree pointer type */
-typedef __be32 xfs_alloc_ptr_t;
-
-/*
- * Block numbers in the AG:
- * SB is sector 0, AGF is sector 1, AGI is sector 2, AGFL is sector 3.
- */
-#define XFS_BNO_BLOCK(mp)       ((xfs_agblock_t)(XFS_AGFL_BLOCK(mp) + 1))
-#define XFS_CNT_BLOCK(mp)       ((xfs_agblock_t)(XFS_BNO_BLOCK(mp) + 1))
-
-/*
  * Btree block header size depends on a superblock flag.
  */
 #define XFS_ALLOC_BLOCK_LEN(mp) \
@@ -95,6 +62,4 @@ extern struct xfs_btree_cur *xfs_allocbt_init_cursor(struct xfs_mount *,
                 xfs_agnumber_t, xfs_btnum_t);
 extern int xfs_allocbt_maxrecs(struct xfs_mount *, int, int);
 
-extern const struct xfs_buf_ops xfs_allocbt_buf_ops;
-
 #endif  /* __XFS_ALLOC_BTREE_H__ */
diff --git a/fs/xfs/xfs_aops.c b/fs/xfs/xfs_aops.c
index e51e581454e9..71c8c9d2b882 100644
--- a/fs/xfs/xfs_aops.c
+++ b/fs/xfs/xfs_aops.c
@@ -16,14 +16,15 @@
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "xfs.h"
-#include "xfs_log.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_trans.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
 #include "xfs_alloc.h"
 #include "xfs_error.h"
@@ -31,6 +32,8 @@
 #include "xfs_trace.h"
 #include "xfs_bmap.h"
 #include "xfs_bmap_util.h"
+#include "xfs_bmap_btree.h"
+#include "xfs_dinode.h"
 #include <linux/aio.h>
 #include <linux/gfp.h>
 #include <linux/mpage.h>
@@ -333,7 +336,7 @@ xfs_map_blocks(
 
         if (type == XFS_IO_DELALLOC &&
             (!nimaps || isnullstartblock(imap->br_startblock))) {
-                error = xfs_iomap_write_allocate(ip, offset, count, imap);
+                error = xfs_iomap_write_allocate(ip, offset, imap);
                 if (!error)
                         trace_xfs_map_blocks_alloc(ip, offset, count, type, imap);
                 return -XFS_ERROR(error);
@@ -1569,8 +1572,7 @@ xfs_vm_write_begin(
 
         ASSERT(len <= PAGE_CACHE_SIZE);
 
-        page = grab_cache_page_write_begin(mapping, index,
-                                           flags | AOP_FLAG_NOFS);
+        page = grab_cache_page_write_begin(mapping, index, flags);
         if (!page)
                 return -ENOMEM;
 
diff --git a/fs/xfs/xfs_attr.c b/fs/xfs/xfs_attr.c
index ddcf2267ffa6..b86127072ac3 100644
--- a/fs/xfs/xfs_attr.c
+++ b/fs/xfs/xfs_attr.c
@@ -17,23 +17,24 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
-#include "xfs_trans_priv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_da_format.h"
 #include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
 #include "xfs_attr_sf.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_alloc.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
 #include "xfs_bmap.h"
 #include "xfs_bmap_util.h"
+#include "xfs_bmap_btree.h"
 #include "xfs_attr.h"
 #include "xfs_attr_leaf.h"
 #include "xfs_attr_remote.h"
@@ -41,6 +42,7 @@
 #include "xfs_quota.h"
 #include "xfs_trans_space.h"
 #include "xfs_trace.h"
+#include "xfs_dinode.h"
 
 /*
  * xfs_attr.c
diff --git a/fs/xfs/xfs_attr_inactive.c b/fs/xfs/xfs_attr_inactive.c
index bb24b07cbedb..09480c57f069 100644
--- a/fs/xfs/xfs_attr_inactive.c
+++ b/fs/xfs/xfs_attr_inactive.c
@@ -18,22 +18,20 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_da_format.h"
 #include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
+#include "xfs_inode.h"
 #include "xfs_alloc.h"
-#include "xfs_btree.h"
 #include "xfs_attr_remote.h"
-#include "xfs_dinode.h"
-#include "xfs_inode.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
 #include "xfs_bmap.h"
 #include "xfs_attr.h"
@@ -41,7 +39,8 @@
 #include "xfs_error.h"
 #include "xfs_quota.h"
 #include "xfs_trace.h"
-#include "xfs_trans_priv.h"
+#include "xfs_dinode.h"
+#include "xfs_dir2.h"
 
 /*
  * Look at all the extents for this logical region,
@@ -232,13 +231,13 @@ xfs_attr3_node_inactive(
         }
 
         node = bp->b_addr;
-        xfs_da3_node_hdr_from_disk(&ichdr, node);
+        dp->d_ops->node_hdr_from_disk(&ichdr, node);
         parent_blkno = bp->b_bn;
         if (!ichdr.count) {
                 xfs_trans_brelse(*trans, bp);
                 return 0;
         }
-        btree = xfs_da3_node_tree_p(node);
+        btree = dp->d_ops->node_tree_p(node);
         child_fsb = be32_to_cpu(btree[0].before);
         xfs_trans_brelse(*trans, bp);   /* no locks for later trans */
 
diff --git a/fs/xfs/xfs_attr_leaf.c b/fs/xfs/xfs_attr_leaf.c
index 86db20a9cc02..7b126f46a2f9 100644
--- a/fs/xfs/xfs_attr_leaf.c
+++ b/fs/xfs/xfs_attr_leaf.c
@@ -18,32 +18,31 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
-#include "xfs_trans_priv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_da_format.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_attr_sf.h"
-#include "xfs_attr_remote.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
+#include "xfs_bmap_btree.h"
 #include "xfs_bmap.h"
+#include "xfs_attr_sf.h"
+#include "xfs_attr_remote.h"
 #include "xfs_attr.h"
 #include "xfs_attr_leaf.h"
 #include "xfs_error.h"
 #include "xfs_trace.h"
 #include "xfs_buf_item.h"
 #include "xfs_cksum.h"
+#include "xfs_dinode.h"
+#include "xfs_dir2.h"
 
 
 /*
@@ -918,8 +917,8 @@ xfs_attr3_leaf_to_node(
         if (error)
                 goto out;
         node = bp1->b_addr;
-        xfs_da3_node_hdr_from_disk(&icnodehdr, node);
-        btree = xfs_da3_node_tree_p(node);
+        dp->d_ops->node_hdr_from_disk(&icnodehdr, node);
+        btree = dp->d_ops->node_tree_p(node);
 
         leaf = bp2->b_addr;
         xfs_attr3_leaf_hdr_from_disk(&icleafhdr, leaf);
@@ -929,7 +928,7 @@ xfs_attr3_leaf_to_node(
         btree[0].hashval = entries[icleafhdr.count - 1].hashval;
         btree[0].before = cpu_to_be32(blkno);
         icnodehdr.count = 1;
-        xfs_da3_node_hdr_to_disk(node, &icnodehdr);
+        dp->d_ops->node_hdr_to_disk(node, &icnodehdr);
         xfs_trans_log_buf(args->trans, bp1, 0, XFS_LBSIZE(mp) - 1);
         error = 0;
 out:
diff --git a/fs/xfs/xfs_attr_leaf.h b/fs/xfs/xfs_attr_leaf.h
index c1022138c7e6..3ec5ec0b8678 100644
--- a/fs/xfs/xfs_attr_leaf.h
+++ b/fs/xfs/xfs_attr_leaf.h
@@ -19,16 +19,6 @@
 #ifndef __XFS_ATTR_LEAF_H__
 #define __XFS_ATTR_LEAF_H__
 
-/*
- * Attribute storage layout, internal structure, access macros, etc.
- *
- * Attribute lists are structured around Btrees where all the data
- * elements are in the leaf nodes.  Attribute names are hashed into an int,
- * then that int is used as the index into the Btree.  Since the hashval
- * of an attribute name may not be unique, we may have duplicate keys.  The
- * internal links in the Btree are logical block offsets into the file.
- */
-
 struct attrlist;
 struct attrlist_cursor_kern;
 struct xfs_attr_list_context;
@@ -38,226 +28,6 @@ struct xfs_da_state_blk;
 struct xfs_inode;
 struct xfs_trans;
 
-/*========================================================================
- * Attribute 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.  Name/values 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 name/value area and try again.  If we
- * still don't have enough space, then we have to split the block.  The
- * name/value structs (both local and remote versions) must be 32bit aligned.
- *
- * Since we have duplicate hash keys, for each key that matches, compare
- * the actual name 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 attribute name is found.
- *
- * We store the fact that an attribute is a ROOT/USER/SECURE attribute in
- * the leaf_entry.  The namespaces are independent only because we also look
- * at the namespace bit when we are looking for a matching attribute name.
- *
- * We also store an "incomplete" bit in the leaf_entry.  It shows that an
- * attribute is in the middle of being created and should not be shown to
- * the user if we crash during the time that the bit is set.  We clear the
- * bit when we have finished setting up the attribute.  We do this because
- * we cannot create some large attributes inside a single transaction, and we
- * need some indication that we weren't finished if we crash in the middle.
- */
-#define XFS_ATTR_LEAF_MAPSIZE   3       /* how many freespace slots */
-
-typedef struct xfs_attr_leaf_map {      /* RLE map of free bytes */
-        __be16  base;                     /* base of free region */
-        __be16  size;                     /* length of free region */
-} xfs_attr_leaf_map_t;
-
-typedef struct xfs_attr_leaf_hdr {      /* constant-structure header block */
-        xfs_da_blkinfo_t info;          /* block type, links, etc. */
-        __be16  count;                  /* count of active leaf_entry's */
-        __be16  usedbytes;              /* num bytes of names/values stored */
-        __be16  firstused;              /* first used byte in name area */
-        __u8    holes;                  /* != 0 if blk needs compaction */
-        __u8    pad1;
-        xfs_attr_leaf_map_t freemap[XFS_ATTR_LEAF_MAPSIZE];
-                                        /* N largest free regions */
-} xfs_attr_leaf_hdr_t;
-
-typedef struct xfs_attr_leaf_entry {    /* sorted on key, not name */
-        __be32  hashval;                /* hash value of name */
-        __be16  nameidx;                /* index into buffer of name/value */
-        __u8    flags;                  /* LOCAL/ROOT/SECURE/INCOMPLETE flag */
-        __u8    pad2;                   /* unused pad byte */
-} xfs_attr_leaf_entry_t;
-
-typedef struct xfs_attr_leaf_name_local {
-        __be16  valuelen;               /* number of bytes in value */
-        __u8    namelen;                /* length of name bytes */
-        __u8    nameval[1];             /* name/value bytes */
-} xfs_attr_leaf_name_local_t;
-
-typedef struct xfs_attr_leaf_name_remote {
-        __be32  valueblk;               /* block number of value bytes */
-        __be32  valuelen;               /* number of bytes in value */
-        __u8    namelen;                /* length of name bytes */
-        __u8    name[1];                /* name bytes */
-} xfs_attr_leaf_name_remote_t;
-
-typedef struct xfs_attr_leafblock {
-        xfs_attr_leaf_hdr_t     hdr;    /* constant-structure header block */
-        xfs_attr_leaf_entry_t   entries[1];     /* sorted on key, not name */
-        xfs_attr_leaf_name_local_t namelist;    /* grows from bottom of buf */
-        xfs_attr_leaf_name_remote_t valuelist;  /* grows from bottom of buf */
-} xfs_attr_leafblock_t;
-
-/*
- * CRC enabled leaf structures. Called "version 3" structures to match the
- * version number of the directory and dablk structures for this feature, and
- * attr2 is already taken by the variable inode attribute fork size feature.
- */
-struct xfs_attr3_leaf_hdr {
-        struct xfs_da3_blkinfo  info;
-        __be16                  count;
-        __be16                  usedbytes;
-        __be16                  firstused;
-        __u8                    holes;
-        __u8                    pad1;
-        struct xfs_attr_leaf_map freemap[XFS_ATTR_LEAF_MAPSIZE];
-        __be32                  pad2;           /* 64 bit alignment */
-};
-
-#define XFS_ATTR3_LEAF_CRC_OFF  (offsetof(struct xfs_attr3_leaf_hdr, info.crc))
-
-struct xfs_attr3_leafblock {
-        struct xfs_attr3_leaf_hdr       hdr;
-        struct xfs_attr_leaf_entry      entries[1];
-
-        /*
-         * The rest of the block contains the following structures after the
-         * leaf entries, growing from the bottom up. The variables are never
-         * referenced, the locations accessed purely from helper functions.
-         *
-         * struct xfs_attr_leaf_name_local
-         * struct xfs_attr_leaf_name_remote
-         */
-};
-
-/*
- * incore, neutral version of the attribute leaf header
- */
-struct xfs_attr3_icleaf_hdr {
-        __uint32_t      forw;
-        __uint32_t      back;
-        __uint16_t      magic;
-        __uint16_t      count;
-        __uint16_t      usedbytes;
-        __uint16_t      firstused;
-        __u8            holes;
-        struct {
-                __uint16_t      base;
-                __uint16_t      size;
-        } freemap[XFS_ATTR_LEAF_MAPSIZE];
-};
-
-/*
- * Flags used in the leaf_entry[i].flags field.
- * NOTE: the INCOMPLETE bit must not collide with the flags bits specified
- * on the system call, they are "or"ed together for various operations.
- */
-#define XFS_ATTR_LOCAL_BIT      0       /* attr is stored locally */
-#define XFS_ATTR_ROOT_BIT       1       /* limit access to trusted attrs */
-#define XFS_ATTR_SECURE_BIT     2       /* limit access to secure attrs */
-#define XFS_ATTR_INCOMPLETE_BIT 7       /* attr in middle of create/delete */
-#define XFS_ATTR_LOCAL          (1 << XFS_ATTR_LOCAL_BIT)
-#define XFS_ATTR_ROOT           (1 << XFS_ATTR_ROOT_BIT)
-#define XFS_ATTR_SECURE         (1 << XFS_ATTR_SECURE_BIT)
-#define XFS_ATTR_INCOMPLETE     (1 << XFS_ATTR_INCOMPLETE_BIT)
-
-/*
- * Conversion macros for converting namespace bits from argument flags
- * to ondisk flags.
- */
-#define XFS_ATTR_NSP_ARGS_MASK          (ATTR_ROOT | ATTR_SECURE)
-#define XFS_ATTR_NSP_ONDISK_MASK        (XFS_ATTR_ROOT | XFS_ATTR_SECURE)
-#define XFS_ATTR_NSP_ONDISK(flags)      ((flags) & XFS_ATTR_NSP_ONDISK_MASK)
-#define XFS_ATTR_NSP_ARGS(flags)        ((flags) & XFS_ATTR_NSP_ARGS_MASK)
-#define XFS_ATTR_NSP_ARGS_TO_ONDISK(x)  (((x) & ATTR_ROOT ? XFS_ATTR_ROOT : 0) |\
-                                         ((x) & ATTR_SECURE ? XFS_ATTR_SECURE : 0))
-#define XFS_ATTR_NSP_ONDISK_TO_ARGS(x)  (((x) & XFS_ATTR_ROOT ? ATTR_ROOT : 0) |\
-                                         ((x) & XFS_ATTR_SECURE ? ATTR_SECURE : 0))
-
-/*
- * Alignment for namelist and valuelist entries (since they are mixed
- * there can be only one alignment value)
- */
-#define XFS_ATTR_LEAF_NAME_ALIGN        ((uint)sizeof(xfs_dablk_t))
-
-static inline int
-xfs_attr3_leaf_hdr_size(struct xfs_attr_leafblock *leafp)
-{
-        if (leafp->hdr.info.magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC))
-                return sizeof(struct xfs_attr3_leaf_hdr);
-        return sizeof(struct xfs_attr_leaf_hdr);
-}
-
-static inline struct xfs_attr_leaf_entry *
-xfs_attr3_leaf_entryp(xfs_attr_leafblock_t *leafp)
-{
-        if (leafp->hdr.info.magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC))
-                return &((struct xfs_attr3_leafblock *)leafp)->entries[0];
-        return &leafp->entries[0];
-}
-
-/*
- * Cast typed pointers for "local" and "remote" name/value structs.
- */
-static inline char *
-xfs_attr3_leaf_name(xfs_attr_leafblock_t *leafp, int idx)
-{
-        struct xfs_attr_leaf_entry *entries = xfs_attr3_leaf_entryp(leafp);
-
-        return &((char *)leafp)[be16_to_cpu(entries[idx].nameidx)];
-}
-
-static inline xfs_attr_leaf_name_remote_t *
-xfs_attr3_leaf_name_remote(xfs_attr_leafblock_t *leafp, int idx)
-{
-        return (xfs_attr_leaf_name_remote_t *)xfs_attr3_leaf_name(leafp, idx);
-}
-
-static inline xfs_attr_leaf_name_local_t *
-xfs_attr3_leaf_name_local(xfs_attr_leafblock_t *leafp, int idx)
-{
-        return (xfs_attr_leaf_name_local_t *)xfs_attr3_leaf_name(leafp, idx);
-}
-
-/*
- * Calculate total bytes used (including trailing pad for alignment) for
- * a "local" name/value structure, a "remote" name/value structure, and
- * a pointer which might be either.
- */
-static inline int xfs_attr_leaf_entsize_remote(int nlen)
-{
-        return ((uint)sizeof(xfs_attr_leaf_name_remote_t) - 1 + (nlen) + \
-                XFS_ATTR_LEAF_NAME_ALIGN - 1) & ~(XFS_ATTR_LEAF_NAME_ALIGN - 1);
-}
-
-static inline int xfs_attr_leaf_entsize_local(int nlen, int vlen)
-{
-        return ((uint)sizeof(xfs_attr_leaf_name_local_t) - 1 + (nlen) + (vlen) +
-                XFS_ATTR_LEAF_NAME_ALIGN - 1) & ~(XFS_ATTR_LEAF_NAME_ALIGN - 1);
-}
-
-static inline int xfs_attr_leaf_entsize_local_max(int bsize)
-{
-        return (((bsize) >> 1) + ((bsize) >> 2));
-}
-
 /*
  * Used to keep a list of "remote value" extents when unlinking an inode.
  */
@@ -336,6 +106,4 @@ void	xfs_attr3_leaf_hdr_from_disk(struct xfs_attr3_icleaf_hdr *to,
 void    xfs_attr3_leaf_hdr_to_disk(struct xfs_attr_leafblock *to,
                                    struct xfs_attr3_icleaf_hdr *from);
 
-extern const struct xfs_buf_ops xfs_attr3_leaf_buf_ops;
-
 #endif  /* __XFS_ATTR_LEAF_H__ */
diff --git a/fs/xfs/xfs_attr_list.c b/fs/xfs/xfs_attr_list.c
index cbc80d485177..2d174b128153 100644
--- a/fs/xfs/xfs_attr_list.c
+++ b/fs/xfs/xfs_attr_list.c
@@ -18,31 +18,29 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_da_format.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_attr_sf.h"
-#include "xfs_attr_remote.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
 #include "xfs_bmap.h"
 #include "xfs_attr.h"
+#include "xfs_attr_sf.h"
+#include "xfs_attr_remote.h"
 #include "xfs_attr_leaf.h"
 #include "xfs_error.h"
 #include "xfs_trace.h"
 #include "xfs_buf_item.h"
 #include "xfs_cksum.h"
+#include "xfs_dinode.h"
+#include "xfs_dir2.h"
 
 STATIC int
 xfs_attr_shortform_compare(const void *a, const void *b)
@@ -229,6 +227,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
         struct xfs_da_node_entry *btree;
         int error, i;
         struct xfs_buf *bp;
+        struct xfs_inode        *dp = context->dp;
 
         trace_xfs_attr_node_list(context);
 
@@ -242,7 +241,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
          */
         bp = NULL;
         if (cursor->blkno > 0) {
-                error = xfs_da3_node_read(NULL, context->dp, cursor->blkno, -1,
+                error = xfs_da3_node_read(NULL, dp, cursor->blkno, -1,
                                               &bp, XFS_ATTR_FORK);
                 if ((error != 0) && (error != EFSCORRUPTED))
                         return(error);
@@ -292,7 +291,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
                 for (;;) {
                         __uint16_t magic;
 
-                        error = xfs_da3_node_read(NULL, context->dp,
+                        error = xfs_da3_node_read(NULL, dp,
                                                       cursor->blkno, -1, &bp,
                                                       XFS_ATTR_FORK);
                         if (error)
@@ -312,8 +311,8 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
                                 return XFS_ERROR(EFSCORRUPTED);
                         }
 
-                        xfs_da3_node_hdr_from_disk(&nodehdr, node);
-                        btree = xfs_da3_node_tree_p(node);
+                        dp->d_ops->node_hdr_from_disk(&nodehdr, node);
+                        btree = dp->d_ops->node_tree_p(node);
                         for (i = 0; i < nodehdr.count; btree++, i++) {
                                 if (cursor->hashval
                                                 <= be32_to_cpu(btree->hashval)) {
@@ -349,8 +348,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
                         break;
                 cursor->blkno = leafhdr.forw;
                 xfs_trans_brelse(NULL, bp);
-                error = xfs_attr3_leaf_read(NULL, context->dp, cursor->blkno, -1,
-                                           &bp);
+                error = xfs_attr3_leaf_read(NULL, dp, cursor->blkno, -1, &bp);
                 if (error)
                         return error;
         }
diff --git a/fs/xfs/xfs_attr_remote.c b/fs/xfs/xfs_attr_remote.c
index 712a502de619..739e0a52deda 100644
--- a/fs/xfs/xfs_attr_remote.c
+++ b/fs/xfs/xfs_attr_remote.c
@@ -18,20 +18,19 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
-#include "xfs_trans_priv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_error.h"
+#include "xfs_da_format.h"
 #include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_alloc.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
 #include "xfs_bmap.h"
 #include "xfs_bmap_util.h"
@@ -42,6 +41,7 @@
 #include "xfs_trace.h"
 #include "xfs_cksum.h"
 #include "xfs_buf_item.h"
+#include "xfs_error.h"
 
 #define ATTR_RMTVALUE_MAPSIZE   1       /* # of map entries at once */
 
diff --git a/fs/xfs/xfs_attr_remote.h b/fs/xfs/xfs_attr_remote.h
index 92a8fd7977cc..5a9acfa156d7 100644
--- a/fs/xfs/xfs_attr_remote.h
+++ b/fs/xfs/xfs_attr_remote.h
@@ -18,35 +18,6 @@
 #ifndef __XFS_ATTR_REMOTE_H__
 #define __XFS_ATTR_REMOTE_H__
 
-#define XFS_ATTR3_RMT_MAGIC     0x5841524d      /* XARM */
-
-/*
- * There is one of these headers per filesystem block in a remote attribute.
- * This is done to ensure there is a 1:1 mapping between the attribute value
- * length and the number of blocks needed to store the attribute. This makes the
- * verification of a buffer a little more complex, but greatly simplifies the
- * allocation, reading and writing of these attributes as we don't have to guess
- * the number of blocks needed to store the attribute data.
- */
-struct xfs_attr3_rmt_hdr {
-        __be32  rm_magic;
-        __be32  rm_offset;
-        __be32  rm_bytes;
-        __be32  rm_crc;
-        uuid_t  rm_uuid;
-        __be64  rm_owner;
-        __be64  rm_blkno;
-        __be64  rm_lsn;
-};
-
-#define XFS_ATTR3_RMT_CRC_OFF   offsetof(struct xfs_attr3_rmt_hdr, rm_crc)
-
-#define XFS_ATTR3_RMT_BUF_SPACE(mp, bufsize)    \
-        ((bufsize) - (xfs_sb_version_hascrc(&(mp)->m_sb) ? \
-                        sizeof(struct xfs_attr3_rmt_hdr) : 0))
-
-extern const struct xfs_buf_ops xfs_attr3_rmt_buf_ops;
-
 int xfs_attr3_rmt_blocks(struct xfs_mount *mp, int attrlen);
 
 int xfs_attr_rmtval_get(struct xfs_da_args *args);
diff --git a/fs/xfs/xfs_bit.c b/fs/xfs/xfs_bit.c
index 48228848f5ae..0e8885a59646 100644
--- a/fs/xfs/xfs_bit.c
+++ b/fs/xfs/xfs_bit.c
@@ -16,10 +16,8 @@
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "xfs.h"
+#include "xfs_log_format.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
-#include "xfs_buf_item.h"
 
 /*
  * XFS bit manipulation routines, used in non-realtime code.
diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index f47e65c30be6..1c02da8bb7df 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -17,39 +17,37 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
 #include "xfs_inum.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_da_format.h"
 #include "xfs_da_btree.h"
-#include "xfs_dir2_format.h"
 #include "xfs_dir2.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_btree.h"
-#include "xfs_mount.h"
-#include "xfs_itable.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
 #include "xfs_extfree_item.h"
 #include "xfs_alloc.h"
 #include "xfs_bmap.h"
 #include "xfs_bmap_util.h"
+#include "xfs_bmap_btree.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
-#include "xfs_attr_leaf.h"
 #include "xfs_quota.h"
 #include "xfs_trans_space.h"
 #include "xfs_buf_item.h"
-#include "xfs_filestream.h"
 #include "xfs_trace.h"
 #include "xfs_symlink.h"
+#include "xfs_attr_leaf.h"
+#include "xfs_dinode.h"
+#include "xfs_filestream.h"
 
 
 kmem_zone_t             *xfs_bmap_free_item_zone;
@@ -1482,7 +1480,7 @@ xfs_bmap_search_extents(
                 xfs_alert_tag(ip->i_mount, XFS_PTAG_FSBLOCK_ZERO,
                                 "Access to block zero in inode %llu "
                                 "start_block: %llx start_off: %llx "
-                                "blkcnt: %llx extent-state: %x lastx: %x\n",
+                                "blkcnt: %llx extent-state: %x lastx: %x",
                         (unsigned long long)ip->i_ino,
                         (unsigned long long)gotp->br_startblock,
                         (unsigned long long)gotp->br_startoff,
diff --git a/fs/xfs/xfs_bmap_btree.c b/fs/xfs/xfs_bmap_btree.c
index bb8de8e399c4..706bc3f777cb 100644
--- a/fs/xfs/xfs_bmap_btree.c
+++ b/fs/xfs/xfs_bmap_btree.c
@@ -17,27 +17,26 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
 #include "xfs_alloc.h"
 #include "xfs_btree.h"
-#include "xfs_itable.h"
+#include "xfs_bmap_btree.h"
 #include "xfs_bmap.h"
 #include "xfs_error.h"
 #include "xfs_quota.h"
 #include "xfs_trace.h"
 #include "xfs_cksum.h"
+#include "xfs_dinode.h"
 
 /*
  * Determine the extent state.
diff --git a/fs/xfs/xfs_bmap_btree.h b/fs/xfs/xfs_bmap_btree.h
index e367461a638e..6e42e1e50b89 100644
--- a/fs/xfs/xfs_bmap_btree.h
+++ b/fs/xfs/xfs_bmap_btree.h
@@ -18,9 +18,6 @@
 #ifndef __XFS_BMAP_BTREE_H__
 #define __XFS_BMAP_BTREE_H__
 
-#define XFS_BMAP_MAGIC          0x424d4150      /* 'BMAP' */
-#define XFS_BMAP_CRC_MAGIC      0x424d4133      /* 'BMA3' */
-
 struct xfs_btree_cur;
 struct xfs_btree_block;
 struct xfs_mount;
@@ -28,85 +25,6 @@ struct xfs_inode;
 struct xfs_trans;
 
 /*
- * Bmap root header, on-disk form only.
- */
-typedef struct xfs_bmdr_block {
-        __be16          bb_level;       /* 0 is a leaf */
-        __be16          bb_numrecs;     /* current # of data records */
-} xfs_bmdr_block_t;
-
-/*
- * Bmap btree record and extent descriptor.
- *  l0:63 is an extent flag (value 1 indicates non-normal).
- *  l0:9-62 are startoff.
- *  l0:0-8 and l1:21-63 are startblock.
- *  l1:0-20 are blockcount.
- */
-#define BMBT_EXNTFLAG_BITLEN    1
-#define BMBT_STARTOFF_BITLEN    54
-#define BMBT_STARTBLOCK_BITLEN  52
-#define BMBT_BLOCKCOUNT_BITLEN  21
-
-typedef struct xfs_bmbt_rec {
-        __be64                  l0, l1;
-} xfs_bmbt_rec_t;
-
-typedef __uint64_t      xfs_bmbt_rec_base_t;    /* use this for casts */
-typedef xfs_bmbt_rec_t xfs_bmdr_rec_t;
-
-typedef struct xfs_bmbt_rec_host {
-        __uint64_t              l0, l1;
-} xfs_bmbt_rec_host_t;
-
-/*
- * Values and macros for delayed-allocation startblock fields.
- */
-#define STARTBLOCKVALBITS       17
-#define STARTBLOCKMASKBITS      (15 + XFS_BIG_BLKNOS * 20)
-#define DSTARTBLOCKMASKBITS     (15 + 20)
-#define STARTBLOCKMASK          \
-        (((((xfs_fsblock_t)1) << STARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
-#define DSTARTBLOCKMASK         \
-        (((((xfs_dfsbno_t)1) << DSTARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
-
-static inline int isnullstartblock(xfs_fsblock_t x)
-{
-        return ((x) & STARTBLOCKMASK) == STARTBLOCKMASK;
-}
-
-static inline int isnulldstartblock(xfs_dfsbno_t x)
-{
-        return ((x) & DSTARTBLOCKMASK) == DSTARTBLOCKMASK;
-}
-
-static inline xfs_fsblock_t nullstartblock(int k)
-{
-        ASSERT(k < (1 << STARTBLOCKVALBITS));
-        return STARTBLOCKMASK | (k);
-}
-
-static inline xfs_filblks_t startblockval(xfs_fsblock_t x)
-{
-        return (xfs_filblks_t)((x) & ~STARTBLOCKMASK);
-}
-
-/*
- * Possible extent formats.
- */
-typedef enum {
-        XFS_EXTFMT_NOSTATE = 0,
-        XFS_EXTFMT_HASSTATE
-} xfs_exntfmt_t;
-
-/*
- * Possible extent states.
- */
-typedef enum {
-        XFS_EXT_NORM, XFS_EXT_UNWRITTEN,
-        XFS_EXT_DMAPI_OFFLINE, XFS_EXT_INVALID
-} xfs_exntst_t;
-
-/*
  * Extent state and extent format macros.
  */
 #define XFS_EXTFMT_INODE(x)     \
@@ -115,27 +33,6 @@ typedef enum {
 #define ISUNWRITTEN(x)  ((x)->br_state == XFS_EXT_UNWRITTEN)
 
 /*
- * Incore version of above.
- */
-typedef struct xfs_bmbt_irec
-{
-        xfs_fileoff_t   br_startoff;    /* starting file offset */
-        xfs_fsblock_t   br_startblock;  /* starting block number */
-        xfs_filblks_t   br_blockcount;  /* number of blocks */
-        xfs_exntst_t    br_state;       /* extent state */
-} xfs_bmbt_irec_t;
-
-/*
- * Key structure for non-leaf levels of the tree.
- */
-typedef struct xfs_bmbt_key {
-        __be64          br_startoff;    /* starting file offset */
-} xfs_bmbt_key_t, xfs_bmdr_key_t;
-
-/* btree pointer type */
-typedef __be64 xfs_bmbt_ptr_t, xfs_bmdr_ptr_t;
-
-/*
  * Btree block header size depends on a superblock flag.
  */
 #define XFS_BMBT_BLOCK_LEN(mp) \
@@ -243,6 +140,4 @@ extern int xfs_bmbt_change_owner(struct xfs_trans *tp, struct xfs_inode *ip,
 extern struct xfs_btree_cur *xfs_bmbt_init_cursor(struct xfs_mount *,
                 struct xfs_trans *, struct xfs_inode *, int);
 
-extern const struct xfs_buf_ops xfs_bmbt_buf_ops;
-
 #endif  /* __XFS_BMAP_BTREE_H__ */
diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index 97f952caea74..5887e41c0323 100644
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -18,31 +18,31 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_inum.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
+#include "xfs_da_format.h"
 #include "xfs_inode.h"
 #include "xfs_btree.h"
+#include "xfs_trans.h"
 #include "xfs_extfree_item.h"
 #include "xfs_alloc.h"
 #include "xfs_bmap.h"
 #include "xfs_bmap_util.h"
+#include "xfs_bmap_btree.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
 #include "xfs_quota.h"
 #include "xfs_trans_space.h"
 #include "xfs_trace.h"
 #include "xfs_icache.h"
+#include "xfs_log.h"
+#include "xfs_dinode.h"
 
 /* Kernel only BMAP related definitions and functions */
 
@@ -965,32 +965,12 @@ xfs_free_eofblocks(
         return error;
 }
 
-/*
- * xfs_alloc_file_space()
- *      This routine allocates disk space for the given file.
- *
- *      If alloc_type == 0, this request is for an ALLOCSP type
- *      request which will change the file size.  In this case, no
- *      DMAPI event will be generated by the call.  A TRUNCATE event
- *      will be generated later by xfs_setattr.
- *
- *      If alloc_type != 0, this request is for a RESVSP type
- *      request, and a DMAPI DM_EVENT_WRITE will be generated if the
- *      lower block boundary byte address is less than the file's
- *      length.
- *
- * RETURNS:
- *       0 on success
- *      errno on error
- *
- */
-STATIC int
+int
 xfs_alloc_file_space(
-        xfs_inode_t             *ip,
+        struct xfs_inode        *ip,
         xfs_off_t               offset,
         xfs_off_t               len,
-        int                     alloc_type,
-        int                     attr_flags)
+        int                     alloc_type)
 {
         xfs_mount_t             *mp = ip->i_mount;
         xfs_off_t               count;
@@ -1232,24 +1212,11 @@ xfs_zero_remaining_bytes(
         return error;
 }
 
-/*
- * xfs_free_file_space()
- *      This routine frees disk space for the given file.
- *
- *      This routine is only called by xfs_change_file_space
- *      for an UNRESVSP type call.
- *
- * RETURNS:
- *       0 on success
- *      errno on error
- *
- */
-STATIC int
+int
 xfs_free_file_space(
-        xfs_inode_t             *ip,
+        struct xfs_inode        *ip,
         xfs_off_t               offset,
-        xfs_off_t               len,
-        int                     attr_flags)
+        xfs_off_t               len)
 {
         int                     committed;
         int                     done;
@@ -1267,7 +1234,6 @@ xfs_free_file_space(
         int                     rt;
         xfs_fileoff_t           startoffset_fsb;
         xfs_trans_t             *tp;
-        int                     need_iolock = 1;
 
         mp = ip->i_mount;
 
@@ -1284,20 +1250,15 @@ xfs_free_file_space(
         startoffset_fsb = XFS_B_TO_FSB(mp, offset);
         endoffset_fsb = XFS_B_TO_FSBT(mp, offset + len);
 
-        if (attr_flags & XFS_ATTR_NOLOCK)
-                need_iolock = 0;
-        if (need_iolock) {
-                xfs_ilock(ip, XFS_IOLOCK_EXCL);
-                /* wait for the completion of any pending DIOs */
-                inode_dio_wait(VFS_I(ip));
-        }
+        /* wait for the completion of any pending DIOs */
+        inode_dio_wait(VFS_I(ip));
 
         rounding = max_t(xfs_off_t, 1 << mp->m_sb.sb_blocklog, PAGE_CACHE_SIZE);
         ioffset = offset & ~(rounding - 1);
         error = -filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
                                               ioffset, -1);
         if (error)
-                goto out_unlock_iolock;
+                goto out;
         truncate_pagecache_range(VFS_I(ip), ioffset, -1);
 
         /*
@@ -1311,7 +1272,7 @@ xfs_free_file_space(
                 error = xfs_bmapi_read(ip, startoffset_fsb, 1,
                                         &imap, &nimap, 0);
                 if (error)
-                        goto out_unlock_iolock;
+                        goto out;
                 ASSERT(nimap == 0 || nimap == 1);
                 if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
                         xfs_daddr_t     block;
@@ -1326,7 +1287,7 @@ xfs_free_file_space(
                 error = xfs_bmapi_read(ip, endoffset_fsb - 1, 1,
                                         &imap, &nimap, 0);
                 if (error)
-                        goto out_unlock_iolock;
+                        goto out;
                 ASSERT(nimap == 0 || nimap == 1);
                 if (nimap && imap.br_startblock != HOLESTARTBLOCK) {
                         ASSERT(imap.br_startblock != DELAYSTARTBLOCK);
@@ -1412,27 +1373,23 @@ xfs_free_file_space(
                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
         }
 
- out_unlock_iolock:
-        if (need_iolock)
-                xfs_iunlock(ip, XFS_IOLOCK_EXCL);
+ out:
         return error;
 
  error0:
         xfs_bmap_cancel(&free_list);
  error1:
         xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
-        xfs_iunlock(ip, need_iolock ? (XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL) :
-                    XFS_ILOCK_EXCL);
-        return error;
+        xfs_iunlock(ip, XFS_ILOCK_EXCL);
+        goto out;
 }
 
 
-STATIC int
+int
 xfs_zero_file_space(
         struct xfs_inode        *ip,
         xfs_off_t               offset,
-        xfs_off_t               len,
-        int                     attr_flags)
+        xfs_off_t               len)
 {
         struct xfs_mount        *mp = ip->i_mount;
         uint                    granularity;
@@ -1453,9 +1410,6 @@ xfs_zero_file_space(
         ASSERT(start_boundary >= offset);
         ASSERT(end_boundary <= offset + len);
 
-        if (!(attr_flags & XFS_ATTR_NOLOCK))
-                xfs_ilock(ip, XFS_IOLOCK_EXCL);
-
         if (start_boundary < end_boundary - 1) {
                 /* punch out the page cache over the conversion range */
                 truncate_pagecache_range(VFS_I(ip), start_boundary,
@@ -1463,16 +1417,16 @@ xfs_zero_file_space(
                 /* convert the blocks */
                 error = xfs_alloc_file_space(ip, start_boundary,
                                         end_boundary - start_boundary - 1,
-                                        XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT,
-                                        attr_flags);
+                                        XFS_BMAPI_PREALLOC | XFS_BMAPI_CONVERT);
                 if (error)
-                        goto out_unlock;
+                        goto out;
 
                 /* We've handled the interior of the range, now for the edges */
-                if (start_boundary != offset)
+                if (start_boundary != offset) {
                         error = xfs_iozero(ip, offset, start_boundary - offset);
-                if (error)
-                        goto out_unlock;
+                        if (error)
+                                goto out;
+                }
 
                 if (end_boundary != offset + len)
                         error = xfs_iozero(ip, end_boundary,
@@ -1486,197 +1440,12 @@ xfs_zero_file_space(
                 error = xfs_iozero(ip, offset, len);
         }
 
-out_unlock:
-        if (!(attr_flags & XFS_ATTR_NOLOCK))
-                xfs_iunlock(ip, XFS_IOLOCK_EXCL);
+out:
         return error;
 
 }
 
 /*
- * xfs_change_file_space()
- *      This routine allocates or frees disk space for the given file.
- *      The user specified parameters are checked for alignment and size
- *      limitations.
- *
- * RETURNS:
- *       0 on success
- *      errno on error
- *
- */
-int
-xfs_change_file_space(
-        xfs_inode_t     *ip,
-        int             cmd,
-        xfs_flock64_t   *bf,
-        xfs_off_t       offset,
-        int             attr_flags)
-{
-        xfs_mount_t     *mp = ip->i_mount;
-        int             clrprealloc;
-        int             error;
-        xfs_fsize_t     fsize;
-        int             setprealloc;
-        xfs_off_t       startoffset;
-        xfs_trans_t     *tp;
-        struct iattr    iattr;
-
-        if (!S_ISREG(ip->i_d.di_mode))
-                return XFS_ERROR(EINVAL);
-
-        switch (bf->l_whence) {
-        case 0: /*SEEK_SET*/
-                break;
-        case 1: /*SEEK_CUR*/
-                bf->l_start += offset;
-                break;
-        case 2: /*SEEK_END*/
-                bf->l_start += XFS_ISIZE(ip);
-                break;
-        default:
-                return XFS_ERROR(EINVAL);
-        }
-
-        /*
-         * length of <= 0 for resv/unresv/zero is invalid.  length for
-         * alloc/free is ignored completely and we have no idea what userspace
-         * might have set it to, so set it to zero to allow range
-         * checks to pass.
-         */
-        switch (cmd) {
-        case XFS_IOC_ZERO_RANGE:
-        case XFS_IOC_RESVSP:
-        case XFS_IOC_RESVSP64:
-        case XFS_IOC_UNRESVSP:
-        case XFS_IOC_UNRESVSP64:
-                if (bf->l_len <= 0)
-                        return XFS_ERROR(EINVAL);
-                break;
-        default:
-                bf->l_len = 0;
-                break;
-        }
-
-        if (bf->l_start < 0 ||
-            bf->l_start > mp->m_super->s_maxbytes ||
-            bf->l_start + bf->l_len < 0 ||
-            bf->l_start + bf->l_len >= mp->m_super->s_maxbytes)
-                return XFS_ERROR(EINVAL);
-
-        bf->l_whence = 0;
-
-        startoffset = bf->l_start;
-        fsize = XFS_ISIZE(ip);
-
-        setprealloc = clrprealloc = 0;
-        switch (cmd) {
-        case XFS_IOC_ZERO_RANGE:
-                error = xfs_zero_file_space(ip, startoffset, bf->l_len,
-                                                attr_flags);
-                if (error)
-                        return error;
-                setprealloc = 1;
-                break;
-
-        case XFS_IOC_RESVSP:
-        case XFS_IOC_RESVSP64:
-                error = xfs_alloc_file_space(ip, startoffset, bf->l_len,
-                                                XFS_BMAPI_PREALLOC, attr_flags);
-                if (error)
-                        return error;
-                setprealloc = 1;
-                break;
-
-        case XFS_IOC_UNRESVSP:
-        case XFS_IOC_UNRESVSP64:
-                if ((error = xfs_free_file_space(ip, startoffset, bf->l_len,
-                                                                attr_flags)))
-                        return error;
-                break;
-
-        case XFS_IOC_ALLOCSP:
-        case XFS_IOC_ALLOCSP64:
-        case XFS_IOC_FREESP:
-        case XFS_IOC_FREESP64:
-                /*
-                 * These operations actually do IO when extending the file, but
-                 * the allocation is done seperately to the zeroing that is
-                 * done. This set of operations need to be serialised against
-                 * other IO operations, such as truncate and buffered IO. We
-                 * need to take the IOLOCK here to serialise the allocation and
-                 * zeroing IO to prevent other IOLOCK holders (e.g. getbmap,
-                 * truncate, direct IO) from racing against the transient
-                 * allocated but not written state we can have here.
-                 */
-                xfs_ilock(ip, XFS_IOLOCK_EXCL);
-                if (startoffset > fsize) {
-                        error = xfs_alloc_file_space(ip, fsize,
-                                        startoffset - fsize, 0,
-                                        attr_flags | XFS_ATTR_NOLOCK);
-                        if (error) {
-                                xfs_iunlock(ip, XFS_IOLOCK_EXCL);
-                                break;
-                        }
-                }
-
-                iattr.ia_valid = ATTR_SIZE;
-                iattr.ia_size = startoffset;
-
-                error = xfs_setattr_size(ip, &iattr,
-                                         attr_flags | XFS_ATTR_NOLOCK);
-                xfs_iunlock(ip, XFS_IOLOCK_EXCL);
-
-                if (error)
-                        return error;
-
-                clrprealloc = 1;
-                break;
-
-        default:
-                ASSERT(0);
-                return XFS_ERROR(EINVAL);
-        }
-
-        /*
-         * update the inode timestamp, mode, and prealloc flag bits
-         */
-        tp = xfs_trans_alloc(mp, XFS_TRANS_WRITEID);
-        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_writeid, 0, 0);
-        if (error) {
-                xfs_trans_cancel(tp, 0);
-                return error;
-        }
-
-        xfs_ilock(ip, XFS_ILOCK_EXCL);
-        xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
-
-        if ((attr_flags & XFS_ATTR_DMI) == 0) {
-                ip->i_d.di_mode &= ~S_ISUID;
-
-                /*
-                 * Note that we don't have to worry about mandatory
-                 * file locking being disabled here because we only
-                 * clear the S_ISGID bit if the Group execute bit is
-                 * on, but if it was on then mandatory locking wouldn't
-                 * have been enabled.
-                 */
-                if (ip->i_d.di_mode & S_IXGRP)
-                        ip->i_d.di_mode &= ~S_ISGID;
-
-                xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
-        }
-        if (setprealloc)
-                ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
-        else if (clrprealloc)
-                ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;
-
-        xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
-        if (attr_flags & XFS_ATTR_SYNC)
-                xfs_trans_set_sync(tp);
-        return xfs_trans_commit(tp, 0);
-}
-
-/*
  * We need to check that the format of the data fork in the temporary inode is
  * valid for the target inode before doing the swap. This is not a problem with
  * attr1 because of the fixed fork offset, but attr2 has a dynamically sized
diff --git a/fs/xfs/xfs_bmap_util.h b/fs/xfs/xfs_bmap_util.h
index 061260946f7a..900747b25772 100644
--- a/fs/xfs/xfs_bmap_util.h
+++ b/fs/xfs/xfs_bmap_util.h
@@ -93,9 +93,12 @@ int	xfs_bmap_last_extent(struct xfs_trans *tp, struct xfs_inode *ip,
                              int *is_empty);
 
 /* preallocation and hole punch interface */
-int     xfs_change_file_space(struct xfs_inode *ip, int cmd,
-                              xfs_flock64_t *bf, xfs_off_t offset,
-                              int attr_flags);
+int     xfs_alloc_file_space(struct xfs_inode *ip, xfs_off_t offset,
+                             xfs_off_t len, int alloc_type);
+int     xfs_free_file_space(struct xfs_inode *ip, xfs_off_t offset,
+                            xfs_off_t len);
+int     xfs_zero_file_space(struct xfs_inode *ip, xfs_off_t offset,
+                            xfs_off_t len);
 
 /* EOF block manipulation functions */
 bool    xfs_can_free_eofblocks(struct xfs_inode *ip, bool force);
diff --git a/fs/xfs/xfs_btree.c b/fs/xfs/xfs_btree.c
index 5690e102243d..9adaae4f3e2f 100644
--- a/fs/xfs/xfs_btree.c
+++ b/fs/xfs/xfs_btree.c
@@ -17,18 +17,16 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
 #include "xfs_buf_item.h"
 #include "xfs_btree.h"
diff --git a/fs/xfs/xfs_btree.h b/fs/xfs/xfs_btree.h
index 06729b67ad58..91e34f21bace 100644
--- a/fs/xfs/xfs_btree.h
+++ b/fs/xfs/xfs_btree.h
@@ -27,73 +27,6 @@ struct xfs_trans;
 extern kmem_zone_t      *xfs_btree_cur_zone;
 
 /*
- * This nonsense is to make -wlint happy.
- */
-#define XFS_LOOKUP_EQ   ((xfs_lookup_t)XFS_LOOKUP_EQi)
-#define XFS_LOOKUP_LE   ((xfs_lookup_t)XFS_LOOKUP_LEi)
-#define XFS_LOOKUP_GE   ((xfs_lookup_t)XFS_LOOKUP_GEi)
-
-#define XFS_BTNUM_BNO   ((xfs_btnum_t)XFS_BTNUM_BNOi)
-#define XFS_BTNUM_CNT   ((xfs_btnum_t)XFS_BTNUM_CNTi)
-#define XFS_BTNUM_BMAP  ((xfs_btnum_t)XFS_BTNUM_BMAPi)
-#define XFS_BTNUM_INO   ((xfs_btnum_t)XFS_BTNUM_INOi)
-
-/*
- * Generic btree header.
- *
- * This is a combination of the actual format used on disk for short and long
- * format btrees.  The first three fields are shared by both format, but the
- * pointers are different and should be used with care.
- *
- * To get the size of the actual short or long form headers please use the size
- * macros below.  Never use sizeof(xfs_btree_block).
- *
- * The blkno, crc, lsn, owner and uuid fields are only available in filesystems
- * with the crc feature bit, and all accesses to them must be conditional on
- * that flag.
- */
-struct xfs_btree_block {
-        __be32          bb_magic;       /* magic number for block type */
-        __be16          bb_level;       /* 0 is a leaf */
-        __be16          bb_numrecs;     /* current # of data records */
-        union {
-                struct {
-                        __be32          bb_leftsib;
-                        __be32          bb_rightsib;
-
-                        __be64          bb_blkno;
-                        __be64          bb_lsn;
-                        uuid_t          bb_uuid;
-                        __be32          bb_owner;
-                        __le32          bb_crc;
-                } s;                    /* short form pointers */
-                struct  {
-                        __be64          bb_leftsib;
-                        __be64          bb_rightsib;
-
-                        __be64          bb_blkno;
-                        __be64          bb_lsn;
-                        uuid_t          bb_uuid;
-                        __be64          bb_owner;
-                        __le32          bb_crc;
-                        __be32          bb_pad; /* padding for alignment */
-                } l;                    /* long form pointers */
-        } bb_u;                         /* rest */
-};
-
-#define XFS_BTREE_SBLOCK_LEN    16      /* size of a short form block */
-#define XFS_BTREE_LBLOCK_LEN    24      /* size of a long form block */
-
-/* sizes of CRC enabled btree blocks */
-#define XFS_BTREE_SBLOCK_CRC_LEN        (XFS_BTREE_SBLOCK_LEN + 40)
-#define XFS_BTREE_LBLOCK_CRC_LEN        (XFS_BTREE_LBLOCK_LEN + 48)
-
-#define XFS_BTREE_SBLOCK_CRC_OFF \
-        offsetof(struct xfs_btree_block, bb_u.s.bb_crc)
-#define XFS_BTREE_LBLOCK_CRC_OFF \
-        offsetof(struct xfs_btree_block, bb_u.l.bb_crc)
-
-/*
  * Generic key, ptr and record wrapper structures.
  *
  * These are disk format structures, and are converted where necessary
@@ -119,6 +52,18 @@ union xfs_btree_rec {
 };
 
 /*
+ * This nonsense is to make -wlint happy.
+ */
+#define XFS_LOOKUP_EQ   ((xfs_lookup_t)XFS_LOOKUP_EQi)
+#define XFS_LOOKUP_LE   ((xfs_lookup_t)XFS_LOOKUP_LEi)
+#define XFS_LOOKUP_GE   ((xfs_lookup_t)XFS_LOOKUP_GEi)
+
+#define XFS_BTNUM_BNO   ((xfs_btnum_t)XFS_BTNUM_BNOi)
+#define XFS_BTNUM_CNT   ((xfs_btnum_t)XFS_BTNUM_CNTi)
+#define XFS_BTNUM_BMAP  ((xfs_btnum_t)XFS_BTNUM_BMAPi)
+#define XFS_BTNUM_INO   ((xfs_btnum_t)XFS_BTNUM_INOi)
+
+/*
  * For logging record fields.
  */
 #define XFS_BB_MAGIC            (1 << 0)
diff --git a/fs/xfs/xfs_buf.c b/fs/xfs/xfs_buf.c
index 263470075ea2..c7f0b77dcb00 100644
--- a/fs/xfs/xfs_buf.c
+++ b/fs/xfs/xfs_buf.c
@@ -34,12 +34,13 @@
 #include <linux/backing-dev.h>
 #include <linux/freezer.h>
 
-#include "xfs_sb.h"
+#include "xfs_log_format.h"
 #include "xfs_trans_resv.h"
-#include "xfs_log.h"
+#include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
 #include "xfs_trace.h"
+#include "xfs_log.h"
 
 static kmem_zone_t *xfs_buf_zone;
 
@@ -590,7 +591,7 @@ found:
                 error = _xfs_buf_map_pages(bp, flags);
                 if (unlikely(error)) {
                         xfs_warn(target->bt_mount,
-                                "%s: failed to map pages\n", __func__);
+                                "%s: failed to map pagesn", __func__);
                         xfs_buf_relse(bp);
                         return NULL;
                 }
@@ -809,7 +810,7 @@ xfs_buf_get_uncached(
         error = _xfs_buf_map_pages(bp, 0);
         if (unlikely(error)) {
                 xfs_warn(target->bt_mount,
-                        "%s: failed to map pages\n", __func__);
+                        "%s: failed to map pages", __func__);
                 goto fail_free_mem;
         }
 
@@ -1618,7 +1619,7 @@ xfs_setsize_buftarg_flags(
                 bdevname(btp->bt_bdev, name);
 
                 xfs_warn(btp->bt_mount,
-                        "Cannot set_blocksize to %u on device %s\n",
+                        "Cannot set_blocksize to %u on device %s",
                         sectorsize, name);
                 return EINVAL;
         }
diff --git a/fs/xfs/xfs_buf_item.c b/fs/xfs/xfs_buf_item.c
index 88c5ea75ebf6..a64f67ba25d3 100644
--- a/fs/xfs/xfs_buf_item.c
+++ b/fs/xfs/xfs_buf_item.c
@@ -17,17 +17,18 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_trans.h"
 #include "xfs_buf_item.h"
 #include "xfs_trans_priv.h"
 #include "xfs_error.h"
 #include "xfs_trace.h"
+#include "xfs_log.h"
 
 
 kmem_zone_t     *xfs_buf_item_zone;
@@ -628,6 +629,7 @@ xfs_buf_item_unlock(
                 else if (aborted) {
                         ASSERT(XFS_FORCED_SHUTDOWN(lip->li_mountp));
                         if (lip->li_flags & XFS_LI_IN_AIL) {
+                                spin_lock(&lip->li_ailp->xa_lock);
                                 xfs_trans_ail_delete(lip->li_ailp, lip,
                                                      SHUTDOWN_LOG_IO_ERROR);
                         }
@@ -807,7 +809,7 @@ xfs_buf_item_init(
  * Mark bytes first through last inclusive as dirty in the buf
  * item's bitmap.
  */
-void
+static void
 xfs_buf_item_log_segment(
         struct xfs_buf_log_item *bip,
         uint                    first,
diff --git a/fs/xfs/xfs_buf_item.h b/fs/xfs/xfs_buf_item.h
index db6371087fe8..3f3455a41510 100644
--- a/fs/xfs/xfs_buf_item.h
+++ b/fs/xfs/xfs_buf_item.h
@@ -71,10 +71,6 @@ void	xfs_buf_attach_iodone(struct xfs_buf *,
 void    xfs_buf_iodone_callbacks(struct xfs_buf *);
 void    xfs_buf_iodone(struct xfs_buf *, struct xfs_log_item *);
 
-void    xfs_trans_buf_set_type(struct xfs_trans *, struct xfs_buf *,
-                               enum xfs_blft);
-void    xfs_trans_buf_copy_type(struct xfs_buf *dst_bp, struct xfs_buf *src_bp);
-
 extern kmem_zone_t      *xfs_buf_item_zone;
 
 #endif  /* __XFS_BUF_ITEM_H__ */
diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c
index 069537c845e5..796272a2e129 100644
--- a/fs/xfs/xfs_da_btree.c
+++ b/fs/xfs/xfs_da_btree.c
@@ -18,20 +18,20 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_da_format.h"
 #include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_dir2_format.h"
 #include "xfs_dir2.h"
 #include "xfs_dir2_priv.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
 #include "xfs_alloc.h"
 #include "xfs_bmap.h"
@@ -129,56 +129,6 @@ xfs_da_state_free(xfs_da_state_t *state)
         kmem_zone_free(xfs_da_state_zone, state);
 }
 
-void
-xfs_da3_node_hdr_from_disk(
-        struct xfs_da3_icnode_hdr       *to,
-        struct xfs_da_intnode           *from)
-{
-        ASSERT(from->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC) ||
-               from->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC));
-
-        if (from->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC)) {
-                struct xfs_da3_node_hdr *hdr3 = (struct xfs_da3_node_hdr *)from;
-
-                to->forw = be32_to_cpu(hdr3->info.hdr.forw);
-                to->back = be32_to_cpu(hdr3->info.hdr.back);
-                to->magic = be16_to_cpu(hdr3->info.hdr.magic);
-                to->count = be16_to_cpu(hdr3->__count);
-                to->level = be16_to_cpu(hdr3->__level);
-                return;
-        }
-        to->forw = be32_to_cpu(from->hdr.info.forw);
-        to->back = be32_to_cpu(from->hdr.info.back);
-        to->magic = be16_to_cpu(from->hdr.info.magic);
-        to->count = be16_to_cpu(from->hdr.__count);
-        to->level = be16_to_cpu(from->hdr.__level);
-}
-
-void
-xfs_da3_node_hdr_to_disk(
-        struct xfs_da_intnode           *to,
-        struct xfs_da3_icnode_hdr       *from)
-{
-        ASSERT(from->magic == XFS_DA_NODE_MAGIC ||
-               from->magic == XFS_DA3_NODE_MAGIC);
-
-        if (from->magic == XFS_DA3_NODE_MAGIC) {
-                struct xfs_da3_node_hdr *hdr3 = (struct xfs_da3_node_hdr *)to;
-
-                hdr3->info.hdr.forw = cpu_to_be32(from->forw);
-                hdr3->info.hdr.back = cpu_to_be32(from->back);
-                hdr3->info.hdr.magic = cpu_to_be16(from->magic);
-                hdr3->__count = cpu_to_be16(from->count);
-                hdr3->__level = cpu_to_be16(from->level);
-                return;
-        }
-        to->hdr.info.forw = cpu_to_be32(from->forw);
-        to->hdr.info.back = cpu_to_be32(from->back);
-        to->hdr.info.magic = cpu_to_be16(from->magic);
-        to->hdr.__count = cpu_to_be16(from->count);
-        to->hdr.__level = cpu_to_be16(from->level);
-}
-
 static bool
 xfs_da3_node_verify(
         struct xfs_buf          *bp)
@@ -186,8 +136,11 @@ xfs_da3_node_verify(
         struct xfs_mount        *mp = bp->b_target->bt_mount;
         struct xfs_da_intnode   *hdr = bp->b_addr;
         struct xfs_da3_icnode_hdr ichdr;
+        const struct xfs_dir_ops *ops;
 
-        xfs_da3_node_hdr_from_disk(&ichdr, hdr);
+        ops = xfs_dir_get_ops(mp, NULL);
+
+        ops->node_hdr_from_disk(&ichdr, hdr);
 
         if (xfs_sb_version_hascrc(&mp->m_sb)) {
                 struct xfs_da3_node_hdr *hdr3 = bp->b_addr;
@@ -354,11 +307,12 @@ xfs_da3_node_create(
         struct xfs_da3_icnode_hdr ichdr = {0};
         struct xfs_buf          *bp;
         int                     error;
+        struct xfs_inode        *dp = args->dp;
 
         trace_xfs_da_node_create(args);
         ASSERT(level <= XFS_DA_NODE_MAXDEPTH);
 
-        error = xfs_da_get_buf(tp, args->dp, blkno, -1, &bp, whichfork);
+        error = xfs_da_get_buf(tp, dp, blkno, -1, &bp, whichfork);
         if (error)
                 return(error);
         bp->b_ops = &xfs_da3_node_buf_ops;
@@ -377,9 +331,9 @@ xfs_da3_node_create(
         }
         ichdr.level = level;
 
-        xfs_da3_node_hdr_to_disk(node, &ichdr);
+        dp->d_ops->node_hdr_to_disk(node, &ichdr);
         xfs_trans_log_buf(tp, bp,
-                XFS_DA_LOGRANGE(node, &node->hdr, xfs_da3_node_hdr_size(node)));
+                XFS_DA_LOGRANGE(node, &node->hdr, dp->d_ops->node_hdr_size));
 
         *bpp = bp;
         return(0);
@@ -589,8 +543,8 @@ xfs_da3_root_split(
             oldroot->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC)) {
                 struct xfs_da3_icnode_hdr nodehdr;
 
-                xfs_da3_node_hdr_from_disk(&nodehdr, oldroot);
-                btree = xfs_da3_node_tree_p(oldroot);
+                dp->d_ops->node_hdr_from_disk(&nodehdr, oldroot);
+                btree = dp->d_ops->node_tree_p(oldroot);
                 size = (int)((char *)&btree[nodehdr.count] - (char *)oldroot);
                 level = nodehdr.level;
 
@@ -604,8 +558,8 @@ xfs_da3_root_split(
                 struct xfs_dir2_leaf_entry *ents;
 
                 leaf = (xfs_dir2_leaf_t *)oldroot;
-                xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
-                ents = xfs_dir3_leaf_ents_p(leaf);
+                dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
+                ents = dp->d_ops->leaf_ents_p(leaf);
 
                 ASSERT(leafhdr.magic == XFS_DIR2_LEAFN_MAGIC ||
                        leafhdr.magic == XFS_DIR3_LEAFN_MAGIC);
@@ -649,14 +603,14 @@ xfs_da3_root_split(
                 return error;
 
         node = bp->b_addr;
-        xfs_da3_node_hdr_from_disk(&nodehdr, node);
-        btree = xfs_da3_node_tree_p(node);
+        dp->d_ops->node_hdr_from_disk(&nodehdr, node);
+        btree = dp->d_ops->node_tree_p(node);
         btree[0].hashval = cpu_to_be32(blk1->hashval);
         btree[0].before = cpu_to_be32(blk1->blkno);
         btree[1].hashval = cpu_to_be32(blk2->hashval);
         btree[1].before = cpu_to_be32(blk2->blkno);
         nodehdr.count = 2;
-        xfs_da3_node_hdr_to_disk(node, &nodehdr);
+        dp->d_ops->node_hdr_to_disk(node, &nodehdr);
 
 #ifdef DEBUG
         if (oldroot->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
@@ -693,11 +647,12 @@ xfs_da3_node_split(
         int                     newcount;
         int                     error;
         int                     useextra;
+        struct xfs_inode        *dp = state->args->dp;
 
         trace_xfs_da_node_split(state->args);
 
         node = oldblk->bp->b_addr;
-        xfs_da3_node_hdr_from_disk(&nodehdr, node);
+        dp->d_ops->node_hdr_from_disk(&nodehdr, node);
 
         /*
          * With V2 dirs the extra block is data or freespace.
@@ -744,7 +699,7 @@ xfs_da3_node_split(
          * If we had double-split op below us, then add the extra block too.
          */
         node = oldblk->bp->b_addr;
-        xfs_da3_node_hdr_from_disk(&nodehdr, node);
+        dp->d_ops->node_hdr_from_disk(&nodehdr, node);
         if (oldblk->index <= nodehdr.count) {
                 oldblk->index++;
                 xfs_da3_node_add(state, oldblk, addblk);
@@ -793,15 +748,16 @@ xfs_da3_node_rebalance(
         int                     count;
         int                     tmp;
         int                     swap = 0;
+        struct xfs_inode        *dp = state->args->dp;
 
         trace_xfs_da_node_rebalance(state->args);
 
         node1 = blk1->bp->b_addr;
         node2 = blk2->bp->b_addr;
-        xfs_da3_node_hdr_from_disk(&nodehdr1, node1);
-        xfs_da3_node_hdr_from_disk(&nodehdr2, node2);
-        btree1 = xfs_da3_node_tree_p(node1);
-        btree2 = xfs_da3_node_tree_p(node2);
+        dp->d_ops->node_hdr_from_disk(&nodehdr1, node1);
+        dp->d_ops->node_hdr_from_disk(&nodehdr2, node2);
+        btree1 = dp->d_ops->node_tree_p(node1);
+        btree2 = dp->d_ops->node_tree_p(node2);
 
         /*
          * Figure out how many entries need to move, and in which direction.
@@ -814,10 +770,10 @@ xfs_da3_node_rebalance(
                 tmpnode = node1;
                 node1 = node2;
                 node2 = tmpnode;
-                xfs_da3_node_hdr_from_disk(&nodehdr1, node1);
-                xfs_da3_node_hdr_from_disk(&nodehdr2, node2);
-                btree1 = xfs_da3_node_tree_p(node1);
-                btree2 = xfs_da3_node_tree_p(node2);
+                dp->d_ops->node_hdr_from_disk(&nodehdr1, node1);
+                dp->d_ops->node_hdr_from_disk(&nodehdr2, node2);
+                btree1 = dp->d_ops->node_tree_p(node1);
+                btree2 = dp->d_ops->node_tree_p(node2);
                 swap = 1;
         }
 
@@ -879,15 +835,14 @@ xfs_da3_node_rebalance(
         /*
          * Log header of node 1 and all current bits of node 2.
          */
-        xfs_da3_node_hdr_to_disk(node1, &nodehdr1);
+        dp->d_ops->node_hdr_to_disk(node1, &nodehdr1);
         xfs_trans_log_buf(tp, blk1->bp,
-                XFS_DA_LOGRANGE(node1, &node1->hdr,
-                                xfs_da3_node_hdr_size(node1)));
+                XFS_DA_LOGRANGE(node1, &node1->hdr, dp->d_ops->node_hdr_size));
 
-        xfs_da3_node_hdr_to_disk(node2, &nodehdr2);
+        dp->d_ops->node_hdr_to_disk(node2, &nodehdr2);
         xfs_trans_log_buf(tp, blk2->bp,
                 XFS_DA_LOGRANGE(node2, &node2->hdr,
-                                xfs_da3_node_hdr_size(node2) +
+                                dp->d_ops->node_hdr_size +
                                 (sizeof(btree2[0]) * nodehdr2.count)));
 
         /*
@@ -897,10 +852,10 @@ xfs_da3_node_rebalance(
         if (swap) {
                 node1 = blk1->bp->b_addr;
                 node2 = blk2->bp->b_addr;
-                xfs_da3_node_hdr_from_disk(&nodehdr1, node1);
-                xfs_da3_node_hdr_from_disk(&nodehdr2, node2);
-                btree1 = xfs_da3_node_tree_p(node1);
-                btree2 = xfs_da3_node_tree_p(node2);
+                dp->d_ops->node_hdr_from_disk(&nodehdr1, node1);
+                dp->d_ops->node_hdr_from_disk(&nodehdr2, node2);
+                btree1 = dp->d_ops->node_tree_p(node1);
+                btree2 = dp->d_ops->node_tree_p(node2);
         }
         blk1->hashval = be32_to_cpu(btree1[nodehdr1.count - 1].hashval);
         blk2->hashval = be32_to_cpu(btree2[nodehdr2.count - 1].hashval);
@@ -927,12 +882,13 @@ xfs_da3_node_add(
         struct xfs_da3_icnode_hdr nodehdr;
         struct xfs_da_node_entry *btree;
         int                     tmp;
+        struct xfs_inode        *dp = state->args->dp;
 
         trace_xfs_da_node_add(state->args);
 
         node = oldblk->bp->b_addr;
-        xfs_da3_node_hdr_from_disk(&nodehdr, node);
-        btree = xfs_da3_node_tree_p(node);
+        dp->d_ops->node_hdr_from_disk(&nodehdr, node);
+        btree = dp->d_ops->node_tree_p(node);
 
         ASSERT(oldblk->index >= 0 && oldblk->index <= nodehdr.count);
         ASSERT(newblk->blkno != 0);
@@ -955,9 +911,9 @@ xfs_da3_node_add(
                                 tmp + sizeof(*btree)));
 
         nodehdr.count += 1;
-        xfs_da3_node_hdr_to_disk(node, &nodehdr);
+        dp->d_ops->node_hdr_to_disk(node, &nodehdr);
         xfs_trans_log_buf(state->args->trans, oldblk->bp,
-                XFS_DA_LOGRANGE(node, &node->hdr, xfs_da3_node_hdr_size(node)));
+                XFS_DA_LOGRANGE(node, &node->hdr, dp->d_ops->node_hdr_size));
 
         /*
          * Copy the last hash value from the oldblk to propagate upwards.
@@ -1094,6 +1050,7 @@ xfs_da3_root_join(
         struct xfs_da3_icnode_hdr oldroothdr;
         struct xfs_da_node_entry *btree;
         int                     error;
+        struct xfs_inode        *dp = state->args->dp;
 
         trace_xfs_da_root_join(state->args);
 
@@ -1101,7 +1058,7 @@ xfs_da3_root_join(
 
         args = state->args;
         oldroot = root_blk->bp->b_addr;
-        xfs_da3_node_hdr_from_disk(&oldroothdr, oldroot);
+        dp->d_ops->node_hdr_from_disk(&oldroothdr, oldroot);
         ASSERT(oldroothdr.forw == 0);
         ASSERT(oldroothdr.back == 0);
 
@@ -1115,10 +1072,10 @@ xfs_da3_root_join(
          * Read in the (only) child block, then copy those bytes into
          * the root block's buffer and free the original child block.
          */
-        btree = xfs_da3_node_tree_p(oldroot);
+        btree = dp->d_ops->node_tree_p(oldroot);
         child = be32_to_cpu(btree[0].before);
         ASSERT(child != 0);
-        error = xfs_da3_node_read(args->trans, args->dp, child, -1, &bp,
+        error = xfs_da3_node_read(args->trans, dp, child, -1, &bp,
                                              args->whichfork);
         if (error)
                 return error;
@@ -1168,6 +1125,7 @@ xfs_da3_node_toosmall(
         int                     error;
         int                     retval;
         int                     i;
+        struct xfs_inode        *dp = state->args->dp;
 
         trace_xfs_da_node_toosmall(state->args);
 
@@ -1179,7 +1137,7 @@ xfs_da3_node_toosmall(
         blk = &state->path.blk[ state->path.active-1 ];
         info = blk->bp->b_addr;
         node = (xfs_da_intnode_t *)info;
-        xfs_da3_node_hdr_from_disk(&nodehdr, node);
+        dp->d_ops->node_hdr_from_disk(&nodehdr, node);
         if (nodehdr.count > (state->node_ents >> 1)) {
                 *action = 0;    /* blk over 50%, don't try to join */
                 return(0);      /* blk over 50%, don't try to join */
@@ -1224,22 +1182,23 @@ xfs_da3_node_toosmall(
         /* start with smaller blk num */
         forward = nodehdr.forw < nodehdr.back;
         for (i = 0; i < 2; forward = !forward, i++) {
+                struct xfs_da3_icnode_hdr thdr;
                 if (forward)
                         blkno = nodehdr.forw;
                 else
                         blkno = nodehdr.back;
                 if (blkno == 0)
                         continue;
-                error = xfs_da3_node_read(state->args->trans, state->args->dp,
+                error = xfs_da3_node_read(state->args->trans, dp,
                                         blkno, -1, &bp, state->args->whichfork);
                 if (error)
                         return(error);
 
                 node = bp->b_addr;
-                xfs_da3_node_hdr_from_disk(&nodehdr, node);
+                dp->d_ops->node_hdr_from_disk(&thdr, node);
                 xfs_trans_brelse(state->args->trans, bp);
 
-                if (count - nodehdr.count >= 0)
+                if (count - thdr.count >= 0)
                         break;  /* fits with at least 25% to spare */
         }
         if (i >= 2) {
@@ -1274,6 +1233,7 @@ xfs_da3_node_toosmall(
  */
 STATIC uint
 xfs_da3_node_lasthash(
+        struct xfs_inode        *dp,
         struct xfs_buf          *bp,
         int                     *count)
 {
@@ -1282,12 +1242,12 @@ xfs_da3_node_lasthash(
         struct xfs_da3_icnode_hdr nodehdr;
 
         node = bp->b_addr;
-        xfs_da3_node_hdr_from_disk(&nodehdr, node);
+        dp->d_ops->node_hdr_from_disk(&nodehdr, node);
         if (count)
                 *count = nodehdr.count;
         if (!nodehdr.count)
                 return 0;
-        btree = xfs_da3_node_tree_p(node);
+        btree = dp->d_ops->node_tree_p(node);
         return be32_to_cpu(btree[nodehdr.count - 1].hashval);
 }
 
@@ -1306,6 +1266,7 @@ xfs_da3_fixhashpath(
         xfs_dahash_t            lasthash=0;
         int                     level;
         int                     count;
+        struct xfs_inode        *dp = state->args->dp;
 
         trace_xfs_da_fixhashpath(state->args);
 
@@ -1318,12 +1279,12 @@ xfs_da3_fixhashpath(
                         return;
                 break;
         case XFS_DIR2_LEAFN_MAGIC:
-                lasthash = xfs_dir2_leafn_lasthash(blk->bp, &count);
+                lasthash = xfs_dir2_leafn_lasthash(dp, blk->bp, &count);
                 if (count == 0)
                         return;
                 break;
         case XFS_DA_NODE_MAGIC:
-                lasthash = xfs_da3_node_lasthash(blk->bp, &count);
+                lasthash = xfs_da3_node_lasthash(dp, blk->bp, &count);
                 if (count == 0)
                         return;
                 break;
@@ -1332,8 +1293,8 @@ xfs_da3_fixhashpath(
                 struct xfs_da3_icnode_hdr nodehdr;
 
                 node = blk->bp->b_addr;
-                xfs_da3_node_hdr_from_disk(&nodehdr, node);
-                btree = xfs_da3_node_tree_p(node);
+                dp->d_ops->node_hdr_from_disk(&nodehdr, node);
+                btree = dp->d_ops->node_tree_p(node);
                 if (be32_to_cpu(btree->hashval) == lasthash)
                         break;
                 blk->hashval = lasthash;
@@ -1359,11 +1320,12 @@ xfs_da3_node_remove(
         struct xfs_da_node_entry *btree;
         int                     index;
         int                     tmp;
+        struct xfs_inode        *dp = state->args->dp;
 
         trace_xfs_da_node_remove(state->args);
 
         node = drop_blk->bp->b_addr;
-        xfs_da3_node_hdr_from_disk(&nodehdr, node);
+        dp->d_ops->node_hdr_from_disk(&nodehdr, node);
         ASSERT(drop_blk->index < nodehdr.count);
         ASSERT(drop_blk->index >= 0);
 
@@ -1371,7 +1333,7 @@ xfs_da3_node_remove(
          * Copy over the offending entry, or just zero it out.
          */
         index = drop_blk->index;
-        btree = xfs_da3_node_tree_p(node);
+        btree = dp->d_ops->node_tree_p(node);
         if (index < nodehdr.count - 1) {
                 tmp  = nodehdr.count - index - 1;
                 tmp *= (uint)sizeof(xfs_da_node_entry_t);
@@ -1384,9 +1346,9 @@ xfs_da3_node_remove(
         xfs_trans_log_buf(state->args->trans, drop_blk->bp,
             XFS_DA_LOGRANGE(node, &btree[index], sizeof(btree[index])));
         nodehdr.count -= 1;
-        xfs_da3_node_hdr_to_disk(node, &nodehdr);
+        dp->d_ops->node_hdr_to_disk(node, &nodehdr);
         xfs_trans_log_buf(state->args->trans, drop_blk->bp,
-            XFS_DA_LOGRANGE(node, &node->hdr, xfs_da3_node_hdr_size(node)));
+            XFS_DA_LOGRANGE(node, &node->hdr, dp->d_ops->node_hdr_size));
 
         /*
          * Copy the last hash value from the block to propagate upwards.
@@ -1413,15 +1375,16 @@ xfs_da3_node_unbalance(
         struct xfs_trans        *tp;
         int                     sindex;
         int                     tmp;
+        struct xfs_inode        *dp = state->args->dp;
 
         trace_xfs_da_node_unbalance(state->args);
 
         drop_node = drop_blk->bp->b_addr;
         save_node = save_blk->bp->b_addr;
-        xfs_da3_node_hdr_from_disk(&drop_hdr, drop_node);
-        xfs_da3_node_hdr_from_disk(&save_hdr, save_node);
-        drop_btree = xfs_da3_node_tree_p(drop_node);
-        save_btree = xfs_da3_node_tree_p(save_node);
+        dp->d_ops->node_hdr_from_disk(&drop_hdr, drop_node);
+        dp->d_ops->node_hdr_from_disk(&save_hdr, save_node);
+        drop_btree = dp->d_ops->node_tree_p(drop_node);
+        save_btree = dp->d_ops->node_tree_p(save_node);
         tp = state->args->trans;
 
         /*
@@ -1455,10 +1418,10 @@ xfs_da3_node_unbalance(
         memcpy(&save_btree[sindex], &drop_btree[0], tmp);
         save_hdr.count += drop_hdr.count;
 
-        xfs_da3_node_hdr_to_disk(save_node, &save_hdr);
+        dp->d_ops->node_hdr_to_disk(save_node, &save_hdr);
         xfs_trans_log_buf(tp, save_blk->bp,
                 XFS_DA_LOGRANGE(save_node, &save_node->hdr,
-                                xfs_da3_node_hdr_size(save_node)));
+                                dp->d_ops->node_hdr_size));
 
         /*
          * Save the last hashval in the remaining block for upward propagation.
@@ -1500,6 +1463,7 @@ xfs_da3_node_lookup_int(
         int                     max;
         int                     error;
         int                     retval;
+        struct xfs_inode        *dp = state->args->dp;
 
         args = state->args;
 
@@ -1535,7 +1499,8 @@ xfs_da3_node_lookup_int(
                 if (blk->magic == XFS_DIR2_LEAFN_MAGIC ||
                     blk->magic == XFS_DIR3_LEAFN_MAGIC) {
                         blk->magic = XFS_DIR2_LEAFN_MAGIC;
-                        blk->hashval = xfs_dir2_leafn_lasthash(blk->bp, NULL);
+                        blk->hashval = xfs_dir2_leafn_lasthash(args->dp,
+                                                               blk->bp, NULL);
                         break;
                 }
 
@@ -1546,8 +1511,8 @@ xfs_da3_node_lookup_int(
                  * Search an intermediate node for a match.
                  */
                 node = blk->bp->b_addr;
-                xfs_da3_node_hdr_from_disk(&nodehdr, node);
-                btree = xfs_da3_node_tree_p(node);
+                dp->d_ops->node_hdr_from_disk(&nodehdr, node);
+                btree = dp->d_ops->node_tree_p(node);
 
                 max = nodehdr.count;
                 blk->hashval = be32_to_cpu(btree[max - 1].hashval);
@@ -1642,6 +1607,7 @@ xfs_da3_node_lookup_int(
  */
 STATIC int
 xfs_da3_node_order(
+        struct xfs_inode *dp,
         struct xfs_buf  *node1_bp,
         struct xfs_buf  *node2_bp)
 {
@@ -1654,10 +1620,10 @@ xfs_da3_node_order(
 
         node1 = node1_bp->b_addr;
         node2 = node2_bp->b_addr;
-        xfs_da3_node_hdr_from_disk(&node1hdr, node1);
-        xfs_da3_node_hdr_from_disk(&node2hdr, node2);
-        btree1 = xfs_da3_node_tree_p(node1);
-        btree2 = xfs_da3_node_tree_p(node2);
+        dp->d_ops->node_hdr_from_disk(&node1hdr, node1);
+        dp->d_ops->node_hdr_from_disk(&node2hdr, node2);
+        btree1 = dp->d_ops->node_tree_p(node1);
+        btree2 = dp->d_ops->node_tree_p(node2);
 
         if (node1hdr.count > 0 && node2hdr.count > 0 &&
             ((be32_to_cpu(btree2[0].hashval) < be32_to_cpu(btree1[0].hashval)) ||
@@ -1684,6 +1650,7 @@ xfs_da3_blk_link(
         struct xfs_buf          *bp;
         int                     before = 0;
         int                     error;
+        struct xfs_inode        *dp = state->args->dp;
 
         /*
          * Set up environment.
@@ -1701,10 +1668,10 @@ xfs_da3_blk_link(
                 before = xfs_attr_leaf_order(old_blk->bp, new_blk->bp);
                 break;
         case XFS_DIR2_LEAFN_MAGIC:
-                before = xfs_dir2_leafn_order(old_blk->bp, new_blk->bp);
+                before = xfs_dir2_leafn_order(dp, old_blk->bp, new_blk->bp);
                 break;
         case XFS_DA_NODE_MAGIC:
-                before = xfs_da3_node_order(old_blk->bp, new_blk->bp);
+                before = xfs_da3_node_order(dp, old_blk->bp, new_blk->bp);
                 break;
         }
 
@@ -1719,7 +1686,7 @@ xfs_da3_blk_link(
                 new_info->forw = cpu_to_be32(old_blk->blkno);
                 new_info->back = old_info->back;
                 if (old_info->back) {
-                        error = xfs_da3_node_read(args->trans, args->dp,
+                        error = xfs_da3_node_read(args->trans, dp,
                                                 be32_to_cpu(old_info->back),
                                                 -1, &bp, args->whichfork);
                         if (error)
@@ -1740,7 +1707,7 @@ xfs_da3_blk_link(
                 new_info->forw = old_info->forw;
                 new_info->back = cpu_to_be32(old_blk->blkno);
                 if (old_info->forw) {
-                        error = xfs_da3_node_read(args->trans, args->dp,
+                        error = xfs_da3_node_read(args->trans, dp,
                                                 be32_to_cpu(old_info->forw),
                                                 -1, &bp, args->whichfork);
                         if (error)
@@ -1860,6 +1827,7 @@ xfs_da3_path_shift(
         xfs_dablk_t             blkno = 0;
         int                     level;
         int                     error;
+        struct xfs_inode        *dp = state->args->dp;
 
         trace_xfs_da_path_shift(state->args);
 
@@ -1875,8 +1843,8 @@ xfs_da3_path_shift(
         level = (path->active-1) - 1;   /* skip bottom layer in path */
         for (blk = &path->blk[level]; level >= 0; blk--, level--) {
                 node = blk->bp->b_addr;
-                xfs_da3_node_hdr_from_disk(&nodehdr, node);
-                btree = xfs_da3_node_tree_p(node);
+                dp->d_ops->node_hdr_from_disk(&nodehdr, node);
+                btree = dp->d_ops->node_tree_p(node);
 
                 if (forward && (blk->index < nodehdr.count - 1)) {
                         blk->index++;
@@ -1910,7 +1878,7 @@ xfs_da3_path_shift(
                  * Read the next child block.
                  */
                 blk->blkno = blkno;
-                error = xfs_da3_node_read(args->trans, args->dp, blkno, -1,
+                error = xfs_da3_node_read(args->trans, dp, blkno, -1,
                                         &blk->bp, args->whichfork);
                 if (error)
                         return(error);
@@ -1932,8 +1900,8 @@ xfs_da3_path_shift(
                 case XFS_DA3_NODE_MAGIC:
                         blk->magic = XFS_DA_NODE_MAGIC;
                         node = (xfs_da_intnode_t *)info;
-                        xfs_da3_node_hdr_from_disk(&nodehdr, node);
-                        btree = xfs_da3_node_tree_p(node);
+                        dp->d_ops->node_hdr_from_disk(&nodehdr, node);
+                        btree = dp->d_ops->node_tree_p(node);
                         blk->hashval = be32_to_cpu(btree[nodehdr.count - 1].hashval);
                         if (forward)
                                 blk->index = 0;
@@ -1946,16 +1914,15 @@ xfs_da3_path_shift(
                         blk->magic = XFS_ATTR_LEAF_MAGIC;
                         ASSERT(level == path->active-1);
                         blk->index = 0;
-                        blk->hashval = xfs_attr_leaf_lasthash(blk->bp,
-                                                              NULL);
+                        blk->hashval = xfs_attr_leaf_lasthash(blk->bp, NULL);
                         break;
                 case XFS_DIR2_LEAFN_MAGIC:
                 case XFS_DIR3_LEAFN_MAGIC:
                         blk->magic = XFS_DIR2_LEAFN_MAGIC;
                         ASSERT(level == path->active-1);
                         blk->index = 0;
-                        blk->hashval = xfs_dir2_leafn_lasthash(blk->bp,
-                                                               NULL);
+                        blk->hashval = xfs_dir2_leafn_lasthash(args->dp,
+                                                               blk->bp, NULL);
                         break;
                 default:
                         ASSERT(0);
@@ -2162,7 +2129,7 @@ xfs_da3_swap_lastblock(
         struct xfs_dir2_leaf    *dead_leaf2;
         struct xfs_da_node_entry *btree;
         struct xfs_da3_icnode_hdr par_hdr;
-        struct xfs_inode        *ip;
+        struct xfs_inode        *dp;
         struct xfs_trans        *tp;
         struct xfs_mount        *mp;
         struct xfs_buf          *dead_buf;
@@ -2186,12 +2153,12 @@ xfs_da3_swap_lastblock(
         dead_buf = *dead_bufp;
         dead_blkno = *dead_blknop;
         tp = args->trans;
-        ip = args->dp;
+        dp = args->dp;
         w = args->whichfork;
         ASSERT(w == XFS_DATA_FORK);
-        mp = ip->i_mount;
+        mp = dp->i_mount;
         lastoff = mp->m_dirfreeblk;
-        error = xfs_bmap_last_before(tp, ip, &lastoff, w);
+        error = xfs_bmap_last_before(tp, dp, &lastoff, w);
         if (error)
                 return error;
         if (unlikely(lastoff == 0)) {
@@ -2203,7 +2170,7 @@ xfs_da3_swap_lastblock(
          * Read the last block in the btree space.
          */
         last_blkno = (xfs_dablk_t)lastoff - mp->m_dirblkfsbs;
-        error = xfs_da3_node_read(tp, ip, last_blkno, -1, &last_buf, w);
+        error = xfs_da3_node_read(tp, dp, last_blkno, -1, &last_buf, w);
         if (error)
                 return error;
         /*
@@ -2221,16 +2188,16 @@ xfs_da3_swap_lastblock(
                 struct xfs_dir2_leaf_entry *ents;
 
                 dead_leaf2 = (xfs_dir2_leaf_t *)dead_info;
-                xfs_dir3_leaf_hdr_from_disk(&leafhdr, dead_leaf2);
-                ents = xfs_dir3_leaf_ents_p(dead_leaf2);
+                dp->d_ops->leaf_hdr_from_disk(&leafhdr, dead_leaf2);
+                ents = dp->d_ops->leaf_ents_p(dead_leaf2);
                 dead_level = 0;
                 dead_hash = be32_to_cpu(ents[leafhdr.count - 1].hashval);
         } else {
                 struct xfs_da3_icnode_hdr deadhdr;
 
                 dead_node = (xfs_da_intnode_t *)dead_info;
-                xfs_da3_node_hdr_from_disk(&deadhdr, dead_node);
-                btree = xfs_da3_node_tree_p(dead_node);
+                dp->d_ops->node_hdr_from_disk(&deadhdr, dead_node);
+                btree = dp->d_ops->node_tree_p(dead_node);
                 dead_level = deadhdr.level;
                 dead_hash = be32_to_cpu(btree[deadhdr.count - 1].hashval);
         }
@@ -2239,7 +2206,7 @@ xfs_da3_swap_lastblock(
          * If the moved block has a left sibling, fix up the pointers.
          */
         if ((sib_blkno = be32_to_cpu(dead_info->back))) {
-                error = xfs_da3_node_read(tp, ip, sib_blkno, -1, &sib_buf, w);
+                error = xfs_da3_node_read(tp, dp, sib_blkno, -1, &sib_buf, w);
                 if (error)
                         goto done;
                 sib_info = sib_buf->b_addr;
@@ -2261,7 +2228,7 @@ xfs_da3_swap_lastblock(
          * If the moved block has a right sibling, fix up the pointers.
          */
         if ((sib_blkno = be32_to_cpu(dead_info->forw))) {
-                error = xfs_da3_node_read(tp, ip, sib_blkno, -1, &sib_buf, w);
+                error = xfs_da3_node_read(tp, dp, sib_blkno, -1, &sib_buf, w);
                 if (error)
                         goto done;
                 sib_info = sib_buf->b_addr;
@@ -2285,11 +2252,11 @@ xfs_da3_swap_lastblock(
          * Walk down the tree looking for the parent of the moved block.
          */
         for (;;) {
-                error = xfs_da3_node_read(tp, ip, par_blkno, -1, &par_buf, w);
+                error = xfs_da3_node_read(tp, dp, par_blkno, -1, &par_buf, w);
                 if (error)
                         goto done;
                 par_node = par_buf->b_addr;
-                xfs_da3_node_hdr_from_disk(&par_hdr, par_node);
+                dp->d_ops->node_hdr_from_disk(&par_hdr, par_node);
                 if (level >= 0 && level != par_hdr.level + 1) {
                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(4)",
                                          XFS_ERRLEVEL_LOW, mp);
@@ -2297,7 +2264,7 @@ xfs_da3_swap_lastblock(
                         goto done;
                 }
                 level = par_hdr.level;
-                btree = xfs_da3_node_tree_p(par_node);
+                btree = dp->d_ops->node_tree_p(par_node);
                 for (entno = 0;
                      entno < par_hdr.count &&
                      be32_to_cpu(btree[entno].hashval) < dead_hash;
@@ -2336,18 +2303,18 @@ xfs_da3_swap_lastblock(
                         error = XFS_ERROR(EFSCORRUPTED);
                         goto done;
                 }
-                error = xfs_da3_node_read(tp, ip, par_blkno, -1, &par_buf, w);
+                error = xfs_da3_node_read(tp, dp, par_blkno, -1, &par_buf, w);
                 if (error)
                         goto done;
                 par_node = par_buf->b_addr;
-                xfs_da3_node_hdr_from_disk(&par_hdr, par_node);
+                dp->d_ops->node_hdr_from_disk(&par_hdr, par_node);
                 if (par_hdr.level != level) {
                         XFS_ERROR_REPORT("xfs_da_swap_lastblock(7)",
                                          XFS_ERRLEVEL_LOW, mp);
                         error = XFS_ERROR(EFSCORRUPTED);
                         goto done;
                 }
-                btree = xfs_da3_node_tree_p(par_node);
+                btree = dp->d_ops->node_tree_p(par_node);
                 entno = 0;
         }
         /*
diff --git a/fs/xfs/xfs_da_btree.h b/fs/xfs/xfs_da_btree.h
index b1f267995dea..6e95ea79f5d7 100644
--- a/fs/xfs/xfs_da_btree.h
+++ b/fs/xfs/xfs_da_btree.h
@@ -23,146 +23,7 @@ struct xfs_bmap_free;
 struct xfs_inode;
 struct xfs_trans;
 struct zone;
-
-/*========================================================================
- * Directory Structure when greater than XFS_LBSIZE(mp) bytes.
- *========================================================================*/
-
-/*
- * This structure is common to both leaf nodes and non-leaf nodes in the Btree.
- *
- * It is used to manage a doubly linked list of all blocks at the same
- * 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_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 */
-
-typedef struct xfs_da_blkinfo {
-        __be32          forw;                   /* previous block in list */
-        __be32          back;                   /* following block in list */
-        __be16          magic;                  /* validity check on block */
-        __be16          pad;                    /* unused */
-} xfs_da_blkinfo_t;
-
-/*
- * CRC enabled directory structure types
- *
- * The headers change size for the additional verification information, but
- * otherwise the tree layouts and contents are unchanged. Hence the da btree
- * code can use the struct xfs_da_blkinfo for manipulating the tree links and
- * magic numbers without modification for both v2 and v3 nodes.
- */
-#define XFS_DA3_NODE_MAGIC      0x3ebe  /* magic number: non-leaf blocks */
-#define XFS_ATTR3_LEAF_MAGIC    0x3bee  /* magic number: attribute leaf blks */
-#define XFS_DIR3_LEAF1_MAGIC    0x3df1  /* magic number: v2 dirlf single blks */
-#define XFS_DIR3_LEAFN_MAGIC    0x3dff  /* magic number: v2 dirlf multi blks */
-
-struct xfs_da3_blkinfo {
-        /*
-         * the node link manipulation code relies on the fact that the first
-         * element of this structure is the struct xfs_da_blkinfo so it can
-         * ignore the differences in the rest of the structures.
-         */
-        struct xfs_da_blkinfo   hdr;
-        __be32                  crc;    /* CRC of block */
-        __be64                  blkno;  /* first block of the buffer */
-        __be64                  lsn;    /* sequence number of last write */
-        uuid_t                  uuid;   /* filesystem we belong to */
-        __be64                  owner;  /* inode that owns the block */
-};
-
-/*
- * This is the structure of the root and intermediate nodes in the Btree.
- * The leaf nodes are defined above.
- *
- * Entries are not packed.
- *
- * Since we have duplicate keys, use a binary search but always follow
- * all match in the block, not just the first match found.
- */
-#define XFS_DA_NODE_MAXDEPTH    5       /* max depth of Btree */
-
-typedef struct xfs_da_node_hdr {
-        struct xfs_da_blkinfo   info;   /* block type, links, etc. */
-        __be16                  __count; /* count of active entries */
-        __be16                  __level; /* level above leaves (leaf == 0) */
-} xfs_da_node_hdr_t;
-
-struct xfs_da3_node_hdr {
-        struct xfs_da3_blkinfo  info;   /* block type, links, etc. */
-        __be16                  __count; /* count of active entries */
-        __be16                  __level; /* level above leaves (leaf == 0) */
-        __be32                  __pad32;
-};
-
-#define XFS_DA3_NODE_CRC_OFF    (offsetof(struct xfs_da3_node_hdr, info.crc))
-
-typedef struct xfs_da_node_entry {
-        __be32  hashval;        /* hash value for this descendant */
-        __be32  before;         /* Btree block before this key */
-} xfs_da_node_entry_t;
-
-typedef struct xfs_da_intnode {
-        struct xfs_da_node_hdr  hdr;
-        struct xfs_da_node_entry __btree[];
-} xfs_da_intnode_t;
-
-struct xfs_da3_intnode {
-        struct xfs_da3_node_hdr hdr;
-        struct xfs_da_node_entry __btree[];
-};
-
-/*
- * In-core version of the node header to abstract the differences in the v2 and
- * v3 disk format of the headers. Callers need to convert to/from disk format as
- * appropriate.
- */
-struct xfs_da3_icnode_hdr {
-        __uint32_t      forw;
-        __uint32_t      back;
-        __uint16_t      magic;
-        __uint16_t      count;
-        __uint16_t      level;
-};
-
-extern void xfs_da3_node_hdr_from_disk(struct xfs_da3_icnode_hdr *to,
-                                       struct xfs_da_intnode *from);
-extern void xfs_da3_node_hdr_to_disk(struct xfs_da_intnode *to,
-                                     struct xfs_da3_icnode_hdr *from);
-
-static inline int
-__xfs_da3_node_hdr_size(bool v3)
-{
-        if (v3)
-                return sizeof(struct xfs_da3_node_hdr);
-        return sizeof(struct xfs_da_node_hdr);
-}
-static inline int
-xfs_da3_node_hdr_size(struct xfs_da_intnode *dap)
-{
-        bool    v3 = dap->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC);
-
-        return __xfs_da3_node_hdr_size(v3);
-}
-
-static inline struct xfs_da_node_entry *
-xfs_da3_node_tree_p(struct xfs_da_intnode *dap)
-{
-        if (dap->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC)) {
-                struct xfs_da3_intnode *dap3 = (struct xfs_da3_intnode *)dap;
-                return dap3->__btree;
-        }
-        return dap->__btree;
-}
-
-extern void xfs_da3_intnode_from_disk(struct xfs_da3_icnode_hdr *to,
-                                      struct xfs_da_intnode *from);
-extern void xfs_da3_intnode_to_disk(struct xfs_da_intnode *to,
-                                    struct xfs_da3_icnode_hdr *from);
-
-#define XFS_LBSIZE(mp)  (mp)->m_sb.sb_blocksize
+struct xfs_dir_ops;
 
 /*========================================================================
  * Btree searching and modification structure definitions.
@@ -309,8 +170,6 @@ int	xfs_da3_node_read(struct xfs_trans *tp, struct xfs_inode *dp,
                          xfs_dablk_t bno, xfs_daddr_t mappedbno,
                          struct xfs_buf **bpp, int which_fork);
 
-extern const struct xfs_buf_ops xfs_da3_node_buf_ops;
-
 /*
  * Utility routines.
  */
diff --git a/fs/xfs/xfs_da_format.c b/fs/xfs/xfs_da_format.c
new file mode 100644
index 000000000000..e6c83e1fbc8a
--- /dev/null
+++ b/fs/xfs/xfs_da_format.c
@@ -0,0 +1,907 @@
+/*
+ * Copyright (c) 2000,2002,2005 Silicon Graphics, Inc.
+ * Copyright (c) 2013 Red Hat, 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_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
+#include "xfs_sb.h"
+#include "xfs_ag.h"
+#include "xfs_mount.h"
+#include "xfs_da_format.h"
+#include "xfs_inode.h"
+#include "xfs_dir2.h"
+
+/*
+ * Shortform directory ops
+ */
+static int
+xfs_dir2_sf_entsize(
+        struct xfs_dir2_sf_hdr  *hdr,
+        int                     len)
+{
+        int count = sizeof(struct xfs_dir2_sf_entry);   /* namelen + offset */
+
+        count += len;                                   /* name */
+        count += hdr->i8count ? sizeof(xfs_dir2_ino8_t) :
+                                sizeof(xfs_dir2_ino4_t); /* ino # */
+        return count;
+}
+
+static int
+xfs_dir3_sf_entsize(
+        struct xfs_dir2_sf_hdr  *hdr,
+        int                     len)
+{
+        return xfs_dir2_sf_entsize(hdr, len) + sizeof(__uint8_t);
+}
+
+static struct xfs_dir2_sf_entry *
+xfs_dir2_sf_nextentry(
+        struct xfs_dir2_sf_hdr  *hdr,
+        struct xfs_dir2_sf_entry *sfep)
+{
+        return (struct xfs_dir2_sf_entry *)
+                ((char *)sfep + xfs_dir2_sf_entsize(hdr, sfep->namelen));
+}
+
+static struct xfs_dir2_sf_entry *
+xfs_dir3_sf_nextentry(
+        struct xfs_dir2_sf_hdr  *hdr,
+        struct xfs_dir2_sf_entry *sfep)
+{
+        return (struct xfs_dir2_sf_entry *)
+                ((char *)sfep + xfs_dir3_sf_entsize(hdr, sfep->namelen));
+}
+
+
+/*
+ * For filetype enabled shortform directories, the file type field is stored at
+ * the end of the name.  Because it's only a single byte, endian conversion is
+ * not necessary. For non-filetype enable directories, the type is always
+ * unknown and we never store the value.
+ */
+static __uint8_t
+xfs_dir2_sfe_get_ftype(
+        struct xfs_dir2_sf_entry *sfep)
+{
+        return XFS_DIR3_FT_UNKNOWN;
+}
+
+static void
+xfs_dir2_sfe_put_ftype(
+        struct xfs_dir2_sf_entry *sfep,
+        __uint8_t               ftype)
+{
+        ASSERT(ftype < XFS_DIR3_FT_MAX);
+}
+
+static __uint8_t
+xfs_dir3_sfe_get_ftype(
+        struct xfs_dir2_sf_entry *sfep)
+{
+        __uint8_t       ftype;
+
+        ftype = sfep->name[sfep->namelen];
+        if (ftype >= XFS_DIR3_FT_MAX)
+                return XFS_DIR3_FT_UNKNOWN;
+        return ftype;
+}
+
+static void
+xfs_dir3_sfe_put_ftype(
+        struct xfs_dir2_sf_entry *sfep,
+        __uint8_t               ftype)
+{
+        ASSERT(ftype < XFS_DIR3_FT_MAX);
+
+        sfep->name[sfep->namelen] = ftype;
+}
+
+/*
+ * Inode numbers in short-form directories can come in two versions,
+ * either 4 bytes or 8 bytes wide.  These helpers deal with the
+ * two forms transparently by looking at the headers i8count field.
+ *
+ * For 64-bit inode number the most significant byte must be zero.
+ */
+static xfs_ino_t
+xfs_dir2_sf_get_ino(
+        struct xfs_dir2_sf_hdr  *hdr,
+        xfs_dir2_inou_t         *from)
+{
+        if (hdr->i8count)
+                return get_unaligned_be64(&from->i8.i) & 0x00ffffffffffffffULL;
+        else
+                return get_unaligned_be32(&from->i4.i);
+}
+
+static void
+xfs_dir2_sf_put_ino(
+        struct xfs_dir2_sf_hdr  *hdr,
+        xfs_dir2_inou_t         *to,
+        xfs_ino_t               ino)
+{
+        ASSERT((ino & 0xff00000000000000ULL) == 0);
+
+        if (hdr->i8count)
+                put_unaligned_be64(ino, &to->i8.i);
+        else
+                put_unaligned_be32(ino, &to->i4.i);
+}
+
+static xfs_ino_t
+xfs_dir2_sf_get_parent_ino(
+        struct xfs_dir2_sf_hdr  *hdr)
+{
+        return xfs_dir2_sf_get_ino(hdr, &hdr->parent);
+}
+
+static void
+xfs_dir2_sf_put_parent_ino(
+        struct xfs_dir2_sf_hdr  *hdr,
+        xfs_ino_t               ino)
+{
+        xfs_dir2_sf_put_ino(hdr, &hdr->parent, ino);
+}
+
+/*
+ * In short-form directory entries the inode numbers are stored at variable
+ * offset behind the entry name. If the entry stores a filetype value, then it
+ * sits between the name and the inode number. Hence the inode numbers may only
+ * be accessed through the helpers below.
+ */
+static xfs_ino_t
+xfs_dir2_sfe_get_ino(
+        struct xfs_dir2_sf_hdr  *hdr,
+        struct xfs_dir2_sf_entry *sfep)
+{
+        return xfs_dir2_sf_get_ino(hdr,
+                                (xfs_dir2_inou_t *)&sfep->name[sfep->namelen]);
+}
+
+static void
+xfs_dir2_sfe_put_ino(
+        struct xfs_dir2_sf_hdr  *hdr,
+        struct xfs_dir2_sf_entry *sfep,
+        xfs_ino_t               ino)
+{
+        xfs_dir2_sf_put_ino(hdr,
+                            (xfs_dir2_inou_t *)&sfep->name[sfep->namelen], ino);
+}
+
+static xfs_ino_t
+xfs_dir3_sfe_get_ino(
+        struct xfs_dir2_sf_hdr  *hdr,
+        struct xfs_dir2_sf_entry *sfep)
+{
+        return xfs_dir2_sf_get_ino(hdr,
+                        (xfs_dir2_inou_t *)&sfep->name[sfep->namelen + 1]);
+}
+
+static void
+xfs_dir3_sfe_put_ino(
+        struct xfs_dir2_sf_hdr  *hdr,
+        struct xfs_dir2_sf_entry *sfep,
+        xfs_ino_t               ino)
+{
+        xfs_dir2_sf_put_ino(hdr,
+                        (xfs_dir2_inou_t *)&sfep->name[sfep->namelen + 1], ino);
+}
+
+
+/*
+ * Directory data block operations
+ */
+
+/*
+ * For special situations, the dirent size ends up fixed because we always know
+ * what the size of the entry is. That's true for the "." and "..", and
+ * therefore we know that they are a fixed size and hence their offsets are
+ * constant, as is the first entry.
+ *
+ * Hence, this calculation is written as a macro to be able to be calculated at
+ * compile time and so certain offsets can be calculated directly in the
+ * structure initaliser via the macro. There are two macros - one for dirents
+ * with ftype and without so there are no unresolvable conditionals in the
+ * calculations. We also use round_up() as XFS_DIR2_DATA_ALIGN is always a power
+ * of 2 and the compiler doesn't reject it (unlike roundup()).
+ */
+#define XFS_DIR2_DATA_ENTSIZE(n)                                        \
+        round_up((offsetof(struct xfs_dir2_data_entry, name[0]) + (n) + \
+                 sizeof(xfs_dir2_data_off_t)), XFS_DIR2_DATA_ALIGN)
+
+#define XFS_DIR3_DATA_ENTSIZE(n)                                        \
+        round_up((offsetof(struct xfs_dir2_data_entry, name[0]) + (n) + \
+                 sizeof(xfs_dir2_data_off_t) + sizeof(__uint8_t)),      \
+                XFS_DIR2_DATA_ALIGN)
+
+static int
+xfs_dir2_data_entsize(
+        int                     n)
+{
+        return XFS_DIR2_DATA_ENTSIZE(n);
+}
+
+static int
+xfs_dir3_data_entsize(
+        int                     n)
+{
+        return XFS_DIR3_DATA_ENTSIZE(n);
+}
+
+static __uint8_t
+xfs_dir2_data_get_ftype(
+        struct xfs_dir2_data_entry *dep)
+{
+        return XFS_DIR3_FT_UNKNOWN;
+}
+
+static void
+xfs_dir2_data_put_ftype(
+        struct xfs_dir2_data_entry *dep,
+        __uint8_t               ftype)
+{
+        ASSERT(ftype < XFS_DIR3_FT_MAX);
+}
+
+static __uint8_t
+xfs_dir3_data_get_ftype(
+        struct xfs_dir2_data_entry *dep)
+{
+        __uint8_t       ftype = dep->name[dep->namelen];
+
+        ASSERT(ftype < XFS_DIR3_FT_MAX);
+        if (ftype >= XFS_DIR3_FT_MAX)
+                return XFS_DIR3_FT_UNKNOWN;
+        return ftype;
+}
+
+static void
+xfs_dir3_data_put_ftype(
+        struct xfs_dir2_data_entry *dep,
+        __uint8_t               type)
+{
+        ASSERT(type < XFS_DIR3_FT_MAX);
+        ASSERT(dep->namelen != 0);
+
+        dep->name[dep->namelen] = type;
+}
+
+/*
+ * Pointer to an entry's tag word.
+ */
+static __be16 *
+xfs_dir2_data_entry_tag_p(
+        struct xfs_dir2_data_entry *dep)
+{
+        return (__be16 *)((char *)dep +
+                xfs_dir2_data_entsize(dep->namelen) - sizeof(__be16));
+}
+
+static __be16 *
+xfs_dir3_data_entry_tag_p(
+        struct xfs_dir2_data_entry *dep)
+{
+        return (__be16 *)((char *)dep +
+                xfs_dir3_data_entsize(dep->namelen) - sizeof(__be16));
+}
+
+/*
+ * location of . and .. in data space (always block 0)
+ */
+static struct xfs_dir2_data_entry *
+xfs_dir2_data_dot_entry_p(
+        struct xfs_dir2_data_hdr *hdr)
+{
+        return (struct xfs_dir2_data_entry *)
+                ((char *)hdr + sizeof(struct xfs_dir2_data_hdr));
+}
+
+static struct xfs_dir2_data_entry *
+xfs_dir2_data_dotdot_entry_p(
+        struct xfs_dir2_data_hdr *hdr)
+{
+        return (struct xfs_dir2_data_entry *)
+                ((char *)hdr + sizeof(struct xfs_dir2_data_hdr) +
+                                XFS_DIR2_DATA_ENTSIZE(1));
+}
+
+static struct xfs_dir2_data_entry *
+xfs_dir2_data_first_entry_p(
+        struct xfs_dir2_data_hdr *hdr)
+{
+        return (struct xfs_dir2_data_entry *)
+                ((char *)hdr + sizeof(struct xfs_dir2_data_hdr) +
+                                XFS_DIR2_DATA_ENTSIZE(1) +
+                                XFS_DIR2_DATA_ENTSIZE(2));
+}
+
+static struct xfs_dir2_data_entry *
+xfs_dir2_ftype_data_dotdot_entry_p(
+        struct xfs_dir2_data_hdr *hdr)
+{
+        return (struct xfs_dir2_data_entry *)
+                ((char *)hdr + sizeof(struct xfs_dir2_data_hdr) +
+                                XFS_DIR3_DATA_ENTSIZE(1));
+}
+
+static struct xfs_dir2_data_entry *
+xfs_dir2_ftype_data_first_entry_p(
+        struct xfs_dir2_data_hdr *hdr)
+{
+        return (struct xfs_dir2_data_entry *)
+                ((char *)hdr + sizeof(struct xfs_dir2_data_hdr) +
+                                XFS_DIR3_DATA_ENTSIZE(1) +
+                                XFS_DIR3_DATA_ENTSIZE(2));
+}
+
+static struct xfs_dir2_data_entry *
+xfs_dir3_data_dot_entry_p(
+        struct xfs_dir2_data_hdr *hdr)
+{
+        return (struct xfs_dir2_data_entry *)
+                ((char *)hdr + sizeof(struct xfs_dir3_data_hdr));
+}
+
+static struct xfs_dir2_data_entry *
+xfs_dir3_data_dotdot_entry_p(
+        struct xfs_dir2_data_hdr *hdr)
+{
+        return (struct xfs_dir2_data_entry *)
+                ((char *)hdr + sizeof(struct xfs_dir3_data_hdr) +
+                                XFS_DIR3_DATA_ENTSIZE(1));
+}
+
+static struct xfs_dir2_data_entry *
+xfs_dir3_data_first_entry_p(
+        struct xfs_dir2_data_hdr *hdr)
+{
+        return (struct xfs_dir2_data_entry *)
+                ((char *)hdr + sizeof(struct xfs_dir3_data_hdr) +
+                                XFS_DIR3_DATA_ENTSIZE(1) +
+                                XFS_DIR3_DATA_ENTSIZE(2));
+}
+
+static struct xfs_dir2_data_free *
+xfs_dir2_data_bestfree_p(struct xfs_dir2_data_hdr *hdr)
+{
+        return hdr->bestfree;
+}
+
+static struct xfs_dir2_data_free *
+xfs_dir3_data_bestfree_p(struct xfs_dir2_data_hdr *hdr)
+{
+        return ((struct xfs_dir3_data_hdr *)hdr)->best_free;
+}
+
+static struct xfs_dir2_data_entry *
+xfs_dir2_data_entry_p(struct xfs_dir2_data_hdr *hdr)
+{
+        return (struct xfs_dir2_data_entry *)
+                ((char *)hdr + sizeof(struct xfs_dir2_data_hdr));
+}
+
+static struct xfs_dir2_data_unused *
+xfs_dir2_data_unused_p(struct xfs_dir2_data_hdr *hdr)
+{
+        return (struct xfs_dir2_data_unused *)
+                ((char *)hdr + sizeof(struct xfs_dir2_data_hdr));
+}
+
+static struct xfs_dir2_data_entry *
+xfs_dir3_data_entry_p(struct xfs_dir2_data_hdr *hdr)
+{
+        return (struct xfs_dir2_data_entry *)
+                ((char *)hdr + sizeof(struct xfs_dir3_data_hdr));
+}
+
+static struct xfs_dir2_data_unused *
+xfs_dir3_data_unused_p(struct xfs_dir2_data_hdr *hdr)
+{
+        return (struct xfs_dir2_data_unused *)
+                ((char *)hdr + sizeof(struct xfs_dir3_data_hdr));
+}
+
+
+/*
+ * Directory Leaf block operations
+ */
+static int
+xfs_dir2_max_leaf_ents(struct xfs_mount *mp)
+{
+        return (mp->m_dirblksize - sizeof(struct xfs_dir2_leaf_hdr)) /
+                (uint)sizeof(struct xfs_dir2_leaf_entry);
+}
+
+static struct xfs_dir2_leaf_entry *
+xfs_dir2_leaf_ents_p(struct xfs_dir2_leaf *lp)
+{
+        return lp->__ents;
+}
+
+static int
+xfs_dir3_max_leaf_ents(struct xfs_mount *mp)
+{
+        return (mp->m_dirblksize - sizeof(struct xfs_dir3_leaf_hdr)) /
+                (uint)sizeof(struct xfs_dir2_leaf_entry);
+}
+
+static struct xfs_dir2_leaf_entry *
+xfs_dir3_leaf_ents_p(struct xfs_dir2_leaf *lp)
+{
+        return ((struct xfs_dir3_leaf *)lp)->__ents;
+}
+
+static void
+xfs_dir2_leaf_hdr_from_disk(
+        struct xfs_dir3_icleaf_hdr      *to,
+        struct xfs_dir2_leaf            *from)
+{
+        to->forw = be32_to_cpu(from->hdr.info.forw);
+        to->back = be32_to_cpu(from->hdr.info.back);
+        to->magic = be16_to_cpu(from->hdr.info.magic);
+        to->count = be16_to_cpu(from->hdr.count);
+        to->stale = be16_to_cpu(from->hdr.stale);
+
+        ASSERT(to->magic == XFS_DIR2_LEAF1_MAGIC ||
+               to->magic == XFS_DIR2_LEAFN_MAGIC);
+}
+
+static void
+xfs_dir2_leaf_hdr_to_disk(
+        struct xfs_dir2_leaf            *to,
+        struct xfs_dir3_icleaf_hdr      *from)
+{
+        ASSERT(from->magic == XFS_DIR2_LEAF1_MAGIC ||
+               from->magic == XFS_DIR2_LEAFN_MAGIC);
+
+        to->hdr.info.forw = cpu_to_be32(from->forw);
+        to->hdr.info.back = cpu_to_be32(from->back);
+        to->hdr.info.magic = cpu_to_be16(from->magic);
+        to->hdr.count = cpu_to_be16(from->count);
+        to->hdr.stale = cpu_to_be16(from->stale);
+}
+
+static void
+xfs_dir3_leaf_hdr_from_disk(
+        struct xfs_dir3_icleaf_hdr      *to,
+        struct xfs_dir2_leaf            *from)
+{
+        struct xfs_dir3_leaf_hdr *hdr3 = (struct xfs_dir3_leaf_hdr *)from;
+
+        to->forw = be32_to_cpu(hdr3->info.hdr.forw);
+        to->back = be32_to_cpu(hdr3->info.hdr.back);
+        to->magic = be16_to_cpu(hdr3->info.hdr.magic);
+        to->count = be16_to_cpu(hdr3->count);
+        to->stale = be16_to_cpu(hdr3->stale);
+
+        ASSERT(to->magic == XFS_DIR3_LEAF1_MAGIC ||
+               to->magic == XFS_DIR3_LEAFN_MAGIC);
+}
+
+static void
+xfs_dir3_leaf_hdr_to_disk(
+        struct xfs_dir2_leaf            *to,
+        struct xfs_dir3_icleaf_hdr      *from)
+{
+        struct xfs_dir3_leaf_hdr *hdr3 = (struct xfs_dir3_leaf_hdr *)to;
+
+        ASSERT(from->magic == XFS_DIR3_LEAF1_MAGIC ||
+               from->magic == XFS_DIR3_LEAFN_MAGIC);
+
+        hdr3->info.hdr.forw = cpu_to_be32(from->forw);
+        hdr3->info.hdr.back = cpu_to_be32(from->back);
+        hdr3->info.hdr.magic = cpu_to_be16(from->magic);
+        hdr3->count = cpu_to_be16(from->count);
+        hdr3->stale = cpu_to_be16(from->stale);
+}
+
+
+/*
+ * Directory/Attribute Node block operations
+ */
+static struct xfs_da_node_entry *
+xfs_da2_node_tree_p(struct xfs_da_intnode *dap)
+{
+        return dap->__btree;
+}
+
+static struct xfs_da_node_entry *
+xfs_da3_node_tree_p(struct xfs_da_intnode *dap)
+{
+        return ((struct xfs_da3_intnode *)dap)->__btree;
+}
+
+static void
+xfs_da2_node_hdr_from_disk(
+        struct xfs_da3_icnode_hdr       *to,
+        struct xfs_da_intnode           *from)
+{
+        ASSERT(from->hdr.info.magic == cpu_to_be16(XFS_DA_NODE_MAGIC));
+        to->forw = be32_to_cpu(from->hdr.info.forw);
+        to->back = be32_to_cpu(from->hdr.info.back);
+        to->magic = be16_to_cpu(from->hdr.info.magic);
+        to->count = be16_to_cpu(from->hdr.__count);
+        to->level = be16_to_cpu(from->hdr.__level);
+}
+
+static void
+xfs_da2_node_hdr_to_disk(
+        struct xfs_da_intnode           *to,
+        struct xfs_da3_icnode_hdr       *from)
+{
+        ASSERT(from->magic == XFS_DA_NODE_MAGIC);
+        to->hdr.info.forw = cpu_to_be32(from->forw);
+        to->hdr.info.back = cpu_to_be32(from->back);
+        to->hdr.info.magic = cpu_to_be16(from->magic);
+        to->hdr.__count = cpu_to_be16(from->count);
+        to->hdr.__level = cpu_to_be16(from->level);
+}
+
+static void
+xfs_da3_node_hdr_from_disk(
+        struct xfs_da3_icnode_hdr       *to,
+        struct xfs_da_intnode           *from)
+{
+        struct xfs_da3_node_hdr *hdr3 = (struct xfs_da3_node_hdr *)from;
+
+        ASSERT(from->hdr.info.magic == cpu_to_be16(XFS_DA3_NODE_MAGIC));
+        to->forw = be32_to_cpu(hdr3->info.hdr.forw);
+        to->back = be32_to_cpu(hdr3->info.hdr.back);
+        to->magic = be16_to_cpu(hdr3->info.hdr.magic);
+        to->count = be16_to_cpu(hdr3->__count);
+        to->level = be16_to_cpu(hdr3->__level);
+}
+
+static void
+xfs_da3_node_hdr_to_disk(
+        struct xfs_da_intnode           *to,
+        struct xfs_da3_icnode_hdr       *from)
+{
+        struct xfs_da3_node_hdr *hdr3 = (struct xfs_da3_node_hdr *)to;
+
+        ASSERT(from->magic == XFS_DA3_NODE_MAGIC);
+        hdr3->info.hdr.forw = cpu_to_be32(from->forw);
+        hdr3->info.hdr.back = cpu_to_be32(from->back);
+        hdr3->info.hdr.magic = cpu_to_be16(from->magic);
+        hdr3->__count = cpu_to_be16(from->count);
+        hdr3->__level = cpu_to_be16(from->level);
+}
+
+
+/*
+ * Directory free space block operations
+ */
+static int
+xfs_dir2_free_max_bests(struct xfs_mount *mp)
+{
+        return (mp->m_dirblksize - sizeof(struct xfs_dir2_free_hdr)) /
+                sizeof(xfs_dir2_data_off_t);
+}
+
+static __be16 *
+xfs_dir2_free_bests_p(struct xfs_dir2_free *free)
+{
+        return (__be16 *)((char *)free + sizeof(struct xfs_dir2_free_hdr));
+}
+
+/*
+ * Convert data space db to the corresponding free db.
+ */
+static xfs_dir2_db_t
+xfs_dir2_db_to_fdb(struct xfs_mount *mp, xfs_dir2_db_t db)
+{
+        return XFS_DIR2_FREE_FIRSTDB(mp) + db / xfs_dir2_free_max_bests(mp);
+}
+
+/*
+ * Convert data space db to the corresponding index in a free db.
+ */
+static int
+xfs_dir2_db_to_fdindex(struct xfs_mount *mp, xfs_dir2_db_t db)
+{
+        return db % xfs_dir2_free_max_bests(mp);
+}
+
+static int
+xfs_dir3_free_max_bests(struct xfs_mount *mp)
+{
+        return (mp->m_dirblksize - sizeof(struct xfs_dir3_free_hdr)) /
+                sizeof(xfs_dir2_data_off_t);
+}
+
+static __be16 *
+xfs_dir3_free_bests_p(struct xfs_dir2_free *free)
+{
+        return (__be16 *)((char *)free + sizeof(struct xfs_dir3_free_hdr));
+}
+
+/*
+ * Convert data space db to the corresponding free db.
+ */
+static xfs_dir2_db_t
+xfs_dir3_db_to_fdb(struct xfs_mount *mp, xfs_dir2_db_t db)
+{
+        return XFS_DIR2_FREE_FIRSTDB(mp) + db / xfs_dir3_free_max_bests(mp);
+}
+
+/*
+ * Convert data space db to the corresponding index in a free db.
+ */
+static int
+xfs_dir3_db_to_fdindex(struct xfs_mount *mp, xfs_dir2_db_t db)
+{
+        return db % xfs_dir3_free_max_bests(mp);
+}
+
+static void
+xfs_dir2_free_hdr_from_disk(
+        struct xfs_dir3_icfree_hdr      *to,
+        struct xfs_dir2_free            *from)
+{
+        to->magic = be32_to_cpu(from->hdr.magic);
+        to->firstdb = be32_to_cpu(from->hdr.firstdb);
+        to->nvalid = be32_to_cpu(from->hdr.nvalid);
+        to->nused = be32_to_cpu(from->hdr.nused);
+        ASSERT(to->magic == XFS_DIR2_FREE_MAGIC);
+}
+
+static void
+xfs_dir2_free_hdr_to_disk(
+        struct xfs_dir2_free            *to,
+        struct xfs_dir3_icfree_hdr      *from)
+{
+        ASSERT(from->magic == XFS_DIR2_FREE_MAGIC);
+
+        to->hdr.magic = cpu_to_be32(from->magic);
+        to->hdr.firstdb = cpu_to_be32(from->firstdb);
+        to->hdr.nvalid = cpu_to_be32(from->nvalid);
+        to->hdr.nused = cpu_to_be32(from->nused);
+}
+
+static void
+xfs_dir3_free_hdr_from_disk(
+        struct xfs_dir3_icfree_hdr      *to,
+        struct xfs_dir2_free            *from)
+{
+        struct xfs_dir3_free_hdr *hdr3 = (struct xfs_dir3_free_hdr *)from;
+
+        to->magic = be32_to_cpu(hdr3->hdr.magic);
+        to->firstdb = be32_to_cpu(hdr3->firstdb);
+        to->nvalid = be32_to_cpu(hdr3->nvalid);
+        to->nused = be32_to_cpu(hdr3->nused);
+
+        ASSERT(to->magic == XFS_DIR3_FREE_MAGIC);
+}
+
+static void
+xfs_dir3_free_hdr_to_disk(
+        struct xfs_dir2_free            *to,
+        struct xfs_dir3_icfree_hdr      *from)
+{
+        struct xfs_dir3_free_hdr *hdr3 = (struct xfs_dir3_free_hdr *)to;
+
+        ASSERT(from->magic == XFS_DIR3_FREE_MAGIC);
+
+        hdr3->hdr.magic = cpu_to_be32(from->magic);
+        hdr3->firstdb = cpu_to_be32(from->firstdb);
+        hdr3->nvalid = cpu_to_be32(from->nvalid);
+        hdr3->nused = cpu_to_be32(from->nused);
+}
+
+static const struct xfs_dir_ops xfs_dir2_ops = {
+        .sf_entsize = xfs_dir2_sf_entsize,
+        .sf_nextentry = xfs_dir2_sf_nextentry,
+        .sf_get_ftype = xfs_dir2_sfe_get_ftype,
+        .sf_put_ftype = xfs_dir2_sfe_put_ftype,
+        .sf_get_ino = xfs_dir2_sfe_get_ino,
+        .sf_put_ino = xfs_dir2_sfe_put_ino,
+        .sf_get_parent_ino = xfs_dir2_sf_get_parent_ino,
+        .sf_put_parent_ino = xfs_dir2_sf_put_parent_ino,
+
+        .data_entsize = xfs_dir2_data_entsize,
+        .data_get_ftype = xfs_dir2_data_get_ftype,
+        .data_put_ftype = xfs_dir2_data_put_ftype,
+        .data_entry_tag_p = xfs_dir2_data_entry_tag_p,
+        .data_bestfree_p = xfs_dir2_data_bestfree_p,
+
+        .data_dot_offset = sizeof(struct xfs_dir2_data_hdr),
+        .data_dotdot_offset = sizeof(struct xfs_dir2_data_hdr) +
+                                XFS_DIR2_DATA_ENTSIZE(1),
+        .data_first_offset =  sizeof(struct xfs_dir2_data_hdr) +
+                                XFS_DIR2_DATA_ENTSIZE(1) +
+                                XFS_DIR2_DATA_ENTSIZE(2),
+        .data_entry_offset = sizeof(struct xfs_dir2_data_hdr),
+
+        .data_dot_entry_p = xfs_dir2_data_dot_entry_p,
+        .data_dotdot_entry_p = xfs_dir2_data_dotdot_entry_p,
+        .data_first_entry_p = xfs_dir2_data_first_entry_p,
+        .data_entry_p = xfs_dir2_data_entry_p,
+        .data_unused_p = xfs_dir2_data_unused_p,
+
+        .leaf_hdr_size = sizeof(struct xfs_dir2_leaf_hdr),
+        .leaf_hdr_to_disk = xfs_dir2_leaf_hdr_to_disk,
+        .leaf_hdr_from_disk = xfs_dir2_leaf_hdr_from_disk,
+        .leaf_max_ents = xfs_dir2_max_leaf_ents,
+        .leaf_ents_p = xfs_dir2_leaf_ents_p,
+
+        .node_hdr_size = sizeof(struct xfs_da_node_hdr),
+        .node_hdr_to_disk = xfs_da2_node_hdr_to_disk,
+        .node_hdr_from_disk = xfs_da2_node_hdr_from_disk,
+        .node_tree_p = xfs_da2_node_tree_p,
+
+        .free_hdr_size = sizeof(struct xfs_dir2_free_hdr),
+        .free_hdr_to_disk = xfs_dir2_free_hdr_to_disk,
+        .free_hdr_from_disk = xfs_dir2_free_hdr_from_disk,
+        .free_max_bests = xfs_dir2_free_max_bests,
+        .free_bests_p = xfs_dir2_free_bests_p,
+        .db_to_fdb = xfs_dir2_db_to_fdb,
+        .db_to_fdindex = xfs_dir2_db_to_fdindex,
+};
+
+static const struct xfs_dir_ops xfs_dir2_ftype_ops = {
+        .sf_entsize = xfs_dir3_sf_entsize,
+        .sf_nextentry = xfs_dir3_sf_nextentry,
+        .sf_get_ftype = xfs_dir3_sfe_get_ftype,
+        .sf_put_ftype = xfs_dir3_sfe_put_ftype,
+        .sf_get_ino = xfs_dir3_sfe_get_ino,
+        .sf_put_ino = xfs_dir3_sfe_put_ino,
+        .sf_get_parent_ino = xfs_dir2_sf_get_parent_ino,
+        .sf_put_parent_ino = xfs_dir2_sf_put_parent_ino,
+
+        .data_entsize = xfs_dir3_data_entsize,
+        .data_get_ftype = xfs_dir3_data_get_ftype,
+        .data_put_ftype = xfs_dir3_data_put_ftype,
+        .data_entry_tag_p = xfs_dir3_data_entry_tag_p,
+        .data_bestfree_p = xfs_dir2_data_bestfree_p,
+
+        .data_dot_offset = sizeof(struct xfs_dir2_data_hdr),
+        .data_dotdot_offset = sizeof(struct xfs_dir2_data_hdr) +
+                                XFS_DIR3_DATA_ENTSIZE(1),
+        .data_first_offset =  sizeof(struct xfs_dir2_data_hdr) +
+                                XFS_DIR3_DATA_ENTSIZE(1) +
+                                XFS_DIR3_DATA_ENTSIZE(2),
+        .data_entry_offset = sizeof(struct xfs_dir2_data_hdr),
+
+        .data_dot_entry_p = xfs_dir2_data_dot_entry_p,
+        .data_dotdot_entry_p = xfs_dir2_ftype_data_dotdot_entry_p,
+        .data_first_entry_p = xfs_dir2_ftype_data_first_entry_p,
+        .data_entry_p = xfs_dir2_data_entry_p,
+        .data_unused_p = xfs_dir2_data_unused_p,
+
+        .leaf_hdr_size = sizeof(struct xfs_dir2_leaf_hdr),
+        .leaf_hdr_to_disk = xfs_dir2_leaf_hdr_to_disk,
+        .leaf_hdr_from_disk = xfs_dir2_leaf_hdr_from_disk,
+        .leaf_max_ents = xfs_dir2_max_leaf_ents,
+        .leaf_ents_p = xfs_dir2_leaf_ents_p,
+
+        .node_hdr_size = sizeof(struct xfs_da_node_hdr),
+        .node_hdr_to_disk = xfs_da2_node_hdr_to_disk,
+        .node_hdr_from_disk = xfs_da2_node_hdr_from_disk,
+        .node_tree_p = xfs_da2_node_tree_p,
+
+        .free_hdr_size = sizeof(struct xfs_dir2_free_hdr),
+        .free_hdr_to_disk = xfs_dir2_free_hdr_to_disk,
+        .free_hdr_from_disk = xfs_dir2_free_hdr_from_disk,
+        .free_max_bests = xfs_dir2_free_max_bests,
+        .free_bests_p = xfs_dir2_free_bests_p,
+        .db_to_fdb = xfs_dir2_db_to_fdb,
+        .db_to_fdindex = xfs_dir2_db_to_fdindex,
+};
+
+static const struct xfs_dir_ops xfs_dir3_ops = {
+        .sf_entsize = xfs_dir3_sf_entsize,
+        .sf_nextentry = xfs_dir3_sf_nextentry,
+        .sf_get_ftype = xfs_dir3_sfe_get_ftype,
+        .sf_put_ftype = xfs_dir3_sfe_put_ftype,
+        .sf_get_ino = xfs_dir3_sfe_get_ino,
+        .sf_put_ino = xfs_dir3_sfe_put_ino,
+        .sf_get_parent_ino = xfs_dir2_sf_get_parent_ino,
+        .sf_put_parent_ino = xfs_dir2_sf_put_parent_ino,
+
+        .data_entsize = xfs_dir3_data_entsize,
+        .data_get_ftype = xfs_dir3_data_get_ftype,
+        .data_put_ftype = xfs_dir3_data_put_ftype,
+        .data_entry_tag_p = xfs_dir3_data_entry_tag_p,
+        .data_bestfree_p = xfs_dir3_data_bestfree_p,
+
+        .data_dot_offset = sizeof(struct xfs_dir3_data_hdr),
+        .data_dotdot_offset = sizeof(struct xfs_dir3_data_hdr) +
+                                XFS_DIR3_DATA_ENTSIZE(1),
+        .data_first_offset =  sizeof(struct xfs_dir3_data_hdr) +
+                                XFS_DIR3_DATA_ENTSIZE(1) +
+                                XFS_DIR3_DATA_ENTSIZE(2),
+        .data_entry_offset = sizeof(struct xfs_dir3_data_hdr),
+
+        .data_dot_entry_p = xfs_dir3_data_dot_entry_p,
+        .data_dotdot_entry_p = xfs_dir3_data_dotdot_entry_p,
+        .data_first_entry_p = xfs_dir3_data_first_entry_p,
+        .data_entry_p = xfs_dir3_data_entry_p,
+        .data_unused_p = xfs_dir3_data_unused_p,
+
+        .leaf_hdr_size = sizeof(struct xfs_dir3_leaf_hdr),
+        .leaf_hdr_to_disk = xfs_dir3_leaf_hdr_to_disk,
+        .leaf_hdr_from_disk = xfs_dir3_leaf_hdr_from_disk,
+        .leaf_max_ents = xfs_dir3_max_leaf_ents,
+        .leaf_ents_p = xfs_dir3_leaf_ents_p,
+
+        .node_hdr_size = sizeof(struct xfs_da3_node_hdr),
+        .node_hdr_to_disk = xfs_da3_node_hdr_to_disk,
+        .node_hdr_from_disk = xfs_da3_node_hdr_from_disk,
+        .node_tree_p = xfs_da3_node_tree_p,
+
+        .free_hdr_size = sizeof(struct xfs_dir3_free_hdr),
+        .free_hdr_to_disk = xfs_dir3_free_hdr_to_disk,
+        .free_hdr_from_disk = xfs_dir3_free_hdr_from_disk,
+        .free_max_bests = xfs_dir3_free_max_bests,
+        .free_bests_p = xfs_dir3_free_bests_p,
+        .db_to_fdb = xfs_dir3_db_to_fdb,
+        .db_to_fdindex = xfs_dir3_db_to_fdindex,
+};
+
+static const struct xfs_dir_ops xfs_dir2_nondir_ops = {
+        .node_hdr_size = sizeof(struct xfs_da_node_hdr),
+        .node_hdr_to_disk = xfs_da2_node_hdr_to_disk,
+        .node_hdr_from_disk = xfs_da2_node_hdr_from_disk,
+        .node_tree_p = xfs_da2_node_tree_p,
+};
+
+static const struct xfs_dir_ops xfs_dir3_nondir_ops = {
+        .node_hdr_size = sizeof(struct xfs_da3_node_hdr),
+        .node_hdr_to_disk = xfs_da3_node_hdr_to_disk,
+        .node_hdr_from_disk = xfs_da3_node_hdr_from_disk,
+        .node_tree_p = xfs_da3_node_tree_p,
+};
+
+/*
+ * Return the ops structure according to the current config.  If we are passed
+ * an inode, then that overrides the default config we use which is based on
+ * feature bits.
+ */
+const struct xfs_dir_ops *
+xfs_dir_get_ops(
+        struct xfs_mount        *mp,
+        struct xfs_inode        *dp)
+{
+        if (dp)
+                return dp->d_ops;
+        if (mp->m_dir_inode_ops)
+                return mp->m_dir_inode_ops;
+        if (xfs_sb_version_hascrc(&mp->m_sb))
+                return &xfs_dir3_ops;
+        if (xfs_sb_version_hasftype(&mp->m_sb))
+                return &xfs_dir2_ftype_ops;
+        return &xfs_dir2_ops;
+}
+
+const struct xfs_dir_ops *
+xfs_nondir_get_ops(
+        struct xfs_mount        *mp,
+        struct xfs_inode        *dp)
+{
+        if (dp)
+                return dp->d_ops;
+        if (mp->m_nondir_inode_ops)
+                return mp->m_nondir_inode_ops;
+        if (xfs_sb_version_hascrc(&mp->m_sb))
+                return &xfs_dir3_nondir_ops;
+        return &xfs_dir2_nondir_ops;
+}
diff --git a/fs/xfs/xfs_dir2_format.h b/fs/xfs/xfs_da_format.h
index a0961a61ac1a..a19d3f8f639c 100644
--- a/fs/xfs/xfs_dir2_format.h
+++ b/fs/xfs/xfs_da_format.h
@@ -16,8 +16,113 @@
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
-#ifndef __XFS_DIR2_FORMAT_H__
-#define __XFS_DIR2_FORMAT_H__
+#ifndef __XFS_DA_FORMAT_H__
+#define __XFS_DA_FORMAT_H__
+
+/*========================================================================
+ * Directory Structure when greater than XFS_LBSIZE(mp) bytes.
+ *========================================================================*/
+
+/*
+ * This structure is common to both leaf nodes and non-leaf nodes in the Btree.
+ *
+ * It is used to manage a doubly linked list of all blocks at the same
+ * 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_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 */
+
+typedef struct xfs_da_blkinfo {
+        __be32          forw;                   /* previous block in list */
+        __be32          back;                   /* following block in list */
+        __be16          magic;                  /* validity check on block */
+        __be16          pad;                    /* unused */
+} xfs_da_blkinfo_t;
+
+/*
+ * CRC enabled directory structure types
+ *
+ * The headers change size for the additional verification information, but
+ * otherwise the tree layouts and contents are unchanged. Hence the da btree
+ * code can use the struct xfs_da_blkinfo for manipulating the tree links and
+ * magic numbers without modification for both v2 and v3 nodes.
+ */
+#define XFS_DA3_NODE_MAGIC      0x3ebe  /* magic number: non-leaf blocks */
+#define XFS_ATTR3_LEAF_MAGIC    0x3bee  /* magic number: attribute leaf blks */
+#define XFS_DIR3_LEAF1_MAGIC    0x3df1  /* magic number: v2 dirlf single blks */
+#define XFS_DIR3_LEAFN_MAGIC    0x3dff  /* magic number: v2 dirlf multi blks */
+
+struct xfs_da3_blkinfo {
+        /*
+         * the node link manipulation code relies on the fact that the first
+         * element of this structure is the struct xfs_da_blkinfo so it can
+         * ignore the differences in the rest of the structures.
+         */
+        struct xfs_da_blkinfo   hdr;
+        __be32                  crc;    /* CRC of block */
+        __be64                  blkno;  /* first block of the buffer */
+        __be64                  lsn;    /* sequence number of last write */
+        uuid_t                  uuid;   /* filesystem we belong to */
+        __be64                  owner;  /* inode that owns the block */
+};
+
+/*
+ * This is the structure of the root and intermediate nodes in the Btree.
+ * The leaf nodes are defined above.
+ *
+ * Entries are not packed.
+ *
+ * Since we have duplicate keys, use a binary search but always follow
+ * all match in the block, not just the first match found.
+ */
+#define XFS_DA_NODE_MAXDEPTH    5       /* max depth of Btree */
+
+typedef struct xfs_da_node_hdr {
+        struct xfs_da_blkinfo   info;   /* block type, links, etc. */
+        __be16                  __count; /* count of active entries */
+        __be16                  __level; /* level above leaves (leaf == 0) */
+} xfs_da_node_hdr_t;
+
+struct xfs_da3_node_hdr {
+        struct xfs_da3_blkinfo  info;   /* block type, links, etc. */
+        __be16                  __count; /* count of active entries */
+        __be16                  __level; /* level above leaves (leaf == 0) */
+        __be32                  __pad32;
+};
+
+#define XFS_DA3_NODE_CRC_OFF    (offsetof(struct xfs_da3_node_hdr, info.crc))
+
+typedef struct xfs_da_node_entry {
+        __be32  hashval;        /* hash value for this descendant */
+        __be32  before;         /* Btree block before this key */
+} xfs_da_node_entry_t;
+
+typedef struct xfs_da_intnode {
+        struct xfs_da_node_hdr  hdr;
+        struct xfs_da_node_entry __btree[];
+} xfs_da_intnode_t;
+
+struct xfs_da3_intnode {
+        struct xfs_da3_node_hdr hdr;
+        struct xfs_da_node_entry __btree[];
+};
+
+/*
+ * In-core version of the node header to abstract the differences in the v2 and
+ * v3 disk format of the headers. Callers need to convert to/from disk format as
+ * appropriate.
+ */
+struct xfs_da3_icnode_hdr {
+        __uint32_t      forw;
+        __uint32_t      back;
+        __uint16_t      magic;
+        __uint16_t      count;
+        __uint16_t      level;
+};
+
+#define XFS_LBSIZE(mp)  (mp)->m_sb.sb_blocksize
 
 /*
  * Directory version 2.
@@ -189,79 +294,6 @@ xfs_dir2_sf_firstentry(struct xfs_dir2_sf_hdr *hdr)
                 ((char *)hdr + xfs_dir2_sf_hdr_size(hdr->i8count));
 }
 
-static inline int
-xfs_dir3_sf_entsize(
-        struct xfs_mount        *mp,
-        struct xfs_dir2_sf_hdr  *hdr,
-        int                     len)
-{
-        int count = sizeof(struct xfs_dir2_sf_entry);   /* namelen + offset */
-
-        count += len;                                   /* name */
-        count += hdr->i8count ? sizeof(xfs_dir2_ino8_t) :
-                                sizeof(xfs_dir2_ino4_t); /* ino # */
-        if (xfs_sb_version_hasftype(&mp->m_sb))
-                count += sizeof(__uint8_t);             /* file type */
-        return count;
-}
-
-static inline struct xfs_dir2_sf_entry *
-xfs_dir3_sf_nextentry(
-        struct xfs_mount        *mp,
-        struct xfs_dir2_sf_hdr  *hdr,
-        struct xfs_dir2_sf_entry *sfep)
-{
-        return (struct xfs_dir2_sf_entry *)
-                ((char *)sfep + xfs_dir3_sf_entsize(mp, hdr, sfep->namelen));
-}
-
-/*
- * in dir3 shortform directories, the file type field is stored at a variable
- * offset after the inode number. Because it's only a single byte, endian
- * conversion is not necessary.
- */
-static inline __uint8_t *
-xfs_dir3_sfe_ftypep(
-        struct xfs_dir2_sf_hdr  *hdr,
-        struct xfs_dir2_sf_entry *sfep)
-{
-        return (__uint8_t *)&sfep->name[sfep->namelen];
-}
-
-static inline __uint8_t
-xfs_dir3_sfe_get_ftype(
-        struct xfs_mount        *mp,
-        struct xfs_dir2_sf_hdr  *hdr,
-        struct xfs_dir2_sf_entry *sfep)
-{
-        __uint8_t       *ftp;
-
-        if (!xfs_sb_version_hasftype(&mp->m_sb))
-                return XFS_DIR3_FT_UNKNOWN;
-
-        ftp = xfs_dir3_sfe_ftypep(hdr, sfep);
-        if (*ftp >= XFS_DIR3_FT_MAX)
-                return XFS_DIR3_FT_UNKNOWN;
-        return *ftp;
-}
-
-static inline void
-xfs_dir3_sfe_put_ftype(
-        struct xfs_mount        *mp,
-        struct xfs_dir2_sf_hdr  *hdr,
-        struct xfs_dir2_sf_entry *sfep,
-        __uint8_t               ftype)
-{
-        __uint8_t       *ftp;
-
-        ASSERT(ftype < XFS_DIR3_FT_MAX);
-
-        if (!xfs_sb_version_hasftype(&mp->m_sb))
-                return;
-        ftp = xfs_dir3_sfe_ftypep(hdr, sfep);
-        *ftp = ftype;
-}
-
 /*
  * Data block structures.
  *
@@ -345,17 +377,6 @@ struct xfs_dir3_data_hdr {
 
 #define XFS_DIR3_DATA_CRC_OFF  offsetof(struct xfs_dir3_data_hdr, hdr.crc)
 
-static inline struct xfs_dir2_data_free *
-xfs_dir3_data_bestfree_p(struct xfs_dir2_data_hdr *hdr)
-{
-        if (hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
-            hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) {
-                struct xfs_dir3_data_hdr *hdr3 = (struct xfs_dir3_data_hdr *)hdr;
-                return hdr3->best_free;
-        }
-        return hdr->bestfree;
-}
-
 /*
  * Active entry in a data block.
  *
@@ -389,72 +410,6 @@ typedef struct xfs_dir2_data_unused {
 } xfs_dir2_data_unused_t;
 
 /*
- * Size of a data entry.
- */
-static inline int
-__xfs_dir3_data_entsize(
-        bool    ftype,
-        int     n)
-{
-        int     size = offsetof(struct xfs_dir2_data_entry, name[0]);
-
-        size += n;
-        size += sizeof(xfs_dir2_data_off_t);
-        if (ftype)
-                size += sizeof(__uint8_t);
-        return roundup(size, XFS_DIR2_DATA_ALIGN);
-}
-static inline int
-xfs_dir3_data_entsize(
-        struct xfs_mount        *mp,
-        int                     n)
-{
-        bool ftype = xfs_sb_version_hasftype(&mp->m_sb) ? true : false;
-        return __xfs_dir3_data_entsize(ftype, n);
-}
-
-static inline __uint8_t
-xfs_dir3_dirent_get_ftype(
-        struct xfs_mount        *mp,
-        struct xfs_dir2_data_entry *dep)
-{
-        if (xfs_sb_version_hasftype(&mp->m_sb)) {
-                __uint8_t       type = dep->name[dep->namelen];
-
-                ASSERT(type < XFS_DIR3_FT_MAX);
-                if (type < XFS_DIR3_FT_MAX)
-                        return type;
-
-        }
-        return XFS_DIR3_FT_UNKNOWN;
-}
-
-static inline void
-xfs_dir3_dirent_put_ftype(
-        struct xfs_mount        *mp,
-        struct xfs_dir2_data_entry *dep,
-        __uint8_t               type)
-{
-        ASSERT(type < XFS_DIR3_FT_MAX);
-        ASSERT(dep->namelen != 0);
-
-        if (xfs_sb_version_hasftype(&mp->m_sb))
-                dep->name[dep->namelen] = type;
-}
-
-/*
- * Pointer to an entry's tag word.
- */
-static inline __be16 *
-xfs_dir3_data_entry_tag_p(
-        struct xfs_mount        *mp,
-        struct xfs_dir2_data_entry *dep)
-{
-        return (__be16 *)((char *)dep +
-                xfs_dir3_data_entsize(mp, dep->namelen) - sizeof(__be16));
-}
-
-/*
  * Pointer to a freespace's tag word.
  */
 static inline __be16 *
@@ -464,104 +419,6 @@ xfs_dir2_data_unused_tag_p(struct xfs_dir2_data_unused *dup)
                         be16_to_cpu(dup->length) - sizeof(__be16));
 }
 
-static inline size_t
-xfs_dir3_data_hdr_size(bool dir3)
-{
-        if (dir3)
-                return sizeof(struct xfs_dir3_data_hdr);
-        return sizeof(struct xfs_dir2_data_hdr);
-}
-
-static inline size_t
-xfs_dir3_data_entry_offset(struct xfs_dir2_data_hdr *hdr)
-{
-        bool dir3 = hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
-                    hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC);
-        return xfs_dir3_data_hdr_size(dir3);
-}
-
-static inline struct xfs_dir2_data_entry *
-xfs_dir3_data_entry_p(struct xfs_dir2_data_hdr *hdr)
-{
-        return (struct xfs_dir2_data_entry *)
-                ((char *)hdr + xfs_dir3_data_entry_offset(hdr));
-}
-
-static inline struct xfs_dir2_data_unused *
-xfs_dir3_data_unused_p(struct xfs_dir2_data_hdr *hdr)
-{
-        return (struct xfs_dir2_data_unused *)
-                ((char *)hdr + xfs_dir3_data_entry_offset(hdr));
-}
-
-/*
- * Offsets of . and .. in data space (always block 0)
- *
- * The macros are used for shortform directories as they have no headers to read
- * the magic number out of. Shortform directories need to know the size of the
- * data block header because the sfe embeds the block offset of the entry into
- * it so that it doesn't change when format conversion occurs. Bad Things Happen
- * if we don't follow this rule.
- *
- * XXX: there is scope for significant optimisation of the logic here. Right
- * now we are checking for "dir3 format" over and over again. Ideally we should
- * only do it once for each operation.
- */
-#define XFS_DIR3_DATA_DOT_OFFSET(mp)    \
-        xfs_dir3_data_hdr_size(xfs_sb_version_hascrc(&(mp)->m_sb))
-#define XFS_DIR3_DATA_DOTDOT_OFFSET(mp) \
-        (XFS_DIR3_DATA_DOT_OFFSET(mp) + xfs_dir3_data_entsize(mp, 1))
-#define XFS_DIR3_DATA_FIRST_OFFSET(mp)          \
-        (XFS_DIR3_DATA_DOTDOT_OFFSET(mp) + xfs_dir3_data_entsize(mp, 2))
-
-static inline xfs_dir2_data_aoff_t
-xfs_dir3_data_dot_offset(struct xfs_dir2_data_hdr *hdr)
-{
-        return xfs_dir3_data_entry_offset(hdr);
-}
-
-static inline xfs_dir2_data_aoff_t
-xfs_dir3_data_dotdot_offset(struct xfs_dir2_data_hdr *hdr)
-{
-        bool dir3 = hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
-                    hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC);
-        return xfs_dir3_data_dot_offset(hdr) +
-                __xfs_dir3_data_entsize(dir3, 1);
-}
-
-static inline xfs_dir2_data_aoff_t
-xfs_dir3_data_first_offset(struct xfs_dir2_data_hdr *hdr)
-{
-        bool dir3 = hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
-                    hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC);
-        return xfs_dir3_data_dotdot_offset(hdr) +
-                __xfs_dir3_data_entsize(dir3, 2);
-}
-
-/*
- * location of . and .. in data space (always block 0)
- */
-static inline struct xfs_dir2_data_entry *
-xfs_dir3_data_dot_entry_p(struct xfs_dir2_data_hdr *hdr)
-{
-        return (struct xfs_dir2_data_entry *)
-                ((char *)hdr + xfs_dir3_data_dot_offset(hdr));
-}
-
-static inline struct xfs_dir2_data_entry *
-xfs_dir3_data_dotdot_entry_p(struct xfs_dir2_data_hdr *hdr)
-{
-        return (struct xfs_dir2_data_entry *)
-                ((char *)hdr + xfs_dir3_data_dotdot_offset(hdr));
-}
-
-static inline struct xfs_dir2_data_entry *
-xfs_dir3_data_first_entry_p(struct xfs_dir2_data_hdr *hdr)
-{
-        return (struct xfs_dir2_data_entry *)
-                ((char *)hdr + xfs_dir3_data_first_offset(hdr));
-}
-
 /*
  * Leaf block structures.
  *
@@ -656,39 +513,6 @@ struct xfs_dir3_leaf {
 
 #define XFS_DIR3_LEAF_CRC_OFF  offsetof(struct xfs_dir3_leaf_hdr, info.crc)
 
-extern void xfs_dir3_leaf_hdr_from_disk(struct xfs_dir3_icleaf_hdr *to,
-                                        struct xfs_dir2_leaf *from);
-
-static inline int
-xfs_dir3_leaf_hdr_size(struct xfs_dir2_leaf *lp)
-{
-        if (lp->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC) ||
-            lp->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC))
-                return sizeof(struct xfs_dir3_leaf_hdr);
-        return sizeof(struct xfs_dir2_leaf_hdr);
-}
-
-static inline int
-xfs_dir3_max_leaf_ents(struct xfs_mount *mp, struct xfs_dir2_leaf *lp)
-{
-        return (mp->m_dirblksize - xfs_dir3_leaf_hdr_size(lp)) /
-                (uint)sizeof(struct xfs_dir2_leaf_entry);
-}
-
-/*
- * Get address of the bestcount field in the single-leaf block.
- */
-static inline struct xfs_dir2_leaf_entry *
-xfs_dir3_leaf_ents_p(struct xfs_dir2_leaf *lp)
-{
-        if (lp->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAF1_MAGIC) ||
-            lp->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC)) {
-                struct xfs_dir3_leaf *lp3 = (struct xfs_dir3_leaf *)lp;
-                return lp3->__ents;
-        }
-        return lp->__ents;
-}
-
 /*
  * Get address of the bestcount field in the single-leaf block.
  */
@@ -880,48 +704,6 @@ struct xfs_dir3_icfree_hdr {
 
 };
 
-void xfs_dir3_free_hdr_from_disk(struct xfs_dir3_icfree_hdr *to,
-                                 struct xfs_dir2_free *from);
-
-static inline int
-xfs_dir3_free_hdr_size(struct xfs_mount *mp)
-{
-        if (xfs_sb_version_hascrc(&mp->m_sb))
-                return sizeof(struct xfs_dir3_free_hdr);
-        return sizeof(struct xfs_dir2_free_hdr);
-}
-
-static inline int
-xfs_dir3_free_max_bests(struct xfs_mount *mp)
-{
-        return (mp->m_dirblksize - xfs_dir3_free_hdr_size(mp)) /
-                sizeof(xfs_dir2_data_off_t);
-}
-
-static inline __be16 *
-xfs_dir3_free_bests_p(struct xfs_mount *mp, struct xfs_dir2_free *free)
-{
-        return (__be16 *)((char *)free + xfs_dir3_free_hdr_size(mp));
-}
-
-/*
- * Convert data space db to the corresponding free db.
- */
-static inline xfs_dir2_db_t
-xfs_dir2_db_to_fdb(struct xfs_mount *mp, xfs_dir2_db_t db)
-{
-        return XFS_DIR2_FREE_FIRSTDB(mp) + db / xfs_dir3_free_max_bests(mp);
-}
-
-/*
- * Convert data space db to the corresponding index in a free db.
- */
-static inline int
-xfs_dir2_db_to_fdindex(struct xfs_mount *mp, xfs_dir2_db_t db)
-{
-        return db % xfs_dir3_free_max_bests(mp);
-}
-
 /*
  * Single block format.
  *
@@ -972,4 +754,262 @@ xfs_dir2_block_leaf_p(struct xfs_dir2_block_tail *btp)
         return ((struct xfs_dir2_leaf_entry *)btp) - be32_to_cpu(btp->count);
 }
 
-#endif /* __XFS_DIR2_FORMAT_H__ */
+
+/*
+ * Attribute storage layout
+ *
+ * Attribute lists are structured around Btrees where all the data
+ * elements are in the leaf nodes.  Attribute names are hashed into an int,
+ * then that int is used as the index into the Btree.  Since the hashval
+ * of an attribute name may not be unique, we may have duplicate keys.  The
+ * internal links in the Btree are logical block offsets into the file.
+ *
+ *========================================================================
+ * Attribute structure when equal to XFS_LBSIZE(mp) bytes.
+ *========================================================================
+ *
+ * Struct leaf_entry's are packed from the top.  Name/values 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 name/value area and try again.  If we
+ * still don't have enough space, then we have to split the block.  The
+ * name/value structs (both local and remote versions) must be 32bit aligned.
+ *
+ * Since we have duplicate hash keys, for each key that matches, compare
+ * the actual name 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 attribute name is found.
+ *
+ * We store the fact that an attribute is a ROOT/USER/SECURE attribute in
+ * the leaf_entry.  The namespaces are independent only because we also look
+ * at the namespace bit when we are looking for a matching attribute name.
+ *
+ * We also store an "incomplete" bit in the leaf_entry.  It shows that an
+ * attribute is in the middle of being created and should not be shown to
+ * the user if we crash during the time that the bit is set.  We clear the
+ * bit when we have finished setting up the attribute.  We do this because
+ * we cannot create some large attributes inside a single transaction, and we
+ * need some indication that we weren't finished if we crash in the middle.
+ */
+#define XFS_ATTR_LEAF_MAPSIZE   3       /* how many freespace slots */
+
+typedef struct xfs_attr_leaf_map {      /* RLE map of free bytes */
+        __be16  base;                     /* base of free region */
+        __be16  size;                     /* length of free region */
+} xfs_attr_leaf_map_t;
+
+typedef struct xfs_attr_leaf_hdr {      /* constant-structure header block */
+        xfs_da_blkinfo_t info;          /* block type, links, etc. */
+        __be16  count;                  /* count of active leaf_entry's */
+        __be16  usedbytes;              /* num bytes of names/values stored */
+        __be16  firstused;              /* first used byte in name area */
+        __u8    holes;                  /* != 0 if blk needs compaction */
+        __u8    pad1;
+        xfs_attr_leaf_map_t freemap[XFS_ATTR_LEAF_MAPSIZE];
+                                        /* N largest free regions */
+} xfs_attr_leaf_hdr_t;
+
+typedef struct xfs_attr_leaf_entry {    /* sorted on key, not name */
+        __be32  hashval;                /* hash value of name */
+        __be16  nameidx;                /* index into buffer of name/value */
+        __u8    flags;                  /* LOCAL/ROOT/SECURE/INCOMPLETE flag */
+        __u8    pad2;                   /* unused pad byte */
+} xfs_attr_leaf_entry_t;
+
+typedef struct xfs_attr_leaf_name_local {
+        __be16  valuelen;               /* number of bytes in value */
+        __u8    namelen;                /* length of name bytes */
+        __u8    nameval[1];             /* name/value bytes */
+} xfs_attr_leaf_name_local_t;
+
+typedef struct xfs_attr_leaf_name_remote {
+        __be32  valueblk;               /* block number of value bytes */
+        __be32  valuelen;               /* number of bytes in value */
+        __u8    namelen;                /* length of name bytes */
+        __u8    name[1];                /* name bytes */
+} xfs_attr_leaf_name_remote_t;
+
+typedef struct xfs_attr_leafblock {
+        xfs_attr_leaf_hdr_t     hdr;    /* constant-structure header block */
+        xfs_attr_leaf_entry_t   entries[1];     /* sorted on key, not name */
+        xfs_attr_leaf_name_local_t namelist;    /* grows from bottom of buf */
+        xfs_attr_leaf_name_remote_t valuelist;  /* grows from bottom of buf */
+} xfs_attr_leafblock_t;
+
+/*
+ * CRC enabled leaf structures. Called "version 3" structures to match the
+ * version number of the directory and dablk structures for this feature, and
+ * attr2 is already taken by the variable inode attribute fork size feature.
+ */
+struct xfs_attr3_leaf_hdr {
+        struct xfs_da3_blkinfo  info;
+        __be16                  count;
+        __be16                  usedbytes;
+        __be16                  firstused;
+        __u8                    holes;
+        __u8                    pad1;
+        struct xfs_attr_leaf_map freemap[XFS_ATTR_LEAF_MAPSIZE];
+        __be32                  pad2;           /* 64 bit alignment */
+};
+
+#define XFS_ATTR3_LEAF_CRC_OFF  (offsetof(struct xfs_attr3_leaf_hdr, info.crc))
+
+struct xfs_attr3_leafblock {
+        struct xfs_attr3_leaf_hdr       hdr;
+        struct xfs_attr_leaf_entry      entries[1];
+
+        /*
+         * The rest of the block contains the following structures after the
+         * leaf entries, growing from the bottom up. The variables are never
+         * referenced, the locations accessed purely from helper functions.
+         *
+         * struct xfs_attr_leaf_name_local
+         * struct xfs_attr_leaf_name_remote
+         */
+};
+
+/*
+ * incore, neutral version of the attribute leaf header
+ */
+struct xfs_attr3_icleaf_hdr {
+        __uint32_t      forw;
+        __uint32_t      back;
+        __uint16_t      magic;
+        __uint16_t      count;
+        __uint16_t      usedbytes;
+        __uint16_t      firstused;
+        __u8            holes;
+        struct {
+                __uint16_t      base;
+                __uint16_t      size;
+        } freemap[XFS_ATTR_LEAF_MAPSIZE];
+};
+
+/*
+ * Flags used in the leaf_entry[i].flags field.
+ * NOTE: the INCOMPLETE bit must not collide with the flags bits specified
+ * on the system call, they are "or"ed together for various operations.
+ */
+#define XFS_ATTR_LOCAL_BIT      0       /* attr is stored locally */
+#define XFS_ATTR_ROOT_BIT       1       /* limit access to trusted attrs */
+#define XFS_ATTR_SECURE_BIT     2       /* limit access to secure attrs */
+#define XFS_ATTR_INCOMPLETE_BIT 7       /* attr in middle of create/delete */
+#define XFS_ATTR_LOCAL          (1 << XFS_ATTR_LOCAL_BIT)
+#define XFS_ATTR_ROOT           (1 << XFS_ATTR_ROOT_BIT)
+#define XFS_ATTR_SECURE         (1 << XFS_ATTR_SECURE_BIT)
+#define XFS_ATTR_INCOMPLETE     (1 << XFS_ATTR_INCOMPLETE_BIT)
+
+/*
+ * Conversion macros for converting namespace bits from argument flags
+ * to ondisk flags.
+ */
+#define XFS_ATTR_NSP_ARGS_MASK          (ATTR_ROOT | ATTR_SECURE)
+#define XFS_ATTR_NSP_ONDISK_MASK        (XFS_ATTR_ROOT | XFS_ATTR_SECURE)
+#define XFS_ATTR_NSP_ONDISK(flags)      ((flags) & XFS_ATTR_NSP_ONDISK_MASK)
+#define XFS_ATTR_NSP_ARGS(flags)        ((flags) & XFS_ATTR_NSP_ARGS_MASK)
+#define XFS_ATTR_NSP_ARGS_TO_ONDISK(x)  (((x) & ATTR_ROOT ? XFS_ATTR_ROOT : 0) |\
+                                         ((x) & ATTR_SECURE ? XFS_ATTR_SECURE : 0))
+#define XFS_ATTR_NSP_ONDISK_TO_ARGS(x)  (((x) & XFS_ATTR_ROOT ? ATTR_ROOT : 0) |\
+                                         ((x) & XFS_ATTR_SECURE ? ATTR_SECURE : 0))
+
+/*
+ * Alignment for namelist and valuelist entries (since they are mixed
+ * there can be only one alignment value)
+ */
+#define XFS_ATTR_LEAF_NAME_ALIGN        ((uint)sizeof(xfs_dablk_t))
+
+static inline int
+xfs_attr3_leaf_hdr_size(struct xfs_attr_leafblock *leafp)
+{
+        if (leafp->hdr.info.magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC))
+                return sizeof(struct xfs_attr3_leaf_hdr);
+        return sizeof(struct xfs_attr_leaf_hdr);
+}
+
+static inline struct xfs_attr_leaf_entry *
+xfs_attr3_leaf_entryp(xfs_attr_leafblock_t *leafp)
+{
+        if (leafp->hdr.info.magic == cpu_to_be16(XFS_ATTR3_LEAF_MAGIC))
+                return &((struct xfs_attr3_leafblock *)leafp)->entries[0];
+        return &leafp->entries[0];
+}
+
+/*
+ * Cast typed pointers for "local" and "remote" name/value structs.
+ */
+static inline char *
+xfs_attr3_leaf_name(xfs_attr_leafblock_t *leafp, int idx)
+{
+        struct xfs_attr_leaf_entry *entries = xfs_attr3_leaf_entryp(leafp);
+
+        return &((char *)leafp)[be16_to_cpu(entries[idx].nameidx)];
+}
+
+static inline xfs_attr_leaf_name_remote_t *
+xfs_attr3_leaf_name_remote(xfs_attr_leafblock_t *leafp, int idx)
+{
+        return (xfs_attr_leaf_name_remote_t *)xfs_attr3_leaf_name(leafp, idx);
+}
+
+static inline xfs_attr_leaf_name_local_t *
+xfs_attr3_leaf_name_local(xfs_attr_leafblock_t *leafp, int idx)
+{
+        return (xfs_attr_leaf_name_local_t *)xfs_attr3_leaf_name(leafp, idx);
+}
+
+/*
+ * Calculate total bytes used (including trailing pad for alignment) for
+ * a "local" name/value structure, a "remote" name/value structure, and
+ * a pointer which might be either.
+ */
+static inline int xfs_attr_leaf_entsize_remote(int nlen)
+{
+        return ((uint)sizeof(xfs_attr_leaf_name_remote_t) - 1 + (nlen) + \
+                XFS_ATTR_LEAF_NAME_ALIGN - 1) & ~(XFS_ATTR_LEAF_NAME_ALIGN - 1);
+}
+
+static inline int xfs_attr_leaf_entsize_local(int nlen, int vlen)
+{
+        return ((uint)sizeof(xfs_attr_leaf_name_local_t) - 1 + (nlen) + (vlen) +
+                XFS_ATTR_LEAF_NAME_ALIGN - 1) & ~(XFS_ATTR_LEAF_NAME_ALIGN - 1);
+}
+
+static inline int xfs_attr_leaf_entsize_local_max(int bsize)
+{
+        return (((bsize) >> 1) + ((bsize) >> 2));
+}
+
+
+
+/*
+ * Remote attribute block format definition
+ *
+ * There is one of these headers per filesystem block in a remote attribute.
+ * This is done to ensure there is a 1:1 mapping between the attribute value
+ * length and the number of blocks needed to store the attribute. This makes the
+ * verification of a buffer a little more complex, but greatly simplifies the
+ * allocation, reading and writing of these attributes as we don't have to guess
+ * the number of blocks needed to store the attribute data.
+ */
+#define XFS_ATTR3_RMT_MAGIC     0x5841524d      /* XARM */
+
+struct xfs_attr3_rmt_hdr {
+        __be32  rm_magic;
+        __be32  rm_offset;
+        __be32  rm_bytes;
+        __be32  rm_crc;
+        uuid_t  rm_uuid;
+        __be64  rm_owner;
+        __be64  rm_blkno;
+        __be64  rm_lsn;
+};
+
+#define XFS_ATTR3_RMT_CRC_OFF   offsetof(struct xfs_attr3_rmt_hdr, rm_crc)
+
+#define XFS_ATTR3_RMT_BUF_SPACE(mp, bufsize)    \
+        ((bufsize) - (xfs_sb_version_hascrc(&(mp)->m_sb) ? \
+                        sizeof(struct xfs_attr3_rmt_hdr) : 0))
+
+#endif /* __XFS_DA_FORMAT_H__ */
diff --git a/fs/xfs/xfs_dir2.c b/fs/xfs/xfs_dir2.c
index edf203ab50af..ce16ef02997a 100644
--- a/fs/xfs/xfs_dir2.c
+++ b/fs/xfs/xfs_dir2.c
@@ -17,25 +17,24 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_inum.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_da_format.h"
 #include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
 #include "xfs_bmap.h"
-#include "xfs_dir2_format.h"
 #include "xfs_dir2.h"
 #include "xfs_dir2_priv.h"
 #include "xfs_error.h"
 #include "xfs_trace.h"
+#include "xfs_dinode.h"
 
 struct xfs_name xfs_name_dotdot = { (unsigned char *)"..", 2, XFS_DIR3_FT_DIR };
 
@@ -96,13 +95,17 @@ xfs_dir_mount(
         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_dir_inode_ops = xfs_dir_get_ops(mp, NULL);
+        mp->m_nondir_inode_ops = xfs_nondir_get_ops(mp, NULL);
+
         mp->m_dirblksize = 1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog);
         mp->m_dirblkfsbs = 1 << mp->m_sb.sb_dirblklog;
         mp->m_dirdatablk = xfs_dir2_db_to_da(mp, XFS_DIR2_DATA_FIRSTDB(mp));
         mp->m_dirleafblk = xfs_dir2_db_to_da(mp, XFS_DIR2_LEAF_FIRSTDB(mp));
         mp->m_dirfreeblk = xfs_dir2_db_to_da(mp, XFS_DIR2_FREE_FIRSTDB(mp));
 
-        nodehdr_size = __xfs_da3_node_hdr_size(xfs_sb_version_hascrc(&mp->m_sb));
+        nodehdr_size = mp->m_dir_inode_ops->node_hdr_size;
         mp->m_attr_node_ents = (mp->m_sb.sb_blocksize - nodehdr_size) /
                                 (uint)sizeof(xfs_da_node_entry_t);
         mp->m_dir_node_ents = (mp->m_dirblksize - nodehdr_size) /
@@ -113,6 +116,7 @@ xfs_dir_mount(
                 mp->m_dirnameops = &xfs_ascii_ci_nameops;
         else
                 mp->m_dirnameops = &xfs_default_nameops;
+
 }
 
 /*
diff --git a/fs/xfs/xfs_dir2.h b/fs/xfs/xfs_dir2.h
index 9910401327d4..cec70e0781ab 100644
--- a/fs/xfs/xfs_dir2.h
+++ b/fs/xfs/xfs_dir2.h
@@ -32,6 +32,83 @@ struct xfs_dir2_data_unused;
 extern struct xfs_name  xfs_name_dotdot;
 
 /*
+ * directory operations vector for encode/decode routines
+ */
+struct xfs_dir_ops {
+        int     (*sf_entsize)(struct xfs_dir2_sf_hdr *hdr, int len);
+        struct xfs_dir2_sf_entry *
+                (*sf_nextentry)(struct xfs_dir2_sf_hdr *hdr,
+                                struct xfs_dir2_sf_entry *sfep);
+        __uint8_t (*sf_get_ftype)(struct xfs_dir2_sf_entry *sfep);
+        void    (*sf_put_ftype)(struct xfs_dir2_sf_entry *sfep,
+                                __uint8_t ftype);
+        xfs_ino_t (*sf_get_ino)(struct xfs_dir2_sf_hdr *hdr,
+                                struct xfs_dir2_sf_entry *sfep);
+        void    (*sf_put_ino)(struct xfs_dir2_sf_hdr *hdr,
+                              struct xfs_dir2_sf_entry *sfep,
+                              xfs_ino_t ino);
+        xfs_ino_t (*sf_get_parent_ino)(struct xfs_dir2_sf_hdr *hdr);
+        void    (*sf_put_parent_ino)(struct xfs_dir2_sf_hdr *hdr,
+                                     xfs_ino_t ino);
+
+        int     (*data_entsize)(int len);
+        __uint8_t (*data_get_ftype)(struct xfs_dir2_data_entry *dep);
+        void    (*data_put_ftype)(struct xfs_dir2_data_entry *dep,
+                                __uint8_t ftype);
+        __be16 * (*data_entry_tag_p)(struct xfs_dir2_data_entry *dep);
+        struct xfs_dir2_data_free *
+                (*data_bestfree_p)(struct xfs_dir2_data_hdr *hdr);
+
+        xfs_dir2_data_aoff_t data_dot_offset;
+        xfs_dir2_data_aoff_t data_dotdot_offset;
+        xfs_dir2_data_aoff_t data_first_offset;
+        size_t  data_entry_offset;
+
+        struct xfs_dir2_data_entry *
+                (*data_dot_entry_p)(struct xfs_dir2_data_hdr *hdr);
+        struct xfs_dir2_data_entry *
+                (*data_dotdot_entry_p)(struct xfs_dir2_data_hdr *hdr);
+        struct xfs_dir2_data_entry *
+                (*data_first_entry_p)(struct xfs_dir2_data_hdr *hdr);
+        struct xfs_dir2_data_entry *
+                (*data_entry_p)(struct xfs_dir2_data_hdr *hdr);
+        struct xfs_dir2_data_unused *
+                (*data_unused_p)(struct xfs_dir2_data_hdr *hdr);
+
+        int     leaf_hdr_size;
+        void    (*leaf_hdr_to_disk)(struct xfs_dir2_leaf *to,
+                                    struct xfs_dir3_icleaf_hdr *from);
+        void    (*leaf_hdr_from_disk)(struct xfs_dir3_icleaf_hdr *to,
+                                      struct xfs_dir2_leaf *from);
+        int     (*leaf_max_ents)(struct xfs_mount *mp);
+        struct xfs_dir2_leaf_entry *
+                (*leaf_ents_p)(struct xfs_dir2_leaf *lp);
+
+        int     node_hdr_size;
+        void    (*node_hdr_to_disk)(struct xfs_da_intnode *to,
+                                    struct xfs_da3_icnode_hdr *from);
+        void    (*node_hdr_from_disk)(struct xfs_da3_icnode_hdr *to,
+                                      struct xfs_da_intnode *from);
+        struct xfs_da_node_entry *
+                (*node_tree_p)(struct xfs_da_intnode *dap);
+
+        int     free_hdr_size;
+        void    (*free_hdr_to_disk)(struct xfs_dir2_free *to,
+                                    struct xfs_dir3_icfree_hdr *from);
+        void    (*free_hdr_from_disk)(struct xfs_dir3_icfree_hdr *to,
+                                      struct xfs_dir2_free *from);
+        int     (*free_max_bests)(struct xfs_mount *mp);
+        __be16 * (*free_bests_p)(struct xfs_dir2_free *free);
+        xfs_dir2_db_t (*db_to_fdb)(struct xfs_mount *mp, xfs_dir2_db_t db);
+        int     (*db_to_fdindex)(struct xfs_mount *mp, xfs_dir2_db_t db);
+};
+
+extern const struct xfs_dir_ops *
+        xfs_dir_get_ops(struct xfs_mount *mp, struct xfs_inode *dp);
+extern const struct xfs_dir_ops *
+        xfs_nondir_get_ops(struct xfs_mount *mp, struct xfs_inode *dp);
+
+/*
  * Generic directory interface routines
  */
 extern void xfs_dir_startup(void);
@@ -65,37 +142,30 @@ extern int xfs_dir2_sf_to_block(struct xfs_da_args *args);
 /*
  * Interface routines used by userspace utilities
  */
-extern xfs_ino_t xfs_dir2_sf_get_parent_ino(struct xfs_dir2_sf_hdr *sfp);
-extern void xfs_dir2_sf_put_parent_ino(struct xfs_dir2_sf_hdr *sfp,
-                xfs_ino_t ino);
-extern xfs_ino_t xfs_dir3_sfe_get_ino(struct xfs_mount *mp,
-                struct xfs_dir2_sf_hdr *sfp, struct xfs_dir2_sf_entry *sfep);
-extern void xfs_dir3_sfe_put_ino(struct xfs_mount *mp,
-                struct xfs_dir2_sf_hdr *hdr, struct xfs_dir2_sf_entry *sfep,
-                xfs_ino_t ino);
-
 extern int xfs_dir2_isblock(struct xfs_trans *tp, struct xfs_inode *dp, int *r);
 extern int xfs_dir2_isleaf(struct xfs_trans *tp, struct xfs_inode *dp, int *r);
 extern int xfs_dir2_shrink_inode(struct xfs_da_args *args, xfs_dir2_db_t db,
                                 struct xfs_buf *bp);
 
-extern void xfs_dir2_data_freescan(struct xfs_mount *mp,
+extern void xfs_dir2_data_freescan(struct xfs_inode *dp,
                 struct xfs_dir2_data_hdr *hdr, int *loghead);
-extern void xfs_dir2_data_log_entry(struct xfs_trans *tp, struct xfs_buf *bp,
-                struct xfs_dir2_data_entry *dep);
-extern void xfs_dir2_data_log_header(struct xfs_trans *tp,
+extern void xfs_dir2_data_log_entry(struct xfs_trans *tp, struct xfs_inode *dp,
+                struct xfs_buf *bp, struct xfs_dir2_data_entry *dep);
+extern void xfs_dir2_data_log_header(struct xfs_trans *tp, struct xfs_inode *dp,
                 struct xfs_buf *bp);
 extern void xfs_dir2_data_log_unused(struct xfs_trans *tp, struct xfs_buf *bp,
                 struct xfs_dir2_data_unused *dup);
-extern void xfs_dir2_data_make_free(struct xfs_trans *tp, struct xfs_buf *bp,
+extern void xfs_dir2_data_make_free(struct xfs_trans *tp, struct xfs_inode *dp,
+                struct xfs_buf *bp, xfs_dir2_data_aoff_t offset,
+                xfs_dir2_data_aoff_t len, int *needlogp, int *needscanp);
+extern void xfs_dir2_data_use_free(struct xfs_trans *tp, struct xfs_inode *dp,
+                struct xfs_buf *bp, struct xfs_dir2_data_unused *dup,
                 xfs_dir2_data_aoff_t offset, xfs_dir2_data_aoff_t len,
                 int *needlogp, int *needscanp);
-extern void xfs_dir2_data_use_free(struct xfs_trans *tp, struct xfs_buf *bp,
-                struct xfs_dir2_data_unused *dup, xfs_dir2_data_aoff_t offset,
-                xfs_dir2_data_aoff_t len, int *needlogp, int *needscanp);
 
 extern struct xfs_dir2_data_free *xfs_dir2_data_freefind(
-                struct xfs_dir2_data_hdr *hdr, struct xfs_dir2_data_unused *dup);
+                struct xfs_dir2_data_hdr *hdr, struct xfs_dir2_data_free *bf,
+                struct xfs_dir2_data_unused *dup);
 
 extern const struct xfs_buf_ops xfs_dir3_block_buf_ops;
 extern const struct xfs_buf_ops xfs_dir3_leafn_buf_ops;
diff --git a/fs/xfs/xfs_dir2_block.c b/fs/xfs/xfs_dir2_block.c
index 0957aa98b6c0..90cdbf4b5f19 100644
--- a/fs/xfs/xfs_dir2_block.c
+++ b/fs/xfs/xfs_dir2_block.c
@@ -18,25 +18,25 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_da_format.h"
 #include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
 #include "xfs_bmap.h"
 #include "xfs_buf_item.h"
-#include "xfs_dir2_format.h"
 #include "xfs_dir2.h"
 #include "xfs_dir2_priv.h"
 #include "xfs_error.h"
 #include "xfs_trace.h"
 #include "xfs_cksum.h"
+#include "xfs_dinode.h"
 
 /*
  * Local function prototypes.
@@ -168,6 +168,7 @@ xfs_dir3_block_init(
 
 static void
 xfs_dir2_block_need_space(
+        struct xfs_inode                *dp,
         struct xfs_dir2_data_hdr        *hdr,
         struct xfs_dir2_block_tail      *btp,
         struct xfs_dir2_leaf_entry      *blp,
@@ -183,7 +184,7 @@ xfs_dir2_block_need_space(
         struct xfs_dir2_data_unused     *enddup = NULL;
 
         *compact = 0;
-        bf = xfs_dir3_data_bestfree_p(hdr);
+        bf = dp->d_ops->data_bestfree_p(hdr);
 
         /*
          * If there are stale entries we'll use one for the leaf.
@@ -280,6 +281,7 @@ out:
 static void
 xfs_dir2_block_compact(
         struct xfs_trans                *tp,
+        struct xfs_inode                *dp,
         struct xfs_buf                  *bp,
         struct xfs_dir2_data_hdr        *hdr,
         struct xfs_dir2_block_tail      *btp,
@@ -312,7 +314,7 @@ xfs_dir2_block_compact(
         *lfloglow = toidx + 1 - (be32_to_cpu(btp->stale) - 1);
         *lfloghigh -= be32_to_cpu(btp->stale) - 1;
         be32_add_cpu(&btp->count, -(be32_to_cpu(btp->stale) - 1));
-        xfs_dir2_data_make_free(tp, bp,
+        xfs_dir2_data_make_free(tp, dp, bp,
                 (xfs_dir2_data_aoff_t)((char *)blp - (char *)hdr),
                 (xfs_dir2_data_aoff_t)((be32_to_cpu(btp->stale) - 1) * sizeof(*blp)),
                 needlog, &needscan);
@@ -323,7 +325,7 @@ xfs_dir2_block_compact(
          * This needs to happen before the next call to use_free.
          */
         if (needscan)
-                xfs_dir2_data_freescan(tp->t_mountp, hdr, needlog);
+                xfs_dir2_data_freescan(dp, hdr, needlog);
 }
 
 /*
@@ -369,7 +371,7 @@ xfs_dir2_block_addname(
         if (error)
                 return error;
 
-        len = xfs_dir3_data_entsize(mp, args->namelen);
+        len = dp->d_ops->data_entsize(args->namelen);
 
         /*
          * Set up pointers to parts of the block.
@@ -382,7 +384,7 @@ xfs_dir2_block_addname(
          * Find out if we can reuse stale entries or whether we need extra
          * space for entry and new leaf.
          */
-        xfs_dir2_block_need_space(hdr, btp, blp, &tagp, &dup,
+        xfs_dir2_block_need_space(dp, hdr, btp, blp, &tagp, &dup,
                                   &enddup, &compact, len);
 
         /*
@@ -418,7 +420,7 @@ xfs_dir2_block_addname(
          * If need to compact the leaf entries, do it now.
          */
         if (compact) {
-                xfs_dir2_block_compact(tp, bp, hdr, btp, blp, &needlog,
+                xfs_dir2_block_compact(tp, dp, bp, hdr, btp, blp, &needlog,
                                       &lfloghigh, &lfloglow);
                 /* recalculate blp post-compaction */
                 blp = xfs_dir2_block_leaf_p(btp);
@@ -453,7 +455,7 @@ xfs_dir2_block_addname(
                 /*
                  * Mark the space needed for the new leaf entry, now in use.
                  */
-                xfs_dir2_data_use_free(tp, bp, enddup,
+                xfs_dir2_data_use_free(tp, dp, bp, enddup,
                         (xfs_dir2_data_aoff_t)
                         ((char *)enddup - (char *)hdr + be16_to_cpu(enddup->length) -
                          sizeof(*blp)),
@@ -468,7 +470,7 @@ xfs_dir2_block_addname(
                  * This needs to happen before the next call to use_free.
                  */
                 if (needscan) {
-                        xfs_dir2_data_freescan(mp, hdr, &needlog);
+                        xfs_dir2_data_freescan(dp, hdr, &needlog);
                         needscan = 0;
                 }
                 /*
@@ -540,7 +542,7 @@ xfs_dir2_block_addname(
         /*
          * Mark space for the data entry used.
          */
-        xfs_dir2_data_use_free(tp, bp, dup,
+        xfs_dir2_data_use_free(tp, dp, bp, dup,
                 (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr),
                 (xfs_dir2_data_aoff_t)len, &needlog, &needscan);
         /*
@@ -549,18 +551,18 @@ xfs_dir2_block_addname(
         dep->inumber = cpu_to_be64(args->inumber);
         dep->namelen = args->namelen;
         memcpy(dep->name, args->name, args->namelen);
-        xfs_dir3_dirent_put_ftype(mp, dep, args->filetype);
-        tagp = xfs_dir3_data_entry_tag_p(mp, dep);
+        dp->d_ops->data_put_ftype(dep, args->filetype);
+        tagp = dp->d_ops->data_entry_tag_p(dep);
         *tagp = cpu_to_be16((char *)dep - (char *)hdr);
         /*
          * Clean up the bestfree array and log the header, tail, and entry.
          */
         if (needscan)
-                xfs_dir2_data_freescan(mp, hdr, &needlog);
+                xfs_dir2_data_freescan(dp, hdr, &needlog);
         if (needlog)
-                xfs_dir2_data_log_header(tp, bp);
+                xfs_dir2_data_log_header(tp, dp, bp);
         xfs_dir2_block_log_tail(tp, bp);
-        xfs_dir2_data_log_entry(tp, bp, dep);
+        xfs_dir2_data_log_entry(tp, dp, bp, dep);
         xfs_dir3_data_check(dp, bp);
         return 0;
 }
@@ -642,7 +644,7 @@ xfs_dir2_block_lookup(
          * Fill in inode number, CI name if appropriate, release the block.
          */
         args->inumber = be64_to_cpu(dep->inumber);
-        args->filetype = xfs_dir3_dirent_get_ftype(mp, dep);
+        args->filetype = dp->d_ops->data_get_ftype(dep);
         error = xfs_dir_cilookup_result(args, dep->name, dep->namelen);
         xfs_trans_brelse(args->trans, bp);
         return XFS_ERROR(error);
@@ -799,9 +801,9 @@ xfs_dir2_block_removename(
          * Mark the data entry's space free.
          */
         needlog = needscan = 0;
-        xfs_dir2_data_make_free(tp, bp,
+        xfs_dir2_data_make_free(tp, dp, bp,
                 (xfs_dir2_data_aoff_t)((char *)dep - (char *)hdr),
-                xfs_dir3_data_entsize(mp, dep->namelen), &needlog, &needscan);
+                dp->d_ops->data_entsize(dep->namelen), &needlog, &needscan);
         /*
          * Fix up the block tail.
          */
@@ -816,9 +818,9 @@ xfs_dir2_block_removename(
          * Fix up bestfree, log the header if necessary.
          */
         if (needscan)
-                xfs_dir2_data_freescan(mp, hdr, &needlog);
+                xfs_dir2_data_freescan(dp, hdr, &needlog);
         if (needlog)
-                xfs_dir2_data_log_header(tp, bp);
+                xfs_dir2_data_log_header(tp, dp, bp);
         xfs_dir3_data_check(dp, bp);
         /*
          * See if the size as a shortform is good enough.
@@ -875,8 +877,8 @@ xfs_dir2_block_replace(
          * Change the inode number to the new value.
          */
         dep->inumber = cpu_to_be64(args->inumber);
-        xfs_dir3_dirent_put_ftype(mp, dep, args->filetype);
-        xfs_dir2_data_log_entry(args->trans, bp, dep);
+        dp->d_ops->data_put_ftype(dep, args->filetype);
+        xfs_dir2_data_log_entry(args->trans, dp, bp, dep);
         xfs_dir3_data_check(dp, bp);
         return 0;
 }
@@ -934,8 +936,8 @@ xfs_dir2_leaf_to_block(
         tp = args->trans;
         mp = dp->i_mount;
         leaf = lbp->b_addr;
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
         ltp = xfs_dir2_leaf_tail_p(mp, leaf);
 
         ASSERT(leafhdr.magic == XFS_DIR2_LEAF1_MAGIC ||
@@ -949,7 +951,7 @@ xfs_dir2_leaf_to_block(
         while (dp->i_d.di_size > mp->m_dirblksize) {
                 int hdrsz;
 
-                hdrsz = xfs_dir3_data_hdr_size(xfs_sb_version_hascrc(&mp->m_sb));
+                hdrsz = dp->d_ops->data_entry_offset;
                 bestsp = xfs_dir2_leaf_bests_p(ltp);
                 if (be16_to_cpu(bestsp[be32_to_cpu(ltp->bestcount) - 1]) ==
                                             mp->m_dirblksize - hdrsz) {
@@ -999,7 +1001,7 @@ xfs_dir2_leaf_to_block(
         /*
          * Use up the space at the end of the block (blp/btp).
          */
-        xfs_dir2_data_use_free(tp, dbp, dup, mp->m_dirblksize - size, size,
+        xfs_dir2_data_use_free(tp, dp, dbp, dup, mp->m_dirblksize - size, size,
                 &needlog, &needscan);
         /*
          * Initialize the block tail.
@@ -1023,9 +1025,9 @@ xfs_dir2_leaf_to_block(
          * Scan the bestfree if we need it and log the data block header.
          */
         if (needscan)
-                xfs_dir2_data_freescan(mp, hdr, &needlog);
+                xfs_dir2_data_freescan(dp, hdr, &needlog);
         if (needlog)
-                xfs_dir2_data_log_header(tp, dbp);
+                xfs_dir2_data_log_header(tp, dp, dbp);
         /*
          * Pitch the old leaf block.
          */
@@ -1136,9 +1138,9 @@ xfs_dir2_sf_to_block(
          * The whole thing is initialized to free by the init routine.
          * Say we're using the leaf and tail area.
          */
-        dup = xfs_dir3_data_unused_p(hdr);
+        dup = dp->d_ops->data_unused_p(hdr);
         needlog = needscan = 0;
-        xfs_dir2_data_use_free(tp, bp, dup, mp->m_dirblksize - i, i, &needlog,
+        xfs_dir2_data_use_free(tp, dp, bp, dup, mp->m_dirblksize - i, i, &needlog,
                 &needscan);
         ASSERT(needscan == 0);
         /*
@@ -1152,38 +1154,38 @@ xfs_dir2_sf_to_block(
         /*
          * Remove the freespace, we'll manage it.
          */
-        xfs_dir2_data_use_free(tp, bp, dup,
+        xfs_dir2_data_use_free(tp, dp, bp, dup,
                 (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr),
                 be16_to_cpu(dup->length), &needlog, &needscan);
         /*
          * Create entry for .
          */
-        dep = xfs_dir3_data_dot_entry_p(hdr);
+        dep = dp->d_ops->data_dot_entry_p(hdr);
         dep->inumber = cpu_to_be64(dp->i_ino);
         dep->namelen = 1;
         dep->name[0] = '.';
-        xfs_dir3_dirent_put_ftype(mp, dep, XFS_DIR3_FT_DIR);
-        tagp = xfs_dir3_data_entry_tag_p(mp, dep);
+        dp->d_ops->data_put_ftype(dep, XFS_DIR3_FT_DIR);
+        tagp = dp->d_ops->data_entry_tag_p(dep);
         *tagp = cpu_to_be16((char *)dep - (char *)hdr);
-        xfs_dir2_data_log_entry(tp, bp, dep);
+        xfs_dir2_data_log_entry(tp, dp, bp, dep);
         blp[0].hashval = cpu_to_be32(xfs_dir_hash_dot);
         blp[0].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(mp,
                                 (char *)dep - (char *)hdr));
         /*
          * Create entry for ..
          */
-        dep = xfs_dir3_data_dotdot_entry_p(hdr);
-        dep->inumber = cpu_to_be64(xfs_dir2_sf_get_parent_ino(sfp));
+        dep = dp->d_ops->data_dotdot_entry_p(hdr);
+        dep->inumber = cpu_to_be64(dp->d_ops->sf_get_parent_ino(sfp));
         dep->namelen = 2;
         dep->name[0] = dep->name[1] = '.';
-        xfs_dir3_dirent_put_ftype(mp, dep, XFS_DIR3_FT_DIR);
-        tagp = xfs_dir3_data_entry_tag_p(mp, dep);
+        dp->d_ops->data_put_ftype(dep, XFS_DIR3_FT_DIR);
+        tagp = dp->d_ops->data_entry_tag_p(dep);
         *tagp = cpu_to_be16((char *)dep - (char *)hdr);
-        xfs_dir2_data_log_entry(tp, bp, dep);
+        xfs_dir2_data_log_entry(tp, dp, bp, dep);
         blp[1].hashval = cpu_to_be32(xfs_dir_hash_dotdot);
         blp[1].address = cpu_to_be32(xfs_dir2_byte_to_dataptr(mp,
                                 (char *)dep - (char *)hdr));
-        offset = xfs_dir3_data_first_offset(hdr);
+        offset = dp->d_ops->data_first_offset;
         /*
          * Loop over existing entries, stuff them in.
          */
@@ -1214,7 +1216,9 @@ xfs_dir2_sf_to_block(
                         *xfs_dir2_data_unused_tag_p(dup) = cpu_to_be16(
                                 ((char *)dup - (char *)hdr));
                         xfs_dir2_data_log_unused(tp, bp, dup);
-                        xfs_dir2_data_freeinsert(hdr, dup, &dummy);
+                        xfs_dir2_data_freeinsert(hdr,
+                                                 dp->d_ops->data_bestfree_p(hdr),
+                                                 dup, &dummy);
                         offset += be16_to_cpu(dup->length);
                         continue;
                 }
@@ -1222,14 +1226,13 @@ xfs_dir2_sf_to_block(
                  * Copy a real entry.
                  */
                 dep = (xfs_dir2_data_entry_t *)((char *)hdr + newoffset);
-                dep->inumber = cpu_to_be64(xfs_dir3_sfe_get_ino(mp, sfp, sfep));
+                dep->inumber = cpu_to_be64(dp->d_ops->sf_get_ino(sfp, sfep));
                 dep->namelen = sfep->namelen;
-                xfs_dir3_dirent_put_ftype(mp, dep,
-                                        xfs_dir3_sfe_get_ftype(mp, sfp, sfep));
+                dp->d_ops->data_put_ftype(dep, dp->d_ops->sf_get_ftype(sfep));
                 memcpy(dep->name, sfep->name, dep->namelen);
-                tagp = xfs_dir3_data_entry_tag_p(mp, dep);
+                tagp = dp->d_ops->data_entry_tag_p(dep);
                 *tagp = cpu_to_be16((char *)dep - (char *)hdr);
-                xfs_dir2_data_log_entry(tp, bp, dep);
+                xfs_dir2_data_log_entry(tp, dp, bp, dep);
                 name.name = sfep->name;
                 name.len = sfep->namelen;
                 blp[2 + i].hashval = cpu_to_be32(mp->m_dirnameops->
@@ -1240,7 +1243,7 @@ xfs_dir2_sf_to_block(
                 if (++i == sfp->count)
                         sfep = NULL;
                 else
-                        sfep = xfs_dir3_sf_nextentry(mp, sfp, sfep);
+                        sfep = dp->d_ops->sf_nextentry(sfp, sfep);
         }
         /* Done with the temporary buffer */
         kmem_free(sfp);
diff --git a/fs/xfs/xfs_dir2_data.c b/fs/xfs/xfs_dir2_data.c
index 47e1326c169a..70acff4ee173 100644
--- a/fs/xfs/xfs_dir2_data.c
+++ b/fs/xfs/xfs_dir2_data.c
@@ -18,20 +18,19 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_da_format.h"
 #include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
-#include "xfs_dir2_format.h"
 #include "xfs_dir2.h"
 #include "xfs_dir2_priv.h"
 #include "xfs_error.h"
+#include "xfs_trans.h"
 #include "xfs_buf_item.h"
 #include "xfs_cksum.h"
 
@@ -63,11 +62,18 @@ __xfs_dir3_data_check(
         char                    *p;             /* current data position */
         int                     stale;          /* count of stale leaves */
         struct xfs_name         name;
+        const struct xfs_dir_ops *ops;
 
         mp = bp->b_target->bt_mount;
+
+        /*
+         * We can be passed a null dp here from a verifier, so we need to go the
+         * hard way to get them.
+         */
+        ops = xfs_dir_get_ops(mp, dp);
+
         hdr = bp->b_addr;
-        bf = xfs_dir3_data_bestfree_p(hdr);
-        p = (char *)xfs_dir3_data_entry_p(hdr);
+        p = (char *)ops->data_entry_p(hdr);
 
         switch (hdr->magic) {
         case cpu_to_be32(XFS_DIR3_BLOCK_MAGIC):
@@ -75,6 +81,16 @@ __xfs_dir3_data_check(
                 btp = xfs_dir2_block_tail_p(mp, hdr);
                 lep = xfs_dir2_block_leaf_p(btp);
                 endp = (char *)lep;
+
+                /*
+                 * The number of leaf entries is limited by the size of the
+                 * block and the amount of space used by the data entries.
+                 * We don't know how much space is used by the data entries yet,
+                 * so just ensure that the count falls somewhere inside the
+                 * block right now.
+                 */
+                XFS_WANT_CORRUPTED_RETURN(be32_to_cpu(btp->count) <
+                        ((char *)btp - p) / sizeof(struct xfs_dir2_leaf_entry));
                 break;
         case cpu_to_be32(XFS_DIR3_DATA_MAGIC):
         case cpu_to_be32(XFS_DIR2_DATA_MAGIC):
@@ -85,10 +101,11 @@ __xfs_dir3_data_check(
                 return EFSCORRUPTED;
         }
 
-        count = lastfree = freeseen = 0;
         /*
          * Account for zero bestfree entries.
          */
+        bf = ops->data_bestfree_p(hdr);
+        count = lastfree = freeseen = 0;
         if (!bf[0].length) {
                 XFS_WANT_CORRUPTED_RETURN(!bf[0].offset);
                 freeseen |= 1 << 0;
@@ -121,7 +138,7 @@ __xfs_dir3_data_check(
                         XFS_WANT_CORRUPTED_RETURN(
                                 be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)) ==
                                                (char *)dup - (char *)hdr);
-                        dfp = xfs_dir2_data_freefind(hdr, dup);
+                        dfp = xfs_dir2_data_freefind(hdr, bf, dup);
                         if (dfp) {
                                 i = (int)(dfp - bf);
                                 XFS_WANT_CORRUPTED_RETURN(
@@ -147,10 +164,10 @@ __xfs_dir3_data_check(
                 XFS_WANT_CORRUPTED_RETURN(
                         !xfs_dir_ino_validate(mp, be64_to_cpu(dep->inumber)));
                 XFS_WANT_CORRUPTED_RETURN(
-                        be16_to_cpu(*xfs_dir3_data_entry_tag_p(mp, dep)) ==
+                        be16_to_cpu(*ops->data_entry_tag_p(dep)) ==
                                                (char *)dep - (char *)hdr);
                 XFS_WANT_CORRUPTED_RETURN(
-                        xfs_dir3_dirent_get_ftype(mp, dep) < XFS_DIR3_FT_MAX);
+                                ops->data_get_ftype(dep) < XFS_DIR3_FT_MAX);
                 count++;
                 lastfree = 0;
                 if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
@@ -168,7 +185,7 @@ __xfs_dir3_data_check(
                         }
                         XFS_WANT_CORRUPTED_RETURN(i < be32_to_cpu(btp->count));
                 }
-                p += xfs_dir3_data_entsize(mp, dep->namelen);
+                p += ops->data_entsize(dep->namelen);
         }
         /*
          * Need to have seen all the entries and all the bestfree slots.
@@ -327,19 +344,18 @@ xfs_dir3_data_readahead(
  */
 xfs_dir2_data_free_t *
 xfs_dir2_data_freefind(
-        xfs_dir2_data_hdr_t     *hdr,           /* data block */
-        xfs_dir2_data_unused_t  *dup)           /* data unused entry */
+        struct xfs_dir2_data_hdr *hdr,          /* data block header */
+        struct xfs_dir2_data_free *bf,          /* bestfree table pointer */
+        struct xfs_dir2_data_unused *dup)       /* unused space */
 {
         xfs_dir2_data_free_t    *dfp;           /* bestfree entry */
         xfs_dir2_data_aoff_t    off;            /* offset value needed */
-        struct xfs_dir2_data_free *bf;
 #ifdef DEBUG
         int                     matched;        /* matched the value */
         int                     seenzero;       /* saw a 0 bestfree entry */
 #endif
 
         off = (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr);
-        bf = xfs_dir3_data_bestfree_p(hdr);
 
 #ifdef DEBUG
         /*
@@ -399,11 +415,11 @@ xfs_dir2_data_freefind(
  */
 xfs_dir2_data_free_t *                          /* entry inserted */
 xfs_dir2_data_freeinsert(
-        xfs_dir2_data_hdr_t     *hdr,           /* data block pointer */
-        xfs_dir2_data_unused_t  *dup,           /* unused space */
+        struct xfs_dir2_data_hdr *hdr,          /* data block pointer */
+        struct xfs_dir2_data_free *dfp,         /* bestfree table pointer */
+        struct xfs_dir2_data_unused *dup,       /* unused space */
         int                     *loghead)       /* log the data header (out) */
 {
-        xfs_dir2_data_free_t    *dfp;           /* bestfree table pointer */
         xfs_dir2_data_free_t    new;            /* new bestfree entry */
 
         ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
@@ -411,7 +427,6 @@ xfs_dir2_data_freeinsert(
                hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
                hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
 
-        dfp = xfs_dir3_data_bestfree_p(hdr);
         new.length = dup->length;
         new.offset = cpu_to_be16((char *)dup - (char *)hdr);
 
@@ -444,11 +459,11 @@ xfs_dir2_data_freeinsert(
  */
 STATIC void
 xfs_dir2_data_freeremove(
-        xfs_dir2_data_hdr_t     *hdr,           /* data block header */
-        xfs_dir2_data_free_t    *dfp,           /* bestfree entry pointer */
+        struct xfs_dir2_data_hdr *hdr,          /* data block header */
+        struct xfs_dir2_data_free *bf,          /* bestfree table pointer */
+        struct xfs_dir2_data_free *dfp,         /* bestfree entry pointer */
         int                     *loghead)       /* out: log data header */
 {
-        struct xfs_dir2_data_free *bf;
 
         ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
                hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
@@ -458,7 +473,6 @@ xfs_dir2_data_freeremove(
         /*
          * It's the first entry, slide the next 2 up.
          */
-        bf = xfs_dir3_data_bestfree_p(hdr);
         if (dfp == &bf[0]) {
                 bf[0] = bf[1];
                 bf[1] = bf[2];
@@ -486,9 +500,9 @@ xfs_dir2_data_freeremove(
  */
 void
 xfs_dir2_data_freescan(
-        xfs_mount_t             *mp,            /* filesystem mount point */
-        xfs_dir2_data_hdr_t     *hdr,           /* data block header */
-        int                     *loghead)       /* out: log data header */
+        struct xfs_inode        *dp,
+        struct xfs_dir2_data_hdr *hdr,
+        int                     *loghead)
 {
         xfs_dir2_block_tail_t   *btp;           /* block tail */
         xfs_dir2_data_entry_t   *dep;           /* active data entry */
@@ -505,19 +519,19 @@ xfs_dir2_data_freescan(
         /*
          * Start by clearing the table.
          */
-        bf = xfs_dir3_data_bestfree_p(hdr);
+        bf = dp->d_ops->data_bestfree_p(hdr);
         memset(bf, 0, sizeof(*bf) * XFS_DIR2_DATA_FD_COUNT);
         *loghead = 1;
         /*
          * Set up pointers.
          */
-        p = (char *)xfs_dir3_data_entry_p(hdr);
+        p = (char *)dp->d_ops->data_entry_p(hdr);
         if (hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
             hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC)) {
-                btp = xfs_dir2_block_tail_p(mp, hdr);
+                btp = xfs_dir2_block_tail_p(dp->i_mount, hdr);
                 endp = (char *)xfs_dir2_block_leaf_p(btp);
         } else
-                endp = (char *)hdr + mp->m_dirblksize;
+                endp = (char *)hdr + dp->i_mount->m_dirblksize;
         /*
          * Loop over the block's entries.
          */
@@ -529,7 +543,7 @@ xfs_dir2_data_freescan(
                 if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
                         ASSERT((char *)dup - (char *)hdr ==
                                be16_to_cpu(*xfs_dir2_data_unused_tag_p(dup)));
-                        xfs_dir2_data_freeinsert(hdr, dup, loghead);
+                        xfs_dir2_data_freeinsert(hdr, bf, dup, loghead);
                         p += be16_to_cpu(dup->length);
                 }
                 /*
@@ -538,8 +552,8 @@ xfs_dir2_data_freescan(
                 else {
                         dep = (xfs_dir2_data_entry_t *)p;
                         ASSERT((char *)dep - (char *)hdr ==
-                               be16_to_cpu(*xfs_dir3_data_entry_tag_p(mp, dep)));
-                        p += xfs_dir3_data_entsize(mp, dep->namelen);
+                               be16_to_cpu(*dp->d_ops->data_entry_tag_p(dep)));
+                        p += dp->d_ops->data_entsize(dep->namelen);
                 }
         }
 }
@@ -594,8 +608,8 @@ xfs_dir3_data_init(
         } else
                 hdr->magic = cpu_to_be32(XFS_DIR2_DATA_MAGIC);
 
-        bf = xfs_dir3_data_bestfree_p(hdr);
-        bf[0].offset = cpu_to_be16(xfs_dir3_data_entry_offset(hdr));
+        bf = dp->d_ops->data_bestfree_p(hdr);
+        bf[0].offset = cpu_to_be16(dp->d_ops->data_entry_offset);
         for (i = 1; i < XFS_DIR2_DATA_FD_COUNT; i++) {
                 bf[i].length = 0;
                 bf[i].offset = 0;
@@ -604,17 +618,17 @@ xfs_dir3_data_init(
         /*
          * Set up an unused entry for the block's body.
          */
-        dup = xfs_dir3_data_unused_p(hdr);
+        dup = dp->d_ops->data_unused_p(hdr);
         dup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
 
-        t = mp->m_dirblksize - (uint)xfs_dir3_data_entry_offset(hdr);
+        t = mp->m_dirblksize - (uint)dp->d_ops->data_entry_offset;
         bf[0].length = cpu_to_be16(t);
         dup->length = cpu_to_be16(t);
         *xfs_dir2_data_unused_tag_p(dup) = cpu_to_be16((char *)dup - (char *)hdr);
         /*
          * Log it and return it.
          */
-        xfs_dir2_data_log_header(tp, bp);
+        xfs_dir2_data_log_header(tp, dp, bp);
         xfs_dir2_data_log_unused(tp, bp, dup);
         *bpp = bp;
         return 0;
@@ -626,11 +640,11 @@ xfs_dir3_data_init(
 void
 xfs_dir2_data_log_entry(
         struct xfs_trans        *tp,
+        struct xfs_inode        *dp,
         struct xfs_buf          *bp,
         xfs_dir2_data_entry_t   *dep)           /* data entry pointer */
 {
         struct xfs_dir2_data_hdr *hdr = bp->b_addr;
-        struct xfs_mount        *mp = tp->t_mountp;
 
         ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
                hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
@@ -638,7 +652,7 @@ xfs_dir2_data_log_entry(
                hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
 
         xfs_trans_log_buf(tp, bp, (uint)((char *)dep - (char *)hdr),
-                (uint)((char *)(xfs_dir3_data_entry_tag_p(mp, dep) + 1) -
+                (uint)((char *)(dp->d_ops->data_entry_tag_p(dep) + 1) -
                        (char *)hdr - 1));
 }
 
@@ -648,16 +662,19 @@ xfs_dir2_data_log_entry(
 void
 xfs_dir2_data_log_header(
         struct xfs_trans        *tp,
+        struct xfs_inode        *dp,
         struct xfs_buf          *bp)
 {
-        xfs_dir2_data_hdr_t     *hdr = bp->b_addr;
+#ifdef DEBUG
+        struct xfs_dir2_data_hdr *hdr = bp->b_addr;
 
         ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
                hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC) ||
                hdr->magic == cpu_to_be32(XFS_DIR2_BLOCK_MAGIC) ||
                hdr->magic == cpu_to_be32(XFS_DIR3_BLOCK_MAGIC));
+#endif
 
-        xfs_trans_log_buf(tp, bp, 0, xfs_dir3_data_entry_offset(hdr) - 1);
+        xfs_trans_log_buf(tp, bp, 0, dp->d_ops->data_entry_offset - 1);
 }
 
 /*
@@ -698,6 +715,7 @@ xfs_dir2_data_log_unused(
 void
 xfs_dir2_data_make_free(
         struct xfs_trans        *tp,
+        struct xfs_inode        *dp,
         struct xfs_buf          *bp,
         xfs_dir2_data_aoff_t    offset,         /* starting byte offset */
         xfs_dir2_data_aoff_t    len,            /* length in bytes */
@@ -735,7 +753,7 @@ xfs_dir2_data_make_free(
          * If this isn't the start of the block, then back up to
          * the previous entry and see if it's free.
          */
-        if (offset > xfs_dir3_data_entry_offset(hdr)) {
+        if (offset > dp->d_ops->data_entry_offset) {
                 __be16                  *tagp;  /* tag just before us */
 
                 tagp = (__be16 *)((char *)hdr + offset) - 1;
@@ -761,15 +779,15 @@ xfs_dir2_data_make_free(
          * Previous and following entries are both free,
          * merge everything into a single free entry.
          */
-        bf = xfs_dir3_data_bestfree_p(hdr);
+        bf = dp->d_ops->data_bestfree_p(hdr);
         if (prevdup && postdup) {
                 xfs_dir2_data_free_t    *dfp2;  /* another bestfree pointer */
 
                 /*
                  * See if prevdup and/or postdup are in bestfree table.
                  */
-                dfp = xfs_dir2_data_freefind(hdr, prevdup);
-                dfp2 = xfs_dir2_data_freefind(hdr, postdup);
+                dfp = xfs_dir2_data_freefind(hdr, bf, prevdup);
+                dfp2 = xfs_dir2_data_freefind(hdr, bf, postdup);
                 /*
                  * We need a rescan unless there are exactly 2 free entries
                  * namely our two.  Then we know what's happening, otherwise
@@ -797,12 +815,13 @@ xfs_dir2_data_make_free(
                                 ASSERT(dfp2 == dfp);
                                 dfp2 = &bf[1];
                         }
-                        xfs_dir2_data_freeremove(hdr, dfp2, needlogp);
-                        xfs_dir2_data_freeremove(hdr, dfp, needlogp);
+                        xfs_dir2_data_freeremove(hdr, bf, dfp2, needlogp);
+                        xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
                         /*
                          * Now insert the new entry.
                          */
-                        dfp = xfs_dir2_data_freeinsert(hdr, prevdup, needlogp);
+                        dfp = xfs_dir2_data_freeinsert(hdr, bf, prevdup,
+                                                       needlogp);
                         ASSERT(dfp == &bf[0]);
                         ASSERT(dfp->length == prevdup->length);
                         ASSERT(!dfp[1].length);
@@ -813,7 +832,7 @@ xfs_dir2_data_make_free(
          * The entry before us is free, merge with it.
          */
         else if (prevdup) {
-                dfp = xfs_dir2_data_freefind(hdr, prevdup);
+                dfp = xfs_dir2_data_freefind(hdr, bf, prevdup);
                 be16_add_cpu(&prevdup->length, len);
                 *xfs_dir2_data_unused_tag_p(prevdup) =
                         cpu_to_be16((char *)prevdup - (char *)hdr);
@@ -824,8 +843,8 @@ xfs_dir2_data_make_free(
                  * the old one and add the new one.
                  */
                 if (dfp) {
-                        xfs_dir2_data_freeremove(hdr, dfp, needlogp);
-                        xfs_dir2_data_freeinsert(hdr, prevdup, needlogp);
+                        xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
+                        xfs_dir2_data_freeinsert(hdr, bf, prevdup, needlogp);
                 }
                 /*
                  * Otherwise we need a scan if the new entry is big enough.
@@ -839,7 +858,7 @@ xfs_dir2_data_make_free(
          * The following entry is free, merge with it.
          */
         else if (postdup) {
-                dfp = xfs_dir2_data_freefind(hdr, postdup);
+                dfp = xfs_dir2_data_freefind(hdr, bf, postdup);
                 newdup = (xfs_dir2_data_unused_t *)((char *)hdr + offset);
                 newdup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
                 newdup->length = cpu_to_be16(len + be16_to_cpu(postdup->length));
@@ -852,8 +871,8 @@ xfs_dir2_data_make_free(
                  * the old one and add the new one.
                  */
                 if (dfp) {
-                        xfs_dir2_data_freeremove(hdr, dfp, needlogp);
-                        xfs_dir2_data_freeinsert(hdr, newdup, needlogp);
+                        xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
+                        xfs_dir2_data_freeinsert(hdr, bf, newdup, needlogp);
                 }
                 /*
                  * Otherwise we need a scan if the new entry is big enough.
@@ -873,7 +892,7 @@ xfs_dir2_data_make_free(
                 *xfs_dir2_data_unused_tag_p(newdup) =
                         cpu_to_be16((char *)newdup - (char *)hdr);
                 xfs_dir2_data_log_unused(tp, bp, newdup);
-                xfs_dir2_data_freeinsert(hdr, newdup, needlogp);
+                xfs_dir2_data_freeinsert(hdr, bf, newdup, needlogp);
         }
         *needscanp = needscan;
 }
@@ -884,6 +903,7 @@ xfs_dir2_data_make_free(
 void
 xfs_dir2_data_use_free(
         struct xfs_trans        *tp,
+        struct xfs_inode        *dp,
         struct xfs_buf          *bp,
         xfs_dir2_data_unused_t  *dup,           /* unused entry */
         xfs_dir2_data_aoff_t    offset,         /* starting offset to use */
@@ -913,9 +933,9 @@ xfs_dir2_data_use_free(
         /*
          * Look up the entry in the bestfree table.
          */
-        dfp = xfs_dir2_data_freefind(hdr, dup);
         oldlen = be16_to_cpu(dup->length);
-        bf = xfs_dir3_data_bestfree_p(hdr);
+        bf = dp->d_ops->data_bestfree_p(hdr);
+        dfp = xfs_dir2_data_freefind(hdr, bf, dup);
         ASSERT(dfp || oldlen <= be16_to_cpu(bf[2].length));
         /*
          * Check for alignment with front and back of the entry.
@@ -932,7 +952,8 @@ xfs_dir2_data_use_free(
                 if (dfp) {
                         needscan = (bf[2].offset != 0);
                         if (!needscan)
-                                xfs_dir2_data_freeremove(hdr, dfp, needlogp);
+                                xfs_dir2_data_freeremove(hdr, bf, dfp,
+                                                         needlogp);
                 }
         }
         /*
@@ -950,8 +971,9 @@ xfs_dir2_data_use_free(
                  * If it was in the table, remove it and add the new one.
                  */
                 if (dfp) {
-                        xfs_dir2_data_freeremove(hdr, dfp, needlogp);
-                        dfp = xfs_dir2_data_freeinsert(hdr, newdup, needlogp);
+                        xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
+                        dfp = xfs_dir2_data_freeinsert(hdr, bf, newdup,
+                                                       needlogp);
                         ASSERT(dfp != NULL);
                         ASSERT(dfp->length == newdup->length);
                         ASSERT(be16_to_cpu(dfp->offset) == (char *)newdup - (char *)hdr);
@@ -977,8 +999,9 @@ xfs_dir2_data_use_free(
                  * If it was in the table, remove it and add the new one.
                  */
                 if (dfp) {
-                        xfs_dir2_data_freeremove(hdr, dfp, needlogp);
-                        dfp = xfs_dir2_data_freeinsert(hdr, newdup, needlogp);
+                        xfs_dir2_data_freeremove(hdr, bf, dfp, needlogp);
+                        dfp = xfs_dir2_data_freeinsert(hdr, bf, newdup,
+                                                       needlogp);
                         ASSERT(dfp != NULL);
                         ASSERT(dfp->length == newdup->length);
                         ASSERT(be16_to_cpu(dfp->offset) == (char *)newdup - (char *)hdr);
@@ -1017,9 +1040,11 @@ xfs_dir2_data_use_free(
                 if (dfp) {
                         needscan = (bf[2].length != 0);
                         if (!needscan) {
-                                xfs_dir2_data_freeremove(hdr, dfp, needlogp);
-                                xfs_dir2_data_freeinsert(hdr, newdup, needlogp);
-                                xfs_dir2_data_freeinsert(hdr, newdup2,
+                                xfs_dir2_data_freeremove(hdr, bf, dfp,
+                                                         needlogp);
+                                xfs_dir2_data_freeinsert(hdr, bf, newdup,
+                                                         needlogp);
+                                xfs_dir2_data_freeinsert(hdr, bf, newdup2,
                                                          needlogp);
                         }
                 }
diff --git a/fs/xfs/xfs_dir2_leaf.c b/fs/xfs/xfs_dir2_leaf.c
index 1021c8356d08..ae47ec6e16c4 100644
--- a/fs/xfs/xfs_dir2_leaf.c
+++ b/fs/xfs/xfs_dir2_leaf.c
@@ -18,23 +18,21 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_da_format.h"
 #include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_bmap.h"
-#include "xfs_dir2_format.h"
 #include "xfs_dir2.h"
 #include "xfs_dir2_priv.h"
 #include "xfs_error.h"
 #include "xfs_trace.h"
+#include "xfs_trans.h"
 #include "xfs_buf_item.h"
 #include "xfs_cksum.h"
 
@@ -52,21 +50,21 @@ static void xfs_dir3_leaf_log_tail(struct xfs_trans *tp, struct xfs_buf *bp);
  * Pop an assert if something is wrong.
  */
 #ifdef DEBUG
-#define xfs_dir3_leaf_check(mp, bp) \
+#define xfs_dir3_leaf_check(dp, bp) \
 do { \
-        if (!xfs_dir3_leaf1_check((mp), (bp))) \
+        if (!xfs_dir3_leaf1_check((dp), (bp))) \
                 ASSERT(0); \
 } while (0);
 
 STATIC bool
 xfs_dir3_leaf1_check(
-        struct xfs_mount        *mp,
+        struct xfs_inode        *dp,
         struct xfs_buf          *bp)
 {
         struct xfs_dir2_leaf    *leaf = bp->b_addr;
         struct xfs_dir3_icleaf_hdr leafhdr;
 
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
 
         if (leafhdr.magic == XFS_DIR3_LEAF1_MAGIC) {
                 struct xfs_dir3_leaf_hdr *leaf3 = bp->b_addr;
@@ -75,71 +73,16 @@ xfs_dir3_leaf1_check(
         } else if (leafhdr.magic != XFS_DIR2_LEAF1_MAGIC)
                 return false;
 
-        return xfs_dir3_leaf_check_int(mp, &leafhdr, leaf);
+        return xfs_dir3_leaf_check_int(dp->i_mount, dp, &leafhdr, leaf);
 }
 #else
-#define xfs_dir3_leaf_check(mp, bp)
+#define xfs_dir3_leaf_check(dp, bp)
 #endif
 
-void
-xfs_dir3_leaf_hdr_from_disk(
-        struct xfs_dir3_icleaf_hdr      *to,
-        struct xfs_dir2_leaf            *from)
-{
-        if (from->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAF1_MAGIC) ||
-            from->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC)) {
-                to->forw = be32_to_cpu(from->hdr.info.forw);
-                to->back = be32_to_cpu(from->hdr.info.back);
-                to->magic = be16_to_cpu(from->hdr.info.magic);
-                to->count = be16_to_cpu(from->hdr.count);
-                to->stale = be16_to_cpu(from->hdr.stale);
-        } else {
-                struct xfs_dir3_leaf_hdr *hdr3 = (struct xfs_dir3_leaf_hdr *)from;
-
-                to->forw = be32_to_cpu(hdr3->info.hdr.forw);
-                to->back = be32_to_cpu(hdr3->info.hdr.back);
-                to->magic = be16_to_cpu(hdr3->info.hdr.magic);
-                to->count = be16_to_cpu(hdr3->count);
-                to->stale = be16_to_cpu(hdr3->stale);
-        }
-
-        ASSERT(to->magic == XFS_DIR2_LEAF1_MAGIC ||
-               to->magic == XFS_DIR3_LEAF1_MAGIC ||
-               to->magic == XFS_DIR2_LEAFN_MAGIC ||
-               to->magic == XFS_DIR3_LEAFN_MAGIC);
-}
-
-void
-xfs_dir3_leaf_hdr_to_disk(
-        struct xfs_dir2_leaf            *to,
-        struct xfs_dir3_icleaf_hdr      *from)
-{
-        ASSERT(from->magic == XFS_DIR2_LEAF1_MAGIC ||
-               from->magic == XFS_DIR3_LEAF1_MAGIC ||
-               from->magic == XFS_DIR2_LEAFN_MAGIC ||
-               from->magic == XFS_DIR3_LEAFN_MAGIC);
-
-        if (from->magic == XFS_DIR2_LEAF1_MAGIC ||
-            from->magic == XFS_DIR2_LEAFN_MAGIC) {
-                to->hdr.info.forw = cpu_to_be32(from->forw);
-                to->hdr.info.back = cpu_to_be32(from->back);
-                to->hdr.info.magic = cpu_to_be16(from->magic);
-                to->hdr.count = cpu_to_be16(from->count);
-                to->hdr.stale = cpu_to_be16(from->stale);
-        } else {
-                struct xfs_dir3_leaf_hdr *hdr3 = (struct xfs_dir3_leaf_hdr *)to;
-
-                hdr3->info.hdr.forw = cpu_to_be32(from->forw);
-                hdr3->info.hdr.back = cpu_to_be32(from->back);
-                hdr3->info.hdr.magic = cpu_to_be16(from->magic);
-                hdr3->count = cpu_to_be16(from->count);
-                hdr3->stale = cpu_to_be16(from->stale);
-        }
-}
-
 bool
 xfs_dir3_leaf_check_int(
         struct xfs_mount        *mp,
+        struct xfs_inode        *dp,
         struct xfs_dir3_icleaf_hdr *hdr,
         struct xfs_dir2_leaf    *leaf)
 {
@@ -147,8 +90,21 @@ xfs_dir3_leaf_check_int(
         xfs_dir2_leaf_tail_t    *ltp;
         int                     stale;
         int                     i;
+        const struct xfs_dir_ops *ops;
+        struct xfs_dir3_icleaf_hdr leafhdr;
 
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        /*
+         * we can be passed a null dp here from a verifier, so we need to go the
+         * hard way to get them.
+         */
+        ops = xfs_dir_get_ops(mp, dp);
+
+        if (!hdr) {
+                ops->leaf_hdr_from_disk(&leafhdr, leaf);
+                hdr = &leafhdr;
+        }
+
+        ents = ops->leaf_ents_p(leaf);
         ltp = xfs_dir2_leaf_tail_p(mp, leaf);
 
         /*
@@ -156,7 +112,7 @@ xfs_dir3_leaf_check_int(
          * Should factor in the size of the bests table as well.
          * We can deduce a value for that from di_size.
          */
-        if (hdr->count > xfs_dir3_max_leaf_ents(mp, leaf))
+        if (hdr->count > ops->leaf_max_ents(mp))
                 return false;
 
         /* Leaves and bests don't overlap in leaf format. */
@@ -192,7 +148,6 @@ xfs_dir3_leaf_verify(
 {
         struct xfs_mount        *mp = bp->b_target->bt_mount;
         struct xfs_dir2_leaf    *leaf = bp->b_addr;
-        struct xfs_dir3_icleaf_hdr leafhdr;
 
         ASSERT(magic == XFS_DIR2_LEAF1_MAGIC || magic == XFS_DIR2_LEAFN_MAGIC);
 
@@ -214,8 +169,7 @@ xfs_dir3_leaf_verify(
                         return false;
         }
 
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
-        return xfs_dir3_leaf_check_int(mp, &leafhdr, leaf);
+        return xfs_dir3_leaf_check_int(mp, NULL, NULL, leaf);
 }
 
 static void
@@ -401,7 +355,7 @@ xfs_dir3_leaf_get_buf(
                 return error;
 
         xfs_dir3_leaf_init(mp, tp, bp, dp->i_ino, magic);
-        xfs_dir3_leaf_log_header(tp, bp);
+        xfs_dir3_leaf_log_header(tp, dp, bp);
         if (magic == XFS_DIR2_LEAF1_MAGIC)
                 xfs_dir3_leaf_log_tail(tp, bp);
         *bpp = bp;
@@ -462,31 +416,31 @@ xfs_dir2_block_to_leaf(
         xfs_dir3_data_check(dp, dbp);
         btp = xfs_dir2_block_tail_p(mp, hdr);
         blp = xfs_dir2_block_leaf_p(btp);
-        bf = xfs_dir3_data_bestfree_p(hdr);
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        bf = dp->d_ops->data_bestfree_p(hdr);
+        ents = dp->d_ops->leaf_ents_p(leaf);
 
         /*
          * Set the counts in the leaf header.
          */
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
         leafhdr.count = be32_to_cpu(btp->count);
         leafhdr.stale = be32_to_cpu(btp->stale);
-        xfs_dir3_leaf_hdr_to_disk(leaf, &leafhdr);
-        xfs_dir3_leaf_log_header(tp, lbp);
+        dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr);
+        xfs_dir3_leaf_log_header(tp, dp, lbp);
 
         /*
          * Could compact these but I think we always do the conversion
          * after squeezing out stale entries.
          */
         memcpy(ents, blp, be32_to_cpu(btp->count) * sizeof(xfs_dir2_leaf_entry_t));
-        xfs_dir3_leaf_log_ents(tp, lbp, 0, leafhdr.count - 1);
+        xfs_dir3_leaf_log_ents(tp, dp, lbp, 0, leafhdr.count - 1);
         needscan = 0;
         needlog = 1;
         /*
          * Make the space formerly occupied by the leaf entries and block
          * tail be free.
          */
-        xfs_dir2_data_make_free(tp, dbp,
+        xfs_dir2_data_make_free(tp, dp, dbp,
                 (xfs_dir2_data_aoff_t)((char *)blp - (char *)hdr),
                 (xfs_dir2_data_aoff_t)((char *)hdr + mp->m_dirblksize -
                                        (char *)blp),
@@ -502,7 +456,7 @@ xfs_dir2_block_to_leaf(
                 hdr->magic = cpu_to_be32(XFS_DIR3_DATA_MAGIC);
 
         if (needscan)
-                xfs_dir2_data_freescan(mp, hdr, &needlog);
+                xfs_dir2_data_freescan(dp, hdr, &needlog);
         /*
          * Set up leaf tail and bests table.
          */
@@ -514,8 +468,8 @@ xfs_dir2_block_to_leaf(
          * Log the data header and leaf bests table.
          */
         if (needlog)
-                xfs_dir2_data_log_header(tp, dbp);
-        xfs_dir3_leaf_check(mp, lbp);
+                xfs_dir2_data_log_header(tp, dp, dbp);
+        xfs_dir3_leaf_check(dp, lbp);
         xfs_dir3_data_check(dp, dbp);
         xfs_dir3_leaf_log_bests(tp, lbp, 0, 0);
         return 0;
@@ -699,10 +653,10 @@ xfs_dir2_leaf_addname(
         index = xfs_dir2_leaf_search_hash(args, lbp);
         leaf = lbp->b_addr;
         ltp = xfs_dir2_leaf_tail_p(mp, leaf);
-        ents = xfs_dir3_leaf_ents_p(leaf);
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
         bestsp = xfs_dir2_leaf_bests_p(ltp);
-        length = xfs_dir3_data_entsize(mp, args->namelen);
+        length = dp->d_ops->data_entsize(args->namelen);
 
         /*
          * See if there are any entries with the same hash value
@@ -864,7 +818,7 @@ xfs_dir2_leaf_addname(
                 else
                         xfs_dir3_leaf_log_bests(tp, lbp, use_block, use_block);
                 hdr = dbp->b_addr;
-                bf = xfs_dir3_data_bestfree_p(hdr);
+                bf = dp->d_ops->data_bestfree_p(hdr);
                 bestsp[use_block] = bf[0].length;
                 grown = 1;
         } else {
@@ -880,7 +834,7 @@ xfs_dir2_leaf_addname(
                         return error;
                 }
                 hdr = dbp->b_addr;
-                bf = xfs_dir3_data_bestfree_p(hdr);
+                bf = dp->d_ops->data_bestfree_p(hdr);
                 grown = 0;
         }
         /*
@@ -893,7 +847,7 @@ xfs_dir2_leaf_addname(
         /*
          * Mark the initial part of our freespace in use for the new entry.
          */
-        xfs_dir2_data_use_free(tp, dbp, dup,
+        xfs_dir2_data_use_free(tp, dp, dbp, dup,
                 (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr), length,
                 &needlog, &needscan);
         /*
@@ -903,20 +857,20 @@ xfs_dir2_leaf_addname(
         dep->inumber = cpu_to_be64(args->inumber);
         dep->namelen = args->namelen;
         memcpy(dep->name, args->name, dep->namelen);
-        xfs_dir3_dirent_put_ftype(mp, dep, args->filetype);
-        tagp = xfs_dir3_data_entry_tag_p(mp, dep);
+        dp->d_ops->data_put_ftype(dep, args->filetype);
+        tagp = dp->d_ops->data_entry_tag_p(dep);
         *tagp = cpu_to_be16((char *)dep - (char *)hdr);
         /*
          * Need to scan fix up the bestfree table.
          */
         if (needscan)
-                xfs_dir2_data_freescan(mp, hdr, &needlog);
+                xfs_dir2_data_freescan(dp, hdr, &needlog);
         /*
          * Need to log the data block's header.
          */
         if (needlog)
-                xfs_dir2_data_log_header(tp, dbp);
-        xfs_dir2_data_log_entry(tp, dbp, dep);
+                xfs_dir2_data_log_header(tp, dp, dbp);
+        xfs_dir2_data_log_entry(tp, dp, dbp, dep);
         /*
          * If the bests table needs to be changed, do it.
          * Log the change unless we've already done that.
@@ -939,10 +893,10 @@ xfs_dir2_leaf_addname(
         /*
          * Log the leaf fields and give up the buffers.
          */
-        xfs_dir3_leaf_hdr_to_disk(leaf, &leafhdr);
-        xfs_dir3_leaf_log_header(tp, lbp);
-        xfs_dir3_leaf_log_ents(tp, lbp, lfloglow, lfloghigh);
-        xfs_dir3_leaf_check(mp, lbp);
+        dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr);
+        xfs_dir3_leaf_log_header(tp, dp, lbp);
+        xfs_dir3_leaf_log_ents(tp, dp, lbp, lfloglow, lfloghigh);
+        xfs_dir3_leaf_check(dp, lbp);
         xfs_dir3_data_check(dp, dbp);
         return 0;
 }
@@ -962,6 +916,7 @@ xfs_dir3_leaf_compact(
         int             loglow;         /* first leaf entry to log */
         int             to;             /* target leaf index */
         struct xfs_dir2_leaf_entry *ents;
+        struct xfs_inode *dp = args->dp;
 
         leaf = bp->b_addr;
         if (!leafhdr->stale)
@@ -970,7 +925,7 @@ xfs_dir3_leaf_compact(
         /*
          * Compress out the stale entries in place.
          */
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
         for (from = to = 0, loglow = -1; from < leafhdr->count; from++) {
                 if (ents[from].address == cpu_to_be32(XFS_DIR2_NULL_DATAPTR))
                         continue;
@@ -991,10 +946,10 @@ xfs_dir3_leaf_compact(
         leafhdr->count -= leafhdr->stale;
         leafhdr->stale = 0;
 
-        xfs_dir3_leaf_hdr_to_disk(leaf, leafhdr);
-        xfs_dir3_leaf_log_header(args->trans, bp);
+        dp->d_ops->leaf_hdr_to_disk(leaf, leafhdr);
+        xfs_dir3_leaf_log_header(args->trans, dp, bp);
         if (loglow != -1)
-                xfs_dir3_leaf_log_ents(args->trans, bp, loglow, to - 1);
+                xfs_dir3_leaf_log_ents(args->trans, dp, bp, loglow, to - 1);
 }
 
 /*
@@ -1121,10 +1076,11 @@ xfs_dir3_leaf_log_bests(
  */
 void
 xfs_dir3_leaf_log_ents(
-        xfs_trans_t             *tp,            /* transaction pointer */
-        struct xfs_buf          *bp,            /* leaf buffer */
-        int                     first,          /* first entry to log */
-        int                     last)           /* last entry to log */
+        struct xfs_trans        *tp,
+        struct xfs_inode        *dp,
+        struct xfs_buf          *bp,
+        int                     first,
+        int                     last)
 {
         xfs_dir2_leaf_entry_t   *firstlep;      /* pointer to first entry */
         xfs_dir2_leaf_entry_t   *lastlep;       /* pointer to last entry */
@@ -1136,7 +1092,7 @@ xfs_dir3_leaf_log_ents(
                leaf->hdr.info.magic == cpu_to_be16(XFS_DIR2_LEAFN_MAGIC) ||
                leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC));
 
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
         firstlep = &ents[first];
         lastlep = &ents[last];
         xfs_trans_log_buf(tp, bp, (uint)((char *)firstlep - (char *)leaf),
@@ -1149,6 +1105,7 @@ xfs_dir3_leaf_log_ents(
 void
 xfs_dir3_leaf_log_header(
         struct xfs_trans        *tp,
+        struct xfs_inode        *dp,
         struct xfs_buf          *bp)
 {
         struct xfs_dir2_leaf    *leaf = bp->b_addr;
@@ -1159,7 +1116,7 @@ xfs_dir3_leaf_log_header(
                leaf->hdr.info.magic == cpu_to_be16(XFS_DIR3_LEAFN_MAGIC));
 
         xfs_trans_log_buf(tp, bp, (uint)((char *)&leaf->hdr - (char *)leaf),
-                          xfs_dir3_leaf_hdr_size(leaf) - 1);
+                          dp->d_ops->leaf_hdr_size - 1);
 }
 
 /*
@@ -1214,9 +1171,9 @@ xfs_dir2_leaf_lookup(
         }
         tp = args->trans;
         dp = args->dp;
-        xfs_dir3_leaf_check(dp->i_mount, lbp);
+        xfs_dir3_leaf_check(dp, lbp);
         leaf = lbp->b_addr;
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
         /*
          * Get to the leaf entry and contained data entry address.
          */
@@ -1232,7 +1189,7 @@ xfs_dir2_leaf_lookup(
          * Return the found inode number & CI name if appropriate
          */
         args->inumber = be64_to_cpu(dep->inumber);
-        args->filetype = xfs_dir3_dirent_get_ftype(dp->i_mount, dep);
+        args->filetype = dp->d_ops->data_get_ftype(dep);
         error = xfs_dir_cilookup_result(args, dep->name, dep->namelen);
         xfs_trans_brelse(tp, dbp);
         xfs_trans_brelse(tp, lbp);
@@ -1279,9 +1236,9 @@ xfs_dir2_leaf_lookup_int(
 
         *lbpp = lbp;
         leaf = lbp->b_addr;
-        xfs_dir3_leaf_check(mp, lbp);
-        ents = xfs_dir3_leaf_ents_p(leaf);
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
+        xfs_dir3_leaf_check(dp, lbp);
+        ents = dp->d_ops->leaf_ents_p(leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
 
         /*
          * Look for the first leaf entry with our hash value.
@@ -1415,9 +1372,9 @@ xfs_dir2_leaf_removename(
         leaf = lbp->b_addr;
         hdr = dbp->b_addr;
         xfs_dir3_data_check(dp, dbp);
-        bf = xfs_dir3_data_bestfree_p(hdr);
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        bf = dp->d_ops->data_bestfree_p(hdr);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
         /*
          * Point to the leaf entry, use that to point to the data entry.
          */
@@ -1433,27 +1390,27 @@ xfs_dir2_leaf_removename(
         /*
          * Mark the former data entry unused.
          */
-        xfs_dir2_data_make_free(tp, dbp,
+        xfs_dir2_data_make_free(tp, dp, dbp,
                 (xfs_dir2_data_aoff_t)((char *)dep - (char *)hdr),
-                xfs_dir3_data_entsize(mp, dep->namelen), &needlog, &needscan);
+                dp->d_ops->data_entsize(dep->namelen), &needlog, &needscan);
         /*
          * We just mark the leaf entry stale by putting a null in it.
          */
         leafhdr.stale++;
-        xfs_dir3_leaf_hdr_to_disk(leaf, &leafhdr);
-        xfs_dir3_leaf_log_header(tp, lbp);
+        dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr);
+        xfs_dir3_leaf_log_header(tp, dp, lbp);
 
         lep->address = cpu_to_be32(XFS_DIR2_NULL_DATAPTR);
-        xfs_dir3_leaf_log_ents(tp, lbp, index, index);
+        xfs_dir3_leaf_log_ents(tp, dp, lbp, index, index);
 
         /*
          * Scan the freespace in the data block again if necessary,
          * log the data block header if necessary.
          */
         if (needscan)
-                xfs_dir2_data_freescan(mp, hdr, &needlog);
+                xfs_dir2_data_freescan(dp, hdr, &needlog);
         if (needlog)
-                xfs_dir2_data_log_header(tp, dbp);
+                xfs_dir2_data_log_header(tp, dp, dbp);
         /*
          * If the longest freespace in the data block has changed,
          * put the new value in the bests table and log that.
@@ -1467,7 +1424,7 @@ xfs_dir2_leaf_removename(
          * If the data block is now empty then get rid of the data block.
          */
         if (be16_to_cpu(bf[0].length) ==
-                        mp->m_dirblksize - xfs_dir3_data_entry_offset(hdr)) {
+                        mp->m_dirblksize - dp->d_ops->data_entry_offset) {
                 ASSERT(db != mp->m_dirdatablk);
                 if ((error = xfs_dir2_shrink_inode(args, db, dbp))) {
                         /*
@@ -1478,7 +1435,7 @@ xfs_dir2_leaf_removename(
                          */
                         if (error == ENOSPC && args->total == 0)
                                 error = 0;
-                        xfs_dir3_leaf_check(mp, lbp);
+                        xfs_dir3_leaf_check(dp, lbp);
                         return error;
                 }
                 dbp = NULL;
@@ -1512,7 +1469,7 @@ xfs_dir2_leaf_removename(
         else if (db != mp->m_dirdatablk)
                 dbp = NULL;
 
-        xfs_dir3_leaf_check(mp, lbp);
+        xfs_dir3_leaf_check(dp, lbp);
         /*
          * See if we can convert to block form.
          */
@@ -1547,7 +1504,7 @@ xfs_dir2_leaf_replace(
         }
         dp = args->dp;
         leaf = lbp->b_addr;
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
         /*
          * Point to the leaf entry, get data address from it.
          */
@@ -1563,10 +1520,10 @@ xfs_dir2_leaf_replace(
          * Put the new inode number in, log it.
          */
         dep->inumber = cpu_to_be64(args->inumber);
-        xfs_dir3_dirent_put_ftype(dp->i_mount, dep, args->filetype);
+        dp->d_ops->data_put_ftype(dep, args->filetype);
         tp = args->trans;
-        xfs_dir2_data_log_entry(tp, dbp, dep);
-        xfs_dir3_leaf_check(dp->i_mount, lbp);
+        xfs_dir2_data_log_entry(tp, dp, dbp, dep);
+        xfs_dir3_leaf_check(dp, lbp);
         xfs_trans_brelse(tp, lbp);
         return 0;
 }
@@ -1592,8 +1549,8 @@ xfs_dir2_leaf_search_hash(
         struct xfs_dir3_icleaf_hdr leafhdr;
 
         leaf = lbp->b_addr;
-        ents = xfs_dir3_leaf_ents_p(leaf);
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
+        ents = args->dp->d_ops->leaf_ents_p(leaf);
+        args->dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
 
         /*
          * Note, the table cannot be empty, so we have to go through the loop.
@@ -1661,12 +1618,12 @@ xfs_dir2_leaf_trim_data(
 #ifdef DEBUG
 {
         struct xfs_dir2_data_hdr *hdr = dbp->b_addr;
-        struct xfs_dir2_data_free *bf = xfs_dir3_data_bestfree_p(hdr);
+        struct xfs_dir2_data_free *bf = dp->d_ops->data_bestfree_p(hdr);
 
         ASSERT(hdr->magic == cpu_to_be32(XFS_DIR2_DATA_MAGIC) ||
                hdr->magic == cpu_to_be32(XFS_DIR3_DATA_MAGIC));
         ASSERT(be16_to_cpu(bf[0].length) ==
-               mp->m_dirblksize - xfs_dir3_data_entry_offset(hdr));
+               mp->m_dirblksize - dp->d_ops->data_entry_offset);
         ASSERT(db == be32_to_cpu(ltp->bestcount) - 1);
 }
 #endif
@@ -1782,7 +1739,7 @@ xfs_dir2_node_to_leaf(
                 return 0;
         lbp = state->path.blk[0].bp;
         leaf = lbp->b_addr;
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
 
         ASSERT(leafhdr.magic == XFS_DIR2_LEAFN_MAGIC ||
                leafhdr.magic == XFS_DIR3_LEAFN_MAGIC);
@@ -1794,7 +1751,7 @@ xfs_dir2_node_to_leaf(
         if (error)
                 return error;
         free = fbp->b_addr;
-        xfs_dir3_free_hdr_from_disk(&freehdr, free);
+        dp->d_ops->free_hdr_from_disk(&freehdr, free);
 
         ASSERT(!freehdr.firstdb);
 
@@ -1828,14 +1785,14 @@ xfs_dir2_node_to_leaf(
         /*
          * Set up the leaf bests table.
          */
-        memcpy(xfs_dir2_leaf_bests_p(ltp), xfs_dir3_free_bests_p(mp, free),
+        memcpy(xfs_dir2_leaf_bests_p(ltp), dp->d_ops->free_bests_p(free),
                 freehdr.nvalid * sizeof(xfs_dir2_data_off_t));
 
-        xfs_dir3_leaf_hdr_to_disk(leaf, &leafhdr);
-        xfs_dir3_leaf_log_header(tp, lbp);
+        dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr);
+        xfs_dir3_leaf_log_header(tp, dp, lbp);
         xfs_dir3_leaf_log_bests(tp, lbp, 0, be32_to_cpu(ltp->bestcount) - 1);
         xfs_dir3_leaf_log_tail(tp, lbp);
-        xfs_dir3_leaf_check(mp, lbp);
+        xfs_dir3_leaf_check(dp, lbp);
 
         /*
          * Get rid of the freespace block.
diff --git a/fs/xfs/xfs_dir2_node.c b/fs/xfs/xfs_dir2_node.c
index 4c3dba7ffb74..56369d4509d5 100644
--- a/fs/xfs/xfs_dir2_node.c
+++ b/fs/xfs/xfs_dir2_node.c
@@ -18,22 +18,21 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_da_format.h"
 #include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_bmap.h"
-#include "xfs_dir2_format.h"
 #include "xfs_dir2.h"
 #include "xfs_dir2_priv.h"
 #include "xfs_error.h"
 #include "xfs_trace.h"
+#include "xfs_trans.h"
 #include "xfs_buf_item.h"
 #include "xfs_cksum.h"
 
@@ -55,21 +54,21 @@ static int xfs_dir2_node_addname_int(xfs_da_args_t *args,
  * Check internal consistency of a leafn block.
  */
 #ifdef DEBUG
-#define xfs_dir3_leaf_check(mp, bp) \
+#define xfs_dir3_leaf_check(dp, bp) \
 do { \
-        if (!xfs_dir3_leafn_check((mp), (bp))) \
+        if (!xfs_dir3_leafn_check((dp), (bp))) \
                 ASSERT(0); \
 } while (0);
 
 static bool
 xfs_dir3_leafn_check(
-        struct xfs_mount        *mp,
+        struct xfs_inode        *dp,
         struct xfs_buf          *bp)
 {
         struct xfs_dir2_leaf    *leaf = bp->b_addr;
         struct xfs_dir3_icleaf_hdr leafhdr;
 
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
 
         if (leafhdr.magic == XFS_DIR3_LEAFN_MAGIC) {
                 struct xfs_dir3_leaf_hdr *leaf3 = bp->b_addr;
@@ -78,10 +77,10 @@ xfs_dir3_leafn_check(
         } else if (leafhdr.magic != XFS_DIR2_LEAFN_MAGIC)
                 return false;
 
-        return xfs_dir3_leaf_check_int(mp, &leafhdr, leaf);
+        return xfs_dir3_leaf_check_int(dp->i_mount, dp, &leafhdr, leaf);
 }
 #else
-#define xfs_dir3_leaf_check(mp, bp)
+#define xfs_dir3_leaf_check(dp, bp)
 #endif
 
 static bool
@@ -193,53 +192,6 @@ xfs_dir2_free_try_read(
         return __xfs_dir3_free_read(tp, dp, fbno, -2, bpp);
 }
 
-
-void
-xfs_dir3_free_hdr_from_disk(
-        struct xfs_dir3_icfree_hdr      *to,
-        struct xfs_dir2_free            *from)
-{
-        if (from->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC)) {
-                to->magic = be32_to_cpu(from->hdr.magic);
-                to->firstdb = be32_to_cpu(from->hdr.firstdb);
-                to->nvalid = be32_to_cpu(from->hdr.nvalid);
-                to->nused = be32_to_cpu(from->hdr.nused);
-        } else {
-                struct xfs_dir3_free_hdr *hdr3 = (struct xfs_dir3_free_hdr *)from;
-
-                to->magic = be32_to_cpu(hdr3->hdr.magic);
-                to->firstdb = be32_to_cpu(hdr3->firstdb);
-                to->nvalid = be32_to_cpu(hdr3->nvalid);
-                to->nused = be32_to_cpu(hdr3->nused);
-        }
-
-        ASSERT(to->magic == XFS_DIR2_FREE_MAGIC ||
-               to->magic == XFS_DIR3_FREE_MAGIC);
-}
-
-static void
-xfs_dir3_free_hdr_to_disk(
-        struct xfs_dir2_free            *to,
-        struct xfs_dir3_icfree_hdr      *from)
-{
-        ASSERT(from->magic == XFS_DIR2_FREE_MAGIC ||
-               from->magic == XFS_DIR3_FREE_MAGIC);
-
-        if (from->magic == XFS_DIR2_FREE_MAGIC) {
-                to->hdr.magic = cpu_to_be32(from->magic);
-                to->hdr.firstdb = cpu_to_be32(from->firstdb);
-                to->hdr.nvalid = cpu_to_be32(from->nvalid);
-                to->hdr.nused = cpu_to_be32(from->nused);
-        } else {
-                struct xfs_dir3_free_hdr *hdr3 = (struct xfs_dir3_free_hdr *)to;
-
-                hdr3->hdr.magic = cpu_to_be32(from->magic);
-                hdr3->firstdb = cpu_to_be32(from->firstdb);
-                hdr3->nvalid = cpu_to_be32(from->nvalid);
-                hdr3->nused = cpu_to_be32(from->nused);
-        }
-}
-
 static int
 xfs_dir3_free_get_buf(
         struct xfs_trans        *tp,
@@ -277,7 +229,7 @@ xfs_dir3_free_get_buf(
                 uuid_copy(&hdr3->hdr.uuid, &mp->m_sb.sb_uuid);
         } else
                 hdr.magic = XFS_DIR2_FREE_MAGIC;
-        xfs_dir3_free_hdr_to_disk(bp->b_addr, &hdr);
+        dp->d_ops->free_hdr_to_disk(bp->b_addr, &hdr);
         *bpp = bp;
         return 0;
 }
@@ -288,6 +240,7 @@ xfs_dir3_free_get_buf(
 STATIC void
 xfs_dir2_free_log_bests(
         struct xfs_trans        *tp,
+        struct xfs_inode        *dp,
         struct xfs_buf          *bp,
         int                     first,          /* first entry to log */
         int                     last)           /* last entry to log */
@@ -296,7 +249,7 @@ xfs_dir2_free_log_bests(
         __be16                  *bests;
 
         free = bp->b_addr;
-        bests = xfs_dir3_free_bests_p(tp->t_mountp, free);
+        bests = dp->d_ops->free_bests_p(free);
         ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC) ||
                free->hdr.magic == cpu_to_be32(XFS_DIR3_FREE_MAGIC));
         xfs_trans_log_buf(tp, bp,
@@ -311,6 +264,7 @@ xfs_dir2_free_log_bests(
 static void
 xfs_dir2_free_log_header(
         struct xfs_trans        *tp,
+        struct xfs_inode        *dp,
         struct xfs_buf          *bp)
 {
 #ifdef DEBUG
@@ -320,7 +274,7 @@ xfs_dir2_free_log_header(
         ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC) ||
                free->hdr.magic == cpu_to_be32(XFS_DIR3_FREE_MAGIC));
 #endif
-        xfs_trans_log_buf(tp, bp, 0, xfs_dir3_free_hdr_size(tp->t_mountp) - 1);
+        xfs_trans_log_buf(tp, bp, 0, dp->d_ops->free_hdr_size - 1);
 }
 
 /*
@@ -369,7 +323,7 @@ xfs_dir2_leaf_to_node(
                 return error;
 
         free = fbp->b_addr;
-        xfs_dir3_free_hdr_from_disk(&freehdr, free);
+        dp->d_ops->free_hdr_from_disk(&freehdr, free);
         leaf = lbp->b_addr;
         ltp = xfs_dir2_leaf_tail_p(mp, leaf);
         ASSERT(be32_to_cpu(ltp->bestcount) <=
@@ -380,7 +334,7 @@ xfs_dir2_leaf_to_node(
          * Count active entries.
          */
         from = xfs_dir2_leaf_bests_p(ltp);
-        to = xfs_dir3_free_bests_p(mp, free);
+        to = dp->d_ops->free_bests_p(free);
         for (i = n = 0; i < be32_to_cpu(ltp->bestcount); i++, from++, to++) {
                 if ((off = be16_to_cpu(*from)) != NULLDATAOFF)
                         n++;
@@ -393,9 +347,9 @@ xfs_dir2_leaf_to_node(
         freehdr.nused = n;
         freehdr.nvalid = be32_to_cpu(ltp->bestcount);
 
-        xfs_dir3_free_hdr_to_disk(fbp->b_addr, &freehdr);
-        xfs_dir2_free_log_bests(tp, fbp, 0, freehdr.nvalid - 1);
-        xfs_dir2_free_log_header(tp, fbp);
+        dp->d_ops->free_hdr_to_disk(fbp->b_addr, &freehdr);
+        xfs_dir2_free_log_bests(tp, dp, fbp, 0, freehdr.nvalid - 1);
+        xfs_dir2_free_log_header(tp, dp, fbp);
 
         /*
          * Converting the leaf to a leafnode is just a matter of changing the
@@ -409,8 +363,8 @@ xfs_dir2_leaf_to_node(
                 leaf->hdr.info.magic = cpu_to_be16(XFS_DIR3_LEAFN_MAGIC);
         lbp->b_ops = &xfs_dir3_leafn_buf_ops;
         xfs_trans_buf_set_type(tp, lbp, XFS_BLFT_DIR_LEAFN_BUF);
-        xfs_dir3_leaf_log_header(tp, lbp);
-        xfs_dir3_leaf_check(mp, lbp);
+        xfs_dir3_leaf_log_header(tp, dp, lbp);
+        xfs_dir3_leaf_check(dp, lbp);
         return 0;
 }
 
@@ -443,8 +397,8 @@ xfs_dir2_leafn_add(
         mp = dp->i_mount;
         tp = args->trans;
         leaf = bp->b_addr;
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
 
         /*
          * Quick check just to make sure we are not going to index
@@ -460,7 +414,7 @@ xfs_dir2_leafn_add(
          * a compact.
          */
 
-        if (leafhdr.count == xfs_dir3_max_leaf_ents(mp, leaf)) {
+        if (leafhdr.count == dp->d_ops->leaf_max_ents(mp)) {
                 if (!leafhdr.stale)
                         return XFS_ERROR(ENOSPC);
                 compact = leafhdr.stale > 1;
@@ -498,30 +452,30 @@ xfs_dir2_leafn_add(
         lep->address = cpu_to_be32(xfs_dir2_db_off_to_dataptr(mp,
                                 args->blkno, args->index));
 
-        xfs_dir3_leaf_hdr_to_disk(leaf, &leafhdr);
-        xfs_dir3_leaf_log_header(tp, bp);
-        xfs_dir3_leaf_log_ents(tp, bp, lfloglow, lfloghigh);
-        xfs_dir3_leaf_check(mp, bp);
+        dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr);
+        xfs_dir3_leaf_log_header(tp, dp, bp);
+        xfs_dir3_leaf_log_ents(tp, dp, bp, lfloglow, lfloghigh);
+        xfs_dir3_leaf_check(dp, bp);
         return 0;
 }
 
 #ifdef DEBUG
 static void
 xfs_dir2_free_hdr_check(
-        struct xfs_mount *mp,
+        struct xfs_inode *dp,
         struct xfs_buf  *bp,
         xfs_dir2_db_t   db)
 {
         struct xfs_dir3_icfree_hdr hdr;
 
-        xfs_dir3_free_hdr_from_disk(&hdr, bp->b_addr);
+        dp->d_ops->free_hdr_from_disk(&hdr, bp->b_addr);
 
-        ASSERT((hdr.firstdb % xfs_dir3_free_max_bests(mp)) == 0);
+        ASSERT((hdr.firstdb % dp->d_ops->free_max_bests(dp->i_mount)) == 0);
         ASSERT(hdr.firstdb <= db);
         ASSERT(db < hdr.firstdb + hdr.nvalid);
 }
 #else
-#define xfs_dir2_free_hdr_check(mp, dp, db)
+#define xfs_dir2_free_hdr_check(dp, bp, db)
 #endif  /* DEBUG */
 
 /*
@@ -530,6 +484,7 @@ xfs_dir2_free_hdr_check(
  */
 xfs_dahash_t                                    /* hash value */
 xfs_dir2_leafn_lasthash(
+        struct xfs_inode *dp,
         struct xfs_buf  *bp,                    /* leaf buffer */
         int             *count)                 /* count of entries in leaf */
 {
@@ -537,7 +492,7 @@ xfs_dir2_leafn_lasthash(
         struct xfs_dir2_leaf_entry *ents;
         struct xfs_dir3_icleaf_hdr leafhdr;
 
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
 
         ASSERT(leafhdr.magic == XFS_DIR2_LEAFN_MAGIC ||
                leafhdr.magic == XFS_DIR3_LEAFN_MAGIC);
@@ -547,7 +502,7 @@ xfs_dir2_leafn_lasthash(
         if (!leafhdr.count)
                 return 0;
 
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
         return be32_to_cpu(ents[leafhdr.count - 1].hashval);
 }
 
@@ -584,10 +539,10 @@ xfs_dir2_leafn_lookup_for_addname(
         tp = args->trans;
         mp = dp->i_mount;
         leaf = bp->b_addr;
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
 
-        xfs_dir3_leaf_check(mp, bp);
+        xfs_dir3_leaf_check(dp, bp);
         ASSERT(leafhdr.count > 0);
 
         /*
@@ -605,7 +560,7 @@ xfs_dir2_leafn_lookup_for_addname(
                 ASSERT(free->hdr.magic == cpu_to_be32(XFS_DIR2_FREE_MAGIC) ||
                        free->hdr.magic == cpu_to_be32(XFS_DIR3_FREE_MAGIC));
         }
-        length = xfs_dir3_data_entsize(mp, args->namelen);
+        length = dp->d_ops->data_entsize(args->namelen);
         /*
          * Loop over leaf entries with the right hash value.
          */
@@ -637,7 +592,7 @@ xfs_dir2_leafn_lookup_for_addname(
                          * Convert the data block to the free block
                          * holding its freespace information.
                          */
-                        newfdb = xfs_dir2_db_to_fdb(mp, newdb);
+                        newfdb = dp->d_ops->db_to_fdb(mp, newdb);
                         /*
                          * If it's not the one we have in hand, read it in.
                          */
@@ -655,16 +610,16 @@ xfs_dir2_leafn_lookup_for_addname(
                                         return error;
                                 free = curbp->b_addr;
 
-                                xfs_dir2_free_hdr_check(mp, curbp, curdb);
+                                xfs_dir2_free_hdr_check(dp, curbp, curdb);
                         }
                         /*
                          * Get the index for our entry.
                          */
-                        fi = xfs_dir2_db_to_fdindex(mp, curdb);
+                        fi = dp->d_ops->db_to_fdindex(mp, curdb);
                         /*
                          * If it has room, return it.
                          */
-                        bests = xfs_dir3_free_bests_p(mp, free);
+                        bests = dp->d_ops->free_bests_p(free);
                         if (unlikely(bests[fi] == cpu_to_be16(NULLDATAOFF))) {
                                 XFS_ERROR_REPORT("xfs_dir2_leafn_lookup_int",
                                                         XFS_ERRLEVEL_LOW, mp);
@@ -734,10 +689,10 @@ xfs_dir2_leafn_lookup_for_entry(
         tp = args->trans;
         mp = dp->i_mount;
         leaf = bp->b_addr;
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
 
-        xfs_dir3_leaf_check(mp, bp);
+        xfs_dir3_leaf_check(dp, bp);
         ASSERT(leafhdr.count > 0);
 
         /*
@@ -816,7 +771,7 @@ xfs_dir2_leafn_lookup_for_entry(
                                 xfs_trans_brelse(tp, state->extrablk.bp);
                         args->cmpresult = cmp;
                         args->inumber = be64_to_cpu(dep->inumber);
-                        args->filetype = xfs_dir3_dirent_get_ftype(mp, dep);
+                        args->filetype = dp->d_ops->data_get_ftype(dep);
                         *indexp = index;
                         state->extravalid = 1;
                         state->extrablk.bp = curbp;
@@ -907,7 +862,7 @@ xfs_dir3_leafn_moveents(
         if (start_d < dhdr->count) {
                 memmove(&dents[start_d + count], &dents[start_d],
                         (dhdr->count - start_d) * sizeof(xfs_dir2_leaf_entry_t));
-                xfs_dir3_leaf_log_ents(tp, bp_d, start_d + count,
+                xfs_dir3_leaf_log_ents(tp, args->dp, bp_d, start_d + count,
                                        count + dhdr->count - 1);
         }
         /*
@@ -929,7 +884,8 @@ xfs_dir3_leafn_moveents(
          */
         memcpy(&dents[start_d], &sents[start_s],
                 count * sizeof(xfs_dir2_leaf_entry_t));
-        xfs_dir3_leaf_log_ents(tp, bp_d, start_d, start_d + count - 1);
+        xfs_dir3_leaf_log_ents(tp, args->dp, bp_d,
+                               start_d, start_d + count - 1);
 
         /*
          * If there are source entries after the ones we copied,
@@ -938,7 +894,8 @@ xfs_dir3_leafn_moveents(
         if (start_s + count < shdr->count) {
                 memmove(&sents[start_s], &sents[start_s + count],
                         count * sizeof(xfs_dir2_leaf_entry_t));
-                xfs_dir3_leaf_log_ents(tp, bp_s, start_s, start_s + count - 1);
+                xfs_dir3_leaf_log_ents(tp, args->dp, bp_s,
+                                       start_s, start_s + count - 1);
         }
 
         /*
@@ -956,6 +913,7 @@ xfs_dir3_leafn_moveents(
  */
 int                                             /* sort order */
 xfs_dir2_leafn_order(
+        struct xfs_inode        *dp,
         struct xfs_buf          *leaf1_bp,              /* leaf1 buffer */
         struct xfs_buf          *leaf2_bp)              /* leaf2 buffer */
 {
@@ -966,10 +924,10 @@ xfs_dir2_leafn_order(
         struct xfs_dir3_icleaf_hdr hdr1;
         struct xfs_dir3_icleaf_hdr hdr2;
 
-        xfs_dir3_leaf_hdr_from_disk(&hdr1, leaf1);
-        xfs_dir3_leaf_hdr_from_disk(&hdr2, leaf2);
-        ents1 = xfs_dir3_leaf_ents_p(leaf1);
-        ents2 = xfs_dir3_leaf_ents_p(leaf2);
+        dp->d_ops->leaf_hdr_from_disk(&hdr1, leaf1);
+        dp->d_ops->leaf_hdr_from_disk(&hdr2, leaf2);
+        ents1 = dp->d_ops->leaf_ents_p(leaf1);
+        ents2 = dp->d_ops->leaf_ents_p(leaf2);
 
         if (hdr1.count > 0 && hdr2.count > 0 &&
             (be32_to_cpu(ents2[0].hashval) < be32_to_cpu(ents1[0].hashval) ||
@@ -1007,12 +965,13 @@ xfs_dir2_leafn_rebalance(
         struct xfs_dir2_leaf_entry *ents2;
         struct xfs_dir3_icleaf_hdr hdr1;
         struct xfs_dir3_icleaf_hdr hdr2;
+        struct xfs_inode        *dp = state->args->dp;
 
         args = state->args;
         /*
          * If the block order is wrong, swap the arguments.
          */
-        if ((swap = xfs_dir2_leafn_order(blk1->bp, blk2->bp))) {
+        if ((swap = xfs_dir2_leafn_order(dp, blk1->bp, blk2->bp))) {
                 xfs_da_state_blk_t      *tmp;   /* temp for block swap */
 
                 tmp = blk1;
@@ -1021,10 +980,10 @@ xfs_dir2_leafn_rebalance(
         }
         leaf1 = blk1->bp->b_addr;
         leaf2 = blk2->bp->b_addr;
-        xfs_dir3_leaf_hdr_from_disk(&hdr1, leaf1);
-        xfs_dir3_leaf_hdr_from_disk(&hdr2, leaf2);
-        ents1 = xfs_dir3_leaf_ents_p(leaf1);
-        ents2 = xfs_dir3_leaf_ents_p(leaf2);
+        dp->d_ops->leaf_hdr_from_disk(&hdr1, leaf1);
+        dp->d_ops->leaf_hdr_from_disk(&hdr2, leaf2);
+        ents1 = dp->d_ops->leaf_ents_p(leaf1);
+        ents2 = dp->d_ops->leaf_ents_p(leaf2);
 
         oldsum = hdr1.count + hdr2.count;
 #if defined(DEBUG) || defined(XFS_WARN)
@@ -1070,13 +1029,13 @@ xfs_dir2_leafn_rebalance(
         ASSERT(hdr1.stale + hdr2.stale == oldstale);
 
         /* log the changes made when moving the entries */
-        xfs_dir3_leaf_hdr_to_disk(leaf1, &hdr1);
-        xfs_dir3_leaf_hdr_to_disk(leaf2, &hdr2);
-        xfs_dir3_leaf_log_header(args->trans, blk1->bp);
-        xfs_dir3_leaf_log_header(args->trans, blk2->bp);
+        dp->d_ops->leaf_hdr_to_disk(leaf1, &hdr1);
+        dp->d_ops->leaf_hdr_to_disk(leaf2, &hdr2);
+        xfs_dir3_leaf_log_header(args->trans, dp, blk1->bp);
+        xfs_dir3_leaf_log_header(args->trans, dp, blk2->bp);
 
-        xfs_dir3_leaf_check(args->dp->i_mount, blk1->bp);
-        xfs_dir3_leaf_check(args->dp->i_mount, blk2->bp);
+        xfs_dir3_leaf_check(dp, blk1->bp);
+        xfs_dir3_leaf_check(dp, blk2->bp);
 
         /*
          * Mark whether we're inserting into the old or new leaf.
@@ -1097,11 +1056,11 @@ xfs_dir2_leafn_rebalance(
          * Finally sanity check just to make sure we are not returning a
          * negative index
          */
-        if(blk2->index < 0) {
+        if (blk2->index < 0) {
                 state->inleaf = 1;
                 blk2->index = 0;
-                xfs_alert(args->dp->i_mount,
-        "%s: picked the wrong leaf? reverting original leaf: blk1->index %d\n",
+                xfs_alert(dp->i_mount,
+        "%s: picked the wrong leaf? reverting original leaf: blk1->index %d",
                         __func__, blk1->index);
         }
 }
@@ -1120,17 +1079,17 @@ xfs_dir3_data_block_free(
         int                     logfree = 0;
         __be16                  *bests;
         struct xfs_dir3_icfree_hdr freehdr;
+        struct xfs_inode        *dp = args->dp;
 
-        xfs_dir3_free_hdr_from_disk(&freehdr, free);
-
-        bests = xfs_dir3_free_bests_p(tp->t_mountp, free);
+        dp->d_ops->free_hdr_from_disk(&freehdr, free);
+        bests = dp->d_ops->free_bests_p(free);
         if (hdr) {
                 /*
                  * Data block is not empty, just set the free entry to the new
                  * value.
                  */
                 bests[findex] = cpu_to_be16(longest);
-                xfs_dir2_free_log_bests(tp, fbp, findex, findex);
+                xfs_dir2_free_log_bests(tp, dp, fbp, findex, findex);
                 return 0;
         }
 
@@ -1157,8 +1116,8 @@ xfs_dir3_data_block_free(
                 logfree = 1;
         }
 
-        xfs_dir3_free_hdr_to_disk(free, &freehdr);
-        xfs_dir2_free_log_header(tp, fbp);
+        dp->d_ops->free_hdr_to_disk(free, &freehdr);
+        xfs_dir2_free_log_header(tp, dp, fbp);
 
         /*
          * If there are no useful entries left in the block, get rid of the
@@ -1182,7 +1141,7 @@ xfs_dir3_data_block_free(
 
         /* Log the free entry that changed, unless we got rid of it.  */
         if (logfree)
-                xfs_dir2_free_log_bests(tp, fbp, findex, findex);
+                xfs_dir2_free_log_bests(tp, dp, fbp, findex, findex);
         return 0;
 }
 
@@ -1222,8 +1181,8 @@ xfs_dir2_leafn_remove(
         tp = args->trans;
         mp = dp->i_mount;
         leaf = bp->b_addr;
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
-        ents = xfs_dir3_leaf_ents_p(leaf);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
 
         /*
          * Point to the entry we're removing.
@@ -1243,11 +1202,11 @@ xfs_dir2_leafn_remove(
          * Log the leaf block changes.
          */
         leafhdr.stale++;
-        xfs_dir3_leaf_hdr_to_disk(leaf, &leafhdr);
-        xfs_dir3_leaf_log_header(tp, bp);
+        dp->d_ops->leaf_hdr_to_disk(leaf, &leafhdr);
+        xfs_dir3_leaf_log_header(tp, dp, bp);
 
         lep->address = cpu_to_be32(XFS_DIR2_NULL_DATAPTR);
-        xfs_dir3_leaf_log_ents(tp, bp, index, index);
+        xfs_dir3_leaf_log_ents(tp, dp, bp, index, index);
 
         /*
          * Make the data entry free.  Keep track of the longest freespace
@@ -1256,19 +1215,19 @@ xfs_dir2_leafn_remove(
         dbp = dblk->bp;
         hdr = dbp->b_addr;
         dep = (xfs_dir2_data_entry_t *)((char *)hdr + off);
-        bf = xfs_dir3_data_bestfree_p(hdr);
+        bf = dp->d_ops->data_bestfree_p(hdr);
         longest = be16_to_cpu(bf[0].length);
         needlog = needscan = 0;
-        xfs_dir2_data_make_free(tp, dbp, off,
-                xfs_dir3_data_entsize(mp, dep->namelen), &needlog, &needscan);
+        xfs_dir2_data_make_free(tp, dp, dbp, off,
+                dp->d_ops->data_entsize(dep->namelen), &needlog, &needscan);
         /*
          * Rescan the data block freespaces for bestfree.
          * Log the data block header if needed.
          */
         if (needscan)
-                xfs_dir2_data_freescan(mp, hdr, &needlog);
+                xfs_dir2_data_freescan(dp, hdr, &needlog);
         if (needlog)
-                xfs_dir2_data_log_header(tp, dbp);
+                xfs_dir2_data_log_header(tp, dp, dbp);
         xfs_dir3_data_check(dp, dbp);
         /*
          * If the longest data block freespace changes, need to update
@@ -1285,7 +1244,7 @@ xfs_dir2_leafn_remove(
                  * Convert the data block number to a free block,
                  * read in the free block.
                  */
-                fdb = xfs_dir2_db_to_fdb(mp, db);
+                fdb = dp->d_ops->db_to_fdb(mp, db);
                 error = xfs_dir2_free_read(tp, dp, xfs_dir2_db_to_da(mp, fdb),
                                            &fbp);
                 if (error)
@@ -1294,22 +1253,22 @@ xfs_dir2_leafn_remove(
 #ifdef DEBUG
         {
                 struct xfs_dir3_icfree_hdr freehdr;
-                xfs_dir3_free_hdr_from_disk(&freehdr, free);
-                ASSERT(freehdr.firstdb == xfs_dir3_free_max_bests(mp) *
+                dp->d_ops->free_hdr_from_disk(&freehdr, free);
+                ASSERT(freehdr.firstdb == dp->d_ops->free_max_bests(mp) *
                                           (fdb - XFS_DIR2_FREE_FIRSTDB(mp)));
         }
 #endif
                 /*
                  * Calculate which entry we need to fix.
                  */
-                findex = xfs_dir2_db_to_fdindex(mp, db);
+                findex = dp->d_ops->db_to_fdindex(mp, db);
                 longest = be16_to_cpu(bf[0].length);
                 /*
                  * If the data block is now empty we can get rid of it
                  * (usually).
                  */
                 if (longest == mp->m_dirblksize -
-                               xfs_dir3_data_entry_offset(hdr)) {
+                               dp->d_ops->data_entry_offset) {
                         /*
                          * Try to punch out the data block.
                          */
@@ -1336,12 +1295,12 @@ xfs_dir2_leafn_remove(
                         return error;
         }
 
-        xfs_dir3_leaf_check(mp, bp);
+        xfs_dir3_leaf_check(dp, bp);
         /*
          * Return indication of whether this leaf block is empty enough
          * to justify trying to join it with a neighbor.
          */
-        *rval = (xfs_dir3_leaf_hdr_size(leaf) +
+        *rval = (dp->d_ops->leaf_hdr_size +
                  (uint)sizeof(ents[0]) * (leafhdr.count - leafhdr.stale)) <
                 mp->m_dir_magicpct;
         return 0;
@@ -1360,13 +1319,14 @@ xfs_dir2_leafn_split(
         xfs_dablk_t             blkno;          /* new leaf block number */
         int                     error;          /* error return value */
         xfs_mount_t             *mp;            /* filesystem mount point */
+        struct xfs_inode        *dp;
 
         /*
          * Allocate space for a new leaf node.
          */
         args = state->args;
-        mp = args->dp->i_mount;
-        ASSERT(args != NULL);
+        dp = args->dp;
+        mp = dp->i_mount;
         ASSERT(oldblk->magic == XFS_DIR2_LEAFN_MAGIC);
         error = xfs_da_grow_inode(args, &blkno);
         if (error) {
@@ -1401,10 +1361,10 @@ xfs_dir2_leafn_split(
         /*
          * Update last hashval in each block since we added the name.
          */
-        oldblk->hashval = xfs_dir2_leafn_lasthash(oldblk->bp, NULL);
-        newblk->hashval = xfs_dir2_leafn_lasthash(newblk->bp, NULL);
-        xfs_dir3_leaf_check(mp, oldblk->bp);
-        xfs_dir3_leaf_check(mp, newblk->bp);
+        oldblk->hashval = xfs_dir2_leafn_lasthash(dp, oldblk->bp, NULL);
+        newblk->hashval = xfs_dir2_leafn_lasthash(dp, newblk->bp, NULL);
+        xfs_dir3_leaf_check(dp, oldblk->bp);
+        xfs_dir3_leaf_check(dp, newblk->bp);
         return error;
 }
 
@@ -1434,6 +1394,7 @@ xfs_dir2_leafn_toosmall(
         int                     rval;           /* result from path_shift */
         struct xfs_dir3_icleaf_hdr leafhdr;
         struct xfs_dir2_leaf_entry *ents;
+        struct xfs_inode        *dp = state->args->dp;
 
         /*
          * Check for the degenerate case of the block being over 50% full.
@@ -1442,12 +1403,12 @@ xfs_dir2_leafn_toosmall(
          */
         blk = &state->path.blk[state->path.active - 1];
         leaf = blk->bp->b_addr;
-        xfs_dir3_leaf_hdr_from_disk(&leafhdr, leaf);
-        ents = xfs_dir3_leaf_ents_p(leaf);
-        xfs_dir3_leaf_check(state->args->dp->i_mount, blk->bp);
+        dp->d_ops->leaf_hdr_from_disk(&leafhdr, leaf);
+        ents = dp->d_ops->leaf_ents_p(leaf);
+        xfs_dir3_leaf_check(dp, blk->bp);
 
         count = leafhdr.count - leafhdr.stale;
-        bytes = xfs_dir3_leaf_hdr_size(leaf) + count * sizeof(ents[0]);
+        bytes = dp->d_ops->leaf_hdr_size + count * sizeof(ents[0]);
         if (bytes > (state->blocksize >> 1)) {
                 /*
                  * Blk over 50%, don't try to join.
@@ -1492,7 +1453,7 @@ xfs_dir2_leafn_toosmall(
                 /*
                  * Read the sibling leaf block.
                  */
-                error = xfs_dir3_leafn_read(state->args->trans, state->args->dp,
+                error = xfs_dir3_leafn_read(state->args->trans, dp,
                                             blkno, -1, &bp);
                 if (error)
                         return error;
@@ -1504,8 +1465,8 @@ xfs_dir2_leafn_toosmall(
                 bytes = state->blocksize - (state->blocksize >> 2);
 
                 leaf = bp->b_addr;
-                xfs_dir3_leaf_hdr_from_disk(&hdr2, leaf);
-                ents = xfs_dir3_leaf_ents_p(leaf);
+                dp->d_ops->leaf_hdr_from_disk(&hdr2, leaf);
+                ents = dp->d_ops->leaf_ents_p(leaf);
                 count += hdr2.count - hdr2.stale;
                 bytes -= count * sizeof(ents[0]);
 
@@ -1559,6 +1520,7 @@ xfs_dir2_leafn_unbalance(
         struct xfs_dir3_icleaf_hdr drophdr;
         struct xfs_dir2_leaf_entry *sents;
         struct xfs_dir2_leaf_entry *dents;
+        struct xfs_inode        *dp = state->args->dp;
 
         args = state->args;
         ASSERT(drop_blk->magic == XFS_DIR2_LEAFN_MAGIC);
@@ -1566,10 +1528,10 @@ xfs_dir2_leafn_unbalance(
         drop_leaf = drop_blk->bp->b_addr;
         save_leaf = save_blk->bp->b_addr;
 
-        xfs_dir3_leaf_hdr_from_disk(&savehdr, save_leaf);
-        xfs_dir3_leaf_hdr_from_disk(&drophdr, drop_leaf);
-        sents = xfs_dir3_leaf_ents_p(save_leaf);
-        dents = xfs_dir3_leaf_ents_p(drop_leaf);
+        dp->d_ops->leaf_hdr_from_disk(&savehdr, save_leaf);
+        dp->d_ops->leaf_hdr_from_disk(&drophdr, drop_leaf);
+        sents = dp->d_ops->leaf_ents_p(save_leaf);
+        dents = dp->d_ops->leaf_ents_p(drop_leaf);
 
         /*
          * If there are any stale leaf entries, take this opportunity
@@ -1584,7 +1546,7 @@ xfs_dir2_leafn_unbalance(
          * Move the entries from drop to the appropriate end of save.
          */
         drop_blk->hashval = be32_to_cpu(dents[drophdr.count - 1].hashval);
-        if (xfs_dir2_leafn_order(save_blk->bp, drop_blk->bp))
+        if (xfs_dir2_leafn_order(dp, save_blk->bp, drop_blk->bp))
                 xfs_dir3_leafn_moveents(args, drop_blk->bp, &drophdr, dents, 0,
                                         save_blk->bp, &savehdr, sents, 0,
                                         drophdr.count);
@@ -1595,13 +1557,13 @@ xfs_dir2_leafn_unbalance(
         save_blk->hashval = be32_to_cpu(sents[savehdr.count - 1].hashval);
 
         /* log the changes made when moving the entries */
-        xfs_dir3_leaf_hdr_to_disk(save_leaf, &savehdr);
-        xfs_dir3_leaf_hdr_to_disk(drop_leaf, &drophdr);
-        xfs_dir3_leaf_log_header(args->trans, save_blk->bp);
-        xfs_dir3_leaf_log_header(args->trans, drop_blk->bp);
+        dp->d_ops->leaf_hdr_to_disk(save_leaf, &savehdr);
+        dp->d_ops->leaf_hdr_to_disk(drop_leaf, &drophdr);
+        xfs_dir3_leaf_log_header(args->trans, dp, save_blk->bp);
+        xfs_dir3_leaf_log_header(args->trans, dp, drop_blk->bp);
 
-        xfs_dir3_leaf_check(args->dp->i_mount, save_blk->bp);
-        xfs_dir3_leaf_check(args->dp->i_mount, drop_blk->bp);
+        xfs_dir3_leaf_check(dp, save_blk->bp);
+        xfs_dir3_leaf_check(dp, drop_blk->bp);
 }
 
 /*
@@ -1712,7 +1674,7 @@ xfs_dir2_node_addname_int(
         dp = args->dp;
         mp = dp->i_mount;
         tp = args->trans;
-        length = xfs_dir3_data_entsize(mp, args->namelen);
+        length = dp->d_ops->data_entsize(args->namelen);
         /*
          * If we came in with a freespace block that means that lookup
          * found an entry with our hash value.  This is the freespace
@@ -1726,8 +1688,8 @@ xfs_dir2_node_addname_int(
                 ifbno = fblk->blkno;
                 free = fbp->b_addr;
                 findex = fblk->index;
-                bests = xfs_dir3_free_bests_p(mp, free);
-                xfs_dir3_free_hdr_from_disk(&freehdr, free);
+                bests = dp->d_ops->free_bests_p(free);
+                dp->d_ops->free_hdr_from_disk(&freehdr, free);
 
                 /*
                  * This means the free entry showed that the data block had
@@ -1819,8 +1781,8 @@ xfs_dir2_node_addname_int(
                  * and the freehdr are actually initialised if they are placed
                  * there, so we have to do it here to avoid warnings. Blech.
                  */
-                bests = xfs_dir3_free_bests_p(mp, free);
-                xfs_dir3_free_hdr_from_disk(&freehdr, free);
+                bests = dp->d_ops->free_bests_p(free);
+                dp->d_ops->free_hdr_from_disk(&freehdr, free);
                 if (be16_to_cpu(bests[findex]) != NULLDATAOFF &&
                     be16_to_cpu(bests[findex]) >= length)
                         dbno = freehdr.firstdb + findex;
@@ -1871,7 +1833,7 @@ xfs_dir2_node_addname_int(
                  * Get the freespace block corresponding to the data block
                  * that was just allocated.
                  */
-                fbno = xfs_dir2_db_to_fdb(mp, dbno);
+                fbno = dp->d_ops->db_to_fdb(mp, dbno);
                 error = xfs_dir2_free_try_read(tp, dp,
                                                xfs_dir2_db_to_da(mp, fbno),
                                                &fbp);
@@ -1888,12 +1850,12 @@ xfs_dir2_node_addname_int(
                         if (error)
                                 return error;
 
-                        if (unlikely(xfs_dir2_db_to_fdb(mp, dbno) != fbno)) {
+                        if (unlikely(dp->d_ops->db_to_fdb(mp, dbno) != fbno)) {
                                 xfs_alert(mp,
                         "%s: dir ino %llu needed freesp block %lld for\n"
                         "  data block %lld, got %lld ifbno %llu lastfbno %d",
                                         __func__, (unsigned long long)dp->i_ino,
-                                        (long long)xfs_dir2_db_to_fdb(mp, dbno),
+                                        (long long)dp->d_ops->db_to_fdb(mp, dbno),
                                         (long long)dbno, (long long)fbno,
                                         (unsigned long long)ifbno, lastfbno);
                                 if (fblk) {
@@ -1918,30 +1880,30 @@ xfs_dir2_node_addname_int(
                         if (error)
                                 return error;
                         free = fbp->b_addr;
-                        bests = xfs_dir3_free_bests_p(mp, free);
-                        xfs_dir3_free_hdr_from_disk(&freehdr, free);
+                        bests = dp->d_ops->free_bests_p(free);
+                        dp->d_ops->free_hdr_from_disk(&freehdr, free);
 
                         /*
                          * Remember the first slot as our empty slot.
                          */
                         freehdr.firstdb = (fbno - XFS_DIR2_FREE_FIRSTDB(mp)) *
-                                        xfs_dir3_free_max_bests(mp);
+                                        dp->d_ops->free_max_bests(mp);
                 } else {
                         free = fbp->b_addr;
-                        bests = xfs_dir3_free_bests_p(mp, free);
-                        xfs_dir3_free_hdr_from_disk(&freehdr, free);
+                        bests = dp->d_ops->free_bests_p(free);
+                        dp->d_ops->free_hdr_from_disk(&freehdr, free);
                 }
 
                 /*
                  * Set the freespace block index from the data block number.
                  */
-                findex = xfs_dir2_db_to_fdindex(mp, dbno);
+                findex = dp->d_ops->db_to_fdindex(mp, dbno);
                 /*
                  * If it's after the end of the current entries in the
                  * freespace block, extend that table.
                  */
                 if (findex >= freehdr.nvalid) {
-                        ASSERT(findex < xfs_dir3_free_max_bests(mp));
+                        ASSERT(findex < dp->d_ops->free_max_bests(mp));
                         freehdr.nvalid = findex + 1;
                         /*
                          * Tag new entry so nused will go up.
@@ -1954,8 +1916,8 @@ xfs_dir2_node_addname_int(
                  */
                 if (bests[findex] == cpu_to_be16(NULLDATAOFF)) {
                         freehdr.nused++;
-                        xfs_dir3_free_hdr_to_disk(fbp->b_addr, &freehdr);
-                        xfs_dir2_free_log_header(tp, fbp);
+                        dp->d_ops->free_hdr_to_disk(fbp->b_addr, &freehdr);
+                        xfs_dir2_free_log_header(tp, dp, fbp);
                 }
                 /*
                  * Update the real value in the table.
@@ -1963,7 +1925,7 @@ xfs_dir2_node_addname_int(
                  * change again.
                  */
                 hdr = dbp->b_addr;
-                bf = xfs_dir3_data_bestfree_p(hdr);
+                bf = dp->d_ops->data_bestfree_p(hdr);
                 bests[findex] = bf[0].length;
                 logfree = 1;
         }
@@ -1985,7 +1947,7 @@ xfs_dir2_node_addname_int(
                 if (error)
                         return error;
                 hdr = dbp->b_addr;
-                bf = xfs_dir3_data_bestfree_p(hdr);
+                bf = dp->d_ops->data_bestfree_p(hdr);
                 logfree = 0;
         }
         ASSERT(be16_to_cpu(bf[0].length) >= length);
@@ -1998,7 +1960,7 @@ xfs_dir2_node_addname_int(
         /*
          * Mark the first part of the unused space, inuse for us.
          */
-        xfs_dir2_data_use_free(tp, dbp, dup,
+        xfs_dir2_data_use_free(tp, dp, dbp, dup,
                 (xfs_dir2_data_aoff_t)((char *)dup - (char *)hdr), length,
                 &needlog, &needscan);
         /*
@@ -2008,24 +1970,24 @@ xfs_dir2_node_addname_int(
         dep->inumber = cpu_to_be64(args->inumber);
         dep->namelen = args->namelen;
         memcpy(dep->name, args->name, dep->namelen);
-        xfs_dir3_dirent_put_ftype(mp, dep, args->filetype);
-        tagp = xfs_dir3_data_entry_tag_p(mp, dep);
+        dp->d_ops->data_put_ftype(dep, args->filetype);
+        tagp = dp->d_ops->data_entry_tag_p(dep);
         *tagp = cpu_to_be16((char *)dep - (char *)hdr);
-        xfs_dir2_data_log_entry(tp, dbp, dep);
+        xfs_dir2_data_log_entry(tp, dp, dbp, dep);
         /*
          * Rescan the block for bestfree if needed.
          */
         if (needscan)
-                xfs_dir2_data_freescan(mp, hdr, &needlog);
+                xfs_dir2_data_freescan(dp, hdr, &needlog);
         /*
          * Log the data block header if needed.
          */
         if (needlog)
-                xfs_dir2_data_log_header(tp, dbp);
+                xfs_dir2_data_log_header(tp, dp, dbp);
         /*
          * If the freespace entry is now wrong, update it.
          */
-        bests = xfs_dir3_free_bests_p(mp, free); /* gcc is so stupid */
+        bests = dp->d_ops->free_bests_p(free); /* gcc is so stupid */
         if (be16_to_cpu(bests[findex]) != be16_to_cpu(bf[0].length)) {
                 bests[findex] = bf[0].length;
                 logfree = 1;
@@ -2034,7 +1996,7 @@ xfs_dir2_node_addname_int(
          * Log the freespace entry if needed.
          */
         if (logfree)
-                xfs_dir2_free_log_bests(tp, fbp, findex, findex);
+                xfs_dir2_free_log_bests(tp, dp, fbp, findex, findex);
         /*
          * Return the data block and offset in args, then drop the data block.
          */
@@ -2212,7 +2174,7 @@ xfs_dir2_node_replace(
                 blk = &state->path.blk[state->path.active - 1];
                 ASSERT(blk->magic == XFS_DIR2_LEAFN_MAGIC);
                 leaf = blk->bp->b_addr;
-                ents = xfs_dir3_leaf_ents_p(leaf);
+                ents = args->dp->d_ops->leaf_ents_p(leaf);
                 lep = &ents[blk->index];
                 ASSERT(state->extravalid);
                 /*
@@ -2229,8 +2191,9 @@ xfs_dir2_node_replace(
                  * Fill in the new inode number and log the entry.
                  */
                 dep->inumber = cpu_to_be64(inum);
-                xfs_dir3_dirent_put_ftype(state->mp, dep, args->filetype);
-                xfs_dir2_data_log_entry(args->trans, state->extrablk.bp, dep);
+                args->dp->d_ops->data_put_ftype(dep, args->filetype);
+                xfs_dir2_data_log_entry(args->trans, args->dp,
+                                        state->extrablk.bp, dep);
                 rval = 0;
         }
         /*
@@ -2285,7 +2248,7 @@ xfs_dir2_node_trim_free(
         if (!bp)
                 return 0;
         free = bp->b_addr;
-        xfs_dir3_free_hdr_from_disk(&freehdr, free);
+        dp->d_ops->free_hdr_from_disk(&freehdr, free);
 
         /*
          * If there are used entries, there's nothing to do.
diff --git a/fs/xfs/xfs_dir2_priv.h b/fs/xfs/xfs_dir2_priv.h
index 1bad84c40829..8b9d2281f85b 100644
--- a/fs/xfs/xfs_dir2_priv.h
+++ b/fs/xfs/xfs_dir2_priv.h
@@ -59,7 +59,8 @@ extern int xfs_dir3_data_readahead(struct xfs_trans *tp, struct xfs_inode *dp,
 
 extern struct xfs_dir2_data_free *
 xfs_dir2_data_freeinsert(struct xfs_dir2_data_hdr *hdr,
-                struct xfs_dir2_data_unused *dup, int *loghead);
+                struct xfs_dir2_data_free *bf, struct xfs_dir2_data_unused *dup,
+                int *loghead);
 extern int xfs_dir3_data_init(struct xfs_da_args *args, xfs_dir2_db_t blkno,
                 struct xfs_buf **bpp);
 
@@ -76,9 +77,9 @@ extern void xfs_dir3_leaf_compact_x1(struct xfs_dir3_icleaf_hdr *leafhdr,
                 int *lowstalep, int *highstalep, int *lowlogp, int *highlogp);
 extern int xfs_dir3_leaf_get_buf(struct xfs_da_args *args, xfs_dir2_db_t bno,
                 struct xfs_buf **bpp, __uint16_t magic);
-extern void xfs_dir3_leaf_log_ents(struct xfs_trans *tp, struct xfs_buf *bp,
-                int first, int last);
-extern void xfs_dir3_leaf_log_header(struct xfs_trans *tp,
+extern void xfs_dir3_leaf_log_ents(struct xfs_trans *tp, struct xfs_inode *dp,
+                struct xfs_buf *bp, int first, int last);
+extern void xfs_dir3_leaf_log_header(struct xfs_trans *tp, struct xfs_inode *dp,
                 struct xfs_buf *bp);
 extern int xfs_dir2_leaf_lookup(struct xfs_da_args *args);
 extern int xfs_dir2_leaf_removename(struct xfs_da_args *args);
@@ -93,21 +94,18 @@ xfs_dir3_leaf_find_entry(struct xfs_dir3_icleaf_hdr *leafhdr,
                 int lowstale, int highstale, int *lfloglow, int *lfloghigh);
 extern int xfs_dir2_node_to_leaf(struct xfs_da_state *state);
 
-extern void xfs_dir3_leaf_hdr_from_disk(struct xfs_dir3_icleaf_hdr *to,
-                struct xfs_dir2_leaf *from);
-extern void xfs_dir3_leaf_hdr_to_disk(struct xfs_dir2_leaf *to,
-                struct xfs_dir3_icleaf_hdr *from);
-extern bool xfs_dir3_leaf_check_int(struct xfs_mount *mp,
+extern bool xfs_dir3_leaf_check_int(struct xfs_mount *mp, struct xfs_inode *dp,
                 struct xfs_dir3_icleaf_hdr *hdr, struct xfs_dir2_leaf *leaf);
 
 /* xfs_dir2_node.c */
 extern int xfs_dir2_leaf_to_node(struct xfs_da_args *args,
                 struct xfs_buf *lbp);
-extern xfs_dahash_t xfs_dir2_leafn_lasthash(struct xfs_buf *bp, int *count);
+extern xfs_dahash_t xfs_dir2_leafn_lasthash(struct xfs_inode *dp,
+                struct xfs_buf *bp, int *count);
 extern int xfs_dir2_leafn_lookup_int(struct xfs_buf *bp,
                 struct xfs_da_args *args, int *indexp,
                 struct xfs_da_state *state);
-extern int xfs_dir2_leafn_order(struct xfs_buf *leaf1_bp,
+extern int xfs_dir2_leafn_order(struct xfs_inode *dp, struct xfs_buf *leaf1_bp,
                 struct xfs_buf *leaf2_bp);
 extern int xfs_dir2_leafn_split(struct xfs_da_state *state,
         struct xfs_da_state_blk *oldblk, struct xfs_da_state_blk *newblk);
diff --git a/fs/xfs/xfs_dir2_readdir.c b/fs/xfs/xfs_dir2_readdir.c
index 8993ec17452c..c4e50c6ed584 100644
--- a/fs/xfs/xfs_dir2_readdir.c
+++ b/fs/xfs/xfs_dir2_readdir.c
@@ -18,23 +18,23 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_da_format.h"
 #include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
-#include "xfs_dir2_format.h"
 #include "xfs_dir2.h"
 #include "xfs_dir2_priv.h"
 #include "xfs_error.h"
 #include "xfs_trace.h"
 #include "xfs_bmap.h"
+#include "xfs_trans.h"
+#include "xfs_dinode.h"
 
 /*
  * Directory file type support functions
@@ -119,9 +119,9 @@ xfs_dir2_sf_getdents(
          * mp->m_dirdatablk.
          */
         dot_offset = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
-                                             XFS_DIR3_DATA_DOT_OFFSET(mp));
+                                                dp->d_ops->data_dot_offset);
         dotdot_offset = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk,
-                                                XFS_DIR3_DATA_DOTDOT_OFFSET(mp));
+                                                dp->d_ops->data_dotdot_offset);
 
         /*
          * Put . entry unless we're starting past it.
@@ -136,7 +136,7 @@ xfs_dir2_sf_getdents(
          * Put .. entry unless we're starting past it.
          */
         if (ctx->pos <= dotdot_offset) {
-                ino = xfs_dir2_sf_get_parent_ino(sfp);
+                ino = dp->d_ops->sf_get_parent_ino(sfp);
                 ctx->pos = dotdot_offset & 0x7fffffff;
                 if (!dir_emit(ctx, "..", 2, ino, DT_DIR))
                         return 0;
@@ -153,17 +153,17 @@ xfs_dir2_sf_getdents(
                                 xfs_dir2_sf_get_offset(sfep));
 
                 if (ctx->pos > off) {
-                        sfep = xfs_dir3_sf_nextentry(mp, sfp, sfep);
+                        sfep = dp->d_ops->sf_nextentry(sfp, sfep);
                         continue;
                 }
 
-                ino = xfs_dir3_sfe_get_ino(mp, sfp, sfep);
-                filetype = xfs_dir3_sfe_get_ftype(mp, sfp, sfep);
+                ino = dp->d_ops->sf_get_ino(sfp, sfep);
+                filetype = dp->d_ops->sf_get_ftype(sfep);
                 ctx->pos = off & 0x7fffffff;
                 if (!dir_emit(ctx, (char *)sfep->name, sfep->namelen, ino,
                             xfs_dir3_get_dtype(mp, filetype)))
                         return 0;
-                sfep = xfs_dir3_sf_nextentry(mp, sfp, sfep);
+                sfep = dp->d_ops->sf_nextentry(sfp, sfep);
         }
 
         ctx->pos = xfs_dir2_db_off_to_dataptr(mp, mp->m_dirdatablk + 1, 0) &
@@ -213,7 +213,7 @@ xfs_dir2_block_getdents(
          * Set up values for the loop.
          */
         btp = xfs_dir2_block_tail_p(mp, hdr);
-        ptr = (char *)xfs_dir3_data_entry_p(hdr);
+        ptr = (char *)dp->d_ops->data_entry_p(hdr);
         endptr = (char *)xfs_dir2_block_leaf_p(btp);
 
         /*
@@ -237,7 +237,7 @@ xfs_dir2_block_getdents(
                 /*
                  * Bump pointer for the next iteration.
                  */
-                ptr += xfs_dir3_data_entsize(mp, dep->namelen);
+                ptr += dp->d_ops->data_entsize(dep->namelen);
                 /*
                  * The entry is before the desired starting point, skip it.
                  */
@@ -248,7 +248,7 @@ xfs_dir2_block_getdents(
                                             (char *)dep - (char *)hdr);
 
                 ctx->pos = cook & 0x7fffffff;
-                filetype = xfs_dir3_dirent_get_ftype(mp, dep);
+                filetype = dp->d_ops->data_get_ftype(dep);
                 /*
                  * If it didn't fit, set the final offset to here & return.
                  */
@@ -578,13 +578,13 @@ xfs_dir2_leaf_getdents(
                         /*
                          * Find our position in the block.
                          */
-                        ptr = (char *)xfs_dir3_data_entry_p(hdr);
+                        ptr = (char *)dp->d_ops->data_entry_p(hdr);
                         byteoff = xfs_dir2_byte_to_off(mp, curoff);
                         /*
                          * Skip past the header.
                          */
                         if (byteoff == 0)
-                                curoff += xfs_dir3_data_entry_offset(hdr);
+                                curoff += dp->d_ops->data_entry_offset;
                         /*
                          * Skip past entries until we reach our offset.
                          */
@@ -601,7 +601,7 @@ xfs_dir2_leaf_getdents(
                                         }
                                         dep = (xfs_dir2_data_entry_t *)ptr;
                                         length =
-                                           xfs_dir3_data_entsize(mp, dep->namelen);
+                                           dp->d_ops->data_entsize(dep->namelen);
                                         ptr += length;
                                 }
                                 /*
@@ -632,8 +632,8 @@ xfs_dir2_leaf_getdents(
                 }
 
                 dep = (xfs_dir2_data_entry_t *)ptr;
-                length = xfs_dir3_data_entsize(mp, dep->namelen);
-                filetype = xfs_dir3_dirent_get_ftype(mp, dep);
+                length = dp->d_ops->data_entsize(dep->namelen);
+                filetype = dp->d_ops->data_get_ftype(dep);
 
                 ctx->pos = xfs_dir2_byte_to_dataptr(mp, curoff) & 0x7fffffff;
                 if (!dir_emit(ctx, (char *)dep->name, dep->namelen,
diff --git a/fs/xfs/xfs_dir2_sf.c b/fs/xfs/xfs_dir2_sf.c
index bb6e2848f473..aafc6e46cb58 100644
--- a/fs/xfs/xfs_dir2_sf.c
+++ b/fs/xfs/xfs_dir2_sf.c
@@ -17,22 +17,22 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_da_format.h"
 #include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
 #include "xfs_error.h"
-#include "xfs_dir2_format.h"
 #include "xfs_dir2.h"
 #include "xfs_dir2_priv.h"
 #include "xfs_trace.h"
+#include "xfs_dinode.h"
 
 /*
  * Prototypes for internal functions.
@@ -57,89 +57,6 @@ static void xfs_dir2_sf_toino8(xfs_da_args_t *args);
 #endif /* XFS_BIG_INUMS */
 
 /*
- * Inode numbers in short-form directories can come in two versions,
- * either 4 bytes or 8 bytes wide.  These helpers deal with the
- * two forms transparently by looking at the headers i8count field.
- *
- * For 64-bit inode number the most significant byte must be zero.
- */
-static xfs_ino_t
-xfs_dir2_sf_get_ino(
-        struct xfs_dir2_sf_hdr  *hdr,
-        xfs_dir2_inou_t         *from)
-{
-        if (hdr->i8count)
-                return get_unaligned_be64(&from->i8.i) & 0x00ffffffffffffffULL;
-        else
-                return get_unaligned_be32(&from->i4.i);
-}
-
-static void
-xfs_dir2_sf_put_ino(
-        struct xfs_dir2_sf_hdr  *hdr,
-        xfs_dir2_inou_t         *to,
-        xfs_ino_t               ino)
-{
-        ASSERT((ino & 0xff00000000000000ULL) == 0);
-
-        if (hdr->i8count)
-                put_unaligned_be64(ino, &to->i8.i);
-        else
-                put_unaligned_be32(ino, &to->i4.i);
-}
-
-xfs_ino_t
-xfs_dir2_sf_get_parent_ino(
-        struct xfs_dir2_sf_hdr  *hdr)
-{
-        return xfs_dir2_sf_get_ino(hdr, &hdr->parent);
-}
-
-void
-xfs_dir2_sf_put_parent_ino(
-        struct xfs_dir2_sf_hdr  *hdr,
-        xfs_ino_t               ino)
-{
-        xfs_dir2_sf_put_ino(hdr, &hdr->parent, ino);
-}
-
-/*
- * In short-form directory entries the inode numbers are stored at variable
- * offset behind the entry name. If the entry stores a filetype value, then it
- * sits between the name and the inode number. Hence the inode numbers may only
- * be accessed through the helpers below.
- */
-static xfs_dir2_inou_t *
-xfs_dir3_sfe_inop(
-        struct xfs_mount        *mp,
-        struct xfs_dir2_sf_entry *sfep)
-{
-        __uint8_t       *ptr = &sfep->name[sfep->namelen];
-        if (xfs_sb_version_hasftype(&mp->m_sb))
-                ptr++;
-        return (xfs_dir2_inou_t *)ptr;
-}
-
-xfs_ino_t
-xfs_dir3_sfe_get_ino(
-        struct xfs_mount        *mp,
-        struct xfs_dir2_sf_hdr  *hdr,
-        struct xfs_dir2_sf_entry *sfep)
-{
-        return xfs_dir2_sf_get_ino(hdr, xfs_dir3_sfe_inop(mp, sfep));
-}
-
-void
-xfs_dir3_sfe_put_ino(
-        struct xfs_mount        *mp,
-        struct xfs_dir2_sf_hdr  *hdr,
-        struct xfs_dir2_sf_entry *sfep,
-        xfs_ino_t               ino)
-{
-        xfs_dir2_sf_put_ino(hdr, xfs_dir3_sfe_inop(mp, sfep), ino);
-}
-
-/*
  * Given a block directory (dp/block), calculate its size as a shortform (sf)
  * directory and a header for the sf directory, if it will fit it the
  * space currently present in the inode.  If it won't fit, the output
@@ -226,7 +143,7 @@ xfs_dir2_block_sfsize(
          */
         sfhp->count = count;
         sfhp->i8count = i8count;
-        xfs_dir2_sf_put_parent_ino(sfhp, parent);
+        dp->d_ops->sf_put_parent_ino(sfhp, parent);
         return size;
 }
 
@@ -293,7 +210,7 @@ xfs_dir2_block_to_sf(
          * Set up to loop over the block's entries.
          */
         btp = xfs_dir2_block_tail_p(mp, hdr);
-        ptr = (char *)xfs_dir3_data_entry_p(hdr);
+        ptr = (char *)dp->d_ops->data_entry_p(hdr);
         endptr = (char *)xfs_dir2_block_leaf_p(btp);
         sfep = xfs_dir2_sf_firstentry(sfp);
         /*
@@ -321,7 +238,7 @@ xfs_dir2_block_to_sf(
                 else if (dep->namelen == 2 &&
                          dep->name[0] == '.' && dep->name[1] == '.')
                         ASSERT(be64_to_cpu(dep->inumber) ==
-                               xfs_dir2_sf_get_parent_ino(sfp));
+                               dp->d_ops->sf_get_parent_ino(sfp));
                 /*
                  * Normal entry, copy it into shortform.
                  */
@@ -331,14 +248,14 @@ xfs_dir2_block_to_sf(
                                 (xfs_dir2_data_aoff_t)
                                 ((char *)dep - (char *)hdr));
                         memcpy(sfep->name, dep->name, dep->namelen);
-                        xfs_dir3_sfe_put_ino(mp, sfp, sfep,
-                                             be64_to_cpu(dep->inumber));
-                        xfs_dir3_sfe_put_ftype(mp, sfp, sfep,
-                                        xfs_dir3_dirent_get_ftype(mp, dep));
+                        dp->d_ops->sf_put_ino(sfp, sfep,
+                                              be64_to_cpu(dep->inumber));
+                        dp->d_ops->sf_put_ftype(sfep,
+                                        dp->d_ops->data_get_ftype(dep));
 
-                        sfep = xfs_dir3_sf_nextentry(mp, sfp, sfep);
+                        sfep = dp->d_ops->sf_nextentry(sfp, sfep);
                 }
-                ptr += xfs_dir3_data_entsize(mp, dep->namelen);
+                ptr += dp->d_ops->data_entsize(dep->namelen);
         }
         ASSERT((char *)sfep - (char *)sfp == size);
         xfs_dir2_sf_check(args);
@@ -389,7 +306,7 @@ xfs_dir2_sf_addname(
         /*
          * Compute entry (and change in) size.
          */
-        add_entsize = xfs_dir3_sf_entsize(dp->i_mount, sfp, args->namelen);
+        add_entsize = dp->d_ops->sf_entsize(sfp, args->namelen);
         incr_isize = add_entsize;
         objchange = 0;
 #if XFS_BIG_INUMS
@@ -483,8 +400,7 @@ xfs_dir2_sf_addname_easy(
         /*
          * Grow the in-inode space.
          */
-        xfs_idata_realloc(dp,
-                          xfs_dir3_sf_entsize(dp->i_mount, sfp, args->namelen),
+        xfs_idata_realloc(dp, dp->d_ops->sf_entsize(sfp, args->namelen),
                           XFS_DATA_FORK);
         /*
          * Need to set up again due to realloc of the inode data.
@@ -497,8 +413,8 @@ xfs_dir2_sf_addname_easy(
         sfep->namelen = args->namelen;
         xfs_dir2_sf_put_offset(sfep, offset);
         memcpy(sfep->name, args->name, sfep->namelen);
-        xfs_dir3_sfe_put_ino(dp->i_mount, sfp, sfep, args->inumber);
-        xfs_dir3_sfe_put_ftype(dp->i_mount, sfp, sfep, args->filetype);
+        dp->d_ops->sf_put_ino(sfp, sfep, args->inumber);
+        dp->d_ops->sf_put_ftype(sfep, args->filetype);
 
         /*
          * Update the header and inode.
@@ -557,13 +473,13 @@ xfs_dir2_sf_addname_hard(
          * to insert the new entry.
          * If it's going to end up at the end then oldsfep will point there.
          */
-        for (offset = XFS_DIR3_DATA_FIRST_OFFSET(mp),
+        for (offset = dp->d_ops->data_first_offset,
               oldsfep = xfs_dir2_sf_firstentry(oldsfp),
-              add_datasize = xfs_dir3_data_entsize(mp, args->namelen),
+              add_datasize = dp->d_ops->data_entsize(args->namelen),
               eof = (char *)oldsfep == &buf[old_isize];
              !eof;
-             offset = new_offset + xfs_dir3_data_entsize(mp, oldsfep->namelen),
-              oldsfep = xfs_dir3_sf_nextentry(mp, oldsfp, oldsfep),
+             offset = new_offset + dp->d_ops->data_entsize(oldsfep->namelen),
+              oldsfep = dp->d_ops->sf_nextentry(oldsfp, oldsfep),
               eof = (char *)oldsfep == &buf[old_isize]) {
                 new_offset = xfs_dir2_sf_get_offset(oldsfep);
                 if (offset + add_datasize <= new_offset)
@@ -592,8 +508,8 @@ xfs_dir2_sf_addname_hard(
         sfep->namelen = args->namelen;
         xfs_dir2_sf_put_offset(sfep, offset);
         memcpy(sfep->name, args->name, sfep->namelen);
-        xfs_dir3_sfe_put_ino(mp, sfp, sfep, args->inumber);
-        xfs_dir3_sfe_put_ftype(mp, sfp, sfep, args->filetype);
+        dp->d_ops->sf_put_ino(sfp, sfep, args->inumber);
+        dp->d_ops->sf_put_ftype(sfep, args->filetype);
         sfp->count++;
 #if XFS_BIG_INUMS
         if (args->inumber > XFS_DIR2_MAX_SHORT_INUM && !objchange)
@@ -603,7 +519,7 @@ xfs_dir2_sf_addname_hard(
          * If there's more left to copy, do that.
          */
         if (!eof) {
-                sfep = xfs_dir3_sf_nextentry(mp, sfp, sfep);
+                sfep = dp->d_ops->sf_nextentry(sfp, sfep);
                 memcpy(sfep, oldsfep, old_isize - nbytes);
         }
         kmem_free(buf);
@@ -639,8 +555,8 @@ xfs_dir2_sf_addname_pick(
         mp = dp->i_mount;
 
         sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
-        size = xfs_dir3_data_entsize(mp, args->namelen);
-        offset = XFS_DIR3_DATA_FIRST_OFFSET(mp);
+        size = dp->d_ops->data_entsize(args->namelen);
+        offset = dp->d_ops->data_first_offset;
         sfep = xfs_dir2_sf_firstentry(sfp);
         holefit = 0;
         /*
@@ -652,8 +568,8 @@ xfs_dir2_sf_addname_pick(
                 if (!holefit)
                         holefit = offset + size <= xfs_dir2_sf_get_offset(sfep);
                 offset = xfs_dir2_sf_get_offset(sfep) +
-                         xfs_dir3_data_entsize(mp, sfep->namelen);
-                sfep = xfs_dir3_sf_nextentry(mp, sfp, sfep);
+                         dp->d_ops->data_entsize(sfep->namelen);
+                sfep = dp->d_ops->sf_nextentry(sfp, sfep);
         }
         /*
          * Calculate data bytes used excluding the new entry, if this
@@ -713,21 +629,20 @@ xfs_dir2_sf_check(
         mp = dp->i_mount;
 
         sfp = (xfs_dir2_sf_hdr_t *)dp->i_df.if_u1.if_data;
-        offset = XFS_DIR3_DATA_FIRST_OFFSET(mp);
-        ino = xfs_dir2_sf_get_parent_ino(sfp);
+        offset = dp->d_ops->data_first_offset;
+        ino = dp->d_ops->sf_get_parent_ino(sfp);
         i8count = ino > XFS_DIR2_MAX_SHORT_INUM;
 
         for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp);
              i < sfp->count;
-             i++, sfep = xfs_dir3_sf_nextentry(mp, sfp, sfep)) {
+             i++, sfep = dp->d_ops->sf_nextentry(sfp, sfep)) {
                 ASSERT(xfs_dir2_sf_get_offset(sfep) >= offset);
-                ino = xfs_dir3_sfe_get_ino(mp, sfp, sfep);
+                ino = dp->d_ops->sf_get_ino(sfp, sfep);
                 i8count += ino > XFS_DIR2_MAX_SHORT_INUM;
                 offset =
                         xfs_dir2_sf_get_offset(sfep) +
-                        xfs_dir3_data_entsize(mp, sfep->namelen);
-                ASSERT(xfs_dir3_sfe_get_ftype(mp, sfp, sfep) <
-                                                        XFS_DIR3_FT_MAX);
+                        dp->d_ops->data_entsize(sfep->namelen);
+                ASSERT(dp->d_ops->sf_get_ftype(sfep) < XFS_DIR3_FT_MAX);
         }
         ASSERT(i8count == sfp->i8count);
         ASSERT(XFS_BIG_INUMS || i8count == 0);
@@ -783,7 +698,7 @@ xfs_dir2_sf_create(
         /*
          * Now can put in the inode number, since i8count is set.
          */
-        xfs_dir2_sf_put_parent_ino(sfp, pino);
+        dp->d_ops->sf_put_parent_ino(sfp, pino);
         sfp->count = 0;
         dp->i_d.di_size = size;
         xfs_dir2_sf_check(args);
@@ -838,7 +753,7 @@ xfs_dir2_sf_lookup(
          */
         if (args->namelen == 2 &&
             args->name[0] == '.' && args->name[1] == '.') {
-                args->inumber = xfs_dir2_sf_get_parent_ino(sfp);
+                args->inumber = dp->d_ops->sf_get_parent_ino(sfp);
                 args->cmpresult = XFS_CMP_EXACT;
                 args->filetype = XFS_DIR3_FT_DIR;
                 return XFS_ERROR(EEXIST);
@@ -848,7 +763,7 @@ xfs_dir2_sf_lookup(
          */
         ci_sfep = NULL;
         for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp); i < sfp->count;
-             i++, sfep = xfs_dir3_sf_nextentry(dp->i_mount, sfp, sfep)) {
+             i++, sfep = dp->d_ops->sf_nextentry(sfp, sfep)) {
                 /*
                  * Compare name and if it's an exact match, return the inode
                  * number. If it's the first case-insensitive match, store the
@@ -858,10 +773,8 @@ xfs_dir2_sf_lookup(
                                                                 sfep->namelen);
                 if (cmp != XFS_CMP_DIFFERENT && cmp != args->cmpresult) {
                         args->cmpresult = cmp;
-                        args->inumber = xfs_dir3_sfe_get_ino(dp->i_mount,
-                                                             sfp, sfep);
-                        args->filetype = xfs_dir3_sfe_get_ftype(dp->i_mount,
-                                                                sfp, sfep);
+                        args->inumber = dp->d_ops->sf_get_ino(sfp, sfep);
+                        args->filetype = dp->d_ops->sf_get_ftype(sfep);
                         if (cmp == XFS_CMP_EXACT)
                                 return XFS_ERROR(EEXIST);
                         ci_sfep = sfep;
@@ -917,10 +830,10 @@ xfs_dir2_sf_removename(
          * Find the one we're deleting.
          */
         for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp); i < sfp->count;
-             i++, sfep = xfs_dir3_sf_nextentry(dp->i_mount, sfp, sfep)) {
+             i++, sfep = dp->d_ops->sf_nextentry(sfp, sfep)) {
                 if (xfs_da_compname(args, sfep->name, sfep->namelen) ==
                                                                 XFS_CMP_EXACT) {
-                        ASSERT(xfs_dir3_sfe_get_ino(dp->i_mount, sfp, sfep) ==
+                        ASSERT(dp->d_ops->sf_get_ino(sfp, sfep) ==
                                args->inumber);
                         break;
                 }
@@ -934,7 +847,7 @@ xfs_dir2_sf_removename(
          * Calculate sizes.
          */
         byteoff = (int)((char *)sfep - (char *)sfp);
-        entsize = xfs_dir3_sf_entsize(dp->i_mount, sfp, args->namelen);
+        entsize = dp->d_ops->sf_entsize(sfp, args->namelen);
         newsize = oldsize - entsize;
         /*
          * Copy the part if any after the removed entry, sliding it down.
@@ -1041,28 +954,25 @@ xfs_dir2_sf_replace(
         if (args->namelen == 2 &&
             args->name[0] == '.' && args->name[1] == '.') {
 #if XFS_BIG_INUMS || defined(DEBUG)
-                ino = xfs_dir2_sf_get_parent_ino(sfp);
+                ino = dp->d_ops->sf_get_parent_ino(sfp);
                 ASSERT(args->inumber != ino);
 #endif
-                xfs_dir2_sf_put_parent_ino(sfp, args->inumber);
+                dp->d_ops->sf_put_parent_ino(sfp, args->inumber);
         }
         /*
          * Normal entry, look for the name.
          */
         else {
                 for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp); i < sfp->count;
-                     i++, sfep = xfs_dir3_sf_nextentry(dp->i_mount, sfp, sfep)) {
+                     i++, sfep = dp->d_ops->sf_nextentry(sfp, sfep)) {
                         if (xfs_da_compname(args, sfep->name, sfep->namelen) ==
                                                                 XFS_CMP_EXACT) {
 #if XFS_BIG_INUMS || defined(DEBUG)
-                                ino = xfs_dir3_sfe_get_ino(dp->i_mount,
-                                                           sfp, sfep);
+                                ino = dp->d_ops->sf_get_ino(sfp, sfep);
                                 ASSERT(args->inumber != ino);
 #endif
-                                xfs_dir3_sfe_put_ino(dp->i_mount, sfp, sfep,
-                                                     args->inumber);
-                                xfs_dir3_sfe_put_ftype(dp->i_mount, sfp, sfep,
-                                                       args->filetype);
+                                dp->d_ops->sf_put_ino(sfp, sfep, args->inumber);
+                                dp->d_ops->sf_put_ftype(sfep, args->filetype);
                                 break;
                         }
                 }
@@ -1165,22 +1075,21 @@ xfs_dir2_sf_toino4(
          */
         sfp->count = oldsfp->count;
         sfp->i8count = 0;
-        xfs_dir2_sf_put_parent_ino(sfp, xfs_dir2_sf_get_parent_ino(oldsfp));
+        dp->d_ops->sf_put_parent_ino(sfp, dp->d_ops->sf_get_parent_ino(oldsfp));
         /*
          * Copy the entries field by field.
          */
         for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp),
                     oldsfep = xfs_dir2_sf_firstentry(oldsfp);
              i < sfp->count;
-             i++, sfep = xfs_dir3_sf_nextentry(mp, sfp, sfep),
-                  oldsfep = xfs_dir3_sf_nextentry(mp, oldsfp, oldsfep)) {
+             i++, sfep = dp->d_ops->sf_nextentry(sfp, sfep),
+                  oldsfep = dp->d_ops->sf_nextentry(oldsfp, oldsfep)) {
                 sfep->namelen = oldsfep->namelen;
                 sfep->offset = oldsfep->offset;
                 memcpy(sfep->name, oldsfep->name, sfep->namelen);
-                xfs_dir3_sfe_put_ino(mp, sfp, sfep,
-                        xfs_dir3_sfe_get_ino(mp, oldsfp, oldsfep));
-                xfs_dir3_sfe_put_ftype(mp, sfp, sfep,
-                        xfs_dir3_sfe_get_ftype(mp, oldsfp, oldsfep));
+                dp->d_ops->sf_put_ino(sfp, sfep,
+                                      dp->d_ops->sf_get_ino(oldsfp, oldsfep));
+                dp->d_ops->sf_put_ftype(sfep, dp->d_ops->sf_get_ftype(oldsfep));
         }
         /*
          * Clean up the inode.
@@ -1244,22 +1153,21 @@ xfs_dir2_sf_toino8(
          */
         sfp->count = oldsfp->count;
         sfp->i8count = 1;
-        xfs_dir2_sf_put_parent_ino(sfp, xfs_dir2_sf_get_parent_ino(oldsfp));
+        dp->d_ops->sf_put_parent_ino(sfp, dp->d_ops->sf_get_parent_ino(oldsfp));
         /*
          * Copy the entries field by field.
          */
         for (i = 0, sfep = xfs_dir2_sf_firstentry(sfp),
                     oldsfep = xfs_dir2_sf_firstentry(oldsfp);
              i < sfp->count;
-             i++, sfep = xfs_dir3_sf_nextentry(mp, sfp, sfep),
-                  oldsfep = xfs_dir3_sf_nextentry(mp, oldsfp, oldsfep)) {
+             i++, sfep = dp->d_ops->sf_nextentry(sfp, sfep),
+                  oldsfep = dp->d_ops->sf_nextentry(oldsfp, oldsfep)) {
                 sfep->namelen = oldsfep->namelen;
                 sfep->offset = oldsfep->offset;
                 memcpy(sfep->name, oldsfep->name, sfep->namelen);
-                xfs_dir3_sfe_put_ino(mp, sfp, sfep,
-                        xfs_dir3_sfe_get_ino(mp, oldsfp, oldsfep));
-                xfs_dir3_sfe_put_ftype(mp, sfp, sfep,
-                        xfs_dir3_sfe_get_ftype(mp, oldsfp, oldsfep));
+                dp->d_ops->sf_put_ino(sfp, sfep,
+                                      dp->d_ops->sf_get_ino(oldsfp, oldsfep));
+                dp->d_ops->sf_put_ftype(sfep, dp->d_ops->sf_get_ftype(oldsfep));
         }
         /*
          * Clean up the inode.
diff --git a/fs/xfs/xfs_discard.c b/fs/xfs/xfs_discard.c
index 45560ee1a4ba..8367d6dc18c9 100644
--- a/fs/xfs/xfs_discard.c
+++ b/fs/xfs/xfs_discard.c
@@ -17,22 +17,21 @@
  */
 #include "xfs.h"
 #include "xfs_format.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
 #include "xfs_quota.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
 #include "xfs_inode.h"
+#include "xfs_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_alloc.h"
 #include "xfs_error.h"
 #include "xfs_extent_busy.h"
 #include "xfs_discard.h"
 #include "xfs_trace.h"
+#include "xfs_log.h"
 
 STATIC int
 xfs_trim_extents(
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 71520e6e5d65..6b1e695caf0e 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -18,28 +18,28 @@
 #include "xfs.h"
 #include "xfs_fs.h"
 #include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_shared.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_alloc.h"
-#include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
 #include "xfs_inode.h"
 #include "xfs_bmap.h"
 #include "xfs_bmap_util.h"
-#include "xfs_rtalloc.h"
+#include "xfs_alloc.h"
+#include "xfs_quota.h"
 #include "xfs_error.h"
-#include "xfs_itable.h"
-#include "xfs_attr.h"
+#include "xfs_trans.h"
 #include "xfs_buf_item.h"
 #include "xfs_trans_space.h"
 #include "xfs_trans_priv.h"
 #include "xfs_qm.h"
 #include "xfs_cksum.h"
 #include "xfs_trace.h"
+#include "xfs_log.h"
+#include "xfs_bmap_btree.h"
 
 /*
  * Lock order:
@@ -64,7 +64,8 @@ int xfs_dqerror_mod = 33;
 struct kmem_zone                *xfs_qm_dqtrxzone;
 static struct kmem_zone         *xfs_qm_dqzone;
 
-static struct lock_class_key xfs_dquot_other_class;
+static struct lock_class_key xfs_dquot_group_class;
+static struct lock_class_key xfs_dquot_project_class;
 
 /*
  * This is called to free all the memory associated with a dquot
@@ -291,118 +292,6 @@ xfs_dquot_set_prealloc_limits(struct xfs_dquot *dqp)
         dqp->q_low_space[XFS_QLOWSP_5_PCNT] = space * 5;
 }
 
-STATIC bool
-xfs_dquot_buf_verify_crc(
-        struct xfs_mount        *mp,
-        struct xfs_buf          *bp)
-{
-        struct xfs_dqblk        *d = (struct xfs_dqblk *)bp->b_addr;
-        int                     ndquots;
-        int                     i;
-
-        if (!xfs_sb_version_hascrc(&mp->m_sb))
-                return true;
-
-        /*
-         * if we are in log recovery, the quota subsystem has not been
-         * initialised so we have no quotainfo structure. In that case, we need
-         * to manually calculate the number of dquots in the buffer.
-         */
-        if (mp->m_quotainfo)
-                ndquots = mp->m_quotainfo->qi_dqperchunk;
-        else
-                ndquots = xfs_qm_calc_dquots_per_chunk(mp,
-                                        XFS_BB_TO_FSB(mp, bp->b_length));
-
-        for (i = 0; i < ndquots; i++, d++) {
-                if (!xfs_verify_cksum((char *)d, sizeof(struct xfs_dqblk),
-                                 XFS_DQUOT_CRC_OFF))
-                        return false;
-                if (!uuid_equal(&d->dd_uuid, &mp->m_sb.sb_uuid))
-                        return false;
-        }
-        return true;
-}
-
-STATIC bool
-xfs_dquot_buf_verify(
-        struct xfs_mount        *mp,
-        struct xfs_buf          *bp)
-{
-        struct xfs_dqblk        *d = (struct xfs_dqblk *)bp->b_addr;
-        xfs_dqid_t              id = 0;
-        int                     ndquots;
-        int                     i;
-
-        /*
-         * if we are in log recovery, the quota subsystem has not been
-         * initialised so we have no quotainfo structure. In that case, we need
-         * to manually calculate the number of dquots in the buffer.
-         */
-        if (mp->m_quotainfo)
-                ndquots = mp->m_quotainfo->qi_dqperchunk;
-        else
-                ndquots = xfs_qm_calc_dquots_per_chunk(mp, bp->b_length);
-
-        /*
-         * On the first read of the buffer, verify that each dquot is valid.
-         * We don't know what the id of the dquot is supposed to be, just that
-         * they should be increasing monotonically within the buffer. If the
-         * first id is corrupt, then it will fail on the second dquot in the
-         * buffer so corruptions could point to the wrong dquot in this case.
-         */
-        for (i = 0; i < ndquots; i++) {
-                struct xfs_disk_dquot   *ddq;
-                int                     error;
-
-                ddq = &d[i].dd_diskdq;
-
-                if (i == 0)
-                        id = be32_to_cpu(ddq->d_id);
-
-                error = xfs_qm_dqcheck(mp, ddq, id + i, 0, XFS_QMOPT_DOWARN,
-                                       "xfs_dquot_buf_verify");
-                if (error)
-                        return false;
-        }
-        return true;
-}
-
-static void
-xfs_dquot_buf_read_verify(
-        struct xfs_buf  *bp)
-{
-        struct xfs_mount        *mp = bp->b_target->bt_mount;
-
-        if (!xfs_dquot_buf_verify_crc(mp, bp) || !xfs_dquot_buf_verify(mp, bp)) {
-                XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
-        }
-}
-
-/*
- * we don't calculate the CRC here as that is done when the dquot is flushed to
- * the buffer after the update is done. This ensures that the dquot in the
- * buffer always has an up-to-date CRC value.
- */
-void
-xfs_dquot_buf_write_verify(
-        struct xfs_buf  *bp)
-{
-        struct xfs_mount        *mp = bp->b_target->bt_mount;
-
-        if (!xfs_dquot_buf_verify(mp, bp)) {
-                XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
-                xfs_buf_ioerror(bp, EFSCORRUPTED);
-                return;
-        }
-}
-
-const struct xfs_buf_ops xfs_dquot_buf_ops = {
-        .verify_read = xfs_dquot_buf_read_verify,
-        .verify_write = xfs_dquot_buf_write_verify,
-};
-
 /*
  * Allocate a block and fill it with dquots.
  * This is called when the bmapi finds a hole.
@@ -513,6 +402,7 @@ xfs_qm_dqalloc(
 
         return (error);
 }
+
 STATIC int
 xfs_qm_dqrepair(
         struct xfs_mount        *mp,
@@ -546,7 +436,7 @@ xfs_qm_dqrepair(
         /* Do the actual repair of dquots in this buffer */
         for (i = 0; i < mp->m_quotainfo->qi_dqperchunk; i++) {
                 ddq = &d[i].dd_diskdq;
-                error = xfs_qm_dqcheck(mp, ddq, firstid + i,
+                error = xfs_dqcheck(mp, ddq, firstid + i,
                                        dqp->dq_flags & XFS_DQ_ALLTYPES,
                                        XFS_QMOPT_DQREPAIR, "xfs_qm_dqrepair");
                 if (error) {
@@ -703,8 +593,20 @@ xfs_qm_dqread(
          * Make sure group quotas have a different lock class than user
          * quotas.
          */
-        if (!(type & XFS_DQ_USER))
-                lockdep_set_class(&dqp->q_qlock, &xfs_dquot_other_class);
+        switch (type) {
+        case XFS_DQ_USER:
+                /* uses the default lock class */
+                break;
+        case XFS_DQ_GROUP:
+                lockdep_set_class(&dqp->q_qlock, &xfs_dquot_group_class);
+                break;
+        case XFS_DQ_PROJ:
+                lockdep_set_class(&dqp->q_qlock, &xfs_dquot_project_class);
+                break;
+        default:
+                ASSERT(0);
+                break;
+        }
 
         XFS_STATS_INC(xs_qm_dquot);
 
@@ -1120,7 +1022,7 @@ xfs_qm_dqflush(
         /*
          * A simple sanity check in case we got a corrupted dquot..
          */
-        error = xfs_qm_dqcheck(mp, &dqp->q_core, be32_to_cpu(ddqp->d_id), 0,
+        error = xfs_dqcheck(mp, &dqp->q_core, be32_to_cpu(ddqp->d_id), 0,
                            XFS_QMOPT_DOWARN, "dqflush (incore copy)");
         if (error) {
                 xfs_buf_relse(bp);
diff --git a/fs/xfs/xfs_dquot.h b/fs/xfs/xfs_dquot.h
index 55abbca2883d..d22ed0053c32 100644
--- a/fs/xfs/xfs_dquot.h
+++ b/fs/xfs/xfs_dquot.h
@@ -172,6 +172,4 @@ static inline struct xfs_dquot *xfs_qm_dqhold(struct xfs_dquot *dqp)
         return dqp;
 }
 
-extern const struct xfs_buf_ops xfs_dquot_buf_ops;
-
 #endif /* __XFS_DQUOT_H__ */
diff --git a/fs/xfs/xfs_dquot_buf.c b/fs/xfs/xfs_dquot_buf.c
new file mode 100644
index 000000000000..d401457d2f25
--- /dev/null
+++ b/fs/xfs/xfs_dquot_buf.c
@@ -0,0 +1,288 @@
+/*
+ * Copyright (c) 2000-2006 Silicon Graphics, Inc.
+ * Copyright (c) 2013 Red Hat, 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_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
+#include "xfs_sb.h"
+#include "xfs_ag.h"
+#include "xfs_mount.h"
+#include "xfs_inode.h"
+#include "xfs_quota.h"
+#include "xfs_trans.h"
+#include "xfs_qm.h"
+#include "xfs_error.h"
+#include "xfs_cksum.h"
+#include "xfs_trace.h"
+
+int
+xfs_calc_dquots_per_chunk(
+        struct xfs_mount        *mp,
+        unsigned int            nbblks) /* basic block units */
+{
+        unsigned int    ndquots;
+
+        ASSERT(nbblks > 0);
+        ndquots = BBTOB(nbblks);
+        do_div(ndquots, sizeof(xfs_dqblk_t));
+
+        return ndquots;
+}
+
+/*
+ * Do some primitive error checking on ondisk dquot data structures.
+ */
+int
+xfs_dqcheck(
+        struct xfs_mount *mp,
+        xfs_disk_dquot_t *ddq,
+        xfs_dqid_t       id,
+        uint             type,    /* used only when IO_dorepair is true */
+        uint             flags,
+        char             *str)
+{
+        xfs_dqblk_t      *d = (xfs_dqblk_t *)ddq;
+        int             errs = 0;
+
+        /*
+         * We can encounter an uninitialized dquot buffer for 2 reasons:
+         * 1. If we crash while deleting the quotainode(s), and those blks got
+         *    used for user data. This is because we take the path of regular
+         *    file deletion; however, the size field of quotainodes is never
+         *    updated, so all the tricks that we play in itruncate_finish
+         *    don't quite matter.
+         *
+         * 2. We don't play the quota buffers when there's a quotaoff logitem.
+         *    But the allocation will be replayed so we'll end up with an
+         *    uninitialized quota block.
+         *
+         * This is all fine; things are still consistent, and we haven't lost
+         * any quota information. Just don't complain about bad dquot blks.
+         */
+        if (ddq->d_magic != cpu_to_be16(XFS_DQUOT_MAGIC)) {
+                if (flags & XFS_QMOPT_DOWARN)
+                        xfs_alert(mp,
+                        "%s : XFS dquot ID 0x%x, magic 0x%x != 0x%x",
+                        str, id, be16_to_cpu(ddq->d_magic), XFS_DQUOT_MAGIC);
+                errs++;
+        }
+        if (ddq->d_version != XFS_DQUOT_VERSION) {
+                if (flags & XFS_QMOPT_DOWARN)
+                        xfs_alert(mp,
+                        "%s : XFS dquot ID 0x%x, version 0x%x != 0x%x",
+                        str, id, ddq->d_version, XFS_DQUOT_VERSION);
+                errs++;
+        }
+
+        if (ddq->d_flags != XFS_DQ_USER &&
+            ddq->d_flags != XFS_DQ_PROJ &&
+            ddq->d_flags != XFS_DQ_GROUP) {
+                if (flags & XFS_QMOPT_DOWARN)
+                        xfs_alert(mp,
+                        "%s : XFS dquot ID 0x%x, unknown flags 0x%x",
+                        str, id, ddq->d_flags);
+                errs++;
+        }
+
+        if (id != -1 && id != be32_to_cpu(ddq->d_id)) {
+                if (flags & XFS_QMOPT_DOWARN)
+                        xfs_alert(mp,
+                        "%s : ondisk-dquot 0x%p, ID mismatch: "
+                        "0x%x expected, found id 0x%x",
+                        str, ddq, id, be32_to_cpu(ddq->d_id));
+                errs++;
+        }
+
+        if (!errs && ddq->d_id) {
+                if (ddq->d_blk_softlimit &&
+                    be64_to_cpu(ddq->d_bcount) >
+                                be64_to_cpu(ddq->d_blk_softlimit)) {
+                        if (!ddq->d_btimer) {
+                                if (flags & XFS_QMOPT_DOWARN)
+                                        xfs_alert(mp,
+                        "%s : Dquot ID 0x%x (0x%p) BLK TIMER NOT STARTED",
+                                        str, (int)be32_to_cpu(ddq->d_id), ddq);
+                                errs++;
+                        }
+                }
+                if (ddq->d_ino_softlimit &&
+                    be64_to_cpu(ddq->d_icount) >
+                                be64_to_cpu(ddq->d_ino_softlimit)) {
+                        if (!ddq->d_itimer) {
+                                if (flags & XFS_QMOPT_DOWARN)
+                                        xfs_alert(mp,
+                        "%s : Dquot ID 0x%x (0x%p) INODE TIMER NOT STARTED",
+                                        str, (int)be32_to_cpu(ddq->d_id), ddq);
+                                errs++;
+                        }
+                }
+                if (ddq->d_rtb_softlimit &&
+                    be64_to_cpu(ddq->d_rtbcount) >
+                                be64_to_cpu(ddq->d_rtb_softlimit)) {
+                        if (!ddq->d_rtbtimer) {
+                                if (flags & XFS_QMOPT_DOWARN)
+                                        xfs_alert(mp,
+                        "%s : Dquot ID 0x%x (0x%p) RTBLK TIMER NOT STARTED",
+                                        str, (int)be32_to_cpu(ddq->d_id), ddq);
+                                errs++;
+                        }
+                }
+        }
+
+        if (!errs || !(flags & XFS_QMOPT_DQREPAIR))
+                return errs;
+
+        if (flags & XFS_QMOPT_DOWARN)
+                xfs_notice(mp, "Re-initializing dquot ID 0x%x", id);
+
+        /*
+         * Typically, a repair is only requested by quotacheck.
+         */
+        ASSERT(id != -1);
+        ASSERT(flags & XFS_QMOPT_DQREPAIR);
+        memset(d, 0, sizeof(xfs_dqblk_t));
+
+        d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
+        d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
+        d->dd_diskdq.d_flags = type;
+        d->dd_diskdq.d_id = cpu_to_be32(id);
+
+        if (xfs_sb_version_hascrc(&mp->m_sb)) {
+                uuid_copy(&d->dd_uuid, &mp->m_sb.sb_uuid);
+                xfs_update_cksum((char *)d, sizeof(struct xfs_dqblk),
+                                 XFS_DQUOT_CRC_OFF);
+        }
+
+        return errs;
+}
+
+STATIC bool
+xfs_dquot_buf_verify_crc(
+        struct xfs_mount        *mp,
+        struct xfs_buf          *bp)
+{
+        struct xfs_dqblk        *d = (struct xfs_dqblk *)bp->b_addr;
+        int                     ndquots;
+        int                     i;
+
+        if (!xfs_sb_version_hascrc(&mp->m_sb))
+                return true;
+
+        /*
+         * if we are in log recovery, the quota subsystem has not been
+         * initialised so we have no quotainfo structure. In that case, we need
+         * to manually calculate the number of dquots in the buffer.
+         */
+        if (mp->m_quotainfo)
+                ndquots = mp->m_quotainfo->qi_dqperchunk;
+        else
+                ndquots = xfs_calc_dquots_per_chunk(mp,
+                                        XFS_BB_TO_FSB(mp, bp->b_length));
+
+        for (i = 0; i < ndquots; i++, d++) {
+                if (!xfs_verify_cksum((char *)d, sizeof(struct xfs_dqblk),
+                                 XFS_DQUOT_CRC_OFF))
+                        return false;
+                if (!uuid_equal(&d->dd_uuid, &mp->m_sb.sb_uuid))
+                        return false;
+        }
+        return true;
+}
+
+STATIC bool
+xfs_dquot_buf_verify(
+        struct xfs_mount        *mp,
+        struct xfs_buf          *bp)
+{
+        struct xfs_dqblk        *d = (struct xfs_dqblk *)bp->b_addr;
+        xfs_dqid_t              id = 0;
+        int                     ndquots;
+        int                     i;
+
+        /*
+         * if we are in log recovery, the quota subsystem has not been
+         * initialised so we have no quotainfo structure. In that case, we need
+         * to manually calculate the number of dquots in the buffer.
+         */
+        if (mp->m_quotainfo)
+                ndquots = mp->m_quotainfo->qi_dqperchunk;
+        else
+                ndquots = xfs_calc_dquots_per_chunk(mp, bp->b_length);
+
+        /*
+         * On the first read of the buffer, verify that each dquot is valid.
+         * We don't know what the id of the dquot is supposed to be, just that
+         * they should be increasing monotonically within the buffer. If the
+         * first id is corrupt, then it will fail on the second dquot in the
+         * buffer so corruptions could point to the wrong dquot in this case.
+         */
+        for (i = 0; i < ndquots; i++) {
+                struct xfs_disk_dquot   *ddq;
+                int                     error;
+
+                ddq = &d[i].dd_diskdq;
+
+                if (i == 0)
+                        id = be32_to_cpu(ddq->d_id);
+
+                error = xfs_dqcheck(mp, ddq, id + i, 0, XFS_QMOPT_DOWARN,
+                                       "xfs_dquot_buf_verify");
+                if (error)
+                        return false;
+        }
+        return true;
+}
+
+static void
+xfs_dquot_buf_read_verify(
+        struct xfs_buf  *bp)
+{
+        struct xfs_mount        *mp = bp->b_target->bt_mount;
+
+        if (!xfs_dquot_buf_verify_crc(mp, bp) || !xfs_dquot_buf_verify(mp, bp)) {
+                XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
+                xfs_buf_ioerror(bp, EFSCORRUPTED);
+        }
+}
+
+/*
+ * we don't calculate the CRC here as that is done when the dquot is flushed to
+ * the buffer after the update is done. This ensures that the dquot in the
+ * buffer always has an up-to-date CRC value.
+ */
+static void
+xfs_dquot_buf_write_verify(
+        struct xfs_buf  *bp)
+{
+        struct xfs_mount        *mp = bp->b_target->bt_mount;
+
+        if (!xfs_dquot_buf_verify(mp, bp)) {
+                XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, bp->b_addr);
+                xfs_buf_ioerror(bp, EFSCORRUPTED);
+                return;
+        }
+}
+
+const struct xfs_buf_ops xfs_dquot_buf_ops = {
+        .verify_read = xfs_dquot_buf_read_verify,
+        .verify_write = xfs_dquot_buf_write_verify,
+};
+
diff --git a/fs/xfs/xfs_dquot_item.c b/fs/xfs/xfs_dquot_item.c
index e838d84b4e85..92e5f62eefc6 100644
--- a/fs/xfs/xfs_dquot_item.c
+++ b/fs/xfs/xfs_dquot_item.c
@@ -18,23 +18,19 @@
 #include "xfs.h"
 #include "xfs_fs.h"
 #include "xfs_format.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_alloc.h"
-#include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
 #include "xfs_inode.h"
-#include "xfs_bmap.h"
-#include "xfs_rtalloc.h"
+#include "xfs_quota.h"
 #include "xfs_error.h"
-#include "xfs_itable.h"
-#include "xfs_attr.h"
+#include "xfs_trans.h"
 #include "xfs_buf_item.h"
 #include "xfs_trans_priv.h"
 #include "xfs_qm.h"
+#include "xfs_log.h"
 
 static inline struct xfs_dq_logitem *DQUOT_ITEM(struct xfs_log_item *lip)
 {
diff --git a/fs/xfs/xfs_error.c b/fs/xfs/xfs_error.c
index 1123d93ff795..9995b807d627 100644
--- a/fs/xfs/xfs_error.c
+++ b/fs/xfs/xfs_error.c
@@ -16,16 +16,13 @@
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "xfs.h"
+#include "xfs_format.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_dinode.h"
-#include "xfs_inode.h"
 #include "xfs_error.h"
 
 #ifdef DEBUG
@@ -159,7 +156,7 @@ xfs_error_report(
 {
         if (level <= xfs_error_level) {
                 xfs_alert_tag(mp, XFS_PTAG_ERROR_REPORT,
-                "Internal error %s at line %d of file %s.  Caller 0x%p\n",
+                "Internal error %s at line %d of file %s.  Caller 0x%p",
                             tag, linenum, filename, ra);
 
                 xfs_stack_trace();
diff --git a/fs/xfs/xfs_export.c b/fs/xfs/xfs_export.c
index 066df425c14f..1399e187d425 100644
--- a/fs/xfs/xfs_export.c
+++ b/fs/xfs/xfs_export.c
@@ -16,21 +16,21 @@
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "xfs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_da_btree.h"
-#include "xfs_dir2_format.h"
+#include "xfs_da_format.h"
 #include "xfs_dir2.h"
 #include "xfs_export.h"
-#include "xfs_bmap_btree.h"
 #include "xfs_inode.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
 #include "xfs_trace.h"
 #include "xfs_icache.h"
+#include "xfs_log.h"
 
 /*
  * Note that we only accept fileids which are long enough rather than allow
diff --git a/fs/xfs/xfs_extent_busy.c b/fs/xfs/xfs_extent_busy.c
index e43708e2f080..fd22f69049d4 100644
--- a/fs/xfs/xfs_extent_busy.c
+++ b/fs/xfs/xfs_extent_busy.c
@@ -19,17 +19,18 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_shared.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
 #include "xfs_alloc.h"
-#include "xfs_inode.h"
 #include "xfs_extent_busy.h"
 #include "xfs_trace.h"
+#include "xfs_trans.h"
+#include "xfs_log.h"
 
 void
 xfs_extent_busy_insert(
diff --git a/fs/xfs/xfs_extent_busy.h b/fs/xfs/xfs_extent_busy.h
index 985412d65ba5..bfff284d2dcc 100644
--- a/fs/xfs/xfs_extent_busy.h
+++ b/fs/xfs/xfs_extent_busy.h
@@ -20,6 +20,10 @@
 #ifndef __XFS_EXTENT_BUSY_H__
 #define __XFS_EXTENT_BUSY_H__
 
+struct xfs_mount;
+struct xfs_trans;
+struct xfs_alloc_arg;
+
 /*
  * Busy block/extent entry.  Indexed by a rbtree in perag to mark blocks that
  * have been freed but whose transactions aren't committed to disk yet.
diff --git a/fs/xfs/xfs_extfree_item.c b/fs/xfs/xfs_extfree_item.c
index dc53e8febbbe..3680d04f973f 100644
--- a/fs/xfs/xfs_extfree_item.c
+++ b/fs/xfs/xfs_extfree_item.c
@@ -17,14 +17,14 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
-#include "xfs_buf_item.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_trans.h"
 #include "xfs_trans_priv.h"
+#include "xfs_buf_item.h"
 #include "xfs_extfree_item.h"
 
 
diff --git a/fs/xfs/xfs_file.c b/fs/xfs/xfs_file.c
index 4c749ab543d0..52c91e143725 100644
--- a/fs/xfs/xfs_file.c
+++ b/fs/xfs/xfs_file.c
@@ -17,25 +17,27 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_log.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_trans.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc.h"
-#include "xfs_dinode.h"
+#include "xfs_da_format.h"
+#include "xfs_da_btree.h"
 #include "xfs_inode.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
 #include "xfs_bmap.h"
 #include "xfs_bmap_util.h"
 #include "xfs_error.h"
-#include "xfs_da_btree.h"
-#include "xfs_dir2_format.h"
 #include "xfs_dir2.h"
 #include "xfs_dir2_priv.h"
 #include "xfs_ioctl.h"
 #include "xfs_trace.h"
+#include "xfs_log.h"
+#include "xfs_dinode.h"
 
 #include <linux/aio.h>
 #include <linux/dcache.h>
@@ -805,44 +807,64 @@ out:
 
 STATIC long
 xfs_file_fallocate(
-        struct file     *file,
-        int             mode,
-        loff_t          offset,
-        loff_t          len)
+        struct file             *file,
+        int                     mode,
+        loff_t                  offset,
+        loff_t                  len)
 {
-        struct inode    *inode = file_inode(file);
-        long            error;
-        loff_t          new_size = 0;
-        xfs_flock64_t   bf;
-        xfs_inode_t     *ip = XFS_I(inode);
-        int             cmd = XFS_IOC_RESVSP;
-        int             attr_flags = XFS_ATTR_NOLOCK;
+        struct inode            *inode = file_inode(file);
+        struct xfs_inode        *ip = XFS_I(inode);
+        struct xfs_trans        *tp;
+        long                    error;
+        loff_t                  new_size = 0;
 
+        if (!S_ISREG(inode->i_mode))
+                return -EINVAL;
         if (mode & ~(FALLOC_FL_KEEP_SIZE | FALLOC_FL_PUNCH_HOLE))
                 return -EOPNOTSUPP;
 
-        bf.l_whence = 0;
-        bf.l_start = offset;
-        bf.l_len = len;
-
         xfs_ilock(ip, XFS_IOLOCK_EXCL);
+        if (mode & FALLOC_FL_PUNCH_HOLE) {
+                error = xfs_free_file_space(ip, offset, len);
+                if (error)
+                        goto out_unlock;
+        } else {
+                if (!(mode & FALLOC_FL_KEEP_SIZE) &&
+                    offset + len > i_size_read(inode)) {
+                        new_size = offset + len;
+                        error = -inode_newsize_ok(inode, new_size);
+                        if (error)
+                                goto out_unlock;
+                }
 
-        if (mode & FALLOC_FL_PUNCH_HOLE)
-                cmd = XFS_IOC_UNRESVSP;
-
-        /* check the new inode size is valid before allocating */
-        if (!(mode & FALLOC_FL_KEEP_SIZE) &&
-            offset + len > i_size_read(inode)) {
-                new_size = offset + len;
-                error = inode_newsize_ok(inode, new_size);
+                error = xfs_alloc_file_space(ip, offset, len,
+                                             XFS_BMAPI_PREALLOC);
                 if (error)
                         goto out_unlock;
         }
 
-        if (file->f_flags & O_DSYNC)
-                attr_flags |= XFS_ATTR_SYNC;
+        tp = xfs_trans_alloc(ip->i_mount, XFS_TRANS_WRITEID);
+        error = xfs_trans_reserve(tp, &M_RES(ip->i_mount)->tr_writeid, 0, 0);
+        if (error) {
+                xfs_trans_cancel(tp, 0);
+                goto out_unlock;
+        }
+
+        xfs_ilock(ip, XFS_ILOCK_EXCL);
+        xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
+        ip->i_d.di_mode &= ~S_ISUID;
+        if (ip->i_d.di_mode & S_IXGRP)
+                ip->i_d.di_mode &= ~S_ISGID;
+
+        if (!(mode & FALLOC_FL_PUNCH_HOLE))
+                ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
 
-        error = -xfs_change_file_space(ip, cmd, &bf, 0, attr_flags);
+        xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
+        xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
+
+        if (file->f_flags & O_DSYNC)
+                xfs_trans_set_sync(tp);
+        error = xfs_trans_commit(tp, 0);
         if (error)
                 goto out_unlock;
 
@@ -852,12 +874,12 @@ xfs_file_fallocate(
 
                 iattr.ia_valid = ATTR_SIZE;
                 iattr.ia_size = new_size;
-                error = -xfs_setattr_size(ip, &iattr, XFS_ATTR_NOLOCK);
+                error = xfs_setattr_size(ip, &iattr);
         }
 
 out_unlock:
         xfs_iunlock(ip, XFS_IOLOCK_EXCL);
-        return error;
+        return -error;
 }
 
 
diff --git a/fs/xfs/xfs_filestream.c b/fs/xfs/xfs_filestream.c
index ce78e654d37b..12b6e7701985 100644
--- a/fs/xfs/xfs_filestream.c
+++ b/fs/xfs/xfs_filestream.c
@@ -16,19 +16,19 @@
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "xfs.h"
-#include "xfs_log.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_inum.h"
-#include "xfs_dinode.h"
-#include "xfs_inode.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_ag.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_mount.h"
+#include "xfs_inum.h"
+#include "xfs_inode.h"
 #include "xfs_bmap.h"
 #include "xfs_bmap_util.h"
 #include "xfs_alloc.h"
 #include "xfs_mru_cache.h"
+#include "xfs_dinode.h"
 #include "xfs_filestream.h"
 #include "xfs_trace.h"
 
diff --git a/fs/xfs/xfs_format.h b/fs/xfs/xfs_format.h
index 35c08ff54ca0..b6ab5a3cfa12 100644
--- a/fs/xfs/xfs_format.h
+++ b/fs/xfs/xfs_format.h
@@ -156,14 +156,259 @@ struct xfs_dsymlink_hdr {
         ((bufsize) - (xfs_sb_version_hascrc(&(mp)->m_sb) ? \
                         sizeof(struct xfs_dsymlink_hdr) : 0))
 
-int xfs_symlink_blocks(struct xfs_mount *mp, int pathlen);
-int xfs_symlink_hdr_set(struct xfs_mount *mp, xfs_ino_t ino, uint32_t offset,
-                        uint32_t size, struct xfs_buf *bp);
-bool xfs_symlink_hdr_ok(struct xfs_mount *mp, xfs_ino_t ino, uint32_t offset,
-                        uint32_t size, struct xfs_buf *bp);
-void xfs_symlink_local_to_remote(struct xfs_trans *tp, struct xfs_buf *bp,
-                                 struct xfs_inode *ip, struct xfs_ifork *ifp);
-
-extern const struct xfs_buf_ops xfs_symlink_buf_ops;
+
+/*
+ * Allocation Btree format definitions
+ *
+ * There are two on-disk btrees, one sorted by blockno and one sorted
+ * by blockcount and blockno.  All blocks look the same to make the code
+ * simpler; if we have time later, we'll make the optimizations.
+ */
+#define XFS_ABTB_MAGIC          0x41425442      /* 'ABTB' for bno tree */
+#define XFS_ABTB_CRC_MAGIC      0x41423342      /* 'AB3B' */
+#define XFS_ABTC_MAGIC          0x41425443      /* 'ABTC' for cnt tree */
+#define XFS_ABTC_CRC_MAGIC      0x41423343      /* 'AB3C' */
+
+/*
+ * Data record/key structure
+ */
+typedef struct xfs_alloc_rec {
+        __be32          ar_startblock;  /* starting block number */
+        __be32          ar_blockcount;  /* count of free blocks */
+} xfs_alloc_rec_t, xfs_alloc_key_t;
+
+typedef struct xfs_alloc_rec_incore {
+        xfs_agblock_t   ar_startblock;  /* starting block number */
+        xfs_extlen_t    ar_blockcount;  /* count of free blocks */
+} xfs_alloc_rec_incore_t;
+
+/* btree pointer type */
+typedef __be32 xfs_alloc_ptr_t;
+
+/*
+ * Block numbers in the AG:
+ * SB is sector 0, AGF is sector 1, AGI is sector 2, AGFL is sector 3.
+ */
+#define XFS_BNO_BLOCK(mp)       ((xfs_agblock_t)(XFS_AGFL_BLOCK(mp) + 1))
+#define XFS_CNT_BLOCK(mp)       ((xfs_agblock_t)(XFS_BNO_BLOCK(mp) + 1))
+
+
+/*
+ * Inode Allocation Btree format definitions
+ *
+ * There is a btree for the inode map per allocation group.
+ */
+#define XFS_IBT_MAGIC           0x49414254      /* 'IABT' */
+#define XFS_IBT_CRC_MAGIC       0x49414233      /* 'IAB3' */
+
+typedef __uint64_t      xfs_inofree_t;
+#define XFS_INODES_PER_CHUNK            (NBBY * sizeof(xfs_inofree_t))
+#define XFS_INODES_PER_CHUNK_LOG        (XFS_NBBYLOG + 3)
+#define XFS_INOBT_ALL_FREE              ((xfs_inofree_t)-1)
+#define XFS_INOBT_MASK(i)               ((xfs_inofree_t)1 << (i))
+
+static inline xfs_inofree_t xfs_inobt_maskn(int i, int n)
+{
+        return ((n >= XFS_INODES_PER_CHUNK ? 0 : XFS_INOBT_MASK(n)) - 1) << i;
+}
+
+/*
+ * Data record structure
+ */
+typedef struct xfs_inobt_rec {
+        __be32          ir_startino;    /* starting inode number */
+        __be32          ir_freecount;   /* count of free inodes (set bits) */
+        __be64          ir_free;        /* free inode mask */
+} xfs_inobt_rec_t;
+
+typedef struct xfs_inobt_rec_incore {
+        xfs_agino_t     ir_startino;    /* starting inode number */
+        __int32_t       ir_freecount;   /* count of free inodes (set bits) */
+        xfs_inofree_t   ir_free;        /* free inode mask */
+} xfs_inobt_rec_incore_t;
+
+
+/*
+ * Key structure
+ */
+typedef struct xfs_inobt_key {
+        __be32          ir_startino;    /* starting inode number */
+} xfs_inobt_key_t;
+
+/* btree pointer type */
+typedef __be32 xfs_inobt_ptr_t;
+
+/*
+ * block numbers in the AG.
+ */
+#define XFS_IBT_BLOCK(mp)               ((xfs_agblock_t)(XFS_CNT_BLOCK(mp) + 1))
+#define XFS_PREALLOC_BLOCKS(mp)         ((xfs_agblock_t)(XFS_IBT_BLOCK(mp) + 1))
+
+
+
+/*
+ * BMAP Btree format definitions
+ *
+ * This includes both the root block definition that sits inside an inode fork
+ * and the record/pointer formats for the leaf/node in the blocks.
+ */
+#define XFS_BMAP_MAGIC          0x424d4150      /* 'BMAP' */
+#define XFS_BMAP_CRC_MAGIC      0x424d4133      /* 'BMA3' */
+
+/*
+ * Bmap root header, on-disk form only.
+ */
+typedef struct xfs_bmdr_block {
+        __be16          bb_level;       /* 0 is a leaf */
+        __be16          bb_numrecs;     /* current # of data records */
+} xfs_bmdr_block_t;
+
+/*
+ * Bmap btree record and extent descriptor.
+ *  l0:63 is an extent flag (value 1 indicates non-normal).
+ *  l0:9-62 are startoff.
+ *  l0:0-8 and l1:21-63 are startblock.
+ *  l1:0-20 are blockcount.
+ */
+#define BMBT_EXNTFLAG_BITLEN    1
+#define BMBT_STARTOFF_BITLEN    54
+#define BMBT_STARTBLOCK_BITLEN  52
+#define BMBT_BLOCKCOUNT_BITLEN  21
+
+typedef struct xfs_bmbt_rec {
+        __be64                  l0, l1;
+} xfs_bmbt_rec_t;
+
+typedef __uint64_t      xfs_bmbt_rec_base_t;    /* use this for casts */
+typedef xfs_bmbt_rec_t xfs_bmdr_rec_t;
+
+typedef struct xfs_bmbt_rec_host {
+        __uint64_t              l0, l1;
+} xfs_bmbt_rec_host_t;
+
+/*
+ * Values and macros for delayed-allocation startblock fields.
+ */
+#define STARTBLOCKVALBITS       17
+#define STARTBLOCKMASKBITS      (15 + XFS_BIG_BLKNOS * 20)
+#define DSTARTBLOCKMASKBITS     (15 + 20)
+#define STARTBLOCKMASK          \
+        (((((xfs_fsblock_t)1) << STARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
+#define DSTARTBLOCKMASK         \
+        (((((xfs_dfsbno_t)1) << DSTARTBLOCKMASKBITS) - 1) << STARTBLOCKVALBITS)
+
+static inline int isnullstartblock(xfs_fsblock_t x)
+{
+        return ((x) & STARTBLOCKMASK) == STARTBLOCKMASK;
+}
+
+static inline int isnulldstartblock(xfs_dfsbno_t x)
+{
+        return ((x) & DSTARTBLOCKMASK) == DSTARTBLOCKMASK;
+}
+
+static inline xfs_fsblock_t nullstartblock(int k)
+{
+        ASSERT(k < (1 << STARTBLOCKVALBITS));
+        return STARTBLOCKMASK | (k);
+}
+
+static inline xfs_filblks_t startblockval(xfs_fsblock_t x)
+{
+        return (xfs_filblks_t)((x) & ~STARTBLOCKMASK);
+}
+
+/*
+ * Possible extent formats.
+ */
+typedef enum {
+        XFS_EXTFMT_NOSTATE = 0,
+        XFS_EXTFMT_HASSTATE
+} xfs_exntfmt_t;
+
+/*
+ * Possible extent states.
+ */
+typedef enum {
+        XFS_EXT_NORM, XFS_EXT_UNWRITTEN,
+        XFS_EXT_DMAPI_OFFLINE, XFS_EXT_INVALID
+} xfs_exntst_t;
+
+/*
+ * Incore version of above.
+ */
+typedef struct xfs_bmbt_irec
+{
+        xfs_fileoff_t   br_startoff;    /* starting file offset */
+        xfs_fsblock_t   br_startblock;  /* starting block number */
+        xfs_filblks_t   br_blockcount;  /* number of blocks */
+        xfs_exntst_t    br_state;       /* extent state */
+} xfs_bmbt_irec_t;
+
+/*
+ * Key structure for non-leaf levels of the tree.
+ */
+typedef struct xfs_bmbt_key {
+        __be64          br_startoff;    /* starting file offset */
+} xfs_bmbt_key_t, xfs_bmdr_key_t;
+
+/* btree pointer type */
+typedef __be64 xfs_bmbt_ptr_t, xfs_bmdr_ptr_t;
+
+
+/*
+ * Generic Btree block format definitions
+ *
+ * This is a combination of the actual format used on disk for short and long
+ * format btrees.  The first three fields are shared by both format, but the
+ * pointers are different and should be used with care.
+ *
+ * To get the size of the actual short or long form headers please use the size
+ * macros below.  Never use sizeof(xfs_btree_block).
+ *
+ * The blkno, crc, lsn, owner and uuid fields are only available in filesystems
+ * with the crc feature bit, and all accesses to them must be conditional on
+ * that flag.
+ */
+struct xfs_btree_block {
+        __be32          bb_magic;       /* magic number for block type */
+        __be16          bb_level;       /* 0 is a leaf */
+        __be16          bb_numrecs;     /* current # of data records */
+        union {
+                struct {
+                        __be32          bb_leftsib;
+                        __be32          bb_rightsib;
+
+                        __be64          bb_blkno;
+                        __be64          bb_lsn;
+                        uuid_t          bb_uuid;
+                        __be32          bb_owner;
+                        __le32          bb_crc;
+                } s;                    /* short form pointers */
+                struct  {
+                        __be64          bb_leftsib;
+                        __be64          bb_rightsib;
+
+                        __be64          bb_blkno;
+                        __be64          bb_lsn;
+                        uuid_t          bb_uuid;
+                        __be64          bb_owner;
+                        __le32          bb_crc;
+                        __be32          bb_pad; /* padding for alignment */
+                } l;                    /* long form pointers */
+        } bb_u;                         /* rest */
+};
+
+#define XFS_BTREE_SBLOCK_LEN    16      /* size of a short form block */
+#define XFS_BTREE_LBLOCK_LEN    24      /* size of a long form block */
+
+/* sizes of CRC enabled btree blocks */
+#define XFS_BTREE_SBLOCK_CRC_LEN        (XFS_BTREE_SBLOCK_LEN + 40)
+#define XFS_BTREE_LBLOCK_CRC_LEN        (XFS_BTREE_LBLOCK_LEN + 48)
+
+#define XFS_BTREE_SBLOCK_CRC_OFF \
+        offsetof(struct xfs_btree_block, bb_u.s.bb_crc)
+#define XFS_BTREE_LBLOCK_CRC_OFF \
+        offsetof(struct xfs_btree_block, bb_u.l.bb_crc)
 
 #endif /* __XFS_FORMAT_H__ */
diff --git a/fs/xfs/xfs_fs.h b/fs/xfs/xfs_fs.h
index 1edb5cc3e5f4..c5fc116dfaa3 100644
--- a/fs/xfs/xfs_fs.h
+++ b/fs/xfs/xfs_fs.h
@@ -233,11 +233,11 @@ typedef struct xfs_fsop_resblks {
 #define XFS_FSOP_GEOM_FLAGS_LOGV2       0x0100  /* log format version 2 */
 #define XFS_FSOP_GEOM_FLAGS_SECTOR      0x0200  /* sector sizes >1BB    */
 #define XFS_FSOP_GEOM_FLAGS_ATTR2       0x0400  /* inline attributes rework */
-#define XFS_FSOP_GEOM_FLAGS_PROJID32    0x0800  /* 32-bit project IDs   */
+#define XFS_FSOP_GEOM_FLAGS_PROJID32    0x0800  /* 32-bit project IDs   */
 #define XFS_FSOP_GEOM_FLAGS_DIRV2CI     0x1000  /* ASCII only CI names  */
 #define XFS_FSOP_GEOM_FLAGS_LAZYSB      0x4000  /* lazy superblock counters */
 #define XFS_FSOP_GEOM_FLAGS_V5SB        0x8000  /* version 5 superblock */
-
+#define XFS_FSOP_GEOM_FLAGS_FTYPE       0x10000 /* inode directory types */
 
 /*
  * Minimum and maximum sizes need for growth checks.
@@ -515,7 +515,7 @@ typedef struct xfs_swapext
 /*      XFS_IOC_GETBIOSIZE ---- deprecated 47      */
 #define XFS_IOC_GETBMAPX        _IOWR('X', 56, struct getbmap)
 #define XFS_IOC_ZERO_RANGE      _IOW ('X', 57, struct xfs_flock64)
-#define XFS_IOC_FREE_EOFBLOCKS  _IOR ('X', 58, struct xfs_eofblocks)
+#define XFS_IOC_FREE_EOFBLOCKS  _IOR ('X', 58, struct xfs_fs_eofblocks)
 
 /*
  * ioctl commands that replace IRIX syssgi()'s
diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index e64ee5288b86..a6e54b3319bd 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -17,28 +17,29 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
-#include "xfs_btree.h"
 #include "xfs_error.h"
+#include "xfs_btree.h"
+#include "xfs_alloc_btree.h"
 #include "xfs_alloc.h"
 #include "xfs_ialloc.h"
 #include "xfs_fsops.h"
 #include "xfs_itable.h"
 #include "xfs_trans_space.h"
 #include "xfs_rtalloc.h"
-#include "xfs_filestream.h"
 #include "xfs_trace.h"
+#include "xfs_log.h"
+#include "xfs_dinode.h"
+#include "xfs_filestream.h"
 
 /*
  * File system operations
@@ -101,7 +102,9 @@ xfs_fs_geometry(
                         (xfs_sb_version_hasprojid32bit(&mp->m_sb) ?
                                 XFS_FSOP_GEOM_FLAGS_PROJID32 : 0) |
                         (xfs_sb_version_hascrc(&mp->m_sb) ?
-                                XFS_FSOP_GEOM_FLAGS_V5SB : 0);
+                                XFS_FSOP_GEOM_FLAGS_V5SB : 0) |
+                        (xfs_sb_version_hasftype(&mp->m_sb) ?
+                                XFS_FSOP_GEOM_FLAGS_FTYPE : 0);
                 geo->logsectsize = xfs_sb_version_hassector(&mp->m_sb) ?
                                 mp->m_sb.sb_logsectsize : BBSIZE;
                 geo->rtsectsize = mp->m_sb.sb_blocksize;
@@ -153,7 +156,7 @@ xfs_growfs_data_private(
         xfs_buf_t               *bp;
         int                     bucket;
         int                     dpct;
-        int                     error;
+        int                     error, saved_error = 0;
         xfs_agnumber_t          nagcount;
         xfs_agnumber_t          nagimax = 0;
         xfs_rfsblock_t          nb, nb_mod;
@@ -496,29 +499,33 @@ xfs_growfs_data_private(
                                 error = ENOMEM;
                 }
 
+                /*
+                 * If we get an error reading or writing alternate superblocks,
+                 * continue.  xfs_repair chooses the "best" superblock based
+                 * on most matches; if we break early, we'll leave more
+                 * superblocks un-updated than updated, and xfs_repair may
+                 * pick them over the properly-updated primary.
+                 */
                 if (error) {
                         xfs_warn(mp,
                 "error %d reading secondary superblock for ag %d",
                                 error, agno);
-                        break;
+                        saved_error = error;
+                        continue;
                 }
                 xfs_sb_to_disk(XFS_BUF_TO_SBP(bp), &mp->m_sb, XFS_SB_ALL_BITS);
 
-                /*
-                 * If we get an error writing out the alternate superblocks,
-                 * just issue a warning and continue.  The real work is
-                 * already done and committed.
-                 */
                 error = xfs_bwrite(bp);
                 xfs_buf_relse(bp);
                 if (error) {
                         xfs_warn(mp,
                 "write error %d updating secondary superblock for ag %d",
                                 error, agno);
-                        break; /* no point in continuing */
+                        saved_error = error;
+                        continue;
                 }
         }
-        return error;
+        return saved_error ? saved_error : error;
 
  error0:
         xfs_trans_cancel(tp, XFS_TRANS_ABORT);
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c
index ccf2fb143962..e87719c5bebe 100644
--- a/fs/xfs/xfs_ialloc.c
+++ b/fs/xfs/xfs_ialloc.c
@@ -17,29 +17,30 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
 #include "xfs_inum.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_btree.h"
 #include "xfs_ialloc.h"
+#include "xfs_ialloc_btree.h"
 #include "xfs_alloc.h"
 #include "xfs_rtalloc.h"
 #include "xfs_error.h"
 #include "xfs_bmap.h"
 #include "xfs_cksum.h"
+#include "xfs_trans.h"
 #include "xfs_buf_item.h"
 #include "xfs_icreate_item.h"
 #include "xfs_icache.h"
+#include "xfs_dinode.h"
+#include "xfs_trace.h"
 
 
 /*
@@ -1627,8 +1628,9 @@ xfs_read_agi(
 {
         int                     error;
 
-        ASSERT(agno != NULLAGNUMBER);
+        trace_xfs_read_agi(mp, agno);
 
+        ASSERT(agno != NULLAGNUMBER);
         error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
                         XFS_AG_DADDR(mp, agno, XFS_AGI_DADDR(mp)),
                         XFS_FSS_TO_BB(mp, 1), 0, bpp, &xfs_agi_buf_ops);
@@ -1651,6 +1653,8 @@ xfs_ialloc_read_agi(
         struct xfs_perag        *pag;   /* per allocation group data */
         int                     error;
 
+        trace_xfs_ialloc_read_agi(mp, agno);
+
         error = xfs_read_agi(mp, tp, agno, bpp);
         if (error)
                 return error;
diff --git a/fs/xfs/xfs_ialloc.h b/fs/xfs/xfs_ialloc.h
index 68c07320f096..a8f76a5ff418 100644
--- a/fs/xfs/xfs_ialloc.h
+++ b/fs/xfs/xfs_ialloc.h
@@ -23,6 +23,7 @@ struct xfs_dinode;
 struct xfs_imap;
 struct xfs_mount;
 struct xfs_trans;
+struct xfs_btree_cur;
 
 /*
  * Allocation parameters for inode allocation.
@@ -42,7 +43,7 @@ struct xfs_trans;
 static inline struct xfs_dinode *
 xfs_make_iptr(struct xfs_mount *mp, struct xfs_buf *b, int o)
 {
-        return (xfs_dinode_t *)
+        return (struct xfs_dinode *)
                 (xfs_buf_offset(b, o << (mp)->m_sb.sb_inodelog));
 }
 
@@ -158,6 +159,4 @@ int xfs_ialloc_inode_init(struct xfs_mount *mp, struct xfs_trans *tp,
                           xfs_agnumber_t agno, xfs_agblock_t agbno,
                           xfs_agblock_t length, unsigned int gen);
 
-extern const struct xfs_buf_ops xfs_agi_buf_ops;
-
 #endif  /* __XFS_IALLOC_H__ */
diff --git a/fs/xfs/xfs_ialloc_btree.c b/fs/xfs/xfs_ialloc_btree.c
index 5448eb6b8c12..c8fa5bbb36de 100644
--- a/fs/xfs/xfs_ialloc_btree.c
+++ b/fs/xfs/xfs_ialloc_btree.c
@@ -17,24 +17,23 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_btree.h"
 #include "xfs_ialloc.h"
+#include "xfs_ialloc_btree.h"
 #include "xfs_alloc.h"
 #include "xfs_error.h"
 #include "xfs_trace.h"
 #include "xfs_cksum.h"
+#include "xfs_trans.h"
 
 
 STATIC int
diff --git a/fs/xfs/xfs_ialloc_btree.h b/fs/xfs/xfs_ialloc_btree.h
index 3ac36b7642e9..f38b22011c4e 100644
--- a/fs/xfs/xfs_ialloc_btree.h
+++ b/fs/xfs/xfs_ialloc_btree.h
@@ -27,55 +27,6 @@ struct xfs_btree_cur;
 struct xfs_mount;
 
 /*
- * There is a btree for the inode map per allocation group.
- */
-#define XFS_IBT_MAGIC           0x49414254      /* 'IABT' */
-#define XFS_IBT_CRC_MAGIC       0x49414233      /* 'IAB3' */
-
-typedef __uint64_t      xfs_inofree_t;
-#define XFS_INODES_PER_CHUNK            (NBBY * sizeof(xfs_inofree_t))
-#define XFS_INODES_PER_CHUNK_LOG        (XFS_NBBYLOG + 3)
-#define XFS_INOBT_ALL_FREE              ((xfs_inofree_t)-1)
-#define XFS_INOBT_MASK(i)               ((xfs_inofree_t)1 << (i))
-
-static inline xfs_inofree_t xfs_inobt_maskn(int i, int n)
-{
-        return ((n >= XFS_INODES_PER_CHUNK ? 0 : XFS_INOBT_MASK(n)) - 1) << i;
-}
-
-/*
- * Data record structure
- */
-typedef struct xfs_inobt_rec {
-        __be32          ir_startino;    /* starting inode number */
-        __be32          ir_freecount;   /* count of free inodes (set bits) */
-        __be64          ir_free;        /* free inode mask */
-} xfs_inobt_rec_t;
-
-typedef struct xfs_inobt_rec_incore {
-        xfs_agino_t     ir_startino;    /* starting inode number */
-        __int32_t       ir_freecount;   /* count of free inodes (set bits) */
-        xfs_inofree_t   ir_free;        /* free inode mask */
-} xfs_inobt_rec_incore_t;
-
-
-/*
- * Key structure
- */
-typedef struct xfs_inobt_key {
-        __be32          ir_startino;    /* starting inode number */
-} xfs_inobt_key_t;
-
-/* btree pointer type */
-typedef __be32 xfs_inobt_ptr_t;
-
-/*
- * block numbers in the AG.
- */
-#define XFS_IBT_BLOCK(mp)               ((xfs_agblock_t)(XFS_CNT_BLOCK(mp) + 1))
-#define XFS_PREALLOC_BLOCKS(mp)         ((xfs_agblock_t)(XFS_IBT_BLOCK(mp) + 1))
-
-/*
  * Btree block header size depends on a superblock flag.
  */
 #define XFS_INOBT_BLOCK_LEN(mp) \
@@ -110,6 +61,4 @@ extern struct xfs_btree_cur *xfs_inobt_init_cursor(struct xfs_mount *,
                 struct xfs_trans *, struct xfs_buf *, xfs_agnumber_t);
 extern int xfs_inobt_maxrecs(struct xfs_mount *, int, int);
 
-extern const struct xfs_buf_ops xfs_inobt_buf_ops;
-
 #endif  /* __XFS_IALLOC_BTREE_H__ */
diff --git a/fs/xfs/xfs_icache.c b/fs/xfs/xfs_icache.c
index 193206ba4358..98d35244eecc 100644
--- a/fs/xfs/xfs_icache.c
+++ b/fs/xfs/xfs_icache.c
@@ -18,24 +18,19 @@
 #include "xfs.h"
 #include "xfs_fs.h"
 #include "xfs_format.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_log_priv.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_inum.h"
-#include "xfs_trans.h"
-#include "xfs_trans_priv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
 #include "xfs_inode.h"
-#include "xfs_dinode.h"
 #include "xfs_error.h"
-#include "xfs_filestream.h"
+#include "xfs_trans.h"
+#include "xfs_trans_priv.h"
 #include "xfs_inode_item.h"
 #include "xfs_quota.h"
 #include "xfs_trace.h"
-#include "xfs_fsops.h"
 #include "xfs_icache.h"
 #include "xfs_bmap_util.h"
 
@@ -119,11 +114,6 @@ xfs_inode_free(
                 ip->i_itemp = NULL;
         }
 
-        /* asserts to verify all state is correct here */
-        ASSERT(atomic_read(&ip->i_pincount) == 0);
-        ASSERT(!spin_is_locked(&ip->i_flags_lock));
-        ASSERT(!xfs_isiflocked(ip));
-
         /*
          * Because we use RCU freeing we need to ensure the inode always
          * appears to be reclaimed with an invalid inode number when in the
@@ -135,6 +125,10 @@ xfs_inode_free(
         ip->i_ino = 0;
         spin_unlock(&ip->i_flags_lock);
 
+        /* asserts to verify all state is correct here */
+        ASSERT(atomic_read(&ip->i_pincount) == 0);
+        ASSERT(!xfs_isiflocked(ip));
+
         call_rcu(&VFS_I(ip)->i_rcu, xfs_inode_free_callback);
 }
 
@@ -501,11 +495,6 @@ xfs_inode_ag_walk_grab(
         if (!igrab(inode))
                 return ENOENT;
 
-        if (is_bad_inode(inode)) {
-                IRELE(ip);
-                return ENOENT;
-        }
-
         /* inode is valid */
         return 0;
 
@@ -919,8 +908,6 @@ restart:
                 xfs_iflock(ip);
         }
 
-        if (is_bad_inode(VFS_I(ip)))
-                goto reclaim;
         if (XFS_FORCED_SHUTDOWN(ip->i_mount)) {
                 xfs_iunpin_wait(ip);
                 xfs_iflush_abort(ip, false);
diff --git a/fs/xfs/xfs_icreate_item.c b/fs/xfs/xfs_icreate_item.c
index 5a5a593994d4..d2eaccfa73f4 100644
--- a/fs/xfs/xfs_icreate_item.c
+++ b/fs/xfs/xfs_icreate_item.c
@@ -17,13 +17,14 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
+#include "xfs_shared.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_trans.h"
 #include "xfs_trans_priv.h"
 #include "xfs_error.h"
 #include "xfs_icreate_item.h"
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index e3d75385aa76..001aa893ed59 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -19,39 +19,38 @@
 
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
-#include "xfs_log.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_inum.h"
-#include "xfs_trans.h"
-#include "xfs_trans_space.h"
-#include "xfs_trans_priv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_inode.h"
+#include "xfs_da_format.h"
 #include "xfs_da_btree.h"
-#include "xfs_dir2_format.h"
 #include "xfs_dir2.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
 #include "xfs_attr_sf.h"
 #include "xfs_attr.h"
-#include "xfs_dinode.h"
-#include "xfs_inode.h"
+#include "xfs_trans_space.h"
+#include "xfs_trans.h"
 #include "xfs_buf_item.h"
 #include "xfs_inode_item.h"
-#include "xfs_btree.h"
-#include "xfs_alloc.h"
 #include "xfs_ialloc.h"
 #include "xfs_bmap.h"
 #include "xfs_bmap_util.h"
 #include "xfs_error.h"
 #include "xfs_quota.h"
+#include "xfs_dinode.h"
 #include "xfs_filestream.h"
 #include "xfs_cksum.h"
 #include "xfs_trace.h"
 #include "xfs_icache.h"
 #include "xfs_symlink.h"
+#include "xfs_trans_priv.h"
+#include "xfs_log.h"
+#include "xfs_bmap_btree.h"
 
 kmem_zone_t *xfs_inode_zone;
 
@@ -1663,6 +1662,126 @@ xfs_release(
 }
 
 /*
+ * xfs_inactive_truncate
+ *
+ * Called to perform a truncate when an inode becomes unlinked.
+ */
+STATIC int
+xfs_inactive_truncate(
+        struct xfs_inode *ip)
+{
+        struct xfs_mount        *mp = ip->i_mount;
+        struct xfs_trans        *tp;
+        int                     error;
+
+        tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
+        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
+        if (error) {
+                ASSERT(XFS_FORCED_SHUTDOWN(mp));
+                xfs_trans_cancel(tp, 0);
+                return error;
+        }
+
+        xfs_ilock(ip, XFS_ILOCK_EXCL);
+        xfs_trans_ijoin(tp, ip, 0);
+
+        /*
+         * Log the inode size first to prevent stale data exposure in the event
+         * of a system crash before the truncate completes. See the related
+         * comment in xfs_setattr_size() for details.
+         */
+        ip->i_d.di_size = 0;
+        xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
+
+        error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0);
+        if (error)
+                goto error_trans_cancel;
+
+        ASSERT(ip->i_d.di_nextents == 0);
+
+        error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
+        if (error)
+                goto error_unlock;
+
+        xfs_iunlock(ip, XFS_ILOCK_EXCL);
+        return 0;
+
+error_trans_cancel:
+        xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
+error_unlock:
+        xfs_iunlock(ip, XFS_ILOCK_EXCL);
+        return error;
+}
+
+/*
+ * xfs_inactive_ifree()
+ *
+ * Perform the inode free when an inode is unlinked.
+ */
+STATIC int
+xfs_inactive_ifree(
+        struct xfs_inode *ip)
+{
+        xfs_bmap_free_t         free_list;
+        xfs_fsblock_t           first_block;
+        int                     committed;
+        struct xfs_mount        *mp = ip->i_mount;
+        struct xfs_trans        *tp;
+        int                     error;
+
+        tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
+        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ifree, 0, 0);
+        if (error) {
+                ASSERT(XFS_FORCED_SHUTDOWN(mp));
+                xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES);
+                return error;
+        }
+
+        xfs_ilock(ip, XFS_ILOCK_EXCL);
+        xfs_trans_ijoin(tp, ip, 0);
+
+        xfs_bmap_init(&free_list, &first_block);
+        error = xfs_ifree(tp, ip, &free_list);
+        if (error) {
+                /*
+                 * If we fail to free the inode, shut down.  The cancel
+                 * might do that, we need to make sure.  Otherwise the
+                 * inode might be lost for a long time or forever.
+                 */
+                if (!XFS_FORCED_SHUTDOWN(mp)) {
+                        xfs_notice(mp, "%s: xfs_ifree returned error %d",
+                                __func__, error);
+                        xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
+                }
+                xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
+                xfs_iunlock(ip, XFS_ILOCK_EXCL);
+                return error;
+        }
+
+        /*
+         * Credit the quota account(s). The inode is gone.
+         */
+        xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
+
+        /*
+         * Just ignore errors at this point.  There is nothing we can
+         * do except to try to keep going. Make sure it's not a silent
+         * error.
+         */
+        error = xfs_bmap_finish(&tp,  &free_list, &committed);
+        if (error)
+                xfs_notice(mp, "%s: xfs_bmap_finish returned error %d",
+                        __func__, error);
+        error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
+        if (error)
+                xfs_notice(mp, "%s: xfs_trans_commit returned error %d",
+                        __func__, error);
+
+        xfs_iunlock(ip, XFS_ILOCK_EXCL);
+        return 0;
+}
+
+/*
  * xfs_inactive
  *
  * This is called when the vnode reference count for the vnode
@@ -1670,16 +1789,11 @@ xfs_release(
  * now be truncated.  Also, we clear all of the read-ahead state
  * kept for the inode here since the file is now closed.
  */
-int
+void
 xfs_inactive(
         xfs_inode_t     *ip)
 {
-        xfs_bmap_free_t         free_list;
-        xfs_fsblock_t           first_block;
-        int                     committed;
-        struct xfs_trans        *tp;
         struct xfs_mount        *mp;
-        struct xfs_trans_res    *resp;
         int                     error;
         int                     truncate = 0;
 
@@ -1687,19 +1801,17 @@ xfs_inactive(
          * If the inode is already free, then there can be nothing
          * to clean up here.
          */
-        if (ip->i_d.di_mode == 0 || is_bad_inode(VFS_I(ip))) {
+        if (ip->i_d.di_mode == 0) {
                 ASSERT(ip->i_df.if_real_bytes == 0);
                 ASSERT(ip->i_df.if_broot_bytes == 0);
-                return VN_INACTIVE_CACHE;
+                return;
         }
 
         mp = ip->i_mount;
 
-        error = 0;
-
         /* If this is a read-only mount, don't do this (would generate I/O) */
         if (mp->m_flags & XFS_MOUNT_RDONLY)
-                goto out;
+                return;
 
         if (ip->i_d.di_nlink != 0) {
                 /*
@@ -1707,12 +1819,10 @@ xfs_inactive(
                  * cache. Post-eof blocks must be freed, lest we end up with
                  * broken free space accounting.
                  */
-                if (xfs_can_free_eofblocks(ip, true)) {
-                        error = xfs_free_eofblocks(mp, ip, false);
-                        if (error)
-                                return VN_INACTIVE_CACHE;
-                }
-                goto out;
+                if (xfs_can_free_eofblocks(ip, true))
+                        xfs_free_eofblocks(mp, ip, false);
+
+                return;
         }
 
         if (S_ISREG(ip->i_d.di_mode) &&
@@ -1722,36 +1832,14 @@ xfs_inactive(
 
         error = xfs_qm_dqattach(ip, 0);
         if (error)
-                return VN_INACTIVE_CACHE;
+                return;
 
-        tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
-        resp = (truncate || S_ISLNK(ip->i_d.di_mode)) ?
-                &M_RES(mp)->tr_itruncate : &M_RES(mp)->tr_ifree;
-
-        error = xfs_trans_reserve(tp, resp, 0, 0);
-        if (error) {
-                ASSERT(XFS_FORCED_SHUTDOWN(mp));
-                xfs_trans_cancel(tp, 0);
-                return VN_INACTIVE_CACHE;
-        }
-
-        xfs_ilock(ip, XFS_ILOCK_EXCL);
-        xfs_trans_ijoin(tp, ip, 0);
-
-        if (S_ISLNK(ip->i_d.di_mode)) {
-                error = xfs_inactive_symlink(ip, &tp);
-                if (error)
-                        goto out_cancel;
-        } else if (truncate) {
-                ip->i_d.di_size = 0;
-                xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
-
-                error = xfs_itruncate_extents(&tp, ip, XFS_DATA_FORK, 0);
-                if (error)
-                        goto out_cancel;
-
-                ASSERT(ip->i_d.di_nextents == 0);
-        }
+        if (S_ISLNK(ip->i_d.di_mode))
+                error = xfs_inactive_symlink(ip);
+        else if (truncate)
+                error = xfs_inactive_truncate(ip);
+        if (error)
+                return;
 
         /*
          * If there are attributes associated with the file then blow them away
@@ -1762,25 +1850,9 @@ xfs_inactive(
         if (ip->i_d.di_anextents > 0) {
                 ASSERT(ip->i_d.di_forkoff != 0);
 
-                error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
-                if (error)
-                        goto out_unlock;
-
-                xfs_iunlock(ip, XFS_ILOCK_EXCL);
-
                 error = xfs_attr_inactive(ip);
                 if (error)
-                        goto out;
-
-                tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
-                error = xfs_trans_reserve(tp, &M_RES(mp)->tr_ifree, 0, 0);
-                if (error) {
-                        xfs_trans_cancel(tp, 0);
-                        goto out;
-                }
-
-                xfs_ilock(ip, XFS_ILOCK_EXCL);
-                xfs_trans_ijoin(tp, ip, 0);
+                        return;
         }
 
         if (ip->i_afp)
@@ -1791,52 +1863,14 @@ xfs_inactive(
         /*
          * Free the inode.
          */
-        xfs_bmap_init(&free_list, &first_block);
-        error = xfs_ifree(tp, ip, &free_list);
-        if (error) {
-                /*
-                 * If we fail to free the inode, shut down.  The cancel
-                 * might do that, we need to make sure.  Otherwise the
-                 * inode might be lost for a long time or forever.
-                 */
-                if (!XFS_FORCED_SHUTDOWN(mp)) {
-                        xfs_notice(mp, "%s: xfs_ifree returned error %d",
-                                __func__, error);
-                        xfs_force_shutdown(mp, SHUTDOWN_META_IO_ERROR);
-                }
-                xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES|XFS_TRANS_ABORT);
-        } else {
-                /*
-                 * Credit the quota account(s). The inode is gone.
-                 */
-                xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_ICOUNT, -1);
-
-                /*
-                 * Just ignore errors at this point.  There is nothing we can
-                 * do except to try to keep going. Make sure it's not a silent
-                 * error.
-                 */
-                error = xfs_bmap_finish(&tp,  &free_list, &committed);
-                if (error)
-                        xfs_notice(mp, "%s: xfs_bmap_finish returned error %d",
-                                __func__, error);
-                error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
-                if (error)
-                        xfs_notice(mp, "%s: xfs_trans_commit returned error %d",
-                                __func__, error);
-        }
+        error = xfs_inactive_ifree(ip);
+        if (error)
+                return;
 
         /*
          * Release the dquots held by inode, if any.
          */
         xfs_qm_dqdetach(ip);
-out_unlock:
-        xfs_iunlock(ip, XFS_ILOCK_EXCL);
-out:
-        return VN_INACTIVE_CACHE;
-out_cancel:
-        xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
-        goto out_unlock;
 }
 
 /*
@@ -2370,6 +2404,33 @@ xfs_iunpin_wait(
                 __xfs_iunpin_wait(ip);
 }
 
+/*
+ * Removing an inode from the namespace involves removing the directory entry
+ * and dropping the link count on the inode. Removing the directory entry can
+ * result in locking an AGF (directory blocks were freed) and removing a link
+ * count can result in placing the inode on an unlinked list which results in
+ * locking an AGI.
+ *
+ * The big problem here is that we have an ordering constraint on AGF and AGI
+ * locking - inode allocation locks the AGI, then can allocate a new extent for
+ * new inodes, locking the AGF after the AGI. Similarly, freeing the inode
+ * removes the inode from the unlinked list, requiring that we lock the AGI
+ * first, and then freeing the inode can result in an inode chunk being freed
+ * and hence freeing disk space requiring that we lock an AGF.
+ *
+ * Hence the ordering that is imposed by other parts of the code is AGI before
+ * AGF. This means we cannot remove the directory entry before we drop the inode
+ * reference count and put it on the unlinked list as this results in a lock
+ * order of AGF then AGI, and this can deadlock against inode allocation and
+ * freeing. Therefore we must drop the link counts before we remove the
+ * directory entry.
+ *
+ * This is still safe from a transactional point of view - it is not until we
+ * get to xfs_bmap_finish() that we have the possibility of multiple
+ * transactions in this operation. Hence as long as we remove the directory
+ * entry and drop the link count in the first transaction of the remove
+ * operation, there are no transactional constraints on the ordering here.
+ */
 int
 xfs_remove(
         xfs_inode_t             *dp,
@@ -2439,6 +2500,7 @@ xfs_remove(
         /*
          * If we're removing a directory perform some additional validation.
          */
+        cancel_flags |= XFS_TRANS_ABORT;
         if (is_dir) {
                 ASSERT(ip->i_d.di_nlink >= 2);
                 if (ip->i_d.di_nlink != 2) {
@@ -2449,31 +2511,16 @@ xfs_remove(
                         error = XFS_ERROR(ENOTEMPTY);
                         goto out_trans_cancel;
                 }
-        }
 
-        xfs_bmap_init(&free_list, &first_block);
-        error = xfs_dir_removename(tp, dp, name, ip->i_ino,
-                                        &first_block, &free_list, resblks);
-        if (error) {
-                ASSERT(error != ENOENT);
-                goto out_bmap_cancel;
-        }
-        xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
-
-        if (is_dir) {
-                /*
-                 * Drop the link from ip's "..".
-                 */
+                /* Drop the link from ip's "..".  */
                 error = xfs_droplink(tp, dp);
                 if (error)
-                        goto out_bmap_cancel;
+                        goto out_trans_cancel;
 
-                /*
-                 * Drop the "." link from ip to self.
-                 */
+                /* Drop the "." link from ip to self.  */
                 error = xfs_droplink(tp, ip);
                 if (error)
-                        goto out_bmap_cancel;
+                        goto out_trans_cancel;
         } else {
                 /*
                  * When removing a non-directory we need to log the parent
@@ -2482,20 +2529,24 @@ xfs_remove(
                  */
                 xfs_trans_log_inode(tp, dp, XFS_ILOG_CORE);
         }
+        xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
 
-        /*
-         * Drop the link from dp to ip.
-         */
+        /* Drop the link from dp to ip. */
         error = xfs_droplink(tp, ip);
         if (error)
-                goto out_bmap_cancel;
+                goto out_trans_cancel;
 
-        /*
-         * Determine if this is the last link while
-         * we are in the transaction.
-         */
+        /* Determine if this is the last link while the inode is locked */
         link_zero = (ip->i_d.di_nlink == 0);
 
+        xfs_bmap_init(&free_list, &first_block);
+        error = xfs_dir_removename(tp, dp, name, ip->i_ino,
+                                        &first_block, &free_list, resblks);
+        if (error) {
+                ASSERT(error != ENOENT);
+                goto out_bmap_cancel;
+        }
+
         /*
          * If this is a synchronous mount, make sure that the
          * remove transaction goes to disk before returning to
@@ -2525,7 +2576,6 @@ xfs_remove(
 
  out_bmap_cancel:
         xfs_bmap_cancel(&free_list);
-        cancel_flags |= XFS_TRANS_ABORT;
  out_trans_cancel:
         xfs_trans_cancel(tp, cancel_flags);
  std_return:
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index 4a91358c1470..9e6efccbae04 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -24,7 +24,6 @@
 /*
  * Kernel only inode definitions
  */
-
 struct xfs_dinode;
 struct xfs_inode;
 struct xfs_buf;
@@ -50,6 +49,9 @@ typedef struct xfs_inode {
         xfs_ifork_t             *i_afp;         /* attribute fork pointer */
         xfs_ifork_t             i_df;           /* data fork */
 
+        /* operations vectors */
+        const struct xfs_dir_ops *d_ops;                /* directory ops vector */
+
         /* Transaction and locking information. */
         struct xfs_inode_log_item *i_itemp;     /* logging information */
         mrlock_t                i_lock;         /* inode lock */
@@ -316,7 +318,7 @@ static inline int xfs_isiflocked(struct xfs_inode *ip)
 
 
 int             xfs_release(struct xfs_inode *ip);
-int             xfs_inactive(struct xfs_inode *ip);
+void            xfs_inactive(struct xfs_inode *ip);
 int             xfs_lookup(struct xfs_inode *dp, struct xfs_name *name,
                            struct xfs_inode **ipp, struct xfs_name *ci_name);
 int             xfs_create(struct xfs_inode *dp, struct xfs_name *name,
diff --git a/fs/xfs/xfs_inode_buf.c b/fs/xfs/xfs_inode_buf.c
index 63382d37f565..4fc9f39dd89e 100644
--- a/fs/xfs/xfs_inode_buf.c
+++ b/fs/xfs/xfs_inode_buf.c
@@ -17,20 +17,20 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_error.h"
 #include "xfs_cksum.h"
 #include "xfs_icache.h"
+#include "xfs_trans.h"
 #include "xfs_ialloc.h"
+#include "xfs_dinode.h"
 
 /*
  * Check that none of the inode's in the buffer have a next
diff --git a/fs/xfs/xfs_inode_buf.h b/fs/xfs/xfs_inode_buf.h
index abba0ae8cf2d..9308c47f2a52 100644
--- a/fs/xfs/xfs_inode_buf.h
+++ b/fs/xfs/xfs_inode_buf.h
@@ -47,7 +47,4 @@ void	xfs_inobp_check(struct xfs_mount *, struct xfs_buf *);
 #define xfs_inobp_check(mp, bp)
 #endif /* DEBUG */
 
-extern const struct xfs_buf_ops xfs_inode_buf_ops;
-extern const struct xfs_buf_ops xfs_inode_buf_ra_ops;
-
 #endif  /* __XFS_INODE_BUF_H__ */
diff --git a/fs/xfs/xfs_inode_fork.c b/fs/xfs/xfs_inode_fork.c
index 02f1083955bb..cfee14a83cfe 100644
--- a/fs/xfs/xfs_inode_fork.c
+++ b/fs/xfs/xfs_inode_fork.c
@@ -20,31 +20,21 @@
 #include "xfs.h"
 #include "xfs_fs.h"
 #include "xfs_format.h"
-#include "xfs_log.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_inum.h"
-#include "xfs_trans.h"
-#include "xfs_trans_priv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_attr_sf.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
-#include "xfs_buf_item.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
-#include "xfs_btree.h"
-#include "xfs_alloc.h"
-#include "xfs_ialloc.h"
+#include "xfs_bmap_btree.h"
 #include "xfs_bmap.h"
 #include "xfs_error.h"
-#include "xfs_quota.h"
-#include "xfs_filestream.h"
-#include "xfs_cksum.h"
 #include "xfs_trace.h"
-#include "xfs_icache.h"
+#include "xfs_attr_sf.h"
+#include "xfs_dinode.h"
 
 kmem_zone_t *xfs_ifork_zone;
 
@@ -1031,15 +1021,14 @@ xfs_iext_add(
                  * the next index needed in the indirection array.
                  */
                 else {
-                        int     count = ext_diff;
+                        uint    count = ext_diff;
 
                         while (count) {
                                 erp = xfs_iext_irec_new(ifp, erp_idx);
-                                erp->er_extcount = count;
-                                count -= MIN(count, (int)XFS_LINEAR_EXTS);
-                                if (count) {
+                                erp->er_extcount = min(count, XFS_LINEAR_EXTS);
+                                count -= erp->er_extcount;
+                                if (count)
                                         erp_idx++;
-                                }
                         }
                 }
         }
@@ -1359,7 +1348,7 @@ xfs_iext_remove_indirect(
 void
 xfs_iext_realloc_direct(
         xfs_ifork_t     *ifp,           /* inode fork pointer */
-        int             new_size)       /* new size of extents */
+        int             new_size)       /* new size of extents after adding */
 {
         int             rnew_size;      /* real new size of extents */
 
@@ -1397,13 +1386,8 @@ xfs_iext_realloc_direct(
                                 rnew_size - ifp->if_real_bytes);
                 }
         }
-        /*
-         * Switch from the inline extent buffer to a direct
-         * extent list. Be sure to include the inline extent
-         * bytes in new_size.
-         */
+        /* Switch from the inline extent buffer to a direct extent list */
         else {
-                new_size += ifp->if_bytes;
                 if (!is_power_of_2(new_size)) {
                         rnew_size = roundup_pow_of_two(new_size);
                 }
diff --git a/fs/xfs/xfs_inode_fork.h b/fs/xfs/xfs_inode_fork.h
index 28661a0d9058..eb329a1ea888 100644
--- a/fs/xfs/xfs_inode_fork.h
+++ b/fs/xfs/xfs_inode_fork.h
@@ -19,6 +19,7 @@
 #define __XFS_INODE_FORK_H__
 
 struct xfs_inode_log_item;
+struct xfs_dinode;
 
 /*
  * The following xfs_ext_irec_t struct introduces a second (top) level
diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c
index 378081109844..7c0d391f9a6e 100644
--- a/fs/xfs/xfs_inode_item.c
+++ b/fs/xfs/xfs_inode_item.c
@@ -17,19 +17,19 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_trans_priv.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_trans.h"
 #include "xfs_inode_item.h"
 #include "xfs_error.h"
 #include "xfs_trace.h"
+#include "xfs_trans_priv.h"
+#include "xfs_dinode.h"
 
 
 kmem_zone_t     *xfs_ili_zone;          /* inode log item zone */
diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c
index 668e8f4ccf5e..4d613401a5e0 100644
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -17,32 +17,31 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_alloc.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_ioctl.h"
+#include "xfs_alloc.h"
 #include "xfs_rtalloc.h"
 #include "xfs_itable.h"
 #include "xfs_error.h"
 #include "xfs_attr.h"
 #include "xfs_bmap.h"
 #include "xfs_bmap_util.h"
-#include "xfs_buf_item.h"
 #include "xfs_fsops.h"
 #include "xfs_discard.h"
 #include "xfs_quota.h"
-#include "xfs_inode_item.h"
 #include "xfs_export.h"
 #include "xfs_trace.h"
 #include "xfs_icache.h"
 #include "xfs_symlink.h"
+#include "xfs_dinode.h"
+#include "xfs_trans.h"
 
 #include <linux/capability.h>
 #include <linux/dcache.h>
@@ -641,7 +640,11 @@ xfs_ioc_space(
         unsigned int            cmd,
         xfs_flock64_t           *bf)
 {
-        int                     attr_flags = 0;
+        struct xfs_mount        *mp = ip->i_mount;
+        struct xfs_trans        *tp;
+        struct iattr            iattr;
+        bool                    setprealloc = false;
+        bool                    clrprealloc = false;
         int                     error;
 
         /*
@@ -661,19 +664,128 @@ xfs_ioc_space(
         if (!S_ISREG(inode->i_mode))
                 return -XFS_ERROR(EINVAL);
 
-        if (filp->f_flags & (O_NDELAY|O_NONBLOCK))
-                attr_flags |= XFS_ATTR_NONBLOCK;
+        error = mnt_want_write_file(filp);
+        if (error)
+                return error;
 
-        if (filp->f_flags & O_DSYNC)
-                attr_flags |= XFS_ATTR_SYNC;
+        xfs_ilock(ip, XFS_IOLOCK_EXCL);
+
+        switch (bf->l_whence) {
+        case 0: /*SEEK_SET*/
+                break;
+        case 1: /*SEEK_CUR*/
+                bf->l_start += filp->f_pos;
+                break;
+        case 2: /*SEEK_END*/
+                bf->l_start += XFS_ISIZE(ip);
+                break;
+        default:
+                error = XFS_ERROR(EINVAL);
+                goto out_unlock;
+        }
 
-        if (ioflags & IO_INVIS)
-                attr_flags |= XFS_ATTR_DMI;
+        /*
+         * length of <= 0 for resv/unresv/zero is invalid.  length for
+         * alloc/free is ignored completely and we have no idea what userspace
+         * might have set it to, so set it to zero to allow range
+         * checks to pass.
+         */
+        switch (cmd) {
+        case XFS_IOC_ZERO_RANGE:
+        case XFS_IOC_RESVSP:
+        case XFS_IOC_RESVSP64:
+        case XFS_IOC_UNRESVSP:
+        case XFS_IOC_UNRESVSP64:
+                if (bf->l_len <= 0) {
+                        error = XFS_ERROR(EINVAL);
+                        goto out_unlock;
+                }
+                break;
+        default:
+                bf->l_len = 0;
+                break;
+        }
+
+        if (bf->l_start < 0 ||
+            bf->l_start > mp->m_super->s_maxbytes ||
+            bf->l_start + bf->l_len < 0 ||
+            bf->l_start + bf->l_len >= mp->m_super->s_maxbytes) {
+                error = XFS_ERROR(EINVAL);
+                goto out_unlock;
+        }
+
+        switch (cmd) {
+        case XFS_IOC_ZERO_RANGE:
+                error = xfs_zero_file_space(ip, bf->l_start, bf->l_len);
+                if (!error)
+                        setprealloc = true;
+                break;
+        case XFS_IOC_RESVSP:
+        case XFS_IOC_RESVSP64:
+                error = xfs_alloc_file_space(ip, bf->l_start, bf->l_len,
+                                                XFS_BMAPI_PREALLOC);
+                if (!error)
+                        setprealloc = true;
+                break;
+        case XFS_IOC_UNRESVSP:
+        case XFS_IOC_UNRESVSP64:
+                error = xfs_free_file_space(ip, bf->l_start, bf->l_len);
+                break;
+        case XFS_IOC_ALLOCSP:
+        case XFS_IOC_ALLOCSP64:
+        case XFS_IOC_FREESP:
+        case XFS_IOC_FREESP64:
+                if (bf->l_start > XFS_ISIZE(ip)) {
+                        error = xfs_alloc_file_space(ip, XFS_ISIZE(ip),
+                                        bf->l_start - XFS_ISIZE(ip), 0);
+                        if (error)
+                                goto out_unlock;
+                }
+
+                iattr.ia_valid = ATTR_SIZE;
+                iattr.ia_size = bf->l_start;
+
+                error = xfs_setattr_size(ip, &iattr);
+                if (!error)
+                        clrprealloc = true;
+                break;
+        default:
+                ASSERT(0);
+                error = XFS_ERROR(EINVAL);
+        }
 
-        error = mnt_want_write_file(filp);
         if (error)
-                return error;
-        error = xfs_change_file_space(ip, cmd, bf, filp->f_pos, attr_flags);
+                goto out_unlock;
+
+        tp = xfs_trans_alloc(mp, XFS_TRANS_WRITEID);
+        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_writeid, 0, 0);
+        if (error) {
+                xfs_trans_cancel(tp, 0);
+                goto out_unlock;
+        }
+
+        xfs_ilock(ip, XFS_ILOCK_EXCL);
+        xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
+
+        if (!(ioflags & IO_INVIS)) {
+                ip->i_d.di_mode &= ~S_ISUID;
+                if (ip->i_d.di_mode & S_IXGRP)
+                        ip->i_d.di_mode &= ~S_ISGID;
+                xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
+        }
+
+        if (setprealloc)
+                ip->i_d.di_flags |= XFS_DIFLAG_PREALLOC;
+        else if (clrprealloc)
+                ip->i_d.di_flags &= ~XFS_DIFLAG_PREALLOC;
+
+        xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
+        if (filp->f_flags & O_DSYNC)
+                xfs_trans_set_sync(tp);
+        error = xfs_trans_commit(tp, 0);
+
+out_unlock:
+        xfs_iunlock(ip, XFS_IOLOCK_EXCL);
         mnt_drop_write_file(filp);
         return -error;
 }
diff --git a/fs/xfs/xfs_ioctl32.c b/fs/xfs/xfs_ioctl32.c
index f671f7e472ac..e8fb1231db81 100644
--- a/fs/xfs/xfs_ioctl32.c
+++ b/fs/xfs/xfs_ioctl32.c
@@ -22,14 +22,13 @@
 #include <asm/uaccess.h>
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
 #include "xfs_vnode.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_itable.h"
 #include "xfs_error.h"
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index 8d4d49b6fbf3..22d1cbea283d 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -17,34 +17,28 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_alloc.h"
-#include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
-#include "xfs_inode_item.h"
 #include "xfs_btree.h"
+#include "xfs_bmap_btree.h"
 #include "xfs_bmap.h"
 #include "xfs_bmap_util.h"
-#include "xfs_rtalloc.h"
 #include "xfs_error.h"
-#include "xfs_itable.h"
-#include "xfs_attr.h"
-#include "xfs_buf_item.h"
+#include "xfs_trans.h"
 #include "xfs_trans_space.h"
 #include "xfs_iomap.h"
 #include "xfs_trace.h"
 #include "xfs_icache.h"
+#include "xfs_quota.h"
 #include "xfs_dquot_item.h"
 #include "xfs_dquot.h"
+#include "xfs_dinode.h"
 
 
 #define XFS_WRITEIO_ALIGN(mp,off)       (((off) >> mp->m_writeio_log) \
@@ -110,7 +104,7 @@ xfs_alert_fsblock_zero(
         xfs_alert_tag(ip->i_mount, XFS_PTAG_FSBLOCK_ZERO,
                         "Access to block zero in inode %llu "
                         "start_block: %llx start_off: %llx "
-                        "blkcnt: %llx extent-state: %x\n",
+                        "blkcnt: %llx extent-state: %x",
                 (unsigned long long)ip->i_ino,
                 (unsigned long long)imap->br_startblock,
                 (unsigned long long)imap->br_startoff,
@@ -655,7 +649,6 @@ int
 xfs_iomap_write_allocate(
         xfs_inode_t     *ip,
         xfs_off_t       offset,
-        size_t          count,
         xfs_bmbt_irec_t *imap)
 {
         xfs_mount_t     *mp = ip->i_mount;
diff --git a/fs/xfs/xfs_iomap.h b/fs/xfs/xfs_iomap.h
index 80615760959a..411fbb8919ef 100644
--- a/fs/xfs/xfs_iomap.h
+++ b/fs/xfs/xfs_iomap.h
@@ -21,12 +21,12 @@
 struct xfs_inode;
 struct xfs_bmbt_irec;
 
-extern int xfs_iomap_write_direct(struct xfs_inode *, xfs_off_t, size_t,
+int xfs_iomap_write_direct(struct xfs_inode *, xfs_off_t, size_t,
                         struct xfs_bmbt_irec *, int);
-extern int xfs_iomap_write_delay(struct xfs_inode *, xfs_off_t, size_t,
+int xfs_iomap_write_delay(struct xfs_inode *, xfs_off_t, size_t,
                         struct xfs_bmbt_irec *);
-extern int xfs_iomap_write_allocate(struct xfs_inode *, xfs_off_t, size_t,
+int xfs_iomap_write_allocate(struct xfs_inode *, xfs_off_t,
                         struct xfs_bmbt_irec *);
-extern int xfs_iomap_write_unwritten(struct xfs_inode *, xfs_off_t, size_t);
+int xfs_iomap_write_unwritten(struct xfs_inode *, xfs_off_t, size_t);
 
 #endif /* __XFS_IOMAP_H__*/
diff --git a/fs/xfs/xfs_iops.c b/fs/xfs/xfs_iops.c
index 2b8952d9199b..27e0e544e963 100644
--- a/fs/xfs/xfs_iops.c
+++ b/fs/xfs/xfs_iops.c
@@ -17,32 +17,28 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
-#include "xfs_acl.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_alloc.h"
-#include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_dinode.h"
+#include "xfs_da_format.h"
 #include "xfs_inode.h"
 #include "xfs_bmap.h"
 #include "xfs_bmap_util.h"
-#include "xfs_rtalloc.h"
+#include "xfs_acl.h"
+#include "xfs_quota.h"
 #include "xfs_error.h"
-#include "xfs_itable.h"
 #include "xfs_attr.h"
-#include "xfs_buf_item.h"
-#include "xfs_inode_item.h"
+#include "xfs_trans.h"
 #include "xfs_trace.h"
 #include "xfs_icache.h"
 #include "xfs_symlink.h"
 #include "xfs_da_btree.h"
-#include "xfs_dir2_format.h"
 #include "xfs_dir2_priv.h"
+#include "xfs_dinode.h"
 
 #include <linux/capability.h>
 #include <linux/xattr.h>
@@ -709,8 +705,7 @@ out_dqrele:
 int
 xfs_setattr_size(
         struct xfs_inode        *ip,
-        struct iattr            *iattr,
-        int                     flags)
+        struct iattr            *iattr)
 {
         struct xfs_mount        *mp = ip->i_mount;
         struct inode            *inode = VFS_I(ip);
@@ -733,15 +728,11 @@ xfs_setattr_size(
         if (error)
                 return XFS_ERROR(error);
 
+        ASSERT(xfs_isilocked(ip, XFS_IOLOCK_EXCL));
         ASSERT(S_ISREG(ip->i_d.di_mode));
         ASSERT((mask & (ATTR_UID|ATTR_GID|ATTR_ATIME|ATTR_ATIME_SET|
                         ATTR_MTIME_SET|ATTR_KILL_PRIV|ATTR_TIMES_SET)) == 0);
 
-        if (!(flags & XFS_ATTR_NOLOCK)) {
-                lock_flags |= XFS_IOLOCK_EXCL;
-                xfs_ilock(ip, lock_flags);
-        }
-
         oldsize = inode->i_size;
         newsize = iattr->ia_size;
 
@@ -750,12 +741,11 @@ xfs_setattr_size(
          */
         if (newsize == 0 && oldsize == 0 && ip->i_d.di_nextents == 0) {
                 if (!(mask & (ATTR_CTIME|ATTR_MTIME)))
-                        goto out_unlock;
+                        return 0;
 
                 /*
                  * Use the regular setattr path to update the timestamps.
                  */
-                xfs_iunlock(ip, lock_flags);
                 iattr->ia_valid &= ~ATTR_SIZE;
                 return xfs_setattr_nonsize(ip, iattr, 0);
         }
@@ -765,7 +755,7 @@ xfs_setattr_size(
          */
         error = xfs_qm_dqattach(ip, 0);
         if (error)
-                goto out_unlock;
+                return error;
 
         /*
          * Now we can make the changes.  Before we join the inode to the
@@ -783,7 +773,7 @@ xfs_setattr_size(
                  */
                 error = xfs_zero_eof(ip, newsize, oldsize);
                 if (error)
-                        goto out_unlock;
+                        return error;
         }
 
         /*
@@ -802,7 +792,7 @@ xfs_setattr_size(
                 error = -filemap_write_and_wait_range(VFS_I(ip)->i_mapping,
                                                       ip->i_d.di_size, newsize);
                 if (error)
-                        goto out_unlock;
+                        return error;
         }
 
         /*
@@ -812,7 +802,7 @@ xfs_setattr_size(
 
         error = -block_truncate_page(inode->i_mapping, newsize, xfs_get_blocks);
         if (error)
-                goto out_unlock;
+                return error;
 
         tp = xfs_trans_alloc(mp, XFS_TRANS_SETATTR_SIZE);
         error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
@@ -916,12 +906,21 @@ out_trans_cancel:
 
 STATIC int
 xfs_vn_setattr(
-        struct dentry   *dentry,
-        struct iattr    *iattr)
+        struct dentry           *dentry,
+        struct iattr            *iattr)
 {
-        if (iattr->ia_valid & ATTR_SIZE)
-                return -xfs_setattr_size(XFS_I(dentry->d_inode), iattr, 0);
-        return -xfs_setattr_nonsize(XFS_I(dentry->d_inode), iattr, 0);
+        struct xfs_inode        *ip = XFS_I(dentry->d_inode);
+        int                     error;
+
+        if (iattr->ia_valid & ATTR_SIZE) {
+                xfs_ilock(ip, XFS_IOLOCK_EXCL);
+                error = xfs_setattr_size(ip, iattr);
+                xfs_iunlock(ip, XFS_IOLOCK_EXCL);
+        } else {
+                error = xfs_setattr_nonsize(ip, iattr, 0);
+        }
+
+        return -error;
 }
 
 STATIC int
@@ -1169,6 +1168,7 @@ xfs_setup_inode(
         struct xfs_inode        *ip)
 {
         struct inode            *inode = &ip->i_vnode;
+        gfp_t                   gfp_mask;
 
         inode->i_ino = ip->i_ino;
         inode->i_state = I_NEW;
@@ -1204,6 +1204,7 @@ xfs_setup_inode(
         inode->i_ctime.tv_nsec  = ip->i_d.di_ctime.t_nsec;
         xfs_diflags_to_iflags(inode, ip);
 
+        ip->d_ops = ip->i_mount->m_nondir_inode_ops;
         switch (inode->i_mode & S_IFMT) {
         case S_IFREG:
                 inode->i_op = &xfs_inode_operations;
@@ -1216,6 +1217,7 @@ xfs_setup_inode(
                 else
                         inode->i_op = &xfs_dir_inode_operations;
                 inode->i_fop = &xfs_dir_file_operations;
+                ip->d_ops = ip->i_mount->m_dir_inode_ops;
                 break;
         case S_IFLNK:
                 inode->i_op = &xfs_symlink_inode_operations;
@@ -1229,6 +1231,14 @@ xfs_setup_inode(
         }
 
         /*
+         * Ensure all page cache allocations are done from GFP_NOFS context to
+         * prevent direct reclaim recursion back into the filesystem and blowing
+         * stacks or deadlocking.
+         */
+        gfp_mask = mapping_gfp_mask(inode->i_mapping);
+        mapping_set_gfp_mask(inode->i_mapping, (gfp_mask & ~(__GFP_FS)));
+
+        /*
          * If there is no attribute fork no ACL can exist on this inode,
          * and it can't have any file capabilities attached to it either.
          */
diff --git a/fs/xfs/xfs_iops.h b/fs/xfs/xfs_iops.h
index d81fb41205ec..d2c5057b5cc4 100644
--- a/fs/xfs/xfs_iops.h
+++ b/fs/xfs/xfs_iops.h
@@ -30,14 +30,10 @@ extern void xfs_setup_inode(struct xfs_inode *);
 /*
  * Internal setattr interfaces.
  */
-#define XFS_ATTR_DMI            0x01    /* invocation from a DMI function */
-#define XFS_ATTR_NONBLOCK       0x02    /* return EAGAIN if op would block */
-#define XFS_ATTR_NOLOCK         0x04    /* Don't grab any conflicting locks */
-#define XFS_ATTR_NOACL          0x08    /* Don't call xfs_acl_chmod */
-#define XFS_ATTR_SYNC           0x10    /* synchronous operation required */
+#define XFS_ATTR_NOACL          0x01    /* Don't call xfs_acl_chmod */
 
 extern int xfs_setattr_nonsize(struct xfs_inode *ip, struct iattr *vap,
                                int flags);
-extern int xfs_setattr_size(struct xfs_inode *ip, struct iattr *vap, int flags);
+extern int xfs_setattr_size(struct xfs_inode *ip, struct iattr *vap);
 
 #endif /* __XFS_IOPS_H__ */
diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c
index 084b3e1741fd..c237ad15d500 100644
--- a/fs/xfs/xfs_itable.c
+++ b/fs/xfs/xfs_itable.c
@@ -17,24 +17,23 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_inum.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_btree.h"
 #include "xfs_ialloc.h"
+#include "xfs_ialloc_btree.h"
 #include "xfs_itable.h"
 #include "xfs_error.h"
-#include "xfs_btree.h"
 #include "xfs_trace.h"
 #include "xfs_icache.h"
+#include "xfs_dinode.h"
 
 STATIC int
 xfs_internal_inum(
diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index a2dea108071a..8497a00e399d 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -17,21 +17,19 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
 #include "xfs_error.h"
+#include "xfs_trans.h"
+#include "xfs_trans_priv.h"
+#include "xfs_log.h"
 #include "xfs_log_priv.h"
-#include "xfs_buf_item.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
 #include "xfs_log_recover.h"
-#include "xfs_trans_priv.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_trace.h"
 #include "xfs_fsops.h"
@@ -1000,27 +998,34 @@ xfs_log_space_wake(
 }
 
 /*
- * Determine if we have a transaction that has gone to disk
- * that needs to be covered. To begin the transition to the idle state
- * firstly the log needs to be idle (no AIL and nothing in the iclogs).
- * If we are then in a state where covering is needed, the caller is informed
- * that dummy transactions are required to move the log into the idle state.
+ * Determine if we have a transaction that has gone to disk that needs to be
+ * covered. To begin the transition to the idle state firstly the log needs to
+ * be idle. That means the CIL, the AIL and the iclogs needs to be empty before
+ * we start attempting to cover the log.
  *
- * Because this is called as part of the sync process, we should also indicate
- * that dummy transactions should be issued in anything but the covered or
- * idle states. This ensures that the log tail is accurately reflected in
- * the log at the end of the sync, hence if a crash occurrs avoids replay
- * of transactions where the metadata is already on disk.
+ * Only if we are then in a state where covering is needed, the caller is
+ * informed that dummy transactions are required to move the log into the idle
+ * state.
+ *
+ * If there are any items in the AIl or CIL, then we do not want to attempt to
+ * cover the log as we may be in a situation where there isn't log space
+ * available to run a dummy transaction and this can lead to deadlocks when the
+ * tail of the log is pinned by an item that is modified in the CIL.  Hence
+ * there's no point in running a dummy transaction at this point because we
+ * can't start trying to idle the log until both the CIL and AIL are empty.
  */
 int
 xfs_log_need_covered(xfs_mount_t *mp)
 {
-        int             needed = 0;
         struct xlog     *log = mp->m_log;
+        int             needed = 0;
 
         if (!xfs_fs_writable(mp))
                 return 0;
 
+        if (!xlog_cil_empty(log))
+                return 0;
+
         spin_lock(&log->l_icloglock);
         switch (log->l_covered_state) {
         case XLOG_STATE_COVER_DONE:
@@ -1029,14 +1034,17 @@ xfs_log_need_covered(xfs_mount_t *mp)
                 break;
         case XLOG_STATE_COVER_NEED:
         case XLOG_STATE_COVER_NEED2:
-                if (!xfs_ail_min_lsn(log->l_ailp) &&
-                    xlog_iclogs_empty(log)) {
-                        if (log->l_covered_state == XLOG_STATE_COVER_NEED)
-                                log->l_covered_state = XLOG_STATE_COVER_DONE;
-                        else
-                                log->l_covered_state = XLOG_STATE_COVER_DONE2;
-                }
-                /* FALLTHRU */
+                if (xfs_ail_min_lsn(log->l_ailp))
+                        break;
+                if (!xlog_iclogs_empty(log))
+                        break;
+
+                needed = 1;
+                if (log->l_covered_state == XLOG_STATE_COVER_NEED)
+                        log->l_covered_state = XLOG_STATE_COVER_DONE;
+                else
+                        log->l_covered_state = XLOG_STATE_COVER_DONE2;
+                break;
         default:
                 needed = 1;
                 break;
@@ -1068,6 +1076,7 @@ xlog_assign_tail_lsn_locked(
                 tail_lsn = lip->li_lsn;
         else
                 tail_lsn = atomic64_read(&log->l_last_sync_lsn);
+        trace_xfs_log_assign_tail_lsn(log, tail_lsn);
         atomic64_set(&log->l_tail_lsn, tail_lsn);
         return tail_lsn;
 }
@@ -1979,7 +1988,7 @@ xlog_print_tic_res(
 
         for (i = 0; i < ticket->t_res_num; i++) {
                 uint r_type = ticket->t_res_arr[i].r_type;
-                xfs_warn(mp, "region[%u]: %s - %u bytes\n", i,
+                xfs_warn(mp, "region[%u]: %s - %u bytes", i,
                             ((r_type <= 0 || r_type > XLOG_REG_TYPE_MAX) ?
                             "bad-rtype" : res_type_str[r_type-1]),
                             ticket->t_res_arr[i].r_len);
@@ -3702,11 +3711,9 @@ xlog_verify_iclog(
         /* check validity of iclog pointers */
         spin_lock(&log->l_icloglock);
         icptr = log->l_iclog;
-        for (i=0; i < log->l_iclog_bufs; i++) {
-                if (icptr == NULL)
-                        xfs_emerg(log->l_mp, "%s: invalid ptr", __func__);
-                icptr = icptr->ic_next;
-        }
+        for (i = 0; i < log->l_iclog_bufs; i++, icptr = icptr->ic_next)
+                ASSERT(icptr);
+
         if (icptr != log->l_iclog)
                 xfs_emerg(log->l_mp, "%s: corrupt iclog ring", __func__);
         spin_unlock(&log->l_icloglock);
diff --git a/fs/xfs/xfs_log.h b/fs/xfs/xfs_log.h
index 1c458487f000..e148719e0a5d 100644
--- a/fs/xfs/xfs_log.h
+++ b/fs/xfs/xfs_log.h
@@ -18,8 +18,6 @@
 #ifndef __XFS_LOG_H__
 #define __XFS_LOG_H__
 
-#include "xfs_log_format.h"
-
 struct xfs_log_vec {
         struct xfs_log_vec      *lv_next;       /* next lv in build list */
         int                     lv_niovecs;     /* number of iovecs in lv */
@@ -82,11 +80,7 @@ struct xlog_ticket;
 struct xfs_log_item;
 struct xfs_item_ops;
 struct xfs_trans;
-
-void    xfs_log_item_init(struct xfs_mount      *mp,
-                        struct xfs_log_item     *item,
-                        int                     type,
-                        const struct xfs_item_ops *ops);
+struct xfs_log_callback;
 
 xfs_lsn_t xfs_log_done(struct xfs_mount *mp,
                        struct xlog_ticket *ticket,
@@ -114,7 +108,7 @@ xfs_lsn_t xlog_assign_tail_lsn_locked(struct xfs_mount *mp);
 void      xfs_log_space_wake(struct xfs_mount *mp);
 int       xfs_log_notify(struct xfs_mount       *mp,
                          struct xlog_in_core    *iclog,
-                         xfs_log_callback_t     *callback_entry);
+                         struct xfs_log_callback *callback_entry);
 int       xfs_log_release_iclog(struct xfs_mount *mp,
                          struct xlog_in_core     *iclog);
 int       xfs_log_reserve(struct xfs_mount *mp,
diff --git a/fs/xfs/xfs_log_cil.c b/fs/xfs/xfs_log_cil.c
index cfe97973ba36..5eb51fc5eb84 100644
--- a/fs/xfs/xfs_log_cil.c
+++ b/fs/xfs/xfs_log_cil.c
@@ -17,11 +17,9 @@
 
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
-#include "xfs_trans_priv.h"
-#include "xfs_log_priv.h"
+#include "xfs_log_format.h"
+#include "xfs_shared.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
@@ -29,6 +27,10 @@
 #include "xfs_alloc.h"
 #include "xfs_extent_busy.h"
 #include "xfs_discard.h"
+#include "xfs_trans.h"
+#include "xfs_trans_priv.h"
+#include "xfs_log.h"
+#include "xfs_log_priv.h"
 
 /*
  * Allocate a new ticket. Failing to get a new ticket makes it really hard to
@@ -711,6 +713,20 @@ xlog_cil_push_foreground(
         xlog_cil_push(log);
 }
 
+bool
+xlog_cil_empty(
+        struct xlog     *log)
+{
+        struct xfs_cil  *cil = log->l_cilp;
+        bool            empty = false;
+
+        spin_lock(&cil->xc_push_lock);
+        if (list_empty(&cil->xc_cil))
+                empty = true;
+        spin_unlock(&cil->xc_push_lock);
+        return empty;
+}
+
 /*
  * Commit a transaction with the given vector to the Committed Item List.
  *
diff --git a/fs/xfs/xfs_log_format.h b/fs/xfs/xfs_log_format.h
index ca7e28a8ed31..f0969c77bdbe 100644
--- a/fs/xfs/xfs_log_format.h
+++ b/fs/xfs/xfs_log_format.h
@@ -234,178 +234,6 @@ typedef struct xfs_trans_header {
         { XFS_LI_ICREATE,       "XFS_LI_ICREATE" }
 
 /*
- * Transaction types.  Used to distinguish types of buffers.
- */
-#define XFS_TRANS_SETATTR_NOT_SIZE      1
-#define XFS_TRANS_SETATTR_SIZE          2
-#define XFS_TRANS_INACTIVE              3
-#define XFS_TRANS_CREATE                4
-#define XFS_TRANS_CREATE_TRUNC          5
-#define XFS_TRANS_TRUNCATE_FILE         6
-#define XFS_TRANS_REMOVE                7
-#define XFS_TRANS_LINK                  8
-#define XFS_TRANS_RENAME                9
-#define XFS_TRANS_MKDIR                 10
-#define XFS_TRANS_RMDIR                 11
-#define XFS_TRANS_SYMLINK               12
-#define XFS_TRANS_SET_DMATTRS           13
-#define XFS_TRANS_GROWFS                14
-#define XFS_TRANS_STRAT_WRITE           15
-#define XFS_TRANS_DIOSTRAT              16
-/* 17 was XFS_TRANS_WRITE_SYNC */
-#define XFS_TRANS_WRITEID               18
-#define XFS_TRANS_ADDAFORK              19
-#define XFS_TRANS_ATTRINVAL             20
-#define XFS_TRANS_ATRUNCATE             21
-#define XFS_TRANS_ATTR_SET              22
-#define XFS_TRANS_ATTR_RM               23
-#define XFS_TRANS_ATTR_FLAG             24
-#define XFS_TRANS_CLEAR_AGI_BUCKET      25
-#define XFS_TRANS_QM_SBCHANGE           26
-/*
- * Dummy entries since we use the transaction type to index into the
- * trans_type[] in xlog_recover_print_trans_head()
- */
-#define XFS_TRANS_DUMMY1                27
-#define XFS_TRANS_DUMMY2                28
-#define XFS_TRANS_QM_QUOTAOFF           29
-#define XFS_TRANS_QM_DQALLOC            30
-#define XFS_TRANS_QM_SETQLIM            31
-#define XFS_TRANS_QM_DQCLUSTER          32
-#define XFS_TRANS_QM_QINOCREATE         33
-#define XFS_TRANS_QM_QUOTAOFF_END       34
-#define XFS_TRANS_SB_UNIT               35
-#define XFS_TRANS_FSYNC_TS              36
-#define XFS_TRANS_GROWFSRT_ALLOC        37
-#define XFS_TRANS_GROWFSRT_ZERO         38
-#define XFS_TRANS_GROWFSRT_FREE         39
-#define XFS_TRANS_SWAPEXT               40
-#define XFS_TRANS_SB_COUNT              41
-#define XFS_TRANS_CHECKPOINT            42
-#define XFS_TRANS_ICREATE               43
-#define XFS_TRANS_TYPE_MAX              43
-/* new transaction types need to be reflected in xfs_logprint(8) */
-
-#define XFS_TRANS_TYPES \
-        { XFS_TRANS_SETATTR_NOT_SIZE,   "SETATTR_NOT_SIZE" }, \
-        { XFS_TRANS_SETATTR_SIZE,       "SETATTR_SIZE" }, \
-        { XFS_TRANS_INACTIVE,           "INACTIVE" }, \
-        { XFS_TRANS_CREATE,             "CREATE" }, \
-        { XFS_TRANS_CREATE_TRUNC,       "CREATE_TRUNC" }, \
-        { XFS_TRANS_TRUNCATE_FILE,      "TRUNCATE_FILE" }, \
-        { XFS_TRANS_REMOVE,             "REMOVE" }, \
-        { XFS_TRANS_LINK,               "LINK" }, \
-        { XFS_TRANS_RENAME,             "RENAME" }, \
-        { XFS_TRANS_MKDIR,              "MKDIR" }, \
-        { XFS_TRANS_RMDIR,              "RMDIR" }, \
-        { XFS_TRANS_SYMLINK,            "SYMLINK" }, \
-        { XFS_TRANS_SET_DMATTRS,        "SET_DMATTRS" }, \
-        { XFS_TRANS_GROWFS,             "GROWFS" }, \
-        { XFS_TRANS_STRAT_WRITE,        "STRAT_WRITE" }, \
-        { XFS_TRANS_DIOSTRAT,           "DIOSTRAT" }, \
-        { XFS_TRANS_WRITEID,            "WRITEID" }, \
-        { XFS_TRANS_ADDAFORK,           "ADDAFORK" }, \
-        { XFS_TRANS_ATTRINVAL,          "ATTRINVAL" }, \
-        { XFS_TRANS_ATRUNCATE,          "ATRUNCATE" }, \
-        { XFS_TRANS_ATTR_SET,           "ATTR_SET" }, \
-        { XFS_TRANS_ATTR_RM,            "ATTR_RM" }, \
-        { XFS_TRANS_ATTR_FLAG,          "ATTR_FLAG" }, \
-        { XFS_TRANS_CLEAR_AGI_BUCKET,   "CLEAR_AGI_BUCKET" }, \
-        { XFS_TRANS_QM_SBCHANGE,        "QM_SBCHANGE" }, \
-        { XFS_TRANS_QM_QUOTAOFF,        "QM_QUOTAOFF" }, \
-        { XFS_TRANS_QM_DQALLOC,         "QM_DQALLOC" }, \
-        { XFS_TRANS_QM_SETQLIM,         "QM_SETQLIM" }, \
-        { XFS_TRANS_QM_DQCLUSTER,       "QM_DQCLUSTER" }, \
-        { XFS_TRANS_QM_QINOCREATE,      "QM_QINOCREATE" }, \
-        { XFS_TRANS_QM_QUOTAOFF_END,    "QM_QOFF_END" }, \
-        { XFS_TRANS_SB_UNIT,            "SB_UNIT" }, \
-        { XFS_TRANS_FSYNC_TS,           "FSYNC_TS" }, \
-        { XFS_TRANS_GROWFSRT_ALLOC,     "GROWFSRT_ALLOC" }, \
-        { XFS_TRANS_GROWFSRT_ZERO,      "GROWFSRT_ZERO" }, \
-        { XFS_TRANS_GROWFSRT_FREE,      "GROWFSRT_FREE" }, \
-        { XFS_TRANS_SWAPEXT,            "SWAPEXT" }, \
-        { XFS_TRANS_SB_COUNT,           "SB_COUNT" }, \
-        { XFS_TRANS_CHECKPOINT,         "CHECKPOINT" }, \
-        { XFS_TRANS_DUMMY1,             "DUMMY1" }, \
-        { XFS_TRANS_DUMMY2,             "DUMMY2" }, \
-        { XLOG_UNMOUNT_REC_TYPE,        "UNMOUNT" }
-
-/*
- * This structure is used to track log items associated with
- * a transaction.  It points to the log item and keeps some
- * flags to track the state of the log item.  It also tracks
- * the amount of space needed to log the item it describes
- * once we get to commit processing (see xfs_trans_commit()).
- */
-struct xfs_log_item_desc {
-        struct xfs_log_item     *lid_item;
-        struct list_head        lid_trans;
-        unsigned char           lid_flags;
-};
-
-#define XFS_LID_DIRTY           0x1
-
-/*
- * Values for t_flags.
- */
-#define XFS_TRANS_DIRTY         0x01    /* something needs to be logged */
-#define XFS_TRANS_SB_DIRTY      0x02    /* superblock is modified */
-#define XFS_TRANS_PERM_LOG_RES  0x04    /* xact took a permanent log res */
-#define XFS_TRANS_SYNC          0x08    /* make commit synchronous */
-#define XFS_TRANS_DQ_DIRTY      0x10    /* at least one dquot in trx dirty */
-#define XFS_TRANS_RESERVE       0x20    /* OK to use reserved data blocks */
-#define XFS_TRANS_FREEZE_PROT   0x40    /* Transaction has elevated writer
-                                           count in superblock */
-
-/*
- * Values for call flags parameter.
- */
-#define XFS_TRANS_RELEASE_LOG_RES       0x4
-#define XFS_TRANS_ABORT                 0x8
-
-/*
- * Field values for xfs_trans_mod_sb.
- */
-#define XFS_TRANS_SB_ICOUNT             0x00000001
-#define XFS_TRANS_SB_IFREE              0x00000002
-#define XFS_TRANS_SB_FDBLOCKS           0x00000004
-#define XFS_TRANS_SB_RES_FDBLOCKS       0x00000008
-#define XFS_TRANS_SB_FREXTENTS          0x00000010
-#define XFS_TRANS_SB_RES_FREXTENTS      0x00000020
-#define XFS_TRANS_SB_DBLOCKS            0x00000040
-#define XFS_TRANS_SB_AGCOUNT            0x00000080
-#define XFS_TRANS_SB_IMAXPCT            0x00000100
-#define XFS_TRANS_SB_REXTSIZE           0x00000200
-#define XFS_TRANS_SB_RBMBLOCKS          0x00000400
-#define XFS_TRANS_SB_RBLOCKS            0x00000800
-#define XFS_TRANS_SB_REXTENTS           0x00001000
-#define XFS_TRANS_SB_REXTSLOG           0x00002000
-
-/*
- * Here we centralize the specification of XFS meta-data buffer
- * reference count values.  This determine how hard the buffer
- * cache tries to hold onto the buffer.
- */
-#define XFS_AGF_REF             4
-#define XFS_AGI_REF             4
-#define XFS_AGFL_REF            3
-#define XFS_INO_BTREE_REF       3
-#define XFS_ALLOC_BTREE_REF     2
-#define XFS_BMAP_BTREE_REF      2
-#define XFS_DIR_BTREE_REF       2
-#define XFS_INO_REF             2
-#define XFS_ATTR_BTREE_REF      1
-#define XFS_DQUOT_REF           1
-
-/*
- * Flags for xfs_trans_ichgtime().
- */
-#define XFS_ICHGTIME_MOD        0x1     /* data fork modification timestamp */
-#define XFS_ICHGTIME_CHG        0x2     /* inode field change timestamp */
-#define XFS_ICHGTIME_CREATE     0x4     /* inode create timestamp */
-
-
-/*
  * Inode Log Item Format definitions.
  *
  * This is the structure used to lay out an inode log item in the
@@ -797,7 +625,6 @@ typedef struct xfs_qoff_logformat {
         char                    qf_pad[12];     /* padding for future */
 } xfs_qoff_logformat_t;
 
-
 /*
  * Disk quotas status in m_qflags, and also sb_qflags. 16 bits.
  */
@@ -849,8 +676,4 @@ struct xfs_icreate_log {
         __be32          icl_gen;        /* inode generation number to use */
 };
 
-int     xfs_log_calc_unit_res(struct xfs_mount *mp, int unit_bytes);
-int     xfs_log_calc_minimum_size(struct xfs_mount *);
-
-
 #endif /* __XFS_LOG_FORMAT_H__ */
diff --git a/fs/xfs/xfs_log_priv.h b/fs/xfs/xfs_log_priv.h
index 136654b9400d..9bc403a9e54f 100644
--- a/fs/xfs/xfs_log_priv.h
+++ b/fs/xfs/xfs_log_priv.h
@@ -22,6 +22,7 @@ struct xfs_buf;
 struct xlog;
 struct xlog_ticket;
 struct xfs_mount;
+struct xfs_log_callback;
 
 /*
  * Flags for log structure
@@ -227,8 +228,8 @@ typedef struct xlog_in_core {
 
         /* Callback structures need their own cacheline */
         spinlock_t              ic_callback_lock ____cacheline_aligned_in_smp;
-        xfs_log_callback_t      *ic_callback;
-        xfs_log_callback_t      **ic_callback_tail;
+        struct xfs_log_callback *ic_callback;
+        struct xfs_log_callback **ic_callback_tail;
 
         /* reference counts need their own cacheline */
         atomic_t                ic_refcnt ____cacheline_aligned_in_smp;
@@ -254,7 +255,7 @@ struct xfs_cil_ctx {
         int                     space_used;     /* aggregate size of regions */
         struct list_head        busy_extents;   /* busy extents in chkpt */
         struct xfs_log_vec      *lv_chain;      /* logvecs being pushed */
-        xfs_log_callback_t      log_cb;         /* completion callback hook. */
+        struct xfs_log_callback log_cb;         /* completion callback hook. */
         struct list_head        committing;     /* ctx committing list */
 };
 
@@ -514,12 +515,10 @@ xlog_assign_grant_head(atomic64_t *head, int cycle, int space)
 /*
  * Committed Item List interfaces
  */
-int
-xlog_cil_init(struct xlog *log);
-void
-xlog_cil_init_post_recovery(struct xlog *log);
-void
-xlog_cil_destroy(struct xlog *log);
+int     xlog_cil_init(struct xlog *log);
+void    xlog_cil_init_post_recovery(struct xlog *log);
+void    xlog_cil_destroy(struct xlog *log);
+bool    xlog_cil_empty(struct xlog *log);
 
 /*
  * CIL force routines
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index dabda9521b4b..b6b669df40f3 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -17,42 +17,34 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
 #include "xfs_inum.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_error.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_btree.h"
-#include "xfs_dinode.h"
+#include "xfs_da_format.h"
 #include "xfs_inode.h"
-#include "xfs_inode_item.h"
-#include "xfs_alloc.h"
-#include "xfs_ialloc.h"
+#include "xfs_trans.h"
+#include "xfs_log.h"
 #include "xfs_log_priv.h"
-#include "xfs_buf_item.h"
 #include "xfs_log_recover.h"
+#include "xfs_inode_item.h"
 #include "xfs_extfree_item.h"
 #include "xfs_trans_priv.h"
+#include "xfs_alloc.h"
+#include "xfs_ialloc.h"
 #include "xfs_quota.h"
 #include "xfs_cksum.h"
 #include "xfs_trace.h"
 #include "xfs_icache.h"
-#include "xfs_icreate_item.h"
-
-/* Need all the magic numbers and buffer ops structures from these headers */
-#include "xfs_symlink.h"
-#include "xfs_da_btree.h"
-#include "xfs_dir2_format.h"
+#include "xfs_bmap_btree.h"
+#include "xfs_dinode.h"
+#include "xfs_error.h"
 #include "xfs_dir2.h"
-#include "xfs_attr_leaf.h"
-#include "xfs_attr_remote.h"
 
 #define BLK_AVG(blk1, blk2)     ((blk1+blk2) >> 1)
 
@@ -305,9 +297,9 @@ xlog_header_check_dump(
         xfs_mount_t             *mp,
         xlog_rec_header_t       *head)
 {
-        xfs_debug(mp, "%s:  SB : uuid = %pU, fmt = %d\n",
+        xfs_debug(mp, "%s:  SB : uuid = %pU, fmt = %d",
                 __func__, &mp->m_sb.sb_uuid, XLOG_FMT);
-        xfs_debug(mp, "    log : uuid = %pU, fmt = %d\n",
+        xfs_debug(mp, "    log : uuid = %pU, fmt = %d",
                 &head->h_fs_uuid, be32_to_cpu(head->h_fmt));
 }
 #else
@@ -1585,6 +1577,7 @@ xlog_recover_add_to_trans(
                 "bad number of regions (%d) in inode log format",
                                   in_f->ilf_size);
                         ASSERT(0);
+                        kmem_free(ptr);
                         return XFS_ERROR(EIO);
                 }
 
@@ -1970,6 +1963,13 @@ xlog_recover_do_inode_buffer(
  * magic number.  If we don't recognise the magic number in the buffer, then
  * return a LSN of -1 so that the caller knows it was an unrecognised block and
  * so can recover the buffer.
+ *
+ * Note: we cannot rely solely on magic number matches to determine that the
+ * buffer has a valid LSN - we also need to verify that it belongs to this
+ * filesystem, so we need to extract the object's LSN and compare it to that
+ * which we read from the superblock. If the UUIDs don't match, then we've got a
+ * stale metadata block from an old filesystem instance that we need to recover
+ * over the top of.
  */
 static xfs_lsn_t
 xlog_recover_get_buf_lsn(
@@ -1980,6 +1980,8 @@ xlog_recover_get_buf_lsn(
         __uint16_t              magic16;
         __uint16_t              magicda;
         void                    *blk = bp->b_addr;
+        uuid_t                  *uuid;
+        xfs_lsn_t               lsn = -1;
 
         /* v4 filesystems always recover immediately */
         if (!xfs_sb_version_hascrc(&mp->m_sb))
@@ -1992,43 +1994,79 @@ xlog_recover_get_buf_lsn(
         case XFS_ABTB_MAGIC:
         case XFS_ABTC_MAGIC:
         case XFS_IBT_CRC_MAGIC:
-        case XFS_IBT_MAGIC:
-                return be64_to_cpu(
-                                ((struct xfs_btree_block *)blk)->bb_u.s.bb_lsn);
+        case XFS_IBT_MAGIC: {
+                struct xfs_btree_block *btb = blk;
+
+                lsn = be64_to_cpu(btb->bb_u.s.bb_lsn);
+                uuid = &btb->bb_u.s.bb_uuid;
+                break;
+        }
         case XFS_BMAP_CRC_MAGIC:
-        case XFS_BMAP_MAGIC:
-                return be64_to_cpu(
-                                ((struct xfs_btree_block *)blk)->bb_u.l.bb_lsn);
+        case XFS_BMAP_MAGIC: {
+                struct xfs_btree_block *btb = blk;
+
+                lsn = be64_to_cpu(btb->bb_u.l.bb_lsn);
+                uuid = &btb->bb_u.l.bb_uuid;
+                break;
+        }
         case XFS_AGF_MAGIC:
-                return be64_to_cpu(((struct xfs_agf *)blk)->agf_lsn);
+                lsn = be64_to_cpu(((struct xfs_agf *)blk)->agf_lsn);
+                uuid = &((struct xfs_agf *)blk)->agf_uuid;
+                break;
         case XFS_AGFL_MAGIC:
-                return be64_to_cpu(((struct xfs_agfl *)blk)->agfl_lsn);
+                lsn = be64_to_cpu(((struct xfs_agfl *)blk)->agfl_lsn);
+                uuid = &((struct xfs_agfl *)blk)->agfl_uuid;
+                break;
         case XFS_AGI_MAGIC:
-                return be64_to_cpu(((struct xfs_agi *)blk)->agi_lsn);
+                lsn = be64_to_cpu(((struct xfs_agi *)blk)->agi_lsn);
+                uuid = &((struct xfs_agi *)blk)->agi_uuid;
+                break;
         case XFS_SYMLINK_MAGIC:
-                return be64_to_cpu(((struct xfs_dsymlink_hdr *)blk)->sl_lsn);
+                lsn = be64_to_cpu(((struct xfs_dsymlink_hdr *)blk)->sl_lsn);
+                uuid = &((struct xfs_dsymlink_hdr *)blk)->sl_uuid;
+                break;
         case XFS_DIR3_BLOCK_MAGIC:
         case XFS_DIR3_DATA_MAGIC:
         case XFS_DIR3_FREE_MAGIC:
-                return be64_to_cpu(((struct xfs_dir3_blk_hdr *)blk)->lsn);
+                lsn = be64_to_cpu(((struct xfs_dir3_blk_hdr *)blk)->lsn);
+                uuid = &((struct xfs_dir3_blk_hdr *)blk)->uuid;
+                break;
         case XFS_ATTR3_RMT_MAGIC:
-                return be64_to_cpu(((struct xfs_attr3_rmt_hdr *)blk)->rm_lsn);
+                lsn = be64_to_cpu(((struct xfs_attr3_rmt_hdr *)blk)->rm_lsn);
+                uuid = &((struct xfs_attr3_rmt_hdr *)blk)->rm_uuid;
+                break;
         case XFS_SB_MAGIC:
-                return be64_to_cpu(((struct xfs_dsb *)blk)->sb_lsn);
+                lsn = be64_to_cpu(((struct xfs_dsb *)blk)->sb_lsn);
+                uuid = &((struct xfs_dsb *)blk)->sb_uuid;
+                break;
         default:
                 break;
         }
 
+        if (lsn != (xfs_lsn_t)-1) {
+                if (!uuid_equal(&mp->m_sb.sb_uuid, uuid))
+                        goto recover_immediately;
+                return lsn;
+        }
+
         magicda = be16_to_cpu(((struct xfs_da_blkinfo *)blk)->magic);
         switch (magicda) {
         case XFS_DIR3_LEAF1_MAGIC:
         case XFS_DIR3_LEAFN_MAGIC:
         case XFS_DA3_NODE_MAGIC:
-                return be64_to_cpu(((struct xfs_da3_blkinfo *)blk)->lsn);
+                lsn = be64_to_cpu(((struct xfs_da3_blkinfo *)blk)->lsn);
+                uuid = &((struct xfs_da3_blkinfo *)blk)->uuid;
+                break;
         default:
                 break;
         }
 
+        if (lsn != (xfs_lsn_t)-1) {
+                if (!uuid_equal(&mp->m_sb.sb_uuid, uuid))
+                        goto recover_immediately;
+                return lsn;
+        }
+
         /*
          * We do individual object checks on dquot and inode buffers as they
          * have their own individual LSN records. Also, we could have a stale
@@ -2316,7 +2354,7 @@ xlog_recover_do_reg_buffer(
                                         item->ri_buf[i].i_len, __func__);
                                 goto next;
                         }
-                        error = xfs_qm_dqcheck(mp, item->ri_buf[i].i_addr,
+                        error = xfs_dqcheck(mp, item->ri_buf[i].i_addr,
                                                -1, 0, XFS_QMOPT_DOWARN,
                                                "dquot_buf_recover");
                         if (error)
@@ -2348,133 +2386,6 @@ xlog_recover_do_reg_buffer(
 }
 
 /*
- * Do some primitive error checking on ondisk dquot data structures.
- */
-int
-xfs_qm_dqcheck(
-        struct xfs_mount *mp,
-        xfs_disk_dquot_t *ddq,
-        xfs_dqid_t       id,
-        uint             type,    /* used only when IO_dorepair is true */
-        uint             flags,
-        char             *str)
-{
-        xfs_dqblk_t      *d = (xfs_dqblk_t *)ddq;
-        int             errs = 0;
-
-        /*
-         * We can encounter an uninitialized dquot buffer for 2 reasons:
-         * 1. If we crash while deleting the quotainode(s), and those blks got
-         *    used for user data. This is because we take the path of regular
-         *    file deletion; however, the size field of quotainodes is never
-         *    updated, so all the tricks that we play in itruncate_finish
-         *    don't quite matter.
-         *
-         * 2. We don't play the quota buffers when there's a quotaoff logitem.
-         *    But the allocation will be replayed so we'll end up with an
-         *    uninitialized quota block.
-         *
-         * This is all fine; things are still consistent, and we haven't lost
-         * any quota information. Just don't complain about bad dquot blks.
-         */
-        if (ddq->d_magic != cpu_to_be16(XFS_DQUOT_MAGIC)) {
-                if (flags & XFS_QMOPT_DOWARN)
-                        xfs_alert(mp,
-                        "%s : XFS dquot ID 0x%x, magic 0x%x != 0x%x",
-                        str, id, be16_to_cpu(ddq->d_magic), XFS_DQUOT_MAGIC);
-                errs++;
-        }
-        if (ddq->d_version != XFS_DQUOT_VERSION) {
-                if (flags & XFS_QMOPT_DOWARN)
-                        xfs_alert(mp,
-                        "%s : XFS dquot ID 0x%x, version 0x%x != 0x%x",
-                        str, id, ddq->d_version, XFS_DQUOT_VERSION);
-                errs++;
-        }
-
-        if (ddq->d_flags != XFS_DQ_USER &&
-            ddq->d_flags != XFS_DQ_PROJ &&
-            ddq->d_flags != XFS_DQ_GROUP) {
-                if (flags & XFS_QMOPT_DOWARN)
-                        xfs_alert(mp,
-                        "%s : XFS dquot ID 0x%x, unknown flags 0x%x",
-                        str, id, ddq->d_flags);
-                errs++;
-        }
-
-        if (id != -1 && id != be32_to_cpu(ddq->d_id)) {
-                if (flags & XFS_QMOPT_DOWARN)
-                        xfs_alert(mp,
-                        "%s : ondisk-dquot 0x%p, ID mismatch: "
-                        "0x%x expected, found id 0x%x",
-                        str, ddq, id, be32_to_cpu(ddq->d_id));
-                errs++;
-        }
-
-        if (!errs && ddq->d_id) {
-                if (ddq->d_blk_softlimit &&
-                    be64_to_cpu(ddq->d_bcount) >
-                                be64_to_cpu(ddq->d_blk_softlimit)) {
-                        if (!ddq->d_btimer) {
-                                if (flags & XFS_QMOPT_DOWARN)
-                                        xfs_alert(mp,
-                        "%s : Dquot ID 0x%x (0x%p) BLK TIMER NOT STARTED",
-                                        str, (int)be32_to_cpu(ddq->d_id), ddq);
-                                errs++;
-                        }
-                }
-                if (ddq->d_ino_softlimit &&
-                    be64_to_cpu(ddq->d_icount) >
-                                be64_to_cpu(ddq->d_ino_softlimit)) {
-                        if (!ddq->d_itimer) {
-                                if (flags & XFS_QMOPT_DOWARN)
-                                        xfs_alert(mp,
-                        "%s : Dquot ID 0x%x (0x%p) INODE TIMER NOT STARTED",
-                                        str, (int)be32_to_cpu(ddq->d_id), ddq);
-                                errs++;
-                        }
-                }
-                if (ddq->d_rtb_softlimit &&
-                    be64_to_cpu(ddq->d_rtbcount) >
-                                be64_to_cpu(ddq->d_rtb_softlimit)) {
-                        if (!ddq->d_rtbtimer) {
-                                if (flags & XFS_QMOPT_DOWARN)
-                                        xfs_alert(mp,
-                        "%s : Dquot ID 0x%x (0x%p) RTBLK TIMER NOT STARTED",
-                                        str, (int)be32_to_cpu(ddq->d_id), ddq);
-                                errs++;
-                        }
-                }
-        }
-
-        if (!errs || !(flags & XFS_QMOPT_DQREPAIR))
-                return errs;
-
-        if (flags & XFS_QMOPT_DOWARN)
-                xfs_notice(mp, "Re-initializing dquot ID 0x%x", id);
-
-        /*
-         * Typically, a repair is only requested by quotacheck.
-         */
-        ASSERT(id != -1);
-        ASSERT(flags & XFS_QMOPT_DQREPAIR);
-        memset(d, 0, sizeof(xfs_dqblk_t));
-
-        d->dd_diskdq.d_magic = cpu_to_be16(XFS_DQUOT_MAGIC);
-        d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
-        d->dd_diskdq.d_flags = type;
-        d->dd_diskdq.d_id = cpu_to_be32(id);
-
-        if (xfs_sb_version_hascrc(&mp->m_sb)) {
-                uuid_copy(&d->dd_uuid, &mp->m_sb.sb_uuid);
-                xfs_update_cksum((char *)d, sizeof(struct xfs_dqblk),
-                                 XFS_DQUOT_CRC_OFF);
-        }
-
-        return errs;
-}
-
-/*
  * Perform a dquot buffer recovery.
  * Simple algorithm: if we have found a QUOTAOFF log item of the same type
  * (ie. USR or GRP), then just toss this buffer away; don't recover it.
@@ -3079,7 +2990,7 @@ xlog_recover_dquot_pass2(
          */
         dq_f = item->ri_buf[0].i_addr;
         ASSERT(dq_f);
-        error = xfs_qm_dqcheck(mp, recddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
+        error = xfs_dqcheck(mp, recddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
                            "xlog_recover_dquot_pass2 (log copy)");
         if (error)
                 return XFS_ERROR(EIO);
@@ -3099,7 +3010,7 @@ xlog_recover_dquot_pass2(
          * was among a chunk of dquots created earlier, and we did some
          * minimal initialization then.
          */
-        error = xfs_qm_dqcheck(mp, ddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
+        error = xfs_dqcheck(mp, ddq, dq_f->qlf_id, 0, XFS_QMOPT_DOWARN,
                            "xlog_recover_dquot_pass2");
         if (error) {
                 xfs_buf_relse(bp);
@@ -4031,7 +3942,7 @@ xlog_unpack_data_crc(
         if (crc != rhead->h_crc) {
                 if (rhead->h_crc || xfs_sb_version_hascrc(&log->l_mp->m_sb)) {
                         xfs_alert(log->l_mp,
-                "log record CRC mismatch: found 0x%x, expected 0x%x.\n",
+                "log record CRC mismatch: found 0x%x, expected 0x%x.",
                                         le32_to_cpu(rhead->h_crc),
                                         le32_to_cpu(crc));
                         xfs_hex_dump(dp, 32);
diff --git a/fs/xfs/xfs_log_rlimit.c b/fs/xfs/xfs_log_rlimit.c
index bbcec0bbc12d..2af1a0a4d0f1 100644
--- a/fs/xfs/xfs_log_rlimit.c
+++ b/fs/xfs/xfs_log_rlimit.c
@@ -17,16 +17,19 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_ag.h"
 #include "xfs_sb.h"
 #include "xfs_mount.h"
+#include "xfs_da_format.h"
 #include "xfs_trans_space.h"
-#include "xfs_bmap_btree.h"
 #include "xfs_inode.h"
 #include "xfs_da_btree.h"
 #include "xfs_attr_leaf.h"
+#include "xfs_bmap_btree.h"
 
 /*
  * Calculate the maximum length in bytes that would be required for a local
diff --git a/fs/xfs/xfs_message.c b/fs/xfs/xfs_message.c
index 9163dc140532..63ca2f0420b1 100644
--- a/fs/xfs/xfs_message.c
+++ b/fs/xfs/xfs_message.c
@@ -17,9 +17,8 @@
 
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 5dcc68019d1b..da88f167af78 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -17,35 +17,30 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
 #include "xfs_inum.h"
-#include "xfs_trans.h"
-#include "xfs_trans_priv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_da_btree.h"
-#include "xfs_dir2_format.h"
-#include "xfs_dir2.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
+#include "xfs_da_format.h"
 #include "xfs_inode.h"
-#include "xfs_btree.h"
+#include "xfs_dir2.h"
 #include "xfs_ialloc.h"
 #include "xfs_alloc.h"
 #include "xfs_rtalloc.h"
 #include "xfs_bmap.h"
+#include "xfs_trans.h"
+#include "xfs_trans_priv.h"
+#include "xfs_log.h"
 #include "xfs_error.h"
 #include "xfs_quota.h"
 #include "xfs_fsops.h"
 #include "xfs_trace.h"
 #include "xfs_icache.h"
-#include "xfs_cksum.h"
-#include "xfs_buf_item.h"
 
 
 #ifdef HAVE_PERCPU_SB
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index 1fa0584b5627..1d8101a10d8e 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -26,6 +26,7 @@ struct xfs_mru_cache;
 struct xfs_nameops;
 struct xfs_ail;
 struct xfs_quotainfo;
+struct xfs_dir_ops;
 
 #ifdef HAVE_PERCPU_SB
 
@@ -148,6 +149,8 @@ typedef struct xfs_mount {
         int                     m_dir_magicpct; /* 37% of the dir blocksize */
         __uint8_t               m_sectbb_log;   /* sectlog - BBSHIFT */
         const struct xfs_nameops *m_dirnameops; /* vector of dir name ops */
+        const struct xfs_dir_ops *m_dir_inode_ops; /* vector of dir inode ops */
+        const struct xfs_dir_ops *m_nondir_inode_ops; /* !dir inode ops */
         int                     m_dirblksize;   /* directory block sz--bytes */
         int                     m_dirblkfsbs;   /* directory block sz--fsbs */
         xfs_dablk_t             m_dirdatablk;   /* blockno of dir data v2 */
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 3e6c2e6c9cd2..14a4996cfec6 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -17,31 +17,28 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_alloc.h"
-#include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_ialloc.h"
 #include "xfs_itable.h"
-#include "xfs_rtalloc.h"
+#include "xfs_quota.h"
 #include "xfs_error.h"
 #include "xfs_bmap.h"
-#include "xfs_attr.h"
-#include "xfs_buf_item.h"
+#include "xfs_bmap_btree.h"
+#include "xfs_trans.h"
 #include "xfs_trans_space.h"
 #include "xfs_qm.h"
 #include "xfs_trace.h"
 #include "xfs_icache.h"
 #include "xfs_cksum.h"
+#include "xfs_dinode.h"
 
 /*
  * The global quota manager. There is only one of these for the entire
@@ -664,20 +661,6 @@ xfs_qm_dqdetach(
         }
 }
 
-int
-xfs_qm_calc_dquots_per_chunk(
-        struct xfs_mount        *mp,
-        unsigned int            nbblks) /* basic block units */
-{
-        unsigned int    ndquots;
-
-        ASSERT(nbblks > 0);
-        ndquots = BBTOB(nbblks);
-        do_div(ndquots, sizeof(xfs_dqblk_t));
-
-        return ndquots;
-}
-
 struct xfs_qm_isolate {
         struct list_head        buffers;
         struct list_head        dispose;
@@ -858,7 +841,7 @@ xfs_qm_init_quotainfo(
 
         /* Precalc some constants */
         qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
-        qinf->qi_dqperchunk = xfs_qm_calc_dquots_per_chunk(mp,
+        qinf->qi_dqperchunk = xfs_calc_dquots_per_chunk(mp,
                                                         qinf->qi_dqchunklen);
 
         mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);
@@ -1092,10 +1075,10 @@ xfs_qm_reset_dqcounts(
                 /*
                  * Do a sanity check, and if needed, repair the dqblk. Don't
                  * output any warnings because it's perfectly possible to
-                 * find uninitialised dquot blks. See comment in xfs_qm_dqcheck.
+                 * find uninitialised dquot blks. See comment in xfs_dqcheck.
                  */
-                (void) xfs_qm_dqcheck(mp, ddq, id+j, type, XFS_QMOPT_DQREPAIR,
-                                      "xfs_quotacheck");
+                xfs_dqcheck(mp, ddq, id+j, type, XFS_QMOPT_DQREPAIR,
+                            "xfs_quotacheck");
                 ddq->d_bcount = 0;
                 ddq->d_icount = 0;
                 ddq->d_rtbcount = 0;
diff --git a/fs/xfs/xfs_qm.h b/fs/xfs/xfs_qm.h
index 2b602df9c242..a788b66a5cb1 100644
--- a/fs/xfs/xfs_qm.h
+++ b/fs/xfs/xfs_qm.h
@@ -103,8 +103,6 @@ xfs_dq_to_quota_inode(struct xfs_dquot *dqp)
         return NULL;
 }
 
-extern int      xfs_qm_calc_dquots_per_chunk(struct xfs_mount *mp,
-                                             unsigned int nbblks);
 extern void     xfs_trans_mod_dquot(struct xfs_trans *,
                                         struct xfs_dquot *, uint, long);
 extern int      xfs_trans_reserve_quota_bydquots(struct xfs_trans *,
diff --git a/fs/xfs/xfs_qm_bhv.c b/fs/xfs/xfs_qm_bhv.c
index 3af50ccdfac1..e9be63abd8d2 100644
--- a/fs/xfs/xfs_qm_bhv.c
+++ b/fs/xfs/xfs_qm_bhv.c
@@ -18,21 +18,15 @@
 #include "xfs.h"
 #include "xfs_fs.h"
 #include "xfs_format.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_alloc.h"
 #include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
 #include "xfs_inode.h"
-#include "xfs_itable.h"
-#include "xfs_bmap.h"
-#include "xfs_rtalloc.h"
 #include "xfs_error.h"
-#include "xfs_attr.h"
-#include "xfs_buf_item.h"
+#include "xfs_trans.h"
 #include "xfs_qm.h"
 
 
diff --git a/fs/xfs/xfs_qm_syscalls.c b/fs/xfs/xfs_qm_syscalls.c
index 8174aad0b388..437c9198031a 100644
--- a/fs/xfs/xfs_qm_syscalls.c
+++ b/fs/xfs/xfs_qm_syscalls.c
@@ -20,24 +20,18 @@
 
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_alloc.h"
-#include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
 #include "xfs_inode.h"
-#include "xfs_inode_item.h"
-#include "xfs_itable.h"
-#include "xfs_bmap.h"
-#include "xfs_rtalloc.h"
+#include "xfs_trans.h"
 #include "xfs_error.h"
-#include "xfs_attr.h"
-#include "xfs_buf_item.h"
+#include "xfs_quota.h"
 #include "xfs_qm.h"
 #include "xfs_trace.h"
 #include "xfs_icache.h"
@@ -287,7 +281,7 @@ xfs_qm_scall_trunc_qfiles(
         int             error = 0, error2 = 0;
 
         if (!xfs_sb_version_hasquota(&mp->m_sb) || flags == 0) {
-                xfs_debug(mp, "%s: flags=%x m_qflags=%x\n",
+                xfs_debug(mp, "%s: flags=%x m_qflags=%x",
                         __func__, flags, mp->m_qflags);
                 return XFS_ERROR(EINVAL);
         }
@@ -325,7 +319,7 @@ xfs_qm_scall_quotaon(
         sbflags = 0;
 
         if (flags == 0) {
-                xfs_debug(mp, "%s: zero flags, m_qflags=%x\n",
+                xfs_debug(mp, "%s: zero flags, m_qflags=%x",
                         __func__, mp->m_qflags);
                 return XFS_ERROR(EINVAL);
         }
@@ -348,7 +342,7 @@ xfs_qm_scall_quotaon(
              (mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) == 0 &&
              (flags & XFS_PQUOTA_ENFD))) {
                 xfs_debug(mp,
-                        "%s: Can't enforce without acct, flags=%x sbflags=%x\n",
+                        "%s: Can't enforce without acct, flags=%x sbflags=%x",
                         __func__, flags, mp->m_sb.sb_qflags);
                 return XFS_ERROR(EINVAL);
         }
@@ -648,7 +642,7 @@ xfs_qm_scall_setqlim(
                         q->qi_bsoftlimit = soft;
                 }
         } else {
-                xfs_debug(mp, "blkhard %Ld < blksoft %Ld\n", hard, soft);
+                xfs_debug(mp, "blkhard %Ld < blksoft %Ld", hard, soft);
         }
         hard = (newlim->d_fieldmask & FS_DQ_RTBHARD) ?
                 (xfs_qcnt_t) XFS_BB_TO_FSB(mp, newlim->d_rtb_hardlimit) :
@@ -664,7 +658,7 @@ xfs_qm_scall_setqlim(
                         q->qi_rtbsoftlimit = soft;
                 }
         } else {
-                xfs_debug(mp, "rtbhard %Ld < rtbsoft %Ld\n", hard, soft);
+                xfs_debug(mp, "rtbhard %Ld < rtbsoft %Ld", hard, soft);
         }
 
         hard = (newlim->d_fieldmask & FS_DQ_IHARD) ?
@@ -681,7 +675,7 @@ xfs_qm_scall_setqlim(
                         q->qi_isoftlimit = soft;
                 }
         } else {
-                xfs_debug(mp, "ihard %Ld < isoft %Ld\n", hard, soft);
+                xfs_debug(mp, "ihard %Ld < isoft %Ld", hard, soft);
         }
 
         /*
diff --git a/fs/xfs/xfs_quota.h b/fs/xfs/xfs_quota.h
index e7d84d2d8683..5376dd406ba2 100644
--- a/fs/xfs/xfs_quota.h
+++ b/fs/xfs/xfs_quota.h
@@ -150,10 +150,6 @@ static inline int xfs_trans_reserve_quota_bydquots(struct xfs_trans *tp,
         xfs_trans_reserve_quota_bydquots(tp, mp, ud, gd, pd, nb, ni, \
                                 f | XFS_QMOPT_RES_REGBLKS)
 
-extern int xfs_qm_dqcheck(struct xfs_mount *, xfs_disk_dquot_t *,
-                                xfs_dqid_t, uint, uint, char *);
 extern int xfs_mount_reset_sbqflags(struct xfs_mount *);
 
-extern const struct xfs_buf_ops xfs_dquot_buf_ops;
-
 #endif  /* __XFS_QUOTA_H__ */
diff --git a/fs/xfs/xfs_quota_defs.h b/fs/xfs/xfs_quota_defs.h
index e6b0d6e1f4f2..b3b2b1065c0f 100644
--- a/fs/xfs/xfs_quota_defs.h
+++ b/fs/xfs/xfs_quota_defs.h
@@ -154,4 +154,8 @@ typedef __uint16_t	xfs_qwarncnt_t;
                 (XFS_QMOPT_UQUOTA | XFS_QMOPT_PQUOTA | XFS_QMOPT_GQUOTA)
 #define XFS_QMOPT_RESBLK_MASK   (XFS_QMOPT_RES_REGBLKS | XFS_QMOPT_RES_RTBLKS)
 
+extern int xfs_dqcheck(struct xfs_mount *mp, xfs_disk_dquot_t *ddq,
+                       xfs_dqid_t id, uint type, uint flags, char *str);
+extern int xfs_calc_dquots_per_chunk(struct xfs_mount *mp, unsigned int nbblks);
+
 #endif  /* __XFS_QUOTA_H__ */
diff --git a/fs/xfs/xfs_quotaops.c b/fs/xfs/xfs_quotaops.c
index 1326d81596c2..af33cafe69b6 100644
--- a/fs/xfs/xfs_quotaops.c
+++ b/fs/xfs/xfs_quotaops.c
@@ -17,15 +17,14 @@
  */
 #include "xfs.h"
 #include "xfs_format.h"
+#include "xfs_log_format.h"
 #include "xfs_trans_resv.h"
-#include "xfs_log.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_inode.h"
 #include "xfs_quota.h"
 #include "xfs_trans.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_inode.h"
 #include "xfs_qm.h"
 #include <linux/quota.h>
 
diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index 6f9e63c9fc26..a6a76b2b6a85 100644
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -17,172 +17,260 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
-#include "xfs_alloc.h"
 #include "xfs_bmap.h"
 #include "xfs_bmap_util.h"
-#include "xfs_rtalloc.h"
-#include "xfs_fsops.h"
+#include "xfs_bmap_btree.h"
+#include "xfs_alloc.h"
 #include "xfs_error.h"
-#include "xfs_inode_item.h"
+#include "xfs_trans.h"
 #include "xfs_trans_space.h"
 #include "xfs_trace.h"
 #include "xfs_buf.h"
 #include "xfs_icache.h"
+#include "xfs_dinode.h"
+#include "xfs_rtalloc.h"
 
 
 /*
- * Prototypes for internal functions.
+ * Read and return the summary information for a given extent size,
+ * bitmap block combination.
+ * Keeps track of a current summary block, so we don't keep reading
+ * it from the buffer cache.
  */
+STATIC int                              /* error */
+xfs_rtget_summary(
+        xfs_mount_t     *mp,            /* file system mount structure */
+        xfs_trans_t     *tp,            /* transaction pointer */
+        int             log,            /* log2 of extent size */
+        xfs_rtblock_t   bbno,           /* bitmap block number */
+        xfs_buf_t       **rbpp,         /* in/out: summary block buffer */
+        xfs_fsblock_t   *rsb,           /* in/out: summary block number */
+        xfs_suminfo_t   *sum)           /* out: summary info for this block */
+{
+        xfs_buf_t       *bp;            /* buffer for summary block */
+        int             error;          /* error value */
+        xfs_fsblock_t   sb;             /* summary fsblock */
+        int             so;             /* index into the summary file */
+        xfs_suminfo_t   *sp;            /* pointer to returned data */
 
+        /*
+         * Compute entry number in the summary file.
+         */
+        so = XFS_SUMOFFS(mp, log, bbno);
+        /*
+         * Compute the block number in the summary file.
+         */
+        sb = XFS_SUMOFFSTOBLOCK(mp, so);
+        /*
+         * If we have an old buffer, and the block number matches, use that.
+         */
+        if (rbpp && *rbpp && *rsb == sb)
+                bp = *rbpp;
+        /*
+         * Otherwise we have to get the buffer.
+         */
+        else {
+                /*
+                 * If there was an old one, get rid of it first.
+                 */
+                if (rbpp && *rbpp)
+                        xfs_trans_brelse(tp, *rbpp);
+                error = xfs_rtbuf_get(mp, tp, sb, 1, &bp);
+                if (error) {
+                        return error;
+                }
+                /*
+                 * Remember this buffer and block for the next call.
+                 */
+                if (rbpp) {
+                        *rbpp = bp;
+                        *rsb = sb;
+                }
+        }
+        /*
+         * Point to the summary information & copy it out.
+         */
+        sp = XFS_SUMPTR(mp, bp, so);
+        *sum = *sp;
+        /*
+         * Drop the buffer if we're not asked to remember it.
+         */
+        if (!rbpp)
+                xfs_trans_brelse(tp, bp);
+        return 0;
+}
 
-STATIC int xfs_rtallocate_range(xfs_mount_t *, xfs_trans_t *, xfs_rtblock_t,
-                xfs_extlen_t, xfs_buf_t **, xfs_fsblock_t *);
-STATIC int xfs_rtany_summary(xfs_mount_t *, xfs_trans_t *, int, int,
-                xfs_rtblock_t, xfs_buf_t **, xfs_fsblock_t *, int *);
-STATIC int xfs_rtcheck_range(xfs_mount_t *, xfs_trans_t *, xfs_rtblock_t,
-                xfs_extlen_t, int, xfs_rtblock_t *, int *);
-STATIC int xfs_rtfind_back(xfs_mount_t *, xfs_trans_t *, xfs_rtblock_t,
-                xfs_rtblock_t, xfs_rtblock_t *);
-STATIC int xfs_rtfind_forw(xfs_mount_t *, xfs_trans_t *, xfs_rtblock_t,
-                xfs_rtblock_t, xfs_rtblock_t *);
-STATIC int xfs_rtget_summary( xfs_mount_t *, xfs_trans_t *, int,
-                xfs_rtblock_t, xfs_buf_t **, xfs_fsblock_t *, xfs_suminfo_t *);
-STATIC int xfs_rtmodify_range(xfs_mount_t *, xfs_trans_t *, xfs_rtblock_t,
-                xfs_extlen_t, int);
-STATIC int xfs_rtmodify_summary(xfs_mount_t *, xfs_trans_t *, int,
-                xfs_rtblock_t, int, xfs_buf_t **, xfs_fsblock_t *);
-
-/*
- * Internal functions.
- */
 
 /*
- * Allocate space to the bitmap or summary file, and zero it, for growfs.
+ * Return whether there are any free extents in the size range given
+ * by low and high, for the bitmap block bbno.
  */
 STATIC int                              /* error */
-xfs_growfs_rt_alloc(
-        xfs_mount_t     *mp,            /* file system mount point */
-        xfs_extlen_t    oblocks,        /* old count of blocks */
-        xfs_extlen_t    nblocks,        /* new count of blocks */
-        xfs_inode_t     *ip)            /* inode (bitmap/summary) */
+xfs_rtany_summary(
+        xfs_mount_t     *mp,            /* file system mount structure */
+        xfs_trans_t     *tp,            /* transaction pointer */
+        int             low,            /* low log2 extent size */
+        int             high,           /* high log2 extent size */
+        xfs_rtblock_t   bbno,           /* bitmap block number */
+        xfs_buf_t       **rbpp,         /* in/out: summary block buffer */
+        xfs_fsblock_t   *rsb,           /* in/out: summary block number */
+        int             *stat)          /* out: any good extents here? */
 {
-        xfs_fileoff_t   bno;            /* block number in file */
-        xfs_buf_t       *bp;            /* temporary buffer for zeroing */
-        int             committed;      /* transaction committed flag */
-        xfs_daddr_t     d;              /* disk block address */
-        int             error;          /* error return value */
-        xfs_fsblock_t   firstblock;     /* first block allocated in xaction */
-        xfs_bmap_free_t flist;          /* list of freed blocks */
-        xfs_fsblock_t   fsbno;          /* filesystem block for bno */
-        xfs_bmbt_irec_t map;            /* block map output */
-        int             nmap;           /* number of block maps */
-        int             resblks;        /* space reservation */
+        int             error;          /* error value */
+        int             log;            /* loop counter, log2 of ext. size */
+        xfs_suminfo_t   sum;            /* summary data */
 
         /*
-         * Allocate space to the file, as necessary.
+         * Loop over logs of extent sizes.  Order is irrelevant.
          */
-        while (oblocks < nblocks) {
-                int             cancelflags = 0;
-                xfs_trans_t     *tp;
-
-                tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFSRT_ALLOC);
-                resblks = XFS_GROWFSRT_SPACE_RES(mp, nblocks - oblocks);
+        for (log = low; log <= high; log++) {
                 /*
-                 * Reserve space & log for one extent added to the file.
+                 * Get one summary datum.
                  */
-                error = xfs_trans_reserve(tp, &M_RES(mp)->tr_growdata,
-                                          resblks, 0);
-                if (error)
-                        goto error_cancel;
-                cancelflags = XFS_TRANS_RELEASE_LOG_RES;
+                error = xfs_rtget_summary(mp, tp, log, bbno, rbpp, rsb, &sum);
+                if (error) {
+                        return error;
+                }
                 /*
-                 * Lock the inode.
+                 * If there are any, return success.
                  */
-                xfs_ilock(ip, XFS_ILOCK_EXCL);
-                xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
+                if (sum) {
+                        *stat = 1;
+                        return 0;
+                }
+        }
+        /*
+         * Found nothing, return failure.
+         */
+        *stat = 0;
+        return 0;
+}
 
-                xfs_bmap_init(&flist, &firstblock);
-                /*
-                 * Allocate blocks to the bitmap file.
-                 */
-                nmap = 1;
-                cancelflags |= XFS_TRANS_ABORT;
-                error = xfs_bmapi_write(tp, ip, oblocks, nblocks - oblocks,
-                                        XFS_BMAPI_METADATA, &firstblock,
-                                        resblks, &map, &nmap, &flist);
-                if (!error && nmap < 1)
-                        error = XFS_ERROR(ENOSPC);
-                if (error)
-                        goto error_cancel;
-                /*
-                 * Free any blocks freed up in the transaction, then commit.
-                 */
-                error = xfs_bmap_finish(&tp, &flist, &committed);
-                if (error)
-                        goto error_cancel;
-                error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
-                if (error)
-                        goto error;
-                /*
-                 * Now we need to clear the allocated blocks.
-                 * Do this one block per transaction, to keep it simple.
-                 */
-                cancelflags = 0;
-                for (bno = map.br_startoff, fsbno = map.br_startblock;
-                     bno < map.br_startoff + map.br_blockcount;
-                     bno++, fsbno++) {
-                        tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFSRT_ZERO);
-                        /*
-                         * Reserve log for one block zeroing.
-                         */
-                        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_growrtzero,
-                                                  0, 0);
+
+/*
+ * Copy and transform the summary file, given the old and new
+ * parameters in the mount structures.
+ */
+STATIC int                              /* error */
+xfs_rtcopy_summary(
+        xfs_mount_t     *omp,           /* old file system mount point */
+        xfs_mount_t     *nmp,           /* new file system mount point */
+        xfs_trans_t     *tp)            /* transaction pointer */
+{
+        xfs_rtblock_t   bbno;           /* bitmap block number */
+        xfs_buf_t       *bp;            /* summary buffer */
+        int             error;          /* error return value */
+        int             log;            /* summary level number (log length) */
+        xfs_suminfo_t   sum;            /* summary data */
+        xfs_fsblock_t   sumbno;         /* summary block number */
+
+        bp = NULL;
+        for (log = omp->m_rsumlevels - 1; log >= 0; log--) {
+                for (bbno = omp->m_sb.sb_rbmblocks - 1;
+                     (xfs_srtblock_t)bbno >= 0;
+                     bbno--) {
+                        error = xfs_rtget_summary(omp, tp, log, bbno, &bp,
+                                &sumbno, &sum);
                         if (error)
-                                goto error_cancel;
-                        /*
-                         * Lock the bitmap inode.
-                         */
-                        xfs_ilock(ip, XFS_ILOCK_EXCL);
-                        xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
-                        /*
-                         * Get a buffer for the block.
-                         */
-                        d = XFS_FSB_TO_DADDR(mp, fsbno);
-                        bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
-                                mp->m_bsize, 0);
-                        if (bp == NULL) {
-                                error = XFS_ERROR(EIO);
-error_cancel:
-                                xfs_trans_cancel(tp, cancelflags);
-                                goto error;
-                        }
-                        memset(bp->b_addr, 0, mp->m_sb.sb_blocksize);
-                        xfs_trans_log_buf(tp, bp, 0, mp->m_sb.sb_blocksize - 1);
-                        /*
-                         * Commit the transaction.
-                         */
-                        error = xfs_trans_commit(tp, 0);
+                                return error;
+                        if (sum == 0)
+                                continue;
+                        error = xfs_rtmodify_summary(omp, tp, log, bbno, -sum,
+                                &bp, &sumbno);
                         if (error)
-                                goto error;
+                                return error;
+                        error = xfs_rtmodify_summary(nmp, tp, log, bbno, sum,
+                                &bp, &sumbno);
+                        if (error)
+                                return error;
+                        ASSERT(sum > 0);
                 }
-                /*
-                 * Go on to the next extent, if any.
-                 */
-                oblocks = map.br_startoff + map.br_blockcount;
         }
         return 0;
+}
+/*
+ * Mark an extent specified by start and len allocated.
+ * Updates all the summary information as well as the bitmap.
+ */
+STATIC int                              /* error */
+xfs_rtallocate_range(
+        xfs_mount_t     *mp,            /* file system mount point */
+        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_rtblock_t   start,          /* start block to allocate */
+        xfs_extlen_t    len,            /* length to allocate */
+        xfs_buf_t       **rbpp,         /* in/out: summary block buffer */
+        xfs_fsblock_t   *rsb)           /* in/out: summary block number */
+{
+        xfs_rtblock_t   end;            /* end of the allocated extent */
+        int             error;          /* error value */
+        xfs_rtblock_t   postblock = 0;  /* first block allocated > end */
+        xfs_rtblock_t   preblock = 0;   /* first block allocated < start */
 
-error:
+        end = start + len - 1;
+        /*
+         * Assume we're allocating out of the middle of a free extent.
+         * We need to find the beginning and end of the extent so we can
+         * properly update the summary.
+         */
+        error = xfs_rtfind_back(mp, tp, start, 0, &preblock);
+        if (error) {
+                return error;
+        }
+        /*
+         * Find the next allocated block (end of free extent).
+         */
+        error = xfs_rtfind_forw(mp, tp, end, mp->m_sb.sb_rextents - 1,
+                &postblock);
+        if (error) {
+                return error;
+        }
+        /*
+         * Decrement the summary information corresponding to the entire
+         * (old) free extent.
+         */
+        error = xfs_rtmodify_summary(mp, tp,
+                XFS_RTBLOCKLOG(postblock + 1 - preblock),
+                XFS_BITTOBLOCK(mp, preblock), -1, rbpp, rsb);
+        if (error) {
+                return error;
+        }
+        /*
+         * If there are blocks not being allocated at the front of the
+         * old extent, add summary data for them to be free.
+         */
+        if (preblock < start) {
+                error = xfs_rtmodify_summary(mp, tp,
+                        XFS_RTBLOCKLOG(start - preblock),
+                        XFS_BITTOBLOCK(mp, preblock), 1, rbpp, rsb);
+                if (error) {
+                        return error;
+                }
+        }
+        /*
+         * If there are blocks not being allocated at the end of the
+         * old extent, add summary data for them to be free.
+         */
+        if (postblock > end) {
+                error = xfs_rtmodify_summary(mp, tp,
+                        XFS_RTBLOCKLOG(postblock - end),
+                        XFS_BITTOBLOCK(mp, end + 1), 1, rbpp, rsb);
+                if (error) {
+                        return error;
+                }
+        }
+        /*
+         * Modify the bitmap to mark this extent allocated.
+         */
+        error = xfs_rtmodify_range(mp, tp, start, len, 0);
         return error;
 }
 
@@ -721,1112 +809,126 @@ xfs_rtallocate_extent_size(
 }
 
 /*
- * Mark an extent specified by start and len allocated.
- * Updates all the summary information as well as the bitmap.
+ * Allocate space to the bitmap or summary file, and zero it, for growfs.
  */
 STATIC int                              /* error */
-xfs_rtallocate_range(
+xfs_growfs_rt_alloc(
         xfs_mount_t     *mp,            /* file system mount point */
-        xfs_trans_t     *tp,            /* transaction pointer */
-        xfs_rtblock_t   start,          /* start block to allocate */
-        xfs_extlen_t    len,            /* length to allocate */
-        xfs_buf_t       **rbpp,         /* in/out: summary block buffer */
-        xfs_fsblock_t   *rsb)           /* in/out: summary block number */
+        xfs_extlen_t    oblocks,        /* old count of blocks */
+        xfs_extlen_t    nblocks,        /* new count of blocks */
+        xfs_inode_t     *ip)            /* inode (bitmap/summary) */
 {
-        xfs_rtblock_t   end;            /* end of the allocated extent */
-        int             error;          /* error value */
-        xfs_rtblock_t   postblock = 0;  /* first block allocated > end */
-        xfs_rtblock_t   preblock = 0;   /* first block allocated < start */
+        xfs_fileoff_t   bno;            /* block number in file */
+        xfs_buf_t       *bp;            /* temporary buffer for zeroing */
+        int             committed;      /* transaction committed flag */
+        xfs_daddr_t     d;              /* disk block address */
+        int             error;          /* error return value */
+        xfs_fsblock_t   firstblock;     /* first block allocated in xaction */
+        xfs_bmap_free_t flist;          /* list of freed blocks */
+        xfs_fsblock_t   fsbno;          /* filesystem block for bno */
+        xfs_bmbt_irec_t map;            /* block map output */
+        int             nmap;           /* number of block maps */
+        int             resblks;        /* space reservation */
 
-        end = start + len - 1;
-        /*
-         * Assume we're allocating out of the middle of a free extent.
-         * We need to find the beginning and end of the extent so we can
-         * properly update the summary.
-         */
-        error = xfs_rtfind_back(mp, tp, start, 0, &preblock);
-        if (error) {
-                return error;
-        }
-        /*
-         * Find the next allocated block (end of free extent).
-         */
-        error = xfs_rtfind_forw(mp, tp, end, mp->m_sb.sb_rextents - 1,
-                &postblock);
-        if (error) {
-                return error;
-        }
-        /*
-         * Decrement the summary information corresponding to the entire
-         * (old) free extent.
-         */
-        error = xfs_rtmodify_summary(mp, tp,
-                XFS_RTBLOCKLOG(postblock + 1 - preblock),
-                XFS_BITTOBLOCK(mp, preblock), -1, rbpp, rsb);
-        if (error) {
-                return error;
-        }
-        /*
-         * If there are blocks not being allocated at the front of the
-         * old extent, add summary data for them to be free.
-         */
-        if (preblock < start) {
-                error = xfs_rtmodify_summary(mp, tp,
-                        XFS_RTBLOCKLOG(start - preblock),
-                        XFS_BITTOBLOCK(mp, preblock), 1, rbpp, rsb);
-                if (error) {
-                        return error;
-                }
-        }
-        /*
-         * If there are blocks not being allocated at the end of the
-         * old extent, add summary data for them to be free.
-         */
-        if (postblock > end) {
-                error = xfs_rtmodify_summary(mp, tp,
-                        XFS_RTBLOCKLOG(postblock - end),
-                        XFS_BITTOBLOCK(mp, end + 1), 1, rbpp, rsb);
-                if (error) {
-                        return error;
-                }
-        }
         /*
-         * Modify the bitmap to mark this extent allocated.
+         * Allocate space to the file, as necessary.
          */
-        error = xfs_rtmodify_range(mp, tp, start, len, 0);
-        return error;
-}
-
-/*
- * Return whether there are any free extents in the size range given
- * by low and high, for the bitmap block bbno.
- */
-STATIC int                              /* error */
-xfs_rtany_summary(
-        xfs_mount_t     *mp,            /* file system mount structure */
-        xfs_trans_t     *tp,            /* transaction pointer */
-        int             low,            /* low log2 extent size */
-        int             high,           /* high log2 extent size */
-        xfs_rtblock_t   bbno,           /* bitmap block number */
-        xfs_buf_t       **rbpp,         /* in/out: summary block buffer */
-        xfs_fsblock_t   *rsb,           /* in/out: summary block number */
-        int             *stat)          /* out: any good extents here? */
-{
-        int             error;          /* error value */
-        int             log;            /* loop counter, log2 of ext. size */
-        xfs_suminfo_t   sum;            /* summary data */
+        while (oblocks < nblocks) {
+                int             cancelflags = 0;
+                xfs_trans_t     *tp;
 
-        /*
-         * Loop over logs of extent sizes.  Order is irrelevant.
-         */
-        for (log = low; log <= high; log++) {
+                tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFSRT_ALLOC);
+                resblks = XFS_GROWFSRT_SPACE_RES(mp, nblocks - oblocks);
                 /*
-                 * Get one summary datum.
+                 * Reserve space & log for one extent added to the file.
                  */
-                error = xfs_rtget_summary(mp, tp, log, bbno, rbpp, rsb, &sum);
-                if (error) {
-                        return error;
-                }
+                error = xfs_trans_reserve(tp, &M_RES(mp)->tr_growdata,
+                                          resblks, 0);
+                if (error)
+                        goto error_cancel;
+                cancelflags = XFS_TRANS_RELEASE_LOG_RES;
                 /*
-                 * If there are any, return success.
+                 * Lock the inode.
                  */
-                if (sum) {
-                        *stat = 1;
-                        return 0;
-                }
-        }
-        /*
-         * Found nothing, return failure.
-         */
-        *stat = 0;
-        return 0;
-}
-
-/*
- * Get a buffer for the bitmap or summary file block specified.
- * The buffer is returned read and locked.
- */
-STATIC int                              /* error */
-xfs_rtbuf_get(
-        xfs_mount_t     *mp,            /* file system mount structure */
-        xfs_trans_t     *tp,            /* transaction pointer */
-        xfs_rtblock_t   block,          /* block number in bitmap or summary */
-        int             issum,          /* is summary not bitmap */
-        xfs_buf_t       **bpp)          /* output: buffer for the block */
-{
-        xfs_buf_t       *bp;            /* block buffer, result */
-        xfs_inode_t     *ip;            /* bitmap or summary inode */
-        xfs_bmbt_irec_t map;
-        int             nmap = 1;
-        int             error;          /* error value */
-
-        ip = issum ? mp->m_rsumip : mp->m_rbmip;
-
-        error = xfs_bmapi_read(ip, block, 1, &map, &nmap, XFS_DATA_FORK);
-        if (error)
-                return error;
-
-        ASSERT(map.br_startblock != NULLFSBLOCK);
-        error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
-                                   XFS_FSB_TO_DADDR(mp, map.br_startblock),
-                                   mp->m_bsize, 0, &bp, NULL);
-        if (error)
-                return error;
-        ASSERT(!xfs_buf_geterror(bp));
-        *bpp = bp;
-        return 0;
-}
-
-#ifdef DEBUG
-/*
- * Check that the given extent (block range) is allocated already.
- */
-STATIC int                              /* error */
-xfs_rtcheck_alloc_range(
-        xfs_mount_t     *mp,            /* file system mount point */
-        xfs_trans_t     *tp,            /* transaction pointer */
-        xfs_rtblock_t   bno,            /* starting block number of extent */
-        xfs_extlen_t    len,            /* length of extent */
-        int             *stat)          /* out: 1 for allocated, 0 for not */
-{
-        xfs_rtblock_t   new;            /* dummy for xfs_rtcheck_range */
-
-        return xfs_rtcheck_range(mp, tp, bno, len, 0, &new, stat);
-}
-#endif
-
-/*
- * Check that the given range is either all allocated (val = 0) or
- * all free (val = 1).
- */
-STATIC int                              /* error */
-xfs_rtcheck_range(
-        xfs_mount_t     *mp,            /* file system mount point */
-        xfs_trans_t     *tp,            /* transaction pointer */
-        xfs_rtblock_t   start,          /* starting block number of extent */
-        xfs_extlen_t    len,            /* length of extent */
-        int             val,            /* 1 for free, 0 for allocated */
-        xfs_rtblock_t   *new,           /* out: first block not matching */
-        int             *stat)          /* out: 1 for matches, 0 for not */
-{
-        xfs_rtword_t    *b;             /* current word in buffer */
-        int             bit;            /* bit number in the word */
-        xfs_rtblock_t   block;          /* bitmap block number */
-        xfs_buf_t       *bp;            /* buf for the block */
-        xfs_rtword_t    *bufp;          /* starting word in buffer */
-        int             error;          /* error value */
-        xfs_rtblock_t   i;              /* current bit number rel. to start */
-        xfs_rtblock_t   lastbit;        /* last useful bit in word */
-        xfs_rtword_t    mask;           /* mask of relevant bits for value */
-        xfs_rtword_t    wdiff;          /* difference from wanted value */
-        int             word;           /* word number in the buffer */
+                xfs_ilock(ip, XFS_ILOCK_EXCL);
+                xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
 
-        /*
-         * Compute starting bitmap block number
-         */
-        block = XFS_BITTOBLOCK(mp, start);
-        /*
-         * Read the bitmap block.
-         */
-        error = xfs_rtbuf_get(mp, tp, block, 0, &bp);
-        if (error) {
-                return error;
-        }
-        bufp = bp->b_addr;
-        /*
-         * Compute the starting word's address, and starting bit.
-         */
-        word = XFS_BITTOWORD(mp, start);
-        b = &bufp[word];
-        bit = (int)(start & (XFS_NBWORD - 1));
-        /*
-         * 0 (allocated) => all zero's; 1 (free) => all one's.
-         */
-        val = -val;
-        /*
-         * If not starting on a word boundary, deal with the first
-         * (partial) word.
-         */
-        if (bit) {
-                /*
-                 * Compute first bit not examined.
-                 */
-                lastbit = XFS_RTMIN(bit + len, XFS_NBWORD);
-                /*
-                 * Mask of relevant bits.
-                 */
-                mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
-                /*
-                 * Compute difference between actual and desired value.
-                 */
-                if ((wdiff = (*b ^ val) & mask)) {
-                        /*
-                         * Different, compute first wrong bit and return.
-                         */
-                        xfs_trans_brelse(tp, bp);
-                        i = XFS_RTLOBIT(wdiff) - bit;
-                        *new = start + i;
-                        *stat = 0;
-                        return 0;
-                }
-                i = lastbit - bit;
-                /*
-                 * Go on to next block if that's where the next word is
-                 * and we need the next word.
-                 */
-                if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
-                        /*
-                         * If done with this block, get the next one.
-                         */
-                        xfs_trans_brelse(tp, bp);
-                        error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
-                        if (error) {
-                                return error;
-                        }
-                        b = bufp = bp->b_addr;
-                        word = 0;
-                } else {
-                        /*
-                         * Go on to the next word in the buffer.
-                         */
-                        b++;
-                }
-        } else {
-                /*
-                 * Starting on a word boundary, no partial word.
-                 */
-                i = 0;
-        }
-        /*
-         * Loop over whole words in buffers.  When we use up one buffer
-         * we move on to the next one.
-         */
-        while (len - i >= XFS_NBWORD) {
-                /*
-                 * Compute difference between actual and desired value.
-                 */
-                if ((wdiff = *b ^ val)) {
-                        /*
-                         * Different, compute first wrong bit and return.
-                         */
-                        xfs_trans_brelse(tp, bp);
-                        i += XFS_RTLOBIT(wdiff);
-                        *new = start + i;
-                        *stat = 0;
-                        return 0;
-                }
-                i += XFS_NBWORD;
+                xfs_bmap_init(&flist, &firstblock);
                 /*
-                 * Go on to next block if that's where the next word is
-                 * and we need the next word.
+                 * Allocate blocks to the bitmap file.
                  */
-                if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
-                        /*
-                         * If done with this block, get the next one.
-                         */
-                        xfs_trans_brelse(tp, bp);
-                        error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
-                        if (error) {
-                                return error;
-                        }
-                        b = bufp = bp->b_addr;
-                        word = 0;
-                } else {
-                        /*
-                         * Go on to the next word in the buffer.
-                         */
-                        b++;
-                }
-        }
-        /*
-         * If not ending on a word boundary, deal with the last
-         * (partial) word.
-         */
-        if ((lastbit = len - i)) {
+                nmap = 1;
+                cancelflags |= XFS_TRANS_ABORT;
+                error = xfs_bmapi_write(tp, ip, oblocks, nblocks - oblocks,
+                                        XFS_BMAPI_METADATA, &firstblock,
+                                        resblks, &map, &nmap, &flist);
+                if (!error && nmap < 1)
+                        error = XFS_ERROR(ENOSPC);
+                if (error)
+                        goto error_cancel;
                 /*
-                 * Mask of relevant bits.
+                 * Free any blocks freed up in the transaction, then commit.
                  */
-                mask = ((xfs_rtword_t)1 << lastbit) - 1;
+                error = xfs_bmap_finish(&tp, &flist, &committed);
+                if (error)
+                        goto error_cancel;
+                error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
+                if (error)
+                        goto error;
                 /*
-                 * Compute difference between actual and desired value.
+                 * Now we need to clear the allocated blocks.
+                 * Do this one block per transaction, to keep it simple.
                  */
-                if ((wdiff = (*b ^ val) & mask)) {
+                cancelflags = 0;
+                for (bno = map.br_startoff, fsbno = map.br_startblock;
+                     bno < map.br_startoff + map.br_blockcount;
+                     bno++, fsbno++) {
+                        tp = xfs_trans_alloc(mp, XFS_TRANS_GROWFSRT_ZERO);
                         /*
-                         * Different, compute first wrong bit and return.
+                         * Reserve log for one block zeroing.
                          */
-                        xfs_trans_brelse(tp, bp);
-                        i += XFS_RTLOBIT(wdiff);
-                        *new = start + i;
-                        *stat = 0;
-                        return 0;
-                } else
-                        i = len;
-        }
-        /*
-         * Successful, return.
-         */
-        xfs_trans_brelse(tp, bp);
-        *new = start + i;
-        *stat = 1;
-        return 0;
-}
-
-/*
- * Copy and transform the summary file, given the old and new
- * parameters in the mount structures.
- */
-STATIC int                              /* error */
-xfs_rtcopy_summary(
-        xfs_mount_t     *omp,           /* old file system mount point */
-        xfs_mount_t     *nmp,           /* new file system mount point */
-        xfs_trans_t     *tp)            /* transaction pointer */
-{
-        xfs_rtblock_t   bbno;           /* bitmap block number */
-        xfs_buf_t       *bp;            /* summary buffer */
-        int             error;          /* error return value */
-        int             log;            /* summary level number (log length) */
-        xfs_suminfo_t   sum;            /* summary data */
-        xfs_fsblock_t   sumbno;         /* summary block number */
-
-        bp = NULL;
-        for (log = omp->m_rsumlevels - 1; log >= 0; log--) {
-                for (bbno = omp->m_sb.sb_rbmblocks - 1;
-                     (xfs_srtblock_t)bbno >= 0;
-                     bbno--) {
-                        error = xfs_rtget_summary(omp, tp, log, bbno, &bp,
-                                &sumbno, &sum);
-                        if (error)
-                                return error;
-                        if (sum == 0)
-                                continue;
-                        error = xfs_rtmodify_summary(omp, tp, log, bbno, -sum,
-                                &bp, &sumbno);
-                        if (error)
-                                return error;
-                        error = xfs_rtmodify_summary(nmp, tp, log, bbno, sum,
-                                &bp, &sumbno);
+                        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_growrtzero,
+                                                  0, 0);
                         if (error)
-                                return error;
-                        ASSERT(sum > 0);
-                }
-        }
-        return 0;
-}
-
-/*
- * Searching backward from start to limit, find the first block whose
- * allocated/free state is different from start's.
- */
-STATIC int                              /* error */
-xfs_rtfind_back(
-        xfs_mount_t     *mp,            /* file system mount point */
-        xfs_trans_t     *tp,            /* transaction pointer */
-        xfs_rtblock_t   start,          /* starting block to look at */
-        xfs_rtblock_t   limit,          /* last block to look at */
-        xfs_rtblock_t   *rtblock)       /* out: start block found */
-{
-        xfs_rtword_t    *b;             /* current word in buffer */
-        int             bit;            /* bit number in the word */
-        xfs_rtblock_t   block;          /* bitmap block number */
-        xfs_buf_t       *bp;            /* buf for the block */
-        xfs_rtword_t    *bufp;          /* starting word in buffer */
-        int             error;          /* error value */
-        xfs_rtblock_t   firstbit;       /* first useful bit in the word */
-        xfs_rtblock_t   i;              /* current bit number rel. to start */
-        xfs_rtblock_t   len;            /* length of inspected area */
-        xfs_rtword_t    mask;           /* mask of relevant bits for value */
-        xfs_rtword_t    want;           /* mask for "good" values */
-        xfs_rtword_t    wdiff;          /* difference from wanted value */
-        int             word;           /* word number in the buffer */
-
-        /*
-         * Compute and read in starting bitmap block for starting block.
-         */
-        block = XFS_BITTOBLOCK(mp, start);
-        error = xfs_rtbuf_get(mp, tp, block, 0, &bp);
-        if (error) {
-                return error;
-        }
-        bufp = bp->b_addr;
-        /*
-         * Get the first word's index & point to it.
-         */
-        word = XFS_BITTOWORD(mp, start);
-        b = &bufp[word];
-        bit = (int)(start & (XFS_NBWORD - 1));
-        len = start - limit + 1;
-        /*
-         * Compute match value, based on the bit at start: if 1 (free)
-         * then all-ones, else all-zeroes.
-         */
-        want = (*b & ((xfs_rtword_t)1 << bit)) ? -1 : 0;
-        /*
-         * If the starting position is not word-aligned, deal with the
-         * partial word.
-         */
-        if (bit < XFS_NBWORD - 1) {
-                /*
-                 * Calculate first (leftmost) bit number to look at,
-                 * and mask for all the relevant bits in this word.
-                 */
-                firstbit = XFS_RTMAX((xfs_srtblock_t)(bit - len + 1), 0);
-                mask = (((xfs_rtword_t)1 << (bit - firstbit + 1)) - 1) <<
-                        firstbit;
-                /*
-                 * Calculate the difference between the value there
-                 * and what we're looking for.
-                 */
-                if ((wdiff = (*b ^ want) & mask)) {
-                        /*
-                         * Different.  Mark where we are and return.
-                         */
-                        xfs_trans_brelse(tp, bp);
-                        i = bit - XFS_RTHIBIT(wdiff);
-                        *rtblock = start - i + 1;
-                        return 0;
-                }
-                i = bit - firstbit + 1;
-                /*
-                 * Go on to previous block if that's where the previous word is
-                 * and we need the previous word.
-                 */
-                if (--word == -1 && i < len) {
-                        /*
-                         * If done with this block, get the previous one.
-                         */
-                        xfs_trans_brelse(tp, bp);
-                        error = xfs_rtbuf_get(mp, tp, --block, 0, &bp);
-                        if (error) {
-                                return error;
-                        }
-                        bufp = bp->b_addr;
-                        word = XFS_BLOCKWMASK(mp);
-                        b = &bufp[word];
-                } else {
-                        /*
-                         * Go on to the previous word in the buffer.
-                         */
-                        b--;
-                }
-        } else {
-                /*
-                 * Starting on a word boundary, no partial word.
-                 */
-                i = 0;
-        }
-        /*
-         * Loop over whole words in buffers.  When we use up one buffer
-         * we move on to the previous one.
-         */
-        while (len - i >= XFS_NBWORD) {
-                /*
-                 * Compute difference between actual and desired value.
-                 */
-                if ((wdiff = *b ^ want)) {
-                        /*
-                         * Different, mark where we are and return.
-                         */
-                        xfs_trans_brelse(tp, bp);
-                        i += XFS_NBWORD - 1 - XFS_RTHIBIT(wdiff);
-                        *rtblock = start - i + 1;
-                        return 0;
-                }
-                i += XFS_NBWORD;
-                /*
-                 * Go on to previous block if that's where the previous word is
-                 * and we need the previous word.
-                 */
-                if (--word == -1 && i < len) {
-                        /*
-                         * If done with this block, get the previous one.
-                         */
-                        xfs_trans_brelse(tp, bp);
-                        error = xfs_rtbuf_get(mp, tp, --block, 0, &bp);
-                        if (error) {
-                                return error;
-                        }
-                        bufp = bp->b_addr;
-                        word = XFS_BLOCKWMASK(mp);
-                        b = &bufp[word];
-                } else {
-                        /*
-                         * Go on to the previous word in the buffer.
-                         */
-                        b--;
-                }
-        }
-        /*
-         * If not ending on a word boundary, deal with the last
-         * (partial) word.
-         */
-        if (len - i) {
-                /*
-                 * Calculate first (leftmost) bit number to look at,
-                 * and mask for all the relevant bits in this word.
-                 */
-                firstbit = XFS_NBWORD - (len - i);
-                mask = (((xfs_rtword_t)1 << (len - i)) - 1) << firstbit;
-                /*
-                 * Compute difference between actual and desired value.
-                 */
-                if ((wdiff = (*b ^ want) & mask)) {
-                        /*
-                         * Different, mark where we are and return.
-                         */
-                        xfs_trans_brelse(tp, bp);
-                        i += XFS_NBWORD - 1 - XFS_RTHIBIT(wdiff);
-                        *rtblock = start - i + 1;
-                        return 0;
-                } else
-                        i = len;
-        }
-        /*
-         * No match, return that we scanned the whole area.
-         */
-        xfs_trans_brelse(tp, bp);
-        *rtblock = start - i + 1;
-        return 0;
-}
-
-/*
- * Searching forward from start to limit, find the first block whose
- * allocated/free state is different from start's.
- */
-STATIC int                              /* error */
-xfs_rtfind_forw(
-        xfs_mount_t     *mp,            /* file system mount point */
-        xfs_trans_t     *tp,            /* transaction pointer */
-        xfs_rtblock_t   start,          /* starting block to look at */
-        xfs_rtblock_t   limit,          /* last block to look at */
-        xfs_rtblock_t   *rtblock)       /* out: start block found */
-{
-        xfs_rtword_t    *b;             /* current word in buffer */
-        int             bit;            /* bit number in the word */
-        xfs_rtblock_t   block;          /* bitmap block number */
-        xfs_buf_t       *bp;            /* buf for the block */
-        xfs_rtword_t    *bufp;          /* starting word in buffer */
-        int             error;          /* error value */
-        xfs_rtblock_t   i;              /* current bit number rel. to start */
-        xfs_rtblock_t   lastbit;        /* last useful bit in the word */
-        xfs_rtblock_t   len;            /* length of inspected area */
-        xfs_rtword_t    mask;           /* mask of relevant bits for value */
-        xfs_rtword_t    want;           /* mask for "good" values */
-        xfs_rtword_t    wdiff;          /* difference from wanted value */
-        int             word;           /* word number in the buffer */
-
-        /*
-         * Compute and read in starting bitmap block for starting block.
-         */
-        block = XFS_BITTOBLOCK(mp, start);
-        error = xfs_rtbuf_get(mp, tp, block, 0, &bp);
-        if (error) {
-                return error;
-        }
-        bufp = bp->b_addr;
-        /*
-         * Get the first word's index & point to it.
-         */
-        word = XFS_BITTOWORD(mp, start);
-        b = &bufp[word];
-        bit = (int)(start & (XFS_NBWORD - 1));
-        len = limit - start + 1;
-        /*
-         * Compute match value, based on the bit at start: if 1 (free)
-         * then all-ones, else all-zeroes.
-         */
-        want = (*b & ((xfs_rtword_t)1 << bit)) ? -1 : 0;
-        /*
-         * If the starting position is not word-aligned, deal with the
-         * partial word.
-         */
-        if (bit) {
-                /*
-                 * Calculate last (rightmost) bit number to look at,
-                 * and mask for all the relevant bits in this word.
-                 */
-                lastbit = XFS_RTMIN(bit + len, XFS_NBWORD);
-                mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
-                /*
-                 * Calculate the difference between the value there
-                 * and what we're looking for.
-                 */
-                if ((wdiff = (*b ^ want) & mask)) {
-                        /*
-                         * Different.  Mark where we are and return.
-                         */
-                        xfs_trans_brelse(tp, bp);
-                        i = XFS_RTLOBIT(wdiff) - bit;
-                        *rtblock = start + i - 1;
-                        return 0;
-                }
-                i = lastbit - bit;
-                /*
-                 * Go on to next block if that's where the next word is
-                 * and we need the next word.
-                 */
-                if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
-                        /*
-                         * If done with this block, get the previous one.
-                         */
-                        xfs_trans_brelse(tp, bp);
-                        error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
-                        if (error) {
-                                return error;
-                        }
-                        b = bufp = bp->b_addr;
-                        word = 0;
-                } else {
-                        /*
-                         * Go on to the previous word in the buffer.
-                         */
-                        b++;
-                }
-        } else {
-                /*
-                 * Starting on a word boundary, no partial word.
-                 */
-                i = 0;
-        }
-        /*
-         * Loop over whole words in buffers.  When we use up one buffer
-         * we move on to the next one.
-         */
-        while (len - i >= XFS_NBWORD) {
-                /*
-                 * Compute difference between actual and desired value.
-                 */
-                if ((wdiff = *b ^ want)) {
+                                goto error_cancel;
                         /*
-                         * Different, mark where we are and return.
+                         * Lock the bitmap inode.
                          */
-                        xfs_trans_brelse(tp, bp);
-                        i += XFS_RTLOBIT(wdiff);
-                        *rtblock = start + i - 1;
-                        return 0;
-                }
-                i += XFS_NBWORD;
-                /*
-                 * Go on to next block if that's where the next word is
-                 * and we need the next word.
-                 */
-                if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
+                        xfs_ilock(ip, XFS_ILOCK_EXCL);
+                        xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
                         /*
-                         * If done with this block, get the next one.
+                         * Get a buffer for the block.
                          */
-                        xfs_trans_brelse(tp, bp);
-                        error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
-                        if (error) {
-                                return error;
+                        d = XFS_FSB_TO_DADDR(mp, fsbno);
+                        bp = xfs_trans_get_buf(tp, mp->m_ddev_targp, d,
+                                mp->m_bsize, 0);
+                        if (bp == NULL) {
+                                error = XFS_ERROR(EIO);
+error_cancel:
+                                xfs_trans_cancel(tp, cancelflags);
+                                goto error;
                         }
-                        b = bufp = bp->b_addr;
-                        word = 0;
-                } else {
+                        memset(bp->b_addr, 0, mp->m_sb.sb_blocksize);
+                        xfs_trans_log_buf(tp, bp, 0, mp->m_sb.sb_blocksize - 1);
                         /*
-                         * Go on to the next word in the buffer.
+                         * Commit the transaction.
                          */
-                        b++;
+                        error = xfs_trans_commit(tp, 0);
+                        if (error)
+                                goto error;
                 }
-        }
-        /*
-         * If not ending on a word boundary, deal with the last
-         * (partial) word.
-         */
-        if ((lastbit = len - i)) {
-                /*
-                 * Calculate mask for all the relevant bits in this word.
-                 */
-                mask = ((xfs_rtword_t)1 << lastbit) - 1;
                 /*
-                 * Compute difference between actual and desired value.
+                 * Go on to the next extent, if any.
                  */
-                if ((wdiff = (*b ^ want) & mask)) {
-                        /*
-                         * Different, mark where we are and return.
-                         */
-                        xfs_trans_brelse(tp, bp);
-                        i += XFS_RTLOBIT(wdiff);
-                        *rtblock = start + i - 1;
-                        return 0;
-                } else
-                        i = len;
+                oblocks = map.br_startoff + map.br_blockcount;
         }
-        /*
-         * No match, return that we scanned the whole area.
-         */
-        xfs_trans_brelse(tp, bp);
-        *rtblock = start + i - 1;
         return 0;
-}
 
-/*
- * Mark an extent specified by start and len freed.
- * Updates all the summary information as well as the bitmap.
- */
-STATIC int                              /* error */
-xfs_rtfree_range(
-        xfs_mount_t     *mp,            /* file system mount point */
-        xfs_trans_t     *tp,            /* transaction pointer */
-        xfs_rtblock_t   start,          /* starting block to free */
-        xfs_extlen_t    len,            /* length to free */
-        xfs_buf_t       **rbpp,         /* in/out: summary block buffer */
-        xfs_fsblock_t   *rsb)           /* in/out: summary block number */
-{
-        xfs_rtblock_t   end;            /* end of the freed extent */
-        int             error;          /* error value */
-        xfs_rtblock_t   postblock;      /* first block freed > end */
-        xfs_rtblock_t   preblock;       /* first block freed < start */
-
-        end = start + len - 1;
-        /*
-         * Modify the bitmap to mark this extent freed.
-         */
-        error = xfs_rtmodify_range(mp, tp, start, len, 1);
-        if (error) {
-                return error;
-        }
-        /*
-         * Assume we're freeing out of the middle of an allocated extent.
-         * We need to find the beginning and end of the extent so we can
-         * properly update the summary.
-         */
-        error = xfs_rtfind_back(mp, tp, start, 0, &preblock);
-        if (error) {
-                return error;
-        }
-        /*
-         * Find the next allocated block (end of allocated extent).
-         */
-        error = xfs_rtfind_forw(mp, tp, end, mp->m_sb.sb_rextents - 1,
-                &postblock);
-        if (error)
-                return error;
-        /*
-         * If there are blocks not being freed at the front of the
-         * old extent, add summary data for them to be allocated.
-         */
-        if (preblock < start) {
-                error = xfs_rtmodify_summary(mp, tp,
-                        XFS_RTBLOCKLOG(start - preblock),
-                        XFS_BITTOBLOCK(mp, preblock), -1, rbpp, rsb);
-                if (error) {
-                        return error;
-                }
-        }
-        /*
-         * If there are blocks not being freed at the end of the
-         * old extent, add summary data for them to be allocated.
-         */
-        if (postblock > end) {
-                error = xfs_rtmodify_summary(mp, tp,
-                        XFS_RTBLOCKLOG(postblock - end),
-                        XFS_BITTOBLOCK(mp, end + 1), -1, rbpp, rsb);
-                if (error) {
-                        return error;
-                }
-        }
-        /*
-         * Increment the summary information corresponding to the entire
-         * (new) free extent.
-         */
-        error = xfs_rtmodify_summary(mp, tp,
-                XFS_RTBLOCKLOG(postblock + 1 - preblock),
-                XFS_BITTOBLOCK(mp, preblock), 1, rbpp, rsb);
+error:
         return error;
 }
 
 /*
- * Read and return the summary information for a given extent size,
- * bitmap block combination.
- * Keeps track of a current summary block, so we don't keep reading
- * it from the buffer cache.
- */
-STATIC int                              /* error */
-xfs_rtget_summary(
-        xfs_mount_t     *mp,            /* file system mount structure */
-        xfs_trans_t     *tp,            /* transaction pointer */
-        int             log,            /* log2 of extent size */
-        xfs_rtblock_t   bbno,           /* bitmap block number */
-        xfs_buf_t       **rbpp,         /* in/out: summary block buffer */
-        xfs_fsblock_t   *rsb,           /* in/out: summary block number */
-        xfs_suminfo_t   *sum)           /* out: summary info for this block */
-{
-        xfs_buf_t       *bp;            /* buffer for summary block */
-        int             error;          /* error value */
-        xfs_fsblock_t   sb;             /* summary fsblock */
-        int             so;             /* index into the summary file */
-        xfs_suminfo_t   *sp;            /* pointer to returned data */
-
-        /*
-         * Compute entry number in the summary file.
-         */
-        so = XFS_SUMOFFS(mp, log, bbno);
-        /*
-         * Compute the block number in the summary file.
-         */
-        sb = XFS_SUMOFFSTOBLOCK(mp, so);
-        /*
-         * If we have an old buffer, and the block number matches, use that.
-         */
-        if (rbpp && *rbpp && *rsb == sb)
-                bp = *rbpp;
-        /*
-         * Otherwise we have to get the buffer.
-         */
-        else {
-                /*
-                 * If there was an old one, get rid of it first.
-                 */
-                if (rbpp && *rbpp)
-                        xfs_trans_brelse(tp, *rbpp);
-                error = xfs_rtbuf_get(mp, tp, sb, 1, &bp);
-                if (error) {
-                        return error;
-                }
-                /*
-                 * Remember this buffer and block for the next call.
-                 */
-                if (rbpp) {
-                        *rbpp = bp;
-                        *rsb = sb;
-                }
-        }
-        /*
-         * Point to the summary information & copy it out.
-         */
-        sp = XFS_SUMPTR(mp, bp, so);
-        *sum = *sp;
-        /*
-         * Drop the buffer if we're not asked to remember it.
-         */
-        if (!rbpp)
-                xfs_trans_brelse(tp, bp);
-        return 0;
-}
-
-/*
- * Set the given range of bitmap bits to the given value.
- * Do whatever I/O and logging is required.
- */
-STATIC int                              /* error */
-xfs_rtmodify_range(
-        xfs_mount_t     *mp,            /* file system mount point */
-        xfs_trans_t     *tp,            /* transaction pointer */
-        xfs_rtblock_t   start,          /* starting block to modify */
-        xfs_extlen_t    len,            /* length of extent to modify */
-        int             val)            /* 1 for free, 0 for allocated */
-{
-        xfs_rtword_t    *b;             /* current word in buffer */
-        int             bit;            /* bit number in the word */
-        xfs_rtblock_t   block;          /* bitmap block number */
-        xfs_buf_t       *bp;            /* buf for the block */
-        xfs_rtword_t    *bufp;          /* starting word in buffer */
-        int             error;          /* error value */
-        xfs_rtword_t    *first;         /* first used word in the buffer */
-        int             i;              /* current bit number rel. to start */
-        int             lastbit;        /* last useful bit in word */
-        xfs_rtword_t    mask;           /* mask o frelevant bits for value */
-        int             word;           /* word number in the buffer */
-
-        /*
-         * Compute starting bitmap block number.
-         */
-        block = XFS_BITTOBLOCK(mp, start);
-        /*
-         * Read the bitmap block, and point to its data.
-         */
-        error = xfs_rtbuf_get(mp, tp, block, 0, &bp);
-        if (error) {
-                return error;
-        }
-        bufp = bp->b_addr;
-        /*
-         * Compute the starting word's address, and starting bit.
-         */
-        word = XFS_BITTOWORD(mp, start);
-        first = b = &bufp[word];
-        bit = (int)(start & (XFS_NBWORD - 1));
-        /*
-         * 0 (allocated) => all zeroes; 1 (free) => all ones.
-         */
-        val = -val;
-        /*
-         * If not starting on a word boundary, deal with the first
-         * (partial) word.
-         */
-        if (bit) {
-                /*
-                 * Compute first bit not changed and mask of relevant bits.
-                 */
-                lastbit = XFS_RTMIN(bit + len, XFS_NBWORD);
-                mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
-                /*
-                 * Set/clear the active bits.
-                 */
-                if (val)
-                        *b |= mask;
-                else
-                        *b &= ~mask;
-                i = lastbit - bit;
-                /*
-                 * Go on to the next block if that's where the next word is
-                 * and we need the next word.
-                 */
-                if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
-                        /*
-                         * Log the changed part of this block.
-                         * Get the next one.
-                         */
-                        xfs_trans_log_buf(tp, bp,
-                                (uint)((char *)first - (char *)bufp),
-                                (uint)((char *)b - (char *)bufp));
-                        error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
-                        if (error) {
-                                return error;
-                        }
-                        first = b = bufp = bp->b_addr;
-                        word = 0;
-                } else {
-                        /*
-                         * Go on to the next word in the buffer
-                         */
-                        b++;
-                }
-        } else {
-                /*
-                 * Starting on a word boundary, no partial word.
-                 */
-                i = 0;
-        }
-        /*
-         * Loop over whole words in buffers.  When we use up one buffer
-         * we move on to the next one.
-         */
-        while (len - i >= XFS_NBWORD) {
-                /*
-                 * Set the word value correctly.
-                 */
-                *b = val;
-                i += XFS_NBWORD;
-                /*
-                 * Go on to the next block if that's where the next word is
-                 * and we need the next word.
-                 */
-                if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
-                        /*
-                         * Log the changed part of this block.
-                         * Get the next one.
-                         */
-                        xfs_trans_log_buf(tp, bp,
-                                (uint)((char *)first - (char *)bufp),
-                                (uint)((char *)b - (char *)bufp));
-                        error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
-                        if (error) {
-                                return error;
-                        }
-                        first = b = bufp = bp->b_addr;
-                        word = 0;
-                } else {
-                        /*
-                         * Go on to the next word in the buffer
-                         */
-                        b++;
-                }
-        }
-        /*
-         * If not ending on a word boundary, deal with the last
-         * (partial) word.
-         */
-        if ((lastbit = len - i)) {
-                /*
-                 * Compute a mask of relevant bits.
-                 */
-                bit = 0;
-                mask = ((xfs_rtword_t)1 << lastbit) - 1;
-                /*
-                 * Set/clear the active bits.
-                 */
-                if (val)
-                        *b |= mask;
-                else
-                        *b &= ~mask;
-                b++;
-        }
-        /*
-         * Log any remaining changed bytes.
-         */
-        if (b > first)
-                xfs_trans_log_buf(tp, bp, (uint)((char *)first - (char *)bufp),
-                        (uint)((char *)b - (char *)bufp - 1));
-        return 0;
-}
-
-/*
- * Read and modify the summary information for a given extent size,
- * bitmap block combination.
- * Keeps track of a current summary block, so we don't keep reading
- * it from the buffer cache.
- */
-STATIC int                              /* error */
-xfs_rtmodify_summary(
-        xfs_mount_t     *mp,            /* file system mount point */
-        xfs_trans_t     *tp,            /* transaction pointer */
-        int             log,            /* log2 of extent size */
-        xfs_rtblock_t   bbno,           /* bitmap block number */
-        int             delta,          /* change to make to summary info */
-        xfs_buf_t       **rbpp,         /* in/out: summary block buffer */
-        xfs_fsblock_t   *rsb)           /* in/out: summary block number */
-{
-        xfs_buf_t       *bp;            /* buffer for the summary block */
-        int             error;          /* error value */
-        xfs_fsblock_t   sb;             /* summary fsblock */
-        int             so;             /* index into the summary file */
-        xfs_suminfo_t   *sp;            /* pointer to returned data */
-
-        /*
-         * Compute entry number in the summary file.
-         */
-        so = XFS_SUMOFFS(mp, log, bbno);
-        /*
-         * Compute the block number in the summary file.
-         */
-        sb = XFS_SUMOFFSTOBLOCK(mp, so);
-        /*
-         * If we have an old buffer, and the block number matches, use that.
-         */
-        if (rbpp && *rbpp && *rsb == sb)
-                bp = *rbpp;
-        /*
-         * Otherwise we have to get the buffer.
-         */
-        else {
-                /*
-                 * If there was an old one, get rid of it first.
-                 */
-                if (rbpp && *rbpp)
-                        xfs_trans_brelse(tp, *rbpp);
-                error = xfs_rtbuf_get(mp, tp, sb, 1, &bp);
-                if (error) {
-                        return error;
-                }
-                /*
-                 * Remember this buffer and block for the next call.
-                 */
-                if (rbpp) {
-                        *rbpp = bp;
-                        *rsb = sb;
-                }
-        }
-        /*
-         * Point to the summary information, modify and log it.
-         */
-        sp = XFS_SUMPTR(mp, bp, so);
-        *sp += delta;
-        xfs_trans_log_buf(tp, bp, (uint)((char *)sp - (char *)bp->b_addr),
-                (uint)((char *)sp - (char *)bp->b_addr + sizeof(*sp) - 1));
-        return 0;
-}
-
-/*
  * Visible (exported) functions.
  */
 
@@ -2129,66 +1231,6 @@ xfs_rtallocate_extent(
 }
 
 /*
- * Free an extent in the realtime subvolume.  Length is expressed in
- * realtime extents, as is the block number.
- */
-int                                     /* error */
-xfs_rtfree_extent(
-        xfs_trans_t     *tp,            /* transaction pointer */
-        xfs_rtblock_t   bno,            /* starting block number to free */
-        xfs_extlen_t    len)            /* length of extent freed */
-{
-        int             error;          /* error value */
-        xfs_mount_t     *mp;            /* file system mount structure */
-        xfs_fsblock_t   sb;             /* summary file block number */
-        xfs_buf_t       *sumbp;         /* summary file block buffer */
-
-        mp = tp->t_mountp;
-
-        ASSERT(mp->m_rbmip->i_itemp != NULL);
-        ASSERT(xfs_isilocked(mp->m_rbmip, XFS_ILOCK_EXCL));
-
-#ifdef DEBUG
-        /*
-         * Check to see that this whole range is currently allocated.
-         */
-        {
-                int     stat;           /* result from checking range */
-
-                error = xfs_rtcheck_alloc_range(mp, tp, bno, len, &stat);
-                if (error) {
-                        return error;
-                }
-                ASSERT(stat);
-        }
-#endif
-        sumbp = NULL;
-        /*
-         * Free the range of realtime blocks.
-         */
-        error = xfs_rtfree_range(mp, tp, bno, len, &sumbp, &sb);
-        if (error) {
-                return error;
-        }
-        /*
-         * Mark more blocks free in the superblock.
-         */
-        xfs_trans_mod_sb(tp, XFS_TRANS_SB_FREXTENTS, (long)len);
-        /*
-         * If we've now freed all the blocks, reset the file sequence
-         * number to 0.
-         */
-        if (tp->t_frextents_delta + mp->m_sb.sb_frextents ==
-            mp->m_sb.sb_rextents) {
-                if (!(mp->m_rbmip->i_d.di_flags & XFS_DIFLAG_NEWRTBM))
-                        mp->m_rbmip->i_d.di_flags |= XFS_DIFLAG_NEWRTBM;
-                *(__uint64_t *)&mp->m_rbmip->i_d.di_atime = 0;
-                xfs_trans_log_inode(tp, mp->m_rbmip, XFS_ILOG_CORE);
-        }
-        return 0;
-}
-
-/*
  * Initialize realtime fields in the mount structure.
  */
 int                             /* error */
diff --git a/fs/xfs/xfs_rtalloc.h b/fs/xfs/xfs_rtalloc.h
index b2a1a24c0e2f..752b63d10300 100644
--- a/fs/xfs/xfs_rtalloc.h
+++ b/fs/xfs/xfs_rtalloc.h
@@ -95,6 +95,30 @@ xfs_growfs_rt(
         struct xfs_mount        *mp,    /* file system mount structure */
         xfs_growfs_rt_t         *in);   /* user supplied growfs struct */
 
+/*
+ * From xfs_rtbitmap.c
+ */
+int xfs_rtbuf_get(struct xfs_mount *mp, struct xfs_trans *tp,
+                  xfs_rtblock_t block, int issum, struct xfs_buf **bpp);
+int xfs_rtcheck_range(struct xfs_mount *mp, struct xfs_trans *tp,
+                      xfs_rtblock_t start, xfs_extlen_t len, int val,
+                      xfs_rtblock_t *new, int *stat);
+int xfs_rtfind_back(struct xfs_mount *mp, struct xfs_trans *tp,
+                    xfs_rtblock_t start, xfs_rtblock_t limit,
+                    xfs_rtblock_t *rtblock);
+int xfs_rtfind_forw(struct xfs_mount *mp, struct xfs_trans *tp,
+                    xfs_rtblock_t start, xfs_rtblock_t limit,
+                    xfs_rtblock_t *rtblock);
+int xfs_rtmodify_range(struct xfs_mount *mp, struct xfs_trans *tp,
+                       xfs_rtblock_t start, xfs_extlen_t len, int val);
+int xfs_rtmodify_summary(struct xfs_mount *mp, struct xfs_trans *tp, int log,
+                         xfs_rtblock_t bbno, int delta, xfs_buf_t **rbpp,
+                         xfs_fsblock_t *rsb);
+int xfs_rtfree_range(struct xfs_mount *mp, struct xfs_trans *tp,
+                     xfs_rtblock_t start, xfs_extlen_t len,
+                     struct xfs_buf **rbpp, xfs_fsblock_t *rsb);
+
+
 #else
 # define xfs_rtallocate_extent(t,b,min,max,l,a,f,p,rb)  (ENOSYS)
 # define xfs_rtfree_extent(t,b,l)                       (ENOSYS)
diff --git a/fs/xfs/xfs_rtbitmap.c b/fs/xfs/xfs_rtbitmap.c
new file mode 100644
index 000000000000..b1f2fe8af4a8
--- /dev/null
+++ b/fs/xfs/xfs_rtbitmap.c
@@ -0,0 +1,974 @@
+/*
+ * 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
+ */
+#include "xfs.h"
+#include "xfs_fs.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
+#include "xfs_bit.h"
+#include "xfs_sb.h"
+#include "xfs_ag.h"
+#include "xfs_mount.h"
+#include "xfs_inode.h"
+#include "xfs_bmap.h"
+#include "xfs_bmap_util.h"
+#include "xfs_bmap_btree.h"
+#include "xfs_alloc.h"
+#include "xfs_error.h"
+#include "xfs_trans.h"
+#include "xfs_trans_space.h"
+#include "xfs_trace.h"
+#include "xfs_buf.h"
+#include "xfs_icache.h"
+#include "xfs_dinode.h"
+#include "xfs_rtalloc.h"
+
+
+/*
+ * Realtime allocator bitmap functions shared with userspace.
+ */
+
+/*
+ * Get a buffer for the bitmap or summary file block specified.
+ * The buffer is returned read and locked.
+ */
+int
+xfs_rtbuf_get(
+        xfs_mount_t     *mp,            /* file system mount structure */
+        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_rtblock_t   block,          /* block number in bitmap or summary */
+        int             issum,          /* is summary not bitmap */
+        xfs_buf_t       **bpp)          /* output: buffer for the block */
+{
+        xfs_buf_t       *bp;            /* block buffer, result */
+        xfs_inode_t     *ip;            /* bitmap or summary inode */
+        xfs_bmbt_irec_t map;
+        int             nmap = 1;
+        int             error;          /* error value */
+
+        ip = issum ? mp->m_rsumip : mp->m_rbmip;
+
+        error = xfs_bmapi_read(ip, block, 1, &map, &nmap, XFS_DATA_FORK);
+        if (error)
+                return error;
+
+        ASSERT(map.br_startblock != NULLFSBLOCK);
+        error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
+                                   XFS_FSB_TO_DADDR(mp, map.br_startblock),
+                                   mp->m_bsize, 0, &bp, NULL);
+        if (error)
+                return error;
+        ASSERT(!xfs_buf_geterror(bp));
+        *bpp = bp;
+        return 0;
+}
+
+/*
+ * Searching backward from start to limit, find the first block whose
+ * allocated/free state is different from start's.
+ */
+int
+xfs_rtfind_back(
+        xfs_mount_t     *mp,            /* file system mount point */
+        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_rtblock_t   start,          /* starting block to look at */
+        xfs_rtblock_t   limit,          /* last block to look at */
+        xfs_rtblock_t   *rtblock)       /* out: start block found */
+{
+        xfs_rtword_t    *b;             /* current word in buffer */
+        int             bit;            /* bit number in the word */
+        xfs_rtblock_t   block;          /* bitmap block number */
+        xfs_buf_t       *bp;            /* buf for the block */
+        xfs_rtword_t    *bufp;          /* starting word in buffer */
+        int             error;          /* error value */
+        xfs_rtblock_t   firstbit;       /* first useful bit in the word */
+        xfs_rtblock_t   i;              /* current bit number rel. to start */
+        xfs_rtblock_t   len;            /* length of inspected area */
+        xfs_rtword_t    mask;           /* mask of relevant bits for value */
+        xfs_rtword_t    want;           /* mask for "good" values */
+        xfs_rtword_t    wdiff;          /* difference from wanted value */
+        int             word;           /* word number in the buffer */
+
+        /*
+         * Compute and read in starting bitmap block for starting block.
+         */
+        block = XFS_BITTOBLOCK(mp, start);
+        error = xfs_rtbuf_get(mp, tp, block, 0, &bp);
+        if (error) {
+                return error;
+        }
+        bufp = bp->b_addr;
+        /*
+         * Get the first word's index & point to it.
+         */
+        word = XFS_BITTOWORD(mp, start);
+        b = &bufp[word];
+        bit = (int)(start & (XFS_NBWORD - 1));
+        len = start - limit + 1;
+        /*
+         * Compute match value, based on the bit at start: if 1 (free)
+         * then all-ones, else all-zeroes.
+         */
+        want = (*b & ((xfs_rtword_t)1 << bit)) ? -1 : 0;
+        /*
+         * If the starting position is not word-aligned, deal with the
+         * partial word.
+         */
+        if (bit < XFS_NBWORD - 1) {
+                /*
+                 * Calculate first (leftmost) bit number to look at,
+                 * and mask for all the relevant bits in this word.
+                 */
+                firstbit = XFS_RTMAX((xfs_srtblock_t)(bit - len + 1), 0);
+                mask = (((xfs_rtword_t)1 << (bit - firstbit + 1)) - 1) <<
+                        firstbit;
+                /*
+                 * Calculate the difference between the value there
+                 * and what we're looking for.
+                 */
+                if ((wdiff = (*b ^ want) & mask)) {
+                        /*
+                         * Different.  Mark where we are and return.
+                         */
+                        xfs_trans_brelse(tp, bp);
+                        i = bit - XFS_RTHIBIT(wdiff);
+                        *rtblock = start - i + 1;
+                        return 0;
+                }
+                i = bit - firstbit + 1;
+                /*
+                 * Go on to previous block if that's where the previous word is
+                 * and we need the previous word.
+                 */
+                if (--word == -1 && i < len) {
+                        /*
+                         * If done with this block, get the previous one.
+                         */
+                        xfs_trans_brelse(tp, bp);
+                        error = xfs_rtbuf_get(mp, tp, --block, 0, &bp);
+                        if (error) {
+                                return error;
+                        }
+                        bufp = bp->b_addr;
+                        word = XFS_BLOCKWMASK(mp);
+                        b = &bufp[word];
+                } else {
+                        /*
+                         * Go on to the previous word in the buffer.
+                         */
+                        b--;
+                }
+        } else {
+                /*
+                 * Starting on a word boundary, no partial word.
+                 */
+                i = 0;
+        }
+        /*
+         * Loop over whole words in buffers.  When we use up one buffer
+         * we move on to the previous one.
+         */
+        while (len - i >= XFS_NBWORD) {
+                /*
+                 * Compute difference between actual and desired value.
+                 */
+                if ((wdiff = *b ^ want)) {
+                        /*
+                         * Different, mark where we are and return.
+                         */
+                        xfs_trans_brelse(tp, bp);
+                        i += XFS_NBWORD - 1 - XFS_RTHIBIT(wdiff);
+                        *rtblock = start - i + 1;
+                        return 0;
+                }
+                i += XFS_NBWORD;
+                /*
+                 * Go on to previous block if that's where the previous word is
+                 * and we need the previous word.
+                 */
+                if (--word == -1 && i < len) {
+                        /*
+                         * If done with this block, get the previous one.
+                         */
+                        xfs_trans_brelse(tp, bp);
+                        error = xfs_rtbuf_get(mp, tp, --block, 0, &bp);
+                        if (error) {
+                                return error;
+                        }
+                        bufp = bp->b_addr;
+                        word = XFS_BLOCKWMASK(mp);
+                        b = &bufp[word];
+                } else {
+                        /*
+                         * Go on to the previous word in the buffer.
+                         */
+                        b--;
+                }
+        }
+        /*
+         * If not ending on a word boundary, deal with the last
+         * (partial) word.
+         */
+        if (len - i) {
+                /*
+                 * Calculate first (leftmost) bit number to look at,
+                 * and mask for all the relevant bits in this word.
+                 */
+                firstbit = XFS_NBWORD - (len - i);
+                mask = (((xfs_rtword_t)1 << (len - i)) - 1) << firstbit;
+                /*
+                 * Compute difference between actual and desired value.
+                 */
+                if ((wdiff = (*b ^ want) & mask)) {
+                        /*
+                         * Different, mark where we are and return.
+                         */
+                        xfs_trans_brelse(tp, bp);
+                        i += XFS_NBWORD - 1 - XFS_RTHIBIT(wdiff);
+                        *rtblock = start - i + 1;
+                        return 0;
+                } else
+                        i = len;
+        }
+        /*
+         * No match, return that we scanned the whole area.
+         */
+        xfs_trans_brelse(tp, bp);
+        *rtblock = start - i + 1;
+        return 0;
+}
+
+/*
+ * Searching forward from start to limit, find the first block whose
+ * allocated/free state is different from start's.
+ */
+int
+xfs_rtfind_forw(
+        xfs_mount_t     *mp,            /* file system mount point */
+        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_rtblock_t   start,          /* starting block to look at */
+        xfs_rtblock_t   limit,          /* last block to look at */
+        xfs_rtblock_t   *rtblock)       /* out: start block found */
+{
+        xfs_rtword_t    *b;             /* current word in buffer */
+        int             bit;            /* bit number in the word */
+        xfs_rtblock_t   block;          /* bitmap block number */
+        xfs_buf_t       *bp;            /* buf for the block */
+        xfs_rtword_t    *bufp;          /* starting word in buffer */
+        int             error;          /* error value */
+        xfs_rtblock_t   i;              /* current bit number rel. to start */
+        xfs_rtblock_t   lastbit;        /* last useful bit in the word */
+        xfs_rtblock_t   len;            /* length of inspected area */
+        xfs_rtword_t    mask;           /* mask of relevant bits for value */
+        xfs_rtword_t    want;           /* mask for "good" values */
+        xfs_rtword_t    wdiff;          /* difference from wanted value */
+        int             word;           /* word number in the buffer */
+
+        /*
+         * Compute and read in starting bitmap block for starting block.
+         */
+        block = XFS_BITTOBLOCK(mp, start);
+        error = xfs_rtbuf_get(mp, tp, block, 0, &bp);
+        if (error) {
+                return error;
+        }
+        bufp = bp->b_addr;
+        /*
+         * Get the first word's index & point to it.
+         */
+        word = XFS_BITTOWORD(mp, start);
+        b = &bufp[word];
+        bit = (int)(start & (XFS_NBWORD - 1));
+        len = limit - start + 1;
+        /*
+         * Compute match value, based on the bit at start: if 1 (free)
+         * then all-ones, else all-zeroes.
+         */
+        want = (*b & ((xfs_rtword_t)1 << bit)) ? -1 : 0;
+        /*
+         * If the starting position is not word-aligned, deal with the
+         * partial word.
+         */
+        if (bit) {
+                /*
+                 * Calculate last (rightmost) bit number to look at,
+                 * and mask for all the relevant bits in this word.
+                 */
+                lastbit = XFS_RTMIN(bit + len, XFS_NBWORD);
+                mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
+                /*
+                 * Calculate the difference between the value there
+                 * and what we're looking for.
+                 */
+                if ((wdiff = (*b ^ want) & mask)) {
+                        /*
+                         * Different.  Mark where we are and return.
+                         */
+                        xfs_trans_brelse(tp, bp);
+                        i = XFS_RTLOBIT(wdiff) - bit;
+                        *rtblock = start + i - 1;
+                        return 0;
+                }
+                i = lastbit - bit;
+                /*
+                 * Go on to next block if that's where the next word is
+                 * and we need the next word.
+                 */
+                if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
+                        /*
+                         * If done with this block, get the previous one.
+                         */
+                        xfs_trans_brelse(tp, bp);
+                        error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
+                        if (error) {
+                                return error;
+                        }
+                        b = bufp = bp->b_addr;
+                        word = 0;
+                } else {
+                        /*
+                         * Go on to the previous word in the buffer.
+                         */
+                        b++;
+                }
+        } else {
+                /*
+                 * Starting on a word boundary, no partial word.
+                 */
+                i = 0;
+        }
+        /*
+         * Loop over whole words in buffers.  When we use up one buffer
+         * we move on to the next one.
+         */
+        while (len - i >= XFS_NBWORD) {
+                /*
+                 * Compute difference between actual and desired value.
+                 */
+                if ((wdiff = *b ^ want)) {
+                        /*
+                         * Different, mark where we are and return.
+                         */
+                        xfs_trans_brelse(tp, bp);
+                        i += XFS_RTLOBIT(wdiff);
+                        *rtblock = start + i - 1;
+                        return 0;
+                }
+                i += XFS_NBWORD;
+                /*
+                 * Go on to next block if that's where the next word is
+                 * and we need the next word.
+                 */
+                if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
+                        /*
+                         * If done with this block, get the next one.
+                         */
+                        xfs_trans_brelse(tp, bp);
+                        error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
+                        if (error) {
+                                return error;
+                        }
+                        b = bufp = bp->b_addr;
+                        word = 0;
+                } else {
+                        /*
+                         * Go on to the next word in the buffer.
+                         */
+                        b++;
+                }
+        }
+        /*
+         * If not ending on a word boundary, deal with the last
+         * (partial) word.
+         */
+        if ((lastbit = len - i)) {
+                /*
+                 * Calculate mask for all the relevant bits in this word.
+                 */
+                mask = ((xfs_rtword_t)1 << lastbit) - 1;
+                /*
+                 * Compute difference between actual and desired value.
+                 */
+                if ((wdiff = (*b ^ want) & mask)) {
+                        /*
+                         * Different, mark where we are and return.
+                         */
+                        xfs_trans_brelse(tp, bp);
+                        i += XFS_RTLOBIT(wdiff);
+                        *rtblock = start + i - 1;
+                        return 0;
+                } else
+                        i = len;
+        }
+        /*
+         * No match, return that we scanned the whole area.
+         */
+        xfs_trans_brelse(tp, bp);
+        *rtblock = start + i - 1;
+        return 0;
+}
+
+/*
+ * Read and modify the summary information for a given extent size,
+ * bitmap block combination.
+ * Keeps track of a current summary block, so we don't keep reading
+ * it from the buffer cache.
+ */
+int
+xfs_rtmodify_summary(
+        xfs_mount_t     *mp,            /* file system mount point */
+        xfs_trans_t     *tp,            /* transaction pointer */
+        int             log,            /* log2 of extent size */
+        xfs_rtblock_t   bbno,           /* bitmap block number */
+        int             delta,          /* change to make to summary info */
+        xfs_buf_t       **rbpp,         /* in/out: summary block buffer */
+        xfs_fsblock_t   *rsb)           /* in/out: summary block number */
+{
+        xfs_buf_t       *bp;            /* buffer for the summary block */
+        int             error;          /* error value */
+        xfs_fsblock_t   sb;             /* summary fsblock */
+        int             so;             /* index into the summary file */
+        xfs_suminfo_t   *sp;            /* pointer to returned data */
+
+        /*
+         * Compute entry number in the summary file.
+         */
+        so = XFS_SUMOFFS(mp, log, bbno);
+        /*
+         * Compute the block number in the summary file.
+         */
+        sb = XFS_SUMOFFSTOBLOCK(mp, so);
+        /*
+         * If we have an old buffer, and the block number matches, use that.
+         */
+        if (rbpp && *rbpp && *rsb == sb)
+                bp = *rbpp;
+        /*
+         * Otherwise we have to get the buffer.
+         */
+        else {
+                /*
+                 * If there was an old one, get rid of it first.
+                 */
+                if (rbpp && *rbpp)
+                        xfs_trans_brelse(tp, *rbpp);
+                error = xfs_rtbuf_get(mp, tp, sb, 1, &bp);
+                if (error) {
+                        return error;
+                }
+                /*
+                 * Remember this buffer and block for the next call.
+                 */
+                if (rbpp) {
+                        *rbpp = bp;
+                        *rsb = sb;
+                }
+        }
+        /*
+         * Point to the summary information, modify and log it.
+         */
+        sp = XFS_SUMPTR(mp, bp, so);
+        *sp += delta;
+        xfs_trans_log_buf(tp, bp, (uint)((char *)sp - (char *)bp->b_addr),
+                (uint)((char *)sp - (char *)bp->b_addr + sizeof(*sp) - 1));
+        return 0;
+}
+
+/*
+ * Set the given range of bitmap bits to the given value.
+ * Do whatever I/O and logging is required.
+ */
+int
+xfs_rtmodify_range(
+        xfs_mount_t     *mp,            /* file system mount point */
+        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_rtblock_t   start,          /* starting block to modify */
+        xfs_extlen_t    len,            /* length of extent to modify */
+        int             val)            /* 1 for free, 0 for allocated */
+{
+        xfs_rtword_t    *b;             /* current word in buffer */
+        int             bit;            /* bit number in the word */
+        xfs_rtblock_t   block;          /* bitmap block number */
+        xfs_buf_t       *bp;            /* buf for the block */
+        xfs_rtword_t    *bufp;          /* starting word in buffer */
+        int             error;          /* error value */
+        xfs_rtword_t    *first;         /* first used word in the buffer */
+        int             i;              /* current bit number rel. to start */
+        int             lastbit;        /* last useful bit in word */
+        xfs_rtword_t    mask;           /* mask o frelevant bits for value */
+        int             word;           /* word number in the buffer */
+
+        /*
+         * Compute starting bitmap block number.
+         */
+        block = XFS_BITTOBLOCK(mp, start);
+        /*
+         * Read the bitmap block, and point to its data.
+         */
+        error = xfs_rtbuf_get(mp, tp, block, 0, &bp);
+        if (error) {
+                return error;
+        }
+        bufp = bp->b_addr;
+        /*
+         * Compute the starting word's address, and starting bit.
+         */
+        word = XFS_BITTOWORD(mp, start);
+        first = b = &bufp[word];
+        bit = (int)(start & (XFS_NBWORD - 1));
+        /*
+         * 0 (allocated) => all zeroes; 1 (free) => all ones.
+         */
+        val = -val;
+        /*
+         * If not starting on a word boundary, deal with the first
+         * (partial) word.
+         */
+        if (bit) {
+                /*
+                 * Compute first bit not changed and mask of relevant bits.
+                 */
+                lastbit = XFS_RTMIN(bit + len, XFS_NBWORD);
+                mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
+                /*
+                 * Set/clear the active bits.
+                 */
+                if (val)
+                        *b |= mask;
+                else
+                        *b &= ~mask;
+                i = lastbit - bit;
+                /*
+                 * Go on to the next block if that's where the next word is
+                 * and we need the next word.
+                 */
+                if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
+                        /*
+                         * Log the changed part of this block.
+                         * Get the next one.
+                         */
+                        xfs_trans_log_buf(tp, bp,
+                                (uint)((char *)first - (char *)bufp),
+                                (uint)((char *)b - (char *)bufp));
+                        error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
+                        if (error) {
+                                return error;
+                        }
+                        first = b = bufp = bp->b_addr;
+                        word = 0;
+                } else {
+                        /*
+                         * Go on to the next word in the buffer
+                         */
+                        b++;
+                }
+        } else {
+                /*
+                 * Starting on a word boundary, no partial word.
+                 */
+                i = 0;
+        }
+        /*
+         * Loop over whole words in buffers.  When we use up one buffer
+         * we move on to the next one.
+         */
+        while (len - i >= XFS_NBWORD) {
+                /*
+                 * Set the word value correctly.
+                 */
+                *b = val;
+                i += XFS_NBWORD;
+                /*
+                 * Go on to the next block if that's where the next word is
+                 * and we need the next word.
+                 */
+                if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
+                        /*
+                         * Log the changed part of this block.
+                         * Get the next one.
+                         */
+                        xfs_trans_log_buf(tp, bp,
+                                (uint)((char *)first - (char *)bufp),
+                                (uint)((char *)b - (char *)bufp));
+                        error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
+                        if (error) {
+                                return error;
+                        }
+                        first = b = bufp = bp->b_addr;
+                        word = 0;
+                } else {
+                        /*
+                         * Go on to the next word in the buffer
+                         */
+                        b++;
+                }
+        }
+        /*
+         * If not ending on a word boundary, deal with the last
+         * (partial) word.
+         */
+        if ((lastbit = len - i)) {
+                /*
+                 * Compute a mask of relevant bits.
+                 */
+                bit = 0;
+                mask = ((xfs_rtword_t)1 << lastbit) - 1;
+                /*
+                 * Set/clear the active bits.
+                 */
+                if (val)
+                        *b |= mask;
+                else
+                        *b &= ~mask;
+                b++;
+        }
+        /*
+         * Log any remaining changed bytes.
+         */
+        if (b > first)
+                xfs_trans_log_buf(tp, bp, (uint)((char *)first - (char *)bufp),
+                        (uint)((char *)b - (char *)bufp - 1));
+        return 0;
+}
+
+/*
+ * Mark an extent specified by start and len freed.
+ * Updates all the summary information as well as the bitmap.
+ */
+int
+xfs_rtfree_range(
+        xfs_mount_t     *mp,            /* file system mount point */
+        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_rtblock_t   start,          /* starting block to free */
+        xfs_extlen_t    len,            /* length to free */
+        xfs_buf_t       **rbpp,         /* in/out: summary block buffer */
+        xfs_fsblock_t   *rsb)           /* in/out: summary block number */
+{
+        xfs_rtblock_t   end;            /* end of the freed extent */
+        int             error;          /* error value */
+        xfs_rtblock_t   postblock;      /* first block freed > end */
+        xfs_rtblock_t   preblock;       /* first block freed < start */
+
+        end = start + len - 1;
+        /*
+         * Modify the bitmap to mark this extent freed.
+         */
+        error = xfs_rtmodify_range(mp, tp, start, len, 1);
+        if (error) {
+                return error;
+        }
+        /*
+         * Assume we're freeing out of the middle of an allocated extent.
+         * We need to find the beginning and end of the extent so we can
+         * properly update the summary.
+         */
+        error = xfs_rtfind_back(mp, tp, start, 0, &preblock);
+        if (error) {
+                return error;
+        }
+        /*
+         * Find the next allocated block (end of allocated extent).
+         */
+        error = xfs_rtfind_forw(mp, tp, end, mp->m_sb.sb_rextents - 1,
+                &postblock);
+        if (error)
+                return error;
+        /*
+         * If there are blocks not being freed at the front of the
+         * old extent, add summary data for them to be allocated.
+         */
+        if (preblock < start) {
+                error = xfs_rtmodify_summary(mp, tp,
+                        XFS_RTBLOCKLOG(start - preblock),
+                        XFS_BITTOBLOCK(mp, preblock), -1, rbpp, rsb);
+                if (error) {
+                        return error;
+                }
+        }
+        /*
+         * If there are blocks not being freed at the end of the
+         * old extent, add summary data for them to be allocated.
+         */
+        if (postblock > end) {
+                error = xfs_rtmodify_summary(mp, tp,
+                        XFS_RTBLOCKLOG(postblock - end),
+                        XFS_BITTOBLOCK(mp, end + 1), -1, rbpp, rsb);
+                if (error) {
+                        return error;
+                }
+        }
+        /*
+         * Increment the summary information corresponding to the entire
+         * (new) free extent.
+         */
+        error = xfs_rtmodify_summary(mp, tp,
+                XFS_RTBLOCKLOG(postblock + 1 - preblock),
+                XFS_BITTOBLOCK(mp, preblock), 1, rbpp, rsb);
+        return error;
+}
+
+/*
+ * Check that the given range is either all allocated (val = 0) or
+ * all free (val = 1).
+ */
+int
+xfs_rtcheck_range(
+        xfs_mount_t     *mp,            /* file system mount point */
+        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_rtblock_t   start,          /* starting block number of extent */
+        xfs_extlen_t    len,            /* length of extent */
+        int             val,            /* 1 for free, 0 for allocated */
+        xfs_rtblock_t   *new,           /* out: first block not matching */
+        int             *stat)          /* out: 1 for matches, 0 for not */
+{
+        xfs_rtword_t    *b;             /* current word in buffer */
+        int             bit;            /* bit number in the word */
+        xfs_rtblock_t   block;          /* bitmap block number */
+        xfs_buf_t       *bp;            /* buf for the block */
+        xfs_rtword_t    *bufp;          /* starting word in buffer */
+        int             error;          /* error value */
+        xfs_rtblock_t   i;              /* current bit number rel. to start */
+        xfs_rtblock_t   lastbit;        /* last useful bit in word */
+        xfs_rtword_t    mask;           /* mask of relevant bits for value */
+        xfs_rtword_t    wdiff;          /* difference from wanted value */
+        int             word;           /* word number in the buffer */
+
+        /*
+         * Compute starting bitmap block number
+         */
+        block = XFS_BITTOBLOCK(mp, start);
+        /*
+         * Read the bitmap block.
+         */
+        error = xfs_rtbuf_get(mp, tp, block, 0, &bp);
+        if (error) {
+                return error;
+        }
+        bufp = bp->b_addr;
+        /*
+         * Compute the starting word's address, and starting bit.
+         */
+        word = XFS_BITTOWORD(mp, start);
+        b = &bufp[word];
+        bit = (int)(start & (XFS_NBWORD - 1));
+        /*
+         * 0 (allocated) => all zero's; 1 (free) => all one's.
+         */
+        val = -val;
+        /*
+         * If not starting on a word boundary, deal with the first
+         * (partial) word.
+         */
+        if (bit) {
+                /*
+                 * Compute first bit not examined.
+                 */
+                lastbit = XFS_RTMIN(bit + len, XFS_NBWORD);
+                /*
+                 * Mask of relevant bits.
+                 */
+                mask = (((xfs_rtword_t)1 << (lastbit - bit)) - 1) << bit;
+                /*
+                 * Compute difference between actual and desired value.
+                 */
+                if ((wdiff = (*b ^ val) & mask)) {
+                        /*
+                         * Different, compute first wrong bit and return.
+                         */
+                        xfs_trans_brelse(tp, bp);
+                        i = XFS_RTLOBIT(wdiff) - bit;
+                        *new = start + i;
+                        *stat = 0;
+                        return 0;
+                }
+                i = lastbit - bit;
+                /*
+                 * Go on to next block if that's where the next word is
+                 * and we need the next word.
+                 */
+                if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
+                        /*
+                         * If done with this block, get the next one.
+                         */
+                        xfs_trans_brelse(tp, bp);
+                        error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
+                        if (error) {
+                                return error;
+                        }
+                        b = bufp = bp->b_addr;
+                        word = 0;
+                } else {
+                        /*
+                         * Go on to the next word in the buffer.
+                         */
+                        b++;
+                }
+        } else {
+                /*
+                 * Starting on a word boundary, no partial word.
+                 */
+                i = 0;
+        }
+        /*
+         * Loop over whole words in buffers.  When we use up one buffer
+         * we move on to the next one.
+         */
+        while (len - i >= XFS_NBWORD) {
+                /*
+                 * Compute difference between actual and desired value.
+                 */
+                if ((wdiff = *b ^ val)) {
+                        /*
+                         * Different, compute first wrong bit and return.
+                         */
+                        xfs_trans_brelse(tp, bp);
+                        i += XFS_RTLOBIT(wdiff);
+                        *new = start + i;
+                        *stat = 0;
+                        return 0;
+                }
+                i += XFS_NBWORD;
+                /*
+                 * Go on to next block if that's where the next word is
+                 * and we need the next word.
+                 */
+                if (++word == XFS_BLOCKWSIZE(mp) && i < len) {
+                        /*
+                         * If done with this block, get the next one.
+                         */
+                        xfs_trans_brelse(tp, bp);
+                        error = xfs_rtbuf_get(mp, tp, ++block, 0, &bp);
+                        if (error) {
+                                return error;
+                        }
+                        b = bufp = bp->b_addr;
+                        word = 0;
+                } else {
+                        /*
+                         * Go on to the next word in the buffer.
+                         */
+                        b++;
+                }
+        }
+        /*
+         * If not ending on a word boundary, deal with the last
+         * (partial) word.
+         */
+        if ((lastbit = len - i)) {
+                /*
+                 * Mask of relevant bits.
+                 */
+                mask = ((xfs_rtword_t)1 << lastbit) - 1;
+                /*
+                 * Compute difference between actual and desired value.
+                 */
+                if ((wdiff = (*b ^ val) & mask)) {
+                        /*
+                         * Different, compute first wrong bit and return.
+                         */
+                        xfs_trans_brelse(tp, bp);
+                        i += XFS_RTLOBIT(wdiff);
+                        *new = start + i;
+                        *stat = 0;
+                        return 0;
+                } else
+                        i = len;
+        }
+        /*
+         * Successful, return.
+         */
+        xfs_trans_brelse(tp, bp);
+        *new = start + i;
+        *stat = 1;
+        return 0;
+}
+
+#ifdef DEBUG
+/*
+ * Check that the given extent (block range) is allocated already.
+ */
+STATIC int                              /* error */
+xfs_rtcheck_alloc_range(
+        xfs_mount_t     *mp,            /* file system mount point */
+        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_rtblock_t   bno,            /* starting block number of extent */
+        xfs_extlen_t    len)            /* length of extent */
+{
+        xfs_rtblock_t   new;            /* dummy for xfs_rtcheck_range */
+        int             stat;
+        int             error;
+
+        error = xfs_rtcheck_range(mp, tp, bno, len, 0, &new, &stat);
+        if (error)
+                return error;
+        ASSERT(stat);
+        return 0;
+}
+#else
+#define xfs_rtcheck_alloc_range(m,t,b,l)        (0)
+#endif
+/*
+ * Free an extent in the realtime subvolume.  Length is expressed in
+ * realtime extents, as is the block number.
+ */
+int                                     /* error */
+xfs_rtfree_extent(
+        xfs_trans_t     *tp,            /* transaction pointer */
+        xfs_rtblock_t   bno,            /* starting block number to free */
+        xfs_extlen_t    len)            /* length of extent freed */
+{
+        int             error;          /* error value */
+        xfs_mount_t     *mp;            /* file system mount structure */
+        xfs_fsblock_t   sb;             /* summary file block number */
+        xfs_buf_t       *sumbp = NULL;  /* summary file block buffer */
+
+        mp = tp->t_mountp;
+
+        ASSERT(mp->m_rbmip->i_itemp != NULL);
+        ASSERT(xfs_isilocked(mp->m_rbmip, XFS_ILOCK_EXCL));
+
+        error = xfs_rtcheck_alloc_range(mp, tp, bno, len);
+        if (error)
+                return error;
+
+        /*
+         * Free the range of realtime blocks.
+         */
+        error = xfs_rtfree_range(mp, tp, bno, len, &sumbp, &sb);
+        if (error) {
+                return error;
+        }
+        /*
+         * Mark more blocks free in the superblock.
+         */
+        xfs_trans_mod_sb(tp, XFS_TRANS_SB_FREXTENTS, (long)len);
+        /*
+         * If we've now freed all the blocks, reset the file sequence
+         * number to 0.
+         */
+        if (tp->t_frextents_delta + mp->m_sb.sb_frextents ==
+            mp->m_sb.sb_rextents) {
+                if (!(mp->m_rbmip->i_d.di_flags & XFS_DIFLAG_NEWRTBM))
+                        mp->m_rbmip->i_d.di_flags |= XFS_DIFLAG_NEWRTBM;
+                *(__uint64_t *)&mp->m_rbmip->i_d.di_atime = 0;
+                xfs_trans_log_inode(tp, mp->m_rbmip, XFS_ILOG_CORE);
+        }
+        return 0;
+}
+
diff --git a/fs/xfs/xfs_sb.c b/fs/xfs/xfs_sb.c
index a5b59d92eb70..b7c9aea77f8f 100644
--- a/fs/xfs/xfs_sb.c
+++ b/fs/xfs/xfs_sb.c
@@ -17,34 +17,26 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_inum.h"
-#include "xfs_trans.h"
-#include "xfs_trans_priv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_da_btree.h"
-#include "xfs_dir2_format.h"
-#include "xfs_dir2.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
-#include "xfs_btree.h"
 #include "xfs_ialloc.h"
 #include "xfs_alloc.h"
-#include "xfs_rtalloc.h"
-#include "xfs_bmap.h"
 #include "xfs_error.h"
-#include "xfs_quota.h"
-#include "xfs_fsops.h"
 #include "xfs_trace.h"
 #include "xfs_cksum.h"
+#include "xfs_trans.h"
 #include "xfs_buf_item.h"
+#include "xfs_dinode.h"
+#include "xfs_bmap_btree.h"
+#include "xfs_alloc_btree.h"
+#include "xfs_ialloc_btree.h"
 
 /*
  * Physical superblock buffer manipulations. Shared with libxfs in userspace.
@@ -249,13 +241,13 @@ xfs_mount_validate_sb(
         if (xfs_sb_version_has_pquotino(sbp)) {
                 if (sbp->sb_qflags & (XFS_OQUOTA_ENFD | XFS_OQUOTA_CHKD)) {
                         xfs_notice(mp,
-                           "Version 5 of Super block has XFS_OQUOTA bits.\n");
+                           "Version 5 of Super block has XFS_OQUOTA bits.");
                         return XFS_ERROR(EFSCORRUPTED);
                 }
         } else if (sbp->sb_qflags & (XFS_PQUOTA_ENFD | XFS_GQUOTA_ENFD |
                                 XFS_PQUOTA_CHKD | XFS_GQUOTA_CHKD)) {
                         xfs_notice(mp,
-"Superblock earlier than Version 5 has XFS_[PQ]UOTA_{ENFD|CHKD} bits.\n");
+"Superblock earlier than Version 5 has XFS_[PQ]UOTA_{ENFD|CHKD} bits.");
                         return XFS_ERROR(EFSCORRUPTED);
         }
 
@@ -596,6 +588,11 @@ xfs_sb_verify(
  * single bit error could clear the feature bit and unused parts of the
  * superblock are supposed to be zero. Hence a non-null crc field indicates that
  * we've potentially lost a feature bit and we should check it anyway.
+ *
+ * However, past bugs (i.e. in growfs) left non-zeroed regions beyond the
+ * last field in V4 secondary superblocks.  So for secondary superblocks,
+ * we are more forgiving, and ignore CRC failures if the primary doesn't
+ * indicate that the fs version is V5.
  */
 static void
 xfs_sb_read_verify(
@@ -616,16 +613,21 @@ xfs_sb_read_verify(
 
                 if (!xfs_verify_cksum(bp->b_addr, be16_to_cpu(dsb->sb_sectsize),
                                       offsetof(struct xfs_sb, sb_crc))) {
-                        error = EFSCORRUPTED;
-                        goto out_error;
+                        /* Only fail bad secondaries on a known V5 filesystem */
+                        if (bp->b_bn != XFS_SB_DADDR &&
+                            xfs_sb_version_hascrc(&mp->m_sb)) {
+                                error = EFSCORRUPTED;
+                                goto out_error;
+                        }
                 }
         }
         error = xfs_sb_verify(bp, true);
 
 out_error:
         if (error) {
-                XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW,
-                                     mp, bp->b_addr);
+                if (error != EWRONGFS)
+                        XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW,
+                                             mp, bp->b_addr);
                 xfs_buf_ioerror(bp, error);
         }
 }
diff --git a/fs/xfs/xfs_sb.h b/fs/xfs/xfs_sb.h
index 6835b44f850e..35061d4b614c 100644
--- a/fs/xfs/xfs_sb.h
+++ b/fs/xfs/xfs_sb.h
@@ -699,7 +699,4 @@ extern void	xfs_sb_from_disk(struct xfs_sb *, struct xfs_dsb *);
 extern void     xfs_sb_to_disk(struct xfs_dsb *, struct xfs_sb *, __int64_t);
 extern void     xfs_sb_quota_from_disk(struct xfs_sb *sbp);
 
-extern const struct xfs_buf_ops xfs_sb_buf_ops;
-extern const struct xfs_buf_ops xfs_sb_quiet_buf_ops;
-
 #endif  /* __XFS_SB_H__ */
diff --git a/fs/xfs/xfs_shared.h b/fs/xfs/xfs_shared.h
new file mode 100644
index 000000000000..8c5035a13df1
--- /dev/null
+++ b/fs/xfs/xfs_shared.h
@@ -0,0 +1,244 @@
+/*
+ * Copyright (c) 2000-2005 Silicon Graphics, Inc.
+ * Copyright (c) 2013 Red Hat, 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_SHARED_H__
+#define __XFS_SHARED_H__
+
+/*
+ * Definitions shared between kernel and userspace that don't fit into any other
+ * header file that is shared with userspace.
+ */
+struct xfs_ifork;
+struct xfs_buf;
+struct xfs_buf_ops;
+struct xfs_mount;
+struct xfs_trans;
+struct xfs_inode;
+
+/*
+ * Buffer verifier operations are widely used, including userspace tools
+ */
+extern const struct xfs_buf_ops xfs_agf_buf_ops;
+extern const struct xfs_buf_ops xfs_agi_buf_ops;
+extern const struct xfs_buf_ops xfs_agf_buf_ops;
+extern const struct xfs_buf_ops xfs_agfl_buf_ops;
+extern const struct xfs_buf_ops xfs_allocbt_buf_ops;
+extern const struct xfs_buf_ops xfs_attr3_leaf_buf_ops;
+extern const struct xfs_buf_ops xfs_attr3_rmt_buf_ops;
+extern const struct xfs_buf_ops xfs_bmbt_buf_ops;
+extern const struct xfs_buf_ops xfs_da3_node_buf_ops;
+extern const struct xfs_buf_ops xfs_dquot_buf_ops;
+extern const struct xfs_buf_ops xfs_symlink_buf_ops;
+extern const struct xfs_buf_ops xfs_agi_buf_ops;
+extern const struct xfs_buf_ops xfs_inobt_buf_ops;
+extern const struct xfs_buf_ops xfs_inode_buf_ops;
+extern const struct xfs_buf_ops xfs_inode_buf_ra_ops;
+extern const struct xfs_buf_ops xfs_dquot_buf_ops;
+extern const struct xfs_buf_ops xfs_sb_buf_ops;
+extern const struct xfs_buf_ops xfs_sb_quiet_buf_ops;
+extern const struct xfs_buf_ops xfs_symlink_buf_ops;
+
+/*
+ * Transaction types.  Used to distinguish types of buffers. These never reach
+ * the log.
+ */
+#define XFS_TRANS_SETATTR_NOT_SIZE      1
+#define XFS_TRANS_SETATTR_SIZE          2
+#define XFS_TRANS_INACTIVE              3
+#define XFS_TRANS_CREATE                4
+#define XFS_TRANS_CREATE_TRUNC          5
+#define XFS_TRANS_TRUNCATE_FILE         6
+#define XFS_TRANS_REMOVE                7
+#define XFS_TRANS_LINK                  8
+#define XFS_TRANS_RENAME                9
+#define XFS_TRANS_MKDIR                 10
+#define XFS_TRANS_RMDIR                 11
+#define XFS_TRANS_SYMLINK               12
+#define XFS_TRANS_SET_DMATTRS           13
+#define XFS_TRANS_GROWFS                14
+#define XFS_TRANS_STRAT_WRITE           15
+#define XFS_TRANS_DIOSTRAT              16
+/* 17 was XFS_TRANS_WRITE_SYNC */
+#define XFS_TRANS_WRITEID               18
+#define XFS_TRANS_ADDAFORK              19
+#define XFS_TRANS_ATTRINVAL             20
+#define XFS_TRANS_ATRUNCATE             21
+#define XFS_TRANS_ATTR_SET              22
+#define XFS_TRANS_ATTR_RM               23
+#define XFS_TRANS_ATTR_FLAG             24
+#define XFS_TRANS_CLEAR_AGI_BUCKET      25
+#define XFS_TRANS_QM_SBCHANGE           26
+/*
+ * Dummy entries since we use the transaction type to index into the
+ * trans_type[] in xlog_recover_print_trans_head()
+ */
+#define XFS_TRANS_DUMMY1                27
+#define XFS_TRANS_DUMMY2                28
+#define XFS_TRANS_QM_QUOTAOFF           29
+#define XFS_TRANS_QM_DQALLOC            30
+#define XFS_TRANS_QM_SETQLIM            31
+#define XFS_TRANS_QM_DQCLUSTER          32
+#define XFS_TRANS_QM_QINOCREATE         33
+#define XFS_TRANS_QM_QUOTAOFF_END       34
+#define XFS_TRANS_SB_UNIT               35
+#define XFS_TRANS_FSYNC_TS              36
+#define XFS_TRANS_GROWFSRT_ALLOC        37
+#define XFS_TRANS_GROWFSRT_ZERO         38
+#define XFS_TRANS_GROWFSRT_FREE         39
+#define XFS_TRANS_SWAPEXT               40
+#define XFS_TRANS_SB_COUNT              41
+#define XFS_TRANS_CHECKPOINT            42
+#define XFS_TRANS_ICREATE               43
+#define XFS_TRANS_TYPE_MAX              43
+/* new transaction types need to be reflected in xfs_logprint(8) */
+
+#define XFS_TRANS_TYPES \
+        { XFS_TRANS_SETATTR_NOT_SIZE,   "SETATTR_NOT_SIZE" }, \
+        { XFS_TRANS_SETATTR_SIZE,       "SETATTR_SIZE" }, \
+        { XFS_TRANS_INACTIVE,           "INACTIVE" }, \
+        { XFS_TRANS_CREATE,             "CREATE" }, \
+        { XFS_TRANS_CREATE_TRUNC,       "CREATE_TRUNC" }, \
+        { XFS_TRANS_TRUNCATE_FILE,      "TRUNCATE_FILE" }, \
+        { XFS_TRANS_REMOVE,             "REMOVE" }, \
+        { XFS_TRANS_LINK,               "LINK" }, \
+        { XFS_TRANS_RENAME,             "RENAME" }, \
+        { XFS_TRANS_MKDIR,              "MKDIR" }, \
+        { XFS_TRANS_RMDIR,              "RMDIR" }, \
+        { XFS_TRANS_SYMLINK,            "SYMLINK" }, \
+        { XFS_TRANS_SET_DMATTRS,        "SET_DMATTRS" }, \
+        { XFS_TRANS_GROWFS,             "GROWFS" }, \
+        { XFS_TRANS_STRAT_WRITE,        "STRAT_WRITE" }, \
+        { XFS_TRANS_DIOSTRAT,           "DIOSTRAT" }, \
+        { XFS_TRANS_WRITEID,            "WRITEID" }, \
+        { XFS_TRANS_ADDAFORK,           "ADDAFORK" }, \
+        { XFS_TRANS_ATTRINVAL,          "ATTRINVAL" }, \
+        { XFS_TRANS_ATRUNCATE,          "ATRUNCATE" }, \
+        { XFS_TRANS_ATTR_SET,           "ATTR_SET" }, \
+        { XFS_TRANS_ATTR_RM,            "ATTR_RM" }, \
+        { XFS_TRANS_ATTR_FLAG,          "ATTR_FLAG" }, \
+        { XFS_TRANS_CLEAR_AGI_BUCKET,   "CLEAR_AGI_BUCKET" }, \
+        { XFS_TRANS_QM_SBCHANGE,        "QM_SBCHANGE" }, \
+        { XFS_TRANS_QM_QUOTAOFF,        "QM_QUOTAOFF" }, \
+        { XFS_TRANS_QM_DQALLOC,         "QM_DQALLOC" }, \
+        { XFS_TRANS_QM_SETQLIM,         "QM_SETQLIM" }, \
+        { XFS_TRANS_QM_DQCLUSTER,       "QM_DQCLUSTER" }, \
+        { XFS_TRANS_QM_QINOCREATE,      "QM_QINOCREATE" }, \
+        { XFS_TRANS_QM_QUOTAOFF_END,    "QM_QOFF_END" }, \
+        { XFS_TRANS_SB_UNIT,            "SB_UNIT" }, \
+        { XFS_TRANS_FSYNC_TS,           "FSYNC_TS" }, \
+        { XFS_TRANS_GROWFSRT_ALLOC,     "GROWFSRT_ALLOC" }, \
+        { XFS_TRANS_GROWFSRT_ZERO,      "GROWFSRT_ZERO" }, \
+        { XFS_TRANS_GROWFSRT_FREE,      "GROWFSRT_FREE" }, \
+        { XFS_TRANS_SWAPEXT,            "SWAPEXT" }, \
+        { XFS_TRANS_SB_COUNT,           "SB_COUNT" }, \
+        { XFS_TRANS_CHECKPOINT,         "CHECKPOINT" }, \
+        { XFS_TRANS_DUMMY1,             "DUMMY1" }, \
+        { XFS_TRANS_DUMMY2,             "DUMMY2" }, \
+        { XLOG_UNMOUNT_REC_TYPE,        "UNMOUNT" }
+
+/*
+ * This structure is used to track log items associated with
+ * a transaction.  It points to the log item and keeps some
+ * flags to track the state of the log item.  It also tracks
+ * the amount of space needed to log the item it describes
+ * once we get to commit processing (see xfs_trans_commit()).
+ */
+struct xfs_log_item_desc {
+        struct xfs_log_item     *lid_item;
+        struct list_head        lid_trans;
+        unsigned char           lid_flags;
+};
+
+#define XFS_LID_DIRTY           0x1
+
+/* log size calculation functions */
+int     xfs_log_calc_unit_res(struct xfs_mount *mp, int unit_bytes);
+int     xfs_log_calc_minimum_size(struct xfs_mount *);
+
+
+/*
+ * Values for t_flags.
+ */
+#define XFS_TRANS_DIRTY         0x01    /* something needs to be logged */
+#define XFS_TRANS_SB_DIRTY      0x02    /* superblock is modified */
+#define XFS_TRANS_PERM_LOG_RES  0x04    /* xact took a permanent log res */
+#define XFS_TRANS_SYNC          0x08    /* make commit synchronous */
+#define XFS_TRANS_DQ_DIRTY      0x10    /* at least one dquot in trx dirty */
+#define XFS_TRANS_RESERVE       0x20    /* OK to use reserved data blocks */
+#define XFS_TRANS_FREEZE_PROT   0x40    /* Transaction has elevated writer
+                                           count in superblock */
+/*
+ * Values for call flags parameter.
+ */
+#define XFS_TRANS_RELEASE_LOG_RES       0x4
+#define XFS_TRANS_ABORT                 0x8
+
+/*
+ * Field values for xfs_trans_mod_sb.
+ */
+#define XFS_TRANS_SB_ICOUNT             0x00000001
+#define XFS_TRANS_SB_IFREE              0x00000002
+#define XFS_TRANS_SB_FDBLOCKS           0x00000004
+#define XFS_TRANS_SB_RES_FDBLOCKS       0x00000008
+#define XFS_TRANS_SB_FREXTENTS          0x00000010
+#define XFS_TRANS_SB_RES_FREXTENTS      0x00000020
+#define XFS_TRANS_SB_DBLOCKS            0x00000040
+#define XFS_TRANS_SB_AGCOUNT            0x00000080
+#define XFS_TRANS_SB_IMAXPCT            0x00000100
+#define XFS_TRANS_SB_REXTSIZE           0x00000200
+#define XFS_TRANS_SB_RBMBLOCKS          0x00000400
+#define XFS_TRANS_SB_RBLOCKS            0x00000800
+#define XFS_TRANS_SB_REXTENTS           0x00001000
+#define XFS_TRANS_SB_REXTSLOG           0x00002000
+
+/*
+ * Here we centralize the specification of XFS meta-data buffer reference count
+ * values.  This determines how hard the buffer cache tries to hold onto the
+ * buffer.
+ */
+#define XFS_AGF_REF             4
+#define XFS_AGI_REF             4
+#define XFS_AGFL_REF            3
+#define XFS_INO_BTREE_REF       3
+#define XFS_ALLOC_BTREE_REF     2
+#define XFS_BMAP_BTREE_REF      2
+#define XFS_DIR_BTREE_REF       2
+#define XFS_INO_REF             2
+#define XFS_ATTR_BTREE_REF      1
+#define XFS_DQUOT_REF           1
+
+/*
+ * Flags for xfs_trans_ichgtime().
+ */
+#define XFS_ICHGTIME_MOD        0x1     /* data fork modification timestamp */
+#define XFS_ICHGTIME_CHG        0x2     /* inode field change timestamp */
+#define XFS_ICHGTIME_CREATE     0x4     /* inode create timestamp */
+
+
+/*
+ * Symlink decoding/encoding functions
+ */
+int xfs_symlink_blocks(struct xfs_mount *mp, int pathlen);
+int xfs_symlink_hdr_set(struct xfs_mount *mp, xfs_ino_t ino, uint32_t offset,
+                        uint32_t size, struct xfs_buf *bp);
+bool xfs_symlink_hdr_ok(struct xfs_mount *mp, xfs_ino_t ino, uint32_t offset,
+                        uint32_t size, struct xfs_buf *bp);
+void xfs_symlink_local_to_remote(struct xfs_trans *tp, struct xfs_buf *bp,
+                                 struct xfs_inode *ip, struct xfs_ifork *ifp);
+
+#endif /* __XFS_SHARED_H__ */
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 15188cc99449..f317488263dd 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -17,34 +17,26 @@
  */
 
 #include "xfs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
-#include "xfs_log.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_inum.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_alloc.h"
-#include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
+#include "xfs_da_format.h"
 #include "xfs_inode.h"
 #include "xfs_btree.h"
-#include "xfs_ialloc.h"
 #include "xfs_bmap.h"
-#include "xfs_rtalloc.h"
+#include "xfs_alloc.h"
 #include "xfs_error.h"
-#include "xfs_itable.h"
 #include "xfs_fsops.h"
-#include "xfs_attr.h"
+#include "xfs_trans.h"
 #include "xfs_buf_item.h"
+#include "xfs_log.h"
 #include "xfs_log_priv.h"
-#include "xfs_trans_priv.h"
-#include "xfs_filestream.h"
 #include "xfs_da_btree.h"
-#include "xfs_dir2_format.h"
 #include "xfs_dir2.h"
 #include "xfs_extfree_item.h"
 #include "xfs_mru_cache.h"
@@ -52,6 +44,9 @@
 #include "xfs_icache.h"
 #include "xfs_trace.h"
 #include "xfs_icreate_item.h"
+#include "xfs_dinode.h"
+#include "xfs_filestream.h"
+#include "xfs_quota.h"
 
 #include <linux/namei.h>
 #include <linux/init.h>
@@ -918,7 +913,7 @@ xfs_flush_inodes(
         struct super_block      *sb = mp->m_super;
 
         if (down_read_trylock(&sb->s_umount)) {
-                sync_inodes_sb(sb);
+                sync_inodes_sb(sb, jiffies);
                 up_read(&sb->s_umount);
         }
 }
@@ -946,10 +941,6 @@ xfs_fs_destroy_inode(
 
         XFS_STATS_INC(vn_reclaim);
 
-        /* bad inode, get out here ASAP */
-        if (is_bad_inode(inode))
-                goto out_reclaim;
-
         ASSERT(XFS_FORCED_SHUTDOWN(ip->i_mount) || ip->i_delayed_blks == 0);
 
         /*
@@ -965,7 +956,6 @@ xfs_fs_destroy_inode(
          * this more efficiently than we can here, so simply let background
          * reclaim tear down all inodes.
          */
-out_reclaim:
         xfs_inode_set_reclaim_tag(ip);
 }
 
@@ -1165,7 +1155,7 @@ xfs_restore_resvblks(struct xfs_mount *mp)
  * Note: xfs_log_quiesce() stops background log work - the callers must ensure
  * it is started again when appropriate.
  */
-void
+static void
 xfs_quiesce_attr(
         struct xfs_mount        *mp)
 {
@@ -1246,7 +1236,7 @@ xfs_fs_remount(
                          */
 #if 0
                         xfs_info(mp,
-                "mount option \"%s\" not supported for remount\n", p);
+                "mount option \"%s\" not supported for remount", p);
                         return -EINVAL;
 #else
                         break;
@@ -1491,10 +1481,6 @@ xfs_fs_fill_super(
                 error = ENOENT;
                 goto out_unmount;
         }
-        if (is_bad_inode(root)) {
-                error = EINVAL;
-                goto out_unmount;
-        }
         sb->s_root = d_make_root(root);
         if (!sb->s_root) {
                 error = ENOMEM;
diff --git a/fs/xfs/xfs_symlink.c b/fs/xfs/xfs_symlink.c
index f622a97a7e33..14e58f2c96bd 100644
--- a/fs/xfs/xfs_symlink.c
+++ b/fs/xfs/xfs_symlink.c
@@ -17,31 +17,31 @@
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #include "xfs.h"
+#include "xfs_shared.h"
 #include "xfs_fs.h"
 #include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_bit.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_da_btree.h"
-#include "xfs_dir2_format.h"
+#include "xfs_da_format.h"
 #include "xfs_dir2.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
 #include "xfs_ialloc.h"
 #include "xfs_alloc.h"
 #include "xfs_bmap.h"
+#include "xfs_bmap_btree.h"
 #include "xfs_bmap_util.h"
 #include "xfs_error.h"
 #include "xfs_quota.h"
 #include "xfs_trans_space.h"
 #include "xfs_trace.h"
 #include "xfs_symlink.h"
-#include "xfs_buf_item.h"
+#include "xfs_trans.h"
+#include "xfs_log.h"
+#include "xfs_dinode.h"
 
 /* ----- Kernel only functions below ----- */
 STATIC int
@@ -424,8 +424,7 @@ xfs_symlink(
  */
 STATIC int
 xfs_inactive_symlink_rmt(
-        xfs_inode_t     *ip,
-        xfs_trans_t     **tpp)
+        struct xfs_inode *ip)
 {
         xfs_buf_t       *bp;
         int             committed;
@@ -437,11 +436,9 @@ xfs_inactive_symlink_rmt(
         xfs_mount_t     *mp;
         xfs_bmbt_irec_t mval[XFS_SYMLINK_MAPS];
         int             nmaps;
-        xfs_trans_t     *ntp;
         int             size;
         xfs_trans_t     *tp;
 
-        tp = *tpp;
         mp = ip->i_mount;
         ASSERT(ip->i_df.if_flags & XFS_IFEXTENTS);
         /*
@@ -453,6 +450,16 @@ xfs_inactive_symlink_rmt(
          */
         ASSERT(ip->i_d.di_nextents > 0 && ip->i_d.di_nextents <= 2);
 
+        tp = xfs_trans_alloc(mp, XFS_TRANS_INACTIVE);
+        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
+        if (error) {
+                xfs_trans_cancel(tp, 0);
+                return error;
+        }
+
+        xfs_ilock(ip, XFS_ILOCK_EXCL);
+        xfs_trans_ijoin(tp, ip, 0);
+
         /*
          * Lock the inode, fix the size, and join it to the transaction.
          * Hold it so in the normal path, we still have it locked for
@@ -471,7 +478,7 @@ xfs_inactive_symlink_rmt(
         error = xfs_bmapi_read(ip, 0, xfs_symlink_blocks(mp, size),
                                 mval, &nmaps, 0);
         if (error)
-                goto error0;
+                goto error_trans_cancel;
         /*
          * Invalidate the block(s). No validation is done.
          */
@@ -481,22 +488,24 @@ xfs_inactive_symlink_rmt(
                         XFS_FSB_TO_BB(mp, mval[i].br_blockcount), 0);
                 if (!bp) {
                         error = ENOMEM;
-                        goto error1;
+                        goto error_bmap_cancel;
                 }
                 xfs_trans_binval(tp, bp);
         }
         /*
          * 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)))
-                goto error1;
+        error = xfs_bunmapi(tp, ip, 0, size, XFS_BMAPI_METADATA, nmaps,
+                            &first_block, &free_list, &done);
+        if (error)
+                goto error_bmap_cancel;
         ASSERT(done);
         /*
          * Commit the first transaction.  This logs the EFI and the inode.
          */
-        if ((error = xfs_bmap_finish(&tp, &free_list, &committed)))
-                goto error1;
+        error = xfs_bmap_finish(&tp, &free_list, &committed);
+        if (error)
+                goto error_bmap_cancel;
         /*
          * The transaction must have been committed, since there were
          * actually extents freed by xfs_bunmapi.  See xfs_bmap_finish.
@@ -511,26 +520,13 @@ xfs_inactive_symlink_rmt(
         xfs_trans_ijoin(tp, ip, 0);
         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
         /*
-         * Get a new, empty transaction to return to our caller.
-         */
-        ntp = xfs_trans_dup(tp);
-        /*
          * Commit the transaction containing extent freeing and EFDs.
-         * If we get an error on the commit here or on the reserve below,
-         * we need to unlock the inode since the new transaction doesn't
-         * have the inode attached.
          */
-        error = xfs_trans_commit(tp, 0);
-        tp = ntp;
+        error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);
         if (error) {
                 ASSERT(XFS_FORCED_SHUTDOWN(mp));
-                goto error0;
+                goto error_unlock;
         }
-        /*
-         * transaction commit worked ok so we can drop the extra ticket
-         * reference that we gained in xfs_trans_dup()
-         */
-        xfs_log_ticket_put(tp->t_ticket);
 
         /*
          * Remove the memory for extent descriptions (just bookkeeping).
@@ -538,23 +534,16 @@ xfs_inactive_symlink_rmt(
         if (ip->i_df.if_bytes)
                 xfs_idata_realloc(ip, -ip->i_df.if_bytes, XFS_DATA_FORK);
         ASSERT(ip->i_df.if_bytes == 0);
-        /*
-         * Put an itruncate log reservation in the new transaction
-         * for our caller.
-         */
-        error = xfs_trans_reserve(tp, &M_RES(mp)->tr_itruncate, 0, 0);
-        if (error) {
-                ASSERT(XFS_FORCED_SHUTDOWN(mp));
-                goto error0;
-        }
 
-        xfs_trans_ijoin(tp, ip, 0);
-        *tpp = tp;
+        xfs_iunlock(ip, XFS_ILOCK_EXCL);
         return 0;
 
- error1:
+error_bmap_cancel:
         xfs_bmap_cancel(&free_list);
- error0:
+error_trans_cancel:
+        xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES | XFS_TRANS_ABORT);
+error_unlock:
+        xfs_iunlock(ip, XFS_ILOCK_EXCL);
         return error;
 }
 
@@ -563,41 +552,46 @@ xfs_inactive_symlink_rmt(
  */
 int
 xfs_inactive_symlink(
-        struct xfs_inode        *ip,
-        struct xfs_trans        **tp)
+        struct xfs_inode        *ip)
 {
         struct xfs_mount        *mp = ip->i_mount;
         int                     pathlen;
 
         trace_xfs_inactive_symlink(ip);
 
-        ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
-
         if (XFS_FORCED_SHUTDOWN(mp))
                 return XFS_ERROR(EIO);
 
+        xfs_ilock(ip, XFS_ILOCK_EXCL);
+
         /*
          * Zero length symlinks _can_ exist.
          */
         pathlen = (int)ip->i_d.di_size;
-        if (!pathlen)
+        if (!pathlen) {
+                xfs_iunlock(ip, XFS_ILOCK_EXCL);
                 return 0;
+        }
 
         if (pathlen < 0 || pathlen > MAXPATHLEN) {
                 xfs_alert(mp, "%s: inode (0x%llx) bad symlink length (%d)",
                          __func__, (unsigned long long)ip->i_ino, pathlen);
+                xfs_iunlock(ip, XFS_ILOCK_EXCL);
                 ASSERT(0);
                 return XFS_ERROR(EFSCORRUPTED);
         }
 
         if (ip->i_df.if_flags & XFS_IFINLINE) {
-                if (ip->i_df.if_bytes > 0)
+                if (ip->i_df.if_bytes > 0) 
                         xfs_idata_realloc(ip, -(ip->i_df.if_bytes),
                                           XFS_DATA_FORK);
+                xfs_iunlock(ip, XFS_ILOCK_EXCL);
                 ASSERT(ip->i_df.if_bytes == 0);
                 return 0;
         }
 
+        xfs_iunlock(ip, XFS_ILOCK_EXCL);
+
         /* remove the remote symlink */
-        return xfs_inactive_symlink_rmt(ip, tp);
+        return xfs_inactive_symlink_rmt(ip);
 }
diff --git a/fs/xfs/xfs_symlink.h b/fs/xfs/xfs_symlink.h
index 99338ba666ac..e75245d09116 100644
--- a/fs/xfs/xfs_symlink.h
+++ b/fs/xfs/xfs_symlink.h
@@ -22,6 +22,6 @@
 int xfs_symlink(struct xfs_inode *dp, struct xfs_name *link_name,
                 const char *target_path, umode_t mode, struct xfs_inode **ipp);
 int xfs_readlink(struct xfs_inode *ip, char *link);
-int xfs_inactive_symlink(struct xfs_inode *ip, struct xfs_trans **tpp);
+int xfs_inactive_symlink(struct xfs_inode *ip);
 
 #endif /* __XFS_SYMLINK_H */
diff --git a/fs/xfs/xfs_symlink_remote.c b/fs/xfs/xfs_symlink_remote.c
index 01c85e3f6470..bf59a2b45f8c 100644
--- a/fs/xfs/xfs_symlink_remote.c
+++ b/fs/xfs/xfs_symlink_remote.c
@@ -19,8 +19,9 @@
 #include "xfs.h"
 #include "xfs_fs.h"
 #include "xfs_format.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_log_format.h"
+#include "xfs_shared.h"
+#include "xfs_trans_resv.h"
 #include "xfs_ag.h"
 #include "xfs_sb.h"
 #include "xfs_mount.h"
@@ -30,6 +31,7 @@
 #include "xfs_trace.h"
 #include "xfs_symlink.h"
 #include "xfs_cksum.h"
+#include "xfs_trans.h"
 #include "xfs_buf_item.h"
 
 
diff --git a/fs/xfs/xfs_trace.c b/fs/xfs/xfs_trace.c
index 5d7b3e40705f..dee3279c095e 100644
--- a/fs/xfs/xfs_trace.c
+++ b/fs/xfs/xfs_trace.c
@@ -17,19 +17,16 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
+#include "xfs_mount.h"
+#include "xfs_da_format.h"
 #include "xfs_inode.h"
 #include "xfs_btree.h"
-#include "xfs_mount.h"
 #include "xfs_da_btree.h"
 #include "xfs_ialloc.h"
 #include "xfs_itable.h"
@@ -37,6 +34,8 @@
 #include "xfs_bmap.h"
 #include "xfs_attr.h"
 #include "xfs_attr_leaf.h"
+#include "xfs_trans.h"
+#include "xfs_log.h"
 #include "xfs_log_priv.h"
 #include "xfs_buf_item.h"
 #include "xfs_quota.h"
@@ -46,6 +45,7 @@
 #include "xfs_dquot.h"
 #include "xfs_log_recover.h"
 #include "xfs_inode_item.h"
+#include "xfs_bmap_btree.h"
 
 /*
  * We include this last to have the helpers above available for the trace
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 47910e638c18..425dfa45b9a0 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -31,8 +31,8 @@ struct xfs_da_args;
 struct xfs_da_node_entry;
 struct xfs_dquot;
 struct xfs_log_item;
-struct xlog_ticket;
 struct xlog;
+struct xlog_ticket;
 struct xlog_recover;
 struct xlog_recover_item;
 struct xfs_buf_log_format;
@@ -135,6 +135,31 @@ DEFINE_PERAG_REF_EVENT(xfs_perag_clear_reclaim);
 DEFINE_PERAG_REF_EVENT(xfs_perag_set_eofblocks);
 DEFINE_PERAG_REF_EVENT(xfs_perag_clear_eofblocks);
 
+DECLARE_EVENT_CLASS(xfs_ag_class,
+        TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno),
+        TP_ARGS(mp, agno),
+        TP_STRUCT__entry(
+                __field(dev_t, dev)
+                __field(xfs_agnumber_t, agno)
+        ),
+        TP_fast_assign(
+                __entry->dev = mp->m_super->s_dev;
+                __entry->agno = agno;
+        ),
+        TP_printk("dev %d:%d agno %u",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->agno)
+);
+#define DEFINE_AG_EVENT(name)   \
+DEFINE_EVENT(xfs_ag_class, name,        \
+        TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno),    \
+        TP_ARGS(mp, agno))
+
+DEFINE_AG_EVENT(xfs_read_agf);
+DEFINE_AG_EVENT(xfs_alloc_read_agf);
+DEFINE_AG_EVENT(xfs_read_agi);
+DEFINE_AG_EVENT(xfs_ialloc_read_agi);
+
 TRACE_EVENT(xfs_attr_list_node_descend,
         TP_PROTO(struct xfs_attr_list_context *ctx,
                  struct xfs_da_node_entry *btree),
@@ -938,6 +963,63 @@ DEFINE_LOG_ITEM_EVENT(xfs_ail_pinned);
 DEFINE_LOG_ITEM_EVENT(xfs_ail_locked);
 DEFINE_LOG_ITEM_EVENT(xfs_ail_flushing);
 
+DECLARE_EVENT_CLASS(xfs_ail_class,
+        TP_PROTO(struct xfs_log_item *lip, xfs_lsn_t old_lsn, xfs_lsn_t new_lsn),
+        TP_ARGS(lip, old_lsn, new_lsn),
+        TP_STRUCT__entry(
+                __field(dev_t, dev)
+                __field(void *, lip)
+                __field(uint, type)
+                __field(uint, flags)
+                __field(xfs_lsn_t, old_lsn)
+                __field(xfs_lsn_t, new_lsn)
+        ),
+        TP_fast_assign(
+                __entry->dev = lip->li_mountp->m_super->s_dev;
+                __entry->lip = lip;
+                __entry->type = lip->li_type;
+                __entry->flags = lip->li_flags;
+                __entry->old_lsn = old_lsn;
+                __entry->new_lsn = new_lsn;
+        ),
+        TP_printk("dev %d:%d lip 0x%p old lsn %d/%d new lsn %d/%d type %s flags %s",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->lip,
+                  CYCLE_LSN(__entry->old_lsn), BLOCK_LSN(__entry->old_lsn),
+                  CYCLE_LSN(__entry->new_lsn), BLOCK_LSN(__entry->new_lsn),
+                  __print_symbolic(__entry->type, XFS_LI_TYPE_DESC),
+                  __print_flags(__entry->flags, "|", XFS_LI_FLAGS))
+)
+
+#define DEFINE_AIL_EVENT(name) \
+DEFINE_EVENT(xfs_ail_class, name, \
+        TP_PROTO(struct xfs_log_item *lip, xfs_lsn_t old_lsn, xfs_lsn_t new_lsn), \
+        TP_ARGS(lip, old_lsn, new_lsn))
+DEFINE_AIL_EVENT(xfs_ail_insert);
+DEFINE_AIL_EVENT(xfs_ail_move);
+DEFINE_AIL_EVENT(xfs_ail_delete);
+
+TRACE_EVENT(xfs_log_assign_tail_lsn,
+        TP_PROTO(struct xlog *log, xfs_lsn_t new_lsn),
+        TP_ARGS(log, new_lsn),
+        TP_STRUCT__entry(
+                __field(dev_t, dev)
+                __field(xfs_lsn_t, new_lsn)
+                __field(xfs_lsn_t, old_lsn)
+                __field(xfs_lsn_t, last_sync_lsn)
+        ),
+        TP_fast_assign(
+                __entry->dev = log->l_mp->m_super->s_dev;
+                __entry->new_lsn = new_lsn;
+                __entry->old_lsn = atomic64_read(&log->l_tail_lsn);
+                __entry->last_sync_lsn = atomic64_read(&log->l_last_sync_lsn);
+        ),
+        TP_printk("dev %d:%d new tail lsn %d/%d, old lsn %d/%d, last sync %d/%d",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  CYCLE_LSN(__entry->new_lsn), BLOCK_LSN(__entry->new_lsn),
+                  CYCLE_LSN(__entry->old_lsn), BLOCK_LSN(__entry->old_lsn),
+                  CYCLE_LSN(__entry->last_sync_lsn), BLOCK_LSN(__entry->last_sync_lsn))
+)
 
 DECLARE_EVENT_CLASS(xfs_file_class,
         TP_PROTO(struct xfs_inode *ip, size_t count, loff_t offset, int flags),
diff --git a/fs/xfs/xfs_trans.c b/fs/xfs/xfs_trans.c
index 5411e01ab452..c812c5c060de 100644
--- a/fs/xfs/xfs_trans.c
+++ b/fs/xfs/xfs_trans.c
@@ -18,32 +18,21 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_error.h"
-#include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
-#include "xfs_btree.h"
-#include "xfs_ialloc.h"
-#include "xfs_alloc.h"
 #include "xfs_extent_busy.h"
-#include "xfs_bmap.h"
 #include "xfs_quota.h"
-#include "xfs_qm.h"
+#include "xfs_trans.h"
 #include "xfs_trans_priv.h"
-#include "xfs_trans_space.h"
-#include "xfs_inode_item.h"
-#include "xfs_log_priv.h"
-#include "xfs_buf_item.h"
+#include "xfs_log.h"
 #include "xfs_trace.h"
+#include "xfs_error.h"
 
 kmem_zone_t     *xfs_trans_zone;
 kmem_zone_t     *xfs_log_item_desc_zone;
diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
index 09cf40b89e8c..9b96d35e483d 100644
--- a/fs/xfs/xfs_trans.h
+++ b/fs/xfs/xfs_trans.h
@@ -18,10 +18,6 @@
 #ifndef __XFS_TRANS_H__
 #define __XFS_TRANS_H__
 
-struct xfs_log_item;
-
-#include "xfs_trans_resv.h"
-
 /* kernel only transaction subsystem defines */
 
 struct xfs_buf;
@@ -77,6 +73,9 @@ struct xfs_item_ops {
         void (*iop_committing)(xfs_log_item_t *, xfs_lsn_t);
 };
 
+void    xfs_log_item_init(struct xfs_mount *mp, struct xfs_log_item *item,
+                          int type, const struct xfs_item_ops *ops);
+
 /*
  * Return values for the iop_push() routines.
  */
@@ -85,18 +84,12 @@ struct xfs_item_ops {
 #define XFS_ITEM_LOCKED         2
 #define XFS_ITEM_FLUSHING       3
 
-/*
- * This is the type of function which can be given to xfs_trans_callback()
- * to be called upon the transaction's commit to disk.
- */
-typedef void (*xfs_trans_callback_t)(struct xfs_trans *, void *);
 
 /*
  * This is the structure maintained for every active transaction.
  */
 typedef struct xfs_trans {
         unsigned int            t_magic;        /* magic number */
-        xfs_log_callback_t      t_logcb;        /* log callback struct */
         unsigned int            t_type;         /* transaction type */
         unsigned int            t_log_res;      /* amt of log space resvd */
         unsigned int            t_log_count;    /* count for perm log res */
@@ -132,7 +125,6 @@ typedef struct xfs_trans {
         int64_t                 t_rextents_delta;/* superblocks rextents chg */
         int64_t                 t_rextslog_delta;/* superblocks rextslog chg */
         struct list_head        t_items;        /* log item descriptors */
-        xfs_trans_header_t      t_header;       /* header for in-log trans */
         struct list_head        t_busy;         /* list of busy extents */
         unsigned long           t_pflags;       /* saved process flags state */
 } xfs_trans_t;
@@ -237,10 +229,16 @@ void		xfs_trans_log_efd_extent(xfs_trans_t *,
                                          xfs_fsblock_t,
                                          xfs_extlen_t);
 int             xfs_trans_commit(xfs_trans_t *, uint flags);
+int             xfs_trans_roll(struct xfs_trans **, struct xfs_inode *);
 void            xfs_trans_cancel(xfs_trans_t *, int);
 int             xfs_trans_ail_init(struct xfs_mount *);
 void            xfs_trans_ail_destroy(struct xfs_mount *);
 
+void            xfs_trans_buf_set_type(struct xfs_trans *, struct xfs_buf *,
+                                       enum xfs_blft);
+void            xfs_trans_buf_copy_type(struct xfs_buf *dst_bp,
+                                        struct xfs_buf *src_bp);
+
 extern kmem_zone_t      *xfs_trans_zone;
 extern kmem_zone_t      *xfs_log_item_desc_zone;
 
diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c
index 21c6d7ddbc06..a7287354e535 100644
--- a/fs/xfs/xfs_trans_ail.c
+++ b/fs/xfs/xfs_trans_ail.c
@@ -18,15 +18,16 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_trans.h"
 #include "xfs_trans_priv.h"
 #include "xfs_trace.h"
 #include "xfs_error.h"
+#include "xfs_log.h"
 
 #ifdef DEBUG
 /*
@@ -658,11 +659,13 @@ xfs_trans_ail_update_bulk(
                         if (XFS_LSN_CMP(lsn, lip->li_lsn) <= 0)
                                 continue;
 
+                        trace_xfs_ail_move(lip, lip->li_lsn, lsn);
                         xfs_ail_delete(ailp, lip);
                         if (mlip == lip)
                                 mlip_changed = 1;
                 } else {
                         lip->li_flags |= XFS_LI_IN_AIL;
+                        trace_xfs_ail_insert(lip, 0, lsn);
                 }
                 lip->li_lsn = lsn;
                 list_add(&lip->li_ail, &tmp);
@@ -731,6 +734,7 @@ xfs_trans_ail_delete_bulk(
                         return;
                 }
 
+                trace_xfs_ail_delete(lip, mlip->li_lsn, lip->li_lsn);
                 xfs_ail_delete(ailp, lip);
                 lip->li_flags &= ~XFS_LI_IN_AIL;
                 lip->li_lsn = 0;
diff --git a/fs/xfs/xfs_trans_buf.c b/fs/xfs/xfs_trans_buf.c
index 8c75b8f67270..c035d11b7734 100644
--- a/fs/xfs/xfs_trans_buf.c
+++ b/fs/xfs/xfs_trans_buf.c
@@ -17,17 +17,15 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
+#include "xfs_trans.h"
 #include "xfs_buf_item.h"
 #include "xfs_trans_priv.h"
 #include "xfs_error.h"
diff --git a/fs/xfs/xfs_trans_dquot.c b/fs/xfs/xfs_trans_dquot.c
index 54ee3c5dee76..cd2a10e15d3a 100644
--- a/fs/xfs/xfs_trans_dquot.c
+++ b/fs/xfs/xfs_trans_dquot.c
@@ -17,23 +17,18 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
-#include "xfs_alloc.h"
-#include "xfs_quota.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
 #include "xfs_inode.h"
-#include "xfs_itable.h"
-#include "xfs_bmap.h"
-#include "xfs_rtalloc.h"
 #include "xfs_error.h"
-#include "xfs_attr.h"
-#include "xfs_buf_item.h"
+#include "xfs_trans.h"
 #include "xfs_trans_priv.h"
+#include "xfs_quota.h"
 #include "xfs_qm.h"
 
 STATIC void     xfs_trans_alloc_dqinfo(xfs_trans_t *);
diff --git a/fs/xfs/xfs_trans_extfree.c b/fs/xfs/xfs_trans_extfree.c
index 8d71b16eccae..47978ba89dae 100644
--- a/fs/xfs/xfs_trans_extfree.c
+++ b/fs/xfs/xfs_trans_extfree.c
@@ -17,12 +17,13 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_shared.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
+#include "xfs_trans.h"
 #include "xfs_trans_priv.h"
 #include "xfs_extfree_item.h"
 
diff --git a/fs/xfs/xfs_trans_inode.c b/fs/xfs/xfs_trans_inode.c
index 53dfe46f3680..1bba7f60d94c 100644
--- a/fs/xfs/xfs_trans_inode.c
+++ b/fs/xfs/xfs_trans_inode.c
@@ -17,18 +17,15 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
-#include "xfs_types.h"
-#include "xfs_log.h"
-#include "xfs_trans.h"
+#include "xfs_shared.h"
+#include "xfs_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
 #include "xfs_inode.h"
-#include "xfs_btree.h"
+#include "xfs_trans.h"
 #include "xfs_trans_priv.h"
 #include "xfs_inode_item.h"
 #include "xfs_trace.h"
diff --git a/fs/xfs/xfs_trans_priv.h b/fs/xfs/xfs_trans_priv.h
index c52def0b441c..12e86af9d9b9 100644
--- a/fs/xfs/xfs_trans_priv.h
+++ b/fs/xfs/xfs_trans_priv.h
@@ -27,7 +27,6 @@ struct xfs_log_vec;
 
 
 void    xfs_trans_init(struct xfs_mount *);
-int     xfs_trans_roll(struct xfs_trans **, struct xfs_inode *);
 void    xfs_trans_add_item(struct xfs_trans *, struct xfs_log_item *);
 void    xfs_trans_del_item(struct xfs_log_item *);
 void    xfs_trans_free_items(struct xfs_trans *tp, xfs_lsn_t commit_lsn,
diff --git a/fs/xfs/xfs_trans_resv.c b/fs/xfs/xfs_trans_resv.c
index a65a3cc40610..d53d9f0627a7 100644
--- a/fs/xfs/xfs_trans_resv.c
+++ b/fs/xfs/xfs_trans_resv.c
@@ -18,27 +18,19 @@
  */
 #include "xfs.h"
 #include "xfs_fs.h"
+#include "xfs_shared.h"
 #include "xfs_format.h"
-#include "xfs_log.h"
+#include "xfs_log_format.h"
 #include "xfs_trans_resv.h"
-#include "xfs_trans.h"
 #include "xfs_sb.h"
 #include "xfs_ag.h"
 #include "xfs_mount.h"
-#include "xfs_error.h"
-#include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
-#include "xfs_alloc_btree.h"
-#include "xfs_ialloc_btree.h"
-#include "xfs_dinode.h"
+#include "xfs_da_format.h"
 #include "xfs_inode.h"
-#include "xfs_btree.h"
+#include "xfs_bmap_btree.h"
 #include "xfs_ialloc.h"
-#include "xfs_alloc.h"
-#include "xfs_extent_busy.h"
-#include "xfs_bmap.h"
-#include "xfs_bmap_util.h"
 #include "xfs_quota.h"
+#include "xfs_trans.h"
 #include "xfs_qm.h"
 #include "xfs_trans_space.h"
 #include "xfs_trace.h"
diff --git a/fs/xfs/xfs_vnode.h b/fs/xfs/xfs_vnode.h
index db14d0c08682..3e8e797c6d11 100644
--- a/fs/xfs/xfs_vnode.h
+++ b/fs/xfs/xfs_vnode.h
@@ -25,14 +25,6 @@ struct xfs_inode;
 struct attrlist_cursor_kern;
 
 /*
- * Return values for xfs_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.
- */
-#define VN_INACTIVE_CACHE       0
-#define VN_INACTIVE_NOCACHE     1
-
-/*
  * Flags for read/write calls - same values as IRIX
  */
 #define IO_ISDIRECT     0x00004         /* bypass page cache */
diff --git a/fs/xfs/xfs_xattr.c b/fs/xfs/xfs_xattr.c
index e01f35ea76ba..9d479073ba41 100644
--- a/fs/xfs/xfs_xattr.c
+++ b/fs/xfs/xfs_xattr.c
@@ -17,9 +17,13 @@
  */
 
 #include "xfs.h"
+#include "xfs_format.h"
 #include "xfs_log_format.h"
-#include "xfs_da_btree.h"
-#include "xfs_bmap_btree.h"
+#include "xfs_trans_resv.h"
+#include "xfs_sb.h"
+#include "xfs_ag.h"
+#include "xfs_mount.h"
+#include "xfs_da_format.h"
 #include "xfs_inode.h"
 #include "xfs_attr.h"
 #include "xfs_attr_leaf.h"