verity: collapse check_block into verify_path

dm-bht.c

  /*
  * Copyright (C) 2010 The Chromium OS Authors <chromium-os-dev@chromium.org>
  *
  * Device-Mapper block hash tree interface.
  * See Documentation/device-mapper/dm-bht.txt for details.
  *
  * This file is released under the GPL.
  */
 
 #include <asm/atomic.h>
@@ skipping 573 matching lines @@
         u8 hex[DM_BHT_MAX_DIGEST_SIZE * 2 + 1];
 #endif
         memcpy(known, computed, bht->digest_size);
 #ifdef CONFIG_DM_DEBUG
         dm_bht_bin_to_hex(computed, hex, bht->digest_size);
         DMDEBUG("updating with hash: %s", hex);
 #endif
         return 0;
 }
 
-/* Check the disk block against the leaf hash. */
-static int dm_bht_check_block(struct dm_bht *bht, unsigned int block_index,
-                              const void *block)
-{
-        unsigned int depth = bht->depth;
-        struct dm_bht_entry *parent = dm_bht_get_entry(bht, depth - 1,
-                                                       block_index);
-        u8 digest[DM_BHT_MAX_DIGEST_SIZE];
-        u8 *node;
-
-        /* This call is only safe if all nodes along the path
-         * are already populated (i.e. READY) via dm_bht_populate.
-         */
-        BUG_ON(atomic_read(&parent->state) < DM_BHT_ENTRY_READY);
-
-        node = dm_bht_get_node(bht, parent, depth, block_index);
-        if (dm_bht_compute_hash(bht, block, digest) ||
-            dm_bht_compare_hash(bht, digest, node)) {
-                DMERR("failed to verify entry's hash against parent "
-                      "(d=%u,bi=%u)", depth, block_index);
-                return DM_BHT_ENTRY_ERROR_MISMATCH;
-        }
-        return 0;
-}
-
 /* Walk all entries at level 0 to compute the root digest.
  * 0 on success.
  */
 static int dm_bht_compute_root(struct dm_bht *bht, u8 *digest)
 {
         struct dm_bht_entry *entry;
         unsigned int count;
         struct scatterlist sg;  /* feeds digest() */
         struct hash_desc *hash_desc;
         hash_desc = &bht->hash_desc[smp_processor_id()];
@@ skipping 46 matching lines @@
                 DMCRIT("invalid root digest: %d", status);
                 dm_bht_log_mismatch(bht, bht->root_digest, digest);
                 return DM_BHT_ENTRY_ERROR_MISMATCH;
         }
         /* Could do a cmpxchg, but this should be safe. */
         atomic_set(&bht->root_state, DM_BHT_ENTRY_VERIFIED);
         return 0;
 }
 
 /* dm_bht_verify_path
- * Verifies the path from block_index to depth=0. Returns 0 on ok.
+ * Verifies the path. Returns 0 on ok.
  */
