CHROMIUM: verity: use sg_set_buf instead of sg_set_page

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 77 matching lines @@
         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_hash: hashes a page of data
  */
-static int dm_bht_compute_hash(struct dm_bht *bht, struct page *page,
+static int dm_bht_compute_hash(struct dm_bht *bht, const void *block,
                                u8 *digest)
 {
         struct hash_desc *hash_desc = &bht->hash_desc[smp_processor_id()];
         struct scatterlist sg;
 
+        /* TODO(msb): Once we supporting block_size < PAGE_SIZE, change this to:
+         *            offset_into_page + length < page_size
+         * For now just check that block is page-aligned.
+         */
+        BUG_ON((uintptr_t)block % PAGE_SIZE);

[Will Drewry, 2011/03/11 21:32:29]

IS_ALIGNED(block, PAGE_SIZE)?

+
         sg_init_table(&sg, 1);
-        sg_set_page(&sg, page, PAGE_SIZE, 0);
+        sg_set_buf(&sg, block, PAGE_SIZE);
         /* 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;
         }
@@ skipping 478 matching lines @@
                                                        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, virt_to_page(block), digest) ||
+        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.
@@ skipping 14 matching lines @@
         }
 
         /* Point the scatterlist to the entries, then compute the digest */
         for (count = 0; count < bht->levels[0].count; ++count, ++entry) {
                 if (atomic_read(&entry->state) <= DM_BHT_ENTRY_PENDING) {
                         DMCRIT("data not ready to compute root: %u",
                                count);
                         return 1;
                 }
                 sg_init_table(&sg, 1);
-                sg_set_page(&sg, virt_to_page(entry->nodes), PAGE_SIZE, 0);
+                sg_set_buf(&sg, entry->nodes, PAGE_SIZE);
                 if (crypto_hash_update(hash_desc, &sg, PAGE_SIZE)) {
                         DMCRIT("Failed to update crypto hash");
                         return -EINVAL;
                 }
         }
 
         if (crypto_hash_final(hash_desc, digest)) {
                 DMCRIT("Failed to compute final digest");
                 return -EINVAL;
         }
@@ skipping 29 matching lines @@
  * 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)
 {
         unsigned int depth = bht->depth - 1;
         struct dm_bht_entry *entry = dm_bht_get_entry(bht, depth, block_index);
 
         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);
                 /* TODO(msb,wad): would be nice to avoid two atomic reads */
                 state = atomic_read(&entry->state);
                 if (state == DM_BHT_ENTRY_VERIFIED) {
                         DMDEBUG("verify_path node %u is verified to root",
                                 block_index);
                         depth++; /* avoid an extra cmpxchg */
@@ skipping 11 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_hash(bht, page, digest) ||
+                if (dm_bht_compute_hash(bht, entry->nodes, digest) ||
                     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;
                 }
 
                 entry = parent;
                 depth--;
         }
         /* Mark path to leaf as verified. */
@@ skipping 76 matching lines @@
                 atomic_set(&entry->state, DM_BHT_ENTRY_READY);
         } 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;
         }
 
-        dm_bht_compute_hash(bht, virt_to_page(block_data),
+        dm_bht_compute_hash(bht, 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
@@ skipping 45 matching lines @@
 
                 r = dm_bht_maybe_read_entries(bht, read_cb_ctx, depth,
                                               0, level->count, true);
                 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);
+                                u8 *block = child->nodes;
+                                u8 *digest = dm_bht_node(bht, entry, j);
 
-                                r = dm_bht_compute_hash(bht, pg, node);
+                                r = dm_bht_compute_hash(bht, block, digest);
                                 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 142 matching lines @@
         return populated;
 }
 EXPORT_SYMBOL(dm_bht_populate);
 
 
 /**
  * dm_bht_verify_block - checks that all nodes in the path for @block are valid
  * @bht:        pointer to a dm_bht_create()d bht
  * @block_index:specific block data is expected from
  * @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;
 
@@ skipping 168 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);