18 files changed, 366 insertions, 176 deletions

diff --git a/fs/xfs/libxfs/xfs_alloc_btree.c b/fs/xfs/libxfs/xfs_alloc_btree.c
index 444626ddbd1b..d9b42425291e 100644
--- a/fs/xfs/libxfs/xfs_alloc_btree.c
+++ b/fs/xfs/libxfs/xfs_alloc_btree.c
@@ -118,8 +118,6 @@ xfs_allocbt_free_block(
         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);
-
-        xfs_trans_binval(cur->bc_tp, bp);
         return 0;
 }
 
diff --git a/fs/xfs/libxfs/xfs_attr_sf.h b/fs/xfs/libxfs/xfs_attr_sf.h
index 919756e3ba53..90928bbe693c 100644
--- a/fs/xfs/libxfs/xfs_attr_sf.h
+++ b/fs/xfs/libxfs/xfs_attr_sf.h
@@ -24,22 +24,6 @@
  * Small attribute lists are packed as tightly as possible so as
  * to fit into the literal area of the inode.
  */
-
-/*
- * Entries are packed toward the top as tight as possible.
- */
-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 */
-        } hdr;
-        struct xfs_attr_sf_entry {
-                __uint8_t namelen;      /* actual length of name (no NULL) */
-                __uint8_t valuelen;     /* actual length of value (no NULL) */
-                __uint8_t flags;        /* flags bits (see xfs_attr_leaf.h) */
-                __uint8_t nameval[1];   /* name & value bytes concatenated */
-        } list[1];                      /* variable sized array */
-} xfs_attr_shortform_t;
 typedef struct xfs_attr_sf_hdr xfs_attr_sf_hdr_t;
 typedef struct xfs_attr_sf_entry xfs_attr_sf_entry_t;
 
diff --git a/fs/xfs/libxfs/xfs_bmap.c b/fs/xfs/libxfs/xfs_bmap.c
index ef00156f4f96..041b6948aecc 100644
--- a/fs/xfs/libxfs/xfs_bmap.c
+++ b/fs/xfs/libxfs/xfs_bmap.c
@@ -477,10 +477,7 @@ xfs_bmap_check_leaf_extents(
                 }
                 block = XFS_BUF_TO_BLOCK(bp);
         }
-        if (bp_release) {
-                bp_release = 0;
-                xfs_trans_brelse(NULL, bp);
-        }
+
         return;
 
 error0:
