Merge tag 'xfs-rmap-for-linus-4.8-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/dgc/linux-xfs

Pull more xfs updates from Dave Chinner:
 "This is the second part of the XFS updates for this merge cycle, and
  contains the new reverse block mapping feature for XFS.

  Reverse mapping allows us to track the owner of a specific block on
  disk precisely.  It is implemented as a set of btrees (one per
  allocation group) that track the owners of allocated extents.
  Effectively it is a "used space tree" that is updated when we allocate
  or free extents.  i.e. it is coherent with the free space btrees we
  already maintain and never overlaps with them.

  This reverse mapping infrastructure is the building block of several
  upcoming features - reflink, copy-on-write data, dedupe, online
  metadata and data scrubbing, highly accurate bad sector/data loss
  reporting to users, and significantly improved reconstruction of
  damaged and corrupted filesystems.  There's a lot of new stuff coming
  along in the next couple of cycles,a nd it all builds in the rmap
  infrastructure.

  As such, it's a huge chunk of new code with new on-disk format
  features and internal infrastructure.  It warns at mount time as an
  experimental feature and that it may eat data (as we do with all new
  on-disk features until they stabilise).  We have not released
  userspace suport for it yet - userspace support currently requires
  download from Darrick's xfsprogs repo and build from source, so the
  access to this feature is really developer/tester only at this point.
  Initial userspace support will be released at the same time kernel
  with this code in it is released.

  The new rmap enabled code regresses 3 xfstests - all are ENOSPC
  related corner cases, one of which Darrick posted a fix for a few
  hours ago.  The other two are fixed by infrastructure that is part of
  the upcoming reflink patchset.  This new ENOSPC infrastructure
  requires a on-disk format tweak required to keep mount times in
  check - we need to keep an on-disk count of allocated rmapbt blocks so
  we don't have to scan the entire btrees at mount time to count them.

  This is currently being tested and will be part of the fixes sent in
  the next week or two so users will not be exposed to this change"

* tag 'xfs-rmap-for-linus-4.8-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/dgc/linux-xfs: (52 commits)
  xfs: move (and rename) the deferred bmap-free tracepoints
  xfs: collapse single use static functions
  xfs: remove unnecessary parentheses from log redo item recovery functions
  xfs: remove the extents array from the rmap update done log item
  xfs: in btree_lshift, only allocate temporary cursor when needed
  xfs: remove unnecesary lshift/rshift key initialization
  xfs: remove the get*keys and update_keys btree ops pointers
  xfs: enable the rmap btree functionality
  xfs: don't update rmapbt when fixing agfl
  xfs: disable XFS_IOC_SWAPEXT when rmap btree is enabled
  xfs: add rmap btree block detection to log recovery
  xfs: add rmap btree geometry feature flag
  xfs: propagate bmap updates to rmapbt
  xfs: enable the xfs_defer mechanism to process rmaps to update
  xfs: log rmap intent items
  xfs: create rmap update intent log items
  xfs: add rmap btree insert and delete helpers
  xfs: convert unwritten status of reverse mappings
  xfs: remove an extent from the rmap btree
  xfs: add an extent to the rmap btree
  ...

64 files changed, 6267 insertions, 915 deletions

diff --git a/fs/xfs/Makefile b/fs/xfs/Makefile
index 52c288514be1..fc593c869493 100644
--- a/fs/xfs/Makefile
+++ b/fs/xfs/Makefile
@@ -39,6 +39,7 @@ xfs-y				+= $(addprefix libxfs/, \
                                    xfs_btree.o \
                                    xfs_da_btree.o \
                                    xfs_da_format.o \
+                                   xfs_defer.o \
                                    xfs_dir2.o \
                                    xfs_dir2_block.o \
                                    xfs_dir2_data.o \
@@ -51,6 +52,8 @@ xfs-y				+= $(addprefix libxfs/, \
                                    xfs_inode_fork.o \
                                    xfs_inode_buf.o \
                                    xfs_log_rlimit.o \
+                                   xfs_rmap.o \
+                                   xfs_rmap_btree.o \
                                    xfs_sb.o \
                                    xfs_symlink_remote.o \
                                    xfs_trans_resv.o \
@@ -100,11 +103,13 @@ xfs-y				+= xfs_log.o \
                                    xfs_extfree_item.o \
                                    xfs_icreate_item.o \
                                    xfs_inode_item.o \
+                                   xfs_rmap_item.o \
                                    xfs_log_recover.o \
                                    xfs_trans_ail.o \
                                    xfs_trans_buf.o \
                                    xfs_trans_extfree.o \
                                    xfs_trans_inode.o \
+                                   xfs_trans_rmap.o \
 
 # optional features
 xfs-$(CONFIG_XFS_QUOTA)         += xfs_dquot.o \
diff --git a/fs/xfs/libxfs/xfs_alloc.c b/fs/xfs/libxfs/xfs_alloc.c
index 88c26b827a2d..776ae2f325d1 100644
--- a/fs/xfs/libxfs/xfs_alloc.c
+++ b/fs/xfs/libxfs/xfs_alloc.c
@@ -24,8 +24,10 @@
 #include "xfs_bit.h"
 #include "xfs_sb.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_inode.h"
 #include "xfs_btree.h"
+#include "xfs_rmap.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_alloc.h"
 #include "xfs_extent_busy.h"
@@ -49,6 +51,81 @@ STATIC int xfs_alloc_ag_vextent_size(xfs_alloc_arg_t *);
 STATIC int xfs_alloc_ag_vextent_small(xfs_alloc_arg_t *,
                 xfs_btree_cur_t *, xfs_agblock_t *, xfs_extlen_t *, int *);
 
+xfs_extlen_t
+xfs_prealloc_blocks(
+        struct xfs_mount        *mp)
+{
+        if (xfs_sb_version_hasrmapbt(&mp->m_sb))
+                return XFS_RMAP_BLOCK(mp) + 1;
+        if (xfs_sb_version_hasfinobt(&mp->m_sb))
+                return XFS_FIBT_BLOCK(mp) + 1;
+        return XFS_IBT_BLOCK(mp) + 1;
+}
+
+/*
+ * In order to avoid ENOSPC-related deadlock caused by out-of-order locking of
+ * AGF buffer (PV 947395), we place constraints on the relationship among
+ * actual allocations for data blocks, freelist blocks, and potential file data
+ * bmap btree blocks. However, these restrictions may result in no actual space
+ * allocated for a delayed extent, for example, a data block in a certain AG is
+ * allocated but there is no additional block for the additional bmap btree
+ * block due to a split of the bmap btree of the file. The result of this may
+ * lead to an infinite loop when the file gets flushed to disk and all delayed
+ * extents need to be actually allocated. To get around this, we explicitly set
+ * aside a few blocks which will not be reserved in delayed allocation.
+ *
+ * When rmap is disabled, we need to reserve 4 fsbs _per AG_ for the freelist
+ * and 4 more to handle a potential split of the file's bmap btree.
+ *
+ * When rmap is enabled, we must also be able to handle two rmap btree inserts
+ * to record both the file data extent and a new bmbt block.  The bmbt block
+ * might not be in the same AG as the file data extent.  In the worst case
+ * the bmap btree splits multiple levels and all the new blocks come from
+ * different AGs, so set aside enough to handle rmap btree splits in all AGs.
+ */
+unsigned int
+xfs_alloc_set_aside(
+        struct xfs_mount        *mp)
+{
+        unsigned int            blocks;
+
+        blocks = 4 + (mp->m_sb.sb_agcount * XFS_ALLOC_AGFL_RESERVE);
+        if (xfs_sb_version_hasrmapbt(&mp->m_sb))
+                blocks += mp->m_sb.sb_agcount * mp->m_rmap_maxlevels;
+        return blocks;
+}
+
+/*
+ * When deciding how much space to allocate out of an AG, we limit the
+ * allocation maximum size to the size the AG. However, we cannot use all the
+ * blocks in the AG - some are permanently used by metadata. These
+ * blocks are generally:
+ *      - the AG superblock, AGF, AGI and AGFL
+ *      - the AGF (bno and cnt) and AGI btree root blocks, and optionally
+ *        the AGI free inode and rmap btree root blocks.
+ *      - blocks on the AGFL according to xfs_alloc_set_aside() limits
+ *      - the rmapbt root block
+ *
+ * The AG headers are sector sized, so the amount of space they take up is
+ * dependent on filesystem geometry. The others are all single blocks.
+ */
+unsigned int
+xfs_alloc_ag_max_usable(
+        struct xfs_mount        *mp)
+{
+        unsigned int            blocks;
+
+        blocks = XFS_BB_TO_FSB(mp, XFS_FSS_TO_BB(mp, 4)); /* ag headers */
+        blocks += XFS_ALLOC_AGFL_RESERVE;
+        blocks += 3;                    /* AGF, AGI btree root blocks */
+        if (xfs_sb_version_hasfinobt(&mp->m_sb))
+                blocks++;               /* finobt root block */
+        if (xfs_sb_version_hasrmapbt(&mp->m_sb))
+                blocks++;               /* rmap root block */
+
+        return mp->m_sb.sb_agblocks - blocks;
+}
+
 /*
  * Lookup the record equal to [bno, len] in the btree given by cur.
  */
@@ -636,6 +713,14 @@ xfs_alloc_ag_vextent(
         ASSERT(!args->wasfromfl || !args->isfl);
         ASSERT(args->agbno % args->alignment == 0);
 
+        /* if not file data, insert new block into the reverse map btree */
+        if (args->oinfo.oi_owner != XFS_RMAP_OWN_UNKNOWN) {
+                error = xfs_rmap_alloc(args->tp, args->agbp, args->agno,
+                                       args->agbno, args->len, &args->oinfo);
+                if (error)
+                        return error;
+        }
+
         if (!args->wasfromfl) {
                 error = xfs_alloc_update_counters(args->tp, args->pag,
                                                   args->agbp,
@@ -1577,14 +1662,15 @@ error0:
 /*
  * Free the extent starting at agno/bno for length.
  */
-STATIC int                      /* error */
+STATIC int
 xfs_free_ag_extent(
-        xfs_trans_t     *tp,    /* transaction pointer */
-        xfs_buf_t       *agbp,  /* buffer for a.g. freelist header */
-        xfs_agnumber_t  agno,   /* allocation group number */
-        xfs_agblock_t   bno,    /* starting block number */
-        xfs_extlen_t    len,    /* length of extent */
-        int             isfl)   /* set if is freelist blocks - no sb acctg */
+        xfs_trans_t             *tp,
+        xfs_buf_t               *agbp,
+        xfs_agnumber_t          agno,
+        xfs_agblock_t           bno,
+        xfs_extlen_t            len,
+        struct xfs_owner_info   *oinfo,
+        int                     isfl)
 {
         xfs_btree_cur_t *bno_cur;       /* cursor for by-block btree */
         xfs_btree_cur_t *cnt_cur;       /* cursor for by-size btree */
@@ -1601,12 +1687,19 @@ xfs_free_ag_extent(
         xfs_extlen_t    nlen;           /* new length of freespace */
         xfs_perag_t     *pag;           /* per allocation group data */
 
+        bno_cur = cnt_cur = NULL;
         mp = tp->t_mountp;
+
+        if (oinfo->oi_owner != XFS_RMAP_OWN_UNKNOWN) {
+                error = xfs_rmap_free(tp, agbp, agno, bno, len, oinfo);
+                if (error)
+                        goto error0;
+        }
+
         /*
          * Allocate and initialize a cursor for the by-block btree.
          */
         bno_cur = xfs_allocbt_init_cursor(mp, tp, agbp, agno, XFS_BTNUM_BNO);
-        cnt_cur = NULL;
         /*
          * Look for a neighboring block on the left (lower block numbers)
          * that is contiguous with this space.
@@ -1875,6 +1968,11 @@ xfs_alloc_min_freelist(
         /* space needed by-size freespace btree */
         min_free += min_t(unsigned int, pag->pagf_levels[XFS_BTNUM_CNTi] + 1,
                                        mp->m_ag_maxlevels);
+        /* space needed reverse mapping used space btree */
+        if (xfs_sb_version_hasrmapbt(&mp->m_sb))
+                min_free += min_t(unsigned int,
+                                  pag->pagf_levels[XFS_BTNUM_RMAPi] + 1,
+                                  mp->m_rmap_maxlevels);
 
         return min_free;
 }
@@ -1992,21 +2090,34 @@ xfs_alloc_fix_freelist(
          * anything other than extra overhead when we need to put more blocks
          * back on the free list? Maybe we should only do this when space is
          * getting low or the AGFL is more than half full?
+         *
+         * The NOSHRINK flag prevents the AGFL from being shrunk if it's too
+         * big; the NORMAP flag prevents AGFL expand/shrink operations from
+         * updating the rmapbt.  Both flags are used in xfs_repair while we're
+         * rebuilding the rmapbt, and neither are used by the kernel.  They're
+         * both required to ensure that rmaps are correctly recorded for the
+         * regenerated AGFL, bnobt, and cntbt.  See repair/phase5.c and
+         * repair/rmap.c in xfsprogs for details.
          */
-        while (pag->pagf_flcount > need) {
+        memset(&targs, 0, sizeof(targs));
+        if (flags & XFS_ALLOC_FLAG_NORMAP)
+                xfs_rmap_skip_owner_update(&targs.oinfo);
+        else
+                xfs_rmap_ag_owner(&targs.oinfo, XFS_RMAP_OWN_AG);
+        while (!(flags & XFS_ALLOC_FLAG_NOSHRINK) && pag->pagf_flcount > need) {
                 struct xfs_buf  *bp;
 
                 error = xfs_alloc_get_freelist(tp, agbp, &bno, 0);
                 if (error)
                         goto out_agbp_relse;
-                error = xfs_free_ag_extent(tp, agbp, args->agno, bno, 1, 1);
+                error = xfs_free_ag_extent(tp, agbp, args->agno, bno, 1,
+                                           &targs.oinfo, 1);
                 if (error)
                         goto out_agbp_relse;
                 bp = xfs_btree_get_bufs(mp, tp, args->agno, bno, 0);
                 xfs_trans_binval(tp, bp);
         }
 
-        memset(&targs, 0, sizeof(targs));
         targs.tp = tp;
         targs.mp = mp;
         targs.agbp = agbp;
@@ -2271,6 +2382,10 @@ xfs_agf_verify(
             be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNT]) > XFS_BTREE_MAXLEVELS)
                 return false;
 
+        if (xfs_sb_version_hasrmapbt(&mp->m_sb) &&
+            be32_to_cpu(agf->agf_levels[XFS_BTNUM_RMAP]) > XFS_BTREE_MAXLEVELS)
+                return false;
+
         /*
          * during growfs operations, the perag is not fully initialised,
          * so we can't use it for any useful checking. growfs ensures we can't
@@ -2402,6 +2517,8 @@ xfs_alloc_read_agf(
                         be32_to_cpu(agf->agf_levels[XFS_BTNUM_BNOi]);
                 pag->pagf_levels[XFS_BTNUM_CNTi] =
                         be32_to_cpu(agf->agf_levels[XFS_BTNUM_CNTi]);
+                pag->pagf_levels[XFS_BTNUM_RMAPi] =
+                        be32_to_cpu(agf->agf_levels[XFS_BTNUM_RMAPi]);
                 spin_lock_init(&pag->pagb_lock);
                 pag->pagb_count = 0;
                 pag->pagb_tree = RB_ROOT;
@@ -2691,7 +2808,8 @@ int				/* error */
 xfs_free_extent(
         struct xfs_trans        *tp,    /* transaction pointer */
         xfs_fsblock_t           bno,    /* starting block number of extent */
-        xfs_extlen_t            len)    /* length of extent */
+        xfs_extlen_t            len,    /* length of extent */
+        struct xfs_owner_info   *oinfo) /* extent owner */
 {
         struct xfs_mount        *mp = tp->t_mountp;
         struct xfs_buf          *agbp;
@@ -2701,6 +2819,11 @@ xfs_free_extent(
 
         ASSERT(len != 0);
 
+        if (XFS_TEST_ERROR(false, mp,
+                        XFS_ERRTAG_FREE_EXTENT,
+                        XFS_RANDOM_FREE_EXTENT))
+                return -EIO;
+
         error = xfs_free_extent_fix_freelist(tp, agno, &agbp);
         if (error)
                 return error;
@@ -2712,7 +2835,7 @@ xfs_free_extent(
                 agbno + len <= be32_to_cpu(XFS_BUF_TO_AGF(agbp)->agf_length),
                                 err);
 
-        error = xfs_free_ag_extent(tp, agbp, agno, agbno, len, 0);
+        error = xfs_free_ag_extent(tp, agbp, agno, agbno, len, oinfo, 0);
         if (error)
                 goto err;
 
diff --git a/fs/xfs/libxfs/xfs_alloc.h b/fs/xfs/libxfs/xfs_alloc.h
index cf268b2d0b6c..6fe2d6b7cfe9 100644
--- a/fs/xfs/libxfs/xfs_alloc.h
+++ b/fs/xfs/libxfs/xfs_alloc.h
@@ -54,41 +54,8 @@ typedef unsigned int xfs_alloctype_t;
  */
 #define XFS_ALLOC_FLAG_TRYLOCK  0x00000001  /* use trylock for buffer locking */
 #define XFS_ALLOC_FLAG_FREEING  0x00000002  /* indicate caller is freeing extents*/
-
-/*
- * In order to avoid ENOSPC-related deadlock caused by
- * out-of-order locking of AGF buffer (PV 947395), we place
- * constraints on the relationship among actual allocations for
- * data blocks, freelist blocks, and potential file data bmap
- * btree blocks. However, these restrictions may result in no
- * actual space allocated for a delayed extent, for example, a data
- * block in a certain AG is allocated but there is no additional
- * block for the additional bmap btree block due to a split of the
- * bmap btree of the file. The result of this may lead to an
- * infinite loop in xfssyncd when the file gets flushed to disk and
- * all delayed extents need to be actually allocated. To get around
- * this, we explicitly set aside a few blocks which will not be
- * reserved in delayed allocation. Considering the minimum number of
- * needed freelist blocks is 4 fsbs _per AG_, a potential split of file's bmap
- * btree requires 1 fsb, so we set the number of set-aside blocks
- * to 4 + 4*agcount.
- */
-#define XFS_ALLOC_SET_ASIDE(mp)  (4 + ((mp)->m_sb.sb_agcount * 4))
-
-/*
- * When deciding how much space to allocate out of an AG, we limit the
- * allocation maximum size to the size the AG. However, we cannot use all the
- * blocks in the AG - some are permanently used by metadata. These
- * blocks are generally:
- *      - the AG superblock, AGF, AGI and AGFL
- *      - the AGF (bno and cnt) and AGI btree root blocks
- *      - 4 blocks on the AGFL according to XFS_ALLOC_SET_ASIDE() limits
- *
- * The AG headers are sector sized, so the amount of space they take up is
- * dependent on filesystem geometry. The others are all single blocks.
- */
-#define XFS_ALLOC_AG_MAX_USABLE(mp)     \
-        ((mp)->m_sb.sb_agblocks - XFS_BB_TO_FSB(mp, XFS_FSS_TO_BB(mp, 4)) - 7)
+#define XFS_ALLOC_FLAG_NORMAP   0x00000004  /* don't modify the rmapbt */
+#define XFS_ALLOC_FLAG_NOSHRINK 0x00000008  /* don't shrink the freelist */
 
 
 /*
@@ -123,6 +90,7 @@ typedef struct xfs_alloc_arg {
         char            isfl;           /* set if is freelist blocks - !acctg */
         char            userdata;       /* mask defining userdata treatment */
         xfs_fsblock_t   firstblock;     /* io first block allocated */
+        struct xfs_owner_info   oinfo;  /* owner of blocks being allocated */
 } xfs_alloc_arg_t;
 
 /*
@@ -132,6 +100,11 @@ typedef struct xfs_alloc_arg {
 #define XFS_ALLOC_INITIAL_USER_DATA     (1 << 1)/* special case start of file */
 #define XFS_ALLOC_USERDATA_ZERO         (1 << 2)/* zero extent on allocation */
 
+/* freespace limit calculations */
+#define XFS_ALLOC_AGFL_RESERVE  4
+unsigned int xfs_alloc_set_aside(struct xfs_mount *mp);
+unsigned int xfs_alloc_ag_max_usable(struct xfs_mount *mp);
+
 xfs_extlen_t xfs_alloc_longest_free_extent(struct xfs_mount *mp,
                 struct xfs_perag *pag, xfs_extlen_t need);
 unsigned int xfs_alloc_min_freelist(struct xfs_mount *mp,
@@ -208,9 +181,10 @@ xfs_alloc_vextent(
  */
 int                             /* error */
 xfs_free_extent(
-        struct xfs_trans *tp,   /* transaction pointer */
-        xfs_fsblock_t   bno,    /* starting block number of extent */
-        xfs_extlen_t    len);   /* length of extent */
+        struct xfs_trans        *tp,    /* transaction pointer */
+        xfs_fsblock_t           bno,    /* starting block number of extent */
+        xfs_extlen_t            len,    /* length of extent */
+        struct xfs_owner_info   *oinfo);/* extent owner */
 
 int                             /* error */
 xfs_alloc_lookup_ge(
@@ -232,4 +206,6 @@ int xfs_alloc_fix_freelist(struct xfs_alloc_arg *args, int flags);
 int xfs_free_extent_fix_freelist(struct xfs_trans *tp, xfs_agnumber_t agno,
                 struct xfs_buf **agbp);
 
+xfs_extlen_t xfs_prealloc_blocks(struct xfs_mount *mp);
+
 #endif  /* __XFS_ALLOC_H__ */
diff --git a/fs/xfs/libxfs/xfs_alloc_btree.c b/fs/xfs/libxfs/xfs_alloc_btree.c
index d9b42425291e..5ba2dac5e67c 100644
--- a/fs/xfs/libxfs/xfs_alloc_btree.c
+++ b/fs/xfs/libxfs/xfs_alloc_btree.c
@@ -212,17 +212,6 @@ xfs_allocbt_init_key_from_rec(
 }
 
 STATIC void
-xfs_allocbt_init_rec_from_key(
-        union xfs_btree_key     *key,
-        union xfs_btree_rec     *rec)
-{
-        ASSERT(key->alloc.ar_startblock != 0);
-
-        rec->alloc.ar_startblock = key->alloc.ar_startblock;
-        rec->alloc.ar_blockcount = key->alloc.ar_blockcount;
-}
-
-STATIC void
 xfs_allocbt_init_rec_from_cur(
         struct xfs_btree_cur    *cur,
         union xfs_btree_rec     *rec)
@@ -406,7 +395,6 @@ static const struct xfs_btree_ops xfs_allocbt_ops = {
         .get_minrecs            = xfs_allocbt_get_minrecs,
         .get_maxrecs            = xfs_allocbt_get_maxrecs,
         .init_key_from_rec      = xfs_allocbt_init_key_from_rec,
-        .init_rec_from_key      = xfs_allocbt_init_rec_from_key,
         .init_rec_from_cur      = xfs_allocbt_init_rec_from_cur,
         .init_ptr_from_cur      = xfs_allocbt_init_ptr_from_cur,
         .key_diff               = xfs_allocbt_key_diff,
diff --git a/fs/xfs/libxfs/xfs_attr.c b/fs/xfs/libxfs/xfs_attr.c
index 4e126f41a0aa..af1ecb19121e 100644
--- a/fs/xfs/libxfs/xfs_attr.c
+++ b/fs/xfs/libxfs/xfs_attr.c
@@ -23,6 +23,7 @@
 #include "xfs_trans_resv.h"
 #include "xfs_bit.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_da_format.h"
 #include "xfs_da_btree.h"
 #include "xfs_attr_sf.h"
@@ -203,7 +204,7 @@ xfs_attr_set(
 {
         struct xfs_mount        *mp = dp->i_mount;
         struct xfs_da_args      args;
-        struct xfs_bmap_free    flist;
+        struct xfs_defer_ops    dfops;
         struct xfs_trans_res    tres;
         xfs_fsblock_t           firstblock;
         int                     rsvd = (flags & ATTR_ROOT) != 0;
@@ -221,7 +222,7 @@ xfs_attr_set(
         args.value = value;
         args.valuelen = valuelen;
         args.firstblock = &firstblock;
-        args.flist = &flist;
+        args.dfops = &dfops;
         args.op_flags = XFS_DA_OP_ADDNAME | XFS_DA_OP_OKNOENT;
         args.total = xfs_attr_calc_size(&args, &local);
 
@@ -316,13 +317,13 @@ xfs_attr_set(
                  * It won't fit in the shortform, transform to a leaf block.
                  * GROT: another possible req'mt for a double-split btree op.
                  */
-                xfs_bmap_init(args.flist, args.firstblock);
+                xfs_defer_init(args.dfops, args.firstblock);
                 error = xfs_attr_shortform_to_leaf(&args);
                 if (!error)
-                        error = xfs_bmap_finish(&args.trans, args.flist, dp);
+                        error = xfs_defer_finish(&args.trans, args.dfops, dp);
                 if (error) {
                         args.trans = NULL;
-                        xfs_bmap_cancel(&flist);
+                        xfs_defer_cancel(&dfops);
                         goto out;
                 }
 
@@ -382,7 +383,7 @@ xfs_attr_remove(
 {
         struct xfs_mount        *mp = dp->i_mount;
         struct xfs_da_args      args;
-        struct xfs_bmap_free    flist;
+        struct xfs_defer_ops    dfops;
         xfs_fsblock_t           firstblock;
         int                     error;
 
@@ -399,7 +400,7 @@ xfs_attr_remove(
                 return error;
 
         args.firstblock = &firstblock;
-        args.flist = &flist;
+        args.dfops = &dfops;
 
         /*
          * we have no control over the attribute names that userspace passes us
@@ -584,13 +585,13 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
                  * Commit that transaction so that the node_addname() call
                  * can manage its own transactions.
                  */
-                xfs_bmap_init(args->flist, args->firstblock);
+                xfs_defer_init(args->dfops, args->firstblock);
                 error = xfs_attr3_leaf_to_node(args);
                 if (!error)
-                        error = xfs_bmap_finish(&args->trans, args->flist, dp);
+                        error = xfs_defer_finish(&args->trans, args->dfops, dp);
                 if (error) {
                         args->trans = NULL;
-                        xfs_bmap_cancel(args->flist);
+                        xfs_defer_cancel(args->dfops);
                         return error;
                 }
 
@@ -674,15 +675,15 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
                  * If the result is small enough, shrink it all into the inode.
                  */
                 if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
-                        xfs_bmap_init(args->flist, args->firstblock);
+                        xfs_defer_init(args->dfops, args->firstblock);
                         error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
                         /* bp is gone due to xfs_da_shrink_inode */
                         if (!error)
-                                error = xfs_bmap_finish(&args->trans,
-                                                        args->flist, dp);
+                                error = xfs_defer_finish(&args->trans,
+                                                        args->dfops, dp);
                         if (error) {
                                 args->trans = NULL;
-                                xfs_bmap_cancel(args->flist);
+                                xfs_defer_cancel(args->dfops);
                                 return error;
                         }
                 }
@@ -737,14 +738,14 @@ xfs_attr_leaf_removename(xfs_da_args_t *args)
          * If the result is small enough, shrink it all into the inode.
          */
         if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
-                xfs_bmap_init(args->flist, args->firstblock);
+                xfs_defer_init(args->dfops, args->firstblock);
                 error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
                 /* bp is gone due to xfs_da_shrink_inode */
                 if (!error)
-                        error = xfs_bmap_finish(&args->trans, args->flist, dp);
+                        error = xfs_defer_finish(&args->trans, args->dfops, dp);
                 if (error) {
                         args->trans = NULL;
-                        xfs_bmap_cancel(args->flist);
+                        xfs_defer_cancel(args->dfops);
                         return error;
                 }
         }
@@ -863,14 +864,14 @@ restart:
                          */
                         xfs_da_state_free(state);
                         state = NULL;
-                        xfs_bmap_init(args->flist, args->firstblock);
+                        xfs_defer_init(args->dfops, args->firstblock);
                         error = xfs_attr3_leaf_to_node(args);
                         if (!error)
-                                error = xfs_bmap_finish(&args->trans,
-                                                        args->flist, dp);
+                                error = xfs_defer_finish(&args->trans,
+                                                        args->dfops, dp);
                         if (error) {
                                 args->trans = NULL;
-                                xfs_bmap_cancel(args->flist);
+                                xfs_defer_cancel(args->dfops);
                                 goto out;
                         }
 
@@ -891,13 +892,13 @@ restart:
                  * in the index/blkno/rmtblkno/rmtblkcnt fields and
                  * in the index2/blkno2/rmtblkno2/rmtblkcnt2 fields.
                  */
-                xfs_bmap_init(args->flist, args->firstblock);
+                xfs_defer_init(args->dfops, args->firstblock);
                 error = xfs_da3_split(state);
                 if (!error)
-                        error = xfs_bmap_finish(&args->trans, args->flist, dp);
+                        error = xfs_defer_finish(&args->trans, args->dfops, dp);
                 if (error) {
                         args->trans = NULL;
-                        xfs_bmap_cancel(args->flist);
+                        xfs_defer_cancel(args->dfops);
                         goto out;
                 }
         } else {
@@ -990,14 +991,14 @@ restart:
                  * Check to see if the tree needs to be collapsed.
                  */
                 if (retval && (state->path.active > 1)) {
-                        xfs_bmap_init(args->flist, args->firstblock);
+                        xfs_defer_init(args->dfops, args->firstblock);
                         error = xfs_da3_join(state);
                         if (!error)
-                                error = xfs_bmap_finish(&args->trans,
-                                                        args->flist, dp);
+                                error = xfs_defer_finish(&args->trans,
+                                                        args->dfops, dp);
                         if (error) {
                                 args->trans = NULL;
-                                xfs_bmap_cancel(args->flist);
+                                xfs_defer_cancel(args->dfops);
                                 goto out;
                         }
                 }
@@ -1113,13 +1114,13 @@ xfs_attr_node_removename(xfs_da_args_t *args)
          * Check to see if the tree needs to be collapsed.
          */
         if (retval && (state->path.active > 1)) {
-                xfs_bmap_init(args->flist, args->firstblock);
+                xfs_defer_init(args->dfops, args->firstblock);
                 error = xfs_da3_join(state);
                 if (!error)
-                        error = xfs_bmap_finish(&args->trans, args->flist, dp);
+                        error = xfs_defer_finish(&args->trans, args->dfops, dp);
                 if (error) {
                         args->trans = NULL;
-                        xfs_bmap_cancel(args->flist);
+                        xfs_defer_cancel(args->dfops);
                         goto out;
                 }
                 /*
@@ -1146,15 +1147,15 @@ xfs_attr_node_removename(xfs_da_args_t *args)
                         goto out;
 
                 if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
-                        xfs_bmap_init(args->flist, args->firstblock);
+                        xfs_defer_init(args->dfops, args->firstblock);
                         error = xfs_attr3_leaf_to_shortform(bp, args, forkoff);
                         /* bp is gone due to xfs_da_shrink_inode */
                         if (!error)
-                                error = xfs_bmap_finish(&args->trans,
-                                                        args->flist, dp);
+                                error = xfs_defer_finish(&args->trans,
+                                                        args->dfops, dp);
                         if (error) {
                                 args->trans = NULL;
-                                xfs_bmap_cancel(args->flist);
+                                xfs_defer_cancel(args->dfops);
                                 goto out;
                         }
                 } else
diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
index 01a5ecfedfcf..8ea91f363093 100644
--- a/fs/xfs/libxfs/xfs_attr_leaf.c
+++ b/fs/xfs/libxfs/xfs_attr_leaf.c
@@ -792,7 +792,7 @@ xfs_attr_shortform_to_leaf(xfs_da_args_t *args)
         nargs.dp = dp;
         nargs.geo = args->geo;
         nargs.firstblock = args->firstblock;
-        nargs.flist = args->flist;
+        nargs.dfops = args->dfops;
         nargs.total = args->total;
         nargs.whichfork = XFS_ATTR_FORK;
         nargs.trans = args->trans;
@@ -922,7 +922,7 @@ xfs_attr3_leaf_to_shortform(
         nargs.geo = args->geo;
         nargs.dp = dp;
         nargs.firstblock = args->firstblock;
-        nargs.flist = args->flist;
+        nargs.dfops = args->dfops;
         nargs.total = args->total;
         nargs.whichfork = XFS_ATTR_FORK;
         nargs.trans = args->trans;
diff --git a/fs/xfs/libxfs/xfs_attr_remote.c b/fs/xfs/libxfs/xfs_attr_remote.c
index a572532a55cd..d52f525f5b2d 100644
--- a/fs/xfs/libxfs/xfs_attr_remote.c
+++ b/fs/xfs/libxfs/xfs_attr_remote.c
@@ -24,6 +24,7 @@
 #include "xfs_trans_resv.h"
 #include "xfs_bit.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_da_format.h"
 #include "xfs_da_btree.h"
 #include "xfs_inode.h"
@@ -460,16 +461,16 @@ xfs_attr_rmtval_set(
                  * extent and then crash then the block may not contain the
                  * correct metadata after log recovery occurs.
                  */
-                xfs_bmap_init(args->flist, args->firstblock);
+                xfs_defer_init(args->dfops, args->firstblock);
                 nmap = 1;
                 error = xfs_bmapi_write(args->trans, dp, (xfs_fileoff_t)lblkno,
                                   blkcnt, XFS_BMAPI_ATTRFORK, args->firstblock,
-                                  args->total, &map, &nmap, args->flist);
+                                  args->total, &map, &nmap, args->dfops);
                 if (!error)
-                        error = xfs_bmap_finish(&args->trans, args->flist, dp);
+                        error = xfs_defer_finish(&args->trans, args->dfops, dp);
                 if (error) {
                         args->trans = NULL;
-                        xfs_bmap_cancel(args->flist);
+                        xfs_defer_cancel(args->dfops);
                         return error;
                 }
 
@@ -503,7 +504,7 @@ xfs_attr_rmtval_set(
 
                 ASSERT(blkcnt > 0);
 
-                xfs_bmap_init(args->flist, args->firstblock);
+                xfs_defer_init(args->dfops, args->firstblock);
                 nmap = 1;
                 error = xfs_bmapi_read(dp, (xfs_fileoff_t)lblkno,
                                        blkcnt, &map, &nmap,
@@ -603,16 +604,16 @@ xfs_attr_rmtval_remove(
         blkcnt = args->rmtblkcnt;
         done = 0;
         while (!done) {
-                xfs_bmap_init(args->flist, args->firstblock);
+                xfs_defer_init(args->dfops, args->firstblock);
                 error = xfs_bunmapi(args->trans, args->dp, lblkno, blkcnt,
                                     XFS_BMAPI_ATTRFORK, 1, args->firstblock,
-                                    args->flist, &done);
+                                    args->dfops, &done);
                 if (!error)
-                        error = xfs_bmap_finish(&args->trans, args->flist,
+                        error = xfs_defer_finish(&args->trans, args->dfops,
                                                 args->dp);
                 if (error) {
                         args->trans = NULL;
-                        xfs_bmap_cancel(args->flist);
+                        xfs_defer_cancel(args->dfops);
                         return error;
                 }
 
diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index 2f2c85cc8117..b060bca93402 100644
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -24,6 +24,7 @@
 #include "xfs_bit.h"
 #include "xfs_sb.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_da_format.h"
 #include "xfs_da_btree.h"
 #include "xfs_dir2.h"
@@ -45,6 +46,7 @@
 #include "xfs_symlink.h"
 #include "xfs_attr_leaf.h"
 #include "xfs_filestream.h"
+#include "xfs_rmap.h"
 
 
 kmem_zone_t             *xfs_bmap_free_item_zone;
@@ -570,12 +572,13 @@ xfs_bmap_validate_ret(
  */
 void
 xfs_bmap_add_free(
-        struct xfs_mount        *mp,            /* mount point structure */
-        struct xfs_bmap_free    *flist,         /* list of extents */
-        xfs_fsblock_t           bno,            /* fs block number of extent */
-        xfs_filblks_t           len)            /* length of extent */
+        struct xfs_mount                *mp,
+        struct xfs_defer_ops            *dfops,
+        xfs_fsblock_t                   bno,
+        xfs_filblks_t                   len,
+        struct xfs_owner_info           *oinfo)
 {
-        struct xfs_bmap_free_item       *new;           /* new element */
+        struct xfs_extent_free_item     *new;           /* new element */
 #ifdef DEBUG
         xfs_agnumber_t          agno;
         xfs_agblock_t           agbno;
@@ -592,44 +595,17 @@ xfs_bmap_add_free(
         ASSERT(agbno + len <= mp->m_sb.sb_agblocks);
 #endif
         ASSERT(xfs_bmap_free_item_zone != NULL);
-        new = kmem_zone_alloc(xfs_bmap_free_item_zone, KM_SLEEP);
-        new->xbfi_startblock = bno;
-        new->xbfi_blockcount = (xfs_extlen_t)len;
-        list_add(&new->xbfi_list, &flist->xbf_flist);
-        flist->xbf_count++;
-}
-
-/*
- * Remove the entry "free" from the free item list.  Prev points to the
- * previous entry, unless "free" is the head of the list.
- */
-void
-xfs_bmap_del_free(
-        struct xfs_bmap_free            *flist, /* free item list header */
-        struct xfs_bmap_free_item       *free)  /* list item to be freed */
-{
-        list_del(&free->xbfi_list);
-        flist->xbf_count--;
-        kmem_zone_free(xfs_bmap_free_item_zone, free);
-}
-
-/*
- * Free up any items left in the list.
- */
-void
-xfs_bmap_cancel(
-        struct xfs_bmap_free            *flist) /* list of bmap_free_items */
-{
-        struct xfs_bmap_free_item       *free;  /* free list item */
 
-        if (flist->xbf_count == 0)
-                return;
-        while (!list_empty(&flist->xbf_flist)) {
-                free = list_first_entry(&flist->xbf_flist,
-                                struct xfs_bmap_free_item, xbfi_list);
-                xfs_bmap_del_free(flist, free);
-        }
-        ASSERT(flist->xbf_count == 0);
+        new = kmem_zone_alloc(xfs_bmap_free_item_zone, KM_SLEEP);
+        new->xefi_startblock = bno;
+        new->xefi_blockcount = (xfs_extlen_t)len;
+        if (oinfo)
+                new->xefi_oinfo = *oinfo;
+        else
+                xfs_rmap_skip_owner_update(&new->xefi_oinfo);
+        trace_xfs_bmap_free_defer(mp, XFS_FSB_TO_AGNO(mp, bno), 0,
+                        XFS_FSB_TO_AGBNO(mp, bno), len);
+        xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_FREE, &new->xefi_list);
 }
 
 /*
@@ -659,6 +635,7 @@ xfs_bmap_btree_to_extents(
         xfs_mount_t             *mp;    /* mount point structure */
         __be64                  *pp;    /* ptr to block address */
         struct xfs_btree_block  *rblock;/* root btree block */
+        struct xfs_owner_info   oinfo;
 
         mp = ip->i_mount;
         ifp = XFS_IFORK_PTR(ip, whichfork);
@@ -682,7 +659,8 @@ xfs_bmap_btree_to_extents(
         cblock = XFS_BUF_TO_BLOCK(cbp);
         if ((error = xfs_btree_check_block(cur, cblock, 0, cbp)))
                 return error;
-        xfs_bmap_add_free(mp, cur->bc_private.b.flist, cbno, 1);
+        xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, whichfork);
+        xfs_bmap_add_free(mp, cur->bc_private.b.dfops, cbno, 1, &oinfo);
         ip->i_d.di_nblocks--;
         xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L);
         xfs_trans_binval(tp, cbp);
@@ -705,7 +683,7 @@ xfs_bmap_extents_to_btree(
         xfs_trans_t             *tp,            /* transaction pointer */
         xfs_inode_t             *ip,            /* incore inode pointer */
         xfs_fsblock_t           *firstblock,    /* first-block-allocated */
-        xfs_bmap_free_t         *flist,         /* blocks freed in xaction */
+        struct xfs_defer_ops    *dfops,         /* blocks freed in xaction */
         xfs_btree_cur_t         **curp,         /* cursor returned to caller */
         int                     wasdel,         /* converting a delayed alloc */
         int                     *logflagsp,     /* inode logging flags */
@@ -754,7 +732,7 @@ xfs_bmap_extents_to_btree(
          */
         cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
         cur->bc_private.b.firstblock = *firstblock;
-        cur->bc_private.b.flist = flist;
+        cur->bc_private.b.dfops = dfops;
         cur->bc_private.b.flags = wasdel ? XFS_BTCUR_BPRV_WASDEL : 0;
         /*
          * Convert to a btree with two levels, one record in root.
@@ -763,11 +741,12 @@ xfs_bmap_extents_to_btree(
         memset(&args, 0, sizeof(args));
         args.tp = tp;
         args.mp = mp;
+        xfs_rmap_ino_bmbt_owner(&args.oinfo, ip->i_ino, whichfork);
         args.firstblock = *firstblock;
         if (*firstblock == NULLFSBLOCK) {
                 args.type = XFS_ALLOCTYPE_START_BNO;
                 args.fsbno = XFS_INO_TO_FSB(mp, ip->i_ino);
-        } else if (flist->xbf_low) {
+        } else if (dfops->dop_low) {
                 args.type = XFS_ALLOCTYPE_START_BNO;
                 args.fsbno = *firstblock;
         } else {
@@ -788,7 +767,7 @@ xfs_bmap_extents_to_btree(
         ASSERT(args.fsbno != NULLFSBLOCK);
         ASSERT(*firstblock == NULLFSBLOCK ||
                args.agno == XFS_FSB_TO_AGNO(mp, *firstblock) ||
-               (flist->xbf_low &&
+               (dfops->dop_low &&
                 args.agno > XFS_FSB_TO_AGNO(mp, *firstblock)));
         *firstblock = cur->bc_private.b.firstblock = args.fsbno;
         cur->bc_private.b.allocated++;
@@ -909,6 +888,7 @@ xfs_bmap_local_to_extents(
         memset(&args, 0, sizeof(args));
         args.tp = tp;
         args.mp = ip->i_mount;
+        xfs_rmap_ino_owner(&args.oinfo, ip->i_ino, whichfork, 0);
         args.firstblock = *firstblock;
         /*
          * Allocate a block.  We know we need only one, since the
@@ -973,7 +953,7 @@ xfs_bmap_add_attrfork_btree(
         xfs_trans_t             *tp,            /* transaction pointer */
         xfs_inode_t             *ip,            /* incore inode pointer */
         xfs_fsblock_t           *firstblock,    /* first block allocated */
-        xfs_bmap_free_t         *flist,         /* blocks to free at commit */
+        struct xfs_defer_ops    *dfops,         /* blocks to free at commit */
         int                     *flags)         /* inode logging flags */
 {
         xfs_btree_cur_t         *cur;           /* btree cursor */
@@ -986,7 +966,7 @@ xfs_bmap_add_attrfork_btree(
                 *flags |= XFS_ILOG_DBROOT;
         else {
                 cur = xfs_bmbt_init_cursor(mp, tp, ip, XFS_DATA_FORK);
-                cur->bc_private.b.flist = flist;
+                cur->bc_private.b.dfops = dfops;
                 cur->bc_private.b.firstblock = *firstblock;
                 if ((error = xfs_bmbt_lookup_ge(cur, 0, 0, 0, &stat)))
                         goto error0;
@@ -1016,7 +996,7 @@ xfs_bmap_add_attrfork_extents(
         xfs_trans_t             *tp,            /* transaction pointer */
         xfs_inode_t             *ip,            /* incore inode pointer */
         xfs_fsblock_t           *firstblock,    /* first block allocated */
-        xfs_bmap_free_t         *flist,         /* blocks to free at commit */
+        struct xfs_defer_ops    *dfops,         /* blocks to free at commit */
         int                     *flags)         /* inode logging flags */
 {
         xfs_btree_cur_t         *cur;           /* bmap btree cursor */
@@ -1025,7 +1005,7 @@ xfs_bmap_add_attrfork_extents(
         if (ip->i_d.di_nextents * sizeof(xfs_bmbt_rec_t) <= XFS_IFORK_DSIZE(ip))
                 return 0;
         cur = NULL;
-        error = xfs_bmap_extents_to_btree(tp, ip, firstblock, flist, &cur, 0,
+        error = xfs_bmap_extents_to_btree(tp, ip, firstblock, dfops, &cur, 0,
                 flags, XFS_DATA_FORK);
         if (cur) {
                 cur->bc_private.b.allocated = 0;
@@ -1051,7 +1031,7 @@ xfs_bmap_add_attrfork_local(
         xfs_trans_t             *tp,            /* transaction pointer */
         xfs_inode_t             *ip,            /* incore inode pointer */
         xfs_fsblock_t           *firstblock,    /* first block allocated */
-        xfs_bmap_free_t         *flist,         /* blocks to free at commit */
+        struct xfs_defer_ops    *dfops,         /* blocks to free at commit */
         int                     *flags)         /* inode logging flags */
 {
         xfs_da_args_t           dargs;          /* args for dir/attr code */
@@ -1064,7 +1044,7 @@ xfs_bmap_add_attrfork_local(
                 dargs.geo = ip->i_mount->m_dir_geo;
                 dargs.dp = ip;
                 dargs.firstblock = firstblock;
-                dargs.flist = flist;
+                dargs.dfops = dfops;
                 dargs.total = dargs.geo->fsbcount;
                 dargs.whichfork = XFS_DATA_FORK;
                 dargs.trans = tp;
@@ -1092,7 +1072,7 @@ xfs_bmap_add_attrfork(
         int                     rsvd)           /* xact may use reserved blks */
 {
         xfs_fsblock_t           firstblock;     /* 1st block/ag allocated */
-        xfs_bmap_free_t         flist;          /* freed extent records */
+        struct xfs_defer_ops    dfops;          /* freed extent records */
         xfs_mount_t             *mp;            /* mount structure */
         xfs_trans_t             *tp;            /* transaction pointer */
         int                     blks;           /* space reservation */
@@ -1158,18 +1138,18 @@ xfs_bmap_add_attrfork(
         ip->i_afp = kmem_zone_zalloc(xfs_ifork_zone, KM_SLEEP);
         ip->i_afp->if_flags = XFS_IFEXTENTS;
         logflags = 0;
-        xfs_bmap_init(&flist, &firstblock);
+        xfs_defer_init(&dfops, &firstblock);
         switch (ip->i_d.di_format) {
         case XFS_DINODE_FMT_LOCAL:
-                error = xfs_bmap_add_attrfork_local(tp, ip, &firstblock, &flist,
+                error = xfs_bmap_add_attrfork_local(tp, ip, &firstblock, &dfops,
                         &logflags);
                 break;
         case XFS_DINODE_FMT_EXTENTS:
                 error = xfs_bmap_add_attrfork_extents(tp, ip, &firstblock,
-                        &flist, &logflags);
+                        &dfops, &logflags);
                 break;
         case XFS_DINODE_FMT_BTREE:
-                error = xfs_bmap_add_attrfork_btree(tp, ip, &firstblock, &flist,
+                error = xfs_bmap_add_attrfork_btree(tp, ip, &firstblock, &dfops,
                         &logflags);
                 break;
         default:
@@ -1198,7 +1178,7 @@ xfs_bmap_add_attrfork(
                         xfs_log_sb(tp);
         }
 
-        error = xfs_bmap_finish(&tp, &flist, NULL);
+        error = xfs_defer_finish(&tp, &dfops, NULL);
         if (error)
                 goto bmap_cancel;
         error = xfs_trans_commit(tp);
@@ -1206,7 +1186,7 @@ xfs_bmap_add_attrfork(
         return error;
 
 bmap_cancel:
-        xfs_bmap_cancel(&flist);
+        xfs_defer_cancel(&dfops);
 trans_cancel:
         xfs_trans_cancel(tp);
         xfs_iunlock(ip, XFS_ILOCK_EXCL);
@@ -2003,7 +1983,7 @@ xfs_bmap_add_extent_delay_real(
 
                 if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
                         error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
-                                        bma->firstblock, bma->flist,
+                                        bma->firstblock, bma->dfops,
                                         &bma->cur, 1, &tmp_rval, whichfork);
                         rval |= tmp_rval;
                         if (error)
@@ -2087,7 +2067,7 @@ xfs_bmap_add_extent_delay_real(
 
                 if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
                         error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
-                                bma->firstblock, bma->flist, &bma->cur, 1,
+                                bma->firstblock, bma->dfops, &bma->cur, 1,
                                 &tmp_rval, whichfork);
                         rval |= tmp_rval;
                         if (error)
@@ -2156,7 +2136,7 @@ xfs_bmap_add_extent_delay_real(
 
                 if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
                         error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
-                                        bma->firstblock, bma->flist, &bma->cur,
+                                        bma->firstblock, bma->dfops, &bma->cur,
                                         1, &tmp_rval, whichfork);
                         rval |= tmp_rval;
                         if (error)
@@ -2199,13 +2179,18 @@ xfs_bmap_add_extent_delay_real(
                 ASSERT(0);
         }
 
+        /* add reverse mapping */
+        error = xfs_rmap_map_extent(mp, bma->dfops, bma->ip, whichfork, new);
+        if (error)
+                goto done;
+
         /* convert to a btree if necessary */
         if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
                 int     tmp_logflags;   /* partial log flag return val */
 
                 ASSERT(bma->cur == NULL);
                 error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
-                                bma->firstblock, bma->flist, &bma->cur,
+                                bma->firstblock, bma->dfops, &bma->cur,
                                 da_old > 0, &tmp_logflags, whichfork);
                 bma->logflags |= tmp_logflags;
                 if (error)
@@ -2247,7 +2232,7 @@ xfs_bmap_add_extent_unwritten_real(
         xfs_btree_cur_t         **curp, /* if *curp is null, not a btree */
         xfs_bmbt_irec_t         *new,   /* new data to add to file extents */
         xfs_fsblock_t           *first, /* pointer to firstblock variable */
-        xfs_bmap_free_t         *flist, /* list of extents to be freed */
+        struct xfs_defer_ops    *dfops, /* list of extents to be freed */
         int                     *logflagsp) /* inode logging flags */
 {
         xfs_btree_cur_t         *cur;   /* btree cursor */
@@ -2735,12 +2720,17 @@ xfs_bmap_add_extent_unwritten_real(
                 ASSERT(0);
         }
 
+        /* update reverse mappings */
+        error = xfs_rmap_convert_extent(mp, dfops, ip, XFS_DATA_FORK, new);
+        if (error)
+                goto done;
+
         /* convert to a btree if necessary */
         if (xfs_bmap_needs_btree(ip, XFS_DATA_FORK)) {
                 int     tmp_logflags;   /* partial log flag return val */
 
                 ASSERT(cur == NULL);
-                error = xfs_bmap_extents_to_btree(tp, ip, first, flist, &cur,
+                error = xfs_bmap_extents_to_btree(tp, ip, first, dfops, &cur,
                                 0, &tmp_logflags, XFS_DATA_FORK);
                 *logflagsp |= tmp_logflags;
                 if (error)
@@ -3127,13 +3117,18 @@ xfs_bmap_add_extent_hole_real(
                 break;
         }
 
+        /* add reverse mapping */
+        error = xfs_rmap_map_extent(mp, bma->dfops, bma->ip, whichfork, new);
+        if (error)
+                goto done;
+
         /* convert to a btree if necessary */
         if (xfs_bmap_needs_btree(bma->ip, whichfork)) {
                 int     tmp_logflags;   /* partial log flag return val */
 
                 ASSERT(bma->cur == NULL);
                 error = xfs_bmap_extents_to_btree(bma->tp, bma->ip,
-                                bma->firstblock, bma->flist, &bma->cur,
+                                bma->firstblock, bma->dfops, &bma->cur,
                                 0, &tmp_logflags, whichfork);
                 bma->logflags |= tmp_logflags;
                 if (error)
@@ -3691,9 +3686,10 @@ xfs_bmap_btalloc(
         args.tp = ap->tp;
         args.mp = mp;
         args.fsbno = ap->blkno;
+        xfs_rmap_skip_owner_update(&args.oinfo);
 
         /* Trim the allocation back to the maximum an AG can fit. */
-        args.maxlen = MIN(ap->length, XFS_ALLOC_AG_MAX_USABLE(mp));
+        args.maxlen = MIN(ap->length, mp->m_ag_max_usable);
         args.firstblock = *ap->firstblock;
         blen = 0;
         if (nullfb) {
@@ -3708,7 +3704,7 @@ xfs_bmap_btalloc(
                         error = xfs_bmap_btalloc_nullfb(ap, &args, &blen);
                 if (error)
                         return error;
-        } else if (ap->flist->xbf_low) {
+        } else if (ap->dfops->dop_low) {
                 if (xfs_inode_is_filestream(ap->ip))
                         args.type = XFS_ALLOCTYPE_FIRST_AG;
                 else
@@ -3741,7 +3737,7 @@ xfs_bmap_btalloc(
          * is >= the stripe unit and the allocation offset is
          * at the end of file.
          */
-        if (!ap->flist->xbf_low && ap->aeof) {
+        if (!ap->dfops->dop_low && ap->aeof) {
                 if (!ap->offset) {
                         args.alignment = stripe_align;
                         atype = args.type;
@@ -3834,7 +3830,7 @@ xfs_bmap_btalloc(
                 args.minleft = 0;
                 if ((error = xfs_alloc_vextent(&args)))
                         return error;
-                ap->flist->xbf_low = 1;
+                ap->dfops->dop_low = true;
         }
         if (args.fsbno != NULLFSBLOCK) {
                 /*
@@ -3844,7 +3840,7 @@ xfs_bmap_btalloc(
                 ASSERT(*ap->firstblock == NULLFSBLOCK ||
                        XFS_FSB_TO_AGNO(mp, *ap->firstblock) ==
                        XFS_FSB_TO_AGNO(mp, args.fsbno) ||
-                       (ap->flist->xbf_low &&
+                       (ap->dfops->dop_low &&
                         XFS_FSB_TO_AGNO(mp, *ap->firstblock) <
                         XFS_FSB_TO_AGNO(mp, args.fsbno)));
 
@@ -3852,7 +3848,7 @@ xfs_bmap_btalloc(
                 if (*ap->firstblock == NULLFSBLOCK)
                         *ap->firstblock = args.fsbno;
                 ASSERT(nullfb || fb_agno == args.agno ||
-                       (ap->flist->xbf_low && fb_agno < args.agno));
+                       (ap->dfops->dop_low && fb_agno < args.agno));
                 ap->length = args.len;
                 ap->ip->i_d.di_nblocks += args.len;
                 xfs_trans_log_inode(ap->tp, ap->ip, XFS_ILOG_CORE);
@@ -4319,7 +4315,7 @@ xfs_bmapi_allocate(
         if (error)
                 return error;
 
-        if (bma->flist->xbf_low)
+        if (bma->dfops->dop_low)
                 bma->minleft = 0;
         if (bma->cur)
                 bma->cur->bc_private.b.firstblock = *bma->firstblock;
@@ -4328,7 +4324,7 @@ xfs_bmapi_allocate(
         if ((ifp->if_flags & XFS_IFBROOT) && !bma->cur) {
                 bma->cur = xfs_bmbt_init_cursor(mp, bma->tp, bma->ip, whichfork);
                 bma->cur->bc_private.b.firstblock = *bma->firstblock;
-                bma->cur->bc_private.b.flist = bma->flist;
+                bma->cur->bc_private.b.dfops = bma->dfops;
         }
         /*
          * Bump the number of extents we've allocated
@@ -4409,7 +4405,7 @@ xfs_bmapi_convert_unwritten(
                 bma->cur = xfs_bmbt_init_cursor(bma->ip->i_mount, bma->tp,
                                         bma->ip, whichfork);
                 bma->cur->bc_private.b.firstblock = *bma->firstblock;
-                bma->cur->bc_private.b.flist = bma->flist;
+                bma->cur->bc_private.b.dfops = bma->dfops;
         }
         mval->br_state = (mval->br_state == XFS_EXT_UNWRITTEN)
                                 ? XFS_EXT_NORM : XFS_EXT_UNWRITTEN;
@@ -4426,7 +4422,7 @@ xfs_bmapi_convert_unwritten(
         }
 
         error = xfs_bmap_add_extent_unwritten_real(bma->tp, bma->ip, &bma->idx,
-                        &bma->cur, mval, bma->firstblock, bma->flist,
+                        &bma->cur, mval, bma->firstblock, bma->dfops,
                         &tmp_logflags);
         /*
          * Log the inode core unconditionally in the unwritten extent conversion
@@ -4480,7 +4476,7 @@ xfs_bmapi_write(
         xfs_extlen_t            total,          /* total blocks needed */
         struct xfs_bmbt_irec    *mval,          /* output: map values */
         int                     *nmap,          /* i/o: mval size/count */
-        struct xfs_bmap_free    *flist)         /* i/o: list extents to free */
+        struct xfs_defer_ops    *dfops)         /* i/o: list extents to free */
 {
         struct xfs_mount        *mp = ip->i_mount;
         struct xfs_ifork        *ifp;
@@ -4570,7 +4566,7 @@ xfs_bmapi_write(
         bma.ip = ip;
         bma.total = total;
         bma.userdata = 0;
-        bma.flist = flist;
+        bma.dfops = dfops;
         bma.firstblock = firstblock;
 
         while (bno < end && n < *nmap) {
@@ -4684,7 +4680,7 @@ error0:
                                XFS_FSB_TO_AGNO(mp, *firstblock) ==
                                XFS_FSB_TO_AGNO(mp,
                                        bma.cur->bc_private.b.firstblock) ||
-                               (flist->xbf_low &&
+                               (dfops->dop_low &&
                                 XFS_FSB_TO_AGNO(mp, *firstblock) <
                                 XFS_FSB_TO_AGNO(mp,
                                         bma.cur->bc_private.b.firstblock)));
@@ -4768,7 +4764,7 @@ xfs_bmap_del_extent(
         xfs_inode_t             *ip,    /* incore inode pointer */
         xfs_trans_t             *tp,    /* current transaction pointer */
         xfs_extnum_t            *idx,   /* extent number to update/delete */
-        xfs_bmap_free_t         *flist, /* list of extents to be freed */
+        struct xfs_defer_ops    *dfops, /* list of extents to be freed */
         xfs_btree_cur_t         *cur,   /* if null, not a btree */
         xfs_bmbt_irec_t         *del,   /* data to remove from extents */
         int                     *logflagsp, /* inode logging flags */
@@ -4870,6 +4866,7 @@ xfs_bmap_del_extent(
                 nblks = 0;
                 do_fx = 0;
         }
+
         /*
          * Set flag value to use in switch statement.
          * Left-contig is 2, right-contig is 1.
@@ -5052,12 +5049,20 @@ xfs_bmap_del_extent(
                 ++*idx;
                 break;
         }
+
+        /* remove reverse mapping */
+        if (!delay) {
+                error = xfs_rmap_unmap_extent(mp, dfops, ip, whichfork, del);
+                if (error)
+                        goto done;
+        }
+
         /*
          * If we need to, add to list of extents to delete.
          */
         if (do_fx)
-                xfs_bmap_add_free(mp, flist, del->br_startblock,
-                        del->br_blockcount);
+                xfs_bmap_add_free(mp, dfops, del->br_startblock,
+                                del->br_blockcount, NULL);
         /*
          * Adjust inode # blocks in the file.
          */
@@ -5097,7 +5102,7 @@ xfs_bunmapi(
         xfs_extnum_t            nexts,          /* number of extents max */
         xfs_fsblock_t           *firstblock,    /* first allocated block
                                                    controls a.g. for allocs */
-        xfs_bmap_free_t         *flist,         /* i/o: list extents to free */
+        struct xfs_defer_ops    *dfops,         /* i/o: list extents to free */
         int                     *done)          /* set if not done yet */
 {
         xfs_btree_cur_t         *cur;           /* bmap btree cursor */
@@ -5170,7 +5175,7 @@ xfs_bunmapi(
                 ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_BTREE);
                 cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
                 cur->bc_private.b.firstblock = *firstblock;
-                cur->bc_private.b.flist = flist;
+                cur->bc_private.b.dfops = dfops;
                 cur->bc_private.b.flags = 0;
         } else
                 cur = NULL;
@@ -5179,8 +5184,10 @@ xfs_bunmapi(
                 /*
                  * Synchronize by locking the bitmap inode.
                  */
-                xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL);
+                xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP);
                 xfs_trans_ijoin(tp, mp->m_rbmip, XFS_ILOCK_EXCL);
+                xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM);
+                xfs_trans_ijoin(tp, mp->m_rsumip, XFS_ILOCK_EXCL);
         }
 
         extno = 0;
@@ -5262,7 +5269,7 @@ xfs_bunmapi(
                         }
                         del.br_state = XFS_EXT_UNWRITTEN;
                         error = xfs_bmap_add_extent_unwritten_real(tp, ip,
-                                        &lastx, &cur, &del, firstblock, flist,
+                                        &lastx, &cur, &del, firstblock, dfops,
                                         &logflags);
                         if (error)
                                 goto error0;
@@ -5321,7 +5328,7 @@ xfs_bunmapi(
                                 lastx--;
                                 error = xfs_bmap_add_extent_unwritten_real(tp,
                                                 ip, &lastx, &cur, &prev,
-                                                firstblock, flist, &logflags);
+                                                firstblock, dfops, &logflags);
                                 if (error)
                                         goto error0;
                                 goto nodelete;
@@ -5330,7 +5337,7 @@ xfs_bunmapi(
                                 del.br_state = XFS_EXT_UNWRITTEN;
                                 error = xfs_bmap_add_extent_unwritten_real(tp,
                                                 ip, &lastx, &cur, &del,
-                                                firstblock, flist, &logflags);
+                                                firstblock, dfops, &logflags);
                                 if (error)
                                         goto error0;
                                 goto nodelete;
@@ -5388,7 +5395,7 @@ xfs_bunmapi(
                 } else if (cur)
                         cur->bc_private.b.flags &= ~XFS_BTCUR_BPRV_WASDEL;
 
-                error = xfs_bmap_del_extent(ip, tp, &lastx, flist, cur, &del,
+                error = xfs_bmap_del_extent(ip, tp, &lastx, dfops, cur, &del,
                                 &tmp_logflags, whichfork);
                 logflags |= tmp_logflags;
                 if (error)
@@ -5422,7 +5429,7 @@ nodelete:
          */
         if (xfs_bmap_needs_btree(ip, whichfork)) {
                 ASSERT(cur == NULL);
-                error = xfs_bmap_extents_to_btree(tp, ip, firstblock, flist,
+                error = xfs_bmap_extents_to_btree(tp, ip, firstblock, dfops,
                         &cur, 0, &tmp_logflags, whichfork);
                 logflags |= tmp_logflags;
                 if (error)
@@ -5589,7 +5596,8 @@ xfs_bmse_shift_one(
         struct xfs_bmbt_rec_host        *gotp,
         struct xfs_btree_cur            *cur,
         int                             *logflags,
-        enum shift_direction            direction)
+        enum shift_direction            direction,
+        struct xfs_defer_ops            *dfops)
 {
         struct xfs_ifork                *ifp;
         struct xfs_mount                *mp;
@@ -5637,9 +5645,13 @@ xfs_bmse_shift_one(
                 /* check whether to merge the extent or shift it down */
                 if (xfs_bmse_can_merge(&adj_irec, &got,
                                        offset_shift_fsb)) {
-                        return xfs_bmse_merge(ip, whichfork, offset_shift_fsb,
-                                              *current_ext, gotp, adj_irecp,
-                                              cur, logflags);
+                        error = xfs_bmse_merge(ip, whichfork, offset_shift_fsb,
+                                               *current_ext, gotp, adj_irecp,
+                                               cur, logflags);
+                        if (error)
+                                return error;
+                        adj_irec = got;
+                        goto update_rmap;
                 }
         } else {
                 startoff = got.br_startoff + offset_shift_fsb;
@@ -5676,9 +5688,10 @@ update_current_ext:
                 (*current_ext)--;
         xfs_bmbt_set_startoff(gotp, startoff);
         *logflags |= XFS_ILOG_CORE;
+        adj_irec = got;
         if (!cur) {
                 *logflags |= XFS_ILOG_DEXT;
-                return 0;
+                goto update_rmap;
         }
 
         error = xfs_bmbt_lookup_eq(cur, got.br_startoff, got.br_startblock,
@@ -5688,8 +5701,18 @@ update_current_ext:
         XFS_WANT_CORRUPTED_RETURN(mp, i == 1);
 
         got.br_startoff = startoff;
-        return xfs_bmbt_update(cur, got.br_startoff, got.br_startblock,
-                               got.br_blockcount, got.br_state);
+        error = xfs_bmbt_update(cur, got.br_startoff, got.br_startblock,
+                        got.br_blockcount, got.br_state);
+        if (error)
+                return error;
+
+update_rmap:
+        /* update reverse mapping */
+        error = xfs_rmap_unmap_extent(mp, dfops, ip, whichfork, &adj_irec);
+        if (error)
+                return error;
+        adj_irec.br_startoff = startoff;
+        return xfs_rmap_map_extent(mp, dfops, ip, whichfork, &adj_irec);
 }
 
 /*
@@ -5711,7 +5734,7 @@ xfs_bmap_shift_extents(
         int                     *done,
         xfs_fileoff_t           stop_fsb,
         xfs_fsblock_t           *firstblock,
-        struct xfs_bmap_free    *flist,
+        struct xfs_defer_ops    *dfops,
         enum shift_direction    direction,
         int                     num_exts)
 {
@@ -5756,7 +5779,7 @@ xfs_bmap_shift_extents(
         if (ifp->if_flags & XFS_IFBROOT) {
                 cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
                 cur->bc_private.b.firstblock = *firstblock;
-                cur->bc_private.b.flist = flist;
+                cur->bc_private.b.dfops = dfops;
                 cur->bc_private.b.flags = 0;
         }
 
@@ -5817,7 +5840,7 @@ xfs_bmap_shift_extents(
         while (nexts++ < num_exts) {
                 error = xfs_bmse_shift_one(ip, whichfork, offset_shift_fsb,
                                            &current_ext, gotp, cur, &logflags,
-                                           direction);
+                                           direction, dfops);
                 if (error)
                         goto del_cursor;
                 /*
@@ -5865,7 +5888,7 @@ xfs_bmap_split_extent_at(
         struct xfs_inode        *ip,
         xfs_fileoff_t           split_fsb,
         xfs_fsblock_t           *firstfsb,
-        struct xfs_bmap_free    *free_list)
+        struct xfs_defer_ops    *dfops)
 {
         int                             whichfork = XFS_DATA_FORK;
         struct xfs_btree_cur            *cur = NULL;
@@ -5927,7 +5950,7 @@ xfs_bmap_split_extent_at(
         if (ifp->if_flags & XFS_IFBROOT) {
                 cur = xfs_bmbt_init_cursor(mp, tp, ip, whichfork);
                 cur->bc_private.b.firstblock = *firstfsb;
-                cur->bc_private.b.flist = free_list;
+                cur->bc_private.b.dfops = dfops;
                 cur->bc_private.b.flags = 0;
                 error = xfs_bmbt_lookup_eq(cur, got.br_startoff,
                                 got.br_startblock,
@@ -5980,7 +6003,7 @@ xfs_bmap_split_extent_at(
                 int tmp_logflags; /* partial log flag return val */
 
                 ASSERT(cur == NULL);
-                error = xfs_bmap_extents_to_btree(tp, ip, firstfsb, free_list,
+                error = xfs_bmap_extents_to_btree(tp, ip, firstfsb, dfops,
                                 &cur, 0, &tmp_logflags, whichfork);
                 logflags |= tmp_logflags;
         }
@@ -6004,7 +6027,7 @@ xfs_bmap_split_extent(
 {
         struct xfs_mount        *mp = ip->i_mount;
         struct xfs_trans        *tp;
-        struct xfs_bmap_free    free_list;
+        struct xfs_defer_ops    dfops;
         xfs_fsblock_t           firstfsb;
         int                     error;
 
@@ -6016,21 +6039,21 @@ xfs_bmap_split_extent(
         xfs_ilock(ip, XFS_ILOCK_EXCL);
         xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
 
-        xfs_bmap_init(&free_list, &firstfsb);
+        xfs_defer_init(&dfops, &firstfsb);
 
         error = xfs_bmap_split_extent_at(tp, ip, split_fsb,
-                        &firstfsb, &free_list);
+                        &firstfsb, &dfops);
         if (error)
                 goto out;
 
-        error = xfs_bmap_finish(&tp, &free_list, NULL);
+        error = xfs_defer_finish(&tp, &dfops, NULL);
         if (error)
                 goto out;
 
         return xfs_trans_commit(tp);
 
 out:
-        xfs_bmap_cancel(&free_list);
+        xfs_defer_cancel(&dfops);
         xfs_trans_cancel(tp);
         return error;
 }
diff --git a/fs/xfs/libxfs/xfs_bmap.h b/fs/xfs/libxfs/xfs_bmap.h
index f1f3ae6c0a3f..254034f96941 100644
--- a/fs/xfs/libxfs/xfs_bmap.h
+++ b/fs/xfs/libxfs/xfs_bmap.h
@@ -32,7 +32,7 @@ extern kmem_zone_t	*xfs_bmap_free_item_zone;
  */
 struct xfs_bmalloca {
         xfs_fsblock_t           *firstblock; /* i/o first block allocated */
-        struct xfs_bmap_free    *flist; /* bmap freelist */
+        struct xfs_defer_ops    *dfops; /* bmap freelist */
         struct xfs_trans        *tp;    /* transaction pointer */
         struct xfs_inode        *ip;    /* incore inode pointer */
         struct xfs_bmbt_irec    prev;   /* extent before the new one */
@@ -62,34 +62,14 @@ struct xfs_bmalloca {
  * List of extents to be free "later".
  * The list is kept sorted on xbf_startblock.
  */
-struct xfs_bmap_free_item
+struct xfs_extent_free_item
 {
-        xfs_fsblock_t           xbfi_startblock;/* starting fs block number */
-        xfs_extlen_t            xbfi_blockcount;/* number of blocks in extent */
-        struct list_head        xbfi_list;
+        xfs_fsblock_t           xefi_startblock;/* starting fs block number */
+        xfs_extlen_t            xefi_blockcount;/* number of blocks in extent */
+        struct list_head        xefi_list;
+        struct xfs_owner_info   xefi_oinfo;     /* extent owner */
 };
 
-/*
- * Header for free extent list.
- *
- * xbf_low is used by the allocator to activate the lowspace algorithm -
- * when free space is running low the extent allocator may choose to
- * allocate an extent from an AG without leaving sufficient space for
- * a btree split when inserting the new extent.  In this case the allocator
- * will enable the lowspace algorithm which is supposed to allow further
- * allocations (such as btree splits and newroots) to allocate from
- * sequential AGs.  In order to avoid locking AGs out of order the lowspace
- * algorithm will start searching for free space from AG 0.  If the correct
- * transaction reservations have been made then this algorithm will eventually
- * find all the space it needs.
- */
-typedef struct xfs_bmap_free
-{
-        struct list_head        xbf_flist;      /* list of to-be-free extents */
-        int                     xbf_count;      /* count of items on list */
-        int                     xbf_low;        /* alloc in low mode */
-} xfs_bmap_free_t;
-
 #define XFS_BMAP_MAX_NMAP       4
 
 /*
@@ -139,14 +119,6 @@ static inline int xfs_bmapi_aflag(int w)
 #define DELAYSTARTBLOCK         ((xfs_fsblock_t)-1LL)
 #define HOLESTARTBLOCK          ((xfs_fsblock_t)-2LL)
 
-static inline void xfs_bmap_init(xfs_bmap_free_t *flp, xfs_fsblock_t *fbp)
-{
-        INIT_LIST_HEAD(&flp->xbf_flist);
-        flp->xbf_count = 0;
-        flp->xbf_low = 0;
-        *fbp = NULLFSBLOCK;
-}
-
 /*
  * Flags for xfs_bmap_add_extent*.
  */
@@ -193,11 +165,9 @@ void	xfs_bmap_trace_exlist(struct xfs_inode *ip, xfs_extnum_t cnt,
 
 int     xfs_bmap_add_attrfork(struct xfs_inode *ip, int size, int rsvd);
 void    xfs_bmap_local_to_extents_empty(struct xfs_inode *ip, int whichfork);
-void    xfs_bmap_add_free(struct xfs_mount *mp, struct xfs_bmap_free *flist,
-                          xfs_fsblock_t bno, xfs_filblks_t len);
-void    xfs_bmap_cancel(struct xfs_bmap_free *flist);
-int     xfs_bmap_finish(struct xfs_trans **tp, struct xfs_bmap_free *flist,
-                        struct xfs_inode *ip);
+void    xfs_bmap_add_free(struct xfs_mount *mp, struct xfs_defer_ops *dfops,
+                          xfs_fsblock_t bno, xfs_filblks_t len,
+                          struct xfs_owner_info *oinfo);
 void    xfs_bmap_compute_maxlevels(struct xfs_mount *mp, int whichfork);
 int     xfs_bmap_first_unused(struct xfs_trans *tp, struct xfs_inode *ip,
                 xfs_extlen_t len, xfs_fileoff_t *unused, int whichfork);
@@ -218,18 +188,18 @@ int	xfs_bmapi_write(struct xfs_trans *tp, struct xfs_inode *ip,
                 xfs_fileoff_t bno, xfs_filblks_t len, int flags,
                 xfs_fsblock_t *firstblock, xfs_extlen_t total,
                 struct xfs_bmbt_irec *mval, int *nmap,
-                struct xfs_bmap_free *flist);
+                struct xfs_defer_ops *dfops);
 int     xfs_bunmapi(struct xfs_trans *tp, struct xfs_inode *ip,
                 xfs_fileoff_t bno, xfs_filblks_t len, int flags,
                 xfs_extnum_t nexts, xfs_fsblock_t *firstblock,
-                struct xfs_bmap_free *flist, int *done);
+                struct xfs_defer_ops *dfops, int *done);
 int     xfs_check_nostate_extents(struct xfs_ifork *ifp, xfs_extnum_t idx,
                 xfs_extnum_t num);
 uint    xfs_default_attroffset(struct xfs_inode *ip);
 int     xfs_bmap_shift_extents(struct xfs_trans *tp, struct xfs_inode *ip,
                 xfs_fileoff_t *next_fsb, xfs_fileoff_t offset_shift_fsb,
                 int *done, xfs_fileoff_t stop_fsb, xfs_fsblock_t *firstblock,
-                struct xfs_bmap_free *flist, enum shift_direction direction,
+                struct xfs_defer_ops *dfops, enum shift_direction direction,
                 int num_exts);
 int     xfs_bmap_split_extent(struct xfs_inode *ip, xfs_fileoff_t split_offset);
 
diff --git a/fs/xfs/libxfs/xfs_bmap_btree.c b/fs/xfs/libxfs/xfs_bmap_btree.c
index db0c71e470c9..cd85274e810c 100644
--- a/fs/xfs/libxfs/xfs_bmap_btree.c
+++ b/fs/xfs/libxfs/xfs_bmap_btree.c
@@ -23,6 +23,7 @@
 #include "xfs_trans_resv.h"
 #include "xfs_bit.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_inode.h"
 #include "xfs_trans.h"
 #include "xfs_inode_item.h"
@@ -34,6 +35,7 @@
 #include "xfs_quota.h"
 #include "xfs_trace.h"
 #include "xfs_cksum.h"
+#include "xfs_rmap.h"
 
 /*
  * Determine the extent state.
@@ -406,11 +408,11 @@ xfs_bmbt_dup_cursor(
                         cur->bc_private.b.ip, cur->bc_private.b.whichfork);
 
         /*
-         * Copy the firstblock, flist, and flags values,
+         * Copy the firstblock, dfops, and flags values,
          * since init cursor doesn't get them.
          */
         new->bc_private.b.firstblock = cur->bc_private.b.firstblock;
-        new->bc_private.b.flist = cur->bc_private.b.flist;
+        new->bc_private.b.dfops = cur->bc_private.b.dfops;
         new->bc_private.b.flags = cur->bc_private.b.flags;
 
         return new;
@@ -423,7 +425,7 @@ xfs_bmbt_update_cursor(
 {
         ASSERT((dst->bc_private.b.firstblock != NULLFSBLOCK) ||
                (dst->bc_private.b.ip->i_d.di_flags & XFS_DIFLAG_REALTIME));
-        ASSERT(dst->bc_private.b.flist == src->bc_private.b.flist);
+        ASSERT(dst->bc_private.b.dfops == src->bc_private.b.dfops);
 
         dst->bc_private.b.allocated += src->bc_private.b.allocated;
         dst->bc_private.b.firstblock = src->bc_private.b.firstblock;
@@ -446,6 +448,8 @@ xfs_bmbt_alloc_block(
         args.mp = cur->bc_mp;
         args.fsbno = cur->bc_private.b.firstblock;
         args.firstblock = args.fsbno;
+        xfs_rmap_ino_bmbt_owner(&args.oinfo, cur->bc_private.b.ip->i_ino,
+                        cur->bc_private.b.whichfork);
 
         if (args.fsbno == NULLFSBLOCK) {
                 args.fsbno = be64_to_cpu(start->l);
@@ -462,7 +466,7 @@ xfs_bmbt_alloc_block(
                  * block allocation here and corrupt the filesystem.
                  */
                 args.minleft = args.tp->t_blk_res;
-        } else if (cur->bc_private.b.flist->xbf_low) {
+        } else if (cur->bc_private.b.dfops->dop_low) {
                 args.type = XFS_ALLOCTYPE_START_BNO;
         } else {
                 args.type = XFS_ALLOCTYPE_NEAR_BNO;
@@ -490,7 +494,7 @@ xfs_bmbt_alloc_block(
                 error = xfs_alloc_vextent(&args);
                 if (error)
                         goto error0;
-                cur->bc_private.b.flist->xbf_low = 1;
+                cur->bc_private.b.dfops->dop_low = true;
         }
         if (args.fsbno == NULLFSBLOCK) {
                 XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
@@ -525,8 +529,10 @@ xfs_bmbt_free_block(
         struct xfs_inode        *ip = cur->bc_private.b.ip;
         struct xfs_trans        *tp = cur->bc_tp;
         xfs_fsblock_t           fsbno = XFS_DADDR_TO_FSB(mp, XFS_BUF_ADDR(bp));
+        struct xfs_owner_info   oinfo;
 
-        xfs_bmap_add_free(mp, cur->bc_private.b.flist, fsbno, 1);
+        xfs_rmap_ino_bmbt_owner(&oinfo, ip->i_ino, cur->bc_private.b.whichfork);
+        xfs_bmap_add_free(mp, cur->bc_private.b.dfops, fsbno, 1, &oinfo);
         ip->i_d.di_nblocks--;
 
         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
@@ -600,17 +606,6 @@ xfs_bmbt_init_key_from_rec(
 }
 
 STATIC void
-xfs_bmbt_init_rec_from_key(
-        union xfs_btree_key     *key,
-        union xfs_btree_rec     *rec)
-{
-        ASSERT(key->bmbt.br_startoff != 0);
-
-        xfs_bmbt_disk_set_allf(&rec->bmbt, be64_to_cpu(key->bmbt.br_startoff),
-                               0, 0, XFS_EXT_NORM);
-}
-
-STATIC void
 xfs_bmbt_init_rec_from_cur(
         struct xfs_btree_cur    *cur,
         union xfs_btree_rec     *rec)
@@ -760,7 +755,6 @@ static const struct xfs_btree_ops xfs_bmbt_ops = {
         .get_minrecs            = xfs_bmbt_get_minrecs,
         .get_dmaxrecs           = xfs_bmbt_get_dmaxrecs,
         .init_key_from_rec      = xfs_bmbt_init_key_from_rec,
-        .init_rec_from_key      = xfs_bmbt_init_rec_from_key,
         .init_rec_from_cur      = xfs_bmbt_init_rec_from_cur,
         .init_ptr_from_cur      = xfs_bmbt_init_ptr_from_cur,
         .key_diff               = xfs_bmbt_key_diff,
@@ -800,7 +794,7 @@ xfs_bmbt_init_cursor(
         cur->bc_private.b.forksize = XFS_IFORK_SIZE(ip, whichfork);
         cur->bc_private.b.ip = ip;
         cur->bc_private.b.firstblock = NULLFSBLOCK;
-        cur->bc_private.b.flist = NULL;
+        cur->bc_private.b.dfops = NULL;
         cur->bc_private.b.allocated = 0;
         cur->bc_private.b.flags = 0;
         cur->bc_private.b.whichfork = whichfork;
diff --git a/fs/xfs/libxfs/xfs_btree.c b/fs/xfs/libxfs/xfs_btree.c
index 07eeb0b4ca74..b5c213a051cd 100644
--- a/fs/xfs/libxfs/xfs_btree.c
+++ b/fs/xfs/libxfs/xfs_btree.c
@@ -23,6 +23,7 @@
 #include "xfs_trans_resv.h"
 #include "xfs_bit.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_inode.h"
 #include "xfs_trans.h"
 #include "xfs_inode_item.h"
@@ -43,15 +44,14 @@ kmem_zone_t	*xfs_btree_cur_zone;
  * Btree magic numbers.
  */
 static const __uint32_t xfs_magics[2][XFS_BTNUM_MAX] = {
-        { XFS_ABTB_MAGIC, XFS_ABTC_MAGIC, XFS_BMAP_MAGIC, XFS_IBT_MAGIC,
+        { XFS_ABTB_MAGIC, XFS_ABTC_MAGIC, 0, XFS_BMAP_MAGIC, XFS_IBT_MAGIC,
           XFS_FIBT_MAGIC },
-        { XFS_ABTB_CRC_MAGIC, XFS_ABTC_CRC_MAGIC,
+        { XFS_ABTB_CRC_MAGIC, XFS_ABTC_CRC_MAGIC, XFS_RMAP_CRC_MAGIC,
           XFS_BMAP_CRC_MAGIC, XFS_IBT_CRC_MAGIC, XFS_FIBT_CRC_MAGIC }
 };
 #define xfs_btree_magic(cur) \
         xfs_magics[!!((cur)->bc_flags & XFS_BTREE_CRC_BLOCKS)][cur->bc_btnum]
 
-
 STATIC int                              /* error (0 or EFSCORRUPTED) */
 xfs_btree_check_lblock(
         struct xfs_btree_cur    *cur,   /* btree cursor */
@@ -428,6 +428,50 @@ xfs_btree_dup_cursor(
  * into a btree block (xfs_btree_*_offset) or return a pointer to the given
  * record, key or pointer (xfs_btree_*_addr).  Note that all addressing
  * inside the btree block is done using indices starting at one, not zero!
+ *
+ * If XFS_BTREE_OVERLAPPING is set, then this btree supports keys containing
+ * overlapping intervals.  In such a tree, records are still sorted lowest to
+ * highest and indexed by the smallest key value that refers to the record.
+ * However, nodes are different: each pointer has two associated keys -- one
+ * indexing the lowest key available in the block(s) below (the same behavior
+ * as the key in a regular btree) and another indexing the highest key
+ * available in the block(s) below.  Because records are /not/ sorted by the
+ * highest key, all leaf block updates require us to compute the highest key
+ * that matches any record in the leaf and to recursively update the high keys
+ * in the nodes going further up in the tree, if necessary.  Nodes look like
+ * this:
+ *
+ *              +--------+-----+-----+-----+-----+-----+-------+-------+-----+
+ * Non-Leaf:    | header | lo1 | hi1 | lo2 | hi2 | ... | ptr 1 | ptr 2 | ... |
+ *              +--------+-----+-----+-----+-----+-----+-------+-------+-----+
+ *
+ * To perform an interval query on an overlapped tree, perform the usual
+ * depth-first search and use the low and high keys to decide if we can skip
+ * that particular node.  If a leaf node is reached, return the records that
+ * intersect the interval.  Note that an interval query may return numerous
+ * entries.  For a non-overlapped tree, simply search for the record associated
+ * with the lowest key and iterate forward until a non-matching record is
+ * found.  Section 14.3 ("Interval Trees") of _Introduction to Algorithms_ by
+ * Cormen, Leiserson, Rivest, and Stein (2nd or 3rd ed. only) discuss this in
+ * more detail.
+ *
+ * Why do we care about overlapping intervals?  Let's say you have a bunch of
+ * reverse mapping records on a reflink filesystem:
+ *
+ * 1: +- file A startblock B offset C length D -----------+
+ * 2:      +- file E startblock F offset G length H --------------+
+ * 3:      +- file I startblock F offset J length K --+
+ * 4:                                                        +- file L... --+
+ *
+ * Now say we want to map block (B+D) into file A at offset (C+D).  Ideally,
+ * we'd simply increment the length of record 1.  But how do we find the record
+ * that ends at (B+D-1) (i.e. record 1)?  A LE lookup of (B+D-1) would return
+ * record 3 because the keys are ordered first by startblock.  An interval
+ * query would return records 1 and 2 because they both overlap (B+D-1), and
+ * from that we can pick out record 1 as the appropriate left neighbor.
+ *
+ * In the non-overlapped case you can do a LE lookup and decrement the cursor
+ * because a record's interval must end before the next record.
  */
 
 /*
@@ -479,6 +523,18 @@ xfs_btree_key_offset(
 }
 
 /*
+ * Calculate offset of the n-th high key in a btree block.
+ */
+STATIC size_t
+xfs_btree_high_key_offset(
+        struct xfs_btree_cur    *cur,
+        int                     n)
+{
+        return xfs_btree_block_len(cur) +
+                (n - 1) * cur->bc_ops->key_len + (cur->bc_ops->key_len / 2);
+}
+
+/*
  * Calculate offset of the n-th block pointer in a btree block.
  */
 STATIC size_t
@@ -519,6 +575,19 @@ xfs_btree_key_addr(
 }
 
 /*
+ * Return a pointer to the n-th high key in the btree block.
+ */
+STATIC union xfs_btree_key *
+xfs_btree_high_key_addr(
+        struct xfs_btree_cur    *cur,
+        int                     n,
+        struct xfs_btree_block  *block)
+{
+        return (union xfs_btree_key *)
+                ((char *)block + xfs_btree_high_key_offset(cur, n));
+}
+
+/*
  * Return a pointer to the n-th block pointer in the btree block.
  */
 STATIC union xfs_btree_ptr *
@@ -1144,6 +1213,9 @@ xfs_btree_set_refs(
         case XFS_BTNUM_BMAP:
                 xfs_buf_set_ref(bp, XFS_BMAP_BTREE_REF);
                 break;
+        case XFS_BTNUM_RMAP:
+                xfs_buf_set_ref(bp, XFS_RMAP_BTREE_REF);
+                break;
         default:
                 ASSERT(0);
         }
@@ -1879,32 +1951,214 @@ error0:
         return error;
 }
 
+/* Find the high key storage area from a regular key. */
+STATIC union xfs_btree_key *
+xfs_btree_high_key_from_key(
+        struct xfs_btree_cur    *cur,
+        union xfs_btree_key     *key)
+{
+        ASSERT(cur->bc_flags & XFS_BTREE_OVERLAPPING);
+        return (union xfs_btree_key *)((char *)key +
+                        (cur->bc_ops->key_len / 2));
+}
+
+/* Determine the low (and high if overlapped) keys of a leaf block */
+STATIC void
+xfs_btree_get_leaf_keys(
+        struct xfs_btree_cur    *cur,
+        struct xfs_btree_block  *block,
+        union xfs_btree_key     *key)
+{
+        union xfs_btree_key     max_hkey;
+        union xfs_btree_key     hkey;
+        union xfs_btree_rec     *rec;
+        union xfs_btree_key     *high;
+        int                     n;
+
+        rec = xfs_btree_rec_addr(cur, 1, block);
+        cur->bc_ops->init_key_from_rec(key, rec);
+
+        if (cur->bc_flags & XFS_BTREE_OVERLAPPING) {
+
+                cur->bc_ops->init_high_key_from_rec(&max_hkey, rec);
+                for (n = 2; n <= xfs_btree_get_numrecs(block); n++) {
+                        rec = xfs_btree_rec_addr(cur, n, block);
+                        cur->bc_ops->init_high_key_from_rec(&hkey, rec);
+                        if (cur->bc_ops->diff_two_keys(cur, &hkey, &max_hkey)
+                                        > 0)
+                                max_hkey = hkey;
+                }
+
+                high = xfs_btree_high_key_from_key(cur, key);
+                memcpy(high, &max_hkey, cur->bc_ops->key_len / 2);
+        }
+}
+
+/* Determine the low (and high if overlapped) keys of a node block */
+STATIC void
+xfs_btree_get_node_keys(
+        struct xfs_btree_cur    *cur,
+        struct xfs_btree_block  *block,
+        union xfs_btree_key     *key)
+{
+        union xfs_btree_key     *hkey;
+        union xfs_btree_key     *max_hkey;
+        union xfs_btree_key     *high;
+        int                     n;
+
+        if (cur->bc_flags & XFS_BTREE_OVERLAPPING) {
+                memcpy(key, xfs_btree_key_addr(cur, 1, block),
+                                cur->bc_ops->key_len / 2);
+
+                max_hkey = xfs_btree_high_key_addr(cur, 1, block);
+                for (n = 2; n <= xfs_btree_get_numrecs(block); n++) {
+                        hkey = xfs_btree_high_key_addr(cur, n, block);
+                        if (cur->bc_ops->diff_two_keys(cur, hkey, max_hkey) > 0)
+                                max_hkey = hkey;
+                }
+
+                high = xfs_btree_high_key_from_key(cur, key);
+                memcpy(high, max_hkey, cur->bc_ops->key_len / 2);
+        } else {
+                memcpy(key, xfs_btree_key_addr(cur, 1, block),
+                                cur->bc_ops->key_len);
+        }
+}
+
+/* Derive the keys for any btree block. */
+STATIC void
+xfs_btree_get_keys(
+        struct xfs_btree_cur    *cur,
+        struct xfs_btree_block  *block,
+        union xfs_btree_key     *key)
+{
+        if (be16_to_cpu(block->bb_level) == 0)
+                xfs_btree_get_leaf_keys(cur, block, key);
+        else
+                xfs_btree_get_node_keys(cur, block, key);
+}
+
 /*
- * Update keys at all levels from here to the root along the cursor's path.
+ * Decide if we need to update the parent keys of a btree block.  For
+ * a standard btree this is only necessary if we're updating the first
+ * record/key.  For an overlapping btree, we must always update the
+ * keys because the highest key can be in any of the records or keys
+ * in the block.
+ */
+static inline bool
+xfs_btree_needs_key_update(
+        struct xfs_btree_cur    *cur,
+        int                     ptr)
+{
+        return (cur->bc_flags & XFS_BTREE_OVERLAPPING) || ptr == 1;
+}
+
+/*
+ * Update the low and high parent keys of the given level, progressing
+ * towards the root.  If force_all is false, stop if the keys for a given
+ * level do not need updating.
  */
 STATIC int
-xfs_btree_updkey(
+__xfs_btree_updkeys(
+        struct xfs_btree_cur    *cur,
+        int                     level,
+        struct xfs_btree_block  *block,
+        struct xfs_buf          *bp0,
+        bool                    force_all)
+{
+        union xfs_btree_bigkey  key;    /* keys from current level */
+        union xfs_btree_key     *lkey;  /* keys from the next level up */
+        union xfs_btree_key     *hkey;
+        union xfs_btree_key     *nlkey; /* keys from the next level up */
+        union xfs_btree_key     *nhkey;
+        struct xfs_buf          *bp;
+        int                     ptr;
+
+        ASSERT(cur->bc_flags & XFS_BTREE_OVERLAPPING);
+
+        /* Exit if there aren't any parent levels to update. */
+        if (level + 1 >= cur->bc_nlevels)
+                return 0;
+
+        trace_xfs_btree_updkeys(cur, level, bp0);
+
+        lkey = (union xfs_btree_key *)&key;
+        hkey = xfs_btree_high_key_from_key(cur, lkey);
+        xfs_btree_get_keys(cur, block, lkey);
+        for (level++; level < cur->bc_nlevels; level++) {
+#ifdef DEBUG
+                int             error;
+#endif
+                block = xfs_btree_get_block(cur, level, &bp);
+                trace_xfs_btree_updkeys(cur, level, bp);
+#ifdef DEBUG
+                error = xfs_btree_check_block(cur, block, level, bp);
+                if (error) {
+                        XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
+                        return error;
+                }
+#endif
+                ptr = cur->bc_ptrs[level];
+                nlkey = xfs_btree_key_addr(cur, ptr, block);
+                nhkey = xfs_btree_high_key_addr(cur, ptr, block);
+                if (!force_all &&
+                    !(cur->bc_ops->diff_two_keys(cur, nlkey, lkey) != 0 ||
+                      cur->bc_ops->diff_two_keys(cur, nhkey, hkey) != 0))
+                        break;
+                xfs_btree_copy_keys(cur, nlkey, lkey, 1);
+                xfs_btree_log_keys(cur, bp, ptr, ptr);
+                if (level + 1 >= cur->bc_nlevels)
+                        break;
+                xfs_btree_get_node_keys(cur, block, lkey);
+        }
+
+        return 0;
+}
+
+/* Update all the keys from some level in cursor back to the root. */
+STATIC int
+xfs_btree_updkeys_force(
+        struct xfs_btree_cur    *cur,
+        int                     level)
+{
+        struct xfs_buf          *bp;
+        struct xfs_btree_block  *block;
+
+        block = xfs_btree_get_block(cur, level, &bp);
+        return __xfs_btree_updkeys(cur, level, block, bp, true);
+}
+
+/*
+ * Update the parent keys of the given level, progressing towards the root.
+ */
+STATIC int
+xfs_btree_update_keys(
         struct xfs_btree_cur    *cur,
-        union xfs_btree_key     *keyp,
         int                     level)
 {
         struct xfs_btree_block  *block;
         struct xfs_buf          *bp;
         union xfs_btree_key     *kp;
+        union xfs_btree_key     key;
         int                     ptr;
 
+        ASSERT(level >= 0);
+
+        block = xfs_btree_get_block(cur, level, &bp);
+        if (cur->bc_flags & XFS_BTREE_OVERLAPPING)
+                return __xfs_btree_updkeys(cur, level, block, bp, false);
+
         XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
         XFS_BTREE_TRACE_ARGIK(cur, level, keyp);
 
-        ASSERT(!(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) || level >= 1);
-
         /*
          * Go up the tree from this level toward the root.
          * At each level, update the key value to the value input.
          * Stop when we reach a level where the cursor isn't pointing
          * at the first entry in the block.
          */
-        for (ptr = 1; ptr == 1 && level < cur->bc_nlevels; level++) {
+        xfs_btree_get_keys(cur, block, &key);
+        for (level++, ptr = 1; ptr == 1 && level < cur->bc_nlevels; level++) {
 #ifdef DEBUG
                 int             error;
 #endif
@@ -1918,7 +2172,7 @@ xfs_btree_updkey(
 #endif
                 ptr = cur->bc_ptrs[level];
                 kp = xfs_btree_key_addr(cur, ptr, block);
-                xfs_btree_copy_keys(cur, kp, keyp, 1);
+                xfs_btree_copy_keys(cur, kp, &key, 1);
                 xfs_btree_log_keys(cur, bp, ptr, ptr);
         }
 
@@ -1970,12 +2224,9 @@ xfs_btree_update(
                                             ptr, LASTREC_UPDATE);
         }
 
-        /* Updating first rec in leaf. Pass new key value up to our parent. */
-        if (ptr == 1) {
-                union xfs_btree_key     key;
-
-                cur->bc_ops->init_key_from_rec(&key, rec);
-                error = xfs_btree_updkey(cur, &key, 1);
+        /* Pass new key value up to our parent. */
+        if (xfs_btree_needs_key_update(cur, ptr)) {
+                error = xfs_btree_update_keys(cur, 0);
                 if (error)
                         goto error0;
         }
@@ -1998,18 +2249,19 @@ xfs_btree_lshift(
         int                     level,
         int                     *stat)          /* success/failure */
 {
-        union xfs_btree_key     key;            /* btree key */
         struct xfs_buf          *lbp;           /* left buffer pointer */
         struct xfs_btree_block  *left;          /* left btree block */
         int                     lrecs;          /* left record count */
         struct xfs_buf          *rbp;           /* right buffer pointer */
         struct xfs_btree_block  *right;         /* right btree block */
+        struct xfs_btree_cur    *tcur;          /* temporary btree cursor */
         int                     rrecs;          /* right record count */
         union xfs_btree_ptr     lptr;           /* left btree pointer */
         union xfs_btree_key     *rkp = NULL;    /* right btree key */
         union xfs_btree_ptr     *rpp = NULL;    /* right address pointer */
         union xfs_btree_rec     *rrp = NULL;    /* right record pointer */
         int                     error;          /* error return value */
+        int                     i;
 
         XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
         XFS_BTREE_TRACE_ARGI(cur, level);
@@ -2139,18 +2391,33 @@ xfs_btree_lshift(
                         xfs_btree_rec_addr(cur, 2, right),
                         -1, rrecs);
                 xfs_btree_log_recs(cur, rbp, 1, rrecs);
+        }
 
-                /*
-                 * If it's the first record in the block, we'll need a key
-                 * structure to pass up to the next level (updkey).
-                 */
-                cur->bc_ops->init_key_from_rec(&key,
-                        xfs_btree_rec_addr(cur, 1, right));
-                rkp = &key;
+        /*
+         * Using a temporary cursor, update the parent key values of the
+         * block on the left.
+         */
+        if (cur->bc_flags & XFS_BTREE_OVERLAPPING) {
+                error = xfs_btree_dup_cursor(cur, &tcur);
+                if (error)
+                        goto error0;
+                i = xfs_btree_firstrec(tcur, level);
+                XFS_WANT_CORRUPTED_GOTO(tcur->bc_mp, i == 1, error0);
+
+                error = xfs_btree_decrement(tcur, level, &i);
+                if (error)
+                        goto error1;
+
+                /* Update the parent high keys of the left block, if needed. */
+                error = xfs_btree_update_keys(tcur, level);
+                if (error)
+                        goto error1;
+
+                xfs_btree_del_cursor(tcur, XFS_BTREE_NOERROR);
         }
 
-        /* Update the parent key values of right. */
-        error = xfs_btree_updkey(cur, rkp, level + 1);
+        /* Update the parent keys of the right block. */
+        error = xfs_btree_update_keys(cur, level);
         if (error)
                 goto error0;
 
@@ -2169,6 +2436,11 @@ out0:
 error0:
         XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
         return error;
+
+error1:
+        XFS_BTREE_TRACE_CURSOR(tcur, XBT_ERROR);
+        xfs_btree_del_cursor(tcur, XFS_BTREE_ERROR);
+        return error;
 }
 
 /*
@@ -2181,7 +2453,6 @@ xfs_btree_rshift(
         int                     level,
         int                     *stat)          /* success/failure */
 {
-        union xfs_btree_key     key;            /* btree key */
         struct xfs_buf          *lbp;           /* left buffer pointer */
         struct xfs_btree_block  *left;          /* left btree block */
         struct xfs_buf          *rbp;           /* right buffer pointer */
@@ -2290,12 +2561,6 @@ xfs_btree_rshift(
                 /* Now put the new data in, and log it. */
                 xfs_btree_copy_recs(cur, rrp, lrp, 1);
                 xfs_btree_log_recs(cur, rbp, 1, rrecs + 1);
-
-                cur->bc_ops->init_key_from_rec(&key, rrp);
-                rkp = &key;
-
-                ASSERT(cur->bc_ops->recs_inorder(cur, rrp,
-                        xfs_btree_rec_addr(cur, 2, right)));
         }
 
         /*
@@ -2315,13 +2580,21 @@ xfs_btree_rshift(
         if (error)
                 goto error0;
         i = xfs_btree_lastrec(tcur, level);
-        XFS_WANT_CORRUPTED_GOTO(cur->bc_mp, i == 1, error0);
+        XFS_WANT_CORRUPTED_GOTO(tcur->bc_mp, i == 1, error0);
 
         error = xfs_btree_increment(tcur, level, &i);
         if (error)
                 goto error1;
 
-        error = xfs_btree_updkey(tcur, rkp, level + 1);
+        /* Update the parent high keys of the left block, if needed. */
+        if (cur->bc_flags & XFS_BTREE_OVERLAPPING) {
+                error = xfs_btree_update_keys(cur, level);
+                if (error)
+                        goto error1;
+        }
+
+        /* Update the parent keys of the right block. */
+        error = xfs_btree_update_keys(tcur, level);
         if (error)
                 goto error1;
 
@@ -2422,6 +2695,11 @@ __xfs_btree_split(
 
         XFS_BTREE_STATS_ADD(cur, moves, rrecs);
 
+        /* Adjust numrecs for the later get_*_keys() calls. */
+        lrecs -= rrecs;
+        xfs_btree_set_numrecs(left, lrecs);
+        xfs_btree_set_numrecs(right, xfs_btree_get_numrecs(right) + rrecs);
+
         /*
          * Copy btree block entries from the left block over to the
          * new block, the right. Update the right block and log the
@@ -2447,14 +2725,15 @@ __xfs_btree_split(
                 }
 #endif
 
+                /* Copy the keys & pointers to the new block. */
                 xfs_btree_copy_keys(cur, rkp, lkp, rrecs);
                 xfs_btree_copy_ptrs(cur, rpp, lpp, rrecs);
 
                 xfs_btree_log_keys(cur, rbp, 1, rrecs);
                 xfs_btree_log_ptrs(cur, rbp, 1, rrecs);
 
-                /* Grab the keys to the entries moved to the right block */
-                xfs_btree_copy_keys(cur, key, rkp, 1);
+                /* Stash the keys of the new block for later insertion. */
+                xfs_btree_get_node_keys(cur, right, key);
         } else {
                 /* It's a leaf.  Move records.  */
                 union xfs_btree_rec     *lrp;   /* left record pointer */
@@ -2463,27 +2742,23 @@ __xfs_btree_split(
                 lrp = xfs_btree_rec_addr(cur, src_index, left);
                 rrp = xfs_btree_rec_addr(cur, 1, right);
 
+                /* Copy records to the new block. */
                 xfs_btree_copy_recs(cur, rrp, lrp, rrecs);
                 xfs_btree_log_recs(cur, rbp, 1, rrecs);
 
-                cur->bc_ops->init_key_from_rec(key,
-                        xfs_btree_rec_addr(cur, 1, right));
+                /* Stash the keys of the new block for later insertion. */
+                xfs_btree_get_leaf_keys(cur, right, key);
         }
 
-
         /*
          * Find the left block number by looking in the buffer.
-         * Adjust numrecs, sibling pointers.
+         * Adjust sibling pointers.
          */
         xfs_btree_get_sibling(cur, left, &rrptr, XFS_BB_RIGHTSIB);
         xfs_btree_set_sibling(cur, right, &rrptr, XFS_BB_RIGHTSIB);
         xfs_btree_set_sibling(cur, right, &lptr, XFS_BB_LEFTSIB);
         xfs_btree_set_sibling(cur, left, &rptr, XFS_BB_RIGHTSIB);
 
-        lrecs -= rrecs;
-        xfs_btree_set_numrecs(left, lrecs);
-        xfs_btree_set_numrecs(right, xfs_btree_get_numrecs(right) + rrecs);
-
         xfs_btree_log_block(cur, rbp, XFS_BB_ALL_BITS);
         xfs_btree_log_block(cur, lbp, XFS_BB_NUMRECS | XFS_BB_RIGHTSIB);
 
@@ -2499,6 +2774,14 @@ __xfs_btree_split(
                 xfs_btree_set_sibling(cur, rrblock, &rptr, XFS_BB_LEFTSIB);
                 xfs_btree_log_block(cur, rrbp, XFS_BB_LEFTSIB);
         }
+
+        /* Update the parent high keys of the left block, if needed. */
+        if (cur->bc_flags & XFS_BTREE_OVERLAPPING) {
+                error = xfs_btree_update_keys(cur, level);
+                if (error)
+                        goto error0;
+        }
+
         /*
          * If the cursor is really in the right block, move it there.
          * If it's just pointing past the last entry in left, then we'll
@@ -2802,6 +3085,7 @@ xfs_btree_new_root(
                 bp = lbp;
                 nptr = 2;
         }
+
         /* Fill in the new block's btree header and log it. */
         xfs_btree_init_block_cur(cur, nbp, cur->bc_nlevels, 2);
         xfs_btree_log_block(cur, nbp, XFS_BB_ALL_BITS);
@@ -2810,19 +3094,24 @@ xfs_btree_new_root(
 
         /* Fill in the key data in the new root. */
         if (xfs_btree_get_level(left) > 0) {
-                xfs_btree_copy_keys(cur,
-                                xfs_btree_key_addr(cur, 1, new),
-                                xfs_btree_key_addr(cur, 1, left), 1);
-                xfs_btree_copy_keys(cur,
-                                xfs_btree_key_addr(cur, 2, new),
-                                xfs_btree_key_addr(cur, 1, right), 1);
+                /*
+                 * Get the keys for the left block's keys and put them directly
+                 * in the parent block.  Do the same for the right block.
+                 */
+                xfs_btree_get_node_keys(cur, left,
+                                xfs_btree_key_addr(cur, 1, new));
+                xfs_btree_get_node_keys(cur, right,
+                                xfs_btree_key_addr(cur, 2, new));
         } else {
-                cur->bc_ops->init_key_from_rec(
-                                xfs_btree_key_addr(cur, 1, new),
-                                xfs_btree_rec_addr(cur, 1, left));
-                cur->bc_ops->init_key_from_rec(
-                                xfs_btree_key_addr(cur, 2, new),
-                                xfs_btree_rec_addr(cur, 1, right));
+                /*
+                 * Get the keys for the left block's records and put them
+                 * directly in the parent block.  Do the same for the right
+                 * block.
+                 */
+                xfs_btree_get_leaf_keys(cur, left,
+                        xfs_btree_key_addr(cur, 1, new));
+                xfs_btree_get_leaf_keys(cur, right,
+                        xfs_btree_key_addr(cur, 2, new));
         }
         xfs_btree_log_keys(cur, nbp, 1, 2);
 
@@ -2858,10 +3147,9 @@ xfs_btree_make_block_unfull(
         int                     *index, /* new tree index */
         union xfs_btree_ptr     *nptr,  /* new btree ptr */
         struct xfs_btree_cur    **ncur, /* new btree cursor */
-        union xfs_btree_rec     *nrec,  /* new record */
+        union xfs_btree_key     *key,   /* key of new block */
         int                     *stat)
 {
-        union xfs_btree_key     key;    /* new btree key value */
         int                     error = 0;
 
         if ((cur->bc_flags & XFS_BTREE_ROOT_IN_INODE) &&
@@ -2871,6 +3159,7 @@ xfs_btree_make_block_unfull(
                 if (numrecs < cur->bc_ops->get_dmaxrecs(cur, level)) {
                         /* A root block that can be made bigger. */
                         xfs_iroot_realloc(ip, 1, cur->bc_private.b.whichfork);
+                        *stat = 1;
                 } else {
                         /* A root block that needs replacing */
                         int     logflags = 0;
@@ -2906,13 +3195,12 @@ xfs_btree_make_block_unfull(
          * If this works we have to re-set our variables because we
          * could be in a different block now.
          */
-        error = xfs_btree_split(cur, level, nptr, &key, ncur, stat);
+        error = xfs_btree_split(cur, level, nptr, key, ncur, stat);
         if (error || *stat == 0)
                 return error;
 
 
         *index = cur->bc_ptrs[level];
-        cur->bc_ops->init_rec_from_key(&key, nrec);
         return 0;
 }
 
@@ -2925,16 +3213,17 @@ xfs_btree_insrec(
         struct xfs_btree_cur    *cur,   /* btree cursor */
         int                     level,  /* level to insert record at */
         union xfs_btree_ptr     *ptrp,  /* i/o: block number inserted */
-        union xfs_btree_rec     *recp,  /* i/o: record data inserted */
+        union xfs_btree_rec     *rec,   /* record to insert */
+        union xfs_btree_key     *key,   /* i/o: block key for ptrp */
         struct xfs_btree_cur    **curp, /* output: new cursor replacing cur */
         int                     *stat)  /* success/failure */
 {
         struct xfs_btree_block  *block; /* btree block */
         struct xfs_buf          *bp;    /* buffer for block */
-        union xfs_btree_key     key;    /* btree key */
         union xfs_btree_ptr     nptr;   /* new block ptr */
         struct xfs_btree_cur    *ncur;  /* new btree cursor */
-        union xfs_btree_rec     nrec;   /* new record count */
+        union xfs_btree_bigkey  nkey;   /* new block key */
+        union xfs_btree_key     *lkey;
         int                     optr;   /* old key/record index */
         int                     ptr;    /* key/record index */
         int                     numrecs;/* number of records */
@@ -2942,11 +3231,13 @@ xfs_btree_insrec(
 #ifdef DEBUG
         int                     i;
 #endif
+        xfs_daddr_t             old_bn;
 
         XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
-        XFS_BTREE_TRACE_ARGIPR(cur, level, *ptrp, recp);
+        XFS_BTREE_TRACE_ARGIPR(cur, level, *ptrp, &rec);
 
         ncur = NULL;
+        lkey = (union xfs_btree_key *)&nkey;
 
         /*
          * If we have an external root pointer, and we've made it to the
@@ -2969,15 +3260,13 @@ xfs_btree_insrec(
                 return 0;
         }
 
-        /* Make a key out of the record data to be inserted, and save it. */
-        cur->bc_ops->init_key_from_rec(&key, recp);
-
         optr = ptr;
 
         XFS_BTREE_STATS_INC(cur, insrec);
 
         /* Get pointers to the btree buffer and block. */
         block = xfs_btree_get_block(cur, level, &bp);
+        old_bn = bp ? bp->b_bn : XFS_BUF_DADDR_NULL;
         numrecs = xfs_btree_get_numrecs(block);
 
 #ifdef DEBUG
@@ -2988,10 +3277,10 @@ xfs_btree_insrec(
         /* Check that the new entry is being inserted in the right place. */
         if (ptr <= numrecs) {
                 if (level == 0) {
-                        ASSERT(cur->bc_ops->recs_inorder(cur, recp,
+                        ASSERT(cur->bc_ops->recs_inorder(cur, rec,
                                 xfs_btree_rec_addr(cur, ptr, block)));
                 } else {
-                        ASSERT(cur->bc_ops->keys_inorder(cur, &key,
+                        ASSERT(cur->bc_ops->keys_inorder(cur, key,
                                 xfs_btree_key_addr(cur, ptr, block)));
                 }
         }
@@ -3004,7 +3293,7 @@ xfs_btree_insrec(
         xfs_btree_set_ptr_null(cur, &nptr);
         if (numrecs == cur->bc_ops->get_maxrecs(cur, level)) {
                 error = xfs_btree_make_block_unfull(cur, level, numrecs,
-                                        &optr, &ptr, &nptr, &ncur, &nrec, stat);
+                                        &optr, &ptr, &nptr, &ncur, lkey, stat);
                 if (error || *stat == 0)
                         goto error0;
         }
@@ -3054,7 +3343,7 @@ xfs_btree_insrec(
 #endif
 
                 /* Now put the new data in, bump numrecs and log it. */
-                xfs_btree_copy_keys(cur, kp, &key, 1);
+                xfs_btree_copy_keys(cur, kp, key, 1);
                 xfs_btree_copy_ptrs(cur, pp, ptrp, 1);
                 numrecs++;
                 xfs_btree_set_numrecs(block, numrecs);
@@ -3075,7 +3364,7 @@ xfs_btree_insrec(
                 xfs_btree_shift_recs(cur, rp, 1, numrecs - ptr + 1);
 
                 /* Now put the new data in, bump numrecs and log it. */
-                xfs_btree_copy_recs(cur, rp, recp, 1);
+                xfs_btree_copy_recs(cur, rp, rec, 1);
                 xfs_btree_set_numrecs(block, ++numrecs);
                 xfs_btree_log_recs(cur, bp, ptr, numrecs);
 #ifdef DEBUG
@@ -3089,9 +3378,18 @@ xfs_btree_insrec(
         /* Log the new number of records in the btree header. */
         xfs_btree_log_block(cur, bp, XFS_BB_NUMRECS);
 
-        /* If we inserted at the start of a block, update the parents' keys. */
-        if (optr == 1) {
-                error = xfs_btree_updkey(cur, &key, level + 1);
+        /*
+         * If we just inserted into a new tree block, we have to
+         * recalculate nkey here because nkey is out of date.
+         *
+         * Otherwise we're just updating an existing block (having shoved
+         * some records into the new tree block), so use the regular key
+         * update mechanism.
+         */
+        if (bp && bp->b_bn != old_bn) {
+                xfs_btree_get_keys(cur, block, lkey);
+        } else if (xfs_btree_needs_key_update(cur, optr)) {
+                error = xfs_btree_update_keys(cur, level);
                 if (error)
                         goto error0;
         }
@@ -3101,7 +3399,7 @@ xfs_btree_insrec(
          * we are at the far right edge of the tree, update it.
          */
         if (xfs_btree_is_lastrec(cur, block, level)) {
-                cur->bc_ops->update_lastrec(cur, block, recp,
+                cur->bc_ops->update_lastrec(cur, block, rec,
                                             ptr, LASTREC_INSREC);
         }
 
@@ -3111,7 +3409,7 @@ xfs_btree_insrec(
          */
         *ptrp = nptr;
         if (!xfs_btree_ptr_is_null(cur, &nptr)) {
-                *recp = nrec;
+                xfs_btree_copy_keys(cur, key, lkey, 1);
                 *curp = ncur;
         }
 
@@ -3142,14 +3440,20 @@ xfs_btree_insert(
         union xfs_btree_ptr     nptr;   /* new block number (split result) */
         struct xfs_btree_cur    *ncur;  /* new cursor (split result) */
         struct xfs_btree_cur    *pcur;  /* previous level's cursor */
+        union xfs_btree_bigkey  bkey;   /* key of block to insert */
+        union xfs_btree_key     *key;
         union xfs_btree_rec     rec;    /* record to insert */
 
         level = 0;
         ncur = NULL;
         pcur = cur;
+        key = (union xfs_btree_key *)&bkey;
 
         xfs_btree_set_ptr_null(cur, &nptr);
+
+        /* Make a key out of the record data to be inserted, and save it. */
         cur->bc_ops->init_rec_from_cur(cur, &rec);
+        cur->bc_ops->init_key_from_rec(key, &rec);
 
         /*
          * Loop going up the tree, starting at the leaf level.
@@ -3161,7 +3465,8 @@ xfs_btree_insert(
                  * Insert nrec/nptr into this level of the tree.
                  * Note if we fail, nptr will be null.
                  */
-                error = xfs_btree_insrec(pcur, level, &nptr, &rec, &ncur, &i);
+                error = xfs_btree_insrec(pcur, level, &nptr, &rec, key,
+                                &ncur, &i);
                 if (error) {
                         if (pcur != cur)
                                 xfs_btree_del_cursor(pcur, XFS_BTREE_ERROR);
@@ -3385,8 +3690,6 @@ xfs_btree_delrec(
         struct xfs_buf          *bp;            /* buffer for block */
         int                     error;          /* error return value */
         int                     i;              /* loop counter */
-        union xfs_btree_key     key;            /* storage for keyp */
-        union xfs_btree_key     *keyp = &key;   /* passed to the next level */
         union xfs_btree_ptr     lptr;           /* left sibling block ptr */
         struct xfs_buf          *lbp;           /* left buffer pointer */
         struct xfs_btree_block  *left;          /* left btree block */
@@ -3457,13 +3760,6 @@ xfs_btree_delrec(
                         xfs_btree_log_keys(cur, bp, ptr, numrecs - 1);
                         xfs_btree_log_ptrs(cur, bp, ptr, numrecs - 1);
                 }
-
-                /*
-                 * If it's the first record in the block, we'll need to pass a
-                 * key up to the next level (updkey).
-                 */
-                if (ptr == 1)
-                        keyp = xfs_btree_key_addr(cur, 1, block);
         } else {
                 /* It's a leaf. operate on records */
                 if (ptr < numrecs) {
@@ -3472,16 +3768,6 @@ xfs_btree_delrec(
                                 -1, numrecs - ptr);
                         xfs_btree_log_recs(cur, bp, ptr, numrecs - 1);
                 }
-
-                /*
-                 * If it's the first record in the block, we'll need a key
-                 * structure to pass up to the next level (updkey).
-                 */
-                if (ptr == 1) {
-                        cur->bc_ops->init_key_from_rec(&key,
-                                        xfs_btree_rec_addr(cur, 1, block));
-                        keyp = &key;
-                }
         }
 
         /*
@@ -3548,8 +3834,8 @@ xfs_btree_delrec(
          * If we deleted the leftmost entry in the block, update the
          * key values above us in the tree.
          */
-        if (ptr == 1) {
-                error = xfs_btree_updkey(cur, keyp, level + 1);
+        if (xfs_btree_needs_key_update(cur, ptr)) {
+                error = xfs_btree_update_keys(cur, level);
                 if (error)
                         goto error0;
         }
@@ -3878,6 +4164,16 @@ xfs_btree_delrec(
         if (level > 0)
                 cur->bc_ptrs[level]--;
 
+        /*
+         * We combined blocks, so we have to update the parent keys if the
+         * btree supports overlapped intervals.  However, bc_ptrs[level + 1]
+         * points to the old block so that the caller knows which record to
+         * delete.  Therefore, the caller must be savvy enough to call updkeys
+         * for us if we return stat == 2.  The other exit points from this
+         * function don't require deletions further up the tree, so they can
+         * call updkeys directly.
+         */
+
         XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
         /* Return value means the next level up has something to do. */
         *stat = 2;
@@ -3903,6 +4199,7 @@ xfs_btree_delete(
         int                     error;  /* error return value */
         int                     level;
         int                     i;
+        bool                    joined = false;
 
         XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
 
@@ -3916,6 +4213,18 @@ xfs_btree_delete(
                 error = xfs_btree_delrec(cur, level, &i);
                 if (error)
                         goto error0;
+                if (i == 2)
+                        joined = true;
+        }
+
+        /*
+         * If we combined blocks as part of deleting the record, delrec won't
+         * have updated the parent high keys so we have to do that here.
+         */
+        if (joined && (cur->bc_flags & XFS_BTREE_OVERLAPPING)) {
+                error = xfs_btree_updkeys_force(cur, 0);
+                if (error)
+                        goto error0;
         }
 
         if (i == 0) {
@@ -3978,6 +4287,81 @@ xfs_btree_get_rec(
         return 0;
 }
 
+/* Visit a block in a btree. */
+STATIC int
+xfs_btree_visit_block(
+        struct xfs_btree_cur            *cur,
+        int                             level,
+        xfs_btree_visit_blocks_fn       fn,
+        void                            *data)
+{
+        struct xfs_btree_block          *block;
+        struct xfs_buf                  *bp;
+        union xfs_btree_ptr             rptr;
+        int                             error;
+
+        /* do right sibling readahead */
+        xfs_btree_readahead(cur, level, XFS_BTCUR_RIGHTRA);
+        block = xfs_btree_get_block(cur, level, &bp);
+
+        /* process the block */
+        error = fn(cur, level, data);
+        if (error)
+                return error;
+
+        /* now read rh sibling block for next iteration */
+        xfs_btree_get_sibling(cur, block, &rptr, XFS_BB_RIGHTSIB);
+        if (xfs_btree_ptr_is_null(cur, &rptr))
+                return -ENOENT;
+
+        return xfs_btree_lookup_get_block(cur, level, &rptr, &block);
+}
+
+
+/* Visit every block in a btree. */
+int
+xfs_btree_visit_blocks(
+        struct xfs_btree_cur            *cur,
+        xfs_btree_visit_blocks_fn       fn,
+        void                            *data)
+{
+        union xfs_btree_ptr             lptr;
+        int                             level;
+        struct xfs_btree_block          *block = NULL;
+        int                             error = 0;
+
+        cur->bc_ops->init_ptr_from_cur(cur, &lptr);
+
+        /* for each level */
+        for (level = cur->bc_nlevels - 1; level >= 0; level--) {
+                /* grab the left hand block */
+                error = xfs_btree_lookup_get_block(cur, level, &lptr, &block);
+                if (error)
+                        return error;
+
+                /* readahead the left most block for the next level down */
+                if (level > 0) {
+                        union xfs_btree_ptr     *ptr;
+
+                        ptr = xfs_btree_ptr_addr(cur, 1, block);
+                        xfs_btree_readahead_ptr(cur, ptr, 1);
+
+                        /* save for the next iteration of the loop */
+                        lptr = *ptr;
+                }
+
+                /* for each buffer in the level */
+                do {
+                        error = xfs_btree_visit_block(cur, level, fn, data);
+                } while (!error);
+
+                if (error != -ENOENT)
+                        return error;
+        }
+
+        return 0;
+}
+
 /*
  * Change the owner of a btree.
  *
@@ -4002,26 +4386,27 @@ xfs_btree_get_rec(
  * just queue the modified buffer as delayed write buffer so the transaction
  * recovery completion writes the changes to disk.
  */
+struct xfs_btree_block_change_owner_info {
+        __uint64_t              new_owner;
+        struct list_head        *buffer_list;
+};
+
 static int
 xfs_btree_block_change_owner(
         struct xfs_btree_cur    *cur,
         int                     level,
-        __uint64_t              new_owner,
-        struct list_head        *buffer_list)
+        void                    *data)
 {
+        struct xfs_btree_block_change_owner_info        *bbcoi = data;
         struct xfs_btree_block  *block;
         struct xfs_buf          *bp;
-        union xfs_btree_ptr     rptr;
-
-        /* do right sibling readahead */
-        xfs_btree_readahead(cur, level, XFS_BTCUR_RIGHTRA);
 
         /* modify the owner */
         block = xfs_btree_get_block(cur, level, &bp);
         if (cur->bc_flags & XFS_BTREE_LONG_PTRS)
-                block->bb_u.l.bb_owner = cpu_to_be64(new_owner);
+                block->bb_u.l.bb_owner = cpu_to_be64(bbcoi->new_owner);
         else
-                block->bb_u.s.bb_owner = cpu_to_be32(new_owner);
+                block->bb_u.s.bb_owner = cpu_to_be32(bbcoi->new_owner);
 
         /*
          * If the block is a root block hosted in an inode, we might not have a
@@ -4035,19 +4420,14 @@ xfs_btree_block_change_owner(
                         xfs_trans_ordered_buf(cur->bc_tp, bp);
                         xfs_btree_log_block(cur, bp, XFS_BB_OWNER);
                 } else {
-                        xfs_buf_delwri_queue(bp, buffer_list);
+                        xfs_buf_delwri_queue(bp, bbcoi->buffer_list);
                 }
         } else {
                 ASSERT(cur->bc_flags & XFS_BTREE_ROOT_IN_INODE);
                 ASSERT(level == cur->bc_nlevels - 1);
         }
 
-        /* now read rh sibling block for next iteration */
-        xfs_btree_get_sibling(cur, block, &rptr, XFS_BB_RIGHTSIB);
-        if (xfs_btree_ptr_is_null(cur, &rptr))
-                return -ENOENT;
-
-        return xfs_btree_lookup_get_block(cur, level, &rptr, &block);
+        return 0;
 }
 
 int
@@ -4056,43 +4436,13 @@ xfs_btree_change_owner(
         __uint64_t              new_owner,
         struct list_head        *buffer_list)
 {
-        union xfs_btree_ptr     lptr;
-        int                     level;
-        struct xfs_btree_block  *block = NULL;
-        int                     error = 0;
-
-        cur->bc_ops->init_ptr_from_cur(cur, &lptr);
-
-        /* for each level */
-        for (level = cur->bc_nlevels - 1; level >= 0; level--) {
-                /* grab the left hand block */
-                error = xfs_btree_lookup_get_block(cur, level, &lptr, &block);
-                if (error)
-                        return error;
-
-                /* readahead the left most block for the next level down */
-                if (level > 0) {
-                        union xfs_btree_ptr     *ptr;
-
-                        ptr = xfs_btree_ptr_addr(cur, 1, block);
-                        xfs_btree_readahead_ptr(cur, ptr, 1);
-
-                        /* save for the next iteration of the loop */
-                        lptr = *ptr;
-                }
-
-                /* for each buffer in the level */
-                do {
-                        error = xfs_btree_block_change_owner(cur, level,
-                                                             new_owner,
-                                                             buffer_list);
-                } while (!error);
+        struct xfs_btree_block_change_owner_info        bbcoi;
 
-                if (error != -ENOENT)
-                        return error;
-        }
+        bbcoi.new_owner = new_owner;
+        bbcoi.buffer_list = buffer_list;
 
-        return 0;
+        return xfs_btree_visit_blocks(cur, xfs_btree_block_change_owner,
+                        &bbcoi);
 }
 
 /**
@@ -4171,3 +4521,267 @@ xfs_btree_compute_maxlevels(
                 maxblocks = (maxblocks + limits[1] - 1) / limits[1];
         return level;
 }
+
+/*
+ * Query a regular btree for all records overlapping a given interval.
+ * Start with a LE lookup of the key of low_rec and return all records
+ * until we find a record with a key greater than the key of high_rec.
+ */
+STATIC int
+xfs_btree_simple_query_range(
+        struct xfs_btree_cur            *cur,
+        union xfs_btree_key             *low_key,
+        union xfs_btree_key             *high_key,
+        xfs_btree_query_range_fn        fn,
+        void                            *priv)
+{
+        union xfs_btree_rec             *recp;
+        union xfs_btree_key             rec_key;
+        __int64_t                       diff;
+        int                             stat;
+        bool                            firstrec = true;
+        int                             error;
+
+        ASSERT(cur->bc_ops->init_high_key_from_rec);
+        ASSERT(cur->bc_ops->diff_two_keys);
+
+        /*
+         * Find the leftmost record.  The btree cursor must be set
+         * to the low record used to generate low_key.
+         */
+        stat = 0;
+        error = xfs_btree_lookup(cur, XFS_LOOKUP_LE, &stat);
+        if (error)
+                goto out;
+
+        while (stat) {
+                /* Find the record. */
+                error = xfs_btree_get_rec(cur, &recp, &stat);
+                if (error || !stat)
+                        break;
+                cur->bc_ops->init_high_key_from_rec(&rec_key, recp);
+
+                /* Skip if high_key(rec) < low_key. */
+                if (firstrec) {
+                        firstrec = false;
+                        diff = cur->bc_ops->diff_two_keys(cur, low_key,
+                                        &rec_key);
+                        if (diff > 0)
+                                goto advloop;
+                }
+
+                /* Stop if high_key < low_key(rec). */
+                diff = cur->bc_ops->diff_two_keys(cur, &rec_key, high_key);
+                if (diff > 0)
+                        break;
+
+                /* Callback */
+                error = fn(cur, recp, priv);
+                if (error < 0 || error == XFS_BTREE_QUERY_RANGE_ABORT)
+                        break;
+
+advloop:
+                /* Move on to the next record. */
+                error = xfs_btree_increment(cur, 0, &stat);
+                if (error)
+                        break;
+        }
+
+out:
+        return error;
+}
+
+/*
+ * Query an overlapped interval btree for all records overlapping a given
+ * interval.  This function roughly follows the algorithm given in
+ * "Interval Trees" of _Introduction to Algorithms_, which is section
+ * 14.3 in the 2nd and 3rd editions.
+ *
+ * First, generate keys for the low and high records passed in.
+ *
+ * For any leaf node, generate the high and low keys for the record.
+ * If the record keys overlap with the query low/high keys, pass the
+ * record to the function iterator.
+ *
+ * For any internal node, compare the low and high keys of each
+ * pointer against the query low/high keys.  If there's an overlap,
+ * follow the pointer.
+ *
+ * As an optimization, we stop scanning a block when we find a low key
+ * that is greater than the query's high key.
+ */
+STATIC int
+xfs_btree_overlapped_query_range(
+        struct xfs_btree_cur            *cur,
+        union xfs_btree_key             *low_key,
+        union xfs_btree_key             *high_key,
+        xfs_btree_query_range_fn        fn,
+        void                            *priv)
+{
+        union xfs_btree_ptr             ptr;
+        union xfs_btree_ptr             *pp;
+        union xfs_btree_key             rec_key;
+        union xfs_btree_key             rec_hkey;
+        union xfs_btree_key             *lkp;
+        union xfs_btree_key             *hkp;
+        union xfs_btree_rec             *recp;
+        struct xfs_btree_block          *block;
+        __int64_t                       ldiff;
+        __int64_t                       hdiff;
+        int                             level;
+        struct xfs_buf                  *bp;
+        int                             i;
+        int                             error;
+
+        /* Load the root of the btree. */
+        level = cur->bc_nlevels - 1;
+        cur->bc_ops->init_ptr_from_cur(cur, &ptr);
+        error = xfs_btree_lookup_get_block(cur, level, &ptr, &block);
+        if (error)
+                return error;
+        xfs_btree_get_block(cur, level, &bp);
+        trace_xfs_btree_overlapped_query_range(cur, level, bp);
+#ifdef DEBUG
+        error = xfs_btree_check_block(cur, block, level, bp);
+        if (error)
+                goto out;
+#endif
+        cur->bc_ptrs[level] = 1;
+
+        while (level < cur->bc_nlevels) {
+                block = xfs_btree_get_block(cur, level, &bp);
+
+                /* End of node, pop back towards the root. */
+                if (cur->bc_ptrs[level] > be16_to_cpu(block->bb_numrecs)) {
+pop_up:
+                        if (level < cur->bc_nlevels - 1)
+                                cur->bc_ptrs[level + 1]++;
+                        level++;
+                        continue;
+                }
+
+                if (level == 0) {
+                        /* Handle a leaf node. */
+                        recp = xfs_btree_rec_addr(cur, cur->bc_ptrs[0], block);
+
+                        cur->bc_ops->init_high_key_from_rec(&rec_hkey, recp);
+                        ldiff = cur->bc_ops->diff_two_keys(cur, &rec_hkey,
+                                        low_key);
+
+                        cur->bc_ops->init_key_from_rec(&rec_key, recp);
+                        hdiff = cur->bc_ops->diff_two_keys(cur, high_key,
+                                        &rec_key);
+
+                        /*
+                         * If (record's high key >= query's low key) and
+                         *    (query's high key >= record's low key), then
+                         * this record overlaps the query range; callback.
+                         */
+                        if (ldiff >= 0 && hdiff >= 0) {
+                                error = fn(cur, recp, priv);
+                                if (error < 0 ||
+                                    error == XFS_BTREE_QUERY_RANGE_ABORT)
+                                        break;
+                        } else if (hdiff < 0) {
+                                /* Record is larger than high key; pop. */
+                                goto pop_up;
+                        }
+                        cur->bc_ptrs[level]++;
+                        continue;
+                }
+
+                /* Handle an internal node. */
+                lkp = xfs_btree_key_addr(cur, cur->bc_ptrs[level], block);
+                hkp = xfs_btree_high_key_addr(cur, cur->bc_ptrs[level], block);
+                pp = xfs_btree_ptr_addr(cur, cur->bc_ptrs[level], block);
+
+                ldiff = cur->bc_ops->diff_two_keys(cur, hkp, low_key);
+                hdiff = cur->bc_ops->diff_two_keys(cur, high_key, lkp);
+
+                /*
+                 * If (pointer's high key >= query's low key) and
+                 *    (query's high key >= pointer's low key), then
+                 * this record overlaps the query range; follow pointer.
+                 */
+                if (ldiff >= 0 && hdiff >= 0) {
+                        level--;
+                        error = xfs_btree_lookup_get_block(cur, level, pp,
+                                        &block);
+                        if (error)
+                                goto out;
+                        xfs_btree_get_block(cur, level, &bp);
+                        trace_xfs_btree_overlapped_query_range(cur, level, bp);
+#ifdef DEBUG
+                        error = xfs_btree_check_block(cur, block, level, bp);
+                        if (error)
+                                goto out;
+#endif
+                        cur->bc_ptrs[level] = 1;
+                        continue;
+                } else if (hdiff < 0) {
+                        /* The low key is larger than the upper range; pop. */
+                        goto pop_up;
+                }
+                cur->bc_ptrs[level]++;
+        }
+
+out:
+        /*
+         * If we don't end this function with the cursor pointing at a record
+         * block, a subsequent non-error cursor deletion will not release
+         * node-level buffers, causing a buffer leak.  This is quite possible
+         * with a zero-results range query, so release the buffers if we
+         * failed to return any results.
+         */
+        if (cur->bc_bufs[0] == NULL) {
+                for (i = 0; i < cur->bc_nlevels; i++) {
+                        if (cur->bc_bufs[i]) {
+                                xfs_trans_brelse(cur->bc_tp, cur->bc_bufs[i]);
+                                cur->bc_bufs[i] = NULL;
+                                cur->bc_ptrs[i] = 0;
+                                cur->bc_ra[i] = 0;
+                        }
+                }
+        }
+
+        return error;
+}
+
+/*
+ * Query a btree for all records overlapping a given interval of keys.  The
+ * supplied function will be called with each record found; return one of the
+ * XFS_BTREE_QUERY_RANGE_{CONTINUE,ABORT} values or the usual negative error
+ * code.  This function returns XFS_BTREE_QUERY_RANGE_ABORT, zero, or a
+ * negative error code.
+ */
+int
+xfs_btree_query_range(
+        struct xfs_btree_cur            *cur,
+        union xfs_btree_irec            *low_rec,
+        union xfs_btree_irec            *high_rec,
+        xfs_btree_query_range_fn        fn,
+        void                            *priv)
+{
+        union xfs_btree_rec             rec;
+        union xfs_btree_key             low_key;
+        union xfs_btree_key             high_key;
+
+        /* Find the keys of both ends of the interval. */
+        cur->bc_rec = *high_rec;
+        cur->bc_ops->init_rec_from_cur(cur, &rec);
+        cur->bc_ops->init_key_from_rec(&high_key, &rec);
+
+        cur->bc_rec = *low_rec;
+        cur->bc_ops->init_rec_from_cur(cur, &rec);
+        cur->bc_ops->init_key_from_rec(&low_key, &rec);
+
+        /* Enforce low key < high key. */
+        if (cur->bc_ops->diff_two_keys(cur, &low_key, &high_key) > 0)
+                return -EINVAL;
+
+        if (!(cur->bc_flags & XFS_BTREE_OVERLAPPING))
+                return xfs_btree_simple_query_range(cur, &low_key,
+                                &high_key, fn, priv);
+        return xfs_btree_overlapped_query_range(cur, &low_key, &high_key,
+                        fn, priv);
+}
diff --git a/fs/xfs/libxfs/xfs_btree.h b/fs/xfs/libxfs/xfs_btree.h
index 785a99682159..04d0865e5e6d 100644
--- a/fs/xfs/libxfs/xfs_btree.h
+++ b/fs/xfs/libxfs/xfs_btree.h
@@ -19,7 +19,7 @@
 #define __XFS_BTREE_H__
 
 struct xfs_buf;
-struct xfs_bmap_free;
+struct xfs_defer_ops;
 struct xfs_inode;
 struct xfs_mount;
 struct xfs_trans;
@@ -38,17 +38,37 @@ union xfs_btree_ptr {
 };
 
 union xfs_btree_key {
-        xfs_bmbt_key_t          bmbt;
-        xfs_bmdr_key_t          bmbr;   /* bmbt root block */
-        xfs_alloc_key_t         alloc;
-        xfs_inobt_key_t         inobt;
+        struct xfs_bmbt_key             bmbt;
+        xfs_bmdr_key_t                  bmbr;   /* bmbt root block */
+        xfs_alloc_key_t                 alloc;
+        struct xfs_inobt_key            inobt;
+        struct xfs_rmap_key             rmap;
+};
+
+/*
+ * In-core key that holds both low and high keys for overlapped btrees.
+ * The two keys are packed next to each other on disk, so do the same
+ * in memory.  Preserve the existing xfs_btree_key as a single key to
+ * avoid the mental model breakage that would happen if we passed a
+ * bigkey into a function that operates on a single key.
+ */
+union xfs_btree_bigkey {
+        struct xfs_bmbt_key             bmbt;
+        xfs_bmdr_key_t                  bmbr;   /* bmbt root block */
+        xfs_alloc_key_t                 alloc;
+        struct xfs_inobt_key            inobt;
+        struct {
+                struct xfs_rmap_key     rmap;
+                struct xfs_rmap_key     rmap_hi;
+        };
 };
 
 union xfs_btree_rec {
-        xfs_bmbt_rec_t          bmbt;
-        xfs_bmdr_rec_t          bmbr;   /* bmbt root block */
-        xfs_alloc_rec_t         alloc;
-        xfs_inobt_rec_t         inobt;
+        struct xfs_bmbt_rec             bmbt;
+        xfs_bmdr_rec_t                  bmbr;   /* bmbt root block */
+        struct xfs_alloc_rec            alloc;
+        struct xfs_inobt_rec            inobt;
+        struct xfs_rmap_rec             rmap;
 };
 
 /*
@@ -63,6 +83,7 @@ union xfs_btree_rec {
 #define XFS_BTNUM_BMAP  ((xfs_btnum_t)XFS_BTNUM_BMAPi)
 #define XFS_BTNUM_INO   ((xfs_btnum_t)XFS_BTNUM_INOi)
 #define XFS_BTNUM_FINO  ((xfs_btnum_t)XFS_BTNUM_FINOi)
+#define XFS_BTNUM_RMAP  ((xfs_btnum_t)XFS_BTNUM_RMAPi)
 
 /*
  * For logging record fields.
@@ -95,6 +116,7 @@ do {    \
         case XFS_BTNUM_BMAP: __XFS_BTREE_STATS_INC(__mp, bmbt, stat); break; \
         case XFS_BTNUM_INO: __XFS_BTREE_STATS_INC(__mp, ibt, stat); break; \
         case XFS_BTNUM_FINO: __XFS_BTREE_STATS_INC(__mp, fibt, stat); break; \
+        case XFS_BTNUM_RMAP: __XFS_BTREE_STATS_INC(__mp, rmap, stat); break; \
         case XFS_BTNUM_MAX: ASSERT(0); /* fucking gcc */ ; break;       \
         }       \
 } while (0)
@@ -115,11 +137,13 @@ do {    \
                 __XFS_BTREE_STATS_ADD(__mp, ibt, stat, val); break; \
         case XFS_BTNUM_FINO:    \
                 __XFS_BTREE_STATS_ADD(__mp, fibt, stat, val); break; \
+        case XFS_BTNUM_RMAP:    \
+                __XFS_BTREE_STATS_ADD(__mp, rmap, stat, val); break; \
         case XFS_BTNUM_MAX: ASSERT(0); /* fucking gcc */ ; break; \
         }       \
 } while (0)
 
-#define XFS_BTREE_MAXLEVELS     8       /* max of all btrees */
+#define XFS_BTREE_MAXLEVELS     9       /* max of all btrees */
 
 struct xfs_btree_ops {
         /* size of the key and record structures */
@@ -158,17 +182,25 @@ struct xfs_btree_ops {
         /* init values of btree structures */
         void    (*init_key_from_rec)(union xfs_btree_key *key,
                                      union xfs_btree_rec *rec);
-        void    (*init_rec_from_key)(union xfs_btree_key *key,
-                                     union xfs_btree_rec *rec);
         void    (*init_rec_from_cur)(struct xfs_btree_cur *cur,
                                      union xfs_btree_rec *rec);
         void    (*init_ptr_from_cur)(struct xfs_btree_cur *cur,
                                      union xfs_btree_ptr *ptr);
+        void    (*init_high_key_from_rec)(union xfs_btree_key *key,
+                                          union xfs_btree_rec *rec);
 
         /* difference between key value and cursor value */
         __int64_t (*key_diff)(struct xfs_btree_cur *cur,
                               union xfs_btree_key *key);
 
+        /*
+         * Difference between key2 and key1 -- positive if key1 > key2,
+         * negative if key1 < key2, and zero if equal.
+         */
+        __int64_t (*diff_two_keys)(struct xfs_btree_cur *cur,
+                                   union xfs_btree_key *key1,
+                                   union xfs_btree_key *key2);
+
         const struct xfs_buf_ops        *buf_ops;
 
 #if defined(DEBUG) || defined(XFS_WARN)
@@ -192,6 +224,13 @@ struct xfs_btree_ops {
 #define LASTREC_DELREC  2
 
 
+union xfs_btree_irec {
+        struct xfs_alloc_rec_incore     a;
+        struct xfs_bmbt_irec            b;
+        struct xfs_inobt_rec_incore     i;
+        struct xfs_rmap_irec            r;
+};
+
 /*
  * Btree cursor structure.
  * This collects all information needed by the btree code in one place.
@@ -202,11 +241,7 @@ typedef struct xfs_btree_cur
         struct xfs_mount        *bc_mp; /* file system mount struct */
         const struct xfs_btree_ops *bc_ops;
         uint                    bc_flags; /* btree features - below */
-        union {
-                xfs_alloc_rec_incore_t  a;
-                xfs_bmbt_irec_t         b;
-                xfs_inobt_rec_incore_t  i;
-        }               bc_rec;         /* current insert/search record value */
+        union xfs_btree_irec    bc_rec; /* current insert/search record value */
         struct xfs_buf  *bc_bufs[XFS_BTREE_MAXLEVELS];  /* buf ptr per level */
         int             bc_ptrs[XFS_BTREE_MAXLEVELS];   /* key/record # */
         __uint8_t       bc_ra[XFS_BTREE_MAXLEVELS];     /* readahead bits */
@@ -218,11 +253,12 @@ typedef struct xfs_btree_cur
         union {
                 struct {                        /* needed for BNO, CNT, INO */
                         struct xfs_buf  *agbp;  /* agf/agi buffer pointer */
+                        struct xfs_defer_ops *dfops;    /* deferred updates */
                         xfs_agnumber_t  agno;   /* ag number */
                 } a;
                 struct {                        /* needed for BMAP */
                         struct xfs_inode *ip;   /* pointer to our inode */
-                        struct xfs_bmap_free *flist;    /* list to free after */
+                        struct xfs_defer_ops *dfops;    /* deferred updates */
                         xfs_fsblock_t   firstblock;     /* 1st blk allocated */
                         int             allocated;      /* count of alloced */
                         short           forksize;       /* fork's inode space */
@@ -238,6 +274,7 @@ typedef struct xfs_btree_cur
 #define XFS_BTREE_ROOT_IN_INODE         (1<<1)  /* root may be variable size */
 #define XFS_BTREE_LASTREC_UPDATE        (1<<2)  /* track last rec externally */
 #define XFS_BTREE_CRC_BLOCKS            (1<<3)  /* uses extended btree blocks */
+#define XFS_BTREE_OVERLAPPING           (1<<4)  /* overlapping intervals */
 
 
 #define XFS_BTREE_NOERROR       0
@@ -477,4 +514,19 @@ bool xfs_btree_sblock_verify(struct xfs_buf *bp, unsigned int max_recs);
 uint xfs_btree_compute_maxlevels(struct xfs_mount *mp, uint *limits,
                                  unsigned long len);
 
+/* return codes */
+#define XFS_BTREE_QUERY_RANGE_CONTINUE  0       /* keep iterating */
+#define XFS_BTREE_QUERY_RANGE_ABORT     1       /* stop iterating */
+typedef int (*xfs_btree_query_range_fn)(struct xfs_btree_cur *cur,
+                union xfs_btree_rec *rec, void *priv);
+
+int xfs_btree_query_range(struct xfs_btree_cur *cur,
+                union xfs_btree_irec *low_rec, union xfs_btree_irec *high_rec,
+                xfs_btree_query_range_fn fn, void *priv);
+
+typedef int (*xfs_btree_visit_blocks_fn)(struct xfs_btree_cur *cur, int level,
+                void *data);
+int xfs_btree_visit_blocks(struct xfs_btree_cur *cur,
+                xfs_btree_visit_blocks_fn fn, void *data);
+
 #endif  /* __XFS_BTREE_H__ */
diff --git a/fs/xfs/libxfs/xfs_da_btree.c b/fs/xfs/libxfs/xfs_da_btree.c
index 0f1f165f4048..f2dc1a950c85 100644
--- a/fs/xfs/libxfs/xfs_da_btree.c
+++ b/fs/xfs/libxfs/xfs_da_btree.c
@@ -2029,7 +2029,7 @@ xfs_da_grow_inode_int(
         error = xfs_bmapi_write(tp, dp, *bno, count,
                         xfs_bmapi_aflag(w)|XFS_BMAPI_METADATA|XFS_BMAPI_CONTIG,
                         args->firstblock, args->total, &map, &nmap,
-                        args->flist);
+                        args->dfops);
         if (error)
                 return error;
 
@@ -2052,7 +2052,7 @@ xfs_da_grow_inode_int(
                         error = xfs_bmapi_write(tp, dp, b, c,
                                         xfs_bmapi_aflag(w)|XFS_BMAPI_METADATA,
                                         args->firstblock, args->total,
-                                        &mapp[mapi], &nmap, args->flist);
+                                        &mapp[mapi], &nmap, args->dfops);
                         if (error)
                                 goto out_free_map;
                         if (nmap < 1)
@@ -2362,7 +2362,7 @@ xfs_da_shrink_inode(
                  */
                 error = xfs_bunmapi(tp, dp, dead_blkno, count,
                                     xfs_bmapi_aflag(w), 0, args->firstblock,
-                                    args->flist, &done);
+                                    args->dfops, &done);
                 if (error == -ENOSPC) {
                         if (w != XFS_DATA_FORK)
                                 break;
diff --git a/fs/xfs/libxfs/xfs_da_btree.h b/fs/xfs/libxfs/xfs_da_btree.h
index 6e153e399a77..98c75cbe6ac2 100644
--- a/fs/xfs/libxfs/xfs_da_btree.h
+++ b/fs/xfs/libxfs/xfs_da_btree.h
@@ -19,7 +19,7 @@
 #ifndef __XFS_DA_BTREE_H__
 #define __XFS_DA_BTREE_H__
 
-struct xfs_bmap_free;
+struct xfs_defer_ops;
 struct xfs_inode;
 struct xfs_trans;
 struct zone;
@@ -70,7 +70,7 @@ typedef struct xfs_da_args {
         xfs_ino_t       inumber;        /* input/output inode number */
         struct xfs_inode *dp;           /* directory inode to manipulate */
         xfs_fsblock_t   *firstblock;    /* ptr to firstblock for bmap calls */
-        struct xfs_bmap_free *flist;    /* ptr to freelist for bmap_finish */
+        struct xfs_defer_ops *dfops;    /* ptr to freelist for bmap_finish */
         struct xfs_trans *trans;        /* current trans (changes over time) */
         xfs_extlen_t    total;          /* total blocks needed, for 1st bmap */
         int             whichfork;      /* data or attribute fork */
diff --git a/fs/xfs/libxfs/xfs_da_format.h b/fs/xfs/libxfs/xfs_da_format.h
index 685f23b67056..9a492a9e19bd 100644
--- a/fs/xfs/libxfs/xfs_da_format.h
+++ b/fs/xfs/libxfs/xfs_da_format.h
@@ -629,6 +629,7 @@ typedef struct xfs_attr_shortform {
         struct xfs_attr_sf_hdr {        /* constant-structure header block */
                 __be16  totsize;        /* total bytes in shortform list */
                 __u8    count;  /* count of active entries */
+                __u8    padding;
         } hdr;
         struct xfs_attr_sf_entry {
                 __uint8_t namelen;      /* actual length of name (no NULL) */
diff --git a/fs/xfs/libxfs/xfs_defer.c b/fs/xfs/libxfs/xfs_defer.c
new file mode 100644
index 000000000000..054a2032fdb3
--- /dev/null
+++ b/fs/xfs/libxfs/xfs_defer.c
@@ -0,0 +1,463 @@
+/*
+ * Copyright (C) 2016 Oracle.  All Rights Reserved.
+ *
+ * Author: Darrick J. Wong <darrick.wong@oracle.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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_mount.h"
+#include "xfs_defer.h"
+#include "xfs_trans.h"
+#include "xfs_trace.h"
+
+/*
+ * Deferred Operations in XFS
+ *
+ * Due to the way locking rules work in XFS, certain transactions (block
+ * mapping and unmapping, typically) have permanent reservations so that
+ * we can roll the transaction to adhere to AG locking order rules and
+ * to unlock buffers between metadata updates.  Prior to rmap/reflink,
+ * the mapping code had a mechanism to perform these deferrals for
+ * extents that were going to be freed; this code makes that facility
+ * more generic.
+ *
+ * When adding the reverse mapping and reflink features, it became
+ * necessary to perform complex remapping multi-transactions to comply
+ * with AG locking order rules, and to be able to spread a single
+ * refcount update operation (an operation on an n-block extent can
+ * update as many as n records!) among multiple transactions.  XFS can
+ * roll a transaction to facilitate this, but using this facility
+ * requires us to log "intent" items in case log recovery needs to
+ * redo the operation, and to log "done" items to indicate that redo
+ * is not necessary.
+ *
+ * Deferred work is tracked in xfs_defer_pending items.  Each pending
+ * item tracks one type of deferred work.  Incoming work items (which
+ * have not yet had an intent logged) are attached to a pending item
+ * on the dop_intake list, where they wait for the caller to finish
+ * the deferred operations.
+ *
+ * Finishing a set of deferred operations is an involved process.  To
+ * start, we define "rolling a deferred-op transaction" as follows:
+ *
+ * > For each xfs_defer_pending item on the dop_intake list,
+ *   - Sort the work items in AG order.  XFS locking
+ *     order rules require us to lock buffers in AG order.
+ *   - Create a log intent item for that type.
+ *   - Attach it to the pending item.
+ *   - Move the pending item from the dop_intake list to the
+ *     dop_pending list.
+ * > Roll the transaction.
+ *
+ * NOTE: To avoid exceeding the transaction reservation, we limit the
+ * number of items that we attach to a given xfs_defer_pending.
+ *
+ * The actual finishing process looks like this:
+ *
+ * > For each xfs_defer_pending in the dop_pending list,
+ *   - Roll the deferred-op transaction as above.
+ *   - Create a log done item for that type, and attach it to the
+ *     log intent item.
+ *   - For each work item attached to the log intent item,
+ *     * Perform the described action.
+ *     * Attach the work item to the log done item.
+ *
+ * The key here is that we must log an intent item for all pending
+ * work items every time we roll the transaction, and that we must log
+ * a done item as soon as the work is completed.  With this mechanism
+ * we can perform complex remapping operations, chaining intent items
+ * as needed.
+ *
+ * This is an example of remapping the extent (E, E+B) into file X at
+ * offset A and dealing with the extent (C, C+B) already being mapped
+ * there:
+ * +-------------------------------------------------+
+ * | Unmap file X startblock C offset A length B     | t0
+ * | Intent to reduce refcount for extent (C, B)     |
+ * | Intent to remove rmap (X, C, A, B)              |
+ * | Intent to free extent (D, 1) (bmbt block)       |
+ * | Intent to map (X, A, B) at startblock E         |
+ * +-------------------------------------------------+
+ * | Map file X startblock E offset A length B       | t1
+ * | Done mapping (X, E, A, B)                       |
+ * | Intent to increase refcount for extent (E, B)   |
+ * | Intent to add rmap (X, E, A, B)                 |
+ * +-------------------------------------------------+
+ * | Reduce refcount for extent (C, B)               | t2
+ * | Done reducing refcount for extent (C, B)        |
+ * | Increase refcount for extent (E, B)             |
+ * | Done increasing refcount for extent (E, B)      |
+ * | Intent to free extent (C, B)                    |
+ * | Intent to free extent (F, 1) (refcountbt block) |
+ * | Intent to remove rmap (F, 1, REFC)              |
+ * +-------------------------------------------------+
+ * | Remove rmap (X, C, A, B)                        | t3
+ * | Done removing rmap (X, C, A, B)                 |
+ * | Add rmap (X, E, A, B)                           |
+ * | Done adding rmap (X, E, A, B)                   |
+ * | Remove rmap (F, 1, REFC)                        |
+ * | Done removing rmap (F, 1, REFC)                 |
+ * +-------------------------------------------------+
+ * | Free extent (C, B)                              | t4
+ * | Done freeing extent (C, B)                      |
+ * | Free extent (D, 1)                              |
+ * | Done freeing extent (D, 1)                      |
+ * | Free extent (F, 1)                              |
+ * | Done freeing extent (F, 1)                      |
+ * +-------------------------------------------------+
+ *
+ * If we should crash before t2 commits, log recovery replays
+ * the following intent items:
+ *
+ * - Intent to reduce refcount for extent (C, B)
+ * - Intent to remove rmap (X, C, A, B)
+ * - Intent to free extent (D, 1) (bmbt block)
+ * - Intent to increase refcount for extent (E, B)
+ * - Intent to add rmap (X, E, A, B)
+ *
+ * In the process of recovering, it should also generate and take care
+ * of these intent items:
+ *
+ * - Intent to free extent (C, B)
+ * - Intent to free extent (F, 1) (refcountbt block)
+ * - Intent to remove rmap (F, 1, REFC)
+ */
+
+static const struct xfs_defer_op_type *defer_op_types[XFS_DEFER_OPS_TYPE_MAX];
+
+/*
+ * For each pending item in the intake list, log its intent item and the
+ * associated extents, then add the entire intake list to the end of
+ * the pending list.
+ */
+STATIC void
+xfs_defer_intake_work(
+        struct xfs_trans                *tp,
+        struct xfs_defer_ops            *dop)
+{
+        struct list_head                *li;
+        struct xfs_defer_pending        *dfp;
+
+        list_for_each_entry(dfp, &dop->dop_intake, dfp_list) {
+                trace_xfs_defer_intake_work(tp->t_mountp, dfp);
+                dfp->dfp_intent = dfp->dfp_type->create_intent(tp,
+                                dfp->dfp_count);
+                list_sort(tp->t_mountp, &dfp->dfp_work,
+                                dfp->dfp_type->diff_items);
+                list_for_each(li, &dfp->dfp_work)
+                        dfp->dfp_type->log_item(tp, dfp->dfp_intent, li);
+        }
+
+        list_splice_tail_init(&dop->dop_intake, &dop->dop_pending);
+}
+
+/* Abort all the intents that were committed. */
+STATIC void
+xfs_defer_trans_abort(
+        struct xfs_trans                *tp,
+        struct xfs_defer_ops            *dop,
+        int                             error)
+{
+        struct xfs_defer_pending        *dfp;
+
+        trace_xfs_defer_trans_abort(tp->t_mountp, dop);
+        /*
+         * If the transaction was committed, drop the intent reference
+         * since we're bailing out of here. The other reference is
+         * dropped when the intent hits the AIL.  If the transaction
+         * was not committed, the intent is freed by the intent item
+         * unlock handler on abort.
+         */
+        if (!dop->dop_committed)
+                return;
+
+        /* Abort intent items. */
+        list_for_each_entry(dfp, &dop->dop_pending, dfp_list) {
+                trace_xfs_defer_pending_abort(tp->t_mountp, dfp);
+                if (dfp->dfp_committed)
+                        dfp->dfp_type->abort_intent(dfp->dfp_intent);
+        }
+
+        /* Shut down FS. */
+        xfs_force_shutdown(tp->t_mountp, (error == -EFSCORRUPTED) ?
+                        SHUTDOWN_CORRUPT_INCORE : SHUTDOWN_META_IO_ERROR);
+}
+
+/* Roll a transaction so we can do some deferred op processing. */
+STATIC int
+xfs_defer_trans_roll(
+        struct xfs_trans                **tp,
+        struct xfs_defer_ops            *dop,
+        struct xfs_inode                *ip)
+{
+        int                             i;
+        int                             error;
+
+        /* Log all the joined inodes except the one we passed in. */
+        for (i = 0; i < XFS_DEFER_OPS_NR_INODES && dop->dop_inodes[i]; i++) {
+                if (dop->dop_inodes[i] == ip)
+                        continue;
+                xfs_trans_log_inode(*tp, dop->dop_inodes[i], XFS_ILOG_CORE);
+        }
+
+        trace_xfs_defer_trans_roll((*tp)->t_mountp, dop);
+
+        /* Roll the transaction. */
+        error = xfs_trans_roll(tp, ip);
+        if (error) {
+                trace_xfs_defer_trans_roll_error((*tp)->t_mountp, dop, error);
+                xfs_defer_trans_abort(*tp, dop, error);
+                return error;
+        }
+        dop->dop_committed = true;
+
+        /* Rejoin the joined inodes except the one we passed in. */
+        for (i = 0; i < XFS_DEFER_OPS_NR_INODES && dop->dop_inodes[i]; i++) {
+                if (dop->dop_inodes[i] == ip)
+                        continue;
+                xfs_trans_ijoin(*tp, dop->dop_inodes[i], 0);
+        }
+
+        return error;
+}
+
+/* Do we have any work items to finish? */
+bool
+xfs_defer_has_unfinished_work(
+        struct xfs_defer_ops            *dop)
+{
+        return !list_empty(&dop->dop_pending) || !list_empty(&dop->dop_intake);
+}
+
+/*
+ * Add this inode to the deferred op.  Each joined inode is relogged
+ * each time we roll the transaction, in addition to any inode passed
+ * to xfs_defer_finish().
+ */
+int
+xfs_defer_join(
+        struct xfs_defer_ops            *dop,
+        struct xfs_inode                *ip)
+{
+        int                             i;
+
+        for (i = 0; i < XFS_DEFER_OPS_NR_INODES; i++) {
+                if (dop->dop_inodes[i] == ip)
+                        return 0;
+                else if (dop->dop_inodes[i] == NULL) {
+                        dop->dop_inodes[i] = ip;
+                        return 0;
+                }
+        }
+
+        return -EFSCORRUPTED;
+}
+
+/*
+ * Finish all the pending work.  This involves logging intent items for
+ * any work items that wandered in since the last transaction roll (if
+ * one has even happened), rolling the transaction, and finishing the
+ * work items in the first item on the logged-and-pending list.
+ *
+ * If an inode is provided, relog it to the new transaction.
+ */
+int
+xfs_defer_finish(
+        struct xfs_trans                **tp,
+        struct xfs_defer_ops            *dop,
+        struct xfs_inode                *ip)
+{
+        struct xfs_defer_pending        *dfp;
+        struct list_head                *li;
+        struct list_head                *n;
+        void                            *done_item = NULL;
+        void                            *state;
+        int                             error = 0;
+        void                            (*cleanup_fn)(struct xfs_trans *, void *, int);
+
+        ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES);
+
+        trace_xfs_defer_finish((*tp)->t_mountp, dop);
+
+        /* Until we run out of pending work to finish... */
+        while (xfs_defer_has_unfinished_work(dop)) {
+                /* Log intents for work items sitting in the intake. */
+                xfs_defer_intake_work(*tp, dop);
+
+                /* Roll the transaction. */
+                error = xfs_defer_trans_roll(tp, dop, ip);
+                if (error)
+                        goto out;
+
+                /* Mark all pending intents as committed. */
+                list_for_each_entry_reverse(dfp, &dop->dop_pending, dfp_list) {
+                        if (dfp->dfp_committed)
+                                break;
+                        trace_xfs_defer_pending_commit((*tp)->t_mountp, dfp);
+                        dfp->dfp_committed = true;
+                }
+
+                /* Log an intent-done item for the first pending item. */
+                dfp = list_first_entry(&dop->dop_pending,
+                                struct xfs_defer_pending, dfp_list);
+                trace_xfs_defer_pending_finish((*tp)->t_mountp, dfp);
+                done_item = dfp->dfp_type->create_done(*tp, dfp->dfp_intent,
+                                dfp->dfp_count);
+                cleanup_fn = dfp->dfp_type->finish_cleanup;
+
+                /* Finish the work items. */
+                state = NULL;
+                list_for_each_safe(li, n, &dfp->dfp_work) {
+                        list_del(li);
+                        dfp->dfp_count--;
+                        error = dfp->dfp_type->finish_item(*tp, dop, li,
+                                        done_item, &state);
+                        if (error) {
+                                /*
+                                 * Clean up after ourselves and jump out.
+                                 * xfs_defer_cancel will take care of freeing
+                                 * all these lists and stuff.
+                                 */
+                                if (cleanup_fn)
+                                        cleanup_fn(*tp, state, error);
+                                xfs_defer_trans_abort(*tp, dop, error);
+                                goto out;
+                        }
+                }
+                /* Done with the dfp, free it. */
+                list_del(&dfp->dfp_list);
+                kmem_free(dfp);
+
+                if (cleanup_fn)
+                        cleanup_fn(*tp, state, error);
+        }
+
+out:
+        if (error)
+                trace_xfs_defer_finish_error((*tp)->t_mountp, dop, error);
+        else
+                trace_xfs_defer_finish_done((*tp)->t_mountp, dop);
+        return error;
+}
+
+/*
+ * Free up any items left in the list.
+ */
+void
+xfs_defer_cancel(
+        struct xfs_defer_ops            *dop)
+{
+        struct xfs_defer_pending        *dfp;
+        struct xfs_defer_pending        *pli;
+        struct list_head                *pwi;
+        struct list_head                *n;
+
+        trace_xfs_defer_cancel(NULL, dop);
+
+        /*
+         * Free the pending items.  Caller should already have arranged
+         * for the intent items to be released.
+         */
+        list_for_each_entry_safe(dfp, pli, &dop->dop_intake, dfp_list) {
+                trace_xfs_defer_intake_cancel(NULL, dfp);
+                list_del(&dfp->dfp_list);
+                list_for_each_safe(pwi, n, &dfp->dfp_work) {
+                        list_del(pwi);
+                        dfp->dfp_count--;
+                        dfp->dfp_type->cancel_item(pwi);
+                }
+                ASSERT(dfp->dfp_count == 0);
+                kmem_free(dfp);
+        }
+        list_for_each_entry_safe(dfp, pli, &dop->dop_pending, dfp_list) {
+                trace_xfs_defer_pending_cancel(NULL, dfp);
+                list_del(&dfp->dfp_list);
+                list_for_each_safe(pwi, n, &dfp->dfp_work) {
+                        list_del(pwi);
+                        dfp->dfp_count--;
+                        dfp->dfp_type->cancel_item(pwi);
+                }
+                ASSERT(dfp->dfp_count == 0);
+                kmem_free(dfp);
+        }
+}
+
+/* Add an item for later deferred processing. */
+void
+xfs_defer_add(
+        struct xfs_defer_ops            *dop,
+        enum xfs_defer_ops_type         type,
+        struct list_head                *li)
+{
+        struct xfs_defer_pending        *dfp = NULL;
+
+        /*
+         * Add the item to a pending item at the end of the intake list.
+         * If the last pending item has the same type, reuse it.  Else,
+         * create a new pending item at the end of the intake list.
+         */
+        if (!list_empty(&dop->dop_intake)) {
+                dfp = list_last_entry(&dop->dop_intake,
+                                struct xfs_defer_pending, dfp_list);
+                if (dfp->dfp_type->type != type ||
+                    (dfp->dfp_type->max_items &&
+                     dfp->dfp_count >= dfp->dfp_type->max_items))
+                        dfp = NULL;
+        }
+        if (!dfp) {
+                dfp = kmem_alloc(sizeof(struct xfs_defer_pending),
+                                KM_SLEEP | KM_NOFS);
+                dfp->dfp_type = defer_op_types[type];
+                dfp->dfp_committed = false;
+                dfp->dfp_intent = NULL;
+                dfp->dfp_count = 0;
+                INIT_LIST_HEAD(&dfp->dfp_work);
+                list_add_tail(&dfp->dfp_list, &dop->dop_intake);
+        }
+
+        list_add_tail(li, &dfp->dfp_work);
+        dfp->dfp_count++;
+}
+
+/* Initialize a deferred operation list. */
+void
+xfs_defer_init_op_type(
+        const struct xfs_defer_op_type  *type)
+{
+        defer_op_types[type->type] = type;
+}
+
+/* Initialize a deferred operation. */
+void
+xfs_defer_init(
+        struct xfs_defer_ops            *dop,
+        xfs_fsblock_t                   *fbp)
+{
+        dop->dop_committed = false;
+        dop->dop_low = false;
+        memset(&dop->dop_inodes, 0, sizeof(dop->dop_inodes));
+        *fbp = NULLFSBLOCK;
+        INIT_LIST_HEAD(&dop->dop_intake);
+        INIT_LIST_HEAD(&dop->dop_pending);
+        trace_xfs_defer_init(NULL, dop);
+}
diff --git a/fs/xfs/libxfs/xfs_defer.h b/fs/xfs/libxfs/xfs_defer.h
new file mode 100644
index 000000000000..cc3981c48296
--- /dev/null
+++ b/fs/xfs/libxfs/xfs_defer.h
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2016 Oracle.  All Rights Reserved.
+ *
+ * Author: Darrick J. Wong <darrick.wong@oracle.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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_DEFER_H__
+#define __XFS_DEFER_H__
+
+struct xfs_defer_op_type;
+
+/*
+ * Save a log intent item and a list of extents, so that we can replay
+ * whatever action had to happen to the extent list and file the log done
+ * item.
+ */
+struct xfs_defer_pending {
+        const struct xfs_defer_op_type  *dfp_type;      /* function pointers */
+        struct list_head                dfp_list;       /* pending items */
+        bool                            dfp_committed;  /* committed trans? */
+        void                            *dfp_intent;    /* log intent item */
+        struct list_head                dfp_work;       /* work items */
+        unsigned int                    dfp_count;      /* # extent items */
+};
+
+/*
+ * Header for deferred operation list.
+ *
+ * dop_low is used by the allocator to activate the lowspace algorithm -
+ * when free space is running low the extent allocator may choose to
+ * allocate an extent from an AG without leaving sufficient space for
+ * a btree split when inserting the new extent.  In this case the allocator
+ * will enable the lowspace algorithm which is supposed to allow further
+ * allocations (such as btree splits and newroots) to allocate from
+ * sequential AGs.  In order to avoid locking AGs out of order the lowspace
+ * algorithm will start searching for free space from AG 0.  If the correct
+ * transaction reservations have been made then this algorithm will eventually
+ * find all the space it needs.
+ */
+enum xfs_defer_ops_type {
+        XFS_DEFER_OPS_TYPE_RMAP,
+        XFS_DEFER_OPS_TYPE_FREE,
+        XFS_DEFER_OPS_TYPE_MAX,
+};
+
+#define XFS_DEFER_OPS_NR_INODES 2       /* join up to two inodes */
+
+struct xfs_defer_ops {
+        bool                    dop_committed;  /* did any trans commit? */
+        bool                    dop_low;        /* alloc in low mode */
+        struct list_head        dop_intake;     /* unlogged pending work */
+        struct list_head        dop_pending;    /* logged pending work */
+
+        /* relog these inodes with each roll */
+        struct xfs_inode        *dop_inodes[XFS_DEFER_OPS_NR_INODES];
+};
+
+void xfs_defer_add(struct xfs_defer_ops *dop, enum xfs_defer_ops_type type,
+                struct list_head *h);
+int xfs_defer_finish(struct xfs_trans **tp, struct xfs_defer_ops *dop,
+                struct xfs_inode *ip);
+void xfs_defer_cancel(struct xfs_defer_ops *dop);
+void xfs_defer_init(struct xfs_defer_ops *dop, xfs_fsblock_t *fbp);
+bool xfs_defer_has_unfinished_work(struct xfs_defer_ops *dop);
+int xfs_defer_join(struct xfs_defer_ops *dop, struct xfs_inode *ip);
+
+/* Description of a deferred type. */
+struct xfs_defer_op_type {
+        enum xfs_defer_ops_type type;
+        unsigned int            max_items;
+        void (*abort_intent)(void *);
+        void *(*create_done)(struct xfs_trans *, void *, unsigned int);
+        int (*finish_item)(struct xfs_trans *, struct xfs_defer_ops *,
+                        struct list_head *, void *, void **);
+        void (*finish_cleanup)(struct xfs_trans *, void *, int);
+        void (*cancel_item)(struct list_head *);
+        int (*diff_items)(void *, struct list_head *, struct list_head *);
+        void *(*create_intent)(struct xfs_trans *, uint);
+        void (*log_item)(struct xfs_trans *, void *, struct list_head *);
+};
+
+void xfs_defer_init_op_type(const struct xfs_defer_op_type *type);
+
+#endif /* __XFS_DEFER_H__ */
diff --git a/fs/xfs/libxfs/xfs_dir2.c b/fs/xfs/libxfs/xfs_dir2.c
index af0f9d171f8a..20a96dd5af7e 100644
--- a/fs/xfs/libxfs/xfs_dir2.c
+++ b/fs/xfs/libxfs/xfs_dir2.c
@@ -21,6 +21,7 @@
 #include "xfs_log_format.h"
 #include "xfs_trans_resv.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_da_format.h"
 #include "xfs_da_btree.h"
 #include "xfs_inode.h"
@@ -259,7 +260,7 @@ xfs_dir_createname(
         struct xfs_name         *name,
         xfs_ino_t               inum,           /* new entry inode number */
         xfs_fsblock_t           *first,         /* bmap's firstblock */
-        xfs_bmap_free_t         *flist,         /* bmap's freeblock list */
+        struct xfs_defer_ops    *dfops,         /* bmap's freeblock list */
         xfs_extlen_t            total)          /* bmap's total block count */
 {
         struct xfs_da_args      *args;
@@ -286,7 +287,7 @@ xfs_dir_createname(
         args->inumber = inum;
         args->dp = dp;
         args->firstblock = first;
-        args->flist = flist;
+        args->dfops = dfops;
         args->total = total;
         args->whichfork = XFS_DATA_FORK;
         args->trans = tp;
@@ -436,7 +437,7 @@ xfs_dir_removename(
         struct xfs_name *name,
         xfs_ino_t       ino,
         xfs_fsblock_t   *first,         /* bmap's firstblock */
-        xfs_bmap_free_t *flist,         /* bmap's freeblock list */
+        struct xfs_defer_ops    *dfops,         /* bmap's freeblock list */
         xfs_extlen_t    total)          /* bmap's total block count */
 {
         struct xfs_da_args *args;
@@ -458,7 +459,7 @@ xfs_dir_removename(
         args->inumber = ino;
         args->dp = dp;
         args->firstblock = first;
-        args->flist = flist;
+        args->dfops = dfops;
         args->total = total;
         args->whichfork = XFS_DATA_FORK;
         args->trans = tp;
@@ -498,7 +499,7 @@ xfs_dir_replace(
         struct xfs_name *name,          /* name of entry to replace */
         xfs_ino_t       inum,           /* new inode number */
         xfs_fsblock_t   *first,         /* bmap's firstblock */
-        xfs_bmap_free_t *flist,         /* bmap's freeblock list */
+        struct xfs_defer_ops    *dfops,         /* bmap's freeblock list */
         xfs_extlen_t    total)          /* bmap's total block count */
 {
         struct xfs_da_args *args;
@@ -523,7 +524,7 @@ xfs_dir_replace(
         args->inumber = inum;
         args->dp = dp;
         args->firstblock = first;
-        args->flist = flist;
+        args->dfops = dfops;
         args->total = total;
         args->whichfork = XFS_DATA_FORK;
         args->trans = tp;
@@ -680,7 +681,7 @@ xfs_dir2_shrink_inode(
 
         /* Unmap the fsblock(s). */
         error = xfs_bunmapi(tp, dp, da, args->geo->fsbcount, 0, 0,
-                            args->firstblock, args->flist, &done);
+                            args->firstblock, args->dfops, &done);
         if (error) {
                 /*
                  * ENOSPC actually can happen if we're in a removename with no
diff --git a/fs/xfs/libxfs/xfs_dir2.h b/fs/xfs/libxfs/xfs_dir2.h
index e55353651f5b..becc926c3e3d 100644
--- a/fs/xfs/libxfs/xfs_dir2.h
+++ b/fs/xfs/libxfs/xfs_dir2.h
@@ -18,7 +18,7 @@
 #ifndef __XFS_DIR2_H__
 #define __XFS_DIR2_H__
 
-struct xfs_bmap_free;
+struct xfs_defer_ops;
 struct xfs_da_args;
 struct xfs_inode;
 struct xfs_mount;
@@ -129,18 +129,18 @@ extern int xfs_dir_init(struct xfs_trans *tp, struct xfs_inode *dp,
 extern int xfs_dir_createname(struct xfs_trans *tp, struct xfs_inode *dp,
                                 struct xfs_name *name, xfs_ino_t inum,
                                 xfs_fsblock_t *first,
-                                struct xfs_bmap_free *flist, xfs_extlen_t tot);
+                                struct xfs_defer_ops *dfops, xfs_extlen_t tot);
 extern int xfs_dir_lookup(struct xfs_trans *tp, struct xfs_inode *dp,
                                 struct xfs_name *name, xfs_ino_t *inum,
                                 struct xfs_name *ci_name);
 extern int xfs_dir_removename(struct xfs_trans *tp, struct xfs_inode *dp,
                                 struct xfs_name *name, xfs_ino_t ino,
                                 xfs_fsblock_t *first,
-                                struct xfs_bmap_free *flist, xfs_extlen_t tot);
+                                struct xfs_defer_ops *dfops, xfs_extlen_t tot);
 extern int xfs_dir_replace(struct xfs_trans *tp, struct xfs_inode *dp,
                                 struct xfs_name *name, xfs_ino_t inum,
                                 xfs_fsblock_t *first,
-                                struct xfs_bmap_free *flist, xfs_extlen_t tot);
+                                struct xfs_defer_ops *dfops, xfs_extlen_t tot);
 extern int xfs_dir_canenter(struct xfs_trans *tp, struct xfs_inode *dp,
                                 struct xfs_name *name);
 
diff --git a/fs/xfs/libxfs/xfs_format.h b/fs/xfs/libxfs/xfs_format.h
index adb204d40f22..f814d42c73b2 100644
--- a/fs/xfs/libxfs/xfs_format.h
+++ b/fs/xfs/libxfs/xfs_format.h
@@ -455,8 +455,10 @@ xfs_sb_has_compat_feature(
 }
 
 #define XFS_SB_FEAT_RO_COMPAT_FINOBT   (1 << 0)         /* free inode btree */
+#define XFS_SB_FEAT_RO_COMPAT_RMAPBT   (1 << 1)         /* reverse map btree */
 #define XFS_SB_FEAT_RO_COMPAT_ALL \
-                (XFS_SB_FEAT_RO_COMPAT_FINOBT)
+                (XFS_SB_FEAT_RO_COMPAT_FINOBT | \
+                 XFS_SB_FEAT_RO_COMPAT_RMAPBT)
 #define XFS_SB_FEAT_RO_COMPAT_UNKNOWN   ~XFS_SB_FEAT_RO_COMPAT_ALL
 static inline bool
 xfs_sb_has_ro_compat_feature(
@@ -538,6 +540,12 @@ static inline bool xfs_sb_version_hasmetauuid(struct xfs_sb *sbp)
                 (sbp->sb_features_incompat & XFS_SB_FEAT_INCOMPAT_META_UUID);
 }
 
+static inline bool xfs_sb_version_hasrmapbt(struct xfs_sb *sbp)
+{
+        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_5) &&
+                (sbp->sb_features_ro_compat & XFS_SB_FEAT_RO_COMPAT_RMAPBT);
+}
+
 /*
  * end of superblock version macros
  */
@@ -598,10 +606,10 @@ xfs_is_quota_inode(struct xfs_sb *sbp, xfs_ino_t ino)
 #define XFS_AGI_GOOD_VERSION(v) ((v) == XFS_AGI_VERSION)
 
 /*
- * Btree number 0 is bno, 1 is cnt.  This value gives the size of the
+ * Btree number 0 is bno, 1 is cnt, 2 is rmap. This value gives the size of the
  * arrays below.
  */
-#define XFS_BTNUM_AGF   ((int)XFS_BTNUM_CNTi + 1)
+#define XFS_BTNUM_AGF   ((int)XFS_BTNUM_RMAPi + 1)
 
 /*
  * The second word of agf_levels in the first a.g. overlaps the EFS
@@ -618,12 +626,10 @@ typedef struct xfs_agf {
         __be32          agf_seqno;      /* sequence # starting from 0 */
         __be32          agf_length;     /* size in blocks of a.g. */
         /*
-         * Freespace information
+         * Freespace and rmap information
          */
         __be32          agf_roots[XFS_BTNUM_AGF];       /* root blocks */
-        __be32          agf_spare0;     /* spare field */
         __be32          agf_levels[XFS_BTNUM_AGF];      /* btree levels */
-        __be32          agf_spare1;     /* spare field */
 
         __be32          agf_flfirst;    /* first freelist block's index */
         __be32          agf_fllast;     /* last freelist block's index */
@@ -1308,17 +1314,118 @@ typedef __be32 xfs_inobt_ptr_t;
 #define XFS_FIBT_BLOCK(mp)              ((xfs_agblock_t)(XFS_IBT_BLOCK(mp) + 1))
 
 /*
- * The first data block of an AG depends on whether the filesystem was formatted
- * with the finobt feature. If so, account for the finobt reserved root btree
- * block.
+ * Reverse mapping btree format definitions
+ *
+ * There is a btree for the reverse map per allocation group
+ */
+#define XFS_RMAP_CRC_MAGIC      0x524d4233      /* 'RMB3' */
+
+/*
+ * Ownership info for an extent.  This is used to create reverse-mapping
+ * entries.
  */
-#define XFS_PREALLOC_BLOCKS(mp) \
+#define XFS_OWNER_INFO_ATTR_FORK        (1 << 0)
+#define XFS_OWNER_INFO_BMBT_BLOCK       (1 << 1)
+struct xfs_owner_info {
+        uint64_t                oi_owner;
+        xfs_fileoff_t           oi_offset;
+        unsigned int            oi_flags;
+};
+
+/*
+ * Special owner types.
+ *
+ * Seeing as we only support up to 8EB, we have the upper bit of the owner field
+ * to tell us we have a special owner value. We use these for static metadata
+ * allocated at mkfs/growfs time, as well as for freespace management metadata.
+ */
+#define XFS_RMAP_OWN_NULL       (-1ULL) /* No owner, for growfs */
+#define XFS_RMAP_OWN_UNKNOWN    (-2ULL) /* Unknown owner, for EFI recovery */
+#define XFS_RMAP_OWN_FS         (-3ULL) /* static fs metadata */
+#define XFS_RMAP_OWN_LOG        (-4ULL) /* static fs metadata */
+#define XFS_RMAP_OWN_AG         (-5ULL) /* AG freespace btree blocks */
+#define XFS_RMAP_OWN_INOBT      (-6ULL) /* Inode btree blocks */
+#define XFS_RMAP_OWN_INODES     (-7ULL) /* Inode chunk */
+#define XFS_RMAP_OWN_MIN        (-8ULL) /* guard */
+
+#define XFS_RMAP_NON_INODE_OWNER(owner) (!!((owner) & (1ULL << 63)))
+
+/*
+ * Data record structure
+ */
+struct xfs_rmap_rec {
+        __be32          rm_startblock;  /* extent start block */
+        __be32          rm_blockcount;  /* extent length */
+        __be64          rm_owner;       /* extent owner */
+        __be64          rm_offset;      /* offset within the owner */
+};
+
+/*
+ * rmap btree record
+ *  rm_offset:63 is the attribute fork flag
+ *  rm_offset:62 is the bmbt block flag
+ *  rm_offset:61 is the unwritten extent flag (same as l0:63 in bmbt)
+ *  rm_offset:54-60 aren't used and should be zero
+ *  rm_offset:0-53 is the block offset within the inode
+ */
+#define XFS_RMAP_OFF_ATTR_FORK  ((__uint64_t)1ULL << 63)
+#define XFS_RMAP_OFF_BMBT_BLOCK ((__uint64_t)1ULL << 62)
+#define XFS_RMAP_OFF_UNWRITTEN  ((__uint64_t)1ULL << 61)
+
+#define XFS_RMAP_LEN_MAX        ((__uint32_t)~0U)
+#define XFS_RMAP_OFF_FLAGS      (XFS_RMAP_OFF_ATTR_FORK | \
+                                 XFS_RMAP_OFF_BMBT_BLOCK | \
+                                 XFS_RMAP_OFF_UNWRITTEN)
+#define XFS_RMAP_OFF_MASK       ((__uint64_t)0x3FFFFFFFFFFFFFULL)
+
+#define XFS_RMAP_OFF(off)               ((off) & XFS_RMAP_OFF_MASK)
+
+#define XFS_RMAP_IS_BMBT_BLOCK(off)     (!!((off) & XFS_RMAP_OFF_BMBT_BLOCK))
+#define XFS_RMAP_IS_ATTR_FORK(off)      (!!((off) & XFS_RMAP_OFF_ATTR_FORK))
+#define XFS_RMAP_IS_UNWRITTEN(len)      (!!((off) & XFS_RMAP_OFF_UNWRITTEN))
+
+#define RMAPBT_STARTBLOCK_BITLEN        32
+#define RMAPBT_BLOCKCOUNT_BITLEN        32
+#define RMAPBT_OWNER_BITLEN             64
+#define RMAPBT_ATTRFLAG_BITLEN          1
+#define RMAPBT_BMBTFLAG_BITLEN          1
+#define RMAPBT_EXNTFLAG_BITLEN          1
+#define RMAPBT_UNUSED_OFFSET_BITLEN     7
+#define RMAPBT_OFFSET_BITLEN            54
+
+#define XFS_RMAP_ATTR_FORK              (1 << 0)
+#define XFS_RMAP_BMBT_BLOCK             (1 << 1)
+#define XFS_RMAP_UNWRITTEN              (1 << 2)
+#define XFS_RMAP_KEY_FLAGS              (XFS_RMAP_ATTR_FORK | \
+                                         XFS_RMAP_BMBT_BLOCK)
+#define XFS_RMAP_REC_FLAGS              (XFS_RMAP_UNWRITTEN)
+struct xfs_rmap_irec {
+        xfs_agblock_t   rm_startblock;  /* extent start block */
+        xfs_extlen_t    rm_blockcount;  /* extent length */
+        __uint64_t      rm_owner;       /* extent owner */
+        __uint64_t      rm_offset;      /* offset within the owner */
+        unsigned int    rm_flags;       /* state flags */
+};
+
+/*
+ * Key structure
+ *
+ * We don't use the length for lookups
+ */
+struct xfs_rmap_key {
+        __be32          rm_startblock;  /* extent start block */
+        __be64          rm_owner;       /* extent owner */
+        __be64          rm_offset;      /* offset within the owner */
+} __attribute__((packed));
+
+/* btree pointer type */
+typedef __be32 xfs_rmap_ptr_t;
+
+#define XFS_RMAP_BLOCK(mp) \
         (xfs_sb_version_hasfinobt(&((mp)->m_sb)) ? \
          XFS_FIBT_BLOCK(mp) + 1 : \
          XFS_IBT_BLOCK(mp) + 1)
 
-
-
 /*
  * BMAP Btree format definitions
  *
diff --git a/fs/xfs/libxfs/xfs_fs.h b/fs/xfs/libxfs/xfs_fs.h
index f5ec9c5ccae6..79455058b752 100644
--- a/fs/xfs/libxfs/xfs_fs.h
+++ b/fs/xfs/libxfs/xfs_fs.h
@@ -206,6 +206,7 @@ typedef struct xfs_fsop_resblks {
 #define XFS_FSOP_GEOM_FLAGS_FTYPE       0x10000 /* inode directory types */
 #define XFS_FSOP_GEOM_FLAGS_FINOBT      0x20000 /* free inode btree */
 #define XFS_FSOP_GEOM_FLAGS_SPINODES    0x40000 /* sparse inode chunks  */
+#define XFS_FSOP_GEOM_FLAGS_RMAPBT      0x80000 /* Reverse mapping btree */
 
 /*
  * Minimum and maximum sizes need for growth checks.
diff --git a/fs/xfs/libxfs/xfs_ialloc.c b/fs/xfs/libxfs/xfs_ialloc.c
index 4b1e408169a8..51b4e0de1fdc 100644
--- a/fs/xfs/libxfs/xfs_ialloc.c
+++ b/fs/xfs/libxfs/xfs_ialloc.c
@@ -24,6 +24,7 @@
 #include "xfs_bit.h"
 #include "xfs_sb.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_inode.h"
 #include "xfs_btree.h"
 #include "xfs_ialloc.h"
@@ -39,6 +40,7 @@
 #include "xfs_icache.h"
 #include "xfs_trace.h"
 #include "xfs_log.h"
+#include "xfs_rmap.h"
 
 
 /*
@@ -614,6 +616,7 @@ xfs_ialloc_ag_alloc(
         args.tp = tp;
         args.mp = tp->t_mountp;
         args.fsbno = NULLFSBLOCK;
+        xfs_rmap_ag_owner(&args.oinfo, XFS_RMAP_OWN_INODES);
 
 #ifdef DEBUG
         /* randomly do sparse inode allocations */
@@ -1817,19 +1820,21 @@ xfs_difree_inode_chunk(
         struct xfs_mount                *mp,
         xfs_agnumber_t                  agno,
         struct xfs_inobt_rec_incore     *rec,
-        struct xfs_bmap_free            *flist)
+        struct xfs_defer_ops            *dfops)
 {
         xfs_agblock_t   sagbno = XFS_AGINO_TO_AGBNO(mp, rec->ir_startino);
         int             startidx, endidx;
         int             nextbit;
         xfs_agblock_t   agbno;
         int             contigblk;
+        struct xfs_owner_info   oinfo;
         DECLARE_BITMAP(holemask, XFS_INOBT_HOLEMASK_BITS);
+        xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INODES);
 
         if (!xfs_inobt_issparse(rec->ir_holemask)) {
                 /* not sparse, calculate extent info directly */
-                xfs_bmap_add_free(mp, flist, XFS_AGB_TO_FSB(mp, agno, sagbno),
-                                  mp->m_ialloc_blks);
+                xfs_bmap_add_free(mp, dfops, XFS_AGB_TO_FSB(mp, agno, sagbno),
+                                  mp->m_ialloc_blks, &oinfo);
                 return;
         }
 
@@ -1872,8 +1877,8 @@ xfs_difree_inode_chunk(
 
                 ASSERT(agbno % mp->m_sb.sb_spino_align == 0);
                 ASSERT(contigblk % mp->m_sb.sb_spino_align == 0);
-                xfs_bmap_add_free(mp, flist, XFS_AGB_TO_FSB(mp, agno, agbno),
-                                  contigblk);
+                xfs_bmap_add_free(mp, dfops, XFS_AGB_TO_FSB(mp, agno, agbno),
+                                  contigblk, &oinfo);
 
                 /* reset range to current bit and carry on... */
                 startidx = endidx = nextbit;
@@ -1889,7 +1894,7 @@ xfs_difree_inobt(
         struct xfs_trans                *tp,
         struct xfs_buf                  *agbp,
         xfs_agino_t                     agino,
-        struct xfs_bmap_free            *flist,
+        struct xfs_defer_ops            *dfops,
         struct xfs_icluster             *xic,
         struct xfs_inobt_rec_incore     *orec)
 {
@@ -1976,7 +1981,7 @@ xfs_difree_inobt(
                         goto error0;
                 }
 
-                xfs_difree_inode_chunk(mp, agno, &rec, flist);
+                xfs_difree_inode_chunk(mp, agno, &rec, dfops);
         } else {
                 xic->deleted = 0;
 
@@ -2121,7 +2126,7 @@ int
 xfs_difree(
         struct xfs_trans        *tp,            /* transaction pointer */
         xfs_ino_t               inode,          /* inode to be freed */
-        struct xfs_bmap_free    *flist,         /* extents to free */
+        struct xfs_defer_ops    *dfops,         /* extents to free */
         struct xfs_icluster     *xic)   /* cluster info if deleted */
 {
         /* REFERENCED */
@@ -2173,7 +2178,7 @@ xfs_difree(
         /*
          * Fix up the inode allocation btree.
          */
-        error = xfs_difree_inobt(mp, tp, agbp, agino, flist, xic, &rec);
+        error = xfs_difree_inobt(mp, tp, agbp, agino, dfops, xic, &rec);
         if (error)
                 goto error0;
 
diff --git a/fs/xfs/libxfs/xfs_ialloc.h b/fs/xfs/libxfs/xfs_ialloc.h
index 6e450df2979b..0bb89669fc07 100644
--- a/fs/xfs/libxfs/xfs_ialloc.h
+++ b/fs/xfs/libxfs/xfs_ialloc.h
@@ -95,7 +95,7 @@ int					/* error */
 xfs_difree(
         struct xfs_trans *tp,           /* transaction pointer */
         xfs_ino_t       inode,          /* inode to be freed */
-        struct xfs_bmap_free *flist,    /* extents to free */
+        struct xfs_defer_ops *dfops,    /* extents to free */
         struct xfs_icluster *ifree);    /* cluster info if deleted */
 
 /*
diff --git a/fs/xfs/libxfs/xfs_ialloc_btree.c b/fs/xfs/libxfs/xfs_ialloc_btree.c
index 89c21d771e35..31ca2208c03d 100644
--- a/fs/xfs/libxfs/xfs_ialloc_btree.c
+++ b/fs/xfs/libxfs/xfs_ialloc_btree.c
@@ -32,6 +32,7 @@
 #include "xfs_trace.h"
 #include "xfs_cksum.h"
 #include "xfs_trans.h"
+#include "xfs_rmap.h"
 
 
 STATIC int
@@ -96,6 +97,7 @@ xfs_inobt_alloc_block(
         memset(&args, 0, sizeof(args));
         args.tp = cur->bc_tp;
         args.mp = cur->bc_mp;
+        xfs_rmap_ag_owner(&args.oinfo, XFS_RMAP_OWN_INOBT);
         args.fsbno = XFS_AGB_TO_FSB(args.mp, cur->bc_private.a.agno, sbno);
         args.minlen = 1;
         args.maxlen = 1;
@@ -125,8 +127,12 @@ xfs_inobt_free_block(
         struct xfs_btree_cur    *cur,
         struct xfs_buf          *bp)
 {
+        struct xfs_owner_info   oinfo;
+
+        xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_INOBT);
         return xfs_free_extent(cur->bc_tp,
-                        XFS_DADDR_TO_FSB(cur->bc_mp, XFS_BUF_ADDR(bp)), 1);
+                        XFS_DADDR_TO_FSB(cur->bc_mp, XFS_BUF_ADDR(bp)), 1,
+                        &oinfo);
 }
 
 STATIC int
@@ -146,14 +152,6 @@ xfs_inobt_init_key_from_rec(
 }
 
 STATIC void
-xfs_inobt_init_rec_from_key(
-        union xfs_btree_key     *key,
-        union xfs_btree_rec     *rec)
-{
-        rec->inobt.ir_startino = key->inobt.ir_startino;
-}
-
-STATIC void
 xfs_inobt_init_rec_from_cur(
         struct xfs_btree_cur    *cur,
         union xfs_btree_rec     *rec)
@@ -314,7 +312,6 @@ static const struct xfs_btree_ops xfs_inobt_ops = {
         .get_minrecs            = xfs_inobt_get_minrecs,
         .get_maxrecs            = xfs_inobt_get_maxrecs,
         .init_key_from_rec      = xfs_inobt_init_key_from_rec,
-        .init_rec_from_key      = xfs_inobt_init_rec_from_key,
         .init_rec_from_cur      = xfs_inobt_init_rec_from_cur,
         .init_ptr_from_cur      = xfs_inobt_init_ptr_from_cur,
         .key_diff               = xfs_inobt_key_diff,
@@ -336,7 +333,6 @@ static const struct xfs_btree_ops xfs_finobt_ops = {
         .get_minrecs            = xfs_inobt_get_minrecs,
         .get_maxrecs            = xfs_inobt_get_maxrecs,
         .init_key_from_rec      = xfs_inobt_init_key_from_rec,
-        .init_rec_from_key      = xfs_inobt_init_rec_from_key,
         .init_rec_from_cur      = xfs_inobt_init_rec_from_cur,
         .init_ptr_from_cur      = xfs_finobt_init_ptr_from_cur,
         .key_diff               = xfs_inobt_key_diff,
diff --git a/fs/xfs/libxfs/xfs_inode_buf.c b/fs/xfs/libxfs/xfs_inode_buf.c
index 9d9559eb2835..4b9769e23c83 100644
--- a/fs/xfs/libxfs/xfs_inode_buf.c
+++ b/fs/xfs/libxfs/xfs_inode_buf.c
@@ -22,6 +22,7 @@
 #include "xfs_log_format.h"
 #include "xfs_trans_resv.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_inode.h"
 #include "xfs_error.h"
 #include "xfs_cksum.h"
diff --git a/fs/xfs/libxfs/xfs_log_format.h b/fs/xfs/libxfs/xfs_log_format.h
index e8f49c029ff0..a6eed43fa7cd 100644
--- a/fs/xfs/libxfs/xfs_log_format.h
+++ b/fs/xfs/libxfs/xfs_log_format.h
@@ -110,7 +110,9 @@ static inline uint xlog_get_cycle(char *ptr)
 #define XLOG_REG_TYPE_COMMIT            18
 #define XLOG_REG_TYPE_TRANSHDR          19
 #define XLOG_REG_TYPE_ICREATE           20
-#define XLOG_REG_TYPE_MAX               20
+#define XLOG_REG_TYPE_RUI_FORMAT        21
+#define XLOG_REG_TYPE_RUD_FORMAT        22
+#define XLOG_REG_TYPE_MAX               22
 
 /*
  * Flags to log operation header
@@ -227,6 +229,8 @@ typedef struct xfs_trans_header {
 #define XFS_LI_DQUOT            0x123d
 #define XFS_LI_QUOTAOFF         0x123e
 #define XFS_LI_ICREATE          0x123f
+#define XFS_LI_RUI              0x1240  /* rmap update intent */
+#define XFS_LI_RUD              0x1241
 
 #define XFS_LI_TYPE_DESC \
         { XFS_LI_EFI,           "XFS_LI_EFI" }, \
@@ -236,7 +240,9 @@ typedef struct xfs_trans_header {
         { XFS_LI_BUF,           "XFS_LI_BUF" }, \
         { XFS_LI_DQUOT,         "XFS_LI_DQUOT" }, \
         { XFS_LI_QUOTAOFF,      "XFS_LI_QUOTAOFF" }, \
-        { XFS_LI_ICREATE,       "XFS_LI_ICREATE" }
+        { XFS_LI_ICREATE,       "XFS_LI_ICREATE" }, \
+        { XFS_LI_RUI,           "XFS_LI_RUI" }, \
+        { XFS_LI_RUD,           "XFS_LI_RUD" }
 
 /*
  * Inode Log Item Format definitions.
@@ -604,6 +610,59 @@ typedef struct xfs_efd_log_format_64 {
 } xfs_efd_log_format_64_t;
 
 /*
+ * RUI/RUD (reverse mapping) log format definitions
+ */
+struct xfs_map_extent {
+        __uint64_t              me_owner;
+        __uint64_t              me_startblock;
+        __uint64_t              me_startoff;
+        __uint32_t              me_len;
+        __uint32_t              me_flags;
+};
+
+/* rmap me_flags: upper bits are flags, lower byte is type code */
+#define XFS_RMAP_EXTENT_MAP             1
+#define XFS_RMAP_EXTENT_UNMAP           3
+#define XFS_RMAP_EXTENT_CONVERT         5
+#define XFS_RMAP_EXTENT_ALLOC           7
+#define XFS_RMAP_EXTENT_FREE            8
+#define XFS_RMAP_EXTENT_TYPE_MASK       0xFF
+
+#define XFS_RMAP_EXTENT_ATTR_FORK       (1U << 31)
+#define XFS_RMAP_EXTENT_BMBT_BLOCK      (1U << 30)
+#define XFS_RMAP_EXTENT_UNWRITTEN       (1U << 29)
+
+#define XFS_RMAP_EXTENT_FLAGS           (XFS_RMAP_EXTENT_TYPE_MASK | \
+                                         XFS_RMAP_EXTENT_ATTR_FORK | \
+                                         XFS_RMAP_EXTENT_BMBT_BLOCK | \
+                                         XFS_RMAP_EXTENT_UNWRITTEN)
+
+/*
+ * This is the structure used to lay out an rui log item in the
+ * log.  The rui_extents field is a variable size array whose
+ * size is given by rui_nextents.
+ */
+struct xfs_rui_log_format {
+        __uint16_t              rui_type;       /* rui log item type */
+        __uint16_t              rui_size;       /* size of this item */
+        __uint32_t              rui_nextents;   /* # extents to free */
+        __uint64_t              rui_id;         /* rui identifier */
+        struct xfs_map_extent   rui_extents[1]; /* array of extents to rmap */
+};
+
+/*
+ * This is the structure used to lay out an rud log item in the
+ * log.  The rud_extents array is a variable size array whose
+ * size is given by rud_nextents;
+ */
+struct xfs_rud_log_format {
+        __uint16_t              rud_type;       /* rud log item type */
+        __uint16_t              rud_size;       /* size of this item */
+        __uint32_t              __pad;
+        __uint64_t              rud_rui_id;     /* id of corresponding rui */
+};
+
+/*
  * Dquot Log format definitions.
  *
  * The first two fields must be the type and size fitting into
diff --git a/fs/xfs/libxfs/xfs_rmap.c b/fs/xfs/libxfs/xfs_rmap.c
new file mode 100644
index 000000000000..73d05407d663
--- /dev/null
+++ b/fs/xfs/libxfs/xfs_rmap.c
@@ -0,0 +1,1399 @@
+/*
+ * Copyright (c) 2014 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_bit.h"
+#include "xfs_sb.h"
+#include "xfs_mount.h"
+#include "xfs_defer.h"
+#include "xfs_da_format.h"
+#include "xfs_da_btree.h"
+#include "xfs_btree.h"
+#include "xfs_trans.h"
+#include "xfs_alloc.h"
+#include "xfs_rmap.h"
+#include "xfs_rmap_btree.h"
+#include "xfs_trans_space.h"
+#include "xfs_trace.h"
+#include "xfs_error.h"
+#include "xfs_extent_busy.h"
+#include "xfs_bmap.h"
+#include "xfs_inode.h"
+
+/*
+ * Lookup the first record less than or equal to [bno, len, owner, offset]
+ * in the btree given by cur.
+ */
+int
+xfs_rmap_lookup_le(
+        struct xfs_btree_cur    *cur,
+        xfs_agblock_t           bno,
+        xfs_extlen_t            len,
+        uint64_t                owner,
+        uint64_t                offset,
+        unsigned int            flags,
+        int                     *stat)
+{
+        cur->bc_rec.r.rm_startblock = bno;
+        cur->bc_rec.r.rm_blockcount = len;
+        cur->bc_rec.r.rm_owner = owner;
+        cur->bc_rec.r.rm_offset = offset;
+        cur->bc_rec.r.rm_flags = flags;
+        return xfs_btree_lookup(cur, XFS_LOOKUP_LE, stat);
+}
+
+/*
+ * Lookup the record exactly matching [bno, len, owner, offset]
+ * in the btree given by cur.
+ */
+int
+xfs_rmap_lookup_eq(
+        struct xfs_btree_cur    *cur,
+        xfs_agblock_t           bno,
+        xfs_extlen_t            len,
+        uint64_t                owner,
+        uint64_t                offset,
+        unsigned int            flags,
+        int                     *stat)
+{
+        cur->bc_rec.r.rm_startblock = bno;
+        cur->bc_rec.r.rm_blockcount = len;
+        cur->bc_rec.r.rm_owner = owner;
+        cur->bc_rec.r.rm_offset = offset;
+        cur->bc_rec.r.rm_flags = flags;
+        return xfs_btree_lookup(cur, XFS_LOOKUP_EQ, stat);
+}
+
+/*
+ * Update the record referred to by cur to the value given
+ * by [bno, len, owner, offset].
+ * This either works (return 0) or gets an EFSCORRUPTED error.
+ */
+STATIC int
+xfs_rmap_update(
+        struct xfs_btree_cur    *cur,
+        struct xfs_rmap_irec    *irec)
+{
+        union xfs_btree_rec     rec;
+        int                     error;
+
+        trace_xfs_rmap_update(cur->bc_mp, cur->bc_private.a.agno,
+                        irec->rm_startblock, irec->rm_blockcount,
+                        irec->rm_owner, irec->rm_offset, irec->rm_flags);
+
+        rec.rmap.rm_startblock = cpu_to_be32(irec->rm_startblock);
+        rec.rmap.rm_blockcount = cpu_to_be32(irec->rm_blockcount);
+        rec.rmap.rm_owner = cpu_to_be64(irec->rm_owner);
+        rec.rmap.rm_offset = cpu_to_be64(
+                        xfs_rmap_irec_offset_pack(irec));
+        error = xfs_btree_update(cur, &rec);
+        if (error)
+                trace_xfs_rmap_update_error(cur->bc_mp,
+                                cur->bc_private.a.agno, error, _RET_IP_);
+        return error;
+}
+
+int
+xfs_rmap_insert(
+        struct xfs_btree_cur    *rcur,
+        xfs_agblock_t           agbno,
+        xfs_extlen_t            len,
+        uint64_t                owner,
+        uint64_t                offset,
+        unsigned int            flags)
+{
+        int                     i;
+        int                     error;
+
+        trace_xfs_rmap_insert(rcur->bc_mp, rcur->bc_private.a.agno, agbno,
+                        len, owner, offset, flags);
+
+        error = xfs_rmap_lookup_eq(rcur, agbno, len, owner, offset, flags, &i);
+        if (error)
+                goto done;
+        XFS_WANT_CORRUPTED_GOTO(rcur->bc_mp, i == 0, done);
+
+        rcur->bc_rec.r.rm_startblock = agbno;
+        rcur->bc_rec.r.rm_blockcount = len;
+        rcur->bc_rec.r.rm_owner = owner;
+        rcur->bc_rec.r.rm_offset = offset;
+        rcur->bc_rec.r.rm_flags = flags;
+        error = xfs_btree_insert(rcur, &i);
+        if (error)
+                goto done;
+        XFS_WANT_CORRUPTED_GOTO(rcur->bc_mp, i == 1, done);
+done:
+        if (error)
+                trace_xfs_rmap_insert_error(rcur->bc_mp,
+                                rcur->bc_private.a.agno, error, _RET_IP_);
+        return error;
+}
+
+static int
+xfs_rmap_btrec_to_irec(
+        union xfs_btree_rec     *rec,
+        struct xfs_rmap_irec    *irec)
+{
+        irec->rm_flags = 0;
+        irec->rm_startblock = be32_to_cpu(rec->rmap.rm_startblock);
+        irec->rm_blockcount = be32_to_cpu(rec->rmap.rm_blockcount);
+        irec->rm_owner = be64_to_cpu(rec->rmap.rm_owner);
+        return xfs_rmap_irec_offset_unpack(be64_to_cpu(rec->rmap.rm_offset),
+                        irec);
+}
+
+/*
+ * Get the data from the pointed-to record.
+ */
+int
+xfs_rmap_get_rec(
+        struct xfs_btree_cur    *cur,
+        struct xfs_rmap_irec    *irec,
+        int                     *stat)
+{
+        union xfs_btree_rec     *rec;
+        int                     error;
+
+        error = xfs_btree_get_rec(cur, &rec, stat);
+        if (error || !*stat)
+                return error;
+
+        return xfs_rmap_btrec_to_irec(rec, irec);
+}
+
+/*
+ * Find the extent in the rmap btree and remove it.
+ *
+ * The record we find should always be an exact match for the extent that we're
+ * looking for, since we insert them into the btree without modification.
+ *
+ * Special Case #1: when growing the filesystem, we "free" an extent when
+ * growing the last AG. This extent is new space and so it is not tracked as
+ * used space in the btree. The growfs code will pass in an owner of
+ * XFS_RMAP_OWN_NULL to indicate that it expected that there is no owner of this
+ * extent. We verify that - the extent lookup result in a record that does not
+ * overlap.
+ *
+ * Special Case #2: EFIs do not record the owner of the extent, so when
+ * recovering EFIs from the log we pass in XFS_RMAP_OWN_UNKNOWN to tell the rmap
+ * btree to ignore the owner (i.e. wildcard match) so we don't trigger
+ * corruption checks during log recovery.
+ */
+STATIC int
+xfs_rmap_unmap(
+        struct xfs_btree_cur    *cur,
+        xfs_agblock_t           bno,
+        xfs_extlen_t            len,
+        bool                    unwritten,
+        struct xfs_owner_info   *oinfo)
+{
+        struct xfs_mount        *mp = cur->bc_mp;
+        struct xfs_rmap_irec    ltrec;
+        uint64_t                ltoff;
+        int                     error = 0;
+        int                     i;
+        uint64_t                owner;
+        uint64_t                offset;
+        unsigned int            flags;
+        bool                    ignore_off;
+
+        xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
+        ignore_off = XFS_RMAP_NON_INODE_OWNER(owner) ||
+                        (flags & XFS_RMAP_BMBT_BLOCK);
+        if (unwritten)
+                flags |= XFS_RMAP_UNWRITTEN;
+        trace_xfs_rmap_unmap(mp, cur->bc_private.a.agno, bno, len,
+                        unwritten, oinfo);
+
+        /*
+         * We should always have a left record because there's a static record
+         * for the AG headers at rm_startblock == 0 created by mkfs/growfs that
+         * will not ever be removed from the tree.
+         */
+        error = xfs_rmap_lookup_le(cur, bno, len, owner, offset, flags, &i);
+        if (error)
+                goto out_error;
+        XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
+
+        error = xfs_rmap_get_rec(cur, &ltrec, &i);
+        if (error)
+                goto out_error;
+        XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
+        trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
+                        cur->bc_private.a.agno, ltrec.rm_startblock,
+                        ltrec.rm_blockcount, ltrec.rm_owner,
+                        ltrec.rm_offset, ltrec.rm_flags);
+        ltoff = ltrec.rm_offset;
+
+        /*
+         * For growfs, the incoming extent must be beyond the left record we
+         * just found as it is new space and won't be used by anyone. This is
+         * just a corruption check as we don't actually do anything with this
+         * extent.  Note that we need to use >= instead of > because it might
+         * be the case that the "left" extent goes all the way to EOFS.
+         */
+        if (owner == XFS_RMAP_OWN_NULL) {
+                XFS_WANT_CORRUPTED_GOTO(mp, bno >= ltrec.rm_startblock +
+                                                ltrec.rm_blockcount, out_error);
+                goto out_done;
+        }
+
+        /* Make sure the unwritten flag matches. */
+        XFS_WANT_CORRUPTED_GOTO(mp, (flags & XFS_RMAP_UNWRITTEN) ==
+                        (ltrec.rm_flags & XFS_RMAP_UNWRITTEN), out_error);
+
+        /* Make sure the extent we found covers the entire freeing range. */
+        XFS_WANT_CORRUPTED_GOTO(mp, ltrec.rm_startblock <= bno &&
+                ltrec.rm_startblock + ltrec.rm_blockcount >=
+                bno + len, out_error);
+
+        /* Make sure the owner matches what we expect to find in the tree. */
+        XFS_WANT_CORRUPTED_GOTO(mp, owner == ltrec.rm_owner ||
+                                    XFS_RMAP_NON_INODE_OWNER(owner), out_error);
+
+        /* Check the offset, if necessary. */
+        if (!XFS_RMAP_NON_INODE_OWNER(owner)) {
+                if (flags & XFS_RMAP_BMBT_BLOCK) {
+                        XFS_WANT_CORRUPTED_GOTO(mp,
+                                        ltrec.rm_flags & XFS_RMAP_BMBT_BLOCK,
+                                        out_error);
+                } else {
+                        XFS_WANT_CORRUPTED_GOTO(mp,
+                                        ltrec.rm_offset <= offset, out_error);
+                        XFS_WANT_CORRUPTED_GOTO(mp,
+                                        ltoff + ltrec.rm_blockcount >= offset + len,
+                                        out_error);
+                }
+        }
+
+        if (ltrec.rm_startblock == bno && ltrec.rm_blockcount == len) {
+                /* exact match, simply remove the record from rmap tree */
+                trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
+                                ltrec.rm_startblock, ltrec.rm_blockcount,
+                                ltrec.rm_owner, ltrec.rm_offset,
+                                ltrec.rm_flags);
+                error = xfs_btree_delete(cur, &i);
+                if (error)
+                        goto out_error;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
+        } else if (ltrec.rm_startblock == bno) {
+                /*
+                 * overlap left hand side of extent: move the start, trim the
+                 * length and update the current record.
+                 *
+                 *       ltbno                ltlen
+                 * Orig:    |oooooooooooooooooooo|
+                 * Freeing: |fffffffff|
+                 * Result:            |rrrrrrrrrr|
+                 *         bno       len
+                 */
+                ltrec.rm_startblock += len;
+                ltrec.rm_blockcount -= len;
+                if (!ignore_off)
+                        ltrec.rm_offset += len;
+                error = xfs_rmap_update(cur, &ltrec);
+                if (error)
+                        goto out_error;
+        } else if (ltrec.rm_startblock + ltrec.rm_blockcount == bno + len) {
+                /*
+                 * overlap right hand side of extent: trim the length and update
+                 * the current record.
+                 *
+                 *       ltbno                ltlen
+                 * Orig:    |oooooooooooooooooooo|
+                 * Freeing:            |fffffffff|
+                 * Result:  |rrrrrrrrrr|
+                 *                    bno       len
+                 */
+                ltrec.rm_blockcount -= len;
+                error = xfs_rmap_update(cur, &ltrec);
+                if (error)
+                        goto out_error;
+        } else {
+
+                /*
+                 * overlap middle of extent: trim the length of the existing
+                 * record to the length of the new left-extent size, increment
+                 * the insertion position so we can insert a new record
+                 * containing the remaining right-extent space.
+                 *
+                 *       ltbno                ltlen
+                 * Orig:    |oooooooooooooooooooo|
+                 * Freeing:       |fffffffff|
+                 * Result:  |rrrrr|         |rrrr|
+                 *               bno       len
+                 */
+                xfs_extlen_t    orig_len = ltrec.rm_blockcount;
+
+                ltrec.rm_blockcount = bno - ltrec.rm_startblock;
+                error = xfs_rmap_update(cur, &ltrec);
+                if (error)
+                        goto out_error;
+
+                error = xfs_btree_increment(cur, 0, &i);
+                if (error)
+                        goto out_error;
+
+                cur->bc_rec.r.rm_startblock = bno + len;
+                cur->bc_rec.r.rm_blockcount = orig_len - len -
+                                                     ltrec.rm_blockcount;
+                cur->bc_rec.r.rm_owner = ltrec.rm_owner;
+                if (ignore_off)
+                        cur->bc_rec.r.rm_offset = 0;
+                else
+                        cur->bc_rec.r.rm_offset = offset + len;
+                cur->bc_rec.r.rm_flags = flags;
+                trace_xfs_rmap_insert(mp, cur->bc_private.a.agno,
+                                cur->bc_rec.r.rm_startblock,
+                                cur->bc_rec.r.rm_blockcount,
+                                cur->bc_rec.r.rm_owner,
+                                cur->bc_rec.r.rm_offset,
+                                cur->bc_rec.r.rm_flags);
+                error = xfs_btree_insert(cur, &i);
+                if (error)
+                        goto out_error;
+        }
+
+out_done:
+        trace_xfs_rmap_unmap_done(mp, cur->bc_private.a.agno, bno, len,
+                        unwritten, oinfo);
+out_error:
+        if (error)
+                trace_xfs_rmap_unmap_error(mp, cur->bc_private.a.agno,
+                                error, _RET_IP_);
+        return error;
+}
+
+/*
+ * Remove a reference to an extent in the rmap btree.
+ */
+int
+xfs_rmap_free(
+        struct xfs_trans        *tp,
+        struct xfs_buf          *agbp,
+        xfs_agnumber_t          agno,
+        xfs_agblock_t           bno,
+        xfs_extlen_t            len,
+        struct xfs_owner_info   *oinfo)
+{
+        struct xfs_mount        *mp = tp->t_mountp;
+        struct xfs_btree_cur    *cur;
+        int                     error;
+
+        if (!xfs_sb_version_hasrmapbt(&mp->m_sb))
+                return 0;
+
+        cur = xfs_rmapbt_init_cursor(mp, tp, agbp, agno);
+
+        error = xfs_rmap_unmap(cur, bno, len, false, oinfo);
+        if (error)
+                goto out_error;
+
+        xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
+        return 0;
+
+out_error:
+        xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
+        return error;
+}
+
+/*
+ * A mergeable rmap must have the same owner and the same values for
+ * the unwritten, attr_fork, and bmbt flags.  The startblock and
+ * offset are checked separately.
+ */
+static bool
+xfs_rmap_is_mergeable(
+        struct xfs_rmap_irec    *irec,
+        uint64_t                owner,
+        unsigned int            flags)
+{
+        if (irec->rm_owner == XFS_RMAP_OWN_NULL)
+                return false;
+        if (irec->rm_owner != owner)
+                return false;
+        if ((flags & XFS_RMAP_UNWRITTEN) ^
+            (irec->rm_flags & XFS_RMAP_UNWRITTEN))
+                return false;
+        if ((flags & XFS_RMAP_ATTR_FORK) ^
+            (irec->rm_flags & XFS_RMAP_ATTR_FORK))
+                return false;
+        if ((flags & XFS_RMAP_BMBT_BLOCK) ^
+            (irec->rm_flags & XFS_RMAP_BMBT_BLOCK))
+                return false;
+        return true;
+}
+
+/*
+ * When we allocate a new block, the first thing we do is add a reference to
+ * the extent in the rmap btree. This takes the form of a [agbno, length,
+ * owner, offset] record.  Flags are encoded in the high bits of the offset
+ * field.
+ */
+STATIC int
+xfs_rmap_map(
+        struct xfs_btree_cur    *cur,
+        xfs_agblock_t           bno,
+        xfs_extlen_t            len,
+        bool                    unwritten,
+        struct xfs_owner_info   *oinfo)
+{
+        struct xfs_mount        *mp = cur->bc_mp;
+        struct xfs_rmap_irec    ltrec;
+        struct xfs_rmap_irec    gtrec;
+        int                     have_gt;
+        int                     have_lt;
+        int                     error = 0;
+        int                     i;
+        uint64_t                owner;
+        uint64_t                offset;
+        unsigned int            flags = 0;
+        bool                    ignore_off;
+
+        xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
+        ASSERT(owner != 0);
+        ignore_off = XFS_RMAP_NON_INODE_OWNER(owner) ||
+                        (flags & XFS_RMAP_BMBT_BLOCK);
+        if (unwritten)
+                flags |= XFS_RMAP_UNWRITTEN;
+        trace_xfs_rmap_map(mp, cur->bc_private.a.agno, bno, len,
+                        unwritten, oinfo);
+
+        /*
+         * For the initial lookup, look for an exact match or the left-adjacent
+         * record for our insertion point. This will also give us the record for
+         * start block contiguity tests.
+         */
+        error = xfs_rmap_lookup_le(cur, bno, len, owner, offset, flags,
+                        &have_lt);
+        if (error)
+                goto out_error;
+        XFS_WANT_CORRUPTED_GOTO(mp, have_lt == 1, out_error);
+
+        error = xfs_rmap_get_rec(cur, &ltrec, &have_lt);
+        if (error)
+                goto out_error;
+        XFS_WANT_CORRUPTED_GOTO(mp, have_lt == 1, out_error);
+        trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
+                        cur->bc_private.a.agno, ltrec.rm_startblock,
+                        ltrec.rm_blockcount, ltrec.rm_owner,
+                        ltrec.rm_offset, ltrec.rm_flags);
+
+        if (!xfs_rmap_is_mergeable(&ltrec, owner, flags))
+                have_lt = 0;
+
+        XFS_WANT_CORRUPTED_GOTO(mp,
+                have_lt == 0 ||
+                ltrec.rm_startblock + ltrec.rm_blockcount <= bno, out_error);
+
+        /*
+         * Increment the cursor to see if we have a right-adjacent record to our
+         * insertion point. This will give us the record for end block
+         * contiguity tests.
+         */
+        error = xfs_btree_increment(cur, 0, &have_gt);
+        if (error)
+                goto out_error;
+        if (have_gt) {
+                error = xfs_rmap_get_rec(cur, &gtrec, &have_gt);
+                if (error)
+                        goto out_error;
+                XFS_WANT_CORRUPTED_GOTO(mp, have_gt == 1, out_error);
+                XFS_WANT_CORRUPTED_GOTO(mp, bno + len <= gtrec.rm_startblock,
+                                        out_error);
+                trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
+                        cur->bc_private.a.agno, gtrec.rm_startblock,
+                        gtrec.rm_blockcount, gtrec.rm_owner,
+                        gtrec.rm_offset, gtrec.rm_flags);
+                if (!xfs_rmap_is_mergeable(&gtrec, owner, flags))
+                        have_gt = 0;
+        }
+
+        /*
+         * Note: cursor currently points one record to the right of ltrec, even
+         * if there is no record in the tree to the right.
+         */
+        if (have_lt &&
+            ltrec.rm_startblock + ltrec.rm_blockcount == bno &&
+            (ignore_off || ltrec.rm_offset + ltrec.rm_blockcount == offset)) {
+                /*
+                 * left edge contiguous, merge into left record.
+                 *
+                 *       ltbno     ltlen
+                 * orig:   |ooooooooo|
+                 * adding:           |aaaaaaaaa|
+                 * result: |rrrrrrrrrrrrrrrrrrr|
+                 *                  bno       len
+                 */
+                ltrec.rm_blockcount += len;
+                if (have_gt &&
+                    bno + len == gtrec.rm_startblock &&
+                    (ignore_off || offset + len == gtrec.rm_offset) &&
+                    (unsigned long)ltrec.rm_blockcount + len +
+                                gtrec.rm_blockcount <= XFS_RMAP_LEN_MAX) {
+                        /*
+                         * right edge also contiguous, delete right record
+                         * and merge into left record.
+                         *
+                         *       ltbno     ltlen    gtbno     gtlen
+                         * orig:   |ooooooooo|         |ooooooooo|
+                         * adding:           |aaaaaaaaa|
+                         * result: |rrrrrrrrrrrrrrrrrrrrrrrrrrrrr|
+                         */
+                        ltrec.rm_blockcount += gtrec.rm_blockcount;
+                        trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
+                                        gtrec.rm_startblock,
+                                        gtrec.rm_blockcount,
+                                        gtrec.rm_owner,
+                                        gtrec.rm_offset,
+                                        gtrec.rm_flags);
+                        error = xfs_btree_delete(cur, &i);
+                        if (error)
+                                goto out_error;
+                        XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
+                }
+
+                /* point the cursor back to the left record and update */
+                error = xfs_btree_decrement(cur, 0, &have_gt);
+                if (error)
+                        goto out_error;
+                error = xfs_rmap_update(cur, &ltrec);
+                if (error)
+                        goto out_error;
+        } else if (have_gt &&
+                   bno + len == gtrec.rm_startblock &&
+                   (ignore_off || offset + len == gtrec.rm_offset)) {
+                /*
+                 * right edge contiguous, merge into right record.
+                 *
+                 *                 gtbno     gtlen
+                 * Orig:             |ooooooooo|
+                 * adding: |aaaaaaaaa|
+                 * Result: |rrrrrrrrrrrrrrrrrrr|
+                 *        bno       len
+                 */
+                gtrec.rm_startblock = bno;
+                gtrec.rm_blockcount += len;
+                if (!ignore_off)
+                        gtrec.rm_offset = offset;
+                error = xfs_rmap_update(cur, &gtrec);
+                if (error)
+                        goto out_error;
+        } else {
+                /*
+                 * no contiguous edge with identical owner, insert
+                 * new record at current cursor position.
+                 */
+                cur->bc_rec.r.rm_startblock = bno;
+                cur->bc_rec.r.rm_blockcount = len;
+                cur->bc_rec.r.rm_owner = owner;
+                cur->bc_rec.r.rm_offset = offset;
+                cur->bc_rec.r.rm_flags = flags;
+                trace_xfs_rmap_insert(mp, cur->bc_private.a.agno, bno, len,
+                        owner, offset, flags);
+                error = xfs_btree_insert(cur, &i);
+                if (error)
+                        goto out_error;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, out_error);
+        }
+
+        trace_xfs_rmap_map_done(mp, cur->bc_private.a.agno, bno, len,
+                        unwritten, oinfo);
+out_error:
+        if (error)
+                trace_xfs_rmap_map_error(mp, cur->bc_private.a.agno,
+                                error, _RET_IP_);
+        return error;
+}
+
+/*
+ * Add a reference to an extent in the rmap btree.
+ */
+int
+xfs_rmap_alloc(
+        struct xfs_trans        *tp,
+        struct xfs_buf          *agbp,
+        xfs_agnumber_t          agno,
+        xfs_agblock_t           bno,
+        xfs_extlen_t            len,
+        struct xfs_owner_info   *oinfo)
+{
+        struct xfs_mount        *mp = tp->t_mountp;
+        struct xfs_btree_cur    *cur;
+        int                     error;
+
+        if (!xfs_sb_version_hasrmapbt(&mp->m_sb))
+                return 0;
+
+        cur = xfs_rmapbt_init_cursor(mp, tp, agbp, agno);
+        error = xfs_rmap_map(cur, bno, len, false, oinfo);
+        if (error)
+                goto out_error;
+
+        xfs_btree_del_cursor(cur, XFS_BTREE_NOERROR);
+        return 0;
+
+out_error:
+        xfs_btree_del_cursor(cur, XFS_BTREE_ERROR);
+        return error;
+}
+
+#define RMAP_LEFT_CONTIG        (1 << 0)
+#define RMAP_RIGHT_CONTIG       (1 << 1)
+#define RMAP_LEFT_FILLING       (1 << 2)
+#define RMAP_RIGHT_FILLING      (1 << 3)
+#define RMAP_LEFT_VALID         (1 << 6)
+#define RMAP_RIGHT_VALID        (1 << 7)
+
+#define LEFT            r[0]
+#define RIGHT           r[1]
+#define PREV            r[2]
+#define NEW             r[3]
+
+/*
+ * Convert an unwritten extent to a real extent or vice versa.
+ * Does not handle overlapping extents.
+ */
+STATIC int
+xfs_rmap_convert(
+        struct xfs_btree_cur    *cur,
+        xfs_agblock_t           bno,
+        xfs_extlen_t            len,
+        bool                    unwritten,
+        struct xfs_owner_info   *oinfo)
+{
+        struct xfs_mount        *mp = cur->bc_mp;
+        struct xfs_rmap_irec    r[4];   /* neighbor extent entries */
+                                        /* left is 0, right is 1, prev is 2 */
+                                        /* new is 3 */
+        uint64_t                owner;
+        uint64_t                offset;
+        uint64_t                new_endoff;
+        unsigned int            oldext;
+        unsigned int            newext;
+        unsigned int            flags = 0;
+        int                     i;
+        int                     state = 0;
+        int                     error;
+
+        xfs_owner_info_unpack(oinfo, &owner, &offset, &flags);
+        ASSERT(!(XFS_RMAP_NON_INODE_OWNER(owner) ||
+                        (flags & (XFS_RMAP_ATTR_FORK | XFS_RMAP_BMBT_BLOCK))));
+        oldext = unwritten ? XFS_RMAP_UNWRITTEN : 0;
+        new_endoff = offset + len;
+        trace_xfs_rmap_convert(mp, cur->bc_private.a.agno, bno, len,
+                        unwritten, oinfo);
+
+        /*
+         * For the initial lookup, look for an exact match or the left-adjacent
+         * record for our insertion point. This will also give us the record for
+         * start block contiguity tests.
+         */
+        error = xfs_rmap_lookup_le(cur, bno, len, owner, offset, oldext, &i);
+        if (error)
+                goto done;
+        XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+
+        error = xfs_rmap_get_rec(cur, &PREV, &i);
+        if (error)
+                goto done;
+        XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+        trace_xfs_rmap_lookup_le_range_result(cur->bc_mp,
+                        cur->bc_private.a.agno, PREV.rm_startblock,
+                        PREV.rm_blockcount, PREV.rm_owner,
+                        PREV.rm_offset, PREV.rm_flags);
+
+        ASSERT(PREV.rm_offset <= offset);
+        ASSERT(PREV.rm_offset + PREV.rm_blockcount >= new_endoff);
+        ASSERT((PREV.rm_flags & XFS_RMAP_UNWRITTEN) == oldext);
+        newext = ~oldext & XFS_RMAP_UNWRITTEN;
+
+        /*
+         * Set flags determining what part of the previous oldext allocation
+         * extent is being replaced by a newext allocation.
+         */
+        if (PREV.rm_offset == offset)
+                state |= RMAP_LEFT_FILLING;
+        if (PREV.rm_offset + PREV.rm_blockcount == new_endoff)
+                state |= RMAP_RIGHT_FILLING;
+
+        /*
+         * Decrement the cursor to see if we have a left-adjacent record to our
+         * insertion point. This will give us the record for end block
+         * contiguity tests.
+         */
+        error = xfs_btree_decrement(cur, 0, &i);
+        if (error)
+                goto done;
+        if (i) {
+                state |= RMAP_LEFT_VALID;
+                error = xfs_rmap_get_rec(cur, &LEFT, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+                XFS_WANT_CORRUPTED_GOTO(mp,
+                                LEFT.rm_startblock + LEFT.rm_blockcount <= bno,
+                                done);
+                trace_xfs_rmap_find_left_neighbor_result(cur->bc_mp,
+                                cur->bc_private.a.agno, LEFT.rm_startblock,
+                                LEFT.rm_blockcount, LEFT.rm_owner,
+                                LEFT.rm_offset, LEFT.rm_flags);
+                if (LEFT.rm_startblock + LEFT.rm_blockcount == bno &&
+                    LEFT.rm_offset + LEFT.rm_blockcount == offset &&
+                    xfs_rmap_is_mergeable(&LEFT, owner, newext))
+                        state |= RMAP_LEFT_CONTIG;
+        }
+
+        /*
+         * Increment the cursor to see if we have a right-adjacent record to our
+         * insertion point. This will give us the record for end block
+         * contiguity tests.
+         */
+        error = xfs_btree_increment(cur, 0, &i);
+        if (error)
+                goto done;
+        XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+        error = xfs_btree_increment(cur, 0, &i);
+        if (error)
+                goto done;
+        if (i) {
+                state |= RMAP_RIGHT_VALID;
+                error = xfs_rmap_get_rec(cur, &RIGHT, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+                XFS_WANT_CORRUPTED_GOTO(mp, bno + len <= RIGHT.rm_startblock,
+                                        done);
+                trace_xfs_rmap_find_right_neighbor_result(cur->bc_mp,
+                                cur->bc_private.a.agno, RIGHT.rm_startblock,
+                                RIGHT.rm_blockcount, RIGHT.rm_owner,
+                                RIGHT.rm_offset, RIGHT.rm_flags);
+                if (bno + len == RIGHT.rm_startblock &&
+                    offset + len == RIGHT.rm_offset &&
+                    xfs_rmap_is_mergeable(&RIGHT, owner, newext))
+                        state |= RMAP_RIGHT_CONTIG;
+        }
+
+        /* check that left + prev + right is not too long */
+        if ((state & (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
+                         RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG)) ==
+            (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
+             RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG) &&
+            (unsigned long)LEFT.rm_blockcount + len +
+             RIGHT.rm_blockcount > XFS_RMAP_LEN_MAX)
+                state &= ~RMAP_RIGHT_CONTIG;
+
+        trace_xfs_rmap_convert_state(mp, cur->bc_private.a.agno, state,
+                        _RET_IP_);
+
+        /* reset the cursor back to PREV */
+        error = xfs_rmap_lookup_le(cur, bno, len, owner, offset, oldext, &i);
+        if (error)
+                goto done;
+        XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+
+        /*
+         * Switch out based on the FILLING and CONTIG state bits.
+         */
+        switch (state & (RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
+                         RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG)) {
+        case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG |
+             RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:
+                /*
+                 * Setting all of a previous oldext extent to newext.
+                 * The left and right neighbors are both contiguous with new.
+                 */
+                error = xfs_btree_increment(cur, 0, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+                trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
+                                RIGHT.rm_startblock, RIGHT.rm_blockcount,
+                                RIGHT.rm_owner, RIGHT.rm_offset,
+                                RIGHT.rm_flags);
+                error = xfs_btree_delete(cur, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+                error = xfs_btree_decrement(cur, 0, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+                trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
+                                PREV.rm_startblock, PREV.rm_blockcount,
+                                PREV.rm_owner, PREV.rm_offset,
+                                PREV.rm_flags);
+                error = xfs_btree_delete(cur, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+                error = xfs_btree_decrement(cur, 0, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+                NEW = LEFT;
+                NEW.rm_blockcount += PREV.rm_blockcount + RIGHT.rm_blockcount;
+                error = xfs_rmap_update(cur, &NEW);
+                if (error)
+                        goto done;
+                break;
+
+        case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG:
+                /*
+                 * Setting all of a previous oldext extent to newext.
+                 * The left neighbor is contiguous, the right is not.
+                 */
+                trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
+                                PREV.rm_startblock, PREV.rm_blockcount,
+                                PREV.rm_owner, PREV.rm_offset,
+                                PREV.rm_flags);
+                error = xfs_btree_delete(cur, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+                error = xfs_btree_decrement(cur, 0, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+                NEW = LEFT;
+                NEW.rm_blockcount += PREV.rm_blockcount;
+                error = xfs_rmap_update(cur, &NEW);
+                if (error)
+                        goto done;
+                break;
+
+        case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:
+                /*
+                 * Setting all of a previous oldext extent to newext.
+                 * The right neighbor is contiguous, the left is not.
+                 */
+                error = xfs_btree_increment(cur, 0, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+                trace_xfs_rmap_delete(mp, cur->bc_private.a.agno,
+                                RIGHT.rm_startblock, RIGHT.rm_blockcount,
+                                RIGHT.rm_owner, RIGHT.rm_offset,
+                                RIGHT.rm_flags);
+                error = xfs_btree_delete(cur, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+                error = xfs_btree_decrement(cur, 0, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+                NEW = PREV;
+                NEW.rm_blockcount = len + RIGHT.rm_blockcount;
+                NEW.rm_flags = newext;
+                error = xfs_rmap_update(cur, &NEW);
+                if (error)
+                        goto done;
+                break;
+
+        case RMAP_LEFT_FILLING | RMAP_RIGHT_FILLING:
+                /*
+                 * Setting all of a previous oldext extent to newext.
+                 * Neither the left nor right neighbors are contiguous with
+                 * the new one.
+                 */
+                NEW = PREV;
+                NEW.rm_flags = newext;
+                error = xfs_rmap_update(cur, &NEW);
+                if (error)
+                        goto done;
+                break;
+
+        case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG:
+                /*
+                 * Setting the first part of a previous oldext extent to newext.
+                 * The left neighbor is contiguous.
+                 */
+                NEW = PREV;
+                NEW.rm_offset += len;
+                NEW.rm_startblock += len;
+                NEW.rm_blockcount -= len;
+                error = xfs_rmap_update(cur, &NEW);
+                if (error)
+                        goto done;
+                error = xfs_btree_decrement(cur, 0, &i);
+                if (error)
+                        goto done;
+                NEW = LEFT;
+                NEW.rm_blockcount += len;
+                error = xfs_rmap_update(cur, &NEW);
+                if (error)
+                        goto done;
+                break;
+
+        case RMAP_LEFT_FILLING:
+                /*
+                 * Setting the first part of a previous oldext extent to newext.
+                 * The left neighbor is not contiguous.
+                 */
+                NEW = PREV;
+                NEW.rm_startblock += len;
+                NEW.rm_offset += len;
+                NEW.rm_blockcount -= len;
+                error = xfs_rmap_update(cur, &NEW);
+                if (error)
+                        goto done;
+                NEW.rm_startblock = bno;
+                NEW.rm_owner = owner;
+                NEW.rm_offset = offset;
+                NEW.rm_blockcount = len;
+                NEW.rm_flags = newext;
+                cur->bc_rec.r = NEW;
+                trace_xfs_rmap_insert(mp, cur->bc_private.a.agno, bno,
+                                len, owner, offset, newext);
+                error = xfs_btree_insert(cur, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+                break;
+
+        case RMAP_RIGHT_FILLING | RMAP_RIGHT_CONTIG:
+                /*
+                 * Setting the last part of a previous oldext extent to newext.
+                 * The right neighbor is contiguous with the new allocation.
+                 */
+                NEW = PREV;
+                NEW.rm_blockcount -= len;
+                error = xfs_rmap_update(cur, &NEW);
+                if (error)
+                        goto done;
+                error = xfs_btree_increment(cur, 0, &i);
+                if (error)
+                        goto done;
+                NEW = RIGHT;
+                NEW.rm_offset = offset;
+                NEW.rm_startblock = bno;
+                NEW.rm_blockcount += len;
+                error = xfs_rmap_update(cur, &NEW);
+                if (error)
+                        goto done;
+                break;
+
+        case RMAP_RIGHT_FILLING:
+                /*
+                 * Setting the last part of a previous oldext extent to newext.
+                 * The right neighbor is not contiguous.
+                 */
+                NEW = PREV;
+                NEW.rm_blockcount -= len;
+                error = xfs_rmap_update(cur, &NEW);
+                if (error)
+                        goto done;
+                error = xfs_rmap_lookup_eq(cur, bno, len, owner, offset,
+                                oldext, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
+                NEW.rm_startblock = bno;
+                NEW.rm_owner = owner;
+                NEW.rm_offset = offset;
+                NEW.rm_blockcount = len;
+                NEW.rm_flags = newext;
+                cur->bc_rec.r = NEW;
+                trace_xfs_rmap_insert(mp, cur->bc_private.a.agno, bno,
+                                len, owner, offset, newext);
+                error = xfs_btree_insert(cur, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+                break;
+
+        case 0:
+                /*
+                 * Setting the middle part of a previous oldext extent to
+                 * newext.  Contiguity is impossible here.
+                 * One extent becomes three extents.
+                 */
+                /* new right extent - oldext */
+                NEW.rm_startblock = bno + len;
+                NEW.rm_owner = owner;
+                NEW.rm_offset = new_endoff;
+                NEW.rm_blockcount = PREV.rm_offset + PREV.rm_blockcount -
+                                new_endoff;
+                NEW.rm_flags = PREV.rm_flags;
+                error = xfs_rmap_update(cur, &NEW);
+                if (error)
+                        goto done;
+                /* new left extent - oldext */
+                NEW = PREV;
+                NEW.rm_blockcount = offset - PREV.rm_offset;
+                cur->bc_rec.r = NEW;
+                trace_xfs_rmap_insert(mp, cur->bc_private.a.agno,
+                                NEW.rm_startblock, NEW.rm_blockcount,
+                                NEW.rm_owner, NEW.rm_offset,
+                                NEW.rm_flags);
+                error = xfs_btree_insert(cur, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+                /*
+                 * Reset the cursor to the position of the new extent
+                 * we are about to insert as we can't trust it after
+                 * the previous insert.
+                 */
+                error = xfs_rmap_lookup_eq(cur, bno, len, owner, offset,
+                                oldext, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 0, done);
+                /* new middle extent - newext */
+                cur->bc_rec.r.rm_flags &= ~XFS_RMAP_UNWRITTEN;
+                cur->bc_rec.r.rm_flags |= newext;
+                trace_xfs_rmap_insert(mp, cur->bc_private.a.agno, bno, len,
+                                owner, offset, newext);
+                error = xfs_btree_insert(cur, &i);
+                if (error)
+                        goto done;
+                XFS_WANT_CORRUPTED_GOTO(mp, i == 1, done);
+                break;
+
+        case RMAP_LEFT_FILLING | RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:
+        case RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:
+        case RMAP_LEFT_FILLING | RMAP_RIGHT_CONTIG:
+        case RMAP_RIGHT_FILLING | RMAP_LEFT_CONTIG:
+        case RMAP_LEFT_CONTIG | RMAP_RIGHT_CONTIG:
+        case RMAP_LEFT_CONTIG:
+        case RMAP_RIGHT_CONTIG:
+                /*
+                 * These cases are all impossible.
+                 */
+                ASSERT(0);
+        }
+
+        trace_xfs_rmap_convert_done(mp, cur->bc_private.a.agno, bno, len,
+                        unwritten, oinfo);
+done:
+        if (error)
+                trace_xfs_rmap_convert_error(cur->bc_mp,
+                                cur->bc_private.a.agno, error, _RET_IP_);
+        return error;
+}
+
+#undef  NEW
+#undef  LEFT
+#undef  RIGHT
+#undef  PREV
+
+struct xfs_rmap_query_range_info {
+        xfs_rmap_query_range_fn fn;
+        void                            *priv;
+};
+
+/* Format btree record and pass to our callback. */
+STATIC int
+xfs_rmap_query_range_helper(
+        struct xfs_btree_cur    *cur,
+        union xfs_btree_rec     *rec,
+        void                    *priv)
+{
+        struct xfs_rmap_query_range_info        *query = priv;
+        struct xfs_rmap_irec                    irec;
+        int                                     error;
+
+        error = xfs_rmap_btrec_to_irec(rec, &irec);
+        if (error)
+                return error;
+        return query->fn(cur, &irec, query->priv);
+}
+
+/* Find all rmaps between two keys. */
+int
+xfs_rmap_query_range(
+        struct xfs_btree_cur            *cur,
+        struct xfs_rmap_irec            *low_rec,
+        struct xfs_rmap_irec            *high_rec,
+        xfs_rmap_query_range_fn fn,
+        void                            *priv)
+{
+        union xfs_btree_irec            low_brec;
+        union xfs_btree_irec            high_brec;
+        struct xfs_rmap_query_range_info        query;
+
+        low_brec.r = *low_rec;
+        high_brec.r = *high_rec;
+        query.priv = priv;
+        query.fn = fn;
+        return xfs_btree_query_range(cur, &low_brec, &high_brec,
+                        xfs_rmap_query_range_helper, &query);
+}
+
+/* Clean up after calling xfs_rmap_finish_one. */
+void
+xfs_rmap_finish_one_cleanup(
+        struct xfs_trans        *tp,
+        struct xfs_btree_cur    *rcur,
+        int                     error)
+{
+        struct xfs_buf          *agbp;
+
+        if (rcur == NULL)
+                return;
+        agbp = rcur->bc_private.a.agbp;
+        xfs_btree_del_cursor(rcur, error ? XFS_BTREE_ERROR : XFS_BTREE_NOERROR);
+        if (error)
+                xfs_trans_brelse(tp, agbp);
+}
+
+/*
+ * Process one of the deferred rmap operations.  We pass back the
+ * btree cursor to maintain our lock on the rmapbt between calls.
+ * This saves time and eliminates a buffer deadlock between the
+ * superblock and the AGF because we'll always grab them in the same
+ * order.
+ */
+int
+xfs_rmap_finish_one(
+        struct xfs_trans                *tp,
+        enum xfs_rmap_intent_type       type,
+        __uint64_t                      owner,
+        int                             whichfork,
+        xfs_fileoff_t                   startoff,
+        xfs_fsblock_t                   startblock,
+        xfs_filblks_t                   blockcount,
+        xfs_exntst_t                    state,
+        struct xfs_btree_cur            **pcur)
+{
+        struct xfs_mount                *mp = tp->t_mountp;
+        struct xfs_btree_cur            *rcur;
+        struct xfs_buf                  *agbp = NULL;
+        int                             error = 0;
+        xfs_agnumber_t                  agno;
+        struct xfs_owner_info           oinfo;
+        xfs_agblock_t                   bno;
+        bool                            unwritten;
+
+        agno = XFS_FSB_TO_AGNO(mp, startblock);
+        ASSERT(agno != NULLAGNUMBER);
+        bno = XFS_FSB_TO_AGBNO(mp, startblock);
+
+        trace_xfs_rmap_deferred(mp, agno, type, bno, owner, whichfork,
+                        startoff, blockcount, state);
+
+        if (XFS_TEST_ERROR(false, mp,
+                        XFS_ERRTAG_RMAP_FINISH_ONE,
+                        XFS_RANDOM_RMAP_FINISH_ONE))
+                return -EIO;
+
+        /*
+         * If we haven't gotten a cursor or the cursor AG doesn't match
+         * the startblock, get one now.
+         */
+        rcur = *pcur;
+        if (rcur != NULL && rcur->bc_private.a.agno != agno) {
+                xfs_rmap_finish_one_cleanup(tp, rcur, 0);
+                rcur = NULL;
+                *pcur = NULL;
+        }
+        if (rcur == NULL) {
+                /*
+                 * Refresh the freelist before we start changing the
+                 * rmapbt, because a shape change could cause us to
+                 * allocate blocks.
+                 */
+                error = xfs_free_extent_fix_freelist(tp, agno, &agbp);
+                if (error)
+                        return error;
+                if (!agbp)
+                        return -EFSCORRUPTED;
+
+                rcur = xfs_rmapbt_init_cursor(mp, tp, agbp, agno);
+                if (!rcur) {
+                        error = -ENOMEM;
+                        goto out_cur;
+                }
+        }
+        *pcur = rcur;
+
+        xfs_rmap_ino_owner(&oinfo, owner, whichfork, startoff);
+        unwritten = state == XFS_EXT_UNWRITTEN;
+        bno = XFS_FSB_TO_AGBNO(rcur->bc_mp, startblock);
+
+        switch (type) {
+        case XFS_RMAP_ALLOC:
+        case XFS_RMAP_MAP:
+                error = xfs_rmap_map(rcur, bno, blockcount, unwritten, &oinfo);
+                break;
+        case XFS_RMAP_FREE:
+        case XFS_RMAP_UNMAP:
+                error = xfs_rmap_unmap(rcur, bno, blockcount, unwritten,
+                                &oinfo);
+                break;
+        case XFS_RMAP_CONVERT:
+                error = xfs_rmap_convert(rcur, bno, blockcount, !unwritten,
+                                &oinfo);
+                break;
+        default:
+                ASSERT(0);
+                error = -EFSCORRUPTED;
+        }
+        return error;
+
+out_cur:
+        xfs_trans_brelse(tp, agbp);
+
+        return error;
+}
+
+/*
+ * Don't defer an rmap if we aren't an rmap filesystem.
+ */
+static bool
+xfs_rmap_update_is_needed(
+        struct xfs_mount        *mp)
+{
+        return xfs_sb_version_hasrmapbt(&mp->m_sb);
+}
+
+/*
+ * Record a rmap intent; the list is kept sorted first by AG and then by
+ * increasing age.
+ */
+static int
+__xfs_rmap_add(
+        struct xfs_mount                *mp,
+        struct xfs_defer_ops            *dfops,
+        enum xfs_rmap_intent_type       type,
+        __uint64_t                      owner,
+        int                             whichfork,
+        struct xfs_bmbt_irec            *bmap)
+{
+        struct xfs_rmap_intent  *ri;
+
+        trace_xfs_rmap_defer(mp, XFS_FSB_TO_AGNO(mp, bmap->br_startblock),
+                        type,
+                        XFS_FSB_TO_AGBNO(mp, bmap->br_startblock),
+                        owner, whichfork,
+                        bmap->br_startoff,
+                        bmap->br_blockcount,
+                        bmap->br_state);
+
+        ri = kmem_alloc(sizeof(struct xfs_rmap_intent), KM_SLEEP | KM_NOFS);
+        INIT_LIST_HEAD(&ri->ri_list);
+        ri->ri_type = type;
+        ri->ri_owner = owner;
+        ri->ri_whichfork = whichfork;
+        ri->ri_bmap = *bmap;
+
+        xfs_defer_add(dfops, XFS_DEFER_OPS_TYPE_RMAP, &ri->ri_list);
+        return 0;
+}
+
+/* Map an extent into a file. */
+int
+xfs_rmap_map_extent(
+        struct xfs_mount        *mp,
+        struct xfs_defer_ops    *dfops,
+        struct xfs_inode        *ip,
+        int                     whichfork,
+        struct xfs_bmbt_irec    *PREV)
+{
+        if (!xfs_rmap_update_is_needed(mp))
+                return 0;
+
+        return __xfs_rmap_add(mp, dfops, XFS_RMAP_MAP, ip->i_ino,
+                        whichfork, PREV);
+}
+
+/* Unmap an extent out of a file. */
+int
+xfs_rmap_unmap_extent(
+        struct xfs_mount        *mp,
+        struct xfs_defer_ops    *dfops,
+        struct xfs_inode        *ip,
+        int                     whichfork,
+        struct xfs_bmbt_irec    *PREV)
+{
+        if (!xfs_rmap_update_is_needed(mp))
+                return 0;
+
+        return __xfs_rmap_add(mp, dfops, XFS_RMAP_UNMAP, ip->i_ino,
+                        whichfork, PREV);
+}
+
+/* Convert a data fork extent from unwritten to real or vice versa. */
+int
+xfs_rmap_convert_extent(
+        struct xfs_mount        *mp,
+        struct xfs_defer_ops    *dfops,
+        struct xfs_inode        *ip,
+        int                     whichfork,
+        struct xfs_bmbt_irec    *PREV)
+{
+        if (!xfs_rmap_update_is_needed(mp))
+                return 0;
+
+        return __xfs_rmap_add(mp, dfops, XFS_RMAP_CONVERT, ip->i_ino,
+                        whichfork, PREV);
+}
+
+/* Schedule the creation of an rmap for non-file data. */
+int
+xfs_rmap_alloc_extent(
+        struct xfs_mount        *mp,
+        struct xfs_defer_ops    *dfops,
+        xfs_agnumber_t          agno,
+        xfs_agblock_t           bno,
+        xfs_extlen_t            len,
+        __uint64_t              owner)
+{
+        struct xfs_bmbt_irec    bmap;
+
+        if (!xfs_rmap_update_is_needed(mp))
+                return 0;
+
+        bmap.br_startblock = XFS_AGB_TO_FSB(mp, agno, bno);
+        bmap.br_blockcount = len;
+        bmap.br_startoff = 0;
+        bmap.br_state = XFS_EXT_NORM;
+
+        return __xfs_rmap_add(mp, dfops, XFS_RMAP_ALLOC, owner,
+                        XFS_DATA_FORK, &bmap);
+}
+
+/* Schedule the deletion of an rmap for non-file data. */
+int
+xfs_rmap_free_extent(
+        struct xfs_mount        *mp,
+        struct xfs_defer_ops    *dfops,
+        xfs_agnumber_t          agno,
+        xfs_agblock_t           bno,
+        xfs_extlen_t            len,
+        __uint64_t              owner)
+{
+        struct xfs_bmbt_irec    bmap;
+
+        if (!xfs_rmap_update_is_needed(mp))
+                return 0;
+
+        bmap.br_startblock = XFS_AGB_TO_FSB(mp, agno, bno);
+        bmap.br_blockcount = len;
+        bmap.br_startoff = 0;
+        bmap.br_state = XFS_EXT_NORM;
+
+        return __xfs_rmap_add(mp, dfops, XFS_RMAP_FREE, owner,
+                        XFS_DATA_FORK, &bmap);
+}
diff --git a/fs/xfs/libxfs/xfs_rmap.h b/fs/xfs/libxfs/xfs_rmap.h
new file mode 100644
index 000000000000..71cf99a4acba
--- /dev/null
+++ b/fs/xfs/libxfs/xfs_rmap.h
@@ -0,0 +1,209 @@
+/*
+ * Copyright (C) 2016 Oracle.  All Rights Reserved.
+ *
+ * Author: Darrick J. Wong <darrick.wong@oracle.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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_RMAP_H__
+#define __XFS_RMAP_H__
+
+static inline void
+xfs_rmap_ag_owner(
+        struct xfs_owner_info   *oi,
+        uint64_t                owner)
+{
+        oi->oi_owner = owner;
+        oi->oi_offset = 0;
+        oi->oi_flags = 0;
+}
+
+static inline void
+xfs_rmap_ino_bmbt_owner(
+        struct xfs_owner_info   *oi,
+        xfs_ino_t               ino,
+        int                     whichfork)
+{
+        oi->oi_owner = ino;
+        oi->oi_offset = 0;
+        oi->oi_flags = XFS_OWNER_INFO_BMBT_BLOCK;
+        if (whichfork == XFS_ATTR_FORK)
+                oi->oi_flags |= XFS_OWNER_INFO_ATTR_FORK;
+}
+
+static inline void
+xfs_rmap_ino_owner(
+        struct xfs_owner_info   *oi,
+        xfs_ino_t               ino,
+        int                     whichfork,
+        xfs_fileoff_t           offset)
+{
+        oi->oi_owner = ino;
+        oi->oi_offset = offset;
+        oi->oi_flags = 0;
+        if (whichfork == XFS_ATTR_FORK)
+                oi->oi_flags |= XFS_OWNER_INFO_ATTR_FORK;
+}
+
+static inline void
+xfs_rmap_skip_owner_update(
+        struct xfs_owner_info   *oi)
+{
+        oi->oi_owner = XFS_RMAP_OWN_UNKNOWN;
+}
+
+/* Reverse mapping functions. */
+
+struct xfs_buf;
+
+static inline __u64
+xfs_rmap_irec_offset_pack(
+        const struct xfs_rmap_irec      *irec)
+{
+        __u64                   x;
+
+        x = XFS_RMAP_OFF(irec->rm_offset);
+        if (irec->rm_flags & XFS_RMAP_ATTR_FORK)
+                x |= XFS_RMAP_OFF_ATTR_FORK;
+        if (irec->rm_flags & XFS_RMAP_BMBT_BLOCK)
+                x |= XFS_RMAP_OFF_BMBT_BLOCK;
+        if (irec->rm_flags & XFS_RMAP_UNWRITTEN)
+                x |= XFS_RMAP_OFF_UNWRITTEN;
+        return x;
+}
+
+static inline int
+xfs_rmap_irec_offset_unpack(
+        __u64                   offset,
+        struct xfs_rmap_irec    *irec)
+{
+        if (offset & ~(XFS_RMAP_OFF_MASK | XFS_RMAP_OFF_FLAGS))
+                return -EFSCORRUPTED;
+        irec->rm_offset = XFS_RMAP_OFF(offset);
+        if (offset & XFS_RMAP_OFF_ATTR_FORK)
+                irec->rm_flags |= XFS_RMAP_ATTR_FORK;
+        if (offset & XFS_RMAP_OFF_BMBT_BLOCK)
+                irec->rm_flags |= XFS_RMAP_BMBT_BLOCK;
+        if (offset & XFS_RMAP_OFF_UNWRITTEN)
+                irec->rm_flags |= XFS_RMAP_UNWRITTEN;
+        return 0;
+}
+
+static inline void
+xfs_owner_info_unpack(
+        struct xfs_owner_info   *oinfo,
+        uint64_t                *owner,
+        uint64_t                *offset,
+        unsigned int            *flags)
+{
+        unsigned int            r = 0;
+
+        *owner = oinfo->oi_owner;
+        *offset = oinfo->oi_offset;
+        if (oinfo->oi_flags & XFS_OWNER_INFO_ATTR_FORK)
+                r |= XFS_RMAP_ATTR_FORK;
+        if (oinfo->oi_flags & XFS_OWNER_INFO_BMBT_BLOCK)
+                r |= XFS_RMAP_BMBT_BLOCK;
+        *flags = r;
+}
+
+static inline void
+xfs_owner_info_pack(
+        struct xfs_owner_info   *oinfo,
+        uint64_t                owner,
+        uint64_t                offset,
+        unsigned int            flags)
+{
+        oinfo->oi_owner = owner;
+        oinfo->oi_offset = XFS_RMAP_OFF(offset);
+        oinfo->oi_flags = 0;
+        if (flags & XFS_RMAP_ATTR_FORK)
+                oinfo->oi_flags |= XFS_OWNER_INFO_ATTR_FORK;
+        if (flags & XFS_RMAP_BMBT_BLOCK)
+                oinfo->oi_flags |= XFS_OWNER_INFO_BMBT_BLOCK;
+}
+
+int xfs_rmap_alloc(struct xfs_trans *tp, struct xfs_buf *agbp,
+                   xfs_agnumber_t agno, xfs_agblock_t bno, xfs_extlen_t len,
+                   struct xfs_owner_info *oinfo);
+int xfs_rmap_free(struct xfs_trans *tp, struct xfs_buf *agbp,
+                  xfs_agnumber_t agno, xfs_agblock_t bno, xfs_extlen_t len,
+                  struct xfs_owner_info *oinfo);
+
+int xfs_rmap_lookup_le(struct xfs_btree_cur *cur, xfs_agblock_t bno,
+                xfs_extlen_t len, uint64_t owner, uint64_t offset,
+                unsigned int flags, int *stat);
+int xfs_rmap_lookup_eq(struct xfs_btree_cur *cur, xfs_agblock_t bno,
+                xfs_extlen_t len, uint64_t owner, uint64_t offset,
+                unsigned int flags, int *stat);
+int xfs_rmap_insert(struct xfs_btree_cur *rcur, xfs_agblock_t agbno,
+                xfs_extlen_t len, uint64_t owner, uint64_t offset,
+                unsigned int flags);
+int xfs_rmap_get_rec(struct xfs_btree_cur *cur, struct xfs_rmap_irec *irec,
+                int *stat);
+
+typedef int (*xfs_rmap_query_range_fn)(
+        struct xfs_btree_cur    *cur,
+        struct xfs_rmap_irec    *rec,
+        void                    *priv);
+
+int xfs_rmap_query_range(struct xfs_btree_cur *cur,
+                struct xfs_rmap_irec *low_rec, struct xfs_rmap_irec *high_rec,
+                xfs_rmap_query_range_fn fn, void *priv);
+
+enum xfs_rmap_intent_type {
+        XFS_RMAP_MAP,
+        XFS_RMAP_MAP_SHARED,
+        XFS_RMAP_UNMAP,
+        XFS_RMAP_UNMAP_SHARED,
+        XFS_RMAP_CONVERT,
+        XFS_RMAP_CONVERT_SHARED,
+        XFS_RMAP_ALLOC,
+        XFS_RMAP_FREE,
+};
+
+struct xfs_rmap_intent {
+        struct list_head                        ri_list;
+        enum xfs_rmap_intent_type               ri_type;
+        __uint64_t                              ri_owner;
+        int                                     ri_whichfork;
+        struct xfs_bmbt_irec                    ri_bmap;
+};
+
+/* functions for updating the rmapbt based on bmbt map/unmap operations */
+int xfs_rmap_map_extent(struct xfs_mount *mp, struct xfs_defer_ops *dfops,
+                struct xfs_inode *ip, int whichfork,
+                struct xfs_bmbt_irec *imap);
+int xfs_rmap_unmap_extent(struct xfs_mount *mp, struct xfs_defer_ops *dfops,
+                struct xfs_inode *ip, int whichfork,
+                struct xfs_bmbt_irec *imap);
+int xfs_rmap_convert_extent(struct xfs_mount *mp, struct xfs_defer_ops *dfops,
+                struct xfs_inode *ip, int whichfork,
+                struct xfs_bmbt_irec *imap);
+int xfs_rmap_alloc_extent(struct xfs_mount *mp, struct xfs_defer_ops *dfops,
+                xfs_agnumber_t agno, xfs_agblock_t bno, xfs_extlen_t len,
+                __uint64_t owner);
+int xfs_rmap_free_extent(struct xfs_mount *mp, struct xfs_defer_ops *dfops,
+                xfs_agnumber_t agno, xfs_agblock_t bno, xfs_extlen_t len,
+                __uint64_t owner);
+
+void xfs_rmap_finish_one_cleanup(struct xfs_trans *tp,
+                struct xfs_btree_cur *rcur, int error);
+int xfs_rmap_finish_one(struct xfs_trans *tp, enum xfs_rmap_intent_type type,
+                __uint64_t owner, int whichfork, xfs_fileoff_t startoff,
+                xfs_fsblock_t startblock, xfs_filblks_t blockcount,
+                xfs_exntst_t state, struct xfs_btree_cur **pcur);
+
+#endif  /* __XFS_RMAP_H__ */
diff --git a/fs/xfs/libxfs/xfs_rmap_btree.c b/fs/xfs/libxfs/xfs_rmap_btree.c
new file mode 100644
index 000000000000..bc1faebc84ec
--- /dev/null
+++ b/fs/xfs/libxfs/xfs_rmap_btree.c
@@ -0,0 +1,511 @@
+/*
+ * Copyright (c) 2014 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_bit.h"
+#include "xfs_sb.h"
+#include "xfs_mount.h"
+#include "xfs_defer.h"
+#include "xfs_inode.h"
+#include "xfs_trans.h"
+#include "xfs_alloc.h"
+#include "xfs_btree.h"
+#include "xfs_rmap.h"
+#include "xfs_rmap_btree.h"
+#include "xfs_trace.h"
+#include "xfs_cksum.h"
+#include "xfs_error.h"
+#include "xfs_extent_busy.h"
+
+/*
+ * Reverse map btree.
+ *
+ * This is a per-ag tree used to track the owner(s) of a given extent. With
+ * reflink it is possible for there to be multiple owners, which is a departure
+ * from classic XFS. Owner records for data extents are inserted when the
+ * extent is mapped and removed when an extent is unmapped.  Owner records for
+ * all other block types (i.e. metadata) are inserted when an extent is
+ * allocated and removed when an extent is freed. There can only be one owner
+ * of a metadata extent, usually an inode or some other metadata structure like
+ * an AG btree.
+ *
+ * The rmap btree is part of the free space management, so blocks for the tree
+ * are sourced from the agfl. Hence we need transaction reservation support for
+ * this tree so that the freelist is always large enough. This also impacts on
+ * the minimum space we need to leave free in the AG.
+ *
+ * The tree is ordered by [ag block, owner, offset]. This is a large key size,
+ * but it is the only way to enforce unique keys when a block can be owned by
+ * multiple files at any offset. There's no need to order/search by extent
+ * size for online updating/management of the tree. It is intended that most
+ * reverse lookups will be to find the owner(s) of a particular block, or to
+ * try to recover tree and file data from corrupt primary metadata.
+ */
+
+static struct xfs_btree_cur *
+xfs_rmapbt_dup_cursor(
+        struct xfs_btree_cur    *cur)
+{
+        return xfs_rmapbt_init_cursor(cur->bc_mp, cur->bc_tp,
+                        cur->bc_private.a.agbp, cur->bc_private.a.agno);
+}
+
+STATIC void
+xfs_rmapbt_set_root(
+        struct xfs_btree_cur    *cur,
+        union xfs_btree_ptr     *ptr,
+        int                     inc)
+{
+        struct xfs_buf          *agbp = cur->bc_private.a.agbp;
+        struct xfs_agf          *agf = XFS_BUF_TO_AGF(agbp);
+        xfs_agnumber_t          seqno = be32_to_cpu(agf->agf_seqno);
+        int                     btnum = cur->bc_btnum;
+        struct xfs_perag        *pag = xfs_perag_get(cur->bc_mp, seqno);
+
+        ASSERT(ptr->s != 0);
+
+        agf->agf_roots[btnum] = ptr->s;
+        be32_add_cpu(&agf->agf_levels[btnum], inc);
+        pag->pagf_levels[btnum] += inc;
+        xfs_perag_put(pag);
+
+        xfs_alloc_log_agf(cur->bc_tp, agbp, XFS_AGF_ROOTS | XFS_AGF_LEVELS);
+}
+
+STATIC int
+xfs_rmapbt_alloc_block(
+        struct xfs_btree_cur    *cur,
+        union xfs_btree_ptr     *start,
+        union xfs_btree_ptr     *new,
+        int                     *stat)
+{
+        int                     error;
+        xfs_agblock_t           bno;
+
+        XFS_BTREE_TRACE_CURSOR(cur, XBT_ENTRY);
+
+        /* Allocate the new block from the freelist. If we can't, give up.  */
+        error = xfs_alloc_get_freelist(cur->bc_tp, cur->bc_private.a.agbp,
+                                       &bno, 1);
+        if (error) {
+                XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
+                return error;
+        }
+
+        trace_xfs_rmapbt_alloc_block(cur->bc_mp, cur->bc_private.a.agno,
+                        bno, 1);
+        if (bno == NULLAGBLOCK) {
+                XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
+                *stat = 0;
+                return 0;
+        }
+
+        xfs_extent_busy_reuse(cur->bc_mp, cur->bc_private.a.agno, bno, 1,
+                        false);
+
+        xfs_trans_agbtree_delta(cur->bc_tp, 1);
+        new->s = cpu_to_be32(bno);
+
+        XFS_BTREE_TRACE_CURSOR(cur, XBT_EXIT);
+        *stat = 1;
+        return 0;
+}
+
+STATIC int
+xfs_rmapbt_free_block(
+        struct xfs_btree_cur    *cur,
+        struct xfs_buf          *bp)
+{
+        struct xfs_buf          *agbp = cur->bc_private.a.agbp;
+        struct xfs_agf          *agf = XFS_BUF_TO_AGF(agbp);
+        xfs_agblock_t           bno;
+        int                     error;
+
+        bno = xfs_daddr_to_agbno(cur->bc_mp, XFS_BUF_ADDR(bp));
+        trace_xfs_rmapbt_free_block(cur->bc_mp, cur->bc_private.a.agno,
+                        bno, 1);
+        error = xfs_alloc_put_freelist(cur->bc_tp, agbp, NULL, bno, 1);
+        if (error)
+                return error;
+
+        xfs_extent_busy_insert(cur->bc_tp, be32_to_cpu(agf->agf_seqno), bno, 1,
+                              XFS_EXTENT_BUSY_SKIP_DISCARD);
+        xfs_trans_agbtree_delta(cur->bc_tp, -1);
+
+        return 0;
+}
+
+STATIC int
+xfs_rmapbt_get_minrecs(
+        struct xfs_btree_cur    *cur,
+        int                     level)
+{
+        return cur->bc_mp->m_rmap_mnr[level != 0];
+}
+
+STATIC int
+xfs_rmapbt_get_maxrecs(
+        struct xfs_btree_cur    *cur,
+        int                     level)
+{
+        return cur->bc_mp->m_rmap_mxr[level != 0];
+}
+
+STATIC void
+xfs_rmapbt_init_key_from_rec(
+        union xfs_btree_key     *key,
+        union xfs_btree_rec     *rec)
+{
+        key->rmap.rm_startblock = rec->rmap.rm_startblock;
+        key->rmap.rm_owner = rec->rmap.rm_owner;
+        key->rmap.rm_offset = rec->rmap.rm_offset;
+}
+
+/*
+ * The high key for a reverse mapping record can be computed by shifting
+ * the startblock and offset to the highest value that would still map
+ * to that record.  In practice this means that we add blockcount-1 to
+ * the startblock for all records, and if the record is for a data/attr
+ * fork mapping, we add blockcount-1 to the offset too.
+ */
+STATIC void
+xfs_rmapbt_init_high_key_from_rec(
+        union xfs_btree_key     *key,
+        union xfs_btree_rec     *rec)
+{
+        __uint64_t              off;
+        int                     adj;
+
+        adj = be32_to_cpu(rec->rmap.rm_blockcount) - 1;
+
+        key->rmap.rm_startblock = rec->rmap.rm_startblock;
+        be32_add_cpu(&key->rmap.rm_startblock, adj);
+        key->rmap.rm_owner = rec->rmap.rm_owner;
+        key->rmap.rm_offset = rec->rmap.rm_offset;
+        if (XFS_RMAP_NON_INODE_OWNER(be64_to_cpu(rec->rmap.rm_owner)) ||
+            XFS_RMAP_IS_BMBT_BLOCK(be64_to_cpu(rec->rmap.rm_offset)))
+                return;
+        off = be64_to_cpu(key->rmap.rm_offset);
+        off = (XFS_RMAP_OFF(off) + adj) | (off & ~XFS_RMAP_OFF_MASK);
+        key->rmap.rm_offset = cpu_to_be64(off);
+}
+
+STATIC void
+xfs_rmapbt_init_rec_from_cur(
+        struct xfs_btree_cur    *cur,
+        union xfs_btree_rec     *rec)
+{
+        rec->rmap.rm_startblock = cpu_to_be32(cur->bc_rec.r.rm_startblock);
+        rec->rmap.rm_blockcount = cpu_to_be32(cur->bc_rec.r.rm_blockcount);
+        rec->rmap.rm_owner = cpu_to_be64(cur->bc_rec.r.rm_owner);
+        rec->rmap.rm_offset = cpu_to_be64(
+                        xfs_rmap_irec_offset_pack(&cur->bc_rec.r));
+}
+
+STATIC void
+xfs_rmapbt_init_ptr_from_cur(
+        struct xfs_btree_cur    *cur,
+        union xfs_btree_ptr     *ptr)
+{
+        struct xfs_agf          *agf = XFS_BUF_TO_AGF(cur->bc_private.a.agbp);
+
+        ASSERT(cur->bc_private.a.agno == be32_to_cpu(agf->agf_seqno));
+        ASSERT(agf->agf_roots[cur->bc_btnum] != 0);
+
+        ptr->s = agf->agf_roots[cur->bc_btnum];
+}
+
+STATIC __int64_t
+xfs_rmapbt_key_diff(
+        struct xfs_btree_cur    *cur,
+        union xfs_btree_key     *key)
+{
+        struct xfs_rmap_irec    *rec = &cur->bc_rec.r;
+        struct xfs_rmap_key     *kp = &key->rmap;
+        __u64                   x, y;
+        __int64_t               d;
+
+        d = (__int64_t)be32_to_cpu(kp->rm_startblock) - rec->rm_startblock;
+        if (d)
+                return d;
+
+        x = be64_to_cpu(kp->rm_owner);
+        y = rec->rm_owner;
+        if (x > y)
+                return 1;
+        else if (y > x)
+                return -1;
+
+        x = XFS_RMAP_OFF(be64_to_cpu(kp->rm_offset));
+        y = rec->rm_offset;
+        if (x > y)
+                return 1;
+        else if (y > x)
+                return -1;
+        return 0;
+}
+
+STATIC __int64_t
+xfs_rmapbt_diff_two_keys(
+        struct xfs_btree_cur    *cur,
+        union xfs_btree_key     *k1,
+        union xfs_btree_key     *k2)
+{
+        struct xfs_rmap_key     *kp1 = &k1->rmap;
+        struct xfs_rmap_key     *kp2 = &k2->rmap;
+        __int64_t               d;
+        __u64                   x, y;
+
+        d = (__int64_t)be32_to_cpu(kp1->rm_startblock) -
+                       be32_to_cpu(kp2->rm_startblock);
+        if (d)
+                return d;
+
+        x = be64_to_cpu(kp1->rm_owner);
+        y = be64_to_cpu(kp2->rm_owner);
+        if (x > y)
+                return 1;
+        else if (y > x)
+                return -1;
+
+        x = XFS_RMAP_OFF(be64_to_cpu(kp1->rm_offset));
+        y = XFS_RMAP_OFF(be64_to_cpu(kp2->rm_offset));
+        if (x > y)
+                return 1;
+        else if (y > x)
+                return -1;
+        return 0;
+}
+
+static bool
+xfs_rmapbt_verify(
+        struct xfs_buf          *bp)
+{
+        struct xfs_mount        *mp = bp->b_target->bt_mount;
+        struct xfs_btree_block  *block = XFS_BUF_TO_BLOCK(bp);
+        struct xfs_perag        *pag = bp->b_pag;
+        unsigned int            level;
+
+        /*
+         * magic number and level verification
+         *
+         * During growfs operations, we can't verify the exact level or owner as
+         * the perag is not fully initialised and hence not attached to the
+         * buffer.  In this case, check against the maximum tree depth.
+         *
+         * Similarly, during log recovery we will have a perag structure
+         * attached, but the agf information will not yet have been initialised
+         * from the on disk AGF. Again, we can only check against maximum limits
+         * in this case.
+         */
+        if (block->bb_magic != cpu_to_be32(XFS_RMAP_CRC_MAGIC))
+                return false;
+
+        if (!xfs_sb_version_hasrmapbt(&mp->m_sb))
+                return false;
+        if (!xfs_btree_sblock_v5hdr_verify(bp))
+                return false;
+
+        level = be16_to_cpu(block->bb_level);
+        if (pag && pag->pagf_init) {
+                if (level >= pag->pagf_levels[XFS_BTNUM_RMAPi])
+                        return false;
+        } else if (level >= mp->m_rmap_maxlevels)
+                return false;
+
+        return xfs_btree_sblock_verify(bp, mp->m_rmap_mxr[level != 0]);
+}
+
+static void
+xfs_rmapbt_read_verify(
+        struct xfs_buf  *bp)
+{
+        if (!xfs_btree_sblock_verify_crc(bp))
+                xfs_buf_ioerror(bp, -EFSBADCRC);
+        else if (!xfs_rmapbt_verify(bp))
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
+
+        if (bp->b_error) {
+                trace_xfs_btree_corrupt(bp, _RET_IP_);
+                xfs_verifier_error(bp);
+        }
+}
+
+static void
+xfs_rmapbt_write_verify(
+        struct xfs_buf  *bp)
+{
+        if (!xfs_rmapbt_verify(bp)) {
+                trace_xfs_btree_corrupt(bp, _RET_IP_);
+                xfs_buf_ioerror(bp, -EFSCORRUPTED);
+                xfs_verifier_error(bp);
+                return;
+        }
+        xfs_btree_sblock_calc_crc(bp);
+
+}
+
+const struct xfs_buf_ops xfs_rmapbt_buf_ops = {
+        .name                   = "xfs_rmapbt",
+        .verify_read            = xfs_rmapbt_read_verify,
+        .verify_write           = xfs_rmapbt_write_verify,
+};
+
+#if defined(DEBUG) || defined(XFS_WARN)
+STATIC int
+xfs_rmapbt_keys_inorder(
+        struct xfs_btree_cur    *cur,
+        union xfs_btree_key     *k1,
+        union xfs_btree_key     *k2)
+{
+        __uint32_t              x;
+        __uint32_t              y;
+        __uint64_t              a;
+        __uint64_t              b;
+
+        x = be32_to_cpu(k1->rmap.rm_startblock);
+        y = be32_to_cpu(k2->rmap.rm_startblock);
+        if (x < y)
+                return 1;
+        else if (x > y)
+                return 0;
+        a = be64_to_cpu(k1->rmap.rm_owner);
+        b = be64_to_cpu(k2->rmap.rm_owner);
+        if (a < b)
+                return 1;
+        else if (a > b)
+                return 0;
+        a = XFS_RMAP_OFF(be64_to_cpu(k1->rmap.rm_offset));
+        b = XFS_RMAP_OFF(be64_to_cpu(k2->rmap.rm_offset));
+        if (a <= b)
+                return 1;
+        return 0;
+}
+
+STATIC int
+xfs_rmapbt_recs_inorder(
+        struct xfs_btree_cur    *cur,
+        union xfs_btree_rec     *r1,
+        union xfs_btree_rec     *r2)
+{
+        __uint32_t              x;
+        __uint32_t              y;
+        __uint64_t              a;
+        __uint64_t              b;
+
+        x = be32_to_cpu(r1->rmap.rm_startblock);
+        y = be32_to_cpu(r2->rmap.rm_startblock);
+        if (x < y)
+                return 1;
+        else if (x > y)
+                return 0;
+        a = be64_to_cpu(r1->rmap.rm_owner);
+        b = be64_to_cpu(r2->rmap.rm_owner);
+        if (a < b)
+                return 1;
+        else if (a > b)
+                return 0;
+        a = XFS_RMAP_OFF(be64_to_cpu(r1->rmap.rm_offset));
+        b = XFS_RMAP_OFF(be64_to_cpu(r2->rmap.rm_offset));
+        if (a <= b)
+                return 1;
+        return 0;
+}
+#endif  /* DEBUG */
+
+static const struct xfs_btree_ops xfs_rmapbt_ops = {
+        .rec_len                = sizeof(struct xfs_rmap_rec),
+        .key_len                = 2 * sizeof(struct xfs_rmap_key),
+
+        .dup_cursor             = xfs_rmapbt_dup_cursor,
+        .set_root               = xfs_rmapbt_set_root,
+        .alloc_block            = xfs_rmapbt_alloc_block,
+        .free_block             = xfs_rmapbt_free_block,
+        .get_minrecs            = xfs_rmapbt_get_minrecs,
+        .get_maxrecs            = xfs_rmapbt_get_maxrecs,
+        .init_key_from_rec      = xfs_rmapbt_init_key_from_rec,
+        .init_high_key_from_rec = xfs_rmapbt_init_high_key_from_rec,
+        .init_rec_from_cur      = xfs_rmapbt_init_rec_from_cur,
+        .init_ptr_from_cur      = xfs_rmapbt_init_ptr_from_cur,
+        .key_diff               = xfs_rmapbt_key_diff,
+        .buf_ops                = &xfs_rmapbt_buf_ops,
+        .diff_two_keys          = xfs_rmapbt_diff_two_keys,
+#if defined(DEBUG) || defined(XFS_WARN)
+        .keys_inorder           = xfs_rmapbt_keys_inorder,
+        .recs_inorder           = xfs_rmapbt_recs_inorder,
+#endif
+};
+
+/*
+ * Allocate a new allocation btree cursor.
+ */
+struct xfs_btree_cur *
+xfs_rmapbt_init_cursor(
+        struct xfs_mount        *mp,
+        struct xfs_trans        *tp,
+        struct xfs_buf          *agbp,
+        xfs_agnumber_t          agno)
+{
+        struct xfs_agf          *agf = XFS_BUF_TO_AGF(agbp);
+        struct xfs_btree_cur    *cur;
+
+        cur = kmem_zone_zalloc(xfs_btree_cur_zone, KM_NOFS);
+        cur->bc_tp = tp;
+        cur->bc_mp = mp;
+        /* Overlapping btree; 2 keys per pointer. */
+        cur->bc_btnum = XFS_BTNUM_RMAP;
+        cur->bc_flags = XFS_BTREE_CRC_BLOCKS | XFS_BTREE_OVERLAPPING;
+        cur->bc_blocklog = mp->m_sb.sb_blocklog;
+        cur->bc_ops = &xfs_rmapbt_ops;
+        cur->bc_nlevels = be32_to_cpu(agf->agf_levels[XFS_BTNUM_RMAP]);
+
+        cur->bc_private.a.agbp = agbp;
+        cur->bc_private.a.agno = agno;
+
+        return cur;
+}
+
+/*
+ * Calculate number of records in an rmap btree block.
+ */
+int
+xfs_rmapbt_maxrecs(
+        struct xfs_mount        *mp,
+        int                     blocklen,
+        int                     leaf)
+{
+        blocklen -= XFS_RMAP_BLOCK_LEN;
+
+        if (leaf)
+                return blocklen / sizeof(struct xfs_rmap_rec);
+        return blocklen /
+                (2 * sizeof(struct xfs_rmap_key) + sizeof(xfs_rmap_ptr_t));
+}
+
+/* Compute the maximum height of an rmap btree. */
+void
+xfs_rmapbt_compute_maxlevels(
+        struct xfs_mount                *mp)
+{
+        mp->m_rmap_maxlevels = xfs_btree_compute_maxlevels(mp,
+                        mp->m_rmap_mnr, mp->m_sb.sb_agblocks);
+}
diff --git a/fs/xfs/libxfs/xfs_rmap_btree.h b/fs/xfs/libxfs/xfs_rmap_btree.h
new file mode 100644
index 000000000000..e73a55357dab
--- /dev/null
+++ b/fs/xfs/libxfs/xfs_rmap_btree.h
@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2014 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_RMAP_BTREE_H__
+#define __XFS_RMAP_BTREE_H__
+
+struct xfs_buf;
+struct xfs_btree_cur;
+struct xfs_mount;
+
+/* rmaps only exist on crc enabled filesystems */
+#define XFS_RMAP_BLOCK_LEN      XFS_BTREE_SBLOCK_CRC_LEN
+
+/*
+ * Record, key, and pointer address macros for btree blocks.
+ *
+ * (note that some of these may appear unused, but they are used in userspace)
+ */
+#define XFS_RMAP_REC_ADDR(block, index) \
+        ((struct xfs_rmap_rec *) \
+                ((char *)(block) + XFS_RMAP_BLOCK_LEN + \
+                 (((index) - 1) * sizeof(struct xfs_rmap_rec))))
+
+#define XFS_RMAP_KEY_ADDR(block, index) \
+        ((struct xfs_rmap_key *) \
+                ((char *)(block) + XFS_RMAP_BLOCK_LEN + \
+                 ((index) - 1) * 2 * sizeof(struct xfs_rmap_key)))
+
+#define XFS_RMAP_HIGH_KEY_ADDR(block, index) \
+        ((struct xfs_rmap_key *) \
+                ((char *)(block) + XFS_RMAP_BLOCK_LEN + \
+                 sizeof(struct xfs_rmap_key) + \
+                 ((index) - 1) * 2 * sizeof(struct xfs_rmap_key)))
+
+#define XFS_RMAP_PTR_ADDR(block, index, maxrecs) \
+        ((xfs_rmap_ptr_t *) \
+                ((char *)(block) + XFS_RMAP_BLOCK_LEN + \
+                 (maxrecs) * 2 * sizeof(struct xfs_rmap_key) + \
+                 ((index) - 1) * sizeof(xfs_rmap_ptr_t)))
+
+struct xfs_btree_cur *xfs_rmapbt_init_cursor(struct xfs_mount *mp,
+                                struct xfs_trans *tp, struct xfs_buf *bp,
+                                xfs_agnumber_t agno);
+int xfs_rmapbt_maxrecs(struct xfs_mount *mp, int blocklen, int leaf);
+extern void xfs_rmapbt_compute_maxlevels(struct xfs_mount *mp);
+
+#endif  /* __XFS_RMAP_BTREE_H__ */
diff --git a/fs/xfs/libxfs/xfs_sb.c b/fs/xfs/libxfs/xfs_sb.c
index 12ca86778e02..0e3d4f5ec33c 100644
--- a/fs/xfs/libxfs/xfs_sb.c
+++ b/fs/xfs/libxfs/xfs_sb.c
@@ -24,6 +24,7 @@
 #include "xfs_bit.h"
 #include "xfs_sb.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_inode.h"
 #include "xfs_ialloc.h"
 #include "xfs_alloc.h"
@@ -36,6 +37,7 @@
 #include "xfs_alloc_btree.h"
 #include "xfs_ialloc_btree.h"
 #include "xfs_log.h"
+#include "xfs_rmap_btree.h"
 
 /*
  * Physical superblock buffer manipulations. Shared with libxfs in userspace.
@@ -729,6 +731,11 @@ xfs_sb_mount_common(
         mp->m_bmap_dmnr[0] = mp->m_bmap_dmxr[0] / 2;
         mp->m_bmap_dmnr[1] = mp->m_bmap_dmxr[1] / 2;
 
+        mp->m_rmap_mxr[0] = xfs_rmapbt_maxrecs(mp, sbp->sb_blocksize, 1);
+        mp->m_rmap_mxr[1] = xfs_rmapbt_maxrecs(mp, sbp->sb_blocksize, 0);
+        mp->m_rmap_mnr[0] = mp->m_rmap_mxr[0] / 2;
+        mp->m_rmap_mnr[1] = mp->m_rmap_mxr[1] / 2;
+
         mp->m_bsize = XFS_FSB_TO_BB(mp, 1);
         mp->m_ialloc_inos = (int)MAX((__uint16_t)XFS_INODES_PER_CHUNK,
                                         sbp->sb_inopblock);
@@ -738,6 +745,8 @@ xfs_sb_mount_common(
                 mp->m_ialloc_min_blks = sbp->sb_spino_align;
         else
                 mp->m_ialloc_min_blks = mp->m_ialloc_blks;
+        mp->m_alloc_set_aside = xfs_alloc_set_aside(mp);
+        mp->m_ag_max_usable = xfs_alloc_ag_max_usable(mp);
 }
 
 /*
diff --git a/fs/xfs/libxfs/xfs_shared.h b/fs/xfs/libxfs/xfs_shared.h
index 16002b5ec4eb..0c5b30bd884c 100644
--- a/fs/xfs/libxfs/xfs_shared.h
+++ b/fs/xfs/libxfs/xfs_shared.h
@@ -38,6 +38,7 @@ 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_rmapbt_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;
@@ -116,6 +117,7 @@ int	xfs_log_calc_minimum_size(struct xfs_mount *);
 #define XFS_INO_BTREE_REF       3
 #define XFS_ALLOC_BTREE_REF     2
 #define XFS_BMAP_BTREE_REF      2
+#define XFS_RMAP_BTREE_REF      2
 #define XFS_DIR_BTREE_REF       2
 #define XFS_INO_REF             2
 #define XFS_ATTR_BTREE_REF      1
diff --git a/fs/xfs/libxfs/xfs_trans_resv.c b/fs/xfs/libxfs/xfs_trans_resv.c
index 68cb1e7bf2bb..301ef2f4dbd6 100644
--- a/fs/xfs/libxfs/xfs_trans_resv.c
+++ b/fs/xfs/libxfs/xfs_trans_resv.c
@@ -64,6 +64,30 @@ xfs_calc_buf_res(
 }
 
 /*
+ * Per-extent log reservation for the btree changes involved in freeing or
+ * allocating an extent.  In classic XFS there were two trees that will be
+ * modified (bnobt + cntbt).  With rmap enabled, there are three trees
+ * (rmapbt).  The number of blocks reserved is based on the formula:
+ *
+ * num trees * ((2 blocks/level * max depth) - 1)
+ *
+ * Keep in mind that max depth is calculated separately for each type of tree.
+ */
+static uint
+xfs_allocfree_log_count(
+        struct xfs_mount *mp,
+        uint            num_ops)
+{
+        uint            blocks;
+
+        blocks = num_ops * 2 * (2 * mp->m_ag_maxlevels - 1);
+        if (xfs_sb_version_hasrmapbt(&mp->m_sb))
+                blocks += num_ops * (2 * mp->m_rmap_maxlevels - 1);
+
+        return blocks;
+}
+
+/*
  * Logging inodes is really tricksy. They are logged in memory format,
  * which means that what we write into the log doesn't directly translate into
  * the amount of space they use on disk.
@@ -126,7 +150,7 @@ xfs_calc_inode_res(
  */
 STATIC uint
 xfs_calc_finobt_res(
-        struct xfs_mount        *mp,
+        struct xfs_mount        *mp,
         int                     alloc,
         int                     modify)
 {
@@ -137,7 +161,7 @@ xfs_calc_finobt_res(
 
         res = xfs_calc_buf_res(mp->m_in_maxlevels, XFS_FSB_TO_B(mp, 1));
         if (alloc)
-                res += xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1), 
+                res += xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
                                         XFS_FSB_TO_B(mp, 1));
         if (modify)
                 res += (uint)XFS_FSB_TO_B(mp, 1);
@@ -153,9 +177,9 @@ xfs_calc_finobt_res(
  * item logged to try to account for the overhead of the transaction mechanism.
  *
  * Note:  Most of the reservations underestimate the number of allocation
- * groups into which they could free extents in the xfs_bmap_finish() call.
+ * groups into which they could free extents in the xfs_defer_finish() call.
  * This is because the number in the worst case is quite high and quite
- * unusual.  In order to fix this we need to change xfs_bmap_finish() to free
+ * unusual.  In order to fix this we need to change xfs_defer_finish() to free
  * extents in only a single AG at a time.  This will require changes to the
  * EFI code as well, however, so that the EFI for the extents not freed is
  * logged again in each transaction.  See SGI PV #261917.
@@ -188,10 +212,10 @@ xfs_calc_write_reservation(
                      xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK),
                                       XFS_FSB_TO_B(mp, 1)) +
                      xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
-                     xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 2),
+                     xfs_calc_buf_res(xfs_allocfree_log_count(mp, 2),
                                       XFS_FSB_TO_B(mp, 1))),
                     (xfs_calc_buf_res(5, mp->m_sb.sb_sectsize) +
-                     xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 2),
+                     xfs_calc_buf_res(xfs_allocfree_log_count(mp, 2),
                                       XFS_FSB_TO_B(mp, 1))));
 }
 
@@ -217,10 +241,10 @@ xfs_calc_itruncate_reservation(
                      xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK) + 1,
                                       XFS_FSB_TO_B(mp, 1))),
                     (xfs_calc_buf_res(9, mp->m_sb.sb_sectsize) +
-                     xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 4),
+                     xfs_calc_buf_res(xfs_allocfree_log_count(mp, 4),
                                       XFS_FSB_TO_B(mp, 1)) +
                     xfs_calc_buf_res(5, 0) +
-                    xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
+                    xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
                                      XFS_FSB_TO_B(mp, 1)) +
                     xfs_calc_buf_res(2 + mp->m_ialloc_blks +
                                      mp->m_in_maxlevels, 0)));
@@ -247,7 +271,7 @@ xfs_calc_rename_reservation(
                      xfs_calc_buf_res(2 * XFS_DIROP_LOG_COUNT(mp),
                                       XFS_FSB_TO_B(mp, 1))),
                     (xfs_calc_buf_res(7, mp->m_sb.sb_sectsize) +
-                     xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 3),
+                     xfs_calc_buf_res(xfs_allocfree_log_count(mp, 3),
                                       XFS_FSB_TO_B(mp, 1))));
 }
 
@@ -286,7 +310,7 @@ xfs_calc_link_reservation(
                      xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp),
                                       XFS_FSB_TO_B(mp, 1))),
                     (xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
-                     xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
+                     xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
                                       XFS_FSB_TO_B(mp, 1))));
 }
 
@@ -324,7 +348,7 @@ xfs_calc_remove_reservation(
                      xfs_calc_buf_res(XFS_DIROP_LOG_COUNT(mp),
                                       XFS_FSB_TO_B(mp, 1))),
                     (xfs_calc_buf_res(4, mp->m_sb.sb_sectsize) +
-                     xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 2),
+                     xfs_calc_buf_res(xfs_allocfree_log_count(mp, 2),
                                       XFS_FSB_TO_B(mp, 1))));
 }
 
@@ -371,7 +395,7 @@ xfs_calc_create_resv_alloc(
                 mp->m_sb.sb_sectsize +
                 xfs_calc_buf_res(mp->m_ialloc_blks, XFS_FSB_TO_B(mp, 1)) +
                 xfs_calc_buf_res(mp->m_in_maxlevels, XFS_FSB_TO_B(mp, 1)) +
-                xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
+                xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
                                  XFS_FSB_TO_B(mp, 1));
 }
 
@@ -399,7 +423,7 @@ xfs_calc_icreate_resv_alloc(
         return xfs_calc_buf_res(2, mp->m_sb.sb_sectsize) +
                 mp->m_sb.sb_sectsize +
                 xfs_calc_buf_res(mp->m_in_maxlevels, XFS_FSB_TO_B(mp, 1)) +
-                xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
+                xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
                                  XFS_FSB_TO_B(mp, 1)) +
                 xfs_calc_finobt_res(mp, 0, 0);
 }
@@ -483,7 +507,7 @@ xfs_calc_ifree_reservation(
                 xfs_calc_buf_res(1, 0) +
                 xfs_calc_buf_res(2 + mp->m_ialloc_blks +
                                  mp->m_in_maxlevels, 0) +
-                xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
+                xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
                                  XFS_FSB_TO_B(mp, 1)) +
                 xfs_calc_finobt_res(mp, 0, 1);
 }
@@ -513,7 +537,7 @@ xfs_calc_growdata_reservation(
         struct xfs_mount        *mp)
 {
         return xfs_calc_buf_res(3, mp->m_sb.sb_sectsize) +
-                xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
+                xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
                                  XFS_FSB_TO_B(mp, 1));
 }
 
@@ -535,7 +559,7 @@ xfs_calc_growrtalloc_reservation(
                 xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK),
                                  XFS_FSB_TO_B(mp, 1)) +
                 xfs_calc_inode_res(mp, 1) +
-                xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
+                xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
                                  XFS_FSB_TO_B(mp, 1));
 }
 
@@ -611,7 +635,7 @@ xfs_calc_addafork_reservation(
                 xfs_calc_buf_res(1, mp->m_dir_geo->blksize) +
                 xfs_calc_buf_res(XFS_DAENTER_BMAP1B(mp, XFS_DATA_FORK) + 1,
                                  XFS_FSB_TO_B(mp, 1)) +
-                xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 1),
+                xfs_calc_buf_res(xfs_allocfree_log_count(mp, 1),
                                  XFS_FSB_TO_B(mp, 1));
 }
 
@@ -634,7 +658,7 @@ xfs_calc_attrinval_reservation(
                     xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK),
                                      XFS_FSB_TO_B(mp, 1))),
                    (xfs_calc_buf_res(9, mp->m_sb.sb_sectsize) +
-                    xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 4),
+                    xfs_calc_buf_res(xfs_allocfree_log_count(mp, 4),
                                      XFS_FSB_TO_B(mp, 1))));
 }
 
@@ -701,7 +725,7 @@ xfs_calc_attrrm_reservation(
                                         XFS_BM_MAXLEVELS(mp, XFS_ATTR_FORK)) +
                      xfs_calc_buf_res(XFS_BM_MAXLEVELS(mp, XFS_DATA_FORK), 0)),
                     (xfs_calc_buf_res(5, mp->m_sb.sb_sectsize) +
-                     xfs_calc_buf_res(XFS_ALLOCFREE_LOG_COUNT(mp, 2),
+                     xfs_calc_buf_res(xfs_allocfree_log_count(mp, 2),
                                       XFS_FSB_TO_B(mp, 1))));
 }
 
diff --git a/fs/xfs/libxfs/xfs_trans_resv.h b/fs/xfs/libxfs/xfs_trans_resv.h
index 797815012c0e..0eb46ed6d404 100644
--- a/fs/xfs/libxfs/xfs_trans_resv.h
+++ b/fs/xfs/libxfs/xfs_trans_resv.h
@@ -68,16 +68,6 @@ struct xfs_trans_resv {
 #define M_RES(mp)       (&(mp)->m_resv)
 
 /*
- * Per-extent log reservation for the allocation btree changes
- * involved in freeing or allocating an extent.
- * 2 trees * (2 blocks/level * max depth - 1) * block size
- */
-#define XFS_ALLOCFREE_LOG_RES(mp,nx) \
-        ((nx) * (2 * XFS_FSB_TO_B((mp), 2 * (mp)->m_ag_maxlevels - 1)))
-#define XFS_ALLOCFREE_LOG_COUNT(mp,nx) \
-        ((nx) * (2 * (2 * (mp)->m_ag_maxlevels - 1)))
-
-/*
  * Per-directory log reservation for any directory change.
  * dir blocks: (1 btree block per level + data block + free block) * dblock size
  * bmap btree: (levels + 2) * max depth * block size
diff --git a/fs/xfs/libxfs/xfs_types.h b/fs/xfs/libxfs/xfs_types.h
index b79dc66b2ecd..3d503647f26b 100644
--- a/fs/xfs/libxfs/xfs_types.h
+++ b/fs/xfs/libxfs/xfs_types.h
@@ -108,8 +108,8 @@ typedef enum {
 } xfs_lookup_t;
 
 typedef enum {
-        XFS_BTNUM_BNOi, XFS_BTNUM_CNTi, XFS_BTNUM_BMAPi, XFS_BTNUM_INOi,
-        XFS_BTNUM_FINOi, XFS_BTNUM_MAX
+        XFS_BTNUM_BNOi, XFS_BTNUM_CNTi, XFS_BTNUM_RMAPi, XFS_BTNUM_BMAPi,
+        XFS_BTNUM_INOi, XFS_BTNUM_FINOi, XFS_BTNUM_MAX
 } xfs_btnum_t;
 
 struct xfs_name {
diff --git a/fs/xfs/xfs_bmap_util.c b/fs/xfs/xfs_bmap_util.c
index cd4a850564f2..4ece4f2ffc72 100644
--- a/fs/xfs/xfs_bmap_util.c
+++ b/fs/xfs/xfs_bmap_util.c
@@ -25,6 +25,7 @@
 #include "xfs_bit.h"
 #include "xfs_mount.h"
 #include "xfs_da_format.h"
+#include "xfs_defer.h"
 #include "xfs_inode.h"
 #include "xfs_btree.h"
 #include "xfs_trans.h"
@@ -40,6 +41,7 @@
 #include "xfs_trace.h"
 #include "xfs_icache.h"
 #include "xfs_log.h"
+#include "xfs_rmap_btree.h"
 
 /* Kernel only BMAP related definitions and functions */
 
@@ -79,95 +81,6 @@ xfs_zero_extent(
                 GFP_NOFS, true);
 }
 
-/* Sort bmap items by AG. */
-static int
-xfs_bmap_free_list_cmp(
-        void                    *priv,
-        struct list_head        *a,
-        struct list_head        *b)
-{
-        struct xfs_mount        *mp = priv;
-        struct xfs_bmap_free_item       *ra;
-        struct xfs_bmap_free_item       *rb;
-
-        ra = container_of(a, struct xfs_bmap_free_item, xbfi_list);
-        rb = container_of(b, struct xfs_bmap_free_item, xbfi_list);
-        return  XFS_FSB_TO_AGNO(mp, ra->xbfi_startblock) -
-                XFS_FSB_TO_AGNO(mp, rb->xbfi_startblock);
-}
-
-/*
- * Routine to be called at transaction's end by xfs_bmapi, xfs_bunmapi
- * caller.  Frees all the extents that need freeing, which must be done
- * last due to locking considerations.  We never free any extents in
- * the first transaction.
- *
- * If an inode *ip is provided, rejoin it to the transaction if
- * the transaction was committed.
- */
-int                                             /* error */
-xfs_bmap_finish(
-        struct xfs_trans                **tp,   /* transaction pointer addr */
-        struct xfs_bmap_free            *flist, /* i/o: list extents to free */
-        struct xfs_inode                *ip)
-{
-        struct xfs_efd_log_item         *efd;   /* extent free data */
-        struct xfs_efi_log_item         *efi;   /* extent free intention */
-        int                             error;  /* error return value */
-        int                             committed;/* xact committed or not */
-        struct xfs_bmap_free_item       *free;  /* free extent item */
-
-        ASSERT((*tp)->t_flags & XFS_TRANS_PERM_LOG_RES);
-        if (flist->xbf_count == 0)
-                return 0;
-
-        list_sort((*tp)->t_mountp, &flist->xbf_flist, xfs_bmap_free_list_cmp);
-
-        efi = xfs_trans_get_efi(*tp, flist->xbf_count);
-        list_for_each_entry(free, &flist->xbf_flist, xbfi_list)
-                xfs_trans_log_efi_extent(*tp, efi, free->xbfi_startblock,
-                        free->xbfi_blockcount);
-
-        error = __xfs_trans_roll(tp, ip, &committed);
-        if (error) {
-                /*
-                 * If the transaction was committed, drop the EFD reference
-                 * since we're bailing out of here. The other reference is
-                 * dropped when the EFI hits the AIL.
-                 *
-                 * If the transaction was not committed, the EFI is freed by the
-                 * EFI item unlock handler on abort. Also, we have a new
-                 * transaction so we should return committed=1 even though we're
-                 * returning an error.
-                 */
-                if (committed) {
-                        xfs_efi_release(efi);
-                        xfs_force_shutdown((*tp)->t_mountp,
-                                           SHUTDOWN_META_IO_ERROR);
-                }
-                return error;
-        }
-
-        /*
-         * Get an EFD and free each extent in the list, logging to the EFD in
-         * the process. The remaining bmap free list is cleaned up by the caller
-         * on error.
-         */
-        efd = xfs_trans_get_efd(*tp, efi, flist->xbf_count);
-        while (!list_empty(&flist->xbf_flist)) {
-                free = list_first_entry(&flist->xbf_flist,
-                                struct xfs_bmap_free_item, xbfi_list);
-                error = xfs_trans_free_extent(*tp, efd, free->xbfi_startblock,
-                                              free->xbfi_blockcount);
-                if (error)
-                        return error;
-
-                xfs_bmap_del_free(flist, free);
-        }
-
-        return 0;
-}
-
 int
 xfs_bmap_rtalloc(
         struct xfs_bmalloca     *ap)    /* bmap alloc argument struct */
@@ -214,9 +127,9 @@ xfs_bmap_rtalloc(
         /*
          * Lock out modifications to both the RT bitmap and summary inodes
          */
-        xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL);
+        xfs_ilock(mp->m_rbmip, XFS_ILOCK_EXCL|XFS_ILOCK_RTBITMAP);
         xfs_trans_ijoin(ap->tp, mp->m_rbmip, XFS_ILOCK_EXCL);
-        xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL);
+        xfs_ilock(mp->m_rsumip, XFS_ILOCK_EXCL|XFS_ILOCK_RTSUM);
         xfs_trans_ijoin(ap->tp, mp->m_rsumip, XFS_ILOCK_EXCL);
 
         /*
@@ -773,7 +686,7 @@ xfs_bmap_punch_delalloc_range(
                 xfs_bmbt_irec_t imap;
                 int             nimaps = 1;
                 xfs_fsblock_t   firstblock;
-                xfs_bmap_free_t flist;
+                struct xfs_defer_ops dfops;
 
                 /*
                  * Map the range first and check that it is a delalloc extent
@@ -804,18 +717,18 @@ xfs_bmap_punch_delalloc_range(
                 WARN_ON(imap.br_blockcount == 0);
 
                 /*
-                 * Note: while we initialise the firstblock/flist pair, they
+                 * Note: while we initialise the firstblock/dfops pair, they
                  * should never be used because blocks should never be
                  * allocated or freed for a delalloc extent and hence we need
                  * don't cancel or finish them after the xfs_bunmapi() call.
                  */
-                xfs_bmap_init(&flist, &firstblock);
+                xfs_defer_init(&dfops, &firstblock);
                 error = xfs_bunmapi(NULL, ip, start_fsb, 1, 0, 1, &firstblock,
-                                        &flist, &done);
+                                        &dfops, &done);
                 if (error)
                         break;
 
-                ASSERT(!flist.xbf_count && list_empty(&flist.xbf_flist));
+                ASSERT(!xfs_defer_has_unfinished_work(&dfops));
 next_block:
                 start_fsb++;
                 remaining--;
@@ -972,7 +885,7 @@ xfs_alloc_file_space(
         int                     rt;
         xfs_trans_t             *tp;
         xfs_bmbt_irec_t         imaps[1], *imapp;
-        xfs_bmap_free_t         free_list;
+        struct xfs_defer_ops    dfops;
         uint                    qblocks, resblks, resrtextents;
         int                     error;
 
@@ -1063,17 +976,17 @@ xfs_alloc_file_space(
 
                 xfs_trans_ijoin(tp, ip, 0);
 
-                xfs_bmap_init(&free_list, &firstfsb);
+                xfs_defer_init(&dfops, &firstfsb);
                 error = xfs_bmapi_write(tp, ip, startoffset_fsb,
                                         allocatesize_fsb, alloc_type, &firstfsb,
-                                        resblks, imapp, &nimaps, &free_list);
+                                        resblks, imapp, &nimaps, &dfops);
                 if (error)
                         goto error0;
 
                 /*
                  * Complete the transaction
                  */
-                error = xfs_bmap_finish(&tp, &free_list, NULL);
+                error = xfs_defer_finish(&tp, &dfops, NULL);
                 if (error)
                         goto error0;
 
@@ -1096,7 +1009,7 @@ xfs_alloc_file_space(
         return error;
 
 error0: /* Cancel bmap, unlock inode, unreserve quota blocks, cancel trans */
-        xfs_bmap_cancel(&free_list);
+        xfs_defer_cancel(&dfops);
         xfs_trans_unreserve_quota_nblks(tp, ip, (long)qblocks, 0, quota_flag);
 
 error1: /* Just cancel transaction */
@@ -1114,7 +1027,7 @@ xfs_unmap_extent(
 {
         struct xfs_mount        *mp = ip->i_mount;
         struct xfs_trans        *tp;
-        struct xfs_bmap_free    free_list;
+        struct xfs_defer_ops    dfops;
         xfs_fsblock_t           firstfsb;
         uint                    resblks = XFS_DIOSTRAT_SPACE_RES(mp, 0);
         int                     error;
@@ -1133,13 +1046,13 @@ xfs_unmap_extent(
 
         xfs_trans_ijoin(tp, ip, 0);
 
-        xfs_bmap_init(&free_list, &firstfsb);
+        xfs_defer_init(&dfops, &firstfsb);
         error = xfs_bunmapi(tp, ip, startoffset_fsb, len_fsb, 0, 2, &firstfsb,
-                        &free_list, done);
+                        &dfops, done);
         if (error)
                 goto out_bmap_cancel;
 
-        error = xfs_bmap_finish(&tp, &free_list, NULL);
+        error = xfs_defer_finish(&tp, &dfops, ip);
         if (error)
                 goto out_bmap_cancel;
 
@@ -1149,7 +1062,7 @@ out_unlock:
         return error;
 
 out_bmap_cancel:
-        xfs_bmap_cancel(&free_list);
+        xfs_defer_cancel(&dfops);
 out_trans_cancel:
         xfs_trans_cancel(tp);
         goto out_unlock;
@@ -1338,7 +1251,7 @@ xfs_shift_file_space(
         struct xfs_mount        *mp = ip->i_mount;
         struct xfs_trans        *tp;
         int                     error;
-        struct xfs_bmap_free    free_list;
+        struct xfs_defer_ops    dfops;
         xfs_fsblock_t           first_block;
         xfs_fileoff_t           stop_fsb;
         xfs_fileoff_t           next_fsb;
@@ -1416,19 +1329,19 @@ xfs_shift_file_space(
 
                 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
 
-                xfs_bmap_init(&free_list, &first_block);
+                xfs_defer_init(&dfops, &first_block);
 
                 /*
                  * We are using the write transaction in which max 2 bmbt
                  * updates are allowed
                  */
                 error = xfs_bmap_shift_extents(tp, ip, &next_fsb, shift_fsb,
-                                &done, stop_fsb, &first_block, &free_list,
+                                &done, stop_fsb, &first_block, &dfops,
                                 direction, XFS_BMAP_MAX_SHIFT_EXTENTS);
                 if (error)
                         goto out_bmap_cancel;
 
-                error = xfs_bmap_finish(&tp, &free_list, NULL);
+                error = xfs_defer_finish(&tp, &dfops, NULL);
                 if (error)
                         goto out_bmap_cancel;
 
@@ -1438,7 +1351,7 @@ xfs_shift_file_space(
         return error;
 
 out_bmap_cancel:
-        xfs_bmap_cancel(&free_list);
+        xfs_defer_cancel(&dfops);
 out_trans_cancel:
         xfs_trans_cancel(tp);
         return error;
@@ -1622,6 +1535,10 @@ xfs_swap_extents(
         __uint64_t      tmp;
         int             lock_flags;
 
+        /* XXX: we can't do this with rmap, will fix later */
+        if (xfs_sb_version_hasrmapbt(&mp->m_sb))
+                return -EOPNOTSUPP;
+
         tempifp = kmem_alloc(sizeof(xfs_ifork_t), KM_MAYFAIL);
         if (!tempifp) {
                 error = -ENOMEM;
diff --git a/fs/xfs/xfs_bmap_util.h b/fs/xfs/xfs_bmap_util.h
index f20071432ca6..68a621a8e0c0 100644
--- a/fs/xfs/xfs_bmap_util.h
+++ b/fs/xfs/xfs_bmap_util.h
@@ -21,7 +21,7 @@
 /* Kernel only BMAP related definitions and functions */
 
 struct xfs_bmbt_irec;
-struct xfs_bmap_free_item;
+struct xfs_extent_free_item;
 struct xfs_ifork;
 struct xfs_inode;
 struct xfs_mount;
@@ -40,8 +40,6 @@ int	xfs_getbmap(struct xfs_inode *ip, struct getbmapx *bmv,
                 xfs_bmap_format_t formatter, void *arg);
 
 /* functions in xfs_bmap.c that are only needed by xfs_bmap_util.c */
-void    xfs_bmap_del_free(struct xfs_bmap_free *flist,
-                          struct xfs_bmap_free_item *free);
 int     xfs_bmap_extsize_align(struct xfs_mount *mp, struct xfs_bmbt_irec *gotp,
                                struct xfs_bmbt_irec *prevp, xfs_extlen_t extsz,
                                int rt, int eof, int delay, int convert,
diff --git a/fs/xfs/xfs_discard.c b/fs/xfs/xfs_discard.c
index 272c3f8b6f7d..4ff499aa7338 100644
--- a/fs/xfs/xfs_discard.c
+++ b/fs/xfs/xfs_discard.c
@@ -179,7 +179,7 @@ xfs_ioc_trim(
          * matter as trimming blocks is an advisory interface.
          */
         if (range.start >= XFS_FSB_TO_B(mp, mp->m_sb.sb_dblocks) ||
-            range.minlen > XFS_FSB_TO_B(mp, XFS_ALLOC_AG_MAX_USABLE(mp)) ||
+            range.minlen > XFS_FSB_TO_B(mp, mp->m_ag_max_usable) ||
             range.len < mp->m_sb.sb_blocksize)
                 return -EINVAL;
 
diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index ccb0811963b2..7a30b8f11db7 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -23,6 +23,7 @@
 #include "xfs_trans_resv.h"
 #include "xfs_bit.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_inode.h"
 #include "xfs_bmap.h"
 #include "xfs_bmap_util.h"
@@ -307,7 +308,7 @@ xfs_qm_dqalloc(
         xfs_buf_t       **O_bpp)
 {
         xfs_fsblock_t   firstblock;
-        xfs_bmap_free_t flist;
+        struct xfs_defer_ops dfops;
         xfs_bmbt_irec_t map;
         int             nmaps, error;
         xfs_buf_t       *bp;
@@ -320,7 +321,7 @@ xfs_qm_dqalloc(
         /*
          * Initialize the bmap freelist prior to calling bmapi code.
          */
-        xfs_bmap_init(&flist, &firstblock);
+        xfs_defer_init(&dfops, &firstblock);
         xfs_ilock(quotip, XFS_ILOCK_EXCL);
         /*
          * Return if this type of quotas is turned off while we didn't
@@ -336,7 +337,7 @@ xfs_qm_dqalloc(
         error = xfs_bmapi_write(tp, quotip, offset_fsb,
                                 XFS_DQUOT_CLUSTER_SIZE_FSB, XFS_BMAPI_METADATA,
                                 &firstblock, XFS_QM_DQALLOC_SPACE_RES(mp),
-                                &map, &nmaps, &flist);
+                                &map, &nmaps, &dfops);
         if (error)
                 goto error0;
         ASSERT(map.br_blockcount == XFS_DQUOT_CLUSTER_SIZE_FSB);
@@ -368,7 +369,7 @@ xfs_qm_dqalloc(
                               dqp->dq_flags & XFS_DQ_ALLTYPES, bp);
 
         /*
-         * xfs_bmap_finish() may commit the current transaction and
+         * xfs_defer_finish() may commit the current transaction and
          * start a second transaction if the freelist is not empty.
          *
          * Since we still want to modify this buffer, we need to
@@ -382,7 +383,7 @@ xfs_qm_dqalloc(
 
         xfs_trans_bhold(tp, bp);
 
-        error = xfs_bmap_finish(tpp, &flist, NULL);
+        error = xfs_defer_finish(tpp, &dfops, NULL);
         if (error)
                 goto error1;
 
@@ -398,7 +399,7 @@ xfs_qm_dqalloc(
         return 0;
 
 error1:
-        xfs_bmap_cancel(&flist);
+        xfs_defer_cancel(&dfops);
 error0:
         xfs_iunlock(quotip, XFS_ILOCK_EXCL);
 
diff --git a/fs/xfs/xfs_error.h b/fs/xfs/xfs_error.h
index 2e4f67f68856..3d224702fbc0 100644
--- a/fs/xfs/xfs_error.h
+++ b/fs/xfs/xfs_error.h
@@ -90,7 +90,9 @@ extern void xfs_verifier_error(struct xfs_buf *bp);
 #define XFS_ERRTAG_STRATCMPL_IOERR                      19
 #define XFS_ERRTAG_DIOWRITE_IOERR                       20
 #define XFS_ERRTAG_BMAPIFORMAT                          21
-#define XFS_ERRTAG_MAX                                  22
+#define XFS_ERRTAG_FREE_EXTENT                          22
+#define XFS_ERRTAG_RMAP_FINISH_ONE                      23
+#define XFS_ERRTAG_MAX                                  24
 
 /*
  * Random factors for above tags, 1 means always, 2 means 1/2 time, etc.
@@ -117,6 +119,8 @@ extern void xfs_verifier_error(struct xfs_buf *bp);
 #define XFS_RANDOM_STRATCMPL_IOERR                      (XFS_RANDOM_DEFAULT/10)
 #define XFS_RANDOM_DIOWRITE_IOERR                       (XFS_RANDOM_DEFAULT/10)
 #define XFS_RANDOM_BMAPIFORMAT                          XFS_RANDOM_DEFAULT
+#define XFS_RANDOM_FREE_EXTENT                          1
+#define XFS_RANDOM_RMAP_FINISH_ONE                      1
 
 #ifdef DEBUG
 extern int xfs_error_test_active;
diff --git a/fs/xfs/xfs_extfree_item.c b/fs/xfs/xfs_extfree_item.c
index ab779460ecbf..d7bc14906af8 100644
--- a/fs/xfs/xfs_extfree_item.c
+++ b/fs/xfs/xfs_extfree_item.c
@@ -20,12 +20,15 @@
 #include "xfs_format.h"
 #include "xfs_log_format.h"
 #include "xfs_trans_resv.h"
+#include "xfs_bit.h"
 #include "xfs_mount.h"
 #include "xfs_trans.h"
 #include "xfs_trans_priv.h"
 #include "xfs_buf_item.h"
 #include "xfs_extfree_item.h"
 #include "xfs_log.h"
+#include "xfs_btree.h"
+#include "xfs_rmap.h"
 
 
 kmem_zone_t     *xfs_efi_zone;
@@ -486,3 +489,69 @@ xfs_efd_init(
 
         return efdp;
 }
+
+/*
+ * Process an extent free intent item that was recovered from
+ * the log.  We need to free the extents that it describes.
+ */
+int
+xfs_efi_recover(
+        struct xfs_mount        *mp,
+        struct xfs_efi_log_item *efip)
+{
+        struct xfs_efd_log_item *efdp;
+        struct xfs_trans        *tp;
+        int                     i;
+        int                     error = 0;
+        xfs_extent_t            *extp;
+        xfs_fsblock_t           startblock_fsb;
+        struct xfs_owner_info   oinfo;
+
+        ASSERT(!test_bit(XFS_EFI_RECOVERED, &efip->efi_flags));
+
+        /*
+         * First check the validity of the extents described by the
+         * EFI.  If any are bad, then assume that all are bad and
+         * just toss the EFI.
+         */
+        for (i = 0; i < efip->efi_format.efi_nextents; i++) {
+                extp = &efip->efi_format.efi_extents[i];
+                startblock_fsb = XFS_BB_TO_FSB(mp,
+                                   XFS_FSB_TO_DADDR(mp, extp->ext_start));
+                if (startblock_fsb == 0 ||
+                    extp->ext_len == 0 ||
+                    startblock_fsb >= mp->m_sb.sb_dblocks ||
+                    extp->ext_len >= mp->m_sb.sb_agblocks) {
+                        /*
+                         * This will pull the EFI from the AIL and
+                         * free the memory associated with it.
+                         */
+                        set_bit(XFS_EFI_RECOVERED, &efip->efi_flags);
+                        xfs_efi_release(efip);
+                        return -EIO;
+                }
+        }
+
+        error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
+        if (error)
+                return error;
+        efdp = xfs_trans_get_efd(tp, efip, efip->efi_format.efi_nextents);
+
+        xfs_rmap_skip_owner_update(&oinfo);
+        for (i = 0; i < efip->efi_format.efi_nextents; i++) {
+                extp = &efip->efi_format.efi_extents[i];
+                error = xfs_trans_free_extent(tp, efdp, extp->ext_start,
+                                              extp->ext_len, &oinfo);
+                if (error)
+                        goto abort_error;
+
+        }
+
+        set_bit(XFS_EFI_RECOVERED, &efip->efi_flags);
+        error = xfs_trans_commit(tp);
+        return error;
+
+abort_error:
+        xfs_trans_cancel(tp);
+        return error;
+}
diff --git a/fs/xfs/xfs_extfree_item.h b/fs/xfs/xfs_extfree_item.h
index 8fa8651705e1..a32c794a86b7 100644
--- a/fs/xfs/xfs_extfree_item.h
+++ b/fs/xfs/xfs_extfree_item.h
@@ -98,4 +98,7 @@ int			xfs_efi_copy_format(xfs_log_iovec_t *buf,
 void                    xfs_efi_item_free(xfs_efi_log_item_t *);
 void                    xfs_efi_release(struct xfs_efi_log_item *);
 
+int                     xfs_efi_recover(struct xfs_mount *mp,
+                                        struct xfs_efi_log_item *efip);
+
 #endif  /* __XFS_EXTFREE_ITEM_H__ */
diff --git a/fs/xfs/xfs_filestream.c b/fs/xfs/xfs_filestream.c
index a51353a1f87f..4a33a3304369 100644
--- a/fs/xfs/xfs_filestream.c
+++ b/fs/xfs/xfs_filestream.c
@@ -22,6 +22,7 @@
 #include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_inode.h"
 #include "xfs_bmap.h"
 #include "xfs_bmap_util.h"
@@ -385,7 +386,7 @@ xfs_filestream_new_ag(
         }
 
         flags = (ap->userdata ? XFS_PICK_USERDATA : 0) |
-                (ap->flist->xbf_low ? XFS_PICK_LOWSPACE : 0);
+                (ap->dfops->dop_low ? XFS_PICK_LOWSPACE : 0);
 
         err = xfs_filestream_pick_ag(pip, startag, agp, flags, minlen);
 
diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index 7191c3878b4a..0f96847b90e1 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -23,6 +23,7 @@
 #include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_da_format.h"
 #include "xfs_da_btree.h"
 #include "xfs_inode.h"
@@ -32,6 +33,7 @@
 #include "xfs_btree.h"
 #include "xfs_alloc_btree.h"
 #include "xfs_alloc.h"
+#include "xfs_rmap_btree.h"
 #include "xfs_ialloc.h"
 #include "xfs_fsops.h"
 #include "xfs_itable.h"
@@ -40,6 +42,7 @@
 #include "xfs_trace.h"
 #include "xfs_log.h"
 #include "xfs_filestream.h"
+#include "xfs_rmap.h"
 
 /*
  * File system operations
@@ -103,7 +106,9 @@ xfs_fs_geometry(
                         (xfs_sb_version_hasfinobt(&mp->m_sb) ?
                                 XFS_FSOP_GEOM_FLAGS_FINOBT : 0) |
                         (xfs_sb_version_hassparseinodes(&mp->m_sb) ?
-                                XFS_FSOP_GEOM_FLAGS_SPINODES : 0);
+                                XFS_FSOP_GEOM_FLAGS_SPINODES : 0) |
+                        (xfs_sb_version_hasrmapbt(&mp->m_sb) ?
+                                XFS_FSOP_GEOM_FLAGS_RMAPBT : 0);
                 geo->logsectsize = xfs_sb_version_hassector(&mp->m_sb) ?
                                 mp->m_sb.sb_logsectsize : BBSIZE;
                 geo->rtsectsize = mp->m_sb.sb_blocksize;
@@ -239,10 +244,16 @@ xfs_growfs_data_private(
                 agf->agf_roots[XFS_BTNUM_CNTi] = cpu_to_be32(XFS_CNT_BLOCK(mp));
                 agf->agf_levels[XFS_BTNUM_BNOi] = cpu_to_be32(1);
                 agf->agf_levels[XFS_BTNUM_CNTi] = cpu_to_be32(1);
+                if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
+                        agf->agf_roots[XFS_BTNUM_RMAPi] =
+                                                cpu_to_be32(XFS_RMAP_BLOCK(mp));
+                        agf->agf_levels[XFS_BTNUM_RMAPi] = cpu_to_be32(1);
+                }
+
                 agf->agf_flfirst = cpu_to_be32(1);
                 agf->agf_fllast = 0;
                 agf->agf_flcount = 0;
-                tmpsize = agsize - XFS_PREALLOC_BLOCKS(mp);
+                tmpsize = agsize - mp->m_ag_prealloc_blocks;
                 agf->agf_freeblks = cpu_to_be32(tmpsize);
                 agf->agf_longest = cpu_to_be32(tmpsize);
                 if (xfs_sb_version_hascrc(&mp->m_sb))
@@ -339,7 +350,7 @@ xfs_growfs_data_private(
                                                 agno, 0);
 
                 arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
-                arec->ar_startblock = cpu_to_be32(XFS_PREALLOC_BLOCKS(mp));
+                arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
                 arec->ar_blockcount = cpu_to_be32(
                         agsize - be32_to_cpu(arec->ar_startblock));
 
@@ -368,7 +379,7 @@ xfs_growfs_data_private(
                                                 agno, 0);
 
                 arec = XFS_ALLOC_REC_ADDR(mp, XFS_BUF_TO_BLOCK(bp), 1);
-                arec->ar_startblock = cpu_to_be32(XFS_PREALLOC_BLOCKS(mp));
+                arec->ar_startblock = cpu_to_be32(mp->m_ag_prealloc_blocks);
                 arec->ar_blockcount = cpu_to_be32(
                         agsize - be32_to_cpu(arec->ar_startblock));
                 nfree += be32_to_cpu(arec->ar_blockcount);
@@ -378,6 +389,72 @@ xfs_growfs_data_private(
                 if (error)
                         goto error0;
 
+                /* RMAP btree root block */
+                if (xfs_sb_version_hasrmapbt(&mp->m_sb)) {
+                        struct xfs_rmap_rec     *rrec;
+                        struct xfs_btree_block  *block;
+
+                        bp = xfs_growfs_get_hdr_buf(mp,
+                                XFS_AGB_TO_DADDR(mp, agno, XFS_RMAP_BLOCK(mp)),
+                                BTOBB(mp->m_sb.sb_blocksize), 0,
+                                &xfs_rmapbt_buf_ops);
+                        if (!bp) {
+                                error = -ENOMEM;
+                                goto error0;
+                        }
+
+                        xfs_btree_init_block(mp, bp, XFS_RMAP_CRC_MAGIC, 0, 0,
+                                                agno, XFS_BTREE_CRC_BLOCKS);
+                        block = XFS_BUF_TO_BLOCK(bp);
+
+
+                        /*
+                         * mark the AG header regions as static metadata The BNO
+                         * btree block is the first block after the headers, so
+                         * it's location defines the size of region the static
+                         * metadata consumes.
+                         *
+                         * Note: unlike mkfs, we never have to account for log
+                         * space when growing the data regions
+                         */
+                        rrec = XFS_RMAP_REC_ADDR(block, 1);
+                        rrec->rm_startblock = 0;
+                        rrec->rm_blockcount = cpu_to_be32(XFS_BNO_BLOCK(mp));
+                        rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_FS);
+                        rrec->rm_offset = 0;
+                        be16_add_cpu(&block->bb_numrecs, 1);
+
+                        /* account freespace btree root blocks */
+                        rrec = XFS_RMAP_REC_ADDR(block, 2);
+                        rrec->rm_startblock = cpu_to_be32(XFS_BNO_BLOCK(mp));
+                        rrec->rm_blockcount = cpu_to_be32(2);
+                        rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
+                        rrec->rm_offset = 0;
+                        be16_add_cpu(&block->bb_numrecs, 1);
+
+                        /* account inode btree root blocks */
+                        rrec = XFS_RMAP_REC_ADDR(block, 3);
+                        rrec->rm_startblock = cpu_to_be32(XFS_IBT_BLOCK(mp));
+                        rrec->rm_blockcount = cpu_to_be32(XFS_RMAP_BLOCK(mp) -
+                                                        XFS_IBT_BLOCK(mp));
+                        rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_INOBT);
+                        rrec->rm_offset = 0;
+                        be16_add_cpu(&block->bb_numrecs, 1);
+
+                        /* account for rmap btree root */
+                        rrec = XFS_RMAP_REC_ADDR(block, 4);
+                        rrec->rm_startblock = cpu_to_be32(XFS_RMAP_BLOCK(mp));
+                        rrec->rm_blockcount = cpu_to_be32(1);
+                        rrec->rm_owner = cpu_to_be64(XFS_RMAP_OWN_AG);
+                        rrec->rm_offset = 0;
+                        be16_add_cpu(&block->bb_numrecs, 1);
+
+                        error = xfs_bwrite(bp);
+                        xfs_buf_relse(bp);
+                        if (error)
+                                goto error0;
+                }
+
                 /*
                  * INO btree root block
                  */
@@ -435,6 +512,8 @@ xfs_growfs_data_private(
          * There are new blocks in the old last a.g.
          */
         if (new) {
+                struct xfs_owner_info   oinfo;
+
                 /*
                  * Change the agi length.
                  */
@@ -462,14 +541,20 @@ xfs_growfs_data_private(
                        be32_to_cpu(agi->agi_length));
 
                 xfs_alloc_log_agf(tp, bp, XFS_AGF_LENGTH);
+
                 /*
                  * Free the new space.
+                 *
+                 * XFS_RMAP_OWN_NULL is used here to tell the rmap btree that
+                 * this doesn't actually exist in the rmap btree.
                  */
-                error = xfs_free_extent(tp, XFS_AGB_TO_FSB(mp, agno,
-                        be32_to_cpu(agf->agf_length) - new), new);
-                if (error) {
+                xfs_rmap_ag_owner(&oinfo, XFS_RMAP_OWN_NULL);
+                error = xfs_free_extent(tp,
+                                XFS_AGB_TO_FSB(mp, agno,
+                                        be32_to_cpu(agf->agf_length) - new),
+                                new, &oinfo);
+                if (error)
                         goto error0;
-                }
         }
 
         /*
@@ -501,6 +586,7 @@ xfs_growfs_data_private(
         } else
                 mp->m_maxicount = 0;
         xfs_set_low_space_thresholds(mp);
+        mp->m_alloc_set_aside = xfs_alloc_set_aside(mp);
 
         /* update secondary superblocks. */
         for (agno = 1; agno < nagcount; agno++) {
@@ -638,7 +724,7 @@ xfs_fs_counts(
         cnt->allocino = percpu_counter_read_positive(&mp->m_icount);
         cnt->freeino = percpu_counter_read_positive(&mp->m_ifree);
         cnt->freedata = percpu_counter_read_positive(&mp->m_fdblocks) -
-                                                        XFS_ALLOC_SET_ASIDE(mp);
+                                                mp->m_alloc_set_aside;
 
         spin_lock(&mp->m_sb_lock);
         cnt->freertx = mp->m_sb.sb_frextents;
@@ -726,7 +812,7 @@ xfs_reserve_blocks(
         error = -ENOSPC;
         do {
                 free = percpu_counter_sum(&mp->m_fdblocks) -
-                                                        XFS_ALLOC_SET_ASIDE(mp);
+                                                mp->m_alloc_set_aside;
                 if (!free)
                         break;
 
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index 8825bcfd314c..e08eaea6327b 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -25,6 +25,7 @@
 #include "xfs_trans_resv.h"
 #include "xfs_sb.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_inode.h"
 #include "xfs_da_format.h"
 #include "xfs_da_btree.h"
@@ -1122,7 +1123,7 @@ xfs_create(
         struct xfs_inode        *ip = NULL;
         struct xfs_trans        *tp = NULL;
         int                     error;
-        xfs_bmap_free_t         free_list;
+        struct xfs_defer_ops    dfops;
         xfs_fsblock_t           first_block;
         bool                    unlock_dp_on_error = false;
         prid_t                  prid;
@@ -1182,7 +1183,7 @@ xfs_create(
                       XFS_IOLOCK_PARENT | XFS_ILOCK_PARENT);
         unlock_dp_on_error = true;
 
-        xfs_bmap_init(&free_list, &first_block);
+        xfs_defer_init(&dfops, &first_block);
 
         /*
          * Reserve disk quota and the inode.
@@ -1219,7 +1220,7 @@ xfs_create(
         unlock_dp_on_error = false;
 
         error = xfs_dir_createname(tp, dp, name, ip->i_ino,
-                                        &first_block, &free_list, resblks ?
+                                        &first_block, &dfops, resblks ?
                                         resblks - XFS_IALLOC_SPACE_RES(mp) : 0);
         if (error) {
                 ASSERT(error != -ENOSPC);
@@ -1253,7 +1254,7 @@ xfs_create(
          */
         xfs_qm_vop_create_dqattach(tp, ip, udqp, gdqp, pdqp);
 
-        error = xfs_bmap_finish(&tp, &free_list, NULL);
+        error = xfs_defer_finish(&tp, &dfops, NULL);
         if (error)
                 goto out_bmap_cancel;
 
@@ -1269,7 +1270,7 @@ xfs_create(
         return 0;
 
  out_bmap_cancel:
-        xfs_bmap_cancel(&free_list);
+        xfs_defer_cancel(&dfops);
  out_trans_cancel:
         xfs_trans_cancel(tp);
  out_release_inode:
@@ -1401,7 +1402,7 @@ xfs_link(
         xfs_mount_t             *mp = tdp->i_mount;
         xfs_trans_t             *tp;
         int                     error;
-        xfs_bmap_free_t         free_list;
+        struct xfs_defer_ops    dfops;
         xfs_fsblock_t           first_block;
         int                     resblks;
 
@@ -1452,7 +1453,7 @@ xfs_link(
                         goto error_return;
         }
 
-        xfs_bmap_init(&free_list, &first_block);
+        xfs_defer_init(&dfops, &first_block);
 
         /*
          * Handle initial link state of O_TMPFILE inode
@@ -1464,7 +1465,7 @@ xfs_link(
         }
 
         error = xfs_dir_createname(tp, tdp, target_name, sip->i_ino,
-                                        &first_block, &free_list, resblks);
+                                        &first_block, &dfops, resblks);
         if (error)
                 goto error_return;
         xfs_trans_ichgtime(tp, tdp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
@@ -1482,9 +1483,9 @@ xfs_link(
         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
                 xfs_trans_set_sync(tp);
 
-        error = xfs_bmap_finish(&tp, &free_list, NULL);
+        error = xfs_defer_finish(&tp, &dfops, NULL);
         if (error) {
-                xfs_bmap_cancel(&free_list);
+                xfs_defer_cancel(&dfops);
                 goto error_return;
         }
 
@@ -1526,7 +1527,7 @@ xfs_itruncate_extents(
 {
         struct xfs_mount        *mp = ip->i_mount;
         struct xfs_trans        *tp = *tpp;
-        xfs_bmap_free_t         free_list;
+        struct xfs_defer_ops    dfops;
         xfs_fsblock_t           first_block;
         xfs_fileoff_t           first_unmap_block;
         xfs_fileoff_t           last_block;
@@ -1562,12 +1563,12 @@ xfs_itruncate_extents(
         ASSERT(first_unmap_block < last_block);
         unmap_len = last_block - first_unmap_block + 1;
         while (!done) {
-                xfs_bmap_init(&free_list, &first_block);
+                xfs_defer_init(&dfops, &first_block);
                 error = xfs_bunmapi(tp, ip,
                                     first_unmap_block, unmap_len,
                                     xfs_bmapi_aflag(whichfork),
                                     XFS_ITRUNC_MAX_EXTENTS,
-                                    &first_block, &free_list,
+                                    &first_block, &dfops,
                                     &done);
                 if (error)
                         goto out_bmap_cancel;
@@ -1576,7 +1577,7 @@ xfs_itruncate_extents(
                  * Duplicate the transaction that has the permanent
                  * reservation and commit the old transaction.
                  */
-                error = xfs_bmap_finish(&tp, &free_list, ip);
+                error = xfs_defer_finish(&tp, &dfops, ip);
                 if (error)
                         goto out_bmap_cancel;
 
@@ -1602,7 +1603,7 @@ out_bmap_cancel:
          * the transaction can be properly aborted.  We just need to make sure
          * we're not holding any resources that we were not when we came in.
          */
-        xfs_bmap_cancel(&free_list);
+        xfs_defer_cancel(&dfops);
         goto out;
 }
 
@@ -1743,7 +1744,7 @@ STATIC int
 xfs_inactive_ifree(
         struct xfs_inode *ip)
 {
-        xfs_bmap_free_t         free_list;
+        struct xfs_defer_ops    dfops;
         xfs_fsblock_t           first_block;
         struct xfs_mount        *mp = ip->i_mount;
         struct xfs_trans        *tp;
@@ -1780,8 +1781,8 @@ xfs_inactive_ifree(
         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);
+        xfs_defer_init(&dfops, &first_block);
+        error = xfs_ifree(tp, ip, &dfops);
         if (error) {
                 /*
                  * If we fail to free the inode, shut down.  The cancel
@@ -1807,11 +1808,11 @@ xfs_inactive_ifree(
          * 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, NULL);
+        error = xfs_defer_finish(&tp, &dfops, NULL);
         if (error) {
-                xfs_notice(mp, "%s: xfs_bmap_finish returned error %d",
+                xfs_notice(mp, "%s: xfs_defer_finish returned error %d",
                         __func__, error);
-                xfs_bmap_cancel(&free_list);
+                xfs_defer_cancel(&dfops);
         }
         error = xfs_trans_commit(tp);
         if (error)
@@ -2367,7 +2368,7 @@ int
 xfs_ifree(
         xfs_trans_t     *tp,
         xfs_inode_t     *ip,
-        xfs_bmap_free_t *flist)
+        struct xfs_defer_ops    *dfops)
 {
         int                     error;
         struct xfs_icluster     xic = { 0 };
@@ -2386,7 +2387,7 @@ xfs_ifree(
         if (error)
                 return error;
 
-        error = xfs_difree(tp, ip->i_ino, flist, &xic);
+        error = xfs_difree(tp, ip->i_ino, dfops, &xic);
         if (error)
                 return error;
 
@@ -2474,7 +2475,7 @@ xfs_iunpin_wait(
  * 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
+ * get to xfs_defer_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.
@@ -2489,7 +2490,7 @@ xfs_remove(
         xfs_trans_t             *tp = NULL;
         int                     is_dir = S_ISDIR(VFS_I(ip)->i_mode);
         int                     error = 0;
-        xfs_bmap_free_t         free_list;
+        struct xfs_defer_ops    dfops;
         xfs_fsblock_t           first_block;
         uint                    resblks;
 
@@ -2571,9 +2572,9 @@ xfs_remove(
         if (error)
                 goto out_trans_cancel;
 
-        xfs_bmap_init(&free_list, &first_block);
+        xfs_defer_init(&dfops, &first_block);
         error = xfs_dir_removename(tp, dp, name, ip->i_ino,
-                                        &first_block, &free_list, resblks);
+                                        &first_block, &dfops, resblks);
         if (error) {
                 ASSERT(error != -ENOENT);
                 goto out_bmap_cancel;
@@ -2587,7 +2588,7 @@ xfs_remove(
         if (mp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
                 xfs_trans_set_sync(tp);
 
-        error = xfs_bmap_finish(&tp, &free_list, NULL);
+        error = xfs_defer_finish(&tp, &dfops, NULL);
         if (error)
                 goto out_bmap_cancel;
 
@@ -2601,7 +2602,7 @@ xfs_remove(
         return 0;
 
  out_bmap_cancel:
-        xfs_bmap_cancel(&free_list);
+        xfs_defer_cancel(&dfops);
  out_trans_cancel:
         xfs_trans_cancel(tp);
  std_return:
@@ -2662,7 +2663,7 @@ xfs_sort_for_rename(
 static int
 xfs_finish_rename(
         struct xfs_trans        *tp,
-        struct xfs_bmap_free    *free_list)
+        struct xfs_defer_ops    *dfops)
 {
         int                     error;
 
@@ -2673,9 +2674,9 @@ xfs_finish_rename(
         if (tp->t_mountp->m_flags & (XFS_MOUNT_WSYNC|XFS_MOUNT_DIRSYNC))
                 xfs_trans_set_sync(tp);
 
-        error = xfs_bmap_finish(&tp, free_list, NULL);
+        error = xfs_defer_finish(&tp, dfops, NULL);
         if (error) {
-                xfs_bmap_cancel(free_list);
+                xfs_defer_cancel(dfops);
                 xfs_trans_cancel(tp);
                 return error;
         }
@@ -2697,7 +2698,7 @@ xfs_cross_rename(
         struct xfs_inode        *dp2,
         struct xfs_name         *name2,
         struct xfs_inode        *ip2,
-        struct xfs_bmap_free    *free_list,
+        struct xfs_defer_ops    *dfops,
         xfs_fsblock_t           *first_block,
         int                     spaceres)
 {
@@ -2709,14 +2710,14 @@ xfs_cross_rename(
         /* Swap inode number for dirent in first parent */
         error = xfs_dir_replace(tp, dp1, name1,
                                 ip2->i_ino,
-                                first_block, free_list, spaceres);
+                                first_block, dfops, spaceres);
         if (error)
                 goto out_trans_abort;
 
         /* Swap inode number for dirent in second parent */
         error = xfs_dir_replace(tp, dp2, name2,
                                 ip1->i_ino,
-                                first_block, free_list, spaceres);
+                                first_block, dfops, spaceres);
         if (error)
                 goto out_trans_abort;
 
@@ -2731,7 +2732,7 @@ xfs_cross_rename(
                 if (S_ISDIR(VFS_I(ip2)->i_mode)) {
                         error = xfs_dir_replace(tp, ip2, &xfs_name_dotdot,
                                                 dp1->i_ino, first_block,
-                                                free_list, spaceres);
+                                                dfops, spaceres);
                         if (error)
                                 goto out_trans_abort;
 
@@ -2758,7 +2759,7 @@ xfs_cross_rename(
                 if (S_ISDIR(VFS_I(ip1)->i_mode)) {
                         error = xfs_dir_replace(tp, ip1, &xfs_name_dotdot,
                                                 dp2->i_ino, first_block,
-                                                free_list, spaceres);
+                                                dfops, spaceres);
                         if (error)
                                 goto out_trans_abort;
 
@@ -2797,10 +2798,10 @@ xfs_cross_rename(
         }
         xfs_trans_ichgtime(tp, dp1, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
         xfs_trans_log_inode(tp, dp1, XFS_ILOG_CORE);
-        return xfs_finish_rename(tp, free_list);
+        return xfs_finish_rename(tp, dfops);
 
 out_trans_abort:
-        xfs_bmap_cancel(free_list);
+        xfs_defer_cancel(dfops);
         xfs_trans_cancel(tp);
         return error;
 }
@@ -2855,7 +2856,7 @@ xfs_rename(
 {
         struct xfs_mount        *mp = src_dp->i_mount;
         struct xfs_trans        *tp;
-        struct xfs_bmap_free    free_list;
+        struct xfs_defer_ops    dfops;
         xfs_fsblock_t           first_block;
         struct xfs_inode        *wip = NULL;            /* whiteout inode */
         struct xfs_inode        *inodes[__XFS_SORT_INODES];
@@ -2944,13 +2945,13 @@ xfs_rename(
                 goto out_trans_cancel;
         }
 
-        xfs_bmap_init(&free_list, &first_block);
+        xfs_defer_init(&dfops, &first_block);
 
         /* RENAME_EXCHANGE is unique from here on. */
         if (flags & RENAME_EXCHANGE)
                 return xfs_cross_rename(tp, src_dp, src_name, src_ip,
                                         target_dp, target_name, target_ip,
-                                        &free_list, &first_block, spaceres);
+                                        &dfops, &first_block, spaceres);
 
         /*
          * Set up the target.
@@ -2972,7 +2973,7 @@ xfs_rename(
                  */
                 error = xfs_dir_createname(tp, target_dp, target_name,
                                                 src_ip->i_ino, &first_block,
-                                                &free_list, spaceres);
+                                                &dfops, spaceres);
                 if (error)
                         goto out_bmap_cancel;
 
@@ -3012,7 +3013,7 @@ xfs_rename(
                  */
                 error = xfs_dir_replace(tp, target_dp, target_name,
                                         src_ip->i_ino,
-                                        &first_block, &free_list, spaceres);
+                                        &first_block, &dfops, spaceres);
                 if (error)
                         goto out_bmap_cancel;
 
@@ -3047,7 +3048,7 @@ xfs_rename(
                  */
                 error = xfs_dir_replace(tp, src_ip, &xfs_name_dotdot,
                                         target_dp->i_ino,
-                                        &first_block, &free_list, spaceres);
+                                        &first_block, &dfops, spaceres);
                 ASSERT(error != -EEXIST);
                 if (error)
                         goto out_bmap_cancel;
@@ -3086,10 +3087,10 @@ xfs_rename(
          */
         if (wip) {
                 error = xfs_dir_replace(tp, src_dp, src_name, wip->i_ino,
-                                        &first_block, &free_list, spaceres);
+                                        &first_block, &dfops, spaceres);
         } else
                 error = xfs_dir_removename(tp, src_dp, src_name, src_ip->i_ino,
-                                           &first_block, &free_list, spaceres);
+                                           &first_block, &dfops, spaceres);
         if (error)
                 goto out_bmap_cancel;
 
@@ -3124,13 +3125,13 @@ xfs_rename(
         if (new_parent)
                 xfs_trans_log_inode(tp, target_dp, XFS_ILOG_CORE);
 
-        error = xfs_finish_rename(tp, &free_list);
+        error = xfs_finish_rename(tp, &dfops);
         if (wip)
                 IRELE(wip);
         return error;
 
 out_bmap_cancel:
-        xfs_bmap_cancel(&free_list);
+        xfs_defer_cancel(&dfops);
 out_trans_cancel:
         xfs_trans_cancel(tp);
 out_release_wip:
diff --git a/fs/xfs/xfs_inode.h b/fs/xfs/xfs_inode.h
index 8eb78ec4a6e2..e1a411e08f00 100644
--- a/fs/xfs/xfs_inode.h
+++ b/fs/xfs/xfs_inode.h
@@ -27,7 +27,7 @@
 struct xfs_dinode;
 struct xfs_inode;
 struct xfs_buf;
-struct xfs_bmap_free;
+struct xfs_defer_ops;
 struct xfs_bmbt_irec;
 struct xfs_inode_log_item;
 struct xfs_mount;
@@ -398,7 +398,7 @@ uint		xfs_ilock_attr_map_shared(struct xfs_inode *);
 
 uint            xfs_ip2xflags(struct xfs_inode *);
 int             xfs_ifree(struct xfs_trans *, xfs_inode_t *,
-                           struct xfs_bmap_free *);
+                           struct xfs_defer_ops *);
 int             xfs_itruncate_extents(struct xfs_trans **, struct xfs_inode *,
                                       int, xfs_fsize_t);
 void            xfs_iext_realloc(xfs_inode_t *, int, int);
diff --git a/fs/xfs/xfs_ioctl.c b/fs/xfs/xfs_ioctl.c
index 9a7c87809d3b..cf46658392ce 100644
--- a/fs/xfs/xfs_ioctl.c
+++ b/fs/xfs/xfs_ioctl.c
@@ -387,6 +387,7 @@ xfs_attrlist_by_handle(
 {
         int                     error = -ENOMEM;
         attrlist_cursor_kern_t  *cursor;
+        struct xfs_fsop_attrlist_handlereq __user       *p = arg;
         xfs_fsop_attrlist_handlereq_t al_hreq;
         struct dentry           *dentry;
         char                    *kbuf;
@@ -419,6 +420,11 @@ xfs_attrlist_by_handle(
         if (error)
                 goto out_kfree;
 
+        if (copy_to_user(&p->pos, cursor, sizeof(attrlist_cursor_kern_t))) {
+                error = -EFAULT;
+                goto out_kfree;
+        }
+
         if (copy_to_user(al_hreq.buffer, kbuf, al_hreq.buflen))
                 error = -EFAULT;
 
diff --git a/fs/xfs/xfs_iomap.c b/fs/xfs/xfs_iomap.c
index 620fc9120444..2114d53df433 100644
--- a/fs/xfs/xfs_iomap.c
+++ b/fs/xfs/xfs_iomap.c
@@ -23,6 +23,7 @@
 #include "xfs_log_format.h"
 #include "xfs_trans_resv.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_inode.h"
 #include "xfs_btree.h"
 #include "xfs_bmap_btree.h"
@@ -128,7 +129,7 @@ xfs_iomap_write_direct(
         int             quota_flag;
         int             rt;
         xfs_trans_t     *tp;
-        xfs_bmap_free_t free_list;
+        struct xfs_defer_ops dfops;
         uint            qblocks, resblks, resrtextents;
         int             error;
         int             lockmode;
@@ -231,18 +232,18 @@ xfs_iomap_write_direct(
          * From this point onwards we overwrite the imap pointer that the
          * caller gave to us.
          */
-        xfs_bmap_init(&free_list, &firstfsb);
+        xfs_defer_init(&dfops, &firstfsb);
         nimaps = 1;
         error = xfs_bmapi_write(tp, ip, offset_fsb, count_fsb,
                                 bmapi_flags, &firstfsb, resblks, imap,
-                                &nimaps, &free_list);
+                                &nimaps, &dfops);
         if (error)
                 goto out_bmap_cancel;
 
         /*
          * Complete the transaction
          */
-        error = xfs_bmap_finish(&tp, &free_list, NULL);
+        error = xfs_defer_finish(&tp, &dfops, NULL);
         if (error)
                 goto out_bmap_cancel;
 
@@ -266,7 +267,7 @@ out_unlock:
         return error;
 
 out_bmap_cancel:
-        xfs_bmap_cancel(&free_list);
+        xfs_defer_cancel(&dfops);
         xfs_trans_unreserve_quota_nblks(tp, ip, (long)qblocks, 0, quota_flag);
 out_trans_cancel:
         xfs_trans_cancel(tp);
@@ -685,7 +686,7 @@ xfs_iomap_write_allocate(
         xfs_fileoff_t   offset_fsb, last_block;
         xfs_fileoff_t   end_fsb, map_start_fsb;
         xfs_fsblock_t   first_block;
-        xfs_bmap_free_t free_list;
+        struct xfs_defer_ops    dfops;
         xfs_filblks_t   count_fsb;
         xfs_trans_t     *tp;
         int             nimaps;
@@ -727,7 +728,7 @@ xfs_iomap_write_allocate(
                         xfs_ilock(ip, XFS_ILOCK_EXCL);
                         xfs_trans_ijoin(tp, ip, 0);
 
-                        xfs_bmap_init(&free_list, &first_block);
+                        xfs_defer_init(&dfops, &first_block);
 
                         /*
                          * it is possible that the extents have changed since
@@ -783,11 +784,11 @@ xfs_iomap_write_allocate(
                         error = xfs_bmapi_write(tp, ip, map_start_fsb,
                                                 count_fsb, 0, &first_block,
                                                 nres, imap, &nimaps,
-                                                &free_list);
+                                                &dfops);
                         if (error)
                                 goto trans_cancel;
 
-                        error = xfs_bmap_finish(&tp, &free_list, NULL);
+                        error = xfs_defer_finish(&tp, &dfops, NULL);
                         if (error)
                                 goto trans_cancel;
 
@@ -821,7 +822,7 @@ xfs_iomap_write_allocate(
         }
 
 trans_cancel:
-        xfs_bmap_cancel(&free_list);
+        xfs_defer_cancel(&dfops);
         xfs_trans_cancel(tp);
 error0:
         xfs_iunlock(ip, XFS_ILOCK_EXCL);
@@ -842,7 +843,7 @@ xfs_iomap_write_unwritten(
         int             nimaps;
         xfs_trans_t     *tp;
         xfs_bmbt_irec_t imap;
-        xfs_bmap_free_t free_list;
+        struct xfs_defer_ops dfops;
         xfs_fsize_t     i_size;
         uint            resblks;
         int             error;
@@ -886,11 +887,11 @@ xfs_iomap_write_unwritten(
                 /*
                  * Modify the unwritten extent state of the buffer.
                  */
-                xfs_bmap_init(&free_list, &firstfsb);
+                xfs_defer_init(&dfops, &firstfsb);
                 nimaps = 1;
                 error = xfs_bmapi_write(tp, ip, offset_fsb, count_fsb,
                                         XFS_BMAPI_CONVERT, &firstfsb, resblks,
-                                        &imap, &nimaps, &free_list);
+                                        &imap, &nimaps, &dfops);
                 if (error)
                         goto error_on_bmapi_transaction;
 
@@ -909,7 +910,7 @@ xfs_iomap_write_unwritten(
                         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
                 }
 
-                error = xfs_bmap_finish(&tp, &free_list, NULL);
+                error = xfs_defer_finish(&tp, &dfops, NULL);
                 if (error)
                         goto error_on_bmapi_transaction;
 
@@ -936,7 +937,7 @@ xfs_iomap_write_unwritten(
         return 0;
 
 error_on_bmapi_transaction:
-        xfs_bmap_cancel(&free_list);
+        xfs_defer_cancel(&dfops);
         xfs_trans_cancel(tp);
         xfs_iunlock(ip, XFS_ILOCK_EXCL);
         return error;
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 835997843846..e8638fd2c0c3 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -43,6 +43,7 @@
 #include "xfs_bmap_btree.h"
 #include "xfs_error.h"
 #include "xfs_dir2.h"
+#include "xfs_rmap_item.h"
 
 #define BLK_AVG(blk1, blk2)     ((blk1+blk2) >> 1)
 
@@ -1911,6 +1912,8 @@ xlog_recover_reorder_trans(
                 case XFS_LI_QUOTAOFF:
                 case XFS_LI_EFD:
                 case XFS_LI_EFI:
+                case XFS_LI_RUI:
+                case XFS_LI_RUD:
                         trace_xfs_log_recover_item_reorder_tail(log,
                                                         trans, item, pass);
                         list_move_tail(&item->ri_list, &inode_list);
@@ -2228,6 +2231,7 @@ xlog_recover_get_buf_lsn(
         case XFS_ABTC_CRC_MAGIC:
         case XFS_ABTB_MAGIC:
         case XFS_ABTC_MAGIC:
+        case XFS_RMAP_CRC_MAGIC:
         case XFS_IBT_CRC_MAGIC:
         case XFS_IBT_MAGIC: {
                 struct xfs_btree_block *btb = blk;
@@ -2396,6 +2400,9 @@ xlog_recover_validate_buf_type(
                 case XFS_BMAP_MAGIC:
                         bp->b_ops = &xfs_bmbt_buf_ops;
                         break;
+                case XFS_RMAP_CRC_MAGIC:
+                        bp->b_ops = &xfs_rmapbt_buf_ops;
+                        break;
                 default:
                         xfs_warn(mp, "Bad btree block magic!");
                         ASSERT(0);
@@ -3415,6 +3422,99 @@ xlog_recover_efd_pass2(
 }
 
 /*
+ * This routine is called to create an in-core extent rmap update
+ * item from the rui format structure which was logged on disk.
+ * It allocates an in-core rui, copies the extents from the format
+ * structure into it, and adds the rui to the AIL with the given
+ * LSN.
+ */
+STATIC int
+xlog_recover_rui_pass2(
+        struct xlog                     *log,
+        struct xlog_recover_item        *item,
+        xfs_lsn_t                       lsn)
+{
+        int                             error;
+        struct xfs_mount                *mp = log->l_mp;
+        struct xfs_rui_log_item         *ruip;
+        struct xfs_rui_log_format       *rui_formatp;
+
+        rui_formatp = item->ri_buf[0].i_addr;
+
+        ruip = xfs_rui_init(mp, rui_formatp->rui_nextents);
+        error = xfs_rui_copy_format(&item->ri_buf[0], &ruip->rui_format);
+        if (error) {
+                xfs_rui_item_free(ruip);
+                return error;
+        }
+        atomic_set(&ruip->rui_next_extent, rui_formatp->rui_nextents);
+
+        spin_lock(&log->l_ailp->xa_lock);
+        /*
+         * The RUI has two references. One for the RUD and one for RUI to ensure
+         * it makes it into the AIL. Insert the RUI into the AIL directly and
+         * drop the RUI reference. Note that xfs_trans_ail_update() drops the
+         * AIL lock.
+         */
+        xfs_trans_ail_update(log->l_ailp, &ruip->rui_item, lsn);
+        xfs_rui_release(ruip);
+        return 0;
+}
+
+
+/*
+ * This routine is called when an RUD format structure is found in a committed
+ * transaction in the log. Its purpose is to cancel the corresponding RUI if it
+ * was still in the log. To do this it searches the AIL for the RUI with an id
+ * equal to that in the RUD format structure. If we find it we drop the RUD
+ * reference, which removes the RUI from the AIL and frees it.
+ */
+STATIC int
+xlog_recover_rud_pass2(
+        struct xlog                     *log,
+        struct xlog_recover_item        *item)
+{
+        struct xfs_rud_log_format       *rud_formatp;
+        struct xfs_rui_log_item         *ruip = NULL;
+        struct xfs_log_item             *lip;
+        __uint64_t                      rui_id;
+        struct xfs_ail_cursor           cur;
+        struct xfs_ail                  *ailp = log->l_ailp;
+
+        rud_formatp = item->ri_buf[0].i_addr;
+        ASSERT(item->ri_buf[0].i_len == sizeof(struct xfs_rud_log_format));
+        rui_id = rud_formatp->rud_rui_id;
+
+        /*
+         * Search for the RUI with the id in the RUD format structure in the
+         * AIL.
+         */
+        spin_lock(&ailp->xa_lock);
+        lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
+        while (lip != NULL) {
+                if (lip->li_type == XFS_LI_RUI) {
+                        ruip = (struct xfs_rui_log_item *)lip;
+                        if (ruip->rui_format.rui_id == rui_id) {
+                                /*
+                                 * Drop the RUD reference to the RUI. This
+                                 * removes the RUI from the AIL and frees it.
+                                 */
+                                spin_unlock(&ailp->xa_lock);
+                                xfs_rui_release(ruip);
+                                spin_lock(&ailp->xa_lock);
+                                break;
+                        }
+                }
+                lip = xfs_trans_ail_cursor_next(ailp, &cur);
+        }
+
+        xfs_trans_ail_cursor_done(&cur);
+        spin_unlock(&ailp->xa_lock);
+
+        return 0;
+}
+
+/*
  * This routine is called when an inode create format structure is found in a
  * committed transaction in the log.  It's purpose is to initialise the inodes
  * being allocated on disk. This requires us to get inode cluster buffers that
@@ -3639,6 +3739,8 @@ xlog_recover_ra_pass2(
         case XFS_LI_EFI:
         case XFS_LI_EFD:
         case XFS_LI_QUOTAOFF:
+        case XFS_LI_RUI:
+        case XFS_LI_RUD:
         default:
                 break;
         }
@@ -3662,6 +3764,8 @@ xlog_recover_commit_pass1(
         case XFS_LI_EFD:
         case XFS_LI_DQUOT:
         case XFS_LI_ICREATE:
+        case XFS_LI_RUI:
+        case XFS_LI_RUD:
                 /* nothing to do in pass 1 */
                 return 0;
         default:
@@ -3692,6 +3796,10 @@ xlog_recover_commit_pass2(
                 return xlog_recover_efi_pass2(log, item, trans->r_lsn);
         case XFS_LI_EFD:
                 return xlog_recover_efd_pass2(log, item);
+        case XFS_LI_RUI:
+                return xlog_recover_rui_pass2(log, item, trans->r_lsn);
+        case XFS_LI_RUD:
+                return xlog_recover_rud_pass2(log, item);
         case XFS_LI_DQUOT:
                 return xlog_recover_dquot_pass2(log, buffer_list, item,
                                                 trans->r_lsn);
@@ -4164,126 +4272,156 @@ xlog_recover_process_data(
         return 0;
 }
 
-/*
- * Process an extent free intent item that was recovered from
- * the log.  We need to free the extents that it describes.
- */
+/* Recover the EFI if necessary. */
 STATIC int
 xlog_recover_process_efi(
-        xfs_mount_t             *mp,
-        xfs_efi_log_item_t      *efip)
+        struct xfs_mount                *mp,
+        struct xfs_ail                  *ailp,
+        struct xfs_log_item             *lip)
 {
-        xfs_efd_log_item_t      *efdp;
-        xfs_trans_t             *tp;
-        int                     i;
-        int                     error = 0;
-        xfs_extent_t            *extp;
-        xfs_fsblock_t           startblock_fsb;
-
-        ASSERT(!test_bit(XFS_EFI_RECOVERED, &efip->efi_flags));
+        struct xfs_efi_log_item         *efip;
+        int                             error;
 
         /*
-         * First check the validity of the extents described by the
-         * EFI.  If any are bad, then assume that all are bad and
-         * just toss the EFI.
+         * Skip EFIs that we've already processed.
          */
-        for (i = 0; i < efip->efi_format.efi_nextents; i++) {
-                extp = &(efip->efi_format.efi_extents[i]);
-                startblock_fsb = XFS_BB_TO_FSB(mp,
-                                   XFS_FSB_TO_DADDR(mp, extp->ext_start));
-                if ((startblock_fsb == 0) ||
-                    (extp->ext_len == 0) ||
-                    (startblock_fsb >= mp->m_sb.sb_dblocks) ||
-                    (extp->ext_len >= mp->m_sb.sb_agblocks)) {
-                        /*
-                         * This will pull the EFI from the AIL and
-                         * free the memory associated with it.
-                         */
-                        set_bit(XFS_EFI_RECOVERED, &efip->efi_flags);
-                        xfs_efi_release(efip);
-                        return -EIO;
-                }
-        }
+        efip = container_of(lip, struct xfs_efi_log_item, efi_item);
+        if (test_bit(XFS_EFI_RECOVERED, &efip->efi_flags))
+                return 0;
 
-        error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
-        if (error)
-                return error;
-        efdp = xfs_trans_get_efd(tp, efip, efip->efi_format.efi_nextents);
+        spin_unlock(&ailp->xa_lock);
+        error = xfs_efi_recover(mp, efip);
+        spin_lock(&ailp->xa_lock);
 
-        for (i = 0; i < efip->efi_format.efi_nextents; i++) {
-                extp = &(efip->efi_format.efi_extents[i]);
-                error = xfs_trans_free_extent(tp, efdp, extp->ext_start,
-                                              extp->ext_len);
-                if (error)
-                        goto abort_error;
+        return error;
+}
 
-        }
+/* Release the EFI since we're cancelling everything. */
+STATIC void
+xlog_recover_cancel_efi(
+        struct xfs_mount                *mp,
+        struct xfs_ail                  *ailp,
+        struct xfs_log_item             *lip)
+{
+        struct xfs_efi_log_item         *efip;
 
-        set_bit(XFS_EFI_RECOVERED, &efip->efi_flags);
-        error = xfs_trans_commit(tp);
-        return error;
+        efip = container_of(lip, struct xfs_efi_log_item, efi_item);
+
+        spin_unlock(&ailp->xa_lock);
+        xfs_efi_release(efip);
+        spin_lock(&ailp->xa_lock);
+}
+
+/* Recover the RUI if necessary. */
+STATIC int
+xlog_recover_process_rui(
+        struct xfs_mount                *mp,
+        struct xfs_ail                  *ailp,
+        struct xfs_log_item             *lip)
+{
+        struct xfs_rui_log_item         *ruip;
+        int                             error;
+
+        /*
+         * Skip RUIs that we've already processed.
+         */
+        ruip = container_of(lip, struct xfs_rui_log_item, rui_item);
+        if (test_bit(XFS_RUI_RECOVERED, &ruip->rui_flags))
+                return 0;
+
+        spin_unlock(&ailp->xa_lock);
+        error = xfs_rui_recover(mp, ruip);
+        spin_lock(&ailp->xa_lock);
 
-abort_error:
-        xfs_trans_cancel(tp);
         return error;
 }
 
+/* Release the RUI since we're cancelling everything. */
+STATIC void
+xlog_recover_cancel_rui(
+        struct xfs_mount                *mp,
+        struct xfs_ail                  *ailp,
+        struct xfs_log_item             *lip)
+{
+        struct xfs_rui_log_item         *ruip;
+
+        ruip = container_of(lip, struct xfs_rui_log_item, rui_item);
+
+        spin_unlock(&ailp->xa_lock);
+        xfs_rui_release(ruip);
+        spin_lock(&ailp->xa_lock);
+}
+
+/* Is this log item a deferred action intent? */
+static inline bool xlog_item_is_intent(struct xfs_log_item *lip)
+{
+        switch (lip->li_type) {
+        case XFS_LI_EFI:
+        case XFS_LI_RUI:
+                return true;
+        default:
+                return false;
+        }
+}
+
 /*
- * When this is called, all of the EFIs which did not have
- * corresponding EFDs should be in the AIL.  What we do now
- * is free the extents associated with each one.
+ * When this is called, all of the log intent items which did not have
+ * corresponding log done items should be in the AIL.  What we do now
+ * is update the data structures associated with each one.
  *
- * Since we process the EFIs in normal transactions, they
- * will be removed at some point after the commit.  This prevents
- * us from just walking down the list processing each one.
- * We'll use a flag in the EFI to skip those that we've already
- * processed and use the AIL iteration mechanism's generation
- * count to try to speed this up at least a bit.
+ * Since we process the log intent items in normal transactions, they
+ * will be removed at some point after the commit.  This prevents us
+ * from just walking down the list processing each one.  We'll use a
+ * flag in the intent item to skip those that we've already processed
+ * and use the AIL iteration mechanism's generation count to try to
+ * speed this up at least a bit.
  *
- * When we start, we know that the EFIs are the only things in
- * the AIL.  As we process them, however, other items are added
- * to the AIL.  Since everything added to the AIL must come after
- * everything already in the AIL, we stop processing as soon as
- * we see something other than an EFI in the AIL.
+ * When we start, we know that the intents are the only things in the
+ * AIL.  As we process them, however, other items are added to the
+ * AIL.
  */
 STATIC int
-xlog_recover_process_efis(
+xlog_recover_process_intents(
         struct xlog             *log)
 {
         struct xfs_log_item     *lip;
-        struct xfs_efi_log_item *efip;
         int                     error = 0;
         struct xfs_ail_cursor   cur;
         struct xfs_ail          *ailp;
+        xfs_lsn_t               last_lsn;
 
         ailp = log->l_ailp;
         spin_lock(&ailp->xa_lock);
         lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
+        last_lsn = xlog_assign_lsn(log->l_curr_cycle, log->l_curr_block);
         while (lip != NULL) {
                 /*
-                 * We're done when we see something other than an EFI.
-                 * There should be no EFIs left in the AIL now.
+                 * We're done when we see something other than an intent.
+                 * There should be no intents left in the AIL now.
                  */
-                if (lip->li_type != XFS_LI_EFI) {
+                if (!xlog_item_is_intent(lip)) {
 #ifdef DEBUG
                         for (; lip; lip = xfs_trans_ail_cursor_next(ailp, &cur))
-                                ASSERT(lip->li_type != XFS_LI_EFI);
+                                ASSERT(!xlog_item_is_intent(lip));
 #endif
                         break;
                 }
 
                 /*
-                 * Skip EFIs that we've already processed.
+                 * We should never see a redo item with a LSN higher than
+                 * the last transaction we found in the log at the start
+                 * of recovery.
                  */
-                efip = container_of(lip, struct xfs_efi_log_item, efi_item);
-                if (test_bit(XFS_EFI_RECOVERED, &efip->efi_flags)) {
-                        lip = xfs_trans_ail_cursor_next(ailp, &cur);
-                        continue;
-                }
+                ASSERT(XFS_LSN_CMP(last_lsn, lip->li_lsn) >= 0);
 
-                spin_unlock(&ailp->xa_lock);
-                error = xlog_recover_process_efi(log->l_mp, efip);
-                spin_lock(&ailp->xa_lock);
+                switch (lip->li_type) {
+                case XFS_LI_EFI:
+                        error = xlog_recover_process_efi(log->l_mp, ailp, lip);
+                        break;
+                case XFS_LI_RUI:
+                        error = xlog_recover_process_rui(log->l_mp, ailp, lip);
+                        break;
+                }
                 if (error)
                         goto out;
                 lip = xfs_trans_ail_cursor_next(ailp, &cur);
@@ -4295,15 +4433,14 @@ out:
 }
 
 /*
- * A cancel occurs when the mount has failed and we're bailing out. Release all
- * pending EFIs so they don't pin the AIL.
+ * A cancel occurs when the mount has failed and we're bailing out.
+ * Release all pending log intent items so they don't pin the AIL.
  */
 STATIC int
-xlog_recover_cancel_efis(
+xlog_recover_cancel_intents(
         struct xlog             *log)
 {
         struct xfs_log_item     *lip;
-        struct xfs_efi_log_item *efip;
         int                     error = 0;
         struct xfs_ail_cursor   cur;
         struct xfs_ail          *ailp;
@@ -4313,22 +4450,25 @@ xlog_recover_cancel_efis(
         lip = xfs_trans_ail_cursor_first(ailp, &cur, 0);
         while (lip != NULL) {
                 /*
-                 * We're done when we see something other than an EFI.
-                 * There should be no EFIs left in the AIL now.
+                 * We're done when we see something other than an intent.
+                 * There should be no intents left in the AIL now.
                  */
-                if (lip->li_type != XFS_LI_EFI) {
+                if (!xlog_item_is_intent(lip)) {
 #ifdef DEBUG
                         for (; lip; lip = xfs_trans_ail_cursor_next(ailp, &cur))
-                                ASSERT(lip->li_type != XFS_LI_EFI);
+                                ASSERT(!xlog_item_is_intent(lip));
 #endif
                         break;
                 }
 
-                efip = container_of(lip, struct xfs_efi_log_item, efi_item);
-
-                spin_unlock(&ailp->xa_lock);
-                xfs_efi_release(efip);
-                spin_lock(&ailp->xa_lock);
+                switch (lip->li_type) {
+                case XFS_LI_EFI:
+                        xlog_recover_cancel_efi(log->l_mp, ailp, lip);
+                        break;
+                case XFS_LI_RUI:
+                        xlog_recover_cancel_rui(log->l_mp, ailp, lip);
+                        break;
+                }
 
                 lip = xfs_trans_ail_cursor_next(ailp, &cur);
         }
@@ -5023,6 +5163,7 @@ xlog_do_recover(
                 xfs_warn(mp, "Failed post-recovery per-ag init: %d", error);
                 return error;
         }
+        mp->m_alloc_set_aside = xfs_alloc_set_aside(mp);
 
         xlog_recover_check_summary(log);
 
@@ -5139,16 +5280,17 @@ xlog_recover_finish(
          */
         if (log->l_flags & XLOG_RECOVERY_NEEDED) {
                 int     error;
-                error = xlog_recover_process_efis(log);
+                error = xlog_recover_process_intents(log);
                 if (error) {
-                        xfs_alert(log->l_mp, "Failed to recover EFIs");
+                        xfs_alert(log->l_mp, "Failed to recover intents");
                         return error;
                 }
+
                 /*
-                 * Sync the log to get all the EFIs out of the AIL.
+                 * Sync the log to get all the intents out of the AIL.
                  * This isn't absolutely necessary, but it helps in
                  * case the unlink transactions would have problems
-                 * pushing the EFIs out of the way.
+                 * pushing the intents out of the way.
                  */
                 xfs_log_force(log->l_mp, XFS_LOG_SYNC);
 
@@ -5173,7 +5315,7 @@ xlog_recover_cancel(
         int             error = 0;
 
         if (log->l_flags & XLOG_RECOVERY_NEEDED)
-                error = xlog_recover_cancel_efis(log);
+                error = xlog_recover_cancel_intents(log);
 
         return error;
 }
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 970c19ba2f56..faeead671f9f 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -24,6 +24,7 @@
 #include "xfs_bit.h"
 #include "xfs_sb.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_da_format.h"
 #include "xfs_da_btree.h"
 #include "xfs_inode.h"
@@ -41,6 +42,7 @@
 #include "xfs_trace.h"
 #include "xfs_icache.h"
 #include "xfs_sysfs.h"
+#include "xfs_rmap_btree.h"
 
 
 static DEFINE_MUTEX(xfs_uuid_table_mutex);
@@ -230,6 +232,8 @@ xfs_initialize_perag(
 
         if (maxagi)
                 *maxagi = index;
+
+        mp->m_ag_prealloc_blocks = xfs_prealloc_blocks(mp);
         return 0;
 
 out_unwind:
@@ -679,6 +683,7 @@ xfs_mountfs(
         xfs_bmap_compute_maxlevels(mp, XFS_DATA_FORK);
         xfs_bmap_compute_maxlevels(mp, XFS_ATTR_FORK);
         xfs_ialloc_compute_maxlevels(mp);
+        xfs_rmapbt_compute_maxlevels(mp);
 
         xfs_set_maxicount(mp);
 
@@ -1216,7 +1221,7 @@ xfs_mod_fdblocks(
                 batch = XFS_FDBLOCKS_BATCH;
 
         __percpu_counter_add(&mp->m_fdblocks, delta, batch);
-        if (__percpu_counter_compare(&mp->m_fdblocks, XFS_ALLOC_SET_ASIDE(mp),
+        if (__percpu_counter_compare(&mp->m_fdblocks, mp->m_alloc_set_aside,
                                      XFS_FDBLOCKS_BATCH) >= 0) {
                 /* we had space! */
                 return 0;
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index c1b798c72126..b36676cde103 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -116,9 +116,15 @@ typedef struct xfs_mount {
         uint                    m_bmap_dmnr[2]; /* min bmap btree records */
         uint                    m_inobt_mxr[2]; /* max inobt btree records */
         uint                    m_inobt_mnr[2]; /* min inobt btree records */
+        uint                    m_rmap_mxr[2];  /* max rmap btree records */
+        uint                    m_rmap_mnr[2];  /* min rmap btree records */
         uint                    m_ag_maxlevels; /* XFS_AG_MAXLEVELS */
         uint                    m_bm_maxlevels[2]; /* XFS_BM_MAXLEVELS */
         uint                    m_in_maxlevels; /* max inobt btree levels. */
+        uint                    m_rmap_maxlevels; /* max rmap btree levels */
+        xfs_extlen_t            m_ag_prealloc_blocks; /* reserved ag blocks */
+        uint                    m_alloc_set_aside; /* space we can't use */
+        uint                    m_ag_max_usable; /* max space per AG */
         struct radix_tree_root  m_perag_tree;   /* per-ag accounting info */
         spinlock_t              m_perag_lock;   /* lock for m_perag_tree */
         struct mutex            m_growlock;     /* growfs mutex */
diff --git a/fs/xfs/xfs_ondisk.h b/fs/xfs/xfs_ondisk.h
index 0cc8d8f74356..69e2986a3776 100644
--- a/fs/xfs/xfs_ondisk.h
+++ b/fs/xfs/xfs_ondisk.h
@@ -49,11 +49,14 @@ xfs_check_ondisk_structs(void)
         XFS_CHECK_STRUCT_SIZE(struct xfs_dsymlink_hdr,          56);
         XFS_CHECK_STRUCT_SIZE(struct xfs_inobt_key,             4);
         XFS_CHECK_STRUCT_SIZE(struct xfs_inobt_rec,             16);
+        XFS_CHECK_STRUCT_SIZE(struct xfs_rmap_key,              20);
+        XFS_CHECK_STRUCT_SIZE(struct xfs_rmap_rec,              24);
         XFS_CHECK_STRUCT_SIZE(struct xfs_timestamp,             8);
         XFS_CHECK_STRUCT_SIZE(xfs_alloc_key_t,                  8);
         XFS_CHECK_STRUCT_SIZE(xfs_alloc_ptr_t,                  4);
         XFS_CHECK_STRUCT_SIZE(xfs_alloc_rec_t,                  8);
         XFS_CHECK_STRUCT_SIZE(xfs_inobt_ptr_t,                  4);
+        XFS_CHECK_STRUCT_SIZE(xfs_rmap_ptr_t,                   4);
 
         /* dir/attr trees */
         XFS_CHECK_STRUCT_SIZE(struct xfs_attr3_leaf_hdr,        80);
diff --git a/fs/xfs/xfs_rmap_item.c b/fs/xfs/xfs_rmap_item.c
new file mode 100644
index 000000000000..2500f28689d5
--- /dev/null
+++ b/fs/xfs/xfs_rmap_item.c
@@ -0,0 +1,536 @@
+/*
+ * Copyright (C) 2016 Oracle.  All Rights Reserved.
+ *
+ * Author: Darrick J. Wong <darrick.wong@oracle.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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_format.h"
+#include "xfs_log_format.h"
+#include "xfs_trans_resv.h"
+#include "xfs_bit.h"
+#include "xfs_mount.h"
+#include "xfs_defer.h"
+#include "xfs_trans.h"
+#include "xfs_trans_priv.h"
+#include "xfs_buf_item.h"
+#include "xfs_rmap_item.h"
+#include "xfs_log.h"
+#include "xfs_rmap.h"
+
+
+kmem_zone_t     *xfs_rui_zone;
+kmem_zone_t     *xfs_rud_zone;
+
+static inline struct xfs_rui_log_item *RUI_ITEM(struct xfs_log_item *lip)
+{
+        return container_of(lip, struct xfs_rui_log_item, rui_item);
+}
+
+void
+xfs_rui_item_free(
+        struct xfs_rui_log_item *ruip)
+{
+        if (ruip->rui_format.rui_nextents > XFS_RUI_MAX_FAST_EXTENTS)
+                kmem_free(ruip);
+        else
+                kmem_zone_free(xfs_rui_zone, ruip);
+}
+
+/*
+ * This returns the number of iovecs needed to log the given rui item.
+ * We only need 1 iovec for an rui item.  It just logs the rui_log_format
+ * structure.
+ */
+static inline int
+xfs_rui_item_sizeof(
+        struct xfs_rui_log_item *ruip)
+{
+        return sizeof(struct xfs_rui_log_format) +
+                        (ruip->rui_format.rui_nextents - 1) *
+                        sizeof(struct xfs_map_extent);
+}
+
+STATIC void
+xfs_rui_item_size(
+        struct xfs_log_item     *lip,
+        int                     *nvecs,
+        int                     *nbytes)
+{
+        *nvecs += 1;
+        *nbytes += xfs_rui_item_sizeof(RUI_ITEM(lip));
+}
+
+/*
+ * This is called to fill in the vector of log iovecs for the
+ * given rui log item. We use only 1 iovec, and we point that
+ * at the rui_log_format structure embedded in the rui item.
+ * It is at this point that we assert that all of the extent
+ * slots in the rui item have been filled.
+ */
+STATIC void
+xfs_rui_item_format(
+        struct xfs_log_item     *lip,
+        struct xfs_log_vec      *lv)
+{
+        struct xfs_rui_log_item *ruip = RUI_ITEM(lip);
+        struct xfs_log_iovec    *vecp = NULL;
+
+        ASSERT(atomic_read(&ruip->rui_next_extent) ==
+                        ruip->rui_format.rui_nextents);
+
+        ruip->rui_format.rui_type = XFS_LI_RUI;
+        ruip->rui_format.rui_size = 1;
+
+        xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_RUI_FORMAT, &ruip->rui_format,
+                        xfs_rui_item_sizeof(ruip));
+}
+
+/*
+ * Pinning has no meaning for an rui item, so just return.
+ */
+STATIC void
+xfs_rui_item_pin(
+        struct xfs_log_item     *lip)
+{
+}
+
+/*
+ * The unpin operation is the last place an RUI is manipulated in the log. It is
+ * either inserted in the AIL or aborted in the event of a log I/O error. In
+ * either case, the RUI transaction has been successfully committed to make it
+ * this far. Therefore, we expect whoever committed the RUI to either construct
+ * and commit the RUD or drop the RUD's reference in the event of error. Simply
+ * drop the log's RUI reference now that the log is done with it.
+ */
+STATIC void
+xfs_rui_item_unpin(
+        struct xfs_log_item     *lip,
+        int                     remove)
+{
+        struct xfs_rui_log_item *ruip = RUI_ITEM(lip);
+
+        xfs_rui_release(ruip);
+}
+
+/*
+ * RUI items have no locking or pushing.  However, since RUIs are pulled from
+ * the AIL when their corresponding RUDs are committed to disk, their situation
+ * is very similar to being pinned.  Return XFS_ITEM_PINNED so that the caller
+ * will eventually flush the log.  This should help in getting the RUI out of
+ * the AIL.
+ */
+STATIC uint
+xfs_rui_item_push(
+        struct xfs_log_item     *lip,
+        struct list_head        *buffer_list)
+{
+        return XFS_ITEM_PINNED;
+}
+
+/*
+ * The RUI has been either committed or aborted if the transaction has been
+ * cancelled. If the transaction was cancelled, an RUD isn't going to be
+ * constructed and thus we free the RUI here directly.
+ */
+STATIC void
+xfs_rui_item_unlock(
+        struct xfs_log_item     *lip)
+{
+        if (lip->li_flags & XFS_LI_ABORTED)
+                xfs_rui_item_free(RUI_ITEM(lip));
+}
+
+/*
+ * The RUI is logged only once and cannot be moved in the log, so simply return
+ * the lsn at which it's been logged.
+ */
+STATIC xfs_lsn_t
+xfs_rui_item_committed(
+        struct xfs_log_item     *lip,
+        xfs_lsn_t               lsn)
+{
+        return lsn;
+}
+
+/*
+ * The RUI dependency tracking op doesn't do squat.  It can't because
+ * it doesn't know where the free extent is coming from.  The dependency
+ * tracking has to be handled by the "enclosing" metadata object.  For
+ * example, for inodes, the inode is locked throughout the extent freeing
+ * so the dependency should be recorded there.
+ */
+STATIC void
+xfs_rui_item_committing(
+        struct xfs_log_item     *lip,
+        xfs_lsn_t               lsn)
+{
+}
+
+/*
+ * This is the ops vector shared by all rui log items.
+ */
+static const struct xfs_item_ops xfs_rui_item_ops = {
+        .iop_size       = xfs_rui_item_size,
+        .iop_format     = xfs_rui_item_format,
+        .iop_pin        = xfs_rui_item_pin,
+        .iop_unpin      = xfs_rui_item_unpin,
+        .iop_unlock     = xfs_rui_item_unlock,
+        .iop_committed  = xfs_rui_item_committed,
+        .iop_push       = xfs_rui_item_push,
+        .iop_committing = xfs_rui_item_committing,
+};
+
+/*
+ * Allocate and initialize an rui item with the given number of extents.
+ */
+struct xfs_rui_log_item *
+xfs_rui_init(
+        struct xfs_mount                *mp,
+        uint                            nextents)
+
+{
+        struct xfs_rui_log_item         *ruip;
+        uint                            size;
+
+        ASSERT(nextents > 0);
+        if (nextents > XFS_RUI_MAX_FAST_EXTENTS) {
+                size = (uint)(sizeof(struct xfs_rui_log_item) +
+                        ((nextents - 1) * sizeof(struct xfs_map_extent)));
+                ruip = kmem_zalloc(size, KM_SLEEP);
+        } else {
+                ruip = kmem_zone_zalloc(xfs_rui_zone, KM_SLEEP);
+        }
+
+        xfs_log_item_init(mp, &ruip->rui_item, XFS_LI_RUI, &xfs_rui_item_ops);
+        ruip->rui_format.rui_nextents = nextents;
+        ruip->rui_format.rui_id = (uintptr_t)(void *)ruip;
+        atomic_set(&ruip->rui_next_extent, 0);
+        atomic_set(&ruip->rui_refcount, 2);
+
+        return ruip;
+}
+
+/*
+ * Copy an RUI format buffer from the given buf, and into the destination
+ * RUI format structure.  The RUI/RUD items were designed not to need any
+ * special alignment handling.
+ */
+int
+xfs_rui_copy_format(
+        struct xfs_log_iovec            *buf,
+        struct xfs_rui_log_format       *dst_rui_fmt)
+{
+        struct xfs_rui_log_format       *src_rui_fmt;
+        uint                            len;
+
+        src_rui_fmt = buf->i_addr;
+        len = sizeof(struct xfs_rui_log_format) +
+                        (src_rui_fmt->rui_nextents - 1) *
+                        sizeof(struct xfs_map_extent);
+
+        if (buf->i_len != len)
+                return -EFSCORRUPTED;
+
+        memcpy((char *)dst_rui_fmt, (char *)src_rui_fmt, len);
+        return 0;
+}
+
+/*
+ * Freeing the RUI requires that we remove it from the AIL if it has already
+ * been placed there. However, the RUI may not yet have been placed in the AIL
+ * when called by xfs_rui_release() from RUD processing due to the ordering of
+ * committed vs unpin operations in bulk insert operations. Hence the reference
+ * count to ensure only the last caller frees the RUI.
+ */
+void
+xfs_rui_release(
+        struct xfs_rui_log_item *ruip)
+{
+        if (atomic_dec_and_test(&ruip->rui_refcount)) {
+                xfs_trans_ail_remove(&ruip->rui_item, SHUTDOWN_LOG_IO_ERROR);
+                xfs_rui_item_free(ruip);
+        }
+}
+
+static inline struct xfs_rud_log_item *RUD_ITEM(struct xfs_log_item *lip)
+{
+        return container_of(lip, struct xfs_rud_log_item, rud_item);
+}
+
+STATIC void
+xfs_rud_item_size(
+        struct xfs_log_item     *lip,
+        int                     *nvecs,
+        int                     *nbytes)
+{
+        *nvecs += 1;
+        *nbytes += sizeof(struct xfs_rud_log_format);
+}
+
+/*
+ * This is called to fill in the vector of log iovecs for the
+ * given rud log item. We use only 1 iovec, and we point that
+ * at the rud_log_format structure embedded in the rud item.
+ * It is at this point that we assert that all of the extent
+ * slots in the rud item have been filled.
+ */
+STATIC void
+xfs_rud_item_format(
+        struct xfs_log_item     *lip,
+        struct xfs_log_vec      *lv)
+{
+        struct xfs_rud_log_item *rudp = RUD_ITEM(lip);
+        struct xfs_log_iovec    *vecp = NULL;
+
+        rudp->rud_format.rud_type = XFS_LI_RUD;
+        rudp->rud_format.rud_size = 1;
+
+        xlog_copy_iovec(lv, &vecp, XLOG_REG_TYPE_RUD_FORMAT, &rudp->rud_format,
+                        sizeof(struct xfs_rud_log_format));
+}
+
+/*
+ * Pinning has no meaning for an rud item, so just return.
+ */
+STATIC void
+xfs_rud_item_pin(
+        struct xfs_log_item     *lip)
+{
+}
+
+/*
+ * Since pinning has no meaning for an rud item, unpinning does
+ * not either.
+ */
+STATIC void
+xfs_rud_item_unpin(
+        struct xfs_log_item     *lip,
+        int                     remove)
+{
+}
+
+/*
+ * There isn't much you can do to push on an rud item.  It is simply stuck
+ * waiting for the log to be flushed to disk.
+ */
+STATIC uint
+xfs_rud_item_push(
+        struct xfs_log_item     *lip,
+        struct list_head        *buffer_list)
+{
+        return XFS_ITEM_PINNED;
+}
+
+/*
+ * The RUD is either committed or aborted if the transaction is cancelled. If
+ * the transaction is cancelled, drop our reference to the RUI and free the
+ * RUD.
+ */
+STATIC void
+xfs_rud_item_unlock(
+        struct xfs_log_item     *lip)
+{
+        struct xfs_rud_log_item *rudp = RUD_ITEM(lip);
+
+        if (lip->li_flags & XFS_LI_ABORTED) {
+                xfs_rui_release(rudp->rud_ruip);
+                kmem_zone_free(xfs_rud_zone, rudp);
+        }
+}
+
+/*
+ * When the rud item is committed to disk, all we need to do is delete our
+ * reference to our partner rui item and then free ourselves. Since we're
+ * freeing ourselves we must return -1 to keep the transaction code from
+ * further referencing this item.
+ */
+STATIC xfs_lsn_t
+xfs_rud_item_committed(
+        struct xfs_log_item     *lip,
+        xfs_lsn_t               lsn)
+{
+        struct xfs_rud_log_item *rudp = RUD_ITEM(lip);
+
+        /*
+         * Drop the RUI reference regardless of whether the RUD has been
+         * aborted. Once the RUD transaction is constructed, it is the sole
+         * responsibility of the RUD to release the RUI (even if the RUI is
+         * aborted due to log I/O error).
+         */
+        xfs_rui_release(rudp->rud_ruip);
+        kmem_zone_free(xfs_rud_zone, rudp);
+
+        return (xfs_lsn_t)-1;
+}
+
+/*
+ * The RUD dependency tracking op doesn't do squat.  It can't because
+ * it doesn't know where the free extent is coming from.  The dependency
+ * tracking has to be handled by the "enclosing" metadata object.  For
+ * example, for inodes, the inode is locked throughout the extent freeing
+ * so the dependency should be recorded there.
+ */
+STATIC void
+xfs_rud_item_committing(
+        struct xfs_log_item     *lip,
+        xfs_lsn_t               lsn)
+{
+}
+
+/*
+ * This is the ops vector shared by all rud log items.
+ */
+static const struct xfs_item_ops xfs_rud_item_ops = {
+        .iop_size       = xfs_rud_item_size,
+        .iop_format     = xfs_rud_item_format,
+        .iop_pin        = xfs_rud_item_pin,
+        .iop_unpin      = xfs_rud_item_unpin,
+        .iop_unlock     = xfs_rud_item_unlock,
+        .iop_committed  = xfs_rud_item_committed,
+        .iop_push       = xfs_rud_item_push,
+        .iop_committing = xfs_rud_item_committing,
+};
+
+/*
+ * Allocate and initialize an rud item with the given number of extents.
+ */
+struct xfs_rud_log_item *
+xfs_rud_init(
+        struct xfs_mount                *mp,
+        struct xfs_rui_log_item         *ruip)
+
+{
+        struct xfs_rud_log_item *rudp;
+
+        rudp = kmem_zone_zalloc(xfs_rud_zone, KM_SLEEP);
+        xfs_log_item_init(mp, &rudp->rud_item, XFS_LI_RUD, &xfs_rud_item_ops);
+        rudp->rud_ruip = ruip;
+        rudp->rud_format.rud_rui_id = ruip->rui_format.rui_id;
+
+        return rudp;
+}
+
+/*
+ * Process an rmap update intent item that was recovered from the log.
+ * We need to update the rmapbt.
+ */
+int
+xfs_rui_recover(
+        struct xfs_mount                *mp,
+        struct xfs_rui_log_item         *ruip)
+{
+        int                             i;
+        int                             error = 0;
+        struct xfs_map_extent           *rmap;
+        xfs_fsblock_t                   startblock_fsb;
+        bool                            op_ok;
+        struct xfs_rud_log_item         *rudp;
+        enum xfs_rmap_intent_type       type;
+        int                             whichfork;
+        xfs_exntst_t                    state;
+        struct xfs_trans                *tp;
+        struct xfs_btree_cur            *rcur = NULL;
+
+        ASSERT(!test_bit(XFS_RUI_RECOVERED, &ruip->rui_flags));
+
+        /*
+         * First check the validity of the extents described by the
+         * RUI.  If any are bad, then assume that all are bad and
+         * just toss the RUI.
+         */
+        for (i = 0; i < ruip->rui_format.rui_nextents; i++) {
+                rmap = &ruip->rui_format.rui_extents[i];
+                startblock_fsb = XFS_BB_TO_FSB(mp,
+                                   XFS_FSB_TO_DADDR(mp, rmap->me_startblock));
+                switch (rmap->me_flags & XFS_RMAP_EXTENT_TYPE_MASK) {
+                case XFS_RMAP_EXTENT_MAP:
+                case XFS_RMAP_EXTENT_UNMAP:
+                case XFS_RMAP_EXTENT_CONVERT:
+                case XFS_RMAP_EXTENT_ALLOC:
+                case XFS_RMAP_EXTENT_FREE:
+                        op_ok = true;
+                        break;
+                default:
+                        op_ok = false;
+                        break;
+                }
+                if (!op_ok || startblock_fsb == 0 ||
+                    rmap->me_len == 0 ||
+                    startblock_fsb >= mp->m_sb.sb_dblocks ||
+                    rmap->me_len >= mp->m_sb.sb_agblocks ||
+                    (rmap->me_flags & ~XFS_RMAP_EXTENT_FLAGS)) {
+                        /*
+                         * This will pull the RUI from the AIL and
+                         * free the memory associated with it.
+                         */
+                        set_bit(XFS_RUI_RECOVERED, &ruip->rui_flags);
+                        xfs_rui_release(ruip);
+                        return -EIO;
+                }
+        }
+
+        error = xfs_trans_alloc(mp, &M_RES(mp)->tr_itruncate, 0, 0, 0, &tp);
+        if (error)
+                return error;
+        rudp = xfs_trans_get_rud(tp, ruip);
+
+        for (i = 0; i < ruip->rui_format.rui_nextents; i++) {
+                rmap = &ruip->rui_format.rui_extents[i];
+                state = (rmap->me_flags & XFS_RMAP_EXTENT_UNWRITTEN) ?
+                                XFS_EXT_UNWRITTEN : XFS_EXT_NORM;
+                whichfork = (rmap->me_flags & XFS_RMAP_EXTENT_ATTR_FORK) ?
+                                XFS_ATTR_FORK : XFS_DATA_FORK;
+                switch (rmap->me_flags & XFS_RMAP_EXTENT_TYPE_MASK) {
+                case XFS_RMAP_EXTENT_MAP:
+                        type = XFS_RMAP_MAP;
+                        break;
+                case XFS_RMAP_EXTENT_UNMAP:
+                        type = XFS_RMAP_UNMAP;
+                        break;
+                case XFS_RMAP_EXTENT_CONVERT:
+                        type = XFS_RMAP_CONVERT;
+                        break;
+                case XFS_RMAP_EXTENT_ALLOC:
+                        type = XFS_RMAP_ALLOC;
+                        break;
+                case XFS_RMAP_EXTENT_FREE:
+                        type = XFS_RMAP_FREE;
+                        break;
+                default:
+                        error = -EFSCORRUPTED;
+                        goto abort_error;
+                }
+                error = xfs_trans_log_finish_rmap_update(tp, rudp, type,
+                                rmap->me_owner, whichfork,
+                                rmap->me_startoff, rmap->me_startblock,
+                                rmap->me_len, state, &rcur);
+                if (error)
+                        goto abort_error;
+
+        }
+
+        xfs_rmap_finish_one_cleanup(tp, rcur, error);
+        set_bit(XFS_RUI_RECOVERED, &ruip->rui_flags);
+        error = xfs_trans_commit(tp);
+        return error;
+
+abort_error:
+        xfs_rmap_finish_one_cleanup(tp, rcur, error);
+        xfs_trans_cancel(tp);
+        return error;
+}
diff --git a/fs/xfs/xfs_rmap_item.h b/fs/xfs/xfs_rmap_item.h
new file mode 100644
index 000000000000..aefcc3a318a5
--- /dev/null
+++ b/fs/xfs/xfs_rmap_item.h
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2016 Oracle.  All Rights Reserved.
+ *
+ * Author: Darrick J. Wong <darrick.wong@oracle.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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_RMAP_ITEM_H__
+#define __XFS_RMAP_ITEM_H__
+
+/*
+ * There are (currently) three pairs of rmap btree redo item types: map, unmap,
+ * and convert.  The common abbreviations for these are RUI (rmap update
+ * intent) and RUD (rmap update done).  The redo item type is encoded in the
+ * flags field of each xfs_map_extent.
+ *
+ * *I items should be recorded in the *first* of a series of rolled
+ * transactions, and the *D items should be recorded in the same transaction
+ * that records the associated rmapbt updates.  Typically, the first
+ * transaction will record a bmbt update, followed by some number of
+ * transactions containing rmapbt updates, and finally transactions with any
+ * bnobt/cntbt updates.
+ *
+ * Should the system crash after the commit of the first transaction but
+ * before the commit of the final transaction in a series, log recovery will
+ * use the redo information recorded by the intent items to replay the
+ * (rmapbt/bnobt/cntbt) metadata updates in the non-first transaction.
+ */
+
+/* kernel only RUI/RUD definitions */
+
+struct xfs_mount;
+struct kmem_zone;
+
+/*
+ * Max number of extents in fast allocation path.
+ */
+#define XFS_RUI_MAX_FAST_EXTENTS        16
+
+/*
+ * Define RUI flag bits. Manipulated by set/clear/test_bit operators.
+ */
+#define XFS_RUI_RECOVERED               1
+
+/*
+ * This is the "rmap update intent" log item.  It is used to log the fact that
+ * some reverse mappings need to change.  It is used in conjunction with the
+ * "rmap update done" log item described below.
+ *
+ * These log items follow the same rules as struct xfs_efi_log_item; see the
+ * comments about that structure (in xfs_extfree_item.h) for more details.
+ */
+struct xfs_rui_log_item {
+        struct xfs_log_item             rui_item;
+        atomic_t                        rui_refcount;
+        atomic_t                        rui_next_extent;
+        unsigned long                   rui_flags;      /* misc flags */
+        struct xfs_rui_log_format       rui_format;
+};
+
+/*
+ * This is the "rmap update done" log item.  It is used to log the fact that
+ * some rmapbt updates mentioned in an earlier rui item have been performed.
+ */
+struct xfs_rud_log_item {
+        struct xfs_log_item             rud_item;
+        struct xfs_rui_log_item         *rud_ruip;
+        struct xfs_rud_log_format       rud_format;
+};
+
+extern struct kmem_zone *xfs_rui_zone;
+extern struct kmem_zone *xfs_rud_zone;
+
+struct xfs_rui_log_item *xfs_rui_init(struct xfs_mount *, uint);
+struct xfs_rud_log_item *xfs_rud_init(struct xfs_mount *,
+                struct xfs_rui_log_item *);
+int xfs_rui_copy_format(struct xfs_log_iovec *buf,
+                struct xfs_rui_log_format *dst_rui_fmt);
+void xfs_rui_item_free(struct xfs_rui_log_item *);
+void xfs_rui_release(struct xfs_rui_log_item *);
+int xfs_rui_recover(struct xfs_mount *mp, struct xfs_rui_log_item *ruip);
+
+#endif  /* __XFS_RMAP_ITEM_H__ */
diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index 3938b37d1043..802bcc326d9f 100644
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -23,6 +23,7 @@
 #include "xfs_trans_resv.h"
 #include "xfs_bit.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_inode.h"
 #include "xfs_bmap.h"
 #include "xfs_bmap_util.h"
@@ -769,7 +770,7 @@ xfs_growfs_rt_alloc(
         xfs_daddr_t             d;              /* disk block address */
         int                     error;          /* error return value */
         xfs_fsblock_t           firstblock;/* first block allocated in xaction */
-        struct xfs_bmap_free    flist;          /* list of freed blocks */
+        struct xfs_defer_ops    dfops;          /* list of freed blocks */
         xfs_fsblock_t           fsbno;          /* filesystem block for bno */
         struct xfs_bmbt_irec    map;            /* block map output */
         int                     nmap;           /* number of block maps */
@@ -794,14 +795,14 @@ xfs_growfs_rt_alloc(
                 xfs_ilock(ip, XFS_ILOCK_EXCL);
                 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
 
-                xfs_bmap_init(&flist, &firstblock);
+                xfs_defer_init(&dfops, &firstblock);
                 /*
                  * Allocate blocks to the bitmap file.
                  */
                 nmap = 1;
                 error = xfs_bmapi_write(tp, ip, oblocks, nblocks - oblocks,
                                         XFS_BMAPI_METADATA, &firstblock,
-                                        resblks, &map, &nmap, &flist);
+                                        resblks, &map, &nmap, &dfops);
                 if (!error && nmap < 1)
                         error = -ENOSPC;
                 if (error)
@@ -809,7 +810,7 @@ xfs_growfs_rt_alloc(
                 /*
                  * Free any blocks freed up in the transaction, then commit.
                  */
-                error = xfs_bmap_finish(&tp, &flist, NULL);
+                error = xfs_defer_finish(&tp, &dfops, NULL);
                 if (error)
                         goto out_bmap_cancel;
                 error = xfs_trans_commit(tp);
@@ -862,7 +863,7 @@ xfs_growfs_rt_alloc(
         return 0;
 
 out_bmap_cancel:
-        xfs_bmap_cancel(&flist);
+        xfs_defer_cancel(&dfops);
 out_trans_cancel:
         xfs_trans_cancel(tp);
         return error;
diff --git a/fs/xfs/xfs_stats.c b/fs/xfs/xfs_stats.c
index d266e835ecc3..6e812fe0fd43 100644
--- a/fs/xfs/xfs_stats.c
+++ b/fs/xfs/xfs_stats.c
@@ -61,6 +61,7 @@ int xfs_stats_format(struct xfsstats __percpu *stats, char *buf)
                 { "bmbt2",              XFSSTAT_END_BMBT_V2             },
                 { "ibt2",               XFSSTAT_END_IBT_V2              },
                 { "fibt2",              XFSSTAT_END_FIBT_V2             },
+                { "rmapbt",             XFSSTAT_END_RMAP_V2             },
                 /* we print both series of quota information together */
                 { "qm",                 XFSSTAT_END_QM                  },
         };
diff --git a/fs/xfs/xfs_stats.h b/fs/xfs/xfs_stats.h
index 483b0eff1988..657865f51e78 100644
--- a/fs/xfs/xfs_stats.h
+++ b/fs/xfs/xfs_stats.h
@@ -197,7 +197,23 @@ struct xfsstats {
         __uint32_t              xs_fibt_2_alloc;
         __uint32_t              xs_fibt_2_free;
         __uint32_t              xs_fibt_2_moves;
-#define XFSSTAT_END_XQMSTAT             (XFSSTAT_END_FIBT_V2+6)
+#define XFSSTAT_END_RMAP_V2             (XFSSTAT_END_FIBT_V2+15)
+        __uint32_t              xs_rmap_2_lookup;
+        __uint32_t              xs_rmap_2_compare;
+        __uint32_t              xs_rmap_2_insrec;
+        __uint32_t              xs_rmap_2_delrec;
+        __uint32_t              xs_rmap_2_newroot;
+        __uint32_t              xs_rmap_2_killroot;
+        __uint32_t              xs_rmap_2_increment;
+        __uint32_t              xs_rmap_2_decrement;
+        __uint32_t              xs_rmap_2_lshift;
+        __uint32_t              xs_rmap_2_rshift;
+        __uint32_t              xs_rmap_2_split;
+        __uint32_t              xs_rmap_2_join;
+        __uint32_t              xs_rmap_2_alloc;
+        __uint32_t              xs_rmap_2_free;
+        __uint32_t              xs_rmap_2_moves;
+#define XFSSTAT_END_XQMSTAT             (XFSSTAT_END_RMAP_V2+6)
         __uint32_t              xs_qm_dqreclaims;
         __uint32_t              xs_qm_dqreclaim_misses;
         __uint32_t              xs_qm_dquot_dups;
diff --git a/fs/xfs/xfs_super.c b/fs/xfs/xfs_super.c
index 0303f1005f88..24ef83ef04de 100644
--- a/fs/xfs/xfs_super.c
+++ b/fs/xfs/xfs_super.c
@@ -46,6 +46,7 @@
 #include "xfs_quota.h"
 #include "xfs_sysfs.h"
 #include "xfs_ondisk.h"
+#include "xfs_rmap_item.h"
 
 #include <linux/namei.h>
 #include <linux/init.h>
@@ -1075,7 +1076,7 @@ xfs_fs_statfs(
         statp->f_blocks = sbp->sb_dblocks - lsize;
         spin_unlock(&mp->m_sb_lock);
 
-        statp->f_bfree = fdblocks - XFS_ALLOC_SET_ASIDE(mp);
+        statp->f_bfree = fdblocks - mp->m_alloc_set_aside;
         statp->f_bavail = statp->f_bfree;
 
         fakeinos = statp->f_bfree << sbp->sb_inopblog;
@@ -1573,6 +1574,10 @@ xfs_fs_fill_super(
                 }
         }
 
+        if (xfs_sb_version_hasrmapbt(&mp->m_sb))
+                xfs_alert(mp,
+        "EXPERIMENTAL reverse mapping btree feature enabled. Use at your own risk!");
+
         error = xfs_mountfs(mp);
         if (error)
                 goto out_filestream_unmount;
@@ -1697,7 +1702,7 @@ xfs_init_zones(void)
                 goto out_free_ioend_bioset;
 
         xfs_bmap_free_item_zone = kmem_zone_init(
-                        sizeof(struct xfs_bmap_free_item),
+                        sizeof(struct xfs_extent_free_item),
                         "xfs_bmap_free_item");
         if (!xfs_bmap_free_item_zone)
                 goto out_destroy_log_ticket_zone;
@@ -1765,8 +1770,24 @@ xfs_init_zones(void)
         if (!xfs_icreate_zone)
                 goto out_destroy_ili_zone;
 
+        xfs_rud_zone = kmem_zone_init(sizeof(struct xfs_rud_log_item),
+                        "xfs_rud_item");
+        if (!xfs_rud_zone)
+                goto out_destroy_icreate_zone;
+
+        xfs_rui_zone = kmem_zone_init((sizeof(struct xfs_rui_log_item) +
+                        ((XFS_RUI_MAX_FAST_EXTENTS - 1) *
+                                sizeof(struct xfs_map_extent))),
+                        "xfs_rui_item");
+        if (!xfs_rui_zone)
+                goto out_destroy_rud_zone;
+
         return 0;
 
+ out_destroy_rud_zone:
+        kmem_zone_destroy(xfs_rud_zone);
+ out_destroy_icreate_zone:
+        kmem_zone_destroy(xfs_icreate_zone);
  out_destroy_ili_zone:
         kmem_zone_destroy(xfs_ili_zone);
  out_destroy_inode_zone:
@@ -1805,6 +1826,8 @@ xfs_destroy_zones(void)
          * destroy caches.
          */
         rcu_barrier();
+        kmem_zone_destroy(xfs_rui_zone);
+        kmem_zone_destroy(xfs_rud_zone);
         kmem_zone_destroy(xfs_icreate_zone);
         kmem_zone_destroy(xfs_ili_zone);
         kmem_zone_destroy(xfs_inode_zone);
@@ -1854,6 +1877,9 @@ init_xfs_fs(void)
         printk(KERN_INFO XFS_VERSION_STRING " with "
                          XFS_BUILD_OPTIONS " enabled\n");
 
+        xfs_extent_free_init_defer_op();
+        xfs_rmap_update_init_defer_op();
+
         xfs_dir_startup();
 
         error = xfs_init_zones();
diff --git a/fs/xfs/xfs_symlink.c b/fs/xfs/xfs_symlink.c
index 08a46c6181fd..58142aeeeea6 100644
--- a/fs/xfs/xfs_symlink.c
+++ b/fs/xfs/xfs_symlink.c
@@ -26,6 +26,7 @@
 #include "xfs_mount.h"
 #include "xfs_da_format.h"
 #include "xfs_da_btree.h"
+#include "xfs_defer.h"
 #include "xfs_dir2.h"
 #include "xfs_inode.h"
 #include "xfs_ialloc.h"
@@ -172,7 +173,7 @@ xfs_symlink(
         struct xfs_inode        *ip = NULL;
         int                     error = 0;
         int                     pathlen;
-        struct xfs_bmap_free    free_list;
+        struct xfs_defer_ops    dfops;
         xfs_fsblock_t           first_block;
         bool                    unlock_dp_on_error = false;
         xfs_fileoff_t           first_fsb;
@@ -269,7 +270,7 @@ xfs_symlink(
          * Initialize the bmap freelist prior to calling either
          * bmapi or the directory create code.
          */
-        xfs_bmap_init(&free_list, &first_block);
+        xfs_defer_init(&dfops, &first_block);
 
         /*
          * Allocate an inode for the symlink.
@@ -313,7 +314,7 @@ xfs_symlink(
 
                 error = xfs_bmapi_write(tp, ip, first_fsb, fs_blocks,
                                   XFS_BMAPI_METADATA, &first_block, resblks,
-                                  mval, &nmaps, &free_list);
+                                  mval, &nmaps, &dfops);
                 if (error)
                         goto out_bmap_cancel;
 
@@ -361,7 +362,7 @@ xfs_symlink(
          * Create the directory entry for the symlink.
          */
         error = xfs_dir_createname(tp, dp, link_name, ip->i_ino,
-                                        &first_block, &free_list, resblks);
+                                        &first_block, &dfops, resblks);
         if (error)
                 goto out_bmap_cancel;
         xfs_trans_ichgtime(tp, dp, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
@@ -376,7 +377,7 @@ xfs_symlink(
                 xfs_trans_set_sync(tp);
         }
 
-        error = xfs_bmap_finish(&tp, &free_list, NULL);
+        error = xfs_defer_finish(&tp, &dfops, NULL);
         if (error)
                 goto out_bmap_cancel;
 
@@ -392,7 +393,7 @@ xfs_symlink(
         return 0;
 
 out_bmap_cancel:
-        xfs_bmap_cancel(&free_list);
+        xfs_defer_cancel(&dfops);
 out_trans_cancel:
         xfs_trans_cancel(tp);
 out_release_inode:
@@ -426,7 +427,7 @@ xfs_inactive_symlink_rmt(
         int             done;
         int             error;
         xfs_fsblock_t   first_block;
-        xfs_bmap_free_t free_list;
+        struct xfs_defer_ops    dfops;
         int             i;
         xfs_mount_t     *mp;
         xfs_bmbt_irec_t mval[XFS_SYMLINK_MAPS];
@@ -465,7 +466,7 @@ xfs_inactive_symlink_rmt(
          * Find the block(s) so we can inval and unmap them.
          */
         done = 0;
-        xfs_bmap_init(&free_list, &first_block);
+        xfs_defer_init(&dfops, &first_block);
         nmaps = ARRAY_SIZE(mval);
         error = xfs_bmapi_read(ip, 0, xfs_symlink_blocks(mp, size),
                                 mval, &nmaps, 0);
@@ -485,17 +486,17 @@ xfs_inactive_symlink_rmt(
                 xfs_trans_binval(tp, bp);
         }
         /*
-         * Unmap the dead block(s) to the free_list.
+         * Unmap the dead block(s) to the dfops.
          */
         error = xfs_bunmapi(tp, ip, 0, size, 0, nmaps,
-                            &first_block, &free_list, &done);
+                            &first_block, &dfops, &done);
         if (error)
                 goto error_bmap_cancel;
         ASSERT(done);
         /*
          * Commit the first transaction.  This logs the EFI and the inode.
          */
-        error = xfs_bmap_finish(&tp, &free_list, ip);
+        error = xfs_defer_finish(&tp, &dfops, ip);
         if (error)
                 goto error_bmap_cancel;
         /*
@@ -525,7 +526,7 @@ xfs_inactive_symlink_rmt(
         return 0;
 
 error_bmap_cancel:
-        xfs_bmap_cancel(&free_list);
+        xfs_defer_cancel(&dfops);
 error_trans_cancel:
         xfs_trans_cancel(tp);
 error_unlock:
diff --git a/fs/xfs/xfs_trace.c b/fs/xfs/xfs_trace.c
index 13a029806805..7f17ae6d709a 100644
--- a/fs/xfs/xfs_trace.c
+++ b/fs/xfs/xfs_trace.c
@@ -22,7 +22,9 @@
 #include "xfs_log_format.h"
 #include "xfs_trans_resv.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_da_format.h"
+#include "xfs_defer.h"
 #include "xfs_inode.h"
 #include "xfs_btree.h"
 #include "xfs_da_btree.h"
diff --git a/fs/xfs/xfs_trace.h b/fs/xfs/xfs_trace.h
index 145169093fe0..551b7e26980c 100644
--- a/fs/xfs/xfs_trace.h
+++ b/fs/xfs/xfs_trace.h
@@ -38,6 +38,7 @@ struct xlog_recover_item;
 struct xfs_buf_log_format;
 struct xfs_inode_log_format;
 struct xfs_bmbt_irec;
+struct xfs_btree_cur;
 
 DECLARE_EVENT_CLASS(xfs_attr_list_class,
         TP_PROTO(struct xfs_attr_list_context *ctx),
@@ -2185,6 +2186,379 @@ DEFINE_DISCARD_EVENT(xfs_discard_toosmall);
 DEFINE_DISCARD_EVENT(xfs_discard_exclude);
 DEFINE_DISCARD_EVENT(xfs_discard_busy);
 
+/* btree cursor events */
+DECLARE_EVENT_CLASS(xfs_btree_cur_class,
+        TP_PROTO(struct xfs_btree_cur *cur, int level, struct xfs_buf *bp),
+        TP_ARGS(cur, level, bp),
+        TP_STRUCT__entry(
+                __field(dev_t, dev)
+                __field(xfs_btnum_t, btnum)
+                __field(int, level)
+                __field(int, nlevels)
+                __field(int, ptr)
+                __field(xfs_daddr_t, daddr)
+        ),
+        TP_fast_assign(
+                __entry->dev = cur->bc_mp->m_super->s_dev;
+                __entry->btnum = cur->bc_btnum;
+                __entry->level = level;
+                __entry->nlevels = cur->bc_nlevels;
+                __entry->ptr = cur->bc_ptrs[level];
+                __entry->daddr = bp ? bp->b_bn : -1;
+        ),
+        TP_printk("dev %d:%d btnum %d level %d/%d ptr %d daddr 0x%llx",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->btnum,
+                  __entry->level,
+                  __entry->nlevels,
+                  __entry->ptr,
+                  (unsigned long long)__entry->daddr)
+)
+
+#define DEFINE_BTREE_CUR_EVENT(name) \
+DEFINE_EVENT(xfs_btree_cur_class, name, \
+        TP_PROTO(struct xfs_btree_cur *cur, int level, struct xfs_buf *bp), \
+        TP_ARGS(cur, level, bp))
+DEFINE_BTREE_CUR_EVENT(xfs_btree_updkeys);
+DEFINE_BTREE_CUR_EVENT(xfs_btree_overlapped_query_range);
+
+/* deferred ops */
+struct xfs_defer_pending;
+struct xfs_defer_intake;
+struct xfs_defer_ops;
+
+DECLARE_EVENT_CLASS(xfs_defer_class,
+        TP_PROTO(struct xfs_mount *mp, struct xfs_defer_ops *dop),
+        TP_ARGS(mp, dop),
+        TP_STRUCT__entry(
+                __field(dev_t, dev)
+                __field(void *, dop)
+                __field(bool, committed)
+                __field(bool, low)
+        ),
+        TP_fast_assign(
+                __entry->dev = mp ? mp->m_super->s_dev : 0;
+                __entry->dop = dop;
+                __entry->committed = dop->dop_committed;
+                __entry->low = dop->dop_low;
+        ),
+        TP_printk("dev %d:%d ops %p committed %d low %d\n",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->dop,
+                  __entry->committed,
+                  __entry->low)
+)
+#define DEFINE_DEFER_EVENT(name) \
+DEFINE_EVENT(xfs_defer_class, name, \
+        TP_PROTO(struct xfs_mount *mp, struct xfs_defer_ops *dop), \
+        TP_ARGS(mp, dop))
+
+DECLARE_EVENT_CLASS(xfs_defer_error_class,
+        TP_PROTO(struct xfs_mount *mp, struct xfs_defer_ops *dop, int error),
+        TP_ARGS(mp, dop, error),
+        TP_STRUCT__entry(
+                __field(dev_t, dev)
+                __field(void *, dop)
+                __field(bool, committed)
+                __field(bool, low)
+                __field(int, error)
+        ),
+        TP_fast_assign(
+                __entry->dev = mp ? mp->m_super->s_dev : 0;
+                __entry->dop = dop;
+                __entry->committed = dop->dop_committed;
+                __entry->low = dop->dop_low;
+                __entry->error = error;
+        ),
+        TP_printk("dev %d:%d ops %p committed %d low %d err %d\n",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->dop,
+                  __entry->committed,
+                  __entry->low,
+                  __entry->error)
+)
+#define DEFINE_DEFER_ERROR_EVENT(name) \
+DEFINE_EVENT(xfs_defer_error_class, name, \
+        TP_PROTO(struct xfs_mount *mp, struct xfs_defer_ops *dop, int error), \
+        TP_ARGS(mp, dop, error))
+
+DECLARE_EVENT_CLASS(xfs_defer_pending_class,
+        TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp),
+        TP_ARGS(mp, dfp),
+        TP_STRUCT__entry(
+                __field(dev_t, dev)
+                __field(int, type)
+                __field(void *, intent)
+                __field(bool, committed)
+                __field(int, nr)
+        ),
+        TP_fast_assign(
+                __entry->dev = mp ? mp->m_super->s_dev : 0;
+                __entry->type = dfp->dfp_type->type;
+                __entry->intent = dfp->dfp_intent;
+                __entry->committed = dfp->dfp_committed;
+                __entry->nr = dfp->dfp_count;
+        ),
+        TP_printk("dev %d:%d optype %d intent %p committed %d nr %d\n",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->type,
+                  __entry->intent,
+                  __entry->committed,
+                  __entry->nr)
+)
+#define DEFINE_DEFER_PENDING_EVENT(name) \
+DEFINE_EVENT(xfs_defer_pending_class, name, \
+        TP_PROTO(struct xfs_mount *mp, struct xfs_defer_pending *dfp), \
+        TP_ARGS(mp, dfp))
+
+DECLARE_EVENT_CLASS(xfs_phys_extent_deferred_class,
+        TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
+                 int type, xfs_agblock_t agbno, xfs_extlen_t len),
+        TP_ARGS(mp, agno, type, agbno, len),
+        TP_STRUCT__entry(
+                __field(dev_t, dev)
+                __field(xfs_agnumber_t, agno)
+                __field(int, type)
+                __field(xfs_agblock_t, agbno)
+                __field(xfs_extlen_t, len)
+        ),
+        TP_fast_assign(
+                __entry->dev = mp->m_super->s_dev;
+                __entry->agno = agno;
+                __entry->type = type;
+                __entry->agbno = agbno;
+                __entry->len = len;
+        ),
+        TP_printk("dev %d:%d op %d agno %u agbno %u len %u",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->type,
+                  __entry->agno,
+                  __entry->agbno,
+                  __entry->len)
+);
+#define DEFINE_PHYS_EXTENT_DEFERRED_EVENT(name) \
+DEFINE_EVENT(xfs_phys_extent_deferred_class, name, \
+        TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
+                 int type, \
+                 xfs_agblock_t bno, \
+                 xfs_extlen_t len), \
+        TP_ARGS(mp, agno, type, bno, len))
+
+DECLARE_EVENT_CLASS(xfs_map_extent_deferred_class,
+        TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
+                 int op,
+                 xfs_agblock_t agbno,
+                 xfs_ino_t ino,
+                 int whichfork,
+                 xfs_fileoff_t offset,
+                 xfs_filblks_t len,
+                 xfs_exntst_t state),
+        TP_ARGS(mp, agno, op, agbno, ino, whichfork, offset, len, state),
+        TP_STRUCT__entry(
+                __field(dev_t, dev)
+                __field(xfs_agnumber_t, agno)
+                __field(xfs_ino_t, ino)
+                __field(xfs_agblock_t, agbno)
+                __field(int, whichfork)
+                __field(xfs_fileoff_t, l_loff)
+                __field(xfs_filblks_t, l_len)
+                __field(xfs_exntst_t, l_state)
+                __field(int, op)
+        ),
+        TP_fast_assign(
+                __entry->dev = mp->m_super->s_dev;
+                __entry->agno = agno;
+                __entry->ino = ino;
+                __entry->agbno = agbno;
+                __entry->whichfork = whichfork;
+                __entry->l_loff = offset;
+                __entry->l_len = len;
+                __entry->l_state = state;
+                __entry->op = op;
+        ),
+        TP_printk("dev %d:%d op %d agno %u agbno %u owner %lld %s offset %llu len %llu state %d",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->op,
+                  __entry->agno,
+                  __entry->agbno,
+                  __entry->ino,
+                  __entry->whichfork == XFS_ATTR_FORK ? "attr" : "data",
+                  __entry->l_loff,
+                  __entry->l_len,
+                  __entry->l_state)
+);
+#define DEFINE_MAP_EXTENT_DEFERRED_EVENT(name) \
+DEFINE_EVENT(xfs_map_extent_deferred_class, name, \
+        TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
+                 int op, \
+                 xfs_agblock_t agbno, \
+                 xfs_ino_t ino, \
+                 int whichfork, \
+                 xfs_fileoff_t offset, \
+                 xfs_filblks_t len, \
+                 xfs_exntst_t state), \
+        TP_ARGS(mp, agno, op, agbno, ino, whichfork, offset, len, state))
+
+DEFINE_DEFER_EVENT(xfs_defer_init);
+DEFINE_DEFER_EVENT(xfs_defer_cancel);
+DEFINE_DEFER_EVENT(xfs_defer_trans_roll);
+DEFINE_DEFER_EVENT(xfs_defer_trans_abort);
+DEFINE_DEFER_EVENT(xfs_defer_finish);
+DEFINE_DEFER_EVENT(xfs_defer_finish_done);
+
+DEFINE_DEFER_ERROR_EVENT(xfs_defer_trans_roll_error);
+DEFINE_DEFER_ERROR_EVENT(xfs_defer_finish_error);
+DEFINE_DEFER_ERROR_EVENT(xfs_defer_op_finish_error);
+
+DEFINE_DEFER_PENDING_EVENT(xfs_defer_intake_work);
+DEFINE_DEFER_PENDING_EVENT(xfs_defer_intake_cancel);
+DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_commit);
+DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_cancel);
+DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_finish);
+DEFINE_DEFER_PENDING_EVENT(xfs_defer_pending_abort);
+
+#define DEFINE_BMAP_FREE_DEFERRED_EVENT DEFINE_PHYS_EXTENT_DEFERRED_EVENT
+DEFINE_BMAP_FREE_DEFERRED_EVENT(xfs_bmap_free_defer);
+DEFINE_BMAP_FREE_DEFERRED_EVENT(xfs_bmap_free_deferred);
+
+/* rmap tracepoints */
+DECLARE_EVENT_CLASS(xfs_rmap_class,
+        TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
+                 xfs_agblock_t agbno, xfs_extlen_t len, bool unwritten,
+                 struct xfs_owner_info *oinfo),
+        TP_ARGS(mp, agno, agbno, len, unwritten, oinfo),
+        TP_STRUCT__entry(
+                __field(dev_t, dev)
+                __field(xfs_agnumber_t, agno)
+                __field(xfs_agblock_t, agbno)
+                __field(xfs_extlen_t, len)
+                __field(uint64_t, owner)
+                __field(uint64_t, offset)
+                __field(unsigned long, flags)
+        ),
+        TP_fast_assign(
+                __entry->dev = mp->m_super->s_dev;
+                __entry->agno = agno;
+                __entry->agbno = agbno;
+                __entry->len = len;
+                __entry->owner = oinfo->oi_owner;
+                __entry->offset = oinfo->oi_offset;
+                __entry->flags = oinfo->oi_flags;
+                if (unwritten)
+                        __entry->flags |= XFS_RMAP_UNWRITTEN;
+        ),
+        TP_printk("dev %d:%d agno %u agbno %u len %u owner %lld offset %llu flags 0x%lx",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->agno,
+                  __entry->agbno,
+                  __entry->len,
+                  __entry->owner,
+                  __entry->offset,
+                  __entry->flags)
+);
+#define DEFINE_RMAP_EVENT(name) \
+DEFINE_EVENT(xfs_rmap_class, name, \
+        TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
+                 xfs_agblock_t agbno, xfs_extlen_t len, bool unwritten, \
+                 struct xfs_owner_info *oinfo), \
+        TP_ARGS(mp, agno, agbno, len, unwritten, oinfo))
+
+/* simple AG-based error/%ip tracepoint class */
+DECLARE_EVENT_CLASS(xfs_ag_error_class,
+        TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, int error,
+                 unsigned long caller_ip),
+        TP_ARGS(mp, agno, error, caller_ip),
+        TP_STRUCT__entry(
+                __field(dev_t, dev)
+                __field(xfs_agnumber_t, agno)
+                __field(int, error)
+                __field(unsigned long, caller_ip)
+        ),
+        TP_fast_assign(
+                __entry->dev = mp->m_super->s_dev;
+                __entry->agno = agno;
+                __entry->error = error;
+                __entry->caller_ip = caller_ip;
+        ),
+        TP_printk("dev %d:%d agno %u error %d caller %ps",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->agno,
+                  __entry->error,
+                  (char *)__entry->caller_ip)
+);
+
+#define DEFINE_AG_ERROR_EVENT(name) \
+DEFINE_EVENT(xfs_ag_error_class, name, \
+        TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, int error, \
+                 unsigned long caller_ip), \
+        TP_ARGS(mp, agno, error, caller_ip))
+
+DEFINE_RMAP_EVENT(xfs_rmap_unmap);
+DEFINE_RMAP_EVENT(xfs_rmap_unmap_done);
+DEFINE_AG_ERROR_EVENT(xfs_rmap_unmap_error);
+DEFINE_RMAP_EVENT(xfs_rmap_map);
+DEFINE_RMAP_EVENT(xfs_rmap_map_done);
+DEFINE_AG_ERROR_EVENT(xfs_rmap_map_error);
+DEFINE_RMAP_EVENT(xfs_rmap_convert);
+DEFINE_RMAP_EVENT(xfs_rmap_convert_done);
+DEFINE_AG_ERROR_EVENT(xfs_rmap_convert_error);
+DEFINE_AG_ERROR_EVENT(xfs_rmap_convert_state);
+
+DECLARE_EVENT_CLASS(xfs_rmapbt_class,
+        TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno,
+                 xfs_agblock_t agbno, xfs_extlen_t len,
+                 uint64_t owner, uint64_t offset, unsigned int flags),
+        TP_ARGS(mp, agno, agbno, len, owner, offset, flags),
+        TP_STRUCT__entry(
+                __field(dev_t, dev)
+                __field(xfs_agnumber_t, agno)
+                __field(xfs_agblock_t, agbno)
+                __field(xfs_extlen_t, len)
+                __field(uint64_t, owner)
+                __field(uint64_t, offset)
+                __field(unsigned int, flags)
+        ),
+        TP_fast_assign(
+                __entry->dev = mp->m_super->s_dev;
+                __entry->agno = agno;
+                __entry->agbno = agbno;
+                __entry->len = len;
+                __entry->owner = owner;
+                __entry->offset = offset;
+                __entry->flags = flags;
+        ),
+        TP_printk("dev %d:%d agno %u agbno %u len %u owner %lld offset %llu flags 0x%x",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->agno,
+                  __entry->agbno,
+                  __entry->len,
+                  __entry->owner,
+                  __entry->offset,
+                  __entry->flags)
+);
+#define DEFINE_RMAPBT_EVENT(name) \
+DEFINE_EVENT(xfs_rmapbt_class, name, \
+        TP_PROTO(struct xfs_mount *mp, xfs_agnumber_t agno, \
+                 xfs_agblock_t agbno, xfs_extlen_t len, \
+                 uint64_t owner, uint64_t offset, unsigned int flags), \
+        TP_ARGS(mp, agno, agbno, len, owner, offset, flags))
+
+#define DEFINE_RMAP_DEFERRED_EVENT DEFINE_MAP_EXTENT_DEFERRED_EVENT
+DEFINE_RMAP_DEFERRED_EVENT(xfs_rmap_defer);
+DEFINE_RMAP_DEFERRED_EVENT(xfs_rmap_deferred);
+
+DEFINE_BUSY_EVENT(xfs_rmapbt_alloc_block);
+DEFINE_BUSY_EVENT(xfs_rmapbt_free_block);
+DEFINE_RMAPBT_EVENT(xfs_rmap_update);
+DEFINE_RMAPBT_EVENT(xfs_rmap_insert);
+DEFINE_RMAPBT_EVENT(xfs_rmap_delete);
+DEFINE_AG_ERROR_EVENT(xfs_rmap_insert_error);
+DEFINE_AG_ERROR_EVENT(xfs_rmap_delete_error);
+DEFINE_AG_ERROR_EVENT(xfs_rmap_update_error);
+DEFINE_RMAPBT_EVENT(xfs_rmap_lookup_le_range_result);
+DEFINE_RMAPBT_EVENT(xfs_rmap_find_right_neighbor_result);
+DEFINE_RMAPBT_EVENT(xfs_rmap_find_left_neighbor_result);
+
 #endif /* _TRACE_XFS_H */
 
 #undef TRACE_INCLUDE_PATH
diff --git a/fs/xfs/xfs_trans.h b/fs/xfs/xfs_trans.h
index 9b2b9fa89331..e2bf86aad33d 100644
--- a/fs/xfs/xfs_trans.h
+++ b/fs/xfs/xfs_trans.h
@@ -33,6 +33,9 @@ struct xfs_trans;
 struct xfs_trans_res;
 struct xfs_dquot_acct;
 struct xfs_busy_extent;
+struct xfs_rud_log_item;
+struct xfs_rui_log_item;
+struct xfs_btree_cur;
 
 typedef struct xfs_log_item {
         struct list_head                li_ail;         /* AIL pointers */
@@ -210,17 +213,14 @@ void		xfs_trans_ichgtime(struct xfs_trans *, struct xfs_inode *, int);
 void            xfs_trans_ijoin(struct xfs_trans *, struct xfs_inode *, uint);
 void            xfs_trans_log_buf(xfs_trans_t *, struct xfs_buf *, uint, uint);
 void            xfs_trans_log_inode(xfs_trans_t *, struct xfs_inode *, uint);
-struct xfs_efi_log_item *xfs_trans_get_efi(xfs_trans_t *, uint);
-void            xfs_trans_log_efi_extent(xfs_trans_t *,
-                                         struct xfs_efi_log_item *,
-                                         xfs_fsblock_t,
-                                         xfs_extlen_t);
-struct xfs_efd_log_item *xfs_trans_get_efd(xfs_trans_t *,
+
+void            xfs_extent_free_init_defer_op(void);
+struct xfs_efd_log_item *xfs_trans_get_efd(struct xfs_trans *,
                                   struct xfs_efi_log_item *,
                                   uint);
 int             xfs_trans_free_extent(struct xfs_trans *,
                                       struct xfs_efd_log_item *, xfs_fsblock_t,
-                                      xfs_extlen_t);
+                                      xfs_extlen_t, struct xfs_owner_info *);
 int             xfs_trans_commit(struct xfs_trans *);
 int             __xfs_trans_roll(struct xfs_trans **, struct xfs_inode *, int *);
 int             xfs_trans_roll(struct xfs_trans **, struct xfs_inode *);
@@ -236,4 +236,16 @@ void		xfs_trans_buf_copy_type(struct xfs_buf *dst_bp,
 extern kmem_zone_t      *xfs_trans_zone;
 extern kmem_zone_t      *xfs_log_item_desc_zone;
 
+/* rmap updates */
+enum xfs_rmap_intent_type;
+
+void xfs_rmap_update_init_defer_op(void);
+struct xfs_rud_log_item *xfs_trans_get_rud(struct xfs_trans *tp,
+                struct xfs_rui_log_item *ruip);
+int xfs_trans_log_finish_rmap_update(struct xfs_trans *tp,
+                struct xfs_rud_log_item *rudp, enum xfs_rmap_intent_type type,
+                __uint64_t owner, int whichfork, xfs_fileoff_t startoff,
+                xfs_fsblock_t startblock, xfs_filblks_t blockcount,
+                xfs_exntst_t state, struct xfs_btree_cur **pcur);
+
 #endif  /* __XFS_TRANS_H__ */
diff --git a/fs/xfs/xfs_trans_extfree.c b/fs/xfs/xfs_trans_extfree.c
index a96ae540eb62..459ddec137a4 100644
--- a/fs/xfs/xfs_trans_extfree.c
+++ b/fs/xfs/xfs_trans_extfree.c
@@ -21,66 +21,15 @@
 #include "xfs_format.h"
 #include "xfs_log_format.h"
 #include "xfs_trans_resv.h"
+#include "xfs_bit.h"
 #include "xfs_mount.h"
+#include "xfs_defer.h"
 #include "xfs_trans.h"
 #include "xfs_trans_priv.h"
 #include "xfs_extfree_item.h"
 #include "xfs_alloc.h"
-
-/*
- * This routine is called to allocate an "extent free intention"
- * log item that will hold nextents worth of extents.  The
- * caller must use all nextents extents, because we are not
- * flexible about this at all.
- */
-xfs_efi_log_item_t *
-xfs_trans_get_efi(xfs_trans_t   *tp,
-                  uint          nextents)
-{
-        xfs_efi_log_item_t      *efip;
-
-        ASSERT(tp != NULL);
-        ASSERT(nextents > 0);
-
-        efip = xfs_efi_init(tp->t_mountp, nextents);
-        ASSERT(efip != NULL);
-
-        /*
-         * Get a log_item_desc to point at the new item.
-         */
-        xfs_trans_add_item(tp, &efip->efi_item);
-        return efip;
-}
-
-/*
- * This routine is called to indicate that the described
- * extent is to be logged as needing to be freed.  It should
- * be called once for each extent to be freed.
- */
-void
-xfs_trans_log_efi_extent(xfs_trans_t            *tp,
-                         xfs_efi_log_item_t     *efip,
-                         xfs_fsblock_t          start_block,
-                         xfs_extlen_t           ext_len)
-{
-        uint                    next_extent;
-        xfs_extent_t            *extp;
-
-        tp->t_flags |= XFS_TRANS_DIRTY;
-        efip->efi_item.li_desc->lid_flags |= XFS_LID_DIRTY;
-
-        /*
-         * atomic_inc_return gives us the value after the increment;
-         * we want to use it as an array index so we need to subtract 1 from
-         * it.
-         */
-        next_extent = atomic_inc_return(&efip->efi_next_extent) - 1;
-        ASSERT(next_extent < efip->efi_format.efi_nextents);
-        extp = &(efip->efi_format.efi_extents[next_extent]);
-        extp->ext_start = start_block;
-        extp->ext_len = ext_len;
-}
-
+#include "xfs_bmap.h"
+#include "xfs_trace.h"
 
 /*
  * This routine is called to allocate an "extent free done"
@@ -88,12 +37,12 @@ xfs_trans_log_efi_extent(xfs_trans_t		*tp,
  * caller must use all nextents extents, because we are not
  * flexible about this at all.
  */
-xfs_efd_log_item_t *
-xfs_trans_get_efd(xfs_trans_t           *tp,
-                  xfs_efi_log_item_t    *efip,
-                  uint                  nextents)
+struct xfs_efd_log_item *
+xfs_trans_get_efd(struct xfs_trans              *tp,
+                  struct xfs_efi_log_item       *efip,
+                  uint                          nextents)
 {
-        xfs_efd_log_item_t      *efdp;
+        struct xfs_efd_log_item                 *efdp;
 
         ASSERT(tp != NULL);
         ASSERT(nextents > 0);
@@ -118,13 +67,19 @@ xfs_trans_free_extent(
         struct xfs_trans        *tp,
         struct xfs_efd_log_item *efdp,
         xfs_fsblock_t           start_block,
-        xfs_extlen_t            ext_len)
+        xfs_extlen_t            ext_len,
+        struct xfs_owner_info   *oinfo)
 {
+        struct xfs_mount        *mp = tp->t_mountp;
         uint                    next_extent;
+        xfs_agnumber_t          agno = XFS_FSB_TO_AGNO(mp, start_block);
+        xfs_agblock_t           agbno = XFS_FSB_TO_AGBNO(mp, start_block);
         struct xfs_extent       *extp;
         int                     error;
 
-        error = xfs_free_extent(tp, start_block, ext_len);
+        trace_xfs_bmap_free_deferred(tp->t_mountp, agno, 0, agbno, ext_len);
+
+        error = xfs_free_extent(tp, start_block, ext_len, oinfo);
 
         /*
          * Mark the transaction dirty, even on error. This ensures the
@@ -145,3 +100,139 @@ xfs_trans_free_extent(
 
         return error;
 }
+
+/* Sort bmap items by AG. */
+static int
+xfs_extent_free_diff_items(
+        void                            *priv,
+        struct list_head                *a,
+        struct list_head                *b)
+{
+        struct xfs_mount                *mp = priv;
+        struct xfs_extent_free_item     *ra;
+        struct xfs_extent_free_item     *rb;
+
+        ra = container_of(a, struct xfs_extent_free_item, xefi_list);
+        rb = container_of(b, struct xfs_extent_free_item, xefi_list);
+        return  XFS_FSB_TO_AGNO(mp, ra->xefi_startblock) -
+                XFS_FSB_TO_AGNO(mp, rb->xefi_startblock);
+}
+
+/* Get an EFI. */
+STATIC void *
+xfs_extent_free_create_intent(
+        struct xfs_trans                *tp,
+        unsigned int                    count)
+{
+        struct xfs_efi_log_item         *efip;
+
+        ASSERT(tp != NULL);
+        ASSERT(count > 0);
+
+        efip = xfs_efi_init(tp->t_mountp, count);
+        ASSERT(efip != NULL);
+
+        /*
+         * Get a log_item_desc to point at the new item.
+         */
+        xfs_trans_add_item(tp, &efip->efi_item);
+        return efip;
+}
+
+/* Log a free extent to the intent item. */
+STATIC void
+xfs_extent_free_log_item(
+        struct xfs_trans                *tp,
+        void                            *intent,
+        struct list_head                *item)
+{
+        struct xfs_efi_log_item         *efip = intent;
+        struct xfs_extent_free_item     *free;
+        uint                            next_extent;
+        struct xfs_extent               *extp;
+
+        free = container_of(item, struct xfs_extent_free_item, xefi_list);
+
+        tp->t_flags |= XFS_TRANS_DIRTY;
+        efip->efi_item.li_desc->lid_flags |= XFS_LID_DIRTY;
+
+        /*
+         * atomic_inc_return gives us the value after the increment;
+         * we want to use it as an array index so we need to subtract 1 from
+         * it.
+         */
+        next_extent = atomic_inc_return(&efip->efi_next_extent) - 1;
+        ASSERT(next_extent < efip->efi_format.efi_nextents);
+        extp = &efip->efi_format.efi_extents[next_extent];
+        extp->ext_start = free->xefi_startblock;
+        extp->ext_len = free->xefi_blockcount;
+}
+
+/* Get an EFD so we can process all the free extents. */
+STATIC void *
+xfs_extent_free_create_done(
+        struct xfs_trans                *tp,
+        void                            *intent,
+        unsigned int                    count)
+{
+        return xfs_trans_get_efd(tp, intent, count);
+}
+
+/* Process a free extent. */
+STATIC int
+xfs_extent_free_finish_item(
+        struct xfs_trans                *tp,
+        struct xfs_defer_ops            *dop,
+        struct list_head                *item,
+        void                            *done_item,
+        void                            **state)
+{
+        struct xfs_extent_free_item     *free;
+        int                             error;
+
+        free = container_of(item, struct xfs_extent_free_item, xefi_list);
+        error = xfs_trans_free_extent(tp, done_item,
+                        free->xefi_startblock,
+                        free->xefi_blockcount,
+                        &free->xefi_oinfo);
+        kmem_free(free);
+        return error;
+}
+
+/* Abort all pending EFIs. */
+STATIC void
+xfs_extent_free_abort_intent(
+        void                            *intent)
+{
+        xfs_efi_release(intent);
+}
+
+/* Cancel a free extent. */
+STATIC void
+xfs_extent_free_cancel_item(
+        struct list_head                *item)
+{
+        struct xfs_extent_free_item     *free;
+
+        free = container_of(item, struct xfs_extent_free_item, xefi_list);
+        kmem_free(free);
+}
+
+static const struct xfs_defer_op_type xfs_extent_free_defer_type = {
+        .type           = XFS_DEFER_OPS_TYPE_FREE,
+        .max_items      = XFS_EFI_MAX_FAST_EXTENTS,
+        .diff_items     = xfs_extent_free_diff_items,
+        .create_intent  = xfs_extent_free_create_intent,
+        .abort_intent   = xfs_extent_free_abort_intent,
+        .log_item       = xfs_extent_free_log_item,
+        .create_done    = xfs_extent_free_create_done,
+        .finish_item    = xfs_extent_free_finish_item,
+        .cancel_item    = xfs_extent_free_cancel_item,
+};
+
+/* Register the deferred op type. */
+void
+xfs_extent_free_init_defer_op(void)
+{
+        xfs_defer_init_op_type(&xfs_extent_free_defer_type);
+}
diff --git a/fs/xfs/xfs_trans_rmap.c b/fs/xfs/xfs_trans_rmap.c
new file mode 100644
index 000000000000..5a50ef881568
--- /dev/null
+++ b/fs/xfs/xfs_trans_rmap.c
@@ -0,0 +1,271 @@
+/*
+ * Copyright (C) 2016 Oracle.  All Rights Reserved.
+ *
+ * Author: Darrick J. Wong <darrick.wong@oracle.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation; either version 2
+ * of the License, or (at your option) any later version.
+ *
+ * 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_mount.h"
+#include "xfs_defer.h"
+#include "xfs_trans.h"
+#include "xfs_trans_priv.h"
+#include "xfs_rmap_item.h"
+#include "xfs_alloc.h"
+#include "xfs_rmap.h"
+
+/* Set the map extent flags for this reverse mapping. */
+static void
+xfs_trans_set_rmap_flags(
+        struct xfs_map_extent           *rmap,
+        enum xfs_rmap_intent_type       type,
+        int                             whichfork,
+        xfs_exntst_t                    state)
+{
+        rmap->me_flags = 0;
+        if (state == XFS_EXT_UNWRITTEN)
+                rmap->me_flags |= XFS_RMAP_EXTENT_UNWRITTEN;
+        if (whichfork == XFS_ATTR_FORK)
+                rmap->me_flags |= XFS_RMAP_EXTENT_ATTR_FORK;
+        switch (type) {
+        case XFS_RMAP_MAP:
+                rmap->me_flags |= XFS_RMAP_EXTENT_MAP;
+                break;
+        case XFS_RMAP_UNMAP:
+                rmap->me_flags |= XFS_RMAP_EXTENT_UNMAP;
+                break;
+        case XFS_RMAP_CONVERT:
+                rmap->me_flags |= XFS_RMAP_EXTENT_CONVERT;
+                break;
+        case XFS_RMAP_ALLOC:
+                rmap->me_flags |= XFS_RMAP_EXTENT_ALLOC;
+                break;
+        case XFS_RMAP_FREE:
+                rmap->me_flags |= XFS_RMAP_EXTENT_FREE;
+                break;
+        default:
+                ASSERT(0);
+        }
+}
+
+struct xfs_rud_log_item *
+xfs_trans_get_rud(
+        struct xfs_trans                *tp,
+        struct xfs_rui_log_item         *ruip)
+{
+        struct xfs_rud_log_item         *rudp;
+
+        rudp = xfs_rud_init(tp->t_mountp, ruip);
+        xfs_trans_add_item(tp, &rudp->rud_item);
+        return rudp;
+}
+
+/*
+ * Finish an rmap update and log it to the RUD. Note that the transaction is
+ * marked dirty regardless of whether the rmap update succeeds or fails to
+ * support the RUI/RUD lifecycle rules.
+ */
+int
+xfs_trans_log_finish_rmap_update(
+        struct xfs_trans                *tp,
+        struct xfs_rud_log_item         *rudp,
+        enum xfs_rmap_intent_type       type,
+        __uint64_t                      owner,
+        int                             whichfork,
+        xfs_fileoff_t                   startoff,
+        xfs_fsblock_t                   startblock,
+        xfs_filblks_t                   blockcount,
+        xfs_exntst_t                    state,
+        struct xfs_btree_cur            **pcur)
+{
+        int                             error;
+
+        error = xfs_rmap_finish_one(tp, type, owner, whichfork, startoff,
+                        startblock, blockcount, state, pcur);
+
+        /*
+         * Mark the transaction dirty, even on error. This ensures the
+         * transaction is aborted, which:
+         *
+         * 1.) releases the RUI and frees the RUD
+         * 2.) shuts down the filesystem
+         */
+        tp->t_flags |= XFS_TRANS_DIRTY;
+        rudp->rud_item.li_desc->lid_flags |= XFS_LID_DIRTY;
+
+        return error;
+}
+
+/* Sort rmap intents by AG. */
+static int
+xfs_rmap_update_diff_items(
+        void                            *priv,
+        struct list_head                *a,
+        struct list_head                *b)
+{
+        struct xfs_mount                *mp = priv;
+        struct xfs_rmap_intent          *ra;
+        struct xfs_rmap_intent          *rb;
+
+        ra = container_of(a, struct xfs_rmap_intent, ri_list);
+        rb = container_of(b, struct xfs_rmap_intent, ri_list);
+        return  XFS_FSB_TO_AGNO(mp, ra->ri_bmap.br_startblock) -
+                XFS_FSB_TO_AGNO(mp, rb->ri_bmap.br_startblock);
+}
+
+/* Get an RUI. */
+STATIC void *
+xfs_rmap_update_create_intent(
+        struct xfs_trans                *tp,
+        unsigned int                    count)
+{
+        struct xfs_rui_log_item         *ruip;
+
+        ASSERT(tp != NULL);
+        ASSERT(count > 0);
+
+        ruip = xfs_rui_init(tp->t_mountp, count);
+        ASSERT(ruip != NULL);
+
+        /*
+         * Get a log_item_desc to point at the new item.
+         */
+        xfs_trans_add_item(tp, &ruip->rui_item);
+        return ruip;
+}
+
+/* Log rmap updates in the intent item. */
+STATIC void
+xfs_rmap_update_log_item(
+        struct xfs_trans                *tp,
+        void                            *intent,
+        struct list_head                *item)
+{
+        struct xfs_rui_log_item         *ruip = intent;
+        struct xfs_rmap_intent          *rmap;
+        uint                            next_extent;
+        struct xfs_map_extent           *map;
+
+        rmap = container_of(item, struct xfs_rmap_intent, ri_list);
+
+        tp->t_flags |= XFS_TRANS_DIRTY;
+        ruip->rui_item.li_desc->lid_flags |= XFS_LID_DIRTY;
+
+        /*
+         * atomic_inc_return gives us the value after the increment;
+         * we want to use it as an array index so we need to subtract 1 from
+         * it.
+         */
+        next_extent = atomic_inc_return(&ruip->rui_next_extent) - 1;
+        ASSERT(next_extent < ruip->rui_format.rui_nextents);
+        map = &ruip->rui_format.rui_extents[next_extent];
+        map->me_owner = rmap->ri_owner;
+        map->me_startblock = rmap->ri_bmap.br_startblock;
+        map->me_startoff = rmap->ri_bmap.br_startoff;
+        map->me_len = rmap->ri_bmap.br_blockcount;
+        xfs_trans_set_rmap_flags(map, rmap->ri_type, rmap->ri_whichfork,
+                        rmap->ri_bmap.br_state);
+}
+
+/* Get an RUD so we can process all the deferred rmap updates. */
+STATIC void *
+xfs_rmap_update_create_done(
+        struct xfs_trans                *tp,
+        void                            *intent,
+        unsigned int                    count)
+{
+        return xfs_trans_get_rud(tp, intent);
+}
+
+/* Process a deferred rmap update. */
+STATIC int
+xfs_rmap_update_finish_item(
+        struct xfs_trans                *tp,
+        struct xfs_defer_ops            *dop,
+        struct list_head                *item,
+        void                            *done_item,
+        void                            **state)
+{
+        struct xfs_rmap_intent          *rmap;
+        int                             error;
+
+        rmap = container_of(item, struct xfs_rmap_intent, ri_list);
+        error = xfs_trans_log_finish_rmap_update(tp, done_item,
+                        rmap->ri_type,
+                        rmap->ri_owner, rmap->ri_whichfork,
+                        rmap->ri_bmap.br_startoff,
+                        rmap->ri_bmap.br_startblock,
+                        rmap->ri_bmap.br_blockcount,
+                        rmap->ri_bmap.br_state,
+                        (struct xfs_btree_cur **)state);
+        kmem_free(rmap);
+        return error;
+}
+
+/* Clean up after processing deferred rmaps. */
+STATIC void
+xfs_rmap_update_finish_cleanup(
+        struct xfs_trans        *tp,
+        void                    *state,
+        int                     error)
+{
+        struct xfs_btree_cur    *rcur = state;
+
+        xfs_rmap_finish_one_cleanup(tp, rcur, error);
+}
+
+/* Abort all pending RUIs. */
+STATIC void
+xfs_rmap_update_abort_intent(
+        void                            *intent)
+{
+        xfs_rui_release(intent);
+}
+
+/* Cancel a deferred rmap update. */
+STATIC void
+xfs_rmap_update_cancel_item(
+        struct list_head                *item)
+{
+        struct xfs_rmap_intent          *rmap;
+
+        rmap = container_of(item, struct xfs_rmap_intent, ri_list);
+        kmem_free(rmap);
+}
+
+static const struct xfs_defer_op_type xfs_rmap_update_defer_type = {
+        .type           = XFS_DEFER_OPS_TYPE_RMAP,
+        .max_items      = XFS_RUI_MAX_FAST_EXTENTS,
+        .diff_items     = xfs_rmap_update_diff_items,
+        .create_intent  = xfs_rmap_update_create_intent,
+        .abort_intent   = xfs_rmap_update_abort_intent,
+        .log_item       = xfs_rmap_update_log_item,
+        .create_done    = xfs_rmap_update_create_done,
+        .finish_item    = xfs_rmap_update_finish_item,
+        .finish_cleanup = xfs_rmap_update_finish_cleanup,
+        .cancel_item    = xfs_rmap_update_cancel_item,
+};
+
+/* Register the deferred op type. */
+void
+xfs_rmap_update_init_defer_op(void)
+{
+        xfs_defer_init_op_type(&xfs_rmap_update_defer_type);
+}