vboot: standardize on vb2_context identifiers in tests

Use `ctx` for global vb2_context variable, and `c` for argument
to functions.  This avoids shadowing the `ctx` identifier, which
was recently disallowed by enabling -Wshadow in CL:1598721.

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

Change-Id: I9db97fd4945694e6f54abc5b0c04ed5533789300
Signed-off-by: Joel Kitching <kitching@google.com>
Reviewed-on: https://chromium-review.googlesource.com/1616872
Commit-Ready: Joel Kitching <kitching@chromium.org>
Tested-by: Joel Kitching <kitching@chromium.org>
Reviewed-by: Youcheng Syu <youcheng@chromium.org>

10 files changed, 541 insertions, 541 deletions

diff --git a/tests/vb20_api_kernel_tests.c b/tests/vb20_api_kernel_tests.c
index 3a2de215..0d48c75c 100644
--- a/tests/vb20_api_kernel_tests.c
+++ b/tests/vb20_api_kernel_tests.c
@@ -20,7 +20,7 @@
 /* Common context for tests */
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
-static struct vb2_context cc;
+static struct vb2_context ctx;
 static struct vb2_shared_data *sd;
 static struct vb2_fw_preamble *fwpre;
 static struct vb2_kernel_preamble *kpre;
@@ -55,18 +55,18 @@ static void reset_common_data(enum reset_type t)
 
 	memset(workbuf, 0xaa, sizeof(workbuf));
 
-	memset(&cc, 0, sizeof(cc));
-	cc.workbuf = workbuf;
-	cc.workbuf_size = sizeof(workbuf);
+	memset(&ctx, 0, sizeof(ctx));
+	ctx.workbuf = workbuf;
+	ctx.workbuf_size = sizeof(workbuf);
 
-	vb2_init_context(&cc);
-	sd = vb2_get_sd(&cc);
+	vb2_init_context(&ctx);
+	sd = vb2_get_sd(&ctx);
 
-	vb2_nv_init(&cc);
+	vb2_nv_init(&ctx);
 
-	vb2_secdatak_create(&cc);
-	vb2_secdatak_init(&cc);
-	vb2_secdatak_set(&cc, VB2_SECDATAK_VERSIONS, 0x20002);
+	vb2_secdatak_create(&ctx);
+	vb2_secdatak_init(&ctx);
+	vb2_secdatak_set(&ctx, VB2_SECDATAK_VERSIONS, 0x20002);
 
 	mock_read_res_fail_on_call = 0;
 	mock_unpack_key_retval = VB2_SUCCESS;
@@ -92,9 +92,9 @@ static void reset_common_data(enum reset_type t)
 		uint8_t *kdata;
 
 		/* Create mock firmware preamble in the context */
-		sd->workbuf_preamble_offset = cc.workbuf_used;
+		sd->workbuf_preamble_offset = ctx.workbuf_used;
 		fwpre = (struct vb2_fw_preamble *)
-			(cc.workbuf + sd->workbuf_preamble_offset);
+			(ctx.workbuf + sd->workbuf_preamble_offset);
 		k = &fwpre->kernel_subkey;
 		kdata = (uint8_t *)fwpre + sizeof(*fwpre);
 		memcpy(kdata, fw_kernel_key_data, sizeof(fw_kernel_key_data));
@@ -102,7 +102,7 @@ static void reset_common_data(enum reset_type t)
 		k->key_offset = vb2_offset_of(k, kdata);
 		k->key_size = sizeof(fw_kernel_key_data);
 		sd->workbuf_preamble_size = sizeof(*fwpre) + k->key_size;
