vboot: pull vb2_context up to higher level in call stack

The original purpose of vb2_context is to provide one shared
state object through the entirety of one particular application.
Pull the creation of vb2_context up to a higher level in order to
work towards this goal.

BUG=b:124141368
TEST=/work/vboot/src/repohooks/pre-upload.py
TEST=make clean && make runtests
TEST=make clean && COV=1 make coverage && make coverage_html
CQ-DEPEND=CL:1517179
BRANCH=none

Change-Id: I7c454afddb2b525895d9945b081b14b29100892c
Signed-off-by: Joel Kitching <kitching@google.com>
Reviewed-on: https://chromium-review.googlesource.com/1517061
Commit-Ready: ChromeOS CL Exonerator Bot <chromiumos-cl-exonerator@appspot.gserviceaccount.com>
Tested-by: Joel Kitching <kitching@chromium.org>
Reviewed-by: Joel Kitching <kitching@chromium.org>

5 files changed, 83 insertions, 82 deletions

diff --git a/firmware/include/vboot_api.h b/firmware/include/vboot_api.h
index 6202fe91..21ac36b4 100644
--- a/firmware/include/vboot_api.h
+++ b/firmware/include/vboot_api.h
@@ -30,6 +30,8 @@
 extern "C" {
 #endif  /* __cplusplus */
 
+struct vb2_context;
+
 /*****************************************************************************/
 /* Error codes */
 
@@ -319,7 +321,8 @@ typedef struct VbSelectAndLoadKernelParams {
  *
  * Returns VBERROR_SUCCESS if success, non-zero if error; on error, caller
  * should reboot. */
-VbError_t VbSelectAndLoadKernel(VbCommonParams *cparams,
+VbError_t VbSelectAndLoadKernel(struct vb2_context *ctx,
+				VbCommonParams *cparams,
 				VbSelectAndLoadKernelParams *kparams);
 
 /**
@@ -331,6 +334,7 @@ VbError_t VbSelectAndLoadKernel(VbCommonParams *cparams,
  * override to allow full fastboot functionality, it checks image integrity, but
  * does not check the image signature.
  *
+ * @param ctx		Vboot context
  * @param cparams	Common parameters, e.g. use member caller_context
  *			to point to useful context data
  * @param kparams	kernel params
@@ -338,7 +342,8 @@ VbError_t VbSelectAndLoadKernel(VbCommonParams *cparams,
  * @param image_size	Size of the image in memory
  * @return VBERROR_... error, VBERROR_SUCCESS on success.
  */
-VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams,
+VbError_t VbVerifyMemoryBootImage(struct vb2_context *ctx,
+				  VbCommonParams *cparams,
 				  VbSelectAndLoadKernelParams *kparams,
 				  void *boot_image,
 				  size_t image_size);
diff --git a/firmware/lib/vboot_api_kernel.c b/firmware/lib/vboot_api_kernel.c
index 78f35744..c08ca131 100644
--- a/firmware/lib/vboot_api_kernel.c
+++ b/firmware/lib/vboot_api_kernel.c
@@ -26,7 +26,6 @@
 /* Global variables */
 static struct RollbackSpaceFwmp fwmp;
 static LoadKernelParams lkp;
-static struct vb2_context ctx;
 static uint8_t *unaligned_workbuf;
 
 #ifdef CHROMEOS_ENVIRONMENT
@@ -221,7 +220,8 @@ VbError_t VbBootNormal(struct vb2_context *ctx)
 	return rv;
 }
 
-static VbError_t vb2_kernel_setup(VbCommonParams *cparams,
+static VbError_t vb2_kernel_setup(struct vb2_context *ctx,
+				  VbCommonParams *cparams,
 				  VbSelectAndLoadKernelParams *kparams)
 {
 	VbSharedDataHeader *shared =
@@ -230,19 +230,11 @@ static VbError_t vb2_kernel_setup(VbCommonParams *cparams,
 	/* Start timer */
 	shared->timer_vb_select_and_load_kernel_enter = VbExGetTimer();
 
-	/*
-	 * Set up vboot context.
-	 *
-	 * TODO: Propagate this up to higher API levels, and use more of the
-	 * context fields (e.g. secdatak) and flags.
-	 */
-	memset(&ctx, 0, sizeof(ctx));
-
 	/* Translate vboot1 flags back to vboot2 */
 	if (shared->recovery_reason)
-		ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+		ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
 	if (shared->flags & VBSD_BOOT_DEV_SWITCH_ON)
-		ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
+		ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
 
 	/*
 	 * The following flags are set by depthcharge.
@@ -252,43 +244,43 @@ static VbError_t vb2_kernel_setup(VbCommonParams *cparams,
 	 * features that won't be used in an image could be compiled out.
 	 */
 	if (shared->flags & VBSD_EC_SOFTWARE_SYNC)
-		ctx.flags |= VB2_CONTEXT_EC_SYNC_SUPPORTED;
+		ctx->flags |= VB2_CONTEXT_EC_SYNC_SUPPORTED;
 	if (shared->flags & VBSD_EC_SLOW_UPDATE)
-		ctx.flags |= VB2_CONTEXT_EC_SYNC_SLOW;
+		ctx->flags |= VB2_CONTEXT_EC_SYNC_SLOW;
 	if (shared->flags & VBSD_EC_EFS)
-		ctx.flags |= VB2_CONTEXT_EC_EFS;
+		ctx->flags |= VB2_CONTEXT_EC_EFS;
 	if (shared->flags & VBSD_NVDATA_V2)
-		ctx.flags |= VB2_CONTEXT_NVDATA_V2;
+		ctx->flags |= VB2_CONTEXT_NVDATA_V2;
 
-	VbExNvStorageRead(ctx.nvdata);
-	vb2_nv_init(&ctx);
+	VbExNvStorageRead(ctx->nvdata);
+	vb2_nv_init(ctx);
 
-	ctx.workbuf_size = VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE +
-			VB2_WORKBUF_ALIGN;
+	ctx->workbuf_size = VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE +
+			    VB2_WORKBUF_ALIGN;
 
-	unaligned_workbuf = ctx.workbuf = malloc(ctx.workbuf_size);
+	unaligned_workbuf = ctx->workbuf = malloc(ctx->workbuf_size);
 	if (!unaligned_workbuf) {
 		VB2_DEBUG("Can't allocate work buffer\n");
-		VbSetRecoveryRequest(&ctx, VB2_RECOVERY_RW_SHARED_DATA);
+		VbSetRecoveryRequest(ctx, VB2_RECOVERY_RW_SHARED_DATA);
 		return VBERROR_INIT_SHARED_DATA;
 	}
 
-	if (VB2_SUCCESS != vb2_align(&ctx.workbuf, &ctx.workbuf_size,
+	if (VB2_SUCCESS != vb2_align(&ctx->workbuf, &ctx->workbuf_size,
 				     VB2_WORKBUF_ALIGN,
 				     VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE)) {
 		VB2_DEBUG("Can't align work buffer\n");
-		VbSetRecoveryRequest(&ctx, VB2_RECOVERY_RW_SHARED_DATA);
+		VbSetRecoveryRequest(ctx, VB2_RECOVERY_RW_SHARED_DATA);
 		return VBERROR_INIT_SHARED_DATA;
 	}
 
-	if (VB2_SUCCESS != vb2_init_context(&ctx)) {
+	if (VB2_SUCCESS != vb2_init_context(ctx)) {
 		VB2_DEBUG("Can't init vb2_context\n");
 		free(unaligned_workbuf);
-		VbSetRecoveryRequest(&ctx, VB2_RECOVERY_RW_SHARED_DATA);
+		VbSetRecoveryRequest(ctx, VB2_RECOVERY_RW_SHARED_DATA);
 		return VBERROR_INIT_SHARED_DATA;
 	}
 
-	struct vb2_shared_data *sd = vb2_get_sd(&ctx);
+	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	sd->recovery_reason = shared->recovery_reason;
 
 	/*
@@ -330,8 +322,8 @@ static VbError_t vb2_kernel_setup(VbCommonParams *cparams,
 	/* Read kernel version from the TPM.  Ignore errors in recovery mode. */
 	if (RollbackKernelRead(&shared->kernel_version_tpm)) {
 		VB2_DEBUG("Unable to get kernel versions from TPM\n");
-		if (!(ctx.flags & VB2_CONTEXT_RECOVERY_MODE)) {
-			VbSetRecoveryRequest(&ctx, VB2_RECOVERY_RW_TPM_R_ERROR);
+		if (!(ctx->flags & VB2_CONTEXT_RECOVERY_MODE)) {
+			VbSetRecoveryRequest(ctx, VB2_RECOVERY_RW_TPM_R_ERROR);
 			return VBERROR_TPM_READ_KERNEL;
 		}
 	}
@@ -343,8 +335,8 @@ static VbError_t vb2_kernel_setup(VbCommonParams *cparams,
 		memset(&fwmp, 0, sizeof(fwmp));
 	} else if (RollbackFwmpRead(&fwmp)) {
 		VB2_DEBUG("Unable to get FWMP from TPM\n");
-		if (!(ctx.flags & VB2_CONTEXT_RECOVERY_MODE)) {
-			VbSetRecoveryRequest(&ctx, VB2_RECOVERY_RW_TPM_R_ERROR);
+		if (!(ctx->flags & VB2_CONTEXT_RECOVERY_MODE)) {
+			VbSetRecoveryRequest(ctx, VB2_RECOVERY_RW_TPM_R_ERROR);
 			return VBERROR_TPM_READ_FWMP;
 		}
 	}
@@ -352,9 +344,10 @@ static VbError_t vb2_kernel_setup(VbCommonParams *cparams,
 	return VBERROR_SUCCESS;
 }
 
-static VbError_t vb2_kernel_phase4(VbSelectAndLoadKernelParams *kparams)
+static VbError_t vb2_kernel_phase4(struct vb2_context *ctx,
+				   VbSelectAndLoadKernelParams *kparams)
 {
-	struct vb2_shared_data *sd = vb2_get_sd(&ctx);
+	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 
 	/* Save disk parameters */
 	kparams->disk_handle = lkp.disk_handle;
@@ -368,10 +361,10 @@ static VbError_t vb2_kernel_phase4(VbSelectAndLoadKernelParams *kparams)
 	       sizeof(kparams->partition_guid));
 
 	/* Lock the kernel versions if not in recovery mode */
-	if (!(ctx.flags & VB2_CONTEXT_RECOVERY_MODE) &&
+	if (!(ctx->flags & VB2_CONTEXT_RECOVERY_MODE) &&
 	    RollbackKernelLock(sd->recovery_reason)) {
 		VB2_DEBUG("Error locking kernel versions.\n");
-		VbSetRecoveryRequest(&ctx, VB2_RECOVERY_RW_TPM_L_ERROR);
+		VbSetRecoveryRequest(ctx, VB2_RECOVERY_RW_TPM_L_ERROR);
 		return VBERROR_TPM_LOCK_KERNEL;
 	}
 
@@ -406,10 +399,12 @@ static void vb2_kernel_cleanup(struct vb2_context *ctx, VbCommonParams *cparams)
 	cparams->shared_data_size = shared->data_used;
 }
 
-VbError_t VbSelectAndLoadKernel(VbCommonParams *cparams,
-				VbSelectAndLoadKernelParams *kparams)
+VbError_t VbSelectAndLoadKernel(
+	struct vb2_context *ctx,
+	VbCommonParams *cparams,
+	VbSelectAndLoadKernelParams *kparams)
 {
-	VbError_t retval = vb2_kernel_setup(cparams, kparams);
+	VbError_t retval = vb2_kernel_setup(ctx, cparams, kparams);
 	if (retval)
 		goto VbSelectAndLoadKernel_exit;
 
@@ -417,25 +412,25 @@ VbError_t VbSelectAndLoadKernel(VbCommonParams *cparams,
 	 * Do EC software sync unless we're in recovery mode. This has UI but
 	 * it's just a single non-interactive WAIT screen.
 	 */
-	if (!(ctx.flags & VB2_CONTEXT_RECOVERY_MODE)) {
-		retval = ec_sync_all(&ctx);
+	if (!(ctx->flags & VB2_CONTEXT_RECOVERY_MODE)) {
+		retval = ec_sync_all(ctx);
 		if (retval)
 			goto VbSelectAndLoadKernel_exit;
 	}
 
 	/* Select boot path */
-	if (ctx.flags & VB2_CONTEXT_RECOVERY_MODE) {
+	if (ctx->flags & VB2_CONTEXT_RECOVERY_MODE) {
 		/* Recovery boot.  This has UI. */
 		if (kparams->inflags & VB_SALK_INFLAGS_ENABLE_DETACHABLE_UI)
-			retval = VbBootRecoveryMenu(&ctx);
+			retval = VbBootRecoveryMenu(ctx);
 		else
-			retval = VbBootRecovery(&ctx);
+			retval = VbBootRecovery(ctx);
 		VbExEcEnteringMode(0, VB_EC_RECOVERY);
-	} else if (DIAGNOSTIC_UI && vb2_nv_get(&ctx, VB2_NV_DIAG_REQUEST)) {
-		struct vb2_shared_data *sd = vb2_get_sd(&ctx);
+	} else if (DIAGNOSTIC_UI && vb2_nv_get(ctx, VB2_NV_DIAG_REQUEST)) {
+		struct vb2_shared_data *sd = vb2_get_sd(ctx);
 		if (sd->vbsd->flags & VBSD_OPROM_MATTERS)
-			vb2_nv_set(&ctx, VB2_NV_OPROM_NEEDED, 0);
-		vb2_nv_set(&ctx, VB2_NV_DIAG_REQUEST, 0);
+			vb2_nv_set(ctx, VB2_NV_OPROM_NEEDED, 0);
+		vb2_nv_set(ctx, VB2_NV_DIAG_REQUEST, 0);
 
 		/*
 		 * Diagnostic boot. This has a UI but only power button
@@ -443,7 +438,7 @@ VbError_t VbSelectAndLoadKernel(VbCommonParams *cparams,
 		 * This mode is also 1-shot so it's placed before developer
 		 * mode.
 		 */
-		retval = VbBootDiagnostic(&ctx);
+		retval = VbBootDiagnostic(ctx);
 		/*
 		 * The diagnostic menu should either boot a rom, or
 		 * return either of reboot or shutdown.  The following
@@ -452,38 +447,38 @@ VbError_t VbSelectAndLoadKernel(VbCommonParams *cparams,
 		if (!retval) {
 			retval = VBERROR_REBOOT_REQUIRED;
 		}
-	} else if (ctx.flags & VB2_CONTEXT_DEVELOPER_MODE) {
+	} else if (ctx->flags & VB2_CONTEXT_DEVELOPER_MODE) {
 		if (kparams->inflags & VB_SALK_INFLAGS_VENDOR_DATA_SETTABLE)
-			ctx.flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
+			ctx->flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
 
 		/* Developer boot.  This has UI. */
 		if (kparams->inflags & VB_SALK_INFLAGS_ENABLE_DETACHABLE_UI)
-			retval = VbBootDeveloperMenu(&ctx);
+			retval = VbBootDeveloperMenu(ctx);
 		else
-			retval = VbBootDeveloper(&ctx);
+			retval = VbBootDeveloper(ctx);
 		VbExEcEnteringMode(0, VB_EC_DEVELOPER);
 	} else {
 		/* Normal boot */
-		retval = VbBootNormal(&ctx);
+		retval = VbBootNormal(ctx);
 		VbExEcEnteringMode(0, VB_EC_NORMAL);
 	}
 
  VbSelectAndLoadKernel_exit:
 
 	if (VBERROR_SUCCESS == retval)
-		retval = vb2_kernel_phase4(kparams);
+		retval = vb2_kernel_phase4(ctx, kparams);
 
-	vb2_kernel_cleanup(&ctx, cparams);
+	vb2_kernel_cleanup(ctx, cparams);
 
 	/* Pass through return value from boot path */
 	VB2_DEBUG("Returning %d\n", (int)retval);
 	return retval;
 }
 
-VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams,
-				  VbSelectAndLoadKernelParams *kparams,
-				  void *boot_image,
-				  size_t image_size)
+VbError_t VbVerifyMemoryBootImage(
+	struct vb2_context *ctx, VbCommonParams *cparams,
+	VbSelectAndLoadKernelParams *kparams, void *boot_image,
+	size_t image_size)
 {
 	VbPublicKey* kernel_subkey = NULL;
 	uint8_t *kbuf;
@@ -495,11 +490,11 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams,
 	uint32_t allow_fastboot_full_cap = 0;
 	struct vb2_workbuf wb;
 
-	VbError_t retval = vb2_kernel_setup(cparams, kparams);
+	VbError_t retval = vb2_kernel_setup(ctx, cparams, kparams);
 	if (retval)
 		goto fail;
 
-	struct vb2_shared_data *sd = vb2_get_sd(&ctx);
+	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	VbSharedDataHeader *shared = sd->vbsd;
 
 	if ((boot_image == NULL) || (image_size == 0)) {
@@ -519,7 +514,7 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams,
 	 */
 	dev_switch = shared->flags & VBSD_BOOT_DEV_SWITCH_ON;
 	allow_fastboot_full_cap =
-			vb2_nv_get(&ctx, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP);
+			vb2_nv_get(ctx, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP);
 
 	if (0 == allow_fastboot_full_cap) {
 		allow_fastboot_full_cap = !!(sd->gbb_flags &
@@ -531,7 +526,7 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams,
 		hash_only = 1;
 	} else {
 		/* Get recovery key. */
-		retval = VbGbbReadRecoveryKey(&ctx, &kernel_subkey);
+		retval = VbGbbReadRecoveryKey(ctx, &kernel_subkey);
 		if (VBERROR_SUCCESS != retval) {
 			VB2_DEBUG("Gbb Read Recovery key failed.\n");
 			goto fail;
@@ -542,7 +537,7 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams,
 	retval = VBERROR_INVALID_KERNEL_FOUND;
 
 	/* Allocate work buffer */
-	vb2_workbuf_from_ctx(&ctx, &wb);
+	vb2_workbuf_from_ctx(ctx, &wb);
 
 	/* Verify the key block. */
 	key_block = (VbKeyBlockHeader *)kbuf;
@@ -631,7 +626,7 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams,
 	retval = VBERROR_SUCCESS;
 
  fail:
-	vb2_kernel_cleanup(&ctx, cparams);
+	vb2_kernel_cleanup(ctx, cparams);
 	if (NULL != kernel_subkey)
 		free(kernel_subkey);
 	return retval;
diff --git a/firmware/linktest/main.c b/firmware/linktest/main.c
index 8d6549ce..29bd9702 100644
--- a/firmware/linktest/main.c
+++ b/firmware/linktest/main.c
@@ -54,7 +54,7 @@ int main(void)
 #endif
 
 	/* vboot_api.h - entry points INTO vboot_reference */
-	VbSelectAndLoadKernel(0, 0);
+	VbSelectAndLoadKernel(0, 0, 0);
 
 	/* vboot_common.h */
 	OffsetOf(0, 0);
diff --git a/tests/vboot_api_kernel4_tests.c b/tests/vboot_api_kernel4_tests.c
index 2d7e04e1..fb27add8 100644
--- a/tests/vboot_api_kernel4_tests.c
+++ b/tests/vboot_api_kernel4_tests.c
@@ -162,7 +162,7 @@ VbError_t VbBootDiagnostic(struct vb2_context *ctx)
 
 static void test_slk(VbError_t retval, int recovery_reason, const char *desc)
 {
-	TEST_EQ(VbSelectAndLoadKernel(&cparams, &kparams), retval, desc);
+	TEST_EQ(VbSelectAndLoadKernel(&ctx, &cparams, &kparams), retval, desc);
 	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		recovery_reason, "  recovery reason");
 }
diff --git a/tests/vboot_api_kernel5_tests.c b/tests/vboot_api_kernel5_tests.c
index 537c13b6..d836349e 100644
--- a/tests/vboot_api_kernel5_tests.c
+++ b/tests/vboot_api_kernel5_tests.c
@@ -193,7 +193,7 @@ static void VerifyMemoryBootImageTest(void)
 	kernel_body_size = sizeof(kernel_buffer) - kernel_body_offset;
 	kernel_body_start = (uintptr_t)kernel_buffer + kernel_body_offset;
 
-	u = VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer,
+	u = VbVerifyMemoryBootImage(&ctx, &cparams, &kparams, kernel_buffer,
 				    kernel_buffer_size);
 	TEST_EQ(u, 0, "Image good");
 	TEST_EQ(kparams.partition_number, 0, "  part num");
@@ -206,19 +206,20 @@ static void VerifyMemoryBootImageTest(void)
 
 	/* Empty image buffer. */
 	ResetMocks();
-	TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, NULL,
+	TEST_EQ(VbVerifyMemoryBootImage(&ctx, &cparams, &kparams, NULL,
 					kernel_buffer_size),
 		VBERROR_INVALID_PARAMETER, "Empty image");
 
 	/* Illegal image size. */
 	ResetMocks();
-	TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer, 0),
+	TEST_EQ(VbVerifyMemoryBootImage(&ctx, &cparams, &kparams, kernel_buffer,
+					0),
 		VBERROR_INVALID_PARAMETER, "Illegal image size");
 
 	/* Key Block Verification Failure */
 	ResetMocks();
 	key_block_verify_fail = 1;
-	TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer,
+	TEST_EQ(VbVerifyMemoryBootImage(&ctx, &cparams, &kparams, kernel_buffer,
 					kernel_buffer_size),
 		VBERROR_INVALID_KERNEL_FOUND, "Key verify failed");
 	TEST_EQ(hash_only_check, 0, "  hash check");
@@ -228,7 +229,7 @@ static void VerifyMemoryBootImageTest(void)
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
 	gbb->flags = GBB_FLAG_FORCE_DEV_BOOT_FASTBOOT_FULL_CAP;
 	key_block_verify_fail = 1;
-	TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer,
+	TEST_EQ(VbVerifyMemoryBootImage(&ctx, &cparams, &kparams, kernel_buffer,
 					kernel_buffer_size),
 		VBERROR_INVALID_KERNEL_FOUND, "Key verify failed");
 	TEST_EQ(hash_only_check, 1, "  hash check");
@@ -238,7 +239,7 @@ static void VerifyMemoryBootImageTest(void)
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
 	key_block_verify_fail = 1;
 	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP, 1);
-	TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer,
+	TEST_EQ(VbVerifyMemoryBootImage(&ctx, &cparams, &kparams, kernel_buffer,
 					kernel_buffer_size),
 		VBERROR_INVALID_KERNEL_FOUND, "Key verify failed");
 	TEST_EQ(hash_only_check, 1, "  hash check -- VBNV flag");
@@ -249,7 +250,7 @@ static void VerifyMemoryBootImageTest(void)
 		KEY_BLOCK_FLAG_RECOVERY_1;
 	copy_kbh();
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
-	TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer,
+	TEST_EQ(VbVerifyMemoryBootImage(&ctx, &cparams, &kparams, kernel_buffer,
 					kernel_buffer_size),
 		VBERROR_INVALID_KERNEL_FOUND,
 		"Developer flag mismatch - dev switch on");
@@ -261,7 +262,7 @@ static void VerifyMemoryBootImageTest(void)
 	copy_kbh();
 	gbb->flags = GBB_FLAG_FORCE_DEV_BOOT_FASTBOOT_FULL_CAP;
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
-	TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer,
+	TEST_EQ(VbVerifyMemoryBootImage(&ctx, &cparams, &kparams, kernel_buffer,
 					kernel_buffer_size),
 		VBERROR_SUCCESS,
 		"Developer flag mismatch - dev switch on(gbb override)");
@@ -273,7 +274,7 @@ static void VerifyMemoryBootImageTest(void)
 	copy_kbh();
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
 	gbb->flags = GBB_FLAG_FORCE_DEV_BOOT_FASTBOOT_FULL_CAP;
-	TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer,
+	TEST_EQ(VbVerifyMemoryBootImage(&ctx, &cparams, &kparams, kernel_buffer,
 					kernel_buffer_size),
 		VBERROR_SUCCESS,
 		"Recovery flag mismatch - dev switch on(gbb override)");
@@ -283,7 +284,7 @@ static void VerifyMemoryBootImageTest(void)
 	kbh.key_block_flags = KEY_BLOCK_FLAG_DEVELOPER_1 |
 		KEY_BLOCK_FLAG_RECOVERY_1;
 	copy_kbh();
-	TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer,
+	TEST_EQ(VbVerifyMemoryBootImage(&ctx, &cparams, &kparams, kernel_buffer,
 					kernel_buffer_size),
 		VBERROR_INVALID_KERNEL_FOUND,
 		"Developer flag mismatch - dev switch off");
@@ -294,21 +295,21 @@ static void VerifyMemoryBootImageTest(void)
 		KEY_BLOCK_FLAG_RECOVERY_0;
 	shared->flags = 0;
 	copy_kbh();
-	TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer,
+	TEST_EQ(VbVerifyMemoryBootImage(&ctx, &cparams, &kparams, kernel_buffer,
 					kernel_buffer_size),
 		VBERROR_INVALID_KERNEL_FOUND, "Recovery flag mismatch");
 
 	/* Preamble verification */
 	ResetMocks();
 	preamble_verify_fail = 1;
-	TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer,
+	TEST_EQ(VbVerifyMemoryBootImage(&ctx, &cparams, &kparams, kernel_buffer,
 					kernel_buffer_size),
 		VBERROR_INVALID_KERNEL_FOUND, "Preamble verification");
 
 	/* Data verification */
 	ResetMocks();
 	verify_data_fail = 1;
-	TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer,
+	TEST_EQ(VbVerifyMemoryBootImage(&ctx, &cparams, &kparams, kernel_buffer,
 					kernel_buffer_size),
 		VBERROR_INVALID_KERNEL_FOUND, "Data verification");
 }