1 files changed, 98 insertions, 95 deletions

diff --git a/fs/xfs/xfs_dir2_block.c b/fs/xfs/xfs_dir2_block.c
index 31bc99faa704..bd5cee6aa51a 100644
--- a/fs/xfs/xfs_dir2_block.c
+++ b/fs/xfs/xfs_dir2_block.c
@@ -81,7 +81,7 @@ xfs_dir2_block_addname(
         xfs_mount_t             *mp;            /* filesystem mount point */
         int                     needlog;        /* need to log header */
         int                     needscan;       /* need to rescan freespace */
-        xfs_dir2_data_off_t     *tagp;          /* pointer to tag value */
+        __be16                  *tagp;          /* pointer to tag value */
         xfs_trans_t             *tp;            /* transaction structure */
 
         xfs_dir2_trace_args("block_addname", args);
@@ -100,8 +100,7 @@ xfs_dir2_block_addname(
         /*
          * Check the magic number, corrupted if wrong.
          */
-        if (unlikely(INT_GET(block->hdr.magic, ARCH_CONVERT)
-                                                != XFS_DIR2_BLOCK_MAGIC)) {
+        if (unlikely(be32_to_cpu(block->hdr.magic) != XFS_DIR2_BLOCK_MAGIC)) {
                 XFS_CORRUPTION_ERROR("xfs_dir2_block_addname",
                                      XFS_ERRLEVEL_LOW, mp, block);
                 xfs_da_brelse(tp, bp);
@@ -121,38 +120,38 @@ xfs_dir2_block_addname(
                 /*
                  * Tag just before the first leaf entry.
                  */
-                tagp = (xfs_dir2_data_off_t *)blp - 1;
+                tagp = (__be16 *)blp - 1;
                 /*
                  * Data object just before the first leaf entry.
                  */
-                enddup = (xfs_dir2_data_unused_t *)((char *)block + INT_GET(*tagp, ARCH_CONVERT));
+                enddup = (xfs_dir2_data_unused_t *)((char *)block + be16_to_cpu(*tagp));
                 /*
                  * If it's not free then can't do this add without cleaning up:
                  * the space before the first leaf entry needs to be free so it
                  * can be expanded to hold the pointer to the new entry.
                  */
-                if (INT_GET(enddup->freetag, ARCH_CONVERT) != XFS_DIR2_DATA_FREE_TAG)
+                if (be16_to_cpu(enddup->freetag) != XFS_DIR2_DATA_FREE_TAG)
                         dup = enddup = NULL;
                 /*
                  * Check out the biggest freespace and see if it's the same one.
                  */
                 else {
                         dup = (xfs_dir2_data_unused_t *)
-                              ((char *)block + INT_GET(bf[0].offset, ARCH_CONVERT));
+                              ((char *)block + be16_to_cpu(bf[0].offset));
                         if (dup == enddup) {
                                 /*
                                  * It is the biggest freespace, is it too small
                                  * to hold the new leaf too?
                                  */
-                                if (INT_GET(dup->length, ARCH_CONVERT) < len + (uint)sizeof(*blp)) {
+                                if (be16_to_cpu(dup->length) < len + (uint)sizeof(*blp)) {
                                         /*
                                          * Yes, we use the second-largest
                                          * entry instead if it works.
                                          */
-                                        if (INT_GET(bf[1].length, ARCH_CONVERT) >= len)
+                                        if (be16_to_cpu(bf[1].length) >= len)
                                                 dup = (xfs_dir2_data_unused_t *)
                                                       ((char *)block +
-                                                       INT_GET(bf[1].offset, ARCH_CONVERT));
+                                                       be16_to_cpu(bf[1].offset));
                                         else
                                                 dup = NULL;
                                 }
@@ -161,7 +160,7 @@ xfs_dir2_block_addname(
                                  * Not the same free entry,
                                  * just check its length.
                                  */
-                                if (INT_GET(dup->length, ARCH_CONVERT) < len) {
+                                if (be16_to_cpu(dup->length) < len) {
                                         dup = NULL;
                                 }
                         }
@@ -172,9 +171,9 @@ xfs_dir2_block_addname(
          * If there are stale entries we'll use one for the leaf.
          * Is the biggest entry enough to avoid compaction?
          */
-        else if (INT_GET(bf[0].length, ARCH_CONVERT) >= len) {
+        else if (be16_to_cpu(bf[0].length) >= len) {
                 dup = (xfs_dir2_data_unused_t *)
-                      ((char *)block + INT_GET(bf[0].offset, ARCH_CONVERT));
+                      ((char *)block + be16_to_cpu(bf[0].offset));
                 compact = 0;
         }
         /*
@@ -184,20 +183,20 @@ xfs_dir2_block_addname(
                 /*
                  * Tag just before the first leaf entry.
                  */
-                tagp = (xfs_dir2_data_off_t *)blp - 1;
+                tagp = (__be16 *)blp - 1;
                 /*
                  * Data object just before the first leaf entry.
                  */
-                dup = (xfs_dir2_data_unused_t *)((char *)block + INT_GET(*tagp, ARCH_CONVERT));
+                dup = (xfs_dir2_data_unused_t *)((char *)block + be16_to_cpu(*tagp));
                 /*
                  * If it's not free then the data will go where the
                  * leaf data starts now, if it works at all.
                  */
-                if (INT_GET(dup->freetag, ARCH_CONVERT) == XFS_DIR2_DATA_FREE_TAG) {
-                        if (INT_GET(dup->length, ARCH_CONVERT) + (INT_GET(btp->stale, ARCH_CONVERT) - 1) *
+                if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
+                        if (be16_to_cpu(dup->length) + (be32_to_cpu(btp->stale) - 1) *
                             (uint)sizeof(*blp) < len)
                                 dup = NULL;
-                } else if ((INT_GET(btp->stale, ARCH_CONVERT) - 1) * (uint)sizeof(*blp) < len)
+                } else if ((be32_to_cpu(btp->stale) - 1) * (uint)sizeof(*blp) < len)
                         dup = NULL;
                 else
                         dup = (xfs_dir2_data_unused_t *)blp;
@@ -243,11 +242,11 @@ xfs_dir2_block_addname(
                 int     fromidx;                /* source leaf index */
                 int     toidx;                  /* target leaf index */
 
-                for (fromidx = toidx = INT_GET(btp->count, ARCH_CONVERT) - 1,
+                for (fromidx = toidx = be32_to_cpu(btp->count) - 1,
                         highstale = lfloghigh = -1;
                      fromidx >= 0;
                      fromidx--) {
-                        if (INT_GET(blp[fromidx].address, ARCH_CONVERT) == XFS_DIR2_NULL_DATAPTR) {
+                        if (be32_to_cpu(blp[fromidx].address) == XFS_DIR2_NULL_DATAPTR) {
                                 if (highstale == -1)
                                         highstale = toidx;
                                 else {
@@ -260,15 +259,15 @@ xfs_dir2_block_addname(
                                 blp[toidx] = blp[fromidx];
                         toidx--;
                 }
-                lfloglow = toidx + 1 - (INT_GET(btp->stale, ARCH_CONVERT) - 1);
-                lfloghigh -= INT_GET(btp->stale, ARCH_CONVERT) - 1;
-                INT_MOD(btp->count, ARCH_CONVERT, -(INT_GET(btp->stale, ARCH_CONVERT) - 1));
+                lfloglow = toidx + 1 - (be32_to_cpu(btp->stale) - 1);
+                lfloghigh -= be32_to_cpu(btp->stale) - 1;
+                be32_add(&btp->count, -(be32_to_cpu(btp->stale) - 1));
                 xfs_dir2_data_make_free(tp, bp,
                         (xfs_dir2_data_aoff_t)((char *)blp - (char *)block),
-                        (xfs_dir2_data_aoff_t)((INT_GET(btp->stale, ARCH_CONVERT) - 1) * sizeof(*blp)),
+                        (xfs_dir2_data_aoff_t)((be32_to_cpu(btp->stale) - 1) * sizeof(*blp)),
                         &needlog, &needscan);
-                blp += INT_GET(btp->stale, ARCH_CONVERT) - 1;
-                INT_SET(btp->stale, ARCH_CONVERT, 1);
+                blp += be32_to_cpu(btp->stale) - 1;
+                btp->stale = cpu_to_be32(1);
                 /*
                  * If we now need to rebuild the bestfree map, do so.
                  * This needs to happen before the next call to use_free.
@@ -283,23 +282,23 @@ xfs_dir2_block_addname(
          * Set leaf logging boundaries to impossible state.
          * For the no-stale case they're set explicitly.
          */
-        else if (INT_GET(btp->stale, ARCH_CONVERT)) {
-                lfloglow = INT_GET(btp->count, ARCH_CONVERT);
+        else if (btp->stale) {
+                lfloglow = be32_to_cpu(btp->count);
                 lfloghigh = -1;
         }
         /*
          * Find the slot that's first lower than our hash value, -1 if none.
          */
-        for (low = 0, high = INT_GET(btp->count, ARCH_CONVERT) - 1; low <= high; ) {
+        for (low = 0, high = be32_to_cpu(btp->count) - 1; low <= high; ) {
                 mid = (low + high) >> 1;
-                if ((hash = INT_GET(blp[mid].hashval, ARCH_CONVERT)) == args->hashval)
+                if ((hash = be32_to_cpu(blp[mid].hashval)) == args->hashval)
                         break;
                 if (hash < args->hashval)
                         low = mid + 1;
                 else
                         high = mid - 1;
         }
-        while (mid >= 0 && INT_GET(blp[mid].hashval, ARCH_CONVERT) >= args->hashval) {
+        while (mid >= 0 && be32_to_cpu(blp[mid].hashval) >= args->hashval) {
                 mid--;
         }
         /*
@@ -311,14 +310,14 @@ xfs_dir2_block_addname(
                  */
                 xfs_dir2_data_use_free(tp, bp, enddup,
                         (xfs_dir2_data_aoff_t)
-                        ((char *)enddup - (char *)block + INT_GET(enddup->length, ARCH_CONVERT) -
+                        ((char *)enddup - (char *)block + be16_to_cpu(enddup->length) -
                          sizeof(*blp)),
                         (xfs_dir2_data_aoff_t)sizeof(*blp),
                         &needlog, &needscan);
                 /*
                  * Update the tail (entry count).
                  */
-                INT_MOD(btp->count, ARCH_CONVERT, +1);
+                be32_add(&btp->count, 1);
                 /*
                  * If we now need to rebuild the bestfree map, do so.
                  * This needs to happen before the next call to use_free.
@@ -346,12 +345,12 @@ xfs_dir2_block_addname(
         else {
                 for (lowstale = mid;
                      lowstale >= 0 &&
-                        INT_GET(blp[lowstale].address, ARCH_CONVERT) != XFS_DIR2_NULL_DATAPTR;
+                        be32_to_cpu(blp[lowstale].address) != XFS_DIR2_NULL_DATAPTR;
                      lowstale--)
                         continue;
                 for (highstale = mid + 1;
-                     highstale < INT_GET(btp->count, ARCH_CONVERT) &&
-                        INT_GET(blp[highstale].address, ARCH_CONVERT) != XFS_DIR2_NULL_DATAPTR &&
+                     highstale < be32_to_cpu(btp->count) &&
+                        be32_to_cpu(blp[highstale].address) != XFS_DIR2_NULL_DATAPTR &&
                         (lowstale < 0 || mid - lowstale > highstale - mid);
                      highstale++)
                         continue;
@@ -359,7 +358,7 @@ xfs_dir2_block_addname(
                  * Move entries toward the low-numbered stale entry.
                  */
                 if (lowstale >= 0 &&
-                    (highstale == INT_GET(btp->count, ARCH_CONVERT) ||
+                    (highstale == be32_to_cpu(btp->count) ||
                      mid - lowstale <= highstale - mid)) {
                         if (mid - lowstale)
                                 memmove(&blp[lowstale], &blp[lowstale + 1],
@@ -371,7 +370,7 @@ xfs_dir2_block_addname(
                  * Move entries toward the high-numbered stale entry.
                  */
                 else {
-                        ASSERT(highstale < INT_GET(btp->count, ARCH_CONVERT));
+                        ASSERT(highstale < be32_to_cpu(btp->count));
                         mid++;
                         if (highstale - mid)
                                 memmove(&blp[mid + 1], &blp[mid],
@@ -379,7 +378,7 @@ xfs_dir2_block_addname(
                         lfloglow = MIN(mid, lfloglow);
                         lfloghigh = MAX(highstale, lfloghigh);
                 }
-                INT_MOD(btp->stale, ARCH_CONVERT, -1);
+                be32_add(&btp->stale, -1);
         }
         /*
          * Point to the new data entry.
@@ -388,8 +387,9 @@ xfs_dir2_block_addname(
         /*
          * Fill in the leaf entry.
          */
-        INT_SET(blp[mid].hashval, ARCH_CONVERT, args->hashval);
-        INT_SET(blp[mid].address, ARCH_CONVERT, XFS_DIR2_BYTE_TO_DATAPTR(mp, (char *)dep - (char *)block));
+        blp[mid].hashval = cpu_to_be32(args->hashval);
+        blp[mid].address = cpu_to_be32(XFS_DIR2_BYTE_TO_DATAPTR(mp,
+                                (char *)dep - (char *)block));
         xfs_dir2_block_log_leaf(tp, bp, lfloglow, lfloghigh);
         /*
          * Mark space for the data entry used.
@@ -404,7 +404,7 @@ xfs_dir2_block_addname(
         dep->namelen = args->namelen;
         memcpy(dep->name, args->name, args->namelen);
         tagp = XFS_DIR2_DATA_ENTRY_TAG_P(dep);
-        INT_SET(*tagp, ARCH_CONVERT, (xfs_dir2_data_off_t)((char *)dep - (char *)block));
+        *tagp = cpu_to_be16((char *)dep - (char *)block);
         /*
          * Clean up the bestfree array and log the header, tail, and entry.
          */
@@ -485,8 +485,8 @@ xfs_dir2_block_getdents(
                 /*
                  * Unused, skip it.
                  */
-                if (INT_GET(dup->freetag, ARCH_CONVERT) == XFS_DIR2_DATA_FREE_TAG) {
-                        ptr += INT_GET(dup->length, ARCH_CONVERT);
+                if (be16_to_cpu(dup->freetag) == XFS_DIR2_DATA_FREE_TAG) {
+                        ptr += be16_to_cpu(dup->length);
                         continue;
                 }
 
@@ -622,7 +622,7 @@ xfs_dir2_block_lookup(
          * Get the offset from the leaf entry, to point to the data.
          */
         dep = (xfs_dir2_data_entry_t *)
-              ((char *)block + XFS_DIR2_DATAPTR_TO_OFF(mp, INT_GET(blp[ent].address, ARCH_CONVERT)));
+              ((char *)block + XFS_DIR2_DATAPTR_TO_OFF(mp, be32_to_cpu(blp[ent].address)));
         /*
          * Fill in inode number, release the block.
          */
@@ -674,10 +674,10 @@ xfs_dir2_block_lookup_int(
          * Loop doing a binary search for our hash value.
          * Find our entry, ENOENT if it's not there.
          */
-        for (low = 0, high = INT_GET(btp->count, ARCH_CONVERT) - 1; ; ) {
+        for (low = 0, high = be32_to_cpu(btp->count) - 1; ; ) {
                 ASSERT(low <= high);
                 mid = (low + high) >> 1;
-                if ((hash = INT_GET(blp[mid].hashval, ARCH_CONVERT)) == args->hashval)
+                if ((hash = be32_to_cpu(blp[mid].hashval)) == args->hashval)
                         break;
                 if (hash < args->hashval)
                         low = mid + 1;
@@ -692,7 +692,7 @@ xfs_dir2_block_lookup_int(
         /*
          * Back up to the first one with the right hash value.
          */
-        while (mid > 0 && INT_GET(blp[mid - 1].hashval, ARCH_CONVERT) == args->hashval) {
+        while (mid > 0 && be32_to_cpu(blp[mid - 1].hashval) == args->hashval) {
                 mid--;
         }
         /*
@@ -700,7 +700,7 @@ xfs_dir2_block_lookup_int(
          * right hash value looking for our name.
          */
         do {
-                if ((addr = INT_GET(blp[mid].address, ARCH_CONVERT)) == XFS_DIR2_NULL_DATAPTR)
+                if ((addr = be32_to_cpu(blp[mid].address)) == XFS_DIR2_NULL_DATAPTR)
                         continue;
                 /*
                  * Get pointer to the entry from the leaf.
@@ -717,7 +717,7 @@ xfs_dir2_block_lookup_int(
                         *entno = mid;
                         return 0;
                 }
-        } while (++mid < INT_GET(btp->count, ARCH_CONVERT) && INT_GET(blp[mid].hashval, ARCH_CONVERT) == hash);
+        } while (++mid < be32_to_cpu(btp->count) && be32_to_cpu(blp[mid].hashval) == hash);
         /*
          * No match, release the buffer and return ENOENT.
          */
@@ -767,7 +767,7 @@ xfs_dir2_block_removename(
          * Point to the data entry using the leaf entry.
          */
         dep = (xfs_dir2_data_entry_t *)
-              ((char *)block + XFS_DIR2_DATAPTR_TO_OFF(mp, INT_GET(blp[ent].address, ARCH_CONVERT)));
+              ((char *)block + XFS_DIR2_DATAPTR_TO_OFF(mp, be32_to_cpu(blp[ent].address)));
         /*
          * Mark the data entry's space free.
          */
@@ -778,12 +778,12 @@ xfs_dir2_block_removename(
         /*
          * Fix up the block tail.
          */
-        INT_MOD(btp->stale, ARCH_CONVERT, +1);
+        be32_add(&btp->stale, 1);
         xfs_dir2_block_log_tail(tp, bp);
         /*
          * Remove the leaf entry by marking it stale.
          */
-        INT_SET(blp[ent].address, ARCH_CONVERT, XFS_DIR2_NULL_DATAPTR);
+        blp[ent].address = cpu_to_be32(XFS_DIR2_NULL_DATAPTR);
         xfs_dir2_block_log_leaf(tp, bp, ent, ent);
         /*
          * Fix up bestfree, log the header if necessary.
@@ -843,7 +843,7 @@ xfs_dir2_block_replace(
          * Point to the data entry we need to change.
          */
         dep = (xfs_dir2_data_entry_t *)
-              ((char *)block + XFS_DIR2_DATAPTR_TO_OFF(mp, INT_GET(blp[ent].address, ARCH_CONVERT)));
+              ((char *)block + XFS_DIR2_DATAPTR_TO_OFF(mp, be32_to_cpu(blp[ent].address)));
         ASSERT(INT_GET(dep->inumber, ARCH_CONVERT) != args->inumber);
         /*
          * Change the inode number to the new value.
@@ -868,8 +868,8 @@ xfs_dir2_block_sort(
 
         la = a;
         lb = b;
-        return INT_GET(la->hashval, ARCH_CONVERT) < INT_GET(lb->hashval, ARCH_CONVERT) ? -1 :
-                (INT_GET(la->hashval, ARCH_CONVERT) > INT_GET(lb->hashval, ARCH_CONVERT) ? 1 : 0);
+        return be32_to_cpu(la->hashval) < be32_to_cpu(lb->hashval) ? -1 :
+                (be32_to_cpu(la->hashval) > be32_to_cpu(lb->hashval) ? 1 : 0);
 }
 
 /*
@@ -881,7 +881,7 @@ xfs_dir2_leaf_to_block(
         xfs_dabuf_t             *lbp,           /* leaf buffer */
         xfs_dabuf_t             *dbp)           /* data buffer */
 {
-        xfs_dir2_data_off_t     *bestsp;        /* leaf bests table */
+        __be16                  *bestsp;        /* leaf bests table */
         xfs_dir2_block_t        *block;         /* block structure */
         xfs_dir2_block_tail_t   *btp;           /* block tail */
         xfs_inode_t             *dp;            /* incore directory inode */
@@ -896,7 +896,7 @@ xfs_dir2_leaf_to_block(
         int                     needscan;       /* need to scan for bestfree */
         xfs_dir2_sf_hdr_t       sfh;            /* shortform header */
         int                     size;           /* bytes used */
-        xfs_dir2_data_off_t     *tagp;          /* end of entry (tag) */
+        __be16                  *tagp;          /* end of entry (tag) */
         int                     to;             /* block/leaf to index */
         xfs_trans_t             *tp;            /* transaction pointer */
 
@@ -905,7 +905,7 @@ xfs_dir2_leaf_to_block(
         tp = args->trans;
         mp = dp->i_mount;
         leaf = lbp->data;
-        ASSERT(INT_GET(leaf->hdr.info.magic, ARCH_CONVERT) == XFS_DIR2_LEAF1_MAGIC);
+        ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR2_LEAF1_MAGIC);
         ltp = XFS_DIR2_LEAF_TAIL_P(mp, leaf);
         /*
          * If there are data blocks other than the first one, take this
@@ -915,11 +915,11 @@ xfs_dir2_leaf_to_block(
          */
         while (dp->i_d.di_size > mp->m_dirblksize) {
                 bestsp = XFS_DIR2_LEAF_BESTS_P(ltp);
-                if (INT_GET(bestsp[INT_GET(ltp->bestcount, ARCH_CONVERT) - 1], ARCH_CONVERT) ==
+                if (be16_to_cpu(bestsp[be32_to_cpu(ltp->bestcount) - 1]) ==
                     mp->m_dirblksize - (uint)sizeof(block->hdr)) {
                         if ((error =
                             xfs_dir2_leaf_trim_data(args, lbp,
-                                    (xfs_dir2_db_t)(INT_GET(ltp->bestcount, ARCH_CONVERT) - 1))))
+                                    (xfs_dir2_db_t)(be32_to_cpu(ltp->bestcount) - 1))))
                                 goto out;
                 } else {
                         error = 0;
@@ -935,28 +935,29 @@ xfs_dir2_leaf_to_block(
                 goto out;
         }
         block = dbp->data;
-        ASSERT(INT_GET(block->hdr.magic, ARCH_CONVERT) == XFS_DIR2_DATA_MAGIC);
+        ASSERT(be32_to_cpu(block->hdr.magic) == XFS_DIR2_DATA_MAGIC);
         /*
          * Size of the "leaf" area in the block.
          */
         size = (uint)sizeof(block->tail) +
-               (uint)sizeof(*lep) * (INT_GET(leaf->hdr.count, ARCH_CONVERT) - INT_GET(leaf->hdr.stale, ARCH_CONVERT));
+               (uint)sizeof(*lep) * (be16_to_cpu(leaf->hdr.count) - be16_to_cpu(leaf->hdr.stale));
         /*
          * Look at the last data entry.
          */
-        tagp = (xfs_dir2_data_off_t *)((char *)block + mp->m_dirblksize) - 1;
-        dup = (xfs_dir2_data_unused_t *)((char *)block + INT_GET(*tagp, ARCH_CONVERT));
+        tagp = (__be16 *)((char *)block + mp->m_dirblksize) - 1;
+        dup = (xfs_dir2_data_unused_t *)((char *)block + be16_to_cpu(*tagp));
         /*
          * If it's not free or is too short we can't do it.
          */
-        if (INT_GET(dup->freetag, ARCH_CONVERT) != XFS_DIR2_DATA_FREE_TAG || INT_GET(dup->length, ARCH_CONVERT) < size) {
+        if (be16_to_cpu(dup->freetag) != XFS_DIR2_DATA_FREE_TAG ||
+            be16_to_cpu(dup->length) < size) {
                 error = 0;
                 goto out;
         }
         /*
          * Start converting it to block form.
          */
-        INT_SET(block->hdr.magic, ARCH_CONVERT, XFS_DIR2_BLOCK_MAGIC);
+        block->hdr.magic = cpu_to_be32(XFS_DIR2_BLOCK_MAGIC);
         needlog = 1;
         needscan = 0;
         /*
@@ -968,20 +969,20 @@ xfs_dir2_leaf_to_block(
          * Initialize the block tail.
          */
         btp = XFS_DIR2_BLOCK_TAIL_P(mp, block);
-        INT_SET(btp->count, ARCH_CONVERT, INT_GET(leaf->hdr.count, ARCH_CONVERT) - INT_GET(leaf->hdr.stale, ARCH_CONVERT));
+        btp->count = cpu_to_be32(be16_to_cpu(leaf->hdr.count) - be16_to_cpu(leaf->hdr.stale));
         btp->stale = 0;
         xfs_dir2_block_log_tail(tp, dbp);
         /*
          * Initialize the block leaf area.  We compact out stale entries.
          */
         lep = XFS_DIR2_BLOCK_LEAF_P(btp);
-        for (from = to = 0; from < INT_GET(leaf->hdr.count, ARCH_CONVERT); from++) {
-                if (INT_GET(leaf->ents[from].address, ARCH_CONVERT) == XFS_DIR2_NULL_DATAPTR)
+        for (from = to = 0; from < be16_to_cpu(leaf->hdr.count); from++) {
+                if (be32_to_cpu(leaf->ents[from].address) == XFS_DIR2_NULL_DATAPTR)
                         continue;
                 lep[to++] = leaf->ents[from];
         }
-        ASSERT(to == INT_GET(btp->count, ARCH_CONVERT));
-        xfs_dir2_block_log_leaf(tp, dbp, 0, INT_GET(btp->count, ARCH_CONVERT) - 1);
+        ASSERT(to == be32_to_cpu(btp->count));
+        xfs_dir2_block_log_leaf(tp, dbp, 0, be32_to_cpu(btp->count) - 1);
         /*
          * Scan the bestfree if we need it and log the data block header.
          */
@@ -1043,7 +1044,7 @@ xfs_dir2_sf_to_block(
         int                     offset;         /* target block offset */
         xfs_dir2_sf_entry_t     *sfep;          /* sf entry pointer */
         xfs_dir2_sf_t           *sfp;           /* shortform structure */
-        xfs_dir2_data_off_t     *tagp;          /* end of data entry */
+        __be16                  *tagp;          /* end of data entry */
         xfs_trans_t             *tp;            /* transaction pointer */
 
         xfs_dir2_trace_args("sf_to_block", args);
@@ -1095,12 +1096,12 @@ xfs_dir2_sf_to_block(
                 return error;
         }
         block = bp->data;
-        INT_SET(block->hdr.magic, ARCH_CONVERT, XFS_DIR2_BLOCK_MAGIC);
+        block->hdr.magic = cpu_to_be32(XFS_DIR2_BLOCK_MAGIC);
         /*
          * Compute size of block "tail" area.
          */
         i = (uint)sizeof(*btp) +
-            (INT_GET(sfp->hdr.count, ARCH_CONVERT) + 2) * (uint)sizeof(xfs_dir2_leaf_entry_t);
+            (sfp->hdr.count + 2) * (uint)sizeof(xfs_dir2_leaf_entry_t);
         /*
          * The whole thing is initialized to free by the init routine.
          * Say we're using the leaf and tail area.
@@ -1114,7 +1115,7 @@ xfs_dir2_sf_to_block(
          * Fill in the tail.
          */
         btp = XFS_DIR2_BLOCK_TAIL_P(mp, block);
-        INT_SET(btp->count, ARCH_CONVERT, INT_GET(sfp->hdr.count, ARCH_CONVERT) + 2);   /* ., .. */
+        btp->count = cpu_to_be32(sfp->hdr.count + 2);   /* ., .. */
         btp->stale = 0;
         blp = XFS_DIR2_BLOCK_LEAF_P(btp);
         endoffset = (uint)((char *)blp - (char *)block);
@@ -1123,7 +1124,7 @@ xfs_dir2_sf_to_block(
          */
         xfs_dir2_data_use_free(tp, bp, dup,
                 (xfs_dir2_data_aoff_t)((char *)dup - (char *)block),
-                INT_GET(dup->length, ARCH_CONVERT), &needlog, &needscan);
+                be16_to_cpu(dup->length), &needlog, &needscan);
         /*
          * Create entry for .
          */
@@ -1133,10 +1134,11 @@ xfs_dir2_sf_to_block(
         dep->namelen = 1;
         dep->name[0] = '.';
         tagp = XFS_DIR2_DATA_ENTRY_TAG_P(dep);
-        INT_SET(*tagp, ARCH_CONVERT, (xfs_dir2_data_off_t)((char *)dep - (char *)block));
+        *tagp = cpu_to_be16((char *)dep - (char *)block);
         xfs_dir2_data_log_entry(tp, bp, dep);
-        INT_SET(blp[0].hashval, ARCH_CONVERT, xfs_dir_hash_dot);
-        INT_SET(blp[0].address, ARCH_CONVERT, XFS_DIR2_BYTE_TO_DATAPTR(mp, (char *)dep - (char *)block));
+        blp[0].hashval = cpu_to_be32(xfs_dir_hash_dot);
+        blp[0].address = cpu_to_be32(XFS_DIR2_BYTE_TO_DATAPTR(mp,
+                                (char *)dep - (char *)block));
         /*
          * Create entry for ..
          */
@@ -1146,15 +1148,16 @@ xfs_dir2_sf_to_block(
         dep->namelen = 2;
         dep->name[0] = dep->name[1] = '.';
         tagp = XFS_DIR2_DATA_ENTRY_TAG_P(dep);
-        INT_SET(*tagp, ARCH_CONVERT, (xfs_dir2_data_off_t)((char *)dep - (char *)block));
+        *tagp = cpu_to_be16((char *)dep - (char *)block);
         xfs_dir2_data_log_entry(tp, bp, dep);
-        INT_SET(blp[1].hashval, ARCH_CONVERT, xfs_dir_hash_dotdot);
-        INT_SET(blp[1].address, ARCH_CONVERT, XFS_DIR2_BYTE_TO_DATAPTR(mp, (char *)dep - (char *)block));
+        blp[1].hashval = cpu_to_be32(xfs_dir_hash_dotdot);
+        blp[1].address = cpu_to_be32(XFS_DIR2_BYTE_TO_DATAPTR(mp,
+                                (char *)dep - (char *)block));
         offset = XFS_DIR2_DATA_FIRST_OFFSET;
         /*
          * Loop over existing entries, stuff them in.
          */
-        if ((i = 0) == INT_GET(sfp->hdr.count, ARCH_CONVERT))
+        if ((i = 0) == sfp->hdr.count)
                 sfep = NULL;
         else
                 sfep = XFS_DIR2_SF_FIRSTENTRY(sfp);
@@ -1176,15 +1179,14 @@ xfs_dir2_sf_to_block(
                 if (offset < newoffset) {
                         dup = (xfs_dir2_data_unused_t *)
                               ((char *)block + offset);
-                        INT_SET(dup->freetag, ARCH_CONVERT, XFS_DIR2_DATA_FREE_TAG);
-                        INT_SET(dup->length, ARCH_CONVERT, newoffset - offset);
-                        INT_SET(*XFS_DIR2_DATA_UNUSED_TAG_P(dup), ARCH_CONVERT,
-                                (xfs_dir2_data_off_t)
+                        dup->freetag = cpu_to_be16(XFS_DIR2_DATA_FREE_TAG);
+                        dup->length = cpu_to_be16(newoffset - offset);
+                        *XFS_DIR2_DATA_UNUSED_TAG_P(dup) = cpu_to_be16(
                                 ((char *)dup - (char *)block));
                         xfs_dir2_data_log_unused(tp, bp, dup);
                         (void)xfs_dir2_data_freeinsert((xfs_dir2_data_t *)block,
                                 dup, &dummy);
-                        offset += INT_GET(dup->length, ARCH_CONVERT);
+                        offset += be16_to_cpu(dup->length);
                         continue;
                 }
                 /*
@@ -1196,13 +1198,14 @@ xfs_dir2_sf_to_block(
                 dep->namelen = sfep->namelen;
                 memcpy(dep->name, sfep->name, dep->namelen);
                 tagp = XFS_DIR2_DATA_ENTRY_TAG_P(dep);
-                INT_SET(*tagp, ARCH_CONVERT, (xfs_dir2_data_off_t)((char *)dep - (char *)block));
+                *tagp = cpu_to_be16((char *)dep - (char *)block);
                 xfs_dir2_data_log_entry(tp, bp, dep);
-                INT_SET(blp[2 + i].hashval, ARCH_CONVERT, xfs_da_hashname((char *)sfep->name, sfep->namelen));
-                INT_SET(blp[2 + i].address, ARCH_CONVERT, XFS_DIR2_BYTE_TO_DATAPTR(mp,
+                blp[2 + i].hashval = cpu_to_be32(xfs_da_hashname(
+                                        (char *)sfep->name, sfep->namelen));
+                blp[2 + i].address = cpu_to_be32(XFS_DIR2_BYTE_TO_DATAPTR(mp,
                                                  (char *)dep - (char *)block));
                 offset = (int)((char *)(tagp + 1) - (char *)block);
-                if (++i == INT_GET(sfp->hdr.count, ARCH_CONVERT))
+                if (++i == sfp->hdr.count)
                         sfep = NULL;
                 else
                         sfep = XFS_DIR2_SF_NEXTENTRY(sfp, sfep);
@@ -1212,13 +1215,13 @@ xfs_dir2_sf_to_block(
         /*
          * Sort the leaf entries by hash value.
          */
-        xfs_sort(blp, INT_GET(btp->count, ARCH_CONVERT), sizeof(*blp), xfs_dir2_block_sort);
+        xfs_sort(blp, be32_to_cpu(btp->count), sizeof(*blp), xfs_dir2_block_sort);
         /*
          * Log the leaf entry area and tail.
          * Already logged the header in data_init, ignore needlog.
          */
         ASSERT(needscan == 0);
-        xfs_dir2_block_log_leaf(tp, bp, 0, INT_GET(btp->count, ARCH_CONVERT) - 1);
+        xfs_dir2_block_log_leaf(tp, bp, 0, be32_to_cpu(btp->count) - 1);
         xfs_dir2_block_log_tail(tp, bp);
         xfs_dir2_data_check(dp, bp);
         xfs_da_buf_done(bp);