firmware: Prune down old region API

The region API was a way for firmware and kernel verification to get
at various blocks of caller-provided data.  In practice, we only used
it internally as a way to get at parts of the GBB.  Prune it down to
access only the bits of GBB we still need, from the buffer we already
know we have.

In the long run we should use the same vb2ex_read_resource() API that
vb2 firmware verification does, but that should be done in a follow-up
CL since it'll need to be coordinated with support in depthcharge.

No change in functionality.

BUG=chromium:611535
BRANCH=none
TEST=make -j runtests; build bob firmware and boot it

Change-Id: I5715cb8d88274164a1a73ed4a56bbd93af46f9bf
Signed-off-by: Randall Spangler <rspangler@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/852798
Commit-Ready: ChromeOS CL Exonerator Bot <chromiumos-cl-exonerator@appspot.gserviceaccount.com>
Reviewed-by: Stefan Reinauer <reinauer@chromium.org>

8 files changed, 48 insertions, 288 deletions

diff --git a/tests/ec_sync_tests.c b/tests/ec_sync_tests.c
index 332290ae..3dcc6803 100644
--- a/tests/ec_sync_tests.c
+++ b/tests/ec_sync_tests.c
@@ -29,7 +29,6 @@
 static VbCommonParams cparams;
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
-static GoogleBinaryBlockHeader gbb;
 
 static int mock_in_rw;
 static VbError_t in_rw_retval;
@@ -69,13 +68,6 @@ static void ResetMocks(void)
 	memset(&cparams, 0, sizeof(cparams));
 	cparams.shared_data_size = sizeof(shared_data);
 	cparams.shared_data_blob = shared_data;
-	cparams.gbb_data = &gbb;
-
-	memset(&gbb, 0, sizeof(gbb));
-	gbb.major_version = GBB_MAJOR_VER;
-	gbb.minor_version = GBB_MINOR_VER;
-	gbb.flags = 0;
-	cparams.gbb = &gbb;
 
 	memset(&ctx, 0, sizeof(ctx));
 	ctx.workbuf = workbuf;
diff --git a/tests/vboot_api_devmode_tests.c b/tests/vboot_api_devmode_tests.c
index 330a89ac..916cf068 100644
--- a/tests/vboot_api_devmode_tests.c
+++ b/tests/vboot_api_devmode_tests.c
@@ -100,7 +100,6 @@ static struct vb2_context ctx;
 static struct vb2_shared_data *sd;
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader* shared = (VbSharedDataHeader*)shared_data;
-static GoogleBinaryBlockHeader gbb;
 static int current_time;
 static uint64_t current_ticks;
 static int current_event;
