vboot: move vb2_context inside vb2_shared_data (persistent context)

Move vb2_context to live inside of vb2_shared_data, instead of
in a separate memory space allocated by the caller.

See design doc:
http://go/vboot2-persistent-context

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

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

1 files changed, 64 insertions, 66 deletions

diff --git a/tests/vb20_kernel_tests.c b/tests/vb20_kernel_tests.c
index 3a80552e..5099cfd8 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 ctx;
+static struct vb2_context *ctx;
 static struct vb2_shared_data *sd;
 
 /* Mocked function data */
@@ -80,18 +80,16 @@ static void reset_common_data(enum reset_type t)
 
 	memset(workbuf, 0xaa, sizeof(workbuf));
 
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.workbuf = workbuf;
-	ctx.workbuf_size = sizeof(workbuf);
-	vb2_workbuf_from_ctx(&ctx, &wb);
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
 
-	vb2_init_context(&ctx);
-	sd = vb2_get_sd(&ctx);
+	vb2_workbuf_from_ctx(ctx, &wb);
+	sd = vb2_get_sd(ctx);
 
-	vb2_nv_init(&ctx);
+	vb2_nv_init(ctx);
 
-	vb2api_secdata_kernel_create(&ctx);
-	vb2_secdata_kernel_init(&ctx);
+	vb2api_secdata_kernel_create(ctx);
+	vb2_secdata_kernel_init(ctx);
 
 	mock_read_res_fail_on_call = 0;
 	mock_unpack_key_retval = VB2_SUCCESS;
@@ -100,7 +98,7 @@ static void reset_common_data(enum reset_type t)
 
 	/* Set up mock data for verifying keyblock */
 	sd->kernel_version_secdata = 0x20002;
-	vb2_secdata_kernel_set(&ctx, VB2_SECDATA_KERNEL_VERSIONS, 0x20002);
+	vb2_secdata_kernel_set(ctx, VB2_SECDATA_KERNEL_VERSIONS, 0x20002);
 
 	mock_gbb.recovery_key.algorithm = 11;
 	mock_gbb.recovery_key.key_offset =
@@ -130,7 +128,7 @@ 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(&ctx);
+		vb2_load_kernel_keyblock(ctx);
 };
 
 /* Mocked functions */
@@ -238,19 +236,19 @@ static void load_kernel_keyblock_tests(void)
 {
 	struct vb2_keyblock *kb = &mock_vblock.k.kb;
 	struct vb2_packed_key *k;
-	int wb_used_before;
+	int expected_offset;
 
 	/* Test successful call */
 	reset_common_data(FOR_KEYBLOCK);
-	wb_used_before = ctx.workbuf_used;
-	TEST_SUCC(vb2_load_kernel_keyblock(&ctx), "Kernel keyblock good");
+	expected_offset = sd->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->data_key_offset, wb_used_before,
+	TEST_EQ(sd->data_key_offset, expected_offset,
 		"keyblock data key offset");
-	TEST_EQ(ctx.workbuf_used,
+	TEST_EQ(sd->workbuf_used,
 		vb2_wb_round_up(sd->data_key_offset +
 				sd->data_key_size),
 		"workbuf used");
@@ -265,7 +263,7 @@ static void load_kernel_keyblock_tests(void)
 		       mock_vblock.k.data_key_data,
 		       sizeof(mock_vblock.k.data_key_data)),
 		0, "data key data");
