vboot: rename VbError_t typedef to vb2_error_t

As part of the conversion of error codes from vboot1 to vboot2,
replace all instances of VbError_t with vb2_error_t.

vboot2 currently uses the int type for return values, but we
would like to implement the use of vb2_error_t instead, which is
potentially clearer than simply using an int.  Existing functions
will be converted to use vb2_error_t in a subsequent CL.

BUG=b:124141368, chromium:988410
TEST=make clean && make runtests
BRANCH=none

Change-Id: Iee90d9a1f46bcf5f088e981ba6ddbcf886ff0f18
Signed-off-by: Joel Kitching <kitching@google.com>
Cq-Depend: chromium:1728112
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/vboot_reference/+/1722914
Reviewed-by: Julius Werner <jwerner@chromium.org>
Commit-Queue: Joel Kitching <kitching@chromium.org>
Tested-by: Joel Kitching <kitching@chromium.org>

31 files changed, 295 insertions, 296 deletions

diff --git a/firmware/2lib/include/2return_codes.h b/firmware/2lib/include/2return_codes.h
index 39165533..f1245875 100644
--- a/firmware/2lib/include/2return_codes.h
+++ b/firmware/2lib/include/2return_codes.h
@@ -7,6 +7,12 @@
 #define VBOOT_2_RETURN_CODES_H_
 
 /*
+ * Functions which return an error all return this type.  This is a 32-bit
+ * value rather than an int so it's consistent across different architectures.
+ */
+typedef uint32_t vb2_error_t;
+
+/*
  * Return codes from verified boot functions.
  *
  * Note that other values may be passed through from vb2ex_*() calls; see
diff --git a/firmware/include/vboot_api.h b/firmware/include/vboot_api.h
index 86c00215..0621750b 100644
--- a/firmware/include/vboot_api.h
+++ b/firmware/include/vboot_api.h
@@ -24,6 +24,7 @@
 #include <stdint.h>
 #include <stdlib.h>
 
+#include "../2lib/include/2return_codes.h"
 #include "gpt.h"
 
 #ifdef __cplusplus
@@ -33,16 +34,6 @@ extern "C" {
 struct vb2_context;
 typedef struct VbSharedDataHeader VbSharedDataHeader;
 
-/*****************************************************************************/
-/* Error codes */
-
-/*
- * Functions which return an error all return this type.  This is a 32-bit
- * value rather than an int so it's consistent across UEFI, which is 32-bit
- * during PEI and 64-bit during DXE/BDS.
- */
-typedef uint32_t VbError_t;
-
 /*
  * Define test_mockable for mocking functions.
  */
