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>
(cherry picked from commit ecdca931ae0637d1a9498f64862939bd5bb99e0b)
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/vboot_reference/+/1918263
Reviewed-by: Shelley Chen <shchen@chromium.org>
Commit-Queue: Shelley Chen <shchen@chromium.org>
Tested-by: Shelley Chen <shchen@chromium.org>

37 files changed, 1637 insertions, 1543 deletions

diff --git a/firmware/2lib/2api.c b/firmware/2lib/2api.c
index 9b7f9533..a94f0193 100644
--- a/firmware/2lib/2api.c
+++ b/firmware/2lib/2api.c
@@ -20,11 +20,7 @@
 vb2_error_t vb2api_fw_phase1(struct vb2_context *ctx)
 {
 	vb2_error_t rv;
-	struct vb2_shared_data *sd;
-
-	/* Initialize the vboot context if it hasn't been yet */
-	vb2_init_context(ctx);
-	sd = vb2_get_sd(ctx);
+	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 
 	/* Initialize NV context */
 	vb2_nv_init(ctx);
diff --git a/firmware/2lib/2misc.c b/firmware/2lib/2misc.c
index a1635f7a..deb4f885 100644
--- a/firmware/2lib/2misc.c
+++ b/firmware/2lib/2misc.c
@@ -29,19 +29,21 @@ vb2_error_t vb2_validate_gbb_signature(uint8_t *sig)
 test_mockable
 struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *ctx)
 {
-	return (struct vb2_gbb_header *)
-	       ((void *)vb2_get_sd(ctx) + vb2_get_sd(ctx)->gbb_offset);
+	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	return (struct vb2_gbb_header *)((void *)sd + sd->gbb_offset);
 }
 
 void vb2_workbuf_from_ctx(struct vb2_context *ctx, struct vb2_workbuf *wb)
 {
-	vb2_workbuf_init(wb, ctx->workbuf + ctx->workbuf_used,
-			 ctx->workbuf_size - ctx->workbuf_used);
+	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	vb2_workbuf_init(wb, (void *)sd + sd->workbuf_used,
+			 sd->workbuf_size - sd->workbuf_used);
 }
 
 void vb2_set_workbuf_used(struct vb2_context *ctx, uint32_t used)
 {
-	ctx->workbuf_used = vb2_wb_round_up(used);
+	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	sd->workbuf_used = vb2_wb_round_up(used);
 }
 
 vb2_error_t vb2_read_gbb_header(struct vb2_context *ctx,
@@ -79,9 +81,6 @@ vb2_error_t vb2_read_gbb_header(struct vb2_context *ctx,
 
 void vb2api_fail(struct vb2_context *ctx, uint8_t reason, uint8_t subcode)
 {
-	/* Initialize the vboot context if it hasn't been yet */
-	vb2_init_context(ctx);
-
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 
 	/* If NV data hasn't been initialized, initialize it now */
@@ -129,46 +128,82 @@ void vb2api_fail(struct vb2_context *ctx, uint8_t reason, uint8_t subcode)
 	}
 }
 
+vb2_error_t vb2api_init(void *workbuf, uint32_t size,
+			struct vb2_context **ctxptr)
+{
+	struct vb2_shared_data *sd = workbuf;
+	*ctxptr = NULL;
+
+	if (!vb2_aligned(workbuf, VB2_WORKBUF_ALIGN))
+		return VB2_ERROR_WORKBUF_ALIGN;
+
+	if (size < vb2_wb_round_up(sizeof(*sd)))
+		return VB2_ERROR_WORKBUF_SMALL;
+
+	/* Zero out vb2_shared_data (which includes vb2_context). */
+	memset(sd, 0, sizeof(*sd));
+
+	/* Initialize shared data. */
+	sd->magic = VB2_SHARED_DATA_MAGIC;
+	sd->struct_version_major = VB2_SHARED_DATA_VERSION_MAJOR;
+	sd->struct_version_minor = VB2_SHARED_DATA_VERSION_MINOR;
+	sd->workbuf_size = size;
+	sd->workbuf_used = vb2_wb_round_up(sizeof(*sd));
+
+	*ctxptr = &sd->ctx;
+	return VB2_SUCCESS;
+}
+
 #pragma GCC diagnostic push
 /* Don't warn for the version_minor check even if the checked version is 0. */
 #pragma GCC diagnostic ignored "-Wtype-limits"
-vb2_error_t vb2_init_context(struct vb2_context *ctx)
+vb2_error_t vb2api_relocate(void *new_workbuf, void *cur_workbuf, uint32_t size,
+			    struct vb2_context **ctxptr)
 {
-	struct vb2_shared_data *sd = vb2_get_sd(ctx);
+	struct vb2_shared_data *sd = cur_workbuf;
 
-	/* Don't do anything if context and workbuf have already been
-	 * initialized. */
-	if (ctx->workbuf_used) {
-		if (sd->magic != VB2_SHARED_DATA_MAGIC)
-			return VB2_ERROR_SHARED_DATA_MAGIC;
+	if (!vb2_aligned(new_workbuf, VB2_WORKBUF_ALIGN))
+		return VB2_ERROR_WORKBUF_ALIGN;
 
-		if (sd->struct_version_major != VB2_SHARED_DATA_VERSION_MAJOR ||
-		    sd->struct_version_minor < VB2_SHARED_DATA_VERSION_MINOR)
-			return VB2_ERROR_SHARED_DATA_VERSION;
+	/* Check magic and version. */
+	if (sd->magic != VB2_SHARED_DATA_MAGIC)
+		return VB2_ERROR_SHARED_DATA_MAGIC;
 
-		return VB2_SUCCESS;
-	}
+	if (sd->struct_version_major != VB2_SHARED_DATA_VERSION_MAJOR ||
+	    sd->struct_version_minor < VB2_SHARED_DATA_VERSION_MINOR)
+		return VB2_ERROR_SHARED_DATA_VERSION;
 
-	/*
-	 * Workbuf had better be big enough for our shared data struct and
-	 * aligned.  Not much we can do if it isn't; we'll die before we can
-	 * store a recovery reason.
-	 */
-	if (ctx->workbuf_size < sizeof(*sd))
-		return VB2_ERROR_INITCTX_WORKBUF_SMALL;
-	if (!vb2_aligned(ctx->workbuf, VB2_WORKBUF_ALIGN))
-		return VB2_ERROR_INITCTX_WORKBUF_ALIGN;
+	/* Check workbuf integrity. */
+	if (sd->workbuf_used < vb2_wb_round_up(sizeof(*sd)))
+		return VB2_ERROR_WORKBUF_INVALID;
+
+	if (sd->workbuf_size < sd->workbuf_used)
+		return VB2_ERROR_WORKBUF_INVALID;
+
+	if (sd->workbuf_used > size)
+		return VB2_ERROR_WORKBUF_SMALL;
+
+	/* Relocate if necessary. */
+	if (cur_workbuf != new_workbuf)
+		memmove(new_workbuf, cur_workbuf, sd->workbuf_used);
+
+	/* Set the new size, and return the context pointer. */
+	sd = new_workbuf;
+	sd->workbuf_size = size;
+	*ctxptr = &sd->ctx;
 
-	/* Initialize the shared data at the start of the work buffer */
-	memset(sd, 0, sizeof(*sd));
-	sd->magic = VB2_SHARED_DATA_MAGIC;
-	sd->struct_version_major = VB2_SHARED_DATA_VERSION_MAJOR;
-	sd->struct_version_minor = VB2_SHARED_DATA_VERSION_MINOR;
-	ctx->workbuf_used = vb2_wb_round_up(sizeof(*sd));
 	return VB2_SUCCESS;
 }
 #pragma GCC diagnostic pop
 
+vb2_error_t vb2api_reinit(void *workbuf, struct vb2_context **ctxptr)
+{
+	/* Blindly retrieve workbuf_size.  vb2api_relocate() will
+	   perform workbuf validation checks. */
+	struct vb2_shared_data *sd = workbuf;
+	return vb2api_relocate(workbuf, workbuf, sd->workbuf_size, ctxptr);
+}
+
 void vb2_check_recovery(struct vb2_context *ctx)
 {
 	struct vb2_shared_data *sd = vb2_get_sd(ctx);
@@ -232,7 +267,7 @@ vb2_error_t vb2_fw_init_gbb(struct vb2_context *ctx)
 
 	/* Keep on the work buffer permanently */
 	sd->gbb_offset = vb2_offset_of(sd, gbb);
-	ctx->workbuf_used = vb2_offset_of(ctx->workbuf, wb.buf);
+	vb2_set_workbuf_used(ctx, vb2_offset_of(ctx, wb.buf));
 
 	/* Set any context flags based on GBB flags */
 	if (gbb->flags & VB2_GBB_FLAG_DISABLE_FWMP)
diff --git a/firmware/2lib/include/2api.h b/firmware/2lib/include/2api.h
index 9aa031a9..0a713265 100644
--- a/firmware/2lib/include/2api.h
+++ b/firmware/2lib/include/2api.h
@@ -196,29 +196,33 @@ enum vb2_context_flags {
 	VB2_CONTEXT_NO_SECDATA_FWMP = (1 << 21),
 };
 
+/* Helper for aligning fields in vb2_context. */
+#define VB2_PAD_STRUCT3(size, align, count) \
+	uint8_t _pad##count[align - (((size - 1) % align) + 1)]
+#define VB2_PAD_STRUCT2(size, align, count) VB2_PAD_STRUCT3(size, align, count)
+#define VB2_PAD_STRUCT(size, align) VB2_PAD_STRUCT2(size, align, __COUNTER__)
+
 /*
  * Context for firmware verification.  Pass this to all vboot APIs.
  *
- * Caller may relocate this between calls to vboot APIs.
+ * Context is stored as part of vb2_shared_data, initialized with vb2api_init().
+ * Subsequent retrieval of the context object should be done by calling
+ * vb2api_reinit(), e.g. if switching firmware applications.
+ *
+ * The context struct can be seen as the "publicly accessible" portion of
+ * vb2_shared_data, and thus does not require its own magic and version fields.
  */
 struct vb2_context {
+
 	/**********************************************************************
-	 * Fields which must be initialized by caller.
+	 * Fields caller must initialize before calling any API functions.
 	 */
 
 	/*
 	 * Flags; see vb2_context_flags.  Some flags may only be set by caller
 	 * prior to calling vboot functions.
 	 */
-	uint32_t flags;
-
-	/*
-	 * Work buffer, and length in bytes.  Caller may relocate this between
-	 * calls to vboot APIs; it contains no internal pointers.  Caller must
-	 * not examine the contents of this work buffer directly.
-	 */
-	uint8_t *workbuf;
-	uint32_t workbuf_size;
+	uint64_t flags;
 
 	/*
 	 * Non-volatile data.  Caller must fill this from some non-volatile
@@ -228,6 +232,7 @@ struct vb2_context {
 	 * and then clear the flag.
 	 */
 	uint8_t nvdata[VB2_NVDATA_SIZE_V2];
+	VB2_PAD_STRUCT(VB2_NVDATA_SIZE_V2, 8);
 
 	/*
 	 * Secure data for firmware verification stage.  Caller must fill this
@@ -237,26 +242,7 @@ struct vb2_context {
 	 * secure non-volatile location and then clear the flag.
 	 */
 	uint8_t secdata_firmware[VB2_SECDATA_FIRMWARE_SIZE];
-
-	/*
-	 * Context pointer for use by caller.  Verified boot never looks at
-	 * this.  Put context here if you need it for APIs that verified boot
-	 * may call (vb2ex_...() functions).
-	 */
-	void *non_vboot_context;
-
-	/**********************************************************************
-	 * Fields caller may examine after calling vb2api_fw_phase1().  Caller
-	 * must set these fields to 0 before calling any vboot functions.
-	 */
-
-	/*
-	 * Amount of work buffer used so far.  Verified boot sub-calls use
-	 * this to know where the unused work area starts.  Caller may use
-	 * this between calls to vboot APIs to know how much data must be
-	 * copied when relocating the work buffer.
-	 */
-	uint32_t workbuf_used;
+	VB2_PAD_STRUCT(VB2_SECDATA_FIRMWARE_SIZE, 8);
 
 	/**********************************************************************
 	 * Fields caller must initialize before calling vb2api_kernel_phase1().
@@ -270,6 +256,7 @@ struct vb2_context {
 	 * to the secure non-volatile location and then clear the flag.
 	 */
 	uint8_t secdata_kernel[VB2_SECDATA_KERNEL_SIZE];
+	VB2_PAD_STRUCT(VB2_SECDATA_KERNEL_SIZE, 8);
 
 	/*
 	 * Firmware management parameters (FWMP) secure data.  Caller must fill
@@ -282,6 +269,7 @@ struct vb2_context {
 	 * location and then clear the flag.
 	 */
 	uint8_t secdata_fwmp[VB2_SECDATA_FWMP_MAX_SIZE];
+	VB2_PAD_STRUCT(VB2_SECDATA_FWMP_MAX_SIZE, 8);
 };
 
 /* Resource index for vb2ex_read_resource() */
@@ -426,6 +414,65 @@ enum vb2_pcr_digest {
  */
 
 /**
+ * Initialize verified boot data structures.
+ *
+ * Needs to be called once per boot, before using any API functions that
+ * accept a vb2_context object.  Sets up the vboot work buffer, as well as
+ * vb2_shared_data and vb2_context.  A pointer to the context object is
+ * written to ctxptr.  After transitioning between different firmware
+ * applications, or any time the context pointer is lost, vb2api_reinit()
+ * should be used to restore access to the context and data on the workbuf.
+ *
+ * If the workbuf needs to be relocated, call vb2api_relocate() instead
+ * of copying memory manually.
+ *
+ * @param workbuf	Workbuf memory location to initialize
+ * @param size		Size of workbuf being initialized
+ * @param ctxptr	Pointer to a context pointer to be filled in
+ * @return VB2_SUCCESS, or non-zero error code.
+ */
+vb2_error_t vb2api_init(void *workbuf, uint32_t size,
+			struct vb2_context **ctxptr);
+
+/**
+ * Reinitialize vboot data structures.
+ *
+ * After transitioning between different firmware applications, or any time the
+ * context pointer is lost, this function should be called to restore access to
+ * the workbuf.  A pointer to the context object is written to ctxptr.  Returns
+ * an error if the vboot work buffer is inconsistent.
+ *
+ * If the workbuf needs to be relocated, call vb2api_relocate() instead
+ * of copying memory manually.
+ *
+ * @param workbuf	Workbuf memory location to check
+ * @param ctxptr	Pointer to a context pointer to be filled in
+ * @return VB2_SUCCESS, or non-zero error code.
+ */
+vb2_error_t vb2api_reinit(void *workbuf, struct vb2_context **ctxptr);
+
+/**
+ * Relocate vboot data structures.
+ *
+ * Move the vboot work buffer from one memory location to another, and expand
+ * or contract the workbuf to fit.  The target memory location may be the same
+ * as the original (used for a "resize" operation), and it is safe to call this
+ * function with overlapping memory regions.
+ *
+ * A pointer to the context object is written to ctxptr.  Returns an error if
+ * the vboot work buffer is inconsistent, or if the new memory space is too
+ * small to contain the work buffer.
+ *
+ * @param new_workbuf	Target workbuf memory location
+ * @param cur_workbuf	Original workbuf memory location to relocate
+ * @param size		Target size of relocated workbuf
+ * @param ctxptr	Pointer to a context pointer to be filled in
+ * @return VB2_SUCCESS, or non-zero error code.
+ */
+vb2_error_t vb2api_relocate(void *new_workbuf, void *cur_workbuf, uint32_t size,
+			    struct vb2_context **ctxptr);
+
+/**
  * Check the validity of firmware secure storage context.
  *
  * Checks version and CRC.
diff --git a/firmware/2lib/include/2misc.h b/firmware/2lib/include/2misc.h
index 5ce10705..d9be9730 100644
--- a/firmware/2lib/include/2misc.h
+++ b/firmware/2lib/include/2misc.h
@@ -14,6 +14,10 @@
 struct vb2_gbb_header;
 struct vb2_workbuf;
 
+#define vb2_container_of(ptr, type, member) ({                     \
+	const typeof(((type *)0)->member) *__mptr = (ptr);         \
+	(type *)((uint8_t *)__mptr - offsetof(type, member) );})   \
+
 /**
  * Get the shared data pointer from the vboot context
  *
@@ -22,7 +26,7 @@ struct vb2_workbuf;
  */
 static inline struct vb2_shared_data *vb2_get_sd(struct vb2_context *ctx)
 {
-	return (struct vb2_shared_data *)ctx->workbuf;
+	return vb2_container_of(ctx, struct vb2_shared_data, ctx);
 }
 
 /**
@@ -73,18 +77,6 @@ vb2_error_t vb2_read_gbb_header(struct vb2_context *ctx,
 				struct vb2_gbb_header *gbb);
 
 /**
- * Set up the verified boot context data, if not already set up.
- *
- * This uses ctx->workbuf_used=0 as a flag to indicate that the data has not
- * yet been set up.  Caller must set that before calling any vboot functions;
- * see 2api.h.
- *
- * @param ctx		Vboot context to initialize
- * @return VB2_SUCCESS, or error code on error.
- */
-vb2_error_t vb2_init_context(struct vb2_context *ctx);
-
-/**
  * Check for recovery reasons we can determine early in the boot process.
  *
  * On exit, check ctx->flags for VB2_CONTEXT_RECOVERY_MODE; if present, jump to
diff --git a/firmware/2lib/include/2return_codes.h b/firmware/2lib/include/2return_codes.h
index 49ee50ab..9f6a54cd 100644
--- a/firmware/2lib/include/2return_codes.h
+++ b/firmware/2lib/include/2return_codes.h
@@ -454,11 +454,11 @@ enum vb2_return_code {
 	 */
 	VB2_ERROR_MISC = VB2_ERROR_BASE + 0x080000,
 
-	/* Work buffer too small in vb2_init_context() */
-	VB2_ERROR_INITCTX_WORKBUF_SMALL,
+	/* Work buffer too small (see vb2api_init and vb2api_reinit) */
+	VB2_ERROR_WORKBUF_SMALL,
 
-	/* Work buffer unaligned in vb2_init_context() */
-	VB2_ERROR_INITCTX_WORKBUF_ALIGN,
+	/* Work buffer unaligned (see vb2api_init and vb2api_reinit) */
+	VB2_ERROR_WORKBUF_ALIGN,
 
 	/* Work buffer too small in GBB-related function */
 	VB2_ERROR_GBB_WORKBUF,
@@ -608,6 +608,9 @@ enum vb2_return_code {
 	/* Invalid parameter */
 	VB2_ERROR_INVALID_PARAMETER,
 
+	/* Problem with workbuf validity (see vb2api_init and vb2api_reinit) */
+	VB2_ERROR_WORKBUF_INVALID,
+
 	/**********************************************************************
 	 * API-level errors
 	 */
diff --git a/firmware/2lib/include/2struct.h b/firmware/2lib/include/2struct.h
index 8fa0254b..a7bd481b 100644
--- a/firmware/2lib/include/2struct.h
+++ b/firmware/2lib/include/2struct.h
@@ -16,17 +16,11 @@
 #ifndef VBOOT_REFERENCE_2STRUCT_H_
 #define VBOOT_REFERENCE_2STRUCT_H_
 
+#include "2api.h"
 #include "2constants.h"
 #include "2crypto.h"
 #include "2sysincludes.h"
 
-/* "V2CT" = vb2_context.magic */
-#define VB2_CONTEXT_MAGIC 0x54433256
-
-/* Current version of vb2_context struct */
-#define VB2_CONTEXT_VERSION_MAJOR 1
-#define VB2_CONTEXT_VERSION_MINOR 0
-
 /* Flags for vb2_shared_data.flags */
 enum vb2_shared_data_flags {
 	/* User has explicitly and physically requested recovery */
@@ -81,9 +75,11 @@ enum vb2_shared_data_status {
 #define VB2_SHARED_DATA_MAGIC 0x44533256
 
 /* Current version of vb2_shared_data struct */
-#define VB2_SHARED_DATA_VERSION_MAJOR 1
+#define VB2_SHARED_DATA_VERSION_MAJOR 2
 #define VB2_SHARED_DATA_VERSION_MINOR 0
 
+#define VB2_CONTEXT_MAX_SIZE 192
+
 /*
  * Data shared between vboot API calls.  Stored at the start of the work
  * buffer.
@@ -96,6 +92,21 @@ struct vb2_shared_data {
 	uint16_t struct_version_major;
 	uint16_t struct_version_minor;
 
+	/* Public fields are stored in the context object */
+	struct vb2_context ctx;
+
+	/* Padding for adding future vb2_context fields */
+	uint8_t padding[VB2_CONTEXT_MAX_SIZE - sizeof(struct vb2_context)];
+
+	/* Work buffer length in bytes. */
+	uint32_t workbuf_size;
+
+	/*
+	 * Amount of work buffer used so far.  Verified boot sub-calls use
+	 * this to know where the unused work area starts.
+	 */
+	uint32_t workbuf_used;
+
 	/* Flags; see enum vb2_shared_data_flags */
 	uint32_t flags;
 
diff --git a/firmware/include/vb2_api.h b/firmware/include/vb2_api.h
index 4774a1a8..d6400c45 100644
--- a/firmware/include/vb2_api.h
+++ b/firmware/include/vb2_api.h
@@ -33,6 +33,7 @@
  * TODO: Make cleaner APIs to this stuff.
  */
 #ifdef NEED_VB20_INTERNALS
+#include "../2lib/include/2misc.h"  /* for vb2_get_sd */
 #include "../2lib/include/2nvstorage.h"
 #include "../2lib/include/2nvstorage_fields.h"
 #include "../2lib/include/2struct.h"
diff --git a/firmware/lib/vboot_api_kernel.c b/firmware/lib/vboot_api_kernel.c
index 68419aa3..52a5dcd0 100644
--- a/firmware/lib/vboot_api_kernel.c
+++ b/firmware/lib/vboot_api_kernel.c
@@ -230,16 +230,8 @@ static vb2_error_t vb2_kernel_setup(struct vb2_context *ctx,
 				    VbSharedDataHeader *shared,
 				    VbSelectAndLoadKernelParams *kparams)
 {
-	vb2_error_t rv;
 	uint32_t tpm_rv;
 
-	rv = vb2_init_context(ctx);
-	if (VB2_SUCCESS != rv) {
-		VB2_DEBUG("Can't init vb2_context\n");
-		vb2api_fail(ctx, VB2_RECOVERY_RW_SHARED_DATA, rv);
-		return VBERROR_INIT_SHARED_DATA;
-	}
-
 	/* Translate vboot1 flags back to vboot2 */
 	if (shared->recovery_reason)
 		ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
diff --git a/firmware/lib20/api_kernel.c b/firmware/lib20/api_kernel.c
index 99a4cf7f..3a4da4ce 100644
--- a/firmware/lib20/api_kernel.c
+++ b/firmware/lib20/api_kernel.c
@@ -110,8 +110,7 @@ vb2_error_t vb2api_kernel_phase1(struct vb2_context *ctx)
 	 *   - kernel key
 	 */
 	sd->kernel_key_size = key_size;
-	vb2_set_workbuf_used(ctx, sd->kernel_key_offset +
-			     sd->kernel_key_size);
+	vb2_set_workbuf_used(ctx, sd->kernel_key_offset + sd->kernel_key_size);
 
 	return VB2_SUCCESS;
 }
diff --git a/firmware/lib20/kernel.c b/firmware/lib20/kernel.c
index eff35bc4..3b3e2c54 100644
--- a/firmware/lib20/kernel.c
+++ b/firmware/lib20/kernel.c
@@ -212,7 +212,7 @@ vb2_error_t vb2_load_kernel_keyblock(struct vb2_context *ctx)
 	 * (which we might still need to verify the next kernel, if the
 	 * assoiciated kernel preamble and data don't verify).
 	 */
-	sd->data_key_offset = ctx->workbuf_used;
+	sd->data_key_offset = sd->workbuf_used;
 	key_data = vb2_member_of(sd, sd->data_key_offset);
 	packed_key = (struct vb2_packed_key *)key_data;
 	memmove(packed_key, &kb->data_key, sizeof(*packed_key));
@@ -233,8 +233,7 @@ vb2_error_t vb2_load_kernel_keyblock(struct vb2_context *ctx)
 	 *   - kernel key
 	 *   - packed kernel data key
 	 */
-	vb2_set_workbuf_used(ctx, sd->data_key_offset +
-			     sd->data_key_size);
+	vb2_set_workbuf_used(ctx, sd->data_key_offset + sd->data_key_size);
 
 	return VB2_SUCCESS;
 }
diff --git a/firmware/lib20/misc.c b/firmware/lib20/misc.c
index e6b4d56c..0fa80e1d 100644
--- a/firmware/lib20/misc.c
+++ b/firmware/lib20/misc.c
@@ -186,8 +186,7 @@ vb2_error_t vb2_load_fw_keyblock(struct vb2_context *ctx)
 	 *   - vb2_shared_data
 	 *   - packed firmware data key
 	 */
-	vb2_set_workbuf_used(ctx, sd->data_key_offset +
-			     sd->data_key_size);
+	vb2_set_workbuf_used(ctx, sd->data_key_offset + sd->data_key_size);
 
 	return VB2_SUCCESS;
 }
diff --git a/firmware/lib21/misc.c b/firmware/lib21/misc.c
index df50436d..ca1a012f 100644
--- a/firmware/lib21/misc.c
+++ b/firmware/lib21/misc.c
@@ -149,8 +149,7 @@ vb2_error_t vb21_load_fw_keyblock(struct vb2_context *ctx)
 	sd->data_key_size = packed_key->c.total_size;
 
 	/* Data key will persist in the workbuf after we return */
-	vb2_set_workbuf_used(ctx, sd->data_key_offset +
-			     sd->data_key_size);
+	vb2_set_workbuf_used(ctx, sd->data_key_offset + sd->data_key_size);
 
 	return VB2_SUCCESS;
 }
@@ -240,8 +239,7 @@ vb2_error_t vb21_load_fw_preamble(struct vb2_context *ctx)
 	sd->preamble_size = pre->c.total_size;
 
 	/* Preamble will persist in work buffer after we return */
-	vb2_set_workbuf_used(ctx, sd->preamble_offset +
-			     sd->preamble_size);
+	vb2_set_workbuf_used(ctx, sd->preamble_offset + sd->preamble_size);
 
 	return VB2_SUCCESS;
 }
diff --git a/tests/vb20_api_kernel_tests.c b/tests/vb20_api_kernel_tests.c
index fdb890f2..a512201a 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 ctx;
+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,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);
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
 
-	vb2_init_context(&ctx);
-	sd = vb2_get_sd(&ctx);
+	sd = vb2_get_sd(ctx);
 
-	vb2_nv_init(&ctx);
+	vb2_nv_init(ctx);
 
-	vb2api_secdata_kernel_create(&ctx);
-	vb2_secdata_kernel_init(&ctx);
-	vb2_secdata_kernel_set(&ctx, VB2_SECDATA_KERNEL_VERSIONS, 0x20002);
+	vb2api_secdata_kernel_create(ctx);
+	vb2_secdata_kernel_init(ctx);
+	vb2_secdata_kernel_set(ctx, VB2_SECDATA_KERNEL_VERSIONS, 0x20002);
 
 	mock_read_res_fail_on_call = 0;
 	mock_unpack_key_retval = VB2_SUCCESS;
@@ -92,7 +90,7 @@ static void reset_common_data(enum reset_type t)
 		uint8_t *kdata;
 
 		/* Create mock firmware preamble in the context */
-		sd->preamble_offset = ctx.workbuf_used;
+		sd->preamble_offset = sd->workbuf_used;
 		fwpre = (struct vb2_fw_preamble *)
 			vb2_member_of(sd, sd->preamble_offset);
 		k = &fwpre->kernel_subkey;
@@ -102,8 +100,8 @@ 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->preamble_size = sizeof(*fwpre) + k->key_size;
-		vb2_set_workbuf_used(&ctx, sd->preamble_offset +
-				     sd->preamble_size);
+		vb2_set_workbuf_used(ctx, 
+				     sd->preamble_offset + sd->preamble_size);
 
 		/* Needed to check that secdata_kernel initialization is
 		   performed by phase1 function. */
@@ -115,16 +113,16 @@ static void reset_common_data(enum reset_type t)
 		uint8_t *sdata;
 
 		/* Create mock kernel data key */
-		sd->data_key_offset = ctx.workbuf_used;
+		sd->data_key_offset = sd->workbuf_used;
 		kdkey = (struct vb2_packed_key *)
 			vb2_member_of(sd, sd->data_key_offset);
 		kdkey->algorithm = VB2_ALG_RSA2048_SHA256;
 		sd->data_key_size = sizeof(*kdkey);
-		vb2_set_workbuf_used(&ctx, sd->data_key_offset +
-				     sd->data_key_size);
+		vb2_set_workbuf_used(ctx, 
+				     sd->data_key_offset + sd->data_key_size);
 
 		/* Create mock kernel preamble in the context */
-		sd->preamble_offset = ctx.workbuf_used;
+		sd->preamble_offset = sd->workbuf_used;
 		kpre = (struct vb2_kernel_preamble *)
 			vb2_member_of(sd, sd->preamble_offset);
 		sdata = (uint8_t *)kpre + sizeof(*kpre);
@@ -142,15 +140,15 @@ static void reset_common_data(enum reset_type t)
 		sd->preamble_size = sizeof(*kpre) + sig->sig_size;
 		sd->vblock_preamble_offset =
 			0x10000 - sd->preamble_size;
-		vb2_set_workbuf_used(&ctx, sd->preamble_offset +
-				     sd->preamble_size);
+		vb2_set_workbuf_used(ctx,
+				     sd->preamble_offset + sd->preamble_size);
 
 	} else {
 		/* Set flags and versions for roll-forward */
 		sd->kernel_version = 0x20004;
 		sd->kernel_version_secdata = 0x20002;
 		sd->flags |= VB2_SD_FLAG_KERNEL_SIGNED;
-		ctx.flags |= VB2_CONTEXT_ALLOW_KERNEL_ROLL_FORWARD;
+		ctx->flags |= VB2_CONTEXT_ALLOW_KERNEL_ROLL_FORWARD;
 	}
 };
 
@@ -229,7 +227,7 @@ static void phase1_tests(void)
 	/* Test successful call */
 	reset_common_data(FOR_PHASE1);
 	old_preamble_offset = sd->preamble_offset;
