Revert "Implementation of Region API"

This reverts commit 1d3c804b6b.

This patch breaks cbuildbot on internal paladins bots.

Change-Id: Icf7f9d9bbb56b092035888eaa3e249ffd23fac16
(cherry picked from commit 3a60335ebb1530e5fd9d5da3bc6214949bc59caf)
Reviewed-on: https://chromium-review.googlesource.com/167451
Reviewed-by: Yoshiki Iguchi <yoshiki@chromium.org>
Commit-Queue: Yoshiki Iguchi <yoshiki@chromium.org>
Tested-by: Yoshiki Iguchi <yoshiki@chromium.org>

Makefile

@@ -239,7 +239,6 @@ VBINIT_SRCS = \
 	firmware/lib/vboot_api_init.c \
 	firmware/lib/vboot_common_init.c \
 	firmware/lib/vboot_nvstorage.c \
-	firmware/lib/region-init.c \
 
 # Additional firmware library sources needed by VbSelectFirmware() call
 VBSF_SRCS = \
@@ -253,8 +252,7 @@ VBSF_SRCS = \
 	firmware/lib/stateful_util.c \
 	firmware/lib/vboot_api_firmware.c \
 	firmware/lib/vboot_common.c \
-	firmware/lib/vboot_firmware.c \
+	firmware/lib/vboot_firmware.c
-	firmware/lib/region-fw.c \
 
 # Additional firmware library sources needed by VbSelectAndLoadKernel() call
 VBSLK_SRCS = \
@@ -266,8 +264,7 @@ VBSLK_SRCS = \
 	firmware/lib/vboot_api_kernel.c \
 	firmware/lib/vboot_audio.c \
 	firmware/lib/vboot_display.c \
-	firmware/lib/vboot_kernel.c \
+	firmware/lib/vboot_kernel.c
-	firmware/lib/region-kernel.c \
 
 # Support real TPM unless BIOS sets MOCK_TPM
 ifeq (${MOCK_TPM},)
@@ -292,8 +289,7 @@ ifeq (${FIRMWARE_ARCH},)
 VBINIT_SRCS += \
 	firmware/stub/tpm_lite_stub.c \
 	firmware/stub/utility_stub.c \
-	firmware/stub/vboot_api_stub_init.c \
+	firmware/stub/vboot_api_stub_init.c
-	firmware/stub/vboot_api_stub_region.c
 
 VBSF_SRCS += \
 	firmware/stub/vboot_api_stub_sf.c
@@ -537,10 +533,6 @@ TEST_NAMES = \
 	tests/vboot_nvstorage_test \
 	tests/futility/test_not_really
 
-ifdef REGION_READ
-TEST_NAMES += tests/vboot_region_tests
-endif
-
 # TODO: port these tests to new API, if not already eqivalent
 # functionality in other tests.  These don't even compile at present.
 #
@@ -650,10 +642,6 @@ ${FWLIB_OBJS}: CFLAGS += -DSAVE_LOCALE_IMMEDIATELY
 ${FWLIB_OBJS}: CFLAGS += -DCOPY_BMP_DATA
 endif
 
-ifdef REGION_READ
-${FWLIB_OBJS}: CFLAGS += -DREGION_READ
-endif
-
 ifeq (${FIRMWARE_ARCH},)
 # Disable rollback TPM when compiling locally, since otherwise
 # load_kernel_test attempts to talk to the TPM.

firmware/include/gbb_access.h

@@ -1,83 +0,0 @@
-/* Copyright (c) 2013 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.
- *
- * Access to portions of the GBB using the region API.
- */
-
-#ifndef VBOOT_REFERENCE_GBB_ACCESS_H_
-#define VBOOT_REFERENCE_GBB_ACCESS_H_
-
-#include "vboot_api.h"
-
-struct BmpBlockHeader;
-struct ImageInfo;
-struct GoogleBinaryBlockHeader;
-struct ScreenLayout;
-struct VbPublicKey;
-
-/**
- * Read the GBB header
- *
- * This accesses the GBB and reads its header.
- *
- * @param cparams	Vboot common parameters
- * @param gbb		Place to put GBB header
- */
-VbError_t VbGbbReadHeader_static(VbCommonParams *cparams,
-				 struct GoogleBinaryBlockHeader *gbb);
-
-/**
- * Read the root key from the GBB
- *
- * @param cparams	Vboot common parameters
- * @param keyp		Returns a pointer to the key. The caller must call
- *			VbExFree() on the key when finished with it.
- * @return VBERROR_... error, VBERROR_SUCCESS on success,
- */
-VbError_t VbGbbReadRootKey(VbCommonParams *cparams,
-			   struct VbPublicKey **keyp);
-
-/**
- * Read the recovery key from the GBB
- *
- * @param cparams	Vboot common parameters
- * @param keyp		Returns a pointer to the key. The caller must call
- *			VbExFree() on the key when finished with it.
- * @return VBERROR_... error, VBERROR_SUCCESS on success,
- */
-VbError_t VbGbbReadRecoveryKey(VbCommonParams *cparams,
-			       struct VbPublicKey **keyp);
-
-/**
- * Read the bitmap block header from the GBB
- *
- * @param cparams	Vboot common parameters
- * @param hdr		The header is placed in this block
- * @return VBERROR_... error, VBERROR_SUCCESS on success,
- */
-VbError_t VbGbbReadBmpHeader(VbCommonParams *cparams,
-			     struct BmpBlockHeader *hdr);
-
-/**
- * Read a image from the GBB
- *
- * The caller must call VbExFree() on *image_datap when finished with it.
- *
- * @param cparams	Vboot common parameters
- * @param localization	Localization/language number
- * @param screen_index	Index of screen to display (VB_SCREEN_...)
- * @param image_num	Image number within the screen
- * @param layout	Returns layout information (x, y position)
- * @param image_info	Returns information about the image (format)
- * @param image_datap	Returns a pointer to the image data
- * @param iamge_data_sizep	Return size of image data
- * @return VBERROR_... error, VBERROR_SUCCESS on success,
- */
-VbError_t VbGbbReadImage(VbCommonParams *cparams,
-			 uint32_t localization, uint32_t screen_index,
-			 uint32_t image_num, struct ScreenLayout *layout,
-			 struct ImageInfo *image_info, char **image_datap,
-			 uint32_t *image_data_sizep);
-
-#endif

firmware/include/region.h

@@ -1,55 +0,0 @@
-/* Copyright (c) 2013 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.
- *
- * Access to portions of the firmware image, perhaps later to be expanded
- * to other devices.
- */
-
-#ifndef VBOOT_REFERENCE_REGION_H_
-#define VBOOT_REFERENCE_REGION_H_
-
-#include "bmpblk_header.h"
-#include "gbb_header.h"
-#include "vboot_api.h"
-#include "vboot_struct.h"
-
-/* The maximum length of a hardware ID */
-#define VB_REGION_HWID_LEN	256
-
-/**
- * Read data from a region
- *
- * @param cparams	Vboot common parameters
- * @param region	Region number to read
- * @param offset	Offset within region to start reading
- * @param size		Size of data to read
- * @param buf		Buffer to put the data into
- * @return VBERROR_... error, VBERROR_SUCCESS on success,
- */
-VbError_t VbRegionReadData(VbCommonParams *cparams,
-			   enum vb_firmware_region region, uint32_t offset,
-			   uint32_t size, void *buf);
-
-/**
- * Check the version of the GBB and print debug information if valid
- *
- * @param cparams	Vboot common parameters
- */
-void VbRegionCheckVersion(VbCommonParams *cparams);
-
-/**
- * Read the hardware ID from the GBB
- *
- * @param cparams	Vboot common parameters
- * @param hwid		Place to put HWID, which will be null-terminated
- * @param max_size	Maximum size of HWID including terminated null
- *			character (suggest VB_REGION_HWID_LEN). If this size
- *			it too small then VBERROR_INVALID_PARAMETER is
- *			returned.
- * @return VBERROR_... error, VBERROR_SUCCESS on success,
- */
-VbError_t VbRegionReadHWID(VbCommonParams *cparams, char *hwid,
-			   uint32_t max_size);
-
-#endif  /* VBOOT_REFERENCE_REGION_H_ */

firmware/include/vboot_api.h