-		vb2_set_workbuf_used(&cc, sd->workbuf_preamble_offset +
+		vb2_set_workbuf_used(&ctx, sd->workbuf_preamble_offset +
 				     sd->workbuf_preamble_size);
 
 	} else if (t == FOR_PHASE2) {
@@ -111,18 +111,18 @@ static void reset_common_data(enum reset_type t)
 		uint8_t *sdata;
 
 		/* Create mock kernel data key */
-		sd->workbuf_data_key_offset = cc.workbuf_used;
+		sd->workbuf_data_key_offset = ctx.workbuf_used;
 		kdkey = (struct vb2_packed_key *)
-			(cc.workbuf + sd->workbuf_data_key_offset);
+			(ctx.workbuf + sd->workbuf_data_key_offset);
 		kdkey->algorithm = VB2_ALG_RSA2048_SHA256;
 		sd->workbuf_data_key_size = sizeof(*kdkey);
-		vb2_set_workbuf_used(&cc, sd->workbuf_data_key_offset +
+		vb2_set_workbuf_used(&ctx, sd->workbuf_data_key_offset +
 				     sd->workbuf_data_key_size);
 
 		/* Create mock kernel preamble in the context */
-		sd->workbuf_preamble_offset = cc.workbuf_used;
+		sd->workbuf_preamble_offset = ctx.workbuf_used;
 		kpre = (struct vb2_kernel_preamble *)
-			(cc.workbuf + sd->workbuf_preamble_offset);
+			(ctx.workbuf + sd->workbuf_preamble_offset);
 		sdata = (uint8_t *)kpre + sizeof(*kpre);
 
 		sig = &kpre->body_signature;
@@ -138,7 +138,7 @@ static void reset_common_data(enum reset_type t)
 		sd->workbuf_preamble_size = sizeof(*kpre) + sig->sig_size;
 		sd->vblock_preamble_offset =
 			0x10000 - sd->workbuf_preamble_size;
-		vb2_set_workbuf_used(&cc, sd->workbuf_preamble_offset +
+		vb2_set_workbuf_used(&ctx, sd->workbuf_preamble_offset +
 				     sd->workbuf_preamble_size);
 
 	} else {
@@ -146,13 +146,13 @@ static void reset_common_data(enum reset_type t)
 		sd->kernel_version = 0x20004;
 		sd->kernel_version_secdatak = 0x20002;
 		sd->flags |= VB2_SD_FLAG_KERNEL_SIGNED;
-		cc.flags |= VB2_CONTEXT_ALLOW_KERNEL_ROLL_FORWARD;
+		ctx.flags |= VB2_CONTEXT_ALLOW_KERNEL_ROLL_FORWARD;
 	}
 };
 
 /* Mocked functions */
 
-int vb2ex_read_resource(struct vb2_context *ctx,
+int vb2ex_read_resource(struct vb2_context *c,
 			enum vb2_resource_index index,
 			uint32_t offset,
 			void *buf,
@@ -180,18 +180,18 @@ int vb2ex_read_resource(struct vb2_context *ctx,
 	return VB2_SUCCESS;
 }
 
-int vb2_read_gbb_header(struct vb2_context *ctx, struct vb2_gbb_header *gbb)
+int 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 *ctx)
+int vb2_load_kernel_keyblock(struct vb2_context *c)
 {
 	return mock_load_kernel_keyblock_retval;
 }
 
-int vb2_load_kernel_preamble(struct vb2_context *ctx)
+int vb2_load_kernel_preamble(struct vb2_context *c)
 {
 	return mock_load_kernel_preamble_retval;
 }
@@ -228,16 +228,16 @@ static void phase1_tests(void)
 	/* Test successful call */
 	reset_common_data(FOR_PHASE1);
 	old_preamble_offset = sd->workbuf_preamble_offset;
-	TEST_SUCC(vb2api_kernel_phase1(&cc), "phase1 good");
+	TEST_SUCC(vb2api_kernel_phase1(&ctx), "phase1 good");
 	TEST_EQ(sd->workbuf_preamble_size, 0, "  no more fw preamble");
 	/* Make sure normal key was loaded */
 	TEST_EQ(sd->workbuf_kernel_key_offset, old_preamble_offset,
 		"  workbuf key offset");
 	k = (struct vb2_packed_key *)
-		(cc.workbuf + sd->workbuf_kernel_key_offset);
+		(ctx.workbuf + sd->workbuf_kernel_key_offset);
 	TEST_EQ(sd->workbuf_kernel_key_size, k->key_offset + k->key_size,
 		"  workbuf key size");
-	TEST_EQ(cc.workbuf_used,
+	TEST_EQ(ctx.workbuf_used,
 		vb2_wb_round_up(sd->workbuf_kernel_key_offset +
 				sd->workbuf_kernel_key_size),
 		"  workbuf used");
@@ -249,20 +249,20 @@ static void phase1_tests(void)
 
 	/* Test successful call in recovery mode */
 	reset_common_data(FOR_PHASE1);
-	cc.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
 	/* No preamble loaded in recovery mode */
-	cc.workbuf_used = old_preamble_offset = sd->workbuf_preamble_offset;
+	ctx.workbuf_used = old_preamble_offset = sd->workbuf_preamble_offset;
 	sd->workbuf_preamble_offset = sd->workbuf_preamble_size = 0;
-	TEST_SUCC(vb2api_kernel_phase1(&cc), "phase1 rec good");
+	TEST_SUCC(vb2api_kernel_phase1(&ctx), "phase1 rec good");
 	TEST_EQ(sd->workbuf_preamble_size, 0, "no more fw preamble");
 	/* Make sure recovery key was loaded */
 	TEST_EQ(sd->workbuf_kernel_key_offset, old_preamble_offset,
 		"  workbuf key offset");
 	k = (struct vb2_packed_key *)
-		(cc.workbuf + sd->workbuf_kernel_key_offset);
+		(ctx.workbuf + sd->workbuf_kernel_key_offset);
 	TEST_EQ(sd->workbuf_kernel_key_size, k->key_offset + k->key_size,
 		"  workbuf key size");
-	TEST_EQ(cc.workbuf_used,
+	TEST_EQ(ctx.workbuf_used,
 		vb2_wb_round_up(sd->workbuf_kernel_key_offset +
 				sd->workbuf_kernel_key_size),
 		"  workbuf used");
@@ -275,63 +275,63 @@ static void phase1_tests(void)
 
 	/* Bad secdatak causes failure in normal mode only */
 	reset_common_data(FOR_PHASE1);
-	cc.secdatak[0] ^= 0x33;
-	TEST_EQ(vb2api_kernel_phase1(&cc), VB2_ERROR_SECDATAK_CRC,
+	ctx.secdatak[0] ^= 0x33;
+	TEST_EQ(vb2api_kernel_phase1(&ctx), VB2_ERROR_SECDATAK_CRC,
 		"phase1 bad secdata");
 	reset_common_data(FOR_PHASE1);
 
-	cc.secdatak[0] ^= 0x33;
-	cc.flags |= VB2_CONTEXT_RECOVERY_MODE;
-	TEST_SUCC(vb2api_kernel_phase1(&cc), "phase1 bad secdata rec");
+	ctx.secdatak[0] ^= 0x33;
+	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	TEST_SUCC(vb2api_kernel_phase1(&ctx), "phase1 bad secdata rec");
 	TEST_EQ(sd->kernel_version_secdatak, 0, "  secdatak version");
 
 	/* Failures while reading recovery key */
 	reset_common_data(FOR_PHASE1);
-	cc.flags |= VB2_CONTEXT_RECOVERY_MODE;
-	cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN -
+	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
 			vb2_wb_round_up(sizeof(struct vb2_gbb_header));
-	TEST_EQ(vb2api_kernel_phase1(&cc), VB2_ERROR_GBB_WORKBUF,
+	TEST_EQ(vb2api_kernel_phase1(&ctx), VB2_ERROR_GBB_WORKBUF,
 		"phase1 rec workbuf gbb header");
 
 	reset_common_data(FOR_PHASE1);
-	cc.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
 	mock_read_gbb_header_retval = VB2_ERROR_MOCK;
-	TEST_EQ(vb2api_kernel_phase1(&cc), VB2_ERROR_MOCK,
+	TEST_EQ(vb2api_kernel_phase1(&ctx), VB2_ERROR_MOCK,
 		"phase1 rec gbb read header");
 
 	reset_common_data(FOR_PHASE1);
-	cc.flags |= VB2_CONTEXT_RECOVERY_MODE;
-	mock_gbb.h.recovery_key_size = cc.workbuf_size - 1;
-	TEST_EQ(vb2api_kernel_phase1(&cc),
+	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	mock_gbb.h.recovery_key_size = ctx.workbuf_size - 1;
+	TEST_EQ(vb2api_kernel_phase1(&ctx),
 		VB2_ERROR_API_KPHASE1_WORKBUF_REC_KEY,
 		"phase1 rec workbuf key");
 
 	reset_common_data(FOR_PHASE1);
-	cc.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
 	mock_read_res_fail_on_call = 1;
-	TEST_EQ(vb2api_kernel_phase1(&cc), VB2_ERROR_MOCK,
+	TEST_EQ(vb2api_kernel_phase1(&ctx), VB2_ERROR_MOCK,
 		"phase1 rec gbb read key");
 
 	/* Failures while parsing subkey from firmware preamble */
 	reset_common_data(FOR_PHASE1);
 	sd->workbuf_preamble_size = 0;
-	TEST_EQ(vb2api_kernel_phase1(&cc), VB2_ERROR_API_KPHASE1_PREAMBLE,
+	TEST_EQ(vb2api_kernel_phase1(&ctx), VB2_ERROR_API_KPHASE1_PREAMBLE,
 		"phase1 fw preamble");
 }
 
 static void load_kernel_vblock_tests(void)
 {
 	reset_common_data(FOR_PHASE1);
-	TEST_SUCC(vb2api_load_kernel_vblock(&cc), "load vblock good");
+	TEST_SUCC(vb2api_load_kernel_vblock(&ctx), "load vblock good");
 
 	reset_common_data(FOR_PHASE1);
 	mock_load_kernel_keyblock_retval = VB2_ERROR_MOCK;
-	TEST_EQ(vb2api_load_kernel_vblock(&cc), VB2_ERROR_MOCK,
+	TEST_EQ(vb2api_load_kernel_vblock(&ctx), VB2_ERROR_MOCK,
 		"load vblock bad keyblock");
 
 	reset_common_data(FOR_PHASE1);
 	mock_load_kernel_preamble_retval = VB2_ERROR_MOCK;
-	TEST_EQ(vb2api_load_kernel_vblock(&cc), VB2_ERROR_MOCK,
+	TEST_EQ(vb2api_load_kernel_vblock(&ctx), VB2_ERROR_MOCK,
 		"load vblock bad preamble");
 }
 
@@ -341,17 +341,17 @@ static void get_kernel_size_tests(void)
 
 	reset_common_data(FOR_PHASE2);
 	offs = size = 0;
-	TEST_SUCC(vb2api_get_kernel_size(&cc, &offs, &size), "get size good");
+	TEST_SUCC(vb2api_get_kernel_size(&ctx, &offs, &size), "get size good");
 	TEST_EQ(offs, 0x10000, "  offset");
 	TEST_EQ(size, sizeof(kernel_data), "  size");
 
 	/* Don't need to pass pointers */
 	reset_common_data(FOR_PHASE2);
-	TEST_SUCC(vb2api_get_kernel_size(&cc, NULL, NULL), "get size null");
+	TEST_SUCC(vb2api_get_kernel_size(&ctx, NULL, NULL), "get size null");
 
 	reset_common_data(FOR_PHASE2);
 	sd->workbuf_preamble_size = 0;
-	TEST_EQ(vb2api_get_kernel_size(&cc, &offs, &size),
+	TEST_EQ(vb2api_get_kernel_size(&ctx, &offs, &size),
 		VB2_ERROR_API_GET_KERNEL_SIZE_PREAMBLE,
 		"get size no preamble");
 }
@@ -359,56 +359,56 @@ static void get_kernel_size_tests(void)
 static void verify_kernel_data_tests(void)
 {
 	reset_common_data(FOR_PHASE2);
-	TEST_SUCC(vb2api_verify_kernel_data(&cc, kernel_data,
+	TEST_SUCC(vb2api_verify_kernel_data(&ctx, kernel_data,
 					    sizeof(kernel_data)),
 		  "verify data good");
 
 	reset_common_data(FOR_PHASE2);
 	sd->workbuf_preamble_size = 0;
-	TEST_EQ(vb2api_verify_kernel_data(&cc, kernel_data,
+	TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data,
 					  sizeof(kernel_data)),
 		VB2_ERROR_API_VERIFY_KDATA_PREAMBLE, "verify no preamble");
 
 	reset_common_data(FOR_PHASE2);
-	TEST_EQ(vb2api_verify_kernel_data(&cc, kernel_data,
+	TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data,
 					  sizeof(kernel_data) + 1),
 		VB2_ERROR_API_VERIFY_KDATA_SIZE, "verify size");
 
 	reset_common_data(FOR_PHASE2);
-	cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN -
+	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
 			vb2_wb_round_up(sizeof(struct vb2_digest_context));
-	TEST_EQ(vb2api_verify_kernel_data(&cc, kernel_data,
+	TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data,
 					  sizeof(kernel_data)),
 		VB2_ERROR_API_VERIFY_KDATA_WORKBUF, "verify workbuf");
 
 	reset_common_data(FOR_PHASE2);
 	sd->workbuf_data_key_size = 0;
-	TEST_EQ(vb2api_verify_kernel_data(&cc, kernel_data,
+	TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data,
 					  sizeof(kernel_data)),
 		VB2_ERROR_API_VERIFY_KDATA_KEY, "verify no key");
 
 	reset_common_data(FOR_PHASE2);
 	mock_unpack_key_retval = VB2_ERROR_MOCK;
-	TEST_EQ(vb2api_verify_kernel_data(&cc, kernel_data,
+	TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data,
 					  sizeof(kernel_data)),
 		VB2_ERROR_MOCK, "verify unpack key");
 
 	reset_common_data(FOR_PHASE2);
 	kdkey->algorithm = VB2_ALG_COUNT;
-	TEST_EQ(vb2api_verify_kernel_data(&cc, kernel_data,
+	TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data,
 					  sizeof(kernel_data)),
 		VB2_ERROR_SHA_INIT_ALGORITHM, "verify hash init");
 
 	reset_common_data(FOR_PHASE2);
-	cc.workbuf_used = cc.workbuf_size -
+	ctx.workbuf_used = ctx.workbuf_size -
 			vb2_wb_round_up(sizeof(struct vb2_digest_context));
-	TEST_EQ(vb2api_verify_kernel_data(&cc, kernel_data,
+	TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data,
 					  sizeof(kernel_data)),
 		VB2_ERROR_API_CHECK_HASH_WORKBUF_DIGEST, "verify hash workbuf");
 
 	reset_common_data(FOR_PHASE2);
 	kernel_data[3] ^= 0xd0;
-	TEST_EQ(vb2api_verify_kernel_data(&cc, kernel_data,
+	TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data,
 					  sizeof(kernel_data)),
 		VB2_ERROR_VDATA_VERIFY_DIGEST, "verify hash digest");
 	kernel_data[3] ^= 0xd0;
@@ -419,37 +419,37 @@ static void phase3_tests(void)
 	uint32_t v;
 
 	reset_common_data(FOR_PHASE3);
-	TEST_SUCC(vb2api_kernel_phase3(&cc), "phase3 good");
-	vb2_secdatak_get(&cc, VB2_SECDATAK_VERSIONS, &v);
+	TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 good");
+	vb2_secdatak_get(&ctx, VB2_SECDATAK_VERSIONS, &v);
 	TEST_EQ(v, 0x20004, "  version");
 
 	reset_common_data(FOR_PHASE3);
 	sd->kernel_version = 0x20001;
-	TEST_SUCC(vb2api_kernel_phase3(&cc), "phase3 no rollback");
-	vb2_secdatak_get(&cc, VB2_SECDATAK_VERSIONS, &v);
+	TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 no rollback");
+	vb2_secdatak_get(&ctx, VB2_SECDATAK_VERSIONS, &v);
 	TEST_EQ(v, 0x20002, "  version");
 
 	reset_common_data(FOR_PHASE3);
 	sd->flags &= ~VB2_SD_FLAG_KERNEL_SIGNED;
-	TEST_SUCC(vb2api_kernel_phase3(&cc), "phase3 unsigned kernel");
-	vb2_secdatak_get(&cc, VB2_SECDATAK_VERSIONS, &v);
+	TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 unsigned kernel");
+	vb2_secdatak_get(&ctx, VB2_SECDATAK_VERSIONS, &v);
 	TEST_EQ(v, 0x20002, "  version");
 
 	reset_common_data(FOR_PHASE3);
-	cc.flags |= VB2_CONTEXT_RECOVERY_MODE;
-	TEST_SUCC(vb2api_kernel_phase3(&cc), "phase3 recovery");
-	vb2_secdatak_get(&cc, VB2_SECDATAK_VERSIONS, &v);
+	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 recovery");
+	vb2_secdatak_get(&ctx, VB2_SECDATAK_VERSIONS, &v);
 	TEST_EQ(v, 0x20002, "  version");
 
 	reset_common_data(FOR_PHASE3);
-	cc.flags &= ~VB2_CONTEXT_ALLOW_KERNEL_ROLL_FORWARD;
-	TEST_SUCC(vb2api_kernel_phase3(&cc), "phase3 no rollforward");
-	vb2_secdatak_get(&cc, VB2_SECDATAK_VERSIONS, &v);
+	ctx.flags &= ~VB2_CONTEXT_ALLOW_KERNEL_ROLL_FORWARD;
+	TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 no rollforward");
+	vb2_secdatak_get(&ctx, VB2_SECDATAK_VERSIONS, &v);
 	TEST_EQ(v, 0x20002, "  version");
 
 	reset_common_data(FOR_PHASE3);
 	sd->status &= ~VB2_SD_STATUS_SECDATAK_INIT;
-	TEST_EQ(vb2api_kernel_phase3(&cc),
+	TEST_EQ(vb2api_kernel_phase3(&ctx),
 		VB2_ERROR_SECDATAK_SET_UNINITIALIZED, "phase3 set fail");
 }
 
diff --git a/tests/vb20_api_tests.c b/tests/vb20_api_tests.c
index 3a5d4968..6c43391e 100644
--- a/tests/vb20_api_tests.c
+++ b/tests/vb20_api_tests.c
@@ -19,7 +19,7 @@
 /* Common context for tests */
 static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
-static struct vb2_context cc;
+static struct vb2_context ctx;
 static struct vb2_shared_data *sd;
 
 const char mock_body[320] = "Mock body";
@@ -57,29 +57,29 @@ static void reset_common_data(enum reset_type t)
 
 	memset(workbuf, 0xaa, sizeof(workbuf));
 
-	memset(&cc, 0, sizeof(cc));
-	cc.workbuf = workbuf;
-	cc.workbuf_size = sizeof(workbuf);
+	memset(&ctx, 0, sizeof(ctx));
+	ctx.workbuf = workbuf;
+	ctx.workbuf_size = sizeof(workbuf);
 
-	vb2_init_context(&cc);
-	sd = vb2_get_sd(&cc);
+	vb2_init_context(&ctx);
+	sd = vb2_get_sd(&ctx);
 
-	vb2_nv_init(&cc);
+	vb2_nv_init(&ctx);
 
-	vb2_secdata_create(&cc);
-	vb2_secdata_init(&cc);
+	vb2_secdata_create(&ctx);
+	vb2_secdata_init(&ctx);
 
 	retval_vb2_load_fw_keyblock = VB2_SUCCESS;
 	retval_vb2_load_fw_preamble = VB2_SUCCESS;
 	retval_vb2_digest_finalize = VB2_SUCCESS;
 	retval_vb2_verify_digest = VB2_SUCCESS;
 
-	sd->workbuf_preamble_offset = cc.workbuf_used;
+	sd->workbuf_preamble_offset = ctx.workbuf_used;
 	sd->workbuf_preamble_size = sizeof(*pre);
-	vb2_set_workbuf_used(&cc, sd->workbuf_preamble_offset
+	vb2_set_workbuf_used(&ctx, sd->workbuf_preamble_offset
 			     + sd->workbuf_preamble_size);
 	pre = (struct vb2_fw_preamble *)
-		(cc.workbuf + sd->workbuf_preamble_offset);
+		(ctx.workbuf + sd->workbuf_preamble_offset);
 	pre->body_signature.data_size = mock_body_size;
 	pre->body_signature.sig_size = mock_sig_size;
 	if (hwcrypto_state == HWCRYPTO_FORBIDDEN)
@@ -87,19 +87,19 @@ static void reset_common_data(enum reset_type t)
 	else
 		pre->flags = 0;
 
-	sd->workbuf_data_key_offset = cc.workbuf_used;
+	sd->workbuf_data_key_offset = ctx.workbuf_used;
 	sd->workbuf_data_key_size = sizeof(*k) + 8;
-	vb2_set_workbuf_used(&cc, sd->workbuf_data_key_offset +
+	vb2_set_workbuf_used(&ctx, sd->workbuf_data_key_offset +
 			     sd->workbuf_data_key_size);
 	k = (struct vb2_packed_key *)
-		(cc.workbuf + sd->workbuf_data_key_offset);
+		(ctx.workbuf + sd->workbuf_data_key_offset);
 	k->algorithm = mock_algorithm;
 
 	if (t == FOR_EXTEND_HASH || t == FOR_CHECK_HASH)
-		vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY, NULL);
+		vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, NULL);
 
 	if (t == FOR_CHECK_HASH)
-		vb2api_extend_hash(&cc, mock_body, mock_body_size);
+		vb2api_extend_hash(&ctx, mock_body, mock_body_size);
 
 	/* Always clear out the digest result. */
 	memset(digest_result, 0, digest_result_size);
@@ -107,12 +107,12 @@ static void reset_common_data(enum reset_type t)
 
 /* Mocked functions */
 
-int vb2_load_fw_keyblock(struct vb2_context *ctx)
+int vb2_load_fw_keyblock(struct vb2_context *c)
 {
 	return retval_vb2_load_fw_keyblock;
 }
 
-int vb2_load_fw_preamble(struct vb2_context *ctx)
+int vb2_load_fw_preamble(struct vb2_context *c)
 {
 	return retval_vb2_load_fw_preamble;
 }
@@ -233,18 +233,18 @@ int vb2_rsa_verify_digest(const struct vb2_public_key *key,
 static void phase3_tests(void)
 {
 	reset_common_data(FOR_MISC);
-	TEST_SUCC(vb2api_fw_phase3(&cc), "phase3 good");
+	TEST_SUCC(vb2api_fw_phase3(&ctx), "phase3 good");
 
 	reset_common_data(FOR_MISC);
 	retval_vb2_load_fw_keyblock = VB2_ERROR_MOCK;
-	TEST_EQ(vb2api_fw_phase3(&cc), VB2_ERROR_MOCK, "phase3 keyblock");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2api_fw_phase3(&ctx), VB2_ERROR_MOCK, "phase3 keyblock");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		VB2_RECOVERY_RO_INVALID_RW, "  recovery reason");
 
 	reset_common_data(FOR_MISC);
 	retval_vb2_load_fw_preamble = VB2_ERROR_MOCK;
-	TEST_EQ(vb2api_fw_phase3(&cc), VB2_ERROR_MOCK, "phase3 keyblock");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2api_fw_phase3(&ctx), VB2_ERROR_MOCK, "phase3 keyblock");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		VB2_RECOVERY_RO_INVALID_RW, "  recovery reason");
 }
 
@@ -256,58 +256,58 @@ static void init_hash_tests(void)
 
 	/* For now, all we support is body signature hash */
 	reset_common_data(FOR_MISC);
-	wb_used_before = cc.workbuf_used;
-	TEST_SUCC(vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY, &size),
+	wb_used_before = ctx.workbuf_used;
+	TEST_SUCC(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size),
 		  "init hash good");
 	TEST_EQ(sd->workbuf_hash_offset, wb_used_before,
 		"hash context offset");
 	TEST_EQ(sd->workbuf_hash_size, sizeof(struct vb2_digest_context),
 		"hash context size");
-	TEST_EQ(cc.workbuf_used,
+	TEST_EQ(ctx.workbuf_used,
 		vb2_wb_round_up(sd->workbuf_hash_offset +
 				sd->workbuf_hash_size),
 		"hash uses workbuf");
 	TEST_EQ(sd->hash_tag, VB2_HASH_TAG_FW_BODY, "hash tag");
 	TEST_EQ(sd->hash_remaining_size, mock_body_size, "hash remaining");
 
-	wb_used_before = cc.workbuf_used;
-	TEST_SUCC(vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY, NULL),
+	wb_used_before = ctx.workbuf_used;
+	TEST_SUCC(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, NULL),
 		  "init hash again");
-	TEST_EQ(cc.workbuf_used, wb_used_before, "init hash reuses context");
+	TEST_EQ(ctx.workbuf_used, wb_used_before, "init hash reuses context");
 
 	reset_common_data(FOR_MISC);
-	TEST_EQ(vb2api_init_hash(&cc, VB2_HASH_TAG_INVALID, &size),
+	TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_INVALID, &size),
 		VB2_ERROR_API_INIT_HASH_TAG, "init hash invalid tag");
 
 	reset_common_data(FOR_MISC);
 	sd->workbuf_preamble_size = 0;
-	TEST_EQ(vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY, &size),
+	TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size),
 		VB2_ERROR_API_INIT_HASH_PREAMBLE, "init hash preamble");
 
 	reset_common_data(FOR_MISC);
-	TEST_EQ(vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY + 1, &size),
+	TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY + 1, &size),
 		VB2_ERROR_API_INIT_HASH_TAG, "init hash unknown tag");
 
 	reset_common_data(FOR_MISC);
-	cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN -
+	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
 			vb2_wb_round_up(sizeof(struct vb2_digest_context));
-	TEST_EQ(vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY, &size),
+	TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size),
 		VB2_ERROR_API_INIT_HASH_WORKBUF, "init hash workbuf");
 
 	reset_common_data(FOR_MISC);
 	sd->workbuf_data_key_size = 0;
-	TEST_EQ(vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY, &size),
+	TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size),
 		VB2_ERROR_API_INIT_HASH_DATA_KEY, "init hash data key");
 
 	reset_common_data(FOR_MISC);
 	sd->workbuf_data_key_size--;
-	TEST_EQ(vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY, &size),
+	TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size),
 		VB2_ERROR_UNPACK_KEY_SIZE, "init hash data key size");
 
 	reset_common_data(FOR_MISC);
-	k = (struct vb2_packed_key *)(cc.workbuf + sd->workbuf_data_key_offset);
+	k = (struct vb2_packed_key *)(ctx.workbuf + sd->workbuf_data_key_offset);
 	k->algorithm--;
-	TEST_EQ(vb2api_init_hash(&cc, VB2_HASH_TAG_FW_BODY, &size),
+	TEST_EQ(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size),
 		VB2_ERROR_SHA_INIT_ALGORITHM, "init hash algorithm");
 }
 
@@ -316,33 +316,33 @@ static void extend_hash_tests(void)
 	struct vb2_digest_context *dc;
 
 	reset_common_data(FOR_EXTEND_HASH);
