Merge tag 'xfs-for-linus-v3.13-rc1' of git://oss.sgi.com/xfs/xfs

Pull xfs update from Ben Myers:
 "For 3.13-rc1 we have an eclectic assortment of bugfixes, cleanups, and
  refactoring.  Bugfixes that stand out are the fix for the AGF/AGI
  deadlock, incore extent list fixes, verifier fixes for v4 superblocks
  and growfs, and memory leaks.  There are some asserts, warnings, and
  strings that were cleaned up.  There was further rearrangement of code
  to make libxfs and the kernel sync up more easily, differences between
  v2 and v3 directory code were abstracted using an ops vector,
  xfs_inactive was reworked, and the preallocation/hole punching code
  was refactored.

   - simplify kmem_zone_zalloc
   - add traces for AGF/AGI read ops
   - add additional AIL traces
   - fix xfs_remove AGF vs AGI deadlock
   - fix the extent count of new incore extent page in the indirection
     array
   - don't fail bad secondary superblocks verification on v4 filesystems
     due to unzeroed bits after v4 fields
   - fix possible NULL dereference in xlog_verify_iclog
   - remove redundant assert in xfs_dir2_leafn_split
   - prevent stack overflows from page cache allocation
   - fix some sparse warnings
   - fix directory block format verifier to check the leaf entry count
   - abstract the differences in dir2/dir3 via an ops vector
   - continue process of reorganization to make libxfs/kernel code
     merges easier
   - refactor the preallocation and hole punching code
   - fix for growfs and verifiers
   - remove unnecessary scary corruption error when probing non-xfs
     filesystems
   - remove extra newlines from strings passed to printk
   - prevent deadlock trying to cover an active log
   - rework xfs_inactive()
   - add the inode directory type support to XFS_IOC_FSGEOM
   - cleanup (remove) usage of is_bad_inode
   - fix miscalculation in xfs_iext_realloc_direct which results in
     oversized direct extent list
   - remove unnecessary count arg to xfs_iomap_write_allocate
   - fix memory leak in xlog_recover_add_to_trans
   - check superblock instead of block magic to determine if dtype field
     is present
   - fix lockdep annotation due to project quotas
   - fix regression in xfs_node_toosmall which can lead to incorrect
     directory btree node collapse
   - make log recovery verify filesystem uuid of recovering blocks
   - fix XFS_IOC_FREE_EOFBLOCKS definition
   - remove invalid assert in xfs_inode_free
   - fix for AIL lock regression"

* tag 'xfs-for-linus-v3.13-rc1' of git://oss.sgi.com/xfs/xfs: (49 commits)
  xfs: simplify kmem_{zone_}zalloc
  xfs: add tracepoints to AGF/AGI read operations
  xfs: trace AIL manipulations
  xfs: xfs_remove deadlocks due to inverted AGF vs AGI lock ordering
  xfs: fix the extent count when allocating an new indirection array entry
  xfs: be more forgiving of a v4 secondary sb w/ junk in v5 fields
  xfs: fix possible NULL dereference in xlog_verify_iclog
  xfs:xfs_dir2_node.c: pointer use before check for null
  xfs: prevent stack overflows from page cache allocation
  xfs: fix static and extern sparse warnings
  xfs: validity check the directory block leaf entry count
  xfs: make dir2 ftype offset pointers explicit
  xfs: convert directory vector functions to constants
  xfs: convert directory vector functions to constants
  xfs: vectorise encoding/decoding directory headers
  xfs: vectorise DA btree operations
  xfs: vectorise directory leaf operations
  xfs: vectorise directory data operations part 2
  xfs: vectorise directory data operations
  xfs: vectorise remaining shortform dir2 ops
  ...

116 files changed, 5209 insertions, 4681 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 f1d85cfc0a54..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;
@@ -808,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 20bf8e8002d6..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 */
@@ -1231,13 +1189,13 @@ xfs_da3_node_toosmall(
                         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(&thdr, node);
+                dp->d_ops->node_hdr_from_disk(&thdr, node);
                 xfs_trans_brelse(state->args->trans, bp);
 
                 if (count - thdr.count >= 0)
@@ -1275,6 +1233,7 @@ xfs_da3_node_toosmall(
  */
 STATIC uint
 xfs_da3_node_lasthash(
+        struct xfs_inode        *dp,
         struct xfs_buf          *bp,
         int                     *count)
 {
@@ -1283,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);
 }
 
@@ -1307,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);
 
