CHROMIUM: verity: do all hashing in dm-bht.c

drivers/md/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 145 matching lines @@
 
         return &level->entries[index];
 }
 
 static inline u8 *dm_bht_get_node(struct dm_bht *bht,
                                   struct dm_bht_entry *entry,
                                   unsigned int depth,
                                   unsigned int block_index)
 {
         unsigned int index = dm_bht_index_at_level(bht, depth, block_index);
-        struct dm_bht_level *level = dm_bht_get_level(bht, depth);
-
-        BUG_ON(index >= level->count);
 
         return dm_bht_node(bht, entry, index % bht->node_count);
 }
 
 
 /*-----------------------------------------------
  * Implementation functions
  *-----------------------------------------------*/
 
 static int dm_bht_initialize_entries(struct dm_bht *bht);
@@ skipping 404 matching lines @@
         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;
 }
 
 /* digest length and bht must be checked already */
 static int dm_bht_check_block(struct dm_bht *bht, unsigned int block_index,
-                              u8 *digest, int *entry_state)
+                              const void *buf, int *entry_state)

[Will Drewry, 2011/03/08 20:53:59]

nit: might prefer something more meaningful like "block" instead of just "buf".

 {
-        int depth;
-        unsigned int index;
-        struct dm_bht_entry *entry;
-
-        /* The leaves contain the block hashes */
-        depth = bht->depth - 1;
-
-        /* Index into the bottom level.  Each entry in this level contains
-         * nodes whose hashes are the direct hashes of one block of data on
-         * disk.
-         */
-        index = block_index >> bht->node_count_shift;
-        entry = &bht->levels[depth].entries[index];
+        unsigned int depth = bht->depth;
+        struct dm_bht_entry *parent = dm_bht_get_entry(bht, depth - 1,
+                                                       block_index);
+        struct hash_desc *hash_desc = &bht->hash_desc[smp_processor_id()];
+        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(&entry->state) < DM_BHT_ENTRY_READY);
+        *entry_state = atomic_read(&parent->state);
+        BUG_ON(*entry_state < DM_BHT_ENTRY_READY);
 
-        /* Index into the entry data */
-        index = (block_index % bht->node_count) * bht->digest_size;
-        if (memcmp(&entry->nodes[index], digest, bht->digest_size)) {
-                DMCRIT("digest mismatch for block %u", block_index);
-                dm_bht_log_mismatch(bht, &entry->nodes[index], digest);
+        node = dm_bht_get_node(bht, parent, depth, block_index);
+        if (dm_bht_compute_hash(bht, hash_desc, virt_to_page(buf), 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)
 {
@@ skipping 433 matching lines @@
  * @bht:        pointer to a dm_bht_create()d bht
  * @block_index:specific block data is expected from
  * @digest:     computed digest for the given block to be checked
  * @digest_len: length of @digest
  *
  * 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,
-                                u8 *digest, unsigned int digest_len)
+                        const void *buf)

[Will Drewry, 2011/03/08 20:53:59]

Please update the comments.

 {
         int unverified = 0;
         int entry_state = 0;
 
-        /* TODO(wad) do we really need this? */
-        if (digest_len != bht->digest_size) {
-                DMERR("invalid digest_len passed to verify_block");
-                return -EINVAL;
-        }
-
         /* 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;
                 }
         }
 
         /* Now check that the digest supplied matches the leaf hash */
-        unverified = dm_bht_check_block(bht, block_index, digest, &entry_state);
+        unverified = dm_bht_check_block(bht, block_index, buf, &entry_state);
         if (unverified) {
                 DMERR_LIMIT("Block check failed for %u: %d", block_index,
                                 unverified);
                 return unverified;
         }
 
         /* 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
@@ skipping 167 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);