verity: extract the compare part out of compute_and_compare

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 75 matching lines @@
         u8 computed_hex[DM_BHT_MAX_DIGEST_SIZE * 2 + 1];
         dm_bht_bin_to_hex(given, given_hex, bht->digest_size);
         dm_bht_bin_to_hex(computed, computed_hex, bht->digest_size);
         DMERR_LIMIT("%s != %s", given_hex, computed_hex);
 }
 
 /* Used for turning verifiers into computers */
 typedef int (*dm_bht_compare_cb)(struct dm_bht *, u8 *, u8 *);
 
 /**
  * dm_bht_compute_and_compare: hashes a page of data; compares it to a hash

[Will Drewry, 2011/01/11 21:38:45]

please update the comment

  */
-static int dm_bht_compute_and_compare(struct dm_bht *bht,
-                                      struct hash_desc *hash_desc,
-                                      struct page *page,
-                                      u8 *expected_digest,
-                                      dm_bht_compare_cb compare_cb)
+static int dm_bht_compute_hash(struct dm_bht *bht, struct hash_desc *hash_desc,
+                               struct page *page, u8 *digest)
 {
         struct scatterlist sg;
-        u8 digest[DM_BHT_MAX_DIGEST_SIZE];
-        int result;
 
         sg_init_table(&sg, 1);
         sg_set_page(&sg, page, PAGE_SIZE, 0);
         /* Note, this is synchronous. */
         if (crypto_hash_init(hash_desc)) {
                 DMCRIT("failed to reinitialize crypto hash (proc:%d)",
                         smp_processor_id());
                 return -EINVAL;
         }
         if (crypto_hash_digest(hash_desc, &sg, PAGE_SIZE, digest)) {
                 DMCRIT("crypto_hash_digest failed");
                 return -EINVAL;
         }
 
-        result = compare_cb(bht, expected_digest, digest);
-#ifdef CONFIG_DM_DEBUG
-        if (result)
-                dm_bht_log_mismatch(bht, expected_digest, digest);
-#endif
-        return result;
+        return 0;
 }
 
 static __always_inline struct dm_bht_level *dm_bht_get_level(struct dm_bht *bht,
                                                              unsigned int depth)
 {
         return &bht->levels[depth];
 }
 
 static __always_inline unsigned int dm_bht_get_level_shift(struct dm_bht *bht,
                                                   unsigned int depth)
@@ skipping 572 matching lines @@
                 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.
  */
-static int dm_bht_verify_path(struct dm_bht *bht, unsigned int block_index,
-                              dm_bht_compare_cb compare_cb)
+static int dm_bht_verify_path(struct dm_bht *bht, unsigned int block_index)
 {
         unsigned int depth = bht->depth - 1;
         struct dm_bht_entry *entry = dm_bht_get_entry(bht, depth, block_index);
         struct hash_desc *hash_desc = &bht->hash_desc[smp_processor_id()];
 
         while (depth > 0) {
+                u8 digest[DM_BHT_MAX_DIGEST_SIZE];
                 struct dm_bht_entry *parent;
+                struct page *page;
                 u8 *node;
                 int state;
 
                 DMDEBUG("verify_path for b=%u on d=%d", block_index, depth);
                 state = atomic_read(&entry->state);
                 if (state == DM_BHT_ENTRY_VERIFIED) {
                         DMDEBUG("verify_path node %u is verified in parent",
                                 block_index);
                         entry = dm_bht_get_entry(bht, --depth, block_index);
                         continue;
@@ skipping 16 matching lines @@
 
                 /* We need to check that this entry matches the expected
                  * hash in the parent->nodes.
                  */
                 parent = dm_bht_get_entry(bht, depth - 1, block_index);
                 /* 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);
+                page = virt_to_page(entry->nodes);
 
-                if (dm_bht_compute_and_compare(bht, hash_desc,
-                                               virt_to_page(entry->nodes),
-                                               node, compare_cb)) {
+                if (dm_bht_compute_hash(bht, hash_desc, page, digest) ||

[Will Drewry, 2011/01/11 21:38:45]

is there a tab hiding before page or is it a rietveld weirdness?

+                    dm_bht_compare_hash(bht, digest, node)) {
                         DMERR("failed to verify entry's hash against parent "
                               "(d=%u,bi=%u)", depth, block_index);
                         goto mismatch;
                 }
 
                 if (bht->verify_mode != DM_BHT_FULL_REVERIFY)
                         atomic_cmpxchg(&entry->state,
                                        DM_BHT_ENTRY_READY,
                                        DM_BHT_ENTRY_VERIFIED);
 
@@ skipping 75 matching lines @@
         } else if (state <= DM_BHT_ENTRY_ERROR) {
                 DMCRIT("leaf entry for block %u is invalid",
                       block_index);
                 return state;
         } else if (state == DM_BHT_ENTRY_PENDING) {
                 DMERR("leaf data is pending for block %u", block_index);
                 return 1;
         }
 
         hash_desc = &bht->hash_desc[smp_processor_id()];
-        dm_bht_compute_and_compare(bht, hash_desc, virt_to_page(block_data),
-                                   dm_bht_node(bht, entry, node_index),
-                                   &dm_bht_update_hash);
+        dm_bht_compute_hash(bht, hash_desc, virt_to_page(block_data),
+                            dm_bht_node(bht, entry, node_index));
         return 0;
 }
 EXPORT_SYMBOL(dm_bht_store_block);
 
 /**
  * dm_bht_zeroread_callback - read callback which always returns 0s
  * @ctx:        ignored
  * @start:      ignored
  * @data:       buffer to write 0s to
  * @count:      number of sectors worth of data to write
@@ skipping 48 matching lines @@
                 if (r < 0) {
                         DMCRIT("an error occurred while reading entry");
                         goto out;
                 }
 
                 for (i = 0; i < level->count; i++, entry++) {
                         for (j = 0; j < count; j++, child++) {
                                 struct page *pg = virt_to_page(child->nodes);
                                 u8 *node = dm_bht_node(bht, entry, j);
 
-                                r = dm_bht_compute_and_compare(bht, hash_desc,
-                                                pg, node, dm_bht_update_hash);
+                                r = dm_bht_compute_hash(bht, hash_desc,
+                                                        pg, node);
                                 if (r) {
                                         DMERR("Failed to update (d=%u,i=%u)",
                                               depth, i);
                                         goto out;
                                 }
                         }
                 }
         }
         /* Don't forget the root digest! */
         DMDEBUG("Calling verify_root with update_hash");
@@ skipping 187 matching lines @@
         /* If the entry which contains the block hash is marked verified, then
          * it means that its hash has been check with the parent.  In addition,
          * since that is only possible via verify_path, it transitively means
          * it is verified to the root of the tree. If the depth is 1, then it
          * means the entry was verified during root verification.
          */
         if (entry_state == DM_BHT_ENTRY_VERIFIED || bht->depth == 1)
                 return unverified;
 
         /* Now check levels in between */
-        unverified = dm_bht_verify_path(bht,
-                                        block_index,
-                                        dm_bht_compare_hash);
+        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;
 }
 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
@@ skipping 150 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);