1 files changed, 85 insertions, 369 deletions

diff --git a/fs/xfs/xfs_attr.c b/fs/xfs/xfs_attr.c
index 888683844d98..20fe3fe9d341 100644
--- a/fs/xfs/xfs_attr.c
+++ b/fs/xfs/xfs_attr.c
@@ -15,7 +15,6 @@
  * along with this program; if not, write the Free Software Foundation,
  * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
-
 #include "xfs.h"
 #include "xfs_fs.h"
 #include "xfs_types.h"
@@ -35,6 +34,7 @@
 #include "xfs_bmap.h"
 #include "xfs_attr.h"
 #include "xfs_attr_leaf.h"
+#include "xfs_attr_remote.h"
 #include "xfs_error.h"
 #include "xfs_quota.h"
 #include "xfs_trans_space.h"
@@ -74,13 +74,6 @@ STATIC int xfs_attr_node_list(xfs_attr_list_context_t *context);
 STATIC int xfs_attr_fillstate(xfs_da_state_t *state);
 STATIC int xfs_attr_refillstate(xfs_da_state_t *state);
 
-/*
- * Routines to manipulate out-of-line attribute values.
- */
-STATIC int xfs_attr_rmtval_set(xfs_da_args_t *args);
-STATIC int xfs_attr_rmtval_remove(xfs_da_args_t *args);
-
-#define ATTR_RMTVALUE_MAPSIZE   1       /* # of map entries at once */
 
 STATIC int
 xfs_attr_name_to_xname(
@@ -820,7 +813,7 @@ xfs_attr_inactive(xfs_inode_t *dp)
                 error = 0;
                 goto out;
         }
-        error = xfs_attr_root_inactive(&trans, dp);
+        error = xfs_attr3_root_inactive(&trans, dp);
         if (error)
                 goto out;
 
@@ -906,7 +899,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
          */
         dp = args->dp;
         args->blkno = 0;
-        error = xfs_attr_leaf_read(args->trans, args->dp, args->blkno, -1, &bp);
+        error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, -1, &bp);
         if (error)
                 return error;
 
@@ -914,14 +907,14 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
          * Look up the given attribute in the leaf block.  Figure out if
          * the given flags produce an error or call for an atomic rename.
          */
-        retval = xfs_attr_leaf_lookup_int(bp, args);
+        retval = xfs_attr3_leaf_lookup_int(bp, args);
         if ((args->flags & ATTR_REPLACE) && (retval == ENOATTR)) {
                 xfs_trans_brelse(args->trans, bp);
-                return(retval);
+                return retval;
         } else if (retval == EEXIST) {
                 if (args->flags & ATTR_CREATE) {        /* pure create op */
                         xfs_trans_brelse(args->trans, bp);
-                        return(retval);
+                        return retval;
                 }
 
                 trace_xfs_attr_leaf_replace(args);
@@ -937,7 +930,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
          * Add the attribute to the leaf block, transitioning to a Btree
          * if required.
          */
-        retval = xfs_attr_leaf_add(bp, args);
+        retval = xfs_attr3_leaf_add(bp, args);
         if (retval == ENOSPC) {
                 /*
                  * Promote the attribute list to the Btree format, then
@@ -945,7 +938,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
                  * can manage its own transactions.
                  */
                 xfs_bmap_init(args->flist, args->firstblock);
-                error = xfs_attr_leaf_to_node(args);
+                error = xfs_attr3_leaf_to_node(args);
                 if (!error) {
                         error = xfs_bmap_finish(&args->trans, args->flist,
                                                 &committed);
@@ -1010,7 +1003,7 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
                  * In a separate transaction, set the incomplete flag on the
                  * "old" attr and clear the incomplete flag on the "new" attr.
                  */
-                error = xfs_attr_leaf_flipflags(args);
+                error = xfs_attr3_leaf_flipflags(args);
                 if (error)
                         return(error);
 
@@ -1032,19 +1025,19 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
                  * Read in the block containing the "old" attr, then
                  * remove the "old" attr from that block (neat, huh!)
                  */
-                error = xfs_attr_leaf_read(args->trans, args->dp, args->blkno,
+                error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno,
                                            -1, &bp);
                 if (error)
                         return error;
 
-                xfs_attr_leaf_remove(bp, args);
+                xfs_attr3_leaf_remove(bp, 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);
-                        error = xfs_attr_leaf_to_shortform(bp, args, forkoff);
+                        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,
@@ -1076,9 +1069,9 @@ xfs_attr_leaf_addname(xfs_da_args_t *args)
                 /*
                  * Added a "remote" value, just clear the incomplete flag.
                  */
-                error = xfs_attr_leaf_clearflag(args);
+                error = xfs_attr3_leaf_clearflag(args);
         }
-        return(error);
+        return error;
 }
 
 /*
@@ -1101,24 +1094,24 @@ xfs_attr_leaf_removename(xfs_da_args_t *args)
          */
         dp = args->dp;
         args->blkno = 0;
-        error = xfs_attr_leaf_read(args->trans, args->dp, args->blkno, -1, &bp);
+        error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, -1, &bp);
         if (error)
                 return error;
 
