[XFS] endianess annotations for xfs_attr_leaf_entry_t

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

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

diff --git a/fs/xfs/xfs_attr.c b/fs/xfs/xfs_attr.c
index 4a3f3cf6b20c523255d6ff81cb94457178af54f0..98d0f4d10602fbe79a6cd75acf4d1cf5b4639681 100644 (file)
--- a/fs/xfs/xfs_attr.c
+++ b/fs/xfs/xfs_attr.c
@@ -1770,17 +1770,14 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
                                break;
                        case XFS_ATTR_LEAF_MAGIC:
                                leaf = bp->data;
-                               if (cursor->hashval >
-                                   INT_GET(leaf->entries[
-                                       be16_to_cpu(leaf->hdr.count)-1].hashval,
-                                                       ARCH_CONVERT)) {
+                               if (cursor->hashval > be32_to_cpu(leaf->entries[
+                                   be16_to_cpu(leaf->hdr.count)-1].hashval)) {
                                        xfs_attr_trace_l_cl("wrong blk",
                                                           context, leaf);
                                        xfs_da_brelse(NULL, bp);
                                        bp = NULL;
                                } else if (cursor->hashval <=
-                                            INT_GET(leaf->entries[0].hashval,
-                                                       ARCH_CONVERT)) {
+                                            be32_to_cpu(leaf->entries[0].hashval)) {
                                        xfs_attr_trace_l_cl("maybe wrong blk",
                                                           context, leaf);
                                        xfs_da_brelse(NULL, bp);
@@ -2289,8 +2286,9 @@ xfs_attr_trace_l_cl(char *where, struct xfs_attr_list_context *context,
                (__psunsigned_t)context->dupcnt,
                (__psunsigned_t)context->flags,
                (__psunsigned_t)be16_to_cpu(leaf->hdr.count),
-               (__psunsigned_t)INT_GET(leaf->entries[0].hashval, ARCH_CONVERT),
-               (__psunsigned_t)INT_GET(leaf->entries[be16_to_cpu(leaf->hdr.count)-1].hashval, ARCH_CONVERT));
+               (__psunsigned_t)be32_to_cpu(leaf->entries[0].hashval),
+               (__psunsigned_t)be32_to_cpu(leaf->entries[
+                               be16_to_cpu(leaf->hdr.count)-1].hashval));
 }
 
 /*

diff --git a/fs/xfs/xfs_attr_leaf.c b/fs/xfs/xfs_attr_leaf.c
index 31b55e58e2cf71a4e02a622091382565b4104048..319285c24e4207686281a93b03fd164b5ae2cab7 100644 (file)
--- a/fs/xfs/xfs_attr_leaf.c
+++ b/fs/xfs/xfs_attr_leaf.c
@@ -819,7 +819,7 @@ xfs_attr_leaf_to_shortform(xfs_dabuf_t *bp, xfs_da_args_t *args, int forkoff)
                nargs.namelen = name_loc->namelen;
                nargs.value = (char *)&name_loc->nameval[nargs.namelen];
                nargs.valuelen = INT_GET(name_loc->valuelen, ARCH_CONVERT);
-               nargs.hashval = INT_GET(entry->hashval, ARCH_CONVERT);
+               nargs.hashval = be32_to_cpu(entry->hashval);
                nargs.flags = (entry->flags & XFS_ATTR_SECURE) ? ATTR_SECURE :
                              ((entry->flags & XFS_ATTR_ROOT) ? ATTR_ROOT : 0);
                xfs_attr_shortform_add(&nargs, forkoff);
@@ -1104,10 +1104,9 @@ xfs_attr_leaf_add_work(xfs_dabuf_t *bp, xfs_da_args_t *args, int mapindex)
        be16_add(&map->size,
                -xfs_attr_leaf_newentsize(args->namelen, args->valuelen,
                                          mp->m_sb.sb_blocksize, &tmp));
-       INT_SET(entry->nameidx, ARCH_CONVERT,
-                                       be16_to_cpu(map->base)
-                                     + be16_to_cpu(map->size));
-       INT_SET(entry->hashval, ARCH_CONVERT, args->hashval);
+       entry->nameidx = cpu_to_be16(be16_to_cpu(map->base) +
+                                    be16_to_cpu(map->size));
+       entry->hashval = cpu_to_be32(args->hashval);
        entry->flags = tmp ? XFS_ATTR_LOCAL : 0;
        entry->flags |= (args->flags & ATTR_SECURE) ? XFS_ATTR_SECURE :
                        ((args->flags & ATTR_ROOT) ? XFS_ATTR_ROOT : 0);
@@ -1120,12 +1119,10 @@ xfs_attr_leaf_add_work(xfs_dabuf_t *bp, xfs_da_args_t *args, int mapindex)
        }
        xfs_da_log_buf(args->trans, bp,
                          XFS_DA_LOGRANGE(leaf, entry, sizeof(*entry)));
-       ASSERT((args->index == 0) || (INT_GET(entry->hashval, ARCH_CONVERT)
-                                               >= INT_GET((entry-1)->hashval,
-                                                           ARCH_CONVERT)));
+       ASSERT((args->index == 0) ||
+              (be32_to_cpu(entry->hashval) >= be32_to_cpu((entry-1)->hashval)));
        ASSERT((args->index == be16_to_cpu(hdr->count)-1) ||
-              (INT_GET(entry->hashval, ARCH_CONVERT)
-                           <= (INT_GET((entry+1)->hashval, ARCH_CONVERT))));
+              (be32_to_cpu(entry->hashval) <= be32_to_cpu((entry+1)->hashval)));
 
        /*
         * Copy the attribute name and value into the new space.
@@ -1161,8 +1158,7 @@ xfs_attr_leaf_add_work(xfs_dabuf_t *bp, xfs_da_args_t *args, int mapindex)
        /*
         * Update the control info for this leaf node
         */
