apfs/linux-apfs
0
0
Fork 0
mirror of https://github.com/linux-apfs/linux-apfs.git synced 2026-05-01 15:00:59 -07:00
Code Issues Packages Projects Releases Wiki Activity

[XFS] endianess annotations for xfs_da_node_hdr_t

Browse Source 
SGI-PV: 943272
SGI-Modid: xfs-linux-melb:xfs-kern:25505a

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Nathan Scott <nathans@sgi.com>
This commit is contained in:
Nathan Scott
2006-03-17 17:29:56 +11:00
parent 403432dcb5
commit fac80cce0e
6 changed files with 86 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files
fs/xfs/xfs_attr.c
+5 -5
View File
@@ -1825,8 +1825,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
return(XFS_ERROR(EFSCORRUPTED)); return(XFS_ERROR(EFSCORRUPTED));
} }
btree = node->btree; btree = node->btree;
for (i = 0; for (i = 0; i < be16_to_cpu(node->hdr.count);
i < INT_GET(node->hdr.count, ARCH_CONVERT);
btree++, i++) { btree++, i++) {
if (cursor->hashval if (cursor->hashval
<= be32_to_cpu(btree->hashval)) { <= be32_to_cpu(btree->hashval)) {
@@ -1836,7 +1835,7 @@ xfs_attr_node_list(xfs_attr_list_context_t *context)
break; break;
} }
} }
if (i == INT_GET(node->hdr.count, ARCH_CONVERT)) { if (i == be16_to_cpu(node->hdr.count)) {
xfs_da_brelse(NULL, bp); xfs_da_brelse(NULL, bp);
return(0); return(0);
} }
@@ -2226,9 +2225,10 @@ xfs_attr_trace_l_cn(char *where, struct xfs_attr_list_context *context,
: 0, : 0,
(__psunsigned_t)context->dupcnt, (__psunsigned_t)context->dupcnt,
(__psunsigned_t)context->flags, (__psunsigned_t)context->flags,
(__psunsigned_t)INT_GET(node->hdr.count, ARCH_CONVERT), (__psunsigned_t)be16_to_cpu(node->hdr.count),
(__psunsigned_t)be32_to_cpu(node->btree[0].hashval), (__psunsigned_t)be32_to_cpu(node->btree[0].hashval),
(__psunsigned_t)be32_to_cpu(node->btree[INT_GET(node->hdr.count, ARCH_CONVERT)-1].hashval)); (__psunsigned_t)be32_to_cpu(node->btree[
be16_to_cpu(node->hdr.count)-1].hashval));
} }
/* /*
fs/xfs/xfs_attr_leaf.c
+2 -2
View File
@@ -870,7 +870,7 @@ xfs_attr_leaf_to_node(xfs_da_args_t *args)
node->btree[0].hashval = node->btree[0].hashval =
leaf->entries[be16_to_cpu(leaf->hdr.count)-1 ].hashval; leaf->entries[be16_to_cpu(leaf->hdr.count)-1 ].hashval;
node->btree[0].before = cpu_to_be32(blkno); node->btree[0].before = cpu_to_be32(blkno);
INT_SET(node->hdr.count, ARCH_CONVERT, 1); node->hdr.count = cpu_to_be16(1);
xfs_da_log_buf(args->trans, bp1, 0, XFS_LBSIZE(dp->i_mount) - 1); xfs_da_log_buf(args->trans, bp1, 0, XFS_LBSIZE(dp->i_mount) - 1);
error = 0; error = 0;
out: out:
@@ -2804,7 +2804,7 @@ xfs_attr_node_inactive(xfs_trans_t **trans, xfs_inode_t *dp, xfs_dabuf_t *bp,
node = bp->data; node = bp->data;
ASSERT(be16_to_cpu(node->hdr.info.magic) == XFS_DA_NODE_MAGIC); ASSERT(be16_to_cpu(node->hdr.info.magic) == XFS_DA_NODE_MAGIC);
parent_blkno = xfs_da_blkno(bp); /* save for re-read later */ parent_blkno = xfs_da_blkno(bp); /* save for re-read later */
count = INT_GET(node->hdr.count, ARCH_CONVERT); count = be16_to_cpu(node->hdr.count);
if (!count) { if (!count) {
xfs_da_brelse(*trans, bp); xfs_da_brelse(*trans, bp);
return(0); return(0);
fs/xfs/xfs_da_btree.c
+69 -70
View File
@@ -129,7 +129,7 @@ xfs_da_node_create(xfs_da_args_t *args, xfs_dablk_t blkno, int level,
node->hdr.info.magic = cpu_to_be16(XFS_DA_NODE_MAGIC); node->hdr.info.magic = cpu_to_be16(XFS_DA_NODE_MAGIC);
node->hdr.info.pad = 0; node->hdr.info.pad = 0;
node->hdr.count = 0; node->hdr.count = 0;
INT_SET(node->hdr.level, ARCH_CONVERT, level); node->hdr.level = cpu_to_be16(level);
xfs_da_log_buf(tp, bp, xfs_da_log_buf(tp, bp,
XFS_DA_LOGRANGE(node, &node->hdr, sizeof(node->hdr))); XFS_DA_LOGRANGE(node, &node->hdr, sizeof(node->hdr)));
@@ -360,7 +360,7 @@ xfs_da_root_split(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
node = bp->data; node = bp->data;
oldroot = blk1->bp->data; oldroot = blk1->bp->data;
if (be16_to_cpu(oldroot->hdr.info.magic) == XFS_DA_NODE_MAGIC) { if (be16_to_cpu(oldroot->hdr.info.magic) == XFS_DA_NODE_MAGIC) {
size = (int)((char *)&oldroot->btree[INT_GET(oldroot->hdr.count, ARCH_CONVERT)] - size = (int)((char *)&oldroot->btree[be16_to_cpu(oldroot->hdr.count)] -
(char *)oldroot); (char *)oldroot);
} else { } else {
ASSERT(XFS_DIR_IS_V2(mp)); ASSERT(XFS_DIR_IS_V2(mp));
@@ -381,7 +381,7 @@ xfs_da_root_split(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
error = xfs_da_node_create(args, error = xfs_da_node_create(args,
args->whichfork == XFS_DATA_FORK && args->whichfork == XFS_DATA_FORK &&
XFS_DIR_IS_V2(mp) ? mp->m_dirleafblk : 0, XFS_DIR_IS_V2(mp) ? mp->m_dirleafblk : 0,
INT_GET(node->hdr.level, ARCH_CONVERT) + 1, &bp, args->whichfork); be16_to_cpu(node->hdr.level) + 1, &bp, args->whichfork);
if (error) if (error)
return(error); return(error);
node = bp->data; node = bp->data;
@@ -389,7 +389,7 @@ xfs_da_root_split(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
node->btree[0].before = cpu_to_be32(blk1->blkno); node->btree[0].before = cpu_to_be32(blk1->blkno);
node->btree[1].hashval = cpu_to_be32(blk2->hashval); node->btree[1].hashval = cpu_to_be32(blk2->hashval);
node->btree[1].before = cpu_to_be32(blk2->blkno); node->btree[1].before = cpu_to_be32(blk2->blkno);
INT_SET(node->hdr.count, ARCH_CONVERT, 2); node->hdr.count = cpu_to_be16(2);
#ifdef DEBUG #ifdef DEBUG
if (be16_to_cpu(oldroot->hdr.info.magic) == XFS_DIR2_LEAFN_MAGIC) { if (be16_to_cpu(oldroot->hdr.info.magic) == XFS_DIR2_LEAFN_MAGIC) {
@@ -435,7 +435,7 @@ xfs_da_node_split(xfs_da_state_t *state, xfs_da_state_blk_t *oldblk,
/* /*
* Do we have to split the node? * Do we have to split the node?
*/ */
if ((INT_GET(node->hdr.count, ARCH_CONVERT) + newcount) > state->node_ents) { if ((be16_to_cpu(node->hdr.count) + newcount) > state->node_ents) {
/* /*
* Allocate a new node, add to the doubly linked chain of * Allocate a new node, add to the doubly linked chain of
* nodes, then move some of our excess entries into it. * nodes, then move some of our excess entries into it.
@@ -472,7 +472,7 @@ xfs_da_node_split(xfs_da_state_t *state, xfs_da_state_blk_t *oldblk,
* If we had double-split op below us, then add the extra block too. * If we had double-split op below us, then add the extra block too.
*/ */
node = oldblk->bp->data; node = oldblk->bp->data;
if (oldblk->index <= INT_GET(node->hdr.count, ARCH_CONVERT)) { if (oldblk->index <= be16_to_cpu(node->hdr.count)) {
oldblk->index++; oldblk->index++;
xfs_da_node_add(state, oldblk, addblk); xfs_da_node_add(state, oldblk, addblk);
if (useextra) { if (useextra) {
@@ -516,17 +516,17 @@ xfs_da_node_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
* Figure out how many entries need to move, and in which direction. * Figure out how many entries need to move, and in which direction.
* Swap the nodes around if that makes it simpler. * Swap the nodes around if that makes it simpler.
*/ */
if ((INT_GET(node1->hdr.count, ARCH_CONVERT) > 0) && (INT_GET(node2->hdr.count, ARCH_CONVERT) > 0) && if ((be16_to_cpu(node1->hdr.count) > 0) && (be16_to_cpu(node2->hdr.count) > 0) &&
((be32_to_cpu(node2->btree[0].hashval) < be32_to_cpu(node1->btree[0].hashval)) || ((be32_to_cpu(node2->btree[0].hashval) < be32_to_cpu(node1->btree[0].hashval)) ||
(be32_to_cpu(node2->btree[INT_GET(node2->hdr.count, ARCH_CONVERT)-1].hashval) < (be32_to_cpu(node2->btree[be16_to_cpu(node2->hdr.count)-1].hashval) <
be32_to_cpu(node1->btree[INT_GET(node1->hdr.count, ARCH_CONVERT)-1].hashval)))) { be32_to_cpu(node1->btree[be16_to_cpu(node1->hdr.count)-1].hashval)))) {
tmpnode = node1; tmpnode = node1;
node1 = node2; node1 = node2;
node2 = tmpnode; node2 = tmpnode;
} }
ASSERT(be16_to_cpu(node1->hdr.info.magic) == XFS_DA_NODE_MAGIC); ASSERT(be16_to_cpu(node1->hdr.info.magic) == XFS_DA_NODE_MAGIC);
ASSERT(be16_to_cpu(node2->hdr.info.magic) == XFS_DA_NODE_MAGIC); ASSERT(be16_to_cpu(node2->hdr.info.magic) == XFS_DA_NODE_MAGIC);
count = (INT_GET(node1->hdr.count, ARCH_CONVERT) - INT_GET(node2->hdr.count, ARCH_CONVERT)) / 2; count = (be16_to_cpu(node1->hdr.count) - be16_to_cpu(node2->hdr.count)) / 2;
if (count == 0) if (count == 0)
return; return;
tp = state->args->trans; tp = state->args->trans;
@@ -537,7 +537,7 @@ xfs_da_node_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
/* /*
* Move elements in node2 up to make a hole. * Move elements in node2 up to make a hole.
*/ */
if ((tmp = INT_GET(node2->hdr.count, ARCH_CONVERT)) > 0) { if ((tmp = be16_to_cpu(node2->hdr.count)) > 0) {
tmp *= (uint)sizeof(xfs_da_node_entry_t); tmp *= (uint)sizeof(xfs_da_node_entry_t);
btree_s = &node2->btree[0]; btree_s = &node2->btree[0];
btree_d = &node2->btree[count]; btree_d = &node2->btree[count];
@@ -548,13 +548,12 @@ xfs_da_node_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
* Move the req'd B-tree elements from high in node1 to * Move the req'd B-tree elements from high in node1 to
* low in node2. * low in node2.
*/ */
INT_MOD(node2->hdr.count, ARCH_CONVERT, count); be16_add(&node2->hdr.count, count);
tmp = count * (uint)sizeof(xfs_da_node_entry_t); tmp = count * (uint)sizeof(xfs_da_node_entry_t);
btree_s = &node1->btree[INT_GET(node1->hdr.count, ARCH_CONVERT) - count]; btree_s = &node1->btree[be16_to_cpu(node1->hdr.count) - count];
btree_d = &node2->btree[0]; btree_d = &node2->btree[0];
memcpy(btree_d, btree_s, tmp); memcpy(btree_d, btree_s, tmp);
INT_MOD(node1->hdr.count, ARCH_CONVERT, -(count)); be16_add(&node1->hdr.count, -count);
} else { } else {
/* /*
* Move the req'd B-tree elements from low in node2 to * Move the req'd B-tree elements from low in node2 to
@@ -563,21 +562,21 @@ xfs_da_node_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
count = -count; count = -count;
tmp = count * (uint)sizeof(xfs_da_node_entry_t); tmp = count * (uint)sizeof(xfs_da_node_entry_t);
btree_s = &node2->btree[0]; btree_s = &node2->btree[0];
btree_d = &node1->btree[INT_GET(node1->hdr.count, ARCH_CONVERT)]; btree_d = &node1->btree[be16_to_cpu(node1->hdr.count)];
memcpy(btree_d, btree_s, tmp); memcpy(btree_d, btree_s, tmp);
INT_MOD(node1->hdr.count, ARCH_CONVERT, count); be16_add(&node1->hdr.count, count);
xfs_da_log_buf(tp, blk1->bp, xfs_da_log_buf(tp, blk1->bp,
XFS_DA_LOGRANGE(node1, btree_d, tmp)); XFS_DA_LOGRANGE(node1, btree_d, tmp));
/* /*
* Move elements in node2 down to fill the hole. * Move elements in node2 down to fill the hole.
*/ */
tmp = INT_GET(node2->hdr.count, ARCH_CONVERT) - count; tmp = be16_to_cpu(node2->hdr.count) - count;
tmp *= (uint)sizeof(xfs_da_node_entry_t); tmp *= (uint)sizeof(xfs_da_node_entry_t);
btree_s = &node2->btree[count]; btree_s = &node2->btree[count];
btree_d = &node2->btree[0]; btree_d = &node2->btree[0];
memmove(btree_d, btree_s, tmp); memmove(btree_d, btree_s, tmp);
INT_MOD(node2->hdr.count, ARCH_CONVERT, -(count)); be16_add(&node2->hdr.count, -count);
} }
/* /*
@@ -588,7 +587,7 @@ xfs_da_node_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
xfs_da_log_buf(tp, blk2->bp, xfs_da_log_buf(tp, blk2->bp,
XFS_DA_LOGRANGE(node2, &node2->hdr, XFS_DA_LOGRANGE(node2, &node2->hdr,
sizeof(node2->hdr) + sizeof(node2->hdr) +
sizeof(node2->btree[0]) * INT_GET(node2->hdr.count, ARCH_CONVERT))); sizeof(node2->btree[0]) * be16_to_cpu(node2->hdr.count)));
/* /*
* Record the last hashval from each block for upward propagation. * Record the last hashval from each block for upward propagation.
@@ -596,15 +595,15 @@ xfs_da_node_rebalance(xfs_da_state_t *state, xfs_da_state_blk_t *blk1,
*/ */
node1 = blk1->bp->data; node1 = blk1->bp->data;
node2 = blk2->bp->data; node2 = blk2->bp->data;
blk1->hashval = be32_to_cpu(node1->btree[ INT_GET(node1->hdr.count, ARCH_CONVERT)-1 ].hashval); blk1->hashval = be32_to_cpu(node1->btree[be16_to_cpu(node1->hdr.count)-1].hashval);
blk2->hashval = be32_to_cpu(node2->btree[ INT_GET(node2->hdr.count, ARCH_CONVERT)-1 ].hashval); blk2->hashval = be32_to_cpu(node2->btree[be16_to_cpu(node2->hdr.count)-1].hashval);
/* /*
* Adjust the expected index for insertion. * Adjust the expected index for insertion.
*/ */
if (blk1->index >= INT_GET(node1->hdr.count, ARCH_CONVERT)) { if (blk1->index >= be16_to_cpu(node1->hdr.count)) {
blk2->index = blk1->index - INT_GET(node1->hdr.count, ARCH_CONVERT); blk2->index = blk1->index - be16_to_cpu(node1->hdr.count);
blk1->index = INT_GET(node1->hdr.count, ARCH_CONVERT) + 1; /* make it invalid */ blk1->index = be16_to_cpu(node1->hdr.count) + 1; /* make it invalid */
} }
} }
@@ -623,7 +622,7 @@ xfs_da_node_add(xfs_da_state_t *state, xfs_da_state_blk_t *oldblk,
node = oldblk->bp->data; node = oldblk->bp->data;
mp = state->mp; mp = state->mp;
ASSERT(be16_to_cpu(node->hdr.info.magic) == XFS_DA_NODE_MAGIC); ASSERT(be16_to_cpu(node->hdr.info.magic) == XFS_DA_NODE_MAGIC);
ASSERT((oldblk->index >= 0) && (oldblk->index <= INT_GET(node->hdr.count, ARCH_CONVERT))); ASSERT((oldblk->index >= 0) && (oldblk->index <= be16_to_cpu(node->hdr.count)));
ASSERT(newblk->blkno != 0); ASSERT(newblk->blkno != 0);
if (state->args->whichfork == XFS_DATA_FORK && XFS_DIR_IS_V2(mp)) if (state->args->whichfork == XFS_DATA_FORK && XFS_DIR_IS_V2(mp))
ASSERT(newblk->blkno >= mp->m_dirleafblk && ASSERT(newblk->blkno >= mp->m_dirleafblk &&
@@ -634,22 +633,22 @@ xfs_da_node_add(xfs_da_state_t *state, xfs_da_state_blk_t *oldblk,
*/ */
tmp = 0; tmp = 0;
btree = &node->btree[ oldblk->index ]; btree = &node->btree[ oldblk->index ];
if (oldblk->index < INT_GET(node->hdr.count, ARCH_CONVERT)) { if (oldblk->index < be16_to_cpu(node->hdr.count)) {
tmp = (INT_GET(node->hdr.count, ARCH_CONVERT) - oldblk->index) * (uint)sizeof(*btree); tmp = (be16_to_cpu(node->hdr.count) - oldblk->index) * (uint)sizeof(*btree);
memmove(btree + 1, btree, tmp); memmove(btree + 1, btree, tmp);
} }
btree->hashval = cpu_to_be32(newblk->hashval); btree->hashval = cpu_to_be32(newblk->hashval);
btree->before = cpu_to_be32(newblk->blkno); btree->before = cpu_to_be32(newblk->blkno);
xfs_da_log_buf(state->args->trans, oldblk->bp, xfs_da_log_buf(state->args->trans, oldblk->bp,
XFS_DA_LOGRANGE(node, btree, tmp + sizeof(*btree))); XFS_DA_LOGRANGE(node, btree, tmp + sizeof(*btree)));
INT_MOD(node->hdr.count, ARCH_CONVERT, +1); be16_add(&node->hdr.count, 1);
xfs_da_log_buf(state->args->trans, oldblk->bp, xfs_da_log_buf(state->args->trans, oldblk->bp,
XFS_DA_LOGRANGE(node, &node->hdr, sizeof(node->hdr))); XFS_DA_LOGRANGE(node, &node->hdr, sizeof(node->hdr)));
/* /*
* Copy the last hash value from the oldblk to propagate upwards. * Copy the last hash value from the oldblk to propagate upwards.
*/ */
oldblk->hashval = be32_to_cpu(node->btree[ INT_GET(node->hdr.count, ARCH_CONVERT)-1 ].hashval); oldblk->hashval = be32_to_cpu(node->btree[be16_to_cpu(node->hdr.count)-1 ].hashval);
} }
/*======================================================================== /*========================================================================
@@ -775,7 +774,7 @@ xfs_da_root_join(xfs_da_state_t *state, xfs_da_state_blk_t *root_blk)
/* /*
* If the root has more than one child, then don't do anything. * If the root has more than one child, then don't do anything.
*/ */
if (INT_GET(oldroot->hdr.count, ARCH_CONVERT) > 1) if (be16_to_cpu(oldroot->hdr.count) > 1)
return(0); return(0);
/* /*
@@ -790,7 +789,7 @@ xfs_da_root_join(xfs_da_state_t *state, xfs_da_state_blk_t *root_blk)
return(error); return(error);
ASSERT(bp != NULL); ASSERT(bp != NULL);
blkinfo = bp->data; blkinfo = bp->data;
if (INT_GET(oldroot->hdr.level, ARCH_CONVERT) == 1) { if (be16_to_cpu(oldroot->hdr.level) == 1) {
ASSERT(be16_to_cpu(blkinfo->magic) == XFS_DIRX_LEAF_MAGIC(state->mp) || ASSERT(be16_to_cpu(blkinfo->magic) == XFS_DIRX_LEAF_MAGIC(state->mp) ||
be16_to_cpu(blkinfo->magic) == XFS_ATTR_LEAF_MAGIC); be16_to_cpu(blkinfo->magic) == XFS_ATTR_LEAF_MAGIC);
} else { } else {
@@ -832,7 +831,7 @@ xfs_da_node_toosmall(xfs_da_state_t *state, int *action)
info = blk->bp->data; info = blk->bp->data;
ASSERT(be16_to_cpu(info->magic) == XFS_DA_NODE_MAGIC); ASSERT(be16_to_cpu(info->magic) == XFS_DA_NODE_MAGIC);
node = (xfs_da_intnode_t *)info; node = (xfs_da_intnode_t *)info;
count = INT_GET(node->hdr.count, ARCH_CONVERT); count = be16_to_cpu(node->hdr.count);
if (count > (state->node_ents >> 1)) { if (count > (state->node_ents >> 1)) {
*action = 0; /* blk over 50%, don't try to join */ *action = 0; /* blk over 50%, don't try to join */
return(0); /* blk over 50%, don't try to join */ return(0); /* blk over 50%, don't try to join */
@@ -888,10 +887,10 @@ xfs_da_node_toosmall(xfs_da_state_t *state, int *action)
node = (xfs_da_intnode_t *)info; node = (xfs_da_intnode_t *)info;
count = state->node_ents; count = state->node_ents;
count -= state->node_ents >> 2; count -= state->node_ents >> 2;
count -= INT_GET(node->hdr.count, ARCH_CONVERT); count -= be16_to_cpu(node->hdr.count);
node = bp->data; node = bp->data;
ASSERT(be16_to_cpu(node->hdr.info.magic) == XFS_DA_NODE_MAGIC); ASSERT(be16_to_cpu(node->hdr.info.magic) == XFS_DA_NODE_MAGIC);
count -= INT_GET(node->hdr.count, ARCH_CONVERT); count -= be16_to_cpu(node->hdr.count);
xfs_da_brelse(state->args->trans, bp); xfs_da_brelse(state->args->trans, bp);
if (count >= 0) if (count >= 0)
break; /* fits with at least 25% to spare */ break; /* fits with at least 25% to spare */
@@ -981,7 +980,7 @@ xfs_da_fixhashpath(xfs_da_state_t *state, xfs_da_state_path_t *path)
xfs_da_log_buf(state->args->trans, blk->bp, xfs_da_log_buf(state->args->trans, blk->bp,
XFS_DA_LOGRANGE(node, btree, sizeof(*btree))); XFS_DA_LOGRANGE(node, btree, sizeof(*btree)));
lasthash = be32_to_cpu(node->btree[ INT_GET(node->hdr.count, ARCH_CONVERT)-1 ].hashval); lasthash = be32_to_cpu(node->btree[be16_to_cpu(node->hdr.count)-1].hashval);
} }
} }
@@ -996,25 +995,25 @@ xfs_da_node_remove(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk)
int tmp; int tmp;
node = drop_blk->bp->data; node = drop_blk->bp->data;
ASSERT(drop_blk->index < INT_GET(node->hdr.count, ARCH_CONVERT)); ASSERT(drop_blk->index < be16_to_cpu(node->hdr.count));
ASSERT(drop_blk->index >= 0); ASSERT(drop_blk->index >= 0);
/* /*
* Copy over the offending entry, or just zero it out. * Copy over the offending entry, or just zero it out.
*/ */
btree = &node->btree[drop_blk->index]; btree = &node->btree[drop_blk->index];
if (drop_blk->index < (INT_GET(node->hdr.count, ARCH_CONVERT)-1)) { if (drop_blk->index < (be16_to_cpu(node->hdr.count)-1)) {
tmp = INT_GET(node->hdr.count, ARCH_CONVERT) - drop_blk->index - 1; tmp = be16_to_cpu(node->hdr.count) - drop_blk->index - 1;
tmp *= (uint)sizeof(xfs_da_node_entry_t); tmp *= (uint)sizeof(xfs_da_node_entry_t);
memmove(btree, btree + 1, tmp); memmove(btree, btree + 1, tmp);
xfs_da_log_buf(state->args->trans, drop_blk->bp, xfs_da_log_buf(state->args->trans, drop_blk->bp,
XFS_DA_LOGRANGE(node, btree, tmp)); XFS_DA_LOGRANGE(node, btree, tmp));
btree = &node->btree[ INT_GET(node->hdr.count, ARCH_CONVERT)-1 ]; btree = &node->btree[be16_to_cpu(node->hdr.count)-1];
} }
memset((char *)btree, 0, sizeof(xfs_da_node_entry_t)); memset((char *)btree, 0, sizeof(xfs_da_node_entry_t));
xfs_da_log_buf(state->args->trans, drop_blk->bp, xfs_da_log_buf(state->args->trans, drop_blk->bp,
XFS_DA_LOGRANGE(node, btree, sizeof(*btree))); XFS_DA_LOGRANGE(node, btree, sizeof(*btree)));
INT_MOD(node->hdr.count, ARCH_CONVERT, -1); be16_add(&node->hdr.count, -1);
xfs_da_log_buf(state->args->trans, drop_blk->bp, xfs_da_log_buf(state->args->trans, drop_blk->bp,
XFS_DA_LOGRANGE(node, &node->hdr, sizeof(node->hdr))); XFS_DA_LOGRANGE(node, &node->hdr, sizeof(node->hdr)));
@@ -1049,31 +1048,31 @@ xfs_da_node_unbalance(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
* elements in the remaining block up to make a hole. * elements in the remaining block up to make a hole.
*/ */
if ((be32_to_cpu(drop_node->btree[0].hashval) < be32_to_cpu(save_node->btree[ 0 ].hashval)) || if ((be32_to_cpu(drop_node->btree[0].hashval) < be32_to_cpu(save_node->btree[ 0 ].hashval)) ||
(be32_to_cpu(drop_node->btree[INT_GET(drop_node->hdr.count, ARCH_CONVERT)-1].hashval) < (be32_to_cpu(drop_node->btree[be16_to_cpu(drop_node->hdr.count)-1].hashval) <
be32_to_cpu(save_node->btree[INT_GET(save_node->hdr.count, ARCH_CONVERT)-1 ].hashval))) be32_to_cpu(save_node->btree[be16_to_cpu(save_node->hdr.count)-1].hashval)))
{ {
btree = &save_node->btree[ INT_GET(drop_node->hdr.count, ARCH_CONVERT) ]; btree = &save_node->btree[be16_to_cpu(drop_node->hdr.count)];
tmp = INT_GET(save_node->hdr.count, ARCH_CONVERT) * (uint)sizeof(xfs_da_node_entry_t); tmp = be16_to_cpu(save_node->hdr.count) * (uint)sizeof(xfs_da_node_entry_t);
memmove(btree, &save_node->btree[0], tmp); memmove(btree, &save_node->btree[0], tmp);
btree = &save_node->btree[0]; btree = &save_node->btree[0];
xfs_da_log_buf(tp, save_blk->bp, xfs_da_log_buf(tp, save_blk->bp,
XFS_DA_LOGRANGE(save_node, btree, XFS_DA_LOGRANGE(save_node, btree,
(INT_GET(save_node->hdr.count, ARCH_CONVERT) + INT_GET(drop_node->hdr.count, ARCH_CONVERT)) * (be16_to_cpu(save_node->hdr.count) + be16_to_cpu(drop_node->hdr.count)) *
sizeof(xfs_da_node_entry_t))); sizeof(xfs_da_node_entry_t)));
} else { } else {
btree = &save_node->btree[ INT_GET(save_node->hdr.count, ARCH_CONVERT) ]; btree = &save_node->btree[be16_to_cpu(save_node->hdr.count)];
xfs_da_log_buf(tp, save_blk->bp, xfs_da_log_buf(tp, save_blk->bp,
XFS_DA_LOGRANGE(save_node, btree, XFS_DA_LOGRANGE(save_node, btree,
INT_GET(drop_node->hdr.count, ARCH_CONVERT) * be16_to_cpu(drop_node->hdr.count) *
sizeof(xfs_da_node_entry_t))); sizeof(xfs_da_node_entry_t)));
} }
/* /*
* Move all the B-tree elements from drop_blk to save_blk. * Move all the B-tree elements from drop_blk to save_blk.
*/ */
tmp = INT_GET(drop_node->hdr.count, ARCH_CONVERT) * (uint)sizeof(xfs_da_node_entry_t); tmp = be16_to_cpu(drop_node->hdr.count) * (uint)sizeof(xfs_da_node_entry_t);
memcpy(btree, &drop_node->btree[0], tmp); memcpy(btree, &drop_node->btree[0], tmp);
INT_MOD(save_node->hdr.count, ARCH_CONVERT, INT_GET(drop_node->hdr.count, ARCH_CONVERT)); be16_add(&save_node->hdr.count, be16_to_cpu(drop_node->hdr.count));
xfs_da_log_buf(tp, save_blk->bp, xfs_da_log_buf(tp, save_blk->bp,
XFS_DA_LOGRANGE(save_node, &save_node->hdr, XFS_DA_LOGRANGE(save_node, &save_node->hdr,
@@ -1082,7 +1081,7 @@ xfs_da_node_unbalance(xfs_da_state_t *state, xfs_da_state_blk_t *drop_blk,
/* /*
* Save the last hashval in the remaining block for upward propagation. * Save the last hashval in the remaining block for upward propagation.
*/ */
save_blk->hashval = be32_to_cpu(save_node->btree[ INT_GET(save_node->hdr.count, ARCH_CONVERT)-1 ].hashval); save_blk->hashval = be32_to_cpu(save_node->btree[be16_to_cpu(save_node->hdr.count)-1].hashval);
} }
/*======================================================================== /*========================================================================
@@ -1147,12 +1146,12 @@ xfs_da_node_lookup_int(xfs_da_state_t *state, int *result)
blk->magic = be16_to_cpu(curr->magic); blk->magic = be16_to_cpu(curr->magic);
if (blk->magic == XFS_DA_NODE_MAGIC) { if (blk->magic == XFS_DA_NODE_MAGIC) {
node = blk->bp->data; node = blk->bp->data;
blk->hashval = be32_to_cpu(node->btree[INT_GET(node->hdr.count, ARCH_CONVERT)-1].hashval); blk->hashval = be32_to_cpu(node->btree[be16_to_cpu(node->hdr.count)-1].hashval);
/* /*
* Binary search. (note: small blocks will skip loop) * Binary search. (note: small blocks will skip loop)
*/ */
max = INT_GET(node->hdr.count, ARCH_CONVERT); max = be16_to_cpu(node->hdr.count);
probe = span = max / 2; probe = span = max / 2;
hashval = args->hashval; hashval = args->hashval;
for (btree = &node->btree[probe]; span > 4; for (btree = &node->btree[probe]; span > 4;
@@ -1358,11 +1357,11 @@ xfs_da_node_order(xfs_dabuf_t *node1_bp, xfs_dabuf_t *node2_bp)
node2 = node2_bp->data; node2 = node2_bp->data;
ASSERT((be16_to_cpu(node1->hdr.info.magic) == XFS_DA_NODE_MAGIC) && ASSERT((be16_to_cpu(node1->hdr.info.magic) == XFS_DA_NODE_MAGIC) &&
(be16_to_cpu(node2->hdr.info.magic) == XFS_DA_NODE_MAGIC)); (be16_to_cpu(node2->hdr.info.magic) == XFS_DA_NODE_MAGIC));
if ((INT_GET(node1->hdr.count, ARCH_CONVERT) > 0) && (INT_GET(node2->hdr.count, ARCH_CONVERT) > 0) && if ((be16_to_cpu(node1->hdr.count) > 0) && (be16_to_cpu(node2->hdr.count) > 0) &&
((be32_to_cpu(node2->btree[0].hashval) < ((be32_to_cpu(node2->btree[0].hashval) <
be32_to_cpu(node1->btree[0].hashval)) || be32_to_cpu(node1->btree[0].hashval)) ||
(be32_to_cpu(node2->btree[INT_GET(node2->hdr.count, ARCH_CONVERT)-1].hashval) < (be32_to_cpu(node2->btree[be16_to_cpu(node2->hdr.count)-1].hashval) <
be32_to_cpu(node1->btree[INT_GET(node1->hdr.count, ARCH_CONVERT)-1].hashval)))) { be32_to_cpu(node1->btree[be16_to_cpu(node1->hdr.count)-1].hashval)))) {
return(1); return(1);
} }
return(0); return(0);
@@ -1379,10 +1378,10 @@ xfs_da_node_lasthash(xfs_dabuf_t *bp, int *count)
node = bp->data; node = bp->data;
ASSERT(be16_to_cpu(node->hdr.info.magic) == XFS_DA_NODE_MAGIC); ASSERT(be16_to_cpu(node->hdr.info.magic) == XFS_DA_NODE_MAGIC);
if (count) if (count)
*count = INT_GET(node->hdr.count, ARCH_CONVERT); *count = be16_to_cpu(node->hdr.count);
if (!node->hdr.count) if (!node->hdr.count)
return(0); return(0);
return be32_to_cpu(node->btree[INT_GET(node->hdr.count, ARCH_CONVERT)-1].hashval); return be32_to_cpu(node->btree[be16_to_cpu(node->hdr.count)-1].hashval);
} }
/* /*
@@ -1491,7 +1490,7 @@ xfs_da_path_shift(xfs_da_state_t *state, xfs_da_state_path_t *path,
ASSERT(blk->bp != NULL); ASSERT(blk->bp != NULL);
node = blk->bp->data; node = blk->bp->data;
ASSERT(be16_to_cpu(node->hdr.info.magic) == XFS_DA_NODE_MAGIC); ASSERT(be16_to_cpu(node->hdr.info.magic) == XFS_DA_NODE_MAGIC);
if (forward && (blk->index < INT_GET(node->hdr.count, ARCH_CONVERT)-1)) { if (forward && (blk->index < be16_to_cpu(node->hdr.count)-1)) {
blk->index++; blk->index++;
blkno = be32_to_cpu(node->btree[blk->index].before); blkno = be32_to_cpu(node->btree[blk->index].before);
break; break;
@@ -1535,11 +1534,11 @@ xfs_da_path_shift(xfs_da_state_t *state, xfs_da_state_path_t *path,
blk->magic = be16_to_cpu(info->magic); blk->magic = be16_to_cpu(info->magic);
if (blk->magic == XFS_DA_NODE_MAGIC) { if (blk->magic == XFS_DA_NODE_MAGIC) {
node = (xfs_da_intnode_t *)info; node = (xfs_da_intnode_t *)info;
blk->hashval = be32_to_cpu(node->btree[INT_GET(node->hdr.count, ARCH_CONVERT)-1].hashval); blk->hashval = be32_to_cpu(node->btree[be16_to_cpu(node->hdr.count)-1].hashval);
if (forward) if (forward)
blk->index = 0; blk->index = 0;
else else
blk->index = INT_GET(node->hdr.count, ARCH_CONVERT)-1; blk->index = be16_to_cpu(node->hdr.count)-1;
blkno = be32_to_cpu(node->btree[blk->index].before); blkno = be32_to_cpu(node->btree[blk->index].before);
} else { } else {
ASSERT(level == path->active-1); ASSERT(level == path->active-1);
@@ -1795,8 +1794,8 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
} else { } else {
ASSERT(be16_to_cpu(dead_info->magic) == XFS_DA_NODE_MAGIC); ASSERT(be16_to_cpu(dead_info->magic) == XFS_DA_NODE_MAGIC);
dead_node = (xfs_da_intnode_t *)dead_info; dead_node = (xfs_da_intnode_t *)dead_info;
dead_level = INT_GET(dead_node->hdr.level, ARCH_CONVERT); dead_level = be16_to_cpu(dead_node->hdr.level);
dead_hash = be32_to_cpu(dead_node->btree[INT_GET(dead_node->hdr.count, ARCH_CONVERT) - 1].hashval); dead_hash = be32_to_cpu(dead_node->btree[be16_to_cpu(dead_node->hdr.count) - 1].hashval);
} }
sib_buf = par_buf = NULL; sib_buf = par_buf = NULL;
/* /*
@@ -1854,19 +1853,19 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
par_node = par_buf->data; par_node = par_buf->data;
if (unlikely( if (unlikely(
be16_to_cpu(par_node->hdr.info.magic) != XFS_DA_NODE_MAGIC || be16_to_cpu(par_node->hdr.info.magic) != XFS_DA_NODE_MAGIC ||
(level >= 0 && level != INT_GET(par_node->hdr.level, ARCH_CONVERT) + 1))) { (level >= 0 && level != be16_to_cpu(par_node->hdr.level) + 1))) {
XFS_ERROR_REPORT("xfs_da_swap_lastblock(4)", XFS_ERROR_REPORT("xfs_da_swap_lastblock(4)",
XFS_ERRLEVEL_LOW, mp); XFS_ERRLEVEL_LOW, mp);
error = XFS_ERROR(EFSCORRUPTED); error = XFS_ERROR(EFSCORRUPTED);
goto done; goto done;
} }
level = INT_GET(par_node->hdr.level, ARCH_CONVERT); level = be16_to_cpu(par_node->hdr.level);
for (entno = 0; for (entno = 0;
entno < INT_GET(par_node->hdr.count, ARCH_CONVERT) && entno < be16_to_cpu(par_node->hdr.count) &&
be32_to_cpu(par_node->btree[entno].hashval) < dead_hash; be32_to_cpu(par_node->btree[entno].hashval) < dead_hash;
entno++) entno++)
continue; continue;
if (unlikely(entno == INT_GET(par_node->hdr.count, ARCH_CONVERT))) { if (unlikely(entno == be16_to_cpu(par_node->hdr.count))) {
XFS_ERROR_REPORT("xfs_da_swap_lastblock(5)", XFS_ERROR_REPORT("xfs_da_swap_lastblock(5)",
XFS_ERRLEVEL_LOW, mp); XFS_ERRLEVEL_LOW, mp);
error = XFS_ERROR(EFSCORRUPTED); error = XFS_ERROR(EFSCORRUPTED);
@@ -1884,11 +1883,11 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
*/ */
for (;;) { for (;;) {
for (; for (;
entno < INT_GET(par_node->hdr.count, ARCH_CONVERT) && entno < be16_to_cpu(par_node->hdr.count) &&
be32_to_cpu(par_node->btree[entno].before) != last_blkno; be32_to_cpu(par_node->btree[entno].before) != last_blkno;
entno++) entno++)
continue; continue;
if (entno < INT_GET(par_node->hdr.count, ARCH_CONVERT)) if (entno < be16_to_cpu(par_node->hdr.count))
break; break;
par_blkno = be32_to_cpu(par_node->hdr.info.forw); par_blkno = be32_to_cpu(par_node->hdr.info.forw);
xfs_da_brelse(tp, par_buf); xfs_da_brelse(tp, par_buf);
@@ -1903,7 +1902,7 @@ xfs_da_swap_lastblock(xfs_da_args_t *args, xfs_dablk_t *dead_blknop,
goto done; goto done;
par_node = par_buf->data; par_node = par_buf->data;
if (unlikely( if (unlikely(
INT_GET(par_node->hdr.level, ARCH_CONVERT) != level || be16_to_cpu(par_node->hdr.level) != level ||
be16_to_cpu(par_node->hdr.info.magic) != XFS_DA_NODE_MAGIC)) { be16_to_cpu(par_node->hdr.info.magic) != XFS_DA_NODE_MAGIC)) {
XFS_ERROR_REPORT("xfs_da_swap_lastblock(7)", XFS_ERROR_REPORT("xfs_da_swap_lastblock(7)",
XFS_ERRLEVEL_LOW, mp); XFS_ERRLEVEL_LOW, mp);
fs/xfs/xfs_da_btree.h
+2 -2
View File
@@ -65,8 +65,8 @@ typedef struct xfs_da_blkinfo {
typedef struct xfs_da_intnode { typedef struct xfs_da_intnode {
struct xfs_da_node_hdr { /* constant-structure header block */ struct xfs_da_node_hdr { /* constant-structure header block */
xfs_da_blkinfo_t info; /* block type, links, etc. */ xfs_da_blkinfo_t info; /* block type, links, etc. */
__uint16_t count; /* count of active entries */ __be16 count; /* count of active entries */
__uint16_t level; /* level above leaves (leaf == 0) */ __be16 level; /* level above leaves (leaf == 0) */
} hdr; } hdr;
struct xfs_da_node_entry { struct xfs_da_node_entry {
__be32 hashval; /* hash value for this descendant */ __be32 hashval; /* hash value for this descendant */
fs/xfs/xfs_dir.c
+4 -4
View File
@@ -953,13 +953,13 @@ xfs_dir_node_getdents(xfs_trans_t *trans, xfs_inode_t *dp, uio_t *uio,
break; break;
btree = &node->btree[0]; btree = &node->btree[0];
xfs_dir_trace_g_dun("node: node detail", dp, uio, node); xfs_dir_trace_g_dun("node: node detail", dp, uio, node);
for (i = 0; i < INT_GET(node->hdr.count, ARCH_CONVERT); btree++, i++) { for (i = 0; i < be16_to_cpu(node->hdr.count); btree++, i++) {
if (be32_to_cpu(btree->hashval) >= cookhash) { if (be32_to_cpu(btree->hashval) >= cookhash) {
bno = be32_to_cpu(btree->before); bno = be32_to_cpu(btree->before);
break; break;
} }
} }
if (i == INT_GET(node->hdr.count, ARCH_CONVERT)) { if (i == be16_to_cpu(node->hdr.count)) {
xfs_da_brelse(trans, bp); xfs_da_brelse(trans, bp);
xfs_dir_trace_g_du("node: hash beyond EOF", xfs_dir_trace_g_du("node: hash beyond EOF",
dp, uio); dp, uio);
@@ -1118,7 +1118,7 @@ void
xfs_dir_trace_g_dun(char *where, xfs_inode_t *dp, uio_t *uio, xfs_dir_trace_g_dun(char *where, xfs_inode_t *dp, uio_t *uio,
xfs_da_intnode_t *node) xfs_da_intnode_t *node)
{ {
int last = INT_GET(node->hdr.count, ARCH_CONVERT) - 1; int last = be16_to_cpu(node->hdr.count) - 1;
xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DUN, where, xfs_dir_trace_enter(XFS_DIR_KTRACE_G_DUN, where,
(void *)dp, (void *)dp->i_mount, (void *)dp, (void *)dp->i_mount,
@@ -1127,7 +1127,7 @@ xfs_dir_trace_g_dun(char *where, xfs_inode_t *dp, uio_t *uio,
(void *)(unsigned long)uio->uio_resid, (void *)(unsigned long)uio->uio_resid,
(void *)(unsigned long)be32_to_cpu(node->hdr.info.forw), (void *)(unsigned long)be32_to_cpu(node->hdr.info.forw),
(void *)(unsigned long) (void *)(unsigned long)
INT_GET(node->hdr.count, ARCH_CONVERT), be16_to_cpu(node->hdr.count),
(void *)(unsigned long) (void *)(unsigned long)
be32_to_cpu(node->btree[0].hashval), be32_to_cpu(node->btree[0].hashval),
(void *)(unsigned long) (void *)(unsigned long)
fs/xfs/xfs_dir_leaf.c
+4 -2
View File
@@ -743,10 +743,12 @@ xfs_dir_leaf_to_node(xfs_da_args_t *args)
node = bp1->data; node = bp1->data;
leaf = bp2->data; leaf = bp2->data;
ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR_LEAF_MAGIC); ASSERT(be16_to_cpu(leaf->hdr.info.magic) == XFS_DIR_LEAF_MAGIC);
INT_SET(node->btree[0].hashval, ARCH_CONVERT, INT_GET(leaf->entries[ INT_GET(leaf->hdr.count, ARCH_CONVERT)-1 ].hashval, ARCH_CONVERT)); node->btree[0].hashval = cpu_to_be32(
INT_GET(leaf->entries[
INT_GET(leaf->hdr.count, ARCH_CONVERT)-1].hashval, ARCH_CONVERT));
xfs_da_buf_done(bp2); xfs_da_buf_done(bp2);
node->btree[0].before = cpu_to_be32(blkno); node->btree[0].before = cpu_to_be32(blkno);
INT_SET(node->hdr.count, ARCH_CONVERT, 1); node->hdr.count = cpu_to_be16(1);
xfs_da_log_buf(args->trans, bp1, xfs_da_log_buf(args->trans, bp1,
XFS_DA_LOGRANGE(node, &node->btree[0], sizeof(node->btree[0]))); XFS_DA_LOGRANGE(node, &node->btree[0], sizeof(node->btree[0])));
xfs_da_buf_done(bp1); xfs_da_buf_done(bp1);