dm-bht-userspace.c

 /*
 * 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);
}