@@ -104,14 +104,6 @@ enum VbErrorPredefined_t {
 	VBERROR_VGA_OPROM_MISMATCH            = 0x10021,
 	/* Need EC to reboot to read-only code */
 	VBERROR_EC_REBOOT_TO_RO_REQUIRED      = 0x10022,
-	/* Invalid region read parameters */
-	VBERROR_REGION_READ_INVALID           = 0x10023,
-	/* Cannot read from region */
-	VBERROR_REGION_READ_FAILED            = 0x10024,
-	/* Unsupported region type */
-	VBERROR_UNSUPPORTED_REGION            = 0x10025,
-	/* No image present (returned from VbGbbReadImage() for missing image) */
-	VBERROR_NO_IMAGE_PRESENT              = 0x10026,
 
 	/* VbExEcGetExpectedRWHash() may return the following codes */
 	/* Compute expected RW hash from the EC image; BIOS doesn't have it */
@@ -175,10 +167,6 @@ typedef struct VbCommonParams {
 	 * the stack.
 	 */
 	void *caller_context;
-
-	/* For internal use of Vboot - do not examine or modify! */
-	struct GoogleBinaryBlockHeader *gbb;
-	struct BmpBlockHeader *bmp;
 } VbCommonParams;
 
 /* Flags for VbInitParams.flags */
@@ -839,33 +827,4 @@ enum {
  */
 int VbExLegacy(void);
 
-/* Regions for VbExRegionRead() */
-enum vb_firmware_region {
-	VB_REGION_GBB,	/* Google Binary Block - see gbbheader.h */
-
-	VB_REGION_COUNT,
-};
-
-/**
- * Read data from a region of the firmware image
- *
- * Vboot wants access to a region, to read data from it. This function
- * reads it (typically from the firmware image such as SPI flash) and
- * returns the data.
- *
- * cparams is passed so that the boot loader has some context for the
- * operation.
- *
- * @param cparams	Common parameters, e.g. use member caller_context
- *			to point to useful context data
- * @param region	Firmware region to read
- * @param offset	Start offset within region
- * @param size		Number of bytes to read
- * @param buf		Place to put data
- * @return VBERROR_... error, VBERROR_SUCCESS on success,
- */
-VbError_t VbExRegionRead(VbCommonParams *cparams,
-			 enum vb_firmware_region region, uint32_t offset,
-			 uint32_t size, void *buf);
-
 #endif  /* VBOOT_REFERENCE_VBOOT_API_H_ */

firmware/lib/include/load_kernel_fw.h

@@ -74,7 +74,7 @@ typedef struct LoadKernelParams {
  * Returns VBERROR_SUCCESS if successful.  If unsuccessful, sets a recovery
  * reason via VbNvStorage and returns an error code.
  */
-VbError_t LoadKernel(LoadKernelParams *params, VbCommonParams *cparams);
+VbError_t LoadKernel(LoadKernelParams *params);
 
 /*
  * The bootloader is loaded using the EFI LoadImage() and StartImage() calls.

firmware/lib/include/vboot_display.h

@@ -42,6 +42,11 @@ void VbRenderTextAtPos(const char *text, int right_to_left,
  */
 const char *RecoveryReasonString(uint8_t code);
 
+/**
+ * Return a fixed string representing the HWID.
+ */
+const char *VbHWID(VbCommonParams *cparams);
+
 /**
  * Get the number of localizations in the GBB bitmap data.
  */

firmware/lib/include/vboot_kernel.h

@@ -11,7 +11,6 @@
 
 #include "cgptlib.h"
 #include "load_firmware_fw.h"
-#include "load_kernel_fw.h"
 #include "vboot_api.h"
 
 /**
@@ -33,11 +32,6 @@ int WriteAndFreeGptData(VbExDiskHandle_t disk_handle, GptData *gptdata);
  */
 VbNvContext *VbApiKernelGetVnc(void);
 
-/**
- * Exported for unit tests only - frees memory used by VbSelectAndLoadKernel()
- */
-void VbApiKernelFree(VbCommonParams *cparams);
-
 /**
  * Try to load a kernel.
  */

firmware/lib/region-fw.c

@@ -1,54 +0,0 @@
-/* Copyright (c) 2013 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.
- *
- * High-level firmware API for loading and verifying rewritable firmware.
- * (Firmware portion)
- */
-
-#include "sysincludes.h"
-
-#include "bmpblk_header.h"
-#include "region.h"
-#include "gbb_header.h"
-#include "load_kernel_fw.h"
-#include "utility.h"
-#include "vboot_api.h"
-#include "vboot_struct.h"
-
-static VbError_t VbGbbReadKey(VbCommonParams *cparams, uint32_t offset,
-			      VbPublicKey **keyp)
-{
-	VbPublicKey hdr, *key;
-	VbError_t ret;
-	uint32_t size;
-
-	ret = VbRegionReadData(cparams, VB_REGION_GBB, offset,
-			       sizeof(VbPublicKey), &hdr);
-	if (ret)
-		return ret;
-
-	/* Deal with a zero-size key (used in testing) */
-	size = hdr.key_offset + hdr.key_size;
-	if (size < sizeof(hdr))
-		size = sizeof(hdr);
-	key = VbExMalloc(size);
-	ret = VbRegionReadData(cparams, VB_REGION_GBB, offset, size, key);
-	if (ret) {
-		VbExFree(key);
-		return ret;
-	}
-
-	*keyp = key;
-	return VBERROR_SUCCESS;
-}
-
-VbError_t VbGbbReadRootKey(VbCommonParams *cparams, VbPublicKey **keyp)
-{
-	return VbGbbReadKey(cparams, cparams->gbb->rootkey_offset, keyp);
-}
-
-VbError_t VbGbbReadRecoveryKey(VbCommonParams *cparams, VbPublicKey **keyp)
-{
-	return VbGbbReadKey(cparams, cparams->gbb->recovery_key_offset, keyp);
-}

firmware/lib/region-init.c

@@ -1,49 +0,0 @@
-/* Copyright (c) 2013 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.
- *
- * High-level firmware API for loading and verifying rewritable firmware.
- * (Firmware portion)
- */
-
-#include "sysincludes.h"
-
-#include "bmpblk_header.h"
-#include "region.h"
-#include "gbb_header.h"
-#include "load_kernel_fw.h"
-#include "utility.h"
-#include "vboot_api.h"
-#include "vboot_struct.h"
-
-VbError_t VbRegionReadData(VbCommonParams *cparams,
-			   enum vb_firmware_region region, uint32_t offset,
-			   uint32_t size, void *buf)
-{
-	/* This is the old API, for backwards compatibility */
-	if (region == VB_REGION_GBB && cparams->gbb_data) {
-		if (offset + size > cparams->gbb_size)
-			return VBERROR_INVALID_GBB;
-		Memcpy(buf, cparams->gbb_data + offset, size);
-	} else
-#ifdef REGION_READ
-	{
-		VbError_t ret;
-
-		ret = VbExRegionRead(cparams, region, offset, size, buf);
-		if (ret)
-			return ret;
-	}
-#else
-	return VBERROR_INVALID_GBB;
-#endif
-
-	return VBERROR_SUCCESS;
-}
-
-VbError_t VbGbbReadHeader_static(VbCommonParams *cparams,
-				 GoogleBinaryBlockHeader *gbb)
-{
-	return VbRegionReadData(cparams, VB_REGION_GBB, 0,
-				sizeof(GoogleBinaryBlockHeader), gbb);
-}

firmware/lib/region-kernel.c

@@ -1,199 +0,0 @@
-/* Copyright (c) 2013 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.
- *
- * High-level firmware API for loading and verifying rewritable firmware.
- * (Firmware portion)
- */
-
-#include "sysincludes.h"
-
-#include "bmpblk_header.h"
-#include "region.h"
-#include "gbb_header.h"
-#include "load_kernel_fw.h"
-#include "utility.h"
-#include "vboot_api.h"
-#include "vboot_struct.h"
-
-static VbError_t VbRegionReadGbb(VbCommonParams *cparams, uint32_t offset,
-				  uint32_t size, void *buf)
-{
-	return VbRegionReadData(cparams, VB_REGION_GBB, offset, size, buf);
-}
-
-VbError_t VbGbbReadBmpHeader(VbCommonParams *cparams, BmpBlockHeader *hdr_ret)
-{
-	BmpBlockHeader *hdr;
-	VbError_t ret;
-
-	if (!cparams)
-		return VBERROR_INVALID_GBB;
-	if (!cparams->bmp) {
-		GoogleBinaryBlockHeader *gbb = cparams->gbb;
-
-		if (0 == gbb->bmpfv_size)
-			return VBERROR_INVALID_GBB;
-
-		hdr = VbExMalloc(sizeof(*hdr));
-		ret = VbRegionReadGbb(cparams, gbb->bmpfv_offset,
-				      sizeof(BmpBlockHeader), hdr);
-		if (ret) {
-			VbExFree(hdr);
-			return ret;
-		}
-
-		/* Sanity-check the bitmap block header */
-		if ((0 != Memcmp(hdr->signature, BMPBLOCK_SIGNATURE,
-				BMPBLOCK_SIGNATURE_SIZE)) ||
-		(hdr->major_version > BMPBLOCK_MAJOR_VERSION) ||
-		((hdr->major_version == BMPBLOCK_MAJOR_VERSION) &&
-		(hdr->minor_version > BMPBLOCK_MINOR_VERSION))) {
-			VBDEBUG(("VbDisplayScreenFromGBB(): "
-				"invalid/too new bitmap header\n"));
-			VbExFree(hdr);
-			return VBERROR_INVALID_BMPFV;
-		}
-		cparams->bmp = hdr;
-	}
-
-	*hdr_ret = *cparams->bmp;
-	return VBERROR_SUCCESS;
-}
-
-VbError_t VbRegionReadHWID(VbCommonParams *cparams, char *hwid,
-			   uint32_t max_size)
-{
-	GoogleBinaryBlockHeader *gbb;
-	VbError_t ret;
-
-	if (!max_size)
-		return VBERROR_INVALID_PARAMETER;
-	*hwid = '\0';
-	StrnAppend(hwid, "{INVALID}", max_size);
-	if (!cparams)
-		return VBERROR_INVALID_GBB;
-
-	gbb = cparams->gbb;
-
-	if (0 == gbb->hwid_size) {
-		VBDEBUG(("VbHWID(): invalid hwid size\n"));
-		return VBERROR_SUCCESS; /* oddly enough! */
-	}
-
-	if (gbb->hwid_size > max_size) {
-		VBDEBUG(("VbDisplayDebugInfo(): invalid hwid offset/size\n"));
-		return VBERROR_INVALID_PARAMETER;
-	}
-	ret = VbRegionReadGbb(cparams, gbb->hwid_offset, gbb->hwid_size, hwid);
-	if (ret)
-		return ret;
-
-	return VBERROR_SUCCESS;
-}
-
-VbError_t VbGbbReadImage(VbCommonParams *cparams,
-			       uint32_t localization, uint32_t screen_index,
-			       uint32_t image_num, ScreenLayout *layout,
-			       ImageInfo *image_info, char **image_datap,
-			       uint32_t *image_data_sizep)
-{
-	uint32_t layout_offset, image_offset, data_offset, data_size;
-	GoogleBinaryBlockHeader *gbb;
-	BmpBlockHeader hdr;
-	void *data = NULL;
-	VbError_t ret;
-
-	if (!cparams)
-		return VBERROR_INVALID_GBB;
-
-	ret = VbGbbReadBmpHeader(cparams, &hdr);
-	if (ret)
-		return ret;
-
-	gbb = cparams->gbb;
-	layout_offset = gbb->bmpfv_offset + sizeof(BmpBlockHeader) +
-		localization * hdr.number_of_screenlayouts *
-			sizeof(ScreenLayout) +
-		screen_index * sizeof(ScreenLayout);
-	ret = VbRegionReadGbb(cparams, layout_offset, sizeof(*layout), layout);
-	if (ret)
-		return ret;
-
-	if (!layout->images[image_num].image_info_offset)
-		return VBERROR_NO_IMAGE_PRESENT;
-
-	image_offset = gbb->bmpfv_offset +
-			layout->images[image_num].image_info_offset;
-	ret = VbRegionReadGbb(cparams, image_offset, sizeof(*image_info),
-			      image_info);
-	if (ret)
-		return ret;
-
-	data_offset = image_offset + sizeof(*image_info);
-	data_size = image_info->compressed_size;
-	if (data_size) {
-		void *orig_data;
-
-		data = VbExMalloc(image_info->compressed_size);
-		ret = VbRegionReadGbb(cparams, data_offset,
-				      image_info->compressed_size, data);
-		if (ret) {
-			VbExFree(data);
-			return ret;
-		}
-		if (image_info->compression != COMPRESS_NONE) {
-			uint32_t inoutsize = image_info->original_size;
-
-			orig_data = VbExMalloc(image_info->original_size);
-			ret = VbExDecompress(data,
-					     image_info->compressed_size,
-					     image_info->compression,
-					     orig_data, &inoutsize);
-			data_size = inoutsize;
-			VbExFree(data);
-			data = orig_data;
-			if (ret) {
-				VbExFree(data);
-				return ret;
-			}
-		}
-	}
-
-	*image_datap = data;
-	*image_data_sizep = data_size;
-
-	return VBERROR_SUCCESS;
-}
-
-#define OUTBUF_LEN 128
-
-void VbRegionCheckVersion(VbCommonParams *cparams)
-{
-	GoogleBinaryBlockHeader *gbb;
-
-	if (!cparams)
-		return;
-
-	gbb = cparams->gbb;
-
-	/*
-	 * If GBB flags is nonzero, complain because that's something that the
-	 * factory MUST fix before shipping. We only have to do this here,
-	 * because it's obvious that something is wrong if we're not displaying
-	 * screens from the GBB.
-	 */
-	if (gbb->major_version == GBB_MAJOR_VER && gbb->minor_version >= 1 &&
-	    (gbb->flags != 0)) {
-		uint32_t used = 0;
-		char outbuf[OUTBUF_LEN];
-
-		*outbuf = '\0';
-		used += StrnAppend(outbuf + used, "gbb.flags is nonzero: 0x",
-				OUTBUF_LEN - used);
-		used += Uint64ToString(outbuf + used, OUTBUF_LEN - used,
-				       gbb->flags, 16, 8);
-		used += StrnAppend(outbuf + used, "\n", OUTBUF_LEN - used);
-		(void)VbExDisplayDebugInfo(outbuf);
-	}
-}

firmware/lib/vboot_api_firmware.c

@@ -7,7 +7,6 @@
 
 #include "sysincludes.h"
 
-#include "gbb_access.h"
 #include "gbb_header.h"
 #include "load_firmware_fw.h"
 #include "rollback_index.h"
@@ -28,9 +27,6 @@ VbError_t VbSelectFirmware(VbCommonParams *cparams,
 	int is_dev = (shared->flags & VBSD_BOOT_DEV_SWITCH_ON ? 1 : 0);
 	uint32_t tpm_status = 0;
 
-	cparams->gbb = NULL;
-	cparams->bmp = NULL;
-
 	/* Start timer */
 	shared->timer_vb_select_firmware_enter = VbExGetTimer();
 
@@ -48,11 +44,6 @@ VbError_t VbSelectFirmware(VbCommonParams *cparams,
 		/* Go directly to recovery mode */
 		fparams->selected_firmware = VB_SELECT_FIRMWARE_RECOVERY;
 	} else {
-		cparams->gbb = VbExMalloc(sizeof(*cparams->gbb));
-		retval = VbGbbReadHeader_static(cparams, cparams->gbb);
-		if (VBERROR_SUCCESS != retval)
-			goto VbSelectFirmware_exit;
-
 		/* Chain to LoadFirmware() */
 		retval = LoadFirmware(cparams, fparams, &vnc);
 
@@ -116,11 +107,6 @@ VbError_t VbSelectFirmware(VbCommonParams *cparams,
 
  VbSelectFirmware_exit:
 
-	if (cparams->gbb) {
-		VbExFree(cparams->gbb);
-		cparams->gbb = NULL;
-	}
-
 	/* Save NV storage */
 	VbNvTeardown(&vnc);
 	if (vnc.raw_changed)

firmware/lib/vboot_api_init.c

@@ -7,8 +7,6 @@
 
 #include "sysincludes.h"
 
-#include "region.h"
-#include "gbb_access.h"
 #include "gbb_header.h"
 #include "load_firmware_fw.h"
 #include "rollback_index.h"
@@ -21,7 +19,8 @@ VbError_t VbInit(VbCommonParams *cparams, VbInitParams *iparams)
 {
 	VbSharedDataHeader *shared =
 		(VbSharedDataHeader *)cparams->shared_data_blob;
-	GoogleBinaryBlockHeader gbb;
+	GoogleBinaryBlockHeader *gbb =
+		(GoogleBinaryBlockHeader *)cparams->gbb_data;
 	VbNvContext vnc;
 	VbError_t retval = VBERROR_SUCCESS;
 	uint32_t recovery = VBNV_RECOVERY_NOT_REQUESTED;
@@ -37,16 +36,12 @@ VbError_t VbInit(VbCommonParams *cparams, VbInitParams *iparams)
 	uint32_t clear_tpm_owner_request = 0;
 	int is_dev = 0;
 
+	VBDEBUG(("VbInit() input flags 0x%x gbb flags 0x%x\n", iparams->flags,
+		gbb->flags));
+
 	/* Initialize output flags */
 	iparams->out_flags = 0;
 
-	retval = VbGbbReadHeader_static(cparams, &gbb);
-	if (retval)
-		return retval;
-
-	VBDEBUG(("VbInit() input flags 0x%x gbb flags 0x%x\n", iparams->flags,
-		gbb.flags));
-
 	/* Set up NV storage */
 	VbExNvStorageRead(vnc.raw);
 	VbNvSetup(&vnc);
@@ -168,7 +163,7 @@ VbError_t VbInit(VbCommonParams *cparams, VbInitParams *iparams)
 		VbNvGet(&vnc, VBNV_DISABLE_DEV_REQUEST, &disable_dev_request);
 
 		/* Allow GBB flag to override dev switch */
-		if (gbb.flags & GBB_FLAG_FORCE_DEV_SWITCH_ON)
+		if (gbb->flags & GBB_FLAG_FORCE_DEV_SWITCH_ON)
 			is_hw_dev = 1;
 
 		/* Have we been explicitly asked to clear the TPM owner? */
@@ -247,11 +242,11 @@ VbError_t VbInit(VbCommonParams *cparams, VbInitParams *iparams)
 	}
 
 	/* Allow BIOS to load arbitrary option ROMs? */
-	if (gbb.flags & GBB_FLAG_LOAD_OPTION_ROMS)
+	if (gbb->flags & GBB_FLAG_LOAD_OPTION_ROMS)
 		iparams->out_flags |= VB_INIT_OUT_ENABLE_OPROM;
 
 	/* Factory may need to boot custom OSes when the dev-switch is on */
-	if (is_dev && (gbb.flags & GBB_FLAG_ENABLE_ALTERNATE_OS))
+	if (is_dev && (gbb->flags & GBB_FLAG_ENABLE_ALTERNATE_OS))
 		iparams->out_flags |= VB_INIT_OUT_ENABLE_ALTERNATE_OS;
 
 	/* Set output flags */

firmware/lib/vboot_api_kernel.c

@@ -7,10 +7,8 @@
 
 #include "sysincludes.h"
 
-#include "gbb_access.h"
 #include "gbb_header.h"
 #include "load_kernel_fw.h"
-#include "region.h"
 #include "rollback_index.h"
 #include "utility.h"
 #include "vboot_api.h"
@@ -99,7 +97,7 @@ uint32_t VbTryLoadKernel(VbCommonParams *cparams, LoadKernelParams *p,
 		p->disk_handle = disk_info[i].handle;
 		p->bytes_per_lba = disk_info[i].bytes_per_lba;
 		p->ending_lba = disk_info[i].lba_count - 1;
-		retval = LoadKernel(p, cparams);
+		retval = LoadKernel(p);
 		VBDEBUG(("VbTryLoadKernel() LoadKernel() = %d\n", retval));
 
 		/*
@@ -175,7 +173,8 @@ VbError_t VbBootNormal(VbCommonParams *cparams, LoadKernelParams *p)
 
 VbError_t VbBootDeveloper(VbCommonParams *cparams, LoadKernelParams *p)
 {
-	GoogleBinaryBlockHeader *gbb = cparams->gbb;
+	GoogleBinaryBlockHeader *gbb =
+		(GoogleBinaryBlockHeader *)cparams->gbb_data;
 	VbSharedDataHeader *shared =
 		(VbSharedDataHeader *)cparams->shared_data_blob;
 	uint32_t allow_usb = 0, allow_legacy = 0, ctrl_d_pressed = 0;
@@ -808,25 +807,13 @@ VbError_t VbEcSoftwareSync(VbCommonParams *cparams)
 	return VBERROR_SUCCESS;
 }
 
-/* This function is also used by tests */
-void VbApiKernelFree(VbCommonParams *cparams)
-{
-	/* VbSelectAndLoadKernel() always allocates this, tests don't */
-	if (cparams->gbb) {
-		VbExFree(cparams->gbb);
-		cparams->gbb = NULL;
-	}
-	if (cparams->bmp) {
-		VbExFree(cparams->bmp);
-		cparams->bmp = NULL;
-	}
-}
-
 VbError_t VbSelectAndLoadKernel(VbCommonParams *cparams,
                                 VbSelectAndLoadKernelParams *kparams)
 {
 	VbSharedDataHeader *shared =
 		(VbSharedDataHeader *)cparams->shared_data_blob;
+	GoogleBinaryBlockHeader *gbb =
+		(GoogleBinaryBlockHeader *)cparams->gbb_data;
 	VbError_t retval = VBERROR_SUCCESS;
 	LoadKernelParams p;
 	uint32_t tpm_status = 0;
@@ -844,15 +831,9 @@ VbError_t VbSelectAndLoadKernel(VbCommonParams *cparams,
 	kparams->bootloader_size = 0;
 	Memset(kparams->partition_guid, 0, sizeof(kparams->partition_guid));
 
-	cparams->bmp = NULL;
-	cparams->gbb = VbExMalloc(sizeof(*cparams->gbb));
-	retval = VbGbbReadHeader_static(cparams, cparams->gbb);
-	if (VBERROR_SUCCESS != retval)
-		goto VbSelectAndLoadKernel_exit;
-
 	/* Do EC software sync if necessary */
 	if ((shared->flags & VBSD_EC_SOFTWARE_SYNC) &&
-	    !(cparams->gbb->flags & GBB_FLAG_DISABLE_EC_SOFTWARE_SYNC)) {
+	    !(gbb->flags & GBB_FLAG_DISABLE_EC_SOFTWARE_SYNC)) {
 		retval = VbEcSoftwareSync(cparams);
 		if (retval != VBERROR_SUCCESS)
 			goto VbSelectAndLoadKernel_exit;
@@ -1001,8 +982,6 @@ VbError_t VbSelectAndLoadKernel(VbCommonParams *cparams,
 
  VbSelectAndLoadKernel_exit:
 
-	VbApiKernelFree(cparams);
-
 	VbNvTeardown(&vnc);
 	if (vnc.raw_changed)
 		VbExNvStorageWrite(vnc.raw);

firmware/lib/vboot_audio.c

@@ -208,7 +208,8 @@ static void VbGetDevMusicNotes(VbAudioContext *audio, int use_short)
  */
 VbAudioContext *VbAudioOpen(VbCommonParams *cparams)
 {
-	GoogleBinaryBlockHeader *gbb = cparams->gbb;
+	GoogleBinaryBlockHeader* gbb =
+		(GoogleBinaryBlockHeader *)cparams->gbb_data;
 	VbAudioContext *audio = &au;
 	int use_short = 0;
 	uint64_t a, b;

firmware/lib/vboot_display.c

@@ -8,9 +8,7 @@
 #include "sysincludes.h"
 
 #include "bmpblk_font.h"
-#include "gbb_access.h"
 #include "gbb_header.h"
-#include "region.h"
 #include "utility.h"
 #include "vboot_api.h"
 #include "vboot_common.h"
@@ -22,20 +20,49 @@ static uint32_t disp_width = 0, disp_height = 0;
 
 VbError_t VbGetLocalizationCount(VbCommonParams *cparams, uint32_t *count)
 {
-	BmpBlockHeader hdr;
+	GoogleBinaryBlockHeader *gbb =
-	VbError_t ret;
+		(GoogleBinaryBlockHeader *)cparams->gbb_data;
+	BmpBlockHeader *hdr;
 
 	/* Default to 0 on error */
 	*count = 0;
 
-	ret = VbGbbReadBmpHeader(cparams, &hdr);
+	/* Make sure bitmap data is inside the GBB and is non-zero in size */
-	if (ret)
+	if (0 == gbb->bmpfv_size ||
-		return ret;
+	    gbb->bmpfv_offset > cparams->gbb_size ||
+	    gbb->bmpfv_offset + gbb->bmpfv_size > cparams->gbb_size) {
+		return VBERROR_INVALID_GBB;
+	}
 
-	*count = hdr.number_of_localizations;
+	/* Sanity-check the bitmap block header */
+	hdr = (BmpBlockHeader *)(((uint8_t *)gbb) + gbb->bmpfv_offset);
+	if ((0 != Memcmp(hdr->signature, BMPBLOCK_SIGNATURE,
+			 BMPBLOCK_SIGNATURE_SIZE)) ||
+	    (hdr->major_version > BMPBLOCK_MAJOR_VERSION) ||
+	    ((hdr->major_version == BMPBLOCK_MAJOR_VERSION) &&
+	     (hdr->minor_version > BMPBLOCK_MINOR_VERSION))) {
+		return VBERROR_INVALID_BMPFV;
+	}
+
+	*count = hdr->number_of_localizations;
 	return VBERROR_SUCCESS;
 }
 
+const char *VbHWID(VbCommonParams *cparams)
+{
+	GoogleBinaryBlockHeader *gbb =
+		(GoogleBinaryBlockHeader *)cparams->gbb_data;
+
+	if (0 == gbb->hwid_size ||
+	    gbb->hwid_offset > cparams->gbb_size ||
+	    gbb->hwid_offset + gbb->hwid_size > cparams->gbb_size) {
+		VBDEBUG(("VbHWID(): invalid hwid offset/size\n"));
+		return "{INVALID}";
+	}
+
+	return (char *)((uint8_t *)gbb + gbb->hwid_offset);
+}
+
 /*
  * TODO: We could cache the font info to speed things up, by making the
  * in-memory font structure distinct from the in-flash version.  We'll do that
@@ -137,24 +164,62 @@ void VbRenderTextAtPos(const char *text, int right_to_left,
 	}
 }
 
+#define OUTBUF_LEN 128
+
 VbError_t VbDisplayScreenFromGBB(VbCommonParams *cparams, uint32_t screen,
                                  VbNvContext *vncptr)
 {
-	char *fullimage = NULL;
+	GoogleBinaryBlockHeader *gbb =
-	BmpBlockHeader hdr;
+		(GoogleBinaryBlockHeader *)cparams->gbb_data;
+	static uint8_t *bmpfv;
+	void *fullimage = NULL;
+	BmpBlockHeader *hdr;
+	ScreenLayout *layout;
+	ImageInfo *image_info;
 	uint32_t screen_index;
 	uint32_t localization = 0;
 	VbError_t retval = VBERROR_UNKNOWN;   /* Assume error until proven ok */
 	uint32_t inoutsize;
+	uint32_t offset;
 	uint32_t i;
 	VbFont_t *font;
 	const char *text_to_show;
 	int rtol = 0;
-	VbError_t ret;
+	char outbuf[OUTBUF_LEN] = "";
+	uint32_t used = 0;
 
-	ret = VbGbbReadBmpHeader(cparams, &hdr);
+	/* Make sure bitmap data is inside the GBB and is non-zero in size */
-	if (ret)
+	if (0 == gbb->bmpfv_size ||
-		return ret;
+	    gbb->bmpfv_offset > cparams->gbb_size ||
+	    gbb->bmpfv_offset + gbb->bmpfv_size > cparams->gbb_size) {
+		VBDEBUG(("VbDisplayScreenFromGBB(): "
+			 "invalid bmpfv offset/size\n"));
+		return VBERROR_INVALID_GBB;
+	}
+
+	/* Copy bitmap data from GBB into RAM for speed */
+	if (!bmpfv) {
+#ifdef COPY_BMP_DATA
+		bmpfv = (uint8_t *)VbExMalloc(gbb->bmpfv_size);
+		Memcpy(bmpfv, ((uint8_t *)gbb) + gbb->bmpfv_offset,
+		       gbb->bmpfv_size);
+#else
+		bmpfv = ((uint8_t *)gbb) + gbb->bmpfv_offset;
+#endif
+	}
+
+	/* Sanity-check the bitmap block header */
+	hdr = (BmpBlockHeader *)bmpfv;
+	if ((0 != Memcmp(hdr->signature, BMPBLOCK_SIGNATURE,
+			 BMPBLOCK_SIGNATURE_SIZE)) ||
+	    (hdr->major_version > BMPBLOCK_MAJOR_VERSION) ||
+	    ((hdr->major_version == BMPBLOCK_MAJOR_VERSION) &&
+	     (hdr->minor_version > BMPBLOCK_MINOR_VERSION))) {
+		VBDEBUG(("VbDisplayScreenFromGBB(): "
+			 "invalid/too new bitmap header\n"));
+		retval = VBERROR_INVALID_BMPFV;
+		goto VbDisplayScreenFromGBB_exit;
+	}
 
 	/*
 	 * Translate screen ID into index.  Note that not all screens are in
@@ -198,7 +263,7 @@ VbError_t VbDisplayScreenFromGBB(VbCommonParams *cparams, uint32_t screen,
 		goto VbDisplayScreenFromGBB_exit;
 	}
 
-	if (screen_index >= hdr.number_of_screenlayouts) {
+	if (screen_index >= hdr->number_of_screenlayouts) {
 		VBDEBUG(("VbDisplayScreenFromGBB(): "
 			 "screen %d index %d not in the GBB\n",
 			 (int)screen, (int)screen_index));
@@ -208,31 +273,48 @@ VbError_t VbDisplayScreenFromGBB(VbCommonParams *cparams, uint32_t screen,
 
 	/* Clip localization to number of localizations present in the GBB */
 	VbNvGet(vncptr, VBNV_LOCALIZATION_INDEX, &localization);
-	if (localization >= hdr.number_of_localizations) {
+	if (localization >= hdr->number_of_localizations) {
 		localization = 0;
 		VbNvSet(vncptr, VBNV_LOCALIZATION_INDEX, localization);
 	}
 
+	/*
+	 * Calculate offset of screen layout = start of screen stuff + correct
+	 * locale + correct screen.
+	 */
+	offset = sizeof(BmpBlockHeader) +
+		localization * hdr->number_of_screenlayouts *
+			sizeof(ScreenLayout) +
+		screen_index * sizeof(ScreenLayout);
+	layout = (ScreenLayout *)(bmpfv + offset);
+
 	/* Display all bitmaps for the image */
 	for (i = 0; i < MAX_IMAGE_IN_LAYOUT; i++) {
-		ScreenLayout layout;
+		if (!layout->images[i].image_info_offset)
-		ImageInfo image_info;
-		char hwid[256];
-
-		ret = VbGbbReadImage(cparams, localization, screen_index,
-				    i, &layout, &image_info,
-				    &fullimage, &inoutsize);
-		if (ret == VBERROR_NO_IMAGE_PRESENT) {
 			continue;
-		} else if (ret) {
+
-			retval = ret;
+		offset = layout->images[i].image_info_offset;
+		image_info = (ImageInfo *)(bmpfv + offset);
+		fullimage = bmpfv + offset + sizeof(ImageInfo);
+		inoutsize = image_info->original_size;
+		if (inoutsize &&
+		    image_info->compression != COMPRESS_NONE) {
+			fullimage = VbExMalloc(inoutsize);
+			retval = VbExDecompress(
+					bmpfv + offset + sizeof(ImageInfo),
+					image_info->compressed_size,
+					image_info->compression,
+					fullimage, &inoutsize);
+			if (VBERROR_SUCCESS != retval) {
+				VbExFree(fullimage);
 				goto VbDisplayScreenFromGBB_exit;
 			}
+		}
 
-		switch(image_info.format) {
+		switch(image_info->format) {
 		case FORMAT_BMP:
-			retval = VbExDisplayImage(layout.images[i].x,
+			retval = VbExDisplayImage(layout->images[i].x,
-						  layout.images[i].y,
+						  layout->images[i].y,
 						  fullimage, inoutsize);
 			break;
 
@@ -241,23 +323,21 @@ VbError_t VbDisplayScreenFromGBB(VbCommonParams *cparams, uint32_t screen,
 			 * The uncompressed blob is our font structure. Cache
 			 * it as needed.
 			 */
-			font = VbInternalizeFontData(
+			font = VbInternalizeFontData(fullimage);
-					(FontArrayHeader *)fullimage);
 
 			/* TODO: handle text in general here */
-			if (TAG_HWID == image_info.tag ||
+			if (TAG_HWID == image_info->tag ||
-			    TAG_HWID_RTOL == image_info.tag) {
+			    TAG_HWID_RTOL == image_info->tag) {
-				VbRegionReadHWID(cparams, hwid, sizeof(hwid));
+				text_to_show = VbHWID(cparams);
-				text_to_show = hwid;
+				rtol = (TAG_HWID_RTOL == image_info->tag);
-				rtol = (TAG_HWID_RTOL == image_info.tag);
 			} else {
 				text_to_show = "";
 				rtol = 0;
 			}
 
 			VbRenderTextAtPos(text_to_show, rtol,
-					  layout.images[i].x,
+					  layout->images[i].x,
-					  layout.images[i].y, font);
+					  layout->images[i].y, font);
 
 			VbDoneWithFontForNow(font);
 			break;
@@ -265,10 +345,11 @@ VbError_t VbDisplayScreenFromGBB(VbCommonParams *cparams, uint32_t screen,
 		default:
 			VBDEBUG(("VbDisplayScreenFromGBB(): "
 				 "unsupported ImageFormat %d\n",
-				 image_info.format));
+				 image_info->format));
 			retval = VBERROR_INVALID_GBB;
 		}
 
+		if (COMPRESS_NONE != image_info->compression)
 			VbExFree(fullimage);
 
 		if (VBERROR_SUCCESS != retval)
@@ -278,15 +359,29 @@ VbError_t VbDisplayScreenFromGBB(VbCommonParams *cparams, uint32_t screen,
 	/* Successful if all bitmaps displayed */
 	retval = VBERROR_SUCCESS;
 
-	VbRegionCheckVersion(cparams);
+	/*
+	 * If GBB flags is nonzero, complain because that's something that the
+	 * factory MUST fix before shipping. We only have to do this here,
+	 * because it's obvious that something is wrong if we're not displaying
+	 * screens from the GBB.
+	 */
+	if (gbb->major_version == GBB_MAJOR_VER && gbb->minor_version >= 1 &&
+	    (gbb->flags != 0)) {
+		used += StrnAppend(outbuf + used, "gbb.flags is nonzero: 0x",
+				OUTBUF_LEN - used);
+		used += Uint64ToString(outbuf + used, OUTBUF_LEN - used,
+				       gbb->flags, 16, 8);
+		used += StrnAppend(outbuf + used, "\n", OUTBUF_LEN - used);
+		(void)VbExDisplayDebugInfo(outbuf);
+	}
 
  VbDisplayScreenFromGBB_exit:
 	VBDEBUG(("leaving VbDisplayScreenFromGBB() with %d\n",retval));
 	return retval;
 }
 
-VbError_t VbDisplayScreen(VbCommonParams *cparams, uint32_t screen,
+VbError_t VbDisplayScreen(VbCommonParams *cparams, uint32_t screen, int force,
-			  int force, VbNvContext *vncptr)
+                          VbNvContext *vncptr)
 {
 	VbError_t retval;
 
@@ -308,8 +403,7 @@ VbError_t VbDisplayScreen(VbCommonParams *cparams, uint32_t screen,
 	disp_current_screen = screen;
 
 	/* Look in the GBB first */
-	if (VBERROR_SUCCESS == VbDisplayScreenFromGBB(cparams, screen,
+	if (VBERROR_SUCCESS == VbDisplayScreenFromGBB(cparams, screen, vncptr))
-						      vncptr))
 		return VBERROR_SUCCESS;
 
 	/* If screen wasn't in the GBB bitmaps, fall back to a default */
@@ -477,22 +571,29 @@ VbError_t VbDisplayDebugInfo(VbCommonParams *cparams, VbNvContext *vncptr)
 {
 	VbSharedDataHeader *shared =
 		(VbSharedDataHeader *)cparams->shared_data_blob;
-	GoogleBinaryBlockHeader *gbb = cparams->gbb;
+	GoogleBinaryBlockHeader *gbb =
+		(GoogleBinaryBlockHeader *)cparams->gbb_data;
 	char buf[DEBUG_INFO_SIZE] = "";
 	char sha1sum[SHA1_DIGEST_SIZE * 2 + 1];
-	char hwid[256];
 	uint32_t used = 0;
-	VbPublicKey *key;
-	VbError_t ret;
 	uint32_t i;
 
 	/* Redisplay current screen to overwrite any previous debug output */
 	VbDisplayScreen(cparams, disp_current_screen, 1, vncptr);
 
 	/* Add hardware ID */
-	VbRegionReadHWID(cparams, hwid, sizeof(hwid));
 	used += StrnAppend(buf + used, "HWID: ", DEBUG_INFO_SIZE - used);
-	used += StrnAppend(buf + used, hwid, DEBUG_INFO_SIZE - used);
+	if (0 == gbb->hwid_size ||
+	    gbb->hwid_offset > cparams->gbb_size ||
+	    gbb->hwid_offset + gbb->hwid_size > cparams->gbb_size) {
+		VBDEBUG(("VbDisplayDebugInfo(): invalid hwid offset/size\n"));
+		used += StrnAppend(buf + used,
+				"(INVALID)", DEBUG_INFO_SIZE - used);
+  } else {
+		used += StrnAppend(buf + used,
+				(char *)((uint8_t *)gbb + gbb->hwid_offset),
+				DEBUG_INFO_SIZE - used);
+  }
 
 	/* Add recovery reason */
 	used += StrnAppend(buf + used,
@@ -553,25 +654,15 @@ VbError_t VbDisplayDebugInfo(VbCommonParams *cparams, VbNvContext *vncptr)
 	}
 
 	/* Add sha1sum for Root & Recovery keys */
-	ret = VbGbbReadRootKey(cparams, &key);
+	FillInSha1Sum(sha1sum,
-	if (!ret) {
+		(VbPublicKey *)((uint8_t *)gbb + gbb->rootkey_offset));
-		FillInSha1Sum(sha1sum, key);
+	used += StrnAppend(buf + used, "\ngbb.rootkey: ", DEBUG_INFO_SIZE - used);
-		VbExFree(key);
+	used += StrnAppend(buf + used, sha1sum, DEBUG_INFO_SIZE - used);
-		used += StrnAppend(buf + used, "\ngbb.rootkey: ",
+	FillInSha1Sum(sha1sum,
-				   DEBUG_INFO_SIZE - used);
+		(VbPublicKey *)((uint8_t *)gbb + gbb->recovery_key_offset));
-		used += StrnAppend(buf + used, sha1sum,
+	used += StrnAppend(buf + used,
-				   DEBUG_INFO_SIZE - used);
+			"\ngbb.recovery_key: ", DEBUG_INFO_SIZE - used);
-	}
+	used += StrnAppend(buf + used, sha1sum, DEBUG_INFO_SIZE - used);
-
-	ret = VbGbbReadRecoveryKey(cparams, &key);
-	if (!ret) {
-		FillInSha1Sum(sha1sum, key);
-		VbExFree(key);
-		used += StrnAppend(buf + used, "\ngbb.recovery_key: ",
-				   DEBUG_INFO_SIZE - used);
-		used += StrnAppend(buf + used, sha1sum,
-				   DEBUG_INFO_SIZE - used);
-	}
 
 	/* If we're in dev-mode, show the kernel subkey that we expect, too. */
 	if (0 == shared->recovery_reason) {

firmware/lib/vboot_firmware.c

@@ -8,8 +8,6 @@
 
 #include "sysincludes.h"
 
-#include "region.h"
-#include "gbb_access.h"
 #include "gbb_header.h"
 #include "load_firmware_fw.h"
 #include "utility.h"
@@ -43,8 +41,9 @@ int LoadFirmware(VbCommonParams *cparams, VbSelectFirmwareParams *fparams,
 {
 	VbSharedDataHeader *shared =
 		(VbSharedDataHeader *)cparams->shared_data_blob;
-	GoogleBinaryBlockHeader *gbb = cparams->gbb;
+	GoogleBinaryBlockHeader *gbb =
-	VbPublicKey *root_key = NULL;
+		(GoogleBinaryBlockHeader *)cparams->gbb_data;
+	VbPublicKey *root_key;
 	VbLoadFirmwareInternal *lfi;
 
 	uint32_t try_b_count;
@@ -63,12 +62,12 @@ int LoadFirmware(VbCommonParams *cparams, VbSelectFirmwareParams *fparams,
 	VBDEBUG(("LoadFirmware started...\n"));
 
 	/* Must have a root key from the GBB */
-	retval = VbGbbReadRootKey(cparams, &root_key);
+	if (!gbb) {
-	if (retval) {
 		VBDEBUG(("No GBB\n"));
 		retval = VBERROR_INVALID_GBB;
 		goto LoadFirmwareExit;
 	}
+	root_key = (VbPublicKey *)((uint8_t *)gbb + gbb->rootkey_offset);
 
 	/* Parse flags */
 	is_dev = (shared->flags & VBSD_BOOT_DEV_SWITCH_ON ? 1 : 0);
@@ -346,8 +345,6 @@ int LoadFirmware(VbCommonParams *cparams, VbSelectFirmwareParams *fparams,
 	}
 
  LoadFirmwareExit:
-	VbExFree(root_key);
-
 	/* Store recovery request, if any */
 	VbNvSet(vnc, VBNV_RECOVERY_REQUEST, VBERROR_SUCCESS != retval ?
 		recovery : VBNV_RECOVERY_NOT_REQUESTED);

firmware/lib/vboot_kernel.c

@@ -10,8 +10,6 @@
 
 #include "cgptlib.h"
 #include "cgptlib_internal.h"
-#include "region.h"
-#include "gbb_access.h"
 #include "gbb_header.h"
 #include "load_kernel_fw.h"
 #include "utility.h"
@@ -161,14 +159,15 @@ fail:
 	return ret;
 }
 
-VbError_t LoadKernel(LoadKernelParams *params, VbCommonParams *cparams)
+VbError_t LoadKernel(LoadKernelParams *params)
 {
 	VbSharedDataHeader *shared =
 		(VbSharedDataHeader *)params->shared_data_blob;
 	VbSharedDataKernelCall *shcall = NULL;
 	VbNvContext* vnc = params->nv_context;
-	VbPublicKey* kernel_subkey = NULL;
+	GoogleBinaryBlockHeader* gbb =
-	int free_kernel_subkey = 0;
+		(GoogleBinaryBlockHeader *)params->gbb_data;
+	VbPublicKey* kernel_subkey;
 	GptData gpt;
 	uint64_t part_start, part_size;
 	uint64_t blba;
@@ -234,10 +233,8 @@ VbError_t LoadKernel(LoadKernelParams *params, VbCommonParams *cparams)
 
 	if (kBootRecovery == boot_mode) {
 		/* Use the recovery key to verify the kernel */
-		retval = VbGbbReadRecoveryKey(cparams, &kernel_subkey);
+		kernel_subkey = (VbPublicKey*)
-		if (VBERROR_SUCCESS != retval)
+			((uint8_t*)gbb + gbb->recovery_key_offset);
-			goto LoadKernelExit;
-		free_kernel_subkey = 1;
 	} else {
 		/* Use the kernel subkey passed from LoadFirmware(). */
 		kernel_subkey = &shared->kernel_subkey;
@@ -635,8 +632,5 @@ VbError_t LoadKernel(LoadKernelParams *params, VbCommonParams *cparams)
 	/* Store how much shared data we used, if any */
 	params->shared_data_size = shared->data_used;
 
-	if (free_kernel_subkey)
-		VbExFree(kernel_subkey);
-
 	return retval;
 }

firmware/linktest/main.c

@@ -27,7 +27,7 @@ int main(void)
   LoadFirmware(0, 0, 0);
 
   /* load_kernel_fw.h */
-  LoadKernel(0, 0);
+  LoadKernel(0);
 
   /* rollback_index.h */
   RollbackS3Resume();

firmware/stub/vboot_api_stub_region.c

@@ -1,21 +0,0 @@
-/* Copyright (c) 2013 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.
- *
- * Stub implementations of region API function.
- */
-
-#include <stdint.h>
-
-#define _STUB_IMPLEMENTATION_
-
-#include <stdlib.h>
-
-#include "vboot_api.h"
-
-VbError_t VbExRegionRead(VbCommonParams *cparams,
-			 enum vb_firmware_region region, uint32_t offset,
-			 uint32_t size, void *buf)
-{
-	return VBERROR_SUCCESS;
-}

tests/vboot_api_devmode_tests.c

@@ -153,7 +153,6 @@ static void ResetMocks(void) {
   cparams.shared_data_size = sizeof(shared_data);
   cparams.shared_data_blob = shared_data;
   cparams.gbb_data = &gbb;
-  cparams.gbb = &gbb;
 
   Memset(&lkparams, 0, sizeof(lkparams));
 

tests/vboot_api_firmware_tests.c

@@ -9,7 +9,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "gbb_header.h"
 #include "host_common.h"
 #include "rollback_index.h"
 #include "test_common.h"
@@ -24,7 +23,6 @@
 /* Mock data */
 static VbCommonParams cparams;
 static VbSelectFirmwareParams fparams;
-static GoogleBinaryBlockHeader gbb;
 static VbNvContext vnc;
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader* shared = (VbSharedDataHeader*)shared_data;
@@ -51,11 +49,6 @@ static void ResetMocks(void) {
 
   Memset(&fparams, 0, sizeof(fparams));
 
-  Memset(&gbb, 0, sizeof(gbb));
-  cparams.gbb_data = &gbb;
-  cparams.gbb_size = sizeof(gbb);
-  cparams.gbb = &gbb;
-
   Memset(&vnc, 0, sizeof(vnc));
   VbNvSetup(&vnc);
   VbNvTeardown(&vnc);  /* So CRC gets generated */

tests/vboot_api_init_tests.c

@@ -40,7 +40,6 @@ static void ResetMocks(void)
 	cparams.shared_data_size = sizeof(shared_data);
 	cparams.shared_data_blob = shared_data;
 	cparams.gbb_data = &gbb;
-	cparams.gbb_size = sizeof(gbb);
 
 	Memset(&gbb, 0, sizeof(gbb));
 	gbb.major_version = GBB_MAJOR_VER;

tests/vboot_api_kernel2_tests.c

@@ -49,7 +49,6 @@ static void ResetMocks(void)
 	cparams.shared_data_size = sizeof(shared_data);
 	cparams.shared_data_blob = shared_data;
 	cparams.gbb_data = &gbb;
-	cparams.gbb = &gbb;
 
 	Memset(&gbb, 0, sizeof(gbb));
 	gbb.major_version = GBB_MAJOR_VER;

tests/vboot_api_kernel4_tests.c

@@ -41,7 +41,6 @@ static void ResetMocks(void)
 	cparams.shared_data_size = sizeof(shared_data);
 	cparams.shared_data_blob = shared_data;
 	cparams.gbb_data = &gbb;
-	cparams.gbb_size = sizeof(gbb);
 
 	Memset(&kparams, 0, sizeof(kparams));
 

tests/vboot_api_kernel_tests.c

@@ -269,7 +269,7 @@ VbError_t VbExDiskFreeInfo(VbDiskInfo *infos,
 	return VBERROR_SUCCESS;
 }
 
-VbError_t LoadKernel(LoadKernelParams *params, VbCommonParams *cparams)
+VbError_t LoadKernel(LoadKernelParams *params)
 {
 	got_find_disk = (const char *)params->disk_handle;
 	VBDEBUG(("%s(%d): got_find_disk = %s\n", __FUNCTION__,

tests/vboot_audio_tests.c

@@ -62,7 +62,6 @@ static void ResetMocks(void) {
   VBDEBUG(("ResetMocks()\n"));
   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;

tests/vboot_display_tests.c

@@ -13,11 +13,9 @@
 #include "bmpblk_font.h"
 #include "gbb_header.h"
 #include "host_common.h"
-#include "region.h"
 #include "test_common.h"
 #include "vboot_common.h"
 #include "vboot_display.h"
-#include "vboot_kernel.h"
 #include "vboot_nvstorage.h"
 
 /* Mock data */
@@ -61,20 +59,6 @@ static void ResetMocks(void)
 	cparams.gbb_data = gbb;
 	cparams.gbb_size = sizeof(gbb_data);
 
-	/*
-	 * Note, VbApiKernelFree() expects this to be allocated by
-	 * VbExMalloc(), so we cannot just assign it staticly.
-	 */
-	cparams.gbb = VbExMalloc(sizeof(*gbb));
-	gbb->header_size = sizeof(*gbb);
-	gbb->rootkey_offset = gbb_used;
-	gbb->rootkey_size = 64;
-	gbb_used += 64;
-	gbb->recovery_key_offset = gbb_used;
-	gbb->recovery_key_size = 64;
-	gbb_used += 64;
-	memcpy(cparams.gbb, gbb, sizeof(*gbb));
-
 	Memset(&vnc, 0, sizeof(vnc));
 	VbNvSetup(&vnc);
 	VbNvTeardown(&vnc);                   /* So CRC gets generated */
@@ -97,7 +81,6 @@ VbError_t VbExDisplayDebugInfo(const char *info_str)
 /* Test displaying debug info */
 static void DebugInfoTest(void)
 {
-	char hwid[VB_REGION_HWID_LEN];
 	int i;
 
 	/* Recovery string should be non-null for any code */
@@ -106,39 +89,28 @@ static void DebugInfoTest(void)
 
 	/* HWID should come from the gbb */
 	ResetMocks();
-	VbRegionReadHWID(&cparams, hwid, sizeof(hwid));
+	TEST_EQ(strcmp(VbHWID(&cparams), "Test HWID"), 0, "HWID");
-	TEST_EQ(strcmp(hwid, "Test HWID"), 0, "HWID");
-	VbApiKernelFree(&cparams);
 
 	ResetMocks();
 	cparams.gbb_size = 0;
-	VbRegionReadHWID(&cparams, hwid, sizeof(hwid));
+	TEST_EQ(strcmp(VbHWID(&cparams), "{INVALID}"), 0, "HWID bad gbb");
-	TEST_EQ(strcmp(hwid, "{INVALID}"), 0, "HWID bad gbb");
-	VbApiKernelFree(&cparams);
 
 	ResetMocks();
-	cparams.gbb->hwid_size = 0;
+	gbb->hwid_size = 0;
-	VbRegionReadHWID(&cparams, hwid, sizeof(hwid));
+	TEST_EQ(strcmp(VbHWID(&cparams), "{INVALID}"), 0, "HWID missing");
-	TEST_EQ(strcmp(hwid, "{INVALID}"), 0, "HWID missing");
-	VbApiKernelFree(&cparams);
 
 	ResetMocks();
-	cparams.gbb->hwid_offset = cparams.gbb_size + 1;
+	gbb->hwid_offset = cparams.gbb_size + 1;
-	VbRegionReadHWID(&cparams, hwid, sizeof(hwid));
+	TEST_EQ(strcmp(VbHWID(&cparams), "{INVALID}"), 0, "HWID past end");
-	TEST_EQ(strcmp(hwid, "{INVALID}"), 0, "HWID past end");
-	VbApiKernelFree(&cparams);
 
 	ResetMocks();
-	cparams.gbb->hwid_size = cparams.gbb_size;
+	gbb->hwid_size = cparams.gbb_size;
-	VbRegionReadHWID(&cparams, hwid, sizeof(hwid));
+	TEST_EQ(strcmp(VbHWID(&cparams), "{INVALID}"), 0, "HWID overflow");
-	TEST_EQ(strcmp(hwid, "{INVALID}"), 0, "HWID overflow");
-	VbApiKernelFree(&cparams);
 
 	/* Display debug info */
 	ResetMocks();
 	VbDisplayDebugInfo(&cparams, &vnc);
 	TEST_NEQ(*debug_info, '\0', "Some debug info was displayed");
-	VbApiKernelFree(&cparams);
 }
 
 /* Test localization */
@@ -147,23 +119,21 @@ static void LocalizationTest(void)
 	uint32_t count = 6;
 
 	ResetMocks();
-	cparams.gbb->bmpfv_size = 0;
+	gbb->bmpfv_size = 0;
 	TEST_EQ(VbGetLocalizationCount(&cparams, &count),
 		VBERROR_INVALID_GBB, "VbGetLocalizationCount bad gbb");
 	TEST_EQ(count, 0, "  count");
-	VbApiKernelFree(&cparams);
 
 	ResetMocks();
 	bhdr->signature[0] ^= 0x5a;
 	TEST_EQ(VbGetLocalizationCount(&cparams, &count),
 		VBERROR_INVALID_BMPFV, "VbGetLocalizationCount bad bmpfv");
-	VbApiKernelFree(&cparams);
 
 	ResetMocks();
 	TEST_EQ(VbGetLocalizationCount(&cparams, &count), 0,
 		"VbGetLocalizationCount()");
 	TEST_EQ(count, 3, "  count");
-	VbApiKernelFree(&cparams);
+
 }
 
 /* Test display key checking */
@@ -174,12 +144,10 @@ static void DisplayKeyTest(void)
 	ResetMocks();
 	VbCheckDisplayKey(&cparams, 'q', &vnc);
 	TEST_EQ(*debug_info, '\0', "DisplayKey q = does nothing");
-	VbApiKernelFree(&cparams);
 
 	ResetMocks();
 	VbCheckDisplayKey(&cparams, '\t', &vnc);
 	TEST_NEQ(*debug_info, '\0', "DisplayKey tab = display");
-	VbApiKernelFree(&cparams);
 
 	/* Toggle localization */
 	ResetMocks();
@@ -197,7 +165,6 @@ static void DisplayKeyTest(void)
 	VbCheckDisplayKey(&cparams, VB_KEY_UP, &vnc);
 	VbNvGet(&vnc, VBNV_LOCALIZATION_INDEX, &u);
 	TEST_EQ(u, 0, "DisplayKey up");
-	VbApiKernelFree(&cparams);
 
 	/* Reset localization if localization count is invalid */
 	ResetMocks();
@@ -207,7 +174,7 @@ static void DisplayKeyTest(void)
 	VbCheckDisplayKey(&cparams, VB_KEY_UP, &vnc);
 	VbNvGet(&vnc, VBNV_LOCALIZATION_INDEX, &u);
 	TEST_EQ(u, 0, "DisplayKey invalid");
-	VbApiKernelFree(&cparams);
+
 }
 
 static void FontTest(void)

tests/vboot_firmware_tests.c

@@ -8,7 +8,6 @@
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <string.h>
 
 #include "gbb_header.h"
 #include "host_common.h"
@@ -34,20 +33,13 @@ static uint8_t* digest_returned;
 static uint8_t* digest_expect_ptr;
 static int hash_fw_index;
 
-#define TEST_KEY_DATA	\
-	"Test contents for the root key this should be 64 chars long."
-
 /* Reset mock data (for use before each test) */
 static void ResetMocks(void) {
-  VbPublicKey *root_key;
-  uint8_t *root_key_data;
   int i;
 
   Memset(&cparams, 0, sizeof(cparams));
   cparams.shared_data_blob = shared_data;
   cparams.gbb_data = gbb_data;
-  cparams.gbb_size = sizeof(gbb_data);
-  cparams.gbb = gbb;
 
   Memset(&fparams, 0, sizeof(fparams));
   fparams.verification_block_A = vblock;
@@ -83,14 +75,6 @@ static void ResetMocks(void) {
 
   Memset(&gbb_data, 0, sizeof(gbb_data));
   gbb->rootkey_offset = sizeof(GoogleBinaryBlockHeader);
-  root_key = (VbPublicKey *)(gbb_data + gbb->rootkey_offset);
-  root_key_data = (uint8_t *)(root_key + 1);
-  strcpy((char *)root_key_data, TEST_KEY_DATA);
-  PublicKeyInit(root_key, (uint8_t *)root_key_data, sizeof(TEST_KEY_DATA));
-
-  gbb->major_version = GBB_MAJOR_VER;
-  gbb->minor_version = GBB_MINOR_VER;
-  gbb->flags = 0;
 
   Memset(&data_key, 0, sizeof(data_key));
 
@@ -107,13 +91,7 @@ int KeyBlockVerify(const VbKeyBlockHeader* block, uint64_t size,
                    const VbPublicKey *key, int hash_only) {
 
   TEST_EQ(hash_only, 0, "  Don't verify firmware with hash");
-
+  TEST_PTR_EQ(key, gbb_data + gbb->rootkey_offset, "  Verify with root key");
-  /*
-   * We cannot check the address of key, since it will be allocated. We
-   * check the contents instead.
-   */
-  TEST_STR_EQ((char *)GetPublicKeyDataC(key), TEST_KEY_DATA,
-              "  Verify with root key");
   TEST_NEQ(block==vblock || block==vblock+1, 0, "  Verify a valid key block");
 
   /* Mock uses header_version_major to hold return value */

tests/vboot_kernel_tests.c

@@ -47,8 +47,7 @@ static int verify_data_fail;
 static RSAPublicKey *mock_data_key;
 static int mock_data_key_allocated;
 
-static uint8_t gbb_data[sizeof(GoogleBinaryBlockHeader) + 2048];
+static GoogleBinaryBlockHeader gbb;
-static GoogleBinaryBlockHeader *gbb = (GoogleBinaryBlockHeader*)gbb_data;
 static VbExDiskHandle_t handle;
 static VbNvContext vnc;
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
@@ -56,7 +55,6 @@ static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
 static LoadKernelParams lkp;
 static VbKeyBlockHeader kbh;
 static VbKernelPreambleHeader kph;
-static VbCommonParams cparams;
 
 static void ResetCallLog(void)
 {
@@ -81,15 +79,10 @@ static void ResetMocks(void)
 	mock_data_key = (RSAPublicKey *)"TestDataKey";
 	mock_data_key_allocated = 0;
 
-	memset(gbb, 0, sizeof(gbb));
+	memset(&gbb, 0, sizeof(gbb));
-	gbb->major_version = GBB_MAJOR_VER;
+	gbb.major_version = GBB_MAJOR_VER;
-	gbb->minor_version = GBB_MINOR_VER;
+	gbb.minor_version = GBB_MINOR_VER;
-	gbb->flags = 0;
+	gbb.flags = 0;
-
-	memset(&cparams, '\0', sizeof(cparams));
-	cparams.gbb = gbb;
-	cparams.gbb_data = gbb;
-	cparams.gbb_size = sizeof(gbb_data);
 
 	memset(&vnc, 0, sizeof(vnc));
 	VbNvSetup(&vnc);
@@ -102,8 +95,7 @@ static void ResetMocks(void)
 	memset(&lkp, 0, sizeof(lkp));
 	lkp.nv_context = &vnc;
 	lkp.shared_data_blob = shared;
-	lkp.gbb_data = gbb;
+	lkp.gbb_data = &gbb;
-	lkp.gbb_size = sizeof(gbb_data);
 	lkp.bytes_per_lba = 512;
 	lkp.ending_lba = 1023;
 	lkp.kernel_buffer = kernel_buffer;
@@ -137,8 +129,6 @@ VbError_t VbExDiskRead(VbExDiskHandle_t handle, uint64_t lba_start,
 	if ((int)lba_start == disk_read_to_fail)
 		return VBERROR_SIMULATED;
 
-	/* Keep valgrind happy */
-	Memset(buffer, '\0', lba_count);
 	return VBERROR_SUCCESS;
 }
 
@@ -248,11 +238,6 @@ static void ReadWriteGptTest(void)
 		   "VbExDiskRead(h, 991, 32)\n"
 		   "VbExDiskRead(h, 1023, 1)\n");
 	ResetCallLog();
-	/*
-	 * Valgrind complains about access to uninitialized memory here, so
-	 * zero the primary header before each test.
-	 */
-	Memset(g.primary_header, '\0', g.sector_bytes);
 	TEST_EQ(WriteAndFreeGptData(handle, &g), 0, "WriteAndFree");
 	TEST_CALLS("");
 
@@ -261,7 +246,6 @@ static void ReadWriteGptTest(void)
 	AllocAndReadGptData(handle, &g);
 	g.modified |= GPT_MODIFIED_HEADER1 | GPT_MODIFIED_ENTRIES1;
 	ResetCallLog();
-	Memset(g.primary_header, '\0', g.sector_bytes);
 	TEST_EQ(WriteAndFreeGptData(handle, &g), 0, "WriteAndFree mod 1");
 	TEST_CALLS("VbExDiskWrite(h, 1, 1)\n"
 		   "VbExDiskWrite(h, 2, 32)\n");
@@ -271,7 +255,6 @@ static void ReadWriteGptTest(void)
 	AllocAndReadGptData(handle, &g);
 	g.modified = -1;
 	ResetCallLog();
-	Memset(g.primary_header, '\0', g.sector_bytes);
 	TEST_EQ(WriteAndFreeGptData(handle, &g), 0, "WriteAndFree mod all");
 	TEST_CALLS("VbExDiskWrite(h, 1, 1)\n"
 		   "VbExDiskWrite(h, 2, 32)\n"
@@ -293,25 +276,21 @@ static void ReadWriteGptTest(void)
 	ResetMocks();
 	disk_read_to_fail = 1;
 	TEST_NEQ(AllocAndReadGptData(handle, &g), 0, "AllocAndRead disk fail");
-	Memset(g.primary_header, '\0', g.sector_bytes);
 	WriteAndFreeGptData(handle, &g);
 
 	ResetMocks();
 	disk_read_to_fail = 2;
 	TEST_NEQ(AllocAndReadGptData(handle, &g), 0, "AllocAndRead disk fail");
-	Memset(g.primary_header, '\0', g.sector_bytes);
 	WriteAndFreeGptData(handle, &g);
 
 	ResetMocks();
 	disk_read_to_fail = 991;
 	TEST_NEQ(AllocAndReadGptData(handle, &g), 0, "AllocAndRead disk fail");
-	Memset(g.primary_header, '\0', g.sector_bytes);
 	WriteAndFreeGptData(handle, &g);
 
 	ResetMocks();
 	disk_read_to_fail = 1023;
 	TEST_NEQ(AllocAndReadGptData(handle, &g), 0, "AllocAndRead disk fail");
-	Memset(g.primary_header, '\0', g.sector_bytes);
 	WriteAndFreeGptData(handle, &g);
 
 	/* Error writing */
@@ -319,28 +298,24 @@ static void ReadWriteGptTest(void)
 	disk_write_to_fail = 1;
 	AllocAndReadGptData(handle, &g);
 	g.modified = -1;
-	Memset(g.primary_header, '\0', g.sector_bytes);
 	TEST_NEQ(WriteAndFreeGptData(handle, &g), 0, "WriteAndFree disk fail");
 
 	ResetMocks();
 	disk_write_to_fail = 2;
 	AllocAndReadGptData(handle, &g);
 	g.modified = -1;
-	Memset(g.primary_header, '\0', g.sector_bytes);
 	TEST_NEQ(WriteAndFreeGptData(handle, &g), 0, "WriteAndFree disk fail");
 
 	ResetMocks();
 	disk_write_to_fail = 991;
 	AllocAndReadGptData(handle, &g);
 	g.modified = -1;
-	Memset(g.primary_header, '\0', g.sector_bytes);
 	TEST_NEQ(WriteAndFreeGptData(handle, &g), 0, "WriteAndFree disk fail");
 
 	ResetMocks();
 	disk_write_to_fail = 1023;
 	AllocAndReadGptData(handle, &g);
 	g.modified = -1;
-	Memset(g.primary_header, '\0', g.sector_bytes);
 	TEST_NEQ(WriteAndFreeGptData(handle, &g), 0, "WriteAndFree disk fail");
 
 }
@@ -352,28 +327,23 @@ static void InvalidParamsTest(void)
 {
 	ResetMocks();
 	lkp.bytes_per_lba = 0;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_PARAMETER,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_PARAMETER, "Bad lba size");
-		"Bad lba size");
 
 	ResetMocks();
 	lkp.ending_lba = 0;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_PARAMETER,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_PARAMETER, "Bad lba count");
-		"Bad lba count");
 
 	ResetMocks();
 	lkp.bytes_per_lba = 128*1024;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_PARAMETER,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_PARAMETER, "Huge lba size");
-		"Huge lba size");
 
 	ResetMocks();
 	disk_read_to_fail = 1;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_NO_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_NO_KERNEL_FOUND, "Can't read disk");
-		"Can't read disk");
 
 	ResetMocks();
 	gpt_init_fail = 1;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_NO_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_NO_KERNEL_FOUND, "Bad GPT");
-		"Bad GPT");
 }
 
 static void LoadKernelTest(void)
@@ -381,7 +351,7 @@ static void LoadKernelTest(void)
 	uint32_t u;
 
 	ResetMocks();
-	TEST_EQ(LoadKernel(&lkp, &cparams), 0, "First kernel good");
+	TEST_EQ(LoadKernel(&lkp), 0, "First kernel good");
 	TEST_EQ(lkp.partition_number, 1, "  part num");
 	TEST_EQ(lkp.bootloader_address, 0xbeadd008, "  bootloader addr");
 	TEST_EQ(lkp.bootloader_size, 0x1234, "  bootloader size");
@@ -392,46 +362,46 @@ static void LoadKernelTest(void)
 	ResetMocks();
 	mock_parts[1].start = 300;
 	mock_parts[1].size = 150;
-	TEST_EQ(LoadKernel(&lkp, &cparams), 0, "Two good kernels");
+	TEST_EQ(LoadKernel(&lkp), 0, "Two good kernels");
 	TEST_EQ(lkp.partition_number, 1, "  part num");
 	TEST_EQ(mock_part_next, 1, "  didn't read second one");
 
 	/* Fail if no kernels found */
 	ResetMocks();
 	mock_parts[0].size = 0;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_NO_KERNEL_FOUND, "No kernels");
+	TEST_EQ(LoadKernel(&lkp), VBERROR_NO_KERNEL_FOUND, "No kernels");
 	VbNvGet(&vnc, VBNV_RECOVERY_REQUEST, &u);
 	TEST_EQ(u, VBNV_RECOVERY_RW_NO_OS, "  recovery request");
 
 	/* Skip kernels which are too small */
 	ResetMocks();
 	mock_parts[0].size = 10;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND, "Too small");
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND, "Too small");
 	VbNvGet(&vnc, VBNV_RECOVERY_REQUEST, &u);
 	TEST_EQ(u, VBNV_RECOVERY_RW_INVALID_OS, "  recovery request");
 
 	ResetMocks();
 	disk_read_to_fail = 100;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND,
 		"Fail reading kernel start");
 
 	ResetMocks();
 	key_block_verify_fail = 1;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND,
 		"Fail key block sig");
 
 	/* In dev mode, fail if hash is bad too */
 	ResetMocks();
 	lkp.boot_flags |= BOOT_FLAG_DEVELOPER;
 	key_block_verify_fail = 2;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND,
 		"Fail key block dev hash");
 
 	/* But just bad sig is ok */
 	ResetMocks();
 	lkp.boot_flags |= BOOT_FLAG_DEVELOPER;
 	key_block_verify_fail = 1;
-	TEST_EQ(LoadKernel(&lkp, &cparams), 0, "Succeed key block dev sig");
+	TEST_EQ(LoadKernel(&lkp), 0, "Succeed key block dev sig");
 
 	/* In dev mode and requiring signed kernel, fail if sig is bad */
 	ResetMocks();
@@ -439,126 +409,124 @@ static void LoadKernelTest(void)
 	VbNvSet(&vnc, VBNV_DEV_BOOT_SIGNED_ONLY, 1);
 	VbNvTeardown(&vnc);
 	key_block_verify_fail = 1;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND,
 		"Fail key block dev sig");
 
 	/* Check key block flag mismatches */
 	ResetMocks();
 	kbh.key_block_flags =
 		KEY_BLOCK_FLAG_RECOVERY_0 | KEY_BLOCK_FLAG_DEVELOPER_1;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND,
 		"Key block dev flag mismatch");
 
 	ResetMocks();
 	kbh.key_block_flags =
 		KEY_BLOCK_FLAG_RECOVERY_1 | KEY_BLOCK_FLAG_DEVELOPER_0;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND,
 		"Key block rec flag mismatch");
 
 	ResetMocks();
 	lkp.boot_flags |= BOOT_FLAG_RECOVERY;
 	kbh.key_block_flags =
 		KEY_BLOCK_FLAG_RECOVERY_1 | KEY_BLOCK_FLAG_DEVELOPER_1;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND,
 		"Key block recdev flag mismatch");
 
 	ResetMocks();
 	lkp.boot_flags |= BOOT_FLAG_RECOVERY | BOOT_FLAG_DEVELOPER;
 	kbh.key_block_flags =
 		KEY_BLOCK_FLAG_RECOVERY_1 | KEY_BLOCK_FLAG_DEVELOPER_0;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND,
 		"Key block rec!dev flag mismatch");
 
 	ResetMocks();
 	kbh.data_key.key_version = 1;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND,
 		"Key block kernel key rollback");
 
 	ResetMocks();
 	kbh.data_key.key_version = 0x10000;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND,
 		"Key block kernel key version too big");
 
 	ResetMocks();
 	kbh.data_key.key_version = 3;
-	TEST_EQ(LoadKernel(&lkp, &cparams), 0, "Key block version roll forward");
+	TEST_EQ(LoadKernel(&lkp), 0, "Key block version roll forward");
 	TEST_EQ(shared->kernel_version_tpm, 0x30001, "  shared version");
 
 	ResetMocks();
 	kbh.data_key.key_version = 3;
 	mock_parts[1].start = 300;
 	mock_parts[1].size = 150;
-	TEST_EQ(LoadKernel(&lkp, &cparams), 0, "Two kernels roll forward");
+	TEST_EQ(LoadKernel(&lkp), 0, "Two kernels roll forward");
 	TEST_EQ(mock_part_next, 2, "  read both");
 	TEST_EQ(shared->kernel_version_tpm, 0x30001, "  shared version");
 
 	ResetMocks();
 	kbh.data_key.key_version = 1;
 	lkp.boot_flags |= BOOT_FLAG_DEVELOPER;
-	TEST_EQ(LoadKernel(&lkp, &cparams), 0, "Key version ignored in dev mode");
+	TEST_EQ(LoadKernel(&lkp), 0, "Key version ignored in dev mode");
 
 	ResetMocks();
 	kbh.data_key.key_version = 1;
 	lkp.boot_flags |= BOOT_FLAG_RECOVERY;
-	TEST_EQ(LoadKernel(&lkp, &cparams), 0, "Key version ignored in rec mode");
+	TEST_EQ(LoadKernel(&lkp), 0, "Key version ignored in rec mode");
 
 	ResetMocks();
 	mock_data_key = NULL;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND, "Bad data key");
-		"Bad data key");
 
 	ResetMocks();
 	preamble_verify_fail = 1;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND,	"Bad preamble");
-		"Bad preamble");
 
 	ResetMocks();
 	kph.kernel_version = 0;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND,
 		"Kernel version rollback");
 
 	ResetMocks();
 	kph.kernel_version = 0;
 	lkp.boot_flags |= BOOT_FLAG_DEVELOPER;
-	TEST_EQ(LoadKernel(&lkp, &cparams), 0, "Kernel version ignored in dev mode");
+	TEST_EQ(LoadKernel(&lkp), 0, "Kernel version ignored in dev mode");
 
 	ResetMocks();
 	kph.kernel_version = 0;
 	lkp.boot_flags |= BOOT_FLAG_RECOVERY;
-	TEST_EQ(LoadKernel(&lkp, &cparams), 0, "Kernel version ignored in rec mode");
+	TEST_EQ(LoadKernel(&lkp), 0, "Kernel version ignored in rec mode");
 
 	ResetMocks();
 	kph.preamble_size |= 0x07;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND,
 		"Kernel body offset");
 
 	/* Check getting kernel load address from header */
 	ResetMocks();
 	kph.body_load_address = (size_t)kernel_buffer;
 	lkp.kernel_buffer = NULL;
-	TEST_EQ(LoadKernel(&lkp, &cparams), 0, "Get load address from preamble");
+	TEST_EQ(LoadKernel(&lkp), 0, "Get load address from preamble");
 	TEST_PTR_EQ(lkp.kernel_buffer, kernel_buffer, "  address");
 	/* Size is rounded up to nearest sector */
 	TEST_EQ(lkp.kernel_buffer_size, 70144, "  size");
 
 	ResetMocks();
 	lkp.kernel_buffer_size = 8192;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND,
 		"Kernel too big for buffer");
 
 	ResetMocks();
 	mock_parts[0].size = 130;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND,
 		"Kernel too big for partition");
 
 	ResetMocks();
 	disk_read_to_fail = 108;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND,
 		"Fail reading kernel data");
 
 	ResetMocks();
 	verify_data_fail = 1;
