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
diff --git a/Android.mk b/Android.mk
index bccf084..083c49b 100644
--- a/Android.mk
+++ b/Android.mk
@@ -32,8 +32,6 @@
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
diff --git a/Makefile b/Makefile
index 013c6d8..d61844b 100644
--- a/Makefile
+++ b/Makefile
@@ -320,7 +320,6 @@
# 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 @@
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 @@
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 @@
${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 0836336..71a0dbb 100644
--- a/firmware/2lib/2nvstorage.c
+++ b/firmware/2lib/2nvstorage.c
@@ -61,12 +61,24 @@
/* 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 e3226a5..1a65469 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 @@
/**
* 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 @@
/**
* 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 @@
/**
* 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 2150929..0b978ed 100644
--- a/firmware/2lib/include/2recovery_reasons.h
+++ b/firmware/2lib/include/2recovery_reasons.h
@@ -48,6 +48,14 @@
/* 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 @@
/* 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 ecb5d00..0000000
--- 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 ca49b3c..08e5578 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 @@
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 2f23753..fbb04e1 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 1879b84..26d32d5 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 @@
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 @@
(unsigned)get_info_flags);
lkp.fwmp = &fwmp;
- lkp.nv_context = &vnc;
lkp.disk_handle = NULL;
/* Find disks */
@@ -122,7 +104,7 @@
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 @@
/* 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 @@
{
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 @@
*/
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 @@
*/
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 @@
* 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 @@
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 @@
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 @@
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 @@
void *boot_image,
size_t image_size)
{
- VbError_t retval;
VbPublicKey* kernel_subkey = NULL;
uint8_t *kbuf;
VbKeyBlockHeader *key_block;
@@ -495,31 +474,19 @@
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 @@
* 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 @@
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 @@
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 @@
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 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 24ac072..7bf341e 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 @@
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 2027244..c5030ef 100644
--- a/firmware/lib/vboot_kernel.c
+++ b/firmware/lib/vboot_kernel.c
@@ -438,7 +438,7 @@
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 @@
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 @@
/* 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 9dc9dc3..0000000
--- 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 c44b70b..4d913f0 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 @@
* recovery mode.
*/
vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST,
- VBNV_RECOVERY_NOT_REQUESTED);
+ VB2_RECOVERY_NOT_REQUESTED);
}
return retval;
}
@@ -182,9 +181,9 @@
/* 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 @@
*/
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 @@
/*
* 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 @@
* 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 b4fdd25..d1c2b1d 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 @@
* recovery mode.
*/
vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST,
- VBNV_RECOVERY_NOT_REQUESTED);
+ VB2_RECOVERY_NOT_REQUESTED);
}
return retval;
}
@@ -355,13 +354,13 @@
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 @@
/* 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 @@
/*
* 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 @@
* 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 0811d81..a170131 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 @@
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 2774178..0a30841 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 @@
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 @@
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 @@
__FUNCTION__, nvctx_path);
goto out;
}
- memcpy(vnc->raw, sector+offset, size);
+ memcpy(ctx->nvdata, sector+offset, size);
rv = 0;
out:
@@ -289,7 +287,7 @@
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 @@
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 @@
__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 @@
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 c0b2587..5c92c9d 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 9f8ca66..f026a14 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 @@
}
-int VbReadNvStorage(VbNvContext* vnc)
+int vb2_read_nv_storage(struct vb2_context *ctx)
{
unsigned offs, blksz;
@@ -168,18 +167,18 @@
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 @@
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 @@
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 @@
/* 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 @@
* 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 @@
/* 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 @@
* 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 64e0c7c..64b6b1d 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 216ff32..5a75861 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 @@
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;
+ vb2_nv_init(&cached_ctx);
+
+ /* TODO: If vnc.raw_changed, attempt to reopen NVRAM for write
+ * and save the new defaults. If we're able to, log. */
+
vnc_read = 1;
}
- 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: release lock */
-
- 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 @@
/* 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 @@
} 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 @@
} 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 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 50198b0..030d9d6 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 @@
/* 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 1d5f8c1..a8c9b78 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 @@
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 @@
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 @@
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 @@
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 @@
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 6ec74b2..a65fc26 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 @@
/* 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 @@
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 @@
/* 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 384c978..da0af9b 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 @@
* 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 @@
/* 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 @@
* 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 @@
/* 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 @@
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 e00c928..e239192 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 077c07a..2d7c2e7 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 verify_data_fail;
static int unpack_key_fail;
-static VbNvContext vnc;
static VbKeyBlockHeader kbh;
static VbKernelPreambleHeader kph;
@@ -61,9 +62,8 @@
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 @@
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 @@
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 a24cde8..801ff72 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 3214d44..dd63bb4 100644
--- a/tests/vboot_api_kernel_tests.c
+++ b/tests/vboot_api_kernel_tests.c
@@ -84,7 +84,7 @@
.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 @@
.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 @@
.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 @@
.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 @@
.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 @@
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 99d9bd4..94bbb0a 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 33421b5..a0f9ead 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 b1e1635..d581b37 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 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 @@
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 @@
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 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 LoadKernelTest(void)
{
- uint32_t u;
-
ResetMocks();
TestLoadKernel(0, "First kernel good");
@@ -612,8 +597,8 @@
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 @@
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 @@
/* 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 c461978..0000000
--- 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 464461c..a08daed 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 @@
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 @@
/* 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 5c48781..58c01ad 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 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 @@
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 @@
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 @@
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 769c24c..517a13f 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 @@
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 */