@@ -912,7 +909,7 @@ xfs_bmap_local_to_extents(
          * We don't want to deal with the case of keeping inode data inline yet.
          * So sending the data fork of a regular inode is invalid.
          */
-        ASSERT(!(S_ISREG(ip->i_d.di_mode) && whichfork == XFS_DATA_FORK));
+        ASSERT(!(S_ISREG(VFS_I(ip)->i_mode) && whichfork == XFS_DATA_FORK));
         ifp = XFS_IFORK_PTR(ip, whichfork);
         ASSERT(XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_LOCAL);
 
@@ -1079,7 +1076,7 @@ xfs_bmap_add_attrfork_local(
         if (ip->i_df.if_bytes <= XFS_IFORK_DSIZE(ip))
                 return 0;
 
-        if (S_ISDIR(ip->i_d.di_mode)) {
+        if (S_ISDIR(VFS_I(ip)->i_mode)) {
                 memset(&dargs, 0, sizeof(dargs));
                 dargs.geo = ip->i_mount->m_dir_geo;
                 dargs.dp = ip;
@@ -1091,7 +1088,7 @@ xfs_bmap_add_attrfork_local(
                 return xfs_dir2_sf_to_block(&dargs);
         }
 
-        if (S_ISLNK(ip->i_d.di_mode))
+        if (S_ISLNK(VFS_I(ip)->i_mode))
                 return xfs_bmap_local_to_extents(tp, ip, firstblock, 1,
                                                  flags, XFS_DATA_FORK,
                                                  xfs_symlink_local_to_remote);
@@ -4721,6 +4718,66 @@ error0:
 }
 
 /*
+ * When a delalloc extent is split (e.g., due to a hole punch), the original
+ * indlen reservation must be shared across the two new extents that are left
+ * behind.
+ *
+ * Given the original reservation and the worst case indlen for the two new
+ * extents (as calculated by xfs_bmap_worst_indlen()), split the original
+ * reservation fairly across the two new extents. If necessary, steal available
+ * blocks from a deleted extent to make up a reservation deficiency (e.g., if
+ * ores == 1). The number of stolen blocks is returned. The availability and
+ * subsequent accounting of stolen blocks is the responsibility of the caller.
+ */
+static xfs_filblks_t
+xfs_bmap_split_indlen(
+        xfs_filblks_t                   ores,           /* original res. */
+        xfs_filblks_t                   *indlen1,       /* ext1 worst indlen */
+        xfs_filblks_t                   *indlen2,       /* ext2 worst indlen */
+        xfs_filblks_t                   avail)          /* stealable blocks */
+{
+        xfs_filblks_t                   len1 = *indlen1;
+        xfs_filblks_t                   len2 = *indlen2;
+        xfs_filblks_t                   nres = len1 + len2; /* new total res. */
+        xfs_filblks_t                   stolen = 0;
+
+        /*
+         * Steal as many blocks as we can to try and satisfy the worst case
+         * indlen for both new extents.
+         */
+        while (nres > ores && avail) {
+                nres--;
+                avail--;
+                stolen++;
+        }
+
+        /*
+         * The only blocks available are those reserved for the original
+         * extent and what we can steal from the extent being removed.
+         * If this still isn't enough to satisfy the combined
+         * requirements for the two new extents, skim blocks off of each
+         * of the new reservations until they match what is available.
+         */
+        while (nres > ores) {
+                if (len1) {
+                        len1--;
+                        nres--;
+                }
+                if (nres == ores)
+                        break;
+                if (len2) {
+                        len2--;
+                        nres--;
+                }
+        }
+
+        *indlen1 = len1;
+        *indlen2 = len2;
+
+        return stolen;
+}
+
+/*
  * Called by xfs_bmapi to update file extent records and the btree
  * after removing space (or undoing a delayed allocation).
  */
@@ -4984,28 +5041,29 @@ xfs_bmap_del_extent(
                         XFS_IFORK_NEXT_SET(ip, whichfork,
                                 XFS_IFORK_NEXTENTS(ip, whichfork) + 1);
                 } else {
+                        xfs_filblks_t   stolen;
                         ASSERT(whichfork == XFS_DATA_FORK);
-                        temp = xfs_bmap_worst_indlen(ip, temp);
+
+                        /*
+                         * Distribute the original indlen reservation across the
+                         * two new extents. Steal blocks from the deleted extent
+                         * if necessary. Stealing blocks simply fudges the
+                         * fdblocks accounting in xfs_bunmapi().
+                         */
+                        temp = xfs_bmap_worst_indlen(ip, got.br_blockcount);
+                        temp2 = xfs_bmap_worst_indlen(ip, new.br_blockcount);
+                        stolen = xfs_bmap_split_indlen(da_old, &temp, &temp2,
+                                                       del->br_blockcount);
+                        da_new = temp + temp2 - stolen;
+                        del->br_blockcount -= stolen;
+
+                        /*
+                         * Set the reservation for each extent. Warn if either
+                         * is zero as this can lead to delalloc problems.
+                         */
+                        WARN_ON_ONCE(!temp || !temp2);
                         xfs_bmbt_set_startblock(ep, nullstartblock((int)temp));
-                        temp2 = xfs_bmap_worst_indlen(ip, temp2);
                         new.br_startblock = nullstartblock((int)temp2);
-                        da_new = temp + temp2;
-                        while (da_new > da_old) {
-                                if (temp) {
-                                        temp--;
-                                        da_new--;
-                                        xfs_bmbt_set_startblock(ep,
-                                                nullstartblock((int)temp));
-                                }
-                                if (da_new == da_old)
-                                        break;
-                                if (temp2) {
-                                        temp2--;
-                                        da_new--;
-                                        new.br_startblock =
-                                                nullstartblock((int)temp2);
-                                }
-                        }
                 }
                 trace_xfs_bmap_post_update(ip, *idx, state, _THIS_IP_);
                 xfs_iext_insert(ip, *idx + 1, 1, &new, state);
@@ -5210,7 +5268,7 @@ xfs_bunmapi(
                          * This is better than zeroing it.
                          */
                         ASSERT(del.br_state == XFS_EXT_NORM);
-                        ASSERT(xfs_trans_get_block_res(tp) > 0);
+                        ASSERT(tp->t_blk_res > 0);
                         /*
                          * If this spans a realtime extent boundary,
                          * chop it back to the start of the one we end at.
@@ -5241,7 +5299,7 @@ xfs_bunmapi(
                                 del.br_startblock += mod;
                         } else if ((del.br_startoff == start &&
                                     (del.br_state == XFS_EXT_UNWRITTEN ||
-                                     xfs_trans_get_block_res(tp) == 0)) ||
+                                     tp->t_blk_res == 0)) ||
                                    !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
                                 /*
                                  * Can't make it unwritten.  There isn't
@@ -5296,9 +5354,37 @@ xfs_bunmapi(
                                 goto nodelete;
                         }
                 }
+
+                /*
+                 * If it's the case where the directory code is running
+                 * with no block reservation, and the deleted block is in
+                 * the middle of its extent, and the resulting insert
+                 * of an extent would cause transformation to btree format,
+                 * then reject it.  The calling code will then swap
+                 * blocks around instead.
+                 * We have to do this now, rather than waiting for the
+                 * conversion to btree format, since the transaction
+                 * will be dirty.
+                 */
+                if (!wasdel && tp->t_blk_res == 0 &&
+                    XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS &&
+                    XFS_IFORK_NEXTENTS(ip, whichfork) >= /* Note the >= */
+                        XFS_IFORK_MAXEXT(ip, whichfork) &&
+                    del.br_startoff > got.br_startoff &&
+                    del.br_startoff + del.br_blockcount <
+                    got.br_startoff + got.br_blockcount) {
+                        error = -ENOSPC;
+                        goto error0;
+                }
+
+                /*
+                 * Unreserve quota and update realtime free space, if
+                 * appropriate. If delayed allocation, update the inode delalloc
+                 * counter now and wait to update the sb counters as
+                 * xfs_bmap_del_extent() might need to borrow some blocks.
+                 */
                 if (wasdel) {
                         ASSERT(startblockval(del.br_startblock) > 0);
-                        /* Update realtime/data freespace, unreserve quota */
                         if (isrt) {
                                 xfs_filblks_t rtexts;
 
@@ -5309,8 +5395,6 @@ xfs_bunmapi(
                                         ip, -((long)del.br_blockcount), 0,
                                         XFS_QMOPT_RES_RTBLKS);
                         } else {
-                                xfs_mod_fdblocks(mp, (int64_t)del.br_blockcount,
-                                                 false);
                                 (void)xfs_trans_reserve_quota_nblks(NULL,
                                         ip, -((long)del.br_blockcount), 0,
                                         XFS_QMOPT_RES_REGBLKS);
@@ -5321,32 +5405,16 @@ xfs_bunmapi(
                                         XFS_BTCUR_BPRV_WASDEL;
                 } else if (cur)
                         cur->bc_private.b.flags &= ~XFS_BTCUR_BPRV_WASDEL;
-                /*
-                 * If it's the case where the directory code is running
-                 * with no block reservation, and the deleted block is in
-                 * the middle of its extent, and the resulting insert
-                 * of an extent would cause transformation to btree format,
-                 * then reject it.  The calling code will then swap
-                 * blocks around instead.
-                 * We have to do this now, rather than waiting for the
-                 * conversion to btree format, since the transaction
-                 * will be dirty.
-                 */
-                if (!wasdel && xfs_trans_get_block_res(tp) == 0 &&
-                    XFS_IFORK_FORMAT(ip, whichfork) == XFS_DINODE_FMT_EXTENTS &&
-                    XFS_IFORK_NEXTENTS(ip, whichfork) >= /* Note the >= */
-                        XFS_IFORK_MAXEXT(ip, whichfork) &&
-                    del.br_startoff > got.br_startoff &&
-                    del.br_startoff + del.br_blockcount <
-                    got.br_startoff + got.br_blockcount) {
-                        error = -ENOSPC;
-                        goto error0;
-                }
+
                 error = xfs_bmap_del_extent(ip, tp, &lastx, flist, cur, &del,
                                 &tmp_logflags, whichfork);
                 logflags |= tmp_logflags;
                 if (error)
                         goto error0;
+
+                if (!isrt && wasdel)
+                        xfs_mod_fdblocks(mp, (int64_t)del.br_blockcount, false);
+
                 bno = del.br_startoff - 1;
 nodelete:
                 /*
diff --git a/fs/xfs/libxfs/xfs_bmap_btree.c b/fs/xfs/libxfs/xfs_bmap_btree.c
index 1637c37bfbaa..6282f6e708af 100644
--- a/fs/xfs/libxfs/xfs_bmap_btree.c
+++ b/fs/xfs/libxfs/xfs_bmap_btree.c
@@ -461,7 +461,7 @@ xfs_bmbt_alloc_block(
                  * reservation amount is insufficient then we may fail a
                  * block allocation here and corrupt the filesystem.
                  */
-                args.minleft = xfs_trans_get_block_res(args.tp);
+                args.minleft = args.tp->t_blk_res;
         } else if (cur->bc_private.b.flist->xbf_low) {
                 args.type = XFS_ALLOCTYPE_START_BNO;
         } else {
@@ -470,7 +470,7 @@ xfs_bmbt_alloc_block(
 
         args.minlen = args.maxlen = args.prod = 1;
         args.wasdel = cur->bc_private.b.flags & XFS_BTCUR_BPRV_WASDEL;
-        if (!args.wasdel && xfs_trans_get_block_res(args.tp) == 0) {
+        if (!args.wasdel && args.tp->t_blk_res == 0) {
                 error = -ENOSPC;
                 goto error0;
         }
@@ -531,7 +531,6 @@ xfs_bmbt_free_block(
 
         xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
         xfs_trans_mod_dquot_byino(tp, ip, XFS_TRANS_DQ_BCOUNT, -1L);
-        xfs_trans_binval(tp, bp);
         return 0;
 }
 
diff --git a/fs/xfs/libxfs/xfs_btree.c b/fs/xfs/libxfs/xfs_btree.c
index a0eb18ce3ad3..1f88e1ce770f 100644
--- a/fs/xfs/libxfs/xfs_btree.c
+++ b/fs/xfs/libxfs/xfs_btree.c
@@ -294,6 +294,21 @@ xfs_btree_sblock_verify_crc(
         return true;
 }
 
+static int
+xfs_btree_free_block(
+        struct xfs_btree_cur    *cur,
+        struct xfs_buf          *bp)
+{
+        int                     error;
+
+        error = cur->bc_ops->free_block(cur, bp);
+        if (!error) {
+                xfs_trans_binval(cur->bc_tp, bp);
+                XFS_BTREE_STATS_INC(cur, free);
+        }
+        return error;
+}
+
 /*
  * Delete the btree cursor.
  */
@@ -3209,6 +3224,7 @@ xfs_btree_kill_iroot(
         int                     level;
         int                     index;
         int                     numrecs;
+        int                     error;
 #ifdef DEBUG
         union xfs_btree_ptr     ptr;
         int                     i;
@@ -3272,8 +3288,6 @@ xfs_btree_kill_iroot(
         cpp = xfs_btree_ptr_addr(cur, 1, cblock);
 #ifdef DEBUG
         for (i = 0; i < numrecs; i++) {
-                int             error;
-
                 error = xfs_btree_check_ptr(cur, cpp, i, level - 1);
                 if (error) {
                         XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
@@ -3283,8 +3297,11 @@ xfs_btree_kill_iroot(
 #endif
         xfs_btree_copy_ptrs(cur, pp, cpp, numrecs);
 
-        cur->bc_ops->free_block(cur, cbp);
-        XFS_BTREE_STATS_INC(cur, free);
+        error = xfs_btree_free_block(cur, cbp);
+        if (error) {
+                XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
+                return error;
+        }
 
         cur->bc_bufs[level - 1] = NULL;
         be16_add_cpu(&block->bb_level, -1);
@@ -3317,14 +3334,12 @@ xfs_btree_kill_root(
          */
         cur->bc_ops->set_root(cur, newroot, -1);
 
-        error = cur->bc_ops->free_block(cur, bp);
+        error = xfs_btree_free_block(cur, bp);
         if (error) {
                 XFS_BTREE_TRACE_CURSOR(cur, XBT_ERROR);
                 return error;
         }
 
-        XFS_BTREE_STATS_INC(cur, free);
-
         cur->bc_bufs[level] = NULL;
         cur->bc_ra[level] = 0;
         cur->bc_nlevels--;
@@ -3830,10 +3845,9 @@ xfs_btree_delrec(
         }
 
         /* Free the deleted block. */
-        error = cur->bc_ops->free_block(cur, rbp);
+        error = xfs_btree_free_block(cur, rbp);
         if (error)
                 goto error0;
-        XFS_BTREE_STATS_INC(cur, free);
 
         /*
          * If we joined with the left neighbor, set the buffer in the
diff --git a/fs/xfs/libxfs/xfs_da_format.h b/fs/xfs/libxfs/xfs_da_format.h
index b14bbd6bb05f..8d4d8bce41bf 100644
--- a/fs/xfs/libxfs/xfs_da_format.h
+++ b/fs/xfs/libxfs/xfs_da_format.h
@@ -641,6 +641,22 @@ xfs_dir2_block_leaf_p(struct xfs_dir2_block_tail *btp)
  */
 #define XFS_ATTR_LEAF_MAPSIZE   3       /* how many freespace slots */
 
+/*
+ * Entries are packed toward the top as tight as possible.
+ */
+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 */
+        } hdr;
+        struct xfs_attr_sf_entry {
+                __uint8_t namelen;      /* actual length of name (no NULL) */
+                __uint8_t valuelen;     /* actual length of value (no NULL) */
+                __uint8_t flags;        /* flags bits (see xfs_attr_leaf.h) */
+                __uint8_t nameval[1];   /* name & value bytes concatenated */
+        } list[1];                      /* variable sized array */
+} xfs_attr_shortform_t;
+
 typedef struct xfs_attr_leaf_map {      /* RLE map of free bytes */
         __be16  base;                     /* base of free region */
         __be16  size;                     /* length of free region */
diff --git a/fs/xfs/libxfs/xfs_dir2.c b/fs/xfs/libxfs/xfs_dir2.c
index 2fb53a5c0a74..af0f9d171f8a 100644
--- a/fs/xfs/libxfs/xfs_dir2.c
+++ b/fs/xfs/libxfs/xfs_dir2.c
@@ -176,7 +176,7 @@ xfs_dir_isempty(
 {
         xfs_dir2_sf_hdr_t       *sfp;
 
-        ASSERT(S_ISDIR(dp->i_d.di_mode));
+        ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
         if (dp->i_d.di_size == 0)       /* might happen during shutdown. */
                 return 1;
         if (dp->i_d.di_size > XFS_IFORK_DSIZE(dp))
@@ -231,7 +231,7 @@ xfs_dir_init(
         struct xfs_da_args *args;
         int             error;
 
-        ASSERT(S_ISDIR(dp->i_d.di_mode));
+        ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
         error = xfs_dir_ino_validate(tp->t_mountp, pdp->i_ino);
         if (error)
                 return error;
@@ -266,7 +266,7 @@ xfs_dir_createname(
         int                     rval;
         int                     v;              /* type-checking value */
 
-        ASSERT(S_ISDIR(dp->i_d.di_mode));
+        ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
         if (inum) {
                 rval = xfs_dir_ino_validate(tp->t_mountp, inum);
                 if (rval)
@@ -364,7 +364,7 @@ xfs_dir_lookup(
         int             v;              /* type-checking value */
         int             lock_mode;
 
-        ASSERT(S_ISDIR(dp->i_d.di_mode));
+        ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
         XFS_STATS_INC(dp->i_mount, xs_dir_lookup);
 
         /*
@@ -443,7 +443,7 @@ xfs_dir_removename(
         int             rval;
         int             v;              /* type-checking value */
 
-        ASSERT(S_ISDIR(dp->i_d.di_mode));
+        ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
         XFS_STATS_INC(dp->i_mount, xs_dir_remove);
 
         args = kmem_zalloc(sizeof(*args), KM_SLEEP | KM_NOFS);
@@ -505,7 +505,7 @@ xfs_dir_replace(
         int             rval;
         int             v;              /* type-checking value */
 
-        ASSERT(S_ISDIR(dp->i_d.di_mode));
+        ASSERT(S_ISDIR(VFS_I(dp)->i_mode));
 
         rval = xfs_dir_ino_validate(tp->t_mountp, inum);
         if (rval)
diff --git a/fs/xfs/libxfs/xfs_dir2_node.c b/fs/xfs/libxfs/xfs_dir2_node.c
index 63ee03db796c..75a557432d0f 100644
--- a/fs/xfs/libxfs/xfs_dir2_node.c
+++ b/fs/xfs/libxfs/xfs_dir2_node.c
@@ -2235,6 +2235,9 @@ xfs_dir2_node_trim_free(
 
         dp = args->dp;
         tp = args->trans;
+
+        *rvalp = 0;
+
         /*
          * Read the freespace block.
          */
@@ -2255,7 +2258,6 @@ xfs_dir2_node_trim_free(
          */
         if (freehdr.nused > 0) {
                 xfs_trans_brelse(tp, bp);
-                *rvalp = 0;
                 return 0;
         }
         /*
diff --git a/fs/xfs/libxfs/xfs_ialloc.c b/fs/xfs/libxfs/xfs_ialloc.c
index 66d702e6b9ff..22297f9b0fd5 100644
--- a/fs/xfs/libxfs/xfs_ialloc.c
+++ b/fs/xfs/libxfs/xfs_ialloc.c
@@ -2403,8 +2403,8 @@ xfs_ialloc_compute_maxlevels(
 
         maxleafents = (1LL << XFS_INO_AGINO_BITS(mp)) >>
                 XFS_INODES_PER_CHUNK_LOG;
-        minleafrecs = mp->m_alloc_mnr[0];
-        minnoderecs = mp->m_alloc_mnr[1];
+        minleafrecs = mp->m_inobt_mnr[0];
+        minnoderecs = mp->m_inobt_mnr[1];
         maxblocks = (maxleafents + minleafrecs - 1) / minleafrecs;
         for (level = 1; maxblocks > 1; level++)
                 maxblocks = (maxblocks + minnoderecs - 1) / minnoderecs;
diff --git a/fs/xfs/libxfs/xfs_ialloc_btree.c b/fs/xfs/libxfs/xfs_ialloc_btree.c
index c679f3c05b63..89c21d771e35 100644
--- a/fs/xfs/libxfs/xfs_ialloc_btree.c
+++ b/fs/xfs/libxfs/xfs_ialloc_btree.c
@@ -125,16 +125,8 @@ xfs_inobt_free_block(
         struct xfs_btree_cur    *cur,
         struct xfs_buf          *bp)
 {
-        xfs_fsblock_t           fsbno;
-        int                     error;
-
-        fsbno = XFS_DADDR_TO_FSB(cur->bc_mp, XFS_BUF_ADDR(bp));
-        error = xfs_free_extent(cur->bc_tp, fsbno, 1);
-        if (error)
-                return error;
-
-        xfs_trans_binval(cur->bc_tp, bp);
-        return error;
+        return xfs_free_extent(cur->bc_tp,
+                        XFS_DADDR_TO_FSB(cur->bc_mp, XFS_BUF_ADDR(bp)), 1);
 }
 
 STATIC int
diff --git a/fs/xfs/libxfs/xfs_inode_buf.c b/fs/xfs/libxfs/xfs_inode_buf.c
index 1aabfda669b0..9d9559eb2835 100644
--- a/fs/xfs/libxfs/xfs_inode_buf.c
+++ b/fs/xfs/libxfs/xfs_inode_buf.c
@@ -195,28 +195,50 @@ xfs_imap_to_bp(
 }
 
 void
-xfs_dinode_from_disk(
-        xfs_icdinode_t          *to,
-        xfs_dinode_t            *from)
+xfs_inode_from_disk(
+        struct xfs_inode        *ip,
+        struct xfs_dinode       *from)
 {
-        to->di_magic = be16_to_cpu(from->di_magic);
-        to->di_mode = be16_to_cpu(from->di_mode);
-        to->di_version = from ->di_version;
+        struct xfs_icdinode     *to = &ip->i_d;
+        struct inode            *inode = VFS_I(ip);
+
+
+        /*
+         * Convert v1 inodes immediately to v2 inode format as this is the
+         * minimum inode version format we support in the rest of the code.
+         */
+        to->di_version = from->di_version;
+        if (to->di_version == 1) {
+                set_nlink(inode, be16_to_cpu(from->di_onlink));
+                to->di_projid_lo = 0;
+                to->di_projid_hi = 0;
+                to->di_version = 2;
+        } else {
+                set_nlink(inode, be32_to_cpu(from->di_nlink));
+                to->di_projid_lo = be16_to_cpu(from->di_projid_lo);
+                to->di_projid_hi = be16_to_cpu(from->di_projid_hi);
+        }
+
         to->di_format = from->di_format;
-        to->di_onlink = be16_to_cpu(from->di_onlink);
         to->di_uid = be32_to_cpu(from->di_uid);
         to->di_gid = be32_to_cpu(from->di_gid);
-        to->di_nlink = be32_to_cpu(from->di_nlink);
-        to->di_projid_lo = be16_to_cpu(from->di_projid_lo);
-        to->di_projid_hi = be16_to_cpu(from->di_projid_hi);
-        memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad));
         to->di_flushiter = be16_to_cpu(from->di_flushiter);
-        to->di_atime.t_sec = be32_to_cpu(from->di_atime.t_sec);
-        to->di_atime.t_nsec = be32_to_cpu(from->di_atime.t_nsec);
-        to->di_mtime.t_sec = be32_to_cpu(from->di_mtime.t_sec);
-        to->di_mtime.t_nsec = be32_to_cpu(from->di_mtime.t_nsec);
-        to->di_ctime.t_sec = be32_to_cpu(from->di_ctime.t_sec);
-        to->di_ctime.t_nsec = be32_to_cpu(from->di_ctime.t_nsec);
+
+        /*
+         * Time is signed, so need to convert to signed 32 bit before
+         * storing in inode timestamp which may be 64 bit. Otherwise
+         * a time before epoch is converted to a time long after epoch
+         * on 64 bit systems.
+         */
+        inode->i_atime.tv_sec = (int)be32_to_cpu(from->di_atime.t_sec);
+        inode->i_atime.tv_nsec = (int)be32_to_cpu(from->di_atime.t_nsec);
+        inode->i_mtime.tv_sec = (int)be32_to_cpu(from->di_mtime.t_sec);
+        inode->i_mtime.tv_nsec = (int)be32_to_cpu(from->di_mtime.t_nsec);
+        inode->i_ctime.tv_sec = (int)be32_to_cpu(from->di_ctime.t_sec);
+        inode->i_ctime.tv_nsec = (int)be32_to_cpu(from->di_ctime.t_nsec);
+        inode->i_generation = be32_to_cpu(from->di_gen);
+        inode->i_mode = be16_to_cpu(from->di_mode);
+
         to->di_size = be64_to_cpu(from->di_size);
         to->di_nblocks = be64_to_cpu(from->di_nblocks);
         to->di_extsize = be32_to_cpu(from->di_extsize);
@@ -227,42 +249,96 @@ xfs_dinode_from_disk(
         to->di_dmevmask = be32_to_cpu(from->di_dmevmask);
         to->di_dmstate  = be16_to_cpu(from->di_dmstate);
         to->di_flags    = be16_to_cpu(from->di_flags);
-        to->di_gen      = be32_to_cpu(from->di_gen);
 
         if (to->di_version == 3) {
-                to->di_changecount = be64_to_cpu(from->di_changecount);
+                inode->i_version = be64_to_cpu(from->di_changecount);
                 to->di_crtime.t_sec = be32_to_cpu(from->di_crtime.t_sec);
                 to->di_crtime.t_nsec = be32_to_cpu(from->di_crtime.t_nsec);
                 to->di_flags2 = be64_to_cpu(from->di_flags2);
-                to->di_ino = be64_to_cpu(from->di_ino);
-                to->di_lsn = be64_to_cpu(from->di_lsn);
-                memcpy(to->di_pad2, from->di_pad2, sizeof(to->di_pad2));
-                uuid_copy(&to->di_uuid, &from->di_uuid);
         }
 }
 
 void
-xfs_dinode_to_disk(
-        xfs_dinode_t            *to,
-        xfs_icdinode_t          *from)
+xfs_inode_to_disk(
+        struct xfs_inode        *ip,
+        struct xfs_dinode       *to,
+        xfs_lsn_t               lsn)
+{
+        struct xfs_icdinode     *from = &ip->i_d;
+        struct inode            *inode = VFS_I(ip);
+
+        to->di_magic = cpu_to_be16(XFS_DINODE_MAGIC);
+        to->di_onlink = 0;
+
+        to->di_version = from->di_version;
+        to->di_format = from->di_format;
+        to->di_uid = cpu_to_be32(from->di_uid);
+        to->di_gid = cpu_to_be32(from->di_gid);
+        to->di_projid_lo = cpu_to_be16(from->di_projid_lo);
+        to->di_projid_hi = cpu_to_be16(from->di_projid_hi);
+
+        memset(to->di_pad, 0, sizeof(to->di_pad));
+        to->di_atime.t_sec = cpu_to_be32(inode->i_atime.tv_sec);
+        to->di_atime.t_nsec = cpu_to_be32(inode->i_atime.tv_nsec);
+        to->di_mtime.t_sec = cpu_to_be32(inode->i_mtime.tv_sec);
+        to->di_mtime.t_nsec = cpu_to_be32(inode->i_mtime.tv_nsec);
+        to->di_ctime.t_sec = cpu_to_be32(inode->i_ctime.tv_sec);
+        to->di_ctime.t_nsec = cpu_to_be32(inode->i_ctime.tv_nsec);
+        to->di_nlink = cpu_to_be32(inode->i_nlink);
+        to->di_gen = cpu_to_be32(inode->i_generation);
+        to->di_mode = cpu_to_be16(inode->i_mode);
+
+        to->di_size = cpu_to_be64(from->di_size);
+        to->di_nblocks = cpu_to_be64(from->di_nblocks);
+        to->di_extsize = cpu_to_be32(from->di_extsize);
+        to->di_nextents = cpu_to_be32(from->di_nextents);
+        to->di_anextents = cpu_to_be16(from->di_anextents);
+        to->di_forkoff = from->di_forkoff;
+        to->di_aformat = from->di_aformat;
+        to->di_dmevmask = cpu_to_be32(from->di_dmevmask);
+        to->di_dmstate = cpu_to_be16(from->di_dmstate);
+        to->di_flags = cpu_to_be16(from->di_flags);
+
+        if (from->di_version == 3) {
+                to->di_changecount = cpu_to_be64(inode->i_version);
+                to->di_crtime.t_sec = cpu_to_be32(from->di_crtime.t_sec);
+                to->di_crtime.t_nsec = cpu_to_be32(from->di_crtime.t_nsec);
+                to->di_flags2 = cpu_to_be64(from->di_flags2);
+
+                to->di_ino = cpu_to_be64(ip->i_ino);
+                to->di_lsn = cpu_to_be64(lsn);
+                memset(to->di_pad2, 0, sizeof(to->di_pad2));
+                uuid_copy(&to->di_uuid, &ip->i_mount->m_sb.sb_meta_uuid);
+                to->di_flushiter = 0;
+        } else {
+                to->di_flushiter = cpu_to_be16(from->di_flushiter);
+        }
+}
+
+void
+xfs_log_dinode_to_disk(
+        struct xfs_log_dinode   *from,
+        struct xfs_dinode       *to)
 {
         to->di_magic = cpu_to_be16(from->di_magic);
         to->di_mode = cpu_to_be16(from->di_mode);
-        to->di_version = from ->di_version;
+        to->di_version = from->di_version;
         to->di_format = from->di_format;
-        to->di_onlink = cpu_to_be16(from->di_onlink);
+        to->di_onlink = 0;
         to->di_uid = cpu_to_be32(from->di_uid);
         to->di_gid = cpu_to_be32(from->di_gid);
         to->di_nlink = cpu_to_be32(from->di_nlink);
         to->di_projid_lo = cpu_to_be16(from->di_projid_lo);
         to->di_projid_hi = cpu_to_be16(from->di_projid_hi);
         memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad));
+
         to->di_atime.t_sec = cpu_to_be32(from->di_atime.t_sec);
         to->di_atime.t_nsec = cpu_to_be32(from->di_atime.t_nsec);
         to->di_mtime.t_sec = cpu_to_be32(from->di_mtime.t_sec);
         to->di_mtime.t_nsec = cpu_to_be32(from->di_mtime.t_nsec);
         to->di_ctime.t_sec = cpu_to_be32(from->di_ctime.t_sec);
         to->di_ctime.t_nsec = cpu_to_be32(from->di_ctime.t_nsec);
+
         to->di_size = cpu_to_be64(from->di_size);
         to->di_nblocks = cpu_to_be64(from->di_nblocks);
         to->di_extsize = cpu_to_be32(from->di_extsize);
@@ -367,13 +443,10 @@ xfs_iread(
             !(mp->m_flags & XFS_MOUNT_IKEEP)) {
                 /* initialise the on-disk inode core */
                 memset(&ip->i_d, 0, sizeof(ip->i_d));
-                ip->i_d.di_magic = XFS_DINODE_MAGIC;
-                ip->i_d.di_gen = prandom_u32();
-                if (xfs_sb_version_hascrc(&mp->m_sb)) {
+                VFS_I(ip)->i_generation = prandom_u32();
+                if (xfs_sb_version_hascrc(&mp->m_sb))
                         ip->i_d.di_version = 3;
-                        ip->i_d.di_ino = ip->i_ino;
-                        uuid_copy(&ip->i_d.di_uuid, &mp->m_sb.sb_meta_uuid);
-                } else
+                else
                         ip->i_d.di_version = 2;
                 return 0;
         }
@@ -403,7 +476,7 @@ xfs_iread(
          * Otherwise, just get the truly permanent information.
          */
         if (dip->di_mode) {
-                xfs_dinode_from_disk(&ip->i_d, dip);
+                xfs_inode_from_disk(ip, dip);
                 error = xfs_iformat_fork(ip, dip);
                 if (error)  {
 #ifdef DEBUG
@@ -417,16 +490,10 @@ xfs_iread(
                  * Partial initialisation of the in-core inode. Just the bits
                  * that xfs_ialloc won't overwrite or relies on being correct.
                  */
-                ip->i_d.di_magic = be16_to_cpu(dip->di_magic);
                 ip->i_d.di_version = dip->di_version;
-                ip->i_d.di_gen = be32_to_cpu(dip->di_gen);
+                VFS_I(ip)->i_generation = be32_to_cpu(dip->di_gen);
                 ip->i_d.di_flushiter = be16_to_cpu(dip->di_flushiter);
 
-                if (dip->di_version == 3) {
-                        ip->i_d.di_ino = be64_to_cpu(dip->di_ino);
-                        uuid_copy(&ip->i_d.di_uuid, &dip->di_uuid);
-                }
-
                 /*
                  * Make sure to pull in the mode here as well in
                  * case the inode is released without being used.
@@ -434,25 +501,10 @@ xfs_iread(
                  * the inode is already free and not try to mess
                  * with the uninitialized part of it.
                  */
-                ip->i_d.di_mode = 0;
-        }
-
-        /*
-         * Automatically convert version 1 inode formats in memory to version 2
-         * inode format. If the inode is modified, it will get logged and
-         * rewritten as a version 2 inode. We can do this because we set the
-         * superblock feature bit for v2 inodes unconditionally during mount
-         * and it means the reast of the code can assume the inode version is 2
-         * or higher.
-         */
-        if (ip->i_d.di_version == 1) {
-                ip->i_d.di_version = 2;
-                memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
-                ip->i_d.di_nlink = ip->i_d.di_onlink;
-                ip->i_d.di_onlink = 0;
-                xfs_set_projid(ip, 0);
+                VFS_I(ip)->i_mode = 0;
         }
 
+        ASSERT(ip->i_d.di_version >= 2);
         ip->i_delayed_blks = 0;
 
         /*
diff --git a/fs/xfs/libxfs/xfs_inode_buf.h b/fs/xfs/libxfs/xfs_inode_buf.h
index 9308c47f2a52..7c4dd321b215 100644
--- a/fs/xfs/libxfs/xfs_inode_buf.h
+++ b/fs/xfs/libxfs/xfs_inode_buf.h
@@ -20,7 +20,36 @@
 
 struct xfs_inode;
 struct xfs_dinode;
-struct xfs_icdinode;
+
+/*
+ * In memory representation of the XFS inode. This is held in the in-core struct
+ * xfs_inode and represents the current on disk values but the structure is not
+ * in on-disk format.  That is, this structure is always translated to on-disk
+ * format specific structures at the appropriate time.
+ */
+struct xfs_icdinode {
+        __int8_t        di_version;     /* inode version */
+        __int8_t        di_format;      /* format of di_c data */
+        __uint16_t      di_flushiter;   /* incremented on flush */
+        __uint32_t      di_uid;         /* owner's user id */
+        __uint32_t      di_gid;         /* owner's group id */
+        __uint16_t      di_projid_lo;   /* lower part of owner's project id */
+        __uint16_t      di_projid_hi;   /* higher part of owner's project id */
+        xfs_fsize_t     di_size;        /* number of bytes in file */
+        xfs_rfsblock_t  di_nblocks;     /* # of direct & btree blocks used */
+        xfs_extlen_t    di_extsize;     /* basic/minimum extent size for file */
+        xfs_extnum_t    di_nextents;    /* number of extents in data fork */
+        xfs_aextnum_t   di_anextents;   /* number of extents in attribute fork*/
+        __uint8_t       di_forkoff;     /* attr fork offs, <<3 for 64b align */
+        __int8_t        di_aformat;     /* format of attr fork's data */
+        __uint32_t      di_dmevmask;    /* DMIG event mask */
+        __uint16_t      di_dmstate;     /* DMIG state info */
+        __uint16_t      di_flags;       /* random flags, XFS_DIFLAG_... */
+
+        __uint64_t      di_flags2;      /* more random flags */
+
+        xfs_ictimestamp_t di_crtime;    /* time created */
+};
 
 /*
  * Inode location information.  Stored in the inode and passed to
@@ -38,8 +67,11 @@ int	xfs_imap_to_bp(struct xfs_mount *, struct xfs_trans *,
 int     xfs_iread(struct xfs_mount *, struct xfs_trans *,
                   struct xfs_inode *, uint);
 void    xfs_dinode_calc_crc(struct xfs_mount *, struct xfs_dinode *);
-void    xfs_dinode_to_disk(struct xfs_dinode *to, struct xfs_icdinode *from);
-void    xfs_dinode_from_disk(struct xfs_icdinode *to, struct xfs_dinode *from);
+void    xfs_inode_to_disk(struct xfs_inode *ip, struct xfs_dinode *to,
+                          xfs_lsn_t lsn);
+void    xfs_inode_from_disk(struct xfs_inode *ip, struct xfs_dinode *from);
+void    xfs_log_dinode_to_disk(struct xfs_log_dinode *from,
+                               struct xfs_dinode *to);
 
 #if defined(DEBUG)
 void    xfs_inobp_check(struct xfs_mount *, struct xfs_buf *);
diff --git a/fs/xfs/libxfs/xfs_inode_fork.c b/fs/xfs/libxfs/xfs_inode_fork.c
index 0defbd02f62d..11faf7df14c8 100644
--- a/fs/xfs/libxfs/xfs_inode_fork.c
+++ b/fs/xfs/libxfs/xfs_inode_fork.c
@@ -31,6 +31,7 @@
 #include "xfs_error.h"
 #include "xfs_trace.h"
 #include "xfs_attr_sf.h"
+#include "xfs_da_format.h"
 
 kmem_zone_t *xfs_ifork_zone;
 
@@ -120,7 +121,7 @@ xfs_iformat_fork(
                 return -EFSCORRUPTED;
         }
 
-        switch (ip->i_d.di_mode & S_IFMT) {
+        switch (VFS_I(ip)->i_mode & S_IFMT) {
         case S_IFIFO:
         case S_IFCHR:
         case S_IFBLK:
diff --git a/fs/xfs/libxfs/xfs_log_format.h b/fs/xfs/libxfs/xfs_log_format.h
index 265314690415..d54a8018b079 100644
--- a/fs/xfs/libxfs/xfs_log_format.h
+++ b/fs/xfs/libxfs/xfs_log_format.h
@@ -290,6 +290,7 @@ typedef struct xfs_inode_log_format_64 {
         __int32_t               ilf_boffset;    /* off of inode in buffer */
 } xfs_inode_log_format_64_t;
 
+
 /*
  * Flags for xfs_trans_log_inode flags field.
  */
@@ -360,15 +361,15 @@ typedef struct xfs_ictimestamp {
 } xfs_ictimestamp_t;
 
 /*
- * NOTE:  This structure must be kept identical to struct xfs_dinode
- *        except for the endianness annotations.
+ * Define the format of the inode core that is logged. This structure must be
+ * kept identical to struct xfs_dinode except for the endianness annotations.
  */
-typedef struct xfs_icdinode {
+struct xfs_log_dinode {
         __uint16_t      di_magic;       /* inode magic # = XFS_DINODE_MAGIC */
         __uint16_t      di_mode;        /* mode and type of file */
         __int8_t        di_version;     /* inode version */
         __int8_t        di_format;      /* format of di_c data */
-        __uint16_t      di_onlink;      /* old number of links to file */
+        __uint8_t       di_pad3[2];     /* unused in v2/3 inodes */
         __uint32_t      di_uid;         /* owner's user id */
         __uint32_t      di_gid;         /* owner's group id */
         __uint32_t      di_nlink;       /* number of links to file */
@@ -407,13 +408,13 @@ typedef struct xfs_icdinode {
         uuid_t          di_uuid;        /* UUID of the filesystem */
 
         /* structure must be padded to 64 bit alignment */
-} xfs_icdinode_t;
+};
 
-static inline uint xfs_icdinode_size(int version)
+static inline uint xfs_log_dinode_size(int version)
 {
         if (version == 3)
-                return sizeof(struct xfs_icdinode);
-        return offsetof(struct xfs_icdinode, di_next_unlinked);
+                return sizeof(struct xfs_log_dinode);
+        return offsetof(struct xfs_log_dinode, di_next_unlinked);
 }
 
 /*
@@ -495,6 +496,8 @@ enum xfs_blft {
         XFS_BLFT_ATTR_LEAF_BUF,
         XFS_BLFT_ATTR_RMT_BUF,
         XFS_BLFT_SB_BUF,
+        XFS_BLFT_RTBITMAP_BUF,
+        XFS_BLFT_RTSUMMARY_BUF,
         XFS_BLFT_MAX_BUF = (1 << XFS_BLFT_BITS),
 };
 
diff --git a/fs/xfs/libxfs/xfs_quota_defs.h b/fs/xfs/libxfs/xfs_quota_defs.h
index f51078f1e92a..8eed51275bb3 100644
--- a/fs/xfs/libxfs/xfs_quota_defs.h
+++ b/fs/xfs/libxfs/xfs_quota_defs.h
@@ -37,7 +37,7 @@ typedef __uint16_t	xfs_qwarncnt_t;
 #define XFS_DQ_PROJ             0x0002          /* project quota */
 #define XFS_DQ_GROUP            0x0004          /* a group quota */
 #define XFS_DQ_DIRTY            0x0008          /* dquot is dirty */
-#define XFS_DQ_FREEING          0x0010          /* dquot is beeing torn down */
+#define XFS_DQ_FREEING          0x0010          /* dquot is being torn down */
 
 #define XFS_DQ_ALLTYPES         (XFS_DQ_USER|XFS_DQ_PROJ|XFS_DQ_GROUP)
 
@@ -116,6 +116,7 @@ typedef __uint16_t	xfs_qwarncnt_t;
 #define XFS_QMOPT_DQREPAIR      0x0001000 /* repair dquot if damaged */
 #define XFS_QMOPT_GQUOTA        0x0002000 /* group dquot requested */
 #define XFS_QMOPT_ENOSPC        0x0004000 /* enospc instead of edquot (prj) */
+#define XFS_QMOPT_DQNEXT        0x0008000 /* return next dquot >= this ID */
 
 /*
  * flags to xfs_trans_mod_dquot to indicate which field needs to be
diff --git a/fs/xfs/libxfs/xfs_rtbitmap.c b/fs/xfs/libxfs/xfs_rtbitmap.c
index 9b59ffa1fc19..951c044e24e4 100644
--- a/fs/xfs/libxfs/xfs_rtbitmap.c
+++ b/fs/xfs/libxfs/xfs_rtbitmap.c
@@ -42,6 +42,31 @@
  */
 
 /*
+ * Real time buffers need verifiers to avoid runtime warnings during IO.
+ * We don't have anything to verify, however, so these are just dummy
+ * operations.
+ */
+static void
+xfs_rtbuf_verify_read(
+        struct xfs_buf  *bp)
+{
+        return;
+}
+
+static void
+xfs_rtbuf_verify_write(
+        struct xfs_buf  *bp)
+{
+        return;
+}
+
+const struct xfs_buf_ops xfs_rtbuf_ops = {
+        .name = "rtbuf",
+        .verify_read = xfs_rtbuf_verify_read,
+        .verify_write = xfs_rtbuf_verify_write,
+};
+
+/*
  * Get a buffer for the bitmap or summary file block specified.
  * The buffer is returned read and locked.
  */
@@ -68,9 +93,12 @@ xfs_rtbuf_get(
         ASSERT(map.br_startblock != NULLFSBLOCK);
         error = xfs_trans_read_buf(mp, tp, mp->m_ddev_targp,
                                    XFS_FSB_TO_DADDR(mp, map.br_startblock),
-                                   mp->m_bsize, 0, &bp, NULL);
+                                   mp->m_bsize, 0, &bp, &xfs_rtbuf_ops);
         if (error)
                 return error;
+
+        xfs_trans_buf_set_type(tp, bp, issum ? XFS_BLFT_RTSUMMARY_BUF
+                                             : XFS_BLFT_RTBITMAP_BUF);
         *bpp = bp;
         return 0;
 }
@@ -983,7 +1011,7 @@ xfs_rtfree_extent(
             mp->m_sb.sb_rextents) {
                 if (!(mp->m_rbmip->i_d.di_flags & XFS_DIFLAG_NEWRTBM))
                         mp->m_rbmip->i_d.di_flags |= XFS_DIFLAG_NEWRTBM;
-                *(__uint64_t *)&mp->m_rbmip->i_d.di_atime = 0;
+                *(__uint64_t *)&VFS_I(mp->m_rbmip)->i_atime = 0;
                 xfs_trans_log_inode(tp, mp->m_rbmip, XFS_ILOG_CORE);
         }
         return 0;
diff --git a/fs/xfs/libxfs/xfs_sb.h b/fs/xfs/libxfs/xfs_sb.h
index b25bb9a343f3..961e6475a309 100644
--- a/fs/xfs/libxfs/xfs_sb.h
+++ b/fs/xfs/libxfs/xfs_sb.h
@@ -27,7 +27,6 @@ extern struct xfs_perag *xfs_perag_get_tag(struct xfs_mount *, xfs_agnumber_t,
 extern void     xfs_perag_put(struct xfs_perag *pag);
 extern int      xfs_initialize_perag_data(struct xfs_mount *, xfs_agnumber_t);
 
-extern void     xfs_sb_calc_crc(struct xfs_buf *bp);
 extern void     xfs_log_sb(struct xfs_trans *tp);
 extern int      xfs_sync_sb(struct xfs_mount *mp, bool wait);
 extern void     xfs_sb_mount_common(struct xfs_mount *mp, struct xfs_sb *sbp);
diff --git a/fs/xfs/libxfs/xfs_shared.h b/fs/xfs/libxfs/xfs_shared.h
index 15c3ceb845b9..81ac870834da 100644
--- a/fs/xfs/libxfs/xfs_shared.h
+++ b/fs/xfs/libxfs/xfs_shared.h
@@ -53,6 +53,7 @@ extern const struct xfs_buf_ops xfs_dquot_buf_ra_ops;
 extern const struct xfs_buf_ops xfs_sb_buf_ops;
 extern const struct xfs_buf_ops xfs_sb_quiet_buf_ops;
 extern const struct xfs_buf_ops xfs_symlink_buf_ops;
+extern const struct xfs_buf_ops xfs_rtbuf_ops;
 
 /*
  * Transaction types.  Used to distinguish types of buffers. These never reach