-	TEST_SUCC(vb2api_extend_hash(&cc, mock_body, 32),
+	TEST_SUCC(vb2api_extend_hash(&ctx, mock_body, 32),
 		"hash extend good");
 	TEST_EQ(sd->hash_remaining_size, mock_body_size - 32,
 		"hash extend remaining");
-	TEST_SUCC(vb2api_extend_hash(&cc, mock_body, mock_body_size - 32),
+	TEST_SUCC(vb2api_extend_hash(&ctx, mock_body, mock_body_size - 32),
 		"hash extend again");
 	TEST_EQ(sd->hash_remaining_size, 0, "hash extend remaining 2");
 
 	reset_common_data(FOR_EXTEND_HASH);
 	sd->workbuf_hash_size = 0;
-	TEST_EQ(vb2api_extend_hash(&cc, mock_body, mock_body_size),
+	TEST_EQ(vb2api_extend_hash(&ctx, mock_body, mock_body_size),
 		VB2_ERROR_API_EXTEND_HASH_WORKBUF, "hash extend no workbuf");
 
 	reset_common_data(FOR_EXTEND_HASH);
-	TEST_EQ(vb2api_extend_hash(&cc, mock_body, mock_body_size + 1),
+	TEST_EQ(vb2api_extend_hash(&ctx, mock_body, mock_body_size + 1),
 		VB2_ERROR_API_EXTEND_HASH_SIZE, "hash extend too much");
 
 	reset_common_data(FOR_EXTEND_HASH);
-	TEST_EQ(vb2api_extend_hash(&cc, mock_body, 0),
+	TEST_EQ(vb2api_extend_hash(&ctx, mock_body, 0),
 		VB2_ERROR_API_EXTEND_HASH_SIZE, "hash extend empty");
 
 	if (hwcrypto_state != HWCRYPTO_ENABLED) {
 		reset_common_data(FOR_EXTEND_HASH);
 		dc = (struct vb2_digest_context *)
-			(cc.workbuf + sd->workbuf_hash_offset);
+			(ctx.workbuf + sd->workbuf_hash_offset);
 		dc->hash_alg = mock_hash_alg + 1;
-		TEST_EQ(vb2api_extend_hash(&cc, mock_body, mock_body_size),
+		TEST_EQ(vb2api_extend_hash(&ctx, mock_body, mock_body_size),
 			VB2_ERROR_SHA_EXTEND_ALGORITHM, "hash extend fail");
 	}
 }
@@ -353,17 +353,17 @@ static void check_hash_tests(void)
 	const uint32_t digest_value = 0x0a0a0a0a;
 
 	reset_common_data(FOR_CHECK_HASH);
-	TEST_SUCC(vb2api_check_hash(&cc), "check hash good");
+	TEST_SUCC(vb2api_check_hash(&ctx), "check hash good");
 
 	reset_common_data(FOR_CHECK_HASH);
-	TEST_SUCC(vb2api_check_hash_get_digest(&cc, digest_result,
+	TEST_SUCC(vb2api_check_hash_get_digest(&ctx, digest_result,
 			digest_result_size), "check hash good with result");
 	/* Check the first 4 bytes to ensure it was copied over. */
 	TEST_SUCC(memcmp(digest_result, &digest_value, sizeof(digest_value)),
 		"check digest value");
 
 	reset_common_data(FOR_CHECK_HASH);
-	TEST_EQ(vb2api_check_hash_get_digest(&cc, digest_result,
+	TEST_EQ(vb2api_check_hash_get_digest(&ctx, digest_result,
 			digest_result_size - 1),
 		VB2_ERROR_API_CHECK_DIGEST_SIZE, "check digest size");
 	TEST_NEQ(memcmp(digest_result, &digest_value, sizeof(digest_value)), 0,
@@ -371,53 +371,53 @@ static void check_hash_tests(void)
 
 	reset_common_data(FOR_CHECK_HASH);
 	sd->workbuf_preamble_size = 0;
-	TEST_EQ(vb2api_check_hash(&cc),
+	TEST_EQ(vb2api_check_hash(&ctx),
 		VB2_ERROR_API_CHECK_HASH_PREAMBLE, "check hash preamble");
 
 	reset_common_data(FOR_CHECK_HASH);
 	sd->workbuf_hash_size = 0;
-	TEST_EQ(vb2api_check_hash(&cc),
+	TEST_EQ(vb2api_check_hash(&ctx),
 		VB2_ERROR_API_CHECK_HASH_WORKBUF, "check hash no workbuf");
 
 	reset_common_data(FOR_CHECK_HASH);
 	sd->hash_remaining_size = 1;
-	TEST_EQ(vb2api_check_hash(&cc),
+	TEST_EQ(vb2api_check_hash(&ctx),
 		VB2_ERROR_API_CHECK_HASH_SIZE, "check hash size");
 
 	reset_common_data(FOR_CHECK_HASH);
-	cc.workbuf_used = cc.workbuf_size;
-	TEST_EQ(vb2api_check_hash(&cc),
+	ctx.workbuf_used = ctx.workbuf_size;
+	TEST_EQ(vb2api_check_hash(&ctx),
 		VB2_ERROR_API_CHECK_HASH_WORKBUF_DIGEST, "check hash workbuf");
 
 	reset_common_data(FOR_CHECK_HASH);
 	retval_vb2_digest_finalize = VB2_ERROR_MOCK;
-	TEST_EQ(vb2api_check_hash(&cc),	VB2_ERROR_MOCK, "check hash finalize");
+	TEST_EQ(vb2api_check_hash(&ctx),	VB2_ERROR_MOCK, "check hash finalize");
 
 	reset_common_data(FOR_CHECK_HASH);
 	sd->hash_tag = VB2_HASH_TAG_INVALID;
-	TEST_EQ(vb2api_check_hash(&cc),
+	TEST_EQ(vb2api_check_hash(&ctx),
 		VB2_ERROR_API_CHECK_HASH_TAG, "check hash tag");
 
 	reset_common_data(FOR_CHECK_HASH);
 	sd->workbuf_data_key_size = 0;
-	TEST_EQ(vb2api_check_hash(&cc),
+	TEST_EQ(vb2api_check_hash(&ctx),
 		VB2_ERROR_API_CHECK_HASH_DATA_KEY, "check hash data key");
 
 	reset_common_data(FOR_CHECK_HASH);
 	sd->workbuf_data_key_size--;
-	TEST_EQ(vb2api_check_hash(&cc),
+	TEST_EQ(vb2api_check_hash(&ctx),
 		VB2_ERROR_UNPACK_KEY_SIZE, "check hash data key size");
 
 	reset_common_data(FOR_CHECK_HASH);
 	pre = (struct vb2_fw_preamble *)
-		(cc.workbuf + sd->workbuf_preamble_offset);
+		(ctx.workbuf + sd->workbuf_preamble_offset);
 	pre->body_signature.sig_size++;
-	TEST_EQ(vb2api_check_hash(&cc),
+	TEST_EQ(vb2api_check_hash(&ctx),
 		VB2_ERROR_VDATA_SIG_SIZE, "check hash sig size");
 
 	reset_common_data(FOR_CHECK_HASH);
 	retval_vb2_digest_finalize = VB2_ERROR_RSA_VERIFY_DIGEST;
-	TEST_EQ(vb2api_check_hash(&cc),
+	TEST_EQ(vb2api_check_hash(&ctx),
 		VB2_ERROR_RSA_VERIFY_DIGEST, "check hash finalize");
 }
 
diff --git a/tests/vb20_kernel_tests.c b/tests/vb20_kernel_tests.c
index 6d936285..ec70f4bb 100644
--- a/tests/vb20_kernel_tests.c
+++ b/tests/vb20_kernel_tests.c
@@ -21,7 +21,7 @@
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
 static struct vb2_workbuf wb;
-static struct vb2_context cc;
+static struct vb2_context ctx;
 static struct vb2_shared_data *sd;
 
 /* Mocked function data */
@@ -80,18 +80,18 @@ static void reset_common_data(enum reset_type t)
 
 	memset(workbuf, 0xaa, sizeof(workbuf));
 
-	memset(&cc, 0, sizeof(cc));
-	cc.workbuf = workbuf;
-	cc.workbuf_size = sizeof(workbuf);
-	vb2_workbuf_from_ctx(&cc, &wb);
+	memset(&ctx, 0, sizeof(ctx));
+	ctx.workbuf = workbuf;
+	ctx.workbuf_size = sizeof(workbuf);
+	vb2_workbuf_from_ctx(&ctx, &wb);
 
-	vb2_init_context(&cc);
-	sd = vb2_get_sd(&cc);
+	vb2_init_context(&ctx);
+	sd = vb2_get_sd(&ctx);
 
-	vb2_nv_init(&cc);
+	vb2_nv_init(&ctx);
 
-	vb2_secdatak_create(&cc);
-	vb2_secdatak_init(&cc);
+	vb2_secdatak_create(&ctx);
+	vb2_secdatak_init(&ctx);
 
 	mock_read_res_fail_on_call = 0;
 	mock_unpack_key_retval = VB2_SUCCESS;
@@ -100,7 +100,7 @@ static void reset_common_data(enum reset_type t)
 
 	/* Set up mock data for verifying keyblock */
 	sd->kernel_version_secdatak = 0x20002;
-	vb2_secdatak_set(&cc, VB2_SECDATAK_VERSIONS, 0x20002);
+	vb2_secdatak_set(&ctx, VB2_SECDATAK_VERSIONS, 0x20002);
 
 	mock_gbb.recovery_key.algorithm = 11;
 	mock_gbb.recovery_key.key_offset =
@@ -130,12 +130,12 @@ static void reset_common_data(enum reset_type t)
 
 	/* If verifying preamble, verify keyblock first to set up data key */
 	if (t == FOR_PREAMBLE)
-		vb2_load_kernel_keyblock(&cc);
+		vb2_load_kernel_keyblock(&ctx);
 };
 
 /* Mocked functions */
 
-int vb2ex_read_resource(struct vb2_context *ctx,
+int vb2ex_read_resource(struct vb2_context *c,
 			enum vb2_resource_index index,
 			uint32_t offset,
 			void *buf,
@@ -246,30 +246,30 @@ static void load_kernel_keyblock_tests(void)
 
 	/* Test successful call */
 	reset_common_data(FOR_KEYBLOCK);
-	wb_used_before = cc.workbuf_used;
-	TEST_SUCC(vb2_load_kernel_keyblock(&cc), "Kernel keyblock good");
+	wb_used_before = ctx.workbuf_used;
+	TEST_SUCC(vb2_load_kernel_keyblock(&ctx), "Kernel keyblock good");
 	TEST_NEQ(sd->flags & VB2_SD_FLAG_KERNEL_SIGNED, 0, "  Kernel signed");
 	TEST_EQ(sd->kernel_version, 0x20000, "keyblock version");
 	TEST_EQ(sd->vblock_preamble_offset, sizeof(mock_vblock.k),
 		"preamble offset");
 	TEST_EQ(sd->workbuf_data_key_offset, wb_used_before,
 		"keyblock data key offset");
-	TEST_EQ(cc.workbuf_used,
+	TEST_EQ(ctx.workbuf_used,
 		vb2_wb_round_up(sd->workbuf_data_key_offset +
 				sd->workbuf_data_key_size),
 		"workbuf used");
 
 	/* Make sure data key was properly saved */
-	k = (struct vb2_packed_key *)(cc.workbuf + sd->workbuf_data_key_offset);
+	k = (struct vb2_packed_key *)(ctx.workbuf + sd->workbuf_data_key_offset);
 	TEST_EQ(k->algorithm, 7, "data key algorithm");
 	TEST_EQ(k->key_version, 2, "data key version");
 	TEST_EQ(k->key_size, sizeof(mock_vblock.k.data_key_data),
 		"data key size");
-	TEST_EQ(memcmp(cc.workbuf + sd->workbuf_data_key_offset +
+	TEST_EQ(memcmp(ctx.workbuf + sd->workbuf_data_key_offset +
 		       k->key_offset, mock_vblock.k.data_key_data,
 		       sizeof(mock_vblock.k.data_key_data)),
 		0, "data key data");
-	TEST_EQ(cc.workbuf_used,
+	TEST_EQ(ctx.workbuf_used,
 		vb2_wb_round_up(sd->workbuf_data_key_offset +
 				sd->workbuf_data_key_size),
 		"workbuf used after");
@@ -277,112 +277,112 @@ static void load_kernel_keyblock_tests(void)
 	/* Test failures */
 	reset_common_data(FOR_KEYBLOCK);
 	mock_unpack_key_retval = VB2_ERROR_MOCK;
-	TEST_EQ(vb2_load_kernel_keyblock(&cc),
+	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
 		VB2_ERROR_MOCK, "Kernel keyblock unpack key");
 
 	reset_common_data(FOR_KEYBLOCK);
-	cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN -
+	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
 			vb2_wb_round_up(sizeof(*kb));
-	TEST_EQ(vb2_load_kernel_keyblock(&cc),
+	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
 		VB2_ERROR_KERNEL_KEYBLOCK_WORKBUF_HEADER,
 		"Kernel keyblock workbuf header");
 
 	reset_common_data(FOR_KEYBLOCK);
 	mock_read_res_fail_on_call = 1;
-	TEST_EQ(vb2_load_kernel_keyblock(&cc),
+	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
 		VB2_ERROR_MOCK, "Kernel keyblock read header");
 
 	reset_common_data(FOR_KEYBLOCK);
-	cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN -
+	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
 			vb2_wb_round_up(kb->keyblock_size);
-	TEST_EQ(vb2_load_kernel_keyblock(&cc),
+	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
 		VB2_ERROR_KERNEL_KEYBLOCK_WORKBUF,
 		"Kernel keyblock workbuf");
 
 	reset_common_data(FOR_KEYBLOCK);
 	mock_read_res_fail_on_call = 2;
-	TEST_EQ(vb2_load_kernel_keyblock(&cc),
+	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
 		VB2_ERROR_MOCK, "Kernel keyblock read");
 
 	/* Normally, require signed keyblock */
 	reset_common_data(FOR_KEYBLOCK);
 	mock_verify_keyblock_retval = VB2_ERROR_MOCK;
-	TEST_EQ(vb2_load_kernel_keyblock(&cc),
+	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
 		VB2_ERROR_MOCK, "Verify keyblock");
 
 	/* Not in dev mode */
 	reset_common_data(FOR_KEYBLOCK);
-	cc.flags |= VB2_CONTEXT_DEVELOPER_MODE;
+	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
 	mock_verify_keyblock_retval = VB2_ERROR_MOCK;
-	TEST_SUCC(vb2_load_kernel_keyblock(&cc), "Kernel keyblock hash good");
+	TEST_SUCC(vb2_load_kernel_keyblock(&ctx), "Kernel keyblock hash good");
 	TEST_EQ(sd->flags & VB2_SD_FLAG_KERNEL_SIGNED, 0, "  Kernel signed");
 
 	/* But we do in dev+rec mode */
 	reset_common_data(FOR_KEYBLOCK);
-	cc.flags |= VB2_CONTEXT_DEVELOPER_MODE | VB2_CONTEXT_RECOVERY_MODE;
+	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE | VB2_CONTEXT_RECOVERY_MODE;
 	mock_verify_keyblock_retval = VB2_ERROR_MOCK;
-	TEST_EQ(vb2_load_kernel_keyblock(&cc),
+	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
 		VB2_ERROR_MOCK, "Kernel keyblock dev+rec");
 
 	/* Test keyblock flags matching mode */
 	reset_common_data(FOR_KEYBLOCK);
 	kb->keyblock_flags &= ~VB2_KEY_BLOCK_FLAG_DEVELOPER_0;
-	TEST_EQ(vb2_load_kernel_keyblock(&cc),
+	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
 		VB2_ERROR_KERNEL_KEYBLOCK_DEV_FLAG,
 		"Kernel keyblock dev only");
 
 	reset_common_data(FOR_KEYBLOCK);
 	kb->keyblock_flags &= ~VB2_KEY_BLOCK_FLAG_RECOVERY_0;
-	TEST_EQ(vb2_load_kernel_keyblock(&cc),
+	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
 		VB2_ERROR_KERNEL_KEYBLOCK_REC_FLAG,
 		"Kernel keyblock rec only");
 
 	reset_common_data(FOR_KEYBLOCK);
 	kb->keyblock_flags &= ~VB2_KEY_BLOCK_FLAG_RECOVERY_1;
-	cc.flags |= VB2_CONTEXT_RECOVERY_MODE;
-	TEST_EQ(vb2_load_kernel_keyblock(&cc),
+	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
 		VB2_ERROR_KERNEL_KEYBLOCK_REC_FLAG,
 		"Kernel keyblock not rec");
 
 	reset_common_data(FOR_KEYBLOCK);
 	kb->keyblock_flags &= ~VB2_KEY_BLOCK_FLAG_DEVELOPER_0;
 	kb->keyblock_flags &= ~VB2_KEY_BLOCK_FLAG_RECOVERY_0;
-	cc.flags |= VB2_CONTEXT_RECOVERY_MODE;
-	TEST_EQ(vb2_load_kernel_keyblock(&cc),
+	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
 		VB2_ERROR_KERNEL_KEYBLOCK_DEV_FLAG,
 		"Kernel keyblock rec but not dev+rec");
 
 	reset_common_data(FOR_KEYBLOCK);
 	kb->keyblock_flags &= ~VB2_KEY_BLOCK_FLAG_DEVELOPER_0;
 	kb->keyblock_flags &= ~VB2_KEY_BLOCK_FLAG_RECOVERY_0;
-	cc.flags |= VB2_CONTEXT_DEVELOPER_MODE | VB2_CONTEXT_RECOVERY_MODE;
-	TEST_SUCC(vb2_load_kernel_keyblock(&cc),
+	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE | VB2_CONTEXT_RECOVERY_MODE;
+	TEST_SUCC(vb2_load_kernel_keyblock(&ctx),
 		  "Kernel keyblock flags dev+rec");
 
 	/* System in dev mode ignores flags */
 	reset_common_data(FOR_KEYBLOCK);
-	cc.flags |= VB2_CONTEXT_DEVELOPER_MODE;
+	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
 	kb->keyblock_flags = 0;
-	TEST_SUCC(vb2_load_kernel_keyblock(&cc), "Kernel keyblock dev flags");
+	TEST_SUCC(vb2_load_kernel_keyblock(&ctx), "Kernel keyblock dev flags");
 
 	/* Test rollback */
 	reset_common_data(FOR_KEYBLOCK);
 	kb->data_key.key_version = 0x10000;
-	TEST_EQ(vb2_load_kernel_keyblock(&cc),
+	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
 		VB2_ERROR_KERNEL_KEYBLOCK_VERSION_RANGE,
 		"Kernel keyblock version range");
 
 	reset_common_data(FOR_KEYBLOCK);
 	kb->data_key.key_version = 1;
-	TEST_EQ(vb2_load_kernel_keyblock(&cc),
+	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
 		VB2_ERROR_KERNEL_KEYBLOCK_VERSION_ROLLBACK,
 		"Kernel keyblock rollback");
 
 	/* Rollback ok in developer mode */
 	reset_common_data(FOR_KEYBLOCK);
 	kb->data_key.key_version = 1;
-	cc.flags |= VB2_CONTEXT_DEVELOPER_MODE;
-	TEST_SUCC(vb2_load_kernel_keyblock(&cc),
+	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
+	TEST_SUCC(vb2_load_kernel_keyblock(&ctx),
 		  "Kernel keyblock rollback dev");
 
 	/*
@@ -391,8 +391,8 @@ static void load_kernel_keyblock_tests(void)
 	 */
 	reset_common_data(FOR_KEYBLOCK);
 	kb->data_key.key_version = 1;
-	cc.flags |= VB2_CONTEXT_RECOVERY_MODE;
-	TEST_SUCC(vb2_load_kernel_keyblock(&cc),
+	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	TEST_SUCC(vb2_load_kernel_keyblock(&ctx),
 		  "Kernel keyblock rollback rec");
 }
 
@@ -404,13 +404,13 @@ static void load_kernel_preamble_tests(void)
 
 	/* Test successful call */
 	reset_common_data(FOR_PREAMBLE);
-	wb_used_before = cc.workbuf_used;
-	TEST_SUCC(vb2_load_kernel_preamble(&cc), "preamble good");
+	wb_used_before = ctx.workbuf_used;
+	TEST_SUCC(vb2_load_kernel_preamble(&ctx), "preamble good");
 	TEST_EQ(sd->kernel_version, 0x20002, "combined version");
 	TEST_EQ(sd->workbuf_preamble_offset, wb_used_before,
 		"preamble offset");
 	TEST_EQ(sd->workbuf_preamble_size, pre->preamble_size, "preamble size");
-	TEST_EQ(cc.workbuf_used,
+	TEST_EQ(ctx.workbuf_used,
 		vb2_wb_round_up(sd->workbuf_preamble_offset +
 				sd->workbuf_preamble_size),
 		"workbuf used");
@@ -418,57 +418,57 @@ static void load_kernel_preamble_tests(void)
 	/* Expected failures */
 	reset_common_data(FOR_PREAMBLE);
 	sd->workbuf_data_key_size = 0;
-	TEST_EQ(vb2_load_kernel_preamble(&cc),
+	TEST_EQ(vb2_load_kernel_preamble(&ctx),
 		VB2_ERROR_KERNEL_PREAMBLE2_DATA_KEY,
 		"preamble no data key");
 
 	reset_common_data(FOR_PREAMBLE);
 	mock_unpack_key_retval = VB2_ERROR_UNPACK_KEY_HASH_ALGORITHM;
-	TEST_EQ(vb2_load_kernel_preamble(&cc),
+	TEST_EQ(vb2_load_kernel_preamble(&ctx),
 		VB2_ERROR_UNPACK_KEY_HASH_ALGORITHM,
 		"preamble unpack data key");
 
 	reset_common_data(FOR_PREAMBLE);
-	cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN -
+	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
 			vb2_wb_round_up(sizeof(struct vb2_kernel_preamble));
-	TEST_EQ(vb2_load_kernel_preamble(&cc),
+	TEST_EQ(vb2_load_kernel_preamble(&ctx),
 		VB2_ERROR_KERNEL_PREAMBLE2_WORKBUF_HEADER,
 		"preamble not enough workbuf for header");
 
 	reset_common_data(FOR_PREAMBLE);
 	sd->vblock_preamble_offset = sizeof(mock_vblock);
-	TEST_EQ(vb2_load_kernel_preamble(&cc),
+	TEST_EQ(vb2_load_kernel_preamble(&ctx),
 		VB2_ERROR_EX_READ_RESOURCE_SIZE,
 		"preamble read header");
 
 	reset_common_data(FOR_PREAMBLE);
-	cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN -
+	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
 			vb2_wb_round_up(sizeof(mock_vblock.p));
-	TEST_EQ(vb2_load_kernel_preamble(&cc),
+	TEST_EQ(vb2_load_kernel_preamble(&ctx),
 		VB2_ERROR_KERNEL_PREAMBLE2_WORKBUF,
 		"preamble not enough workbuf");
 
 	reset_common_data(FOR_PREAMBLE);
 	pre->preamble_size = sizeof(mock_vblock);
-	TEST_EQ(vb2_load_kernel_preamble(&cc),
+	TEST_EQ(vb2_load_kernel_preamble(&ctx),
 		VB2_ERROR_EX_READ_RESOURCE_SIZE,
 		"preamble read full");
 
 	reset_common_data(FOR_PREAMBLE);
 	mock_verify_preamble_retval = VB2_ERROR_MOCK;
-	TEST_EQ(vb2_load_kernel_preamble(&cc),
+	TEST_EQ(vb2_load_kernel_preamble(&ctx),
 		VB2_ERROR_MOCK,
 		"preamble verify");
 
 	reset_common_data(FOR_PREAMBLE);
 	pre->kernel_version = 0x10000;
-	TEST_EQ(vb2_load_kernel_preamble(&cc),
+	TEST_EQ(vb2_load_kernel_preamble(&ctx),
 		VB2_ERROR_KERNEL_PREAMBLE_VERSION_RANGE,
 		"preamble version range");
 
 	reset_common_data(FOR_PREAMBLE);
 	pre->kernel_version = 1;
-	TEST_EQ(vb2_load_kernel_preamble(&cc),
+	TEST_EQ(vb2_load_kernel_preamble(&ctx),
 		VB2_ERROR_KERNEL_PREAMBLE_VERSION_ROLLBACK,
 		"preamble version rollback");
 }
diff --git a/tests/vb20_misc_tests.c b/tests/vb20_misc_tests.c
index 995e0fc6..84e8e96e 100644
--- a/tests/vb20_misc_tests.c
+++ b/tests/vb20_misc_tests.c
@@ -20,7 +20,7 @@
 /* Common context for tests */
 static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
-static struct vb2_context cc;
+static struct vb2_context ctx;
 static struct vb2_shared_data *sd;
 
 /* Mocked function data */
@@ -64,17 +64,17 @@ static void reset_common_data(enum reset_type t)
 
 	memset(workbuf, 0xaa, sizeof(workbuf));
 
-	memset(&cc, 0, sizeof(cc));
-	cc.workbuf = workbuf;
-	cc.workbuf_size = sizeof(workbuf);
+	memset(&ctx, 0, sizeof(ctx));
+	ctx.workbuf = workbuf;
+	ctx.workbuf_size = sizeof(workbuf);
 
-	vb2_init_context(&cc);
-	sd = vb2_get_sd(&cc);
+	vb2_init_context(&ctx);
+	sd = vb2_get_sd(&ctx);
 
-	vb2_nv_init(&cc);
+	vb2_nv_init(&ctx);
 
-	vb2_secdata_create(&cc);
-	vb2_secdata_init(&cc);
+	vb2_secdata_create(&ctx);
+	vb2_secdata_init(&ctx);
 
 	mock_read_res_fail_on_call = 0;
 	mock_unpack_key_retval = VB2_SUCCESS;
@@ -83,7 +83,7 @@ static void reset_common_data(enum reset_type t)
 
 	/* Set up mock data for verifying keyblock */
 	sd->fw_version_secdata = 0x20002;
-	vb2_secdata_set(&cc, VB2_SECDATA_VERSIONS, sd->fw_version_secdata);
+	vb2_secdata_set(&ctx, VB2_SECDATA_VERSIONS, sd->fw_version_secdata);
 
 	sd->gbb_rootkey_offset = vb2_offset_of(&mock_gbb, &mock_gbb.rootkey);
 	sd->gbb_rootkey_size = sizeof(mock_gbb.rootkey_data);
@@ -109,12 +109,12 @@ static void reset_common_data(enum reset_type t)
 
 	/* If verifying preamble, verify keyblock first to set up data key */
 	if (t == FOR_PREAMBLE)
-		vb2_load_fw_keyblock(&cc);
+		vb2_load_fw_keyblock(&ctx);
 };
 
 /* Mocked functions */
 
-int vb2ex_read_resource(struct vb2_context *ctx,
+int vb2ex_read_resource(struct vb2_context *c,
 			enum vb2_resource_index index,
 			uint32_t offset,
 			void *buf,
@@ -180,102 +180,102 @@ static void verify_keyblock_tests(void)
 
 	/* Test successful call */
 	reset_common_data(FOR_KEYBLOCK);
-	wb_used_before = cc.workbuf_used;
-	TEST_SUCC(vb2_load_fw_keyblock(&cc), "keyblock verify");
+	wb_used_before = ctx.workbuf_used;
+	TEST_SUCC(vb2_load_fw_keyblock(&ctx), "keyblock verify");
 	TEST_EQ(sd->fw_version, 0x20000, "keyblock version");
 	TEST_EQ(sd->vblock_preamble_offset, sizeof(mock_vblock.k),
 		"preamble offset");
 	TEST_EQ(sd->workbuf_data_key_offset, wb_used_before,
 		"keyblock data key offset");
-	TEST_EQ(cc.workbuf_used,
+	TEST_EQ(ctx.workbuf_used,
 		vb2_wb_round_up(sd->workbuf_data_key_offset +
 				sd->workbuf_data_key_size),
 		"workbuf used");
 
 	/* Make sure data key was properly saved */
-	k = (struct vb2_packed_key *)(cc.workbuf + sd->workbuf_data_key_offset);
+	k = (struct vb2_packed_key *)(ctx.workbuf + sd->workbuf_data_key_offset);
 	TEST_EQ(k->algorithm, 7, "data key algorithm");
 	TEST_EQ(k->key_version, 2, "data key version");
 	TEST_EQ(k->key_size, sizeof(mock_vblock.k.data_key_data),
 		"data key size");
-	TEST_EQ(memcmp(cc.workbuf + sd->workbuf_data_key_offset +
+	TEST_EQ(memcmp(ctx.workbuf + sd->workbuf_data_key_offset +
 		       k->key_offset, mock_vblock.k.data_key_data,
 		       sizeof(mock_vblock.k.data_key_data)),
 		0, "data key data");
-	TEST_EQ(cc.workbuf_used,
+	TEST_EQ(ctx.workbuf_used,
 		vb2_wb_round_up(sd->workbuf_data_key_offset +
 				sd->workbuf_data_key_size),
 		"workbuf used after");
 
 	/* Test failures */
 	reset_common_data(FOR_KEYBLOCK);
-	cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN -
+	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
 			vb2_wb_round_up(sd->gbb_rootkey_size);
-	TEST_EQ(vb2_load_fw_keyblock(&cc),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_FW_KEYBLOCK_WORKBUF_ROOT_KEY,
 		"keyblock not enough workbuf for root key");
 
 	reset_common_data(FOR_KEYBLOCK);
 	sd->gbb_rootkey_size = sizeof(mock_gbb);
-	TEST_EQ(vb2_load_fw_keyblock(&cc),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_EX_READ_RESOURCE_SIZE,
 		"keyblock read root key");
 
 	reset_common_data(FOR_KEYBLOCK);
 	mock_unpack_key_retval = VB2_ERROR_UNPACK_KEY_SIG_ALGORITHM;
-	TEST_EQ(vb2_load_fw_keyblock(&cc),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_UNPACK_KEY_SIG_ALGORITHM,
 		"keyblock unpack root key");
 
 	reset_common_data(FOR_KEYBLOCK);
-	cc.workbuf_used = cc.workbuf_size -
+	ctx.workbuf_used = ctx.workbuf_size -
 			vb2_wb_round_up(sd->gbb_rootkey_size);
-	TEST_EQ(vb2_load_fw_keyblock(&cc),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_FW_KEYBLOCK_WORKBUF_HEADER,
 		"keyblock not enough workbuf for header");
 
 	reset_common_data(FOR_KEYBLOCK);
 	mock_read_res_fail_on_call = 2;
-	TEST_EQ(vb2_load_fw_keyblock(&cc),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_EX_READ_RESOURCE_INDEX,
 		"keyblock read keyblock header");
 
 	reset_common_data(FOR_KEYBLOCK);
-	cc.workbuf_used = cc.workbuf_size -
+	ctx.workbuf_used = ctx.workbuf_size -
 			vb2_wb_round_up(sd->gbb_rootkey_size) -
 			vb2_wb_round_up(sizeof(struct vb2_keyblock));
-	TEST_EQ(vb2_load_fw_keyblock(&cc),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_FW_KEYBLOCK_WORKBUF,
 		"keyblock not enough workbuf for entire keyblock");
 
 	reset_common_data(FOR_KEYBLOCK);
 	kb->keyblock_size = sizeof(mock_vblock) + 1;
-	TEST_EQ(vb2_load_fw_keyblock(&cc),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_EX_READ_RESOURCE_SIZE,
 		"keyblock read keyblock");
 
 	reset_common_data(FOR_KEYBLOCK);
 	mock_verify_keyblock_retval = VB2_ERROR_KEYBLOCK_MAGIC;
-	TEST_EQ(vb2_load_fw_keyblock(&cc),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_KEYBLOCK_MAGIC,
 		"keyblock verify keyblock");
 
 	reset_common_data(FOR_KEYBLOCK);
 	kb->data_key.key_version = 0x10000;
-	TEST_EQ(vb2_load_fw_keyblock(&cc),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_FW_KEYBLOCK_VERSION_RANGE,
 		"keyblock version range");
 
 	reset_common_data(FOR_KEYBLOCK);
 	kb->data_key.key_version = 1;
-	TEST_EQ(vb2_load_fw_keyblock(&cc),
+	TEST_EQ(vb2_load_fw_keyblock(&ctx),
 		VB2_ERROR_FW_KEYBLOCK_VERSION_ROLLBACK,
 		"keyblock rollback");
 
 	reset_common_data(FOR_KEYBLOCK);
 	kb->data_key.key_version = 1;
 	sd->gbb_flags |= VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK;
-	TEST_SUCC(vb2_load_fw_keyblock(&cc), "keyblock rollback with GBB flag");
+	TEST_SUCC(vb2_load_fw_keyblock(&ctx), "keyblock rollback with GBB flag");
 }
 
 static void verify_preamble_tests(void)
@@ -286,13 +286,13 @@ static void verify_preamble_tests(void)
 
 	/* Test successful call */
 	reset_common_data(FOR_PREAMBLE);
-	wb_used_before = cc.workbuf_used;
-	TEST_SUCC(vb2_load_fw_preamble(&cc), "preamble good");
+	wb_used_before = ctx.workbuf_used;
+	TEST_SUCC(vb2_load_fw_preamble(&ctx), "preamble good");
 	TEST_EQ(sd->fw_version, 0x20002, "combined version");
 	TEST_EQ(sd->workbuf_preamble_offset, wb_used_before,
 		"preamble offset");
 	TEST_EQ(sd->workbuf_preamble_size, pre->preamble_size, "preamble size");
-	TEST_EQ(cc.workbuf_used,
+	TEST_EQ(ctx.workbuf_used,
 		vb2_wb_round_up(sd->workbuf_preamble_offset +
 				sd->workbuf_preamble_size),
 		"workbuf used");
@@ -300,88 +300,88 @@ static void verify_preamble_tests(void)
 	/* Expected failures */
 	reset_common_data(FOR_PREAMBLE);
 	sd->workbuf_data_key_size = 0;
-	TEST_EQ(vb2_load_fw_preamble(&cc),
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
 		VB2_ERROR_FW_PREAMBLE2_DATA_KEY,
 		"preamble no data key");
 
 	reset_common_data(FOR_PREAMBLE);
 	mock_unpack_key_retval = VB2_ERROR_UNPACK_KEY_HASH_ALGORITHM;
-	TEST_EQ(vb2_load_fw_preamble(&cc),
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
 		VB2_ERROR_UNPACK_KEY_HASH_ALGORITHM,
 		"preamble unpack data key");
 
 	reset_common_data(FOR_PREAMBLE);
-	cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN -
+	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
 			vb2_wb_round_up(sizeof(struct vb2_fw_preamble));
-	TEST_EQ(vb2_load_fw_preamble(&cc),
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
 		VB2_ERROR_FW_PREAMBLE2_WORKBUF_HEADER,
 		"preamble not enough workbuf for header");
 
 	reset_common_data(FOR_PREAMBLE);
 	sd->vblock_preamble_offset = sizeof(mock_vblock);
-	TEST_EQ(vb2_load_fw_preamble(&cc),
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
 		VB2_ERROR_EX_READ_RESOURCE_SIZE,
 		"preamble read header");
 
 	reset_common_data(FOR_PREAMBLE);
-	cc.workbuf_used = cc.workbuf_size + VB2_WORKBUF_ALIGN -
+	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
 			vb2_wb_round_up(sizeof(mock_vblock.p));
-	TEST_EQ(vb2_load_fw_preamble(&cc),
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
 		VB2_ERROR_FW_PREAMBLE2_WORKBUF,
 		"preamble not enough workbuf");
 
 	reset_common_data(FOR_PREAMBLE);
 	pre->preamble_size = sizeof(mock_vblock);
-	TEST_EQ(vb2_load_fw_preamble(&cc),
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
 		VB2_ERROR_EX_READ_RESOURCE_SIZE,
 		"preamble read full");
 
 	reset_common_data(FOR_PREAMBLE);
 	mock_verify_preamble_retval = VB2_ERROR_PREAMBLE_SIG_INVALID;
-	TEST_EQ(vb2_load_fw_preamble(&cc),
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
 		VB2_ERROR_PREAMBLE_SIG_INVALID,
 		"preamble verify");
 
 	reset_common_data(FOR_PREAMBLE);
 	pre->firmware_version = 0x10000;
-	TEST_EQ(vb2_load_fw_preamble(&cc),
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
 		VB2_ERROR_FW_PREAMBLE_VERSION_RANGE,
 		"preamble version range");
 
 	reset_common_data(FOR_PREAMBLE);
 	pre->firmware_version = 1;
-	TEST_EQ(vb2_load_fw_preamble(&cc),
+	TEST_EQ(vb2_load_fw_preamble(&ctx),
 		VB2_ERROR_FW_PREAMBLE_VERSION_ROLLBACK,
 		"preamble version rollback");
 
 	reset_common_data(FOR_PREAMBLE);
 	pre->firmware_version = 1;
 	sd->gbb_flags |= VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK;
-	TEST_SUCC(vb2_load_fw_preamble(&cc), "version rollback with GBB flag");
+	TEST_SUCC(vb2_load_fw_preamble(&ctx), "version rollback with GBB flag");
 
 	reset_common_data(FOR_PREAMBLE);
 	pre->firmware_version = 3;
-	TEST_SUCC(vb2_load_fw_preamble(&cc),
+	TEST_SUCC(vb2_load_fw_preamble(&ctx),
 		  "preamble version roll forward");
-	vb2_secdata_get(&cc, VB2_SECDATA_VERSIONS, &v);
+	vb2_secdata_get(&ctx, VB2_SECDATA_VERSIONS, &v);
 	TEST_EQ(v, 0x20003, "roll forward");
 
 	/* Newer version without result success doesn't roll forward */
 	reset_common_data(FOR_PREAMBLE);
 	pre->firmware_version = 3;
 	sd->last_fw_result = VB2_FW_RESULT_UNKNOWN;
-	TEST_SUCC(vb2_load_fw_preamble(&cc),
+	TEST_SUCC(vb2_load_fw_preamble(&ctx),
 		  "preamble version no roll forward 1");
-	vb2_secdata_get(&cc, VB2_SECDATA_VERSIONS, &v);
+	vb2_secdata_get(&ctx, VB2_SECDATA_VERSIONS, &v);
 	TEST_EQ(v, 0x20002, "no roll forward");
 
 	/* Newer version with success but for other slot doesn't roll forward */
 	reset_common_data(FOR_PREAMBLE);
 	pre->firmware_version = 3;
 	sd->last_fw_slot = 1;
-	TEST_SUCC(vb2_load_fw_preamble(&cc),
+	TEST_SUCC(vb2_load_fw_preamble(&ctx),
 		  "preamble version no roll forward 2");
-	vb2_secdata_get(&cc, VB2_SECDATA_VERSIONS, &v);
+	vb2_secdata_get(&ctx, VB2_SECDATA_VERSIONS, &v);
 	TEST_EQ(v, 0x20002, "no roll forward");
 }
 
diff --git a/tests/vb20_verify_fw.c b/tests/vb20_verify_fw.c
index 5025859c..2e098f38 100644
--- a/tests/vb20_verify_fw.c
+++ b/tests/vb20_verify_fw.c
@@ -20,7 +20,7 @@ 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 *ctx,
+int vb2ex_read_resource(struct vb2_context *c,
 			enum vb2_resource_index index,
 			uint32_t offset,
 			void *buf,
@@ -60,7 +60,7 @@ int vb2ex_read_resource(struct vb2_context *ctx,
 	return got_size == size ? VB2_SUCCESS : VB2_ERROR_UNKNOWN;
 }
 
-int vb2ex_tpm_clear_owner(struct vb2_context *ctx)
+int vb2ex_tpm_clear_owner(struct vb2_context *c)
 {
 	// TODO: implement
 	return VB2_SUCCESS;
@@ -69,24 +69,24 @@ int vb2ex_tpm_clear_owner(struct vb2_context *ctx)
 /**
  * Save non-volatile and/or secure data if needed.
  */
-static void save_if_needed(struct vb2_context *ctx)
+static void save_if_needed(struct vb2_context *c)
 {
 
-	if (ctx->flags & VB2_CONTEXT_NVDATA_CHANGED) {
+	if (c->flags & VB2_CONTEXT_NVDATA_CHANGED) {
 		// TODO: implement
-		ctx->flags &= ~VB2_CONTEXT_NVDATA_CHANGED;
+		c->flags &= ~VB2_CONTEXT_NVDATA_CHANGED;
 	}
 
-	if (ctx->flags & VB2_CONTEXT_SECDATA_CHANGED) {
+	if (c->flags & VB2_CONTEXT_SECDATA_CHANGED) {
 		// TODO: implement
-		ctx->flags &= ~VB2_CONTEXT_SECDATA_CHANGED;
+		c->flags &= ~VB2_CONTEXT_SECDATA_CHANGED;
 	}
 }
 
 /**
  * Verify firmware body
  */
-static int hash_body(struct vb2_context *ctx)
+static int hash_body(struct vb2_context *c)
 {
 	uint32_t expect_size;
 	uint8_t block[8192];
@@ -100,7 +100,7 @@ static int hash_body(struct vb2_context *ctx)
 		return VB2_ERROR_TEST_INPUT_FILE;
 
 	/* Start the body hash */
-	rv = vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY, &expect_size);
+	rv = vb2api_init_hash(c, VB2_HASH_TAG_FW_BODY, &expect_size);
 	if (rv) {
 		fclose(f);
 		return rv;
@@ -120,7 +120,7 @@ static int hash_body(struct vb2_context *ctx)
 			break;
 
 		/* Hash it */
-		rv = vb2api_extend_hash(ctx, block, size);
+		rv = vb2api_extend_hash(c, block, size);
 		if (rv) {
 			fclose(f);
 			return rv;
@@ -132,7 +132,7 @@ static int hash_body(struct vb2_context *ctx)
 	fclose(f);
 
 	/* Check the result */
-	rv = vb2api_check_hash(ctx);
+	rv = vb2api_check_hash(c);
 	if (rv)
 		return rv;
 
diff --git a/tests/vb2_api_tests.c b/tests/vb2_api_tests.c
index d45f7451..97fc6d97 100644
--- a/tests/vb2_api_tests.c
+++ b/tests/vb2_api_tests.c
@@ -19,7 +19,7 @@
 /* Common context for tests */
 static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
-static struct vb2_context cc;
+static struct vb2_context ctx;
 static struct vb2_shared_data *sd;
 
 const char mock_body[320] = "Mock body";
@@ -49,17 +49,17 @@ static void reset_common_data(enum reset_type t)
 {
 	memset(workbuf, 0xaa, sizeof(workbuf));
 
-	memset(&cc, 0, sizeof(cc));
-	cc.workbuf = workbuf;
-	cc.workbuf_size = sizeof(workbuf);
+	memset(&ctx, 0, sizeof(ctx));
+	ctx.workbuf = workbuf;
+	ctx.workbuf_size = sizeof(workbuf);
 
-	vb2_init_context(&cc);
-	sd = vb2_get_sd(&cc);
+	vb2_init_context(&ctx);
+	sd = vb2_get_sd(&ctx);
 
-	vb2_nv_init(&cc);
+	vb2_nv_init(&ctx);
 
-	vb2_secdata_create(&cc);
-	vb2_secdata_init(&cc);
+	vb2_secdata_create(&ctx);
+	vb2_secdata_init(&ctx);
 
 	force_dev_mode = 0;
 	retval_vb2_fw_parse_gbb = VB2_SUCCESS;
@@ -73,24 +73,24 @@ static void reset_common_data(enum reset_type t)
 
 /* Mocked functions */
 
-int vb2_fw_parse_gbb(struct vb2_context *ctx)
+int vb2_fw_parse_gbb(struct vb2_context *c)
 {
 	return retval_vb2_fw_parse_gbb;
 }
 
-int vb2_check_dev_switch(struct vb2_context *ctx)
+int 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 *ctx)
+int vb2_check_tpm_clear(struct vb2_context *c)
 {
 	return retval_vb2_check_tpm_clear;
 }
 
-int vb2_select_fw_slot(struct vb2_context *ctx)
+int vb2_select_fw_slot(struct vb2_context *c)
 {
 	return retval_vb2_select_fw_slot;
 }
@@ -102,173 +102,173 @@ static void misc_tests(void)
 	/* Test secdata passthru functions */
 	reset_common_data(FOR_MISC);
 	/* Corrupt secdata so initial check will fail */
-	cc.secdata[0] ^= 0x42;
-	TEST_EQ(vb2api_secdata_check(&cc), VB2_ERROR_SECDATA_CRC,
+	ctx.secdata[0] ^= 0x42;
+	TEST_EQ(vb2api_secdata_check(&ctx), VB2_ERROR_SECDATA_CRC,
 		"secdata check");
-	TEST_SUCC(vb2api_secdata_create(&cc), "secdata create");
-	TEST_SUCC(vb2api_secdata_check(&cc), "secdata check 2");
+	TEST_SUCC(vb2api_secdata_create(&ctx), "secdata create");
+	TEST_SUCC(vb2api_secdata_check(&ctx), "secdata check 2");
 
 	/* Test fail passthru */
 	reset_common_data(FOR_MISC);
-	vb2api_fail(&cc, 12, 34);
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST),
+	vb2api_fail(&ctx, 12, 34);
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		12, "vb2api_fail request");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_SUBCODE),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_SUBCODE),
 		34, "vb2api_fail subcode");
 }
 
 static void phase1_tests(void)
 {
 	reset_common_data(FOR_MISC);
-	TEST_SUCC(vb2api_fw_phase1(&cc), "phase1 good");
+	TEST_SUCC(vb2api_fw_phase1(&ctx), "phase1 good");
 	TEST_EQ(sd->recovery_reason, 0, "  not recovery");
-	TEST_EQ(cc.flags & VB2_CONTEXT_RECOVERY_MODE, 0, "  recovery flag");
-	TEST_EQ(cc.flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
-	TEST_EQ(cc.flags & VB2_CONTEXT_DISPLAY_INIT,
+	TEST_EQ(ctx.flags & VB2_CONTEXT_RECOVERY_MODE, 0, "  recovery flag");
+	TEST_EQ(ctx.flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
+	TEST_EQ(ctx.flags & VB2_CONTEXT_DISPLAY_INIT,
 		0, "  display init context flag");
 	TEST_EQ(sd->flags & VB2_SD_FLAG_DISPLAY_AVAILABLE,
 		0, "  display available SD flag");
 
 	reset_common_data(FOR_MISC);
 	retval_vb2_fw_parse_gbb = VB2_ERROR_GBB_MAGIC;
-	TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_RECOVERY,
+	TEST_EQ(vb2api_fw_phase1(&ctx), VB2_ERROR_API_PHASE1_RECOVERY,
 		"phase1 gbb");
 	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_GBB_HEADER,
 		"  recovery reason");
-	TEST_NEQ(cc.flags & VB2_CONTEXT_RECOVERY_MODE, 0, "  recovery flag");
-	TEST_NEQ(cc.flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
+	TEST_NEQ(ctx.flags & VB2_CONTEXT_RECOVERY_MODE, 0, "  recovery flag");
+	TEST_NEQ(ctx.flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
 
 	/* Dev switch error in normal mode reboots to recovery */
 	reset_common_data(FOR_MISC);
 	retval_vb2_check_dev_switch = VB2_ERROR_MOCK;
-	TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_MOCK, "phase1 dev switch");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2api_fw_phase1(&ctx), VB2_ERROR_MOCK, "phase1 dev switch");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		VB2_RECOVERY_DEV_SWITCH, "  recovery request");
 
 	/* Dev switch error already in recovery mode just proceeds */
 	reset_common_data(FOR_MISC);
-	vb2_nv_set(&cc, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED);
+	vb2_nv_set(&ctx, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED);
 	retval_vb2_check_dev_switch = VB2_ERROR_MOCK;
-	TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_RECOVERY,
+	TEST_EQ(vb2api_fw_phase1(&ctx), VB2_ERROR_API_PHASE1_RECOVERY,
 		"phase1 dev switch error in recovery");
 	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_UNSPECIFIED,
 		"  recovery reason");
 	/* Check that DISPLAY_AVAILABLE gets set on recovery mode. */
-	TEST_NEQ(cc.flags & VB2_CONTEXT_DISPLAY_INIT,
+	TEST_NEQ(ctx.flags & VB2_CONTEXT_DISPLAY_INIT,
 		 0, "  display init context flag");
 	TEST_NEQ(sd->flags & VB2_SD_FLAG_DISPLAY_AVAILABLE,
 		 0, "  display available SD flag");
 
 	reset_common_data(FOR_MISC);
-	cc.secdata[0] ^= 0x42;
-	TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_RECOVERY,
+	ctx.secdata[0] ^= 0x42;
+	TEST_EQ(vb2api_fw_phase1(&ctx), VB2_ERROR_API_PHASE1_RECOVERY,
 		"phase1 secdata");
 	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_SECDATA_INIT,
 		"  recovery reason");
-	TEST_NEQ(cc.flags & VB2_CONTEXT_RECOVERY_MODE, 0, "  recovery flag");
-	TEST_NEQ(cc.flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
+	TEST_NEQ(ctx.flags & VB2_CONTEXT_RECOVERY_MODE, 0, "  recovery flag");
+	TEST_NEQ(ctx.flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
 
 	/* Test secdata-requested reboot */
 	reset_common_data(FOR_MISC);
-	cc.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
-	TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_SECDATA_REBOOT,
+	ctx.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
+	TEST_EQ(vb2api_fw_phase1(&ctx), VB2_ERROR_API_PHASE1_SECDATA_REBOOT,
 		"phase1 secdata reboot normal");
 	TEST_EQ(sd->recovery_reason, 0,	"  recovery reason");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_TPM_REQUESTED_REBOOT),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TPM_REQUESTED_REBOOT),
 		1, "  tpm reboot request");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		0, "  recovery request");
 
 	reset_common_data(FOR_MISC);
-	vb2_nv_set(&cc, VB2_NV_TPM_REQUESTED_REBOOT, 1);
-	TEST_SUCC(vb2api_fw_phase1(&cc), "phase1 secdata reboot back normal");
+	vb2_nv_set(&ctx, VB2_NV_TPM_REQUESTED_REBOOT, 1);
+	TEST_SUCC(vb2api_fw_phase1(&ctx), "phase1 secdata reboot back normal");
 	TEST_EQ(sd->recovery_reason, 0,	"  recovery reason");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_TPM_REQUESTED_REBOOT),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TPM_REQUESTED_REBOOT),
 		0, "  tpm reboot request");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		0, "  recovery request");
 
 	reset_common_data(FOR_MISC);
-	cc.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
-	memset(cc.secdata, 0, sizeof(cc.secdata));
-	TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_SECDATA_REBOOT,
+	ctx.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
+	memset(ctx.secdata, 0, sizeof(ctx.secdata));
+	TEST_EQ(vb2api_fw_phase1(&ctx), VB2_ERROR_API_PHASE1_SECDATA_REBOOT,
 		"phase1 secdata reboot normal, secdata blank");
 	TEST_EQ(sd->recovery_reason, 0,	"  recovery reason");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_TPM_REQUESTED_REBOOT),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TPM_REQUESTED_REBOOT),
 		1, "  tpm reboot request");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		0, "  recovery request");
 
 	reset_common_data(FOR_MISC);
-	cc.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
-	vb2_nv_set(&cc, VB2_NV_TPM_REQUESTED_REBOOT, 1);
-	TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_RECOVERY,
+	ctx.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
+	vb2_nv_set(&ctx, VB2_NV_TPM_REQUESTED_REBOOT, 1);
+	TEST_EQ(vb2api_fw_phase1(&ctx), VB2_ERROR_API_PHASE1_RECOVERY,
 		"phase1 secdata reboot normal again");
 	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_TPM_REBOOT,
 		"  recovery reason");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_TPM_REQUESTED_REBOOT),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TPM_REQUESTED_REBOOT),
 		1, "  tpm reboot request");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		0, "  recovery request");
 
 	reset_common_data(FOR_MISC);
-	cc.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
-	vb2_nv_set(&cc, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED);
-	TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_SECDATA_REBOOT,
+	ctx.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
+	vb2_nv_set(&ctx, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED);
+	TEST_EQ(vb2api_fw_phase1(&ctx), VB2_ERROR_API_PHASE1_SECDATA_REBOOT,
 		"phase1 secdata reboot recovery");
 	/* Recovery reason isn't set this boot because we're rebooting first */
 	TEST_EQ(sd->recovery_reason, 0, "  recovery reason not set THIS boot");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_TPM_REQUESTED_REBOOT),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TPM_REQUESTED_REBOOT),
 		1, "  tpm reboot request");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		VB2_RECOVERY_RO_UNSPECIFIED, "  recovery request not cleared");
 
 	reset_common_data(FOR_MISC);
-	vb2_nv_set(&cc, VB2_NV_TPM_REQUESTED_REBOOT, 1);
-	vb2_nv_set(&cc, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED);
-	TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_RECOVERY,
+	vb2_nv_set(&ctx, VB2_NV_TPM_REQUESTED_REBOOT, 1);
+	vb2_nv_set(&ctx, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED);
+	TEST_EQ(vb2api_fw_phase1(&ctx), VB2_ERROR_API_PHASE1_RECOVERY,
 		"phase1 secdata reboot back recovery");
 	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_UNSPECIFIED,
 		"  recovery reason");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_TPM_REQUESTED_REBOOT),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TPM_REQUESTED_REBOOT),
 		0, "  tpm reboot request");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0,
 		"  recovery request cleared");
 
 	reset_common_data(FOR_MISC);
-	cc.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
-	vb2_nv_set(&cc, VB2_NV_TPM_REQUESTED_REBOOT, 1);
-	vb2_nv_set(&cc, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED);
-	TEST_EQ(vb2api_fw_phase1(&cc), VB2_ERROR_API_PHASE1_RECOVERY,
+	ctx.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
+	vb2_nv_set(&ctx, VB2_NV_TPM_REQUESTED_REBOOT, 1);
+	vb2_nv_set(&ctx, VB2_NV_RECOVERY_REQUEST, VB2_RECOVERY_RO_UNSPECIFIED);
+	TEST_EQ(vb2api_fw_phase1(&ctx), VB2_ERROR_API_PHASE1_RECOVERY,
 		"phase1 secdata reboot recovery again");
 	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_UNSPECIFIED,
 		"  recovery reason");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_TPM_REQUESTED_REBOOT),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TPM_REQUESTED_REBOOT),
 		1, "  tpm reboot request");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0,
 		"  recovery request cleared");
 
 	/* Cases for checking DISPLAY_INIT and DISPLAY_AVAILABLE. */
 	reset_common_data(FOR_MISC);
-	cc.flags |= VB2_CONTEXT_DISPLAY_INIT;
-	TEST_SUCC(vb2api_fw_phase1(&cc), "phase1 with DISPLAY_INIT");
-	TEST_NEQ(cc.flags & VB2_CONTEXT_DISPLAY_INIT,
+	ctx.flags |= VB2_CONTEXT_DISPLAY_INIT;
+	TEST_SUCC(vb2api_fw_phase1(&ctx), "phase1 with DISPLAY_INIT");
+	TEST_NEQ(ctx.flags & VB2_CONTEXT_DISPLAY_INIT,
 		 0, "  display init context flag");
 	TEST_NEQ(sd->flags & VB2_SD_FLAG_DISPLAY_AVAILABLE,
 		 0, "  display available SD flag");
 
 	reset_common_data(FOR_MISC);
-	vb2_nv_set(&cc, VB2_NV_DISPLAY_REQUEST, 1);
-	TEST_SUCC(vb2api_fw_phase1(&cc), "phase1 with DISPLAY_REQUEST");
-	TEST_NEQ(cc.flags & VB2_CONTEXT_DISPLAY_INIT,
+	vb2_nv_set(&ctx, VB2_NV_DISPLAY_REQUEST, 1);
+	TEST_SUCC(vb2api_fw_phase1(&ctx), "phase1 with DISPLAY_REQUEST");
+	TEST_NEQ(ctx.flags & VB2_CONTEXT_DISPLAY_INIT,
 		 0, "  display init context flag");
 	TEST_NEQ(sd->flags & VB2_SD_FLAG_DISPLAY_AVAILABLE,
 		 0, "  display available SD flag");
 
 	reset_common_data(FOR_MISC);
 	force_dev_mode = 1;
-	TEST_SUCC(vb2api_fw_phase1(&cc), "phase1 in dev mode");
-	TEST_NEQ(cc.flags & VB2_CONTEXT_DISPLAY_INIT,
+	TEST_SUCC(vb2api_fw_phase1(&ctx), "phase1 in dev mode");
+	TEST_NEQ(ctx.flags & VB2_CONTEXT_DISPLAY_INIT,
 		 0, "  display init context flag");
 	TEST_NEQ(sd->flags & VB2_SD_FLAG_DISPLAY_AVAILABLE,
 		 0, "  display available SD flag");
@@ -277,40 +277,40 @@ static void phase1_tests(void)
 static void phase2_tests(void)
 {
 	reset_common_data(FOR_MISC);
-	TEST_SUCC(vb2api_fw_phase2(&cc), "phase2 good");
-	TEST_EQ(cc.flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
-	TEST_EQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, "  slot b flag");
+	TEST_SUCC(vb2api_fw_phase2(&ctx), "phase2 good");
+	TEST_EQ(ctx.flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
+	TEST_EQ(ctx.flags & VB2_CONTEXT_FW_SLOT_B, 0, "  slot b flag");
 
 	reset_common_data(FOR_MISC);
-	cc.flags |= VB2_CONTEXT_DEVELOPER_MODE;
-	TEST_SUCC(vb2api_fw_phase2(&cc), "phase2 dev");
-	TEST_NEQ(cc.flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
+	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
+	TEST_SUCC(vb2api_fw_phase2(&ctx), "phase2 dev");
+	TEST_NEQ(ctx.flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
 
 	reset_common_data(FOR_MISC);
 	retval_vb2_check_tpm_clear = VB2_ERROR_MOCK;
-	TEST_EQ(vb2api_fw_phase2(&cc), VB2_ERROR_MOCK, "phase2 tpm clear");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2api_fw_phase2(&ctx), VB2_ERROR_MOCK, "phase2 tpm clear");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		VB2_RECOVERY_TPM_CLEAR_OWNER, "  recovery reason");
 
 	reset_common_data(FOR_MISC);
 	retval_vb2_select_fw_slot = VB2_ERROR_MOCK;
-	TEST_EQ(vb2api_fw_phase2(&cc), VB2_ERROR_MOCK, "phase2 slot");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2api_fw_phase2(&ctx), VB2_ERROR_MOCK, "phase2 slot");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		VB2_RECOVERY_FW_SLOT, "  recovery reason");
 
 	/* S3 resume exits before clearing RAM */
 	reset_common_data(FOR_MISC);
-	cc.flags |= VB2_CONTEXT_S3_RESUME;
-	cc.flags |= VB2_CONTEXT_DEVELOPER_MODE;
-	TEST_SUCC(vb2api_fw_phase2(&cc), "phase2 s3 dev");
-	TEST_EQ(cc.flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
-	TEST_EQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, "  slot b flag");
+	ctx.flags |= VB2_CONTEXT_S3_RESUME;
+	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
+	TEST_SUCC(vb2api_fw_phase2(&ctx), "phase2 s3 dev");
+	TEST_EQ(ctx.flags & VB2_CONTEXT_CLEAR_RAM, 0, "  clear ram flag");
+	TEST_EQ(ctx.flags & VB2_CONTEXT_FW_SLOT_B, 0, "  slot b flag");
 
 	reset_common_data(FOR_MISC);
-	cc.flags |= VB2_CONTEXT_S3_RESUME;
-	vb2_nv_set(&cc, VB2_NV_FW_TRIED, 1);
-	TEST_SUCC(vb2api_fw_phase2(&cc), "phase2 s3");
-	TEST_NEQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, "  slot b flag");
+	ctx.flags |= VB2_CONTEXT_S3_RESUME;
+	vb2_nv_set(&ctx, VB2_NV_FW_TRIED, 1);
+	TEST_SUCC(vb2api_fw_phase2(&ctx), "phase2 s3");
+	TEST_NEQ(ctx.flags & VB2_CONTEXT_FW_SLOT_B, 0, "  slot b flag");
 }
 
 static void get_pcr_digest_tests(void)
@@ -325,7 +325,7 @@ static void get_pcr_digest_tests(void)
 	digest_size = sizeof(digest);
 	memset(digest, 0, sizeof(digest));
 	TEST_SUCC(vb2api_get_pcr_digest(
-			&cc, BOOT_MODE_PCR, digest, &digest_size),
+			&ctx, BOOT_MODE_PCR, digest, &digest_size),
 		  "BOOT_MODE_PCR");
 	TEST_EQ(digest_size, VB2_SHA1_DIGEST_SIZE, "BOOT_MODE_PCR digest size");
 	TEST_TRUE(memcmp(digest, digest_org, digest_size),
@@ -334,7 +334,7 @@ static void get_pcr_digest_tests(void)
 	digest_size = sizeof(digest);
 	memset(digest, 0, sizeof(digest));
 	TEST_SUCC(vb2api_get_pcr_digest(
-			&cc, HWID_DIGEST_PCR, digest, &digest_size),
+			&ctx, HWID_DIGEST_PCR, digest, &digest_size),
 		  "HWID_DIGEST_PCR");
 	TEST_EQ(digest_size, VB2_GBB_HWID_DIGEST_SIZE,
 		"HWID_DIGEST_PCR digest size");
@@ -342,12 +342,12 @@ static void get_pcr_digest_tests(void)
 		   "HWID_DIGEST_PCR digest");
 
 	digest_size = 1;
-	TEST_EQ(vb2api_get_pcr_digest(&cc, BOOT_MODE_PCR, digest, &digest_size),
+	TEST_EQ(vb2api_get_pcr_digest(&ctx, BOOT_MODE_PCR, digest, &digest_size),
 		VB2_ERROR_API_PCR_DIGEST_BUF,
 		"BOOT_MODE_PCR buffer too small");
 
 	TEST_EQ(vb2api_get_pcr_digest(
-			&cc, HWID_DIGEST_PCR + 1, digest, &digest_size),
+			&ctx, HWID_DIGEST_PCR + 1, digest, &digest_size),
 		VB2_ERROR_API_PCR_DIGEST,
 		"invalid enum vb2_pcr_digest");
 }
diff --git a/tests/vb2_misc_tests.c b/tests/vb2_misc_tests.c
index 781b0847..0f3f0c58 100644
--- a/tests/vb2_misc_tests.c
+++ b/tests/vb2_misc_tests.c
@@ -17,7 +17,7 @@
 /* Common context for tests */
 static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
-static struct vb2_context cc;
+static struct vb2_context ctx;
 static struct vb2_shared_data *sd;
 
 /* Mocked function data */
@@ -32,17 +32,17 @@ static void reset_common_data(void)
 {
 	memset(workbuf, 0xaa, sizeof(workbuf));
 
-	memset(&cc, 0, sizeof(cc));
-	cc.workbuf = workbuf;
-	cc.workbuf_size = sizeof(workbuf);
+	memset(&ctx, 0, sizeof(ctx));
+	ctx.workbuf = workbuf;
+	ctx.workbuf_size = sizeof(workbuf);
 
-	vb2_init_context(&cc);
-	sd = vb2_get_sd(&cc);
+	vb2_init_context(&ctx);
+	sd = vb2_get_sd(&ctx);
 
-	vb2_nv_init(&cc);
+	vb2_nv_init(&ctx);
 
-	vb2_secdata_create(&cc);
-	vb2_secdata_init(&cc);
+	vb2_secdata_create(&ctx);
+	vb2_secdata_init(&ctx);
 
 	mock_tpm_clear_called = 0;
 	mock_tpm_clear_retval = VB2_SUCCESS;
@@ -50,7 +50,7 @@ static void reset_common_data(void)
 
 /* Mocked functions */
 
-int vb2ex_read_resource(struct vb2_context *ctx,
+int vb2ex_read_resource(struct vb2_context *c,
 			enum vb2_resource_index index,
 			uint32_t offset,
 			void *buf,
@@ -66,7 +66,7 @@ int vb2ex_read_resource(struct vb2_context *ctx,
 	return VB2_SUCCESS;
 }
 
-int vb2ex_tpm_clear_owner(struct vb2_context *ctx)
+int vb2ex_tpm_clear_owner(struct vb2_context *c)
 {
 	mock_tpm_clear_called++;
 
@@ -148,13 +148,13 @@ static void misc_tests(void)
 	struct vb2_workbuf wb;
 
 	reset_common_data();
-	cc.workbuf_used = VB2_WORKBUF_ALIGN;
+	ctx.workbuf_used = VB2_WORKBUF_ALIGN;
 
-	vb2_workbuf_from_ctx(&cc, &wb);
+	vb2_workbuf_from_ctx(&ctx, &wb);
 
 	TEST_PTR_EQ(wb.buf, workbuf + VB2_WORKBUF_ALIGN,
 		    "vb_workbuf_from_ctx() buf");
-	TEST_EQ(wb.size, cc.workbuf_size - VB2_WORKBUF_ALIGN,
+	TEST_EQ(wb.size, ctx.workbuf_size - VB2_WORKBUF_ALIGN,
 		"vb_workbuf_from_ctx() size");
 }
 
@@ -182,52 +182,52 @@ static void gbb_tests(void)
 	mock_resource_index = VB2_RES_GBB;
 	mock_resource_ptr = &gbb;
 	mock_resource_size = sizeof(gbb);
-	TEST_SUCC(vb2_read_gbb_header(&cc, &gbbdest), "read gbb header good");
+	TEST_SUCC(vb2_read_gbb_header(&ctx, &gbbdest), "read gbb header good");
 	TEST_SUCC(memcmp(&gbb, &gbbdest, sizeof(gbb)), "read gbb contents");
 
 	mock_resource_index = VB2_RES_GBB + 1;
-	TEST_EQ(vb2_read_gbb_header(&cc, &gbbdest),
+	TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest),
 		VB2_ERROR_EX_READ_RESOURCE_INDEX, "read gbb header missing");
 	mock_resource_index = VB2_RES_GBB;
 
 	gbb.signature[0]++;
-	TEST_EQ(vb2_read_gbb_header(&cc, &gbbdest),
+	TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest),
 		VB2_ERROR_GBB_MAGIC, "read gbb header bad magic");
 	gbb.signature[0]--;
 
 	gbb.major_version = VB2_GBB_MAJOR_VER + 1;
-	TEST_EQ(vb2_read_gbb_header(&cc, &gbbdest),
+	TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest),
 		VB2_ERROR_GBB_VERSION, "read gbb header major version");
 	gbb.major_version = VB2_GBB_MAJOR_VER;
 
 	gbb.minor_version = VB2_GBB_MINOR_VER + 1;
-	TEST_SUCC(vb2_read_gbb_header(&cc, &gbbdest),
+	TEST_SUCC(vb2_read_gbb_header(&ctx, &gbbdest),
 		  "read gbb header minor++");
 	gbb.minor_version = 1;
-	TEST_EQ(vb2_read_gbb_header(&cc, &gbbdest),
+	TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest),
 		VB2_ERROR_GBB_TOO_OLD, "read gbb header 1.1 fails");
 	gbb.minor_version = 0;
-	TEST_EQ(vb2_read_gbb_header(&cc, &gbbdest),
+	TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest),
 		VB2_ERROR_GBB_TOO_OLD, "read gbb header 1.0 fails");
 	gbb.minor_version = VB2_GBB_MINOR_VER;
 
 	gbb.header_size--;
-	TEST_EQ(vb2_read_gbb_header(&cc, &gbbdest),
+	TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest),
 		VB2_ERROR_GBB_HEADER_SIZE, "read gbb header size");
-	TEST_EQ(vb2_fw_parse_gbb(&cc),
+	TEST_EQ(vb2_fw_parse_gbb(&ctx),
 		VB2_ERROR_GBB_HEADER_SIZE, "parse gbb failure");
 	gbb.header_size++;
 
 	/* Parse GBB */
-	TEST_SUCC(vb2_fw_parse_gbb(&cc), "parse gbb");
+	TEST_SUCC(vb2_fw_parse_gbb(&ctx), "parse gbb");
 	TEST_EQ(sd->gbb_flags, gbb.flags, "gbb flags");
 	TEST_EQ(sd->gbb_rootkey_offset, gbb.rootkey_offset, "rootkey offset");
 	TEST_EQ(sd->gbb_rootkey_size, gbb.rootkey_size, "rootkey size");
 
 	/* Workbuf failure */
 	reset_common_data();
-	cc.workbuf_used = cc.workbuf_size - 4;
-	TEST_EQ(vb2_fw_parse_gbb(&cc),
+	ctx.workbuf_used = ctx.workbuf_size - 4;
+	TEST_EQ(vb2_fw_parse_gbb(&ctx),
 		VB2_ERROR_GBB_WORKBUF, "parse gbb no workbuf");
 }
 
@@ -236,34 +236,34 @@ static void fail_tests(void)
 	/* Early fail (before even NV init) */
 	reset_common_data();
 	sd->status &= ~VB2_SD_STATUS_NV_INIT;
-	vb2_fail(&cc, 1, 2);
+	vb2_fail(&ctx, 1, 2);
 	TEST_NEQ(sd->status & VB2_SD_STATUS_NV_INIT, 0, "vb2_fail inits NV");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		1, "vb2_fail request");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_SUBCODE),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_SUBCODE),
 		2, "vb2_fail subcode");
 
 	/* Repeated fail doesn't overwrite the error code */
-	vb2_fail(&cc, 3, 4);
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST),
+	vb2_fail(&ctx, 3, 4);
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		1, "vb2_fail repeat");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_SUBCODE),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_SUBCODE),
 		2, "vb2_fail repeat2");
 
 	/* Fail with other slot good doesn't trigger recovery */
 	reset_common_data();
-	vb2_nv_set(&cc, VB2_NV_TRY_COUNT, 3);
-	vb2_nv_set(&cc, VB2_NV_FW_RESULT, VB2_FW_RESULT_UNKNOWN);
+	vb2_nv_set(&ctx, VB2_NV_TRY_COUNT, 3);
+	vb2_nv_set(&ctx, VB2_NV_FW_RESULT, VB2_FW_RESULT_UNKNOWN);
 	sd->status |= VB2_SD_STATUS_CHOSE_SLOT;
 	sd->fw_slot = 0;
 	sd->last_fw_slot = 1;
 	sd->last_fw_result = VB2_FW_RESULT_UNKNOWN;
-	vb2_fail(&cc, 5, 6);
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), 0, "vb2_failover");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_RESULT),
+	vb2_fail(&ctx, 5, 6);
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "vb2_failover");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_RESULT),
 		VB2_FW_RESULT_FAILURE, "vb2_fail this fw");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_TRY_COUNT), 0, "vb2_fail use up tries");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_TRY_NEXT), 1, "vb2_fail try other slot");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TRY_COUNT), 0, "vb2_fail use up tries");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TRY_NEXT), 1, "vb2_fail try other slot");
 
 	/* Fail with other slot already failing triggers recovery */
 	reset_common_data();