@@ -118,8 +117,6 @@ extern int audio_open_count;
 static void ResetMocks(void)
 {
 	memset(&cparams, 0, sizeof(cparams));
-	cparams.gbb_data = &gbb;
-	cparams.gbb = &gbb;
 
 	memset(&ctx, 0, sizeof(ctx));
 	ctx.workbuf = workbuf;
@@ -134,11 +131,6 @@ static void ResetMocks(void)
 	VbSharedDataInit(shared, sizeof(shared_data));
 	shared->fw_keyblock_flags = 0xABCDE0;
 
-	memset(&gbb, 0, sizeof(gbb));
-	gbb.major_version = GBB_MAJOR_VER;
-	gbb.minor_version = GBB_MINOR_VER;
-	gbb.flags = 0;
-
 	current_ticks = 0;
 	current_time = 0;
 
diff --git a/tests/vboot_api_kernel2_tests.c b/tests/vboot_api_kernel2_tests.c
index 04e64667..92041207 100644
--- a/tests/vboot_api_kernel2_tests.c
+++ b/tests/vboot_api_kernel2_tests.c
@@ -28,7 +28,6 @@
 static VbCommonParams cparams;
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
-static GoogleBinaryBlockHeader gbb;
 static LoadKernelParams lkp;
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
 static struct vb2_context ctx;
@@ -59,13 +58,6 @@ extern struct RollbackSpaceFwmp *VbApiKernelGetFwmp(void);
 static void ResetMocks(void)
 {
 	memset(&cparams, 0, sizeof(cparams));
-	cparams.gbb_data = &gbb;
-	cparams.gbb = &gbb;
-
-	memset(&gbb, 0, sizeof(gbb));
-	gbb.major_version = GBB_MAJOR_VER;
-	gbb.minor_version = GBB_MINOR_VER;
-	gbb.flags = 0;
 
 	memset(VbApiKernelGetFwmp(), 0, sizeof(struct RollbackSpaceFwmp));
 
@@ -212,48 +204,48 @@ static void VbUserConfirmsTest(void)
 
 	ResetMocks();
 	shutdown_request_calls_left = 1;
-	TEST_EQ(VbUserConfirms(&ctx, &cparams, 0), -1, "Shutdown requested");
+	TEST_EQ(VbUserConfirms(&ctx, 0), -1, "Shutdown requested");
 
 	ResetMocks();
 	mock_keypress[0] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbUserConfirms(&ctx, &cparams, 0), -1, "Shutdown requested");
+	TEST_EQ(VbUserConfirms(&ctx, 0), -1, "Shutdown requested");
 
 	ResetMocks();
 	mock_keypress[0] = '\r';
-	TEST_EQ(VbUserConfirms(&ctx, &cparams, 0), 1, "Enter");
+	TEST_EQ(VbUserConfirms(&ctx, 0), 1, "Enter");
 
 	ResetMocks();
 	mock_keypress[0] = 0x1b;
-	TEST_EQ(VbUserConfirms(&ctx, &cparams, 0), 0, "Esc");
+	TEST_EQ(VbUserConfirms(&ctx, 0), 0, "Esc");
 
 	ResetMocks();
 	mock_keypress[0] = ' ';
 	shutdown_request_calls_left = 1;
-	TEST_EQ(VbUserConfirms(&ctx, &cparams, VB_CONFIRM_SPACE_MEANS_NO), 0,
+	TEST_EQ(VbUserConfirms(&ctx, VB_CONFIRM_SPACE_MEANS_NO), 0,
                 "Space means no");
 
 	ResetMocks();
 	mock_keypress[0] = ' ';
 	shutdown_request_calls_left = 1;
-	TEST_EQ(VbUserConfirms(&ctx, &cparams, 0), -1, "Space ignored");
+	TEST_EQ(VbUserConfirms(&ctx, 0), -1, "Space ignored");
 
 	ResetMocks();
 	mock_keypress[0] = '\r';
 	mock_keyflags[0] = VB_KEY_FLAG_TRUSTED_KEYBOARD;
-	TEST_EQ(VbUserConfirms(&ctx, &cparams, VB_CONFIRM_MUST_TRUST_KEYBOARD),
+	TEST_EQ(VbUserConfirms(&ctx, VB_CONFIRM_MUST_TRUST_KEYBOARD),
 		1, "Enter with trusted keyboard");
 
 	ResetMocks();
 	mock_keypress[0] = '\r';	/* untrusted */
 	mock_keypress[1] = ' ';
-	TEST_EQ(VbUserConfirms(&ctx, &cparams,
+	TEST_EQ(VbUserConfirms(&ctx,
 			       VB_CONFIRM_SPACE_MEANS_NO |
 			       VB_CONFIRM_MUST_TRUST_KEYBOARD),
 		0, "Untrusted keyboard");
 
 	ResetMocks();
 	mock_switches[0] = VB_INIT_FLAG_REC_BUTTON_PRESSED;
-	TEST_EQ(VbUserConfirms(&ctx, &cparams,
+	TEST_EQ(VbUserConfirms(&ctx,
 			       VB_CONFIRM_SPACE_MEANS_NO |
 			       VB_CONFIRM_MUST_TRUST_KEYBOARD),
 		1, "Recovery button");
@@ -265,7 +257,7 @@ static void VbUserConfirmsTest(void)
 	mock_keypress[3] = ' ';
 	mock_switches[0] = VB_INIT_FLAG_REC_BUTTON_PRESSED;
 	mock_switches_are_stuck = 1;
-	TEST_EQ(VbUserConfirms(&ctx, &cparams,
+	TEST_EQ(VbUserConfirms(&ctx,
 			       VB_CONFIRM_SPACE_MEANS_NO |
 			       VB_CONFIRM_MUST_TRUST_KEYBOARD),
 		0, "Recovery button stuck");
diff --git a/tests/vboot_api_kernel5_tests.c b/tests/vboot_api_kernel5_tests.c
index fc54eb7a..a831e7f5 100644
--- a/tests/vboot_api_kernel5_tests.c
+++ b/tests/vboot_api_kernel5_tests.c
@@ -34,7 +34,8 @@ static VbCommonParams cparams;
 static VbSelectAndLoadKernelParams kparams;
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
-static GoogleBinaryBlockHeader gbb;
+static uint8_t gbb_buf[4096];
+static GoogleBinaryBlockHeader *gbb = (GoogleBinaryBlockHeader *)gbb_buf;
 
 static uint8_t kernel_buffer[80000];
 static int key_block_verify_fail;  /* 0=ok, 1=sig, 2=hash */
@@ -55,15 +56,17 @@ static void ResetMocks(void)
 	memset(&cparams, 0, sizeof(cparams));
 	cparams.shared_data_size = sizeof(shared_data);
 	cparams.shared_data_blob = shared_data;
-	cparams.gbb_data = &gbb;
-	cparams.gbb_size = sizeof(gbb);
+	cparams.gbb_data = gbb_buf;
+	cparams.gbb_size = sizeof(gbb_buf);
 
 	memset(&kparams, 0, sizeof(kparams));
 
-	memset(&gbb, 0, sizeof(gbb));
-	gbb.major_version = GBB_MAJOR_VER;
-	gbb.minor_version = GBB_MINOR_VER;
-	gbb.flags = 0;
+	memset(gbb_buf, 0, sizeof(gbb_buf));
+	gbb->major_version = GBB_MAJOR_VER;
+	gbb->minor_version = GBB_MINOR_VER;
+	gbb->flags = 0;
+	gbb->rootkey_offset = sizeof(*gbb);
+	gbb->rootkey_size = sizeof(VbPublicKey);
 
 	memset(&ctx, 0, sizeof(ctx));
 	ctx.workbuf = workbuf;
@@ -223,7 +226,7 @@ static void VerifyMemoryBootImageTest(void)
 	/* Key Block Hash Failure */
 	ResetMocks();
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
-	gbb.flags = GBB_FLAG_FORCE_DEV_BOOT_FASTBOOT_FULL_CAP;
+	gbb->flags = GBB_FLAG_FORCE_DEV_BOOT_FASTBOOT_FULL_CAP;
 	key_block_verify_fail = 1;
 	TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer,
 					kernel_buffer_size),
@@ -256,7 +259,7 @@ static void VerifyMemoryBootImageTest(void)
 	kbh.key_block_flags = KEY_BLOCK_FLAG_DEVELOPER_0 |
 		KEY_BLOCK_FLAG_RECOVERY_1;
 	copy_kbh();
-	gbb.flags = GBB_FLAG_FORCE_DEV_BOOT_FASTBOOT_FULL_CAP;
+	gbb->flags = GBB_FLAG_FORCE_DEV_BOOT_FASTBOOT_FULL_CAP;
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
 	TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer,
 					kernel_buffer_size),
@@ -269,7 +272,7 @@ static void VerifyMemoryBootImageTest(void)
 		KEY_BLOCK_FLAG_RECOVERY_0;
 	copy_kbh();
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
-	gbb.flags = GBB_FLAG_FORCE_DEV_BOOT_FASTBOOT_FULL_CAP;
+	gbb->flags = GBB_FLAG_FORCE_DEV_BOOT_FASTBOOT_FULL_CAP;
 	TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer,
 					kernel_buffer_size),
 		VBERROR_SUCCESS,
diff --git a/tests/vboot_detach_menu_tests.c b/tests/vboot_detach_menu_tests.c
index 0e3cc3b0..db04f6ba 100644
--- a/tests/vboot_detach_menu_tests.c
+++ b/tests/vboot_detach_menu_tests.c
@@ -30,7 +30,6 @@
 static VbCommonParams cparams;
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
-static GoogleBinaryBlockHeader gbb;
 static LoadKernelParams lkp;
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
 static struct vb2_context ctx;
@@ -61,13 +60,6 @@ extern struct RollbackSpaceFwmp *VbApiKernelGetFwmp(void);
 static void ResetMocks(void)
 {
 	memset(&cparams, 0, sizeof(cparams));
-	cparams.gbb_data = &gbb;
-	cparams.gbb = &gbb;
-
-	memset(&gbb, 0, sizeof(gbb));
-	gbb.major_version = GBB_MAJOR_VER;
-	gbb.minor_version = GBB_MINOR_VER;
-	gbb.flags = 0;
 
 	memset(VbApiKernelGetFwmp(), 0, sizeof(struct RollbackSpaceFwmp));
 
diff --git a/tests/vboot_display_tests.c b/tests/vboot_display_tests.c
index 7ddc28e9..a6d2b9f4 100644
--- a/tests/vboot_display_tests.c
+++ b/tests/vboot_display_tests.c
@@ -15,9 +15,9 @@
 #include "2misc.h"
 #include "2nvstorage.h"
 #include "bmpblk_font.h"
+#include "gbb_access.h"
 #include "gbb_header.h"
 #include "host_common.h"
-#include "region.h"
 #include "test_common.h"
 #include "vboot_common.h"
 #include "vboot_display.h"
@@ -31,6 +31,7 @@ static char gbb_data[4096 + sizeof(GoogleBinaryBlockHeader)];
 static GoogleBinaryBlockHeader *gbb = (GoogleBinaryBlockHeader *)gbb_data;
 static char debug_info[4096];
 static struct vb2_context ctx;
+struct vb2_shared_data *sd;
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
 static uint32_t mock_localization_count;
 
@@ -55,12 +56,6 @@ static void ResetMocks(void)
 	memset(&cparams, 0, sizeof(cparams));
 	cparams.gbb_data = gbb;
 	cparams.gbb_size = sizeof(gbb_data);
-
-	/*
-	 * Note, VbApiKernelFree() expects this to be allocated by
-	 * malloc(), so we cannot just assign it staticly.
-	 */
-	cparams.gbb = malloc(sizeof(*gbb));
 	gbb->header_size = sizeof(*gbb);
 	gbb->rootkey_offset = gbb_used;
 	gbb->rootkey_size = 64;
@@ -68,7 +63,6 @@ static void ResetMocks(void)
 	gbb->recovery_key_offset = gbb_used;
 	gbb->recovery_key_size = 64;
 	gbb_used += 64;
-	memcpy(cparams.gbb, gbb, sizeof(*gbb));
 
 	memset(&ctx, 0, sizeof(ctx));
 	ctx.workbuf = workbuf;
@@ -76,8 +70,10 @@ static void ResetMocks(void)
 	vb2_init_context(&ctx);
 	vb2_nv_init(&ctx);
 
-	struct vb2_shared_data *sd = vb2_get_sd(&ctx);
+	sd = vb2_get_sd(&ctx);
 	sd->vbsd = shared;
+	sd->gbb = (struct vb2_gbb_header *)gbb_data;
+	sd->gbb_size = sizeof(gbb_data);
 
 	memset(&shared_data, 0, sizeof(shared_data));
 	VbSharedDataInit(shared, sizeof(shared_data));
@@ -106,7 +102,7 @@ VbError_t VbExDisplayDebugInfo(const char *info_str)
 /* Test displaying debug info */
 static void DebugInfoTest(void)
 {
-	char hwid[VB_REGION_HWID_LEN];
+	char hwid[256];
 	int i;
 
 	/* Recovery string should be non-null for any code */
@@ -115,82 +111,72 @@ static void DebugInfoTest(void)
 
 	/* HWID should come from the gbb */
 	ResetMocks();
-	VbRegionReadHWID(&cparams, hwid, sizeof(hwid));
+	VbGbbReadHWID(&ctx, hwid, sizeof(hwid));
 	TEST_EQ(strcmp(hwid, "Test HWID"), 0, "HWID");
-	VbApiKernelFree(&cparams);
 
 	ResetMocks();
-	cparams.gbb_size = 0;
-	VbRegionReadHWID(&cparams, hwid, sizeof(hwid));
+	sd->gbb_size = 0;
+	VbGbbReadHWID(&ctx, hwid, sizeof(hwid));
 	TEST_EQ(strcmp(hwid, "{INVALID}"), 0, "HWID bad gbb");
-	VbApiKernelFree(&cparams);
 
 	ResetMocks();
-	cparams.gbb->hwid_size = 0;
-	VbRegionReadHWID(&cparams, hwid, sizeof(hwid));
+	sd->gbb->hwid_size = 0;
+	VbGbbReadHWID(&ctx, hwid, sizeof(hwid));
 	TEST_EQ(strcmp(hwid, "{INVALID}"), 0, "HWID missing");
-	VbApiKernelFree(&cparams);
 
 	ResetMocks();
-	cparams.gbb->hwid_offset = cparams.gbb_size + 1;
-	VbRegionReadHWID(&cparams, hwid, sizeof(hwid));
+	sd->gbb->hwid_offset = sd->gbb_size + 1;
+	VbGbbReadHWID(&ctx, hwid, sizeof(hwid));
 	TEST_EQ(strcmp(hwid, "{INVALID}"), 0, "HWID past end");
-	VbApiKernelFree(&cparams);
 
 	ResetMocks();
-	cparams.gbb->hwid_size = cparams.gbb_size;
-	VbRegionReadHWID(&cparams, hwid, sizeof(hwid));
+	sd->gbb->hwid_size = sd->gbb_size;
+	VbGbbReadHWID(&ctx, hwid, sizeof(hwid));
 	TEST_EQ(strcmp(hwid, "{INVALID}"), 0, "HWID overflow");
-	VbApiKernelFree(&cparams);
 
 	/* Display debug info */
 	ResetMocks();
-	VbDisplayDebugInfo(&ctx, &cparams);
+	VbDisplayDebugInfo(&ctx);
 	TEST_NEQ(*debug_info, '\0', "Some debug info was displayed");
-	VbApiKernelFree(&cparams);
 }
 
 /* Test display key checking */
 static void DisplayKeyTest(void)
 {
 	ResetMocks();
-	VbCheckDisplayKey(&ctx, &cparams, 'q');
+	VbCheckDisplayKey(&ctx, 'q');
 	TEST_EQ(*debug_info, '\0', "DisplayKey q = does nothing");
-	VbApiKernelFree(&cparams);
 
 	ResetMocks();
-	VbCheckDisplayKey(&ctx, &cparams, '\t');
+	VbCheckDisplayKey(&ctx, '\t');
 	TEST_NEQ(*debug_info, '\0', "DisplayKey tab = display");
-	VbApiKernelFree(&cparams);
 
 	/* Toggle localization */
 	ResetMocks();
 	vb2_nv_set(&ctx, VB2_NV_LOCALIZATION_INDEX, 0);
-	VbCheckDisplayKey(&ctx, &cparams, VB_KEY_DOWN);
+	VbCheckDisplayKey(&ctx, VB_KEY_DOWN);
 	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_LOCALIZATION_INDEX), 2,
 		"DisplayKey up");
-	VbCheckDisplayKey(&ctx, &cparams, VB_KEY_LEFT);
+	VbCheckDisplayKey(&ctx, VB_KEY_LEFT);
 	vb2_nv_get(&ctx, VB2_NV_LOCALIZATION_INDEX);
 	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_LOCALIZATION_INDEX), 1,
 		"DisplayKey left");
-	VbCheckDisplayKey(&ctx, &cparams, VB_KEY_RIGHT);
+	VbCheckDisplayKey(&ctx, VB_KEY_RIGHT);
 	vb2_nv_get(&ctx, VB2_NV_LOCALIZATION_INDEX);
 	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_LOCALIZATION_INDEX), 2,
 		"DisplayKey right");
-	VbCheckDisplayKey(&ctx, &cparams, VB_KEY_UP);
+	VbCheckDisplayKey(&ctx, VB_KEY_UP);
 	vb2_nv_get(&ctx, VB2_NV_LOCALIZATION_INDEX);
 	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_LOCALIZATION_INDEX), 0,
 		"DisplayKey up");