@@ -163,9 +154,9 @@ typedef struct VbSelectAndLoadKernelParams {
  *
  * Returns VBERROR_SUCCESS if success, non-zero if error; on error, caller
  * should reboot. */
-VbError_t VbSelectAndLoadKernel(struct vb2_context *ctx,
-				VbSharedDataHeader *shared,
-				VbSelectAndLoadKernelParams *kparams);
+vb2_error_t VbSelectAndLoadKernel(struct vb2_context *ctx,
+				  VbSharedDataHeader *shared,
+				  VbSelectAndLoadKernelParams *kparams);
 
 /**
  * Verify Kernel Image loaded in memory.
@@ -183,11 +174,10 @@ VbError_t VbSelectAndLoadKernel(struct vb2_context *ctx,
  * @param image_size	Size of the image in memory
  * @return VBERROR_... error, VBERROR_SUCCESS on success.
  */
-VbError_t VbVerifyMemoryBootImage(struct vb2_context *ctx,
-				  VbSharedDataHeader *shared,
-				  VbSelectAndLoadKernelParams *kparams,
-				  void *boot_image,
-				  size_t image_size);
+vb2_error_t VbVerifyMemoryBootImage(struct vb2_context *ctx,
+				    VbSharedDataHeader *shared,
+				    VbSelectAndLoadKernelParams *kparams,
+				    void *boot_image, size_t image_size);
 
 /**
  * Fastboot API to enter dev mode.
@@ -202,7 +192,7 @@ VbError_t VbVerifyMemoryBootImage(struct vb2_context *ctx,
  *
  * @return VBERROR_... error, VBERROR_SUCCESS on success.
  */
-VbError_t VbUnlockDevice(void);
+vb2_error_t VbUnlockDevice(void);
 
 /*****************************************************************************/
 /* Timer and delay (first two from utility.h) */
@@ -245,22 +235,22 @@ void VbExSleepMs(uint32_t msec);
  * support is not available.  At a minimum, it must delay for the specified
  * non-zero duration.
  */
-VbError_t VbExBeep(uint32_t msec, uint32_t frequency);
+vb2_error_t VbExBeep(uint32_t msec, uint32_t frequency);
 
 /*****************************************************************************/
 /* TPM (from tlcl_stub.h) */
 
 /**
  * Initialize the stub library. */
-VbError_t VbExTpmInit(void);
+vb2_error_t VbExTpmInit(void);
 
 /**
  * Close and open the device.  This is needed for running more complex commands
  * at user level, such as TPM_TakeOwnership, since the TPM device can be opened
  * only by one process at a time.
  */
-VbError_t VbExTpmClose(void);
-VbError_t VbExTpmOpen(void);
+vb2_error_t VbExTpmClose(void);
+vb2_error_t VbExTpmOpen(void);
 
 /**
  * Send request to TPM and receive response
@@ -291,7 +281,7 @@ uint32_t VbExTpmSendReceive(const uint8_t *request, uint32_t request_length,
  * attacker with communication interception abilities could launch replay
  * attacks by reusing previous nonces.
  */
-VbError_t VbExTpmGetRandom(uint8_t *buf, uint32_t length);
+vb2_error_t VbExTpmGetRandom(uint8_t *buf, uint32_t length);
 
 #endif  /* CHROMEOS_ENVIRONMENT */
 
@@ -303,12 +293,12 @@ VbError_t VbExTpmGetRandom(uint8_t *buf, uint32_t length);
 /**
  * Read the VBNV_BLOCK_SIZE-byte non-volatile storage into buf.
  */
-VbError_t VbExNvStorageRead(uint8_t *buf);
+vb2_error_t VbExNvStorageRead(uint8_t *buf);
 
 /**
  * Write the VBNV_BLOCK_SIZE-byte non-volatile storage from buf.
  */
-VbError_t VbExNvStorageWrite(const uint8_t *buf);
+vb2_error_t VbExNvStorageWrite(const uint8_t *buf);
 
 /*****************************************************************************/
 /* Disk access (previously in boot_device.h) */
@@ -396,8 +386,8 @@ typedef struct VbDiskInfo {
  * The firmware must not alter or free the list pointed to by [infos_ptr] until
  * VbExDiskFreeInfo() is called.
  */
-VbError_t VbExDiskGetInfo(VbDiskInfo **infos_ptr, uint32_t *count,
-			  uint32_t disk_flags);
+vb2_error_t VbExDiskGetInfo(VbDiskInfo **infos_ptr, uint32_t *count,
+			    uint32_t disk_flags);
 
 /**
  * Free a disk information list [infos] previously returned by
@@ -405,8 +395,8 @@ VbError_t VbExDiskGetInfo(VbDiskInfo **infos_ptr, uint32_t *count,
  * that handle remains valid after this call; all other handles from the info
  * list need not remain valid after this call.
  */
-VbError_t VbExDiskFreeInfo(VbDiskInfo *infos,
-			   VbExDiskHandle_t preserve_handle);
+vb2_error_t VbExDiskFreeInfo(VbDiskInfo *infos,
+			     VbExDiskHandle_t preserve_handle);
 
 /**
  * Read lba_count LBA sectors, starting at sector lba_start, from the disk,
@@ -419,8 +409,8 @@ VbError_t VbExDiskFreeInfo(VbDiskInfo *infos,
  * which as been removed), the function must return error but must not
  * crash.
  */
-VbError_t VbExDiskRead(VbExDiskHandle_t handle, uint64_t lba_start,
-		       uint64_t lba_count, void *buffer);
+vb2_error_t VbExDiskRead(VbExDiskHandle_t handle, uint64_t lba_start,
+			 uint64_t lba_count, void *buffer);
 
 /**
  * Write lba_count LBA sectors, starting at sector lba_start, to the disk, from
@@ -433,8 +423,8 @@ VbError_t VbExDiskRead(VbExDiskHandle_t handle, uint64_t lba_start,
  * which as been removed), the function must return error but must not
  * crash.
  */
-VbError_t VbExDiskWrite(VbExDiskHandle_t handle, uint64_t lba_start,
-			uint64_t lba_count, const void *buffer);
+vb2_error_t VbExDiskWrite(VbExDiskHandle_t handle, uint64_t lba_start,
+			  uint64_t lba_count, const void *buffer);
 
 /* Streaming read interface */
 typedef void *VbExStream_t;
@@ -453,8 +443,8 @@ typedef void *VbExStream_t;
  * device. It is not used to access the GPT. The size of the content addressed
  * is within streaming_lba_count.
  */
-VbError_t VbExStreamOpen(VbExDiskHandle_t handle, uint64_t lba_start,
-			 uint64_t lba_count, VbExStream_t *stream_ptr);
+vb2_error_t VbExStreamOpen(VbExDiskHandle_t handle, uint64_t lba_start,
+			   uint64_t lba_count, VbExStream_t *stream_ptr);
 
 /**
  * Read from a stream on a disk
@@ -469,7 +459,7 @@ VbError_t VbExStreamOpen(VbExDiskHandle_t handle, uint64_t lba_start,
  * This is used for access to the contents of the actual partitions on the
  * device. It is not used to access the GPT.
  */
-VbError_t VbExStreamRead(VbExStream_t stream, uint32_t bytes, void *buffer);
+vb2_error_t VbExStreamRead(VbExStream_t stream, uint32_t bytes, void *buffer);
 
 /**
  * Close a stream
@@ -558,7 +548,7 @@ typedef struct VbScreenData
  * to be simple ASCII text such as "NO GOOD" or "INSERT"; these screens should
  * only be seen during development.
  */
-VbError_t VbExDisplayScreen(uint32_t screen_type, uint32_t locale,
+vb2_error_t VbExDisplayScreen(uint32_t screen_type, uint32_t locale,
 			    const VbScreenData *data);
 
 /**
@@ -573,7 +563,7 @@ VbError_t VbExDisplayScreen(uint32_t screen_type, uint32_t locale,
  *
  * @return VBERROR_SUCCESS or error code on error.
  */
-VbError_t VbExDisplayMenu(uint32_t screen_type, uint32_t locale,
+vb2_error_t VbExDisplayMenu(uint32_t screen_type, uint32_t locale,
 			  uint32_t selected_index, uint32_t disabled_idx_mask,
 			  uint32_t redraw_base);
 
@@ -590,7 +580,7 @@ VbError_t VbExDisplayMenu(uint32_t screen_type, uint32_t locale,
  *
  * @return VBERROR_SUCCESS or error code on error.
  */
-VbError_t VbExDisplayDebugInfo(const char *info_str, int full_info);
+vb2_error_t VbExDisplayDebugInfo(const char *info_str, int full_info);
 
 /**
  * Write vendor data to read-only VPD
@@ -601,7 +591,7 @@ VbError_t VbExDisplayDebugInfo(const char *info_str, int full_info);
  *
  * @return VBERROR_SUCCESS or error code on error.
  */
-VbError_t VbExSetVendorData(const char *vendor_data_value);
+vb2_error_t VbExSetVendorData(const char *vendor_data_value);
 
 /*****************************************************************************/
 /* Keyboard and switches */
@@ -707,20 +697,20 @@ int VbExTrustEC(int devidx);
  * If the EC is in RO code, sets *in_rw=0.
  * If the EC is in RW code, sets *in_rw non-zero.
  * If the current EC image is unknown, returns error. */
-VbError_t VbExEcRunningRW(int devidx, int *in_rw);
+vb2_error_t VbExEcRunningRW(int devidx, int *in_rw);
 
 /**
  * Request the EC jump to its rewritable code.  If successful, returns when the
  * EC has booting its RW code far enough to respond to subsequent commands.
  * Does nothing if the EC is already in its rewritable code.
  */
-VbError_t VbExEcJumpToRW(int devidx);
+vb2_error_t VbExEcJumpToRW(int devidx);
 
 /**
  * Tell the EC to refuse another jump until it reboots. Subsequent calls to
  * VbExEcJumpToRW() in this boot will fail.
  */
-VbError_t VbExEcDisableJump(int devidx);
+vb2_error_t VbExEcDisableJump(int devidx);
 
 /**
  * Read the SHA-256 hash of the selected EC image.
@@ -731,42 +721,43 @@ VbError_t VbExEcDisableJump(int devidx);
  * @param hash_size Pointer to the hash size.
  * @return          VBERROR_... error, VBERROR_SUCCESS on success.
  */
-VbError_t VbExEcHashImage(int devidx, enum VbSelectFirmware_t select,
-			  const uint8_t **hash, int *hash_size);
+vb2_error_t VbExEcHashImage(int devidx, enum VbSelectFirmware_t select,
+			    const uint8_t **hash, int *hash_size);
 
 /**
  * Get the expected contents of the EC image associated with the main firmware
  * specified by the "select" argument.
  */
-VbError_t VbExEcGetExpectedImage(int devidx, enum VbSelectFirmware_t select,
-				 const uint8_t **image, int *image_size);
+vb2_error_t VbExEcGetExpectedImage(int devidx, enum VbSelectFirmware_t select,
+				   const uint8_t **image, int *image_size);
 
 /**
  * Read the SHA-256 hash of the expected contents of the EC image associated
  * with the main firmware specified by the "select" argument.
  */
-VbError_t VbExEcGetExpectedImageHash(int devidx, enum VbSelectFirmware_t select,
-				     const uint8_t **hash, int *hash_size);
+vb2_error_t VbExEcGetExpectedImageHash(int devidx,
+				       enum VbSelectFirmware_t select,
+				       const uint8_t **hash, int *hash_size);
 
 /**
  * Update the selected EC image.
  */
-VbError_t VbExEcUpdateImage(int devidx, enum VbSelectFirmware_t select,
-			    const uint8_t *image, int image_size);
+vb2_error_t VbExEcUpdateImage(int devidx, enum VbSelectFirmware_t select,
+			      const uint8_t *image, int image_size);
 
 /**
  * Lock the selected EC code to prevent updates until the EC is rebooted.
  * Subsequent calls to VbExEcUpdateImage() with the same region this boot will
  * fail.
  */
-VbError_t VbExEcProtect(int devidx, enum VbSelectFirmware_t select);
+vb2_error_t VbExEcProtect(int devidx, enum VbSelectFirmware_t select);
 
 /**
  * Info the EC of the boot mode selected by the AP.
  * mode: Normal, Developer, or Recovery
  */
 enum VbEcBootMode_t {VB_EC_NORMAL, VB_EC_DEVELOPER, VB_EC_RECOVERY };
-VbError_t VbExEcEnteringMode(int devidx, enum VbEcBootMode_t mode);
+vb2_error_t VbExEcEnteringMode(int devidx, enum VbEcBootMode_t mode);
 
 /**
  * Perform EC post-verification / updating / jumping actions.
@@ -779,12 +770,12 @@ VbError_t VbExEcEnteringMode(int devidx, enum VbEcBootMode_t mode);
  * @param in_recovery	1 if recovery mode is selected by the AP, 0 otherwise.
  * @return VBERROR_... error, VBERROR_SUCCESS on success.
  */
-VbError_t VbExEcVbootDone(int in_recovery);
+vb2_error_t VbExEcVbootDone(int in_recovery);
 
 /**
  * Request EC to stop discharging and cut-off battery.
  */
-VbError_t VbExEcBatteryCutOff(void);
+vb2_error_t VbExEcBatteryCutOff(void);
 
 /*
  * severity levels for an auxiliary firmware update request
@@ -813,7 +804,7 @@ typedef enum {
  * @return VBERROR_... error, VBERROR_SUCCESS on success.
  */
 
-VbError_t VbExCheckAuxFw(VbAuxFwUpdateSeverity_t *severity);
+vb2_error_t VbExCheckAuxFw(VbAuxFwUpdateSeverity_t *severity);
 
 /**
  * Perform auxiliary firmware update(s).
@@ -824,7 +815,7 @@ VbError_t VbExCheckAuxFw(VbAuxFwUpdateSeverity_t *severity);
  * @return VBERROR_... error, VBERROR_SUCCESS on success.
  */
 
-VbError_t VbExUpdateAuxFw(void);
+vb2_error_t VbExUpdateAuxFw(void);
 
 /*****************************************************************************/
 /* Misc */
@@ -914,7 +905,7 @@ uint8_t VbExOverrideGptEntryPriority(const GptEntry *e);
  * @param count		Pointer to the number of locales.
  * @return VBERROR_... error, VBERROR_SUCCESS on success.
  */
-VbError_t VbExGetLocalizationCount(uint32_t *count);
+vb2_error_t VbExGetLocalizationCount(uint32_t *count);
 
 enum vb_altfw {
 	VB_ALTFW_COUNT	= 9,	/* We allow 9 bootloaders, numbered 1-9 */
diff --git a/firmware/lib/ec_sync.c b/firmware/lib/ec_sync.c
index b6729985..23951aff 100644
--- a/firmware/lib/ec_sync.c
+++ b/firmware/lib/ec_sync.c
@@ -43,8 +43,8 @@ static void request_recovery(struct vb2_context *ctx, uint32_t recovery_request)
 /**
  * Wrapper around VbExEcProtect() which sets recovery reason on error.
  */
-static VbError_t protect_ec(struct vb2_context *ctx, int devidx,
-			   enum VbSelectFirmware_t select)
+static vb2_error_t protect_ec(struct vb2_context *ctx, int devidx,
+			      enum VbSelectFirmware_t select)
 {
 	int rv = VbExEcProtect(devidx, select);
 
@@ -145,8 +145,8 @@ static int check_ec_hash(struct vb2_context *ctx, int devidx,
  * @param select	Which firmware image to check
  * @return VBERROR_SUCCESS, or non-zero error code.
  */
-static VbError_t update_ec(struct vb2_context *ctx, int devidx,
-			   enum VbSelectFirmware_t select)
+static vb2_error_t update_ec(struct vb2_context *ctx, int devidx,
+			     enum VbSelectFirmware_t select)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 
@@ -201,7 +201,7 @@ static VbError_t update_ec(struct vb2_context *ctx, int devidx,
  * @param ctx		Vboot2 context
  * @param devidx	Which device (EC=0, PD=1)
  */
-static VbError_t check_ec_active(struct vb2_context *ctx, int devidx)
+static vb2_error_t check_ec_active(struct vb2_context *ctx, int devidx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	int in_rw = 0;
@@ -235,7 +235,7 @@ static VbError_t check_ec_active(struct vb2_context *ctx, int devidx)
  * @param devidx	Which device (EC=0, PD=1)
  * @return VBERROR_SUCCESS, or non-zero if error.
  */
-static VbError_t sync_one_ec(struct vb2_context *ctx, int devidx)
+static vb2_error_t sync_one_ec(struct vb2_context *ctx, int devidx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	int is_rw_ab = ctx->flags & RW_AB(devidx);
@@ -335,7 +335,7 @@ static VbError_t sync_one_ec(struct vb2_context *ctx, int devidx)
 	return rv;
 }
 
-VbError_t ec_sync_phase1(struct vb2_context *ctx)
+vb2_error_t ec_sync_phase1(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
@@ -422,8 +422,8 @@ static int ec_sync_allowed(struct vb2_context *ctx)
 	return 1;
 }
 
-VbError_t ec_sync_check_aux_fw(struct vb2_context *ctx,
-			       VbAuxFwUpdateSeverity_t *severity)
+vb2_error_t ec_sync_check_aux_fw(struct vb2_context *ctx,
+				 VbAuxFwUpdateSeverity_t *severity)
 {
 	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
 
@@ -436,9 +436,9 @@ VbError_t ec_sync_check_aux_fw(struct vb2_context *ctx,
 	return VbExCheckAuxFw(severity);
 }
 
-VbError_t ec_sync_update_aux_fw(struct vb2_context *ctx)
+vb2_error_t ec_sync_update_aux_fw(struct vb2_context *ctx)
 {
-	VbError_t rv = VbExUpdateAuxFw();
+	vb2_error_t rv = VbExUpdateAuxFw();
 	if (rv) {
 		if (rv == VBERROR_EC_REBOOT_TO_RO_REQUIRED) {
 			VB2_DEBUG("AUX firmware update requires RO reboot.\n");
@@ -450,13 +450,13 @@ VbError_t ec_sync_update_aux_fw(struct vb2_context *ctx)
 	return rv;
 }
 
-VbError_t ec_sync_phase2(struct vb2_context *ctx)
+vb2_error_t ec_sync_phase2(struct vb2_context *ctx)
 {
 	if (!ec_sync_allowed(ctx))
 		return VBERROR_SUCCESS;
 
 	/* Handle updates and jumps for EC */
-	VbError_t retval = sync_one_ec(ctx, 0);
+	vb2_error_t retval = sync_one_ec(ctx, 0);
 	if (retval != VBERROR_SUCCESS)
 		return retval;
 
@@ -473,12 +473,12 @@ VbError_t ec_sync_phase2(struct vb2_context *ctx)
 	return VBERROR_SUCCESS;
 }
 
-VbError_t ec_sync_phase3(struct vb2_context *ctx)
+vb2_error_t ec_sync_phase3(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 
 	/* EC verification (and possibly updating / jumping) is done */
-	VbError_t rv = VbExEcVbootDone(!!sd->recovery_reason);
+	vb2_error_t rv = VbExEcVbootDone(!!sd->recovery_reason);
 	if (rv)
 		return rv;
 
diff --git a/firmware/lib/ec_sync_all.c b/firmware/lib/ec_sync_all.c
index f09b708f..600218d5 100644
--- a/firmware/lib/ec_sync_all.c
+++ b/firmware/lib/ec_sync_all.c
@@ -33,13 +33,13 @@ static void display_wait_screen(struct vb2_context *ctx, const char *fw_name)
 	VbDisplayScreen(ctx, VB_SCREEN_WAIT, 0, NULL);
 }
 
-VbError_t ec_sync_all(struct vb2_context *ctx)
+vb2_error_t ec_sync_all(struct vb2_context *ctx)
 {
 	VbAuxFwUpdateSeverity_t fw_update = VB_AUX_FW_NO_UPDATE;
-	VbError_t rv;
+	vb2_error_t rv;
 
 	/* Phase 1; this determines if we need an update */
-	VbError_t phase1_rv = ec_sync_phase1(ctx);
+	vb2_error_t phase1_rv = ec_sync_phase1(ctx);
 	int need_wait_screen = ec_will_update_slowly(ctx);
 
 	/* Check if EC SW Sync Phase1 needs reboot */
diff --git a/firmware/lib/include/ec_sync.h b/firmware/lib/include/ec_sync.h
index 303ea2a4..e71d68b0 100644
--- a/firmware/lib/include/ec_sync.h
+++ b/firmware/lib/include/ec_sync.h
@@ -23,7 +23,7 @@ struct vb2_context;
  * reboot back to its RO code to continue EC sync, or other non-zero error
  * code.
  */
-VbError_t ec_sync_phase1(struct vb2_context *ctx);
+vb2_error_t ec_sync_phase1(struct vb2_context *ctx);
 
 /**
  * Returns non-zero if the EC will perform a slow update during phase 2.
@@ -44,7 +44,7 @@ int ec_will_update_slowly(struct vb2_context *ctx);
  * @param severity	VB_AUX_FW_{NO,FAST,SLOW}_UPDATE
  * @return VBERROR_SUCCESS or non-zero error code.
  */
-VbError_t ec_sync_check_aux_fw(struct vb2_context *ctx,
+vb2_error_t ec_sync_check_aux_fw(struct vb2_context *ctx,
 			       VbAuxFwUpdateSeverity_t *severity);
 
 /**
@@ -53,7 +53,7 @@ VbError_t ec_sync_check_aux_fw(struct vb2_context *ctx,
  * @param ctx          Vboot2 context
  * @return VBERROR_SUCCESS or non-zero error code.
  */
-VbError_t ec_sync_update_aux_fw(struct vb2_context *ctx);
+vb2_error_t ec_sync_update_aux_fw(struct vb2_context *ctx);
 
 /**
  * EC sync, phase 2
@@ -69,7 +69,7 @@ VbError_t ec_sync_update_aux_fw(struct vb2_context *ctx);
  * reboot back to its RO code to continue EC sync, or other non-zero error
  * code.
  */
-VbError_t ec_sync_phase2(struct vb2_context *ctx);
+vb2_error_t ec_sync_phase2(struct vb2_context *ctx);
 
 /**
  * EC sync, phase 3
@@ -79,7 +79,7 @@ VbError_t ec_sync_phase2(struct vb2_context *ctx);
  * @param ctx		Vboot2 context
  * @return VBERROR_SUCCESS or non-zero error code.
  */
-VbError_t ec_sync_phase3(struct vb2_context *ctx);
+vb2_error_t ec_sync_phase3(struct vb2_context *ctx);
 
 /**
  * Sync all EC devices to expected versions.
@@ -89,6 +89,6 @@ VbError_t ec_sync_phase3(struct vb2_context *ctx);
  * @param ctx		Vboot context
  * @return VBERROR_SUCCESS, or non-zero if error.
  */
-VbError_t ec_sync_all(struct vb2_context *ctx);
+vb2_error_t ec_sync_all(struct vb2_context *ctx);
 
 #endif  /* VBOOT_REFERENCE_EC_SYNC_H_ */
diff --git a/firmware/lib/include/load_kernel_fw.h b/firmware/lib/include/load_kernel_fw.h
index 87e0e2ab..4b7fb639 100644
--- a/firmware/lib/include/load_kernel_fw.h
+++ b/firmware/lib/include/load_kernel_fw.h
@@ -65,6 +65,6 @@ typedef struct LoadKernelParams {
  * Returns VBERROR_SUCCESS if successful.  If unsuccessful, sets a recovery
  * reason via VbNvStorage and returns an error code.
  */
-VbError_t LoadKernel(struct vb2_context *ctx, LoadKernelParams *params);
+vb2_error_t LoadKernel(struct vb2_context *ctx, LoadKernelParams *params);
 
 #endif  /* VBOOT_REFERENCE_LOAD_KERNEL_FW_H_ */
diff --git a/firmware/lib/include/vboot_display.h b/firmware/lib/include/vboot_display.h
index ed259a0c..6dfaeaa9 100644
--- a/firmware/lib/include/vboot_display.h
+++ b/firmware/lib/include/vboot_display.h
@@ -8,13 +8,13 @@
 #ifndef VBOOT_REFERENCE_VBOOT_DISPLAY_H_
 #define VBOOT_REFERENCE_VBOOT_DISPLAY_H_
 
-VbError_t VbDisplayScreen(struct vb2_context *ctx, uint32_t screen, int force,
+vb2_error_t VbDisplayScreen(struct vb2_context *ctx, uint32_t screen, int force,
 			  const VbScreenData *data);
-VbError_t VbDisplayMenu(struct vb2_context *ctx,
+vb2_error_t VbDisplayMenu(struct vb2_context *ctx,
 			uint32_t screen, int force, uint32_t selected_index,
 			uint32_t disabled_idx_mask);
-VbError_t VbDisplayDebugInfo(struct vb2_context *ctx);
-VbError_t VbCheckDisplayKey(struct vb2_context *ctx, uint32_t key,
+vb2_error_t VbDisplayDebugInfo(struct vb2_context *ctx);
+vb2_error_t VbCheckDisplayKey(struct vb2_context *ctx, uint32_t key,
 			    const VbScreenData *data);
 
 /**
diff --git a/firmware/lib/include/vboot_kernel.h b/firmware/lib/include/vboot_kernel.h
index fe8d7023..61ce2c93 100644
--- a/firmware/lib/include/vboot_kernel.h
+++ b/firmware/lib/include/vboot_kernel.h
@@ -52,32 +52,32 @@ int VbUserConfirms(struct vb2_context *ctx, uint32_t confirm_flags);
 /**
  * Handle a normal boot.
  */
-VbError_t VbBootNormal(struct vb2_context *ctx);
+vb2_error_t VbBootNormal(struct vb2_context *ctx);
 
 /**
  * Handle a developer-mode boot.
  */
-VbError_t VbBootDeveloper(struct vb2_context *ctx);
+vb2_error_t VbBootDeveloper(struct vb2_context *ctx);
 
 /**
  * Handle a diagnostic-mode boot.
  */
-VbError_t VbBootDiagnostic(struct vb2_context *ctx);
+vb2_error_t VbBootDiagnostic(struct vb2_context *ctx);
 
 /**
  * Handle a recovery-mode boot.
  */
-VbError_t VbBootRecovery(struct vb2_context *ctx);
+vb2_error_t VbBootRecovery(struct vb2_context *ctx);
 
 /**
  * Handle a developer-mode boot using detachable menu ui
  */
-VbError_t VbBootDeveloperMenu(struct vb2_context *ctx);
+vb2_error_t VbBootDeveloperMenu(struct vb2_context *ctx);
 
 /**
  * Handle a recovery-mode boot using detachable menu ui
  */
-VbError_t VbBootRecoveryMenu(struct vb2_context *ctx);
+vb2_error_t VbBootRecoveryMenu(struct vb2_context *ctx);
 
 /**
  * Return the current FWMP flags.  Valid only inside VbSelectAndLoadKernel().
diff --git a/firmware/lib/include/vboot_ui_menu_private.h b/firmware/lib/include/vboot_ui_menu_private.h
index aef2dff6..b92fb5da 100644
--- a/firmware/lib/include/vboot_ui_menu_private.h
+++ b/firmware/lib/include/vboot_ui_menu_private.h
@@ -13,7 +13,7 @@
 
 struct vb2_menu_item {
 	const char *text;
-	VbError_t (*action)(struct vb2_context *ctx);
+	vb2_error_t (*action)(struct vb2_context *ctx);
 };
 
 struct vb2_menu {
diff --git a/firmware/lib/vboot_api_kernel.c b/firmware/lib/vboot_api_kernel.c
index 9135085e..9202c6b8 100644
--- a/firmware/lib/vboot_api_kernel.c
+++ b/firmware/lib/vboot_api_kernel.c
@@ -68,7 +68,7 @@ uint32_t vb2_get_fwmp_flags(void)
 
 uint32_t VbTryLoadKernel(struct vb2_context *ctx, uint32_t get_info_flags)
 {
-	VbError_t retval = VBERROR_UNKNOWN;
+	vb2_error_t retval = VBERROR_UNKNOWN;
 	VbDiskInfo* disk_info = NULL;
 	uint32_t disk_count = 0;
 	uint32_t i;
@@ -175,7 +175,7 @@ static int vb2_reset_nv_requests(struct vb2_context *ctx)
 	return need_reboot;
 }
 
-VbError_t VbBootNormal(struct vb2_context *ctx)
+vb2_error_t VbBootNormal(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	VbSharedDataHeader *shared = sd->vbsd;
@@ -190,7 +190,7 @@ VbError_t VbBootNormal(struct vb2_context *ctx)
 		return VBERROR_REBOOT_REQUIRED;
 	}
 
-	VbError_t rv = VbTryLoadKernel(ctx, VB_DISK_FLAG_FIXED);
+	vb2_error_t rv = VbTryLoadKernel(ctx, VB_DISK_FLAG_FIXED);
 
 	VB2_DEBUG("Checking if TPM kernel version needs advancing\n");
 
@@ -248,9 +248,9 @@ VbError_t VbBootNormal(struct vb2_context *ctx)
 	return rv;
 }
 
-static VbError_t vb2_kernel_setup(struct vb2_context *ctx,
-				  VbSharedDataHeader *shared,
-				  VbSelectAndLoadKernelParams *kparams)
+static vb2_error_t vb2_kernel_setup(struct vb2_context *ctx,
+				    VbSharedDataHeader *shared,
+				    VbSelectAndLoadKernelParams *kparams)
 {
 	if (VB2_SUCCESS != vb2_init_context(ctx)) {
 		VB2_DEBUG("Can't init vb2_context\n");
@@ -346,8 +346,8 @@ static VbError_t vb2_kernel_setup(struct vb2_context *ctx,
 	return VBERROR_SUCCESS;
 }
 
-static VbError_t vb2_kernel_phase4(struct vb2_context *ctx,
-				   VbSelectAndLoadKernelParams *kparams)
+static vb2_error_t vb2_kernel_phase4(struct vb2_context *ctx,
+				     VbSelectAndLoadKernelParams *kparams)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 
@@ -385,12 +385,11 @@ static void vb2_kernel_cleanup(struct vb2_context *ctx)
 		sd->vbsd->timer_vb_select_and_load_kernel_exit = VbExGetTimer();
 }
 
-VbError_t VbSelectAndLoadKernel(
-	struct vb2_context *ctx,
-	VbSharedDataHeader *shared,
-	VbSelectAndLoadKernelParams *kparams)
+vb2_error_t VbSelectAndLoadKernel(struct vb2_context *ctx,
+				  VbSharedDataHeader *shared,
+				  VbSelectAndLoadKernelParams *kparams)
 {
-	VbError_t retval = vb2_kernel_setup(ctx, shared, kparams);
+	vb2_error_t retval = vb2_kernel_setup(ctx, shared, kparams);
 	if (retval)
 		goto VbSelectAndLoadKernel_exit;
 
@@ -459,10 +458,10 @@ VbError_t VbSelectAndLoadKernel(
 	return retval;
 }
 
-VbError_t VbVerifyMemoryBootImage(
-	struct vb2_context *ctx, VbSharedDataHeader *shared,
-	VbSelectAndLoadKernelParams *kparams, void *boot_image,
-	size_t image_size)
+vb2_error_t VbVerifyMemoryBootImage(struct vb2_context *ctx,
+				    VbSharedDataHeader *shared,
+				    VbSelectAndLoadKernelParams *kparams,
+				    void *boot_image, size_t image_size)
 {
 	struct vb2_packed_key *kernel_subkey = NULL;
 	uint8_t *kbuf;
@@ -473,7 +472,7 @@ VbError_t VbVerifyMemoryBootImage(
 	int dev_switch;
 	uint32_t allow_fastboot_full_cap = 0;
 	struct vb2_workbuf wb;
-	VbError_t retval;
+	vb2_error_t retval;
 	int rv;
 
 	/* Allocate work buffer */
@@ -615,7 +614,7 @@ VbError_t VbVerifyMemoryBootImage(
 	return retval;
 }
 
-VbError_t VbUnlockDevice(void)
+vb2_error_t VbUnlockDevice(void)
 {
 	VB2_DEBUG("Enabling dev-mode...\n");
 	if (TPM_SUCCESS != SetVirtualDevMode(1))
diff --git a/firmware/lib/vboot_display.c b/firmware/lib/vboot_display.c
index 8b97f406..a2b57ef4 100644
--- a/firmware/lib/vboot_display.c
+++ b/firmware/lib/vboot_display.c
@@ -22,18 +22,18 @@ static uint32_t disp_current_index = 0;
 static uint32_t disp_disabled_idx_mask = 0;
 
 __attribute__((weak))
-VbError_t VbExGetLocalizationCount(uint32_t *count) {
+vb2_error_t VbExGetLocalizationCount(uint32_t *count) {
 	*count = 0;
 	return VBERROR_UNKNOWN;
 }
 
 __attribute__((weak))
-VbError_t VbExGetAltFwIdxMask(void) {
+vb2_error_t VbExGetAltFwIdxMask(void) {
 	return 0;
 }
 
-VbError_t VbDisplayScreen(struct vb2_context *ctx, uint32_t screen, int force,
-			  const VbScreenData *data)
+vb2_error_t VbDisplayScreen(struct vb2_context *ctx, uint32_t screen, int force,
+			    const VbScreenData *data)
 {
 	uint32_t locale;
 
@@ -50,8 +50,8 @@ VbError_t VbDisplayScreen(struct vb2_context *ctx, uint32_t screen, int force,
 	return VbExDisplayScreen(screen, locale, data);
 }
 
-VbError_t VbDisplayMenu(struct vb2_context *ctx, uint32_t screen, int force,
-			uint32_t selected_index, uint32_t disabled_idx_mask)
+vb2_error_t VbDisplayMenu(struct vb2_context *ctx, uint32_t screen, int force,
+			  uint32_t selected_index, uint32_t disabled_idx_mask)
 {
 	uint32_t locale;
 	uint32_t redraw_base_screen = 0;
@@ -269,7 +269,7 @@ const char *RecoveryReasonString(uint8_t code)
 
 #define DEBUG_INFO_SIZE 512
 
-VbError_t VbDisplayDebugInfo(struct vb2_context *ctx)
+vb2_error_t VbDisplayDebugInfo(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
@@ -411,7 +411,7 @@ VbError_t VbDisplayDebugInfo(struct vb2_context *ctx)
 	return VbExDisplayDebugInfo(buf, 1);
 }
 
-VbError_t VbCheckDisplayKey(struct vb2_context *ctx, uint32_t key,
+vb2_error_t VbCheckDisplayKey(struct vb2_context *ctx, uint32_t key,
 			    const VbScreenData *data)
 {
 	uint32_t loc = 0;
diff --git a/firmware/lib/vboot_kernel.c b/firmware/lib/vboot_kernel.c
index 5fdc6a4e..96461d9f 100644
--- a/firmware/lib/vboot_kernel.c
+++ b/firmware/lib/vboot_kernel.c
@@ -434,7 +434,7 @@ static int vb2_load_partition(struct vb2_context *ctx,
 	return VB2_SUCCESS;
 }
 
-VbError_t LoadKernel(struct vb2_context *ctx, LoadKernelParams *params)
+vb2_error_t LoadKernel(struct vb2_context *ctx, LoadKernelParams *params)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	struct vb2_workbuf wb;
@@ -442,7 +442,7 @@ VbError_t LoadKernel(struct vb2_context *ctx, LoadKernelParams *params)
 	VbSharedDataKernelCall *shcall = NULL;
 	int found_partitions = 0;
 	uint32_t lowest_version = LOWEST_TPM_VERSION;
-	VbError_t retval = VBERROR_UNKNOWN;
+	vb2_error_t retval = VBERROR_UNKNOWN;
 	int recovery = VB2_RECOVERY_LK_UNSPECIFIED;
 	int rv;
 
diff --git a/firmware/lib/vboot_ui.c b/firmware/lib/vboot_ui.c
index 8a990047..51167801 100644
--- a/firmware/lib/vboot_ui.c
+++ b/firmware/lib/vboot_ui.c
@@ -185,7 +185,7 @@ int VbUserConfirms(struct vb2_context *ctx, uint32_t confirm_flags)
  * This shows the user a list of bootloaders and allows selection of one of
  * them. We loop forever until something is chosen or Escape is pressed.
  */
-static VbError_t vb2_altfw_ui(struct vb2_context *ctx)
+static vb2_error_t vb2_altfw_ui(struct vb2_context *ctx)
 {
 	int active = 1;
 
@@ -243,8 +243,8 @@ static inline int is_vowel(uint32_t key) {
 /*
  * Prompt the user to enter the vendor data
  */
-static VbError_t vb2_enter_vendor_data_ui(struct vb2_context *ctx,
-					  char *data_value)
+static vb2_error_t vb2_enter_vendor_data_ui(struct vb2_context *ctx,
+					    char *data_value)
 {
 	int len = 0;
 	VbScreenData data = {
@@ -323,14 +323,14 @@ static VbError_t vb2_enter_vendor_data_ui(struct vb2_context *ctx,
 /*
  * User interface for setting the vendor data in VPD
  */
-static VbError_t vb2_vendor_data_ui(struct vb2_context *ctx)
+static vb2_error_t vb2_vendor_data_ui(struct vb2_context *ctx)
 {
 	char data_value[VENDOR_DATA_LENGTH + 1];
 	VbScreenData data = {
 		.vendor_data = { data_value }
 	};
 
-	VbError_t ret = vb2_enter_vendor_data_ui(ctx, data_value);
+	vb2_error_t ret = vb2_enter_vendor_data_ui(ctx, data_value);
 
 	if (ret)
 		return ret;
@@ -387,8 +387,8 @@ static VbError_t vb2_vendor_data_ui(struct vb2_context *ctx)
 	return VBERROR_SUCCESS;
 }
 
-static VbError_t vb2_check_diagnostic_key(struct vb2_context *ctx,
-					  uint32_t key) {
+static vb2_error_t vb2_check_diagnostic_key(struct vb2_context *ctx,
+					    uint32_t key) {
 	if (DIAGNOSTIC_UI && (key == VB_KEY_CTRL('C') || key == VB_KEY_F(12))) {
 		VB2_DEBUG("Diagnostic mode requested, rebooting\n");
 		vb2_nv_set(ctx, VB2_NV_DIAG_REQUEST, 1);
@@ -406,12 +406,12 @@ static VbError_t vb2_check_diagnostic_key(struct vb2_context *ctx,
  * can press the power button to confirm or press escape. There is a 30-second
  * timeout which acts the same as escape.
  */
-static VbError_t vb2_diagnostics_ui(struct vb2_context *ctx)
+static vb2_error_t vb2_diagnostics_ui(struct vb2_context *ctx)
 {
 	int active = 1;
 	int power_button_was_released = 0;
 	int power_button_was_pressed = 0;
-	VbError_t result = VBERROR_REBOOT_REQUIRED;
+	vb2_error_t result = VBERROR_REBOOT_REQUIRED;
 	int action_confirmed = 0;
 	uint64_t start_time_us;
 
@@ -512,7 +512,7 @@ static const char dev_disable_msg[] =
 	"For more information, see http://dev.chromium.org/chromium-os/fwmp\n"
 	"\n";
 
-static VbError_t vb2_developer_ui(struct vb2_context *ctx)
+static vb2_error_t vb2_developer_ui(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
@@ -782,18 +782,18 @@ static VbError_t vb2_developer_ui(struct vb2_context *ctx)
 	return VbTryLoadKernel(ctx, VB_DISK_FLAG_FIXED);
 }
 
-VbError_t VbBootDeveloper(struct vb2_context *ctx)
+vb2_error_t VbBootDeveloper(struct vb2_context *ctx)
 {
 	vb2_init_ui();
-	VbError_t retval = vb2_developer_ui(ctx);
+	vb2_error_t retval = vb2_developer_ui(ctx);
 	VbDisplayScreen(ctx, VB_SCREEN_BLANK, 0, NULL);
 	return retval;
 }
 
-VbError_t VbBootDiagnostic(struct vb2_context *ctx)
+vb2_error_t VbBootDiagnostic(struct vb2_context *ctx)
 {
 	vb2_init_ui();
-	VbError_t retval = vb2_diagnostics_ui(ctx);
+	vb2_error_t retval = vb2_diagnostics_ui(ctx);
 	VbDisplayScreen(ctx, VB_SCREEN_BLANK, 0, NULL);
 	return retval;
 }
@@ -803,7 +803,7 @@ VbError_t VbBootDiagnostic(struct vb2_context *ctx)
 #define REC_KEY_DELAY        20       /* Check keys every 20ms */
 #define REC_MEDIA_INIT_DELAY 500      /* Check removable media every 500ms */
 
-static VbError_t recovery_ui(struct vb2_context *ctx)
+static vb2_error_t recovery_ui(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	VbSharedDataHeader *shared = sd->vbsd;
@@ -953,9 +953,9 @@ static VbError_t recovery_ui(struct vb2_context *ctx)
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbBootRecovery(struct vb2_context *ctx)
+vb2_error_t VbBootRecovery(struct vb2_context *ctx)
 {
-	VbError_t retval = recovery_ui(ctx);
+	vb2_error_t retval = recovery_ui(ctx);
 	VbDisplayScreen(ctx, VB_SCREEN_BLANK, 0, NULL);
 	return retval;
 }
diff --git a/firmware/lib/vboot_ui_menu.c b/firmware/lib/vboot_ui_menu.c
index c3268d1e..5a0f117a 100644
--- a/firmware/lib/vboot_ui_menu.c
+++ b/firmware/lib/vboot_ui_menu.c
@@ -61,8 +61,8 @@ static int VbWantShutdownMenu(struct vb2_context *ctx)
 }
 
 /* (Re-)Draw the menu identified by current_menu[_idx] to the screen. */
-static VbError_t vb2_draw_current_screen(struct vb2_context *ctx) {
-	VbError_t ret = VbDisplayMenu(ctx, menus[current_menu].screen,
+static vb2_error_t vb2_draw_current_screen(struct vb2_context *ctx) {
+	vb2_error_t ret = VbDisplayMenu(ctx, menus[current_menu].screen,
 			force_redraw, current_menu_idx, disabled_idx_mask);
 	force_redraw = 0;
 	return ret;
@@ -130,7 +130,7 @@ static void vb2_change_menu(VB_MENU new_current_menu,
  ************************/
 
 /* Boot from internal disk if allowed. */
-static VbError_t boot_disk_action(struct vb2_context *ctx)
+static vb2_error_t boot_disk_action(struct vb2_context *ctx)
 {
 	if (disable_dev_boot) {
 		vb2_flash_screen(ctx);
@@ -143,7 +143,7 @@ static VbError_t boot_disk_action(struct vb2_context *ctx)
 }
 
 /* Boot legacy BIOS if allowed and available. */
-static VbError_t boot_legacy_action(struct vb2_context *ctx)
+static vb2_error_t boot_legacy_action(struct vb2_context *ctx)
 {
 	if (disable_dev_boot) {
 		vb2_flash_screen(ctx);
@@ -168,7 +168,7 @@ static VbError_t boot_legacy_action(struct vb2_context *ctx)
 }
 
 /* Boot from USB or SD card if allowed and available. */
-static VbError_t boot_usb_action(struct vb2_context *ctx)
+static vb2_error_t boot_usb_action(struct vb2_context *ctx)
 {
 	const char no_kernel[] = "No bootable kernel found on USB/SD.\n";
 
@@ -204,7 +204,7 @@ static VbError_t boot_usb_action(struct vb2_context *ctx)
 	return VBERROR_KEEP_LOOPING;
 }
 
-static VbError_t enter_developer_menu(struct vb2_context *ctx)
+static vb2_error_t enter_developer_menu(struct vb2_context *ctx)
 {
 	int menu_idx;
 	switch(default_boot) {
@@ -224,14 +224,14 @@ static VbError_t enter_developer_menu(struct vb2_context *ctx)
 	return VBERROR_KEEP_LOOPING;
 }
 
-static VbError_t enter_dev_warning_menu(struct vb2_context *ctx)
+static vb2_error_t enter_dev_warning_menu(struct vb2_context *ctx)
 {
 	vb2_change_menu(VB_MENU_DEV_WARNING, VB_WARN_POWER_OFF);
 	vb2_draw_current_screen(ctx);
 	return VBERROR_KEEP_LOOPING;
 }
 
-static VbError_t enter_language_menu(struct vb2_context *ctx)
+static vb2_error_t enter_language_menu(struct vb2_context *ctx)
 {
 	vb2_change_menu(VB_MENU_LANGUAGES,
 			vb2_nv_get(ctx, VB2_NV_LOCALIZATION_INDEX));
@@ -239,7 +239,7 @@ static VbError_t enter_language_menu(struct vb2_context *ctx)
 	return VBERROR_KEEP_LOOPING;
 }
 
-static VbError_t enter_recovery_base_screen(struct vb2_context *ctx)
+static vb2_error_t enter_recovery_base_screen(struct vb2_context *ctx)
 {
 	if (!vb2_allow_recovery(ctx))
 		vb2_change_menu(VB_MENU_RECOVERY_BROKEN, 0);
@@ -251,14 +251,14 @@ static VbError_t enter_recovery_base_screen(struct vb2_context *ctx)
 	return VBERROR_KEEP_LOOPING;
 }
 
-static VbError_t enter_options_menu(struct vb2_context *ctx)
+static vb2_error_t enter_options_menu(struct vb2_context *ctx)
 {
 	vb2_change_menu(VB_MENU_OPTIONS, VB_OPTIONS_CANCEL);
 	vb2_draw_current_screen(ctx);
 	return VBERROR_KEEP_LOOPING;
 }
 
-static VbError_t enter_to_dev_menu(struct vb2_context *ctx)
+static vb2_error_t enter_to_dev_menu(struct vb2_context *ctx)
 {
 	const char dev_already_on[] =
 		"WARNING: TODEV rejected, developer mode is already on.\n";
@@ -272,7 +272,7 @@ static VbError_t enter_to_dev_menu(struct vb2_context *ctx)
 	return VBERROR_KEEP_LOOPING;
 }
 
-static VbError_t enter_to_norm_menu(struct vb2_context *ctx)
+static vb2_error_t enter_to_norm_menu(struct vb2_context *ctx)
 {
 	vb2_change_menu(VB_MENU_TO_NORM, VB_TO_NORM_CONFIRM);
 	vb2_draw_current_screen(ctx);
@@ -280,7 +280,7 @@ static VbError_t enter_to_norm_menu(struct vb2_context *ctx)
 }
 
 /* Boot alternative bootloader if allowed and available. */
-static VbError_t enter_altfw_menu(struct vb2_context *ctx)
+static vb2_error_t enter_altfw_menu(struct vb2_context *ctx)
 {
 	VB2_DEBUG("enter_altfw_menu()\n");
 	if (disable_dev_boot) {
@@ -299,7 +299,7 @@ static VbError_t enter_altfw_menu(struct vb2_context *ctx)
 	return VBERROR_KEEP_LOOPING;
 }
 
-static VbError_t debug_info_action(struct vb2_context *ctx)
+static vb2_error_t debug_info_action(struct vb2_context *ctx)
 {
 	force_redraw = 1;
 	VbDisplayDebugInfo(ctx);
@@ -307,7 +307,7 @@ static VbError_t debug_info_action(struct vb2_context *ctx)
 }
 
 /* Action when selecting a language entry in the language menu. */
-static VbError_t language_action(struct vb2_context *ctx)
+static vb2_error_t language_action(struct vb2_context *ctx)
 {
 	VbSharedDataHeader *vbsd = vb2_get_sd(ctx)->vbsd;
 
@@ -341,7 +341,7 @@ static VbError_t language_action(struct vb2_context *ctx)
 }
 
 /* Action when selecting a bootloader in the alternative firmware menu. */
-static VbError_t altfw_action(struct vb2_context *ctx)
+static vb2_error_t altfw_action(struct vb2_context *ctx)
 {
 	vb2_run_altfw(ctx, current_menu_idx + 1);
 	vb2_flash_screen(ctx);
@@ -352,7 +352,7 @@ static VbError_t altfw_action(struct vb2_context *ctx)
 }
 
 /* Action that enables developer mode and reboots. */
-static VbError_t to_dev_action(struct vb2_context *ctx)
+static vb2_error_t to_dev_action(struct vb2_context *ctx)
 {
 	uint32_t vbsd_flags = vb2_get_sd(ctx)->vbsd->flags;
 
@@ -374,7 +374,7 @@ static VbError_t to_dev_action(struct vb2_context *ctx)
 }
 
 /* Action that disables developer mode, shows TO_NORM_CONFIRMED and reboots. */
-static VbError_t to_norm_action(struct vb2_context *ctx)
+static vb2_error_t to_norm_action(struct vb2_context *ctx)
 {
 	if (vb2_get_gbb(ctx)->flags & VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON) {
 		vb2_flash_screen(ctx);
@@ -393,7 +393,7 @@ static VbError_t to_norm_action(struct vb2_context *ctx)
 }
 
 /* Action that will power off the system. */
-static VbError_t power_off_action(struct vb2_context *ctx)
+static vb2_error_t power_off_action(struct vb2_context *ctx)
 {
 	VB2_DEBUG("Power off requested from screen 0x%x\n",
 		  menus[current_menu].screen);
@@ -442,8 +442,8 @@ static void vb2_update_selection(uint32_t key) {
 	vb2_log_menu_change();
 }
 
-static VbError_t vb2_handle_menu_input(struct vb2_context *ctx,
-				       uint32_t key, uint32_t key_flags)
+static vb2_error_t vb2_handle_menu_input(struct vb2_context *ctx,
+					 uint32_t key, uint32_t key_flags)
 {
 	switch (key) {
 	case 0:
@@ -706,7 +706,7 @@ static struct vb2_menu menus[VB_MENU_COUNT] = {
 };
 
 /* Initialize menu state. Must be called once before displaying any menus. */
-static VbError_t vb2_init_menus(struct vb2_context *ctx)
+static vb2_error_t vb2_init_menus(struct vb2_context *ctx)
 {
 	struct vb2_menu_item *items;
 	uint32_t count;
@@ -738,10 +738,10 @@ static VbError_t vb2_init_menus(struct vb2_context *ctx)
  * @param ctx		Vboot2 context
  * @return VBERROR_SUCCESS, or non-zero error code if error.
  */
-static VbError_t vb2_developer_menu(struct vb2_context *ctx)
+static vb2_error_t vb2_developer_menu(struct vb2_context *ctx)
 {
 	struct vb2_gbb_header *gbb = vb2_get_gbb(ctx);
-	VbError_t ret;
+	vb2_error_t ret;
 
 	/* Check if the default is to boot using disk, usb, or legacy */
 	default_boot = vb2_nv_get(ctx, VB2_NV_DEV_DEFAULT_BOOT);
@@ -833,9 +833,9 @@ static VbError_t vb2_developer_menu(struct vb2_context *ctx)
 }
 
 /* Developer mode entry point. */
-VbError_t VbBootDeveloperMenu(struct vb2_context *ctx)
+vb2_error_t VbBootDeveloperMenu(struct vb2_context *ctx)
 {
-	VbError_t retval = vb2_init_menus(ctx);
+	vb2_error_t retval = vb2_init_menus(ctx);
 	if (VBERROR_SUCCESS != retval)
 		return retval;
 	retval = vb2_developer_menu(ctx);
@@ -844,7 +844,7 @@ VbError_t VbBootDeveloperMenu(struct vb2_context *ctx)
 }
 
 /* Main function that handles non-manual recovery (BROKEN) menu functionality */
-static VbError_t broken_ui(struct vb2_context *ctx)
+static vb2_error_t broken_ui(struct vb2_context *ctx)
 {
 	VbSharedDataHeader *vbsd = vb2_get_sd(ctx)->vbsd;
 
@@ -863,7 +863,7 @@ static VbError_t broken_ui(struct vb2_context *ctx)
 	VB2_DEBUG("waiting for manual recovery\n");
 	while (1) {
 		uint32_t key = VbExKeyboardRead();
-		VbError_t ret = vb2_handle_menu_input(ctx, key, 0);
+		vb2_error_t ret = vb2_handle_menu_input(ctx, key, 0);
 		if (ret != VBERROR_KEEP_LOOPING)
 			return ret;
 	}
@@ -880,11 +880,11 @@ static VbError_t broken_ui(struct vb2_context *ctx)
  * @param ctx		Vboot2 context
  * @return VBERROR_SUCCESS, or non-zero error code if error.
  */
-static VbError_t recovery_ui(struct vb2_context *ctx)
+static vb2_error_t recovery_ui(struct vb2_context *ctx)
 {
 	uint32_t key;
 	uint32_t key_flags;
-	VbError_t ret;
+	vb2_error_t ret;
 	int i;
 
 	/* Loop and wait for a recovery image */
@@ -935,9 +935,9 @@ static VbError_t recovery_ui(struct vb2_context *ctx)
 }
 
 /* Recovery mode entry point. */
-VbError_t VbBootRecoveryMenu(struct vb2_context *ctx)
+vb2_error_t VbBootRecoveryMenu(struct vb2_context *ctx)
 {
-	VbError_t retval = vb2_init_menus(ctx);
+	vb2_error_t retval = vb2_init_menus(ctx);
 	if (VBERROR_SUCCESS != retval)
 		return retval;
 	if (vb2_allow_recovery(ctx))
diff --git a/firmware/stub/tpm_lite_stub.c b/firmware/stub/tpm_lite_stub.c
index 673a3574..53fac7b4 100644
--- a/firmware/stub/tpm_lite_stub.c
+++ b/firmware/stub/tpm_lite_stub.c
@@ -176,7 +176,7 @@ static inline int TpmResponseSize(const uint8_t* buffer)
 	return (int) size;
 }
 
-VbError_t VbExTpmInit(void)
+vb2_error_t VbExTpmInit(void)
 {
 	char *no_exit = getenv("TPM_NO_EXIT");
 	if (no_exit)
@@ -184,7 +184,7 @@ VbError_t VbExTpmInit(void)
 	return VbExTpmOpen();
 }
 
-VbError_t VbExTpmClose(void)
+vb2_error_t VbExTpmClose(void)
 {
 	if (tpm_fd != -1) {
 		close(tpm_fd);
@@ -193,7 +193,7 @@ VbError_t VbExTpmClose(void)
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExTpmOpen(void)
+vb2_error_t VbExTpmOpen(void)
 {
 	const char *device_path;
 	struct timespec delay;
@@ -292,7 +292,7 @@ uint32_t VbExTpmSendReceive(const uint8_t* request, uint32_t request_length,
 	return TPM_SUCCESS;
 }
 
-VbError_t VbExTpmGetRandom(uint8_t *buf, uint32_t length)
+vb2_error_t VbExTpmGetRandom(uint8_t *buf, uint32_t length)
 {
 	static int urandom_fd = -1;
 	if (urandom_fd < 0) {
diff --git a/firmware/stub/vboot_api_stub.c b/firmware/stub/vboot_api_stub.c
index 23eb4d5b..8d4719e9 100644
--- a/firmware/stub/vboot_api_stub.c
+++ b/firmware/stub/vboot_api_stub.c
@@ -23,25 +23,25 @@ void VbExSleepMs(uint32_t msec)
 {
 }
 
-VbError_t VbExBeep(uint32_t msec, uint32_t frequency)
+vb2_error_t VbExBeep(uint32_t msec, uint32_t frequency)
 {
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExDisplayScreen(uint32_t screen_type, uint32_t locale,
-			    const VbScreenData *data)
+vb2_error_t VbExDisplayScreen(uint32_t screen_type, uint32_t locale,
+			      const VbScreenData *data)
 {
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExDisplayMenu(uint32_t screen_type, uint32_t locale,
-			  uint32_t selected_index, uint32_t disabled_idx_mask,
-			  uint32_t redraw_base)
+vb2_error_t VbExDisplayMenu(uint32_t screen_type, uint32_t locale,
+			    uint32_t selected_index, uint32_t disabled_idx_mask,
+			    uint32_t redraw_base)
 {
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExDisplayDebugInfo(const char *info_str, int full_info)
+vb2_error_t VbExDisplayDebugInfo(const char *info_str, int full_info)
 {
 	return VBERROR_SUCCESS;
 }
@@ -71,26 +71,26 @@ int VbExTrustEC(int devidx)
 	return 1;
 }
 
-VbError_t VbExEcRunningRW(int devidx, int *in_rw)
+vb2_error_t VbExEcRunningRW(int devidx, int *in_rw)
 {
 	*in_rw = 0;
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExEcJumpToRW(int devidx)
+vb2_error_t VbExEcJumpToRW(int devidx)
 {
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExEcDisableJump(int devidx)
+vb2_error_t VbExEcDisableJump(int devidx)
 {
 	return VBERROR_SUCCESS;
 }
 
 #define SHA256_HASH_SIZE 32
 
-VbError_t VbExEcHashImage(int devidx, enum VbSelectFirmware_t select,
-			  const uint8_t **hash, int *hash_size)
+vb2_error_t VbExEcHashImage(int devidx, enum VbSelectFirmware_t select,
+			    const uint8_t **hash, int *hash_size)
 {
 	static const uint8_t fake_hash[32] = {1, 2, 3, 4};
 
@@ -99,8 +99,8 @@ VbError_t VbExEcHashImage(int devidx, enum VbSelectFirmware_t select,
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExEcGetExpectedImage(int devidx, enum VbSelectFirmware_t select,
-				 const uint8_t **image, int *image_size)
+vb2_error_t VbExEcGetExpectedImage(int devidx, enum VbSelectFirmware_t select,
+				   const uint8_t **image, int *image_size)
 {
 	static uint8_t fake_image[64] = {5, 6, 7, 8};
 	*image = fake_image;
@@ -108,8 +108,9 @@ VbError_t VbExEcGetExpectedImage(int devidx, enum VbSelectFirmware_t select,
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExEcGetExpectedImageHash(int devidx, enum VbSelectFirmware_t select,
-				     const uint8_t **hash, int *hash_size)
+vb2_error_t VbExEcGetExpectedImageHash(int devidx,
+				       enum VbSelectFirmware_t select,
+				       const uint8_t **hash, int *hash_size)
 {
 	static const uint8_t fake_hash[32] = {1, 2, 3, 4};
 
@@ -118,40 +119,40 @@ VbError_t VbExEcGetExpectedImageHash(int devidx, enum VbSelectFirmware_t select,
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExEcUpdateImage(int devidx, enum VbSelectFirmware_t select,
-			    const uint8_t *image, int image_size)
+vb2_error_t VbExEcUpdateImage(int devidx, enum VbSelectFirmware_t select,
+			      const uint8_t *image, int image_size)
 {
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExEcProtect(int devidx, enum VbSelectFirmware_t select)
+vb2_error_t VbExEcProtect(int devidx, enum VbSelectFirmware_t select)
 {
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExEcEnteringMode(int devidx, enum VbEcBootMode_t mode)
+vb2_error_t VbExEcEnteringMode(int devidx, enum VbEcBootMode_t mode)
 {
 	vboot_mode = mode;
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExEcVbootDone(int in_recovery)
+vb2_error_t VbExEcVbootDone(int in_recovery)
 {
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExEcBatteryCutOff(void)
+vb2_error_t VbExEcBatteryCutOff(void)
 {
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExCheckAuxFw(VbAuxFwUpdateSeverity_t *severity)
+vb2_error_t VbExCheckAuxFw(VbAuxFwUpdateSeverity_t *severity)
 {
 	*severity = VB_AUX_FW_NO_UPDATE;
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExUpdateAuxFw(void)
+vb2_error_t VbExUpdateAuxFw(void)
 {
 	return VBERROR_SUCCESS;
 }
@@ -171,7 +172,7 @@ uint8_t VbExOverrideGptEntryPriority(const GptEntry *e)
 	return 0;
 }
 
-VbError_t VbExSetVendorData(const char *vendor_data_value)
+vb2_error_t VbExSetVendorData(const char *vendor_data_value)
 {
 	return 0;
 }
diff --git a/firmware/stub/vboot_api_stub_disk.c b/firmware/stub/vboot_api_stub_disk.c
index 9ff87cbb..f377b3ae 100644
--- a/firmware/stub/vboot_api_stub_disk.c
+++ b/firmware/stub/vboot_api_stub_disk.c
@@ -16,8 +16,8 @@
 #include "vboot_api.h"
 
 
-VbError_t VbExDiskGetInfo(VbDiskInfo** infos_ptr, uint32_t* count,
-			  uint32_t disk_flags)
+vb2_error_t VbExDiskGetInfo(VbDiskInfo** infos_ptr, uint32_t* count,
+			    uint32_t disk_flags)
 {
 	*infos_ptr = NULL;
 	*count = 0;
@@ -25,22 +25,22 @@ VbError_t VbExDiskGetInfo(VbDiskInfo** infos_ptr, uint32_t* count,
 }
 
 
-VbError_t VbExDiskFreeInfo(VbDiskInfo* infos_ptr,
-			   VbExDiskHandle_t preserve_handle)
+vb2_error_t VbExDiskFreeInfo(VbDiskInfo* infos_ptr,
+			     VbExDiskHandle_t preserve_handle)
 {
 	return VBERROR_SUCCESS;
 }
 
 
-VbError_t VbExDiskRead(VbExDiskHandle_t handle, uint64_t lba_start,
-		       uint64_t lba_count, void* buffer)
+vb2_error_t VbExDiskRead(VbExDiskHandle_t handle, uint64_t lba_start,
+			 uint64_t lba_count, void* buffer)
 {
 	return VBERROR_SUCCESS;
 }
 
 
-VbError_t VbExDiskWrite(VbExDiskHandle_t handle, uint64_t lba_start,
-			uint64_t lba_count, const void* buffer)
+vb2_error_t VbExDiskWrite(VbExDiskHandle_t handle, uint64_t lba_start,
+			  uint64_t lba_count, const void* buffer)
 {
 	return VBERROR_SUCCESS;
 }
diff --git a/firmware/stub/vboot_api_stub_init.c b/firmware/stub/vboot_api_stub_init.c
index 828591bd..25b31cd5 100644
--- a/firmware/stub/vboot_api_stub_init.c
+++ b/firmware/stub/vboot_api_stub_init.c
@@ -23,12 +23,12 @@ uint64_t VbExGetTimer(void)
 	return (uint64_t)tv.tv_sec * VB_USEC_PER_SEC + (uint64_t)tv.tv_usec;
 }
 
-VbError_t test_mockable VbExNvStorageRead(uint8_t *buf)
+vb2_error_t test_mockable VbExNvStorageRead(uint8_t *buf)
 {
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExNvStorageWrite(const uint8_t *buf)
+vb2_error_t VbExNvStorageWrite(const uint8_t *buf)
 {
 	return VBERROR_SUCCESS;
 }
diff --git a/firmware/stub/vboot_api_stub_stream.c b/firmware/stub/vboot_api_stub_stream.c
index e8e960b9..8e5d8a16 100644
--- a/firmware/stub/vboot_api_stub_stream.c
+++ b/firmware/stub/vboot_api_stub_stream.c
@@ -25,8 +25,8 @@ struct disk_stream {
 	uint64_t sectors_left;
 };
 
-VbError_t VbExStreamOpen(VbExDiskHandle_t handle, uint64_t lba_start,
-			 uint64_t lba_count, VbExStream_t *stream)
+vb2_error_t VbExStreamOpen(VbExDiskHandle_t handle, uint64_t lba_start,
+			   uint64_t lba_count, VbExStream_t *stream)
 {
 	struct disk_stream *s;
 
@@ -45,11 +45,11 @@ VbError_t VbExStreamOpen(VbExDiskHandle_t handle, uint64_t lba_start,
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExStreamRead(VbExStream_t stream, uint32_t bytes, void *buffer)
+vb2_error_t VbExStreamRead(VbExStream_t stream, uint32_t bytes, void *buffer)
 {
 	struct disk_stream *s = (struct disk_stream *)stream;
 	uint64_t sectors;
-	VbError_t rv;
+	vb2_error_t rv;
 
 	if (!s)
 		return VBERROR_UNKNOWN;
diff --git a/tests/ec_sync_tests.c b/tests/ec_sync_tests.c
index 44efb7de..038c7ef6 100644
--- a/tests/ec_sync_tests.c
+++ b/tests/ec_sync_tests.c
@@ -29,7 +29,7 @@ static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
 
 static int mock_in_rw;
-static VbError_t in_rw_retval;
+static vb2_error_t in_rw_retval;
 static int protect_retval;
 static int ec_ro_protected;
 static int ec_rw_protected;
@@ -56,7 +56,7 @@ static struct vb2_gbb_header gbb;
 static uint32_t screens_displayed[8];
 static uint32_t screens_count = 0;
 
-static VbError_t ec_aux_fw_retval;
+static vb2_error_t ec_aux_fw_retval;
 static int ec_aux_fw_update_req;
 static VbAuxFwUpdateSeverity_t ec_aux_fw_mock_severity;
 static VbAuxFwUpdateSeverity_t ec_aux_fw_update_severity;
@@ -141,13 +141,13 @@ int VbExTrustEC(int devidx)
 	return !mock_in_rw;
 }
 
-VbError_t VbExEcRunningRW(int devidx, int *in_rw)
+vb2_error_t VbExEcRunningRW(int devidx, int *in_rw)
 {
 	*in_rw = mock_in_rw;
 	return in_rw_retval;
 }
 
-VbError_t VbExEcProtect(int devidx, enum VbSelectFirmware_t select)
+vb2_error_t VbExEcProtect(int devidx, enum VbSelectFirmware_t select)
 {
 	if (select == VB_SELECT_FIRMWARE_READONLY)
 		ec_ro_protected = 1;
@@ -156,20 +156,20 @@ VbError_t VbExEcProtect(int devidx, enum VbSelectFirmware_t select)
 	return protect_retval;
 }
 
-VbError_t VbExEcDisableJump(int devidx)
+vb2_error_t VbExEcDisableJump(int devidx)
 {
 	return run_retval;
 }
 
-VbError_t VbExEcJumpToRW(int devidx)
+vb2_error_t VbExEcJumpToRW(int devidx)
 {
 	ec_run_image = 1;
 	mock_in_rw = 1;
 	return run_retval;
 }
 
-VbError_t VbExEcHashImage(int devidx, enum VbSelectFirmware_t select,
-			  const uint8_t **hash, int *hash_size)
+vb2_error_t VbExEcHashImage(int devidx, enum VbSelectFirmware_t select,
+			    const uint8_t **hash, int *hash_size)
 {
 	*hash = select == VB_SELECT_FIRMWARE_READONLY ?
 		mock_ec_ro_hash : mock_ec_rw_hash;
@@ -178,8 +178,8 @@ VbError_t VbExEcHashImage(int devidx, enum VbSelectFirmware_t select,
 	return *hash_size ? VBERROR_SUCCESS : VBERROR_SIMULATED;
 }
 
-VbError_t VbExEcGetExpectedImage(int devidx, enum VbSelectFirmware_t select,
-				 const uint8_t **image, int *image_size)
+vb2_error_t VbExEcGetExpectedImage(int devidx, enum VbSelectFirmware_t select,
+				   const uint8_t **image, int *image_size)
 {
 	static uint8_t fake_image[64] = {5, 6, 7, 8};
 	*image = fake_image;
@@ -187,8 +187,9 @@ VbError_t VbExEcGetExpectedImage(int devidx, enum VbSelectFirmware_t select,
 	return get_expected_retval;
 }
 
-VbError_t VbExEcGetExpectedImageHash(int devidx, enum VbSelectFirmware_t select,
-				     const uint8_t **hash, int *hash_size)
+vb2_error_t VbExEcGetExpectedImageHash(int devidx,
+				       enum VbSelectFirmware_t select,
+				       const uint8_t **hash, int *hash_size)
 {
 	*hash = want_ec_hash;
 	*hash_size = want_ec_hash_size;
@@ -196,8 +197,8 @@ VbError_t VbExEcGetExpectedImageHash(int devidx, enum VbSelectFirmware_t select,
 	return want_ec_hash_size ? VBERROR_SUCCESS : VBERROR_SIMULATED;
 }
 
-VbError_t VbExEcUpdateImage(int devidx, enum VbSelectFirmware_t select,
-			    const uint8_t *image, int image_size)
+vb2_error_t VbExEcUpdateImage(int devidx, enum VbSelectFirmware_t select,
+			      const uint8_t *image, int image_size)
 {
 	if (select == VB_SELECT_FIRMWARE_READONLY) {
 		ec_ro_updated = 1;
@@ -209,8 +210,8 @@ VbError_t VbExEcUpdateImage(int devidx, enum VbSelectFirmware_t select,
 	return update_retval;
 }
 
-VbError_t VbDisplayScreen(struct vb2_context *c, uint32_t screen, int force,
-			  const VbScreenData *data)
+vb2_error_t VbDisplayScreen(struct vb2_context *c, uint32_t screen, int force,
+			    const VbScreenData *data)
 {
 	if (screens_count < ARRAY_SIZE(screens_displayed))
 		screens_displayed[screens_count++] = screen;
@@ -218,14 +219,14 @@ VbError_t VbDisplayScreen(struct vb2_context *c, uint32_t screen, int force,
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExCheckAuxFw(VbAuxFwUpdateSeverity_t *severity)
+vb2_error_t VbExCheckAuxFw(VbAuxFwUpdateSeverity_t *severity)
 {
 	*severity = ec_aux_fw_mock_severity;
 	ec_aux_fw_update_severity = ec_aux_fw_mock_severity;
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExUpdateAuxFw()
+vb2_error_t VbExUpdateAuxFw()
 {
 	if (ec_aux_fw_update_severity != VB_AUX_FW_NO_DEVICE &&
 	    ec_aux_fw_update_severity != VB_AUX_FW_NO_UPDATE)
@@ -233,13 +234,14 @@ VbError_t VbExUpdateAuxFw()
 	return ec_aux_fw_retval;
 }
 
-VbError_t VbExEcVbootDone(int in_recovery)
+vb2_error_t VbExEcVbootDone(int in_recovery)
 {
 	ec_aux_fw_protected = ec_aux_fw_update_severity != VB_AUX_FW_NO_DEVICE;
 	return ec_aux_fw_retval;
 }
 
-static void test_ssync(VbError_t retval, int recovery_reason, const char *desc)
+static void test_ssync(vb2_error_t retval, int recovery_reason,
+		       const char *desc)
 {
 	TEST_EQ(ec_sync_all(&ctx), retval, desc);
 	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
diff --git a/tests/tlcl_tests.c b/tests/tlcl_tests.c
index fc6dee54..3bdb593e 100644
--- a/tests/tlcl_tests.c
+++ b/tests/tlcl_tests.c
@@ -18,7 +18,7 @@
 
 /* Mock data */
 static char debug_info[4096];
-static VbError_t mock_retval;
+static vb2_error_t mock_retval;
 
 /* Call to mocked VbExTpmSendReceive() */
 struct srcall
@@ -29,7 +29,7 @@ struct srcall
 	int req_size;  /* Request size */
 	uint32_t req_cmd;  /* Request command code */
 	int rsp_size;  /* Response size */
-	VbError_t retval;  /* Value to return */
+	vb2_error_t retval;  /* Value to return */
 };
 
 #define MAXCALLS 8
@@ -65,13 +65,13 @@ static void SetResponse(int call_idx, uint32_t response_code, int rsp_size)
 
 /* Mocks */
 
-VbError_t VbExTpmInit(void)
+vb2_error_t VbExTpmInit(void)
 {
 	return mock_retval;
 }
 
 
-VbError_t VbExTpmClose(void)
+vb2_error_t VbExTpmClose(void)
 {
 	return mock_retval;
 }
@@ -98,7 +98,7 @@ uint32_t VbExTpmSendReceive(const uint8_t *request, uint32_t request_length,
 	return c->retval;
 }
 
-VbError_t VbExTpmGetRandom(uint8_t *buf, uint32_t length)
+vb2_error_t VbExTpmGetRandom(uint8_t *buf, uint32_t length)
 {
 	memset(buf, 0xa5, length);
 	return VBERROR_SUCCESS;
diff --git a/tests/vboot_api_devmode_tests.c b/tests/vboot_api_devmode_tests.c
index 53373bda..fcfd06e8 100644
--- a/tests/vboot_api_devmode_tests.c
+++ b/tests/vboot_api_devmode_tests.c
@@ -40,7 +40,7 @@ typedef struct {
 typedef struct {
 	const char *name;
 	uint32_t gbb_flags;
-	VbError_t beep_return;
+	vb2_error_t beep_return;
 	uint32_t keypress_key;
 	int keypress_at_count;
 	int num_events;
@@ -105,7 +105,7 @@ static int max_events;
 static int matched_events;
 static int kbd_fire_at;
 static uint32_t kbd_fire_key;
-static VbError_t beep_return;
+static vb2_error_t beep_return;
 static note_event_t *expected_event;
 
 /* Audio open count, so we can reset it */
@@ -150,36 +150,36 @@ struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
 	return &gbb;
 }
 
-VbError_t VbExNvStorageRead(uint8_t* buf)
+vb2_error_t VbExNvStorageRead(uint8_t* buf)
 {
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExNvStorageWrite(const uint8_t* buf)
+vb2_error_t VbExNvStorageWrite(const uint8_t* buf)
 {
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExDiskGetInfo(VbDiskInfo** infos_ptr, uint32_t* count,
-			  uint32_t disk_flags)
+vb2_error_t VbExDiskGetInfo(VbDiskInfo** infos_ptr, uint32_t* count,
+			    uint32_t disk_flags)
 {
 	return VBERROR_UNKNOWN;
 }
 
-VbError_t VbExDiskFreeInfo(VbDiskInfo* infos,
-			   VbExDiskHandle_t preserve_handle)
+vb2_error_t VbExDiskFreeInfo(VbDiskInfo* infos,
+			     VbExDiskHandle_t preserve_handle)
 {
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExDiskRead(VbExDiskHandle_t handle, uint64_t lba_start,
-		       uint64_t lba_count, void* buffer)
+vb2_error_t VbExDiskRead(VbExDiskHandle_t handle, uint64_t lba_start,
+			 uint64_t lba_count, void* buffer)
 {
 	return VBERROR_UNKNOWN;
 }
 
-VbError_t VbExDiskWrite(VbExDiskHandle_t handle, uint64_t lba_start,
-			uint64_t lba_count, const void* buffer)
+vb2_error_t VbExDiskWrite(VbExDiskHandle_t handle, uint64_t lba_start,
+			  uint64_t lba_count, const void* buffer)
 {
 	return VBERROR_UNKNOWN;
 }
@@ -221,7 +221,7 @@ uint64_t VbExGetTimer(void)
 	return current_ticks;
 }
 
-VbError_t VbExBeep(uint32_t msec, uint32_t frequency)
+vb2_error_t VbExBeep(uint32_t msec, uint32_t frequency)
 {
 	VB2_DEBUG("VbExBeep(%d, %d) at %d msec\n",
 		  msec, frequency, current_time);
@@ -240,8 +240,8 @@ VbError_t VbExBeep(uint32_t msec, uint32_t frequency)
 	return beep_return;
 }
 
-VbError_t VbExDisplayScreen(uint32_t screen_type, uint32_t locale,
-			    const VbScreenData *data)
+vb2_error_t VbExDisplayScreen(uint32_t screen_type, uint32_t locale,
+			      const VbScreenData *data)
 {
 	switch(screen_type) {
 		case VB_SCREEN_BLANK:
diff --git a/tests/vboot_api_kernel2_tests.c b/tests/vboot_api_kernel2_tests.c
index c8e269e0..f37913c4 100644
--- a/tests/vboot_api_kernel2_tests.c
+++ b/tests/vboot_api_kernel2_tests.c
@@ -199,8 +199,8 @@ uint64_t VbExGetTimer(void)
 	return current_ticks;
 }
 
-VbError_t VbExDiskGetInfo(VbDiskInfo **infos_ptr, uint32_t *count,
-			  uint32_t disk_flags)
+vb2_error_t VbExDiskGetInfo(VbDiskInfo **infos_ptr, uint32_t *count,
+			    uint32_t disk_flags)
 {
 	if (mock_num_disks_count < ARRAY_SIZE(mock_num_disks)) {
 		if (mock_num_disks[mock_num_disks_count] == -1)
@@ -213,8 +213,8 @@ VbError_t VbExDiskGetInfo(VbDiskInfo **infos_ptr, uint32_t *count,
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExDiskFreeInfo(VbDiskInfo *infos,
-			   VbExDiskHandle_t preserve_handle)
+vb2_error_t VbExDiskFreeInfo(VbDiskInfo *infos,
+			     VbExDiskHandle_t preserve_handle)
 {
 	return VBERROR_SUCCESS;
 }
@@ -239,8 +239,8 @@ uint32_t VbTryLoadKernel(struct vb2_context *c, uint32_t get_info_flags)
 	return vbtlk_retval + get_info_flags;
 }
 
-VbError_t VbDisplayScreen(struct vb2_context *c, uint32_t screen, int force,
-			  const VbScreenData *data)
+vb2_error_t VbDisplayScreen(struct vb2_context *c, uint32_t screen, int force,
+			    const VbScreenData *data)
 {
 	if (screens_count < ARRAY_SIZE(screens_displayed))
 		screens_displayed[screens_count++] = screen;
@@ -254,7 +254,7 @@ uint32_t SetVirtualDevMode(int val)
 	return virtdev_retval;
 }
 
-VbError_t VbExSetVendorData(const char *vendor_data_value)
+vb2_error_t VbExSetVendorData(const char *vendor_data_value)
 {
 	set_vendor_data_called = 1;
 	strncpy(set_vendor_data, vendor_data_value, sizeof(set_vendor_data));
diff --git a/tests/vboot_api_kernel4_tests.c b/tests/vboot_api_kernel4_tests.c
index d2f19fa9..e466baf9 100644
--- a/tests/vboot_api_kernel4_tests.c
+++ b/tests/vboot_api_kernel4_tests.c
@@ -38,7 +38,7 @@ static uint32_t rkr_version;
 static uint32_t new_version;
 static struct RollbackSpaceFwmp rfr_fwmp;
 static int rkr_retval, rkw_retval, rkl_retval, rfr_retval;
-static VbError_t vbboot_retval;
+static vb2_error_t vbboot_retval;
 
 static uint32_t mock_switches[8];
 static uint32_t mock_switches_count;
@@ -90,14 +90,14 @@ static void ResetMocks(void)
 
 /* Mock functions */
 
-VbError_t VbExNvStorageRead(uint8_t *buf)
+vb2_error_t VbExNvStorageRead(uint8_t *buf)
 {
 	memcpy(buf, ctx_nvram_backend.nvdata,
 	       vb2_nv_get_size(&ctx_nvram_backend));
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExNvStorageWrite(const uint8_t *buf)
+vb2_error_t VbExNvStorageWrite(const uint8_t *buf)
 {
 	memcpy(ctx_nvram_backend.nvdata, buf,
 	       vb2_nv_get_size(&ctx_nvram_backend));
@@ -137,7 +137,7 @@ uint32_t VbTryLoadKernel(struct vb2_context *c, uint32_t get_info_flags)
 	return vbboot_retval;
 }
 
-VbError_t VbBootDeveloper(struct vb2_context *c)
+vb2_error_t VbBootDeveloper(struct vb2_context *c)
 {
 	shared->kernel_version_tpm = new_version;
 
@@ -147,7 +147,7 @@ VbError_t VbBootDeveloper(struct vb2_context *c)
 	return vbboot_retval;
 }
 
-VbError_t VbBootRecovery(struct vb2_context *c)
+vb2_error_t VbBootRecovery(struct vb2_context *c)
 {
 	shared->kernel_version_tpm = new_version;
 
@@ -157,7 +157,7 @@ VbError_t VbBootRecovery(struct vb2_context *c)
 	return vbboot_retval;
 }
 
-VbError_t VbBootDiagnostic(struct vb2_context *c)
+vb2_error_t VbBootDiagnostic(struct vb2_context *c)
 {
 	if (vbboot_retval == -4)
 		return VBERROR_SIMULATED;
@@ -165,7 +165,7 @@ VbError_t VbBootDiagnostic(struct vb2_context *c)
 	return vbboot_retval;
 }
 
-static void test_slk(VbError_t retval, int recovery_reason, const char *desc)
+static void test_slk(vb2_error_t retval, int recovery_reason, const char *desc)
 {
 	TEST_EQ(VbSelectAndLoadKernel(&ctx, shared, &kparams), retval, desc);
 	TEST_EQ(vb2_nv_get(&ctx_nvram_backend, VB2_NV_RECOVERY_REQUEST),
diff --git a/tests/vboot_api_kernel5_tests.c b/tests/vboot_api_kernel5_tests.c
index efaef8bd..1f4e6cd9 100644
--- a/tests/vboot_api_kernel5_tests.c
+++ b/tests/vboot_api_kernel5_tests.c
@@ -206,7 +206,7 @@ int vb2_verify_data(const uint8_t *data,
 	return VB2_SUCCESS;
 }
 
-VbError_t VbExNvStorageRead(uint8_t *buf)
+vb2_error_t VbExNvStorageRead(uint8_t *buf)
 {
 	memcpy(buf, ctx_nvram_backend.nvdata,
 	       vb2_nv_get_size(&ctx_nvram_backend));
diff --git a/tests/vboot_api_kernel_tests.c b/tests/vboot_api_kernel_tests.c
index fc0d3893..7afe6d04 100644
--- a/tests/vboot_api_kernel_tests.c
+++ b/tests/vboot_api_kernel_tests.c
@@ -36,10 +36,10 @@ typedef struct {
 
 	/* inputs for test case */
 	uint32_t want_flags;
-	VbError_t diskgetinfo_return_val;
+	vb2_error_t diskgetinfo_return_val;
 	disk_desc_t disks_to_provide[MAX_TEST_DISKS];
 	int disk_count_to_return;
-	VbError_t loadkernel_return_val[MAX_TEST_DISKS];
+	vb2_error_t loadkernel_return_val[MAX_TEST_DISKS];
 	uint8_t external_expected[MAX_TEST_DISKS];
 
 	/* outputs from test */
@@ -260,8 +260,8 @@ static int is_nonzero(const void *vptr, size_t count)
 /****************************************************************************/
 /* Mocked verification functions */
 
-VbError_t VbExDiskGetInfo(VbDiskInfo **infos_ptr, uint32_t *count,
-			  uint32_t disk_flags)
+vb2_error_t VbExDiskGetInfo(VbDiskInfo **infos_ptr, uint32_t *count,
+			    uint32_t disk_flags)
 {
 	int i;
 	int num_disks = 0;
@@ -308,7 +308,7 @@ VbError_t VbExDiskGetInfo(VbDiskInfo **infos_ptr, uint32_t *count,
 	return t->diskgetinfo_return_val;
 }
 
-VbError_t VbExDiskFreeInfo(VbDiskInfo *infos,
+vb2_error_t VbExDiskFreeInfo(VbDiskInfo *infos,
 			   VbExDiskHandle_t preserve_handle)
 {
 	got_load_disk = (const char *)preserve_handle;
@@ -317,7 +317,7 @@ VbError_t VbExDiskFreeInfo(VbDiskInfo *infos,
 	return VBERROR_SUCCESS;
 }
 
-VbError_t LoadKernel(struct vb2_context *c, LoadKernelParams *params)
+vb2_error_t LoadKernel(struct vb2_context *c, LoadKernelParams *params)
 {
 	got_find_disk = (const char *)params->disk_handle;
 	VB2_DEBUG("%s(%d): got_find_disk = %s\n", __FUNCTION__,
diff --git a/tests/vboot_detach_menu_tests.c b/tests/vboot_detach_menu_tests.c
index 4d618659..cba297b8 100644
--- a/tests/vboot_detach_menu_tests.c
+++ b/tests/vboot_detach_menu_tests.c
@@ -36,10 +36,10 @@ static struct vb2_gbb_header gbb;
 
 static int shutdown_request_calls_left;
 static int audio_looping_calls_left;
-static VbError_t vbtlk_retval[5];
-static VbError_t vbtlk_last_retval;
+static vb2_error_t vbtlk_retval[5];
+static vb2_error_t vbtlk_last_retval;
 static int vbtlk_retval_count;
-static const VbError_t vbtlk_retval_fixed = 1002;
+static const vb2_error_t vbtlk_retval_fixed = 1002;
 static int vbexlegacy_called;
 static enum VbAltFwIndex_t altfw_num;
 static int debug_info_displayed;
@@ -199,7 +199,7 @@ int vb2_audio_looping(void)
 	return 1;
 }
 
-VbError_t VbTryLoadKernel(struct vb2_context *c, uint32_t get_info_flags)
+vb2_error_t VbTryLoadKernel(struct vb2_context *c, uint32_t get_info_flags)
 {
 	if (vbtlk_retval_count < ARRAY_SIZE(vbtlk_retval) &&
 	    vbtlk_retval[vbtlk_retval_count] != 0)
@@ -207,8 +207,8 @@ VbError_t VbTryLoadKernel(struct vb2_context *c, uint32_t get_info_flags)
 	return vbtlk_last_retval + get_info_flags;
 }
 
-VbError_t VbDisplayScreen(struct vb2_context *c, uint32_t screen, int force,
-			  const VbScreenData *data)
+vb2_error_t VbDisplayScreen(struct vb2_context *c, uint32_t screen, int force,
+			    const VbScreenData *data)
 {
 	if (screens_count < ARRAY_SIZE(screens_displayed))
 		screens_displayed[screens_count++] = screen;
@@ -217,8 +217,8 @@ VbError_t VbDisplayScreen(struct vb2_context *c, uint32_t screen, int force,
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbDisplayMenu(struct vb2_context *c, uint32_t screen, int force,
-			uint32_t selected_index, uint32_t disabled_idx_mask)
+vb2_error_t VbDisplayMenu(struct vb2_context *c, uint32_t screen, int force,
+			  uint32_t selected_index, uint32_t disabled_idx_mask)
 {
 	if (screens_count < ARRAY_SIZE(screens_displayed))
 		screens_displayed[screens_count++] = screen;
@@ -232,13 +232,13 @@ VbError_t VbDisplayMenu(struct vb2_context *c, uint32_t screen, int force,
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbDisplayDebugInfo(struct vb2_context *c)
+vb2_error_t VbDisplayDebugInfo(struct vb2_context *c)
 {
 	debug_info_displayed = 1;
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExBeep(uint32_t msec, uint32_t frequency)
+vb2_error_t VbExBeep(uint32_t msec, uint32_t frequency)
 {
 	if (beeps_count < ARRAY_SIZE(beeps_played))
 		beeps_played[beeps_count++] = frequency;
diff --git a/tests/vboot_display_tests.c b/tests/vboot_display_tests.c
index c509e365..7d4662ea 100644
--- a/tests/vboot_display_tests.c
+++ b/tests/vboot_display_tests.c
@@ -53,7 +53,7 @@ static void ResetMocks(void)
 }
 
 /* Mocks */
-VbError_t VbExGetLocalizationCount(uint32_t *count) {
+vb2_error_t VbExGetLocalizationCount(uint32_t *count) {
 
 	if (mock_localization_count == 0xffffffff)
 		return VBERROR_UNKNOWN;
@@ -66,7 +66,7 @@ uint32_t VbExGetAltFwIdxMask() {
 	return mock_altfw_mask;
 }
 
-VbError_t VbExDisplayDebugInfo(const char *info_str, int full_info)
+vb2_error_t VbExDisplayDebugInfo(const char *info_str, int full_info)
 {
 	strncpy(debug_info, info_str, sizeof(debug_info));
 	debug_info[sizeof(debug_info) - 1] = '\0';
diff --git a/tests/vboot_kernel_tests.c b/tests/vboot_kernel_tests.c
index 1c7440cf..56efbf36 100644
--- a/tests/vboot_kernel_tests.c
+++ b/tests/vboot_kernel_tests.c
@@ -221,7 +221,7 @@ int vb2_gbb_read_recovery_key(struct vb2_context *c,
 	return VB2_SUCCESS;
 }
 
-VbError_t VbExDiskRead(VbExDiskHandle_t h, uint64_t lba_start,
+vb2_error_t VbExDiskRead(VbExDiskHandle_t h, uint64_t lba_start,
 		       uint64_t lba_count, void *buffer)
 {
 	LOGCALL("VbExDiskRead(h, %d, %d)\n", (int)lba_start, (int)lba_count);
@@ -235,7 +235,7 @@ VbError_t VbExDiskRead(VbExDiskHandle_t h, uint64_t lba_start,
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExDiskWrite(VbExDiskHandle_t h, uint64_t lba_start,
+vb2_error_t VbExDiskWrite(VbExDiskHandle_t h, uint64_t lba_start,
 			uint64_t lba_count, const void *buffer)
 {
 	LOGCALL("VbExDiskWrite(h, %d, %d)\n", (int)lba_start, (int)lba_count);
diff --git a/tests/verify_kernel.c b/tests/verify_kernel.c
index f326ec7d..269fe733 100644
--- a/tests/verify_kernel.c
+++ b/tests/verify_kernel.c
@@ -26,7 +26,7 @@ static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
 
 static LoadKernelParams params;
 
-VbError_t VbExDiskRead(VbExDiskHandle_t handle, uint64_t lba_start,
+vb2_error_t VbExDiskRead(VbExDiskHandle_t handle, uint64_t lba_start,
 		       uint64_t lba_count, void *buffer)
 {
 	if (handle != (VbExDiskHandle_t)1)
@@ -40,7 +40,7 @@ VbError_t VbExDiskRead(VbExDiskHandle_t handle, uint64_t lba_start,
 	return VBERROR_SUCCESS;
 }
 
-VbError_t VbExDiskWrite(VbExDiskHandle_t handle, uint64_t lba_start,
+vb2_error_t VbExDiskWrite(VbExDiskHandle_t handle, uint64_t lba_start,
 			uint64_t lba_count, const void *buffer)
 {
 	if (handle != (VbExDiskHandle_t)1)
diff --git a/utility/load_kernel_test.c b/utility/load_kernel_test.c
index c2ff61e6..2fbf0c54 100644
--- a/utility/load_kernel_test.c
+++ b/utility/load_kernel_test.c
@@ -32,7 +32,7 @@ static FILE *image_file = NULL;
 
 
 /* Boot device stub implementations to read from the image file */
-VbError_t VbExDiskRead(VbExDiskHandle_t handle, uint64_t lba_start,
+vb2_error_t VbExDiskRead(VbExDiskHandle_t handle, uint64_t lba_start,
                        uint64_t lba_count, void *buffer) {
   printf("Read(%" PRIu64 ", %" PRIu64 ")\n", lba_start, lba_count);
 
@@ -52,7 +52,7 @@ VbError_t VbExDiskRead(VbExDiskHandle_t handle, uint64_t lba_start,
 }
 
 
-VbError_t VbExDiskWrite(VbExDiskHandle_t handle, uint64_t lba_start,
+vb2_error_t VbExDiskWrite(VbExDiskHandle_t handle, uint64_t lba_start,
                         uint64_t lba_count, const void *buffer) {
   printf("Write(%" PRIu64 ", %" PRIu64 ")\n", lba_start, lba_count);
 
@@ -86,7 +86,7 @@ int main(int argc, char* argv[]) {
   uint8_t* key_blob = NULL;
   VbSharedDataHeader* shared;
   struct vb2_gbb_header* gbb;
-  VbError_t rv;
+  vb2_error_t rv;
   int c, argsleft;
   int errorcnt = 0;
   char *e = 0;