@@ -271,50 +271,50 @@ static void fail_tests(void)
 	sd->fw_slot = 1;
 	sd->last_fw_slot = 0;
 	sd->last_fw_result = VB2_FW_RESULT_FAILURE;
-	vb2_fail(&cc, 7, 8);
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), 7,
+	vb2_fail(&ctx, 7, 8);
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 7,
 		"vb2_fail both slots bad");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_RESULT),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_RESULT),
 		VB2_FW_RESULT_FAILURE, "vb2_fail this fw");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_TRY_NEXT), 0, "vb2_fail try other slot");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TRY_NEXT), 0, "vb2_fail try other slot");
 }
 
 static void recovery_tests(void)
 {
 	/* No recovery */
 	reset_common_data();
-	vb2_check_recovery(&cc);
+	vb2_check_recovery(&ctx);
 	TEST_EQ(sd->recovery_reason, 0, "No recovery reason");
 	TEST_EQ(sd->flags & VB2_SD_FLAG_MANUAL_RECOVERY,
 		0, "Not manual recovery");
-	TEST_EQ(cc.flags & VB2_CONTEXT_RECOVERY_MODE,
+	TEST_EQ(ctx.flags & VB2_CONTEXT_RECOVERY_MODE,
 		0, "Not recovery mode");
 
 	/* From request */
 	reset_common_data();
-	vb2_nv_set(&cc, VB2_NV_RECOVERY_REQUEST, 3);
-	vb2_check_recovery(&cc);
+	vb2_nv_set(&ctx, VB2_NV_RECOVERY_REQUEST, 3);
+	vb2_check_recovery(&ctx);
 	TEST_EQ(sd->recovery_reason, 3, "Recovery reason from request");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST), 0, "NV cleared");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "NV cleared");
 	TEST_EQ(sd->flags & VB2_SD_FLAG_MANUAL_RECOVERY,
 		0, "Not manual recovery");
