vboot: update vboot2 functions to use new vb2_error_t

To make explicit when vboot2 error codes should be returned,
use the new vb2_error_t type on all functions which return
VB2_ERROR_* constants.

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

Change-Id: Idd3ee8afe8c78347783ce5fa829cb78f1e5719e2
Signed-off-by: Joel Kitching <kitching@google.com>
Cq-Depend: chromium:1728113, chromium:1728499
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/vboot_reference/+/1728292
Reviewed-by: Joel Kitching <kitching@chromium.org>
Commit-Queue: Joel Kitching <kitching@chromium.org>
Tested-by: Joel Kitching <kitching@chromium.org>

17 files changed, 166 insertions, 209 deletions

diff --git a/tests/vb20_api_kernel_tests.c b/tests/vb20_api_kernel_tests.c
index 64fb421f..3a300ab6 100644
--- a/tests/vb20_api_kernel_tests.c
+++ b/tests/vb20_api_kernel_tests.c
@@ -152,11 +152,9 @@ static void reset_common_data(enum reset_type t)
 
 /* Mocked functions */
 
-int vb2ex_read_resource(struct vb2_context *c,
-			enum vb2_resource_index index,
-			uint32_t offset,
-			void *buf,
-			uint32_t size)
+vb2_error_t vb2ex_read_resource(struct vb2_context *c,
+				enum vb2_resource_index index, uint32_t offset,
+				void *buf, uint32_t size)
 {
 	uint8_t *rptr;
 	uint32_t rsize;
@@ -180,25 +178,25 @@ int vb2ex_read_resource(struct vb2_context *c,
 	return VB2_SUCCESS;
 }
 
-int vb2_read_gbb_header(struct vb2_context *c, struct vb2_gbb_header *gbb)
+vb2_error_t vb2_read_gbb_header(struct vb2_context *c,
+				struct vb2_gbb_header *gbb)
 {
 	memcpy(gbb, &mock_gbb.h, sizeof(*gbb));
 	return mock_read_gbb_header_retval;
 }
 
-int vb2_load_kernel_keyblock(struct vb2_context *c)
+vb2_error_t vb2_load_kernel_keyblock(struct vb2_context *c)
 {
 	return mock_load_kernel_keyblock_retval;
 }
 
-int vb2_load_kernel_preamble(struct vb2_context *c)
+vb2_error_t vb2_load_kernel_preamble(struct vb2_context *c)
 {
 	return mock_load_kernel_preamble_retval;
 }
 
-int vb2_unpack_key_buffer(struct vb2_public_key *key,
-		   const uint8_t *buf,
-		   uint32_t size)
+vb2_error_t vb2_unpack_key_buffer(struct vb2_public_key *key,
+				  const uint8_t *buf, uint32_t size)
 {
 	const struct vb2_packed_key *k = (const struct vb2_packed_key *)buf;
 
@@ -207,10 +205,9 @@ int vb2_unpack_key_buffer(struct vb2_public_key *key,
 	return mock_unpack_key_retval;
 }
 
-int vb2_verify_digest(const struct vb2_public_key *key,
-		      struct vb2_signature *sig,
-		      const uint8_t *digest,
-		      const struct vb2_workbuf *wb)
+vb2_error_t vb2_verify_digest(const struct vb2_public_key *key,
+			      struct vb2_signature *sig, const uint8_t *digest,
+			      const struct vb2_workbuf *wb)
 {
 	if (memcmp(digest, (uint8_t *)sig + sig->sig_offset, sig->sig_size))
 		return VB2_ERROR_VDATA_VERIFY_DIGEST;
diff --git a/tests/vb20_api_tests.c b/tests/vb20_api_tests.c
index 1c96efa1..ae6a216c 100644
--- a/tests/vb20_api_tests.c
+++ b/tests/vb20_api_tests.c
@@ -38,10 +38,10 @@ static enum {
 	HWCRYPTO_FORBIDDEN,
 } hwcrypto_state;
 
-static int retval_vb2_load_fw_keyblock;
-static int retval_vb2_load_fw_preamble;
-static int retval_vb2_digest_finalize;
-static int retval_vb2_verify_digest;
+static vb2_error_t retval_vb2_load_fw_keyblock;
+static vb2_error_t retval_vb2_load_fw_preamble;
+static vb2_error_t retval_vb2_digest_finalize;
+static vb2_error_t retval_vb2_verify_digest;
 
 /* Type of test to reset for */
 enum reset_type {
@@ -107,19 +107,18 @@ static void reset_common_data(enum reset_type t)
 
 /* Mocked functions */
 
-int vb2_load_fw_keyblock(struct vb2_context *c)
+vb2_error_t vb2_load_fw_keyblock(struct vb2_context *c)
 {
 	return retval_vb2_load_fw_keyblock;
 }
 
-int vb2_load_fw_preamble(struct vb2_context *c)
+vb2_error_t vb2_load_fw_preamble(struct vb2_context *c)
 {
 	return retval_vb2_load_fw_preamble;
 }
 
-int vb2_unpack_key_buffer(struct vb2_public_key *key,
-		   const uint8_t *buf,
-		   uint32_t size)
+vb2_error_t vb2_unpack_key_buffer(struct vb2_public_key *key,
+				  const uint8_t *buf, uint32_t size)
 {
 	struct vb2_packed_key *k = (struct vb2_packed_key *)buf;
 
@@ -132,8 +131,8 @@ int vb2_unpack_key_buffer(struct vb2_public_key *key,
 	return VB2_SUCCESS;
 }
 
-int vb2ex_hwcrypto_digest_init(enum vb2_hash_algorithm hash_alg,
-			       uint32_t data_size)
+vb2_error_t vb2ex_hwcrypto_digest_init(enum vb2_hash_algorithm hash_alg,
+				       uint32_t data_size)
 {
 	switch (hwcrypto_state) {
 	case HWCRYPTO_DISABLED:
@@ -149,8 +148,8 @@ int vb2ex_hwcrypto_digest_init(enum vb2_hash_algorithm hash_alg,
 	}
 }
 
-int vb2ex_hwcrypto_digest_extend(const uint8_t *buf,
-				 uint32_t size)
+vb2_error_t vb2ex_hwcrypto_digest_extend(const uint8_t *buf,
+					 uint32_t size)
 {
 	if (hwcrypto_state != HWCRYPTO_ENABLED)
 		return VB2_ERROR_UNKNOWN;
@@ -164,7 +163,7 @@ static void fill_digest(uint8_t *digest, uint32_t digest_size)
 	memset(digest, 0x0a, digest_size);
 }
 
-int vb2ex_hwcrypto_digest_finalize(uint8_t *digest,
+vb2_error_t vb2ex_hwcrypto_digest_finalize(uint8_t *digest,
 				   uint32_t digest_size)
 {
 	if (hwcrypto_state != HWCRYPTO_ENABLED)
@@ -176,7 +175,7 @@ int vb2ex_hwcrypto_digest_finalize(uint8_t *digest,
 	return retval_vb2_digest_finalize;
 }
 
-int vb2_digest_init(struct vb2_digest_context *dc,
+vb2_error_t vb2_digest_init(struct vb2_digest_context *dc,
 		    enum vb2_hash_algorithm hash_alg)
 {
 	if (hwcrypto_state == HWCRYPTO_ENABLED)
@@ -190,9 +189,8 @@ int vb2_digest_init(struct vb2_digest_context *dc,
 	return VB2_SUCCESS;
 }
 
-int vb2_digest_extend(struct vb2_digest_context *dc,
-		      const uint8_t *buf,
-		      uint32_t size)
+vb2_error_t vb2_digest_extend(struct vb2_digest_context *dc, const uint8_t *buf,
+			      uint32_t size)
 {
 	if (hwcrypto_state == HWCRYPTO_ENABLED)
 		return VB2_ERROR_UNKNOWN;
@@ -202,9 +200,8 @@ int vb2_digest_extend(struct vb2_digest_context *dc,
 	return VB2_SUCCESS;
 }
 
-int vb2_digest_finalize(struct vb2_digest_context *dc,
-			uint8_t *digest,
-			uint32_t digest_size)
+vb2_error_t vb2_digest_finalize(struct vb2_digest_context *dc, uint8_t *digest,
+				uint32_t digest_size)
 {
 	if (hwcrypto_state == HWCRYPTO_ENABLED)
 		return VB2_ERROR_UNKNOWN;
@@ -220,10 +217,9 @@ uint32_t vb2_rsa_sig_size(enum vb2_signature_algorithm sig_alg)
 	return mock_sig_size;
 }
 
-int vb2_rsa_verify_digest(const struct vb2_public_key *key,
-			  uint8_t *sig,
-			  const uint8_t *digest,
-			  const struct vb2_workbuf *wb)
+vb2_error_t vb2_rsa_verify_digest(const struct vb2_public_key *key,
+				  uint8_t *sig, const uint8_t *digest,
+				  const struct vb2_workbuf *wb)
 {
 	return retval_vb2_verify_digest;
 }
diff --git a/tests/vb20_kernel_tests.c b/tests/vb20_kernel_tests.c
index c798f862..5490ccce 100644
--- a/tests/vb20_kernel_tests.c
+++ b/tests/vb20_kernel_tests.c
@@ -135,11 +135,9 @@ static void reset_common_data(enum reset_type t)
 
 /* Mocked functions */
 
-int vb2ex_read_resource(struct vb2_context *c,
-			enum vb2_resource_index index,
-			uint32_t offset,
-			void *buf,
-			uint32_t size)
+vb2_error_t vb2ex_read_resource(struct vb2_context *c,
+				enum vb2_resource_index index, uint32_t offset,
+				void *buf, uint32_t size)
 {
 	uint8_t *rptr;
 	uint32_t rsize;
@@ -167,26 +165,24 @@ int vb2ex_read_resource(struct vb2_context *c,
 	return VB2_SUCCESS;
 }
 
-int vb2_unpack_key_buffer(struct vb2_public_key *key,
-		   const uint8_t *buf,
-		   uint32_t size)
+vb2_error_t vb2_unpack_key_buffer(struct vb2_public_key *key,
+				  const uint8_t *buf, uint32_t size)
 {
 	key->arrsize = 0;
 	return mock_unpack_key_retval;
 }
 
-int vb2_verify_keyblock(struct vb2_keyblock *block,
-			uint32_t size,
-			const struct vb2_public_key *key,
-			const struct vb2_workbuf *w)
+vb2_error_t vb2_verify_keyblock(struct vb2_keyblock *block, uint32_t size,
+				const struct vb2_public_key *key,
+				const struct vb2_workbuf *w)
 {
 	return mock_verify_keyblock_retval;
 }
 
-int vb2_verify_kernel_preamble(struct vb2_kernel_preamble *preamble,
-			       uint32_t size,
-			       const struct vb2_public_key *key,
-			       const struct vb2_workbuf *w)
+vb2_error_t vb2_verify_kernel_preamble(struct vb2_kernel_preamble *preamble,
+				       uint32_t size,
+				       const struct vb2_public_key *key,
+				       const struct vb2_workbuf *w)
 {
 	return mock_verify_preamble_retval;
 }
diff --git a/tests/vb20_misc_tests.c b/tests/vb20_misc_tests.c
index 9716ae2a..46e3f036 100644
--- a/tests/vb20_misc_tests.c
+++ b/tests/vb20_misc_tests.c
@@ -121,11 +121,9 @@ struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
 	return &gbb;
 }
 
-int vb2ex_read_resource(struct vb2_context *c,
-			enum vb2_resource_index index,
-			uint32_t offset,
-			void *buf,
-			uint32_t size)
+vb2_error_t vb2ex_read_resource(struct vb2_context *c,
+				enum vb2_resource_index index, uint32_t offset,
+				void *buf, uint32_t size)
 {
 	uint8_t *rptr;
 	uint32_t rsize;
@@ -153,26 +151,24 @@ int vb2ex_read_resource(struct vb2_context *c,
 	return VB2_SUCCESS;
 }
 
-int vb2_unpack_key_buffer(struct vb2_public_key *key,
-		   const uint8_t *buf,
-		   uint32_t size)
+vb2_error_t vb2_unpack_key_buffer(struct vb2_public_key *key,
+				  const uint8_t *buf, uint32_t size)
 {
 	key->arrsize = 0;
 	return mock_unpack_key_retval;
 }
 
-int vb2_verify_keyblock(struct vb2_keyblock *block,
-			uint32_t size,
-			const struct vb2_public_key *key,
-			const struct vb2_workbuf *wb)
+vb2_error_t vb2_verify_keyblock(struct vb2_keyblock *block, uint32_t size,
+				const struct vb2_public_key *key,
+				const struct vb2_workbuf *wb)
 {
 	return mock_verify_keyblock_retval;
 }
 
-int vb2_verify_fw_preamble(struct vb2_fw_preamble *preamble,
-			   uint32_t size,
-			   const struct vb2_public_key *key,
-			   const struct vb2_workbuf *wb)
+vb2_error_t vb2_verify_fw_preamble(struct vb2_fw_preamble *preamble,
+				   uint32_t size,
+				   const struct vb2_public_key *key,
+				   const struct vb2_workbuf *wb)
 {
 	return mock_verify_preamble_retval;
 }
diff --git a/tests/vb20_verify_fw.c b/tests/vb20_verify_fw.c
index 5fd232a5..850d4b01 100644
--- a/tests/vb20_verify_fw.c
+++ b/tests/vb20_verify_fw.c
@@ -20,11 +20,9 @@ const char *body_fname;
  * Local implementation which reads resources from individual files.  Could be
  * more elegant and read from bios.bin, if we understood the fmap.
  */
-int vb2ex_read_resource(struct vb2_context *c,
-			enum vb2_resource_index index,
-			uint32_t offset,
-			void *buf,
-			uint32_t size)
+vb2_error_t vb2ex_read_resource(struct vb2_context *c,
+				enum vb2_resource_index index, uint32_t offset,
+				void *buf, uint32_t size)
 {
 	const char *fname;
 	FILE *f;
@@ -60,7 +58,7 @@ int vb2ex_read_resource(struct vb2_context *c,
 	return got_size == size ? VB2_SUCCESS : VB2_ERROR_UNKNOWN;
 }
 
-int vb2ex_tpm_clear_owner(struct vb2_context *c)
+vb2_error_t vb2ex_tpm_clear_owner(struct vb2_context *c)
 {
 	// TODO: implement
 	return VB2_SUCCESS;
@@ -86,13 +84,13 @@ static void save_if_needed(struct vb2_context *c)
 /**
  * Verify firmware body
  */
-static int hash_body(struct vb2_context *c)
+static vb2_error_t hash_body(struct vb2_context *c)
 {
 	uint32_t expect_size;
 	uint8_t block[8192];
 	uint32_t size;
 	FILE *f;
-	int rv;
+	vb2_error_t rv;
 
 	/* Open the body data */
 	f = fopen(body_fname, "rb");
@@ -148,7 +146,7 @@ int main(int argc, char *argv[])
 {
 	struct vb2_context ctx;
 	uint8_t workbuf[16384] __attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
-	int rv;
+	vb2_error_t rv;
 
 	if (argc < 4) {
 		print_help(argv[0]);
diff --git a/tests/vb21_api_tests.c b/tests/vb21_api_tests.c
index cbe61086..53177957 100644
--- a/tests/vb21_api_tests.c
+++ b/tests/vb21_api_tests.c
@@ -50,9 +50,9 @@ static enum {
 
 static struct vb2_digest_context hwcrypto_emulation_dc;
 
-static int retval_hwcrypto;
-static int retval_vb21_load_fw_keyblock;
-static int retval_vb21_load_fw_preamble;
+static vb2_error_t retval_hwcrypto;
+static vb2_error_t retval_vb21_load_fw_keyblock;
+static vb2_error_t retval_vb21_load_fw_preamble;
 
 /* Type of test to reset for */
 enum reset_type {
@@ -124,18 +124,18 @@ static void reset_common_data(enum reset_type t)
 
 /* Mocked functions */
 
-int vb21_load_fw_keyblock(struct vb2_context *c)
+vb2_error_t vb21_load_fw_keyblock(struct vb2_context *c)
 {
 	return retval_vb21_load_fw_keyblock;
 }
 
-int vb21_load_fw_preamble(struct vb2_context *c)
+vb2_error_t vb21_load_fw_preamble(struct vb2_context *c)
 {
 	return retval_vb21_load_fw_preamble;
 }
 
-int vb2ex_hwcrypto_digest_init(enum vb2_hash_algorithm hash_alg,
-			       uint32_t data_size)
+vb2_error_t vb2ex_hwcrypto_digest_init(enum vb2_hash_algorithm hash_alg,
+				       uint32_t data_size)
 {
 	vb2_digest_init(&hwcrypto_emulation_dc, hash_alg);
 
@@ -153,8 +153,7 @@ int vb2ex_hwcrypto_digest_init(enum vb2_hash_algorithm hash_alg,
 	}
 }
 
-int vb2ex_hwcrypto_digest_extend(const uint8_t *buf,
-				 uint32_t size)
+vb2_error_t vb2ex_hwcrypto_digest_extend(const uint8_t *buf, uint32_t size)
 {
 	vb2_digest_extend(&hwcrypto_emulation_dc, buf, size);
 
@@ -164,8 +163,8 @@ int vb2ex_hwcrypto_digest_extend(const uint8_t *buf,
 	return retval_hwcrypto;
 }
 
-int vb2ex_hwcrypto_digest_finalize(uint8_t *digest,
-				   uint32_t digest_size)
+vb2_error_t vb2ex_hwcrypto_digest_finalize(uint8_t *digest,
+					   uint32_t digest_size)
 {
 	vb2_digest_finalize(&hwcrypto_emulation_dc, digest, digest_size);
 
diff --git a/tests/vb21_misc_tests.c b/tests/vb21_misc_tests.c
index db7cd775..37c0ea3a 100644
--- a/tests/vb21_misc_tests.c
+++ b/tests/vb21_misc_tests.c
@@ -126,11 +126,9 @@ struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
 	return &gbb;
 }
 
-int vb2ex_read_resource(struct vb2_context *c,
-			enum vb2_resource_index index,
-			uint32_t offset,
-			void *buf,
-			uint32_t size)
+vb2_error_t vb2ex_read_resource(struct vb2_context *c,
+				enum vb2_resource_index index, uint32_t offset,
+				void *buf, uint32_t size)
 {
 	uint8_t *rptr;
 	uint32_t rsize;
@@ -158,25 +156,23 @@ int vb2ex_read_resource(struct vb2_context *c,
 	return VB2_SUCCESS;
 }
 
-int vb21_unpack_key(struct vb2_public_key *key,
-		    const uint8_t *buf,
-		    uint32_t size)
+vb2_error_t vb21_unpack_key(struct vb2_public_key *key, const uint8_t *buf,
+			    uint32_t size)
 {
 	return mock_unpack_key_retval;
 }
 
-int vb21_verify_keyblock(struct vb21_keyblock *block,
-			 uint32_t size,
-			 const struct vb2_public_key *key,
-			 const struct vb2_workbuf *wb)
+vb2_error_t vb21_verify_keyblock(struct vb21_keyblock *block, uint32_t size,
+				 const struct vb2_public_key *key,
+				 const struct vb2_workbuf *wb)
 {
 	return mock_verify_keyblock_retval;
 }
 
-int vb21_verify_fw_preamble(struct vb21_fw_preamble *preamble,
-			    uint32_t size,
-			    const struct vb2_public_key *key,
-			    const struct vb2_workbuf *wb)
+vb2_error_t vb21_verify_fw_preamble(struct vb21_fw_preamble *preamble,
+				    uint32_t size,
+				    const struct vb2_public_key *key,
+				    const struct vb2_workbuf *wb)
 {
 	return mock_verify_preamble_retval;
 }
diff --git a/tests/vb2_api_tests.c b/tests/vb2_api_tests.c
index 144102a6..b4db22b8 100644
--- a/tests/vb2_api_tests.c
+++ b/tests/vb2_api_tests.c
@@ -36,10 +36,10 @@ static const uint8_t mock_hwid_digest[VB2_GBB_HWID_DIGEST_SIZE] = {
 
 /* Mocked function data */
 static int force_dev_mode;
-static int retval_vb2_fw_parse_gbb;
-static int retval_vb2_check_dev_switch;
-static int retval_vb2_check_tpm_clear;
-static int retval_vb2_select_fw_slot;
+static vb2_error_t retval_vb2_fw_parse_gbb;
+static vb2_error_t retval_vb2_check_dev_switch;
+static vb2_error_t retval_vb2_check_tpm_clear;
+static vb2_error_t retval_vb2_select_fw_slot;
 
 /* Type of test to reset for */
 enum reset_type {
@@ -78,24 +78,24 @@ struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
 	return &gbb;
 }
 
-int vb2_fw_parse_gbb(struct vb2_context *c)
+vb2_error_t vb2_fw_parse_gbb(struct vb2_context *c)
 {
 	return retval_vb2_fw_parse_gbb;
 }
 
-int vb2_check_dev_switch(struct vb2_context *c)
+vb2_error_t vb2_check_dev_switch(struct vb2_context *c)
 {
 	if (force_dev_mode)
 		sd->flags |= VB2_SD_FLAG_DEV_MODE_ENABLED;
 	return retval_vb2_check_dev_switch;
 }
 
-int vb2_check_tpm_clear(struct vb2_context *c)
+vb2_error_t vb2_check_tpm_clear(struct vb2_context *c)
 {
 	return retval_vb2_check_tpm_clear;
 }
 
-int vb2_select_fw_slot(struct vb2_context *c)
+vb2_error_t vb2_select_fw_slot(struct vb2_context *c)
 {
 	return retval_vb2_select_fw_slot;
 }
diff --git a/tests/vb2_gbb_tests.c b/tests/vb2_gbb_tests.c
index a7ff9b35..92d617aa 100644
--- a/tests/vb2_gbb_tests.c
+++ b/tests/vb2_gbb_tests.c
@@ -62,11 +62,9 @@ struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
 	return gbb;
 }
 
-int vb2ex_read_resource(struct vb2_context *c,
-			enum vb2_resource_index index,
-			uint32_t offset,
-			void *buf,
-			uint32_t size)
+vb2_error_t vb2ex_read_resource(struct vb2_context *c,
+				enum vb2_resource_index index, uint32_t offset,
+				void *buf, uint32_t size)
 {
 	uint8_t *rptr;
 	uint32_t rsize;
diff --git a/tests/vb2_misc_tests.c b/tests/vb2_misc_tests.c
index 85a6e697..a9f82531 100644
--- a/tests/vb2_misc_tests.c
+++ b/tests/vb2_misc_tests.c
@@ -57,11 +57,9 @@ struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
 	return &gbb;
 }
 
-int vb2ex_read_resource(struct vb2_context *c,
-			enum vb2_resource_index index,
-			uint32_t offset,
-			void *buf,
-			uint32_t size)
+vb2_error_t vb2ex_read_resource(struct vb2_context *c,
+				enum vb2_resource_index index, uint32_t offset,
+				void *buf, uint32_t size)
 {
 	if (index != mock_resource_index)
 		return VB2_ERROR_EX_READ_RESOURCE_INDEX;
@@ -73,7 +71,7 @@ int vb2ex_read_resource(struct vb2_context *c,
 	return VB2_SUCCESS;
 }
 
-int vb2ex_tpm_clear_owner(struct vb2_context *c)
+vb2_error_t vb2ex_tpm_clear_owner(struct vb2_context *c)
 {
 	mock_tpm_clear_called++;
 
diff --git a/tests/vboot_api_kernel2_tests.c b/tests/vboot_api_kernel2_tests.c
index f37913c4..56e8727a 100644
--- a/tests/vboot_api_kernel2_tests.c
+++ b/tests/vboot_api_kernel2_tests.c
@@ -180,7 +180,7 @@ uint32_t VbExGetSwitches(uint32_t request_mask)
 	return result;
 }
 
-int VbExLegacy(enum VbAltFwIndex_t _altfw_num)
+vb2_error_t VbExLegacy(enum VbAltFwIndex_t _altfw_num)
 {
 	vbexlegacy_called++;
 	altfw_num = _altfw_num;
@@ -234,7 +234,7 @@ int vb2_audio_looping(void)
 	return 1;
 }
 
-uint32_t VbTryLoadKernel(struct vb2_context *c, uint32_t get_info_flags)
+vb2_error_t VbTryLoadKernel(struct vb2_context *c, uint32_t get_info_flags)
 {
 	return vbtlk_retval + get_info_flags;
 }
@@ -248,7 +248,7 @@ vb2_error_t VbDisplayScreen(struct vb2_context *c, uint32_t screen, int force,
 	return VBERROR_SUCCESS;
 }
 
-uint32_t SetVirtualDevMode(int val)
+vb2_error_t SetVirtualDevMode(int val)
 {
 	virtdev_set = val;
 	return virtdev_retval;
@@ -262,7 +262,7 @@ vb2_error_t VbExSetVendorData(const char *vendor_data_value)
 	return VBERROR_SUCCESS;
 }
 
-int vb2ex_tpm_set_mode(enum vb2_tpm_mode mode_val)
+vb2_error_t vb2ex_tpm_set_mode(enum vb2_tpm_mode mode_val)
 {
 	tpm_set_mode_called = 1;
 	/*
diff --git a/tests/vboot_api_kernel4_tests.c b/tests/vboot_api_kernel4_tests.c
index e466baf9..8ed46200 100644
--- a/tests/vboot_api_kernel4_tests.c
+++ b/tests/vboot_api_kernel4_tests.c
@@ -127,7 +127,7 @@ uint32_t RollbackFwmpRead(struct RollbackSpaceFwmp *fwmp)
 	return rfr_retval;
 }
 
-uint32_t VbTryLoadKernel(struct vb2_context *c, uint32_t get_info_flags)
+vb2_error_t VbTryLoadKernel(struct vb2_context *c, uint32_t get_info_flags)
 {
 	shared->kernel_version_tpm = new_version;
 
@@ -182,7 +182,7 @@ uint32_t VbExGetSwitches(uint32_t request_mask)
 		return 0;
 }
 
-int vb2ex_tpm_set_mode(enum vb2_tpm_mode mode_val)
+vb2_error_t vb2ex_tpm_set_mode(enum vb2_tpm_mode mode_val)
 {
 	return VB2_SUCCESS;
 }
diff --git a/tests/vboot_api_kernel5_tests.c b/tests/vboot_api_kernel5_tests.c
index 1f4e6cd9..a0833fd9 100644
--- a/tests/vboot_api_kernel5_tests.c
+++ b/tests/vboot_api_kernel5_tests.c
@@ -114,37 +114,32 @@ struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
 	return &gbb;
 }
 
-int vb2ex_read_resource(struct vb2_context *c,
-			enum vb2_resource_index index,
-			uint32_t offset,
-			void *buf,
-			uint32_t size)
+vb2_error_t vb2ex_read_resource(struct vb2_context *c,
+				enum vb2_resource_index index, uint32_t offset,
+				void *buf, uint32_t size)
 {
 	memset(buf, 0, size);
 	return VB2_SUCCESS;
 }
 
-int vb2_gbb_read_root_key(struct vb2_context *c,
-			  struct vb2_packed_key **keyp,
-			  uint32_t *size,
-			  struct vb2_workbuf *wb)
+vb2_error_t vb2_gbb_read_root_key(struct vb2_context *c,
+				  struct vb2_packed_key **keyp, uint32_t *size,
+				  struct vb2_workbuf *wb)
 {
 	*keyp = &mock_key;
 	return VB2_SUCCESS;
 }
 
-int vb2_gbb_read_recovery_key(struct vb2_context *c,
-			      struct vb2_packed_key **keyp,
-			      uint32_t *size,
-			      struct vb2_workbuf *wb)
+vb2_error_t vb2_gbb_read_recovery_key(struct vb2_context *c,
+				      struct vb2_packed_key **keyp,
+				      uint32_t *size, struct vb2_workbuf *wb)
 {
 	*keyp = &mock_key;
 	return VB2_SUCCESS;
 }
 
-int vb2_unpack_key_buffer(struct vb2_public_key *key,
-		   const uint8_t *buf,
-		   uint32_t size)
+vb2_error_t vb2_unpack_key_buffer(struct vb2_public_key *key,
+				  const uint8_t *buf, uint32_t size)
 {
 	if (--unpack_key_fail == 0)
 		return VB2_ERROR_MOCK;
@@ -152,10 +147,9 @@ int vb2_unpack_key_buffer(struct vb2_public_key *key,
 	return VB2_SUCCESS;
 }
 
-int vb2_verify_keyblock(struct vb2_keyblock *block,
-			uint32_t size,
-			const struct vb2_public_key *key,
-			const struct vb2_workbuf *wb)
+vb2_error_t vb2_verify_keyblock(struct vb2_keyblock *block, uint32_t size,
+				const struct vb2_public_key *key,
+				const struct vb2_workbuf *wb)
 {
 	hash_only_check = 0;
 
@@ -167,9 +161,9 @@ int vb2_verify_keyblock(struct vb2_keyblock *block,
 	return VB2_SUCCESS;
 }
 
-int vb2_verify_keyblock_hash(const struct vb2_keyblock *block,
-			     uint32_t size,
-			     const struct vb2_workbuf *wb)
+vb2_error_t vb2_verify_keyblock_hash(const struct vb2_keyblock *block,
+				     uint32_t size,
+				     const struct vb2_workbuf *wb)
 {
 	hash_only_check = 1;
 
@@ -181,10 +175,10 @@ int vb2_verify_keyblock_hash(const struct vb2_keyblock *block,
 	return VB2_SUCCESS;
 }
 
-int vb2_verify_kernel_preamble(struct vb2_kernel_preamble *preamble,
-			       uint32_t size,
-			       const struct vb2_public_key *key,
-			       const struct vb2_workbuf *wb)
+vb2_error_t vb2_verify_kernel_preamble(struct vb2_kernel_preamble *preamble,
+				       uint32_t size,
+				       const struct vb2_public_key *key,
+				       const struct vb2_workbuf *wb)
 {
 	if (preamble_verify_fail)
 		return VB2_ERROR_MOCK;
@@ -194,11 +188,10 @@ int vb2_verify_kernel_preamble(struct vb2_kernel_preamble *preamble,
 	return VB2_SUCCESS;
 }
 
-int vb2_verify_data(const uint8_t *data,
-		    uint32_t size,
-		    struct vb2_signature *sig,
-		    const struct vb2_public_key *key,
-		    const struct vb2_workbuf *wb)
+vb2_error_t vb2_verify_data(const uint8_t *data, uint32_t size,
+			    struct vb2_signature *sig,
+			    const struct vb2_public_key *key,
+			    const struct vb2_workbuf *wb)
 {
 	if (verify_data_fail)
 		return VB2_ERROR_MOCK;
diff --git a/tests/vboot_api_kernel6_tests.c b/tests/vboot_api_kernel6_tests.c
index dde977b3..7e2a7d40 100644
--- a/tests/vboot_api_kernel6_tests.c
+++ b/tests/vboot_api_kernel6_tests.c
@@ -27,7 +27,7 @@ static void ResetMocks(void)
 }
 
 /* Mocks */
-uint32_t SetVirtualDevMode(int val)
+vb2_error_t SetVirtualDevMode(int val)
 {
 	if (virtual_dev_mode_fail)
 		return VBERROR_SIMULATED;
diff --git a/tests/vboot_detach_menu_tests.c b/tests/vboot_detach_menu_tests.c
index cba297b8..37ab65ff 100644
--- a/tests/vboot_detach_menu_tests.c
+++ b/tests/vboot_detach_menu_tests.c
@@ -176,7 +176,7 @@ uint32_t VbExGetSwitches(uint32_t request_mask)
 		return 0;
 }
 
-int VbExLegacy(enum VbAltFwIndex_t _altfw_num)
+vb2_error_t VbExLegacy(enum VbAltFwIndex_t _altfw_num)
 {
 	vbexlegacy_called++;
 	altfw_num = _altfw_num;
@@ -247,7 +247,7 @@ vb2_error_t VbExBeep(uint32_t msec, uint32_t frequency)
 	return VBERROR_SUCCESS;
 }
 
-uint32_t SetVirtualDevMode(int val)
+vb2_error_t SetVirtualDevMode(int val)
 {
 	virtdev_set = val;
 	return virtdev_retval;
diff --git a/tests/vboot_kernel_tests.c b/tests/vboot_kernel_tests.c
index 56efbf36..ad0a9f6d 100644
--- a/tests/vboot_kernel_tests.c
+++ b/tests/vboot_kernel_tests.c
@@ -193,36 +193,32 @@ struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
 	return &gbb;
 }
 
-int vb2ex_read_resource(struct vb2_context *c,
-			enum vb2_resource_index index,
-			uint32_t offset,
-			void *buf,
-			uint32_t size)
+vb2_error_t vb2ex_read_resource(struct vb2_context *c,
+				enum vb2_resource_index index, uint32_t offset,
+				void *buf, uint32_t size)
 {
 	memset(buf, 0, size);
 	return VB2_SUCCESS;
 }
 
-int vb2_gbb_read_root_key(struct vb2_context *c,
-			  struct vb2_packed_key **keyp,
-			  uint32_t *size,
-			  struct vb2_workbuf *wb)
+vb2_error_t vb2_gbb_read_root_key(struct vb2_context *c,
+				  struct vb2_packed_key **keyp, uint32_t *size,
+				  struct vb2_workbuf *wb)
 {
 	*keyp = &mock_key;
 	return VB2_SUCCESS;
 }
 
-int vb2_gbb_read_recovery_key(struct vb2_context *c,
-			      struct vb2_packed_key **keyp,
-			      uint32_t *size,
-			      struct vb2_workbuf *wb)
+vb2_error_t vb2_gbb_read_recovery_key(struct vb2_context *c,
+				      struct vb2_packed_key **keyp,
+				      uint32_t *size, struct vb2_workbuf *wb)
 {
 	*keyp = &mock_key;
 	return VB2_SUCCESS;
 }
 
 vb2_error_t VbExDiskRead(VbExDiskHandle_t h, uint64_t lba_start,
-		       uint64_t lba_count, void *buffer)
+			 uint64_t lba_count, void *buffer)
 {
 	LOGCALL("VbExDiskRead(h, %d, %d)\n", (int)lba_start, (int)lba_count);
 
@@ -236,7 +232,7 @@ vb2_error_t VbExDiskRead(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)
+			  uint64_t lba_count, const void *buffer)
 {
 	LOGCALL("VbExDiskWrite(h, %d, %d)\n", (int)lba_start, (int)lba_count);
 
@@ -278,9 +274,8 @@ void GetCurrentKernelUniqueGuid(GptData *gpt, void *dest)
 	memcpy(dest, fake_guid, sizeof(fake_guid));
 }
 
-int vb2_unpack_key_buffer(struct vb2_public_key *key,
-		   const uint8_t *buf,
-		   uint32_t size)
+vb2_error_t vb2_unpack_key_buffer(struct vb2_public_key *key,
+				  const uint8_t *buf, uint32_t size)
 {
 	if (--unpack_key_fail == 0)
 		return VB2_ERROR_MOCK;
@@ -288,10 +283,9 @@ int vb2_unpack_key_buffer(struct vb2_public_key *key,
 	return VB2_SUCCESS;
 }
 
-int vb2_verify_keyblock(struct vb2_keyblock *block,
-			uint32_t size,
-			const struct vb2_public_key *key,
-			const struct vb2_workbuf *wb)
+vb2_error_t vb2_verify_keyblock(struct vb2_keyblock *block, uint32_t size,
+				const struct vb2_public_key *key,
+				const struct vb2_workbuf *wb)
 {
 	if (key_block_verify_fail >= 1)
 		return VB2_ERROR_MOCK;
@@ -301,9 +295,9 @@ int vb2_verify_keyblock(struct vb2_keyblock *block,
 	return VB2_SUCCESS;
 }
 
-int vb2_verify_keyblock_hash(const struct vb2_keyblock *block,
-			     uint32_t size,
-			     const struct vb2_workbuf *wb)
+vb2_error_t vb2_verify_keyblock_hash(const struct vb2_keyblock *block,
+				     uint32_t size,
+				     const struct vb2_workbuf *wb)
 {
 	if (key_block_verify_fail >= 2)
 		return VB2_ERROR_MOCK;
@@ -313,9 +307,8 @@ int vb2_verify_keyblock_hash(const struct vb2_keyblock *block,
 	return VB2_SUCCESS;
 }
 
-int vb2_verify_kernel_preamble(struct vb2_kernel_preamble *preamble,
-			       uint32_t size,
-			       const struct vb2_public_key *key,
+vb2_error_t vb2_verify_kernel_preamble(struct vb2_kernel_preamble *preamble,
+			       uint32_t size, const struct vb2_public_key *key,
 			       const struct vb2_workbuf *wb)
 {
 	if (preamble_verify_fail)
@@ -326,11 +319,10 @@ int vb2_verify_kernel_preamble(struct vb2_kernel_preamble *preamble,
 	return VB2_SUCCESS;
 }
 
-int vb2_verify_data(const uint8_t *data,
-		    uint32_t size,
-		    struct vb2_signature *sig,
-		    const struct vb2_public_key *key,
-		    const struct vb2_workbuf *wb)
+vb2_error_t vb2_verify_data(const uint8_t *data, uint32_t size,
+			    struct vb2_signature *sig,
+			    const struct vb2_public_key *key,
+			    const struct vb2_workbuf *wb)
 {
 	if (verify_data_fail)
 		return VB2_ERROR_MOCK;
@@ -338,11 +330,9 @@ int vb2_verify_data(const uint8_t *data,
 	return VB2_SUCCESS;
 }
 
-int vb2_digest_buffer(const uint8_t *buf,
-		      uint32_t size,
-		      enum vb2_hash_algorithm hash_alg,
-		      uint8_t *digest,
-		      uint32_t digest_size)
+vb2_error_t vb2_digest_buffer(const uint8_t *buf, uint32_t size,
+			      enum vb2_hash_algorithm hash_alg, uint8_t *digest,
+			      uint32_t digest_size)
 {
 	memcpy(digest, mock_digest, sizeof(mock_digest));
 	return VB2_SUCCESS;
diff --git a/tests/verify_kernel.c b/tests/verify_kernel.c
index 269fe733..4f6f2bb3 100644
--- a/tests/verify_kernel.c
+++ b/tests/verify_kernel.c
@@ -27,7 +27,7 @@ static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
 static LoadKernelParams params;
 
 vb2_error_t VbExDiskRead(VbExDiskHandle_t handle, uint64_t lba_start,
-		       uint64_t lba_count, void *buffer)
+			 uint64_t lba_count, void *buffer)
 {
 	if (handle != (VbExDiskHandle_t)1)
 		return VBERROR_UNKNOWN;
@@ -41,7 +41,7 @@ vb2_error_t VbExDiskRead(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)
+			  uint64_t lba_count, const void *buffer)
 {
 	if (handle != (VbExDiskHandle_t)1)
 		return VBERROR_UNKNOWN;
@@ -64,7 +64,7 @@ int main(int argc, char *argv[])
 {
 	struct vb2_packed_key *kernkey;
 	uint64_t disk_bytes = 0;
-	int rv;
+	vb2_error_t rv;
 
 	if (argc < 3) {
 		print_help(argv[0]);