-	TEST_SUCC(vb2api_kernel_phase1(&ctx), "phase1 good");
+	TEST_SUCC(vb2api_kernel_phase1(ctx), "phase1 good");
 	TEST_EQ(sd->preamble_size, 0, "  no more fw preamble");
 	/* Make sure normal key was loaded */
 	TEST_EQ(sd->kernel_key_offset, old_preamble_offset,
@@ -237,7 +235,7 @@ static void phase1_tests(void)
 	k = vb2_member_of(sd, sd->kernel_key_offset);
 	TEST_EQ(sd->kernel_key_size, k->key_offset + k->key_size,
 		"  workbuf key size");
-	TEST_EQ(ctx.workbuf_used,
+	TEST_EQ(sd->workbuf_used,
 		vb2_wb_round_up(sd->kernel_key_offset +
 				sd->kernel_key_size),
 		"  workbuf used");
@@ -250,11 +248,12 @@ static void phase1_tests(void)
 
 	/* Test successful call in recovery mode */
 	reset_common_data(FOR_PHASE1);
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
 	/* No preamble loaded in recovery mode */
-	ctx.workbuf_used = old_preamble_offset = sd->preamble_offset;
+	old_preamble_offset = sd->preamble_offset;
+	sd->workbuf_used = sd->preamble_offset;
 	sd->preamble_offset = sd->preamble_size = 0;
-	TEST_SUCC(vb2api_kernel_phase1(&ctx), "phase1 rec good");
+	TEST_SUCC(vb2api_kernel_phase1(ctx), "phase1 rec good");
 	TEST_EQ(sd->preamble_size, 0, "no more fw preamble");
 	/* Make sure recovery key was loaded */
 	TEST_EQ(sd->kernel_key_offset, old_preamble_offset,
@@ -262,7 +261,7 @@ static void phase1_tests(void)
 	k = vb2_member_of(sd, sd->kernel_key_offset);
 	TEST_EQ(sd->kernel_key_size, k->key_offset + k->key_size,
 		"  workbuf key size");
-	TEST_EQ(ctx.workbuf_used,
+	TEST_EQ(sd->workbuf_used,
 		vb2_wb_round_up(sd->kernel_key_offset +
 				sd->kernel_key_size),
 		"  workbuf used");
@@ -276,63 +275,63 @@ static void phase1_tests(void)
 
 	/* Bad secdata_kernel causes failure in normal mode only */
 	reset_common_data(FOR_PHASE1);
-	ctx.secdata_kernel[0] ^= 0x33;
-	TEST_EQ(vb2api_kernel_phase1(&ctx), VB2_ERROR_SECDATA_KERNEL_CRC,
+	ctx->secdata_kernel[0] ^= 0x33;
+	TEST_EQ(vb2api_kernel_phase1(ctx), VB2_ERROR_SECDATA_KERNEL_CRC,
 		"phase1 bad secdata");
 
 	reset_common_data(FOR_PHASE1);
-	ctx.secdata_kernel[0] ^= 0x33;
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
-	TEST_SUCC(vb2api_kernel_phase1(&ctx), "phase1 bad secdata rec");
+	ctx->secdata_kernel[0] ^= 0x33;
+	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
+	TEST_SUCC(vb2api_kernel_phase1(ctx), "phase1 bad secdata rec");
 	TEST_EQ(sd->kernel_version_secdata, 0, "  secdata_kernel version");
 
 	/* Failures while reading recovery key */
 	reset_common_data(FOR_PHASE1);
-	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(&ctx), VB2_ERROR_GBB_WORKBUF,
+	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
+	sd->workbuf_used = sd->workbuf_size + VB2_WORKBUF_ALIGN -
+			   vb2_wb_round_up(sizeof(struct vb2_gbb_header));
+	TEST_EQ(vb2api_kernel_phase1(ctx), VB2_ERROR_GBB_WORKBUF,
 		"phase1 rec workbuf gbb header");
 
 	reset_common_data(FOR_PHASE1);
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
 	mock_read_gbb_header_retval = VB2_ERROR_MOCK;
-	TEST_EQ(vb2api_kernel_phase1(&ctx), VB2_ERROR_MOCK,
+	TEST_EQ(vb2api_kernel_phase1(ctx), VB2_ERROR_MOCK,
 		"phase1 rec gbb read header");
 
 	reset_common_data(FOR_PHASE1);
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
-	mock_gbb.h.recovery_key_size = ctx.workbuf_size - 1;
-	TEST_EQ(vb2api_kernel_phase1(&ctx),
+	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
+	mock_gbb.h.recovery_key_size = sd->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);
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
 	mock_read_res_fail_on_call = 1;
-	TEST_EQ(vb2api_kernel_phase1(&ctx), 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->preamble_size = 0;
-	TEST_EQ(vb2api_kernel_phase1(&ctx), 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(&ctx), "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(&ctx), 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(&ctx), VB2_ERROR_MOCK,
+	TEST_EQ(vb2api_load_kernel_vblock(ctx), VB2_ERROR_MOCK,
 		"load vblock bad preamble");
 }
 
@@ -342,17 +341,17 @@ static void get_kernel_size_tests(void)
 
 	reset_common_data(FOR_PHASE2);
 	offs = size = 0;
-	TEST_SUCC(vb2api_get_kernel_size(&ctx, &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(&ctx, NULL, NULL), "get size null");
+	TEST_SUCC(vb2api_get_kernel_size(ctx, NULL, NULL), "get size null");
 
 	reset_common_data(FOR_PHASE2);
 	sd->preamble_size = 0;
-	TEST_EQ(vb2api_get_kernel_size(&ctx, &offs, &size),
+	TEST_EQ(vb2api_get_kernel_size(ctx, &offs, &size),
 		VB2_ERROR_API_GET_KERNEL_SIZE_PREAMBLE,
 		"get size no preamble");
 }
@@ -360,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(&ctx, kernel_data,
+	TEST_SUCC(vb2api_verify_kernel_data(ctx, kernel_data,
 					    sizeof(kernel_data)),
 		  "verify data good");
 
 	reset_common_data(FOR_PHASE2);
 	sd->preamble_size = 0;
-	TEST_EQ(vb2api_verify_kernel_data(&ctx, 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(&ctx, 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);
-	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
-			vb2_wb_round_up(sizeof(struct vb2_digest_context));
-	TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data,
+	sd->workbuf_used = sd->workbuf_size + VB2_WORKBUF_ALIGN -
+			   vb2_wb_round_up(sizeof(struct vb2_digest_context));
+	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->data_key_size = 0;
-	TEST_EQ(vb2api_verify_kernel_data(&ctx, 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(&ctx, 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(&ctx, 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);
-	ctx.workbuf_used = ctx.workbuf_size -
-			vb2_wb_round_up(sizeof(struct vb2_digest_context));
-	TEST_EQ(vb2api_verify_kernel_data(&ctx, kernel_data,
+	sd->workbuf_used = sd->workbuf_size -
+			   vb2_wb_round_up(sizeof(struct vb2_digest_context));
+	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(&ctx, 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;
@@ -420,37 +419,37 @@ static void phase3_tests(void)
 	uint32_t v;
 
 	reset_common_data(FOR_PHASE3);
-	TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 good");
-	v = vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS);
+	TEST_SUCC(vb2api_kernel_phase3(ctx), "phase3 good");
+	v = vb2_secdata_kernel_get(ctx, VB2_SECDATA_KERNEL_VERSIONS);
 	TEST_EQ(v, 0x20004, "  version");
 
 	reset_common_data(FOR_PHASE3);
 	sd->kernel_version = 0x20001;
-	TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 no rollback");
-	v = vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS);
+	TEST_SUCC(vb2api_kernel_phase3(ctx), "phase3 no rollback");
+	v = vb2_secdata_kernel_get(ctx, VB2_SECDATA_KERNEL_VERSIONS);
 	TEST_EQ(v, 0x20002, "  version");
 
 	reset_common_data(FOR_PHASE3);
 	sd->flags &= ~VB2_SD_FLAG_KERNEL_SIGNED;
-	TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 unsigned kernel");
-	v = vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS);
+	TEST_SUCC(vb2api_kernel_phase3(ctx), "phase3 unsigned kernel");
+	v = vb2_secdata_kernel_get(ctx, VB2_SECDATA_KERNEL_VERSIONS);
 	TEST_EQ(v, 0x20002, "  version");
 
 	reset_common_data(FOR_PHASE3);
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
-	TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 recovery");
-	v = vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS);
+	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
+	TEST_SUCC(vb2api_kernel_phase3(ctx), "phase3 recovery");
+	v = vb2_secdata_kernel_get(ctx, VB2_SECDATA_KERNEL_VERSIONS);
 	TEST_EQ(v, 0x20002, "  version");
 
 	reset_common_data(FOR_PHASE3);
-	ctx.flags &= ~VB2_CONTEXT_ALLOW_KERNEL_ROLL_FORWARD;
-	TEST_SUCC(vb2api_kernel_phase3(&ctx), "phase3 no rollforward");
-	v = vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS);
+	ctx->flags &= ~VB2_CONTEXT_ALLOW_KERNEL_ROLL_FORWARD;
+	TEST_SUCC(vb2api_kernel_phase3(ctx), "phase3 no rollforward");
+	v = vb2_secdata_kernel_get(ctx, VB2_SECDATA_KERNEL_VERSIONS);
 	TEST_EQ(v, 0x20002, "  version");
 
 	reset_common_data(FOR_PHASE3);
 	sd->status &= ~VB2_SD_STATUS_SECDATA_KERNEL_INIT;
-	TEST_ABORT(vb2api_kernel_phase3(&ctx), "phase3 set fail");
+	TEST_ABORT(vb2api_kernel_phase3(ctx), "phase3 set fail");
 }
 
 int main(int argc, char* argv[])
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");
 }
diff --git a/tests/vb20_misc_tests.c b/tests/vb20_misc_tests.c
index 7eed0867..5531f59c 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 ctx;
+static struct vb2_context *ctx;
 static struct vb2_shared_data *sd;
 static struct vb2_gbb_header gbb;
 
@@ -65,19 +65,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);
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
 
 	memset(&gbb, 0, sizeof(gbb));
+	sd = vb2_get_sd(ctx);
 
-	vb2_init_context(&ctx);
-	sd = vb2_get_sd(&ctx);
+	vb2_nv_init(ctx);
 
-	vb2_nv_init(&ctx);
-
-	vb2api_secdata_firmware_create(&ctx);
-	vb2_secdata_firmware_init(&ctx);
+	vb2api_secdata_firmware_create(ctx);
+	vb2_secdata_firmware_init(ctx);
 
 	mock_read_res_fail_on_call = 0;
 	mock_unpack_key_retval = VB2_SUCCESS;
@@ -86,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_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
+	vb2_secdata_firmware_set(ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
 				 sd->fw_version_secdata);
 
 	gbb.rootkey_offset = vb2_offset_of(&mock_gbb, &mock_gbb.rootkey);
@@ -113,7 +110,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_fw_keyblock(&ctx);
+		vb2_load_fw_keyblock(ctx);
 };
 
 /* Mocked functions */
@@ -180,18 +177,18 @@ static void verify_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_fw_keyblock(&ctx), "keyblock verify");
+	expected_offset = sd->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->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");
@@ -206,97 +203,97 @@ static void verify_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");
 
 	/* Test failures */
 	reset_common_data(FOR_KEYBLOCK);
-	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
-			vb2_wb_round_up(gbb.rootkey_size);
-	TEST_EQ(vb2_load_fw_keyblock(&ctx),
+	sd->workbuf_used = sd->workbuf_size + VB2_WORKBUF_ALIGN -
+			   vb2_wb_round_up(gbb.rootkey_size);
+	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);
 	gbb.rootkey_size = sizeof(mock_gbb);
-	TEST_EQ(vb2_load_fw_keyblock(&ctx),
+	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(&ctx),
+	TEST_EQ(vb2_load_fw_keyblock(ctx),
 		VB2_ERROR_UNPACK_KEY_SIG_ALGORITHM,
 		"keyblock unpack root key");
 
 	reset_common_data(FOR_KEYBLOCK);
-	ctx.workbuf_used = ctx.workbuf_size -
-			vb2_wb_round_up(gbb.rootkey_size);
-	TEST_EQ(vb2_load_fw_keyblock(&ctx),
+	sd->workbuf_used = sd->workbuf_size -
+			   vb2_wb_round_up(gbb.rootkey_size);
+	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(&ctx),
+	TEST_EQ(vb2_load_fw_keyblock(ctx),
 		VB2_ERROR_EX_READ_RESOURCE_INDEX,
 		"keyblock read keyblock header");
 
 	reset_common_data(FOR_KEYBLOCK);
-	ctx.workbuf_used = ctx.workbuf_size -
-			vb2_wb_round_up(gbb.rootkey_size) -
-			vb2_wb_round_up(sizeof(struct vb2_keyblock));
-	TEST_EQ(vb2_load_fw_keyblock(&ctx),
+	sd->workbuf_used = sd->workbuf_size -
+			   vb2_wb_round_up(gbb.rootkey_size) -
+			   vb2_wb_round_up(sizeof(struct vb2_keyblock));
+	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(&ctx),
+	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(&ctx),
+	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(&ctx),
+	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(&ctx),
+	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;
 	gbb.flags |= VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK;
-	TEST_SUCC(vb2_load_fw_keyblock(&ctx), "keyblock rollback with GBB flag");
+	TEST_SUCC(vb2_load_fw_keyblock(ctx), "keyblock rollback with GBB flag");
 }
 
 static void verify_preamble_tests(void)
 {
 	struct vb2_fw_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_fw_preamble(&ctx), "preamble good");
+	expected_offset = sd->workbuf_used;
+	TEST_SUCC(vb2_load_fw_preamble(ctx), "preamble good");
 	TEST_EQ(sd->fw_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");
@@ -304,88 +301,88 @@ static void verify_preamble_tests(void)
 	/* Expected failures */
 	reset_common_data(FOR_PREAMBLE);
 	sd->data_key_size = 0;
-	TEST_EQ(vb2_load_fw_preamble(&ctx),
+	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(&ctx),
+	TEST_EQ(vb2_load_fw_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_fw_preamble));
-	TEST_EQ(vb2_load_fw_preamble(&ctx),
+	sd->workbuf_used = sd->workbuf_size + VB2_WORKBUF_ALIGN -
+			   vb2_wb_round_up(sizeof(struct vb2_fw_preamble));
+	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(&ctx),
+	TEST_EQ(vb2_load_fw_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_fw_preamble(&ctx),
+	sd->workbuf_used = sd->workbuf_size + VB2_WORKBUF_ALIGN -
+			   vb2_wb_round_up(sizeof(mock_vblock.p));
+	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(&ctx),
+	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(&ctx),
+	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(&ctx),
+	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(&ctx),
+	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;
 	gbb.flags |= VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK;
-	TEST_SUCC(vb2_load_fw_preamble(&ctx), "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(&ctx),
+	TEST_SUCC(vb2_load_fw_preamble(ctx),
 		  "preamble version roll forward");
-	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
+	v = vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
 	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(&ctx),
+	TEST_SUCC(vb2_load_fw_preamble(ctx),
 		  "preamble version no roll forward 1");
-	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
+	v = vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
 	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(&ctx),
+	TEST_SUCC(vb2_load_fw_preamble(ctx),
 		  "preamble version no roll forward 2");
-	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
+	v = vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
 	TEST_EQ(v, 0x20002, "no roll forward");
 }
 
diff --git a/tests/vb20_verify_fw.c b/tests/vb20_verify_fw.c
index 1fe662c2..52d24489 100644
--- a/tests/vb20_verify_fw.c
+++ b/tests/vb20_verify_fw.c
@@ -10,6 +10,7 @@
 #include <string.h>
 
 #include "2common.h"
+#include "2misc.h"
 #include "2sysincludes.h"
 
 const char *gbb_fname;
@@ -144,8 +145,9 @@ static void print_help(const char *progname)
 
 int main(int argc, char *argv[])
 {
-	struct vb2_context ctx;
 	uint8_t workbuf[16384] __attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
+	struct vb2_context *ctx;
+	struct vb2_shared_data *sd;
 	vb2_error_t rv;
 
 	if (argc < 4) {
@@ -159,46 +161,48 @@ int main(int argc, char *argv[])
 	body_fname = argv[3];
 
 	/* Set up context */
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.workbuf = workbuf;
-	ctx.workbuf_size = sizeof(workbuf);
+	if (vb2api_init(workbuf, sizeof(workbuf), &ctx)) {
+		printf("Failed to initialize workbuf.\n");
+		return 1;
+	}
+	sd = vb2_get_sd(ctx);
 
 	/* Initialize secure context */
-	vb2api_secdata_firmware_create(&ctx);
+	vb2api_secdata_firmware_create(ctx);
 
 	// TODO: optional args to set contents for nvdata, secdata?
 
 	/* Do early init */
 	printf("Phase 1...\n");
-	rv = vb2api_fw_phase1(&ctx);
+	rv = vb2api_fw_phase1(ctx);
 	if (rv) {
 		printf("Phase 1 wants recovery mode.\n");
-		save_if_needed(&ctx);
+		save_if_needed(ctx);
 		return rv;
 	}
 
 	/* Determine which firmware slot to boot */
 	printf("Phase 2...\n");
-	rv = vb2api_fw_phase2(&ctx);
+	rv = vb2api_fw_phase2(ctx);
 	if (rv) {
 		printf("Phase 2 wants reboot.\n");
-		save_if_needed(&ctx);
+		save_if_needed(ctx);
 		return rv;
 	}
 
 	/* Try that slot */
 	printf("Phase 3...\n");
-	rv = vb2api_fw_phase3(&ctx);
+	rv = vb2api_fw_phase3(ctx);
 	if (rv) {
 		printf("Phase 3 wants reboot.\n");
-		save_if_needed(&ctx);
+		save_if_needed(ctx);
 		return rv;
 	}
 
 	/* Verify body */
 	printf("Hash body...\n");
-	rv = hash_body(&ctx);
-	save_if_needed(&ctx);
+	rv = hash_body(ctx);
+	save_if_needed(ctx);
 	if (rv) {
 		printf("Phase 4 wants reboot.\n");
 		return rv;
@@ -206,7 +210,7 @@ int main(int argc, char *argv[])
 
 	printf("Yaay!\n");
 
-	printf("Workbuf used = %d bytes\n", ctx.workbuf_used);
+	printf("Workbuf used = %d bytes\n", sd->workbuf_used);
 
 	return 0;
 }
diff --git a/tests/vb21_api_tests.c b/tests/vb21_api_tests.c
index d0215bfa..5daeddb4 100644
--- a/tests/vb21_api_tests.c
+++ b/tests/vb21_api_tests.c
@@ -22,7 +22,7 @@
 /* Common context for tests */
 static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
-static struct vb2_context ctx;
+static struct vb2_context *ctx;
 static struct vb2_shared_data *sd;
 
 static const uint8_t mock_body[320] = "Mock body";
@@ -69,17 +69,14 @@ 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);
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
 
-	vb2_init_context(&ctx);
-	sd = vb2_get_sd(&ctx);
+	sd = vb2_get_sd(ctx);
+	vb2_nv_init(ctx);
 
-	vb2_nv_init(&ctx);
-
-	vb2api_secdata_firmware_create(&ctx);
-	vb2_secdata_firmware_init(&ctx);
+	vb2api_secdata_firmware_create(ctx);
+	vb2_secdata_firmware_init(ctx);
 
 	memset(&hwcrypto_emulation_dc, 0, sizeof(hwcrypto_emulation_dc));
 	retval_hwcrypto = VB2_SUCCESS;
@@ -88,7 +85,7 @@ static void reset_common_data(enum reset_type t)
 
 	vb2_private_key_hash(&hash_key, mock_hash_alg);
 
-	sd->preamble_offset = ctx.workbuf_used;
+	sd->preamble_offset = sd->workbuf_used;
 	pre = vb2_member_of(sd, sd->preamble_offset);
 	pre->hash_count = 3;
 	pre->hash_offset = sig_offset = sizeof(*pre);
@@ -108,14 +105,14 @@ static void reset_common_data(enum reset_type t)
 	}
 
 	sd->preamble_size = sig_offset;
-	ctx.workbuf_used = vb2_wb_round_up(sd->preamble_offset +
+	sd->workbuf_used = vb2_wb_round_up(sd->preamble_offset +
 					   sd->preamble_size);
 
 	if (t == FOR_EXTEND_HASH || t == FOR_CHECK_HASH)
-		vb21api_init_hash(&ctx, test_id, NULL);
+		vb21api_init_hash(ctx, test_id, NULL);
 
 	if (t == FOR_CHECK_HASH)
-		vb2api_extend_hash(&ctx, mock_body, mock_body_size);
+		vb2api_extend_hash(ctx, mock_body, mock_body_size);
 };
 
 /* Mocked functions */
@@ -175,18 +172,18 @@ vb2_error_t vb2ex_hwcrypto_digest_finalize(uint8_t *digest,
 static void phase3_tests(void)
 {
 	reset_common_data(FOR_MISC);
-	TEST_SUCC(vb21api_fw_phase3(&ctx), "phase3 good");
+	TEST_SUCC(vb21api_fw_phase3(ctx), "phase3 good");
 
 	reset_common_data(FOR_MISC);
 	retval_vb21_load_fw_keyblock = VB2_ERROR_MOCK;
-	TEST_EQ(vb21api_fw_phase3(&ctx), VB2_ERROR_MOCK, "phase3 keyblock");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb21api_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_vb21_load_fw_preamble = VB2_ERROR_MOCK;
-	TEST_EQ(vb21api_fw_phase3(&ctx), VB2_ERROR_MOCK, "phase3 keyblock");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb21api_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");
 }
 
@@ -194,6 +191,7 @@ static void init_hash_tests(void)
 {
 	struct vb21_fw_preamble *pre;
 	struct vb21_signature *sig;
+	int expected_offset;
 	int wb_used_before;
 	uint32_t size;
 
@@ -201,14 +199,14 @@ static void init_hash_tests(void)
 	pre = vb2_member_of(sd, sd->preamble_offset);
 	sig = (struct vb21_signature *)((uint8_t *)pre + pre->hash_offset);
 
-	wb_used_before = ctx.workbuf_used;
-	TEST_SUCC(vb21api_init_hash(&ctx, test_id, &size),
+	expected_offset = sd->workbuf_used;
+	TEST_SUCC(vb21api_init_hash(ctx, test_id, &size),
 		  "init hash good");
-	TEST_EQ(sd->hash_offset, wb_used_before,
+	TEST_EQ(sd->hash_offset, expected_offset,
 		"hash context offset");
 	TEST_EQ(sd->hash_size, sizeof(struct vb2_digest_context),
 		"hash context size");
-	TEST_EQ(ctx.workbuf_used,
+	TEST_EQ(sd->workbuf_used,
 		vb2_wb_round_up(sd->hash_offset +
 				sd->hash_size),
 		"hash uses workbuf");
@@ -217,39 +215,39 @@ static void init_hash_tests(void)
 		"hash signature offset");
 	TEST_EQ(sd->hash_remaining_size, mock_body_size, "hash remaining");
 
-	wb_used_before = ctx.workbuf_used;
-	TEST_SUCC(vb21api_init_hash(&ctx, test_id + 2, NULL),
+	wb_used_before = sd->workbuf_used;
+	TEST_SUCC(vb21api_init_hash(ctx, test_id + 2, NULL),
 		  "init hash again");
-	TEST_EQ(ctx.workbuf_used, wb_used_before, "init hash reuses context");
+	TEST_EQ(sd->workbuf_used, wb_used_before, "init hash reuses context");
 	TEST_EQ(sd->hash_tag,
 		sd->preamble_offset + pre->hash_offset +
 		2 * mock_sig_size,
 		"hash signature offset 2");
 
 	reset_common_data(FOR_MISC);
-	TEST_EQ(vb21api_init_hash(&ctx, test_id + 3, &size),
+	TEST_EQ(vb21api_init_hash(ctx, test_id + 3, &size),
 		VB2_ERROR_API_INIT_HASH_ID, "init hash invalid id");
 
 	reset_common_data(FOR_MISC);
 	sd->preamble_size = 0;
-	TEST_EQ(vb21api_init_hash(&ctx, test_id, &size),
+	TEST_EQ(vb21api_init_hash(ctx, test_id, &size),
 		VB2_ERROR_API_INIT_HASH_PREAMBLE, "init hash preamble");
 
 	reset_common_data(FOR_MISC);
-	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
-			vb2_wb_round_up(sizeof(struct vb2_digest_context));
-	TEST_EQ(vb21api_init_hash(&ctx, test_id, &size),
+	sd->workbuf_used = sd->workbuf_size + VB2_WORKBUF_ALIGN -
+			   vb2_wb_round_up(sizeof(struct vb2_digest_context));
+	TEST_EQ(vb21api_init_hash(ctx, test_id, &size),
 		VB2_ERROR_API_INIT_HASH_WORKBUF, "init hash workbuf");
 
 	reset_common_data(FOR_MISC);
 	sig->hash_alg = VB2_HASH_INVALID;
-	TEST_EQ(vb21api_init_hash(&ctx, test_id, &size),
+	TEST_EQ(vb21api_init_hash(ctx, test_id, &size),
 		VB2_ERROR_SHA_INIT_ALGORITHM, "init hash algorithm");
 
 	if (hwcrypto_state == HWCRYPTO_ENABLED) {
 		reset_common_data(FOR_MISC);
 		retval_hwcrypto = VB2_ERROR_MOCK;
-		TEST_EQ(vb21api_init_hash(&ctx, test_id, &size),
+		TEST_EQ(vb21api_init_hash(ctx, test_id, &size),
 			VB2_ERROR_MOCK, "init hash use hwcrypto");
 	}
 }
@@ -259,38 +257,38 @@ static void extend_hash_tests(void)
 	struct vb2_digest_context *dc;
 
 	reset_common_data(FOR_EXTEND_HASH);
-	TEST_SUCC(vb2api_extend_hash(&ctx, 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(&ctx, 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->hash_size = 0;
-	TEST_EQ(vb2api_extend_hash(&ctx, 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(&ctx, 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(&ctx, 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);
 		retval_hwcrypto = VB2_ERROR_MOCK;
-		TEST_EQ(vb2api_extend_hash(&ctx, mock_body, mock_body_size),
+		TEST_EQ(vb2api_extend_hash(ctx, mock_body, mock_body_size),
 			VB2_ERROR_MOCK, "hash extend use hwcrypto");
 	} else {
 		reset_common_data(FOR_EXTEND_HASH);
 		dc = (struct vb2_digest_context *)
 			vb2_member_of(sd, sd->hash_offset);
 		dc->hash_alg = VB2_HASH_INVALID;
-		TEST_EQ(vb2api_extend_hash(&ctx, mock_body, mock_body_size),
+		TEST_EQ(vb2api_extend_hash(ctx, mock_body, mock_body_size),
 			VB2_ERROR_SHA_EXTEND_ALGORITHM, "hash extend fail");
 	}
 }
@@ -306,43 +304,43 @@ static void check_hash_tests(void)
 	sig = vb2_member_of(pre, pre->hash_offset);
 	dc = vb2_member_of(sd, sd->hash_offset);
 
-	TEST_SUCC(vb21api_check_hash(&ctx), "check hash good");
+	TEST_SUCC(vb21api_check_hash(ctx), "check hash good");
 
 	reset_common_data(FOR_CHECK_HASH);
 	sd->hash_tag = 0;
-	TEST_EQ(vb21api_check_hash(&ctx),
+	TEST_EQ(vb21api_check_hash(ctx),
 		VB2_ERROR_API_CHECK_HASH_TAG, "check hash tag");
 
 	reset_common_data(FOR_CHECK_HASH);
 	sd->hash_size = 0;
-	TEST_EQ(vb21api_check_hash(&ctx),
+	TEST_EQ(vb21api_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(vb21api_check_hash(&ctx),
+	TEST_EQ(vb21api_check_hash(ctx),
 		VB2_ERROR_API_CHECK_HASH_SIZE, "check hash size");
 
 	reset_common_data(FOR_CHECK_HASH);
-	ctx.workbuf_used = ctx.workbuf_size;
-	TEST_EQ(vb21api_check_hash(&ctx),
+	sd->workbuf_used = sd->workbuf_size;
+	TEST_EQ(vb21api_check_hash(ctx),
 		VB2_ERROR_API_CHECK_HASH_WORKBUF_DIGEST, "check hash workbuf");
 
 	reset_common_data(FOR_CHECK_HASH);
 	*((uint8_t *)sig + sig->sig_offset) ^= 0x55;
-	TEST_EQ(vb21api_check_hash(&ctx),
+	TEST_EQ(vb21api_check_hash(ctx),
 		VB2_ERROR_API_CHECK_HASH_SIG, "check hash sig");
 
 	if (hwcrypto_state == HWCRYPTO_ENABLED) {
 		reset_common_data(FOR_CHECK_HASH);
 		retval_hwcrypto = VB2_ERROR_MOCK;
-		TEST_EQ(vb21api_check_hash(&ctx),
+		TEST_EQ(vb21api_check_hash(ctx),
 			VB2_ERROR_MOCK, "check hash use hwcrypto");
 	} else {
 		reset_common_data(FOR_CHECK_HASH);
 		dc->hash_alg = VB2_HASH_INVALID;
 		*((uint8_t *)sig + sig->sig_offset) ^= 0x55;
-		TEST_EQ(vb21api_check_hash(&ctx),
+		TEST_EQ(vb21api_check_hash(ctx),
 			VB2_ERROR_SHA_FINALIZE_ALGORITHM, "check hash finaliz");
 	}
 }
diff --git a/tests/vb21_misc_tests.c b/tests/vb21_misc_tests.c
index 35ddf0e1..f86d3f2e 100644
--- a/tests/vb21_misc_tests.c
+++ b/tests/vb21_misc_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 ctx;
+static struct vb2_context *ctx;
 static struct vb2_shared_data *sd;
 static struct vb2_gbb_header gbb;
 
@@ -65,19 +65,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);
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
 
 	memset(&gbb, 0, sizeof(gbb));
+	sd = vb2_get_sd(ctx);
 
-	vb2_init_context(&ctx);
-	sd = vb2_get_sd(&ctx);
+	vb2_nv_init(ctx);
 
-	vb2_nv_init(&ctx);
-
-	vb2api_secdata_firmware_create(&ctx);
-	vb2_secdata_firmware_init(&ctx);
+	vb2api_secdata_firmware_create(ctx);
+	vb2_secdata_firmware_init(ctx);
 
 	mock_read_res_fail_on_call = 0;
 	mock_unpack_key_retval = VB2_SUCCESS;
@@ -86,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_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
+	vb2_secdata_firmware_set(ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
 				 sd->fw_version_secdata);
 
 	gbb.rootkey_offset = vb2_offset_of(&mock_gbb, &mock_gbb.rootkey);
@@ -116,7 +113,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)
-		vb21_load_fw_keyblock(&ctx);
+		vb21_load_fw_keyblock(ctx);
 };
 
 /* Mocked functions */
@@ -183,18 +180,18 @@ static void load_keyblock_tests(void)
 	struct vb21_keyblock *kb = &mock_vblock.k.kb;
 	struct vb21_packed_key *dk = &mock_vblock.k.data_key;
 	struct vb21_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(vb21_load_fw_keyblock(&ctx), "keyblock verify");
+	expected_offset = sd->workbuf_used;
+	TEST_SUCC(vb21_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->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");
@@ -209,80 +206,80 @@ static void load_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");
 
 	/* Test failures */
 	reset_common_data(FOR_KEYBLOCK);
-	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
-			vb2_wb_round_up(gbb.rootkey_size);
-	TEST_EQ(vb21_load_fw_keyblock(&ctx),
+	sd->workbuf_used = sd->workbuf_size + VB2_WORKBUF_ALIGN -
+			   vb2_wb_round_up(gbb.rootkey_size);
+	TEST_EQ(vb21_load_fw_keyblock(ctx),
 		VB2_ERROR_FW_KEYBLOCK_WORKBUF_ROOT_KEY,
 		"keyblock not enough workbuf for root key");
 
 	reset_common_data(FOR_KEYBLOCK);
 	gbb.rootkey_size = sizeof(mock_gbb);
-	TEST_EQ(vb21_load_fw_keyblock(&ctx),
+	TEST_EQ(vb21_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(vb21_load_fw_keyblock(&ctx),
+	TEST_EQ(vb21_load_fw_keyblock(ctx),
 		VB2_ERROR_UNPACK_KEY_SIG_ALGORITHM,
 		"keyblock unpack root key");
 
 	reset_common_data(FOR_KEYBLOCK);
-	ctx.workbuf_used = ctx.workbuf_size -
-			vb2_wb_round_up(gbb.rootkey_size);
-	TEST_EQ(vb21_load_fw_keyblock(&ctx),
+	sd->workbuf_used = sd->workbuf_size -
+			   vb2_wb_round_up(gbb.rootkey_size);
+	TEST_EQ(vb21_load_fw_keyblock(ctx),
 		VB2_ERROR_READ_RESOURCE_OBJECT_BUF,
 		"keyblock not enough workbuf for header");
 
 	reset_common_data(FOR_KEYBLOCK);
 	mock_read_res_fail_on_call = 2;
-	TEST_EQ(vb21_load_fw_keyblock(&ctx),
+	TEST_EQ(vb21_load_fw_keyblock(ctx),
 		VB2_ERROR_EX_READ_RESOURCE_INDEX,
 		"keyblock read keyblock header");
 
 	reset_common_data(FOR_KEYBLOCK);
-	ctx.workbuf_used = ctx.workbuf_size -
-			vb2_wb_round_up(gbb.rootkey_size) -
+	sd->workbuf_used = sd->workbuf_size -
+			   vb2_wb_round_up(gbb.rootkey_size) -
 			vb2_wb_round_up(sizeof(struct vb21_keyblock));
-	TEST_EQ(vb21_load_fw_keyblock(&ctx),
+	TEST_EQ(vb21_load_fw_keyblock(ctx),
 		VB2_ERROR_READ_RESOURCE_OBJECT_BUF,
 		"keyblock not enough workbuf for entire keyblock");
 
 	reset_common_data(FOR_KEYBLOCK);
 	kb->c.total_size = sizeof(mock_vblock) + 1;
-	TEST_EQ(vb21_load_fw_keyblock(&ctx),
+	TEST_EQ(vb21_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(vb21_load_fw_keyblock(&ctx),
+	TEST_EQ(vb21_load_fw_keyblock(ctx),
 		VB2_ERROR_KEYBLOCK_MAGIC,
 		"keyblock verify keyblock");
 
 	reset_common_data(FOR_KEYBLOCK);
 	dk->key_version = 0x10000;
-	TEST_EQ(vb21_load_fw_keyblock(&ctx),
+	TEST_EQ(vb21_load_fw_keyblock(ctx),
 		VB2_ERROR_FW_KEYBLOCK_VERSION_RANGE,
 		"keyblock version range");
 
 	reset_common_data(FOR_KEYBLOCK);
 	dk->key_version = 1;
-	TEST_EQ(vb21_load_fw_keyblock(&ctx),
+	TEST_EQ(vb21_load_fw_keyblock(ctx),
 		VB2_ERROR_FW_KEYBLOCK_VERSION_ROLLBACK,
 		"keyblock rollback");
 
 	reset_common_data(FOR_KEYBLOCK);
 	dk->key_version = 1;
 	gbb.flags |= VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK;
-	TEST_SUCC(vb21_load_fw_keyblock(&ctx), "keyblock rollback + GBB flag");
+	TEST_SUCC(vb21_load_fw_keyblock(ctx), "keyblock rollback + GBB flag");
 }
 
 static void load_preamble_tests(void)
@@ -294,12 +291,12 @@ static void load_preamble_tests(void)
 	/* Test successful call */
 	reset_common_data(FOR_PREAMBLE);
 	data_key_offset_before = sd->data_key_offset;
-	TEST_SUCC(vb21_load_fw_preamble(&ctx), "preamble good");
+	TEST_SUCC(vb21_load_fw_preamble(ctx), "preamble good");
 	TEST_EQ(sd->fw_version, 0x20002, "combined version");
 	TEST_EQ(sd->preamble_offset, data_key_offset_before,
 		"preamble offset");
 	TEST_EQ(sd->preamble_size, pre->c.total_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");
@@ -309,88 +306,88 @@ static void load_preamble_tests(void)
 	/* Expected failures */
 	reset_common_data(FOR_PREAMBLE);
 	sd->data_key_size = 0;
-	TEST_EQ(vb21_load_fw_preamble(&ctx),
+	TEST_EQ(vb21_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(vb21_load_fw_preamble(&ctx),
+	TEST_EQ(vb21_load_fw_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 vb21_fw_preamble));
-	TEST_EQ(vb21_load_fw_preamble(&ctx),
+	sd->workbuf_used = sd->workbuf_size + VB2_WORKBUF_ALIGN -
+			   vb2_wb_round_up(sizeof(struct vb21_fw_preamble));
+	TEST_EQ(vb21_load_fw_preamble(ctx),
 		VB2_ERROR_READ_RESOURCE_OBJECT_BUF,
 		"preamble not enough workbuf for header");
 
 	reset_common_data(FOR_PREAMBLE);
 	sd->vblock_preamble_offset = sizeof(mock_vblock);
-	TEST_EQ(vb21_load_fw_preamble(&ctx),
+	TEST_EQ(vb21_load_fw_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(vb21_load_fw_preamble(&ctx),
+	sd->workbuf_used = sd->workbuf_size + VB2_WORKBUF_ALIGN -
+			   vb2_wb_round_up(sizeof(mock_vblock.p));
+	TEST_EQ(vb21_load_fw_preamble(ctx),
 		VB2_ERROR_READ_RESOURCE_OBJECT_BUF,
 		"preamble not enough workbuf");
 
 	reset_common_data(FOR_PREAMBLE);
 	pre->c.total_size = sizeof(mock_vblock);
-	TEST_EQ(vb21_load_fw_preamble(&ctx),
+	TEST_EQ(vb21_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(vb21_load_fw_preamble(&ctx),
+	TEST_EQ(vb21_load_fw_preamble(ctx),
 		VB2_ERROR_PREAMBLE_SIG_INVALID,
 		"preamble verify");
 
 	reset_common_data(FOR_PREAMBLE);
 	pre->fw_version = 0x10000;
-	TEST_EQ(vb21_load_fw_preamble(&ctx),
+	TEST_EQ(vb21_load_fw_preamble(ctx),
 		VB2_ERROR_FW_PREAMBLE_VERSION_RANGE,
 		"preamble version range");
 
 	reset_common_data(FOR_PREAMBLE);
 	pre->fw_version = 1;
-	TEST_EQ(vb21_load_fw_preamble(&ctx),
+	TEST_EQ(vb21_load_fw_preamble(ctx),
 		VB2_ERROR_FW_PREAMBLE_VERSION_ROLLBACK,
 		"preamble version rollback");
 
 	reset_common_data(FOR_PREAMBLE);
 	pre->fw_version = 1;
 	gbb.flags |= VB2_GBB_FLAG_DISABLE_FW_ROLLBACK_CHECK;
-	TEST_SUCC(vb21_load_fw_preamble(&ctx), "version rollback with GBB flag");
+	TEST_SUCC(vb21_load_fw_preamble(ctx), "version rollback with GBB flag");
 
 	reset_common_data(FOR_PREAMBLE);
 	pre->fw_version = 3;
-	TEST_SUCC(vb21_load_fw_preamble(&ctx),
+	TEST_SUCC(vb21_load_fw_preamble(ctx),
 		  "preamble version roll forward");
-	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
+	v = vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
 	TEST_EQ(v, 0x20003, "roll forward");
 
 	/* Newer version without result success doesn't roll forward */
 	reset_common_data(FOR_PREAMBLE);
 	pre->fw_version = 3;
 	sd->last_fw_result = VB2_FW_RESULT_UNKNOWN;
-	TEST_SUCC(vb21_load_fw_preamble(&ctx),
+	TEST_SUCC(vb21_load_fw_preamble(ctx),
 		  "preamble version no roll forward 1");
-	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
+	v = vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
 	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->fw_version = 3;
 	sd->last_fw_slot = 1;
-	TEST_SUCC(vb21_load_fw_preamble(&ctx),
+	TEST_SUCC(vb21_load_fw_preamble(ctx),
 		  "preamble version no roll forward 2");
-	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
+	v = vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
 	TEST_EQ(v, 0x20002, "no roll forward");
 }
 
diff --git a/tests/vb2_api_tests.c b/tests/vb2_api_tests.c
index e5883002..40cd160e 100644
--- a/tests/vb2_api_tests.c
+++ b/tests/vb2_api_tests.c
@@ -22,7 +22,7 @@
 
 static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
-static struct vb2_context ctx;
+static struct vb2_context *ctx;
 static struct vb2_shared_data *sd;
 static struct vb2_gbb_header gbb;
 
@@ -73,17 +73,14 @@ 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);
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
+	sd = vb2_get_sd(ctx);
 
-	vb2_init_context(&ctx);
-	sd = vb2_get_sd(&ctx);
+	vb2_nv_init(ctx);
 
-	vb2_nv_init(&ctx);
-
-	vb2api_secdata_firmware_create(&ctx);
-	vb2_secdata_firmware_init(&ctx);
+	vb2api_secdata_firmware_create(ctx);
+	vb2_secdata_firmware_init(ctx);
 
 	force_dev_mode = 0;
 	retval_vb2_fw_init_gbb = VB2_SUCCESS;
@@ -98,10 +95,9 @@ static void reset_common_data(enum reset_type t)
 	memcpy(&gbb.hwid_digest, mock_hwid_digest,
 	       sizeof(gbb.hwid_digest));
 
-	sd->preamble_offset = ctx.workbuf_used;
+	sd->preamble_offset = sd->workbuf_used;
 	sd->preamble_size = sizeof(*pre);
-	vb2_set_workbuf_used(&ctx, sd->preamble_offset
-			     + sd->preamble_size);
+	vb2_set_workbuf_used(ctx, sd->preamble_offset + sd->preamble_size);
 	pre = vb2_member_of(sd, sd->preamble_offset);
 	pre->body_signature.data_size = mock_body_size;
 	pre->body_signature.sig_size = mock_sig_size;
@@ -110,18 +106,17 @@ static void reset_common_data(enum reset_type t)
 	else
 		pre->flags = 0;
 
-	sd->data_key_offset = ctx.workbuf_used;
+	sd->data_key_offset = sd->workbuf_used;
 	sd->data_key_size = sizeof(*k) + 8;
-	vb2_set_workbuf_used(&ctx, sd->data_key_offset +
-			     sd->data_key_size);
+	vb2_set_workbuf_used(ctx, sd->data_key_offset + sd->data_key_size);
 	k = vb2_member_of(sd, sd->data_key_offset);
 	k->algorithm = mock_algorithm;
 
 	if (t == FOR_EXTEND_HASH || t == FOR_CHECK_HASH)
-		vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, NULL);
+		vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY, NULL);
 
 	if (t == FOR_CHECK_HASH)
-		vb2api_extend_hash(&ctx, 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);
@@ -279,178 +274,178 @@ static void misc_tests(void)
 	/* Test secdata_firmware passthru functions */
 	reset_common_data(FOR_MISC);
 	/* Corrupt secdata_firmware so initial check will fail */
-	ctx.secdata_firmware[0] ^= 0x42;
-	TEST_EQ(vb2api_secdata_firmware_check(&ctx),
+	ctx->secdata_firmware[0] ^= 0x42;
+	TEST_EQ(vb2api_secdata_firmware_check(ctx),
 		VB2_ERROR_SECDATA_FIRMWARE_CRC,
 		"secdata_firmware check");
-	TEST_EQ(vb2api_secdata_firmware_create(&ctx), VB2_SECDATA_FIRMWARE_SIZE,
+	TEST_EQ(vb2api_secdata_firmware_create(ctx), VB2_SECDATA_FIRMWARE_SIZE,
 		  "secdata_firmware create");
-	TEST_SUCC(vb2api_secdata_firmware_check(&ctx),
+	TEST_SUCC(vb2api_secdata_firmware_check(ctx),
 		  "secdata_firmware check 2");
 
 	/* Test fail passthru */
 	reset_common_data(FOR_MISC);
-	vb2api_fail(&ctx, 12, 34);
-	TEST_EQ(vb2_nv_get(&ctx, 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(&ctx, 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(&ctx), "phase1 good");
+	TEST_SUCC(vb2api_fw_phase1(ctx), "phase1 good");
 	TEST_EQ(sd->recovery_reason, 0, "  not recovery");
-	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,
+	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_init_gbb = VB2_ERROR_GBB_MAGIC;
-	TEST_EQ(vb2api_fw_phase1(&ctx), 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(ctx.flags & VB2_CONTEXT_RECOVERY_MODE, 0, "  recovery flag");
-	TEST_NEQ(ctx.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(&ctx), VB2_ERROR_MOCK, "phase1 dev switch");
-	TEST_EQ(vb2_nv_get(&ctx, 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(&ctx, 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(&ctx), 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(ctx.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);
-	ctx.secdata_firmware[0] ^= 0x42;
-	TEST_EQ(vb2api_fw_phase1(&ctx), VB2_ERROR_API_PHASE1_RECOVERY,
+	ctx->secdata_firmware[0] ^= 0x42;
+	TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_RECOVERY,
 		"phase1 secdata_firmware");
 	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_SECDATA_FIRMWARE_INIT,
 		"  recovery reason");
-	TEST_NEQ(ctx.flags & VB2_CONTEXT_RECOVERY_MODE, 0, "  recovery flag");
-	TEST_NEQ(ctx.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_firmware-requested reboot */
 	reset_common_data(FOR_MISC);
-	ctx.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
-	TEST_EQ(vb2api_fw_phase1(&ctx), 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_firmware reboot normal");
 	TEST_EQ(sd->recovery_reason, 0,	"  recovery reason");
-	TEST_EQ(vb2_nv_get(&ctx, 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(&ctx, 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(&ctx, VB2_NV_TPM_REQUESTED_REBOOT, 1);
-	TEST_SUCC(vb2api_fw_phase1(&ctx),
+	vb2_nv_set(ctx, VB2_NV_TPM_REQUESTED_REBOOT, 1);
+	TEST_SUCC(vb2api_fw_phase1(ctx),
 		  "phase1 secdata_firmware reboot back normal");
 	TEST_EQ(sd->recovery_reason, 0,	"  recovery reason");
-	TEST_EQ(vb2_nv_get(&ctx, 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(&ctx, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
 		0, "  recovery request");
 
 	reset_common_data(FOR_MISC);
-	ctx.flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
-	memset(ctx.secdata_firmware, 0, sizeof(ctx.secdata_firmware));
-	TEST_EQ(vb2api_fw_phase1(&ctx), VB2_ERROR_API_PHASE1_SECDATA_REBOOT,
+	ctx->flags |= VB2_CONTEXT_SECDATA_WANTS_REBOOT;
+	memset(ctx->secdata_firmware, 0, sizeof(ctx->secdata_firmware));
+	TEST_EQ(vb2api_fw_phase1(ctx), VB2_ERROR_API_PHASE1_SECDATA_REBOOT,
 		"phase1 secdata_firmware reboot normal, "
 		"secdata_firmware blank");
 	TEST_EQ(sd->recovery_reason, 0,	"  recovery reason");
-	TEST_EQ(vb2_nv_get(&ctx, 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(&ctx, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
 		0, "  recovery request");
 
 	reset_common_data(FOR_MISC);
-	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,
+	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_firmware reboot normal again");
 	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_TPM_REBOOT,
 		"  recovery reason");
-	TEST_EQ(vb2_nv_get(&ctx, 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(&ctx, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
 		0, "  recovery request");
 
 	reset_common_data(FOR_MISC);
-	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,
+	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_firmware 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(&ctx, 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(&ctx, 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(&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,
+	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_firmware reboot back recovery");
 	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_UNSPECIFIED,
 		"  recovery reason");
-	TEST_EQ(vb2_nv_get(&ctx, 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(&ctx, VB2_NV_RECOVERY_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0,
 		"  recovery request cleared");
 
 	reset_common_data(FOR_MISC);
-	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,
+	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_firmware reboot recovery again");
 	TEST_EQ(sd->recovery_reason, VB2_RECOVERY_RO_UNSPECIFIED,
 		"  recovery reason");
-	TEST_EQ(vb2_nv_get(&ctx, 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(&ctx, 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);
-	ctx.flags |= VB2_CONTEXT_DISPLAY_INIT;
-	TEST_SUCC(vb2api_fw_phase1(&ctx), "phase1 with DISPLAY_INIT");
-	TEST_NEQ(ctx.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(&ctx, VB2_NV_DISPLAY_REQUEST, 1);
-	TEST_SUCC(vb2api_fw_phase1(&ctx), "phase1 with DISPLAY_REQUEST");
-	TEST_NEQ(ctx.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(&ctx), "phase1 in dev mode");
-	TEST_NEQ(ctx.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");
@@ -459,40 +454,40 @@ static void phase1_tests(void)
 static void phase2_tests(void)
 {
 	reset_common_data(FOR_MISC);
-	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");
+	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);
-	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");
+	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(&ctx), VB2_ERROR_MOCK, "phase2 tpm clear");
-	TEST_EQ(vb2_nv_get(&ctx, 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(&ctx), VB2_ERROR_MOCK, "phase2 slot");
-	TEST_EQ(vb2_nv_get(&ctx, 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);
-	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");
+	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);
-	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");
+	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)
@@ -507,7 +502,7 @@ static void get_pcr_digest_tests(void)
 	digest_size = sizeof(digest);
 	memset(digest, 0, sizeof(digest));
 	TEST_SUCC(vb2api_get_pcr_digest(
-			&ctx, 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),
@@ -516,7 +511,7 @@ static void get_pcr_digest_tests(void)
 	digest_size = sizeof(digest);
 	memset(digest, 0, sizeof(digest));
 	TEST_SUCC(vb2api_get_pcr_digest(
-			&ctx, 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");
@@ -524,12 +519,12 @@ static void get_pcr_digest_tests(void)
 		   "HWID_DIGEST_PCR digest");
 
 	digest_size = 1;
-	TEST_EQ(vb2api_get_pcr_digest(&ctx, 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(
-			&ctx, 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");
 }
@@ -537,18 +532,18 @@ static void get_pcr_digest_tests(void)
 static void phase3_tests(void)
 {
 	reset_common_data(FOR_MISC);
-	TEST_SUCC(vb2api_fw_phase3(&ctx), "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(&ctx), VB2_ERROR_MOCK, "phase3 keyblock");
-	TEST_EQ(vb2_nv_get(&ctx, 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(&ctx), VB2_ERROR_MOCK, "phase3 keyblock");
-	TEST_EQ(vb2_nv_get(&ctx, 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");
 }
 
@@ -560,58 +555,56 @@ static void init_hash_tests(void)
 
 	/* For now, all we support is body signature hash */
 	reset_common_data(FOR_MISC);
-	wb_used_before = ctx.workbuf_used;
-	TEST_SUCC(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, &size),
+	wb_used_before = sd->workbuf_used;
+	TEST_SUCC(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY, &size),
 		  "init hash good");
-	TEST_EQ(sd->hash_offset, wb_used_before,
-		"hash context offset");
+	TEST_EQ(sd->hash_offset, wb_used_before, "hash context offset");
 	TEST_EQ(sd->hash_size, sizeof(struct vb2_digest_context),
 		"hash context size");
-	TEST_EQ(ctx.workbuf_used,
-		vb2_wb_round_up(sd->hash_offset +
-				sd->hash_size),
+	TEST_EQ(sd->workbuf_used,
+		vb2_wb_round_up(sd->hash_offset + sd->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 = ctx.workbuf_used;
-	TEST_SUCC(vb2api_init_hash(&ctx, VB2_HASH_TAG_FW_BODY, NULL),
+	wb_used_before = sd->workbuf_used;
+	TEST_SUCC(vb2api_init_hash(ctx, VB2_HASH_TAG_FW_BODY, NULL),
 		  "init hash again");
-	TEST_EQ(ctx.workbuf_used, wb_used_before, "init hash reuses context");
+	TEST_EQ(sd->workbuf_used, wb_used_before, "init hash reuses context");
 
 	reset_common_data(FOR_MISC);
-	TEST_EQ(vb2api_init_hash(&ctx, 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->preamble_size = 0;
-	TEST_EQ(vb2api_init_hash(&ctx, 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(&ctx, 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);
-	ctx.workbuf_used = ctx.workbuf_size + VB2_WORKBUF_ALIGN -
+	sd->workbuf_used = sd->workbuf_size + VB2_WORKBUF_ALIGN -
 			vb2_wb_round_up(sizeof(struct vb2_digest_context));
-	TEST_EQ(vb2api_init_hash(&ctx, 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->data_key_size = 0;
-	TEST_EQ(vb2api_init_hash(&ctx, 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->data_key_size--;
-	TEST_EQ(vb2api_init_hash(&ctx, 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 = vb2_member_of(sd, sd->data_key_offset);
 	k->algorithm--;
-	TEST_EQ(vb2api_init_hash(&ctx, 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");
 }
 
@@ -620,25 +613,25 @@ static void extend_hash_tests(void)
 	struct vb2_digest_context *dc;
 
 	reset_common_data(FOR_EXTEND_HASH);
-	TEST_SUCC(vb2api_extend_hash(&ctx, 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(&ctx, 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->hash_size = 0;
-	TEST_EQ(vb2api_extend_hash(&ctx, 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(&ctx, 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(&ctx, 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) {
@@ -646,7 +639,7 @@ static void extend_hash_tests(void)
 		dc = (struct vb2_digest_context *)
 			vb2_member_of(sd, sd->hash_offset);
 		dc->hash_alg = mock_hash_alg + 1;
-		TEST_EQ(vb2api_extend_hash(&ctx, mock_body, mock_body_size),
+		TEST_EQ(vb2api_extend_hash(ctx, mock_body, mock_body_size),
 			VB2_ERROR_SHA_EXTEND_ALGORITHM, "hash extend fail");
 	}
 }
@@ -657,17 +650,17 @@ static void check_hash_tests(void)
 	const uint32_t digest_value = 0x0a0a0a0a;
 
 	reset_common_data(FOR_CHECK_HASH);
-	TEST_SUCC(vb2api_check_hash(&ctx), "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(&ctx, 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(&ctx, 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,
@@ -675,52 +668,52 @@ static void check_hash_tests(void)
 
 	reset_common_data(FOR_CHECK_HASH);
 	sd->preamble_size = 0;
-	TEST_EQ(vb2api_check_hash(&ctx),
+	TEST_EQ(vb2api_check_hash(ctx),
 		VB2_ERROR_API_CHECK_HASH_PREAMBLE, "check hash preamble");
 
 	reset_common_data(FOR_CHECK_HASH);
 	sd->hash_size = 0;
-	TEST_EQ(vb2api_check_hash(&ctx),
+	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(&ctx),
+	TEST_EQ(vb2api_check_hash(ctx),
 		VB2_ERROR_API_CHECK_HASH_SIZE, "check hash size");
 
 	reset_common_data(FOR_CHECK_HASH);
-	ctx.workbuf_used = ctx.workbuf_size;
-	TEST_EQ(vb2api_check_hash(&ctx),
+	sd->workbuf_used = sd->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(&ctx), 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(&ctx),
+	TEST_EQ(vb2api_check_hash(ctx),
 		VB2_ERROR_API_CHECK_HASH_TAG, "check hash tag");
 
 	reset_common_data(FOR_CHECK_HASH);
 	sd->data_key_size = 0;
-	TEST_EQ(vb2api_check_hash(&ctx),
+	TEST_EQ(vb2api_check_hash(ctx),
 		VB2_ERROR_API_CHECK_HASH_DATA_KEY, "check hash data key");
 
 	reset_common_data(FOR_CHECK_HASH);
 	sd->data_key_size--;
-	TEST_EQ(vb2api_check_hash(&ctx),
+	TEST_EQ(vb2api_check_hash(ctx),
 		VB2_ERROR_UNPACK_KEY_SIZE, "check hash data key size");
 
 	reset_common_data(FOR_CHECK_HASH);
 	pre = vb2_member_of(sd, sd->preamble_offset);
 	pre->body_signature.sig_size++;
-	TEST_EQ(vb2api_check_hash(&ctx),
+	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(&ctx),
+	TEST_EQ(vb2api_check_hash(ctx),
 		VB2_ERROR_RSA_VERIFY_DIGEST, "check hash finalize");
 }
 
diff --git a/tests/vb2_ec_sync_tests.c b/tests/vb2_ec_sync_tests.c
index d93c9629..91083035 100644
--- a/tests/vb2_ec_sync_tests.c
+++ b/tests/vb2_ec_sync_tests.c
@@ -48,8 +48,8 @@ static int mock_ec_rw_hash_size;
 static uint8_t want_ec_hash[32];
 static uint8_t update_hash;
 static int want_ec_hash_size;
-static struct vb2_context ctx;
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
+static struct vb2_context *ctx;
 static struct vb2_shared_data *sd;
 static struct vb2_gbb_header gbb;
 
@@ -65,14 +65,13 @@ static int ec_aux_fw_protected;
 /* Reset mock data (for use before each test) */
 static void ResetMocks(void)
 {
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.workbuf = workbuf;
-	ctx.workbuf_size = sizeof(workbuf);
-	ctx.flags = VB2_CONTEXT_EC_SYNC_SUPPORTED;
-	vb2_init_context(&ctx);
-	vb2_nv_init(&ctx);
-
-	sd = vb2_get_sd(&ctx);
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
+
+	ctx->flags = VB2_CONTEXT_EC_SYNC_SUPPORTED;
+	vb2_nv_init(ctx);
+
+	sd = vb2_get_sd(ctx);
 	sd->vbsd = shared;
 	sd->flags |= VB2_SD_FLAG_DISPLAY_AVAILABLE;
 
@@ -243,8 +242,8 @@ vb2_error_t VbExEcVbootDone(int in_recovery)
 static void test_ssync(vb2_error_t retval, int recovery_reason,
 		       const char *desc)
 {
-	TEST_EQ(ec_sync_all(&ctx), retval, desc);
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(ec_sync_all(ctx), retval, desc);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
 		recovery_reason, "  recovery reason");
 }
 
@@ -294,7 +293,7 @@ static void VbSoftwareSyncTest(void)
 
 	ResetMocks();
 	mock_ec_rw_hash[0]++;
-	vb2_nv_set(&ctx, VB2_NV_TRY_RO_SYNC, 1);
+	vb2_nv_set(ctx, VB2_NV_TRY_RO_SYNC, 1);
 	test_ssync(0, 0, "Update rw without reboot");
 	TEST_EQ(ec_rw_protected, 1, "  ec rw protected");
 	TEST_EQ(ec_run_image, 1, "  ec run image");
@@ -305,7 +304,7 @@ static void VbSoftwareSyncTest(void)
 	ResetMocks();
 	mock_ec_rw_hash[0]++;
 	mock_ec_ro_hash[0]++;
-	vb2_nv_set(&ctx, VB2_NV_TRY_RO_SYNC, 1);
+	vb2_nv_set(ctx, VB2_NV_TRY_RO_SYNC, 1);
 	test_ssync(0, 0, "Update rw and ro images without reboot");
 	TEST_EQ(ec_rw_protected, 1, "  ec rw protected");
 	TEST_EQ(ec_run_image, 1, "  ec run image");
@@ -314,16 +313,16 @@ static void VbSoftwareSyncTest(void)
 	TEST_EQ(ec_ro_updated, 1, "  ec ro updated");
 
 	ResetMocks();
-	vb2_nv_set(&ctx, VB2_NV_TRY_RO_SYNC, 1);
+	vb2_nv_set(ctx, VB2_NV_TRY_RO_SYNC, 1);
 	mock_ec_ro_hash[0]++;
-	vb2_nv_set(&ctx, VB2_NV_DISPLAY_REQUEST, 1);
+	vb2_nv_set(ctx, VB2_NV_DISPLAY_REQUEST, 1);
 	test_ssync(0, 0, "rw update not needed");
 	TEST_EQ(ec_rw_protected, 1, "  ec rw protected");
 	TEST_EQ(ec_run_image, 1, "  ec run image");
 	TEST_EQ(ec_rw_updated, 0, "  ec rw not updated");
 	TEST_EQ(ec_ro_protected, 1, "  ec ro protected");
 	TEST_EQ(ec_ro_updated, 1, "  ec ro updated");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISPLAY_REQUEST), 1,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DISPLAY_REQUEST), 1,
 		"  DISPLAY_REQUEST left untouched");
 
 	ResetMocks();
@@ -363,35 +362,35 @@ static void VbSoftwareSyncTest(void)
 
 	ResetMocks();
 	mock_ec_rw_hash[0]++;
-	ctx.flags |= VB2_CONTEXT_EC_SYNC_SLOW;
+	ctx->flags |= VB2_CONTEXT_EC_SYNC_SLOW;
 	test_ssync(0, 0, "Slow update");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_WAIT, "  wait screen");
 
 	ResetMocks();
 	mock_ec_rw_hash[0]++;
-	ctx.flags |= VB2_CONTEXT_EC_SYNC_SLOW;
+	ctx->flags |= VB2_CONTEXT_EC_SYNC_SLOW;
 	sd->flags &= ~VB2_SD_FLAG_DISPLAY_AVAILABLE;
 	test_ssync(VBERROR_REBOOT_REQUIRED, 0,
 		   "Slow update - reboot for display");
 
 	ResetMocks();
 	mock_ec_rw_hash[0]++;
-	ctx.flags |= VB2_CONTEXT_EC_SYNC_SLOW;
-	vb2_nv_set(&ctx, VB2_NV_DISPLAY_REQUEST, 1);
+	ctx->flags |= VB2_CONTEXT_EC_SYNC_SLOW;
+	vb2_nv_set(ctx, VB2_NV_DISPLAY_REQUEST, 1);
 	test_ssync(VB2_SUCCESS, 0,
 		   "Slow update with display request");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_WAIT, "  wait screen");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISPLAY_REQUEST), 1,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DISPLAY_REQUEST), 1,
 		"  DISPLAY_REQUEST left untouched");
 
 	ResetMocks();
 	mock_ec_rw_hash[0]++;
-	ctx.flags |= VB2_CONTEXT_EC_SYNC_SLOW;
-	vb2_nv_set(&ctx, VB2_NV_DISPLAY_REQUEST, 0);
+	ctx->flags |= VB2_CONTEXT_EC_SYNC_SLOW;
+	vb2_nv_set(ctx, VB2_NV_DISPLAY_REQUEST, 0);
 	test_ssync(VB2_SUCCESS, 0,
 		   "Slow update without display request (no reboot needed)");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_WAIT, "  wait screen");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISPLAY_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DISPLAY_REQUEST), 0,
 		"  DISPLAY_REQUEST left untouched");
 
 	/* RW cases, no update */
diff --git a/tests/vb2_gbb_tests.c b/tests/vb2_gbb_tests.c
index 4acb328c..25691643 100644
--- a/tests/vb2_gbb_tests.c
+++ b/tests/vb2_gbb_tests.c
@@ -13,7 +13,7 @@
 static char gbb_data[4096 + sizeof(struct vb2_gbb_header)];
 static struct vb2_gbb_header *gbb = (struct vb2_gbb_header *)gbb_data;
 static struct vb2_packed_key *rootkey;
-static struct vb2_context ctx;
+static struct vb2_context *ctx;
 static struct vb2_workbuf wb;
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
 
@@ -48,12 +48,9 @@ static void reset_common_data(void)
 	const char hwid_src[] = "Test HWID";
 	set_gbb_hwid(hwid_src, sizeof(hwid_src));
 
-	memset(workbuf, 0, sizeof(workbuf));
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.workbuf = workbuf;
-	ctx.workbuf_size = sizeof(workbuf);
-	vb2_init_context(&ctx);
-	vb2_workbuf_from_ctx(&ctx, &wb);
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
+	vb2_workbuf_from_ctx(ctx, &wb);
 }
 
 /* Mocks */
@@ -90,7 +87,7 @@ static void flag_tests(void)
 {
 	reset_common_data();
 	gbb->flags = 0xdeadbeef;
-	TEST_EQ(vb2api_gbb_get_flags(&ctx), gbb->flags,
+	TEST_EQ(vb2api_gbb_get_flags(ctx), gbb->flags,
 		"retrieve GBB flags");
 }
 
@@ -107,7 +104,7 @@ static void key_tests(void)
 	reset_common_data();
 	wborig = wb;
 	gbb->rootkey_offset = sizeof(*gbb) - 1;
-	TEST_EQ(vb2_gbb_read_root_key(&ctx, &keyp, &size, &wb),
+	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		VB2_ERROR_GBB_INVALID,
 		"gbb.rootkey offset too small");
 	TEST_TRUE(wb.buf == wborig.buf,
@@ -117,7 +114,7 @@ static void key_tests(void)
 	reset_common_data();
 	wborig = wb;
 	gbb->rootkey_offset = sizeof(gbb_data) + 1;
-	TEST_EQ(vb2_gbb_read_root_key(&ctx, &keyp, &size, &wb),
+	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		VB2_ERROR_EX_READ_RESOURCE_SIZE,
 		"gbb.rootkey offset too large");
 	TEST_TRUE(wb.buf == wborig.buf,
@@ -127,7 +124,7 @@ static void key_tests(void)
 	reset_common_data();
 	wborig = wb;
 	gbb->rootkey_size = sizeof(*rootkey) - 1;
-	TEST_EQ(vb2_gbb_read_root_key(&ctx, &keyp, &size, &wb),
+	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		VB2_ERROR_GBB_INVALID,
 		"gbb.rootkey size too small");
 	TEST_TRUE(wb.buf == wborig.buf,
@@ -137,7 +134,7 @@ static void key_tests(void)
 	reset_common_data();
 	wborig = wb;
 	wb.size = sizeof(*rootkey) - 1;
-	TEST_EQ(vb2_gbb_read_root_key(&ctx, &keyp, &size, &wb),
+	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		VB2_ERROR_GBB_WORKBUF,
 		"workbuf size too small for vb2_packed_key header");
 	TEST_TRUE(wb.buf == wborig.buf,
@@ -148,7 +145,7 @@ static void key_tests(void)
 	wborig = wb;
 	rootkey->key_size = 1;
 	rootkey->key_offset = sizeof(*rootkey) - 1;
-	TEST_EQ(vb2_gbb_read_root_key(&ctx, &keyp, &size, &wb),
+	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		VB2_ERROR_INSIDE_DATA_OVERLAP,
 		"rootkey offset too small");
 	TEST_TRUE(wb.buf == wborig.buf,
@@ -160,7 +157,7 @@ static void key_tests(void)
 	rootkey->key_size = 1;
 	rootkey->key_offset = sizeof(gbb_data) + 1;
 	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size;
-	TEST_EQ(vb2_gbb_read_root_key(&ctx, &keyp, &size, &wb),
+	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		VB2_ERROR_EX_READ_RESOURCE_SIZE,
 		"rootkey size too large");
 	TEST_TRUE(wb.buf == wborig.buf,
@@ -171,7 +168,7 @@ static void key_tests(void)
 	wborig = wb;
 	rootkey->key_size = wb.size + 1;
 	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size + 1;
-	TEST_EQ(vb2_gbb_read_root_key(&ctx, &keyp, &size, &wb),
+	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		VB2_ERROR_GBB_WORKBUF,
 		"workbuf size too small for vb2_packed_key contents");
 	TEST_TRUE(wb.buf == wborig.buf,
@@ -182,7 +179,7 @@ static void key_tests(void)
 	wborig = wb;
 	rootkey->key_size = 2;
 	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size - 1;
-	TEST_EQ(vb2_gbb_read_root_key(&ctx, &keyp, &size, &wb),
+	TEST_EQ(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		VB2_ERROR_INSIDE_DATA_OUTSIDE,
 		"rootkey size exceeds gbb.rootkey size");
 	TEST_TRUE(wb.buf == wborig.buf,
@@ -195,7 +192,7 @@ static void key_tests(void)
 	memcpy((void *)rootkey + rootkey->key_offset,
 	       key_data, sizeof(key_data));
 	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size;
-	TEST_SUCC(vb2_gbb_read_root_key(&ctx, &keyp, &size, &wb),
+	TEST_SUCC(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		  "succeeds when gbb.rootkey and rootkey sizes agree");
 	TEST_TRUE(wb.size < wborig.size,
 		  "  workbuf shrank on success");
@@ -210,7 +207,7 @@ static void key_tests(void)
 	wborig = wb;
 	rootkey->key_size = 1;
 	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size + 1;
-	TEST_SUCC(vb2_gbb_read_root_key(&ctx, &keyp, &size, &wb),
+	TEST_SUCC(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		  "succeeds when gbb.rootkey is padded after key");
 	TEST_TRUE(wb.size < wborig.size,
 		  "  workbuf shrank on success");
@@ -224,7 +221,7 @@ static void key_tests(void)
 	rootkey->key_offset = sizeof(*rootkey) + 1;
 	rootkey->key_size = 1;
 	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size;
-	TEST_SUCC(vb2_gbb_read_root_key(&ctx, &keyp, &size, &wb),
+	TEST_SUCC(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		  "succeeds when gbb.rootkey is padded before key");
 	TEST_TRUE(wb.size < wborig.size,
 		  "  workbuf shrank on success");
@@ -237,7 +234,7 @@ static void key_tests(void)
 	rootkey->key_offset = sizeof(*rootkey) + 1;
 	rootkey->key_size = 0;
 	gbb->rootkey_size = rootkey->key_offset + rootkey->key_size + 1;
-	TEST_SUCC(vb2_gbb_read_root_key(&ctx, &keyp, &size, &wb),
+	TEST_SUCC(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		  "succeeds when gbb.rootkey is padded; empty test key");
 	TEST_TRUE(wb.size < wborig.size,
 		  "  workbuf shrank on success");
@@ -250,7 +247,7 @@ static void key_tests(void)
 	rootkey->key_offset = sizeof(*rootkey) - 1;
 	rootkey->key_size = 0;
 	gbb->rootkey_size = sizeof(*rootkey) + rootkey->key_size + 1;
-	TEST_SUCC(vb2_gbb_read_root_key(&ctx, &keyp, &size, &wb),
+	TEST_SUCC(vb2_gbb_read_root_key(ctx, &keyp, &size, &wb),
 		  "succeeds when gbb.rootkey is padded; empty test key");
 	TEST_TRUE(wb.size < wborig.size,
 		  "  workbuf shrank on success");
@@ -267,7 +264,7 @@ static void hwid_tests(void)
 		reset_common_data();
 		gbb->hwid_size = 0;
 		size = VB2_GBB_HWID_MAX_SIZE;
-		TEST_EQ(vb2api_gbb_read_hwid(&ctx, hwid, &size),
+		TEST_EQ(vb2api_gbb_read_hwid(ctx, hwid, &size),
 			VB2_ERROR_GBB_INVALID,
 			"GBB HWID size invalid (HWID missing)");
 	}
@@ -277,7 +274,7 @@ static void hwid_tests(void)
 		reset_common_data();
 		gbb->hwid_offset = sizeof(gbb_data) + 1;
 		size = VB2_GBB_HWID_MAX_SIZE;
-		TEST_EQ(vb2api_gbb_read_hwid(&ctx, hwid, &size),
+		TEST_EQ(vb2api_gbb_read_hwid(ctx, hwid, &size),
 			VB2_ERROR_EX_READ_RESOURCE_SIZE,
 			"GBB HWID offset invalid");
 	}
@@ -288,7 +285,7 @@ static void hwid_tests(void)
 		reset_common_data();
 		set_gbb_hwid(hwid_src, sizeof(hwid_src));
 		size = sizeof(hwid_src) - 1;
-		TEST_EQ(vb2api_gbb_read_hwid(&ctx, hwid, &size),
+		TEST_EQ(vb2api_gbb_read_hwid(ctx, hwid, &size),
 			VB2_ERROR_INVALID_PARAMETER,
 			"HWID too large for buffer");
 	}
@@ -299,7 +296,7 @@ static void hwid_tests(void)
 		reset_common_data();
 		set_gbb_hwid(hwid_src, sizeof(hwid_src) - 1);
 		size = sizeof(hwid_src);
-		TEST_EQ(vb2api_gbb_read_hwid(&ctx, hwid, &size),
+		TEST_EQ(vb2api_gbb_read_hwid(ctx, hwid, &size),
 			VB2_ERROR_INVALID_PARAMETER,
 			"HWID larger than GBB HWID size");
 	}
@@ -310,7 +307,7 @@ static void hwid_tests(void)
 		reset_common_data();
 		set_gbb_hwid(hwid_src, sizeof(hwid_src));
 		size = sizeof(hwid_src);
-		TEST_SUCC(vb2api_gbb_read_hwid(&ctx, hwid, &size),
+		TEST_SUCC(vb2api_gbb_read_hwid(ctx, hwid, &size),
 			  "read normal HWID");
 		TEST_EQ(strcmp(hwid, "Test HWID"), 0, "  HWID correct");
 		TEST_EQ(strlen(hwid) + 1, size, "  HWID size consistent");
@@ -324,7 +321,7 @@ static void hwid_tests(void)
 		reset_common_data();
 		set_gbb_hwid(hwid_src, sizeof(hwid_src));
 		size = sizeof(hwid_src) + 1;
-		TEST_SUCC(vb2api_gbb_read_hwid(&ctx, hwid, &size),
+		TEST_SUCC(vb2api_gbb_read_hwid(ctx, hwid, &size),
 			  "read normal HWID");
 		TEST_EQ(strcmp(hwid, "Test HWID"), 0, "  HWID correct");
 		TEST_EQ(strlen(hwid) + 1, size, "  HWID size consistent");
@@ -338,7 +335,7 @@ static void hwid_tests(void)
 		reset_common_data();
 		set_gbb_hwid(hwid_src, sizeof(hwid_src));
 		size = VB2_GBB_HWID_MAX_SIZE;
-		TEST_SUCC(vb2api_gbb_read_hwid(&ctx, hwid, &size),
+		TEST_SUCC(vb2api_gbb_read_hwid(ctx, hwid, &size),
 			  "read HWID with garbage");
 		TEST_EQ(strcmp(hwid, "Test HWID"), 0, "  HWID correct");
 		TEST_EQ(strlen(hwid) + 1, size, "  HWID size consistent");
diff --git a/tests/vb2_keyblock_fuzzer.c b/tests/vb2_keyblock_fuzzer.c
index 7ac7499c..53f2e7c5 100644
--- a/tests/vb2_keyblock_fuzzer.c
+++ b/tests/vb2_keyblock_fuzzer.c
@@ -10,7 +10,7 @@
 #include "2rsa.h"
 #include "vboot_test.h"
 
-static struct vb2_context ctx;
+static struct vb2_context *ctx;
 __attribute__((aligned(VB2_WORKBUF_ALIGN)))
 static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE];
 static struct {
@@ -73,8 +73,6 @@ vb2_error_t vb2_safe_memcmp(const void *s1, const void *s2, size_t size)
 
 int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size);
 int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
-	vb2_error_t rv;
-
 	if (size < sizeof(gbb.rootkey))
 		return 0;
 
@@ -86,13 +84,10 @@ int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
 	mock_keyblock = data + sizeof(gbb.rootkey);
 	mock_keyblock_size = size - sizeof(gbb.rootkey);
 
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.workbuf = workbuf;
-	ctx.workbuf_size = sizeof(workbuf);
-	rv = vb2_init_context(&ctx);
-	assert(rv == VB2_SUCCESS);
+	if (vb2api_init(workbuf, sizeof(workbuf), &ctx))
+		abort();
 
-	vb2_load_fw_keyblock(&ctx);
+	vb2_load_fw_keyblock(ctx);
 
 	return 0;
 }
diff --git a/tests/vb2_misc_tests.c b/tests/vb2_misc_tests.c
index 2b18b4ee..26cf21e3 100644
--- a/tests/vb2_misc_tests.c
+++ b/tests/vb2_misc_tests.c
@@ -16,7 +16,9 @@
 /* Common context for tests */
 static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
-static struct vb2_context ctx;
+static uint8_t workbuf2[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
+	__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
+static struct vb2_context *ctx;
 static struct vb2_shared_data *sd;
 static struct vb2_gbb_header gbb;
 
@@ -31,20 +33,19 @@ int mock_tpm_clear_retval;
 static void reset_common_data(void)
 {
 	memset(workbuf, 0xaa, sizeof(workbuf));
+	memset(workbuf2, 0xbb, sizeof(workbuf2));
 
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.workbuf = workbuf;
-	ctx.workbuf_size = sizeof(workbuf);
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
 
-	vb2_init_context(&ctx);
-	sd = vb2_get_sd(&ctx);
+	sd = vb2_get_sd(ctx);
 
 	memset(&gbb, 0, sizeof(gbb));
 
-	vb2_nv_init(&ctx);
+	vb2_nv_init(ctx);
 
-	vb2api_secdata_firmware_create(&ctx);
-	vb2_secdata_firmware_init(&ctx);
+	vb2api_secdata_firmware_create(ctx);
+	vb2_secdata_firmware_init(ctx);
 
 	mock_tpm_clear_called = 0;
 	mock_tpm_clear_retval = VB2_SUCCESS;
@@ -78,72 +79,167 @@ vb2_error_t vb2ex_tpm_clear_owner(struct vb2_context *c)
 }
 
 /* Tests */
-static void init_context_tests(void)
+static void init_workbuf_tests(void)
 {
-	/* Use our own context struct so we can re-init it */
-	struct vb2_context c = {
-		.workbuf = workbuf,
-		.workbuf_size = sizeof(workbuf),
-	};
+	struct vb2_context *orig_ctx;
+
+	/* check constants */
+	TEST_TRUE(sizeof(struct vb2_context) < VB2_CONTEXT_MAX_SIZE,
+		  "vb2_context max size constant");
+
+	/* vb2api_init() - misaligned */
+	TEST_EQ(vb2api_init(workbuf + 1, sizeof(workbuf) - 1, &ctx),
+		VB2_ERROR_WORKBUF_ALIGN, "vb2api_init - misaligned");
+
+	/* vb2api_init() - size too small */
+	TEST_EQ(vb2api_init(workbuf, sizeof(struct vb2_shared_data) - 1,
+			      &ctx), VB2_ERROR_WORKBUF_SMALL,
+		"vb2api_init - size too small");
+
+	/* vb2api_init() - success */
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init - success");
+	TEST_TRUE((uintptr_t)workbuf < (uintptr_t)ctx &&
+		  (uintptr_t)ctx < (uintptr_t)workbuf + sizeof(workbuf),
+		  "  return proper pointer");
+	struct vb2_context zero_ctx = {0};
+	TEST_SUCC(memcmp(ctx, &zero_ctx, sizeof(struct vb2_context)),
+		  "  vb2_context set to zero");
+	sd = vb2_get_sd(ctx);
+	TEST_EQ(sd->magic, VB2_SHARED_DATA_MAGIC, "  set magic");
+	TEST_EQ(sd->struct_version_major, VB2_SHARED_DATA_VERSION_MAJOR,
+		"  set major version");
+	TEST_EQ(sd->struct_version_minor, VB2_SHARED_DATA_VERSION_MINOR,
+		"  set minor version");
+	TEST_EQ(sd->workbuf_size, sizeof(workbuf), "  set workbuf size");
+	TEST_TRUE(sd->workbuf_used - sizeof(struct vb2_shared_data)
+		  < VB2_WORKBUF_ALIGN, "  set workbuf used");
 
+	/* vb2api_relocate() - misaligned source */
 	reset_common_data();
+	memmove(workbuf + 1, workbuf, sizeof(workbuf) - 1);
+	TEST_SUCC(vb2api_relocate(workbuf2, workbuf + 1, sizeof(workbuf) - 1,
+				  &ctx), "vb2api_relocate - misaligned source");
 
-	TEST_SUCC(vb2_init_context(&c), "Init context good");
-	TEST_EQ(c.workbuf_used, vb2_wb_round_up(sizeof(struct vb2_shared_data)),
-		"Init vbsd");
-	TEST_EQ(sd->magic, VB2_SHARED_DATA_MAGIC, "Bad magic");
-	TEST_EQ(sd->struct_version_major, VB2_SHARED_DATA_VERSION_MAJOR,
-		"No major version");
-	TEST_EQ(sd->struct_version_minor, VB2_SHARED_DATA_VERSION_MINOR,
-		"No minor version");
+	/* vb2api_relocate() - misaligned target */
+	reset_common_data();
+	TEST_EQ(vb2api_relocate(workbuf2 + 1, workbuf, sizeof(workbuf) - 1,
+				&ctx),
+		VB2_ERROR_WORKBUF_ALIGN, "vb2api_relocate - misaligned target");
 
-	/* Don't re-init if used is non-zero */
-	c.workbuf_used = 200;
-	TEST_SUCC(vb2_init_context(&c), "Re-init context good");
-	TEST_EQ(c.workbuf_used, 200, "Didn't re-init");
+	/* vb2api_relocate() - bad magic */
+	reset_common_data();
+	sd->magic = 0;
+	TEST_EQ(vb2api_relocate(workbuf2, workbuf, sizeof(workbuf), &ctx),
+		VB2_ERROR_SHARED_DATA_MAGIC, "vb2api_relocate - bad magic");
 
-	/* Error if re-init with incorrect magic */
-	sd->magic = 0xdeadbeef;
-	TEST_EQ(vb2_init_context(&c),
-		VB2_ERROR_SHARED_DATA_MAGIC, "Missed bad magic");
-	sd->magic = VB2_SHARED_DATA_MAGIC;
+	/* vb2api_relocate() - small major version */
+	reset_common_data();
+	sd->struct_version_major--;
+	TEST_EQ(vb2api_relocate(workbuf2, workbuf, sizeof(workbuf), &ctx),
+		VB2_ERROR_SHARED_DATA_VERSION,
+		"vb2api_relocate - small major version");
 
-	/* Success if re-init with higher minor version */
-	sd->struct_version_minor++;
-	TEST_SUCC(vb2_init_context(&c), "Didn't allow higher minor version");
-	sd->struct_version_minor = VB2_SHARED_DATA_VERSION_MINOR;
+	/* vb2api_relocate() - big major version */
+	reset_common_data();
+	sd->struct_version_major++;
+	TEST_EQ(vb2api_relocate(workbuf2, workbuf, sizeof(workbuf), &ctx),
+		VB2_ERROR_SHARED_DATA_VERSION,
+		"vb2api_relocate - big major version");
 
-	/* Error if re-init with lower minor version */
+	/* vb2api_relocate() - small minor version */
 	if (VB2_SHARED_DATA_VERSION_MINOR > 0) {
+		reset_common_data();
 		sd->struct_version_minor--;
-		TEST_EQ(vb2_init_context(&c), VB2_ERROR_SHARED_DATA_VERSION,
-			"Allowed lower minor version");
-		sd->struct_version_minor = VB2_SHARED_DATA_VERSION_MINOR;
+		TEST_EQ(vb2api_relocate(workbuf2, workbuf, sizeof(workbuf),
+					&ctx),
+			VB2_ERROR_SHARED_DATA_VERSION,
+			  "vb2api_relocate - small minor version");
 	}
 
-	/* Error if re-init with higher major version */
-	sd->struct_version_major++;
-	TEST_EQ(vb2_init_context(&c),
-		VB2_ERROR_SHARED_DATA_VERSION, "Allowed higher major version");
-	sd->struct_version_major = VB2_SHARED_DATA_VERSION_MAJOR;
-
-	/* Error if re-init with lower major version */
-	sd->struct_version_major--;
-	TEST_EQ(vb2_init_context(&c),
-		VB2_ERROR_SHARED_DATA_VERSION, "Allowed lower major version");
-	sd->struct_version_major = VB2_SHARED_DATA_VERSION_MAJOR;
-
-	/* Handle workbuf errors */
-	c.workbuf_used = 0;
-	c.workbuf_size = sizeof(struct vb2_shared_data) - 1;
-	TEST_EQ(vb2_init_context(&c),
-		VB2_ERROR_INITCTX_WORKBUF_SMALL, "Init too small");
-	c.workbuf_size = sizeof(workbuf);
-
-	/* Handle workbuf unaligned */
-	c.workbuf++;
-	TEST_EQ(vb2_init_context(&c),
-		VB2_ERROR_INITCTX_WORKBUF_ALIGN, "Init unaligned");
+	/* vb2api_relocate() - big minor version */
+	reset_common_data();
+	sd->struct_version_minor++;
+	TEST_SUCC(vb2api_relocate(workbuf2, workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_relocate - big minor version");
+
+	/* vb2api_relocate() - small workbuf_used */
+	reset_common_data();
+	sd->workbuf_used = sizeof(struct vb2_shared_data) - 1;
+	TEST_EQ(vb2api_relocate(workbuf2, workbuf, sizeof(workbuf), &ctx),
+		VB2_ERROR_WORKBUF_INVALID,
+		"vb2api_relocate - small workbuf_used");
+
+	/* vb2api_relocate() - workbuf_size < workbuf_used */
+	reset_common_data();
+	sd->workbuf_used = sd->workbuf_size;
+	sd->workbuf_size--;
+	TEST_EQ(vb2api_relocate(workbuf2, workbuf, sizeof(workbuf), &ctx),
+		VB2_ERROR_WORKBUF_INVALID,
+		"vb2api_relocate - workbuf_size < workbuf_used");
+
+	/* vb2api_relocate() - target workbuf too small */
+	reset_common_data();
+	sd->workbuf_used = sd->workbuf_size - 1;
+	TEST_EQ(vb2api_relocate(workbuf2, workbuf, sd->workbuf_used - 1, &ctx),
+		VB2_ERROR_WORKBUF_SMALL,
+		"vb2api_relocate - target workbuf too small");
+
+	/* vb2api_relocate() - success (same size) */
+	reset_common_data();
+	orig_ctx = ctx;
+	TEST_SUCC(vb2api_relocate(workbuf2, workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_relocate - success (same size)");
+	sd = vb2_get_sd(ctx);
+	TEST_EQ((uintptr_t)orig_ctx - (uintptr_t)workbuf,
+		(uintptr_t)ctx - (uintptr_t)workbuf2,
+		"  same context pointer");
+	TEST_SUCC(memcmp(workbuf2, workbuf, sd->workbuf_used),
+		  "  same workbuf");
+
+	/* vb2api_relocate() - success (smaller size) */
+	reset_common_data();
+	TEST_SUCC(vb2api_relocate(workbuf2, workbuf, sizeof(workbuf) - 1, &ctx),
+		  "vb2api_relocate - success (smaller size)");
+	sd = vb2_get_sd(ctx);
+	TEST_EQ(sd->workbuf_size, sizeof(workbuf) - 1, "  set workbuf size");
+
+	/* vb2api_relocate() - success (larger size) */
+	reset_common_data();
+	sd->workbuf_size--;
+	TEST_SUCC(vb2api_relocate(workbuf2, workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_relocate - success (larger size)");
+	sd = vb2_get_sd(ctx);
+	TEST_EQ(sd->workbuf_size, sizeof(workbuf), "  set workbuf size");
+
+	/* vb2api_relocate() - success (overlapping) */
+	reset_common_data();
+	orig_ctx = ctx;
+	sd->workbuf_size -= VB2_WORKBUF_ALIGN;
+	memcpy(workbuf2, workbuf, sd->workbuf_used);
+	TEST_SUCC(vb2api_relocate(workbuf + VB2_WORKBUF_ALIGN, workbuf,
+				  sizeof(workbuf) - VB2_WORKBUF_ALIGN, &ctx),
+		  "vb2api_relocate - success (overlapping)");
+	sd = vb2_get_sd(ctx);
+	TEST_EQ((uintptr_t)ctx - (uintptr_t)orig_ctx,
+		VB2_WORKBUF_ALIGN,
+		"  context pointer moved");
+	TEST_SUCC(memcmp(workbuf2, workbuf + VB2_WORKBUF_ALIGN,
+			 sd->workbuf_used), "  same workbuf");
+
+	/* vb2api_reinit() - workbuf_size < workbuf_used */
+	reset_common_data();
+	sd->workbuf_size = sd->workbuf_used - 1;
+	TEST_EQ(vb2api_reinit(workbuf, &ctx), VB2_ERROR_WORKBUF_INVALID,
+		"vb2api_reinit - workbuf_size < workbuf_used");
+
+	/* vb2api_reinit() - success */
+	reset_common_data();
+	orig_ctx = ctx;
+	TEST_SUCC(vb2api_reinit(workbuf, &ctx),
+		  "vb2api_reinit - success");
+	TEST_EQ((uintptr_t)ctx, (uintptr_t)orig_ctx,
+		"  context pointer unchanged");
 }
 
 static void misc_tests(void)
@@ -151,13 +247,13 @@ static void misc_tests(void)
 	struct vb2_workbuf wb;
 
 	reset_common_data();
-	ctx.workbuf_used = VB2_WORKBUF_ALIGN;
+	sd->workbuf_used = VB2_WORKBUF_ALIGN;
 
-	vb2_workbuf_from_ctx(&ctx, &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, ctx.workbuf_size - VB2_WORKBUF_ALIGN,
+	TEST_EQ(wb.size, sd->workbuf_size - VB2_WORKBUF_ALIGN,
 		"vb_workbuf_from_ctx() size");
 }
 
@@ -185,69 +281,69 @@ static void gbb_tests(void)
 	mock_resource_index = VB2_RES_GBB;
 	mock_resource_ptr = &gbbsrc;
 	mock_resource_size = sizeof(gbbsrc);
-	TEST_SUCC(vb2_read_gbb_header(&ctx, &gbbdest), "read gbb header good");
+	TEST_SUCC(vb2_read_gbb_header(ctx, &gbbdest), "read gbb header good");
 	TEST_SUCC(memcmp(&gbbsrc, &gbbdest, sizeof(gbbsrc)),
 		  "read gbb contents");
 
 	mock_resource_index = VB2_RES_GBB + 1;
-	TEST_EQ(vb2_read_gbb_header(&ctx, &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;
 
 	gbbsrc.signature[0]++;
-	TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest),
+	TEST_EQ(vb2_read_gbb_header(ctx, &gbbdest),
 		VB2_ERROR_GBB_MAGIC, "read gbb header bad magic");
 	gbbsrc.signature[0]--;
 
 	gbbsrc.major_version = VB2_GBB_MAJOR_VER + 1;
-	TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest),
+	TEST_EQ(vb2_read_gbb_header(ctx, &gbbdest),
 		VB2_ERROR_GBB_VERSION, "read gbb header major version");
 	gbbsrc.major_version = VB2_GBB_MAJOR_VER;
 
 	gbbsrc.minor_version = VB2_GBB_MINOR_VER + 1;
-	TEST_SUCC(vb2_read_gbb_header(&ctx, &gbbdest),
+	TEST_SUCC(vb2_read_gbb_header(ctx, &gbbdest),
 		  "read gbb header minor++");
 	gbbsrc.minor_version = 1;
-	TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest),
+	TEST_EQ(vb2_read_gbb_header(ctx, &gbbdest),
 		VB2_ERROR_GBB_TOO_OLD, "read gbb header 1.1 fails");
 	gbbsrc.minor_version = 0;
-	TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest),
+	TEST_EQ(vb2_read_gbb_header(ctx, &gbbdest),
 		VB2_ERROR_GBB_TOO_OLD, "read gbb header 1.0 fails");
 	gbbsrc.minor_version = VB2_GBB_MINOR_VER;
 
 	gbbsrc.header_size--;
-	TEST_EQ(vb2_read_gbb_header(&ctx, &gbbdest),
+	TEST_EQ(vb2_read_gbb_header(ctx, &gbbdest),
 		VB2_ERROR_GBB_HEADER_SIZE, "read gbb header size");
-	TEST_EQ(vb2_fw_init_gbb(&ctx),
+	TEST_EQ(vb2_fw_init_gbb(ctx),
 		VB2_ERROR_GBB_HEADER_SIZE, "init gbb failure");
 	gbbsrc.header_size++;
 
 	/* Init GBB */
-	int used_before = ctx.workbuf_used;
-	TEST_SUCC(vb2_fw_init_gbb(&ctx), "init gbb");
+	int used_before = sd->workbuf_used;
+	TEST_SUCC(vb2_fw_init_gbb(ctx), "init gbb");
 	/* Manually calculate the location of GBB since we have mocked out the
 	   original definition of vb2_get_gbb. */
 	struct vb2_gbb_header *current_gbb = vb2_member_of(sd, sd->gbb_offset);
 	TEST_SUCC(memcmp(&gbbsrc, current_gbb, sizeof(gbbsrc)),
 		  "copy gbb contents");
-	TEST_EQ(used_before, ctx.workbuf_used - sizeof(gbbsrc),
+	TEST_EQ(used_before, sd->workbuf_used - sizeof(gbbsrc),
 		"unexpected workbuf size");
 
 	/* Workbuf failure */
 	reset_common_data();
-	ctx.workbuf_used = ctx.workbuf_size - 4;
-	TEST_EQ(vb2_fw_init_gbb(&ctx),
+	sd->workbuf_used = sd->workbuf_size - 4;
+	TEST_EQ(vb2_fw_init_gbb(ctx),
 		VB2_ERROR_GBB_WORKBUF, "init gbb no workbuf");
 
 	/* Check for setting NO_SECDATA_FWMP context flag */
 	reset_common_data();
-	TEST_SUCC(vb2_fw_init_gbb(&ctx), "init gbb");
-	TEST_EQ(ctx.flags & VB2_CONTEXT_NO_SECDATA_FWMP, 0,
+	TEST_SUCC(vb2_fw_init_gbb(ctx), "init gbb");
+	TEST_EQ(ctx->flags & VB2_CONTEXT_NO_SECDATA_FWMP, 0,
 		"without DISABLE_FWMP: NO_SECDATA_FWMP shouldn't be set");
 	reset_common_data();
 	gbbsrc.flags |= VB2_GBB_FLAG_DISABLE_FWMP;
-	TEST_SUCC(vb2_fw_init_gbb(&ctx), "init gbb");
-	TEST_NEQ(ctx.flags & VB2_CONTEXT_NO_SECDATA_FWMP, 0,
+	TEST_SUCC(vb2_fw_init_gbb(ctx), "init gbb");
+	TEST_NEQ(ctx->flags & VB2_CONTEXT_NO_SECDATA_FWMP, 0,
 		 "with DISABLE_FWMP: NO_SECDATA_FWMP should be set");
 }
 
@@ -256,35 +352,35 @@ static void fail_tests(void)
 	/* Early fail (before even NV init) */
 	reset_common_data();
 	sd->status &= ~VB2_SD_STATUS_NV_INIT;
-	vb2api_fail(&ctx, 1, 2);
+	vb2api_fail(ctx, 1, 2);
 	TEST_NEQ(sd->status & VB2_SD_STATUS_NV_INIT, 0, "vb2api_fail inits NV");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
 		1, "vb2api_fail request");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_SUBCODE),
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_SUBCODE),
 		2, "vb2api_fail subcode");
 
 	/* Repeated fail doesn't overwrite the error code */
-	vb2api_fail(&ctx, 3, 4);
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
+	vb2api_fail(ctx, 3, 4);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
 		1, "vb2api_fail repeat");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_SUBCODE),
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_SUBCODE),
 		2, "vb2api_fail repeat2");
 
 	/* Fail with other slot good doesn't trigger recovery */
 	reset_common_data();
-	vb2_nv_set(&ctx, VB2_NV_TRY_COUNT, 3);
-	vb2_nv_set(&ctx, 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;
-	vb2api_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),
+	vb2api_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, "vb2api_fail this fw");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TRY_COUNT), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_TRY_COUNT), 0,
 		"vb2api_fail use up tries");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TRY_NEXT), 1,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_TRY_NEXT), 1,
 		"vb2api_fail try other slot");
 
 	/* Fail with other slot already failing triggers recovery */
@@ -293,12 +389,12 @@ static void fail_tests(void)
 	sd->fw_slot = 1;
 	sd->last_fw_slot = 0;
 	sd->last_fw_result = VB2_FW_RESULT_FAILURE;
-	vb2api_fail(&ctx, 7, 8);
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 7,
+	vb2api_fail(ctx, 7, 8);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 7,
 		"vb2api_fail both slots bad");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_FW_RESULT),
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_FW_RESULT),
 		VB2_FW_RESULT_FAILURE, "vb2api_fail this fw");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_TRY_NEXT), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_TRY_NEXT), 0,
 		"vb2api_fail try other slot");
 }
 
@@ -306,38 +402,38 @@ static void recovery_tests(void)
 {
 	/* No recovery */
 	reset_common_data();
-	vb2_check_recovery(&ctx);
+	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(ctx.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(&ctx, VB2_NV_RECOVERY_REQUEST, 3);
-	vb2_check_recovery(&ctx);
+	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(&ctx, 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(ctx.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(&ctx, VB2_NV_RECOVERY_REQUEST, 4);
+	vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, 4);
 	sd->recovery_reason = 5;
-	vb2_check_recovery(&ctx);
+	vb2_check_recovery(ctx);
 	TEST_EQ(sd->recovery_reason, 5, "Recovery reason already failed");
-	TEST_EQ(vb2_nv_get(&ctx, 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;
-	ctx.flags |= VB2_CONTEXT_FORCE_RECOVERY_MODE;
-	vb2_check_recovery(&ctx);
+	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,
@@ -345,9 +441,9 @@ static void recovery_tests(void)
 
 	/* Override at broken screen */
 	reset_common_data();
-	vb2_nv_set(&ctx, VB2_NV_RECOVERY_SUBCODE, VB2_RECOVERY_US_TEST);
-	ctx.flags |= VB2_CONTEXT_FORCE_RECOVERY_MODE;
-	vb2_check_recovery(&ctx);
+	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,
@@ -360,77 +456,77 @@ static void dev_switch_tests(void)
 
 	/* Normal mode */
 	reset_common_data();
-	TEST_SUCC(vb2_check_dev_switch(&ctx), "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(ctx.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(&ctx, 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_firmware_set(
-		&ctx, VB2_SECDATA_FIRMWARE_FLAGS,
+		ctx, VB2_SECDATA_FIRMWARE_FLAGS,
 		(VB2_SECDATA_FIRMWARE_FLAG_DEV_MODE |
 		 VB2_SECDATA_FIRMWARE_FLAG_LAST_BOOT_DEVELOPER));
-	TEST_SUCC(vb2_check_dev_switch(&ctx), "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(ctx.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(&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_DEFAULT_BOOT, 1);
-	TEST_SUCC(vb2_check_dev_switch(&ctx), "dev mode off");
-	TEST_EQ(vb2_nv_get(&ctx, 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_DEFAULT_BOOT, 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(&ctx, 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(&ctx, 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(&ctx, VB2_NV_DEV_DEFAULT_BOOT),
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DEV_DEFAULT_BOOT),
 		0, "  cleared dev default boot");
 
 	/* Normal-dev transition clears TPM */
 	reset_common_data();
-	vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_FLAGS,
+	vb2_secdata_firmware_set(ctx, VB2_SECDATA_FIRMWARE_FLAGS,
 				 VB2_SECDATA_FIRMWARE_FLAG_DEV_MODE);
-	TEST_SUCC(vb2_check_dev_switch(&ctx), "to dev mode");
+	TEST_SUCC(vb2_check_dev_switch(ctx), "to dev mode");
 	TEST_EQ(mock_tpm_clear_called, 1, "  tpm clear");
-	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS);
+	v = vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_FLAGS);
 	TEST_EQ(v, (VB2_SECDATA_FIRMWARE_FLAG_DEV_MODE |
 		    VB2_SECDATA_FIRMWARE_FLAG_LAST_BOOT_DEVELOPER),
 		"  last boot developer now");
 
 	/* Dev-normal transition clears TPM too */
 	reset_common_data();
-	vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_FLAGS,
+	vb2_secdata_firmware_set(ctx, VB2_SECDATA_FIRMWARE_FLAGS,
 				 VB2_SECDATA_FIRMWARE_FLAG_LAST_BOOT_DEVELOPER);
-	TEST_SUCC(vb2_check_dev_switch(&ctx), "from dev mode");
+	TEST_SUCC(vb2_check_dev_switch(ctx), "from dev mode");
 	TEST_EQ(mock_tpm_clear_called, 1, "  tpm clear");
-	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS);
+	v = vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_FLAGS);
 	TEST_EQ(v, 0, "  last boot not developer now");
 
 	/* Disable dev mode */
 	reset_common_data();
 	vb2_secdata_firmware_set(
-		&ctx, VB2_SECDATA_FIRMWARE_FLAGS,
+		ctx, VB2_SECDATA_FIRMWARE_FLAGS,
 		(VB2_SECDATA_FIRMWARE_FLAG_DEV_MODE |
 		 VB2_SECDATA_FIRMWARE_FLAG_LAST_BOOT_DEVELOPER));
-	vb2_nv_set(&ctx, VB2_NV_DISABLE_DEV_REQUEST, 1);
-	TEST_SUCC(vb2_check_dev_switch(&ctx), "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(&ctx, 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();
 	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON;
-	TEST_SUCC(vb2_check_dev_switch(&ctx), "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");
-	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS);
+	v = vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_FLAGS);
 	TEST_EQ(v, VB2_SECDATA_FIRMWARE_FLAG_LAST_BOOT_DEVELOPER,
 		"  doesn't set dev on in secdata_firmware "
 		"but does set last boot dev");
@@ -439,27 +535,27 @@ static void dev_switch_tests(void)
 	/* Request disable by ctx flag */
 	reset_common_data();
 	vb2_secdata_firmware_set(
-		&ctx, VB2_SECDATA_FIRMWARE_FLAGS,
+		ctx, VB2_SECDATA_FIRMWARE_FLAGS,
 		(VB2_SECDATA_FIRMWARE_FLAG_DEV_MODE |
 		 VB2_SECDATA_FIRMWARE_FLAG_LAST_BOOT_DEVELOPER));
-	ctx.flags |= VB2_CONTEXT_DISABLE_DEVELOPER_MODE;
-	TEST_SUCC(vb2_check_dev_switch(&ctx), "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_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_FLAGS,
+	vb2_secdata_firmware_set(ctx, VB2_SECDATA_FIRMWARE_FLAGS,
 				 VB2_SECDATA_FIRMWARE_FLAG_LAST_BOOT_DEVELOPER);
 	mock_tpm_clear_retval = VB2_ERROR_EX_TPM_CLEAR_OWNER;
-	TEST_EQ(vb2_check_dev_switch(&ctx),
+	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");
-	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS);
+	v = vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_FLAGS);
 	TEST_EQ(v, VB2_SECDATA_FIRMWARE_FLAG_LAST_BOOT_DEVELOPER,
 		"  last boot still developer");
-	TEST_EQ(vb2_nv_get(&ctx, 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(&ctx, VB2_NV_RECOVERY_SUBCODE),
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_SUBCODE),
 		(uint8_t)VB2_ERROR_EX_TPM_CLEAR_OWNER, "  recovery subcode");
 
 	/*
@@ -467,77 +563,77 @@ static void dev_switch_tests(void)
 	 * if dev mode was on in the (inaccessible) secdata_firmware.
 	 */
 	reset_common_data();
-	vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_FLAGS,
+	vb2_secdata_firmware_set(ctx, VB2_SECDATA_FIRMWARE_FLAGS,
 				 VB2_SECDATA_FIRMWARE_FLAG_DEV_MODE);
 	sd->status &= ~VB2_SD_STATUS_SECDATA_FIRMWARE_INIT;
-	TEST_ABORT(vb2_check_dev_switch(&ctx), "secdata_firmware fail normal");
+	TEST_ABORT(vb2_check_dev_switch(ctx), "secdata_firmware fail normal");
 	TEST_EQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, "  sd not in dev");
-	TEST_EQ(ctx.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, "  ctx not in dev");
+	TEST_EQ(ctx->flags & VB2_CONTEXT_DEVELOPER_MODE, 0, "  ctx not in dev");
 
 	/* secdata_firmware failure in recovery mode continues */
 	reset_common_data();
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
 	sd->status &= ~VB2_SD_STATUS_SECDATA_FIRMWARE_INIT;
-	TEST_SUCC(vb2_check_dev_switch(&ctx), "secdata_firmware fail recovery");
+	TEST_SUCC(vb2_check_dev_switch(ctx), "secdata_firmware fail recovery");
 	TEST_EQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, "  sd not in dev");
-	TEST_EQ(ctx.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();
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
 	sd->status &= ~VB2_SD_STATUS_SECDATA_FIRMWARE_INIT;
-	vb2_nv_set(&ctx, VB2_NV_DISABLE_DEV_REQUEST, 1);
-	TEST_SUCC(vb2_check_dev_switch(&ctx),
+	vb2_nv_set(ctx, VB2_NV_DISABLE_DEV_REQUEST, 1);
+	TEST_SUCC(vb2_check_dev_switch(ctx),
 		  "secdata_firmware fail recovery disable");
 	TEST_EQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, "  sd not in dev");
-	TEST_EQ(ctx.flags & VB2_CONTEXT_DEVELOPER_MODE, 0, "  ctx not in dev");
-	TEST_EQ(vb2_nv_get(&ctx, 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();
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
 	sd->status &= ~VB2_SD_STATUS_SECDATA_FIRMWARE_INIT;
 	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON;
-	TEST_SUCC(vb2_check_dev_switch(&ctx),
+	TEST_SUCC(vb2_check_dev_switch(ctx),
 		  "secdata_firmware fail recovery gbb");
 	TEST_NEQ(sd->flags & VB2_SD_FLAG_DEV_MODE_ENABLED, 0, "  sd in dev");
-	TEST_NEQ(ctx.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();
-	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");
+	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(&ctx), "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(&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),
+	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(&ctx, 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(&ctx, VB2_NV_CLEAR_TPM_OWNER_REQUEST, 1);
-	TEST_EQ(vb2_check_tpm_clear(&ctx),
+	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(&ctx, 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(&ctx, VB2_NV_CLEAR_TPM_OWNER_DONE),
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_CLEAR_TPM_OWNER_DONE),
 		0, "done not set");
 }
 
@@ -545,92 +641,92 @@ static void select_slot_tests(void)
 {
 	/* Slot A */
 	reset_common_data();
-	TEST_SUCC(vb2_select_fw_slot(&ctx), "select slot A");
-	TEST_EQ(vb2_nv_get(&ctx, 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(&ctx, 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(ctx.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(&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_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(&ctx, 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(ctx.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(&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");
+	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(&ctx, 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(ctx.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();
-	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");
+	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(&ctx, 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(ctx.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(&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_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(&ctx, 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(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");
+	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();
-	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),
+	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(&ctx, 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(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");
+	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(&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,
+	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(&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,
+	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");
 }
 
 int main(int argc, char* argv[])
 {
-	init_context_tests();
+	init_workbuf_tests();
 	misc_tests();
 	gbb_tests();
 	fail_tests();
diff --git a/tests/vb2_nvstorage_tests.c b/tests/vb2_nvstorage_tests.c
index fdb0e742..9909d7c4 100644
--- a/tests/vb2_nvstorage_tests.c
+++ b/tests/vb2_nvstorage_tests.c
@@ -83,186 +83,186 @@ static void nv_storage_test(uint32_t ctxflags)
 	uint8_t goodcrc;
 	uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
 		__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
-	struct vb2_context c = {
-		.flags = ctxflags,
-		.workbuf = workbuf,
-		.workbuf_size = sizeof(workbuf),
-	};
-	struct vb2_shared_data *sd = vb2_get_sd(&c);
+	struct vb2_context *ctx;
+
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
+	ctx->flags = ctxflags;
+
+	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 
 	/* Things that change between V1 and V2 */
 	int expect_header = 0x30 | (ctxflags ? VB2_NV_HEADER_SIGNATURE_V2 :
 				    VB2_NV_HEADER_SIGNATURE_V1);
 	int crc_offs = ctxflags ? VB2_NV_OFFS_CRC_V2 : VB2_NV_OFFS_CRC_V1;
 
-	TEST_EQ(vb2_nv_get_size(&c), ctxflags ? VB2_NVDATA_SIZE_V2 :
+	TEST_EQ(vb2_nv_get_size(ctx), ctxflags ? VB2_NVDATA_SIZE_V2 :
 				VB2_NVDATA_SIZE, "vb2_nv_get_size()");
 
-	memset(c.nvdata, 0xA6, sizeof(c.nvdata));
-	vb2_init_context(&c);
+	memset(ctx->nvdata, 0xA6, sizeof(ctx->nvdata));
 
 	/* Init with invalid data should set defaults and regenerate CRC */
-	vb2_nv_init(&c);
-	TEST_EQ(c.nvdata[VB2_NV_OFFS_HEADER], expect_header,
+	vb2_nv_init(ctx);
+	TEST_EQ(ctx->nvdata[VB2_NV_OFFS_HEADER], expect_header,
 		"vb2_nv_init() reset header byte");
-	TEST_NEQ(c.nvdata[crc_offs], 0, "vb2_nv_init() CRC");
+	TEST_NEQ(ctx->nvdata[crc_offs], 0, "vb2_nv_init() CRC");
 	TEST_EQ(sd->status, VB2_SD_STATUS_NV_INIT | VB2_SD_STATUS_NV_REINIT,
 		"vb2_nv_init() status changed");
-	test_changed(&c, 1, "vb2_nv_init() reset changed");
-	goodcrc = c.nvdata[crc_offs];
-	TEST_SUCC(vb2_nv_check_crc(&c), "vb2_nv_check_crc() good");
+	test_changed(ctx, 1, "vb2_nv_init() reset changed");
+	goodcrc = ctx->nvdata[crc_offs];
+	TEST_SUCC(vb2_nv_check_crc(ctx), "vb2_nv_check_crc() good");
 
 	/* Another init should not cause further changes */
-	c.flags = ctxflags;
+	ctx->flags = ctxflags;
 	sd->status = 0;
-	vb2_nv_init(&c);
-	test_changed(&c, 0, "vb2_nv_init() didn't re-reset");
-	TEST_EQ(c.nvdata[crc_offs], goodcrc,
+	vb2_nv_init(ctx);
+	test_changed(ctx, 0, "vb2_nv_init() didn't re-reset");
+	TEST_EQ(ctx->nvdata[crc_offs], goodcrc,
 		"vb2_nv_init() CRC same");
 	TEST_EQ(sd->status, VB2_SD_STATUS_NV_INIT,
 		"vb2_nv_init() status same");
 
 	/* Perturbing signature bits in the header should force defaults */
-	c.nvdata[VB2_NV_OFFS_HEADER] ^= 0x40;
-	TEST_EQ(vb2_nv_check_crc(&c),
+	ctx->nvdata[VB2_NV_OFFS_HEADER] ^= 0x40;
+	TEST_EQ(vb2_nv_check_crc(ctx),
 		VB2_ERROR_NV_HEADER, "vb2_nv_check_crc() bad header");
-	vb2_nv_init(&c);
-	TEST_EQ(c.nvdata[VB2_NV_OFFS_HEADER], expect_header,
+	vb2_nv_init(ctx);
+	TEST_EQ(ctx->nvdata[VB2_NV_OFFS_HEADER], expect_header,
 		"vb2_nv_init() reset header byte again");
-	test_changed(&c, 1, "vb2_nv_init() corrupt changed");
-	TEST_EQ(c.nvdata[crc_offs], goodcrc,
+	test_changed(ctx, 1, "vb2_nv_init() corrupt changed");
+	TEST_EQ(ctx->nvdata[crc_offs], goodcrc,
 		"vb2_nv_init() CRC same again");
 
 	/* So should perturbing some other byte */
-	TEST_EQ(c.nvdata[VB2_NV_OFFS_KERNEL1], 0, "Kernel byte starts at 0");
-	c.nvdata[VB2_NV_OFFS_KERNEL1] = 12;
-	TEST_EQ(vb2_nv_check_crc(&c),
+	TEST_EQ(ctx->nvdata[VB2_NV_OFFS_KERNEL1], 0, "Kernel byte starts at 0");
+	ctx->nvdata[VB2_NV_OFFS_KERNEL1] = 12;
+	TEST_EQ(vb2_nv_check_crc(ctx),
 		VB2_ERROR_NV_CRC, "vb2_nv_check_crc() bad CRC");
-	vb2_nv_init(&c);
-	TEST_EQ(c.nvdata[VB2_NV_OFFS_KERNEL1], 0,
+	vb2_nv_init(ctx);
+	TEST_EQ(ctx->nvdata[VB2_NV_OFFS_KERNEL1], 0,
 		"vb2_nv_init() reset kernel byte");
-	test_changed(&c, 1, "vb2_nv_init() corrupt elsewhere changed");
-	TEST_EQ(c.nvdata[crc_offs], goodcrc,
+	test_changed(ctx, 1, "vb2_nv_init() corrupt elsewhere changed");
+	TEST_EQ(ctx->nvdata[crc_offs], goodcrc,
 		"vb2_nv_init() CRC same again");
 
 	/* Clear the kernel and firmware flags */
-	vb2_nv_init(&c);
-	TEST_EQ(vb2_nv_get(&c, VB2_NV_FIRMWARE_SETTINGS_RESET),
+	vb2_nv_init(ctx);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_FIRMWARE_SETTINGS_RESET),
 		1, "Firmware settings are reset");
-	vb2_nv_set(&c, VB2_NV_FIRMWARE_SETTINGS_RESET, 0);
-	TEST_EQ(vb2_nv_get(&c, VB2_NV_FIRMWARE_SETTINGS_RESET),
+	vb2_nv_set(ctx, VB2_NV_FIRMWARE_SETTINGS_RESET, 0);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_FIRMWARE_SETTINGS_RESET),
 		0, "Firmware settings are clear");
 
-	TEST_EQ(vb2_nv_get(&c, VB2_NV_KERNEL_SETTINGS_RESET),
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_KERNEL_SETTINGS_RESET),
 		1, "Kernel settings are reset");
-	vb2_nv_set(&c, VB2_NV_KERNEL_SETTINGS_RESET, 0);
-	TEST_EQ(vb2_nv_get(&c, VB2_NV_KERNEL_SETTINGS_RESET),
+	vb2_nv_set(ctx, VB2_NV_KERNEL_SETTINGS_RESET, 0);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_KERNEL_SETTINGS_RESET),
 		0, "Kernel settings are clear");
 
-	TEST_EQ(c.nvdata[VB2_NV_OFFS_HEADER],
+	TEST_EQ(ctx->nvdata[VB2_NV_OFFS_HEADER],
 		expect_header & VB2_NV_HEADER_SIGNATURE_MASK,
 		"Header byte now just has the signature");
 	/* That should have changed the CRC */
-	TEST_NEQ(c.nvdata[crc_offs], goodcrc,
+	TEST_NEQ(ctx->nvdata[crc_offs], goodcrc,
 		 "vb2_nv_init() CRC changed due to flags clear");
 
 	/* Test explicitly setting the reset flags again */
-	vb2_nv_init(&c);
-	vb2_nv_set(&c, VB2_NV_FIRMWARE_SETTINGS_RESET, 1);
-	TEST_EQ(vb2_nv_get(&c, VB2_NV_FIRMWARE_SETTINGS_RESET),
+	vb2_nv_init(ctx);
+	vb2_nv_set(ctx, VB2_NV_FIRMWARE_SETTINGS_RESET, 1);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_FIRMWARE_SETTINGS_RESET),
 		1, "Firmware settings forced reset");
-	vb2_nv_set(&c, VB2_NV_FIRMWARE_SETTINGS_RESET, 0);
+	vb2_nv_set(ctx, VB2_NV_FIRMWARE_SETTINGS_RESET, 0);
 
-	vb2_nv_set(&c, VB2_NV_KERNEL_SETTINGS_RESET, 1);
-	TEST_EQ(vb2_nv_get(&c, VB2_NV_KERNEL_SETTINGS_RESET),
+	vb2_nv_set(ctx, VB2_NV_KERNEL_SETTINGS_RESET, 1);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_KERNEL_SETTINGS_RESET),
 		1, "Kernel settings forced reset");
-	vb2_nv_set(&c, VB2_NV_KERNEL_SETTINGS_RESET, 0);
+	vb2_nv_set(ctx, VB2_NV_KERNEL_SETTINGS_RESET, 0);
 
 	/* Get/set an invalid field */
-	vb2_nv_init(&c);
-	vb2_nv_set(&c, -1, 1);
-	TEST_EQ(vb2_nv_get(&c, -1), 0, "Get invalid setting");
+	vb2_nv_init(ctx);
+	vb2_nv_set(ctx, -1, 1);
+	TEST_EQ(vb2_nv_get(ctx, -1), 0, "Get invalid setting");
 
 	/* Test other fields */
-	vb2_nv_init(&c);
+	vb2_nv_init(ctx);
 	for (vnf = nvfields; vnf->desc; vnf++) {
-		TEST_EQ(vb2_nv_get(&c, vnf->param), vnf->default_value,
+		TEST_EQ(vb2_nv_get(ctx, vnf->param), vnf->default_value,
 			vnf->desc);
-		vb2_nv_set(&c, vnf->param, vnf->test_value);
-		TEST_EQ(vb2_nv_get(&c, vnf->param), vnf->test_value, vnf->desc);
-		vb2_nv_set(&c, vnf->param, vnf->test_value2);
-		TEST_EQ(vb2_nv_get(&c, vnf->param), vnf->test_value2,
+		vb2_nv_set(ctx, vnf->param, vnf->test_value);
+		TEST_EQ(vb2_nv_get(ctx, vnf->param), vnf->test_value, vnf->desc);
+		vb2_nv_set(ctx, vnf->param, vnf->test_value2);
+		TEST_EQ(vb2_nv_get(ctx, vnf->param), vnf->test_value2,
 			vnf->desc);
 	}
 
 	for (vnf = nv2fields; vnf->desc; vnf++) {
 		if (ctxflags) {
-			TEST_EQ(vb2_nv_get(&c, vnf->param), vnf->default_value,
+			TEST_EQ(vb2_nv_get(ctx, vnf->param), vnf->default_value,
 				vnf->desc);
-			vb2_nv_set(&c, vnf->param, vnf->test_value);
-			TEST_EQ(vb2_nv_get(&c, vnf->param), vnf->test_value,
+			vb2_nv_set(ctx, vnf->param, vnf->test_value);
+			TEST_EQ(vb2_nv_get(ctx, vnf->param), vnf->test_value,
 				vnf->desc);
-			vb2_nv_set(&c, vnf->param, vnf->test_value2);
-			TEST_EQ(vb2_nv_get(&c, vnf->param), vnf->test_value2,
+			vb2_nv_set(ctx, vnf->param, vnf->test_value2);
+			TEST_EQ(vb2_nv_get(ctx, vnf->param), vnf->test_value2,
 				vnf->desc);
 		} else {
 			/*
 			 * V2 fields always return defaults and can't be set if
 			 * a V1 struct is present.
 			 */
-			TEST_EQ(vb2_nv_get(&c, vnf->param), vnf->test_value,
+			TEST_EQ(vb2_nv_get(ctx, vnf->param), vnf->test_value,
 				vnf->desc);
-			vb2_nv_set(&c, vnf->param, vnf->test_value2);
-			TEST_EQ(vb2_nv_get(&c, vnf->param), vnf->test_value,
+			vb2_nv_set(ctx, vnf->param, vnf->test_value2);
+			TEST_EQ(vb2_nv_get(ctx, vnf->param), vnf->test_value,
 				vnf->desc);
 		}
 	}
 
 	/* None of those changes should have caused a reset to defaults */
-	vb2_nv_init(&c);
-	TEST_EQ(vb2_nv_get(&c, VB2_NV_FIRMWARE_SETTINGS_RESET),
+	vb2_nv_init(ctx);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_FIRMWARE_SETTINGS_RESET),
 		0, "Firmware settings are still clear");
-	TEST_EQ(vb2_nv_get(&c, VB2_NV_KERNEL_SETTINGS_RESET),
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_KERNEL_SETTINGS_RESET),
 		0, "Kernel settings are still clear");
 
 	/* Writing identical settings doesn't cause the CRC to regenerate */
-	c.flags = ctxflags;
-	vb2_nv_init(&c);
-	test_changed(&c, 0, "No regen CRC on open");
+	ctx->flags = ctxflags;
+	vb2_nv_init(ctx);
+	test_changed(ctx, 0, "No regen CRC on open");
 	for (vnf = nvfields; vnf->desc; vnf++)
-		vb2_nv_set(&c, vnf->param, vnf->test_value2);
-	test_changed(&c, 0, "No regen CRC if data not changed");
+		vb2_nv_set(ctx, vnf->param, vnf->test_value2);
+	test_changed(ctx, 0, "No regen CRC if data not changed");
 	/*
 	 * If struct is V2, this is the same test.  If struct is V1, this
 	 * verifies that the field couldn't be changed anyway.
 	 */
 	for (vnf = nv2fields; vnf->desc; vnf++)
-		vb2_nv_set(&c, vnf->param, vnf->test_value2);
-	test_changed(&c, 0, "No regen CRC if V2 data not changed");
+		vb2_nv_set(ctx, vnf->param, vnf->test_value2);
+	test_changed(ctx, 0, "No regen CRC if V2 data not changed");
 
 	/* Test out-of-range fields mapping to defaults or failing */
-	vb2_nv_init(&c);
-	vb2_nv_set(&c, VB2_NV_TRY_COUNT, 16);
-	TEST_EQ(vb2_nv_get(&c, VB2_NV_TRY_COUNT),
+	vb2_nv_init(ctx);
+	vb2_nv_set(ctx, VB2_NV_TRY_COUNT, 16);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_TRY_COUNT),
 		15, "Try b count out of range");
-	vb2_nv_set(&c, VB2_NV_RECOVERY_REQUEST, 0x101);
-	TEST_EQ(vb2_nv_get(&c, VB2_NV_RECOVERY_REQUEST),
+	vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, 0x101);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
 		VB2_RECOVERY_LEGACY, "Recovery request out of range");
-	vb2_nv_set(&c, VB2_NV_LOCALIZATION_INDEX, 0x102);
-	TEST_EQ(vb2_nv_get(&c, VB2_NV_LOCALIZATION_INDEX),
+	vb2_nv_set(ctx, VB2_NV_LOCALIZATION_INDEX, 0x102);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_LOCALIZATION_INDEX),
 		0, "Localization index out of range");
 
-	vb2_nv_set(&c, VB2_NV_FW_RESULT, 100);
-	TEST_EQ(vb2_nv_get(&c, VB2_NV_FW_RESULT),
+	vb2_nv_set(ctx, VB2_NV_FW_RESULT, 100);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_FW_RESULT),
 		VB2_FW_RESULT_UNKNOWN, "Firmware result out of range");
 
-	vb2_nv_set(&c, VB2_NV_FW_PREV_RESULT, 100);
-	TEST_EQ(vb2_nv_get(&c, VB2_NV_FW_PREV_RESULT),
+	vb2_nv_set(ctx, VB2_NV_FW_PREV_RESULT, 100);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_FW_PREV_RESULT),
 		VB2_FW_RESULT_UNKNOWN, "Fw prev result out of range");
 
-	vb2_nv_set(&c, VB2_NV_DEV_DEFAULT_BOOT,
+	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
 		   VB2_DEV_DEFAULT_BOOT_DISK + 100);
-	TEST_EQ(vb2_nv_get(&c, VB2_NV_DEV_DEFAULT_BOOT),
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DEV_DEFAULT_BOOT),
 		VB2_DEV_DEFAULT_BOOT_DISK, "default to booting from disk");
 }
 
diff --git a/tests/vb2_preamble_fuzzer.c b/tests/vb2_preamble_fuzzer.c
index 0ad2298e..edc429a4 100644
--- a/tests/vb2_preamble_fuzzer.c
+++ b/tests/vb2_preamble_fuzzer.c
@@ -11,7 +11,7 @@
 #include "2secdata.h"
 #include "vboot_test.h"
 
-static struct vb2_context ctx;
+static struct vb2_context *ctx;
 __attribute__((aligned(VB2_WORKBUF_ALIGN)))
 static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE];
 
@@ -62,19 +62,15 @@ vb2_error_t vb2_safe_memcmp(const void *s1, const void *s2, size_t size)
 int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size);
 int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
 	const size_t datakey_size = 4096;	// enough for all our signatures
-	vb2_error_t rv;
 
 	if (size < datakey_size)
 		return 0;
 
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.workbuf = workbuf;
-	ctx.workbuf_size = sizeof(workbuf);
-	rv = vb2_init_context(&ctx);
-	assert(rv == VB2_SUCCESS);
+	if (vb2api_init(workbuf, sizeof(workbuf), &ctx))
+		abort();
 
 	struct vb2_workbuf wb;
-	vb2_workbuf_from_ctx(&ctx, &wb);
+	vb2_workbuf_from_ctx(ctx, &wb);
 
 	uint8_t *key = vb2_workbuf_alloc(&wb, datakey_size);
 	assert(key);
@@ -83,13 +79,13 @@ int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
 	mock_preamble = data + datakey_size;
 	mock_preamble_size = size - datakey_size;
 
-	struct vb2_shared_data *sd = vb2_get_sd(&ctx);
+	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	sd->data_key_offset = vb2_offset_of(sd, key);
 	sd->data_key_size = datakey_size;
-	vb2_set_workbuf_used(&ctx, sd->data_key_offset + sd->data_key_size);
+	vb2_set_workbuf_used(ctx, sd->data_key_offset + sd->data_key_size);
 
 	sd->vblock_preamble_offset = 0;
-	vb2_load_fw_preamble(&ctx);
+	vb2_load_fw_preamble(ctx);
 
 	return 0;
 }
diff --git a/tests/vb2_secdata_firmware_tests.c b/tests/vb2_secdata_firmware_tests.c
index 84cb2741..68a5ce21 100644
--- a/tests/vb2_secdata_firmware_tests.c
+++ b/tests/vb2_secdata_firmware_tests.c
@@ -17,22 +17,19 @@
 
 static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
-static struct vb2_context ctx;
+static struct vb2_context *ctx;
 static struct vb2_shared_data *sd;
 static struct vb2_secdata_firmware *sec;
 
 static void reset_common_data(void)
 {
 	memset(workbuf, 0xaa, sizeof(workbuf));
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
 
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.workbuf = workbuf;
-	ctx.workbuf_size = sizeof(workbuf);
+	sd = vb2_get_sd(ctx);
 
-	vb2_init_context(&ctx);
-	sd = vb2_get_sd(&ctx);
-
-	sec = (struct vb2_secdata_firmware *)ctx.secdata_firmware;
+	sec = (struct vb2_secdata_firmware *)ctx->secdata_firmware;
 }
 
 static void test_changed(struct vb2_context *c, int changed, const char *why)
@@ -57,89 +54,89 @@ static void secdata_firmware_test(void)
 		"Struct size constant");
 
 	/* Blank data is invalid */
-	memset(ctx.secdata_firmware, 0xa6, sizeof(ctx.secdata_firmware));
-	TEST_EQ(vb2api_secdata_firmware_check(&ctx),
+	memset(&ctx->secdata_firmware, 0xa6, sizeof(ctx->secdata_firmware));
+	TEST_EQ(vb2api_secdata_firmware_check(ctx),
 		VB2_ERROR_SECDATA_FIRMWARE_CRC, "Check blank CRC");
-	TEST_EQ(vb2_secdata_firmware_init(&ctx),
+	TEST_EQ(vb2_secdata_firmware_init(ctx),
 		VB2_ERROR_SECDATA_FIRMWARE_CRC, "Init blank CRC");
 
 	/* Ensure zeroed buffers are invalid (coreboot relies on this) */
-	memset(ctx.secdata_firmware, 0, sizeof(ctx.secdata_firmware));
-	TEST_EQ(vb2_secdata_firmware_init(&ctx),
+	memset(&ctx->secdata_firmware, 0, sizeof(ctx->secdata_firmware));
+	TEST_EQ(vb2_secdata_firmware_init(ctx),
 		VB2_ERROR_SECDATA_FIRMWARE_VERSION,
 		"Zeroed buffer (invalid version)");
 
 	/* Try with bad version */
-	TEST_EQ(vb2api_secdata_firmware_create(&ctx), VB2_SECDATA_FIRMWARE_SIZE,
+	TEST_EQ(vb2api_secdata_firmware_create(ctx), VB2_SECDATA_FIRMWARE_SIZE,
 		"Create");
 	sec->struct_version -= 1;
 	sec->crc8 = vb2_crc8(sec, offsetof(struct vb2_secdata_firmware, crc8));
-	TEST_EQ(vb2api_secdata_firmware_check(&ctx),
+	TEST_EQ(vb2api_secdata_firmware_check(ctx),
 		VB2_ERROR_SECDATA_FIRMWARE_VERSION, "Check invalid version");
-	TEST_EQ(vb2_secdata_firmware_init(&ctx),
+	TEST_EQ(vb2_secdata_firmware_init(ctx),
 		VB2_ERROR_SECDATA_FIRMWARE_VERSION, "Init invalid version");
 
 	/* Create good data */
-	vb2api_secdata_firmware_create(&ctx);
-	TEST_SUCC(vb2api_secdata_firmware_check(&ctx), "Check created CRC");
-	TEST_SUCC(vb2_secdata_firmware_init(&ctx), "Init created CRC");
+	vb2api_secdata_firmware_create(ctx);
+	TEST_SUCC(vb2api_secdata_firmware_check(ctx), "Check created CRC");
+	TEST_SUCC(vb2_secdata_firmware_init(ctx), "Init created CRC");
 	TEST_NEQ(sd->status & VB2_SD_STATUS_SECDATA_FIRMWARE_INIT, 0,
 		 "Init set SD status");
 	sd->status &= ~VB2_SD_STATUS_SECDATA_FIRMWARE_INIT;
-	test_changed(&ctx, 1, "Create changes data");
+	test_changed(ctx, 1, "Create changes data");
 
 	/* Now corrupt it */
-	ctx.secdata_firmware[2]++;
-	TEST_EQ(vb2api_secdata_firmware_check(&ctx),
+	ctx->secdata_firmware[2]++;
+	TEST_EQ(vb2api_secdata_firmware_check(ctx),
 		VB2_ERROR_SECDATA_FIRMWARE_CRC, "Check invalid CRC");
-	TEST_EQ(vb2_secdata_firmware_init(&ctx),
+	TEST_EQ(vb2_secdata_firmware_init(ctx),
 		VB2_ERROR_SECDATA_FIRMWARE_CRC, "Init invalid CRC");
 
 	/* Read/write flags */
-	vb2api_secdata_firmware_create(&ctx);
-	vb2_secdata_firmware_init(&ctx);
-	ctx.flags = 0;
-	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS);
+	vb2api_secdata_firmware_create(ctx);
+	vb2_secdata_firmware_init(ctx);
+	ctx->flags = 0;
+	v = vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_FLAGS);
 	TEST_EQ(v, 0, "Flags created 0");
-	test_changed(&ctx, 0, "Get doesn't change data");
-	vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_FLAGS, 0x12);
-	test_changed(&ctx, 1, "Set changes data");
-	vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_FLAGS, 0x12);
-	test_changed(&ctx, 0, "Set again doesn't change data");
-	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_FLAGS);
+	test_changed(ctx, 0, "Get doesn't change data");
+	vb2_secdata_firmware_set(ctx, VB2_SECDATA_FIRMWARE_FLAGS, 0x12);
+	test_changed(ctx, 1, "Set changes data");
+	vb2_secdata_firmware_set(ctx, VB2_SECDATA_FIRMWARE_FLAGS, 0x12);
+	test_changed(ctx, 0, "Set again doesn't change data");
+	v = vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_FLAGS);
 	TEST_EQ(v, 0x12, "Flags changed");
-	TEST_ABORT(vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_FLAGS,
+	TEST_ABORT(vb2_secdata_firmware_set(ctx, VB2_SECDATA_FIRMWARE_FLAGS,
 					    0x100),
 		   "Bad flags");
 
 	/* Read/write versions */
-	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
+	v = vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
 	TEST_EQ(v, 0, "Versions created 0");
-	test_changed(&ctx, 0, "Get doesn't change data");
-	vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
+	test_changed(ctx, 0, "Get doesn't change data");
+	vb2_secdata_firmware_set(ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
 				 0x123456ff);
-	test_changed(&ctx, 1, "Set changes data");
-	vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
+	test_changed(ctx, 1, "Set changes data");
+	vb2_secdata_firmware_set(ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
 				 0x123456ff);
-	test_changed(&ctx, 0, "Set again doesn't change data");
-	v = vb2_secdata_firmware_get(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
+	test_changed(ctx, 0, "Set again doesn't change data");
+	v = vb2_secdata_firmware_get(ctx, VB2_SECDATA_FIRMWARE_VERSIONS);
 	TEST_EQ(v, 0x123456ff, "Versions changed");
 
 	/* Invalid field fails */
-	TEST_ABORT(vb2_secdata_firmware_get(&ctx, -1), "Get invalid");
-	TEST_ABORT(vb2_secdata_firmware_set(&ctx, -1, 456), "Set invalid");
-	test_changed(&ctx, 0, "Set invalid field doesn't change data");
+	TEST_ABORT(vb2_secdata_firmware_get(ctx, -1), "Get invalid");
+	TEST_ABORT(vb2_secdata_firmware_set(ctx, -1, 456), "Set invalid");
+	test_changed(ctx, 0, "Set invalid field doesn't change data");
 
 	/* Read/write uninitialized data fails */
 	sd->status &= ~VB2_SD_STATUS_SECDATA_FIRMWARE_INIT;
-	TEST_ABORT(vb2_secdata_firmware_get(&ctx,
+	TEST_ABORT(vb2_secdata_firmware_get(ctx,
 					    VB2_SECDATA_FIRMWARE_VERSIONS),
 		   "Get uninitialized");
-	test_changed(&ctx, 0, "Get uninitialized doesn't change data");
-	TEST_ABORT(vb2_secdata_firmware_set(&ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
+	test_changed(ctx, 0, "Get uninitialized doesn't change data");
+	TEST_ABORT(vb2_secdata_firmware_set(ctx, VB2_SECDATA_FIRMWARE_VERSIONS,
 					    0x123456ff),
 		   "Set uninitialized");
-	test_changed(&ctx, 0, "Set uninitialized doesn't change data");
+	test_changed(ctx, 0, "Set uninitialized doesn't change data");
 }
 
 int main(int argc, char* argv[])
diff --git a/tests/vb2_secdata_fwmp_tests.c b/tests/vb2_secdata_fwmp_tests.c
index d6ba934b..6c433db5 100644
--- a/tests/vb2_secdata_fwmp_tests.c
+++ b/tests/vb2_secdata_fwmp_tests.c
@@ -13,7 +13,7 @@
 
 static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
-static struct vb2_context ctx;
+static struct vb2_context *ctx;
 static struct vb2_gbb_header gbb;
 static struct vb2_shared_data *sd;
 static struct vb2_secdata_fwmp *sec;
@@ -21,19 +21,15 @@ static struct vb2_secdata_fwmp *sec;
 static void reset_common_data(void)
 {
 	memset(workbuf, 0xaa, sizeof(workbuf));
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
 
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.workbuf = workbuf;
-	ctx.workbuf_size = sizeof(workbuf);
-	ctx.flags = 0;
-
-	vb2_init_context(&ctx);
-	sd = vb2_get_sd(&ctx);
+	sd = vb2_get_sd(ctx);
 	sd->status = VB2_SD_STATUS_SECDATA_FWMP_INIT;
 
 	memset(&gbb, 0, sizeof(gbb));
 
-	sec = (struct vb2_secdata_fwmp *)ctx.secdata_fwmp;
+	sec = (struct vb2_secdata_fwmp *)ctx->secdata_fwmp;
 	sec->struct_size = VB2_SECDATA_FWMP_MIN_SIZE;
 	sec->struct_version = VB2_SECDATA_FWMP_VERSION;
 	sec->flags = 0;
@@ -62,9 +58,9 @@ static void check_init_test(void)
 	sec->struct_size = VB2_SECDATA_FWMP_MAX_SIZE + 1;
 	sec->crc8 = vb2_secdata_fwmp_crc(sec);
 	size = sec->struct_size;
-	TEST_EQ(vb2api_secdata_fwmp_check(&ctx, &size),
+	TEST_EQ(vb2api_secdata_fwmp_check(ctx, &size),
 		VB2_ERROR_SECDATA_FWMP_SIZE, "Check struct_size too large");
-	TEST_EQ(vb2_secdata_fwmp_init(&ctx),
+	TEST_EQ(vb2_secdata_fwmp_init(ctx),
 		VB2_ERROR_SECDATA_FWMP_SIZE, "Init struct_size too large");
 
 	/* struct_size too small */
@@ -72,7 +68,7 @@ static void check_init_test(void)
 	sec->struct_size = VB2_SECDATA_FWMP_MIN_SIZE - 1;
 	sec->crc8 = vb2_secdata_fwmp_crc(sec);
 	size = VB2_SECDATA_FWMP_MIN_SIZE;
-	TEST_EQ(vb2api_secdata_fwmp_check(&ctx, &size),
+	TEST_EQ(vb2api_secdata_fwmp_check(ctx, &size),
 		VB2_ERROR_SECDATA_FWMP_SIZE, "Check struct_size too small");
 
 	/* Need more data to reach minimum size */
@@ -80,9 +76,9 @@ static void check_init_test(void)
 	sec->struct_size = VB2_SECDATA_FWMP_MIN_SIZE - 1;
 	sec->crc8 = vb2_secdata_fwmp_crc(sec);
 	size = 0;
-	TEST_EQ(vb2api_secdata_fwmp_check(&ctx, &size),
+	TEST_EQ(vb2api_secdata_fwmp_check(ctx, &size),
 		VB2_ERROR_SECDATA_FWMP_INCOMPLETE, "Check more to reach MIN");
-	TEST_EQ(vb2_secdata_fwmp_init(&ctx),
+	TEST_EQ(vb2_secdata_fwmp_init(ctx),
 		VB2_ERROR_SECDATA_FWMP_INCOMPLETE, "Init more to reach MIN");
 
 	/* Need more data to reach full size */
@@ -90,17 +86,17 @@ static void check_init_test(void)
 	sec->struct_size = VB2_SECDATA_FWMP_MIN_SIZE + 1;
 	sec->crc8 = vb2_secdata_fwmp_crc(sec);
 	size = VB2_SECDATA_FWMP_MIN_SIZE;
-	TEST_EQ(vb2api_secdata_fwmp_check(&ctx, &size),
+	TEST_EQ(vb2api_secdata_fwmp_check(ctx, &size),
 		VB2_ERROR_SECDATA_FWMP_INCOMPLETE, "Check more for full size");
 
 	/* Bad data is invalid */
 	reset_common_data();
-	memset(ctx.secdata_fwmp, 0xa6, sizeof(ctx.secdata_fwmp));
+	memset(&ctx->secdata_fwmp, 0xa6, sizeof(ctx->secdata_fwmp));
 	sec->struct_size = VB2_SECDATA_FWMP_MIN_SIZE;
 	size = sec->struct_size;
-	TEST_EQ(vb2api_secdata_fwmp_check(&ctx, &size),
+	TEST_EQ(vb2api_secdata_fwmp_check(ctx, &size),
 		VB2_ERROR_SECDATA_FWMP_CRC, "Check bad data CRC");
-	TEST_EQ(vb2_secdata_fwmp_init(&ctx),
+	TEST_EQ(vb2_secdata_fwmp_init(ctx),
 		VB2_ERROR_SECDATA_FWMP_CRC, "Init bad data CRC");
 
 	/* Bad CRC with corruption past minimum size */
@@ -109,50 +105,50 @@ static void check_init_test(void)
 	sec->crc8 = vb2_secdata_fwmp_crc(sec);
 	size = sec->struct_size;
 	*((uint8_t *)sec + sec->struct_size - 1) += 1;
-	TEST_EQ(vb2api_secdata_fwmp_check(&ctx, &size),
+	TEST_EQ(vb2api_secdata_fwmp_check(ctx, &size),
 		VB2_ERROR_SECDATA_FWMP_CRC, "Check corruption CRC");
-	TEST_EQ(vb2_secdata_fwmp_init(&ctx),
+	TEST_EQ(vb2_secdata_fwmp_init(ctx),
 		VB2_ERROR_SECDATA_FWMP_CRC, "Init corruption CRC");
 
 	/* Zeroed data is invalid */
 	reset_common_data();
-	memset(ctx.secdata_fwmp, 0, sizeof(ctx.secdata_fwmp));
+	memset(&ctx->secdata_fwmp, 0, sizeof(ctx->secdata_fwmp));
 	sec->struct_size = VB2_SECDATA_FWMP_MIN_SIZE;
 	size = sec->struct_size;
-	TEST_EQ(vb2api_secdata_fwmp_check(&ctx, &size),
+	TEST_EQ(vb2api_secdata_fwmp_check(ctx, &size),
 		VB2_ERROR_SECDATA_FWMP_VERSION, "Check zeroed data CRC");
-	TEST_EQ(vb2_secdata_fwmp_init(&ctx),
+	TEST_EQ(vb2_secdata_fwmp_init(ctx),
 		VB2_ERROR_SECDATA_FWMP_VERSION, "Init zeroed data CRC");
 
 	/* Major version too high */
 	reset_common_data();
 	sec->struct_version = ((VB2_SECDATA_FWMP_VERSION >> 4) + 1) << 4;
 	sec->crc8 = vb2_secdata_fwmp_crc(sec);
-	TEST_EQ(vb2api_secdata_fwmp_check(&ctx, &size),
+	TEST_EQ(vb2api_secdata_fwmp_check(ctx, &size),
 		VB2_ERROR_SECDATA_FWMP_VERSION, "Check major too high");
-	TEST_EQ(vb2_secdata_fwmp_init(&ctx),
+	TEST_EQ(vb2_secdata_fwmp_init(ctx),
 		VB2_ERROR_SECDATA_FWMP_VERSION, "Init major too high");
 
 	/* Major version too low */
 	reset_common_data();
 	sec->struct_version = ((VB2_SECDATA_FWMP_VERSION >> 4) - 1) << 4;
 	sec->crc8 = vb2_secdata_fwmp_crc(sec);
-	TEST_EQ(vb2api_secdata_fwmp_check(&ctx, &size),
+	TEST_EQ(vb2api_secdata_fwmp_check(ctx, &size),
 		VB2_ERROR_SECDATA_FWMP_VERSION, "Check major too low");
-	TEST_EQ(vb2_secdata_fwmp_init(&ctx),
+	TEST_EQ(vb2_secdata_fwmp_init(ctx),
 		VB2_ERROR_SECDATA_FWMP_VERSION, "Init major too low");
 
 	/* Minor version difference okay */
 	reset_common_data();
 	sec->struct_version += 1;
 	sec->crc8 = vb2_secdata_fwmp_crc(sec);
-	TEST_SUCC(vb2api_secdata_fwmp_check(&ctx, &size), "Check minor okay");
-	TEST_SUCC(vb2_secdata_fwmp_init(&ctx), "Init minor okay");
+	TEST_SUCC(vb2api_secdata_fwmp_check(ctx, &size), "Check minor okay");
+	TEST_SUCC(vb2_secdata_fwmp_init(ctx), "Init minor okay");
 
 	/* Good FWMP data at minimum size */
 	reset_common_data();
-	TEST_SUCC(vb2api_secdata_fwmp_check(&ctx, &size), "Check good (min)");
-	TEST_SUCC(vb2_secdata_fwmp_init(&ctx), "Init good (min)");
+	TEST_SUCC(vb2api_secdata_fwmp_check(ctx, &size), "Check good (min)");
+	TEST_SUCC(vb2_secdata_fwmp_init(ctx), "Init good (min)");
 	TEST_NEQ(sd->status & VB2_SD_STATUS_SECDATA_FWMP_INIT, 0,
 		 "Init flag set");
 
@@ -161,16 +157,16 @@ static void check_init_test(void)
 	sec->struct_size = VB2_SECDATA_FWMP_MIN_SIZE + 1;
 	sec->crc8 = vb2_secdata_fwmp_crc(sec);
 	size = sec->struct_size;
-	TEST_SUCC(vb2api_secdata_fwmp_check(&ctx, &size), "Check good (min+N)");
-	TEST_SUCC(vb2_secdata_fwmp_init(&ctx), "Init good (min+N)");
+	TEST_SUCC(vb2api_secdata_fwmp_check(ctx, &size), "Check good (min+N)");
+	TEST_SUCC(vb2_secdata_fwmp_init(ctx), "Init good (min+N)");
 	TEST_NEQ(sd->status & VB2_SD_STATUS_SECDATA_FWMP_INIT, 0,
 		 "Init flag set");
 
 	/* Skip data check when NO_SECDATA_FWMP set */
 	reset_common_data();
-	memset(ctx.secdata_fwmp, 0xa6, sizeof(ctx.secdata_fwmp));
-	ctx.flags |= VB2_CONTEXT_NO_SECDATA_FWMP;
-	TEST_EQ(vb2_secdata_fwmp_init(&ctx), 0,
+	memset(&ctx->secdata_fwmp, 0xa6, sizeof(ctx->secdata_fwmp));
+	ctx->flags |= VB2_CONTEXT_NO_SECDATA_FWMP;
+	TEST_EQ(vb2_secdata_fwmp_init(ctx), 0,
 		"Init skip data check when NO_SECDATA_FWMP set");
 	TEST_NEQ(sd->status & VB2_SD_STATUS_SECDATA_FWMP_INIT, 0,
 		 "Init flag set");
@@ -181,27 +177,27 @@ static void get_flag_test(void)
 	/* Successfully returns value */
 	reset_common_data();
 	sec->flags |= 1;
-	TEST_EQ(vb2_secdata_fwmp_get_flag(&ctx, 1), 1,
+	TEST_EQ(vb2_secdata_fwmp_get_flag(ctx, 1), 1,
 		"Successfully returns flag value");
 
 	/* NO_SECDATA_FWMP */
 	reset_common_data();
 	sec->flags |= 1;
-	ctx.flags |= VB2_CONTEXT_NO_SECDATA_FWMP;
-	TEST_EQ(vb2_secdata_fwmp_get_flag(&ctx, 1), 0,
+	ctx->flags |= VB2_CONTEXT_NO_SECDATA_FWMP;
+	TEST_EQ(vb2_secdata_fwmp_get_flag(ctx, 1), 0,
 		"NO_SECDATA_FWMP forces default flag value");
 
 	/* FWMP hasn't been initialized (recovery mode) */
 	reset_common_data();
 	sd->status &= ~VB2_SD_STATUS_SECDATA_FWMP_INIT;
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
-	TEST_EQ(vb2_secdata_fwmp_get_flag(&ctx, 0), 0,
+	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
+	TEST_EQ(vb2_secdata_fwmp_get_flag(ctx, 0), 0,
 		"non-init in recovery mode forces default flag value");
 
 	/* FWMP hasn't been initialized (normal mode) */
 	reset_common_data();
 	sd->status &= ~VB2_SD_STATUS_SECDATA_FWMP_INIT;
-	TEST_ABORT(vb2_secdata_fwmp_get_flag(&ctx, 0),
+	TEST_ABORT(vb2_secdata_fwmp_get_flag(ctx, 0),
 		   "non-init in normal mode triggers abort");
 }
 
@@ -209,26 +205,26 @@ static void get_dev_key_hash_test(void)
 {
 	/* CONTEXT_NO_SECDATA_FWMP */
 	reset_common_data();
-	ctx.flags |= VB2_CONTEXT_NO_SECDATA_FWMP;
-	TEST_TRUE(vb2_secdata_fwmp_get_dev_key_hash(&ctx) == NULL,
+	ctx->flags |= VB2_CONTEXT_NO_SECDATA_FWMP;
+	TEST_TRUE(vb2_secdata_fwmp_get_dev_key_hash(ctx) == NULL,
 		  "NO_SECDATA_FWMP forces NULL pointer");
 
 	/* FWMP hasn't been initialized (recovery mode) */
 	reset_common_data();
 	sd->status &= ~VB2_SD_STATUS_SECDATA_FWMP_INIT;
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
-	TEST_TRUE(vb2_secdata_fwmp_get_dev_key_hash(&ctx) == NULL,
+	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
+	TEST_TRUE(vb2_secdata_fwmp_get_dev_key_hash(ctx) == NULL,
 		  "non-init in recovery mode forces NULL pointer");
 
 	/* FWMP hasn't been initialized (normal mode) */
 	reset_common_data();
 	sd->status &= ~VB2_SD_STATUS_SECDATA_FWMP_INIT;
-	TEST_ABORT(vb2_secdata_fwmp_get_dev_key_hash(&ctx),
+	TEST_ABORT(vb2_secdata_fwmp_get_dev_key_hash(ctx),
 		   "non-init in normal mode triggers abort");
 
 	/* Success case */
 	reset_common_data();
-	TEST_TRUE(vb2_secdata_fwmp_get_dev_key_hash(&ctx) ==
+	TEST_TRUE(vb2_secdata_fwmp_get_dev_key_hash(ctx) ==
 		  sec->dev_key_hash, "proper dev_key_hash pointer returned");
 }
 
diff --git a/tests/vb2_secdata_kernel_tests.c b/tests/vb2_secdata_kernel_tests.c
index 89184d99..d4ad3d2f 100644
--- a/tests/vb2_secdata_kernel_tests.c
+++ b/tests/vb2_secdata_kernel_tests.c
@@ -17,22 +17,19 @@
 
 static uint8_t workbuf[VB2_FIRMWARE_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__ ((aligned (VB2_WORKBUF_ALIGN)));
-static struct vb2_context ctx;
+static struct vb2_context *ctx;
 static struct vb2_shared_data *sd;
 static struct vb2_secdata_kernel *sec;
 
 static void reset_common_data(void)
 {
 	memset(workbuf, 0xaa, sizeof(workbuf));
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
 
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.workbuf = workbuf;
-	ctx.workbuf_size = sizeof(workbuf);
+	sd = vb2_get_sd(ctx);
 
-	vb2_init_context(&ctx);
-	sd = vb2_get_sd(&ctx);
-
-	sec = (struct vb2_secdata_kernel *)ctx.secdata_kernel;
+	sec = (struct vb2_secdata_kernel *)ctx->secdata_kernel;
 }
 
 static void test_changed(struct vb2_context *c, int changed, const char *why)
@@ -55,79 +52,79 @@ static void secdata_kernel_test(void)
 		"Struct size constant");
 
 	/* Blank data is invalid */
-	memset(ctx.secdata_kernel, 0xa6, sizeof(ctx.secdata_kernel));
-	TEST_EQ(vb2api_secdata_kernel_check(&ctx),
+	memset(&ctx->secdata_kernel, 0xa6, sizeof(ctx->secdata_kernel));
+	TEST_EQ(vb2api_secdata_kernel_check(ctx),
 		VB2_ERROR_SECDATA_KERNEL_CRC, "Check blank CRC");
-	TEST_EQ(vb2_secdata_kernel_init(&ctx),
+	TEST_EQ(vb2_secdata_kernel_init(ctx),
 		VB2_ERROR_SECDATA_KERNEL_CRC, "Init blank CRC");
 
 	/* Ensure zeroed buffers are invalid */
-	memset(ctx.secdata_kernel, 0, sizeof(ctx.secdata_kernel));
-	TEST_EQ(vb2_secdata_kernel_init(&ctx), VB2_ERROR_SECDATA_KERNEL_VERSION,
+	memset(&ctx->secdata_kernel, 0, sizeof(ctx->secdata_kernel));
+	TEST_EQ(vb2_secdata_kernel_init(ctx), VB2_ERROR_SECDATA_KERNEL_VERSION,
 		"Zeroed buffer (invalid version)");
 
 	/* Try with bad version */
-	TEST_EQ(vb2api_secdata_kernel_create(&ctx), VB2_SECDATA_KERNEL_SIZE,
+	TEST_EQ(vb2api_secdata_kernel_create(ctx), VB2_SECDATA_KERNEL_SIZE,
 		"Create");
 	sec->struct_version -= 1;
 	sec->crc8 = vb2_crc8(sec, offsetof(struct vb2_secdata_kernel, crc8));
-	TEST_EQ(vb2api_secdata_kernel_check(&ctx),
+	TEST_EQ(vb2api_secdata_kernel_check(ctx),
 		VB2_ERROR_SECDATA_KERNEL_VERSION, "Check invalid version");
-	TEST_EQ(vb2_secdata_kernel_init(&ctx),
+	TEST_EQ(vb2_secdata_kernel_init(ctx),
 		VB2_ERROR_SECDATA_KERNEL_VERSION, "Init invalid version");
 
 	/* Create good data */
-	vb2api_secdata_kernel_create(&ctx);
-	TEST_SUCC(vb2api_secdata_kernel_check(&ctx), "Check created CRC");
-	TEST_SUCC(vb2_secdata_kernel_init(&ctx), "Init created CRC");
+	vb2api_secdata_kernel_create(ctx);
+	TEST_SUCC(vb2api_secdata_kernel_check(ctx), "Check created CRC");
+	TEST_SUCC(vb2_secdata_kernel_init(ctx), "Init created CRC");
 	TEST_NEQ(sd->status & VB2_SD_STATUS_SECDATA_KERNEL_INIT, 0,
 		 "Init set SD status");
 	sd->status &= ~VB2_SD_STATUS_SECDATA_KERNEL_INIT;
-	test_changed(&ctx, 1, "Create changes data");
+	test_changed(ctx, 1, "Create changes data");
 
 	/* Now corrupt it */
-	ctx.secdata_kernel[2]++;
-	TEST_EQ(vb2api_secdata_kernel_check(&ctx),
+	ctx->secdata_kernel[2]++;
+	TEST_EQ(vb2api_secdata_kernel_check(ctx),
 		VB2_ERROR_SECDATA_KERNEL_CRC, "Check invalid CRC");
-	TEST_EQ(vb2_secdata_kernel_init(&ctx),
+	TEST_EQ(vb2_secdata_kernel_init(ctx),
 		VB2_ERROR_SECDATA_KERNEL_CRC, "Init invalid CRC");
 
 	/* Make sure UID is checked */
 
-	vb2api_secdata_kernel_create(&ctx);
+	vb2api_secdata_kernel_create(ctx);
 	sec->uid++;
 	sec->crc8 = vb2_crc8(sec, offsetof(struct vb2_secdata_kernel, crc8));
-	TEST_EQ(vb2_secdata_kernel_init(&ctx), VB2_ERROR_SECDATA_KERNEL_UID,
+	TEST_EQ(vb2_secdata_kernel_init(ctx), VB2_ERROR_SECDATA_KERNEL_UID,
 		"Init invalid struct UID");
 
 	/* Read/write versions */
-	vb2api_secdata_kernel_create(&ctx);
-	vb2_secdata_kernel_init(&ctx);
-	ctx.flags = 0;
-	v = vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS);
+	vb2api_secdata_kernel_create(ctx);
+	vb2_secdata_kernel_init(ctx);
+	ctx->flags = 0;
+	v = vb2_secdata_kernel_get(ctx, VB2_SECDATA_KERNEL_VERSIONS);
 	TEST_EQ(v, 0, "Versions created 0");
-	test_changed(&ctx, 0, "Get doesn't change data");
-	vb2_secdata_kernel_set(&ctx, VB2_SECDATA_KERNEL_VERSIONS, 0x123456ff);
-	test_changed(&ctx, 1, "Set changes data");
-	vb2_secdata_kernel_set(&ctx, VB2_SECDATA_KERNEL_VERSIONS, 0x123456ff);
-	test_changed(&ctx, 0, "Set again doesn't change data");
-	v = vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS);
+	test_changed(ctx, 0, "Get doesn't change data");
+	vb2_secdata_kernel_set(ctx, VB2_SECDATA_KERNEL_VERSIONS, 0x123456ff);
+	test_changed(ctx, 1, "Set changes data");
+	vb2_secdata_kernel_set(ctx, VB2_SECDATA_KERNEL_VERSIONS, 0x123456ff);
+	test_changed(ctx, 0, "Set again doesn't change data");
+	v = vb2_secdata_kernel_get(ctx, VB2_SECDATA_KERNEL_VERSIONS);
 	TEST_EQ(v, 0x123456ff, "Versions changed");
 
 	/* Invalid field fails */
-	TEST_ABORT(vb2_secdata_kernel_get(&ctx, -1), "Get invalid");
-	TEST_ABORT(vb2_secdata_kernel_set(&ctx, -1, 456), "Set invalid");
-	test_changed(&ctx, 0, "Set invalid field doesn't change data");
+	TEST_ABORT(vb2_secdata_kernel_get(ctx, -1), "Get invalid");
+	TEST_ABORT(vb2_secdata_kernel_set(ctx, -1, 456), "Set invalid");
+	test_changed(ctx, 0, "Set invalid field doesn't change data");
 
 	/* Read/write uninitialized data fails */
 	sd->status &= ~VB2_SD_STATUS_SECDATA_KERNEL_INIT;
-	TEST_ABORT(vb2_secdata_kernel_get(&ctx, VB2_SECDATA_KERNEL_VERSIONS),
+	TEST_ABORT(vb2_secdata_kernel_get(ctx, VB2_SECDATA_KERNEL_VERSIONS),
 		   "Get uninitialized");
-	test_changed(&ctx, 0, "Get uninitialized doesn't change data");
-	TEST_ABORT(vb2_secdata_kernel_set(&ctx, VB2_SECDATA_KERNEL_VERSIONS,
+	test_changed(ctx, 0, "Get uninitialized doesn't change data");
+	TEST_ABORT(vb2_secdata_kernel_set(ctx, VB2_SECDATA_KERNEL_VERSIONS,
 					  0x123456ff),
 		   "Set uninitialized");
-	test_changed(&ctx, 0, "Set uninitialized doesn't change data");
+	test_changed(ctx, 0, "Set uninitialized doesn't change data");
 }
 
 int main(int argc, char* argv[])
diff --git a/tests/vboot_api_devmode_tests.c b/tests/vboot_api_devmode_tests.c
index 7126850e..03454890 100644
--- a/tests/vboot_api_devmode_tests.c
+++ b/tests/vboot_api_devmode_tests.c
@@ -93,7 +93,7 @@ test_case_t test[] = {
 
 /* Mock data */
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
-static struct vb2_context ctx;
+static struct vb2_context *ctx;
 static struct vb2_shared_data *sd;
 static struct vb2_gbb_header gbb;
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
@@ -114,13 +114,11 @@ extern int audio_open_count;
 /* Reset mock data (for use before each test) */
 static void ResetMocks(void)
 {
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.workbuf = workbuf;
-	ctx.workbuf_size = sizeof(workbuf);
-	vb2_init_context(&ctx);
-	vb2_nv_init(&ctx);
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
+	vb2_nv_init(ctx);
 
-	sd = vb2_get_sd(&ctx);
+	sd = vb2_get_sd(ctx);
 	sd->vbsd = shared;
 
 	memset(&gbb, 0, sizeof(gbb));
@@ -284,7 +282,7 @@ static void VbBootDeveloperSoundTest(void)
 		kbd_fire_at = test[i].keypress_at_count;
 		max_events = test[i].num_events;
 		expected_event = test[i].notes;
-		(void) VbBootDeveloper(&ctx);
+		(void) VbBootDeveloper(ctx);
 		VbExBeep(0, 0); /* Dummy call to determine end time */
 		VB2_DEBUG("INFO: matched %d total %d expected %d\n",
 			  matched_events, current_event, test[i].num_events);
diff --git a/tests/vboot_api_kernel2_tests.c b/tests/vboot_api_kernel2_tests.c
index 0b82bdcd..627a804c 100644
--- a/tests/vboot_api_kernel2_tests.c
+++ b/tests/vboot_api_kernel2_tests.c
@@ -26,7 +26,7 @@ static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
 static LoadKernelParams lkp;
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
-static struct vb2_context ctx;
+static struct vb2_context *ctx;
 static struct vb2_shared_data *sd;
 static struct vb2_gbb_header gbb;
 
@@ -88,13 +88,11 @@ static void ResetMocks(void)
 
 	memset(&lkp, 0, sizeof(lkp));
 
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.workbuf = workbuf;
-	ctx.workbuf_size = sizeof(workbuf);
-	vb2_init_context(&ctx);
-	vb2_nv_init(&ctx);
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
+	vb2_nv_init(ctx);
 
-	sd = vb2_get_sd(&ctx);
+	sd = vb2_get_sd(ctx);
 	sd->vbsd = shared;
 	sd->flags |= VB2_SD_FLAG_DISPLAY_AVAILABLE;
 
@@ -314,12 +312,12 @@ static void VbUserConfirmsTestGpio(uint32_t first, uint32_t second,
 	mock_gpio[3].gpio_flags = third;
 	mock_gpio[3].count = 4;
 	if (confirm) {
-		TEST_EQ(VbUserConfirms(&ctx,
+		TEST_EQ(VbUserConfirms(ctx,
 			VB_CONFIRM_SPACE_MEANS_NO |
 			VB_CONFIRM_MUST_TRUST_KEYBOARD),
 			1, msg);
 	} else {
-		TEST_EQ(VbUserConfirms(&ctx,
+		TEST_EQ(VbUserConfirms(ctx,
 			VB_CONFIRM_SPACE_MEANS_NO |
 			VB_CONFIRM_MUST_TRUST_KEYBOARD),
 			-1, msg);
@@ -332,48 +330,48 @@ static void VbUserConfirmsTest(void)
 
 	ResetMocks();
 	MockGpioAfter(1, GPIO_SHUTDOWN);
-	TEST_EQ(VbUserConfirms(&ctx, 0), -1, "Shutdown requested");
+	TEST_EQ(VbUserConfirms(ctx, 0), -1, "Shutdown requested");
 
 	ResetMocks();
 	mock_keypress[0] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbUserConfirms(&ctx, 0), -1, "Shutdown requested");
+	TEST_EQ(VbUserConfirms(ctx, 0), -1, "Shutdown requested");
 
 	ResetMocks();
 	mock_keypress[0] = VB_KEY_ENTER;
-	TEST_EQ(VbUserConfirms(&ctx, 0), 1, "Enter");
+	TEST_EQ(VbUserConfirms(ctx, 0), 1, "Enter");
 
 	ResetMocks();
 	mock_keypress[0] = VB_KEY_ESC;
-	TEST_EQ(VbUserConfirms(&ctx, 0), 0, "Esc");
+	TEST_EQ(VbUserConfirms(ctx, 0), 0, "Esc");
 
 	ResetMocks();
 	mock_keypress[0] = ' ';
 	MockGpioAfter(1, GPIO_SHUTDOWN);
-	TEST_EQ(VbUserConfirms(&ctx, VB_CONFIRM_SPACE_MEANS_NO), 0,
+	TEST_EQ(VbUserConfirms(ctx, VB_CONFIRM_SPACE_MEANS_NO), 0,
 		"Space means no");
 
 	ResetMocks();
 	mock_keypress[0] = ' ';
 	MockGpioAfter(1, GPIO_SHUTDOWN);
-	TEST_EQ(VbUserConfirms(&ctx, 0), -1, "Space ignored");
+	TEST_EQ(VbUserConfirms(ctx, 0), -1, "Space ignored");
 
 	ResetMocks();
 	mock_keypress[0] = VB_KEY_ENTER;
 	mock_keyflags[0] = VB_KEY_FLAG_TRUSTED_KEYBOARD;
-	TEST_EQ(VbUserConfirms(&ctx, VB_CONFIRM_MUST_TRUST_KEYBOARD),
+	TEST_EQ(VbUserConfirms(ctx, VB_CONFIRM_MUST_TRUST_KEYBOARD),
 		1, "Enter with trusted keyboard");
 
 	ResetMocks();
 	mock_keypress[0] = VB_KEY_ENTER;	/* untrusted */
 	mock_keypress[1] = ' ';
-	TEST_EQ(VbUserConfirms(&ctx,
+	TEST_EQ(VbUserConfirms(ctx,
 			       VB_CONFIRM_SPACE_MEANS_NO |
 			       VB_CONFIRM_MUST_TRUST_KEYBOARD),
 		0, "Untrusted keyboard");
 
 	ResetMocks();
 	MockGpioAfter(0, GPIO_PRESENCE);
-	TEST_EQ(VbUserConfirms(&ctx,
+	TEST_EQ(VbUserConfirms(ctx,
 			       VB_CONFIRM_SPACE_MEANS_NO |
 			       VB_CONFIRM_MUST_TRUST_KEYBOARD),
 		1, "Presence button");
@@ -461,7 +459,7 @@ static void VbUserConfirmsTest(void)
 	mock_keypress[3] = ' ';
 	mock_gpio[0].gpio_flags = GPIO_PRESENCE;
 	mock_gpio[0].count = ~0;
-	TEST_EQ(VbUserConfirms(&ctx,
+	TEST_EQ(VbUserConfirms(ctx,
 			       VB_CONFIRM_SPACE_MEANS_NO |
 			       VB_CONFIRM_MUST_TRUST_KEYBOARD),
 		0, "Recovery button stuck");
@@ -471,20 +469,20 @@ static void VbUserConfirmsTest(void)
 static void VbBootTest(void)
 {
 	ResetMocks();
-	TEST_EQ(VbBootNormal(&ctx), 1002, "VbBootNormal()");
+	TEST_EQ(VbBootNormal(ctx), 1002, "VbBootNormal()");
 
 	ResetMocks();
-	vb2_nv_set(&ctx, VB2_NV_DISPLAY_REQUEST, 1);
-	TEST_EQ(VbBootNormal(&ctx), VBERROR_REBOOT_REQUIRED,
+	vb2_nv_set(ctx, VB2_NV_DISPLAY_REQUEST, 1);
+	TEST_EQ(VbBootNormal(ctx), VBERROR_REBOOT_REQUIRED,
 		"VbBootNormal() reboot to reset NVRAM display request");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISPLAY_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DISPLAY_REQUEST), 0,
 		"  display request reset");
 
 	ResetMocks();
-	vb2_nv_set(&ctx, VB2_NV_DIAG_REQUEST, 1);
-	TEST_EQ(VbBootNormal(&ctx), VBERROR_REBOOT_REQUIRED,
+	vb2_nv_set(ctx, VB2_NV_DIAG_REQUEST, 1);
+	TEST_EQ(VbBootNormal(ctx), VBERROR_REBOOT_REQUIRED,
 		"VbBootNormal() reboot to reset NVRAM diag request");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DIAG_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DIAG_REQUEST), 0,
 		"  diag request reset");
 }
 
@@ -496,10 +494,10 @@ static void VbBootDevTest(void)
 
 	/* Proceed after timeout */
 	ResetMocks();
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Timeout");
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Timeout");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING,
 		"  warning screen");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0,
 		"  recovery reason");
 	TEST_EQ(audio_looping_calls_left, 0, "  used up audio");
 
@@ -507,7 +505,7 @@ static void VbBootDevTest(void)
 	ResetMocks();
 	gbb.flags |= VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY |
 			VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Timeout");
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Timeout");
 	TEST_EQ(vbexlegacy_called, 1, "  try legacy");
 	TEST_EQ(altfw_num, 0, "  check altfw_num");
 
@@ -515,61 +513,61 @@ static void VbBootDevTest(void)
 	ResetMocks();
 	gbb.flags |= VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY |
 			VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Timeout");
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Timeout");
 	TEST_EQ(vbexlegacy_called, 1, "  try legacy");
 	TEST_EQ(altfw_num, 0, "  check altfw_num");
 
 	/* Proceed to legacy after timeout if boot legacy and default boot
 	 * legacy are set */
 	ResetMocks();
-	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT,
+	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
 		   VB2_DEV_DEFAULT_BOOT_LEGACY);
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Timeout");
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Timeout");
 	TEST_EQ(vbexlegacy_called, 1, "  try legacy");
 	TEST_EQ(altfw_num, 0, "  check altfw_num");
 
 	/* Proceed to legacy boot mode only if enabled */
 	ResetMocks();
-	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT,
+	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
 		   VB2_DEV_DEFAULT_BOOT_LEGACY);
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Timeout");
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Timeout");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 
 	/* Proceed to usb after timeout if boot usb and default boot
 	 * usb are set */
 	ResetMocks();
-	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT,
+	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
 		   VB2_DEV_DEFAULT_BOOT_USB);
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
 	vbtlk_retval = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootDeveloper(&ctx), 0, "Ctrl+U USB");
+	TEST_EQ(VbBootDeveloper(ctx), 0, "Ctrl+U USB");
 
 	/* Proceed to usb boot mode only if enabled */
 	ResetMocks();
-	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT,
+	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
 		   VB2_DEV_DEFAULT_BOOT_USB);
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Timeout");
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Timeout");
 
 	/* If no USB tries fixed disk */
 	ResetMocks();
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
-	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT,
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT,
 		   VB2_DEV_DEFAULT_BOOT_USB);
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Ctrl+U enabled");
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Ctrl+U enabled");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 
 	/* Up arrow is uninteresting / passed to VbCheckDisplayKey() */
 	ResetMocks();
 	mock_keypress[0] = VB_KEY_UP;
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Up arrow");
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Up arrow");
 
 	/* Shutdown requested in loop */
 	ResetMocks();
 	mock_gpio[0].gpio_flags = 0;
 	mock_gpio[0].count = 2;
 	mock_gpio[1].gpio_flags = GPIO_SHUTDOWN;
-	TEST_EQ(VbBootDeveloper(&ctx),
+	TEST_EQ(VbBootDeveloper(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested");
 	TEST_NEQ(audio_looping_calls_left, 0, "  aborts audio");
@@ -577,7 +575,7 @@ static void VbBootDevTest(void)
 	/* Shutdown requested by keyboard in loop */
 	ResetMocks();
 	mock_keypress[0] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootDeveloper(&ctx),
+	TEST_EQ(VbBootDeveloper(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested by keyboard");
 
@@ -586,7 +584,7 @@ static void VbBootDevTest(void)
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
 	mock_keypress[0] = ' ';
 	mock_keypress[1] = VB_KEY_ENTER;
-	TEST_EQ(VbBootDeveloper(&ctx), VBERROR_REBOOT_REQUIRED,
+	TEST_EQ(VbBootDeveloper(ctx), VBERROR_REBOOT_REQUIRED,
 		"Space = tonorm");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING,
 		"  warning screen");
@@ -594,7 +592,7 @@ static void VbBootDevTest(void)
 		"  tonorm screen");
 	TEST_EQ(screens_displayed[2], VB_SCREEN_TO_NORM_CONFIRMED,
 		"  confirm screen");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISABLE_DEV_REQUEST), 1,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DISABLE_DEV_REQUEST), 1,
 		"  disable dev request");
 
 	/* Space-space doesn't disable it */
@@ -603,7 +601,7 @@ static void VbBootDevTest(void)
 	mock_keypress[0] = ' ';
 	mock_keypress[1] = ' ';
 	mock_keypress[2] = VB_KEY_ESC;
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Space-space");
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Space-space");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING,
 		"  warning screen");
 	TEST_EQ(screens_displayed[1], VB_SCREEN_DEVELOPER_TO_NORM,
@@ -616,7 +614,7 @@ static void VbBootDevTest(void)
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
 	mock_keypress[0] = VB_KEY_ENTER;
 	mock_keypress[1] = VB_KEY_ENTER;
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Enter ignored");
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Enter ignored");
 
 	/* Enter does if GBB flag set */
 	ResetMocks();
@@ -624,7 +622,7 @@ static void VbBootDevTest(void)
 	gbb.flags |= VB2_GBB_FLAG_ENTER_TRIGGERS_TONORM;
 	mock_keypress[0] = VB_KEY_ENTER;
 	mock_keypress[1] = VB_KEY_ENTER;
-	TEST_EQ(VbBootDeveloper(&ctx), VBERROR_REBOOT_REQUIRED,
+	TEST_EQ(VbBootDeveloper(ctx), VBERROR_REBOOT_REQUIRED,
 		"Enter = tonorm");
 
 	/* Tonorm ignored if GBB forces dev switch on */
@@ -633,7 +631,7 @@ static void VbBootDevTest(void)
 	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_SWITCH_ON;
 	mock_keypress[0] = ' ';
 	mock_keypress[1] = VB_KEY_ENTER;
-	TEST_EQ(VbBootDeveloper(&ctx), 1002,
+	TEST_EQ(VbBootDeveloper(ctx), 1002,
 		"Can't tonorm gbb-dev");
 
 	/* Shutdown requested at tonorm screen */
@@ -641,7 +639,7 @@ static void VbBootDevTest(void)
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
 	mock_keypress[0] = ' ';
 	MockGpioAfter(3, GPIO_SHUTDOWN);
-	TEST_EQ(VbBootDeveloper(&ctx),
+	TEST_EQ(VbBootDeveloper(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested at tonorm");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING,
@@ -653,15 +651,15 @@ static void VbBootDevTest(void)
 	ResetMocks();
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
 	mock_keypress[0] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootDeveloper(&ctx),
+	TEST_EQ(VbBootDeveloper(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested by keyboard at nonorm");
 
 	/* Ctrl+D dismisses warning */
 	ResetMocks();
 	mock_keypress[0] = VB_KEY_CTRL('D');
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Ctrl+D");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0,
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Ctrl+D");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0,
 		"  recovery reason");
 	TEST_NEQ(audio_looping_calls_left, 0, "  aborts audio");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
@@ -670,13 +668,13 @@ static void VbBootDevTest(void)
 	ResetMocks();
 	mock_keypress[0] = VB_KEY_CTRL('D');
 	gbb.flags |= VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY;
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Ctrl+D");
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Ctrl+D");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 
 	/* Ctrl+L tries legacy boot mode only if enabled */
 	ResetMocks();
 	mock_keypress[0] = VB_KEY_CTRL('L');
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Ctrl+L normal");
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Ctrl+L normal");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 
 	/* Enter altfw menu and time out */
@@ -684,7 +682,7 @@ static void VbBootDevTest(void)
 	MockGpioAfter(1000, GPIO_SHUTDOWN);
 	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
 	mock_keypress[0] = VB_KEY_CTRL('L');
-	TEST_EQ(VbBootDeveloper(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootDeveloper(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Ctrl+L force legacy");
 	TEST_EQ(vbexlegacy_called, 0, "  try legacy");
 
@@ -693,26 +691,26 @@ static void VbBootDevTest(void)
 	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
 	mock_keypress[0] = VB_KEY_CTRL('L');
 	mock_keypress[1] = '0';
-	TEST_EQ(VbBootDeveloper(&ctx), 1002,
+	TEST_EQ(VbBootDeveloper(ctx), 1002,
 		"Ctrl+L force legacy");
 	TEST_EQ(vbexlegacy_called, 1, "  try legacy");
 	TEST_EQ(altfw_num, 0, "  check altfw_num");
 
 	/* Enter altfw menu and then exit it */
 	ResetMocks();
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
 	mock_keypress[0] = VB_KEY_CTRL('L');
 	mock_keypress[1] = VB_KEY_ESC;
-	TEST_EQ(VbBootDeveloper(&ctx), 1002,
+	TEST_EQ(VbBootDeveloper(ctx), 1002,
 		"Ctrl+L nv legacy");
 	TEST_EQ(vbexlegacy_called, 0, "  try legacy");
 
 	/* Enter altfw menu and select firmware 0 */
 	ResetMocks();
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
 	mock_keypress[0] = VB_KEY_CTRL('L');
 	mock_keypress[1] = '0';
-	TEST_EQ(VbBootDeveloper(&ctx), 1002,
+	TEST_EQ(VbBootDeveloper(ctx), 1002,
 		"Ctrl+L nv legacy");
 	TEST_EQ(vbexlegacy_called, 1, "  try legacy");
 	TEST_EQ(altfw_num, 0, "  check altfw_num");
@@ -722,7 +720,7 @@ static void VbBootDevTest(void)
 	VbApiKernelGetFwmp()->flags |= FWMP_DEV_ENABLE_LEGACY;
 	mock_keypress[0] = VB_KEY_CTRL('L');
 	mock_keypress[1] = '0';
-	TEST_EQ(VbBootDeveloper(&ctx), 1002,
+	TEST_EQ(VbBootDeveloper(ctx), 1002,
 		"Ctrl+L fwmp legacy");
 	TEST_EQ(vbexlegacy_called, 1, "  fwmp legacy");
 	TEST_EQ(altfw_num, 0, "  check altfw_num");
@@ -731,21 +729,21 @@ static void VbBootDevTest(void)
 	for (key = '1'; key <= '9'; key++) {
 		ResetMocks();
 		mock_keypress[0] = key;
-		TEST_EQ(VbBootDeveloper(&ctx), 1002, "'1' normal");
+		TEST_EQ(VbBootDeveloper(ctx), 1002, "'1' normal");
 		TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 
 		ResetMocks();
 		gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
 		mock_keypress[0] = key;
-		TEST_EQ(VbBootDeveloper(&ctx), 1002,
+		TEST_EQ(VbBootDeveloper(ctx), 1002,
 			"Ctrl+L force legacy");
 		TEST_EQ(vbexlegacy_called, 1, "  try legacy");
 		TEST_EQ(altfw_num, key - '0', "  check altfw_num");
 
 		ResetMocks();
-		vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
+		vb2_nv_set(ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
 		mock_keypress[0] = key;
-		TEST_EQ(VbBootDeveloper(&ctx), 1002,
+		TEST_EQ(VbBootDeveloper(ctx), 1002,
 			"Ctrl+L nv legacy");
 		TEST_EQ(vbexlegacy_called, 1, "  try legacy");
 		TEST_EQ(altfw_num, key - '0', "  check altfw_num");
@@ -753,7 +751,7 @@ static void VbBootDevTest(void)
 		ResetMocks();
 		VbApiKernelGetFwmp()->flags |= FWMP_DEV_ENABLE_LEGACY;
 		mock_keypress[0] = key;
-		TEST_EQ(VbBootDeveloper(&ctx), 1002,
+		TEST_EQ(VbBootDeveloper(ctx), 1002,
 			"Ctrl+L fwmp legacy");
 		TEST_EQ(vbexlegacy_called, 1, "  fwmp legacy");
 		TEST_EQ(altfw_num, key - '0', "  check altfw_num");
@@ -762,32 +760,32 @@ static void VbBootDevTest(void)
 	/* Ctrl+U boots USB only if enabled */
 	ResetMocks();
 	mock_keypress[0] = VB_KEY_CTRL('U');
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Ctrl+U normal");
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Ctrl+U normal");
 
 	/* Ctrl+U enabled, with good USB boot */
 	ResetMocks();
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
 	mock_keypress[0] = VB_KEY_CTRL('U');
 	vbtlk_retval = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootDeveloper(&ctx), 0, "Ctrl+U USB");
+	TEST_EQ(VbBootDeveloper(ctx), 0, "Ctrl+U USB");
 
 	/* Ctrl+U enabled via GBB */
 	ResetMocks();
 	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_USB;
 	mock_keypress[0] = VB_KEY_CTRL('U');
 	vbtlk_retval = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootDeveloper(&ctx), 0, "Ctrl+U force USB");
+	TEST_EQ(VbBootDeveloper(ctx), 0, "Ctrl+U force USB");
 
 	/* Ctrl+U enabled via FWMP */
 	ResetMocks();
 	VbApiKernelGetFwmp()->flags |= FWMP_DEV_ENABLE_USB;
 	mock_keypress[0] = VB_KEY_CTRL('U');
 	vbtlk_retval = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootDeveloper(&ctx), 0, "Ctrl+U force USB");
+	TEST_EQ(VbBootDeveloper(ctx), 0, "Ctrl+U force USB");
 
 	/* Ctrl+S set vendor data and reboot */
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
+	ctx->flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
 	mock_keypress[0] = VB_KEY_CTRL('S');
 	mock_keypress[1] = '4';
 	mock_keypress[2] = '3';
@@ -795,14 +793,14 @@ static void VbBootDevTest(void)
 	mock_keypress[4] = '1';
 	mock_keypress[5] = VB_KEY_ENTER; // Set vendor data
 	mock_keypress[6] = VB_KEY_ENTER; // Confirm vendor data
-	TEST_EQ(VbBootDeveloper(&ctx), VBERROR_REBOOT_REQUIRED,
+	TEST_EQ(VbBootDeveloper(ctx), VBERROR_REBOOT_REQUIRED,
 		"Ctrl+S set vendor data and reboot");
 	TEST_EQ(set_vendor_data_called, 1, "  VbExSetVendorData() called");
 	TEST_STR_EQ(set_vendor_data, "4321", "  Vendor data correct");
 
 	/* Ctrl+S extra keys ignored */
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
+	ctx->flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
 	mock_keypress[0] = VB_KEY_CTRL('S');
 	mock_keypress[1] = '4';
 	mock_keypress[2] = '3';
@@ -811,14 +809,14 @@ static void VbBootDevTest(void)
 	mock_keypress[5] = '5';
 	mock_keypress[6] = VB_KEY_ENTER; // Set vendor data
 	mock_keypress[7] = VB_KEY_ENTER; // Confirm vendor data
-	TEST_EQ(VbBootDeveloper(&ctx), VBERROR_REBOOT_REQUIRED,
+	TEST_EQ(VbBootDeveloper(ctx), VBERROR_REBOOT_REQUIRED,
 		"Ctrl+S extra keys ignored");
 	TEST_EQ(set_vendor_data_called, 1, "  VbExSetVendorData() called");
 	TEST_STR_EQ(set_vendor_data, "4321", "  Vendor data correct");
 
 	/* Ctrl+S converts case */
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
+	ctx->flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
 	mock_keypress[0] = VB_KEY_CTRL('S');
 	mock_keypress[1] = 'a';
 	mock_keypress[2] = 'B';
@@ -826,14 +824,14 @@ static void VbBootDevTest(void)
 	mock_keypress[4] = 'z';
 	mock_keypress[5] = VB_KEY_ENTER; // Set vendor data
 	mock_keypress[6] = VB_KEY_ENTER; // Confirm vendor data
-	TEST_EQ(VbBootDeveloper(&ctx), VBERROR_REBOOT_REQUIRED,
+	TEST_EQ(VbBootDeveloper(ctx), VBERROR_REBOOT_REQUIRED,
 		"Ctrl+S converts case");
 	TEST_EQ(set_vendor_data_called, 1, "  VbExSetVendorData() called");
 	TEST_STR_EQ(set_vendor_data, "ABYZ", "  Vendor data correct");
 
 	/* Ctrl+S backspace works */
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
+	ctx->flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
 	mock_keypress[0] = VB_KEY_CTRL('S');
 	mock_keypress[1] = 'A';
 	mock_keypress[2] = 'B';
@@ -845,14 +843,14 @@ static void VbBootDevTest(void)
 	mock_keypress[8] = '1';
 	mock_keypress[9] = VB_KEY_ENTER; // Set vendor data
 	mock_keypress[10] = VB_KEY_ENTER; // Confirm vendor data
-	TEST_EQ(VbBootDeveloper(&ctx), VBERROR_REBOOT_REQUIRED,
+	TEST_EQ(VbBootDeveloper(ctx), VBERROR_REBOOT_REQUIRED,
 		"Ctrl+S backspace works");
 	TEST_EQ(set_vendor_data_called, 1, "  VbExSetVendorData() called");
 	TEST_STR_EQ(set_vendor_data, "A321", "  Vendor data correct");
 
 	/* Ctrl+S invalid chars don't print */
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
+	ctx->flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
 	mock_keypress[0] = VB_KEY_CTRL('S');
 	mock_keypress[1] = '4';
 	mock_keypress[2] = '-';
@@ -865,14 +863,14 @@ static void VbBootDevTest(void)
 	mock_keypress[9] = '1';
 	mock_keypress[10] = VB_KEY_ENTER; // Set vendor data
 	mock_keypress[11] = VB_KEY_ENTER; // Confirm vendor data
-	TEST_EQ(VbBootDeveloper(&ctx), VBERROR_REBOOT_REQUIRED,
+	TEST_EQ(VbBootDeveloper(ctx), VBERROR_REBOOT_REQUIRED,
 		"Ctrl+S invalid chars don't print");
 	TEST_EQ(set_vendor_data_called, 1, "  VbExSetVendorData() called");
 	TEST_STR_EQ(set_vendor_data, "4321", "  Vendor data correct");
 
 	/* Ctrl+S invalid chars don't print with backspace */
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
+	ctx->flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
 	mock_keypress[0] = VB_KEY_CTRL('S');
 	mock_keypress[1] = '4';
 	mock_keypress[2] = '-';
@@ -883,14 +881,14 @@ static void VbBootDevTest(void)
 	mock_keypress[7] = '0';
 	mock_keypress[8] = VB_KEY_ENTER; // Set vendor data
 	mock_keypress[9] = VB_KEY_ENTER; // Confirm vendor data
-	TEST_EQ(VbBootDeveloper(&ctx), VBERROR_REBOOT_REQUIRED,
+	TEST_EQ(VbBootDeveloper(ctx), VBERROR_REBOOT_REQUIRED,
 		"Ctrl+S invalid chars don't print with backspace");
 	TEST_EQ(set_vendor_data_called, 1, "  VbExSetVendorData() called");
 	TEST_STR_EQ(set_vendor_data, "3210", "  Vendor data correct");
 
 	/* Ctrl+S backspace only doesn't underrun */
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
+	ctx->flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
 	mock_keypress[0] = VB_KEY_CTRL('S');
 	mock_keypress[1] = 'A';
 	mock_keypress[2] = VB_KEY_BACKSPACE;
@@ -901,14 +899,14 @@ static void VbBootDevTest(void)
 	mock_keypress[7] = '1';
 	mock_keypress[8] = VB_KEY_ENTER; // Set vendor data
 	mock_keypress[9] = VB_KEY_ENTER; // Confirm vendor data
-	TEST_EQ(VbBootDeveloper(&ctx), VBERROR_REBOOT_REQUIRED,
+	TEST_EQ(VbBootDeveloper(ctx), VBERROR_REBOOT_REQUIRED,
 		"Ctrl+S backspace only doesn't underrun");
 	TEST_EQ(set_vendor_data_called, 1, "  VbExSetVendorData() called");
 	TEST_STR_EQ(set_vendor_data, "4321", "  Vendor data correct");
 
 	/* Ctrl+S vowels not allowed after first char */
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
+	ctx->flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
 	mock_keypress[0] = VB_KEY_CTRL('S');
 	mock_keypress[1] = 'A';
 	mock_keypress[2] = 'A';
@@ -921,14 +919,14 @@ static void VbBootDevTest(void)
 	mock_keypress[9] = 'D';
 	mock_keypress[10] = VB_KEY_ENTER; // Set vendor data
 	mock_keypress[11] = VB_KEY_ENTER; // Confirm vendor data
-	TEST_EQ(VbBootDeveloper(&ctx), VBERROR_REBOOT_REQUIRED,
+	TEST_EQ(VbBootDeveloper(ctx), VBERROR_REBOOT_REQUIRED,
 		"Ctrl+S vowels not allowed after first char");
 	TEST_EQ(set_vendor_data_called, 1, "  VbExSetVendorData() called");
 	TEST_STR_EQ(set_vendor_data, "ABCD", "  Vendor data correct");
 
 	/* Ctrl+S too short */
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
+	ctx->flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
 	mock_keypress[0] = VB_KEY_CTRL('S');
 	mock_keypress[1] = '1';
 	mock_keypress[2] = '2';
@@ -936,33 +934,33 @@ static void VbBootDevTest(void)
 	mock_keypress[4] = VB_KEY_ENTER; // Set vendor data (Nothing happens)
 	mock_keypress[5] = VB_KEY_ENTER; // Confirm vendor data (Nothing happens)
 	mock_keypress[6] = VB_KEY_ESC;
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Ctrl+S too short");
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Ctrl+S too short");
 	TEST_EQ(set_vendor_data_called, 0, "  VbExSetVendorData() not called");
 
 	/* Ctrl+S esc from set screen */
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
+	ctx->flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
 	mock_keypress[0] = VB_KEY_CTRL('S');
 	mock_keypress[1] = VB_KEY_ESC;
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Ctrl+S esc from set screen");
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Ctrl+S esc from set screen");
 	TEST_EQ(set_vendor_data_called, 0, "  VbExSetVendorData() not called");
 
 	/* Ctrl+S esc from set screen with tag */
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
+	ctx->flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
 	mock_keypress[0] = VB_KEY_CTRL('S');
 	mock_keypress[1] = '4';
 	mock_keypress[2] = '3';
 	mock_keypress[3] = '2';
 	mock_keypress[4] = '1';
 	mock_keypress[5] = VB_KEY_ESC;
-	TEST_EQ(VbBootDeveloper(&ctx), 1002,
+	TEST_EQ(VbBootDeveloper(ctx), 1002,
 		"Ctrl+S esc from set screen with tag");
 	TEST_EQ(set_vendor_data_called, 0, "  VbExSetVendorData() not called");
 
 	/* Ctrl+S esc from confirm screen */
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
+	ctx->flags |= VB2_CONTEXT_VENDOR_DATA_SETTABLE;
 	mock_keypress[0] = VB_KEY_CTRL('S');
 	mock_keypress[1] = '4';
 	mock_keypress[2] = '3';
@@ -970,16 +968,16 @@ static void VbBootDevTest(void)
 	mock_keypress[4] = '1';
 	mock_keypress[5] = VB_KEY_ENTER; // Set vendor data
 	mock_keypress[6] = VB_KEY_ESC;
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Ctrl+S esc from set screen");
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Ctrl+S esc from set screen");
 	TEST_EQ(set_vendor_data_called, 0, "  VbExSetVendorData() not called");
 
 	/* If no USB, eventually times out and tries fixed disk */
 	ResetMocks();
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
 	mock_keypress[0] = VB_KEY_CTRL('U');
-	TEST_EQ(VbBootDeveloper(&ctx), 1002, "Ctrl+U enabled");
+	TEST_EQ(VbBootDeveloper(ctx), 1002, "Ctrl+U enabled");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0,
 		"  recovery reason");
 	TEST_EQ(audio_looping_calls_left, 0, "  used up audio");
 
@@ -988,7 +986,7 @@ static void VbBootDevTest(void)
 	VbApiKernelGetFwmp()->flags |= FWMP_DEV_DISABLE_BOOT;
 	mock_keypress[0] = VB_KEY_ESC;  /* Just causes TONORM again */
 	mock_keypress[1] = VB_KEY_ENTER;
-	TEST_EQ(VbBootDeveloper(&ctx), VBERROR_REBOOT_REQUIRED,
+	TEST_EQ(VbBootDeveloper(ctx), VBERROR_REBOOT_REQUIRED,
 		"FWMP dev disabled");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_TO_NORM,
 		"  tonorm screen");
@@ -996,7 +994,7 @@ static void VbBootDevTest(void)
 		"  tonorm screen");
 	TEST_EQ(screens_displayed[2], VB_SCREEN_TO_NORM_CONFIRMED,
 		"  confirm screen");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISABLE_DEV_REQUEST), 1,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DISABLE_DEV_REQUEST), 1,
 		"  disable dev request");
 
 	/* Shutdown requested when dev disabled */
@@ -1004,7 +1002,7 @@ static void VbBootDevTest(void)
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
 	VbApiKernelGetFwmp()->flags |= FWMP_DEV_DISABLE_BOOT;
 	MockGpioAfter(1, GPIO_SHUTDOWN);
-	TEST_EQ(VbBootDeveloper(&ctx),
+	TEST_EQ(VbBootDeveloper(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested when dev disabled");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_TO_NORM,
@@ -1015,7 +1013,7 @@ static void VbBootDevTest(void)
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
 	VbApiKernelGetFwmp()->flags |= FWMP_DEV_DISABLE_BOOT;
 	mock_keypress[0] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootDeveloper(&ctx),
+	TEST_EQ(VbBootDeveloper(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested by keyboard when dev disabled");
 
@@ -1048,11 +1046,11 @@ static void VbBootRecTestGpio(uint32_t first, uint32_t second, uint32_t third,
 	mock_gpio[3].count = 4;
 
 	if (confirm) {
-		TEST_EQ(VbBootRecovery(&ctx), VBERROR_EC_REBOOT_TO_RO_REQUIRED,
+		TEST_EQ(VbBootRecovery(ctx), VBERROR_EC_REBOOT_TO_RO_REQUIRED,
 			msg);
 		TEST_EQ(virtdev_set, 1, "  virtual dev mode on");
 	} else {
-		TEST_EQ(VbBootRecovery(&ctx), VBERROR_SHUTDOWN_REQUESTED, msg);
+		TEST_EQ(VbBootRecovery(ctx), VBERROR_SHUTDOWN_REQUESTED, msg);
 		TEST_EQ(virtdev_set, 0, "  virtual dev mode off");
 	}
 }
@@ -1064,11 +1062,11 @@ static void VbBootRecTest(void)
 	/* Shutdown requested in loop */
 	ResetMocks();
 	MockGpioAfter(10, GPIO_SHUTDOWN);
-	TEST_EQ(VbBootRecovery(&ctx),
+	TEST_EQ(VbBootRecovery(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested");
 
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0,
 		"  recovery reason");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_OS_BROKEN,
 		"  broken screen");
@@ -1076,7 +1074,7 @@ static void VbBootRecTest(void)
 	/* Shutdown requested by keyboard */
 	ResetMocks();
 	mock_keypress[0] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootRecovery(&ctx),
+	TEST_EQ(VbBootRecovery(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested by keyboard");
 
@@ -1093,7 +1091,7 @@ static void VbBootRecTest(void)
 	shared->flags = VBSD_BOOT_REC_SWITCH_ON;
 	trust_ec = 1;
 	vbtlk_retval = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecovery(&ctx),
+	TEST_EQ(VbBootRecovery(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Ignore power button held on boot");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_RECOVERY_INSERT,
@@ -1108,7 +1106,7 @@ static void VbBootRecTest(void)
 	mock_num_disks[1] = 1;
 	mock_num_disks[2] = 1;
 	vbtlk_retval = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecovery(&ctx),
+	TEST_EQ(VbBootRecovery(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Broken");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_OS_BROKEN,
@@ -1121,7 +1119,7 @@ static void VbBootRecTest(void)
 	mock_num_disks[1] = 1;
 	shared->flags |= VBSD_BOOT_DEV_SWITCH_ON;
 	vbtlk_retval = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecovery(&ctx),
+	TEST_EQ(VbBootRecovery(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Broken (dev)");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_OS_BROKEN,
@@ -1132,7 +1130,7 @@ static void VbBootRecTest(void)
 	MockGpioAfter(100, GPIO_SHUTDOWN);
 	gbb.flags |= VB2_GBB_FLAG_FORCE_MANUAL_RECOVERY;
 	vbtlk_retval = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecovery(&ctx),
+	TEST_EQ(VbBootRecovery(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Insert (forced by GBB)");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_RECOVERY_INSERT,
@@ -1145,7 +1143,7 @@ static void VbBootRecTest(void)
 	mock_num_disks[1] = 1;
 	shared->flags |= VBSD_BOOT_REC_SWITCH_ON;
 	vbtlk_retval = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecovery(&ctx),
+	TEST_EQ(VbBootRecovery(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"No remove in rec");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_OS_BROKEN,
@@ -1157,7 +1155,7 @@ static void VbBootRecTest(void)
 	mock_num_disks[0] = 0;
 	mock_num_disks[1] = 1;
 	vbtlk_retval = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecovery(&ctx),
+	TEST_EQ(VbBootRecovery(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Remove");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_OS_BROKEN,
@@ -1168,7 +1166,7 @@ static void VbBootRecTest(void)
 	MockGpioAfter(10, GPIO_SHUTDOWN);
 	mock_num_disks[0] = -1;
 	vbtlk_retval = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecovery(&ctx),
+	TEST_EQ(VbBootRecovery(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Bad disk count");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_OS_BROKEN,
@@ -1180,7 +1178,7 @@ static void VbBootRecTest(void)
 	MockGpioAfter(100, GPIO_SHUTDOWN);
 	mock_keypress[0] = VB_KEY_CTRL('D');
 	trust_ec = 0;
-	TEST_EQ(VbBootRecovery(&ctx),
+	TEST_EQ(VbBootRecovery(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Ctrl+D ignored if EC not trusted");
 	TEST_EQ(virtdev_set, 0, "  virtual dev mode off");
@@ -1192,7 +1190,7 @@ static void VbBootRecTest(void)
 	trust_ec = 1;
 	MockGpioAfter(100, GPIO_SHUTDOWN);
 	mock_keypress[0] = VB_KEY_CTRL('D');
-	TEST_EQ(VbBootRecovery(&ctx),
+	TEST_EQ(VbBootRecovery(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Ctrl+D ignored if already in dev mode");
 	TEST_EQ(virtdev_set, 0, "  virtual dev mode off");
@@ -1203,7 +1201,7 @@ static void VbBootRecTest(void)
 	trust_ec = 1;
 	MockGpioAfter(100, GPIO_SHUTDOWN);
 	mock_keypress[0] = VB_KEY_CTRL('D');
-	TEST_EQ(VbBootRecovery(&ctx),
+	TEST_EQ(VbBootRecovery(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Ctrl+D ignored if recovery not manually triggered");
 	TEST_EQ(virtdev_set, 0, "  virtual dev mode off");
@@ -1221,7 +1219,7 @@ static void VbBootRecTest(void)
 	mock_gpio[0].count = 100;
 	mock_gpio[1].gpio_flags = GPIO_PRESENCE | GPIO_SHUTDOWN;
 	mock_gpio[1].count = 100;
-	TEST_EQ(VbBootRecovery(&ctx),
+	TEST_EQ(VbBootRecovery(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Ctrl+D ignored if phys pres button is still pressed");
 	TEST_NEQ(screens_displayed[1], VB_SCREEN_RECOVERY_TO_DEV,
@@ -1235,7 +1233,7 @@ static void VbBootRecTest(void)
 	trust_ec = 1;
 	mock_keypress[0] = VB_KEY_CTRL('D');
 	mock_keypress[1] = ' ';
-	TEST_EQ(VbBootRecovery(&ctx),
+	TEST_EQ(VbBootRecovery(ctx),
 		VBERROR_SHUTDOWN_REQUESTED,
 		"Ctrl+D todev abort");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_RECOVERY_INSERT,
@@ -1255,7 +1253,7 @@ static void VbBootRecTest(void)
 	mock_keypress[0] = VB_KEY_CTRL('D');
 	mock_keypress[1] = VB_KEY_ENTER;
 	mock_keyflags[1] = VB_KEY_FLAG_TRUSTED_KEYBOARD;
-	TEST_EQ(VbBootRecovery(&ctx), VBERROR_EC_REBOOT_TO_RO_REQUIRED,
+	TEST_EQ(VbBootRecovery(ctx), VBERROR_EC_REBOOT_TO_RO_REQUIRED,
 		"Ctrl+D todev confirm via enter");
 	TEST_EQ(virtdev_set, 1, "  virtual dev mode on");
 
@@ -1351,7 +1349,7 @@ static void VbBootRecTest(void)
 	mock_keypress[1] = VB_KEY_ENTER;
 	mock_keyflags[1] = VB_KEY_FLAG_TRUSTED_KEYBOARD;
 	virtdev_retval = VB2_ERROR_MOCK;
-	TEST_EQ(VbBootRecovery(&ctx),
+	TEST_EQ(VbBootRecovery(ctx),
 		VBERROR_TPM_SET_BOOT_MODE_STATE,
 		"Ctrl+D todev failure");
 
@@ -1362,20 +1360,20 @@ static void VbBootRecTest(void)
 	vbtlk_retval = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
 	MockGpioAfter(100, GPIO_SHUTDOWN);
 	mock_keypress[0] = VB_KEY_CTRL('C');
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DIAG_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DIAG_REQUEST), 0,
 		"todiag is zero");
 	if (DIAGNOSTIC_UI)
-		TEST_EQ(VbBootRecovery(&ctx),
+		TEST_EQ(VbBootRecovery(ctx),
 			VBERROR_REBOOT_REQUIRED,
 			"Ctrl+C todiag - enabled");
 	else
-		TEST_EQ(VbBootRecovery(&ctx),
+		TEST_EQ(VbBootRecovery(ctx),
 			VBERROR_SHUTDOWN_REQUESTED,
 			"Ctrl+C todiag - disabled");
 
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DIAG_REQUEST), DIAGNOSTIC_UI,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DIAG_REQUEST), DIAGNOSTIC_UI,
 		"  todiag is updated for Ctrl-C");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISPLAY_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DISPLAY_REQUEST), 0,
 		"  todiag doesn't set unneeded DISPLAY_REQUEST");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_RECOVERY_INSERT,
 		"  insert screen");
@@ -1388,19 +1386,19 @@ static void VbBootRecTest(void)
 	vbtlk_retval = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
 	MockGpioAfter(100, GPIO_SHUTDOWN);
 	mock_keypress[0] = VB_KEY_F(12);
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DIAG_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DIAG_REQUEST), 0,
 		"todiag is zero");
 	if (DIAGNOSTIC_UI)
-		TEST_EQ(VbBootRecovery(&ctx),
+		TEST_EQ(VbBootRecovery(ctx),
 			VBERROR_REBOOT_REQUIRED,
 			"F12 todiag - enabled");
 	else
-		TEST_EQ(VbBootRecovery(&ctx),
+		TEST_EQ(VbBootRecovery(ctx),
 			VBERROR_SHUTDOWN_REQUESTED,
 			"F12 todiag - disabled");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DIAG_REQUEST), DIAGNOSTIC_UI,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DIAG_REQUEST), DIAGNOSTIC_UI,
 		"  todiag is updated for F12");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISPLAY_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DISPLAY_REQUEST), 0,
 		"  todiag doesn't set unneeded DISPLAY_REQUEST");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_RECOVERY_INSERT,
 		"  insert screen");
@@ -1410,19 +1408,19 @@ static void VbBootRecTest(void)
 	shared->flags = 0;
 	MockGpioAfter(100, GPIO_SHUTDOWN);
 	mock_keypress[0] = VB_KEY_CTRL('C');
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DIAG_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DIAG_REQUEST), 0,
 		"todiag is zero");
 	if (DIAGNOSTIC_UI)
-		TEST_EQ(VbBootRecovery(&ctx),
+		TEST_EQ(VbBootRecovery(ctx),
 			VBERROR_REBOOT_REQUIRED,
 			"Ctrl+C todiag os broken - enabled");
 	else
-		TEST_EQ(VbBootRecovery(&ctx),
+		TEST_EQ(VbBootRecovery(ctx),
 			VBERROR_SHUTDOWN_REQUESTED,
 			"Ctrl+C todiag os broken - disabled");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DIAG_REQUEST), DIAGNOSTIC_UI,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DIAG_REQUEST), DIAGNOSTIC_UI,
 		"  todiag is updated for Ctrl-C");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISPLAY_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DISPLAY_REQUEST), 0,
 		"  todiag doesn't set unneeded DISPLAY_REQUEST");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_OS_BROKEN,
 		"  os broken screen");
@@ -1436,7 +1434,7 @@ static void VbBootDiagTest(void)
 
 	/* No key pressed - timeout. */
 	ResetMocks();
-	TEST_EQ(VbBootDiagnostic(&ctx), VBERROR_REBOOT_REQUIRED, "Timeout");
+	TEST_EQ(VbBootDiagnostic(ctx), VBERROR_REBOOT_REQUIRED, "Timeout");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_CONFIRM_DIAG,
 		"  confirm screen");
 	TEST_EQ(screens_displayed[1], VB_SCREEN_BLANK,
@@ -1449,7 +1447,7 @@ static void VbBootDiagTest(void)
 	/* Esc key pressed. */
 	ResetMocks();
 	mock_keypress[0] = VB_KEY_ESC;
-	TEST_EQ(VbBootDiagnostic(&ctx), VBERROR_REBOOT_REQUIRED, "Esc key");
+	TEST_EQ(VbBootDiagnostic(ctx), VBERROR_REBOOT_REQUIRED, "Esc key");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_CONFIRM_DIAG,
 		"  confirm screen");
 	TEST_EQ(screens_displayed[1], VB_SCREEN_BLANK,
@@ -1461,7 +1459,7 @@ static void VbBootDiagTest(void)
 	/* Shutdown requested via lid close */
 	ResetMocks();
 	MockGpioAfter(10, GPIO_LID_CLOSED);
-	TEST_EQ(VbBootDiagnostic(&ctx), VBERROR_SHUTDOWN_REQUESTED, "Shutdown");
+	TEST_EQ(VbBootDiagnostic(ctx), VBERROR_SHUTDOWN_REQUESTED, "Shutdown");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_CONFIRM_DIAG,
 		"  confirm screen");
 	TEST_EQ(screens_displayed[1], VB_SCREEN_BLANK,
@@ -1474,7 +1472,7 @@ static void VbBootDiagTest(void)
 	ResetMocks();
 	mock_gpio[0].gpio_flags = GPIO_PRESENCE;
 	mock_gpio[0].count = ~0;
-	TEST_EQ(VbBootDiagnostic(&ctx), VBERROR_REBOOT_REQUIRED, "Power held");
+	TEST_EQ(VbBootDiagnostic(ctx), VBERROR_REBOOT_REQUIRED, "Power held");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_CONFIRM_DIAG,
 		"  confirm screen");
 	TEST_EQ(screens_displayed[1], VB_SCREEN_BLANK,
@@ -1485,7 +1483,7 @@ static void VbBootDiagTest(void)
 	/* Power button is pressed and released. */
 	ResetMocks();
 	MockGpioAfter(3, GPIO_PRESENCE);
-	TEST_EQ(VbBootDiagnostic(&ctx), VBERROR_REBOOT_REQUIRED, "Confirm");
+	TEST_EQ(VbBootDiagnostic(ctx), VBERROR_REBOOT_REQUIRED, "Confirm");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_CONFIRM_DIAG,
 		"  confirm screen");
 	TEST_EQ(screens_displayed[1], VB_SCREEN_BLANK,
@@ -1498,7 +1496,7 @@ static void VbBootDiagTest(void)
 	 * Ideally we'd that no recovery request was recorded, but
 	 * VbExLegacy() can only fail or crash the tests.
 	 */
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
 		VB2_RECOVERY_ALTFW_HASH_FAILED,
 		"  recovery request");
 
@@ -1509,7 +1507,7 @@ static void VbBootDiagTest(void)
 	mock_gpio[0].count = 2;
 	mock_gpio[1].gpio_flags = GPIO_PRESENCE;
 	mock_gpio[1].count = 2;
-	TEST_EQ(VbBootDiagnostic(&ctx), VBERROR_REBOOT_REQUIRED,
+	TEST_EQ(VbBootDiagnostic(ctx), VBERROR_REBOOT_REQUIRED,
 		"Confirm but tpm fail");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_CONFIRM_DIAG,
 		"  confirm screen");
@@ -1518,7 +1516,7 @@ static void VbBootDiagTest(void)
 	TEST_EQ(tpm_set_mode_called, 1, "  tpm call");
 	TEST_EQ(tpm_mode, VB2_TPM_MODE_DISABLED, "  tpm disabled");
 	TEST_EQ(vbexlegacy_called, 0, "  legacy not called");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
 		VB2_RECOVERY_TPM_DISABLE_FAILED,
 		"  recovery request");
 
diff --git a/tests/vboot_api_kernel4_tests.c b/tests/vboot_api_kernel4_tests.c
index ee02fe30..ed0758f8 100644
--- a/tests/vboot_api_kernel4_tests.c
+++ b/tests/vboot_api_kernel4_tests.c
@@ -25,7 +25,7 @@
 
 /* Mock data */
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
-static struct vb2_context ctx;
+static struct vb2_context *ctx;
 static struct vb2_context ctx_nvram_backend;
 static struct vb2_shared_data *sd;
 static VbSelectAndLoadKernelParams kparams;
@@ -53,12 +53,9 @@ static void ResetMocks(void)
 	gbb.minor_version = VB2_GBB_MINOR_VER;
 	gbb.flags = 0;
 
-	/* ctx.workbuf will be initialized by VbSelectAndLoadKernel. */
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.workbuf = workbuf;
-	ctx.workbuf_size = sizeof(workbuf);
-	vb2_init_context(&ctx);
-	sd = vb2_get_sd(&ctx);
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
+	sd = vb2_get_sd(ctx);
 	sd->flags |= VB2_SD_FLAG_DISPLAY_AVAILABLE;
 
 	/*
@@ -166,7 +163,7 @@ vb2_error_t VbBootDiagnostic(struct vb2_context *c)
 
 static void test_slk(vb2_error_t retval, int recovery_reason, const char *desc)
 {
-	TEST_EQ(VbSelectAndLoadKernel(&ctx, shared, &kparams), retval, desc);
+	TEST_EQ(VbSelectAndLoadKernel(ctx, shared, &kparams), retval, desc);
 	TEST_EQ(vb2_nv_get(&ctx_nvram_backend, VB2_NV_RECOVERY_REQUEST),
 		recovery_reason, "  recovery reason");
 }
diff --git a/tests/vboot_api_kernel_tests.c b/tests/vboot_api_kernel_tests.c
index 5452f1d3..35d8ee9d 100644
--- a/tests/vboot_api_kernel_tests.c
+++ b/tests/vboot_api_kernel_tests.c
@@ -303,17 +303,15 @@ static const char *got_load_disk;
 static uint32_t got_return_val;
 static uint32_t got_external_mismatch;
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
-static struct vb2_context ctx;
+static struct vb2_context *ctx;
 
 /**
  * Reset mock data (for use before each test)
  */
 static void ResetMocks(int i)
 {
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.workbuf = workbuf;
-	ctx.workbuf_size = sizeof(workbuf);
-	vb2_init_context(&ctx);
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
 
 	memset(VbApiKernelGetParams(), 0, sizeof(LoadKernelParams));
 
@@ -431,7 +429,7 @@ static void VbTryLoadKernelTest(void)
 	for (i = 0; i < num_tests; i++) {
 		printf("Test case: %s ...\n", test[i].name);
 		ResetMocks(i);
-		TEST_EQ(VbTryLoadKernel(&ctx, test[i].want_flags),
+		TEST_EQ(VbTryLoadKernel(ctx, test[i].want_flags),
 			t->expected_return_val, "  return value");
 		TEST_EQ(got_recovery_request_val,
 			t->expected_recovery_request_val, "  recovery_request");
diff --git a/tests/vboot_detach_menu_tests.c b/tests/vboot_detach_menu_tests.c
index 7374882c..5e040753 100644
--- a/tests/vboot_detach_menu_tests.c
+++ b/tests/vboot_detach_menu_tests.c
@@ -28,7 +28,7 @@ static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
 static LoadKernelParams lkp;
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
-static struct vb2_context ctx;
+static struct vb2_context *ctx;
 static struct vb2_shared_data *sd;
 static struct vb2_gbb_header gbb;
 
@@ -68,13 +68,11 @@ static void ResetMocks(void)
 
 	memset(&lkp, 0, sizeof(lkp));
 
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.workbuf = workbuf;
-	ctx.workbuf_size = sizeof(workbuf);
-	vb2_init_context(&ctx);
-	vb2_nv_init(&ctx);
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
+	vb2_nv_init(ctx);
 
-	sd = vb2_get_sd(&ctx);
+	sd = vb2_get_sd(ctx);
 	sd->vbsd = shared;
 
 	memset(&gbb, 0, sizeof(gbb));
@@ -273,12 +271,12 @@ static void VbBootDevTest(void)
 
 	/* Proceed after timeout */
 	ResetMocksForDeveloper();
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed, "Timeout");
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed, "Timeout");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
 	TEST_EQ(screens_displayed[1], VB_SCREEN_BLANK, "  final blank screen");
 	TEST_EQ(screens_count, 2, "  no extra screens");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0,
 		"  recovery reason");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(audio_looping_calls_left, 0, "  used up audio");
@@ -288,7 +286,7 @@ static void VbBootDevTest(void)
 	ResetMocksForDeveloper();
 	gbb.flags |= VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY |
 		     VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"default legacy GBB");
 	TEST_EQ(vbexlegacy_called, 1, "  try legacy");
 	TEST_EQ(altfw_num, 0, "  check altfw_num");
@@ -306,9 +304,9 @@ static void VbBootDevTest(void)
 	/* Proceed to legacy after timeout if boot legacy and default boot
 	 * legacy are set */
 	ResetMocksForDeveloper();
-	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT, VB2_DEV_DEFAULT_BOOT_LEGACY);
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT, VB2_DEV_DEFAULT_BOOT_LEGACY);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"default legacy NV");
 	TEST_EQ(vbexlegacy_called, 1, "  try legacy");
 	TEST_EQ(altfw_num, 0, "  check altfw_num");
@@ -325,11 +323,11 @@ static void VbBootDevTest(void)
 
 	/* Proceed to legacy boot mode only if enabled */
 	ResetMocksForDeveloper();
-	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT, VB2_DEV_DEFAULT_BOOT_LEGACY);
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT, VB2_DEV_DEFAULT_BOOT_LEGACY);
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"default legacy not enabled");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
 	TEST_EQ(screens_displayed[1], VB_SCREEN_BLANK, "  blank (error flash)");
@@ -345,10 +343,10 @@ static void VbBootDevTest(void)
 	/* Proceed to usb after timeout if boot usb and default boot
 	 * usb are set */
 	ResetMocksForDeveloper();
-	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT, VB2_DEV_DEFAULT_BOOT_USB);
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT, VB2_DEV_DEFAULT_BOOT_USB);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
 	vbtlk_retval[0] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), 0, "Ctrl+U USB");
+	TEST_EQ(VbBootDeveloperMenu(ctx), 0, "Ctrl+U USB");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
 	TEST_EQ(screens_displayed[1], VB_SCREEN_BLANK, "  final blank screen");
@@ -358,10 +356,10 @@ static void VbBootDevTest(void)
 
 	/* Proceed to usb boot mode only if enabled */
 	ResetMocksForDeveloper();
-	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT, VB2_DEV_DEFAULT_BOOT_USB);
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT, VB2_DEV_DEFAULT_BOOT_USB);
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"default USB not enabled");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
 	TEST_EQ(screens_displayed[1], VB_SCREEN_BLANK, "  blank (error flash)");
@@ -376,12 +374,12 @@ static void VbBootDevTest(void)
 
 	/* If no USB tries fixed disk */
 	ResetMocksForDeveloper();
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
-	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT, VB2_DEV_DEFAULT_BOOT_USB);
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT, VB2_DEV_DEFAULT_BOOT_USB);
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"default USB with no disk");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
 	TEST_EQ(screens_displayed[1], VB_SCREEN_BLANK, "  blank (error flash)");
@@ -396,9 +394,9 @@ static void VbBootDevTest(void)
 	/* Shutdown requested in loop */
 	ResetMocksForDeveloper();
 	shutdown_request_calls_left = 2;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootDeveloperMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
@@ -413,9 +411,9 @@ static void VbBootDevTest(void)
 	 */
 	ResetMocksForDeveloper();
 	mock_keypress[0] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootDeveloperMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"dev warning menu: default to power off");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
 	TEST_EQ(screens_displayed[1], VB_SCREEN_BLANK, "  final blank screen");
@@ -433,12 +431,12 @@ static void VbBootDevTest(void)
 	mock_keypress[i++] = VB_BUTTON_VOL_DOWN_SHORT_PRESS; // Cancel
 	mock_keypress[i++] = VB_BUTTON_VOL_DOWN_SHORT_PRESS; // Power Off
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootDeveloperMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Power Off in DEVELOPER");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 	TEST_NEQ(audio_looping_calls_left, 0, "  aborts audio");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	i = 0;
 	TEST_EQ(screens_displayed[i++], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  dev warning menu: power off");
@@ -461,7 +459,7 @@ static void VbBootDevTest(void)
 	/* Pressing ENTER is equivalent to power button. */
 	ResetMocksForDeveloper();
 	mock_keypress[0] = VB_KEY_ENTER;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootDeveloperMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"dev warning menu: ENTER is power button");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
@@ -474,7 +472,7 @@ static void VbBootDevTest(void)
 	ResetMocksForDeveloper();
 	gbb.flags |= VB2_GBB_FLAG_ENTER_TRIGGERS_TONORM;
 	mock_keypress[0] = VB_KEY_ENTER;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootDeveloperMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"dev warning menu: ENTER unaffected by GBB");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
@@ -488,9 +486,9 @@ static void VbBootDevTest(void)
 	mock_keypress[0] = ' ';
 	mock_keypress[1] = VB_BUTTON_VOL_UP_DOWN_COMBO_PRESS;
 	mock_keypress[2] = VB_BUTTON_POWER_SHORT_PRESS;	// select Power Off
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootDeveloperMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"SPACE or VolUp+Down have no effect");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
@@ -505,9 +503,9 @@ static void VbBootDevTest(void)
 	mock_keypress[0] = VB_BUTTON_VOL_UP_SHORT_PRESS;
 	mock_keypress[1] = VB_BUTTON_POWER_SHORT_PRESS;
 	mock_keypress[2] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VBERROR_REBOOT_REQUIRED,
+	TEST_EQ(VbBootDeveloperMenu(ctx), VBERROR_REBOOT_REQUIRED,
 		"disable developer mode");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
 	TEST_EQ(screens_displayed[1], VB_SCREEN_DEVELOPER_WARNING_MENU,
@@ -518,7 +516,7 @@ static void VbBootDevTest(void)
 		"  confirm screen");
 	TEST_EQ(screens_displayed[4], VB_SCREEN_BLANK, "  final blank screen");
 	TEST_EQ(screens_count, 5, "  no extra screens");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISABLE_DEV_REQUEST), 1,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DISABLE_DEV_REQUEST), 1,
 		"  disable dev request");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_NEQ(audio_looping_calls_left, 0, "  aborts audio");
@@ -531,9 +529,9 @@ static void VbBootDevTest(void)
 	mock_keypress[0] = VB_BUTTON_VOL_UP_SHORT_PRESS;
 	mock_keypress[1] = VB_BUTTON_POWER_SHORT_PRESS;
 	mock_keypress[2] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"Can't tonorm gbb-dev");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen: power off");
 	TEST_EQ(screens_displayed[1], VB_SCREEN_DEVELOPER_WARNING_MENU,
@@ -557,9 +555,9 @@ static void VbBootDevTest(void)
 	mock_keypress[0] = VB_BUTTON_VOL_UP_SHORT_PRESS;
 	mock_keypress[1] = VB_BUTTON_POWER_SHORT_PRESS;
 	shutdown_request_calls_left = 2;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootDeveloperMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested at tonorm");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		" developer warning screen: power off");
 	TEST_EQ(screens_displayed[1], VB_SCREEN_DEVELOPER_WARNING_MENU,
@@ -573,8 +571,8 @@ static void VbBootDevTest(void)
 	/* Ctrl+D dismisses warning */
 	ResetMocksForDeveloper();
 	mock_keypress[0] = VB_KEY_CTRL('D');
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed, "Ctrl+D");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0,
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed, "Ctrl+D");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0,
 		"  recovery reason");
 	TEST_NEQ(audio_looping_calls_left, 0, "  aborts audio");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
@@ -589,15 +587,15 @@ static void VbBootDevTest(void)
 	ResetMocksForDeveloper();
 	mock_keypress[0] = VB_KEY_CTRL('D');
 	gbb.flags |= VB2_GBB_FLAG_DEFAULT_DEV_BOOT_LEGACY;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed, "Ctrl+D");
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed, "Ctrl+D");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 
 	/* Volume-down long press shortcut acts like Ctrl+D */
 	ResetMocksForDeveloper();
 	mock_keypress[0] = VB_BUTTON_VOL_DOWN_LONG_PRESS;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"VolDown long press");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0,
 		"  recovery reason");
 	TEST_NEQ(audio_looping_calls_left, 0, "  aborts audio");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
@@ -610,9 +608,9 @@ static void VbBootDevTest(void)
 	/* Ctrl+L tries legacy boot mode only if enabled */
 	ResetMocksForDeveloper();
 	mock_keypress[0] = VB_KEY_CTRL('L');
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed, "Ctrl+L normal");
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed, "Ctrl+L normal");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(audio_looping_calls_left, 0, "  audio timed out");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
@@ -631,7 +629,7 @@ static void VbBootDevTest(void)
 	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_LEGACY;
 	mock_keypress[0] = VB_KEY_CTRL('L');
 	mock_keypress[1] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"Ctrl+L force legacy");
 	TEST_EQ(vbexlegacy_called, 1, "  try legacy");
 	TEST_EQ(altfw_num, 1, "  check altfw_num");
@@ -647,13 +645,13 @@ static void VbBootDevTest(void)
 
 	/* Ctrl+L boots legacy if enabled by NVRAM */
 	ResetMocksForDeveloper();
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
 	mock_keypress[0] = VB_KEY_CTRL('L');
 	mock_keypress[1] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"Ctrl+L nv legacy");
 	TEST_EQ(vbexlegacy_called, 1, "  try legacy");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
 	TEST_EQ(screens_displayed[1], VB_SCREEN_ALT_FW_MENU, "  altfw");
@@ -669,7 +667,7 @@ static void VbBootDevTest(void)
 	VbApiKernelGetFwmp()->flags |= FWMP_DEV_ENABLE_LEGACY;
 	mock_keypress[0] = VB_KEY_CTRL('L');
 	mock_keypress[1] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"Ctrl+L fwmp legacy");
 	TEST_EQ(vbexlegacy_called, 1, "  fwmp legacy");
 	TEST_EQ(altfw_num, 1, "  check altfw_num");
@@ -688,11 +686,11 @@ static void VbBootDevTest(void)
 	/* Ctrl+U boots USB only if enabled */
 	ResetMocksForDeveloper();
 	mock_keypress[0] = VB_KEY_CTRL('U');
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"Ctrl+U not enabled");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(audio_looping_calls_left, 0, "  audio timed out");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
@@ -707,13 +705,13 @@ static void VbBootDevTest(void)
 
 	/* Ctrl+U enabled, with good USB boot */
 	ResetMocksForDeveloper();
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
 	mock_keypress[0] = VB_KEY_CTRL('U');
 	vbtlk_retval[0] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VB2_SUCCESS, "Ctrl+U USB");
+	TEST_EQ(VbBootDeveloperMenu(ctx), VB2_SUCCESS, "Ctrl+U USB");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_NEQ(audio_looping_calls_left, 0, "  aborts audio");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
@@ -723,12 +721,12 @@ static void VbBootDevTest(void)
 
 	/* Ctrl+U enabled, without valid USB */
 	ResetMocksForDeveloper();
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
 	mock_keypress[0] = VB_KEY_CTRL('U');
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"Ctrl+U without valid USB");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
@@ -746,7 +744,7 @@ static void VbBootDevTest(void)
 	gbb.flags |= VB2_GBB_FLAG_FORCE_DEV_BOOT_USB;
 	mock_keypress[0] = VB_KEY_CTRL('U');
 	vbtlk_retval[0] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VB2_SUCCESS, "Ctrl+U force USB");
+	TEST_EQ(VbBootDeveloperMenu(ctx), VB2_SUCCESS, "Ctrl+U force USB");
 	TEST_NEQ(audio_looping_calls_left, 0, "  aborts audio");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
@@ -759,7 +757,7 @@ static void VbBootDevTest(void)
 	VbApiKernelGetFwmp()->flags |= FWMP_DEV_ENABLE_USB;
 	mock_keypress[0] = VB_KEY_CTRL('U');
 	vbtlk_retval[0] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VB2_SUCCESS, "Ctrl+U force USB");
+	TEST_EQ(VbBootDeveloperMenu(ctx), VB2_SUCCESS, "Ctrl+U force USB");
 	TEST_NEQ(audio_looping_calls_left, 0, "  aborts audio");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
@@ -769,12 +767,12 @@ static void VbBootDevTest(void)
 
 	/* If no valid USB, eventually times out and tries fixed disk */
 	ResetMocksForDeveloper();
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
 	mock_keypress[0] = VB_KEY_CTRL('U');
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"Ctrl+U failed - no USB");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(audio_looping_calls_left, 0, "  used up audio");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
@@ -795,14 +793,14 @@ static void VbBootDevTest(void)
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Boot From USB
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
 	vbtlk_retval[0] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VB2_SUCCESS,
+	TEST_EQ(VbBootDeveloperMenu(ctx), VB2_SUCCESS,
 		"Menu selected USB boot");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 	TEST_NEQ(audio_looping_calls_left, 0, "  aborts audio");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	i = 0;
 	TEST_EQ(screens_displayed[i++], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  dev warning menu: power off");
@@ -822,20 +820,20 @@ static void VbBootDevTest(void)
 
 	/* If default USB, the option is preselected */
 	ResetMocksForDeveloper();
-	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT, VB2_DEV_DEFAULT_BOOT_USB);
+	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT, VB2_DEV_DEFAULT_BOOT_USB);
 	i = 0;
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Enable OS Verif
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Show Debug Info
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Developer Options
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
 	vbtlk_retval[0] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VB2_SUCCESS,
+	TEST_EQ(VbBootDeveloperMenu(ctx), VB2_SUCCESS,
 		"Menu selected USB default boot");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 	TEST_NEQ(audio_looping_calls_left, 0, "  aborts audio");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	i = 0;
 	TEST_EQ(screens_displayed[i++], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  dev warning menu: power off");
@@ -860,12 +858,12 @@ static void VbBootDevTest(void)
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Boot From USB
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"Menu selected invalid USB boot");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 	TEST_EQ(audio_looping_calls_left, 0, "  used up audio");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	i = 0;
 	TEST_EQ(screens_displayed[i++], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  dev warning menu: power off");
@@ -896,11 +894,11 @@ static void VbBootDevTest(void)
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Boot From USB
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"Menu selected disabled USB boot");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 	TEST_EQ(audio_looping_calls_left, 0, "  used up audio");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	i = 0;
 	TEST_EQ(screens_displayed[i++], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  dev warning menu: power off");
@@ -932,15 +930,15 @@ static void VbBootDevTest(void)
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS; // Enter altfw menu
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS; // Select first option
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS; // and again
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
-	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT, VB2_DEV_DEFAULT_BOOT_LEGACY);
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_DEFAULT_BOOT, VB2_DEV_DEFAULT_BOOT_LEGACY);
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"Menu selected legacy boot");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(vbexlegacy_called, 2, "  tried legacy boot twice");
 	TEST_EQ(altfw_num, 0, "  check altfw_num");
 	TEST_EQ(audio_looping_calls_left, 0, "  audio timeout");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	i = 0;
 	TEST_EQ(screens_displayed[i++], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  dev warning menu: power off");
@@ -973,12 +971,12 @@ static void VbBootDevTest(void)
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Boot From USB
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Boot Legacy BIOS
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"Menu selected legacy boot when not enabled");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(vbexlegacy_called, 0, "  did not attempt legacy boot");
 	TEST_EQ(audio_looping_calls_left, 0, "  audio timeout");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	i = 0;
 	TEST_EQ(screens_displayed[i++], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  dev warning menu: power off");
@@ -1005,12 +1003,12 @@ static void VbBootDevTest(void)
 
 	/* Use volume-up long press shortcut to boot USB */
 	ResetMocksForDeveloper();
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
 	mock_keypress[0] = VB_BUTTON_VOL_UP_LONG_PRESS;
 	vbtlk_retval[0] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VB2_SUCCESS, "VolUp USB");
+	TEST_EQ(VbBootDeveloperMenu(ctx), VB2_SUCCESS, "VolUp USB");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_NEQ(audio_looping_calls_left, 0, "  aborts audio");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
@@ -1020,15 +1018,15 @@ static void VbBootDevTest(void)
 
 	/* Can boot a valid USB image after failing to boot invalid image */
 	ResetMocksForDeveloper();
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
 	mock_keypress[0] = VB_BUTTON_VOL_UP_LONG_PRESS;
 	mock_keypress[1] = VB_BUTTON_VOL_UP_LONG_PRESS;
 	vbtlk_retval[0] = VB2_ERROR_MOCK - VB_DISK_FLAG_REMOVABLE;
 	vbtlk_retval[1] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VB2_SUCCESS,
+	TEST_EQ(VbBootDeveloperMenu(ctx), VB2_SUCCESS,
 		"VolUp USB valid after invalid");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_NEQ(audio_looping_calls_left, 0, "  aborts audio");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
@@ -1043,10 +1041,10 @@ static void VbBootDevTest(void)
 	/* Volume-up long press only works if USB is enabled */
 	ResetMocksForDeveloper();
 	mock_keypress[0] = VB_BUTTON_VOL_UP_LONG_PRESS;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"VolUp not enabled");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(audio_looping_calls_left, 0, "  audio timed out");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
@@ -1061,12 +1059,12 @@ static void VbBootDevTest(void)
 
 	/* Volume-up long press without valid USB will still time out */
 	ResetMocksForDeveloper();
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
 	mock_keypress[0] = VB_BUTTON_VOL_UP_LONG_PRESS;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"VolUp without valid USB");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  warning screen");
 	TEST_EQ(screens_displayed[1], VB_SCREEN_BLANK, "  blank (error flash)");
@@ -1080,7 +1078,7 @@ static void VbBootDevTest(void)
 
 	/* Volume-up long press works from other menus, like LANGUAGE */
 	ResetMocksForDeveloper();
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_USB, 1);
 	i = 0;
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Enable OS Verif
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Show Debug Info
@@ -1092,10 +1090,10 @@ static void VbBootDevTest(void)
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_LONG_PRESS;
 	vbtlk_retval[0] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VB2_SUCCESS,
+	TEST_EQ(VbBootDeveloperMenu(ctx), VB2_SUCCESS,
 		"VolUp USB from LANGUAGE");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_NEQ(audio_looping_calls_left, 0, "  aborts audio");
 	i = 0;
 	TEST_EQ(screens_displayed[i++], VB_SCREEN_DEVELOPER_WARNING_MENU,
@@ -1126,11 +1124,11 @@ static void VbBootDevTest(void)
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // enable os verification
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS; // confirm is the default
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VBERROR_REBOOT_REQUIRED,
+	TEST_EQ(VbBootDeveloperMenu(ctx), VBERROR_REBOOT_REQUIRED,
 		"TONORM via menu");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISABLE_DEV_REQUEST), 1,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DISABLE_DEV_REQUEST), 1,
 		"  disable dev request");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_NEQ(audio_looping_calls_left, 0, "  aborts audio");
@@ -1159,11 +1157,11 @@ static void VbBootDevTest(void)
 	mock_keypress[i++] = VB_BUTTON_VOL_DOWN_LONG_PRESS;	/* same */
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_DOWN_COMBO_PRESS;	/* noop */
 	mock_keypress[i++] = VB_KEY_ENTER;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VBERROR_REBOOT_REQUIRED,
+	TEST_EQ(VbBootDeveloperMenu(ctx), VBERROR_REBOOT_REQUIRED,
 		"FWMP dev disabled");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISABLE_DEV_REQUEST), 1,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DISABLE_DEV_REQUEST), 1,
 		"  disable dev request");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 	TEST_NEQ(audio_looping_calls_left, 0, "  aborts audio");
@@ -1205,10 +1203,10 @@ static void VbBootDevTest(void)
 	ResetMocksForDeveloper();
 	VbApiKernelGetFwmp()->flags |= FWMP_DEV_DISABLE_BOOT;
 	shutdown_request_calls_left = 1;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootDeveloperMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested when dev disabled");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISABLE_DEV_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DISABLE_DEV_REQUEST), 0,
 		"  did not exit dev mode");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_DEVELOPER_TO_NORM_MENU,
 		"  tonorm screen");
@@ -1223,10 +1221,10 @@ static void VbBootDevTest(void)
 	i = 0;
 	mock_keypress[i++] = VB_BUTTON_VOL_DOWN_SHORT_PRESS;	// Power Off
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootDeveloperMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Power Off when dev disabled");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_DISABLE_DEV_REQUEST), 0,
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DISABLE_DEV_REQUEST), 0,
 		"  did not exit dev mode");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_NEQ(audio_looping_calls_left, 0, "  aborts audio");
@@ -1246,12 +1244,12 @@ static void VbBootDevTest(void)
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Enable OS Verif
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // Show Debug Info
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"Show Debug Info");
 	TEST_EQ(debug_info_displayed, 1, "  debug info displayed");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 	TEST_EQ(audio_looping_calls_left, 0, "  audio timed out");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	i = 0;
 	TEST_EQ(screens_displayed[i++], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  dev warning menu: power off");
@@ -1267,12 +1265,12 @@ static void VbBootDevTest(void)
 	ResetMocksForDeveloper();
 	i = 0;
 	mock_keypress[i++] = '\t';
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"Show Debug Info (Tab shortcut)");
 	TEST_EQ(debug_info_displayed, 1, "  debug info displayed");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 	TEST_EQ(audio_looping_calls_left, 0, "  audio timed out");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	i = 0;
 	TEST_EQ(screens_displayed[i++], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  dev warning menu: power off");
@@ -1292,9 +1290,9 @@ static void VbBootRecTest(void)
 
 	/* Shutdown requested in BROKEN */
 	ResetMocks();
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested in BROKEN");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_OS_BROKEN,
 		"  broken screen");
@@ -1309,9 +1307,9 @@ static void VbBootRecTest(void)
 	vbtlk_retval[1] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
 	vbtlk_retval[2] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
 	vbtlk_retval[3] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested in BROKEN with disks");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_OS_BROKEN,
 		"  broken screen");
@@ -1323,9 +1321,9 @@ static void VbBootRecTest(void)
 	ResetMocks();
 	vbtlk_retval[0] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
 	vbtlk_retval[1] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested in BROKEN with later disk");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_OS_BROKEN,
 		"  broken screen");
@@ -1339,9 +1337,9 @@ static void VbBootRecTest(void)
 	vbtlk_retval[1] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
 	vbtlk_retval[2] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
 	shared->flags |= VBSD_BOOT_DEV_SWITCH_ON;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested in BROKEN with dev switch");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_OS_BROKEN,
 		"  broken screen");
@@ -1352,9 +1350,9 @@ static void VbBootRecTest(void)
 	/* go to INSERT if recovery button physically pressed and EC trusted */
 	ResetMocksForManualRecovery();
 	vbtlk_retval[0] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested in INSERT with manual rec");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_RECOVERY_INSERT,
 		"  insert screen");
@@ -1366,9 +1364,9 @@ static void VbBootRecTest(void)
 	ResetMocks();
 	vbtlk_retval[0] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
 	gbb.flags |= VB2_GBB_FLAG_FORCE_MANUAL_RECOVERY;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Shutdown requested in INSERT forced by GBB flag");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_RECOVERY_INSERT,
 		"  insert screen");
@@ -1380,9 +1378,9 @@ static void VbBootRecTest(void)
 	ResetMocksForManualRecovery();
 	vbtlk_retval[0] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
 	shared->flags &= ~VBSD_BOOT_REC_SWITCH_ON;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Go to BROKEN if recovery not manually requested");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_OS_BROKEN,
 		"  broken screen");
@@ -1394,9 +1392,9 @@ static void VbBootRecTest(void)
 	ResetMocksForManualRecovery();
 	vbtlk_retval[0] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
 	trust_ec = 0;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Go to BROKEN if EC is not trusted");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_OS_BROKEN,
 		"  broken screen");
@@ -1408,9 +1406,9 @@ static void VbBootRecTest(void)
 	ResetMocksForManualRecovery();
 	vbtlk_retval[0] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
 	vbtlk_retval[1] = VB2_ERROR_MOCK - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VB2_SUCCESS,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VB2_SUCCESS,
 		"INSERT boots without screens if valid on first try");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(virtdev_set, 0, "  virtual dev mode off");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_BLANK, "  final blank screen");
@@ -1424,9 +1422,9 @@ static void VbBootRecTest(void)
 	vbtlk_retval[2] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
 	vbtlk_retval[3] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
 	vbtlk_retval[4] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VB2_SUCCESS,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VB2_SUCCESS,
 		"INSERT boots after valid image appears");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(virtdev_set, 0, "  virtual dev mode off");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_RECOVERY_INSERT,
@@ -1442,9 +1440,9 @@ static void VbBootRecTest(void)
 	vbtlk_retval[2] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
 	vbtlk_retval[3] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
 	vbtlk_retval[4] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VB2_SUCCESS,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VB2_SUCCESS,
 		"INSERT boots after valid image appears");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(virtdev_set, 0, "  virtual dev mode off");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_RECOVERY_NO_GOOD,
@@ -1471,11 +1469,11 @@ static void VbBootRecTest(void)
 	mock_keypress[i] = VB_KEY_FLAG_TRUSTED_KEYBOARD;
 	mock_keypress[i++] = VB_BUTTON_VOL_DOWN_LONG_PRESS;
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Shortcuts ignored in BROKEN");
 	TEST_EQ(virtdev_set, 0, "  virtual dev mode off");
 	TEST_NEQ(shutdown_request_calls_left, 0, "  powered down explicitly");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_OS_BROKEN,
 		"  broken screen");
@@ -1498,11 +1496,11 @@ static void VbBootRecTest(void)
 	mock_keypress[i++] = VB_BUTTON_VOL_DOWN_LONG_PRESS;
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
 	vbtlk_retval[0] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Shortcuts ignored in INSERT");
 	TEST_EQ(virtdev_set, 0, "  virtual dev mode off");
 	TEST_NEQ(shutdown_request_calls_left, 0, "  powered down explicitly");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_RECOVERY_INSERT,
 		"  insert screen");
@@ -1515,9 +1513,9 @@ static void VbBootRecTest(void)
 	mock_keypress[0] = VB_BUTTON_VOL_UP_SHORT_PRESS; // enter options
 	mock_keypress[1] = VB_BUTTON_VOL_DOWN_SHORT_PRESS; // power off
 	mock_keypress[2] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Power Off BROKEN through OPTIONS");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_NEQ(shutdown_request_calls_left, 0, "  powered down explicitly");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_OS_BROKEN,
@@ -1535,9 +1533,9 @@ static void VbBootRecTest(void)
 	mock_keypress[0] = VB_BUTTON_VOL_UP_SHORT_PRESS; // enter options
 	mock_keypress[1] = VB_BUTTON_VOL_DOWN_SHORT_PRESS; // power off
 	mock_keypress[2] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Power Off NOGOOD through OPTIONS");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_NEQ(shutdown_request_calls_left, 0, "  powered down explicitly");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_RECOVERY_NO_GOOD,
@@ -1558,9 +1556,9 @@ static void VbBootRecTest(void)
 	mock_keypress[1] = VB_BUTTON_VOL_DOWN_SHORT_PRESS; // power off
 	mock_keypress[2] = VB_BUTTON_POWER_SHORT_PRESS;
 	vbtlk_retval[0] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Power Off INSERT through TO_DEV");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_NEQ(shutdown_request_calls_left, 0, "  powered down explicitly");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_RECOVERY_INSERT,
@@ -1578,9 +1576,9 @@ static void VbBootRecTest(void)
 	mock_keypress[0] = VB_BUTTON_VOL_UP_SHORT_PRESS; // enter options
 	mock_keypress[1] = VB_BUTTON_VOL_UP_SHORT_PRESS; // show debug info
 	mock_keypress[2] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Show Debug info from BROKEN through OPTIONS");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 1, "  no debug info");
 	TEST_EQ(shutdown_request_calls_left, 0, "  timed out");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_OS_BROKEN,
@@ -1596,9 +1594,9 @@ static void VbBootRecTest(void)
 	/* Show Debug Info on NOGOOD with Tab */
 	ResetMocksForManualRecovery();
 	mock_keypress[0] = '\t';
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Show Debug info on NOGOOD with Tab");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 1, "  no debug info");
 	TEST_EQ(shutdown_request_calls_left, 0, "  timed out");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_RECOVERY_NO_GOOD,
@@ -1619,11 +1617,11 @@ static void VbBootRecTest(void)
 	mock_keypress[i++] = VB_BUTTON_VOL_DOWN_SHORT_PRESS; // cancel
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS; // power off
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"go to TO_DEV screen and cancel");
 	TEST_NEQ(shutdown_request_calls_left, 0, "  powered down explicitly");
 	TEST_EQ(virtdev_set, 0, "  virtual dev mode off");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	i = 0;
 	TEST_EQ(screens_displayed[i++], VB_SCREEN_RECOVERY_INSERT,
@@ -1649,9 +1647,9 @@ static void VbBootRecTest(void)
 	mock_keyflags[i] = VB_KEY_FLAG_TRUSTED_KEYBOARD;
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS;
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_REBOOT_REQUIRED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_REBOOT_REQUIRED,
 		"go to TO_DEV screen and confirm");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(virtdev_set, 1, "  virtual dev mode on");
 	i = 0;
@@ -1671,9 +1669,9 @@ static void VbBootRecTest(void)
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_DOWN_COMBO_PRESS; // try to_dev
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // try confirm
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Untrusted keyboard cannot enter TO_DEV");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(shutdown_request_calls_left, 0, "  timed out");
 	i = 0;
@@ -1694,9 +1692,9 @@ static void VbBootRecTest(void)
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_DOWN_COMBO_PRESS; // enter to_dev
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // try to confirm...
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Untrusted keyboard cannot navigate in TO_DEV");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(shutdown_request_calls_left, 0, "  timed out");
 	i = 0;
@@ -1724,9 +1722,9 @@ static void VbBootRecTest(void)
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_SHORT_PRESS; // confirm enabling
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
 	virtdev_retval = VB2_ERROR_MOCK;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_TPM_SET_BOOT_MODE_STATE,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_TPM_SET_BOOT_MODE_STATE,
 		"todev TPM failure");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_NEQ(shutdown_request_calls_left, 0, "  aborted explicitly");
 	TEST_EQ(virtdev_set, 1, "  virtual dev mode on");
@@ -1748,9 +1746,9 @@ static void VbBootRecTest(void)
 	i = 0;
 	mock_keyflags[i] = VB_KEY_FLAG_TRUSTED_KEYBOARD;
 	mock_keypress[i++] = VB_BUTTON_VOL_UP_DOWN_COMBO_PRESS; // enter to_dev
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Ctrl+D ignored if already in dev mode");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(shutdown_request_calls_left, 0, "  timed out");
 	TEST_EQ(virtdev_set, 0, "  virtual dev mode wasn't enabled again");
@@ -1776,11 +1774,11 @@ static void VbBootRecTest(void)
 	mock_keypress[57] = VB_BUTTON_POWER_SHORT_PRESS;
 	vbtlk_retval[0] = VB2_ERROR_MOCK - VB_DISK_FLAG_REMOVABLE;
 	vbtlk_retval[1] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Drop back to INSERT from TO_DEV when removing invalid USB");
 	TEST_NEQ(shutdown_request_calls_left, 0, "  powered down explicitly");
 	TEST_EQ(virtdev_set, 0, "  virtual dev mode off");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_RECOVERY_NO_GOOD,
 		"  nogood screen");
@@ -1807,11 +1805,11 @@ static void VbBootRecTest(void)
 	vbtlk_retval[2] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
 	vbtlk_retval[3] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
 	vbtlk_retval[4] = VB2_ERROR_MOCK - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"Drop back to NOGOOD from LANGUAGE when inserting invalid USB");
 	TEST_EQ(shutdown_request_calls_left, 0, "  timed out");
 	TEST_EQ(virtdev_set, 0, "  virtual dev mode off");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_RECOVERY_INSERT,
 		"  insert screen");
@@ -1834,11 +1832,11 @@ static void VbBootRecTest(void)
 	mock_keypress[0] = VB_BUTTON_VOL_UP_SHORT_PRESS; // enter OPTIONS
 	vbtlk_retval[0] = VBERROR_NO_DISK_FOUND - VB_DISK_FLAG_REMOVABLE;
 	vbtlk_retval[1] = VB2_SUCCESS - VB_DISK_FLAG_REMOVABLE;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VB2_SUCCESS,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VB2_SUCCESS,
 		"Boot by plugging in USB straight from OPTIONS menu");
 	TEST_NEQ(shutdown_request_calls_left, 0, "  booted explicitly");
 	TEST_EQ(virtdev_set, 0, "  virtual dev mode off");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_EQ(screens_displayed[0], VB_SCREEN_RECOVERY_INSERT,
 		"  insert screen");
@@ -1867,7 +1865,7 @@ static void VbTestLanguageMenu(void)
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS; // select current lang
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS; // cancel -> BROKEN
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS; // power off
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"go to language menu from BROKEN");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_NEQ(shutdown_request_calls_left, 0, "  powered down explicitly");
@@ -1914,7 +1912,7 @@ static void VbTestLanguageMenu(void)
 	mock_keyflags[i] = VB_KEY_FLAG_TRUSTED_KEYBOARD;
 	mock_keypress[i++] = VB_BUTTON_VOL_DOWN_SHORT_PRESS; // power off
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"go to language menus from INSERT");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_NEQ(shutdown_request_calls_left, 0, "  powered down explicitly");
@@ -1978,7 +1976,7 @@ static void VbTestLanguageMenu(void)
 	mock_keypress[i++] = VB_BUTTON_VOL_DOWN_SHORT_PRESS; // cancel
 	mock_keypress[i++] = VB_BUTTON_VOL_DOWN_SHORT_PRESS; // power off
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootDeveloperMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootDeveloperMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		" scroll through all language menus in developer options");
 	TEST_EQ(debug_info_displayed, 0, "  no debug info");
 	TEST_NEQ(shutdown_request_calls_left, 0, "  powered down explicitly");
@@ -2098,7 +2096,7 @@ static void VbNavigationTest(void)
 	mock_keypress[i++] = VB_BUTTON_VOL_DOWN_SHORT_PRESS; // power off
 	mock_keypress[i++] = VB_BUTTON_VOL_DOWN_SHORT_PRESS; // language
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS;
-	TEST_EQ(VbBootRecoveryMenu(&ctx), VBERROR_SHUTDOWN_REQUESTED,
+	TEST_EQ(VbBootRecoveryMenu(ctx), VBERROR_SHUTDOWN_REQUESTED,
 		"recovery mode long navigation");
 	TEST_EQ(debug_info_displayed, 1, "  showed debug info");
 	TEST_EQ(shutdown_request_calls_left, 0, "  timed out");
@@ -2226,14 +2224,14 @@ static void VbNavigationTest(void)
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS; // Select altfw menu
 	mock_keypress[i++] = VB_BUTTON_VOL_DOWN_SHORT_PRESS; // Second altfw
 	mock_keypress[i++] = VB_BUTTON_POWER_SHORT_PRESS; // Select 2nd altfw
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
-	TEST_EQ(VbBootDeveloperMenu(&ctx), vbtlk_retval_fixed,
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
+	TEST_EQ(VbBootDeveloperMenu(ctx), vbtlk_retval_fixed,
 		"developer mode long navigation");
 	TEST_EQ(debug_info_displayed, 1, "  showed debug info");
 	TEST_EQ(vbexlegacy_called, 1, "  tried legacy");
 	TEST_EQ(altfw_num, 2, "  check altfw_num");
 	TEST_EQ(audio_looping_calls_left, 0, "  audio timeout");
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST), 0, "  no recovery");
 	i = 0;
 	TEST_EQ(screens_displayed[i++], VB_SCREEN_DEVELOPER_WARNING_MENU,
 		"  dev warning menu: power off");
diff --git a/tests/vboot_display_tests.c b/tests/vboot_display_tests.c
index 8286d4f6..592c7850 100644
--- a/tests/vboot_display_tests.c
+++ b/tests/vboot_display_tests.c
@@ -25,7 +25,7 @@
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
 static char debug_info[4096];
-static struct vb2_context ctx;
+static struct vb2_context *ctx;
 static struct vb2_shared_data *sd;
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
 static uint32_t mock_localization_count;
@@ -37,13 +37,11 @@ static void ResetMocks(void)
 	mock_localization_count = 3;
 	mock_altfw_mask = 3 << 1;	/* This mask selects 1 and 2 */
 
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.workbuf = workbuf;
-	ctx.workbuf_size = sizeof(workbuf);
-	vb2_init_context(&ctx);
-	vb2_nv_init(&ctx);
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
+	vb2_nv_init(ctx);
 
-	sd = vb2_get_sd(&ctx);
+	sd = vb2_get_sd(ctx);
 	sd->vbsd = shared;
 
 	memset(&shared_data, 0, sizeof(shared_data));
@@ -84,7 +82,7 @@ static void DebugInfoTest(void)
 
 	/* Display debug info */
 	ResetMocks();
-	TEST_SUCC(VbDisplayDebugInfo(&ctx),
+	TEST_SUCC(VbDisplayDebugInfo(ctx),
 		  "Display debug info");
 	TEST_NEQ(*debug_info, '\0', "  Some debug info was displayed");
 }
@@ -93,38 +91,38 @@ static void DebugInfoTest(void)
 static void DisplayKeyTest(void)
 {
 	ResetMocks();
-	VbCheckDisplayKey(&ctx, 'q', NULL);
+	VbCheckDisplayKey(ctx, 'q', NULL);
 	TEST_EQ(*debug_info, '\0', "DisplayKey q = does nothing");
 
 	ResetMocks();
-	VbCheckDisplayKey(&ctx, '\t', NULL);
+	VbCheckDisplayKey(ctx, '\t', NULL);
 	TEST_NEQ(*debug_info, '\0', "DisplayKey tab = display");
 
 	/* Toggle localization */
 	ResetMocks();
-	vb2_nv_set(&ctx, VB2_NV_LOCALIZATION_INDEX, 0);
-	VbCheckDisplayKey(&ctx, VB_KEY_DOWN, NULL);
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_LOCALIZATION_INDEX), 2,
+	vb2_nv_set(ctx, VB2_NV_LOCALIZATION_INDEX, 0);
+	VbCheckDisplayKey(ctx, VB_KEY_DOWN, NULL);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_LOCALIZATION_INDEX), 2,
 		"DisplayKey up");
-	VbCheckDisplayKey(&ctx, VB_KEY_LEFT, NULL);
-	vb2_nv_get(&ctx, VB2_NV_LOCALIZATION_INDEX);
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_LOCALIZATION_INDEX), 1,
+	VbCheckDisplayKey(ctx, VB_KEY_LEFT, NULL);
+	vb2_nv_get(ctx, VB2_NV_LOCALIZATION_INDEX);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_LOCALIZATION_INDEX), 1,
 		"DisplayKey left");
-	VbCheckDisplayKey(&ctx, VB_KEY_RIGHT, NULL);
-	vb2_nv_get(&ctx, VB2_NV_LOCALIZATION_INDEX);
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_LOCALIZATION_INDEX), 2,
+	VbCheckDisplayKey(ctx, VB_KEY_RIGHT, NULL);
+	vb2_nv_get(ctx, VB2_NV_LOCALIZATION_INDEX);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_LOCALIZATION_INDEX), 2,
 		"DisplayKey right");
-	VbCheckDisplayKey(&ctx, VB_KEY_UP, NULL);
-	vb2_nv_get(&ctx, VB2_NV_LOCALIZATION_INDEX);
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_LOCALIZATION_INDEX), 0,
+	VbCheckDisplayKey(ctx, VB_KEY_UP, NULL);
+	vb2_nv_get(ctx, VB2_NV_LOCALIZATION_INDEX);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_LOCALIZATION_INDEX), 0,
 		"DisplayKey up");
 
 	/* Reset localization if localization count is invalid */
 	ResetMocks();
-	vb2_nv_set(&ctx, VB2_NV_LOCALIZATION_INDEX, 1);
+	vb2_nv_set(ctx, VB2_NV_LOCALIZATION_INDEX, 1);
 	mock_localization_count = 0xffffffff;
-	VbCheckDisplayKey(&ctx, VB_KEY_UP, NULL);
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_LOCALIZATION_INDEX), 0,
+	VbCheckDisplayKey(ctx, VB_KEY_UP, NULL);
+	TEST_EQ(vb2_nv_get(ctx, VB2_NV_LOCALIZATION_INDEX), 0,
 		"DisplayKey invalid");
 }
 
diff --git a/tests/vboot_kernel_tests.c b/tests/vboot_kernel_tests.c
index 531a1187..3273b9f9 100644
--- a/tests/vboot_kernel_tests.c
+++ b/tests/vboot_kernel_tests.c
@@ -71,7 +71,7 @@ static GptHeader *mock_gpt_secondary =
 	(GptHeader*)&mock_disk[MOCK_SECTOR_SIZE * (MOCK_SECTOR_COUNT - 1)];
 static uint8_t mock_digest[VB2_SHA256_DIGEST_SIZE] = {12, 34, 56, 78};
 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
-static struct vb2_context ctx;
+static struct vb2_context *ctx;
 static struct vb2_packed_key mock_key;
 
 /**
@@ -171,14 +171,13 @@ static void ResetMocks(void)
 	mock_parts[0].size = 150;  /* 75 KB */
 	mock_part_next = 0;
 
-	memset(&ctx, 0, sizeof(ctx));
-	ctx.workbuf = workbuf;
-	ctx.workbuf_size = sizeof(workbuf);
-	vb2_nv_init(&ctx);
+	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
+		  "vb2api_init failed");
+	vb2_nv_init(ctx);
 
 	memset(&mock_key, 0, sizeof(mock_key));
 
-	struct vb2_shared_data *sd = vb2_get_sd(&ctx);
+	struct vb2_shared_data *sd = vb2_get_sd(ctx);
 	sd->vbsd = shared;
 
 	// TODO: more workbuf fields - flags, secdata_firmware, secdata_kernel
@@ -594,11 +593,7 @@ static void ReadWriteGptTest(void)
 
 static void TestLoadKernel(int expect_retval, const char *test_name)
 {
-	TEST_EQ(LoadKernel(&ctx, &lkp), expect_retval, test_name);
-
-	/* LoadKernel() should never request recovery directly. */
-	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
-		0, "  recovery request");
+	TEST_EQ(LoadKernel(ctx, &lkp), expect_retval, test_name);
 }
 
 /**
@@ -655,25 +650,25 @@ static void LoadKernelTest(void)
 
 	/* In dev mode, fail if hash is bad too */
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
+	ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
 	keyblock_verify_fail = 2;
 	TestLoadKernel(VBERROR_INVALID_KERNEL_FOUND, "Fail keyblock dev hash");
 
 	/* But just bad sig is ok */
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
+	ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
 	keyblock_verify_fail = 1;
 	TestLoadKernel(0, "Succeed keyblock dev sig");
 
 	/* In dev mode and requiring signed kernel, fail if sig is bad */
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
-	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_SIGNED_ONLY, 1);
+	ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
+	vb2_nv_set(ctx, VB2_NV_DEV_BOOT_SIGNED_ONLY, 1);
 	keyblock_verify_fail = 1;
 	TestLoadKernel(VBERROR_INVALID_KERNEL_FOUND, "Fail keyblock dev sig");
 
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
+	ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
 	lkp.fwmp = &fwmp;
 	fwmp.flags |= FWMP_DEV_ENABLE_OFFICIAL_ONLY;
 	keyblock_verify_fail = 1;
@@ -694,14 +689,14 @@ static void LoadKernelTest(void)
 		       "Keyblock rec flag mismatch");
 
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
 	kbh.keyblock_flags =
 		VB2_KEYBLOCK_FLAG_RECOVERY_1 | VB2_KEYBLOCK_FLAG_DEVELOPER_1;
 	TestLoadKernel(VBERROR_INVALID_KERNEL_FOUND,
 		       "Keyblock recdev flag mismatch");
 
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE | VB2_CONTEXT_DEVELOPER_MODE;
+	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE | VB2_CONTEXT_DEVELOPER_MODE;
 	kbh.keyblock_flags =
 		VB2_KEYBLOCK_FLAG_RECOVERY_1 | VB2_KEYBLOCK_FLAG_DEVELOPER_0;
 	TestLoadKernel(VBERROR_INVALID_KERNEL_FOUND,
@@ -732,12 +727,12 @@ static void LoadKernelTest(void)
 
 	ResetMocks();
 	kbh.data_key.key_version = 1;
-	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
+	ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
 	TestLoadKernel(0, "Key version ignored in dev mode");
 
 	ResetMocks();
 	kbh.data_key.key_version = 1;
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
 	TestLoadKernel(0, "Key version ignored in rec mode");
 
 	ResetMocks();
@@ -754,17 +749,17 @@ static void LoadKernelTest(void)
 
 	ResetMocks();
 	kph.kernel_version = 0;
-	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
+	ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
 	TestLoadKernel(0, "Kernel version ignored in dev mode");
 
 	ResetMocks();
 	kph.kernel_version = 0;
-	ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+	ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
 	TestLoadKernel(0, "Kernel version ignored in rec mode");
 
 	/* Check developer key hash - bad */
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
+	ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
 	lkp.fwmp = &fwmp;
 	fwmp.flags |= FWMP_DEV_USE_KEY_HASH;
 	fwmp.dev_key_hash[0]++;
@@ -773,7 +768,7 @@ static void LoadKernelTest(void)
 
 	/* Check developer key hash - good */
 	ResetMocks();
-	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
+	ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
 	lkp.fwmp = &fwmp;
 	fwmp.flags |= FWMP_DEV_USE_KEY_HASH;
 	TestLoadKernel(0, "Good keyblock dev fwmp hash");
diff --git a/tests/verify_kernel.c b/tests/verify_kernel.c
index b14d77fe..fffd102c 100644
--- a/tests/verify_kernel.c
+++ b/tests/verify_kernel.c
@@ -19,6 +19,10 @@
 #include "vboot_api.h"
 #include "vboot_kernel.h"
 
+static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
+static struct vb2_context *ctx;
+static struct vb2_shared_data *sd;
+
 static uint8_t *diskbuf;
 
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
@@ -107,39 +111,21 @@ int main(int argc, char *argv[])
 	/* TODO(chromium:441893): support dev-mode flag and external gpt flag */
 	params.boot_flags = 0;
 
-	/*
-	 * Set up vboot context.
-	 *
-	 * TODO: Propagate this up to higher API levels
-	 */
-	struct vb2_context ctx;
-	memset(&ctx, 0, sizeof(ctx));
-
-	/* TODO(chromium:441893): support dev-mode flag and external gpt flag */
-	ctx.workbuf = malloc(VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE);
-	if (!ctx.workbuf) {
-		fprintf(stderr, "Can't allocate workbuf\n");
+	if (vb2api_init(&workbuf, sizeof(workbuf), &ctx)) {
+		fprintf(stderr, "Can't initialize workbuf\n");
 		return 1;
 	}
-	ctx.workbuf_size = VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE;
-
-	if (VB2_SUCCESS != vb2_init_context(&ctx)) {
-		free(ctx.workbuf);
-		fprintf(stderr, "Can't init context\n");
-		return 1;
-	}
-
-	struct vb2_shared_data *sd = vb2_get_sd(&ctx);
+	sd = vb2_get_sd(ctx);
 	sd->vbsd = shared;
 
 	/*
 	 * LoadKernel() cares only about VBNV_DEV_BOOT_SIGNED_ONLY, and only in
 	 * dev mode.  So just use defaults for nv storage.
 	 */
-	vb2_nv_init(&ctx);
+	vb2_nv_init(ctx);
 
 	/* Try loading kernel */
-	rv = LoadKernel(&ctx, &params);
+	rv = LoadKernel(ctx, &params);
 	if (rv != VB2_SUCCESS) {
 		fprintf(stderr, "LoadKernel() failed with code %d\n", rv);
 		return 1;
diff --git a/utility/load_kernel_test.c b/utility/load_kernel_test.c
index 3e4fb90c..540d4382 100644
--- a/utility/load_kernel_test.c
+++ b/utility/load_kernel_test.c
@@ -22,6 +22,10 @@
 #define LBA_BYTES 512
 #define KERNEL_BUFFER_SIZE 0xA00000
 
+static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE];
+static struct vb2_context *ctx;
+static struct vb2_shared_data *sd;
+
 /* Global variables for stub functions */
 static LoadKernelParams lkp;
 static FILE *image_file = NULL;
@@ -225,31 +229,22 @@ int main(int argc, char* argv[])
 	lkp.kernel_buffer_size = KERNEL_BUFFER_SIZE;
 
 	/* Set up vboot context. */
-	struct vb2_context ctx;
-	memset(&ctx, 0, sizeof(ctx));
-	/* No need to initialize ctx->nvdata[]; defaults are fine */
-	/* TODO(chromium:441893): support dev-mode flag and external gpt flag */
-	ctx.workbuf = malloc(VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE);
-	if (!ctx.workbuf) {
-		fprintf(stderr, "Can't allocate workbuf\n");
+	if (vb2api_init(&workbuf, sizeof(workbuf), &ctx)) {
+		fprintf(stderr, "Can't initialize workbuf\n");
 		return 1;
 	}
-	ctx.workbuf_size = VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE;
+	sd = vb2_get_sd(ctx);
+	sd->vbsd = shared;
+
+	/* No need to initialize ctx->nvdata[]; defaults are fine */
+	/* TODO(chromium:441893): support dev-mode flag and external gpt flag */
 	if (boot_flags & BOOT_FLAG_RECOVERY)
-		ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
+		ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;
 	if (boot_flags & BOOT_FLAG_DEVELOPER)
-		ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
-	if (VB2_SUCCESS != vb2_init_context(&ctx)) {
-		free(ctx.workbuf);
-		fprintf(stderr, "Can't init context\n");
-		return 1;
-	}
-
-	struct vb2_shared_data *sd = vb2_get_sd(&ctx);
-	sd->vbsd = shared;
+		ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
 
 	/* Call LoadKernel() */
-	rv = LoadKernel(&ctx, &lkp);
+	rv = LoadKernel(ctx, &lkp);
 	printf("LoadKernel() returned %d\n", rv);
 
 	if (VB2_SUCCESS == rv) {