From ecdca931ae0637d1a9498f64862939bd5bb99e0b Mon Sep 17 00:00:00 2001 From: Joel Kitching Date: Thu, 25 Jul 2019 18:26:18 +0800 Subject: 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 Cq-Depend: chromium:1874753, chromium:1902339 Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/vboot_reference/+/1716351 Tested-by: Joel Kitching Commit-Queue: Julius Werner Reviewed-by: Joel Kitching Reviewed-by: Julius Werner --- firmware/2lib/2api.c | 6 +- firmware/2lib/2misc.c | 107 ++++--- firmware/2lib/include/2api.h | 109 +++++-- firmware/2lib/include/2misc.h | 18 +- firmware/2lib/include/2return_codes.h | 11 +- firmware/2lib/include/2struct.h | 27 +- firmware/include/vb2_api.h | 1 + firmware/lib/vboot_api_kernel.c | 8 - firmware/lib20/api_kernel.c | 3 +- firmware/lib20/kernel.c | 5 +- firmware/lib20/misc.c | 3 +- firmware/lib21/misc.c | 6 +- tests/vb20_api_kernel_tests.c | 149 +++++----- tests/vb20_kernel_tests.c | 130 ++++----- tests/vb20_misc_tests.c | 119 ++++---- tests/vb20_verify_fw.c | 32 +- tests/vb21_api_tests.c | 96 +++--- tests/vb21_misc_tests.c | 111 ++++--- tests/vb2_api_tests.c | 291 +++++++++--------- tests/vb2_ec_sync_tests.c | 47 ++- tests/vb2_gbb_tests.c | 53 ++-- tests/vb2_keyblock_fuzzer.c | 13 +- tests/vb2_misc_tests.c | 536 ++++++++++++++++++++-------------- tests/vb2_nvstorage_tests.c | 176 +++++------ tests/vb2_preamble_fuzzer.c | 18 +- tests/vb2_secdata_firmware_tests.c | 93 +++--- tests/vb2_secdata_fwmp_tests.c | 92 +++--- tests/vb2_secdata_kernel_tests.c | 81 +++-- tests/vboot_api_devmode_tests.c | 14 +- tests/vboot_api_kernel2_tests.c | 294 +++++++++---------- tests/vboot_api_kernel4_tests.c | 13 +- tests/vboot_api_kernel_tests.c | 10 +- tests/vboot_detach_menu_tests.c | 352 +++++++++++----------- tests/vboot_display_tests.c | 48 ++- tests/vboot_kernel_tests.c | 43 ++- tests/verify_kernel.c | 32 +- utility/load_kernel_test.c | 33 +-- 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() */ @@ -425,6 +413,65 @@ enum vb2_pcr_digest { * writable this boot. */ +/** + * 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. * 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); } /** @@ -72,18 +76,6 @@ void vb2_set_workbuf_used(struct vb2_context *ctx, uint32_t used); 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. * 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 #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, ¶ms); + rv = LoadKernel(ctx, ¶ms); 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) { -- cgit v1.2.1