-       if (INT_GET(entry->nameidx, ARCH_CONVERT)
-                               < be16_to_cpu(hdr->firstused)) {
+       if (be16_to_cpu(entry->nameidx) < be16_to_cpu(hdr->firstused)) {
                /* both on-disk, don't endian-flip twice */
                hdr->firstused = entry->nameidx;
        }
@@ -1364,12 +1360,10 @@ xfs_attr_leaf_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
        /*
         * Copy out last hashval in each block for B-tree code.
         */
-       blk1->hashval =
-           INT_GET(leaf1->entries[be16_to_cpu(leaf1->hdr.count)-1].hashval,
-                           ARCH_CONVERT);
-       blk2->hashval =
-           INT_GET(leaf2->entries[be16_to_cpu(leaf2->hdr.count)-1].hashval,
-                           ARCH_CONVERT);
+       blk1->hashval = be32_to_cpu(
+               leaf1->entries[be16_to_cpu(leaf1->hdr.count)-1].hashval);
+       blk2->hashval = be32_to_cpu(
+               leaf2->entries[be16_to_cpu(leaf2->hdr.count)-1].hashval);
 
        /*
         * Adjust the expected index for insertion.
@@ -1668,9 +1662,8 @@ xfs_attr_leaf_remove(xfs_dabuf_t *bp, xfs_da_args_t *args)
        ASSERT(be16_to_cpu(hdr->firstused) >=
               ((be16_to_cpu(hdr->count) * sizeof(*entry)) + sizeof(*hdr)));
        entry = &leaf->entries[args->index];
-       ASSERT(INT_GET(entry->nameidx, ARCH_CONVERT)
-                               >= be16_to_cpu(hdr->firstused));
-       ASSERT(INT_GET(entry->nameidx, ARCH_CONVERT) < XFS_LBSIZE(mp));
+       ASSERT(be16_to_cpu(entry->nameidx) >= be16_to_cpu(hdr->firstused));
+       ASSERT(be16_to_cpu(entry->nameidx) < XFS_LBSIZE(mp));
 
        /*
         * Scan through free region table:
@@ -1695,10 +1688,10 @@ xfs_attr_leaf_remove(xfs_dabuf_t *bp, xfs_da_args_t *args)
                }
 
                if ((be16_to_cpu(map->base) + be16_to_cpu(map->size))
-                               == INT_GET(entry->nameidx, ARCH_CONVERT)) {
+                               == be16_to_cpu(entry->nameidx)) {
                        before = i;
                } else if (be16_to_cpu(map->base)
-                       == (INT_GET(entry->nameidx, ARCH_CONVERT) + entsize)) {
+                       == (be16_to_cpu(entry->nameidx) + entsize)) {
                        after = i;
                } else if (be16_to_cpu(map->size) < tmp) {
                        tmp = be16_to_cpu(map->size);
@@ -1733,8 +1726,7 @@ xfs_attr_leaf_remove(xfs_dabuf_t *bp, xfs_da_args_t *args)
                 */
                map = &hdr->freemap[smallest];
                if (be16_to_cpu(map->size) < entsize) {
-                       map->base = cpu_to_be16(
-                                       INT_GET(entry->nameidx, ARCH_CONVERT));
+                       map->base = cpu_to_be16(be16_to_cpu(entry->nameidx));
                        map->size = cpu_to_be16(entsize);
                }
        }
