blob: 6cad10901db53c65d80b02eec306dd0e5291641a [file] [log] [blame] [edit]
/*
* Copyright (C) 2011 The Chromium OS Authors <chromium-os-dev@chromium.org>
*
* Device-Mapper block hash tree interface.
*
* This file is released under the GPL.
*/
#include <errno.h>
#include <string.h>
#include <asm/page.h>
#include <linux/device-mapper.h>
#include "verity/dm-bht.h"
#define DM_MSG_PREFIX "dm bht"
/**
* dm_bht_compute_hash: hashes a page of data
*/
static int dm_bht_compute_hash(struct dm_bht* bht,
const u8* buffer,
u8* digest) {
struct hash_desc* hash_desc = &bht->hash_desc[0];
/* Note, this is synchronous. */
if (crypto_hash_init(hash_desc)) {
DMCRIT("failed to reinitialize crypto hash");
return -EINVAL;
}
if (crypto_hash_update(hash_desc, buffer, PAGE_SIZE)) {
DMCRIT("crypto_hash_update failed");
return -EINVAL;
}
if (bht->have_salt) {
if (crypto_hash_update(hash_desc, bht->salt, sizeof(bht->salt))) {
DMCRIT("crypto_hash_update failed");
return -EINVAL;
}
}
if (crypto_hash_final(hash_desc, digest)) {
DMCRIT("crypto_hash_final failed");
return -EINVAL;
}
return 0;
}
void dm_bht_set_buffer(struct dm_bht* bht, void* buffer) {
int depth;
for (depth = 0; depth < bht->depth; ++depth) {
struct dm_bht_level* level = dm_bht_get_level(bht, depth);
struct dm_bht_entry* entry_end = level->entries + level->count;
struct dm_bht_entry* entry;
for (entry = level->entries; entry < entry_end; ++entry) {
entry->nodes = buffer;
memset(buffer, 0, PAGE_SIZE);
buffer += PAGE_SIZE;
}
}
}
/**
* dm_bht_compute - computes and updates all non-block-level hashes in a tree
* @bht: pointer to a dm_bht_create()d bht
*
* Returns 0 on success, >0 when data is pending, and <0 when a IO or other
* error has occurred.
*
* Walks the tree and computes the hashes at each level from the
* hashes below.
*/
int dm_bht_compute(struct dm_bht* bht) {
int depth, r = 0;
for (depth = bht->depth - 2; depth >= 0; depth--) {
struct dm_bht_level* level = dm_bht_get_level(bht, depth);
struct dm_bht_level* child_level = level + 1;
struct dm_bht_entry* entry = level->entries;
struct dm_bht_entry* child = child_level->entries;
unsigned int i, j;
for (i = 0; i < level->count; i++, entry++) {
unsigned int count = bht->node_count;
memset(entry->nodes, 0, PAGE_SIZE);
entry->state = DM_BHT_ENTRY_READY;
if (i == (level->count - 1))
count = child_level->count % bht->node_count;
if (count == 0)
count = bht->node_count;
for (j = 0; j < count; j++, child++) {
u8* digest = dm_bht_node(bht, entry, j);
r = dm_bht_compute_hash(bht, child->nodes, digest);
if (r) {
DMERR("Failed to update (d=%d,i=%u)", depth, i);
goto out;
}
}
}
}
r = dm_bht_compute_hash(bht, bht->levels[0].entries->nodes, bht->root_digest);
if (r)
DMERR("Failed to update root hash");
out:
return r;
}
/**
* dm_bht_store_block - sets a given block's hash in the tree
* @bht: pointer to a dm_bht_create()d bht
* @block: numeric index of the block in the tree
* @block_data: array of u8s containing the block of data to hash
*
* Returns 0 on success.
*
* If the containing entry in the tree is unallocated, it will allocate memory
* and mark the entry as ready. All other block entries will be 0s.
*
* It is up to the users of the update interface to ensure the entry data is
* fully populated prior to use. The number of updated entries is NOT tracked.
*/
int dm_bht_store_block(struct dm_bht* bht, unsigned int block, u8* block_data) {
int depth = bht->depth;
struct dm_bht_entry* entry = dm_bht_get_entry(bht, depth - 1, block);
u8* node = dm_bht_get_node(bht, entry, depth, block);
return dm_bht_compute_hash(bht, block_data, node);
}