-	TEST_EQ(LoadKernel(&lkp, &cparams), VBERROR_INVALID_KERNEL_FOUND,	"Bad data");
+	TEST_EQ(LoadKernel(&lkp), VBERROR_INVALID_KERNEL_FOUND,	"Bad data");
 }
 
 int main(void)

tests/vboot_region_tests.c

@@ -1,213 +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_nvstorage.h"
-#include "vboot_struct.h"
-
-/* Mock data */
-static VbCommonParams cparams;
-static VbNvContext vnc;
-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(&vnc, 0, sizeof(vnc));
-	VbNvSetup(&vnc);
-	VbNvTeardown(&vnc);                   /* So CRC gets generated */
-
-	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 */
-
-uint32_t SetTPMBootModeState(int developer_mode, int recovery_mode,
-                             uint64_t fw_keyblock_flags) {
-  return VBERROR_SUCCESS;
-}
-
-VbError_t VbExNvStorageRead(uint8_t* buf) {
-  Memcpy(buf, vnc.raw, sizeof(vnc.raw));
-  return VBERROR_SUCCESS;
-}
-
-VbError_t VbExNvStorageWrite(const uint8_t* buf) {
-  Memcpy(vnc.raw, buf, sizeof(vnc.raw));
-  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[]) {
-  int error_code = 0;
-
-  VbRegionReadTest();
-
-  if (vboot_api_stub_check_memory())
-    error_code = 255;
-  if (!gTestSuccess)
-    error_code = 255;
-
-  return error_code;
-}