@@ -1742,8 +1734,7 @@ xfs_attr_leaf_remove(xfs_dabuf_t *bp, xfs_da_args_t *args)
        /*
         * Did we remove the first entry?
         */
-       if (INT_GET(entry->nameidx, ARCH_CONVERT)
-                               == be16_to_cpu(hdr->firstused))
+       if (be16_to_cpu(entry->nameidx) == be16_to_cpu(hdr->firstused))
                smallest = 1;
        else
                smallest = 0;
@@ -1776,12 +1767,12 @@ xfs_attr_leaf_remove(xfs_dabuf_t *bp, xfs_da_args_t *args)
                tmp = XFS_LBSIZE(mp);
                entry = &leaf->entries[0];
                for (i = be16_to_cpu(hdr->count)-1; i >= 0; entry++, i--) {
-                       ASSERT(INT_GET(entry->nameidx, ARCH_CONVERT)
-                               >= be16_to_cpu(hdr->firstused));
-                       ASSERT(INT_GET(entry->nameidx, ARCH_CONVERT)
-                                                       < XFS_LBSIZE(mp));
-                       if (INT_GET(entry->nameidx, ARCH_CONVERT) < tmp)
-                               tmp = INT_GET(entry->nameidx, ARCH_CONVERT);
+                       ASSERT(be16_to_cpu(entry->nameidx) >=
+                              be16_to_cpu(hdr->firstused));
+                       ASSERT(be16_to_cpu(entry->nameidx) < XFS_LBSIZE(mp));
+
+                       if (be16_to_cpu(entry->nameidx) < tmp)
+                               tmp = be16_to_cpu(entry->nameidx);
                }
                hdr->firstused = cpu_to_be16(tmp);
                if (!hdr->firstused) {
@@ -1832,9 +1823,8 @@ xfs_attr_leaf_unbalance(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
        /*
         * Save last hashval from dying block for later Btree fixup.
         */
-       drop_blk->hashval =
-               INT_GET(drop_leaf->entries[be16_to_cpu(drop_leaf->hdr.count)-1]
-                               .hashval, ARCH_CONVERT);
+       drop_blk->hashval = be32_to_cpu(
+               drop_leaf->entries[be16_to_cpu(drop_leaf->hdr.count)-1].hashval);
 
        /*
         * Check if we need a temp buffer, or can we do it in place.
@@ -1895,9 +1885,8 @@ xfs_attr_leaf_unbalance(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
        /*
         * Copy out last hashval in each block for B-tree code.
         */
-       save_blk->hashval =
-               INT_GET(save_leaf->entries[be16_to_cpu(save_leaf->hdr.count)-1]
-                                               .hashval, ARCH_CONVERT);
+       save_blk->hashval = be32_to_cpu(
+               save_leaf->entries[be16_to_cpu(save_leaf->hdr.count)-1].hashval);
 }
 
 /*========================================================================
@@ -1940,9 +1929,9 @@ xfs_attr_leaf_lookup_int(xfs_dabuf_t *bp, xfs_da_args_t *args)
        for (entry = &leaf->entries[probe]; span > 4;
                   entry = &leaf->entries[probe]) {
                span /= 2;
-               if (INT_GET(entry->hashval, ARCH_CONVERT) < hashval)
+               if (be32_to_cpu(entry->hashval) < hashval)
                        probe += span;
-               else if (INT_GET(entry->hashval, ARCH_CONVERT) > hashval)
+               else if (be32_to_cpu(entry->hashval) > hashval)
                        probe -= span;
                else
                        break;
@@ -1950,25 +1939,23 @@ xfs_attr_leaf_lookup_int(xfs_dabuf_t *bp, xfs_da_args_t *args)
        ASSERT((probe >= 0) && 
               (!leaf->hdr.count
               || (probe < be16_to_cpu(leaf->hdr.count))));
-       ASSERT((span <= 4) || (INT_GET(entry->hashval, ARCH_CONVERT)
-                                                       == hashval));
+       ASSERT((span <= 4) || (be32_to_cpu(entry->hashval) == hashval));
 
        /*
         * Since we may have duplicate hashval's, find the first matching
         * hashval in the leaf.
         */
-       while ((probe > 0) && (INT_GET(entry->hashval, ARCH_CONVERT)
-                                                       >= hashval)) {
+       while ((probe > 0) && (be32_to_cpu(entry->hashval) >= hashval)) {
                entry--;
                probe--;
        }
-       while ((probe < be16_to_cpu(leaf->hdr.count))
-               && (INT_GET(entry->hashval, ARCH_CONVERT) < hashval)) {
+       while ((probe < be16_to_cpu(leaf->hdr.count)) &&
+              (be32_to_cpu(entry->hashval) < hashval)) {
                entry++;
                probe++;
        }
-       if ((probe == be16_to_cpu(leaf->hdr.count))
-                   || (INT_GET(entry->hashval, ARCH_CONVERT) != hashval)) {
+       if ((probe == be16_to_cpu(leaf->hdr.count)) ||
+           (be32_to_cpu(entry->hashval) != hashval)) {
                args->index = probe;
                return(XFS_ERROR(ENOATTR));
        }
@@ -1976,8 +1963,8 @@ xfs_attr_leaf_lookup_int(xfs_dabuf_t *bp, xfs_da_args_t *args)
        /*
         * Duplicate keys may be present, so search all of them for a match.
         */
-       for (  ; (probe < be16_to_cpu(leaf->hdr.count))
-                       && (INT_GET(entry->hashval, ARCH_CONVERT) == hashval);
+       for (  ; (probe < be16_to_cpu(leaf->hdr.count)) &&
+                       (be32_to_cpu(entry->hashval) == hashval);
                        entry++, probe++) {
 /*
  * GROT: Add code to remove incomplete entries.
@@ -2150,7 +2137,7 @@ xfs_attr_leaf_moveents(xfs_attr_leafblock_t *leaf_s, int start_s,
        entry_d = &leaf_d->entries[start_d];
        desti = start_d;
        for (i = 0; i < count; entry_s++, entry_d++, desti++, i++) {
-               ASSERT(INT_GET(entry_s->nameidx, ARCH_CONVERT)
+               ASSERT(be16_to_cpu(entry_s->nameidx)
                                >= be16_to_cpu(hdr_s->firstused));
                tmp = xfs_attr_leaf_entsize(leaf_s, start_s + i);
 #ifdef GROT
@@ -2175,11 +2162,11 @@ xfs_attr_leaf_moveents(xfs_attr_leafblock_t *leaf_s, int start_s,
                        /* both on-disk, don't endian flip twice */
                        entry_d->nameidx = hdr_d->firstused;
                        entry_d->flags = entry_s->flags;
-                       ASSERT(INT_GET(entry_d->nameidx, ARCH_CONVERT) + tmp
+                       ASSERT(be16_to_cpu(entry_d->nameidx) + tmp
                                                        <= XFS_LBSIZE(mp));
                        memmove(XFS_ATTR_LEAF_NAME(leaf_d, desti),
                                XFS_ATTR_LEAF_NAME(leaf_s, start_s + i), tmp);
-                       ASSERT(INT_GET(entry_s->nameidx, ARCH_CONVERT) + tmp
+                       ASSERT(be16_to_cpu(entry_s->nameidx) + tmp
                                                        <= XFS_LBSIZE(mp));
                        memset(XFS_ATTR_LEAF_NAME(leaf_s, start_s + i), 0, tmp);
                        be16_add(&hdr_s->usedbytes, -tmp);
@@ -2252,12 +2239,12 @@ xfs_attr_leaf_order(xfs_dabuf_t *leaf1_bp, xfs_dabuf_t *leaf2_bp)
               (be16_to_cpu(leaf2->hdr.info.magic) == XFS_ATTR_LEAF_MAGIC));
        if ((be16_to_cpu(leaf1->hdr.count) > 0) &&
            (be16_to_cpu(leaf2->hdr.count) > 0) &&
-           ((INT_GET(leaf2->entries[0].hashval, ARCH_CONVERT) <
-             INT_GET(leaf1->entries[0].hashval, ARCH_CONVERT)) ||
-            (INT_GET(leaf2->entries[be16_to_cpu(leaf2->hdr.count)-1].hashval,
-                                               ARCH_CONVERT) <
-             INT_GET(leaf1->entries[be16_to_cpu(leaf1->hdr.count)-1].hashval,
-                                               ARCH_CONVERT)))) {
+           ((be32_to_cpu(leaf2->entries[0].hashval) <
+             be32_to_cpu(leaf1->entries[0].hashval)) ||
+            (be32_to_cpu(leaf2->entries[
+                       be16_to_cpu(leaf2->hdr.count)-1].hashval) <
+             be32_to_cpu(leaf1->entries[
+                       be16_to_cpu(leaf1->hdr.count)-1].hashval)))) {
                return(1);
        }
        return(0);
@@ -2277,8 +2264,7 @@ xfs_attr_leaf_lasthash(xfs_dabuf_t *bp, int *count)
                *count = be16_to_cpu(leaf->hdr.count);
        if (!leaf->hdr.count)
                return(0);
-       return (INT_GET(leaf->entries[be16_to_cpu(leaf->hdr.count)-1].hashval,
-                               ARCH_CONVERT));
+       return be32_to_cpu(leaf->entries[be16_to_cpu(leaf->hdr.count)-1].hashval);
 }
 
 /*
@@ -2356,15 +2342,14 @@ xfs_attr_leaf_list_int(xfs_dabuf_t *bp, xfs_attr_list_context_t *context)
        if (context->resynch) {
                entry = &leaf->entries[0];
                for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
-                       if (INT_GET(entry->hashval, ARCH_CONVERT)
-                                                       == cursor->hashval) {
+                       if (be32_to_cpu(entry->hashval) == cursor->hashval) {
                                if (cursor->offset == context->dupcnt) {
                                        context->dupcnt = 0;
                                        break;
                                }
                                context->dupcnt++;
-                       } else if (INT_GET(entry->hashval, ARCH_CONVERT)
-                                                       > cursor->hashval) {
+                       } else if (be32_to_cpu(entry->hashval) >
+                                       cursor->hashval) {
                                context->dupcnt = 0;
                                break;
                        }
@@ -2387,8 +2372,8 @@ xfs_attr_leaf_list_int(xfs_dabuf_t *bp, xfs_attr_list_context_t *context)
             && (retval == 0); entry++, i++) {
                attrnames_t     *namesp;
 
-               if (INT_GET(entry->hashval, ARCH_CONVERT) != cursor->hashval) {
-                       cursor->hashval = INT_GET(entry->hashval, ARCH_CONVERT);
+               if (be32_to_cpu(entry->hashval) != cursor->hashval) {
+                       cursor->hashval = be32_to_cpu(entry->hashval);
                        cursor->offset = 0;
                }
 
@@ -2554,7 +2539,7 @@ xfs_attr_leaf_clearflag(xfs_da_args_t *args)
                namelen = name_rmt->namelen;
                name = (char *)name_rmt->name;
        }
-       ASSERT(INT_GET(entry->hashval, ARCH_CONVERT) == args->hashval);
+       ASSERT(be32_to_cpu(entry->hashval) == args->hashval);
        ASSERT(namelen == args->namelen);
        ASSERT(memcmp(name, args->name, namelen) == 0);
 #endif /* DEBUG */
@@ -2706,7 +2691,7 @@ xfs_attr_leaf_flipflags(xfs_da_args_t *args)
                namelen2 = name_rmt->namelen;
                name2 = (char *)name_rmt->name;
        }
-       ASSERT(INT_GET(entry1->hashval, ARCH_CONVERT) == INT_GET(entry2->hashval, ARCH_CONVERT));
+       ASSERT(be32_to_cpu(entry1->hashval) == be32_to_cpu(entry2->hashval));
        ASSERT(namelen1 == namelen2);
        ASSERT(memcmp(name1, name2, namelen1) == 0);
 #endif /* DEBUG */
@@ -2934,8 +2919,8 @@ xfs_attr_leaf_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp)
        count = 0;
        entry = &leaf->entries[0];
        for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
-               if (   INT_GET(entry->nameidx, ARCH_CONVERT)
-                   && ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
+               if (be16_to_cpu(entry->nameidx) &&
+                   ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
                        name_rmt = XFS_ATTR_LEAF_NAME_REMOTE(leaf, i);
                        if (name_rmt->valueblk)
                                count++;
@@ -2962,8 +2947,8 @@ xfs_attr_leaf_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp)
        lp = list;
        entry = &leaf->entries[0];
        for (i = 0; i < be16_to_cpu(leaf->hdr.count); entry++, i++) {
-               if (   INT_GET(entry->nameidx, ARCH_CONVERT)
-                   && ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
+               if (be16_to_cpu(entry->nameidx) &&
+                   ((entry->flags & XFS_ATTR_LOCAL) == 0)) {
                        name_rmt = XFS_ATTR_LEAF_NAME_REMOTE(leaf, i);
                        if (name_rmt->valueblk) {
                                /* both on-disk, don't endian flip twice */

diff --git a/fs/xfs/xfs_attr_leaf.h b/fs/xfs/xfs_attr_leaf.h
index 52b771052c57724dd060762e67194d5e08123d08..7fbe4880bb83d4fb6a7e0320495e55f224d951fd 100644 (file)
--- a/fs/xfs/xfs_attr_leaf.h
+++ b/fs/xfs/xfs_attr_leaf.h
@@ -89,10 +89,10 @@ typedef struct xfs_attr_leaf_hdr {  /* constant-structure header block */
 } xfs_attr_leaf_hdr_t;
 
 typedef struct xfs_attr_leaf_entry {   /* sorted on key, not name */
-       xfs_dahash_t    hashval;        /* hash value of name */
-       __uint16_t      nameidx;        /* index into buffer of name/value */
-       __uint8_t       flags;          /* LOCAL/ROOT/SECURE/INCOMPLETE flag */
-       __uint8_t       pad2;           /* unused pad byte */
+       __be32  hashval;                /* hash value of name */
+       __be16  nameidx;                /* index into buffer of name/value */
+       __u8    flags;                  /* LOCAL/ROOT/SECURE/INCOMPLETE flag */
+       __u8    pad2;                   /* unused pad byte */
 } xfs_attr_leaf_entry_t;
 
 typedef struct xfs_attr_leaf_name_local {
@@ -143,8 +143,8 @@ typedef struct xfs_attr_leafblock {
 static inline xfs_attr_leaf_name_remote_t *
 xfs_attr_leaf_name_remote(xfs_attr_leafblock_t *leafp, int idx)
 {
-       return (xfs_attr_leaf_name_remote_t *) &((char *)
-               (leafp))[INT_GET((leafp)->entries[idx].nameidx, ARCH_CONVERT)];
+       return (xfs_attr_leaf_name_remote_t *)
+               &((char *)leafp)[be16_to_cpu(leafp->entries[idx].nameidx)];
 }
 
 #define XFS_ATTR_LEAF_NAME_LOCAL(leafp,idx)    \
@@ -152,16 +152,15 @@ xfs_attr_leaf_name_remote(xfs_attr_leafblock_t *leafp, int idx)
 static inline xfs_attr_leaf_name_local_t *
 xfs_attr_leaf_name_local(xfs_attr_leafblock_t *leafp, int idx)
 {
-       return (xfs_attr_leaf_name_local_t *) &((char *)
-               (leafp))[INT_GET((leafp)->entries[idx].nameidx, ARCH_CONVERT)];
+       return (xfs_attr_leaf_name_local_t *)
+               &((char *)leafp)[be16_to_cpu(leafp->entries[idx].nameidx)];
 }
 
 #define XFS_ATTR_LEAF_NAME(leafp,idx)          \
        xfs_attr_leaf_name(leafp,idx)
 static inline char *xfs_attr_leaf_name(xfs_attr_leafblock_t *leafp, int idx)
 {
-       return (&((char *)
-               (leafp))[INT_GET((leafp)->entries[idx].nameidx, ARCH_CONVERT)]);
+       return &((char *)leafp)[be16_to_cpu(leafp->entries[idx].nameidx)];
 }
 
 /*