diff options
| author | Randall Spangler <rspangler@chromium.org> | 2017-11-27 15:37:13 -0800 |
|---|---|---|
| committer | chrome-bot <chrome-bot@chromium.org> | 2017-12-11 15:16:25 -0800 |
| commit | dff5852c2f41c240842b49549b212c36287d5e26 (patch) | |
| tree | 20f31422c7dd6868ce58b156634ab5290963acfc | |
| parent | 626340420e2ebc42f8f24b0b2c3d56cc73dc6e60 (diff) | |
| download | vboot-dff5852c2f41c240842b49549b212c36287d5e26.tar.gz | |
vboot: Use 2nvstorage instead of vboot_nvstorage
Remove the old vboot1 vboot_nvstorage library (VbNv*() functions) and
use the vboot2 library (vb2_nv_*()) instead. This is needed in
preparation for moving to 64-byte records; no sense in implementing
that change twice...
Should be (better be) no change in system behavior.
BUG=chromium:789276
BRANCH=none
TEST=make runtests
compare output of crossystem before/after change (should be identical)
Change-Id: I10f9975b0824263064b9a74a3c6daadcecc085d3
Signed-off-by: Randall Spangler <rspangler@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/794732
35 files changed, 413 insertions, 1549 deletions
@@ -32,8 +32,6 @@ VBINIT_SRCS = \ firmware/lib/utility.c \ firmware/lib/vboot_api_init.c \ firmware/lib/vboot_common_init.c \ - firmware/lib/vboot_nvstorage.c \ - firmware/lib/vboot_nvstorage_rollback.c \ firmware/lib/region-init.c \ # Additional firmware library sources needed by VbSelectFirmware() call @@ -320,7 +320,6 @@ BDBLIB = ${BUILD}/bdb.a # Firmware library sources needed by VbInit() call VBINIT_SRCS = \ firmware/lib/vboot_common_init.c \ - firmware/lib/vboot_nvstorage.c \ firmware/lib/region-init.c \ # Additional firmware library sources needed by VbSelectFirmware() call @@ -496,13 +495,13 @@ HOSTLIB_SRCS = \ cgpt/cgpt_create.c \ cgpt/cgpt_prioritize.c \ firmware/2lib/2crc8.c \ + firmware/2lib/2nvstorage.c \ firmware/2lib/2stub.c \ firmware/lib/cgptlib/cgptlib_internal.c \ firmware/lib/cgptlib/crc32.c \ firmware/lib/gpt_misc.c \ ${TLCL_SRCS} \ firmware/lib/utility_string.c \ - firmware/lib/vboot_nvstorage.c \ firmware/stub/tpm_lite_stub.c \ firmware/stub/vboot_api_stub.c \ firmware/stub/vboot_api_stub_disk.c \ @@ -736,7 +735,6 @@ TEST_NAMES = \ tests/vboot_common_tests \ tests/vboot_display_tests \ tests/vboot_kernel_tests \ - tests/vboot_nvstorage_test \ tests/verify_kernel ifeq (${TPM2_MODE},) @@ -1440,7 +1438,6 @@ endif ${RUNTEST} ${BUILD_RUN}/tests/vboot_common_tests ${RUNTEST} ${BUILD_RUN}/tests/vboot_display_tests ${RUNTEST} ${BUILD_RUN}/tests/vboot_kernel_tests - ${RUNTEST} ${BUILD_RUN}/tests/vboot_nvstorage_test .PHONY: run2tests run2tests: test_setup diff --git a/firmware/2lib/2nvstorage.c b/firmware/2lib/2nvstorage.c index 08363362..71a0dbb9 100644 --- a/firmware/2lib/2nvstorage.c +++ b/firmware/2lib/2nvstorage.c @@ -61,12 +61,24 @@ void vb2_nv_init(struct vb2_context *ctx) /* Regenerate CRC */ vb2_nv_regen_crc(ctx); - /* Set status flag */ - sd->status |= VB2_SD_STATUS_NV_REINIT; + /* + * Set status flag. + * + * Note that early in some calling sequences, shared data may + * not be available. For example, if there is an error + * allocating the context work buffer, and we're trying to + * initialize non-volatile storage so we can write a recovery + * request. In that case, sd will be NULL. So while we don't + * usually need to check for that in other library functions, + * here we do. + */ + if (sd) + sd->status |= VB2_SD_STATUS_NV_REINIT; /* TODO: unit test for status flag being set */ } - sd->status |= VB2_SD_STATUS_NV_INIT; + if (sd) + sd->status |= VB2_SD_STATUS_NV_INIT; } /* Macro for vb2_nv_get() single-bit settings to reduce duplicate code. */ diff --git a/firmware/2lib/include/2nvstorage.h b/firmware/2lib/include/2nvstorage.h index e3226a58..1a654691 100644 --- a/firmware/2lib/include/2nvstorage.h +++ b/firmware/2lib/include/2nvstorage.h @@ -8,6 +8,8 @@ #ifndef VBOOT_REFERENCE_VBOOT_2NVSTORAGE_H_ #define VBOOT_REFERENCE_VBOOT_2NVSTORAGE_H_ +struct vb2_context; + enum vb2_nv_param { /* * Parameter values have been reset to defaults (flag for firmware). @@ -149,6 +151,16 @@ int vb2_nv_check_crc(const struct vb2_context *ctx); /** * Initialize the non-volatile storage context and verify its CRC. * + * This may be called before vb2_context_init(), as long as: + * + * 1) The ctx structure has been cleared to 0. + * 2) Existing non-volatile data, if any, has been stored to ctx->nvdata[]. + * + * This is to support using the non-volatile storage functions to request + * recovery if there is an error allocating the workbuf for the context. It + * also allows host-side code to use this library without setting up a bunch of + * extra context. + * * @param ctx Context pointer */ void vb2_nv_init(struct vb2_context *ctx); @@ -156,6 +168,8 @@ void vb2_nv_init(struct vb2_context *ctx); /** * Read a non-volatile value. * + * Valid only after calling vb2_nv_init(). + * * @param ctx Context pointer * @param param Parameter to read * @return The value of the parameter. If you somehow force an invalid @@ -166,7 +180,9 @@ uint32_t vb2_nv_get(struct vb2_context *ctx, enum vb2_nv_param param); /** * Write a non-volatile value. * - * Ignores writes to unknown params. + * Ignores writes to unknown params. Valid only after calling vb2_nv_init(). + * If this changes ctx->nvdata[], it will set VB2_CONTEXT_NVDATA_CHANGED in + * ctx->flags. * * @param ctx Context pointer * @param param Parameter to write diff --git a/firmware/2lib/include/2recovery_reasons.h b/firmware/2lib/include/2recovery_reasons.h index 21509298..0b978edd 100644 --- a/firmware/2lib/include/2recovery_reasons.h +++ b/firmware/2lib/include/2recovery_reasons.h @@ -48,6 +48,14 @@ enum vb2_nv_recovery { /* Test error from LoadFirmware() (deprecated) */ VB2_RECOVERY_RO_TEST_LF = 0x09, + /* + * RW firmware failed signature check (neither RW firmware slot was + * valid). Recovery reason is VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + + * the check value for the slot which came closest to validating; see + * VBSD_LF_CHECK_* in vboot_struct.h. + */ + VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN = 0x10, + /* Latest tried RW firmware keyblock verification failed */ VB2_RECOVERY_FW_KEYBLOCK = 0x13, @@ -63,6 +71,9 @@ enum vb2_nv_recovery { /* Latest tried RW firmware body verification failed */ VB2_RECOVERY_FW_BODY = 0x1b, + /* Highest reason for failed RW firmware signature check */ + VB2_RECOVERY_RO_INVALID_RW_CHECK_MAX = 0x1f, + /* * Firmware boot failure outside of verified boot (RAM init, missing * SSD, etc.). diff --git a/firmware/include/vboot_nvstorage.h b/firmware/include/vboot_nvstorage.h deleted file mode 100644 index ecb5d007..00000000 --- a/firmware/include/vboot_nvstorage.h +++ /dev/null @@ -1,358 +0,0 @@ -/* Copyright (c) 2013 The Chromium OS Authors. All rights reserved. - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - */ - -/* Non-volatile storage routines for verified boot. */ - -#ifndef VBOOT_REFERENCE_NVSTORAGE_H_ -#define VBOOT_REFERENCE_NVSTORAGE_H_ -#include <stdint.h> - -#define VBNV_BLOCK_SIZE 16 /* Size of NV storage block in bytes */ - -typedef struct VbNvContext { - /* Raw NV data. Caller must fill this before calling VbNvSetup(). */ - uint8_t raw[VBNV_BLOCK_SIZE]; - /* - * Flag indicating whether raw data has changed. Set by VbNvTeardown() - * if the raw data has changed and needs to be stored to the underlying - * non-volatile data store. - */ - int raw_changed; - - /* - * Internal data for NV storage routines. Caller should not touch - * these fields. - */ - int regenerate_crc; -} VbNvContext; - -/* Parameter type for VbNvGet(), VbNvSet(). */ -typedef enum VbNvParam { - /* - * Parameter values have been reset to defaults (flag for firmware). - * 0=clear; 1=set. - */ - VBNV_FIRMWARE_SETTINGS_RESET = 0, - /* - * Parameter values have been reset to defaults (flag for kernel). - * 0=clear; 1=set. - */ - VBNV_KERNEL_SETTINGS_RESET, - /* Request debug reset on next S3->S0 transition. 0=clear; 1=set. */ - VBNV_DEBUG_RESET_MODE, - /* - * Number of times to try booting RW firmware slot B before slot A. - * Valid range: 0-15. - * - * Vboot2: Number of times to try the firmware in VBNV_FW_TRY_NEXT. - * - * These refer to the same field, but have different enum values so - * case statement don't complain about duplicates. - */ - VBNV_TRY_B_COUNT, - VBNV_FW_TRY_COUNT, - /* - * Request recovery mode on next boot; see VBNB_RECOVERY_* below for - * currently defined reason codes. 8-bit value. - */ - VBNV_RECOVERY_REQUEST, - /* - * Localization index for screen bitmaps displayed by firmware. - * 8-bit value. - */ - VBNV_LOCALIZATION_INDEX, - /* Field reserved for kernel/user-mode use; 32-bit value. */ - VBNV_KERNEL_FIELD, - /* Allow booting from USB in developer mode. 0=no, 1=yes. */ - VBNV_DEV_BOOT_USB, - /* Allow booting of legacy OSes in developer mode. 0=no, 1=yes. */ - VBNV_DEV_BOOT_LEGACY, - /* Only boot Google-signed images in developer mode. 0=no, 1=yes. */ - VBNV_DEV_BOOT_SIGNED_ONLY, - /* - * Allow full fastboot capability in firmware in developer mode. - * 0=no, 1=yes. - */ - VBNV_DEV_BOOT_FASTBOOT_FULL_CAP, - /* Set default boot mode (see VbDevDefaultBoot) */ - VBNV_DEV_DEFAULT_BOOT, - /* - * Set by userspace to request that RO firmware disable dev-mode on the - * next boot. This is likely only possible if the dev-switch is - * virtual. - */ - VBNV_DISABLE_DEV_REQUEST, - /* - * Set and cleared by vboot to request that the video Option ROM be - * loaded at boot time, so that BIOS screens can be displayed. 0=no, - * 1=yes. - */ - VBNV_OPROM_NEEDED, - /* Request that the firmware clear the TPM owner on the next boot. */ - VBNV_CLEAR_TPM_OWNER_REQUEST, - /* Flag that TPM owner was cleared on request. */ - VBNV_CLEAR_TPM_OWNER_DONE, - /* TPM requested a reboot */ - VBNV_TPM_REQUESTED_REBOOT, - /* More details on recovery reason */ - VBNV_RECOVERY_SUBCODE, - /* Request that NVRAM be backed up at next boot if possible. */ - VBNV_BACKUP_NVRAM_REQUEST, - - /* Vboot2: Firmware slot to try next. 0=A, 1=B */ - VBNV_FW_TRY_NEXT, - /* Vboot2: Firmware slot tried this boot (0=A, 1=B) */ - VBNV_FW_TRIED, - /* Vboot2: Result of trying that firmware (see vb2_fw_result) */ - VBNV_FW_RESULT, - /* Firmware slot tried previous boot (0=A, 1=B) */ - VBNV_FW_PREV_TRIED, - /* Result of trying that firmware (see vb2_fw_result) */ - VBNV_FW_PREV_RESULT, - /* Wipeout request from firmware present. */ - VBNV_FW_REQ_WIPEOUT, - - /* Fastboot: Unlock in firmware, 0=disabled, 1=enabled. */ - VBNV_FASTBOOT_UNLOCK_IN_FW, - /* Boot system when AC detected (0=no, 1=yes). */ - VBNV_BOOT_ON_AC_DETECT, - /* Try to update the EC-RO image (0=no, 1=yes). */ - VBNV_TRY_RO_SYNC, - /* - * Finish mode transition (if requested), perform battery cut-off and - * shutdown in next boot. - */ - VBNV_BATTERY_CUTOFF_REQUEST, - /* Maximum kernel version to roll forward to */ - VBNV_KERNEL_MAX_ROLLFORWARD, -} VbNvParam; - -/* Set default boot in developer mode */ -typedef enum VbDevDefaultBoot { - /* Default to boot from disk*/ - VBNV_DEV_DEFAULT_BOOT_DISK = 0, - - /* Default to boot from USB */ - VBNV_DEV_DEFAULT_BOOT_USB = 1, - - /* Default to boot legacy OS */ - VBNV_DEV_DEFAULT_BOOT_LEGACY = 2, - -} VbDevDefaultBoot; - -/* Result of trying the firmware in VBNV_FW_TRIED */ -typedef enum VbFwResult { - /* Unknown */ - VBNV_FW_RESULT_UNKNOWN = 0, - - /* Trying a new slot, but haven't reached success/failure */ - VBNV_FW_RESULT_TRYING = 1, - - /* Successfully booted to the OS */ - VBNV_FW_RESULT_SUCCESS = 2, - - /* Known failure */ - VBNV_FW_RESULT_FAILURE = 3, - -} VbFwResult; - -/* Recovery reason codes for VBNV_RECOVERY_REQUEST */ -/* Recovery not requested. */ -#define VBNV_RECOVERY_NOT_REQUESTED 0x00 -/* - * Recovery requested from legacy utility. (Prior to the NV storage spec, - * recovery mode was a single bitfield; this value is reserved so that scripts - * which wrote 1 to the recovery field are distinguishable from scripts whch - * use the recovery reasons listed here. - */ -#define VBNV_RECOVERY_LEGACY 0x01 -/* User manually requested recovery via recovery button */ -#define VBNV_RECOVERY_RO_MANUAL 0x02 -/* RW firmware failed signature check (neither RW firmware slot was valid) */ -#define VBNV_RECOVERY_RO_INVALID_RW 0x03 -/* S3 resume failed */ -#define VBNV_RECOVERY_RO_S3_RESUME 0x04 -/* TPM error in read-only firmware (deprecated) */ -#define VBNV_RECOVERY_DEP_RO_TPM_ERROR 0x05 -/* Shared data error in read-only firmware */ -#define VBNV_RECOVERY_RO_SHARED_DATA 0x06 -/* Test error from S3Resume() */ -#define VBNV_RECOVERY_RO_TEST_S3 0x07 -/* Test error from LoadFirmwareSetup() */ -#define VBNV_RECOVERY_RO_TEST_LFS 0x08 -/* Test error from LoadFirmware() */ -#define VBNV_RECOVERY_RO_TEST_LF 0x09 -/* - * RW firmware failed signature check (neither RW firmware slot was valid). - * Recovery reason is VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + the check value - * for the slot which came closest to validating; see VBSD_LF_CHECK_* in - * vboot_struct.h. - */ -#define VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN 0x10 -#define VBNV_RECOVERY_RO_INVALID_RW_CHECK_MAX 0x1F -/* - * Firmware boot failure outside of verified boot (RAM init, missing SSD, - * etc.). - */ -#define VBNV_RECOVERY_RO_FIRMWARE 0x20 -/* - * Recovery mode TPM initialization requires a system reboot. The system was - * already in recovery mode for some other reason when this happened. - */ -#define VBNV_RECOVERY_RO_TPM_REBOOT 0x21 -/* EC software sync - other error */ -#define VBNV_RECOVERY_EC_SOFTWARE_SYNC 0x22 -/* EC software sync - unable to determine active EC image */ -#define VBNV_RECOVERY_EC_UNKNOWN_IMAGE 0x23 -/* EC software sync - error obtaining EC image hash (deprecated) */ -#define VBNV_RECOVERY_DEP_EC_HASH 0x24 -/* EC software sync - error obtaining expected EC image */ -#define VBNV_RECOVERY_EC_EXPECTED_IMAGE 0x25 -/* EC software sync - error updating EC */ -#define VBNV_RECOVERY_EC_UPDATE 0x26 -/* EC software sync - unable to jump to EC-RW */ -#define VBNV_RECOVERY_EC_JUMP_RW 0x27 -/* EC software sync - unable to protect / unprotect EC-RW */ -#define VBNV_RECOVERY_EC_PROTECT 0x28 -/* EC software sync - error obtaining expected EC hash */ -#define VBNV_RECOVERY_EC_EXPECTED_HASH 0x29 -/* EC software sync - expected EC image doesn't match hash */ -#define VBNV_RECOVERY_EC_HASH_MISMATCH 0x2A -/* VB2: Secure data inititalization error */ -#define VBNV_RECOVERY_VB2_SECDATA_INIT 0x2B -/* VB2: GBB header is bad */ -#define VBNV_RECOVERY_VB2_GBB_HEADER 0x2C -/* VB2: Unable to clear TPM owner */ -#define VBNV_RECOVERY_VB2_TPM_CLEAR_OWNER 0x2D -/* VB2: Error determining/updating virtual dev switch */ -#define VBNV_RECOVERY_VB2_DEV_SWITCH 0x2E -/* VB2: Error determining firmware slot */ -#define VBNV_RECOVERY_VB2_FW_SLOT 0x2F -/* Unspecified/unknown error in read-only firmware */ -#define VBNV_RECOVERY_RO_UNSPECIFIED 0x3F -/* - * User manually requested recovery by pressing a key at developer - * warning screen - */ -#define VBNV_RECOVERY_RW_DEV_SCREEN 0x41 -/* No OS kernel detected */ -#define VBNV_RECOVERY_RW_NO_OS 0x42 -/* OS kernel failed signature check */ -#define VBNV_RECOVERY_RW_INVALID_OS 0x43 -/* TPM error in rewritable firmware (deprecated) */ -#define VBNV_RECOVERY_DEP_RW_TPM_ERROR 0x44 -/* RW firmware in dev mode, but dev switch is off */ -#define VBNV_RECOVERY_RW_DEV_MISMATCH 0x45 -/* Shared data error in rewritable firmware */ -#define VBNV_RECOVERY_RW_SHARED_DATA 0x46 -/* Test error from LoadKernel() */ -#define VBNV_RECOVERY_RW_TEST_LK 0x47 -/* No bootable disk found (deprecated)*/ -#define VBNV_RECOVERY_DEP_RW_NO_DISK 0x48 -/* Rebooting did not correct TPM_E_FAIL or TPM_E_FAILEDSELFTEST */ -#define VBNV_RECOVERY_TPM_E_FAIL 0x49 -/* TPM setup error in read-only firmware */ -#define VBNV_RECOVERY_RO_TPM_S_ERROR 0x50 -/* TPM write error in read-only firmware */ -#define VBNV_RECOVERY_RO_TPM_W_ERROR 0x51 -/* TPM lock error in read-only firmware */ -#define VBNV_RECOVERY_RO_TPM_L_ERROR 0x52 -/* TPM update error in read-only firmware */ -#define VBNV_RECOVERY_RO_TPM_U_ERROR 0x53 -/* TPM read error in rewritable firmware */ -#define VBNV_RECOVERY_RW_TPM_R_ERROR 0x54 -/* TPM write error in rewritable firmware */ -#define VBNV_RECOVERY_RW_TPM_W_ERROR 0x55 -/* TPM lock error in rewritable firmware */ -#define VBNV_RECOVERY_RW_TPM_L_ERROR 0x56 -/* EC software sync unable to get EC image hash */ -#define VBNV_RECOVERY_EC_HASH_FAILED 0x57 -/* EC software sync invalid image hash size */ -#define VBNV_RECOVERY_EC_HASH_SIZE 0x58 -/* Unspecified error while trying to load kernel */ -#define VBNV_RECOVERY_LK_UNSPECIFIED 0x59 -/* No bootable storage device in system */ -#define VBNV_RECOVERY_RW_NO_DISK 0x5A -/* No bootable kernel found on disk */ -#define VBNV_RECOVERY_RW_NO_KERNEL 0x5B -/* BCB-related error in RW firmware */ -#define VBNV_RECOVERY_RW_BCB_ERROR 0x5C -/* Fastboot mode requested in firmware */ -#define VBNV_RECOVERY_FW_FASTBOOT 0x5E -/* Recovery hash space lock error in RO firmware */ -#define VBNV_RECOVERY_RO_TPM_REC_HASH_L_ERROR 0x5F -/* Unspecified/unknown error in rewritable firmware */ -#define VBNV_RECOVERY_RW_UNSPECIFIED 0x7F -/* DM-verity error */ -#define VBNV_RECOVERY_KE_DM_VERITY 0x81 -/* Unspecified/unknown error in kernel */ -#define VBNV_RECOVERY_KE_UNSPECIFIED 0xBF -/* Recovery mode test from user-mode */ -#define VBNV_RECOVERY_US_TEST 0xC1 -/* Recovery requested by user-mode via BCB */ -#define VBNV_RECOVERY_BCB_USER_MODE 0xC2 -/* Fastboot mode requested by user-mode */ -#define VBNV_RECOVERY_US_FASTBOOT 0xC3 -/* User requested recovery for training memory and rebooting. */ -#define VBNV_RECOVERY_TRAIN_AND_REBOOT 0xC4 -/* Unspecified/unknown error in user-mode */ -#define VBNV_RECOVERY_US_UNSPECIFIED 0xFF - -/** - * Initialize the NV storage library. - * - * This must be called before any other functions in this library. Returns 0 - * if success, non-zero if error. - * - * Proper calling procedure: - * 1) Allocate a context struct. - * 2) If multi-threaded/multi-process, acquire a lock to prevent - * other processes from modifying the underlying storage. - * 3) Read underlying storage and fill in context->raw. - * 4) Call VbNvSetup(). - * - * If you have access to global variables, you may want to wrap all that in - * your own VbNvOpen() function. We don't do that in here because there are no - * global variables in UEFI BIOS during the PEI phase (that's also why we have - * to pass around a context pointer). - */ -int VbNvSetup(VbNvContext *context); - -/** - * Clean up and flush changes back to the raw data. - * - * This must be called after other functions in this library. Returns 0 if - * success, non-zero if error. - * - * Proper calling procedure: - * 1) Call VbNvExit(). - * 2) If context.raw_changed, write data back to underlying storage. - * 3) Release any lock you acquired before calling VbNvSetup(). - * 4) Free the context struct. - * - * If you have access to global variables, you may want to wrap this - * in your own VbNvClose() function. - */ -int VbNvTeardown(VbNvContext *context); - -/** - * Read a NV storage parameter into *dest. - * - * Returns 0 if success, non-zero if error. - * - * This may only be called between VbNvSetup() and VbNvTeardown(). - */ -int VbNvGet(VbNvContext *context, VbNvParam param, uint32_t *dest); - -/** - * Set a NV storage param to a new value. - * - * Returns 0 if success, non-zero if error. - * - * This may only be called between VbNvSetup() and VbNvTeardown(). - */ -int VbNvSet(VbNvContext *context, VbNvParam param, uint32_t value); - -#endif /* VBOOT_REFERENCE_NVSTORAGE_H_ */ diff --git a/firmware/lib/include/load_kernel_fw.h b/firmware/lib/include/load_kernel_fw.h index ca49b3c6..08e55787 100644 --- a/firmware/lib/include/load_kernel_fw.h +++ b/firmware/lib/include/load_kernel_fw.h @@ -10,7 +10,6 @@ #define VBOOT_REFERENCE_LOAD_KERNEL_FW_H_ #include "vboot_api.h" -#include "vboot_nvstorage.h" struct vb2_context; @@ -38,11 +37,6 @@ typedef struct LoadKernelParams { uint64_t kernel_buffer_size; /* Boot flags */ uint64_t boot_flags; - /* - * Context for NV storage. Caller is responsible for calling - * VbNvSetup() and VbNvTeardown() on the context. - */ - VbNvContext *nv_context; /* Firmware management parameters; may be NULL if not present. */ const struct RollbackSpaceFwmp *fwmp; diff --git a/firmware/lib/include/vboot_display.h b/firmware/lib/include/vboot_display.h index 2f237533..fbb04e13 100644 --- a/firmware/lib/include/vboot_display.h +++ b/firmware/lib/include/vboot_display.h @@ -9,8 +9,6 @@ #define VBOOT_REFERENCE_VBOOT_DISPLAY_H_ #include "bmpblk_font.h" -#include "vboot_api.h" -#include "vboot_nvstorage.h" struct vb2_context; diff --git a/firmware/lib/vboot_api_kernel.c b/firmware/lib/vboot_api_kernel.c index 1879b845..26d32d55 100644 --- a/firmware/lib/vboot_api_kernel.c +++ b/firmware/lib/vboot_api_kernel.c @@ -23,10 +23,8 @@ #include "vboot_api.h" #include "vboot_common.h" #include "vboot_kernel.h" -#include "vboot_nvstorage.h" /* Global variables */ -static VbNvContext vnc; static struct RollbackSpaceFwmp fwmp; static LoadKernelParams lkp; static struct vb2_context ctx; @@ -57,29 +55,14 @@ static void VbSetRecoveryRequest(struct vb2_context *ctx, vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, recovery_request); } -static void VbNvLoad(void) -{ - VbExNvStorageRead(vnc.raw); - VbNvSetup(&vnc); -} - -static void VbNvCommit(void) -{ - VbNvTeardown(&vnc); - if (vnc.raw_changed) - VbExNvStorageWrite(vnc.raw); -} - void vb2_nv_commit(struct vb2_context *ctx) { - /* Copy nvdata back to old vboot1 nv context if needed */ - if (ctx->flags & VB2_CONTEXT_NVDATA_CHANGED) { - memcpy(vnc.raw, ctx->nvdata, VB2_NVDATA_SIZE); - vnc.raw_changed = 1; - ctx->flags &= ~VB2_CONTEXT_NVDATA_CHANGED; - } + /* Exit if nothing has changed */ + if (!(ctx->flags & VB2_CONTEXT_NVDATA_CHANGED)) + return; - VbNvCommit(); + ctx->flags &= ~VB2_CONTEXT_NVDATA_CHANGED; + VbExNvStorageWrite(ctx->nvdata); } uint32_t vb2_get_fwmp_flags(void) @@ -112,7 +95,6 @@ uint32_t VbTryLoadKernel(struct vb2_context *ctx, VbCommonParams *cparams, (unsigned)get_info_flags); lkp.fwmp = &fwmp; - lkp.nv_context = &vnc; lkp.disk_handle = NULL; /* Find disks */ @@ -122,7 +104,7 @@ uint32_t VbTryLoadKernel(struct vb2_context *ctx, VbCommonParams *cparams, VB2_DEBUG("VbTryLoadKernel() found %d disks\n", (int)disk_count); if (0 == disk_count) { - VbSetRecoveryRequest(ctx, VBNV_RECOVERY_RW_NO_DISK); + VbSetRecoveryRequest(ctx, VB2_RECOVERY_RW_NO_DISK); return VBERROR_NO_DISK_FOUND; } @@ -171,7 +153,7 @@ uint32_t VbTryLoadKernel(struct vb2_context *ctx, VbCommonParams *cparams, /* If we didn't find any good kernels, don't return a disk handle. */ if (VBERROR_SUCCESS != retval) { - VbSetRecoveryRequest(ctx, VBNV_RECOVERY_RW_NO_KERNEL); + VbSetRecoveryRequest(ctx, VB2_RECOVERY_RW_NO_KERNEL); lkp.disk_handle = NULL; } @@ -188,7 +170,8 @@ VbError_t VbBootNormal(struct vb2_context *ctx, VbCommonParams *cparams) { VbSharedDataHeader *shared = (VbSharedDataHeader *)cparams->shared_data_blob; - uint32_t max_rollforward; + uint32_t max_rollforward = vb2_nv_get(ctx, + VB2_NV_KERNEL_MAX_ROLLFORWARD); /* Boot from fixed disk only */ VB2_DEBUG("Entering\n"); @@ -219,35 +202,32 @@ VbError_t VbBootNormal(struct vb2_context *ctx, VbCommonParams *cparams) */ if (rv == VBERROR_INVALID_KERNEL_FOUND) { VB2_DEBUG("Trying FW B; only found invalid kernels.\n"); - VbSetRecoveryRequest(ctx, VBNV_RECOVERY_NOT_REQUESTED); + VbSetRecoveryRequest(ctx, VB2_RECOVERY_NOT_REQUESTED); } return rv; } - /* Limit kernel version rollforward if needed */ - if (0 == VbNvGet(&vnc, VBNV_KERNEL_MAX_ROLLFORWARD, &max_rollforward)) { - /* - * Can't limit kernel version to less than the version - * currently in the TPM. That is, we're limiting rollforward, - * not allowing rollback. - */ - if (max_rollforward < shared->kernel_version_tpm_start) - max_rollforward = shared->kernel_version_tpm_start; + /* + * Limit kernel version rollforward if needed. Can't limit kernel + * version to less than the version currently in the TPM. That is, + * we're limiting rollforward, not allowing rollback. + */ + if (max_rollforward < shared->kernel_version_tpm_start) + max_rollforward = shared->kernel_version_tpm_start; - if (shared->kernel_version_tpm > max_rollforward) { - VB2_DEBUG("Limiting TPM kernel version roll-forward " - "to 0x%x < 0x%x\n", - max_rollforward, shared->kernel_version_tpm); + if (shared->kernel_version_tpm > max_rollforward) { + VB2_DEBUG("Limiting TPM kernel version roll-forward " + "to 0x%x < 0x%x\n", + max_rollforward, shared->kernel_version_tpm); - shared->kernel_version_tpm = max_rollforward; - } + shared->kernel_version_tpm = max_rollforward; } if ((shared->kernel_version_tpm > shared->kernel_version_tpm_start) && RollbackKernelWrite(shared->kernel_version_tpm)) { VB2_DEBUG("Error writing kernel versions to TPM.\n"); - VbSetRecoveryRequest(ctx, VBNV_RECOVERY_RW_TPM_W_ERROR); + VbSetRecoveryRequest(ctx, VB2_RECOVERY_RW_TPM_W_ERROR); return VBERROR_TPM_WRITE_KERNEL; } @@ -285,8 +265,8 @@ static VbError_t vb2_kernel_setup(VbCommonParams *cparams, */ memset(&ctx, 0, sizeof(ctx)); - VbNvLoad(); - memcpy(ctx.nvdata, vnc.raw, VB2_NVDATA_SIZE); + VbExNvStorageRead(ctx.nvdata); + vb2_nv_init(&ctx); if (shared->recovery_reason) ctx.flags |= VB2_CONTEXT_RECOVERY_MODE; @@ -325,7 +305,7 @@ static VbError_t vb2_kernel_setup(VbCommonParams *cparams, * If we're in recovery mode just to do memory retraining, all we * need to do is reboot. */ - if (shared->recovery_reason == VBNV_RECOVERY_TRAIN_AND_REBOOT) { + if (shared->recovery_reason == VB2_RECOVERY_TRAIN_AND_REBOOT) { VB2_DEBUG("Reboot after retraining in recovery.\n"); return VBERROR_REBOOT_REQUIRED; } @@ -355,7 +335,7 @@ static VbError_t vb2_kernel_setup(VbCommonParams *cparams, VB2_DEBUG("Unable to get kernel versions from TPM\n"); if (!shared->recovery_reason) { VbSetRecoveryRequest(&ctx, - VBNV_RECOVERY_RW_TPM_R_ERROR); + VB2_RECOVERY_RW_TPM_R_ERROR); return VBERROR_TPM_READ_KERNEL; } } @@ -369,7 +349,7 @@ static VbError_t vb2_kernel_setup(VbCommonParams *cparams, VB2_DEBUG("Unable to get FWMP from TPM\n"); if (!shared->recovery_reason) { VbSetRecoveryRequest(&ctx, - VBNV_RECOVERY_RW_TPM_R_ERROR); + VB2_RECOVERY_RW_TPM_R_ERROR); return VBERROR_TPM_READ_FWMP; } } @@ -398,7 +378,7 @@ static VbError_t vb2_kernel_phase4(VbCommonParams *cparams, if (!shared->recovery_reason && RollbackKernelLock(shared->recovery_reason)) { VB2_DEBUG("Error locking kernel versions.\n"); - VbSetRecoveryRequest(&ctx, VBNV_RECOVERY_RW_TPM_L_ERROR); + VbSetRecoveryRequest(&ctx, VB2_RECOVERY_RW_TPM_L_ERROR); return VBERROR_TPM_LOCK_KERNEL; } @@ -484,7 +464,6 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams, void *boot_image, size_t image_size) { - VbError_t retval; VbPublicKey* kernel_subkey = NULL; uint8_t *kbuf; VbKeyBlockHeader *key_block; @@ -495,31 +474,19 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams, int hash_only = 0; int dev_switch; uint32_t allow_fastboot_full_cap = 0; - uint8_t *workbuf = NULL; struct vb2_workbuf wb; - if ((boot_image == NULL) || (image_size == 0)) - return VBERROR_INVALID_PARAMETER; + VbError_t retval = vb2_kernel_setup(cparams, kparams); + if (retval) + goto fail; - /* Clear output params in case we fail. */ - kparams->disk_handle = NULL; - kparams->partition_number = 0; - kparams->bootloader_address = 0; - kparams->bootloader_size = 0; - kparams->flags = 0; - memset(kparams->partition_guid, 0, sizeof(kparams->partition_guid)); + if ((boot_image == NULL) || (image_size == 0)) { + retval = VBERROR_INVALID_PARAMETER; + goto fail; + } kbuf = boot_image; - /* Read GBB Header */ - cparams->bmp = NULL; - cparams->gbb = malloc(sizeof(*cparams->gbb)); - retval = VbGbbReadHeader_static(cparams, cparams->gbb); - if (VBERROR_SUCCESS != retval) { - VB2_DEBUG("Gbb read header failed.\n"); - return retval; - } - /* * We don't care verifying the image if: * 1. dev-mode switch is on and @@ -529,10 +496,8 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams, * Check only the integrity of the image. */ dev_switch = shared->flags & VBSD_BOOT_DEV_SWITCH_ON; - - VbNvLoad(); - VbNvGet(&vnc, VBNV_DEV_BOOT_FASTBOOT_FULL_CAP, - &allow_fastboot_full_cap); + allow_fastboot_full_cap = + vb2_nv_get(&ctx, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP); if (0 == allow_fastboot_full_cap) { allow_fastboot_full_cap = !!(cparams->gbb->flags & @@ -547,7 +512,7 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams, retval = VbGbbReadRecoveryKey(cparams, &kernel_subkey); if (VBERROR_SUCCESS != retval) { VB2_DEBUG("Gbb Read Recovery key failed.\n"); - return retval; + goto fail; } } @@ -555,10 +520,7 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams, retval = VBERROR_INVALID_KERNEL_FOUND; /* Allocate work buffer */ - workbuf = (uint8_t *)malloc(VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE); - if (!workbuf) - goto fail; - vb2_workbuf_init(&wb, workbuf, VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE); + vb2_workbuf_from_ctx(&ctx, &wb); /* Verify the key block. */ key_block = (VbKeyBlockHeader *)kbuf; @@ -647,11 +609,9 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams, retval = VBERROR_SUCCESS; fail: - VbApiKernelFree(cparams); + vb2_kernel_cleanup(&ctx, cparams); if (NULL != kernel_subkey) free(kernel_subkey); - if (NULL != workbuf) - free(workbuf); return retval; } @@ -667,12 +627,13 @@ VbError_t VbUnlockDevice(void) VbError_t VbLockDevice(void) { - VbNvLoad(); - VB2_DEBUG("Storing request to leave dev-mode.\n"); - VbNvSet(&vnc, VBNV_DISABLE_DEV_REQUEST, 1); - VbNvCommit(); + memset(&ctx, 0, sizeof(ctx)); + VbExNvStorageRead(ctx.nvdata); + vb2_nv_init(&ctx); + vb2_nv_set(&ctx, VB2_NV_DISABLE_DEV_REQUEST, 1); + vb2_nv_commit(&ctx); VB2_DEBUG("Mode change will take effect on next reboot.\n"); diff --git a/firmware/lib/vboot_display.c b/firmware/lib/vboot_display.c index 24ac0725..7bf341e1 100644 --- a/firmware/lib/vboot_display.c +++ b/firmware/lib/vboot_display.c @@ -19,7 +19,6 @@ #include "vboot_api.h" #include "vboot_common.h" #include "vboot_display.h" -#include "vboot_nvstorage.h" static uint32_t disp_current_screen = VB_SCREEN_BLANK; static uint32_t disp_current_index = 0; @@ -442,154 +441,154 @@ static void FillInSha1Sum(char *outbuf, VbPublicKey *key) const char *RecoveryReasonString(uint8_t code) { switch(code) { - case VBNV_RECOVERY_NOT_REQUESTED: + case VB2_RECOVERY_NOT_REQUESTED: return "Recovery not requested"; - case VBNV_RECOVERY_LEGACY: + case VB2_RECOVERY_LEGACY: return "Recovery requested from legacy utility"; - case VBNV_RECOVERY_RO_MANUAL: + case VB2_RECOVERY_RO_MANUAL: return "recovery button pressed"; - case VBNV_RECOVERY_RO_INVALID_RW: + case VB2_RECOVERY_RO_INVALID_RW: return "RW firmware failed signature check"; - case VBNV_RECOVERY_RO_S3_RESUME: + case VB2_RECOVERY_RO_S3_RESUME: return "S3 resume failed"; - case VBNV_RECOVERY_DEP_RO_TPM_ERROR: + case VB2_RECOVERY_DEP_RO_TPM_ERROR: return "TPM error in read-only firmware"; - case VBNV_RECOVERY_RO_SHARED_DATA: + case VB2_RECOVERY_RO_SHARED_DATA: return "Shared data error in read-only firmware"; - case VBNV_RECOVERY_RO_TEST_S3: + case VB2_RECOVERY_RO_TEST_S3: return "Test error from S3Resume()"; - case VBNV_RECOVERY_RO_TEST_LFS: + case VB2_RECOVERY_RO_TEST_LFS: return "Test error from LoadFirmwareSetup()"; - case VBNV_RECOVERY_RO_TEST_LF: + case VB2_RECOVERY_RO_TEST_LF: return "Test error from LoadFirmware()"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_NOT_DONE: + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_NOT_DONE: return "RW firmware check not done"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_DEV_MISMATCH: + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_DEV_MISMATCH: return "RW firmware developer flag mismatch"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_REC_MISMATCH: + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_REC_MISMATCH: return "RW firmware recovery flag mismatch"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_VERIFY_KEYBLOCK: return "RW firmware unable to verify key block"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_KEY_ROLLBACK: + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_KEY_ROLLBACK: return "RW firmware key version rollback detected"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_DATA_KEY_PARSE: return "RW firmware unable to parse data key"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_VERIFY_PREAMBLE: return "RW firmware unable to verify preamble"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_FW_ROLLBACK: + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_FW_ROLLBACK: return "RW firmware version rollback detected"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_GET_FW_BODY: + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_GET_FW_BODY: return "RW firmware unable to get firmware body"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_HASH_WRONG_SIZE: return "RW firmware hash is wrong size"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_VERIFY_BODY: + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_VERIFY_BODY: return "RW firmware unable to verify firmware body"; - case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_NO_RO_NORMAL: + case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_NO_RO_NORMAL: return "RW firmware read-only normal path is not supported"; - case VBNV_RECOVERY_RO_FIRMWARE: + case VB2_RECOVERY_RO_FIRMWARE: return "Firmware problem outside of verified boot"; - case VBNV_RECOVERY_RO_TPM_REBOOT: + case VB2_RECOVERY_RO_TPM_REBOOT: return "TPM requires a system reboot (should be transient)"; - case VBNV_RECOVERY_EC_SOFTWARE_SYNC: + case VB2_RECOVERY_EC_SOFTWARE_SYNC: return "EC software sync error"; - case VBNV_RECOVERY_EC_UNKNOWN_IMAGE: + case VB2_RECOVERY_EC_UNKNOWN_IMAGE: return "EC software sync unable to determine active EC image"; - case VBNV_RECOVERY_DEP_EC_HASH: + case VB2_RECOVERY_DEP_EC_HASH: return "EC software sync error obtaining EC image hash"; - case VBNV_RECOVERY_EC_EXPECTED_IMAGE: + case VB2_RECOVERY_EC_EXPECTED_IMAGE: return "EC software sync error " "obtaining expected EC image from BIOS"; - case VBNV_RECOVERY_EC_EXPECTED_HASH: + case VB2_RECOVERY_EC_EXPECTED_HASH: return "EC software sync error " "obtaining expected EC hash from BIOS"; - case VBNV_RECOVERY_EC_HASH_MISMATCH: + case VB2_RECOVERY_EC_HASH_MISMATCH: return "EC software sync error " "comparing expected EC hash and image"; - case VBNV_RECOVERY_EC_UPDATE: + case VB2_RECOVERY_EC_UPDATE: return "EC software sync error updating EC"; - case VBNV_RECOVERY_EC_JUMP_RW: + case VB2_RECOVERY_EC_JUMP_RW: return "EC software sync unable to jump to EC-RW"; - case VBNV_RECOVERY_EC_PROTECT: + case VB2_RECOVERY_EC_PROTECT: return "EC software sync protection error"; - case VBNV_RECOVERY_VB2_SECDATA_INIT: + case VB2_RECOVERY_SECDATA_INIT: return "Secure NVRAM (TPM) initialization error"; - case VBNV_RECOVERY_VB2_GBB_HEADER: + case VB2_RECOVERY_GBB_HEADER: return "Error parsing GBB header"; - case VBNV_RECOVERY_VB2_TPM_CLEAR_OWNER: + case VB2_RECOVERY_TPM_CLEAR_OWNER: return "Error trying to clear TPM owner"; - case VBNV_RECOVERY_VB2_DEV_SWITCH: + case VB2_RECOVERY_DEV_SWITCH: return "Error reading or updating developer switch"; - case VBNV_RECOVERY_VB2_FW_SLOT: + case VB2_RECOVERY_FW_SLOT: return "Error selecting RW firmware slot"; - case VBNV_RECOVERY_RO_UNSPECIFIED: + case VB2_RECOVERY_RO_UNSPECIFIED: return "Unspecified/unknown error in RO firmware"; - case VBNV_RECOVERY_RW_DEV_SCREEN: + case VB2_RECOVERY_RW_DEV_SCREEN: return "User requested recovery from dev-mode warning screen"; - case VBNV_RECOVERY_RW_NO_OS: + case VB2_RECOVERY_RW_NO_OS: return "No OS kernel detected (or kernel rollback attempt?)"; - case VBNV_RECOVERY_RW_INVALID_OS: + case VB2_RECOVERY_RW_INVALID_OS: return "OS kernel failed signature check"; - case VBNV_RECOVERY_DEP_RW_TPM_ERROR: + case VB2_RECOVERY_DEP_RW_TPM_ERROR: return "TPM error in rewritable firmware"; - case VBNV_RECOVERY_RW_DEV_MISMATCH: + case VB2_RECOVERY_RW_DEV_MISMATCH: return "RW firmware in dev mode, but dev switch is off"; - case VBNV_RECOVERY_RW_SHARED_DATA: + case VB2_RECOVERY_RW_SHARED_DATA: return "Shared data error in rewritable firmware"; - case VBNV_RECOVERY_RW_TEST_LK: + case VB2_RECOVERY_RW_TEST_LK: return "Test error from LoadKernel()"; - case VBNV_RECOVERY_DEP_RW_NO_DISK: + case VB2_RECOVERY_DEP_RW_NO_DISK: return "No bootable disk found"; - case VBNV_RECOVERY_TPM_E_FAIL: + case VB2_RECOVERY_TPM_E_FAIL: return "TPM error that was not fixed by reboot"; - case VBNV_RECOVERY_RO_TPM_S_ERROR: + case VB2_RECOVERY_RO_TPM_S_ERROR: return "TPM setup error in read-only firmware"; - case VBNV_RECOVERY_RO_TPM_W_ERROR: + case VB2_RECOVERY_RO_TPM_W_ERROR: return "TPM write error in read-only firmware"; - case VBNV_RECOVERY_RO_TPM_L_ERROR: + case VB2_RECOVERY_RO_TPM_L_ERROR: return "TPM lock error in read-only firmware"; - case VBNV_RECOVERY_RO_TPM_U_ERROR: + case VB2_RECOVERY_RO_TPM_U_ERROR: return "TPM update error in read-only firmware"; - case VBNV_RECOVERY_RW_TPM_R_ERROR: + case VB2_RECOVERY_RW_TPM_R_ERROR: return "TPM read error in rewritable firmware"; - case VBNV_RECOVERY_RW_TPM_W_ERROR: + case VB2_RECOVERY_RW_TPM_W_ERROR: return "TPM write error in rewritable firmware"; - case VBNV_RECOVERY_RW_TPM_L_ERROR: + case VB2_RECOVERY_RW_TPM_L_ERROR: return "TPM lock error in rewritable firmware"; - case VBNV_RECOVERY_EC_HASH_FAILED: + case VB2_RECOVERY_EC_HASH_FAILED: return "EC software sync unable to get EC image hash"; - case VBNV_RECOVERY_EC_HASH_SIZE: + case VB2_RECOVERY_EC_HASH_SIZE: return "EC software sync invalid image hash size"; - case VBNV_RECOVERY_LK_UNSPECIFIED: + case VB2_RECOVERY_LK_UNSPECIFIED: return "Unspecified error while trying to load kernel"; - case VBNV_RECOVERY_RW_NO_DISK: + case VB2_RECOVERY_RW_NO_DISK: return "No bootable storage device in system"; - case VBNV_RECOVERY_RW_NO_KERNEL: + case VB2_RECOVERY_RW_NO_KERNEL: return "No bootable kernel found on disk"; - case VBNV_RECOVERY_RW_BCB_ERROR: + case VB2_RECOVERY_RW_BCB_ERROR: return "BCB partition error on disk"; - case VBNV_RECOVERY_FW_FASTBOOT: + case VB2_RECOVERY_FW_FASTBOOT: return "Fastboot-mode requested in firmware"; - case VBNV_RECOVERY_RO_TPM_REC_HASH_L_ERROR: + case VB2_RECOVERY_RO_TPM_REC_HASH_L_ERROR: return "Recovery hash space lock error in RO firmware"; - case VBNV_RECOVERY_RW_UNSPECIFIED: + case VB2_RECOVERY_RW_UNSPECIFIED: return "Unspecified/unknown error in RW firmware"; - case VBNV_RECOVERY_KE_DM_VERITY: + case VB2_RECOVERY_KE_DM_VERITY: return "DM-verity error"; - case VBNV_RECOVERY_KE_UNSPECIFIED: + case VB2_RECOVERY_KE_UNSPECIFIED: return "Unspecified/unknown error in kernel"; - case VBNV_RECOVERY_US_TEST: + case VB2_RECOVERY_US_TEST: return "Recovery mode test from user-mode"; - case VBNV_RECOVERY_BCB_USER_MODE: + case VB2_RECOVERY_BCB_USER_MODE: return "User-mode requested recovery via BCB"; - case VBNV_RECOVERY_US_FASTBOOT: + case VB2_RECOVERY_US_FASTBOOT: return "User-mode requested fastboot mode"; - case VBNV_RECOVERY_TRAIN_AND_REBOOT: + case VB2_RECOVERY_TRAIN_AND_REBOOT: return "User-mode requested DRAM train and reboot"; - case VBNV_RECOVERY_US_UNSPECIFIED: + case VB2_RECOVERY_US_UNSPECIFIED: return "Unspecified/unknown error in user-mode"; } return "We have no idea what this means"; diff --git a/firmware/lib/vboot_kernel.c b/firmware/lib/vboot_kernel.c index 20272448..c5030ef8 100644 --- a/firmware/lib/vboot_kernel.c +++ b/firmware/lib/vboot_kernel.c @@ -438,7 +438,7 @@ VbError_t LoadKernel(struct vb2_context *ctx, LoadKernelParams *params, uint32_t lowest_version = LOWEST_TPM_VERSION; VbError_t retval = VBERROR_UNKNOWN; - int recovery = VBNV_RECOVERY_LK_UNSPECIFIED; + int recovery = VB2_RECOVERY_LK_UNSPECIFIED; /* Clear output params in case we fail */ params->partition_number = 0; @@ -644,11 +644,11 @@ gpt_done: retval = VBERROR_SUCCESS; } else if (found_partitions > 0) { shcall->check_result = VBSD_LKC_CHECK_INVALID_PARTITIONS; - recovery = VBNV_RECOVERY_RW_INVALID_OS; + recovery = VB2_RECOVERY_RW_INVALID_OS; retval = VBERROR_INVALID_KERNEL_FOUND; } else { shcall->check_result = VBSD_LKC_CHECK_NO_PARTITIONS; - recovery = VBNV_RECOVERY_RW_NO_OS; + recovery = VB2_RECOVERY_RW_NO_OS; retval = VBERROR_NO_KERNEL_FOUND; } @@ -656,7 +656,7 @@ load_kernel_exit: /* Store recovery request, if any */ vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, VBERROR_SUCCESS != retval ? - recovery : VBNV_RECOVERY_NOT_REQUESTED); + recovery : VB2_RECOVERY_NOT_REQUESTED); /* Store how much shared data we used, if any */ cparams->shared_data_size = shared->data_used; diff --git a/firmware/lib/vboot_nvstorage.c b/firmware/lib/vboot_nvstorage.c deleted file mode 100644 index 9dc9dc3d..00000000 --- a/firmware/lib/vboot_nvstorage.c +++ /dev/null @@ -1,496 +0,0 @@ -/* Copyright (c) 2013 The Chromium OS Authors. All rights reserved. - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - */ - -/* Non-volatile storage routines. - */ -#include "sysincludes.h" - -#include "2crc8.h" -#include "utility.h" -#include "vboot_common.h" -#include "vboot_nvstorage.h" - -/* - * Constants for NV storage. We use this rather than structs and bitfields so - * the data format is consistent across platforms and compilers. - * - * These constants must match the equivalent constants in 2lib/2nvstorage.c. - * (We currently don't share a common header file because we're tring to keep - * the two libs independent, and we hope to deprecate this one.) - */ -#define HEADER_OFFSET 0 -#define HEADER_MASK 0xC0 -#define HEADER_SIGNATURE 0x40 -#define HEADER_FIRMWARE_SETTINGS_RESET 0x20 -#define HEADER_KERNEL_SETTINGS_RESET 0x10 -#define HEADER_WIPEOUT 0x08 - -#define BOOT_OFFSET 1 -#define BOOT_DEBUG_RESET_MODE 0x80 -#define BOOT_DISABLE_DEV_REQUEST 0x40 -#define BOOT_OPROM_NEEDED 0x20 -#define BOOT_BACKUP_NVRAM 0x10 -#define BOOT_TRY_B_COUNT_MASK 0x0F - -#define RECOVERY_OFFSET 2 -#define LOCALIZATION_OFFSET 3 - -#define DEV_FLAGS_OFFSET 4 -#define DEV_BOOT_USB_MASK 0x01 -#define DEV_BOOT_SIGNED_ONLY_MASK 0x02 -#define DEV_BOOT_LEGACY_MASK 0x04 -#define DEV_BOOT_FASTBOOT_FULL_CAP_MASK 0x08 -#define DEV_DEFAULT_BOOT_MASK 0x30 -#define DEV_DEFAULT_BOOT_SHIFT 4 /* Number of bits to shift */ - -#define TPM_FLAGS_OFFSET 5 -#define TPM_CLEAR_OWNER_REQUEST 0x01 -#define TPM_CLEAR_OWNER_DONE 0x02 -#define TPM_REBOOTED 0x04 - -#define RECOVERY_SUBCODE_OFFSET 6 - -#define BOOT2_OFFSET 7 -#define BOOT2_RESULT_MASK 0x03 -#define BOOT2_TRIED 0x04 -#define BOOT2_TRY_NEXT 0x08 -#define BOOT2_PREV_RESULT_MASK 0x30 -#define BOOT2_PREV_RESULT_SHIFT 4 /* Number of bits to shift result */ -#define BOOT2_PREV_TRIED 0x40 - -#define MISC_OFFSET 8 -#define MISC_UNLOCK_FASTBOOT 0x01 -#define MISC_BOOT_ON_AC_DETECT 0x02 -#define MISC_TRY_RO_SYNC 0x04 -#define MISC_BATTERY_CUTOFF_REQUEST 0x08 - -#define KERNEL_MAX_ROLLFORWARD1_OFFSET 9 /* Low bits */ -#define KERNEL_MAX_ROLLFORWARD2_OFFSET 10 -#define KERNEL_MAX_ROLLFORWARD3_OFFSET 13 -#define KERNEL_MAX_ROLLFORWARD4_OFFSET 14 /* High bits */ - -#define KERNEL_FIELD1_OFFSET 11 /* Low bits */ -#define KERNEL_FIELD2_OFFSET 12 /* Low bits */ - -#define CRC_OFFSET 15 - -int VbNvSetup(VbNvContext *context) -{ - uint8_t *raw = context->raw; - - /* Nothing has changed yet. */ - context->raw_changed = 0; - context->regenerate_crc = 0; - - /* Check data for consistency */ - if ((HEADER_SIGNATURE != (raw[HEADER_OFFSET] & HEADER_MASK)) - || (vb2_crc8(raw, CRC_OFFSET) != raw[CRC_OFFSET])) { - /* Data is inconsistent (bad CRC or header); reset defaults */ - memset(raw, 0, VBNV_BLOCK_SIZE); - raw[HEADER_OFFSET] = (HEADER_SIGNATURE | - HEADER_FIRMWARE_SETTINGS_RESET | - HEADER_KERNEL_SETTINGS_RESET); - - /* Regenerate CRC on exit */ - context->regenerate_crc = 1; - } - - return 0; -} - -int VbNvTeardown(VbNvContext *context) -{ - if (context->regenerate_crc) { - context->raw[CRC_OFFSET] = vb2_crc8(context->raw, CRC_OFFSET); - context->regenerate_crc = 0; - context->raw_changed = 1; - } - - return 0; -} - -int VbNvGet(VbNvContext *context, VbNvParam param, uint32_t *dest) -{ - const uint8_t *raw = context->raw; - - switch (param) { - case VBNV_FIRMWARE_SETTINGS_RESET: - *dest = (raw[HEADER_OFFSET] & HEADER_FIRMWARE_SETTINGS_RESET ? - 1 : 0); - return 0; - - case VBNV_KERNEL_SETTINGS_RESET: - *dest = (raw[HEADER_OFFSET] & HEADER_KERNEL_SETTINGS_RESET ? - 1 : 0); - return 0; - - case VBNV_DEBUG_RESET_MODE: - *dest = (raw[BOOT_OFFSET] & BOOT_DEBUG_RESET_MODE ? 1 : 0); - return 0; - - case VBNV_TRY_B_COUNT: - case VBNV_FW_TRY_COUNT: - *dest = raw[BOOT_OFFSET] & BOOT_TRY_B_COUNT_MASK; - return 0; - - case VBNV_RECOVERY_REQUEST: - *dest = raw[RECOVERY_OFFSET]; - return 0; - - case VBNV_RECOVERY_SUBCODE: - *dest = raw[RECOVERY_SUBCODE_OFFSET]; - return 0; - - case VBNV_LOCALIZATION_INDEX: - *dest = raw[LOCALIZATION_OFFSET]; - return 0; - - case VBNV_KERNEL_FIELD: - *dest = (raw[KERNEL_FIELD1_OFFSET] - | (raw[KERNEL_FIELD2_OFFSET] << 8)); - return 0; - - case VBNV_DEV_BOOT_USB: - *dest = (raw[DEV_FLAGS_OFFSET] & DEV_BOOT_USB_MASK ? 1 : 0); - return 0; - - case VBNV_DEV_BOOT_LEGACY: - *dest = (raw[DEV_FLAGS_OFFSET] & DEV_BOOT_LEGACY_MASK ? 1 : 0); - return 0; - - case VBNV_DEV_DEFAULT_BOOT: - *dest = (raw[DEV_FLAGS_OFFSET] & DEV_DEFAULT_BOOT_MASK) - >> DEV_DEFAULT_BOOT_SHIFT; - return 0; - - case VBNV_DEV_BOOT_SIGNED_ONLY: - *dest = (raw[DEV_FLAGS_OFFSET] & DEV_BOOT_SIGNED_ONLY_MASK ? - 1 : 0); - return 0; - - case VBNV_DEV_BOOT_FASTBOOT_FULL_CAP: - *dest = (raw[DEV_FLAGS_OFFSET] & DEV_BOOT_FASTBOOT_FULL_CAP_MASK - ? 1 : 0); - return 0; - - case VBNV_DISABLE_DEV_REQUEST: - *dest = (raw[BOOT_OFFSET] & BOOT_DISABLE_DEV_REQUEST ? 1 : 0); - return 0; - - case VBNV_OPROM_NEEDED: - *dest = (raw[BOOT_OFFSET] & BOOT_OPROM_NEEDED ? 1 : 0); - return 0; - - case VBNV_CLEAR_TPM_OWNER_REQUEST: - *dest = (raw[TPM_FLAGS_OFFSET] & TPM_CLEAR_OWNER_REQUEST ? - 1 : 0); - return 0; - - case VBNV_CLEAR_TPM_OWNER_DONE: - *dest = (raw[TPM_FLAGS_OFFSET] & TPM_CLEAR_OWNER_DONE ? 1 : 0); - return 0; - - case VBNV_TPM_REQUESTED_REBOOT: - *dest = (raw[TPM_FLAGS_OFFSET] & TPM_REBOOTED ? 1 : 0); - return 0; - - case VBNV_BACKUP_NVRAM_REQUEST: - *dest = (raw[BOOT_OFFSET] & BOOT_BACKUP_NVRAM ? 1 : 0); - return 0; - - case VBNV_FW_TRY_NEXT: - *dest = (raw[BOOT2_OFFSET] & BOOT2_TRY_NEXT ? 1 : 0); - return 0; - - case VBNV_FW_TRIED: - *dest = (raw[BOOT2_OFFSET] & BOOT2_TRIED ? 1 : 0); - return 0; - - case VBNV_FW_RESULT: - *dest = raw[BOOT2_OFFSET] & BOOT2_RESULT_MASK; - return 0; - - case VBNV_FW_PREV_TRIED: - *dest = (raw[BOOT2_OFFSET] & BOOT2_PREV_TRIED ? 1 : 0); - return 0; - - case VBNV_FW_PREV_RESULT: - *dest = (raw[BOOT2_OFFSET] & BOOT2_PREV_RESULT_MASK) - >> BOOT2_PREV_RESULT_SHIFT; - return 0; - - case VBNV_FW_REQ_WIPEOUT: - *dest = (raw[HEADER_OFFSET] & HEADER_WIPEOUT) ? 1 : 0; - return 0; - - case VBNV_FASTBOOT_UNLOCK_IN_FW: - *dest = (raw[MISC_OFFSET] & MISC_UNLOCK_FASTBOOT) ? 1 : 0; - return 0; - - case VBNV_BOOT_ON_AC_DETECT: - *dest = (raw[MISC_OFFSET] & MISC_BOOT_ON_AC_DETECT) ? 1 : 0; - return 0; - - case VBNV_TRY_RO_SYNC: - *dest = (raw[MISC_OFFSET] & MISC_TRY_RO_SYNC) ? 1 : 0; - return 0; - - case VBNV_BATTERY_CUTOFF_REQUEST: - *dest = (raw[MISC_OFFSET] & MISC_BATTERY_CUTOFF_REQUEST) - ? 1 : 0; - return 0; - - case VBNV_KERNEL_MAX_ROLLFORWARD: - *dest = (raw[KERNEL_MAX_ROLLFORWARD1_OFFSET] - | (raw[KERNEL_MAX_ROLLFORWARD2_OFFSET] << 8) - | (raw[KERNEL_MAX_ROLLFORWARD3_OFFSET] << 16) - | (raw[KERNEL_MAX_ROLLFORWARD4_OFFSET] << 24)); - return 0; - - default: - return 1; - } -} - -int VbNvSet(VbNvContext *context, VbNvParam param, uint32_t value) -{ - uint8_t *raw = context->raw; - uint32_t current; - - /* If not changing the value, don't regenerate the CRC. */ - if (0 == VbNvGet(context, param, ¤t) && current == value) - return 0; - - switch (param) { - case VBNV_FIRMWARE_SETTINGS_RESET: - if (value) - raw[HEADER_OFFSET] |= HEADER_FIRMWARE_SETTINGS_RESET; - else - raw[HEADER_OFFSET] &= ~HEADER_FIRMWARE_SETTINGS_RESET; - break; - - case VBNV_KERNEL_SETTINGS_RESET: - if (value) - raw[HEADER_OFFSET] |= HEADER_KERNEL_SETTINGS_RESET; - else - raw[HEADER_OFFSET] &= ~HEADER_KERNEL_SETTINGS_RESET; - break; - - case VBNV_DEBUG_RESET_MODE: - if (value) - raw[BOOT_OFFSET] |= BOOT_DEBUG_RESET_MODE; - else - raw[BOOT_OFFSET] &= ~BOOT_DEBUG_RESET_MODE; - break; - - case VBNV_TRY_B_COUNT: - case VBNV_FW_TRY_COUNT: - /* Clip to valid range. */ - if (value > BOOT_TRY_B_COUNT_MASK) - value = BOOT_TRY_B_COUNT_MASK; - - raw[BOOT_OFFSET] &= ~BOOT_TRY_B_COUNT_MASK; - raw[BOOT_OFFSET] |= (uint8_t)value; - break; - - case VBNV_RECOVERY_REQUEST: - /* - * Map values outside the valid range to the legacy reason, - * since we can't determine if we're called from kernel or user - * mode. - */ - if (value > 0xFF) - value = VBNV_RECOVERY_LEGACY; - raw[RECOVERY_OFFSET] = (uint8_t)value; - break; - - case VBNV_RECOVERY_SUBCODE: - raw[RECOVERY_SUBCODE_OFFSET] = (uint8_t)value; - break; - - case VBNV_LOCALIZATION_INDEX: - /* Map values outside the valid range to the default index. */ - if (value > 0xFF) - value = 0; - raw[LOCALIZATION_OFFSET] = (uint8_t)value; - break; - - case VBNV_KERNEL_FIELD: - raw[KERNEL_FIELD1_OFFSET] = (uint8_t)(value); - raw[KERNEL_FIELD2_OFFSET] = (uint8_t)(value >> 8); - break; - - case VBNV_DEV_BOOT_USB: - if (value) - raw[DEV_FLAGS_OFFSET] |= DEV_BOOT_USB_MASK; - else - raw[DEV_FLAGS_OFFSET] &= ~DEV_BOOT_USB_MASK; - break; - - case VBNV_DEV_BOOT_LEGACY: - if (value) - raw[DEV_FLAGS_OFFSET] |= DEV_BOOT_LEGACY_MASK; - else - raw[DEV_FLAGS_OFFSET] &= ~DEV_BOOT_LEGACY_MASK; - break; - - case VBNV_DEV_DEFAULT_BOOT: - /* Map out of range values to boot disk */ - if (value > (DEV_DEFAULT_BOOT_MASK >> - DEV_DEFAULT_BOOT_SHIFT)) - value = VBNV_DEV_DEFAULT_BOOT_DISK; - - raw[DEV_FLAGS_OFFSET] &= ~DEV_DEFAULT_BOOT_MASK; - raw[DEV_FLAGS_OFFSET] |= (uint8_t)value << - DEV_DEFAULT_BOOT_SHIFT; - break; - - case VBNV_DEV_BOOT_SIGNED_ONLY: - if (value) - raw[DEV_FLAGS_OFFSET] |= DEV_BOOT_SIGNED_ONLY_MASK; - else - raw[DEV_FLAGS_OFFSET] &= ~DEV_BOOT_SIGNED_ONLY_MASK; - break; - - case VBNV_DEV_BOOT_FASTBOOT_FULL_CAP: - if (value) - raw[DEV_FLAGS_OFFSET] |= - DEV_BOOT_FASTBOOT_FULL_CAP_MASK; - else - raw[DEV_FLAGS_OFFSET] &= - ~DEV_BOOT_FASTBOOT_FULL_CAP_MASK; - break; - - case VBNV_DISABLE_DEV_REQUEST: - if (value) - raw[BOOT_OFFSET] |= BOOT_DISABLE_DEV_REQUEST; - else - raw[BOOT_OFFSET] &= ~BOOT_DISABLE_DEV_REQUEST; - break; - - case VBNV_OPROM_NEEDED: - if (value) - raw[BOOT_OFFSET] |= BOOT_OPROM_NEEDED; - else - raw[BOOT_OFFSET] &= ~BOOT_OPROM_NEEDED; - break; - - case VBNV_CLEAR_TPM_OWNER_REQUEST: - if (value) - raw[TPM_FLAGS_OFFSET] |= TPM_CLEAR_OWNER_REQUEST; - else - raw[TPM_FLAGS_OFFSET] &= ~TPM_CLEAR_OWNER_REQUEST; - break; - - case VBNV_CLEAR_TPM_OWNER_DONE: - if (value) - raw[TPM_FLAGS_OFFSET] |= TPM_CLEAR_OWNER_DONE; - else - raw[TPM_FLAGS_OFFSET] &= ~TPM_CLEAR_OWNER_DONE; - break; - - case VBNV_TPM_REQUESTED_REBOOT: - if (value) - raw[TPM_FLAGS_OFFSET] |= TPM_REBOOTED; - else - raw[TPM_FLAGS_OFFSET] &= ~TPM_REBOOTED; - break; - - case VBNV_BACKUP_NVRAM_REQUEST: - if (value) - raw[BOOT_OFFSET] |= BOOT_BACKUP_NVRAM; - else - raw[BOOT_OFFSET] &= ~BOOT_BACKUP_NVRAM; - break; - - case VBNV_FW_TRY_NEXT: - if (value) - raw[BOOT2_OFFSET] |= BOOT2_TRY_NEXT; - else - raw[BOOT2_OFFSET] &= ~BOOT2_TRY_NEXT; - break; - - case VBNV_FW_TRIED: - if (value) - raw[BOOT2_OFFSET] |= BOOT2_TRIED; - else - raw[BOOT2_OFFSET] &= ~BOOT2_TRIED; - break; - - case VBNV_FW_RESULT: - /* Map out of range values to unknown */ - if (value > BOOT2_RESULT_MASK) - value = VBNV_FW_RESULT_UNKNOWN; - - raw[BOOT2_OFFSET] &= ~BOOT2_RESULT_MASK; - raw[BOOT2_OFFSET] |= (uint8_t)value; - break; - - case VBNV_FW_PREV_TRIED: - if (value) - raw[BOOT2_OFFSET] |= BOOT2_PREV_TRIED; - else - raw[BOOT2_OFFSET] &= ~BOOT2_PREV_TRIED; - break; - - case VBNV_FW_PREV_RESULT: - /* Map out of range values to unknown */ - if (value > BOOT2_RESULT_MASK) - value = VBNV_FW_RESULT_UNKNOWN; - - raw[BOOT2_OFFSET] &= ~BOOT2_PREV_RESULT_MASK; - raw[BOOT2_OFFSET] |= (uint8_t)value << BOOT2_PREV_RESULT_SHIFT; - break; - - case VBNV_FW_REQ_WIPEOUT: - if (value) - raw[HEADER_OFFSET] |= HEADER_WIPEOUT; - else - raw[HEADER_OFFSET] &= ~HEADER_WIPEOUT; - break; - - case VBNV_FASTBOOT_UNLOCK_IN_FW: - if (value) - raw[MISC_OFFSET] |= MISC_UNLOCK_FASTBOOT; - else - raw[MISC_OFFSET] &= ~MISC_UNLOCK_FASTBOOT; - break; - - case VBNV_BOOT_ON_AC_DETECT: - if (value) - raw[MISC_OFFSET] |= MISC_BOOT_ON_AC_DETECT; - else - raw[MISC_OFFSET] &= ~MISC_BOOT_ON_AC_DETECT; - break; - - case VBNV_TRY_RO_SYNC: - if (value) - raw[MISC_OFFSET] |= MISC_TRY_RO_SYNC; - else - raw[MISC_OFFSET] &= ~MISC_TRY_RO_SYNC; - break; - - case VBNV_BATTERY_CUTOFF_REQUEST: - if (value) - raw[MISC_OFFSET] |= MISC_BATTERY_CUTOFF_REQUEST; - else - raw[MISC_OFFSET] &= ~MISC_BATTERY_CUTOFF_REQUEST; - break; - - case VBNV_KERNEL_MAX_ROLLFORWARD: - raw[KERNEL_MAX_ROLLFORWARD1_OFFSET] = (uint8_t)(value); - raw[KERNEL_MAX_ROLLFORWARD2_OFFSET] = (uint8_t)(value >> 8); - raw[KERNEL_MAX_ROLLFORWARD3_OFFSET] = (uint8_t)(value >> 16); - raw[KERNEL_MAX_ROLLFORWARD4_OFFSET] = (uint8_t)(value >> 24); - break; - - default: - return 1; - } - - /* Need to regenerate CRC, since the value changed. */ - context->regenerate_crc = 1; - return 0; -} diff --git a/firmware/lib/vboot_ui.c b/firmware/lib/vboot_ui.c index c44b70b1..4d913f0e 100644 --- a/firmware/lib/vboot_ui.c +++ b/firmware/lib/vboot_ui.c @@ -25,7 +25,6 @@ #include "vboot_common.h" #include "vboot_display.h" #include "vboot_kernel.h" -#include "vboot_nvstorage.h" static void VbAllowUsbBoot(struct vb2_context *ctx) { @@ -84,7 +83,7 @@ uint32_t VbTryUsb(struct vb2_context *ctx, VbCommonParams *cparams) * recovery mode. */ vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, - VBNV_RECOVERY_NOT_REQUESTED); + VB2_RECOVERY_NOT_REQUESTED); } return retval; } @@ -182,9 +181,9 @@ VbError_t vb2_developer_ui(struct vb2_context *ctx, VbCommonParams *cparams) /* Check if the default is to boot using disk, usb, or legacy */ uint32_t default_boot = vb2_nv_get(ctx, VB2_NV_DEV_DEFAULT_BOOT); - if(default_boot == VBNV_DEV_DEFAULT_BOOT_USB) + if(default_boot == VB2_DEV_DEFAULT_BOOT_USB) use_usb = 1; - if(default_boot == VBNV_DEV_DEFAULT_BOOT_LEGACY) + if(default_boot == VB2_DEV_DEFAULT_BOOT_LEGACY) use_legacy = 1; /* Handle GBB flag override */ @@ -315,7 +314,7 @@ VbError_t vb2_developer_ui(struct vb2_context *ctx, VbCommonParams *cparams) */ VB2_DEBUG("going to recovery\n"); vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, - VBNV_RECOVERY_RW_DEV_SCREEN); + VB2_RECOVERY_RW_DEV_SCREEN); VbAudioClose(audio); return VBERROR_LOAD_KERNEL_RECOVERY; } @@ -427,8 +426,8 @@ static VbError_t recovery_ui(struct vb2_context *ctx, VbCommonParams *cparams) /* * We have to save the reason here so that it will survive * coming up three-finger-salute. We're saving it in - * VBNV_RECOVERY_SUBCODE to avoid a recovery loop. - * If we save the reason in VBNV_RECOVERY_REQUEST, we will come + * VB2_RECOVERY_SUBCODE to avoid a recovery loop. + * If we save the reason in VB2_RECOVERY_REQUEST, we will come * back here, thus, we won't be able to give a user a chance to * reboot to workaround a boot hiccup. */ @@ -466,7 +465,7 @@ static VbError_t recovery_ui(struct vb2_context *ctx, VbCommonParams *cparams) * us stuck in recovery mode. */ vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, - VBNV_RECOVERY_NOT_REQUESTED); + VB2_RECOVERY_NOT_REQUESTED); if (VBERROR_SUCCESS == retval) break; /* Found a recovery kernel */ diff --git a/firmware/lib/vboot_ui_menu.c b/firmware/lib/vboot_ui_menu.c index b4fdd25e..d1c2b1d3 100644 --- a/firmware/lib/vboot_ui_menu.c +++ b/firmware/lib/vboot_ui_menu.c @@ -23,7 +23,6 @@ #include "vboot_common.h" #include "vboot_display.h" #include "vboot_kernel.h" -#include "vboot_nvstorage.h" static void VbAllowUsbBootMenu(struct vb2_context *ctx) { @@ -84,7 +83,7 @@ uint32_t VbTryUsbMenu(struct vb2_context *ctx, VbCommonParams *cparams) * recovery mode. */ vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, - VBNV_RECOVERY_NOT_REQUESTED); + VB2_RECOVERY_NOT_REQUESTED); } return retval; } @@ -355,13 +354,13 @@ VbError_t vb2_update_menu(struct vb2_context *ctx) switch(current_menu_idx) { case VB_WARN_OPTIONS: switch(default_boot) { - case VBNV_DEV_DEFAULT_BOOT_DISK: + case VB2_DEV_DEFAULT_BOOT_DISK: next_menu_idx = VB_DEV_DISK; break; - case VBNV_DEV_DEFAULT_BOOT_USB: + case VB2_DEV_DEFAULT_BOOT_USB: next_menu_idx = VB_DEV_USB; break; - case VBNV_DEV_DEFAULT_BOOT_LEGACY: + case VB2_DEV_DEFAULT_BOOT_LEGACY: next_menu_idx = VB_DEV_LEGACY; break; } @@ -675,9 +674,9 @@ VbError_t vb2_developer_menu(struct vb2_context *ctx, VbCommonParams *cparams) /* Check if the default is to boot using disk, usb, or legacy */ default_boot = vb2_nv_get(ctx, VB2_NV_DEV_DEFAULT_BOOT); - if(default_boot == VBNV_DEV_DEFAULT_BOOT_USB) + if(default_boot == VB2_DEV_DEFAULT_BOOT_USB) use_usb = 1; - if(default_boot == VBNV_DEV_DEFAULT_BOOT_LEGACY) + if(default_boot == VB2_DEV_DEFAULT_BOOT_LEGACY) use_legacy = 1; /* Handle GBB flag override */ @@ -990,8 +989,8 @@ static VbError_t recovery_ui(struct vb2_context *ctx, VbCommonParams *cparams) /* * We have to save the reason here so that it will survive * coming up three-finger-salute. We're saving it in - * VBNV_RECOVERY_SUBCODE to avoid a recovery loop. - * If we save the reason in VBNV_RECOVERY_REQUEST, we will come + * VB2_RECOVERY_SUBCODE to avoid a recovery loop. + * If we save the reason in VB2_RECOVERY_REQUEST, we will come * back here, thus, we won't be able to give a user a chance to * reboot to workaround a boot hiccup. */ @@ -1040,7 +1039,7 @@ static VbError_t recovery_ui(struct vb2_context *ctx, VbCommonParams *cparams) * us stuck in recovery mode. */ vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, - VBNV_RECOVERY_NOT_REQUESTED); + VB2_RECOVERY_NOT_REQUESTED); if (VBERROR_SUCCESS == retval) break; /* Found a recovery kernel */ diff --git a/firmware/linktest/main.c b/firmware/linktest/main.c index 0811d81d..a170131c 100644 --- a/firmware/linktest/main.c +++ b/firmware/linktest/main.c @@ -11,7 +11,6 @@ #include "tlcl.h" #include "vboot_common.h" #include "vboot_kernel.h" -#include "vboot_nvstorage.h" int main(void) @@ -71,10 +70,5 @@ int main(void) VbSharedDataReserve(0, 0); VbSharedDataSetKernelKey(0, 0); - VbNvSetup(0); - VbNvGet(0, 0, 0); - VbNvSet(0, 0, 0); - VbNvTeardown(0); - return 0; } diff --git a/host/arch/arm/lib/crossystem_arch.c b/host/arch/arm/lib/crossystem_arch.c index 27741783..0a308416 100644 --- a/host/arch/arm/lib/crossystem_arch.c +++ b/host/arch/arm/lib/crossystem_arch.c @@ -20,7 +20,6 @@ #include <netinet/in.h> #include "vboot_common.h" -#include "vboot_nvstorage.h" #include "host_common.h" #include "crossystem.h" #include "crossystem_arch.h" @@ -245,8 +244,7 @@ out: return ret; } - -static int VbReadNvStorage_disk(VbNvContext* vnc) +static int vb2_read_nv_storage_disk(struct vb2_context *ctx) { int nvctx_fd = -1; uint8_t sector[SECTOR_SIZE]; @@ -262,7 +260,7 @@ static int VbReadNvStorage_disk(VbNvContext* vnc) return E_FAIL; snprintf(nvctx_path, sizeof(nvctx_path), NVCTX_PATH, emmc_dev); - if (size != sizeof(vnc->raw) || (size + offset > SECTOR_SIZE)) + if (size != sizeof(ctx->nvdata) || (size + offset > SECTOR_SIZE)) return E_FAIL; nvctx_fd = open(nvctx_path, O_RDONLY); @@ -279,7 +277,7 @@ static int VbReadNvStorage_disk(VbNvContext* vnc) __FUNCTION__, nvctx_path); goto out; } - memcpy(vnc->raw, sector+offset, size); + memcpy(ctx->nvdata, sector+offset, size); rv = 0; out: @@ -289,7 +287,7 @@ out: return rv; } -static int VbWriteNvStorage_disk(VbNvContext* vnc) +static int vb2_write_nv_storage_disk(struct vb2_context *ctx) { int nvctx_fd = -1; uint8_t sector[SECTOR_SIZE]; @@ -305,7 +303,7 @@ static int VbWriteNvStorage_disk(VbNvContext* vnc) return E_FAIL; snprintf(nvctx_path, sizeof(nvctx_path), NVCTX_PATH, emmc_dev); - if (size != sizeof(vnc->raw) || (size + offset > SECTOR_SIZE)) + if (size != sizeof(ctx->nvdata) || (size + offset > SECTOR_SIZE)) return E_FAIL; do { @@ -323,7 +321,7 @@ static int VbWriteNvStorage_disk(VbNvContext* vnc) __FUNCTION__, nvctx_path); break; } - memcpy(sector+offset, vnc->raw, size); + memcpy(sector+offset, ctx->nvdata, size); lseek(nvctx_fd, lba * SECTOR_SIZE, SEEK_SET); rv = write(nvctx_fd, sector, SECTOR_SIZE); if (rv <= 0) { @@ -351,35 +349,35 @@ static int VbWriteNvStorage_disk(VbNvContext* vnc) return rv; } -int VbReadNvStorage(VbNvContext* vnc) +int vb2_read_nv_storage(struct vb2_context *ctx) { /* Default to disk for older firmware which does not provide storage * type */ char *media; if (!FdtPropertyExist(FDT_NVSTORAGE_TYPE_PROP)) - return VbReadNvStorage_disk(vnc); + return vb2_read_nv_storage_disk(ctx); media = ReadFdtString(FDT_NVSTORAGE_TYPE_PROP); if (!strcmp(media, "disk")) - return VbReadNvStorage_disk(vnc); + return vb2_read_nv_storage_disk(ctx); if (!strcmp(media, "cros-ec") || !strcmp(media, "mkbp") || !strcmp(media, "flash")) - return VbReadNvStorage_mosys(vnc); + return vb2_read_nv_storage_mosys(ctx); return -1; } -int VbWriteNvStorage(VbNvContext* vnc) +int vb2_write_nv_storage(struct vb2_context *ctx) { /* Default to disk for older firmware which does not provide storage * type */ char *media; if (!FdtPropertyExist(FDT_NVSTORAGE_TYPE_PROP)) - return VbWriteNvStorage_disk(vnc); + return vb2_write_nv_storage_disk(ctx); media = ReadFdtString(FDT_NVSTORAGE_TYPE_PROP); if (!strcmp(media, "disk")) - return VbWriteNvStorage_disk(vnc); + return vb2_write_nv_storage_disk(ctx); if (!strcmp(media, "cros-ec") || !strcmp(media, "mkbp") || !strcmp(media, "flash")) - return VbWriteNvStorage_mosys(vnc); + return vb2_write_nv_storage_mosys(ctx); return -1; } diff --git a/host/arch/mips/lib/crossystem_arch.c b/host/arch/mips/lib/crossystem_arch.c index c0b25877..5c92c9d5 100644 --- a/host/arch/mips/lib/crossystem_arch.c +++ b/host/arch/mips/lib/crossystem_arch.c @@ -6,7 +6,6 @@ #include <string.h> #include "vboot_common.h" -#include "vboot_nvstorage.h" #include "host_common.h" #include "crossystem.h" #include "crossystem_arch.h" @@ -15,12 +14,12 @@ * wherever possible. They will need real implementation as part of of MIPS * firmware bringup. */ -int VbReadNvStorage(VbNvContext* vnc) +int vb2_read_nv_storage(struct vb2_context *ctx) { return -1; } -int VbWriteNvStorage(VbNvContext* vnc) +int vb2_write_nv_storage(struct vb2_context *ctx) { return -1; } diff --git a/host/arch/x86/lib/crossystem_arch.c b/host/arch/x86/lib/crossystem_arch.c index 9f8ca663..f026a14f 100644 --- a/host/arch/x86/lib/crossystem_arch.c +++ b/host/arch/x86/lib/crossystem_arch.c @@ -22,7 +22,6 @@ #include "host_common.h" #include "utility.h" #include "vboot_common.h" -#include "vboot_nvstorage.h" #include "vboot_struct.h" @@ -156,7 +155,7 @@ static int VbCmosWrite(unsigned offs, size_t size, const void *ptr) } -int VbReadNvStorage(VbNvContext* vnc) +int vb2_read_nv_storage(struct vb2_context *ctx) { unsigned offs, blksz; @@ -168,18 +167,18 @@ int VbReadNvStorage(VbNvContext* vnc) if (VBNV_BLOCK_SIZE > blksz) return -1; /* NV storage block is too small */ - if (0 != VbCmosRead(offs, VBNV_BLOCK_SIZE, vnc->raw)) + if (0 != VbCmosRead(offs, sizeof(ctx->nvdata), ctx->nvdata)) return -1; return 0; } -int VbWriteNvStorage(VbNvContext* vnc) +int vb2_write_nv_storage(struct vb2_context *ctx) { unsigned offs, blksz; - if (!vnc->raw_changed) + if (!(ctx->flags & VB2_CONTEXT_NVDATA_CHANGED)) return 0; /* Nothing changed, so no need to write */ /* Get the byte offset from VBNV */ @@ -190,14 +189,14 @@ int VbWriteNvStorage(VbNvContext* vnc) if (VBNV_BLOCK_SIZE > blksz) return -1; /* NV storage block is too small */ - if (0 != VbCmosWrite(offs, VBNV_BLOCK_SIZE, vnc->raw)) + if (0 != VbCmosWrite(offs, sizeof(ctx->nvdata), ctx->nvdata)) return -1; /* Also attempt to write using mosys if using vboot2 */ VbSharedDataHeader *sh = VbSharedDataRead(); if (sh) { if (sh->flags & VBSD_BOOT_FIRMWARE_VBOOT2) - VbWriteNvStorage_mosys(vnc); + vb2_write_nv_storage_mosys(ctx); free(sh); } @@ -453,19 +452,19 @@ static int VbGetRecoveryReason(void) switch(value) { case BINF0_NORMAL: case BINF0_DEVELOPER: - return VBNV_RECOVERY_NOT_REQUESTED; + return VB2_RECOVERY_NOT_REQUESTED; case BINF0_RECOVERY_BUTTON: - return VBNV_RECOVERY_RO_MANUAL; + return VB2_RECOVERY_RO_MANUAL; case BINF0_RECOVERY_DEV_SCREEN_KEY: - return VBNV_RECOVERY_RW_DEV_SCREEN; + return VB2_RECOVERY_RW_DEV_SCREEN; case BINF0_RECOVERY_RW_FW_BAD: - return VBNV_RECOVERY_RO_INVALID_RW; + return VB2_RECOVERY_RO_INVALID_RW; case BINF0_RECOVERY_NO_OS: - return VBNV_RECOVERY_RW_NO_OS; + return VB2_RECOVERY_RW_NO_OS; case BINF0_RECOVERY_BAD_OS: - return VBNV_RECOVERY_RW_INVALID_OS; + return VB2_RECOVERY_RW_INVALID_OS; case BINF0_RECOVERY_OS_INITIATED: - return VBNV_RECOVERY_LEGACY; + return VB2_RECOVERY_LEGACY; default: /* Other values don't map cleanly to firmware type. */ return -1; @@ -817,15 +816,15 @@ int VbGetArchPropertyInt(const char* name) /* NV storage values. If unable to get from NV storage, fall back to * the CMOS reboot field used by older BIOS (e.g. Mario). */ if (!strcasecmp(name,"recovery_request")) { - value = VbGetNvStorage(VBNV_RECOVERY_REQUEST); + value = vb2_get_nv_storage(VB2_NV_RECOVERY_REQUEST); if (-1 == value) value = VbGetCmosRebootField(CMOSRF_RECOVERY); } else if (!strcasecmp(name,"dbg_reset")) { - value = VbGetNvStorage(VBNV_DEBUG_RESET_MODE); + value = vb2_get_nv_storage(VB2_NV_DEBUG_RESET_MODE); if (-1 == value) value = VbGetCmosRebootField(CMOSRF_DEBUG_RESET); } else if (!strcasecmp(name,"fwb_tries")) { - value = VbGetNvStorage(VBNV_TRY_B_COUNT); + value = vb2_get_nv_storage(VB2_NV_TRY_COUNT); if (-1 == value) value = VbGetCmosRebootField(CMOSRF_TRY_B); } @@ -835,7 +834,7 @@ int VbGetArchPropertyInt(const char* name) * stateful partition. */ if (!strcasecmp(name,"fwupdate_tries")) { unsigned fwupdate_value; - if (-1 != VbGetNvStorage(VBNV_KERNEL_FIELD)) + if (-1 != vb2_get_nv_storage(VB2_NV_KERNEL_FIELD)) return -1; /* NvStorage supported; fail through * arch-specific implementation to normal * implementation. */ @@ -900,15 +899,15 @@ int VbSetArchPropertyInt(const char* name, int value) /* NV storage values. If unable to get from NV storage, fall back to * the CMOS reboot field used by older BIOS. */ if (!strcasecmp(name,"recovery_request")) { - if (0 == VbSetNvStorage(VBNV_RECOVERY_REQUEST, value)) + if (0 == vb2_set_nv_storage(VB2_NV_RECOVERY_REQUEST, value)) return 0; return VbSetCmosRebootField(CMOSRF_RECOVERY, value); } else if (!strcasecmp(name,"dbg_reset")) { - if (0 == VbSetNvStorage(VBNV_DEBUG_RESET_MODE, value)) + if (0 == vb2_set_nv_storage(VB2_NV_DEBUG_RESET_MODE, value)) return 0; return VbSetCmosRebootField(CMOSRF_DEBUG_RESET, value); } else if (!strcasecmp(name,"fwb_tries")) { - if (0 == VbSetNvStorage(VBNV_TRY_B_COUNT, value)) + if (0 == vb2_set_nv_storage(VB2_NV_TRY_COUNT, value)) return 0; return VbSetCmosRebootField(CMOSRF_TRY_B, value); } @@ -916,7 +915,7 @@ int VbSetArchPropertyInt(const char* name, int value) * older systems where it's not, it was stored in a file in the * stateful partition. */ else if (!strcasecmp(name,"fwupdate_tries")) { - if (-1 != VbGetNvStorage(VBNV_KERNEL_FIELD)) + if (-1 != vb2_get_nv_storage(VB2_NV_KERNEL_FIELD)) return -1; /* NvStorage supported; fail through * arch-specific implementation to normal * implementation */ diff --git a/host/include/crossystem_vbnv.h b/host/include/crossystem_vbnv.h index 64e0c7c7..64b6b1d6 100644 --- a/host/include/crossystem_vbnv.h +++ b/host/include/crossystem_vbnv.h @@ -12,21 +12,21 @@ extern "C" { #endif -#include <vboot_nvstorage.h> +struct vb2_context; /** - * Attempt to read VbNvContext using mosys. + * Attempt to read non-volatile storage using mosys. * * Returns 0 if success, non-zero if error. */ -int VbReadNvStorage_mosys(VbNvContext* vnc); +int vb2_read_nv_storage_mosys(struct vb2_context *ctx); /** - * Attempt to write VbNvContext using mosys. + * Attempt to write non-volatile storage using mosys. * * Returns 0 if success, non-zero if error. */ -int VbWriteNvStorage_mosys(VbNvContext* vnc); +int vb2_write_nv_storage_mosys(struct vb2_context* ctx); #ifdef __cplusplus } diff --git a/host/lib/crossystem.c b/host/lib/crossystem.c index 216ff32c..5a758616 100644 --- a/host/lib/crossystem.c +++ b/host/lib/crossystem.c @@ -16,6 +16,10 @@ #include <fcntl.h> #include <unistd.h> +#include "2sysincludes.h" +#include "2api.h" +#include "2nvstorage.h" + #include "host_common.h" #include "crossystem.h" @@ -23,7 +27,6 @@ #include "crossystem_vbnv.h" #include "utility.h" #include "vboot_common.h" -#include "vboot_nvstorage.h" #include "vboot_struct.h" /* Filename for kernel command line */ @@ -93,75 +96,58 @@ int FwidStartsWith(const char *start) static int vnc_read; -int VbGetNvStorage(VbNvParam param) +int vb2_get_nv_storage(enum vb2_nv_param param) { - uint32_t value; - int retval; - static VbNvContext cached_vnc; + static struct vb2_context cached_ctx; /* TODO: locking around NV access */ if (!vnc_read) { - if (0 != VbReadNvStorage(&cached_vnc)) + memset(&cached_ctx, 0, sizeof(cached_ctx)); + if (0 != vb2_read_nv_storage(&cached_ctx)) return -1; - vnc_read = 1; - } + vb2_nv_init(&cached_ctx); - if (0 != VbNvSetup(&cached_vnc)) - return -1; - retval = VbNvGet(&cached_vnc, param, &value); - if (0 != VbNvTeardown(&cached_vnc)) - return -1; - if (0 != retval) - return -1; + /* TODO: If vnc.raw_changed, attempt to reopen NVRAM for write + * and save the new defaults. If we're able to, log. */ - /* TODO: If vnc.raw_changed, attempt to reopen NVRAM for write and - * save the new defaults. If we're able to, log. */ - /* TODO: release lock */ + vnc_read = 1; + } - return (int)value; + return (int)vb2_nv_get(&cached_ctx, param); } -int VbSetNvStorage(VbNvParam param, int value) +int vb2_set_nv_storage(enum vb2_nv_param param, int value) { - VbNvContext vnc; - int retval = -1; - int i; + struct vb2_context ctx; - if (0 != VbReadNvStorage(&vnc)) + /* TODO: locking around NV access */ + memset(&ctx, 0, sizeof(ctx)); + if (0 != vb2_read_nv_storage(&ctx)) return -1; + vb2_nv_init(&ctx); + vb2_nv_set(&ctx, param, (uint32_t)value); - if (0 != VbNvSetup(&vnc)) - goto VbSetNvCleanup; - i = VbNvSet(&vnc, param, (uint32_t)value); - if (0 != VbNvTeardown(&vnc)) - goto VbSetNvCleanup; - if (0 != i) - goto VbSetNvCleanup; - - if (vnc.raw_changed) { + if (ctx.flags & VB2_CONTEXT_NVDATA_CHANGED) { vnc_read = 0; - if (0 != VbWriteNvStorage(&vnc)) - goto VbSetNvCleanup; + if (0 != vb2_write_nv_storage(&ctx)) + return -1; } /* Success */ - retval = 0; - -VbSetNvCleanup: - /* TODO: release lock */ - return retval; + return 0; } /* - * Set a param value, and try to flag it for persistent backup. - * It's okay if backup isn't supported. It's best-effort only. + * Set a param value, and try to flag it for persistent backup. It's okay if + * backup isn't supported (which it isn't, in current designs). It's + * best-effort only. */ -static int VbSetNvStorage_WithBackup(VbNvParam param, int value) +static int vb2_set_nv_storage_with_backup(enum vb2_nv_param param, int value) { int retval; - retval = VbSetNvStorage(param, value); + retval = vb2_set_nv_storage(param, value); if (!retval) - VbSetNvStorage(VBNV_BACKUP_NVRAM_REQUEST, 1); + vb2_set_nv_storage(VB2_NV_BACKUP_NVRAM_REQUEST, 1); return retval; } @@ -468,63 +454,62 @@ int VbGetSystemPropertyInt(const char *name) /* NV storage values */ else if (!strcasecmp(name,"kern_nv")) { - value = VbGetNvStorage(VBNV_KERNEL_FIELD); + value = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD); } else if (!strcasecmp(name,"nvram_cleared")) { - value = VbGetNvStorage(VBNV_KERNEL_SETTINGS_RESET); + value = vb2_get_nv_storage(VB2_NV_KERNEL_SETTINGS_RESET); } else if (!strcasecmp(name,"recovery_request")) { - value = VbGetNvStorage(VBNV_RECOVERY_REQUEST); + value = vb2_get_nv_storage(VB2_NV_RECOVERY_REQUEST); } else if (!strcasecmp(name,"dbg_reset")) { - value = VbGetNvStorage(VBNV_DEBUG_RESET_MODE); + value = vb2_get_nv_storage(VB2_NV_DEBUG_RESET_MODE); } else if (!strcasecmp(name,"disable_dev_request")) { - value = VbGetNvStorage(VBNV_DISABLE_DEV_REQUEST); + value = vb2_get_nv_storage(VB2_NV_DISABLE_DEV_REQUEST); } else if (!strcasecmp(name,"clear_tpm_owner_request")) { - value = VbGetNvStorage(VBNV_CLEAR_TPM_OWNER_REQUEST); + value = vb2_get_nv_storage(VB2_NV_CLEAR_TPM_OWNER_REQUEST); } else if (!strcasecmp(name,"clear_tpm_owner_done")) { - value = VbGetNvStorage(VBNV_CLEAR_TPM_OWNER_DONE); + value = vb2_get_nv_storage(VB2_NV_CLEAR_TPM_OWNER_DONE); } else if (!strcasecmp(name,"tpm_rebooted")) { - value = VbGetNvStorage(VBNV_TPM_REQUESTED_REBOOT); - } else if (!strcasecmp(name,"fwb_tries")) { - value = VbGetNvStorage(VBNV_TRY_B_COUNT); + value = vb2_get_nv_storage(VB2_NV_TPM_REQUESTED_REBOOT); + } else if (!strcasecmp(name,"fwb_tries") || + !strcasecmp(name,"fw_try_count")) { + value = vb2_get_nv_storage(VB2_NV_TRY_COUNT); } else if (!strcasecmp(name,"fw_vboot2")) { value = GetVdatInt(VDAT_INT_FW_BOOT2); - } else if (!strcasecmp(name,"fw_try_count")) { - value = VbGetNvStorage(VBNV_FW_TRY_COUNT); } else if (!strcasecmp(name,"fwupdate_tries")) { - value = VbGetNvStorage(VBNV_KERNEL_FIELD); + value = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD); if (value != -1) value &= KERN_NV_FWUPDATE_TRIES_MASK; } else if (!strcasecmp(name,"block_devmode")) { - value = VbGetNvStorage(VBNV_KERNEL_FIELD); + value = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD); if (value != -1) { value &= KERN_NV_BLOCK_DEVMODE_FLAG; value = !!value; } } else if (!strcasecmp(name,"tpm_attack")) { - value = VbGetNvStorage(VBNV_KERNEL_FIELD); + value = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD); if (value != -1) { value &= KERN_NV_TPM_ATTACK_FLAG; value = !!value; } } else if (!strcasecmp(name,"loc_idx")) { - value = VbGetNvStorage(VBNV_LOCALIZATION_INDEX); + value = vb2_get_nv_storage(VB2_NV_LOCALIZATION_INDEX); } else if (!strcasecmp(name,"backup_nvram_request")) { - value = VbGetNvStorage(VBNV_BACKUP_NVRAM_REQUEST); + value = vb2_get_nv_storage(VB2_NV_BACKUP_NVRAM_REQUEST); } else if (!strcasecmp(name,"dev_boot_usb")) { - value = VbGetNvStorage(VBNV_DEV_BOOT_USB); + value = vb2_get_nv_storage(VB2_NV_DEV_BOOT_USB); } else if (!strcasecmp(name,"dev_boot_legacy")) { - value = VbGetNvStorage(VBNV_DEV_BOOT_LEGACY); + value = vb2_get_nv_storage(VB2_NV_DEV_BOOT_LEGACY); } else if (!strcasecmp(name,"dev_boot_signed_only")) { - value = VbGetNvStorage(VBNV_DEV_BOOT_SIGNED_ONLY); + value = vb2_get_nv_storage(VB2_NV_DEV_BOOT_SIGNED_ONLY); } else if (!strcasecmp(name,"dev_boot_fastboot_full_cap")) { - value = VbGetNvStorage(VBNV_DEV_BOOT_FASTBOOT_FULL_CAP); + value = vb2_get_nv_storage(VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP); } else if (!strcasecmp(name,"oprom_needed")) { - value = VbGetNvStorage(VBNV_OPROM_NEEDED); + value = vb2_get_nv_storage(VB2_NV_OPROM_NEEDED); } else if (!strcasecmp(name,"recovery_subcode")) { - value = VbGetNvStorage(VBNV_RECOVERY_SUBCODE); + value = vb2_get_nv_storage(VB2_NV_RECOVERY_SUBCODE); } else if (!strcasecmp(name,"wipeout_request")) { - value = VbGetNvStorage(VBNV_FW_REQ_WIPEOUT); + value = vb2_get_nv_storage(VB2_NV_REQ_WIPEOUT); } else if (!strcasecmp(name,"kernel_max_rollforward")) { - value = VbGetNvStorage(VBNV_KERNEL_MAX_ROLLFORWARD); + value = vb2_get_nv_storage(VB2_NV_KERNEL_MAX_ROLLFORWARD); } /* Other parameters */ else if (!strcasecmp(name,"cros_debug")) { @@ -550,13 +535,13 @@ int VbGetSystemPropertyInt(const char *name) } else if (!strcasecmp(name,"recovery_reason")) { value = GetVdatInt(VDAT_INT_RECOVERY_REASON); } else if (!strcasecmp(name, "fastboot_unlock_in_fw")) { - value = VbGetNvStorage(VBNV_FASTBOOT_UNLOCK_IN_FW); + value = vb2_get_nv_storage(VB2_NV_FASTBOOT_UNLOCK_IN_FW); } else if (!strcasecmp(name, "boot_on_ac_detect")) { - value = VbGetNvStorage(VBNV_BOOT_ON_AC_DETECT); + value = vb2_get_nv_storage(VB2_NV_BOOT_ON_AC_DETECT); } else if (!strcasecmp(name, "try_ro_sync")) { - value = VbGetNvStorage(VBNV_TRY_RO_SYNC); + value = vb2_get_nv_storage(VB2_NV_TRY_RO_SYNC); } else if (!strcasecmp(name, "battery_cutoff_request")) { - value = VbGetNvStorage(VBNV_BATTERY_CUTOFF_REQUEST); + value = vb2_get_nv_storage(VB2_NV_BATTERY_CUTOFF_REQUEST); } else if (!strcasecmp(name, "inside_vm")) { /* Detect if the host is a VM. If there is no HWID and the * firmware type is "nonchrome", then assume it is a VM. If @@ -604,25 +589,25 @@ const char *VbGetSystemPropertyString(const char *name, char *dest, } else if (!strcasecmp(name, "vdat_lkdebug")) { return GetVdatString(dest, size, VDAT_STRING_LOAD_KERNEL_DEBUG); } else if (!strcasecmp(name, "fw_try_next")) { - return VbGetNvStorage(VBNV_FW_TRY_NEXT) ? "B" : "A"; + return vb2_get_nv_storage(VB2_NV_TRY_NEXT) ? "B" : "A"; } else if (!strcasecmp(name, "fw_tried")) { - return VbGetNvStorage(VBNV_FW_TRIED) ? "B" : "A"; + return vb2_get_nv_storage(VB2_NV_FW_TRIED) ? "B" : "A"; } else if (!strcasecmp(name, "fw_result")) { - int v = VbGetNvStorage(VBNV_FW_RESULT); + int v = vb2_get_nv_storage(VB2_NV_FW_RESULT); if (v < ARRAY_SIZE(fw_results)) return fw_results[v]; else return "unknown"; } else if (!strcasecmp(name, "fw_prev_tried")) { - return VbGetNvStorage(VBNV_FW_PREV_TRIED) ? "B" : "A"; + return vb2_get_nv_storage(VB2_NV_FW_PREV_TRIED) ? "B" : "A"; } else if (!strcasecmp(name, "fw_prev_result")) { - int v = VbGetNvStorage(VBNV_FW_PREV_RESULT); + int v = vb2_get_nv_storage(VB2_NV_FW_PREV_RESULT); if (v < ARRAY_SIZE(fw_results)) return fw_results[v]; else return "unknown"; } else if (!strcasecmp(name,"dev_default_boot")) { - int v = VbGetNvStorage(VBNV_DEV_DEFAULT_BOOT); + int v = vb2_get_nv_storage(VB2_NV_DEV_DEFAULT_BOOT); if (v < ARRAY_SIZE(default_boot)) return default_boot[v]; else @@ -644,82 +629,89 @@ int VbSetSystemPropertyInt(const char *name, int value) if (!strcasecmp(name,"nvram_cleared")) { /* Can only clear this flag; it's set inside the NV storage * library. */ - return VbSetNvStorage(VBNV_KERNEL_SETTINGS_RESET, 0); + return vb2_set_nv_storage(VB2_NV_KERNEL_SETTINGS_RESET, 0); } else if (!strcasecmp(name,"recovery_request")) { - return VbSetNvStorage(VBNV_RECOVERY_REQUEST, value); + return vb2_set_nv_storage(VB2_NV_RECOVERY_REQUEST, value); } else if (!strcasecmp(name,"recovery_subcode")) { - return VbSetNvStorage(VBNV_RECOVERY_SUBCODE, value); + return vb2_set_nv_storage(VB2_NV_RECOVERY_SUBCODE, value); } else if (!strcasecmp(name,"dbg_reset")) { - return VbSetNvStorage(VBNV_DEBUG_RESET_MODE, value); + return vb2_set_nv_storage(VB2_NV_DEBUG_RESET_MODE, value); } else if (!strcasecmp(name,"disable_dev_request")) { - return VbSetNvStorage(VBNV_DISABLE_DEV_REQUEST, value); + return vb2_set_nv_storage(VB2_NV_DISABLE_DEV_REQUEST, value); } else if (!strcasecmp(name,"clear_tpm_owner_request")) { - return VbSetNvStorage(VBNV_CLEAR_TPM_OWNER_REQUEST, value); + return vb2_set_nv_storage(VB2_NV_CLEAR_TPM_OWNER_REQUEST, value); } else if (!strcasecmp(name,"clear_tpm_owner_done")) { /* Can only clear this flag; it's set by firmware. */ - return VbSetNvStorage(VBNV_CLEAR_TPM_OWNER_DONE, 0); - } else if (!strcasecmp(name,"fwb_tries")) { - return VbSetNvStorage(VBNV_TRY_B_COUNT, value); - } else if (!strcasecmp(name,"fw_try_count")) { - return VbSetNvStorage(VBNV_FW_TRY_COUNT, value); + return vb2_set_nv_storage(VB2_NV_CLEAR_TPM_OWNER_DONE, 0); + } else if (!strcasecmp(name,"fwb_tries") || + !strcasecmp(name,"fw_try_count")) { + return vb2_set_nv_storage(VB2_NV_TRY_COUNT, value); } else if (!strcasecmp(name,"oprom_needed")) { - return VbSetNvStorage(VBNV_OPROM_NEEDED, value); + return vb2_set_nv_storage(VB2_NV_OPROM_NEEDED, value); } else if (!strcasecmp(name,"wipeout_request")) { /* Can only clear this flag, set only by firmware. */ - return VbSetNvStorage(VBNV_FW_REQ_WIPEOUT, 0); + return vb2_set_nv_storage(VB2_NV_REQ_WIPEOUT, 0); } else if (!strcasecmp(name,"backup_nvram_request")) { /* Best-effort only, since it requires firmware and TPM * support. */ - return VbSetNvStorage(VBNV_BACKUP_NVRAM_REQUEST, value); + return vb2_set_nv_storage(VB2_NV_BACKUP_NVRAM_REQUEST, value); } else if (!strcasecmp(name,"fwupdate_tries")) { - int kern_nv = VbGetNvStorage(VBNV_KERNEL_FIELD); + int kern_nv = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD); if (kern_nv == -1) return -1; kern_nv &= ~KERN_NV_FWUPDATE_TRIES_MASK; kern_nv |= (value & KERN_NV_FWUPDATE_TRIES_MASK); - return VbSetNvStorage_WithBackup(VBNV_KERNEL_FIELD, kern_nv); + return vb2_set_nv_storage_with_backup(VB2_NV_KERNEL_FIELD, + kern_nv); } else if (!strcasecmp(name,"block_devmode")) { - int kern_nv = VbGetNvStorage(VBNV_KERNEL_FIELD); + int kern_nv = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD); if (kern_nv == -1) return -1; kern_nv &= ~KERN_NV_BLOCK_DEVMODE_FLAG; if (value) kern_nv |= KERN_NV_BLOCK_DEVMODE_FLAG; - return VbSetNvStorage_WithBackup(VBNV_KERNEL_FIELD, kern_nv); + return vb2_set_nv_storage_with_backup(VB2_NV_KERNEL_FIELD, + kern_nv); } else if (!strcasecmp(name,"tpm_attack")) { /* This value should only be read and cleared, but we allow * setting it to 1 for testing. */ - int kern_nv = VbGetNvStorage(VBNV_KERNEL_FIELD); + int kern_nv = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD); if (kern_nv == -1) return -1; kern_nv &= ~KERN_NV_TPM_ATTACK_FLAG; if (value) kern_nv |= KERN_NV_TPM_ATTACK_FLAG; - return VbSetNvStorage_WithBackup(VBNV_KERNEL_FIELD, kern_nv); + return vb2_set_nv_storage_with_backup( + VB2_NV_KERNEL_FIELD, kern_nv); } else if (!strcasecmp(name,"loc_idx")) { - return VbSetNvStorage_WithBackup(VBNV_LOCALIZATION_INDEX, + return vb2_set_nv_storage_with_backup( + VB2_NV_LOCALIZATION_INDEX, value); } else if (!strcasecmp(name,"dev_boot_usb")) { - return VbSetNvStorage_WithBackup(VBNV_DEV_BOOT_USB, value); + return vb2_set_nv_storage_with_backup( + VB2_NV_DEV_BOOT_USB, value); } else if (!strcasecmp(name,"dev_boot_legacy")) { - return VbSetNvStorage_WithBackup(VBNV_DEV_BOOT_LEGACY, value); + return vb2_set_nv_storage_with_backup( + VB2_NV_DEV_BOOT_LEGACY, value); } else if (!strcasecmp(name,"dev_boot_signed_only")) { - return VbSetNvStorage_WithBackup(VBNV_DEV_BOOT_SIGNED_ONLY, - value); + return vb2_set_nv_storage_with_backup( + VB2_NV_DEV_BOOT_SIGNED_ONLY, value); } else if (!strcasecmp(name,"dev_boot_fastboot_full_cap")) { - return VbSetNvStorage_WithBackup( - VBNV_DEV_BOOT_FASTBOOT_FULL_CAP, value); + return vb2_set_nv_storage_with_backup( + VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP, value); } else if (!strcasecmp(name, "fastboot_unlock_in_fw")) { - return VbSetNvStorage_WithBackup(VBNV_FASTBOOT_UNLOCK_IN_FW, - value); + return vb2_set_nv_storage_with_backup( + VB2_NV_FASTBOOT_UNLOCK_IN_FW, value); } else if (!strcasecmp(name, "boot_on_ac_detect")) { - return VbSetNvStorage_WithBackup(VBNV_BOOT_ON_AC_DETECT, value); + return vb2_set_nv_storage_with_backup( + VB2_NV_BOOT_ON_AC_DETECT, value); } else if (!strcasecmp(name, "try_ro_sync")) { - return VbSetNvStorage_WithBackup(VBNV_TRY_RO_SYNC, value); + return vb2_set_nv_storage_with_backup( + VB2_NV_TRY_RO_SYNC, value); } else if (!strcasecmp(name, "battery_cutoff_request")) { - return VbSetNvStorage(VBNV_BATTERY_CUTOFF_REQUEST, value); + return vb2_set_nv_storage(VB2_NV_BATTERY_CUTOFF_REQUEST, value); } else if (!strcasecmp(name,"kernel_max_rollforward")) { - return VbSetNvStorage(VBNV_KERNEL_MAX_ROLLFORWARD, value); + return vb2_set_nv_storage(VB2_NV_KERNEL_MAX_ROLLFORWARD, value); } return -1; @@ -733,9 +725,9 @@ int VbSetSystemPropertyString(const char* name, const char* value) if (!strcasecmp(name, "fw_try_next")) { if (!strcasecmp(value, "A")) - return VbSetNvStorage(VBNV_FW_TRY_NEXT, 0); + return vb2_set_nv_storage(VB2_NV_TRY_NEXT, 0); else if (!strcasecmp(value, "B")) - return VbSetNvStorage(VBNV_FW_TRY_NEXT, 1); + return vb2_set_nv_storage(VB2_NV_TRY_NEXT, 1); else return -1; @@ -744,7 +736,7 @@ int VbSetSystemPropertyString(const char* name, const char* value) for (i = 0; i < ARRAY_SIZE(fw_results); i++) { if (!strcasecmp(value, fw_results[i])) - return VbSetNvStorage(VBNV_FW_RESULT, i); + return vb2_set_nv_storage(VB2_NV_FW_RESULT, i); } return -1; } else if (!strcasecmp(name, "dev_default_boot")) { @@ -752,7 +744,8 @@ int VbSetSystemPropertyString(const char* name, const char* value) for (i = 0; i < ARRAY_SIZE(default_boot); i++) { if (!strcasecmp(value, default_boot[i])) - return VbSetNvStorage(VBNV_DEV_DEFAULT_BOOT, i); + return vb2_set_nv_storage( + VB2_NV_DEV_DEFAULT_BOOT, i); } return -1; } @@ -839,7 +832,7 @@ static int ExecuteMosys(char * const argv[], char *buf, size_t bufsize) return 0; } -int VbReadNvStorage_mosys(VbNvContext *vnc) +int vb2_read_nv_storage_mosys(struct vb2_context *ctx) { char hexstring[VBNV_BLOCK_SIZE * 2 + 32]; /* Reserve extra 32 bytes */ char * const argv[] = { @@ -855,12 +848,12 @@ int VbReadNvStorage_mosys(VbNvContext *vnc) for (i = 0; i < VBNV_BLOCK_SIZE; i++) { hexdigit[0] = hexstring[i * 2]; hexdigit[1] = hexstring[i * 2 + 1]; - vnc->raw[i] = strtol(hexdigit, NULL, 16); + ctx->nvdata[i] = strtol(hexdigit, NULL, 16); } return 0; } -int VbWriteNvStorage_mosys(VbNvContext* vnc) +int vb2_write_nv_storage_mosys(struct vb2_context *ctx) { char hexstring[VBNV_BLOCK_SIZE * 2 + 1]; char * const argv[] = { @@ -870,7 +863,7 @@ int VbWriteNvStorage_mosys(VbNvContext* vnc) int i; for (i = 0; i < VBNV_BLOCK_SIZE; i++) - snprintf(hexstring + i * 2, 3, "%02x", vnc->raw[i]); + snprintf(hexstring + i * 2, 3, "%02x", ctx->nvdata[i]); hexstring[sizeof(hexstring) - 1] = '\0'; if (ExecuteMosys(argv, NULL, 0)) return -1; diff --git a/host/lib/include/crossystem_arch.h b/host/lib/include/crossystem_arch.h index 50198b07..030d9d69 100644 --- a/host/lib/include/crossystem_arch.h +++ b/host/lib/include/crossystem_arch.h @@ -10,7 +10,9 @@ #include <stddef.h> -#include "vboot_nvstorage.h" +#include "2sysincludes.h" +#include "2api.h" +#include "2nvstorage.h" #include "vboot_struct.h" /* Firmware types from BINF.3. Placed in the common file because both x86 and @@ -28,12 +30,12 @@ /* Read an integer property from VbNvStorage. * * Returns the parameter value, or -1 if error. */ -int VbGetNvStorage(VbNvParam param); +int vb2_get_nv_storage(enum vb2_nv_param param); /* Write an integer property to VbNvStorage. * * Returns 0 if success, -1 if error. */ -int VbSetNvStorage(VbNvParam param, int value); +int vb2_set_nv_storage(enum vb2_nv_param param, int value); /* Return true if the FWID starts with the specified string. */ int FwidStartsWith(const char *start); @@ -46,12 +48,12 @@ int VbSharedDataVersion(void); /* Read the non-volatile context from NVRAM. * * Returns 0 if success, -1 if error. */ -int VbReadNvStorage(VbNvContext* vnc); +int vb2_read_nv_storage(struct vb2_context *ctx); /* Write the non-volatile context to NVRAM. * * Returns 0 if success, -1 if error. */ -int VbWriteNvStorage(VbNvContext* vnc); +int vb2_write_nv_storage(struct vb2_context *ctx); /* Read the VbSharedData buffer. * diff --git a/tests/ec_sync_tests.c b/tests/ec_sync_tests.c index 1d5f8c1b..a8c9b78c 100644 --- a/tests/ec_sync_tests.c +++ b/tests/ec_sync_tests.c @@ -23,7 +23,6 @@ #include "vboot_common.h" #include "vboot_display.h" #include "vboot_kernel.h" -#include "vboot_nvstorage.h" #include "vboot_struct.h" /* Mock data */ @@ -250,28 +249,28 @@ static void VbSoftwareSyncTest(void) ResetMocks(); in_rw_retval = VBERROR_SIMULATED; test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED, - VBNV_RECOVERY_EC_UNKNOWN_IMAGE, "Unknown EC image"); + VB2_RECOVERY_EC_UNKNOWN_IMAGE, "Unknown EC image"); /* Calculate hashes */ ResetMocks(); mock_ec_rw_hash_size = 0; test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED, - VBNV_RECOVERY_EC_HASH_FAILED, "Bad EC hash"); + VB2_RECOVERY_EC_HASH_FAILED, "Bad EC hash"); ResetMocks(); mock_ec_rw_hash_size = 16; test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED, - VBNV_RECOVERY_EC_HASH_SIZE, "Bad EC hash size"); + VB2_RECOVERY_EC_HASH_SIZE, "Bad EC hash size"); ResetMocks(); want_ec_hash_size = 0; test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED, - VBNV_RECOVERY_EC_EXPECTED_HASH, "Bad precalculated hash"); + VB2_RECOVERY_EC_EXPECTED_HASH, "Bad precalculated hash"); ResetMocks(); want_ec_hash_size = 16; test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED, - VBNV_RECOVERY_EC_HASH_SIZE, + VB2_RECOVERY_EC_HASH_SIZE, "Hash size mismatch"); ResetMocks(); @@ -343,7 +342,7 @@ static void VbSoftwareSyncTest(void) mock_ec_rw_hash[0]++; update_hash++; test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED, - VBNV_RECOVERY_EC_UPDATE, "updated hash mismatch"); + VB2_RECOVERY_EC_UPDATE, "updated hash mismatch"); TEST_EQ(ec_rw_protected, 0, " ec rw protected"); TEST_EQ(ec_run_image, 0, " ec run image"); TEST_EQ(ec_rw_updated, 1, " ec rw updated"); @@ -362,7 +361,7 @@ static void VbSoftwareSyncTest(void) mock_ec_rw_hash[0]++; update_retval = VBERROR_SIMULATED; test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED, - VBNV_RECOVERY_EC_UPDATE, "Update failed"); + VB2_RECOVERY_EC_UPDATE, "Update failed"); ResetMocks(); mock_ec_rw_hash[0]++; @@ -386,7 +385,7 @@ static void VbSoftwareSyncTest(void) ResetMocks(); run_retval = VBERROR_SIMULATED; test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED, - VBNV_RECOVERY_EC_JUMP_RW, "Jump to RW fail"); + VB2_RECOVERY_EC_JUMP_RW, "Jump to RW fail"); ResetMocks(); run_retval = VBERROR_EC_REBOOT_TO_RO_REQUIRED; @@ -396,7 +395,7 @@ static void VbSoftwareSyncTest(void) ResetMocks(); protect_retval = VBERROR_SIMULATED; test_ssync(VBERROR_SIMULATED, - VBNV_RECOVERY_EC_PROTECT, "Protect error"); + VB2_RECOVERY_EC_PROTECT, "Protect error"); /* No longer check for shutdown requested */ ResetMocks(); diff --git a/tests/vboot_api_devmode_tests.c b/tests/vboot_api_devmode_tests.c index 6ec74b29..a65fc269 100644 --- a/tests/vboot_api_devmode_tests.c +++ b/tests/vboot_api_devmode_tests.c @@ -12,6 +12,7 @@ #include "2sysincludes.h" #include "2api.h" +#include "2nvstorage.h" #include "crc32.h" #include "gbb_header.h" #include "host_common.h" @@ -21,7 +22,6 @@ #include "vboot_common.h" #include "vboot_display.h" #include "vboot_kernel.h" -#include "vboot_nvstorage.h" #include "vboot_struct.h" @@ -135,7 +135,6 @@ test_case_t test[] = { /* Mock data */ static VbCommonParams cparams; static struct vb2_context ctx; -static VbNvContext vnc; static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE]; static VbSharedDataHeader* shared = (VbSharedDataHeader*)shared_data; static GoogleBinaryBlockHeader gbb; @@ -161,10 +160,7 @@ static void ResetMocks(void) { cparams.gbb = &gbb; memset(&ctx, 0, sizeof(ctx)); - - memset(&vnc, 0, sizeof(vnc)); - VbNvSetup(&vnc); - VbNvTeardown(&vnc); /* So CRC gets generated */ + vb2_nv_init(&ctx); memset(&shared_data, 0, sizeof(shared_data)); VbSharedDataInit(shared, sizeof(shared_data)); @@ -193,12 +189,10 @@ static void ResetMocks(void) { /* Mocked verification functions */ VbError_t VbExNvStorageRead(uint8_t* buf) { - memcpy(buf, vnc.raw, sizeof(vnc.raw)); return VBERROR_SUCCESS; } VbError_t VbExNvStorageWrite(const uint8_t* buf) { - memcpy(vnc.raw, buf, sizeof(vnc.raw)); return VBERROR_SUCCESS; } diff --git a/tests/vboot_api_kernel2_tests.c b/tests/vboot_api_kernel2_tests.c index 384c978d..da0af9b5 100644 --- a/tests/vboot_api_kernel2_tests.c +++ b/tests/vboot_api_kernel2_tests.c @@ -22,7 +22,6 @@ #include "vboot_common.h" #include "vboot_display.h" #include "vboot_kernel.h" -#include "vboot_nvstorage.h" #include "vboot_struct.h" /* Mock data */ @@ -307,7 +306,7 @@ static void VbBootDevTest(void) * legacy are set */ ResetMocks(); vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT, - VBNV_DEV_DEFAULT_BOOT_LEGACY); + VB2_DEV_DEFAULT_BOOT_LEGACY); vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_LEGACY, 1); TEST_EQ(VbBootDeveloper(&ctx, &cparams), 1002, "Timeout"); TEST_EQ(vbexlegacy_called, 1, " try legacy"); @@ -315,7 +314,7 @@ static void VbBootDevTest(void) /* Proceed to legacy boot mode only if enabled */ ResetMocks(); vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT, - VBNV_DEV_DEFAULT_BOOT_LEGACY); + VB2_DEV_DEFAULT_BOOT_LEGACY); TEST_EQ(VbBootDeveloper(&ctx, &cparams), 1002, "Timeout"); TEST_EQ(vbexlegacy_called, 0, " not legacy"); @@ -323,7 +322,7 @@ static void VbBootDevTest(void) * usb are set */ ResetMocks(); vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT, - VBNV_DEV_DEFAULT_BOOT_USB); + VB2_DEV_DEFAULT_BOOT_USB); vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1); vbtlk_retval = VBERROR_SUCCESS - VB_DISK_FLAG_REMOVABLE; TEST_EQ(VbBootDeveloper(&ctx, &cparams), 0, "Ctrl+U USB"); @@ -331,14 +330,14 @@ static void VbBootDevTest(void) /* Proceed to usb boot mode only if enabled */ ResetMocks(); vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT, - VBNV_DEV_DEFAULT_BOOT_USB); + VB2_DEV_DEFAULT_BOOT_USB); TEST_EQ(VbBootDeveloper(&ctx, &cparams), 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, - VBNV_DEV_DEFAULT_BOOT_USB); + VB2_DEV_DEFAULT_BOOT_USB); TEST_EQ(VbBootDeveloper(&ctx, &cparams), 1002, "Ctrl+U enabled"); TEST_EQ(vbexlegacy_called, 0, " not legacy"); @@ -369,7 +368,7 @@ static void VbBootDevTest(void) VBERROR_LOAD_KERNEL_RECOVERY, "Space = recovery"); TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), - VBNV_RECOVERY_RW_DEV_SCREEN, " recovery reason"); + VB2_RECOVERY_RW_DEV_SCREEN, " recovery reason"); /* Space asks to disable virtual dev switch */ ResetMocks(); diff --git a/tests/vboot_api_kernel4_tests.c b/tests/vboot_api_kernel4_tests.c index e00c928a..e239192c 100644 --- a/tests/vboot_api_kernel4_tests.c +++ b/tests/vboot_api_kernel4_tests.c @@ -9,6 +9,9 @@ #include <stdio.h> #include <stdlib.h> +#include "2sysincludes.h" +#include "2api.h" +#include "2nvstorage.h" #include "ec_sync.h" #include "gbb_header.h" #include "host_common.h" @@ -18,13 +21,12 @@ #include "vboot_audio.h" #include "vboot_common.h" #include "vboot_kernel.h" -#include "vboot_nvstorage.h" #include "vboot_struct.h" /* Mock data */ +static struct vb2_context ctx; static VbCommonParams cparams; static VbSelectAndLoadKernelParams kparams; -static VbNvContext vnc; static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE]; static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data; static GoogleBinaryBlockHeader gbb; @@ -51,10 +53,9 @@ static void ResetMocks(void) gbb.minor_version = GBB_MINOR_VER; gbb.flags = 0; - memset(&vnc, 0, sizeof(vnc)); - VbNvSetup(&vnc); - VbNvSet(&vnc, VBNV_KERNEL_MAX_ROLLFORWARD, 0xffffffff); - VbNvTeardown(&vnc); /* So CRC gets generated */ + memset(&ctx, 0, sizeof(ctx)); + vb2_nv_init(&ctx); + vb2_nv_set(&ctx, VB2_NV_KERNEL_MAX_ROLLFORWARD, 0xffffffff); memset(&shared_data, 0, sizeof(shared_data)); VbSharedDataInit(shared, sizeof(shared_data)); @@ -71,13 +72,13 @@ static void ResetMocks(void) VbError_t VbExNvStorageRead(uint8_t *buf) { - memcpy(buf, vnc.raw, sizeof(vnc.raw)); + memcpy(buf, ctx.nvdata, sizeof(ctx.nvdata)); return VBERROR_SUCCESS; } VbError_t VbExNvStorageWrite(const uint8_t *buf) { - memcpy(vnc.raw, buf, sizeof(vnc.raw)); + memcpy(ctx.nvdata, buf, sizeof(ctx.nvdata)); return VBERROR_SUCCESS; } @@ -137,11 +138,9 @@ VbError_t VbBootRecovery(struct vb2_context *ctx, VbCommonParams *cparams) static void test_slk(VbError_t retval, int recovery_reason, const char *desc) { - uint32_t u; - TEST_EQ(VbSelectAndLoadKernel(&cparams, &kparams), retval, desc); - VbNvGet(&vnc, VBNV_RECOVERY_REQUEST, &u); - TEST_EQ(u, recovery_reason, " recovery reason"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), + recovery_reason, " recovery reason"); } /* Tests */ @@ -169,7 +168,7 @@ static void VbSlkTest(void) ResetMocks(); rkr_retval = 123; test_slk(VBERROR_TPM_READ_KERNEL, - VBNV_RECOVERY_RW_TPM_R_ERROR, "Read kernel rollback"); + VB2_RECOVERY_RW_TPM_R_ERROR, "Read kernel rollback"); ResetMocks(); new_version = 0x20003; @@ -184,23 +183,20 @@ static void VbSlkTest(void) TEST_EQ(rkr_version, 0x10002, " version"); ResetMocks(); - VbNvSet(&vnc, VBNV_KERNEL_MAX_ROLLFORWARD, 0x30005); - VbNvTeardown(&vnc); + vb2_nv_set(&ctx, VB2_NV_KERNEL_MAX_ROLLFORWARD, 0x30005); new_version = 0x40006; test_slk(0, 0, "Limit max roll forward"); TEST_EQ(rkr_version, 0x30005, " version"); ResetMocks(); - VbNvSet(&vnc, VBNV_KERNEL_MAX_ROLLFORWARD, 0x10001); - VbNvTeardown(&vnc); + vb2_nv_set(&ctx, VB2_NV_KERNEL_MAX_ROLLFORWARD, 0x10001); new_version = 0x40006; test_slk(0, 0, "Max roll forward can't rollback"); TEST_EQ(rkr_version, 0x10002, " version"); ResetMocks(); vbboot_retval = VBERROR_INVALID_KERNEL_FOUND; - VbNvSet(&vnc, VBNV_RECOVERY_REQUEST, 123); - VbNvTeardown(&vnc); + vb2_nv_set(&ctx, VB2_NV_RECOVERY_REQUEST, 123); shared->flags |= VBSD_FWB_TRIED; shared->firmware_index = 1; test_slk(VBERROR_INVALID_KERNEL_FOUND, @@ -210,12 +206,12 @@ static void VbSlkTest(void) new_version = 0x20003; rkw_retval = 123; test_slk(VBERROR_TPM_WRITE_KERNEL, - VBNV_RECOVERY_RW_TPM_W_ERROR, "Write kernel rollback"); + VB2_RECOVERY_RW_TPM_W_ERROR, "Write kernel rollback"); ResetMocks(); rkl_retval = 123; test_slk(VBERROR_TPM_LOCK_KERNEL, - VBNV_RECOVERY_RW_TPM_L_ERROR, "Lock kernel rollback"); + VB2_RECOVERY_RW_TPM_L_ERROR, "Lock kernel rollback"); /* Boot normal */ ResetMocks(); @@ -252,7 +248,7 @@ static void VbSlkTest(void) test_slk(0, 0, "Recovery ignore TPM errors"); ResetMocks(); - shared->recovery_reason = VBNV_RECOVERY_TRAIN_AND_REBOOT; + shared->recovery_reason = VB2_RECOVERY_TRAIN_AND_REBOOT; test_slk(VBERROR_REBOOT_REQUIRED, 0, "Recovery train and reboot"); // todo: rkr/w/l fail ignored if recovery diff --git a/tests/vboot_api_kernel5_tests.c b/tests/vboot_api_kernel5_tests.c index 077c07a4..2d7c2e76 100644 --- a/tests/vboot_api_kernel5_tests.c +++ b/tests/vboot_api_kernel5_tests.c @@ -11,7 +11,9 @@ #include <string.h> #include "2sysincludes.h" +#include "2api.h" #include "2common.h" +#include "2nvstorage.h" #include "2rsa.h" #include "gbb_header.h" #include "host_common.h" @@ -21,10 +23,10 @@ #include "vboot_api.h" #include "vboot_common.h" #include "vboot_kernel.h" -#include "vboot_nvstorage.h" #include "vboot_struct.h" /* Mock data */ +static struct vb2_context ctx; static VbCommonParams cparams; static VbSelectAndLoadKernelParams kparams; static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE]; @@ -37,7 +39,6 @@ static int preamble_verify_fail; static int verify_data_fail; static int unpack_key_fail; -static VbNvContext vnc; static VbKeyBlockHeader kbh; static VbKernelPreambleHeader kph; @@ -61,9 +62,8 @@ static void ResetMocks(void) gbb.minor_version = GBB_MINOR_VER; gbb.flags = 0; - memset(&vnc, 0, sizeof(vnc)); - VbNvSetup(&vnc); - VbNvTeardown(&vnc); /* So CRC gets generated */ + memset(&ctx, 0, sizeof(ctx)); + vb2_nv_init(&ctx); memset(&shared_data, 0, sizeof(shared_data)); VbSharedDataInit(shared, sizeof(shared_data)); @@ -162,7 +162,7 @@ int vb2_verify_data(const uint8_t *data, VbError_t VbExNvStorageRead(uint8_t *buf) { - memcpy(buf, vnc.raw, sizeof(vnc.raw)); + memcpy(buf, ctx.nvdata, sizeof(ctx.nvdata)); return VBERROR_SUCCESS; } @@ -225,8 +225,7 @@ static void VerifyMemoryBootImageTest(void) ResetMocks(); shared->flags = VBSD_BOOT_DEV_SWITCH_ON; key_block_verify_fail = 1; - VbNvSet(&vnc, VBNV_DEV_BOOT_FASTBOOT_FULL_CAP, 1); - VbNvTeardown(&vnc); + vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP, 1); TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer, kernel_buffer_size), VBERROR_INVALID_KERNEL_FOUND, "Key verify failed"); diff --git a/tests/vboot_api_kernel6_tests.c b/tests/vboot_api_kernel6_tests.c index a24cde80..801ff727 100644 --- a/tests/vboot_api_kernel6_tests.c +++ b/tests/vboot_api_kernel6_tests.c @@ -12,7 +12,6 @@ #include "test_common.h" #include "vboot_api.h" -#include "vboot_nvstorage.h" /* Mock data */ static uint32_t virtual_dev_mode_fail; diff --git a/tests/vboot_api_kernel_tests.c b/tests/vboot_api_kernel_tests.c index 3214d442..dd63bb4b 100644 --- a/tests/vboot_api_kernel_tests.c +++ b/tests/vboot_api_kernel_tests.c @@ -84,7 +84,7 @@ test_case_t test[] = { .loadkernel_return_val = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1,}, .external_expected = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0,}, - .expected_recovery_request_val = VBNV_RECOVERY_NOT_REQUESTED, + .expected_recovery_request_val = VB2_RECOVERY_NOT_REQUESTED, .expected_to_find_disk = pickme, .expected_to_load_disk = pickme, .expected_return_val = VBERROR_SUCCESS @@ -102,7 +102,7 @@ test_case_t test[] = { .diskgetinfo_return_val = VBERROR_SUCCESS, .loadkernel_return_val = {1, 0, 1, 1, 1, 1, 1, 1, 1, 1,}, - .expected_recovery_request_val = VBNV_RECOVERY_NOT_REQUESTED, + .expected_recovery_request_val = VB2_RECOVERY_NOT_REQUESTED, .expected_to_find_disk = pickme, .expected_to_load_disk = pickme, .expected_return_val = VBERROR_SUCCESS @@ -132,7 +132,7 @@ test_case_t test[] = { .diskgetinfo_return_val = VBERROR_SUCCESS, .loadkernel_return_val = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1,}, - .expected_recovery_request_val = VBNV_RECOVERY_NOT_REQUESTED, + .expected_recovery_request_val = VB2_RECOVERY_NOT_REQUESTED, .expected_to_find_disk = pickme, .expected_to_load_disk = pickme, .expected_return_val = VBERROR_SUCCESS @@ -145,7 +145,7 @@ test_case_t test[] = { .diskgetinfo_return_val = VBERROR_SUCCESS, .loadkernel_return_val = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1,}, - .expected_recovery_request_val = VBNV_RECOVERY_RW_NO_DISK, + .expected_recovery_request_val = VB2_RECOVERY_RW_NO_DISK, .expected_to_find_disk = 0, .expected_to_load_disk = 0, .expected_return_val = VBERROR_NO_DISK_FOUND @@ -173,7 +173,7 @@ test_case_t test[] = { .diskgetinfo_return_val = VBERROR_SUCCESS, .loadkernel_return_val = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1,}, - .expected_recovery_request_val = VBNV_RECOVERY_RW_NO_KERNEL, + .expected_recovery_request_val = VB2_RECOVERY_RW_NO_KERNEL, .expected_to_find_disk = DONT_CARE, .expected_to_load_disk = 0, .expected_return_val = 1 @@ -205,7 +205,7 @@ static void ResetMocks(int i) memset(&mock_disks, 0, sizeof(mock_disks)); load_kernel_calls = 0; - got_recovery_request_val = VBNV_RECOVERY_NOT_REQUESTED; + got_recovery_request_val = VB2_RECOVERY_NOT_REQUESTED; got_find_disk = 0; got_load_disk = 0; got_return_val = 0xdeadbeef; diff --git a/tests/vboot_audio_tests.c b/tests/vboot_audio_tests.c index 99d9bd4f..94bbb0ac 100644 --- a/tests/vboot_audio_tests.c +++ b/tests/vboot_audio_tests.c @@ -20,7 +20,6 @@ #include "vboot_audio_private.h" #include "vboot_common.h" #include "vboot_display.h" -#include "vboot_nvstorage.h" #include "vboot_struct.h" diff --git a/tests/vboot_display_tests.c b/tests/vboot_display_tests.c index 33421b5b..a0f9eade 100644 --- a/tests/vboot_display_tests.c +++ b/tests/vboot_display_tests.c @@ -22,7 +22,6 @@ #include "vboot_common.h" #include "vboot_display.h" #include "vboot_kernel.h" -#include "vboot_nvstorage.h" /* Mock data */ static VbCommonParams cparams; diff --git a/tests/vboot_kernel_tests.c b/tests/vboot_kernel_tests.c index b1e1635e..d581b373 100644 --- a/tests/vboot_kernel_tests.c +++ b/tests/vboot_kernel_tests.c @@ -14,6 +14,7 @@ #include "2api.h" #include "2common.h" #include "2misc.h" +#include "2nvstorage.h" #include "2sha.h" #include "cgptlib.h" #include "cgptlib_internal.h" @@ -28,7 +29,6 @@ #include "vboot_api.h" #include "vboot_common.h" #include "vboot_kernel.h" -#include "vboot_nvstorage.h" #define LOGCALL(fmt, args...) sprintf(call_log + strlen(call_log), fmt, ##args) #define TEST_CALLS(expect_log) TEST_STR_EQ(call_log, expect_log, " calls") @@ -62,7 +62,6 @@ static int gpt_flag_external; static uint8_t gbb_data[sizeof(GoogleBinaryBlockHeader) + 2048]; static GoogleBinaryBlockHeader *gbb = (GoogleBinaryBlockHeader*)gbb_data; static VbExDiskHandle_t handle; -static VbNvContext vnc; static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE]; static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data; static LoadKernelParams lkp; @@ -152,12 +151,7 @@ static void ResetMocks(void) cparams.gbb_size = sizeof(gbb_data); cparams.shared_data_blob = shared; - memset(&vnc, 0, sizeof(vnc)); - VbNvSetup(&vnc); - VbNvTeardown(&vnc); /* So CRC gets generated */ - memset(&lkp, 0, sizeof(lkp)); - lkp.nv_context = &vnc; lkp.bytes_per_lba = 512; lkp.streaming_lba_count = 1024; lkp.gpt_lba_count = 1024; @@ -186,9 +180,10 @@ static void ResetMocks(void) mock_part_next = 0; memset(&ctx, 0, sizeof(ctx)); - memcpy(ctx.nvdata, vnc.raw, VB2_NVDATA_SIZE); ctx.workbuf = workbuf; ctx.workbuf_size = sizeof(workbuf); + vb2_nv_init(&ctx); + // TODO: more workbuf fields - flags, secdata, secdatak } @@ -574,15 +569,7 @@ static void ReadWriteGptTest(void) static void TestLoadKernel(int expect_retval, char *test_name) { - memcpy(ctx.nvdata, vnc.raw, VB2_NVDATA_SIZE); - TEST_EQ(LoadKernel(&ctx, &lkp, &cparams), expect_retval, test_name); - - if (ctx.flags & VB2_CONTEXT_NVDATA_CHANGED) { - memcpy(vnc.raw, ctx.nvdata, VB2_NVDATA_SIZE); - vnc.raw_changed = 1; - ctx.flags &= ~VB2_CONTEXT_NVDATA_CHANGED; - } } /** @@ -602,8 +589,6 @@ static void InvalidParamsTest(void) static void LoadKernelTest(void) { - uint32_t u; - ResetMocks(); TestLoadKernel(0, "First kernel good"); @@ -612,8 +597,8 @@ static void LoadKernelTest(void) TEST_EQ(lkp.bootloader_size, 0x1234, " bootloader size"); TEST_STR_EQ((char *)lkp.partition_guid, "FakeGuid", " guid"); TEST_EQ(gpt_flag_external, 0, "GPT was internal"); - VbNvGet(&vnc, VBNV_RECOVERY_REQUEST, &u); - TEST_EQ(u, 0, " recovery request"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), + 0, " recovery request"); ResetMocks(); mock_parts[1].start = 300; @@ -626,15 +611,15 @@ static void LoadKernelTest(void) ResetMocks(); mock_parts[0].size = 0; TestLoadKernel(VBERROR_NO_KERNEL_FOUND, "No kernels"); - VbNvGet(&vnc, VBNV_RECOVERY_REQUEST, &u); - TEST_EQ(u, VBNV_RECOVERY_RW_NO_OS, " recovery request"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), + VB2_RECOVERY_RW_NO_OS, " recovery request"); /* Skip kernels which are too small */ ResetMocks(); mock_parts[0].size = 10; TestLoadKernel(VBERROR_INVALID_KERNEL_FOUND, "Too small"); - VbNvGet(&vnc, VBNV_RECOVERY_REQUEST, &u); - TEST_EQ(u, VBNV_RECOVERY_RW_INVALID_OS, " recovery request"); + TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST), + VB2_RECOVERY_RW_INVALID_OS, " recovery request"); ResetMocks(); disk_read_to_fail = 100; @@ -660,8 +645,7 @@ static void LoadKernelTest(void) /* In dev mode and requiring signed kernel, fail if sig is bad */ ResetMocks(); ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE; - VbNvSet(&vnc, VBNV_DEV_BOOT_SIGNED_ONLY, 1); - VbNvTeardown(&vnc); + vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_SIGNED_ONLY, 1); key_block_verify_fail = 1; TestLoadKernel(VBERROR_INVALID_KERNEL_FOUND, "Fail key block dev sig"); diff --git a/tests/vboot_nvstorage_test.c b/tests/vboot_nvstorage_test.c deleted file mode 100644 index c461978f..00000000 --- a/tests/vboot_nvstorage_test.c +++ /dev/null @@ -1,208 +0,0 @@ -/* Copyright (c) 2013 The Chromium OS Authors. All rights reserved. - * Use of this source code is governed by a BSD-style license that can be - * found in the LICENSE file. - * - * Tests for firmware NV storage library. - */ - -#include <stdint.h> -#include <stdio.h> -#include <stdlib.h> -#include <string.h> - -#include "test_common.h" -#include "vboot_common.h" -#include "vboot_nvstorage.h" - -/* Single NV storage field to test */ -typedef struct VbNvField { - VbNvParam param; /* Parameter index */ - uint32_t default_value; /* Expected default value */ - uint32_t test_value; /* Value to test writing */ - uint32_t test_value2; /* Second value to test writing */ - char* desc; /* Field description */ -} VbNvField; - -/* Array of fields to test, terminated with a field with desc==NULL. */ -static VbNvField nvfields[] = { - {VBNV_DEBUG_RESET_MODE, 0, 1, 0, "debug reset mode"}, - {VBNV_TRY_B_COUNT, 0, 6, 15, "try B count"}, - {VBNV_RECOVERY_REQUEST, 0, 0x42, 0xED, "recovery request"}, - {VBNV_LOCALIZATION_INDEX, 0, 0x69, 0xB0, "localization index"}, - {VBNV_KERNEL_FIELD, 0, 0x1234, 0xFEDC, "kernel field"}, - {VBNV_DEV_BOOT_USB, 0, 1, 0, "dev boot usb"}, - {VBNV_DEV_BOOT_LEGACY, 0, 1, 0, "dev boot legacy"}, - {VBNV_DEV_BOOT_SIGNED_ONLY, 0, 1, 0, "dev boot custom"}, - {VBNV_DEV_BOOT_FASTBOOT_FULL_CAP, 0, 1, 0, "dev boot fastboot full cap"}, - {VBNV_DEV_DEFAULT_BOOT, 0, 1, 2, "dev default boot"}, - {VBNV_DISABLE_DEV_REQUEST, 0, 1, 0, "disable dev request"}, - {VBNV_CLEAR_TPM_OWNER_REQUEST, 0, 1, 0, "clear tpm owner request"}, - {VBNV_CLEAR_TPM_OWNER_DONE, 0, 1, 0, "clear tpm owner done"}, - {VBNV_TPM_REQUESTED_REBOOT, 0, 1, 0, "tpm requested reboot"}, - {VBNV_OPROM_NEEDED, 0, 1, 0, "oprom needed"}, - {VBNV_FW_TRY_COUNT, 0, 8, 15, "try count"}, - {VBNV_FW_TRY_NEXT, 0, 1, 0, "try next"}, - {VBNV_FW_TRIED, 0, 1, 0, "firmware tried"}, - {VBNV_FW_RESULT, VBNV_FW_RESULT_UNKNOWN, 1, 2, "firmware result"}, - {VBNV_FW_PREV_TRIED, 0, 1, 0, "firmware prev tried"}, - {VBNV_FW_PREV_RESULT, VBNV_FW_RESULT_UNKNOWN, 1, 3, "firmware prev result"}, - {VBNV_FASTBOOT_UNLOCK_IN_FW, 0, 1, 0, "fastboot unlock in firmware"}, - {VBNV_BOOT_ON_AC_DETECT, 0, 1, 0, "boot on ac detect"}, - {VBNV_TRY_RO_SYNC, 0, 1, 0, "try read only software sync"}, - {VBNV_KERNEL_MAX_ROLLFORWARD, 0, 0x12345678, 0xFEDCBA98, - "kernel max rollforward"}, - {0, 0, 0, 0, NULL} -}; - -static void VbNvStorageTest(void) { - - VbNvField* vnf; - VbNvContext c; - uint8_t goodcrc; - uint32_t data; - - memset(&c, 0xA6, sizeof(c)); - - /* Open with invalid data should set defaults */ - TEST_EQ(VbNvSetup(&c), 0, "VbNvSetup()"); - TEST_EQ(c.raw[0], 0x70, "VbNvSetup() reset header byte"); - /* Close then regenerates the CRC */ - TEST_EQ(VbNvTeardown(&c), 0, "VbNvTeardown()"); - TEST_NEQ(c.raw[15], 0, "VbNvTeardown() CRC"); - TEST_EQ(c.raw_changed, 1, "VbNvTeardown() changed"); - goodcrc = c.raw[15]; - /* Another open-close pair should not cause further changes */ - VbNvSetup(&c); - VbNvTeardown(&c); - TEST_EQ(c.raw_changed, 0, "VbNvTeardown() didn't change"); - TEST_EQ(c.raw[15], goodcrc, "VbNvTeardown() CRC same"); - - /* Perturbing the header should force defaults */ - c.raw[0] ^= 0x40; - VbNvSetup(&c); - TEST_EQ(c.raw[0], 0x70, "VbNvSetup() reset header byte again"); - /* Close then regenerates the CRC */ - VbNvTeardown(&c); - TEST_EQ(c.raw_changed, 1, "VbNvTeardown() changed again"); - TEST_EQ(c.raw[15], goodcrc, "VbNvTeardown() CRC same again"); - - /* So should perturbing some other byte */ - TEST_EQ(c.raw[11], 0, "Kernel byte starts at 0"); - c.raw[11] = 12; - VbNvSetup(&c); - TEST_EQ(c.raw[11], 0, "VbNvSetup() reset kernel byte"); - /* Close then regenerates the CRC */ - VbNvTeardown(&c); - TEST_EQ(c.raw_changed, 1, "VbNvTeardown() changed again"); - TEST_EQ(c.raw[15], goodcrc, "VbNvTeardown() CRC same again"); - - /* Clear the kernel and firmware flags */ - VbNvSetup(&c); - TEST_EQ(VbNvGet(&c, VBNV_FIRMWARE_SETTINGS_RESET, &data), 0, - "Get firmware settings reset"); - TEST_EQ(data, 1, "Firmware settings are reset"); - TEST_EQ(VbNvSet(&c, VBNV_FIRMWARE_SETTINGS_RESET, 0), 0, - "Clear firmware settings reset"); - VbNvGet(&c, VBNV_FIRMWARE_SETTINGS_RESET, &data); - TEST_EQ(data, 0, "Firmware settings are clear"); - - TEST_EQ(VbNvGet(&c, VBNV_KERNEL_SETTINGS_RESET, &data), 0, - "Get kernel settings reset"); - TEST_EQ(data, 1, "Kernel settings are reset"); - TEST_EQ(VbNvSet(&c, VBNV_KERNEL_SETTINGS_RESET, 0), 0, - "Clear kernel settings reset"); - VbNvGet(&c, VBNV_KERNEL_SETTINGS_RESET, &data); - TEST_EQ(data, 0, "Kernel settings are clear"); - TEST_EQ(c.raw[0], 0x40, "Header byte now just has the header bit"); - VbNvTeardown(&c); - /* That should have changed the CRC */ - TEST_NEQ(c.raw[15], goodcrc, "VbNvTeardown() CRC changed due to flags clear"); - - /* Test explicitly setting the reset flags again */ - VbNvSetup(&c); - VbNvSet(&c, VBNV_FIRMWARE_SETTINGS_RESET, 1); - VbNvGet(&c, VBNV_FIRMWARE_SETTINGS_RESET, &data); - TEST_EQ(data, 1, "Firmware settings forced reset"); - VbNvSet(&c, VBNV_FIRMWARE_SETTINGS_RESET, 0); - - VbNvSet(&c, VBNV_KERNEL_SETTINGS_RESET, 1); - VbNvGet(&c, VBNV_KERNEL_SETTINGS_RESET, &data); - TEST_EQ(data, 1, "Kernel settings forced reset"); - VbNvSet(&c, VBNV_KERNEL_SETTINGS_RESET, 0); - VbNvTeardown(&c); - - /* Get/set an invalid field */ - VbNvSetup(&c); - TEST_EQ(VbNvGet(&c, -1, &data), 1, "Get invalid setting"); - TEST_EQ(VbNvSet(&c, -1, 0), 1, "Set invalid setting"); - VbNvTeardown(&c); - - /* Test other fields */ - VbNvSetup(&c); - /* Test all defaults first, since some fields alias onto others */ - for (vnf = nvfields; vnf->desc; vnf++) { - printf("Testing field: %s\n", vnf->desc); - TEST_EQ(VbNvGet(&c, vnf->param, &data), 0, " get"); - TEST_EQ(data, vnf->default_value, " default"); - } - /* Now test get/set */ - for (vnf = nvfields; vnf->desc; vnf++) { - printf("Testing field: %s\n", vnf->desc); - TEST_EQ(VbNvSet(&c, vnf->param, vnf->test_value), 0, " set 1"); - TEST_EQ(VbNvGet(&c, vnf->param, &data), 0, " get 1"); - TEST_EQ(data, vnf->test_value, " value 1"); - - TEST_EQ(VbNvSet(&c, vnf->param, vnf->test_value2), 0, " set 2"); - TEST_EQ(VbNvGet(&c, vnf->param, &data), 0, " get 2"); - TEST_EQ(data, vnf->test_value2, " value 2"); - } - VbNvTeardown(&c); - - /* None of those changes should have caused a reset to defaults */ - VbNvSetup(&c); - VbNvGet(&c, VBNV_FIRMWARE_SETTINGS_RESET, &data); - TEST_EQ(data, 0, "Firmware settings are still clear"); - VbNvGet(&c, VBNV_KERNEL_SETTINGS_RESET, &data); - TEST_EQ(data, 0, "Kernel settings are still clear"); - VbNvTeardown(&c); - - /* Verify writing identical settings doesn't cause the CRC to regenerate */ - VbNvSetup(&c); - TEST_EQ(c.regenerate_crc, 0, "No regen CRC on open"); - for (vnf = nvfields; vnf->desc; vnf++) - TEST_EQ(VbNvSet(&c, vnf->param, vnf->test_value2), 0, vnf->desc); - TEST_EQ(c.regenerate_crc, 0, "No regen CRC if data not changed"); - VbNvTeardown(&c); - TEST_EQ(c.raw_changed, 0, "No raw change if data not changed"); - - /* Test out-of-range fields mapping to defaults */ - VbNvSetup(&c); - VbNvSet(&c, VBNV_TRY_B_COUNT, 16); - VbNvGet(&c, VBNV_TRY_B_COUNT, &data); - TEST_EQ(data, 15, "Try b count out of range"); - VbNvSetup(&c); - VbNvSet(&c, VBNV_FW_TRY_COUNT, 16); - VbNvGet(&c, VBNV_FW_TRY_COUNT, &data); - TEST_EQ(data, 15, "Try count out of range"); - VbNvSet(&c, VBNV_RECOVERY_REQUEST, 0x101); - VbNvGet(&c, VBNV_RECOVERY_REQUEST, &data); - TEST_EQ(data, VBNV_RECOVERY_LEGACY, "Recovery request out of range"); - VbNvSet(&c, VBNV_LOCALIZATION_INDEX, 0x102); - VbNvGet(&c, VBNV_LOCALIZATION_INDEX, &data); - TEST_EQ(data, 0, "Localization index out of range"); - VbNvSet(&c, VBNV_FW_RESULT, VBNV_FW_RESULT_UNKNOWN + 100); - VbNvGet(&c, VBNV_FW_RESULT, &data); - TEST_EQ(data, VBNV_FW_RESULT_UNKNOWN, "Firmware result out of range"); - VbNvSet(&c, VBNV_DEV_DEFAULT_BOOT, VBNV_DEV_DEFAULT_BOOT_DISK + 100); - VbNvGet(&c, VBNV_DEV_DEFAULT_BOOT, &data); - TEST_EQ(data, VBNV_DEV_DEFAULT_BOOT_DISK, "Firmware result out of range"); - VbNvTeardown(&c); -} - - -int main(int argc, char* argv[]) -{ - VbNvStorageTest(); - - return gTestSuccess ? 0 : 255; -} diff --git a/tests/vboot_region_tests.c b/tests/vboot_region_tests.c index 464461c7..a08daede 100644 --- a/tests/vboot_region_tests.c +++ b/tests/vboot_region_tests.c @@ -16,12 +16,12 @@ #include "rollback_index.h" #include "test_common.h" #include "vboot_common.h" -#include "vboot_nvstorage.h" #include "vboot_struct.h" +typedef struct VbNvContext VbNvContext; + /* Mock data */ static VbCommonParams cparams; -static VbNvContext vnc; static VbSelectFirmwareParams fparams; VbSelectAndLoadKernelParams kparams; static char gbb_data[4096 + sizeof(GoogleBinaryBlockHeader)]; @@ -45,10 +45,6 @@ static void ResetMocks(void) { ScreenLayout *layout; int gbb_used; - memset(&vnc, 0, sizeof(vnc)); - VbNvSetup(&vnc); - VbNvTeardown(&vnc); /* So CRC gets generated */ - memset(&cparams, 0, sizeof(cparams)); cparams.shared_data_size = sizeof(shared_data); cparams.shared_data_blob = shared_data; @@ -116,12 +112,10 @@ static void ResetMocks(void) { /* Mocked verification functions */ VbError_t VbExNvStorageRead(uint8_t* buf) { - memcpy(buf, vnc.raw, sizeof(vnc.raw)); return VBERROR_SUCCESS; } VbError_t VbExNvStorageWrite(const uint8_t* buf) { - memcpy(vnc.raw, buf, sizeof(vnc.raw)); return VBERROR_SUCCESS; } diff --git a/tests/verify_kernel.c b/tests/verify_kernel.c index 5c48781b..58c01ad9 100644 --- a/tests/verify_kernel.c +++ b/tests/verify_kernel.c @@ -12,6 +12,7 @@ #include "2sysincludes.h" #include "2api.h" #include "2misc.h" +#include "2nvstorage.h" #include "host_common.h" #include "util_misc.h" #include "vboot_common.h" @@ -22,7 +23,6 @@ static uint8_t *diskbuf; static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE]; static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data; -static VbNvContext nvc; static LoadKernelParams params; static VbCommonParams cparams; @@ -111,20 +111,13 @@ int main(int argc, char *argv[]) params.boot_flags = 0; /* - * LoadKernel() cares only about VBNV_DEV_BOOT_SIGNED_ONLY, and only in - * dev mode. So just use defaults. - */ - VbNvSetup(&nvc); - params.nv_context = &nvc; - - /* * Set up vboot context. * * TODO: Propagate this up to higher API levels */ 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) { @@ -139,6 +132,12 @@ int main(int argc, char *argv[]) return 1; } + /* + * 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); + /* Try loading kernel */ rv = LoadKernel(&ctx, ¶ms, &cparams); if (rv != VBERROR_SUCCESS) { @@ -151,7 +150,7 @@ int main(int argc, char *argv[]) printf("Bootloader address: 0x%" PRIx64 "\n", params.bootloader_address); - /* TODO: print other things (partition GUID, nv_context, shared_data) */ + /* TODO: print other things (partition GUID, shared_data) */ printf("Yaay!\n"); return 0; diff --git a/utility/load_kernel_test.c b/utility/load_kernel_test.c index 769c24c5..517a13ff 100644 --- a/utility/load_kernel_test.c +++ b/utility/load_kernel_test.c @@ -30,7 +30,6 @@ /* Global variables for stub functions */ static LoadKernelParams lkp; static VbCommonParams cparams; -static VbNvContext vnc; static FILE *image_file = NULL; @@ -97,9 +96,6 @@ int main(int argc, char* argv[]) { memset(&lkp, 0, sizeof(LoadKernelParams)); lkp.bytes_per_lba = LBA_BYTES; int boot_flags = BOOT_FLAG_RECOVERY; - memset(&vnc, 0, sizeof(VbNvContext)); - VbNvSetup(&vnc); - lkp.nv_context = &vnc; memset(&cparams, 0, sizeof(VbCommonParams)); /* Parse options */ |