-	TEST_NEQ(cc.flags & VB2_CONTEXT_RECOVERY_MODE,
+	TEST_NEQ(ctx.flags & VB2_CONTEXT_RECOVERY_MODE,
 		 0, "Recovery mode");
 
 	/* From request, but already failed */
 	reset_common_data();
-	vb2_nv_set(&cc, VB2_NV_RECOVERY_REQUEST, 4);
+	vb2_nv_set(&ctx, VB2_NV_RECOVERY_REQUEST, 4);
 	sd->recovery_reason = 5;
-	vb2_check_recovery(&cc);
+	vb2_check_recovery(&ctx);
 	TEST_EQ(sd->recovery_reason, 5, "Recovery reason already failed");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		0, "NV still cleared");
 
 	/* Override */
 	reset_common_data();
 	sd->recovery_reason = 6;
-	cc.flags |= VB2_CONTEXT_FORCE_RECOVERY_MODE;
-	vb2_check_recovery(&cc);
+	ctx.flags |= VB2_CONTEXT_FORCE_RECOVERY_MODE;
+	vb2_check_recovery(&ctx);
 	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_MANUAL,
 		"Recovery reason forced");
 	TEST_NEQ(sd->flags & VB2_SD_FLAG_MANUAL_RECOVERY,
@@ -322,9 +322,9 @@ static void recovery_tests(void)
 
 	/* Override at broken screen */
 	reset_common_data();
-	vb2_nv_set(&cc, VB2_NV_RECOVERY_SUBCODE, VB2_RECOVERY_US_TEST);
-	cc.flags |= VB2_CONTEXT_FORCE_RECOVERY_MODE;
-	vb2_check_recovery(&cc);
+	vb2_nv_set(&ctx, VB2_NV_RECOVERY_SUBCODE, VB2_RECOVERY_US_TEST);
+	ctx.flags |= VB2_CONTEXT_FORCE_RECOVERY_MODE;
+	vb2_check_recovery(&ctx);
 	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_US_TEST,
 		"Recovery reason forced from broken");
 	TEST_NEQ(sd->flags & VB2_SD_FLAG_MANUAL_RECOVERY,
@@ -337,107 +337,107 @@ static void dev_switch_tests(void)
 
 	/* Normal mode */
 	reset_common_data();
-	TEST_SUCC(vb2_check_dev_switch(&cc), "dev mode off");
+	TEST_SUCC(vb2_check_dev_switch(&ctx), "dev mode off");
 	TEST_EQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, "  sd not in dev");