-static int dm_bht_verify_path(struct dm_bht *bht, unsigned int block_index)
+static int dm_bht_verify_path(struct dm_bht *bht, unsigned int block_index,
+                              const void *block)
 {
-        unsigned int depth = bht->depth - 1;
-        struct dm_bht_entry *entry = dm_bht_get_entry(bht, depth, block_index);
-        int state = atomic_read(&entry->state);
+        unsigned int depth = bht->depth;
+        struct dm_bht_entry *entry;
+        int state;
 
-        while (depth > 0 && state != DM_BHT_ENTRY_VERIFIED) {
+        do {
                 u8 digest[DM_BHT_MAX_DIGEST_SIZE];
-                struct dm_bht_entry *parent;
                 u8 *node;
 
-                /* We need to check that this entry matches the expected
-                 * hash in the parent->nodes.
+                /* Need to check that the hash of the current block is accurate
+                 * in its parent.
                  */
-                parent = dm_bht_get_entry(bht, depth - 1, block_index);
-                state = atomic_read(&parent->state);
+                entry = dm_bht_get_entry(bht, depth - 1, block_index);
+                state = atomic_read(&entry->state);
                 /* This call is only safe if all nodes along the path
                  * are already populated (i.e. READY) via dm_bht_populate.
                  */
                 BUG_ON(state < DM_BHT_ENTRY_READY);
-                node = dm_bht_get_node(bht, parent, depth, block_index);
+                node = dm_bht_get_node(bht, entry, depth, block_index);
 
-                if (dm_bht_compute_hash(bht, entry->nodes, digest) ||
+                if (dm_bht_compute_hash(bht, block, digest) ||
                     dm_bht_compare_hash(bht, digest, node))
                         goto mismatch;
 
-                entry = parent;
-                depth--;
-        }
+                /* Keep the containing block of hashes to be verified in the
+                 * next pass.
+                 */
+                block = entry->nodes;
+        } while (--depth > 0 && state != DM_BHT_ENTRY_VERIFIED);
 
         /* Mark path to leaf as verified. */
         for (depth++; depth < bht->depth; depth++) {
                 entry = dm_bht_get_entry(bht, depth, block_index);
                 atomic_cmpxchg(&entry->state,
                                DM_BHT_ENTRY_READY,
                                DM_BHT_ENTRY_VERIFIED);
         }
 
         DMDEBUG("verify_path: node %u is verified to root", block_index);
@@ skipping 312 matching lines @@
  * @block:      virtual address of the block data in memory
  *              (must be aligned to block size)
  *
  * Returns 0 on success, 1 on missing data, and a negative error
  * code on verification failure. All supporting functions called
  * should return similarly.
  */
 int dm_bht_verify_block(struct dm_bht *bht, unsigned int block_index,
                         const void *block)
 {
-        int unverified = 0;
+        int r = 0;
 
         /* Make sure that the root has been verified */
         if (atomic_read(&bht->root_state) != DM_BHT_ENTRY_VERIFIED) {
-                unverified = dm_bht_verify_root(bht, dm_bht_compare_hash);
-                if (unverified) {
-                        DMERR_LIMIT("Failed to verify root: %d", unverified);
-                        return unverified;
+                r = dm_bht_verify_root(bht, dm_bht_compare_hash);
+                if (r) {
+                        DMERR_LIMIT("Failed to verify root: %d", r);
+                        goto out;
                 }
         }
 
-        /* Now check that the digest supplied matches the leaf hash */
-        unverified = dm_bht_check_block(bht, block_index, block);
-        if (unverified) {
-                DMERR_LIMIT("Block check failed for %u: %d", block_index,
-                                unverified);
-                return unverified;
-        }
+        /* Now check levels in between */
+        r = dm_bht_verify_path(bht, block_index, block);
+        if (r)
+                DMERR_LIMIT("Failed to verify block: %u (%d)", block_index, r);
 
-        /* Now check levels in between */
-        unverified = dm_bht_verify_path(bht, block_index);
-        if (unverified)
-                DMERR_LIMIT("Failed to verify intermediary nodes for block: %u (%d)",
-                      block_index, unverified);
-        return unverified;
+out:
+        return r;
 }
 EXPORT_SYMBOL(dm_bht_verify_block);
 
 /**
  * dm_bht_destroy - cleans up all memory used by @bht
  * @bht:        pointer to a dm_bht_create()d bht
  *
  * Returns 0 on success. Does not free @bht itself.
  */
 int dm_bht_destroy(struct dm_bht *bht)
@@ skipping 135 matching lines @@
                 DMERR("no root digest exists to export");
                 if (available > 0)
                         *hexdigest = 0;
                 return -1;
         }
         dm_bht_bin_to_hex(bht->root_digest, hexdigest, bht->digest_size);
         return 0;
 }
 EXPORT_SYMBOL(dm_bht_root_hexdigest);