-	VbApiKernelFree(&cparams);
 
 	/* Reset localization if localization count is invalid */
 	ResetMocks();
 	vb2_nv_set(&ctx, VB2_NV_LOCALIZATION_INDEX, 1);
 	mock_localization_count = 0xffffffff;
-	VbCheckDisplayKey(&ctx, &cparams, VB_KEY_UP);
+	VbCheckDisplayKey(&ctx, VB_KEY_UP);
 	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_LOCALIZATION_INDEX), 0,
 		"DisplayKey invalid");
-	VbApiKernelFree(&cparams);
 }
 
 int main(void)
diff --git a/tests/vboot_kernel_tests.c b/tests/vboot_kernel_tests.c
index a5919780..c6798d2c 100644
--- a/tests/vboot_kernel_tests.c
+++ b/tests/vboot_kernel_tests.c
@@ -146,9 +146,6 @@ static void ResetMocks(void)
 	shared->kernel_version_tpm = 0x20001;
 
 	memset(&cparams, '\0', sizeof(cparams));
-	cparams.gbb = gbb;
-	cparams.gbb_data = gbb;
-	cparams.gbb_size = sizeof(gbb_data);
 
 	memset(&lkp, 0, sizeof(lkp));
 	lkp.bytes_per_lba = 512;