-	TEST_EQ(cc.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, "  ctx not in dev");
+	TEST_EQ(ctx.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, "  ctx not in dev");
 	TEST_EQ(mock_tpm_clear_called, 0, "  no tpm clear");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_REQ_WIPEOUT), 0, "  no nv wipeout");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_REQ_WIPEOUT), 0, "  no nv wipeout");
 
 	/* Dev mode */
 	reset_common_data();
-	vb2_secdata_set(&cc, VB2_SECDATA_FLAGS,
+	vb2_secdata_set(&ctx, VB2_SECDATA_FLAGS,
 			(VB2_SECDATA_FLAG_DEV_MODE |
 			 VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER));
-	TEST_SUCC(vb2_check_dev_switch(&cc), "dev mode on");
+	TEST_SUCC(vb2_check_dev_switch(&ctx), "dev mode on");
 	TEST_NEQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, "  sd in dev");
-	TEST_NEQ(cc.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, "  ctx in dev");
+	TEST_NEQ(ctx.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, "  ctx in dev");
 	TEST_EQ(mock_tpm_clear_called, 0, "  no tpm clear");
 
 	/* Any normal mode boot clears dev boot flags */
 	reset_common_data();
-	vb2_nv_set(&cc, VB2_NV_DEV_BOOT_USB, 1);
-	vb2_nv_set(&cc, VB2_NV_DEV_BOOT_LEGACY, 1);
-	vb2_nv_set(&cc, VB2_NV_DEV_BOOT_SIGNED_ONLY, 1);
-	vb2_nv_set(&cc, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP, 1);
-	vb2_nv_set(&cc, VB2_NV_DEV_DEFAULT_BOOT, 1);
-	vb2_nv_set(&cc, VB2_NV_FASTBOOT_UNLOCK_IN_FW, 1);
-	TEST_SUCC(vb2_check_dev_switch(&cc), "dev mode off");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_DEV_BOOT_USB),
+	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
+	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_SIGNED_ONLY, 1);
+	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP, 1);
+	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT, 1);
+	vb2_nv_set(&ctx, VB2_NV_FASTBOOT_UNLOCK_IN_FW, 1);
+	TEST_SUCC(vb2_check_dev_switch(&ctx), "dev mode off");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DEV_BOOT_USB),
 		0, "  cleared dev boot usb");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_DEV_BOOT_LEGACY),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DEV_BOOT_LEGACY),
 		0, "  cleared dev boot legacy");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_DEV_BOOT_SIGNED_ONLY),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DEV_BOOT_SIGNED_ONLY),
 		0, "  cleared dev boot signed only");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP),
 		0, "  cleared dev boot fastboot full cap");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_DEV_DEFAULT_BOOT),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DEV_DEFAULT_BOOT),
 		0, "  cleared dev default boot");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_FASTBOOT_UNLOCK_IN_FW),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FASTBOOT_UNLOCK_IN_FW),
 		0, "  cleared dev boot fastboot unlock in fw");
 
 	/* Normal-dev transition clears TPM */
 	reset_common_data();