@@ -1319,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;
@@ -1333,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;
@@ -1360,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);
 
@@ -1372,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);
@@ -1385,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.
@@ -1414,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;
 
         /*
@@ -1456,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.
@@ -1501,6 +1463,7 @@ xfs_da3_node_lookup_int(
         int                     max;
         int                     error;
         int                     retval;
+        struct xfs_inode        *dp = state->args->dp;
 
         args = state->args;
 
@@ -1536,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;
                 }
 
@@ -1547,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);
@@ -1643,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)
 {
@@ -1655,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)) ||
@@ -1685,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.
@@ -1702,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;
         }
 
@@ -1720,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)
@@ -1741,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)
@@ -1861,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);
 
@@ -1876,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++;
@@ -1911,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);
@@ -1933,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;
@@ -1947,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);
@@ -2163,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;
@@ -2187,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)) {
@@ -2204,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;
         /*
@@ -2222,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);
         }
@@ -2240,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;
@@ -2262,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;
@@ -2286,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);
@@ -2298,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;
@@ -2337,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 9cf67381adf6..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,93 +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)
- *
- * 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.
- */
-static inline xfs_dir2_data_aoff_t
-xfs_dir3_data_dot_offset(struct xfs_mount *mp)
-{
-        return xfs_dir3_data_hdr_size(xfs_sb_version_hascrc(&mp->m_sb));
-}
-
-static inline xfs_dir2_data_aoff_t
-xfs_dir3_data_dotdot_offset(struct xfs_mount *mp)
-{
-        return xfs_dir3_data_dot_offset(mp) +
-                xfs_dir3_data_entsize(mp, 1);
-}
-
-static inline xfs_dir2_data_aoff_t
-xfs_dir3_data_first_offset(struct xfs_mount *mp)
-{
-        return xfs_dir3_data_dotdot_offset(mp) +
-                xfs_dir3_data_entsize(mp, 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_mount        *mp,
-        struct xfs_dir2_data_hdr *hdr)
-{
-        return (struct xfs_dir2_data_entry *)
-                ((char *)hdr + xfs_dir3_data_dot_offset(mp));
-}
-
-static inline struct xfs_dir2_data_entry *
-xfs_dir3_data_dotdot_entry_p(
-        struct xfs_mount        *mp,
-        struct xfs_dir2_data_hdr *hdr)
-{
-        return (struct xfs_dir2_data_entry *)
-                ((char *)hdr + xfs_dir3_data_dotdot_offset(mp));
-}
-
-static inline struct xfs_dir2_data_entry *
-xfs_dir3_data_first_entry_p(
-        struct xfs_mount        *mp,
-        struct xfs_dir2_data_hdr *hdr)
-{
-        return (struct xfs_dir2_data_entry *)
-                ((char *)hdr + xfs_dir3_data_first_offset(mp));
-}
-
 /*
  * Leaf block structures.
  *
@@ -645,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.
  */
@@ -869,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.
  *
@@ -961,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 12dad188939d..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(mp, 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(mp, 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(mp);
+        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 8f84153e98a8..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 3ef6d402084c..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 1ee776d477c3..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:
@@ -292,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.
@@ -514,6 +402,7 @@ xfs_qm_dqalloc(
 
         return (error);
 }
+
 STATIC int
 xfs_qm_dqrepair(
         struct xfs_mount        *mp,
@@ -547,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) {
@@ -1133,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 18272c766a50..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.
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 474807a401c8..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"
 
@@ -500,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;
 
@@ -918,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 39797490a1f1..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
@@ -2362,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)
@@ -2394,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.
@@ -3125,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);
@@ -3145,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);
@@ -4077,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 8968f5036fa1..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>
@@ -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"