@@ -185,6 +182,8 @@ static void ResetMocks(void)
 
 	struct vb2_shared_data *sd = vb2_get_sd(&ctx);
 	sd->vbsd = shared;
+	sd->gbb = (struct vb2_gbb_header *)gbb_data;
+	sd->gbb_size = sizeof(gbb_data);
 
 	// TODO: more workbuf fields - flags, secdata, secdatak
 }
diff --git a/tests/vboot_region_tests.c b/tests/vboot_region_tests.c
deleted file mode 100644
index a08daede..00000000
--- a/tests/vboot_region_tests.c
+++ /dev/null
@@ -1,196 +0,0 @@
-/* Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- *
- * Tests for vboot region API
- */
-
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "bmpblk_font.h"
-#include "gbb_header.h"
-#include "host_common.h"
-#include "rollback_index.h"
-#include "test_common.h"
-#include "vboot_common.h"
-#include "vboot_struct.h"
-
-typedef struct VbNvContext VbNvContext;
-
-/* Mock data */
-static VbCommonParams cparams;
-static VbSelectFirmwareParams fparams;
-VbSelectAndLoadKernelParams kparams;
-static char gbb_data[4096 + sizeof(GoogleBinaryBlockHeader)];
-static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
-static VbSharedDataHeader* shared = (VbSharedDataHeader*)shared_data;
-/* Mock TPM versions */
-static uint32_t mock_tpm_version;
-static uint32_t mock_lf_tpm_version;  /* TPM version set by LoadFirmware() */
-static uint32_t mock_seen_region;
-/* Mock return values, so we can simulate errors */
-static VbError_t mock_lf_retval;
-
-#define COMPRESSED_SIZE		200
-#define ORIGINAL_SIZE		400
-
-/* Reset mock data (for use before each test) */
-static void ResetMocks(void) {
-	GoogleBinaryBlockHeader *gbb;
-	BmpBlockHeader *bhdr;
-	ImageInfo *image_info;
-	ScreenLayout *layout;
-	int gbb_used;
-
-	memset(&cparams, 0, sizeof(cparams));
-	cparams.shared_data_size = sizeof(shared_data);
-	cparams.shared_data_blob = shared_data;
-
-	memset(&fparams, 0, sizeof(fparams));
-
-	memset(gbb_data, 0, sizeof(gbb_data));
-	gbb = (GoogleBinaryBlockHeader *)gbb_data;
-	gbb->major_version = GBB_MAJOR_VER;
-	gbb->minor_version = GBB_MINOR_VER;
-	gbb->flags = 0;
-	gbb_used = sizeof(GoogleBinaryBlockHeader);
-
-	gbb->hwid_offset = gbb_used;
-	strcpy(gbb_data + gbb->hwid_offset, "Test HWID");
-	gbb->hwid_size = strlen(gbb_data + gbb->hwid_offset) + 1;
-	gbb_used = (gbb_used + gbb->hwid_size + 7) & ~7;
-
-	gbb->bmpfv_offset = gbb_used;
-	bhdr = (BmpBlockHeader *)(gbb_data + gbb->bmpfv_offset);
-	gbb->bmpfv_size = sizeof(BmpBlockHeader);
-	gbb_used = (gbb_used + gbb->bmpfv_size + 7) & ~7;
-	memcpy(bhdr->signature, BMPBLOCK_SIGNATURE, BMPBLOCK_SIGNATURE_SIZE);
-	bhdr->major_version = BMPBLOCK_MAJOR_VERSION;
-	bhdr->minor_version = BMPBLOCK_MINOR_VERSION;
-	bhdr->number_of_localizations = 3;
-	bhdr->number_of_screenlayouts = 1;
-
-	layout = (ScreenLayout *)(gbb_data + gbb_used);
-	gbb_used += sizeof(*layout);
-	layout->images[0].x = 1;
-	layout->images[0].image_info_offset = gbb_used - gbb->bmpfv_offset;
-
-	/* First image is uncompressed */
-	image_info = (ImageInfo *)(gbb_data + gbb_used);
-	image_info->format = FORMAT_BMP;
-	image_info->compressed_size = ORIGINAL_SIZE;
-	image_info->original_size = ORIGINAL_SIZE;
-	image_info->compression = COMPRESS_NONE;
-	gbb_used += sizeof(*image_info);
-	strcpy(gbb_data + gbb_used, "original");
-	gbb_used += ORIGINAL_SIZE;
-
-	/* Second image is compressed */
-	layout->images[1].image_info_offset = gbb_used - gbb->bmpfv_offset;
-	layout->images[1].x = 2;
-	image_info = (ImageInfo *)(gbb_data + gbb_used);
-	image_info->format = FORMAT_BMP;
-	image_info->compressed_size = COMPRESSED_SIZE;
-	image_info->original_size = ORIGINAL_SIZE;
-	image_info->compression = COMPRESS_LZMA1;
-	gbb_used += sizeof(*image_info) + COMPRESSED_SIZE;
-
-	memset(&shared_data, 0, sizeof(shared_data));
-	VbSharedDataInit(shared, sizeof(shared_data));
-	shared->fw_keyblock_flags = 0xABCDE0;
-
-	mock_tpm_version = mock_lf_tpm_version = 0x20004;
-	shared->fw_version_tpm_start = mock_tpm_version;
-	mock_lf_retval = 0;
-	mock_seen_region = 0;
-}
-
-/****************************************************************************/
-/* Mocked verification functions */
-
-VbError_t VbExNvStorageRead(uint8_t* buf) {
-  return VBERROR_SUCCESS;
-}
-
-VbError_t VbExNvStorageWrite(const uint8_t* buf) {
-  return VBERROR_SUCCESS;
-}
-
-VbError_t VbExRegionRead(VbCommonParams *cparams,
-			 enum vb_firmware_region region, uint32_t offset,
-			 uint32_t size, void *buf)
-{
-	if (region != VB_REGION_GBB)
-		return VBERROR_UNSUPPORTED_REGION;
-	mock_seen_region |= 1 << region;
-	if (offset + size > sizeof(gbb_data))
-		return VBERROR_REGION_READ_INVALID;
-	memcpy(buf, gbb_data + offset, size);
-	return VBERROR_SUCCESS;
-}
-
-VbError_t VbExDisplayImage(uint32_t x, uint32_t y,
-                           void *buffer, uint32_t buffersize)
-{
-	switch (x) {
-	case 1:
-		TEST_STR_EQ(buffer, "original", "  uncompressed image");
-		break;
-	case 2:
-		TEST_STR_EQ(buffer, "decompressed", "  compressed image");
-		break;
-	default:
-		TEST_STR_EQ(buffer, "invalid", "  correct image");
-		break;
-	}
-	return VBERROR_SUCCESS;
-}
-
-VbError_t VbExDecompress(void *inbuf, uint32_t in_size,
-                         uint32_t compression_type,
-                         void *outbuf, uint32_t *out_size)
-{
-	*out_size = ORIGINAL_SIZE;
-	strcpy(outbuf, "decompressed");
-	return VBERROR_SUCCESS;
-}
-
-int LoadFirmware(VbCommonParams *cparams, VbSelectFirmwareParams *fparams,
-                 VbNvContext *vnc) {
-	shared->fw_version_tpm = mock_lf_tpm_version;
-	TEST_PTR_NEQ(cparams->gbb, NULL, "  GBB allocated");
-	return mock_lf_retval;
-}
-
-/****************************************************************************/
-
-static void VbRegionReadTest(void) {
-	/* Should read GBB */
-	ResetMocks();
-	TEST_TRUE(1, "Normal call");
-	TEST_EQ(VbSelectFirmware(&cparams, &fparams), VBERROR_SUCCESS,
-		"  Success");
-	TEST_EQ(mock_seen_region, 1 << VB_REGION_GBB, "  GBB region");
-	TEST_PTR_EQ(cparams.gbb, NULL, "  GBB free");
-
-	ResetMocks();
-	TEST_EQ(VbSelectAndLoadKernel(&cparams, &kparams),
-		VBERROR_NO_DISK_FOUND, "Kernel");
-	TEST_PTR_EQ(cparams.gbb, NULL, "  GBB free");
-	TEST_PTR_EQ(cparams.bmp, NULL, "  BMP free");
-
-	ResetMocks();
-	shared->flags |= VBSD_BOOT_DEV_SWITCH_ON;
-	TEST_EQ(VbSelectAndLoadKernel(&cparams, &kparams),
-		VBERROR_NO_DISK_FOUND, "Kernel");
-}
-
-int main(int argc, char* argv[])
-{
-  VbRegionReadTest();
-
-  return gTestSuccess ? 0 : 255;
-}