-	vb2_secdata_set(&cc, VB2_SECDATA_FLAGS, VB2_SECDATA_FLAG_DEV_MODE);
-	TEST_SUCC(vb2_check_dev_switch(&cc), "to dev mode");
+	vb2_secdata_set(&ctx, VB2_SECDATA_FLAGS, VB2_SECDATA_FLAG_DEV_MODE);
+	TEST_SUCC(vb2_check_dev_switch(&ctx), "to dev mode");
 	TEST_EQ(mock_tpm_clear_called, 1, "  tpm clear");
-	vb2_secdata_get(&cc, VB2_SECDATA_FLAGS, &v);
+	vb2_secdata_get(&ctx, VB2_SECDATA_FLAGS, &v);
 	TEST_EQ(v, (VB2_SECDATA_FLAG_DEV_MODE |
 		    VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER),
 		"  last boot developer now");
 
 	/* Dev-normal transition clears TPM too */
 	reset_common_data();
-	vb2_secdata_set(&cc, VB2_SECDATA_FLAGS,
+	vb2_secdata_set(&ctx, VB2_SECDATA_FLAGS,
 			VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER);
-	TEST_SUCC(vb2_check_dev_switch(&cc), "from dev mode");
+	TEST_SUCC(vb2_check_dev_switch(&ctx), "from dev mode");
 	TEST_EQ(mock_tpm_clear_called, 1, "  tpm clear");
-	vb2_secdata_get(&cc, VB2_SECDATA_FLAGS, &v);
+	vb2_secdata_get(&ctx, VB2_SECDATA_FLAGS, &v);
 	TEST_EQ(v, 0, "  last boot not developer now");
 
 	/* Disable dev mode */
 	reset_common_data();
-	vb2_secdata_set(&cc, VB2_SECDATA_FLAGS,
+	vb2_secdata_set(&ctx, VB2_SECDATA_FLAGS,
 			(VB2_SECDATA_FLAG_DEV_MODE |
 			 VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER));
-	vb2_nv_set(&cc, VB2_NV_DISABLE_DEV_REQUEST, 1);
-	TEST_SUCC(vb2_check_dev_switch(&cc), "disable dev request");
+	vb2_nv_set(&ctx, VB2_NV_DISABLE_DEV_REQUEST, 1);
+	TEST_SUCC(vb2_check_dev_switch(&ctx), "disable dev request");
 	TEST_EQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, "  sd not in dev");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_DISABLE_DEV_REQUEST),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISABLE_DEV_REQUEST),
 		0, "  request cleared");
 
 	/* Force enabled by GBB */
 	reset_common_data();
 	sd->gbb_flags |= VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON;
-	TEST_SUCC(vb2_check_dev_switch(&cc), "dev on via gbb");
+	TEST_SUCC(vb2_check_dev_switch(&ctx), "dev on via gbb");
 	TEST_NEQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, "  sd in dev");
-	vb2_secdata_get(&cc, VB2_SECDATA_FLAGS, &v);
+	vb2_secdata_get(&ctx, VB2_SECDATA_FLAGS, &v);
 	TEST_EQ(v, VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER,
 		"  doesn't set dev on in secdata but does set last boot dev");
 	TEST_EQ(mock_tpm_clear_called, 1, "  tpm clear");
 
 	/* Request disable by ctx flag */
 	reset_common_data();
-	vb2_secdata_set(&cc, VB2_SECDATA_FLAGS,
+	vb2_secdata_set(&ctx, VB2_SECDATA_FLAGS,
 			(VB2_SECDATA_FLAG_DEV_MODE |
 			 VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER));
-	cc.flags |= VB2_CONTEXT_DISABLE_DEVELOPER_MODE;
-	TEST_SUCC(vb2_check_dev_switch(&cc), "disable dev on ctx request");
+	ctx.flags |= VB2_CONTEXT_DISABLE_DEVELOPER_MODE;
+	TEST_SUCC(vb2_check_dev_switch(&ctx), "disable dev on ctx request");
 	TEST_EQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, "  sd not in dev");
 
 	/* Simulate clear owner failure */
 	reset_common_data();
-	vb2_secdata_set(&cc, VB2_SECDATA_FLAGS,
+	vb2_secdata_set(&ctx, VB2_SECDATA_FLAGS,
 			VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER);
 	mock_tpm_clear_retval = VB2_ERROR_EX_TPM_CLEAR_OWNER;
-	TEST_EQ(vb2_check_dev_switch(&cc),
+	TEST_EQ(vb2_check_dev_switch(&ctx),
 		VB2_ERROR_EX_TPM_CLEAR_OWNER, "tpm clear fail");
 	TEST_EQ(mock_tpm_clear_called, 1, "  tpm clear");
-	vb2_secdata_get(&cc, VB2_SECDATA_FLAGS, &v);
+	vb2_secdata_get(&ctx, VB2_SECDATA_FLAGS, &v);
 	TEST_EQ(v, VB2_SECDATA_FLAG_LAST_BOOT_DEVELOPER,
 		"  last boot still developer");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
 		VB2_RECOVERY_TPM_CLEAR_OWNER, "  requests recovery");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_RECOVERY_SUBCODE),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_SUBCODE),
 		(uint8_t)VB2_ERROR_EX_TPM_CLEAR_OWNER, "  recovery subcode");
 
 	/*
@@ -445,75 +445,75 @@ static void dev_switch_tests(void)
 	 * mode was on in the (inaccessible) secdata.
 	 */
 	reset_common_data();
-	vb2_secdata_set(&cc, VB2_SECDATA_FLAGS, VB2_SECDATA_FLAG_DEV_MODE);
+	vb2_secdata_set(&ctx, VB2_SECDATA_FLAGS, VB2_SECDATA_FLAG_DEV_MODE);
 	sd->status &= ~VB2_SD_STATUS_SECDATA_INIT;
-	TEST_EQ(vb2_check_dev_switch(&cc), VB2_ERROR_SECDATA_GET_UNINITIALIZED,
+	TEST_EQ(vb2_check_dev_switch(&ctx), VB2_ERROR_SECDATA_GET_UNINITIALIZED,
 		"secdata fail normal");
 	TEST_EQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, "  sd not in dev");
