[XFS] endianess annotations for xfs_dir2_leaf_hdr_t

SGI-PV: 943272
SGI-Modid: xfs-linux-melb:xfs-kern:25492a

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Nathan Scott <nathans@sgi.com>

5 files changed, 100 insertions, 100 deletions

diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c
index 2f4acb9d9b9c..c443cbaaaa92 100644
--- a/fs/xfs/xfs_da_btree.c
+++ b/fs/xfs/xfs_da_btree.c
@@ -366,7 +366,7 @@ xfs_da_root_split(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
                 ASSERT(XFS_DIR_IS_V2(mp));
                 ASSERT(INT_GET(oldroot->hdr.info.magic, ARCH_CONVERT) == XFS_DIR2_LEAFN_MAGIC);
                 leaf = (xfs_dir2_leaf_t *)oldroot;
-                size = (int)((char *)&leaf->ents[INT_GET(leaf->hdr.count, ARCH_CONVERT)] -
+                size = (int)((char *)&leaf->ents[be16_to_cpu(leaf->hdr.count)] -
                              (char *)leaf);
         }
         memcpy(node, oldroot, size);
@@ -1798,7 +1798,7 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
                 ASSERT(XFS_DIR_IS_V2(mp));
                 dead_leaf2 = (xfs_dir2_leaf_t *)dead_info;
                 dead_level = 0;
-                dead_hash = INT_GET(dead_leaf2->ents[INT_GET(dead_leaf2->hdr.count, ARCH_CONVERT) - 1].hashval, ARCH_CONVERT);
+                dead_hash = INT_GET(dead_leaf2->ents[be16_to_cpu(dead_leaf2->hdr.count) - 1].hashval, ARCH_CONVERT);
         } else {
                 ASSERT(INT_GET(dead_info->magic, ARCH_CONVERT) == XFS_DA_NODE_MAGIC);
                 dead_node = (xfs_da_intnode_t *)dead_info;
diff --git a/fs/xfs/xfs_dir2_block.c b/fs/xfs/xfs_dir2_block.c
index 6f3b99dfe55c..1dd1a7694e4b 100644
--- a/fs/xfs/xfs_dir2_block.c
+++ b/fs/xfs/xfs_dir2_block.c
@@ -939,7 +939,7 @@ xfs_dir2_leaf_to_block(
          * 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.
          */
@@ -968,14 +968,14 @@ xfs_dir2_leaf_to_block(
          * Initialize the block tail.
          */
         btp = XFS_DIR2_BLOCK_TAIL_P(mp, block);
-        btp->count = cpu_to_be32(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++) {
+        for (from = to = 0; from < be16_to_cpu(leaf->hdr.count); from++) {
                 if (INT_GET(leaf->ents[from].address, ARCH_CONVERT) == XFS_DIR2_NULL_DATAPTR)
                         continue;
                 lep[to++] = leaf->ents[from];
diff --git a/fs/xfs/xfs_dir2_leaf.c b/fs/xfs/xfs_dir2_leaf.c
index 63e81dc2737e..0d366ab4db17 100644
--- a/fs/xfs/xfs_dir2_leaf.c
+++ b/fs/xfs/xfs_dir2_leaf.c
@@ -111,14 +111,14 @@ xfs_dir2_block_to_leaf(
         /*
          * Set the counts in the leaf header.
          */
-        leaf->hdr.count = btp->count;
-        leaf->hdr.stale = btp->stale;
+        leaf->hdr.count = cpu_to_be16(be32_to_cpu(btp->count));
+        leaf->hdr.stale = cpu_to_be16(be32_to_cpu(btp->stale));
         /*
          * Could compact these but I think we always do the conversion
          * after squeezing out stale entries.
          */
         memcpy(leaf->ents, blp, be32_to_cpu(btp->count) * sizeof(xfs_dir2_leaf_entry_t));
-        xfs_dir2_leaf_log_ents(tp, lbp, 0, INT_GET(leaf->hdr.count, ARCH_CONVERT) - 1);
+        xfs_dir2_leaf_log_ents(tp, lbp, 0, be16_to_cpu(leaf->hdr.count) - 1);
         needscan = 0;
         needlog = 1;
         /*
@@ -222,7 +222,7 @@ xfs_dir2_leaf_addname(
          * in a data block, improving the lookup of those entries.
          */
         for (use_block = -1, lep = &leaf->ents[index];
-             index < INT_GET(leaf->hdr.count, ARCH_CONVERT) && INT_GET(lep->hashval, ARCH_CONVERT) == args->hashval;
+             index < be16_to_cpu(leaf->hdr.count) && INT_GET(lep->hashval, ARCH_CONVERT) == args->hashval;
              index++, lep++) {
                 if (INT_GET(lep->address, ARCH_CONVERT) == XFS_DIR2_NULL_DATAPTR)
                         continue;
@@ -266,15 +266,15 @@ xfs_dir2_leaf_addname(
          * If we don't have enough free bytes but we can make enough
          * by compacting out stale entries, we'll do that.
          */
-        if ((char *)bestsp - (char *)&leaf->ents[INT_GET(leaf->hdr.count, ARCH_CONVERT)] < needbytes &&
-            INT_GET(leaf->hdr.stale, ARCH_CONVERT) > 1) {
+        if ((char *)bestsp - (char *)&leaf->ents[be16_to_cpu(leaf->hdr.count)] < needbytes &&
+            be16_to_cpu(leaf->hdr.stale) > 1) {
                 compact = 1;
         }
         /*
          * Otherwise if we don't have enough free bytes we need to
          * convert to node form.
          */
-        else if ((char *)bestsp - (char *)&leaf->ents[INT_GET(leaf->hdr.count, ARCH_CONVERT)] <
+        else if ((char *)bestsp - (char *)&leaf->ents[be16_to_cpu(leaf->hdr.count)] <
                  needbytes) {
                 /*
                  * Just checking or no space reservation, give up.
@@ -330,8 +330,8 @@ xfs_dir2_leaf_addname(
          * There are stale entries, so we'll need log-low and log-high
          * impossibly bad values later.
          */
-        else if (INT_GET(leaf->hdr.stale, ARCH_CONVERT)) {
-                lfloglow = INT_GET(leaf->hdr.count, ARCH_CONVERT);
+        else if (be16_to_cpu(leaf->hdr.stale)) {
+                lfloglow = be16_to_cpu(leaf->hdr.count);
                 lfloghigh = -1;
         }
         /*
@@ -440,15 +440,15 @@ xfs_dir2_leaf_addname(
                 /*
                  * lep is still good as the index leaf entry.
                  */
-                if (index < INT_GET(leaf->hdr.count, ARCH_CONVERT))
+                if (index < be16_to_cpu(leaf->hdr.count))
                         memmove(lep + 1, lep,
-                                (INT_GET(leaf->hdr.count, ARCH_CONVERT) - index) * sizeof(*lep));
+                                (be16_to_cpu(leaf->hdr.count) - index) * sizeof(*lep));
                 /*
                  * Record low and high logging indices for the leaf.
                  */
                 lfloglow = index;
-                lfloghigh = INT_GET(leaf->hdr.count, ARCH_CONVERT);
-                INT_MOD(leaf->hdr.count, ARCH_CONVERT, +1);
+                lfloghigh = be16_to_cpu(leaf->hdr.count);
+                be16_add(&leaf->hdr.count, 1);
         }
         /*
          * There are stale entries.
@@ -478,7 +478,7 @@ xfs_dir2_leaf_addname(
                          * lowstale entry would be better.
                          */
                         for (highstale = index;
-                             highstale < INT_GET(leaf->hdr.count, ARCH_CONVERT) &&
+                             highstale < be16_to_cpu(leaf->hdr.count) &&
                                 INT_GET(leaf->ents[highstale].address, ARCH_CONVERT) !=
                                 XFS_DIR2_NULL_DATAPTR &&
                                 (lowstale < 0 ||
@@ -490,7 +490,7 @@ xfs_dir2_leaf_addname(
                  * If the low one is better, use it.
                  */
                 if (lowstale >= 0 &&
-                    (highstale == INT_GET(leaf->hdr.count, ARCH_CONVERT) ||
+                    (highstale == be16_to_cpu(leaf->hdr.count) ||
                      index - lowstale - 1 < highstale - index)) {
                         ASSERT(index - lowstale - 1 >= 0);
                         ASSERT(INT_GET(leaf->ents[lowstale].address, ARCH_CONVERT) ==
@@ -526,7 +526,7 @@ xfs_dir2_leaf_addname(
                         lfloglow = MIN(index, lfloglow);
                         lfloghigh = MAX(highstale, lfloghigh);
                 }
-                INT_MOD(leaf->hdr.stale, ARCH_CONVERT, -1);
+                be16_add(&leaf->hdr.stale, -1);
         }
         /*
          * Fill in the new leaf entry.
@@ -569,24 +569,24 @@ xfs_dir2_leaf_check(
          * Should factor in the size of the bests table as well.
          * We can deduce a value for that from di_size.
          */
-        ASSERT(INT_GET(leaf->hdr.count, ARCH_CONVERT) <= XFS_DIR2_MAX_LEAF_ENTS(mp));
+        ASSERT(be16_to_cpu(leaf->hdr.count) <= XFS_DIR2_MAX_LEAF_ENTS(mp));
         ltp = XFS_DIR2_LEAF_TAIL_P(mp, leaf);
         /*
          * Leaves and bests don't overlap.
          */
-        ASSERT((char *)&leaf->ents[INT_GET(leaf->hdr.count, ARCH_CONVERT)] <=
+        ASSERT((char *)&leaf->ents[be16_to_cpu(leaf->hdr.count)] <=
                (char *)XFS_DIR2_LEAF_BESTS_P(ltp));
         /*
          * Check hash value order, count stale entries.
          */
-        for (i = stale = 0; i < INT_GET(leaf->hdr.count, ARCH_CONVERT); i++) {
-                if (i + 1 < INT_GET(leaf->hdr.count, ARCH_CONVERT))
+        for (i = stale = 0; i < be16_to_cpu(leaf->hdr.count); i++) {
+                if (i + 1 < be16_to_cpu(leaf->hdr.count))
                         ASSERT(INT_GET(leaf->ents[i].hashval, ARCH_CONVERT) <=
                                INT_GET(leaf->ents[i + 1].hashval, ARCH_CONVERT));
                 if (INT_GET(leaf->ents[i].address, ARCH_CONVERT) == XFS_DIR2_NULL_DATAPTR)
                         stale++;
         }
-        ASSERT(INT_GET(leaf->hdr.stale, ARCH_CONVERT) == stale);
+        ASSERT(be16_to_cpu(leaf->hdr.stale) == stale);
 }
 #endif  /* DEBUG */
 
@@ -611,7 +611,7 @@ xfs_dir2_leaf_compact(
         /*
          * Compress out the stale entries in place.
          */
-        for (from = to = 0, loglow = -1; from < INT_GET(leaf->hdr.count, ARCH_CONVERT); from++) {
+        for (from = to = 0, loglow = -1; from < be16_to_cpu(leaf->hdr.count); from++) {
                 if (INT_GET(leaf->ents[from].address, ARCH_CONVERT) == XFS_DIR2_NULL_DATAPTR)
                         continue;
                 /*
@@ -627,8 +627,8 @@ xfs_dir2_leaf_compact(
         /*
          * Update and log the header, log the leaf entries.
          */
-        ASSERT(INT_GET(leaf->hdr.stale, ARCH_CONVERT) == from - to);
-        INT_MOD(leaf->hdr.count, ARCH_CONVERT, -(INT_GET(leaf->hdr.stale, ARCH_CONVERT)));
+        ASSERT(be16_to_cpu(leaf->hdr.stale) == from - to);
+        be16_add(&leaf->hdr.count, -(be16_to_cpu(leaf->hdr.stale)));
         leaf->hdr.stale = 0;
         xfs_dir2_leaf_log_header(args->trans, bp);
         if (loglow != -1)
@@ -662,7 +662,7 @@ xfs_dir2_leaf_compact_x1(
         int             to;             /* destination copy index */
 
         leaf = bp->data;
-        ASSERT(INT_GET(leaf->hdr.stale, ARCH_CONVERT) > 1);
+        ASSERT(be16_to_cpu(leaf->hdr.stale) > 1);
         index = *indexp;
         /*
          * Find the first stale entry before our index, if any.
@@ -677,7 +677,7 @@ xfs_dir2_leaf_compact_x1(
          * Stop if the answer would be worse than lowstale.
          */
         for (highstale = index;
-             highstale < INT_GET(leaf->hdr.count, ARCH_CONVERT) &&
+             highstale < be16_to_cpu(leaf->hdr.count) &&
                 INT_GET(leaf->ents[highstale].address, ARCH_CONVERT) != XFS_DIR2_NULL_DATAPTR &&
                 (lowstale < 0 || index - lowstale > highstale - index);
              highstale++)
@@ -686,7 +686,7 @@ xfs_dir2_leaf_compact_x1(
          * Pick the better of lowstale and highstale.
          */
         if (lowstale >= 0 &&
-            (highstale == INT_GET(leaf->hdr.count, ARCH_CONVERT) ||
+            (highstale == be16_to_cpu(leaf->hdr.count) ||
              index - lowstale <= highstale - index))
                 keepstale = lowstale;
         else
@@ -695,7 +695,7 @@ xfs_dir2_leaf_compact_x1(
          * Copy the entries in place, removing all the stale entries
          * except keepstale.
          */
-        for (from = to = 0; from < INT_GET(leaf->hdr.count, ARCH_CONVERT); from++) {
+        for (from = to = 0; from < be16_to_cpu(leaf->hdr.count); from++) {
                 /*
                  * Notice the new value of index.
                  */
@@ -730,8 +730,8 @@ xfs_dir2_leaf_compact_x1(
         /*
          * Adjust the leaf header values.
          */
-        INT_MOD(leaf->hdr.count, ARCH_CONVERT, -(from - to));
-        INT_SET(leaf->hdr.stale, ARCH_CONVERT, 1);
+        be16_add(&leaf->hdr.count, -(from - to));
+        leaf->hdr.stale = cpu_to_be16(1);
         /*
          * Remember the low/high stale value only in the "right"
          * direction.
@@ -739,8 +739,8 @@ xfs_dir2_leaf_compact_x1(
         if (lowstale >= newindex)
                 lowstale = -1;
         else
-                highstale = INT_GET(leaf->hdr.count, ARCH_CONVERT);
-        *highlogp = INT_GET(leaf->hdr.count, ARCH_CONVERT) - 1;
+                highstale = be16_to_cpu(leaf->hdr.count);
+        *highlogp = be16_to_cpu(leaf->hdr.count) - 1;
         *lowstalep = lowstale;
         *highstalep = highstale;
 }
@@ -1373,7 +1373,7 @@ xfs_dir2_leaf_lookup_int(
          * looking to match the name.
          */
         for (lep = &leaf->ents[index], dbp = NULL, curdb = -1;
-             index < INT_GET(leaf->hdr.count, ARCH_CONVERT) && INT_GET(lep->hashval, ARCH_CONVERT) == args->hashval;
+             index < be16_to_cpu(leaf->hdr.count) && INT_GET(lep->hashval, ARCH_CONVERT) == args->hashval;
              lep++, index++) {
                 /*
                  * Skip over stale leaf entries.
@@ -1488,7 +1488,7 @@ xfs_dir2_leaf_removename(
         /*
          * We just mark the leaf entry stale by putting a null in it.
          */
-        INT_MOD(leaf->hdr.stale, ARCH_CONVERT, +1);
+        be16_add(&leaf->hdr.stale, 1);
         xfs_dir2_leaf_log_header(tp, lbp);
         INT_SET(lep->address, ARCH_CONVERT, XFS_DIR2_NULL_DATAPTR);
         xfs_dir2_leaf_log_ents(tp, lbp, index, index);
@@ -1645,7 +1645,7 @@ xfs_dir2_leaf_search_hash(
          * Note, the table cannot be empty, so we have to go through the loop.
          * Binary search the leaf entries looking for our hash value.
          */
-        for (lep = leaf->ents, low = 0, high = INT_GET(leaf->hdr.count, ARCH_CONVERT) - 1,
+        for (lep = leaf->ents, low = 0, high = be16_to_cpu(leaf->hdr.count) - 1,
                 hashwant = args->hashval;
              low <= high; ) {
                 mid = (low + high) >> 1;
@@ -1821,7 +1821,7 @@ xfs_dir2_node_to_leaf(
          * If not, release the buffer and give up.
          */
         if ((uint)sizeof(leaf->hdr) +
-            (INT_GET(leaf->hdr.count, ARCH_CONVERT) - INT_GET(leaf->hdr.stale, ARCH_CONVERT)) * (uint)sizeof(leaf->ents[0]) +
+            (be16_to_cpu(leaf->hdr.count) - be16_to_cpu(leaf->hdr.stale)) * (uint)sizeof(leaf->ents[0]) +
             be32_to_cpu(free->hdr.nvalid) * (uint)sizeof(leaf->bests[0]) +
             (uint)sizeof(leaf->tail) >
             mp->m_dirblksize) {
@@ -1832,7 +1832,7 @@ xfs_dir2_node_to_leaf(
          * If the leaf has any stale entries in it, compress them out.
          * The compact routine will log the header.
          */
-        if (INT_GET(leaf->hdr.stale, ARCH_CONVERT))
+        if (be16_to_cpu(leaf->hdr.stale))
                 xfs_dir2_leaf_compact(args, lbp);
         else
                 xfs_dir2_leaf_log_header(tp, lbp);
diff --git a/fs/xfs/xfs_dir2_leaf.h b/fs/xfs/xfs_dir2_leaf.h
index fcd3b7dea0f6..a1db51b845b9 100644
--- a/fs/xfs/xfs_dir2_leaf.h
+++ b/fs/xfs/xfs_dir2_leaf.h
@@ -46,8 +46,8 @@ typedef	__uint32_t	xfs_dir2_dataptr_t;
  */
 typedef struct xfs_dir2_leaf_hdr {
         xfs_da_blkinfo_t        info;           /* header for da routines */
-        __uint16_t              count;          /* count of entries */
-        __uint16_t              stale;          /* count of stale entries */
+        __be16                  count;          /* count of entries */
+        __be16                  stale;          /* count of stale entries */
 } xfs_dir2_leaf_hdr_t;
 
 /*
diff --git a/fs/xfs/xfs_dir2_node.c b/fs/xfs/xfs_dir2_node.c
index c32894cb6223..40e4a2e27765 100644
--- a/fs/xfs/xfs_dir2_node.c
+++ b/fs/xfs/xfs_dir2_node.c
@@ -217,14 +217,14 @@ xfs_dir2_leafn_add(
          * a compact.
          */
 
-        if (INT_GET(leaf->hdr.count, ARCH_CONVERT) == XFS_DIR2_MAX_LEAF_ENTS(mp)) {
+        if (be16_to_cpu(leaf->hdr.count) == XFS_DIR2_MAX_LEAF_ENTS(mp)) {
                 if (!leaf->hdr.stale)
                         return XFS_ERROR(ENOSPC);
-                compact = INT_GET(leaf->hdr.stale, ARCH_CONVERT) > 1;
+                compact = be16_to_cpu(leaf->hdr.stale) > 1;
         } else
                 compact = 0;
         ASSERT(index == 0 || INT_GET(leaf->ents[index - 1].hashval, ARCH_CONVERT) <= args->hashval);
-        ASSERT(index == INT_GET(leaf->hdr.count, ARCH_CONVERT) ||
+        ASSERT(index == be16_to_cpu(leaf->hdr.count) ||
                INT_GET(leaf->ents[index].hashval, ARCH_CONVERT) >= args->hashval);
 
         if (args->justcheck)
@@ -242,7 +242,7 @@ xfs_dir2_leafn_add(
          * Set impossible logging indices for this case.
          */
         else if (leaf->hdr.stale) {
-                lfloglow = INT_GET(leaf->hdr.count, ARCH_CONVERT);
+                lfloglow = be16_to_cpu(leaf->hdr.count);
                 lfloghigh = -1;
         }
         /*
@@ -250,12 +250,12 @@ xfs_dir2_leafn_add(
          */
         if (!leaf->hdr.stale) {
                 lep = &leaf->ents[index];
-                if (index < INT_GET(leaf->hdr.count, ARCH_CONVERT))
+                if (index < be16_to_cpu(leaf->hdr.count))
                         memmove(lep + 1, lep,
-                                (INT_GET(leaf->hdr.count, ARCH_CONVERT) - index) * sizeof(*lep));
+                                (be16_to_cpu(leaf->hdr.count) - index) * sizeof(*lep));
                 lfloglow = index;
-                lfloghigh = INT_GET(leaf->hdr.count, ARCH_CONVERT);
-                INT_MOD(leaf->hdr.count, ARCH_CONVERT, +1);
+                lfloghigh = be16_to_cpu(leaf->hdr.count);
+                be16_add(&leaf->hdr.count, 1);
         }
         /*
          * There are stale entries.  We'll use one for the new entry.
@@ -281,7 +281,7 @@ xfs_dir2_leafn_add(
                          * lowstale already found.
                          */
                         for (highstale = index;
-                             highstale < INT_GET(leaf->hdr.count, ARCH_CONVERT) &&
+                             highstale < be16_to_cpu(leaf->hdr.count) &&
                                 INT_GET(leaf->ents[highstale].address, ARCH_CONVERT) !=
                                 XFS_DIR2_NULL_DATAPTR &&
                                 (lowstale < 0 ||
@@ -294,7 +294,7 @@ xfs_dir2_leafn_add(
                  * Shift entries up toward the stale slot.
                  */
                 if (lowstale >= 0 &&
-                    (highstale == INT_GET(leaf->hdr.count, ARCH_CONVERT) ||
+                    (highstale == be16_to_cpu(leaf->hdr.count) ||
                      index - lowstale - 1 < highstale - index)) {
                         ASSERT(INT_GET(leaf->ents[lowstale].address, ARCH_CONVERT) ==
                                XFS_DIR2_NULL_DATAPTR);
@@ -323,7 +323,7 @@ xfs_dir2_leafn_add(
                         lfloglow = MIN(index, lfloglow);
                         lfloghigh = MAX(highstale, lfloghigh);
                 }
-                INT_MOD(leaf->hdr.stale, ARCH_CONVERT, -1);
+                be16_add(&leaf->hdr.stale, -1);
         }
         /*
          * Insert the new entry, log everything.
@@ -353,16 +353,16 @@ xfs_dir2_leafn_check(
         leaf = bp->data;
         mp = dp->i_mount;
         ASSERT(INT_GET(leaf->hdr.info.magic, ARCH_CONVERT) == XFS_DIR2_LEAFN_MAGIC);
-        ASSERT(INT_GET(leaf->hdr.count, ARCH_CONVERT) <= XFS_DIR2_MAX_LEAF_ENTS(mp));
-        for (i = stale = 0; i < INT_GET(leaf->hdr.count, ARCH_CONVERT); i++) {
-                if (i + 1 < INT_GET(leaf->hdr.count, ARCH_CONVERT)) {
+        ASSERT(be16_to_cpu(leaf->hdr.count) <= XFS_DIR2_MAX_LEAF_ENTS(mp));
+        for (i = stale = 0; i < be16_to_cpu(leaf->hdr.count); i++) {
+                if (i + 1 < be16_to_cpu(leaf->hdr.count)) {
                         ASSERT(INT_GET(leaf->ents[i].hashval, ARCH_CONVERT) <=
                                INT_GET(leaf->ents[i + 1].hashval, ARCH_CONVERT));
                 }
                 if (INT_GET(leaf->ents[i].address, ARCH_CONVERT) == XFS_DIR2_NULL_DATAPTR)
                         stale++;
         }
-        ASSERT(INT_GET(leaf->hdr.stale, ARCH_CONVERT) == stale);
+        ASSERT(be16_to_cpu(leaf->hdr.stale) == stale);
 }
 #endif  /* DEBUG */
 
@@ -380,10 +380,10 @@ xfs_dir2_leafn_lasthash(
         leaf = bp->data;
         ASSERT(INT_GET(leaf->hdr.info.magic, ARCH_CONVERT) == XFS_DIR2_LEAFN_MAGIC);
         if (count)
-                *count = INT_GET(leaf->hdr.count, ARCH_CONVERT);
+                *count = be16_to_cpu(leaf->hdr.count);
         if (!leaf->hdr.count)
                 return 0;
-        return INT_GET(leaf->ents[INT_GET(leaf->hdr.count, ARCH_CONVERT) - 1].hashval, ARCH_CONVERT);
+        return INT_GET(leaf->ents[be16_to_cpu(leaf->hdr.count) - 1].hashval, ARCH_CONVERT);
 }
 
 /*
@@ -421,7 +421,7 @@ xfs_dir2_leafn_lookup_int(
         leaf = bp->data;
         ASSERT(INT_GET(leaf->hdr.info.magic, ARCH_CONVERT) == XFS_DIR2_LEAFN_MAGIC);
 #ifdef __KERNEL__
-        ASSERT(INT_GET(leaf->hdr.count, ARCH_CONVERT) > 0);
+        ASSERT(be16_to_cpu(leaf->hdr.count) > 0);
 #endif
         xfs_dir2_leafn_check(dp, bp);
         /*
@@ -456,7 +456,7 @@ xfs_dir2_leafn_lookup_int(
          * Loop over leaf entries with the right hash value.
          */
         for (lep = &leaf->ents[index];
-             index < INT_GET(leaf->hdr.count, ARCH_CONVERT) && INT_GET(lep->hashval, ARCH_CONVERT) == args->hashval;
+             index < be16_to_cpu(leaf->hdr.count) && INT_GET(lep->hashval, ARCH_CONVERT) == args->hashval;
              lep++, index++) {
                 /*
                  * Skip stale leaf entries.
@@ -619,7 +619,7 @@ xfs_dir2_leafn_lookup_int(
          * Return the final index, that will be the insertion point.
          */
         *indexp = index;
-        ASSERT(index == INT_GET(leaf->hdr.count, ARCH_CONVERT) || args->oknoent);
+        ASSERT(index == be16_to_cpu(leaf->hdr.count) || args->oknoent);
         return XFS_ERROR(ENOENT);
 }
 
@@ -657,12 +657,12 @@ xfs_dir2_leafn_moveents(
          * destination leaf entries, open up a hole in the destination
          * to hold the new entries.
          */
-        if (start_d < INT_GET(leaf_d->hdr.count, ARCH_CONVERT)) {
+        if (start_d < be16_to_cpu(leaf_d->hdr.count)) {
                 memmove(&leaf_d->ents[start_d + count], &leaf_d->ents[start_d],
-                        (INT_GET(leaf_d->hdr.count, ARCH_CONVERT) - start_d) *
+                        (be16_to_cpu(leaf_d->hdr.count) - start_d) *
                         sizeof(xfs_dir2_leaf_entry_t));
                 xfs_dir2_leaf_log_ents(tp, bp_d, start_d + count,
-                        count + INT_GET(leaf_d->hdr.count, ARCH_CONVERT) - 1);
+                        count + be16_to_cpu(leaf_d->hdr.count) - 1);
         }
         /*
          * If the source has stale leaves, count the ones in the copy range
@@ -687,7 +687,7 @@ xfs_dir2_leafn_moveents(
          * If there are source entries after the ones we copied,
          * delete the ones we copied by sliding the next ones down.
          */
-        if (start_s + count < INT_GET(leaf_s->hdr.count, ARCH_CONVERT)) {
+        if (start_s + count < be16_to_cpu(leaf_s->hdr.count)) {
                 memmove(&leaf_s->ents[start_s], &leaf_s->ents[start_s + count],
                         count * sizeof(xfs_dir2_leaf_entry_t));
                 xfs_dir2_leaf_log_ents(tp, bp_s, start_s, start_s + count - 1);
@@ -695,10 +695,10 @@ xfs_dir2_leafn_moveents(
         /*
          * Update the headers and log them.
          */
-        INT_MOD(leaf_s->hdr.count, ARCH_CONVERT, -(count));
-        INT_MOD(leaf_s->hdr.stale, ARCH_CONVERT, -(stale));
-        INT_MOD(leaf_d->hdr.count, ARCH_CONVERT, count);
-        INT_MOD(leaf_d->hdr.stale, ARCH_CONVERT, stale);
+        be16_add(&leaf_s->hdr.count, -(count));
+        be16_add(&leaf_s->hdr.stale, -(stale));
+        be16_add(&leaf_d->hdr.count, count);
+        be16_add(&leaf_d->hdr.stale, stale);
         xfs_dir2_leaf_log_header(tp, bp_s);
         xfs_dir2_leaf_log_header(tp, bp_d);
         xfs_dir2_leafn_check(args->dp, bp_s);
@@ -721,11 +721,11 @@ xfs_dir2_leafn_order(
         leaf2 = leaf2_bp->data;
         ASSERT(INT_GET(leaf1->hdr.info.magic, ARCH_CONVERT) == XFS_DIR2_LEAFN_MAGIC);
         ASSERT(INT_GET(leaf2->hdr.info.magic, ARCH_CONVERT) == XFS_DIR2_LEAFN_MAGIC);
-        if (INT_GET(leaf1->hdr.count, ARCH_CONVERT) > 0 &&
-            INT_GET(leaf2->hdr.count, ARCH_CONVERT) > 0 &&
+        if (be16_to_cpu(leaf1->hdr.count) > 0 &&
+            be16_to_cpu(leaf2->hdr.count) > 0 &&
             (INT_GET(leaf2->ents[0].hashval, ARCH_CONVERT) < INT_GET(leaf1->ents[0].hashval, ARCH_CONVERT) ||
-             INT_GET(leaf2->ents[INT_GET(leaf2->hdr.count, ARCH_CONVERT) - 1].hashval, ARCH_CONVERT) <
-             INT_GET(leaf1->ents[INT_GET(leaf1->hdr.count, ARCH_CONVERT) - 1].hashval, ARCH_CONVERT)))
+             INT_GET(leaf2->ents[be16_to_cpu(leaf2->hdr.count) - 1].hashval, ARCH_CONVERT) <
+             INT_GET(leaf1->ents[be16_to_cpu(leaf1->hdr.count) - 1].hashval, ARCH_CONVERT)))
                 return 1;
         return 0;
 }
@@ -768,9 +768,9 @@ xfs_dir2_leafn_rebalance(
         }
         leaf1 = blk1->bp->data;
         leaf2 = blk2->bp->data;
-        oldsum = INT_GET(leaf1->hdr.count, ARCH_CONVERT) + INT_GET(leaf2->hdr.count, ARCH_CONVERT);
+        oldsum = be16_to_cpu(leaf1->hdr.count) + be16_to_cpu(leaf2->hdr.count);
 #ifdef DEBUG
-        oldstale = INT_GET(leaf1->hdr.stale, ARCH_CONVERT) + INT_GET(leaf2->hdr.stale, ARCH_CONVERT);
+        oldstale = be16_to_cpu(leaf1->hdr.stale) + be16_to_cpu(leaf2->hdr.stale);
 #endif
         mid = oldsum >> 1;
         /*
@@ -780,8 +780,8 @@ xfs_dir2_leafn_rebalance(
         if (oldsum & 1) {
                 xfs_dahash_t    midhash;        /* middle entry hash value */
 
-                if (mid >= INT_GET(leaf1->hdr.count, ARCH_CONVERT))
-                        midhash = INT_GET(leaf2->ents[mid - INT_GET(leaf1->hdr.count, ARCH_CONVERT)].hashval, ARCH_CONVERT);
+                if (mid >= be16_to_cpu(leaf1->hdr.count))
+                        midhash = INT_GET(leaf2->ents[mid - be16_to_cpu(leaf1->hdr.count)].hashval, ARCH_CONVERT);
                 else
                         midhash = INT_GET(leaf1->ents[mid].hashval, ARCH_CONVERT);
                 isleft = args->hashval <= midhash;
@@ -797,30 +797,30 @@ xfs_dir2_leafn_rebalance(
          * Calculate moved entry count.  Positive means left-to-right,
          * negative means right-to-left.  Then move the entries.
          */
-        count = INT_GET(leaf1->hdr.count, ARCH_CONVERT) - mid + (isleft == 0);
+        count = be16_to_cpu(leaf1->hdr.count) - mid + (isleft == 0);
         if (count > 0)
                 xfs_dir2_leafn_moveents(args, blk1->bp,
-                        INT_GET(leaf1->hdr.count, ARCH_CONVERT) - count, blk2->bp, 0, count);
+                        be16_to_cpu(leaf1->hdr.count) - count, blk2->bp, 0, count);
         else if (count < 0)
                 xfs_dir2_leafn_moveents(args, blk2->bp, 0, blk1->bp,
-                        INT_GET(leaf1->hdr.count, ARCH_CONVERT), count);
-        ASSERT(INT_GET(leaf1->hdr.count, ARCH_CONVERT) + INT_GET(leaf2->hdr.count, ARCH_CONVERT) == oldsum);
-        ASSERT(INT_GET(leaf1->hdr.stale, ARCH_CONVERT) + INT_GET(leaf2->hdr.stale, ARCH_CONVERT) == oldstale);
+                        be16_to_cpu(leaf1->hdr.count), count);
+        ASSERT(be16_to_cpu(leaf1->hdr.count) + be16_to_cpu(leaf2->hdr.count) == oldsum);
+        ASSERT(be16_to_cpu(leaf1->hdr.stale) + be16_to_cpu(leaf2->hdr.stale) == oldstale);
         /*
          * Mark whether we're inserting into the old or new leaf.
          */
-        if (INT_GET(leaf1->hdr.count, ARCH_CONVERT) < INT_GET(leaf2->hdr.count, ARCH_CONVERT))
+        if (be16_to_cpu(leaf1->hdr.count) < be16_to_cpu(leaf2->hdr.count))
                 state->inleaf = swap;
-        else if (INT_GET(leaf1->hdr.count, ARCH_CONVERT) > INT_GET(leaf2->hdr.count, ARCH_CONVERT))
+        else if (be16_to_cpu(leaf1->hdr.count) > be16_to_cpu(leaf2->hdr.count))
                 state->inleaf = !swap;
         else
                 state->inleaf =
-                        swap ^ (blk1->index <= INT_GET(leaf1->hdr.count, ARCH_CONVERT));
+                        swap ^ (blk1->index <= be16_to_cpu(leaf1->hdr.count));
         /*
          * Adjust the expected index for insertion.
          */
         if (!state->inleaf)
-                blk2->index = blk1->index - INT_GET(leaf1->hdr.count, ARCH_CONVERT);
+                blk2->index = blk1->index - be16_to_cpu(leaf1->hdr.count);
         
         /* 
          * Finally sanity check just to make sure we are not returning a negative index 
@@ -883,7 +883,7 @@ xfs_dir2_leafn_remove(
          * Kill the leaf entry by marking it stale.
          * Log the leaf block changes.
          */
-        INT_MOD(leaf->hdr.stale, ARCH_CONVERT, +1);
+        be16_add(&leaf->hdr.stale, 1);
         xfs_dir2_leaf_log_header(tp, bp);
         INT_SET(lep->address, ARCH_CONVERT, XFS_DIR2_NULL_DATAPTR);
         xfs_dir2_leaf_log_ents(tp, bp, index, index);
@@ -1039,7 +1039,7 @@ xfs_dir2_leafn_remove(
         *rval =
                 ((uint)sizeof(leaf->hdr) +
                  (uint)sizeof(leaf->ents[0]) *
-                 (INT_GET(leaf->hdr.count, ARCH_CONVERT) - INT_GET(leaf->hdr.stale, ARCH_CONVERT))) <
+                 (be16_to_cpu(leaf->hdr.count) - be16_to_cpu(leaf->hdr.stale))) <
                 mp->m_dir_magicpct;
         return 0;
 }
@@ -1140,7 +1140,7 @@ xfs_dir2_leafn_toosmall(
         info = blk->bp->data;
         ASSERT(INT_GET(info->magic, ARCH_CONVERT) == XFS_DIR2_LEAFN_MAGIC);
         leaf = (xfs_dir2_leaf_t *)info;
-        count = INT_GET(leaf->hdr.count, ARCH_CONVERT) - INT_GET(leaf->hdr.stale, ARCH_CONVERT);
+        count = be16_to_cpu(leaf->hdr.count) - be16_to_cpu(leaf->hdr.stale);
         bytes = (uint)sizeof(leaf->hdr) + count * (uint)sizeof(leaf->ents[0]);
         if (bytes > (state->blocksize >> 1)) {
                 /*
@@ -1194,11 +1194,11 @@ xfs_dir2_leafn_toosmall(
                  * Count bytes in the two blocks combined.
                  */
                 leaf = (xfs_dir2_leaf_t *)info;
-                count = INT_GET(leaf->hdr.count, ARCH_CONVERT) - INT_GET(leaf->hdr.stale, ARCH_CONVERT);
+                count = be16_to_cpu(leaf->hdr.count) - be16_to_cpu(leaf->hdr.stale);
                 bytes = state->blocksize - (state->blocksize >> 2);
                 leaf = bp->data;
                 ASSERT(INT_GET(leaf->hdr.info.magic, ARCH_CONVERT) == XFS_DIR2_LEAFN_MAGIC);
-                count += INT_GET(leaf->hdr.count, ARCH_CONVERT) - INT_GET(leaf->hdr.stale, ARCH_CONVERT);
+                count += be16_to_cpu(leaf->hdr.count) - be16_to_cpu(leaf->hdr.stale);
                 bytes -= count * (uint)sizeof(leaf->ents[0]);
                 /*
                  * Fits with at least 25% to spare.
@@ -1262,21 +1262,21 @@ xfs_dir2_leafn_unbalance(
          * If there are any stale leaf entries, take this opportunity
          * to purge them.
          */
-        if (INT_GET(drop_leaf->hdr.stale, ARCH_CONVERT))
+        if (drop_leaf->hdr.stale)
                 xfs_dir2_leaf_compact(args, drop_blk->bp);
-        if (INT_GET(save_leaf->hdr.stale, ARCH_CONVERT))
+        if (save_leaf->hdr.stale)
                 xfs_dir2_leaf_compact(args, save_blk->bp);
         /*
          * Move the entries from drop to the appropriate end of save.
          */
-        drop_blk->hashval = INT_GET(drop_leaf->ents[INT_GET(drop_leaf->hdr.count, ARCH_CONVERT) - 1].hashval, ARCH_CONVERT);
+        drop_blk->hashval = INT_GET(drop_leaf->ents[be16_to_cpu(drop_leaf->hdr.count) - 1].hashval, ARCH_CONVERT);
         if (xfs_dir2_leafn_order(save_blk->bp, drop_blk->bp))
                 xfs_dir2_leafn_moveents(args, drop_blk->bp, 0, save_blk->bp, 0,
-                        INT_GET(drop_leaf->hdr.count, ARCH_CONVERT));
+                        be16_to_cpu(drop_leaf->hdr.count));
         else
                 xfs_dir2_leafn_moveents(args, drop_blk->bp, 0, save_blk->bp,
-                        INT_GET(save_leaf->hdr.count, ARCH_CONVERT), INT_GET(drop_leaf->hdr.count, ARCH_CONVERT));
-        save_blk->hashval = INT_GET(save_leaf->ents[INT_GET(save_leaf->hdr.count, ARCH_CONVERT) - 1].hashval, ARCH_CONVERT);
+                        be16_to_cpu(save_leaf->hdr.count), be16_to_cpu(drop_leaf->hdr.count));
+        save_blk->hashval = INT_GET(save_leaf->ents[be16_to_cpu(save_leaf->hdr.count) - 1].hashval, ARCH_CONVERT);
         xfs_dir2_leafn_check(args->dp, save_blk->bp);
 }