utility/load_kernel_test.c

@@ -27,7 +27,6 @@
 
 /* Global variables for stub functions */
 static LoadKernelParams lkp;
-static VbCommonParams cparams;
 static VbNvContext vnc;
 static FILE *image_file = NULL;
 
@@ -95,7 +94,6 @@ int main(int argc, char* argv[]) {
   Memset(&vnc, 0, sizeof(VbNvContext));
   VbNvSetup(&vnc);
   lkp.nv_context = &vnc;
-  Memset(&cparams, 0, sizeof(VbCommonParams));
 
   /* Parse options */
   opterr = 0;
@@ -159,7 +157,6 @@ int main(int argc, char* argv[]) {
   lkp.gbb_size = sizeof(GoogleBinaryBlockHeader) + key_size;
   lkp.gbb_data = (void*)malloc(lkp.gbb_size);
   gbb = (GoogleBinaryBlockHeader*)lkp.gbb_data;
-  cparams.gbb = gbb;
   Memset(gbb, 0, lkp.gbb_size);
   Memcpy(gbb->signature, GBB_SIGNATURE, GBB_SIGNATURE_SIZE);
   gbb->major_version = GBB_MAJOR_VER;
@@ -217,7 +214,7 @@ int main(int argc, char* argv[]) {
   lkp.kernel_buffer_size = KERNEL_BUFFER_SIZE;
 
   /* Call LoadKernel() */
-  rv = LoadKernel(&lkp, &cparams);
+  rv = LoadKernel(&lkp);
   printf("LoadKernel() returned %d\n", rv);
 
   if (VBERROR_SUCCESS == rv) {