-	TEST_EQ(cc.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, "  ctx not in dev");
+	TEST_EQ(ctx.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, "  ctx not in dev");
 
 	/* Secdata failure in recovery mode continues */
 	reset_common_data();
-	cc.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
 	sd->status &= ~VB2_SD_STATUS_SECDATA_INIT;
-	TEST_SUCC(vb2_check_dev_switch(&cc), "secdata fail recovery");
+	TEST_SUCC(vb2_check_dev_switch(&ctx), "secdata fail recovery");
 	TEST_EQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, "  sd not in dev");
-	TEST_EQ(cc.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, "  ctx not in dev");
+	TEST_EQ(ctx.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, "  ctx not in dev");
 
 	/* And doesn't check or clear dev disable request */
 	reset_common_data();
-	cc.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
 	sd->status &= ~VB2_SD_STATUS_SECDATA_INIT;
-	vb2_nv_set(&cc, VB2_NV_DISABLE_DEV_REQUEST, 1);
-	TEST_SUCC(vb2_check_dev_switch(&cc), "secdata fail recovery disable");
+	vb2_nv_set(&ctx, VB2_NV_DISABLE_DEV_REQUEST, 1);
+	TEST_SUCC(vb2_check_dev_switch(&ctx), "secdata fail recovery disable");
 	TEST_EQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, "  sd not in dev");
-	TEST_EQ(cc.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, "  ctx not in dev");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_DISABLE_DEV_REQUEST),
+	TEST_EQ(ctx.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, "  ctx not in dev");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISABLE_DEV_REQUEST),
 		1, "  request not cleared");
 
 	/* Can still override with GBB flag */
 	reset_common_data();
-	cc.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
 	sd->status &= ~VB2_SD_STATUS_SECDATA_INIT;
 	sd->gbb_flags |= VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON;
-	TEST_SUCC(vb2_check_dev_switch(&cc), "secdata fail recovery gbb");
+	TEST_SUCC(vb2_check_dev_switch(&ctx), "secdata fail recovery gbb");
 	TEST_NEQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, "  sd in dev");
-	TEST_NEQ(cc.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, "  ctx in dev");
+	TEST_NEQ(ctx.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, "  ctx in dev");
 	TEST_EQ(mock_tpm_clear_called, 1, "  tpm clear");
 
 	/* Force wipeout by ctx flag */
 	reset_common_data();
-	cc.flags |= VB2_CONTEXT_FORCE_WIPEOUT_MODE;
-	TEST_SUCC(vb2_check_dev_switch(&cc), "wipeout on ctx flag");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_REQ_WIPEOUT), 1, "  nv wipeout");
+	ctx.flags |= VB2_CONTEXT_FORCE_WIPEOUT_MODE;
+	TEST_SUCC(vb2_check_dev_switch(&ctx), "wipeout on ctx flag");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_REQ_WIPEOUT), 1, "  nv wipeout");
 }
 
 static void tpm_clear_tests(void)
 {
 	/* No clear request */
 	reset_common_data();
-	TEST_SUCC(vb2_check_tpm_clear(&cc), "no clear request");
+	TEST_SUCC(vb2_check_tpm_clear(&ctx), "no clear request");
 	TEST_EQ(mock_tpm_clear_called, 0, "tpm not cleared");
 
 	/* Successful request */
 	reset_common_data();
-	vb2_nv_set(&cc, VB2_NV_CLEAR_TPM_OWNER_REQUEST, 1);
-	TEST_SUCC(vb2_check_tpm_clear(&cc), "clear request");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_CLEAR_TPM_OWNER_REQUEST),
+	vb2_nv_set(&ctx, VB2_NV_CLEAR_TPM_OWNER_REQUEST, 1);
+	TEST_SUCC(vb2_check_tpm_clear(&ctx), "clear request");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_CLEAR_TPM_OWNER_REQUEST),
 		0, "request cleared");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_CLEAR_TPM_OWNER_DONE),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_CLEAR_TPM_OWNER_DONE),
 		1, "done set");
 	TEST_EQ(mock_tpm_clear_called, 1, "tpm cleared");
 
 	/* Failed request */
 	reset_common_data();
 	mock_tpm_clear_retval = VB2_ERROR_EX_TPM_CLEAR_OWNER;
-	vb2_nv_set(&cc, VB2_NV_CLEAR_TPM_OWNER_REQUEST, 1);
-	TEST_EQ(vb2_check_tpm_clear(&cc),
+	vb2_nv_set(&ctx, VB2_NV_CLEAR_TPM_OWNER_REQUEST, 1);
+	TEST_EQ(vb2_check_tpm_clear(&ctx),
 		VB2_ERROR_EX_TPM_CLEAR_OWNER, "clear failure");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_CLEAR_TPM_OWNER_REQUEST),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_CLEAR_TPM_OWNER_REQUEST),
 		0, "request cleared");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_CLEAR_TPM_OWNER_DONE),
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_CLEAR_TPM_OWNER_DONE),
 		0, "done not set");
 }
 
@@ -521,86 +521,86 @@ static void select_slot_tests(void)
 {
 	/* Slot A */
 	reset_common_data();
-	TEST_SUCC(vb2_select_fw_slot(&cc), "select slot A");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_RESULT),
+	TEST_SUCC(vb2_select_fw_slot(&ctx), "select slot A");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_RESULT),
 		VB2_FW_RESULT_UNKNOWN, "result unknown");
 	TEST_NEQ(sd->status & VB2_SD_STATUS_CHOSE_SLOT, 0, "chose slot");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_TRIED), 0, "tried A");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_TRIED), 0, "tried A");
 	TEST_EQ(sd->fw_slot, 0, "selected A");
-	TEST_EQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, "didn't choose B");
+	TEST_EQ(ctx.flags & VB2_CONTEXT_FW_SLOT_B, 0, "didn't choose B");
 
 	/* Slot B */
 	reset_common_data();
-	vb2_nv_set(&cc, VB2_NV_TRY_NEXT, 1);
-	TEST_SUCC(vb2_select_fw_slot(&cc), "select slot B");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_RESULT),
+	vb2_nv_set(&ctx, VB2_NV_TRY_NEXT, 1);
+	TEST_SUCC(vb2_select_fw_slot(&ctx), "select slot B");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_RESULT),
 		VB2_FW_RESULT_UNKNOWN, "result unknown");
 	TEST_NEQ(sd->status & VB2_SD_STATUS_CHOSE_SLOT, 0, "chose slot");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_TRIED), 1, "tried B");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_TRIED), 1, "tried B");
 	TEST_EQ(sd->fw_slot, 1, "selected B");
-	TEST_NEQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, "ctx says choose B");
+	TEST_NEQ(ctx.flags & VB2_CONTEXT_FW_SLOT_B, 0, "ctx says choose B");
 
 	/* Slot A ran out of tries */
 	reset_common_data();
-	vb2_nv_set(&cc, VB2_NV_FW_RESULT, VB2_FW_RESULT_TRYING);
-	TEST_SUCC(vb2_select_fw_slot(&cc), "select slot A out of tries");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_TRY_NEXT), 1, "try B next");
+	vb2_nv_set(&ctx, VB2_NV_FW_RESULT, VB2_FW_RESULT_TRYING);
+	TEST_SUCC(vb2_select_fw_slot(&ctx), "select slot A out of tries");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TRY_NEXT), 1, "try B next");
 	TEST_NEQ(sd->status & VB2_SD_STATUS_CHOSE_SLOT, 0, "chose slot");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_TRIED), 1, "tried B");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_TRIED), 1, "tried B");
 	TEST_EQ(sd->fw_slot, 1, "selected B");
-	TEST_NEQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, "ctx says choose B");
+	TEST_NEQ(ctx.flags & VB2_CONTEXT_FW_SLOT_B, 0, "ctx says choose B");
 
 	/* Slot A ran out of tries, even with nofail active */
 	reset_common_data();
-	cc.flags |= VB2_CONTEXT_NOFAIL_BOOT;
-	vb2_nv_set(&cc, VB2_NV_FW_RESULT, VB2_FW_RESULT_TRYING);
-	TEST_SUCC(vb2_select_fw_slot(&cc), "select slot A out of tries");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_TRY_NEXT), 1, "try B next");
+	ctx.flags |= VB2_CONTEXT_NOFAIL_BOOT;
+	vb2_nv_set(&ctx, VB2_NV_FW_RESULT, VB2_FW_RESULT_TRYING);
+	TEST_SUCC(vb2_select_fw_slot(&ctx), "select slot A out of tries");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TRY_NEXT), 1, "try B next");
 	TEST_NEQ(sd->status & VB2_SD_STATUS_CHOSE_SLOT, 0, "chose slot");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_TRIED), 1, "tried B");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_TRIED), 1, "tried B");
 	TEST_EQ(sd->fw_slot, 1, "selected B");
-	TEST_NEQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, "ctx says choose B");
+	TEST_NEQ(ctx.flags & VB2_CONTEXT_FW_SLOT_B, 0, "ctx says choose B");
 
 	/* Slot A used up a try */
 	reset_common_data();
-	vb2_nv_set(&cc, VB2_NV_TRY_COUNT, 3);
-	TEST_SUCC(vb2_select_fw_slot(&cc), "try slot A");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_RESULT),
+	vb2_nv_set(&ctx, VB2_NV_TRY_COUNT, 3);
+	TEST_SUCC(vb2_select_fw_slot(&ctx), "try slot A");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_RESULT),
 		VB2_FW_RESULT_TRYING, "result trying");
 	TEST_NEQ(sd->status & VB2_SD_STATUS_CHOSE_SLOT, 0, "chose slot");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_TRIED), 0, "tried A");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_TRIED), 0, "tried A");
 	TEST_EQ(sd->fw_slot, 0, "selected A");
-	TEST_EQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, "didn't choose B");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_TRY_COUNT), 2, "tries decremented");
+	TEST_EQ(ctx.flags & VB2_CONTEXT_FW_SLOT_B, 0, "didn't choose B");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TRY_COUNT), 2, "tries decremented");
 
 	/* Slot A failed, but nofail active */
 	reset_common_data();
-	cc.flags |= VB2_CONTEXT_NOFAIL_BOOT;
-	vb2_nv_set(&cc, VB2_NV_TRY_COUNT, 3);
-	TEST_SUCC(vb2_select_fw_slot(&cc), "try slot A");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_RESULT),
+	ctx.flags |= VB2_CONTEXT_NOFAIL_BOOT;
+	vb2_nv_set(&ctx, VB2_NV_TRY_COUNT, 3);
+	TEST_SUCC(vb2_select_fw_slot(&ctx), "try slot A");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_RESULT),
 		VB2_FW_RESULT_TRYING, "result trying");
 	TEST_NEQ(sd->status & VB2_SD_STATUS_CHOSE_SLOT, 0, "chose slot");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_TRIED), 0, "tried A");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_TRIED), 0, "tried A");
 	TEST_EQ(sd->fw_slot, 0, "selected A");
-	TEST_EQ(cc.flags & VB2_CONTEXT_FW_SLOT_B, 0, "didn't choose B");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_TRY_COUNT), 3, "tries not decremented");
+	TEST_EQ(ctx.flags & VB2_CONTEXT_FW_SLOT_B, 0, "didn't choose B");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TRY_COUNT), 3, "tries not decremented");
 
 	/* Tried/result get copied to the previous fields */
 	reset_common_data();
-	vb2_nv_set(&cc, VB2_NV_FW_TRIED, 0);
-	vb2_nv_set(&cc, VB2_NV_FW_RESULT, VB2_FW_RESULT_SUCCESS);
-	vb2_select_fw_slot(&cc);
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_PREV_TRIED), 0, "prev A");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_PREV_RESULT),	VB2_FW_RESULT_SUCCESS,
+	vb2_nv_set(&ctx, VB2_NV_FW_TRIED, 0);
+	vb2_nv_set(&ctx, VB2_NV_FW_RESULT, VB2_FW_RESULT_SUCCESS);
+	vb2_select_fw_slot(&ctx);
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_PREV_TRIED), 0, "prev A");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_PREV_RESULT),	VB2_FW_RESULT_SUCCESS,
 		"prev success");
 
 	reset_common_data();
-	vb2_nv_set(&cc, VB2_NV_FW_TRIED, 1);
-	vb2_nv_set(&cc, VB2_NV_FW_RESULT, VB2_FW_RESULT_FAILURE);
-	vb2_select_fw_slot(&cc);
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_PREV_TRIED), 1, "prev B");
-	TEST_EQ(vb2_nv_get(&cc, VB2_NV_FW_PREV_RESULT),	VB2_FW_RESULT_FAILURE,
+	vb2_nv_set(&ctx, VB2_NV_FW_TRIED, 1);
+	vb2_nv_set(&ctx, VB2_NV_FW_RESULT, VB2_FW_RESULT_FAILURE);
+	vb2_select_fw_slot(&ctx);
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_PREV_TRIED), 1, "prev B");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_PREV_RESULT),	VB2_FW_RESULT_FAILURE,
 		"prev failure");
 }
 
diff --git a/tests/vb2_nvstorage_tests.c b/tests/vb2_nvstorage_tests.c
index 52c14d4e..d47eaef7 100644
--- a/tests/vb2_nvstorage_tests.c
+++ b/tests/vb2_nvstorage_tests.c
@@ -73,12 +73,12 @@ static struct nv_field nv2fields[] = {
 	{0, 0, 0, 0, NULL}
 };
 
-static void test_changed(struct vb2_context *ctx, int changed, const char *why)
+static void test_changed(struct vb2_context *c, int changed, const char *why)
 {
 	if (changed)
-		TEST_NEQ(ctx->flags & VB2_CONTEXT_NVDATA_CHANGED, 0, why);
+		TEST_NEQ(c->flags & VB2_CONTEXT_NVDATA_CHANGED, 0, why);
 	else
-		TEST_EQ(ctx->flags & VB2_CONTEXT_NVDATA_CHANGED, 0, why);
+		TEST_EQ(c->flags & VB2_CONTEXT_NVDATA_CHANGED, 0, why);
 };
 
 static void nv_storage_test(uint32_t ctxflags)
diff --git a/tests/vb2_secdata_tests.c b/tests/vb2_secdata_tests.c
index 823efab5..460bf831 100644
--- a/tests/vb2_secdata_tests.c
+++ b/tests/vb2_secdata_tests.c
@@ -20,14 +20,14 @@
 #include "2misc.h"
 #include "2secdata.h"
 
-static void test_changed(struct vb2_context *ctx, int changed, const char *why)
+static void test_changed(struct vb2_context *c, int changed, const char *why)
 {
 	if (changed)
-		TEST_NEQ(ctx->flags & VB2_CONTEXT_SECDATA_CHANGED, 0, why);
+		TEST_NEQ(c->flags & VB2_CONTEXT_SECDATA_CHANGED, 0, why);
 	else
-		TEST_EQ(ctx->flags & VB2_CONTEXT_SECDATA_CHANGED, 0, why);
+		TEST_EQ(c->flags & VB2_CONTEXT_SECDATA_CHANGED, 0, why);
 
-	ctx->flags &= ~VB2_CONTEXT_SECDATA_CHANGED;
+	c->flags &= ~VB2_CONTEXT_SECDATA_CHANGED;
 };
 
 static void secdata_test(void)
diff --git a/tests/vb2_secdatak_tests.c b/tests/vb2_secdatak_tests.c
index c0207a3a..6a4f9017 100644
--- a/tests/vb2_secdatak_tests.c
+++ b/tests/vb2_secdatak_tests.c
@@ -21,14 +21,14 @@
 #include "2misc.h"
 #include "2secdata.h"
 
-static void test_changed(struct vb2_context *ctx, int changed, const char *why)
+static void test_changed(struct vb2_context *c, int changed, const char *why)
 {
 	if (changed)
-		TEST_NEQ(ctx->flags & VB2_CONTEXT_SECDATAK_CHANGED, 0, why);
+		TEST_NEQ(c->flags & VB2_CONTEXT_SECDATAK_CHANGED, 0, why);
 	else
-		TEST_EQ(ctx->flags & VB2_CONTEXT_SECDATAK_CHANGED, 0, why);
+		TEST_EQ(c->flags & VB2_CONTEXT_SECDATAK_CHANGED, 0, why);
 
-	ctx->flags &= ~VB2_CONTEXT_SECDATAK_CHANGED;
+	c->flags &= ~VB2_CONTEXT_SECDATAK_CHANGED;
 };
 
 static void secdatak_test(void)