-        error = xfs_attr_leaf_lookup_int(bp, args);
+        error = xfs_attr3_leaf_lookup_int(bp, args);
         if (error == ENOATTR) {
                 xfs_trans_brelse(args->trans, bp);
-                return(error);
+                return error;
         }
 
-        xfs_attr_leaf_remove(bp, args);
+        xfs_attr3_leaf_remove(bp, 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);
-                error = xfs_attr_leaf_to_shortform(bp, args, forkoff);
+                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,
@@ -1128,7 +1121,7 @@ xfs_attr_leaf_removename(xfs_da_args_t *args)
                         ASSERT(committed);
                         args->trans = NULL;
                         xfs_bmap_cancel(args->flist);
-                        return(error);
+                        return error;
                 }
 
                 /*
@@ -1138,7 +1131,7 @@ xfs_attr_leaf_removename(xfs_da_args_t *args)
                 if (committed)
                         xfs_trans_ijoin(args->trans, dp, 0);
         }
-        return(0);
+        return 0;
 }
 
 /*
@@ -1156,21 +1149,21 @@ xfs_attr_leaf_get(xfs_da_args_t *args)
         trace_xfs_attr_leaf_get(args);
 
         args->blkno = 0;
-        error = xfs_attr_leaf_read(args->trans, args->dp, args->blkno, -1, &bp);
+        error = xfs_attr3_leaf_read(args->trans, args->dp, args->blkno, -1, &bp);
         if (error)
                 return error;
 
-        error = xfs_attr_leaf_lookup_int(bp, args);
+        error = xfs_attr3_leaf_lookup_int(bp, args);
         if (error != EEXIST)  {
                 xfs_trans_brelse(args->trans, bp);
-                return(error);
+                return error;
         }
-        error = xfs_attr_leaf_getvalue(bp, args);
+        error = xfs_attr3_leaf_getvalue(bp, args);
         xfs_trans_brelse(args->trans, bp);
         if (!error && (args->rmtblkno > 0) && !(args->flags & ATTR_KERNOVAL)) {
                 error = xfs_attr_rmtval_get(args);
         }
-        return(error);
+        return error;
 }
 
 /*
@@ -1185,11 +1178,11 @@ xfs_attr_leaf_list(xfs_attr_list_context_t *context)
         trace_xfs_attr_leaf_list(context);
 
         context->cursor->blkno = 0;
-        error = xfs_attr_leaf_read(NULL, context->dp, 0, -1, &bp);
+        error = xfs_attr3_leaf_read(NULL, context->dp, 0, -1, &bp);
         if (error)
                 return XFS_ERROR(error);
 
-        error = xfs_attr_leaf_list_int(bp, context);
+        error = xfs_attr3_leaf_list_int(bp, context);
         xfs_trans_brelse(NULL, bp);
         return XFS_ERROR(error);
 }
@@ -1236,7 +1229,7 @@ restart:
          * Search to see if name already exists, and get back a pointer
          * to where it should go.
          */