-	TEST_EQ(ctx.workbuf_used,
+	TEST_EQ(sd->workbuf_used,
 		vb2_wb_round_up(sd->data_key_offset +
 				sd->data_key_size),
 		"workbuf used after");
@@ -273,112 +271,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(&ctx),
+	TEST_EQ(vb2_load_kernel_keyblock(ctx),
 		VB2_ERROR_MOCK, "Kernel keyblock unpack key");
 
 	reset_common_data(FOR_KEYBLOCK);
-	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
-			vb2_wb_round_up(sizeof(*kb));
-	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
+	sd->workbuf_used = sd->workbuf_size + VB2_WORKBUF_ALIGN -
+			   vb2_wb_round_up(sizeof(*kb));
+	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(&ctx),
+	TEST_EQ(vb2_load_kernel_keyblock(ctx),
 		VB2_ERROR_MOCK, "Kernel keyblock read header");
 
 	reset_common_data(FOR_KEYBLOCK);
-	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
-			vb2_wb_round_up(kb->keyblock_size);
-	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
+	sd->workbuf_used = sd->workbuf_size + VB2_WORKBUF_ALIGN -
+			   vb2_wb_round_up(kb->keyblock_size);
+	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(&ctx),
+	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(&ctx),
+	TEST_EQ(vb2_load_kernel_keyblock(ctx),
 		VB2_ERROR_MOCK, "Verify keyblock");
 
 	/* Not in dev mode */
 	reset_common_data(FOR_KEYBLOCK);
-	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
+	ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
 	mock_verify_keyblock_retval = VB2_ERROR_MOCK;
-	TEST_SUCC(vb2_load_kernel_keyblock(&ctx), "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);
-	ctx.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(&ctx),
+	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_KEYBLOCK_FLAG_DEVELOPER_0;
-	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
+	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_KEYBLOCK_FLAG_RECOVERY_0;
-	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
+	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_KEYBLOCK_FLAG_RECOVERY_1;
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
-	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
+	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_KEYBLOCK_FLAG_DEVELOPER_0;
 	kb->keyblock_flags &= ~VB2_KEYBLOCK_FLAG_RECOVERY_0;
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
-	TEST_EQ(vb2_load_kernel_keyblock(&ctx),
+	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_KEYBLOCK_FLAG_DEVELOPER_0;
 	kb->keyblock_flags &= ~VB2_KEYBLOCK_FLAG_RECOVERY_0;
-	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE | VB2_CONTEXT_RECOVERY_MODE;
-	TEST_SUCC(vb2_load_kernel_keyblock(&ctx),
+	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);
-	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
+	ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
 	kb->keyblock_flags = 0;
-	TEST_SUCC(vb2_load_kernel_keyblock(&ctx), "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(&ctx),
+	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(&ctx),
+	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;
-	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
-	TEST_SUCC(vb2_load_kernel_keyblock(&ctx),
+	ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
+	TEST_SUCC(vb2_load_kernel_keyblock(ctx),
 		  "Kernel keyblock rollback dev");
 
 	/*
@@ -387,26 +385,26 @@ static void load_kernel_keyblock_tests(void)
 	 */
 	reset_common_data(FOR_KEYBLOCK);
 	kb->data_key.key_version = 1;
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
-	TEST_SUCC(vb2_load_kernel_keyblock(&ctx),
+	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
+	TEST_SUCC(vb2_load_kernel_keyblock(ctx),
 		  "Kernel keyblock rollback rec");
 }
 
 static void load_kernel_preamble_tests(void)
 {
 	struct vb2_kernel_preamble *pre = &mock_vblock.p.pre;
-	int wb_used_before;
+	int expected_offset;
 	//uint32_t v;
 
 	/* Test successful call */
 	reset_common_data(FOR_PREAMBLE);
-	wb_used_before = ctx.workbuf_used;
-	TEST_SUCC(vb2_load_kernel_preamble(&ctx), "preamble good");
+	expected_offset = sd->workbuf_used;
+	TEST_SUCC(vb2_load_kernel_preamble(ctx), "preamble good");
 	TEST_EQ(sd->kernel_version, 0x20002, "combined version");
-	TEST_EQ(sd->preamble_offset, wb_used_before,
+	TEST_EQ(sd->preamble_offset, expected_offset,
 		"preamble offset");
 	TEST_EQ(sd->preamble_size, pre->preamble_size, "preamble size");
-	TEST_EQ(ctx.workbuf_used,
+	TEST_EQ(sd->workbuf_used,
 		vb2_wb_round_up(sd->preamble_offset +
 				sd->preamble_size),
 		"workbuf used");
@@ -414,57 +412,57 @@ static void load_kernel_preamble_tests(void)
 	/* Expected failures */
 	reset_common_data(FOR_PREAMBLE);
 	sd->data_key_size = 0;
-	TEST_EQ(vb2_load_kernel_preamble(&ctx),
+	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(&ctx),
+	TEST_EQ(vb2_load_kernel_preamble(ctx),
 		VB2_ERROR_UNPACK_KEY_HASH_ALGORITHM,
 		"preamble unpack data key");
 
 	reset_common_data(FOR_PREAMBLE);
-	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
-			vb2_wb_round_up(sizeof(struct vb2_kernel_preamble));
-	TEST_EQ(vb2_load_kernel_preamble(&ctx),
+	sd->workbuf_used = sd->workbuf_size + VB2_WORKBUF_ALIGN -
+			   vb2_wb_round_up(sizeof(struct vb2_kernel_preamble));
+	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(&ctx),
+	TEST_EQ(vb2_load_kernel_preamble(ctx),
 		VB2_ERROR_EX_READ_RESOURCE_SIZE,
 		"preamble read header");
 
 	reset_common_data(FOR_PREAMBLE);
-	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
-			vb2_wb_round_up(sizeof(mock_vblock.p));
-	TEST_EQ(vb2_load_kernel_preamble(&ctx),
+	sd->workbuf_used = sd->workbuf_size + VB2_WORKBUF_ALIGN -
+			   vb2_wb_round_up(sizeof(mock_vblock.p));
+	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(&ctx),
+	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(&ctx),
+	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(&ctx),
+	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(&ctx),
+	TEST_EQ(vb2_load_kernel_preamble(ctx),
 		VB2_ERROR_KERNEL_PREAMBLE_VERSION_ROLLBACK,
 		"preamble version rollback");
 }