[XFS] Minor code rearranging and cleanup to prevent some coverity false

positives.

SGI-PV: 955502
SGI-Modid: xfs-linux-melb:xfs-kern:26805a

Signed-off-by: Nathan Scott <nathans@sgi.com>
Signed-off-by: Tim Shimmin <tes@sgi.com>

1 files changed, 18 insertions, 15 deletions

diff --git a/fs/xfs/xfs_da_btree.c b/fs/xfs/xfs_da_btree.c
index 32ab61d17ace..a68bc1f1a313 100644
--- a/fs/xfs/xfs_da_btree.c
+++ b/fs/xfs/xfs_da_btree.c
@@ -1054,7 +1054,7 @@ xfs_da_node_lookup_int(xfs_da_state_t *state, int *result)
         xfs_da_node_entry_t *btree;
         xfs_dablk_t blkno;
         int probe, span, max, error, retval;
-        xfs_dahash_t hashval;
+        xfs_dahash_t hashval, btreehashval;
         xfs_da_args_t *args;
 
         args = state->args;
@@ -1079,30 +1079,32 @@ xfs_da_node_lookup_int(xfs_da_state_t *state, int *result)
                         return(error);
                 }
                 curr = blk->bp->data;
-                ASSERT(be16_to_cpu(curr->magic) == XFS_DA_NODE_MAGIC ||
-                       be16_to_cpu(curr->magic) == XFS_DIR2_LEAFN_MAGIC ||
-                       be16_to_cpu(curr->magic) == XFS_ATTR_LEAF_MAGIC);
+                blk->magic = be16_to_cpu(curr->magic);
+                ASSERT(blk->magic == XFS_DA_NODE_MAGIC ||
+                       blk->magic == XFS_DIR2_LEAFN_MAGIC ||
+                       blk->magic == XFS_ATTR_LEAF_MAGIC);
 
                 /*
                  * Search an intermediate node for a match.
                  */
-                blk->magic = be16_to_cpu(curr->magic);
                 if (blk->magic == XFS_DA_NODE_MAGIC) {
                         node = blk->bp->data;
-                        blk->hashval = be32_to_cpu(node->btree[be16_to_cpu(node->hdr.count)-1].hashval);
+                        max = be16_to_cpu(node->hdr.count);
+                        btreehashval = node->btree[max-1].hashval;
+                        blk->hashval = be32_to_cpu(btreehashval);
 
                         /*
                          * Binary search.  (note: small blocks will skip loop)
                          */
-                        max = be16_to_cpu(node->hdr.count);
                         probe = span = max / 2;
                         hashval = args->hashval;
                         for (btree = &node->btree[probe]; span > 4;
                                    btree = &node->btree[probe]) {
                                 span /= 2;
-                                if (be32_to_cpu(btree->hashval) < hashval)
+                                btreehashval = be32_to_cpu(btree->hashval);
+                                if (btreehashval < hashval)
                                         probe += span;
-                                else if (be32_to_cpu(btree->hashval) > hashval)
+                                else if (btreehashval > hashval)
                                         probe -= span;
                                 else
                                         break;
@@ -1133,10 +1135,10 @@ xfs_da_node_lookup_int(xfs_da_state_t *state, int *result)
                                 blk->index = probe;
                                 blkno = be32_to_cpu(btree->before);
                         }
-                } else if (be16_to_cpu(curr->magic) == XFS_ATTR_LEAF_MAGIC) {
+                } else if (blk->magic == XFS_ATTR_LEAF_MAGIC) {
                         blk->hashval = xfs_attr_leaf_lasthash(blk->bp, NULL);
                         break;
-                } else if (be16_to_cpu(curr->magic) == XFS_DIR2_LEAFN_MAGIC) {
+                } else if (blk->magic == XFS_DIR2_LEAFN_MAGIC) {
                         blk->hashval = xfs_dir2_leafn_lasthash(blk->bp, NULL);
                         break;
                 }
@@ -1152,11 +1154,13 @@ xfs_da_node_lookup_int(xfs_da_state_t *state, int *result)
                 if (blk->magic == XFS_DIR2_LEAFN_MAGIC) {
                         retval = xfs_dir2_leafn_lookup_int(blk->bp, args,
                                                         &blk->index, state);
-                }
-                else if (blk->magic == XFS_ATTR_LEAF_MAGIC) {
+                } else if (blk->magic == XFS_ATTR_LEAF_MAGIC) {
                         retval = xfs_attr_leaf_lookup_int(blk->bp, args);
                         blk->index = args->index;
                         args->blkno = blk->blkno;
+                } else {
+                        ASSERT(0);
+                        return XFS_ERROR(EFSCORRUPTED);
                 }
                 if (((retval == ENOENT) || (retval == ENOATTR)) &&
                     (blk->hashval == args->hashval)) {
@@ -1166,8 +1170,7 @@ xfs_da_node_lookup_int(xfs_da_state_t *state, int *result)
                                 return(error);
                         if (retval == 0) {
                                 continue;
-                        }
-                        else if (blk->magic == XFS_ATTR_LEAF_MAGIC) {
+                        } else if (blk->magic == XFS_ATTR_LEAF_MAGIC) {
                                 /* path_shift() gives ENOENT */
                                 retval = XFS_ERROR(ENOATTR);
                         }