-        error = xfs_da_node_lookup_int(state, &retval);
+        error = xfs_da3_node_lookup_int(state, &retval);
         if (error)
                 goto out;
         blk = &state->path.blk[ state->path.active-1 ];
@@ -1258,7 +1251,7 @@ restart:
                 args->rmtblkcnt = 0;
         }
 
-        retval = xfs_attr_leaf_add(blk->bp, state->args);
+        retval = xfs_attr3_leaf_add(blk->bp, state->args);
         if (retval == ENOSPC) {
                 if (state->path.active == 1) {
                         /*
@@ -1268,7 +1261,7 @@ restart:
                          */
                         xfs_da_state_free(state);
                         xfs_bmap_init(args->flist, args->firstblock);
-                        error = xfs_attr_leaf_to_node(args);
+                        error = xfs_attr3_leaf_to_node(args);
                         if (!error) {
                                 error = xfs_bmap_finish(&args->trans,
                                                         args->flist,
@@ -1307,7 +1300,7 @@ restart:
                  * in the index2/blkno2/rmtblkno2/rmtblkcnt2 fields.
                  */
                 xfs_bmap_init(args->flist, args->firstblock);
-                error = xfs_da_split(state);
+                error = xfs_da3_split(state);
                 if (!error) {
                         error = xfs_bmap_finish(&args->trans, args->flist,
                                                 &committed);
@@ -1329,7 +1322,7 @@ restart:
                 /*
                  * Addition succeeded, update Btree hashvals.
                  */
-                xfs_da_fixhashpath(state, &state->path);
+                xfs_da3_fixhashpath(state, &state->path);
         }
 
         /*
@@ -1370,7 +1363,7 @@ restart:
                  * In a separate transaction, set the incomplete flag on the
                  * "old" attr and clear the incomplete flag on the "new" attr.
                  */
-                error = xfs_attr_leaf_flipflags(args);
+                error = xfs_attr3_leaf_flipflags(args);
                 if (error)
                         goto out;
 
@@ -1400,7 +1393,7 @@ restart:
                 state->blocksize = state->mp->m_sb.sb_blocksize;
                 state->node_ents = state->mp->m_attr_node_ents;
                 state->inleaf = 0;
-                error = xfs_da_node_lookup_int(state, &retval);
+                error = xfs_da3_node_lookup_int(state, &retval);
                 if (error)
                         goto out;
 
@@ -1409,15 +1402,15 @@ restart:
                  */
                 blk = &state->path.blk[ state->path.active-1 ];
                 ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
-                error = xfs_attr_leaf_remove(blk->bp, args);
-                xfs_da_fixhashpath(state, &state->path);
+                error = xfs_attr3_leaf_remove(blk->bp, args);
+                xfs_da3_fixhashpath(state, &state->path);
 
                 /*
                  * Check to see if the tree needs to be collapsed.
                  */
                 if (retval && (state->path.active > 1)) {
                         xfs_bmap_init(args->flist, args->firstblock);
-                        error = xfs_da_join(state);
+                        error = xfs_da3_join(state);
                         if (!error) {
                                 error = xfs_bmap_finish(&args->trans,
                                                         args->flist,
@@ -1450,7 +1443,7 @@ restart:
                 /*
                  * Added a "remote" value, just clear the incomplete flag.
                  */
-                error = xfs_attr_leaf_clearflag(args);
+                error = xfs_attr3_leaf_clearflag(args);
                 if (error)
                         goto out;
         }
@@ -1495,7 +1488,7 @@ xfs_attr_node_removename(xfs_da_args_t *args)
         /*
          * Search to see if name exists, and get back a pointer to it.
          */
-        error = xfs_da_node_lookup_int(state, &retval);
+        error = xfs_da3_node_lookup_int(state, &retval);
         if (error || (retval != EEXIST)) {
                 if (error == 0)
                         error = retval;
@@ -1524,7 +1517,7 @@ xfs_attr_node_removename(xfs_da_args_t *args)
                  * Mark the attribute as INCOMPLETE, then bunmapi() the
                  * remote value.
                  */
-                error = xfs_attr_leaf_setflag(args);
+                error = xfs_attr3_leaf_setflag(args);
                 if (error)
                         goto out;
                 error = xfs_attr_rmtval_remove(args);
@@ -1545,15 +1538,15 @@ xfs_attr_node_removename(xfs_da_args_t *args)
          */
         blk = &state->path.blk[ state->path.active-1 ];
         ASSERT(blk->magic == XFS_ATTR_LEAF_MAGIC);
-        retval = xfs_attr_leaf_remove(blk->bp, args);
-        xfs_da_fixhashpath(state, &state->path);
+        retval = xfs_attr3_leaf_remove(blk->bp, args);
+        xfs_da3_fixhashpath(state, &state->path);
 
         /*
          * Check to see if the tree needs to be collapsed.
          */
         if (retval && (state->path.active > 1)) {
                 xfs_bmap_init(args->flist, args->firstblock);
-                error = xfs_da_join(state);
+                error = xfs_da3_join(state);
                 if (!error) {
                         error = xfs_bmap_finish(&args->trans, args->flist,
                                                 &committed);
@@ -1591,13 +1584,13 @@ xfs_attr_node_removename(xfs_da_args_t *args)
                 ASSERT(state->path.blk[0].bp);
                 state->path.blk[0].bp = NULL;
 
-                error = xfs_attr_leaf_read(args->trans, args->dp, 0, -1, &bp);
+                error = xfs_attr3_leaf_read(args->trans, args->dp, 0, -1, &bp);
                 if (error)
                         goto out;
 
                 if ((forkoff = xfs_attr_shortform_allfit(bp, dp))) {
                         xfs_bmap_init(args->flist, args->firstblock);
-                        error = xfs_attr_leaf_to_shortform(bp, args, forkoff);
+                        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,
@@ -1699,7 +1692,7 @@ xfs_attr_refillstate(xfs_da_state_t *state)
         ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
         for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
                 if (blk->disk_blkno) {
-                        error = xfs_da_node_read(state->args->trans,
+                        error = xfs_da3_node_read(state->args->trans,
                                                 state->args->dp,
                                                 blk->blkno, blk->disk_blkno,
                                                 &blk->bp, XFS_ATTR_FORK);
@@ -1718,7 +1711,7 @@ xfs_attr_refillstate(xfs_da_state_t *state)
         ASSERT((path->active >= 0) && (path->active < XFS_DA_NODE_MAXDEPTH));
         for (blk = path->blk, level = 0; level < path->active; blk++, level++) {
                 if (blk->disk_blkno) {
-                        error = xfs_da_node_read(state->args->trans,
+                        error = xfs_da3_node_read(state->args->trans,
                                                 state->args->dp,
                                                 blk->blkno, blk->disk_blkno,
                                                 &blk->bp, XFS_ATTR_FORK);
@@ -1758,7 +1751,7 @@ xfs_attr_node_get(xfs_da_args_t *args)
         /*
          * Search to see if name exists, and get back a pointer to it.
          */
-        error = xfs_da_node_lookup_int(state, &retval);
+        error = xfs_da3_node_lookup_int(state, &retval);
         if (error) {
                 retval = error;
         } else if (retval == EEXIST) {
@@ -1769,7 +1762,7 @@ xfs_attr_node_get(xfs_da_args_t *args)
                 /*
                  * Get the value, local or "remote"
                  */
-                retval = xfs_attr_leaf_getvalue(blk->bp, args);
+                retval = xfs_attr3_leaf_getvalue(blk->bp, args);
                 if (!retval && (args->rmtblkno > 0)
                     && !(args->flags & ATTR_KERNOVAL)) {
                         retval = xfs_attr_rmtval_get(args);
@@ -1794,7 +1787,9 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
         attrlist_cursor_kern_t *cursor;
         xfs_attr_leafblock_t *leaf;
         xfs_da_intnode_t *node;
-        xfs_da_node_entry_t *btree;
+        struct xfs_attr3_icleaf_hdr leafhdr;
+        struct xfs_da3_icnode_hdr nodehdr;
+        struct xfs_da_node_entry *btree;
         int error, i;
         struct xfs_buf *bp;
 
@@ -1810,27 +1805,33 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
          */
         bp = NULL;
         if (cursor->blkno > 0) {
-                error = xfs_da_node_read(NULL, context->dp, cursor->blkno, -1,
+                error = xfs_da3_node_read(NULL, context->dp, cursor->blkno, -1,
                                               &bp, XFS_ATTR_FORK);
                 if ((error != 0) && (error != EFSCORRUPTED))
                         return(error);
                 if (bp) {
+                        struct xfs_attr_leaf_entry *entries;
+
                         node = bp->b_addr;
                         switch (be16_to_cpu(node->hdr.info.magic)) {
                         case XFS_DA_NODE_MAGIC:
+                        case XFS_DA3_NODE_MAGIC:
                                 trace_xfs_attr_list_wrong_blk(context);
                                 xfs_trans_brelse(NULL, bp);
                                 bp = NULL;
                                 break;
                         case XFS_ATTR_LEAF_MAGIC:
+                        case XFS_ATTR3_LEAF_MAGIC:
                                 leaf = bp->b_addr;
-                                if (cursor->hashval > be32_to_cpu(leaf->entries[
-                                    be16_to_cpu(leaf->hdr.count)-1].hashval)) {
+                                xfs_attr3_leaf_hdr_from_disk(&leafhdr, leaf);
+                                entries = xfs_attr3_leaf_entryp(leaf);
+                                if (cursor->hashval > be32_to_cpu(
+                                                entries[leafhdr.count - 1].hashval)) {
                                         trace_xfs_attr_list_wrong_blk(context);
                                         xfs_trans_brelse(NULL, bp);
                                         bp = NULL;
-                                } else if (cursor->hashval <=
-                                             be32_to_cpu(leaf->entries[0].hashval)) {
+                                } else if (cursor->hashval <= be32_to_cpu(
+                                                entries[0].hashval)) {
                                         trace_xfs_attr_list_wrong_blk(context);
                                         xfs_trans_brelse(NULL, bp);
                                         bp = NULL;
@@ -1852,27 +1853,31 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
         if (bp == NULL) {
                 cursor->blkno = 0;
                 for (;;) {
-                        error = xfs_da_node_read(NULL, context->dp,
+                        __uint16_t magic;
+
+                        error = xfs_da3_node_read(NULL, context->dp,
                                                       cursor->blkno, -1, &bp,
                                                       XFS_ATTR_FORK);
                         if (error)
                                 return(error);
                         node = bp->b_addr;
-                        if (node->hdr.info.magic ==
-                            cpu_to_be16(XFS_ATTR_LEAF_MAGIC))
+                        magic = be16_to_cpu(node->hdr.info.magic);
+                        if (magic == XFS_ATTR_LEAF_MAGIC ||
+                            magic == XFS_ATTR3_LEAF_MAGIC)
                                 break;
-                        if (unlikely(node->hdr.info.magic !=
-                                     cpu_to_be16(XFS_DA_NODE_MAGIC))) {
+                        if (magic != XFS_DA_NODE_MAGIC &&
+                            magic != XFS_DA3_NODE_MAGIC) {
                                 XFS_CORRUPTION_ERROR("xfs_attr_node_list(3)",
                                                      XFS_ERRLEVEL_LOW,
                                                      context->dp->i_mount,
                                                      node);
                                 xfs_trans_brelse(NULL, bp);
-                                return(XFS_ERROR(EFSCORRUPTED));
+                                return XFS_ERROR(EFSCORRUPTED);
                         }
-                        btree = node->btree;
-                        for (i = 0; i < be16_to_cpu(node->hdr.count);
-                                                                btree++, i++) {
+
+                        xfs_da3_node_hdr_from_disk(&nodehdr, node);
+                        btree = xfs_da3_node_tree_p(node);
+                        for (i = 0; i < nodehdr.count; btree++, i++) {
                                 if (cursor->hashval
                                                 <= be32_to_cpu(btree->hashval)) {
                                         cursor->blkno = be32_to_cpu(btree->before);
@@ -1881,9 +1886,9 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
                                         break;
                                 }
                         }
-                        if (i == be16_to_cpu(node->hdr.count)) {
+                        if (i == nodehdr.count) {
                                 xfs_trans_brelse(NULL, bp);
-                                return(0);
+                                return 0;
                         }
                         xfs_trans_brelse(NULL, bp);
                 }
@@ -1897,310 +1902,21 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
          */
         for (;;) {
                 leaf = bp->b_addr;
-                error = xfs_attr_leaf_list_int(bp, context);
+                error = xfs_attr3_leaf_list_int(bp, context);
                 if (error) {
                         xfs_trans_brelse(NULL, bp);
                         return error;
                 }
-                if (context->seen_enough || leaf->hdr.info.forw == 0)
+                xfs_attr3_leaf_hdr_from_disk(&leafhdr, leaf);
+                if (context->seen_enough || leafhdr.forw == 0)
                         break;
-                cursor->blkno = be32_to_cpu(leaf->hdr.info.forw);
+                cursor->blkno = leafhdr.forw;
                 xfs_trans_brelse(NULL, bp);
-                error = xfs_attr_leaf_read(NULL, context->dp, cursor->blkno, -1,
+                error = xfs_attr3_leaf_read(NULL, context->dp, cursor->blkno, -1,
                                            &bp);
                 if (error)
                         return error;
         }
         xfs_trans_brelse(NULL, bp);
-        return(0);
-}
-
-
-/*========================================================================
- * External routines for manipulating out-of-line attribute values.
- *========================================================================*/
-
-/*
- * Read the value associated with an attribute from the out-of-line buffer
- * that we stored it in.
- */
-int
-xfs_attr_rmtval_get(xfs_da_args_t *args)
-{
-        xfs_bmbt_irec_t map[ATTR_RMTVALUE_MAPSIZE];
-        xfs_mount_t *mp;
-        xfs_daddr_t dblkno;
-        void *dst;
-        xfs_buf_t *bp;
-        int nmap, error, tmp, valuelen, blkcnt, i;
-        xfs_dablk_t lblkno;
-
-        trace_xfs_attr_rmtval_get(args);
-
-        ASSERT(!(args->flags & ATTR_KERNOVAL));
-
-        mp = args->dp->i_mount;
-        dst = args->value;
-        valuelen = args->valuelen;
-        lblkno = args->rmtblkno;
-        while (valuelen > 0) {
-                nmap = ATTR_RMTVALUE_MAPSIZE;
-                error = xfs_bmapi_read(args->dp, (xfs_fileoff_t)lblkno,
-                                       args->rmtblkcnt, map, &nmap,
-                                       XFS_BMAPI_ATTRFORK);
-                if (error)
-                        return(error);
-                ASSERT(nmap >= 1);
-
-                for (i = 0; (i < nmap) && (valuelen > 0); i++) {
-                        ASSERT((map[i].br_startblock != DELAYSTARTBLOCK) &&
-                               (map[i].br_startblock != HOLESTARTBLOCK));
-                        dblkno = XFS_FSB_TO_DADDR(mp, map[i].br_startblock);
-                        blkcnt = XFS_FSB_TO_BB(mp, map[i].br_blockcount);
-                        error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
-                                                   dblkno, blkcnt, 0, &bp, NULL);
-                        if (error)
-                                return(error);
-
-                        tmp = min_t(int, valuelen, BBTOB(bp->b_length));
-                        xfs_buf_iomove(bp, 0, tmp, dst, XBRW_READ);
-                        xfs_buf_relse(bp);
-                        dst += tmp;
-                        valuelen -= tmp;
-
-                        lblkno += map[i].br_blockcount;
-                }
-        }
-        ASSERT(valuelen == 0);
-        return(0);
-}
-
-/*
- * Write the value associated with an attribute into the out-of-line buffer
- * that we have defined for it.
- */
-STATIC int
-xfs_attr_rmtval_set(xfs_da_args_t *args)
-{
-        xfs_mount_t *mp;
-        xfs_fileoff_t lfileoff;
-        xfs_inode_t *dp;
-        xfs_bmbt_irec_t map;
-        xfs_daddr_t dblkno;
-        void *src;
-        xfs_buf_t *bp;
-        xfs_dablk_t lblkno;
-        int blkcnt, valuelen, nmap, error, tmp, committed;
-
-        trace_xfs_attr_rmtval_set(args);
-
-        dp = args->dp;
-        mp = dp->i_mount;
-        src = args->value;
-
-        /*
-         * Find a "hole" in the attribute address space large enough for
-         * us to drop the new attribute's value into.
-         */
-        blkcnt = XFS_B_TO_FSB(mp, args->valuelen);
-        lfileoff = 0;
-        error = xfs_bmap_first_unused(args->trans, args->dp, blkcnt, &lfileoff,
-                                                   XFS_ATTR_FORK);
-        if (error) {
-                return(error);
-        }
-        args->rmtblkno = lblkno = (xfs_dablk_t)lfileoff;
-        args->rmtblkcnt = blkcnt;
-
-        /*
-         * Roll through the "value", allocating blocks on disk as required.
-         */
-        while (blkcnt > 0) {
-                /*
-                 * Allocate a single extent, up to the size of the value.
-                 */
-                xfs_bmap_init(args->flist, args->firstblock);
-                nmap = 1;
-                error = xfs_bmapi_write(args->trans, dp, (xfs_fileoff_t)lblkno,
-                                  blkcnt,
-                                  XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA,
-                                  args->firstblock, args->total, &map, &nmap,
-                                  args->flist);
-                if (!error) {
-                        error = xfs_bmap_finish(&args->trans, args->flist,
-                                                &committed);
-                }
-                if (error) {
-                        ASSERT(committed);
-                        args->trans = NULL;
-                        xfs_bmap_cancel(args->flist);
-                        return(error);
-                }
-
-                /*
-                 * bmap_finish() may have committed the last trans and started
-                 * a new one.  We need the inode to be in all transactions.
-                 */
-                if (committed)
-                        xfs_trans_ijoin(args->trans, dp, 0);
-
-                ASSERT(nmap == 1);
-                ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
-                       (map.br_startblock != HOLESTARTBLOCK));
-                lblkno += map.br_blockcount;
-                blkcnt -= map.br_blockcount;
-
-                /*
-                 * Start the next trans in the chain.
-                 */
-                error = xfs_trans_roll(&args->trans, dp);
-                if (error)
-                        return (error);
-        }
-
-        /*
-         * Roll through the "value", copying the attribute value to the
-         * already-allocated blocks.  Blocks are written synchronously
-         * so that we can know they are all on disk before we turn off
-         * the INCOMPLETE flag.
-         */
-        lblkno = args->rmtblkno;
-        valuelen = args->valuelen;
-        while (valuelen > 0) {
-                int buflen;
-
-                /*
-                 * Try to remember where we decided to put the value.
-                 */
-                xfs_bmap_init(args->flist, args->firstblock);
-                nmap = 1;
-                error = xfs_bmapi_read(dp, (xfs_fileoff_t)lblkno,
-                                       args->rmtblkcnt, &map, &nmap,
-                                       XFS_BMAPI_ATTRFORK);
-                if (error)
-                        return(error);
-                ASSERT(nmap == 1);
-                ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
-                       (map.br_startblock != HOLESTARTBLOCK));
-
-                dblkno = XFS_FSB_TO_DADDR(mp, map.br_startblock),
-                blkcnt = XFS_FSB_TO_BB(mp, map.br_blockcount);
-
-                bp = xfs_buf_get(mp->m_ddev_targp, dblkno, blkcnt, 0);
-                if (!bp)
-                        return ENOMEM;
-
-                buflen = BBTOB(bp->b_length);
-                tmp = min_t(int, valuelen, buflen);
-                xfs_buf_iomove(bp, 0, tmp, src, XBRW_WRITE);
-                if (tmp < buflen)
-                        xfs_buf_zero(bp, tmp, buflen - tmp);
-
-                error = xfs_bwrite(bp); /* GROT: NOTE: synchronous write */
-                xfs_buf_relse(bp);
-                if (error)
-                        return error;
-                src += tmp;
-                valuelen -= tmp;
-
-                lblkno += map.br_blockcount;
-        }
-        ASSERT(valuelen == 0);
-        return(0);
-}
-
-/*
- * Remove the value associated with an attribute by deleting the
- * out-of-line buffer that it is stored on.
- */
-STATIC int
-xfs_attr_rmtval_remove(xfs_da_args_t *args)
-{
-        xfs_mount_t *mp;
-        xfs_bmbt_irec_t map;
-        xfs_buf_t *bp;
-        xfs_daddr_t dblkno;
-        xfs_dablk_t lblkno;
-        int valuelen, blkcnt, nmap, error, done, committed;
-
-        trace_xfs_attr_rmtval_remove(args);
-
-        mp = args->dp->i_mount;
-
-        /*
-         * Roll through the "value", invalidating the attribute value's
-         * blocks.
-         */
-        lblkno = args->rmtblkno;
-        valuelen = args->rmtblkcnt;
-        while (valuelen > 0) {
-                /*
-                 * Try to remember where we decided to put the value.
-                 */
-                nmap = 1;
-                error = xfs_bmapi_read(args->dp, (xfs_fileoff_t)lblkno,
-                                       args->rmtblkcnt, &map, &nmap,
-                                       XFS_BMAPI_ATTRFORK);
-                if (error)
-                        return(error);
-                ASSERT(nmap == 1);
-                ASSERT((map.br_startblock != DELAYSTARTBLOCK) &&
-                       (map.br_startblock != HOLESTARTBLOCK));
-
-                dblkno = XFS_FSB_TO_DADDR(mp, map.br_startblock),
-                blkcnt = XFS_FSB_TO_BB(mp, map.br_blockcount);
-
-                /*
-                 * If the "remote" value is in the cache, remove it.
-                 */
-                bp = xfs_incore(mp->m_ddev_targp, dblkno, blkcnt, XBF_TRYLOCK);
-                if (bp) {
-                        xfs_buf_stale(bp);
-                        xfs_buf_relse(bp);
-                        bp = NULL;
-                }
-
-                valuelen -= map.br_blockcount;
-
-                lblkno += map.br_blockcount;
-        }
-
-        /*
-         * Keep de-allocating extents until the remote-value region is gone.
-         */
-        lblkno = args->rmtblkno;
-        blkcnt = args->rmtblkcnt;
-        done = 0;
-        while (!done) {
-                xfs_bmap_init(args->flist, args->firstblock);
-                error = xfs_bunmapi(args->trans, args->dp, lblkno, blkcnt,
-                                    XFS_BMAPI_ATTRFORK | XFS_BMAPI_METADATA,
-                                    1, args->firstblock, args->flist,
-                                    &done);
-                if (!error) {
-                        error = xfs_bmap_finish(&args->trans, args->flist,
-                                                &committed);
-                }
-                if (error) {
-                        ASSERT(committed);
-                        args->trans = NULL;
-                        xfs_bmap_cancel(args->flist);
-                        return(error);
-                }
-
-                /*
-                 * bmap_finish() may have committed the last trans and started
-                 * a new one.  We need the inode to be in all transactions.
-                 */
-                if (committed)
-                        xfs_trans_ijoin(args->trans, args->dp, 0);
-
-                /*
-                 * Close out trans and start the next one in the chain.
-                 */
-                error = xfs_trans_roll(&args->trans, args->dp);
-                if (error)
-                        return (error);
-        }
-        return(0);
+        return 0;
 }