coreboot-mirror
/
vboot
mirror of https://review.coreboot.org/vboot.git
1
0
Fork 0
Code Issues Releases Wiki Activity

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
This commit is contained in:
Randall Spangler 2017-11-27 15:37:13 -08:00 committed by chrome-bot
parent 626340420e
commit dff5852c2f
35 changed files with 413 additions and 1549 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
Android.mk
View File

@ -32,8 +32,6 @@ VBINIT_SRCS = \
firmware/lib/utility.c \
firmware/lib/vboot_api_init.c \
firmware/lib/vboot_common_init.c \
firmware/lib/vboot_nvstorage.c \
firmware/lib/vboot_nvstorage_rollback.c \
firmware/lib/region-init.c \
# Additional firmware library sources needed by VbSelectFirmware() call

5
Makefile
View File

@ -320,7 +320,6 @@ BDBLIB = ${BUILD}/bdb.a
# Firmware library sources needed by VbInit() call
VBINIT_SRCS = \
firmware/lib/vboot_common_init.c \
firmware/lib/vboot_nvstorage.c \
firmware/lib/region-init.c \
# Additional firmware library sources needed by VbSelectFirmware() call
@ -496,13 +495,13 @@ HOSTLIB_SRCS = \
cgpt/cgpt_create.c \
cgpt/cgpt_prioritize.c \
firmware/2lib/2crc8.c \
firmware/2lib/2nvstorage.c \
firmware/2lib/2stub.c \
firmware/lib/cgptlib/cgptlib_internal.c \
firmware/lib/cgptlib/crc32.c \
firmware/lib/gpt_misc.c \
${TLCL_SRCS} \
firmware/lib/utility_string.c \
firmware/lib/vboot_nvstorage.c \
firmware/stub/tpm_lite_stub.c \
firmware/stub/vboot_api_stub.c \
firmware/stub/vboot_api_stub_disk.c \
@ -736,7 +735,6 @@ TEST_NAMES = \
tests/vboot_common_tests \
tests/vboot_display_tests \
tests/vboot_kernel_tests \
tests/vboot_nvstorage_test \
tests/verify_kernel
ifeq (${TPM2_MODE},)
@ -1440,7 +1438,6 @@ endif
${RUNTEST} ${BUILD_RUN}/tests/vboot_common_tests
${RUNTEST} ${BUILD_RUN}/tests/vboot_display_tests
${RUNTEST} ${BUILD_RUN}/tests/vboot_kernel_tests
${RUNTEST} ${BUILD_RUN}/tests/vboot_nvstorage_test
.PHONY: run2tests
run2tests: test_setup

18
firmware/2lib/2nvstorage.c
View File

@ -61,12 +61,24 @@ void vb2_nv_init(struct vb2_context *ctx)
/* Regenerate CRC */
vb2_nv_regen_crc(ctx);
/* Set status flag */
sd->status |= VB2_SD_STATUS_NV_REINIT;
/*
* Set status flag.
*
* Note that early in some calling sequences, shared data may
* not be available. For example, if there is an error
* allocating the context work buffer, and we're trying to
* initialize non-volatile storage so we can write a recovery
* request. In that case, sd will be NULL. So while we don't
* usually need to check for that in other library functions,
* here we do.
*/
if (sd)
sd->status |= VB2_SD_STATUS_NV_REINIT;
/* TODO: unit test for status flag being set */
}
sd->status |= VB2_SD_STATUS_NV_INIT;
if (sd)
sd->status |= VB2_SD_STATUS_NV_INIT;
}
/* Macro for vb2_nv_get() single-bit settings to reduce duplicate code. */

18
firmware/2lib/include/2nvstorage.h
View File

@ -8,6 +8,8 @@
#ifndef VBOOT_REFERENCE_VBOOT_2NVSTORAGE_H_
#define VBOOT_REFERENCE_VBOOT_2NVSTORAGE_H_
struct vb2_context;
enum vb2_nv_param {
/*
* Parameter values have been reset to defaults (flag for firmware).
@ -149,6 +151,16 @@ int vb2_nv_check_crc(const struct vb2_context *ctx);
/**
* Initialize the non-volatile storage context and verify its CRC.
*
* This may be called before vb2_context_init(), as long as:
*
* 1) The ctx structure has been cleared to 0.
* 2) Existing non-volatile data, if any, has been stored to ctx->nvdata[].
*
* This is to support using the non-volatile storage functions to request
* recovery if there is an error allocating the workbuf for the context. It
* also allows host-side code to use this library without setting up a bunch of
* extra context.
*
* @param ctx Context pointer
*/
void vb2_nv_init(struct vb2_context *ctx);
@ -156,6 +168,8 @@ void vb2_nv_init(struct vb2_context *ctx);
/**
* Read a non-volatile value.
*
* Valid only after calling vb2_nv_init().
*
* @param ctx Context pointer
* @param param Parameter to read
* @return The value of the parameter. If you somehow force an invalid
@ -166,7 +180,9 @@ uint32_t vb2_nv_get(struct vb2_context *ctx, enum vb2_nv_param param);
/**
* Write a non-volatile value.
*
* Ignores writes to unknown params.
* Ignores writes to unknown params. Valid only after calling vb2_nv_init().
* If this changes ctx->nvdata[], it will set VB2_CONTEXT_NVDATA_CHANGED in
* ctx->flags.
*
* @param ctx Context pointer
* @param param Parameter to write

11
firmware/2lib/include/2recovery_reasons.h
View File

@ -48,6 +48,14 @@ enum vb2_nv_recovery {
/* Test error from LoadFirmware() (deprecated) */
VB2_RECOVERY_RO_TEST_LF = 0x09,
/*
* RW firmware failed signature check (neither RW firmware slot was
* valid). Recovery reason is VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN +
* the check value for the slot which came closest to validating; see
* VBSD_LF_CHECK_* in vboot_struct.h.
*/
VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN = 0x10,
/* Latest tried RW firmware keyblock verification failed */
VB2_RECOVERY_FW_KEYBLOCK = 0x13,
@ -63,6 +71,9 @@ enum vb2_nv_recovery {
/* Latest tried RW firmware body verification failed */
VB2_RECOVERY_FW_BODY = 0x1b,
/* Highest reason for failed RW firmware signature check */
VB2_RECOVERY_RO_INVALID_RW_CHECK_MAX = 0x1f,
/*
* Firmware boot failure outside of verified boot (RAM init, missing
* SSD, etc.).

358
firmware/include/vboot_nvstorage.h
View File

@ -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_ */

6
firmware/lib/include/load_kernel_fw.h
View File

@ -10,7 +10,6 @@
#define VBOOT_REFERENCE_LOAD_KERNEL_FW_H_
#include "vboot_api.h"
#include "vboot_nvstorage.h"
struct vb2_context;
@ -38,11 +37,6 @@ typedef struct LoadKernelParams {
uint64_t kernel_buffer_size;
/* Boot flags */
uint64_t boot_flags;
/*
* Context for NV storage. Caller is responsible for calling
* VbNvSetup() and VbNvTeardown() on the context.
*/
VbNvContext *nv_context;
/* Firmware management parameters; may be NULL if not present. */
const struct RollbackSpaceFwmp *fwmp;

2
firmware/lib/include/vboot_display.h
View File

@ -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;

131
firmware/lib/vboot_api_kernel.c
View File

@ -23,10 +23,8 @@
#include "vboot_api.h"
#include "vboot_common.h"
#include "vboot_kernel.h"
#include "vboot_nvstorage.h"
/* Global variables */
static VbNvContext vnc;
static struct RollbackSpaceFwmp fwmp;
static LoadKernelParams lkp;
static struct vb2_context ctx;
@ -57,29 +55,14 @@ static void VbSetRecoveryRequest(struct vb2_context *ctx,
vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST, recovery_request);
}
static void VbNvLoad(void)
{
VbExNvStorageRead(vnc.raw);
VbNvSetup(&vnc);
}
static void VbNvCommit(void)
{
VbNvTeardown(&vnc);
if (vnc.raw_changed)
VbExNvStorageWrite(vnc.raw);
}
void vb2_nv_commit(struct vb2_context *ctx)
{
/* Copy nvdata back to old vboot1 nv context if needed */
if (ctx->flags & VB2_CONTEXT_NVDATA_CHANGED) {
memcpy(vnc.raw, ctx->nvdata, VB2_NVDATA_SIZE);
vnc.raw_changed = 1;
ctx->flags &= ~VB2_CONTEXT_NVDATA_CHANGED;
}
/* Exit if nothing has changed */
if (!(ctx->flags & VB2_CONTEXT_NVDATA_CHANGED))
return;
VbNvCommit();
ctx->flags &= ~VB2_CONTEXT_NVDATA_CHANGED;
VbExNvStorageWrite(ctx->nvdata);
}
uint32_t vb2_get_fwmp_flags(void)
@ -112,7 +95,6 @@ uint32_t VbTryLoadKernel(struct vb2_context *ctx, VbCommonParams *cparams,
(unsigned)get_info_flags);
lkp.fwmp = &fwmp;
lkp.nv_context = &vnc;
lkp.disk_handle = NULL;
/* Find disks */
@ -122,7 +104,7 @@ uint32_t VbTryLoadKernel(struct vb2_context *ctx, VbCommonParams *cparams,
VB2_DEBUG("VbTryLoadKernel() found %d disks\n", (int)disk_count);
if (0 == disk_count) {
VbSetRecoveryRequest(ctx, VBNV_RECOVERY_RW_NO_DISK);
VbSetRecoveryRequest(ctx, VB2_RECOVERY_RW_NO_DISK);
return VBERROR_NO_DISK_FOUND;
}
@ -171,7 +153,7 @@ uint32_t VbTryLoadKernel(struct vb2_context *ctx, VbCommonParams *cparams,
/* If we didn't find any good kernels, don't return a disk handle. */
if (VBERROR_SUCCESS != retval) {
VbSetRecoveryRequest(ctx, VBNV_RECOVERY_RW_NO_KERNEL);
VbSetRecoveryRequest(ctx, VB2_RECOVERY_RW_NO_KERNEL);
lkp.disk_handle = NULL;
}
@ -188,7 +170,8 @@ VbError_t VbBootNormal(struct vb2_context *ctx, VbCommonParams *cparams)
{
VbSharedDataHeader *shared =
(VbSharedDataHeader *)cparams->shared_data_blob;
uint32_t max_rollforward;
uint32_t max_rollforward = vb2_nv_get(ctx,
VB2_NV_KERNEL_MAX_ROLLFORWARD);
/* Boot from fixed disk only */
VB2_DEBUG("Entering\n");
@ -219,35 +202,32 @@ VbError_t VbBootNormal(struct vb2_context *ctx, VbCommonParams *cparams)
*/
if (rv == VBERROR_INVALID_KERNEL_FOUND) {
VB2_DEBUG("Trying FW B; only found invalid kernels.\n");
VbSetRecoveryRequest(ctx, VBNV_RECOVERY_NOT_REQUESTED);
VbSetRecoveryRequest(ctx, VB2_RECOVERY_NOT_REQUESTED);
}
return rv;
}
/* Limit kernel version rollforward if needed */
if (0 == VbNvGet(&vnc, VBNV_KERNEL_MAX_ROLLFORWARD, &max_rollforward)) {
/*
* Can't limit kernel version to less than the version
* currently in the TPM. That is, we're limiting rollforward,
* not allowing rollback.
*/
if (max_rollforward < shared->kernel_version_tpm_start)
max_rollforward = shared->kernel_version_tpm_start;
/*
* Limit kernel version rollforward if needed. Can't limit kernel
* version to less than the version currently in the TPM. That is,
* we're limiting rollforward, not allowing rollback.
*/
if (max_rollforward < shared->kernel_version_tpm_start)
max_rollforward = shared->kernel_version_tpm_start;
if (shared->kernel_version_tpm > max_rollforward) {
VB2_DEBUG("Limiting TPM kernel version roll-forward "
"to 0x%x < 0x%x\n",
max_rollforward, shared->kernel_version_tpm);
if (shared->kernel_version_tpm > max_rollforward) {
VB2_DEBUG("Limiting TPM kernel version roll-forward "
"to 0x%x < 0x%x\n",
max_rollforward, shared->kernel_version_tpm);
shared->kernel_version_tpm = max_rollforward;
}
shared->kernel_version_tpm = max_rollforward;
}
if ((shared->kernel_version_tpm > shared->kernel_version_tpm_start) &&
RollbackKernelWrite(shared->kernel_version_tpm)) {
VB2_DEBUG("Error writing kernel versions to TPM.\n");
VbSetRecoveryRequest(ctx, VBNV_RECOVERY_RW_TPM_W_ERROR);
VbSetRecoveryRequest(ctx, VB2_RECOVERY_RW_TPM_W_ERROR);
return VBERROR_TPM_WRITE_KERNEL;
}
@ -285,8 +265,8 @@ static VbError_t vb2_kernel_setup(VbCommonParams *cparams,
*/
memset(&ctx, 0, sizeof(ctx));
VbNvLoad();
memcpy(ctx.nvdata, vnc.raw, VB2_NVDATA_SIZE);
VbExNvStorageRead(ctx.nvdata);
vb2_nv_init(&ctx);
if (shared->recovery_reason)
ctx.flags |= VB2_CONTEXT_RECOVERY_MODE;
@ -325,7 +305,7 @@ static VbError_t vb2_kernel_setup(VbCommonParams *cparams,
* If we're in recovery mode just to do memory retraining, all we
* need to do is reboot.
*/
if (shared->recovery_reason == VBNV_RECOVERY_TRAIN_AND_REBOOT) {
if (shared->recovery_reason == VB2_RECOVERY_TRAIN_AND_REBOOT) {
VB2_DEBUG("Reboot after retraining in recovery.\n");
return VBERROR_REBOOT_REQUIRED;
}
@ -355,7 +335,7 @@ static VbError_t vb2_kernel_setup(VbCommonParams *cparams,
VB2_DEBUG("Unable to get kernel versions from TPM\n");
if (!shared->recovery_reason) {
VbSetRecoveryRequest(&ctx,
VBNV_RECOVERY_RW_TPM_R_ERROR);
VB2_RECOVERY_RW_TPM_R_ERROR);
return VBERROR_TPM_READ_KERNEL;
}
}
@ -369,7 +349,7 @@ static VbError_t vb2_kernel_setup(VbCommonParams *cparams,
VB2_DEBUG("Unable to get FWMP from TPM\n");
if (!shared->recovery_reason) {
VbSetRecoveryRequest(&ctx,
VBNV_RECOVERY_RW_TPM_R_ERROR);
VB2_RECOVERY_RW_TPM_R_ERROR);
return VBERROR_TPM_READ_FWMP;
}
}
@ -398,7 +378,7 @@ static VbError_t vb2_kernel_phase4(VbCommonParams *cparams,
if (!shared->recovery_reason &&
RollbackKernelLock(shared->recovery_reason)) {
VB2_DEBUG("Error locking kernel versions.\n");
VbSetRecoveryRequest(&ctx, VBNV_RECOVERY_RW_TPM_L_ERROR);
VbSetRecoveryRequest(&ctx, VB2_RECOVERY_RW_TPM_L_ERROR);
return VBERROR_TPM_LOCK_KERNEL;
}
@ -484,7 +464,6 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams,
void *boot_image,
size_t image_size)
{
VbError_t retval;
VbPublicKey* kernel_subkey = NULL;
uint8_t *kbuf;
VbKeyBlockHeader *key_block;
@ -495,31 +474,19 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams,
int hash_only = 0;
int dev_switch;
uint32_t allow_fastboot_full_cap = 0;
uint8_t *workbuf = NULL;
struct vb2_workbuf wb;
if ((boot_image == NULL) || (image_size == 0))
return VBERROR_INVALID_PARAMETER;
VbError_t retval = vb2_kernel_setup(cparams, kparams);
if (retval)
goto fail;
/* Clear output params in case we fail. */
kparams->disk_handle = NULL;
kparams->partition_number = 0;
kparams->bootloader_address = 0;
kparams->bootloader_size = 0;
kparams->flags = 0;
memset(kparams->partition_guid, 0, sizeof(kparams->partition_guid));
if ((boot_image == NULL) || (image_size == 0)) {
retval = VBERROR_INVALID_PARAMETER;
goto fail;
}
kbuf = boot_image;
/* Read GBB Header */
cparams->bmp = NULL;
cparams->gbb = malloc(sizeof(*cparams->gbb));
retval = VbGbbReadHeader_static(cparams, cparams->gbb);
if (VBERROR_SUCCESS != retval) {
VB2_DEBUG("Gbb read header failed.\n");
return retval;
}
/*
* We don't care verifying the image if:
* 1. dev-mode switch is on and
@ -529,10 +496,8 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams,
* Check only the integrity of the image.
*/
dev_switch = shared->flags & VBSD_BOOT_DEV_SWITCH_ON;
VbNvLoad();
VbNvGet(&vnc, VBNV_DEV_BOOT_FASTBOOT_FULL_CAP,
&allow_fastboot_full_cap);
allow_fastboot_full_cap =
vb2_nv_get(&ctx, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP);
if (0 == allow_fastboot_full_cap) {
allow_fastboot_full_cap = !!(cparams->gbb->flags &
@ -547,7 +512,7 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams,
retval = VbGbbReadRecoveryKey(cparams, &kernel_subkey);
if (VBERROR_SUCCESS != retval) {
VB2_DEBUG("Gbb Read Recovery key failed.\n");
return retval;
goto fail;
}
}
@ -555,10 +520,7 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams,
retval = VBERROR_INVALID_KERNEL_FOUND;
/* Allocate work buffer */
workbuf = (uint8_t *)malloc(VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE);
if (!workbuf)
goto fail;
vb2_workbuf_init(&wb, workbuf, VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE);
vb2_workbuf_from_ctx(&ctx, &wb);
/* Verify the key block. */
key_block = (VbKeyBlockHeader *)kbuf;
@ -647,11 +609,9 @@ VbError_t VbVerifyMemoryBootImage(VbCommonParams *cparams,
retval = VBERROR_SUCCESS;
fail:
VbApiKernelFree(cparams);
vb2_kernel_cleanup(&ctx, cparams);
if (NULL != kernel_subkey)
free(kernel_subkey);
if (NULL != workbuf)
free(workbuf);
return retval;
}
@ -667,12 +627,13 @@ VbError_t VbUnlockDevice(void)
VbError_t VbLockDevice(void)
{
VbNvLoad();
VB2_DEBUG("Storing request to leave dev-mode.\n");
VbNvSet(&vnc, VBNV_DISABLE_DEV_REQUEST, 1);
VbNvCommit();
memset(&ctx, 0, sizeof(ctx));
VbExNvStorageRead(ctx.nvdata);
vb2_nv_init(&ctx);
vb2_nv_set(&ctx, VB2_NV_DISABLE_DEV_REQUEST, 1);
vb2_nv_commit(&ctx);
VB2_DEBUG("Mode change will take effect on next reboot.\n");

143
firmware/lib/vboot_display.c
View File

@ -19,7 +19,6 @@
#include "vboot_api.h"
#include "vboot_common.h"
#include "vboot_display.h"
#include "vboot_nvstorage.h"
static uint32_t disp_current_screen = VB_SCREEN_BLANK;
static uint32_t disp_current_index = 0;
@ -442,154 +441,154 @@ static void FillInSha1Sum(char *outbuf, VbPublicKey *key)
const char *RecoveryReasonString(uint8_t code)
{
switch(code) {
case VBNV_RECOVERY_NOT_REQUESTED:
case VB2_RECOVERY_NOT_REQUESTED:
return "Recovery not requested";
case VBNV_RECOVERY_LEGACY:
case VB2_RECOVERY_LEGACY:
return "Recovery requested from legacy utility";
case VBNV_RECOVERY_RO_MANUAL:
case VB2_RECOVERY_RO_MANUAL:
return "recovery button pressed";
case VBNV_RECOVERY_RO_INVALID_RW:
case VB2_RECOVERY_RO_INVALID_RW:
return "RW firmware failed signature check";
case VBNV_RECOVERY_RO_S3_RESUME:
case VB2_RECOVERY_RO_S3_RESUME:
return "S3 resume failed";
case VBNV_RECOVERY_DEP_RO_TPM_ERROR:
case VB2_RECOVERY_DEP_RO_TPM_ERROR:
return "TPM error in read-only firmware";
case VBNV_RECOVERY_RO_SHARED_DATA:
case VB2_RECOVERY_RO_SHARED_DATA:
return "Shared data error in read-only firmware";
case VBNV_RECOVERY_RO_TEST_S3:
case VB2_RECOVERY_RO_TEST_S3:
return "Test error from S3Resume()";
case VBNV_RECOVERY_RO_TEST_LFS:
case VB2_RECOVERY_RO_TEST_LFS:
return "Test error from LoadFirmwareSetup()";
case VBNV_RECOVERY_RO_TEST_LF:
case VB2_RECOVERY_RO_TEST_LF:
return "Test error from LoadFirmware()";
case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_NOT_DONE:
case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_NOT_DONE:
return "RW firmware check not done";
case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_DEV_MISMATCH:
case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_DEV_MISMATCH:
return "RW firmware developer flag mismatch";
case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_REC_MISMATCH:
case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_REC_MISMATCH:
return "RW firmware recovery flag mismatch";
case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN +
case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN +
VBSD_LF_CHECK_VERIFY_KEYBLOCK:
return "RW firmware unable to verify key block";
case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_KEY_ROLLBACK:
case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_KEY_ROLLBACK:
return "RW firmware key version rollback detected";
case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN +
case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN +
VBSD_LF_CHECK_DATA_KEY_PARSE:
return "RW firmware unable to parse data key";
case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN +
case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN +
VBSD_LF_CHECK_VERIFY_PREAMBLE:
return "RW firmware unable to verify preamble";
case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_FW_ROLLBACK:
case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_FW_ROLLBACK:
return "RW firmware version rollback detected";
case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_GET_FW_BODY:
case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_GET_FW_BODY:
return "RW firmware unable to get firmware body";
case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN +
case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN +
VBSD_LF_CHECK_HASH_WRONG_SIZE:
return "RW firmware hash is wrong size";
case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_VERIFY_BODY:
case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_VERIFY_BODY:
return "RW firmware unable to verify firmware body";
case VBNV_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_NO_RO_NORMAL:
case VB2_RECOVERY_RO_INVALID_RW_CHECK_MIN + VBSD_LF_CHECK_NO_RO_NORMAL:
return "RW firmware read-only normal path is not supported";
case VBNV_RECOVERY_RO_FIRMWARE:
case VB2_RECOVERY_RO_FIRMWARE:
return "Firmware problem outside of verified boot";
case VBNV_RECOVERY_RO_TPM_REBOOT:
case VB2_RECOVERY_RO_TPM_REBOOT:
return "TPM requires a system reboot (should be transient)";
case VBNV_RECOVERY_EC_SOFTWARE_SYNC:
case VB2_RECOVERY_EC_SOFTWARE_SYNC:
return "EC software sync error";
case VBNV_RECOVERY_EC_UNKNOWN_IMAGE:
case VB2_RECOVERY_EC_UNKNOWN_IMAGE:
return "EC software sync unable to determine active EC image";
case VBNV_RECOVERY_DEP_EC_HASH:
case VB2_RECOVERY_DEP_EC_HASH:
return "EC software sync error obtaining EC image hash";
case VBNV_RECOVERY_EC_EXPECTED_IMAGE:
case VB2_RECOVERY_EC_EXPECTED_IMAGE:
return "EC software sync error "
"obtaining expected EC image from BIOS";
case VBNV_RECOVERY_EC_EXPECTED_HASH:
case VB2_RECOVERY_EC_EXPECTED_HASH:
return "EC software sync error "
"obtaining expected EC hash from BIOS";
case VBNV_RECOVERY_EC_HASH_MISMATCH:
case VB2_RECOVERY_EC_HASH_MISMATCH:
return "EC software sync error "
"comparing expected EC hash and image";
case VBNV_RECOVERY_EC_UPDATE:
case VB2_RECOVERY_EC_UPDATE:
return "EC software sync error updating EC";
case VBNV_RECOVERY_EC_JUMP_RW:
case VB2_RECOVERY_EC_JUMP_RW:
return "EC software sync unable to jump to EC-RW";
case VBNV_RECOVERY_EC_PROTECT:
case VB2_RECOVERY_EC_PROTECT:
return "EC software sync protection error";
case VBNV_RECOVERY_VB2_SECDATA_INIT:
case VB2_RECOVERY_SECDATA_INIT:
return "Secure NVRAM (TPM) initialization error";
case VBNV_RECOVERY_VB2_GBB_HEADER:
case VB2_RECOVERY_GBB_HEADER:
return "Error parsing GBB header";
case VBNV_RECOVERY_VB2_TPM_CLEAR_OWNER:
case VB2_RECOVERY_TPM_CLEAR_OWNER:
return "Error trying to clear TPM owner";
case VBNV_RECOVERY_VB2_DEV_SWITCH:
case VB2_RECOVERY_DEV_SWITCH:
return "Error reading or updating developer switch";
case VBNV_RECOVERY_VB2_FW_SLOT:
case VB2_RECOVERY_FW_SLOT:
return "Error selecting RW firmware slot";
case VBNV_RECOVERY_RO_UNSPECIFIED:
case VB2_RECOVERY_RO_UNSPECIFIED:
return "Unspecified/unknown error in RO firmware";
case VBNV_RECOVERY_RW_DEV_SCREEN:
case VB2_RECOVERY_RW_DEV_SCREEN:
return "User requested recovery from dev-mode warning screen";
case VBNV_RECOVERY_RW_NO_OS:
case VB2_RECOVERY_RW_NO_OS:
return "No OS kernel detected (or kernel rollback attempt?)";
case VBNV_RECOVERY_RW_INVALID_OS:
case VB2_RECOVERY_RW_INVALID_OS:
return "OS kernel failed signature check";
case VBNV_RECOVERY_DEP_RW_TPM_ERROR:
case VB2_RECOVERY_DEP_RW_TPM_ERROR:
return "TPM error in rewritable firmware";
case VBNV_RECOVERY_RW_DEV_MISMATCH:
case VB2_RECOVERY_RW_DEV_MISMATCH:
return "RW firmware in dev mode, but dev switch is off";
case VBNV_RECOVERY_RW_SHARED_DATA:
case VB2_RECOVERY_RW_SHARED_DATA:
return "Shared data error in rewritable firmware";
case VBNV_RECOVERY_RW_TEST_LK:
case VB2_RECOVERY_RW_TEST_LK:
return "Test error from LoadKernel()";
case VBNV_RECOVERY_DEP_RW_NO_DISK:
case VB2_RECOVERY_DEP_RW_NO_DISK:
return "No bootable disk found";
case VBNV_RECOVERY_TPM_E_FAIL:
case VB2_RECOVERY_TPM_E_FAIL:
return "TPM error that was not fixed by reboot";
case VBNV_RECOVERY_RO_TPM_S_ERROR:
case VB2_RECOVERY_RO_TPM_S_ERROR:
return "TPM setup error in read-only firmware";
case VBNV_RECOVERY_RO_TPM_W_ERROR:
case VB2_RECOVERY_RO_TPM_W_ERROR:
return "TPM write error in read-only firmware";
case VBNV_RECOVERY_RO_TPM_L_ERROR:
case VB2_RECOVERY_RO_TPM_L_ERROR:
return "TPM lock error in read-only firmware";
case VBNV_RECOVERY_RO_TPM_U_ERROR:
case VB2_RECOVERY_RO_TPM_U_ERROR:
return "TPM update error in read-only firmware";
case VBNV_RECOVERY_RW_TPM_R_ERROR:
case VB2_RECOVERY_RW_TPM_R_ERROR:
return "TPM read error in rewritable firmware";
case VBNV_RECOVERY_RW_TPM_W_ERROR:
case VB2_RECOVERY_RW_TPM_W_ERROR:
return "TPM write error in rewritable firmware";
case VBNV_RECOVERY_RW_TPM_L_ERROR:
case VB2_RECOVERY_RW_TPM_L_ERROR:
return "TPM lock error in rewritable firmware";
case VBNV_RECOVERY_EC_HASH_FAILED:
case VB2_RECOVERY_EC_HASH_FAILED:
return "EC software sync unable to get EC image hash";
case VBNV_RECOVERY_EC_HASH_SIZE:
case VB2_RECOVERY_EC_HASH_SIZE:
return "EC software sync invalid image hash size";
case VBNV_RECOVERY_LK_UNSPECIFIED:
case VB2_RECOVERY_LK_UNSPECIFIED:
return "Unspecified error while trying to load kernel";
case VBNV_RECOVERY_RW_NO_DISK:
case VB2_RECOVERY_RW_NO_DISK:
return "No bootable storage device in system";
case VBNV_RECOVERY_RW_NO_KERNEL:
case VB2_RECOVERY_RW_NO_KERNEL:
return "No bootable kernel found on disk";
case VBNV_RECOVERY_RW_BCB_ERROR:
case VB2_RECOVERY_RW_BCB_ERROR:
return "BCB partition error on disk";
case VBNV_RECOVERY_FW_FASTBOOT:
case VB2_RECOVERY_FW_FASTBOOT:
return "Fastboot-mode requested in firmware";
case VBNV_RECOVERY_RO_TPM_REC_HASH_L_ERROR:
case VB2_RECOVERY_RO_TPM_REC_HASH_L_ERROR:
return "Recovery hash space lock error in RO firmware";
case VBNV_RECOVERY_RW_UNSPECIFIED:
case VB2_RECOVERY_RW_UNSPECIFIED:
return "Unspecified/unknown error in RW firmware";
case VBNV_RECOVERY_KE_DM_VERITY:
case VB2_RECOVERY_KE_DM_VERITY:
return "DM-verity error";
case VBNV_RECOVERY_KE_UNSPECIFIED:
case VB2_RECOVERY_KE_UNSPECIFIED:
return "Unspecified/unknown error in kernel";
case VBNV_RECOVERY_US_TEST:
case VB2_RECOVERY_US_TEST:
return "Recovery mode test from user-mode";
case VBNV_RECOVERY_BCB_USER_MODE:
case VB2_RECOVERY_BCB_USER_MODE:
return "User-mode requested recovery via BCB";
case VBNV_RECOVERY_US_FASTBOOT:
case VB2_RECOVERY_US_FASTBOOT:
return "User-mode requested fastboot mode";
case VBNV_RECOVERY_TRAIN_AND_REBOOT:
case VB2_RECOVERY_TRAIN_AND_REBOOT:
return "User-mode requested DRAM train and reboot";
case VBNV_RECOVERY_US_UNSPECIFIED:
case VB2_RECOVERY_US_UNSPECIFIED:
return "Unspecified/unknown error in user-mode";
}
return "We have no idea what this means";

8
firmware/lib/vboot_kernel.c
View File

@ -438,7 +438,7 @@ VbError_t LoadKernel(struct vb2_context *ctx, LoadKernelParams *params,
uint32_t lowest_version = LOWEST_TPM_VERSION;
VbError_t retval = VBERROR_UNKNOWN;
int recovery = VBNV_RECOVERY_LK_UNSPECIFIED;
int recovery = VB2_RECOVERY_LK_UNSPECIFIED;
/* Clear output params in case we fail */
params->partition_number = 0;
@ -644,11 +644,11 @@ gpt_done:
retval = VBERROR_SUCCESS;
} else if (found_partitions > 0) {
shcall->check_result = VBSD_LKC_CHECK_INVALID_PARTITIONS;
recovery = VBNV_RECOVERY_RW_INVALID_OS;
recovery = VB2_RECOVERY_RW_INVALID_OS;
retval = VBERROR_INVALID_KERNEL_FOUND;
} else {
shcall->check_result = VBSD_LKC_CHECK_NO_PARTITIONS;
recovery = VBNV_RECOVERY_RW_NO_OS;
recovery = VB2_RECOVERY_RW_NO_OS;
retval = VBERROR_NO_KERNEL_FOUND;
}
@ -656,7 +656,7 @@ load_kernel_exit:
/* Store recovery request, if any */
vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST,
VBERROR_SUCCESS != retval ?
recovery : VBNV_RECOVERY_NOT_REQUESTED);
recovery : VB2_RECOVERY_NOT_REQUESTED);
/* Store how much shared data we used, if any */
cparams->shared_data_size = shared->data_used;

496
firmware/lib/vboot_nvstorage.c
View File

@ -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, &current) && 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;
}

15
firmware/lib/vboot_ui.c
View File

@ -25,7 +25,6 @@
#include "vboot_common.h"
#include "vboot_display.h"
#include "vboot_kernel.h"
#include "vboot_nvstorage.h"
static void VbAllowUsbBoot(struct vb2_context *ctx)
{
@ -84,7 +83,7 @@ uint32_t VbTryUsb(struct vb2_context *ctx, VbCommonParams *cparams)
* recovery mode.
*/
vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST,
VBNV_RECOVERY_NOT_REQUESTED);
VB2_RECOVERY_NOT_REQUESTED);
}
return retval;
}
@ -182,9 +181,9 @@ VbError_t vb2_developer_ui(struct vb2_context *ctx, VbCommonParams *cparams)
/* Check if the default is to boot using disk, usb, or legacy */
uint32_t default_boot = vb2_nv_get(ctx, VB2_NV_DEV_DEFAULT_BOOT);
if(default_boot == VBNV_DEV_DEFAULT_BOOT_USB)
if(default_boot == VB2_DEV_DEFAULT_BOOT_USB)
use_usb = 1;
if(default_boot == VBNV_DEV_DEFAULT_BOOT_LEGACY)
if(default_boot == VB2_DEV_DEFAULT_BOOT_LEGACY)
use_legacy = 1;
/* Handle GBB flag override */
@ -315,7 +314,7 @@ VbError_t vb2_developer_ui(struct vb2_context *ctx, VbCommonParams *cparams)
*/
VB2_DEBUG("going to recovery\n");
vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST,
VBNV_RECOVERY_RW_DEV_SCREEN);
VB2_RECOVERY_RW_DEV_SCREEN);
VbAudioClose(audio);
return VBERROR_LOAD_KERNEL_RECOVERY;
}
@ -427,8 +426,8 @@ static VbError_t recovery_ui(struct vb2_context *ctx, VbCommonParams *cparams)
/*
* We have to save the reason here so that it will survive
* coming up three-finger-salute. We're saving it in
* VBNV_RECOVERY_SUBCODE to avoid a recovery loop.
* If we save the reason in VBNV_RECOVERY_REQUEST, we will come
* VB2_RECOVERY_SUBCODE to avoid a recovery loop.
* If we save the reason in VB2_RECOVERY_REQUEST, we will come
* back here, thus, we won't be able to give a user a chance to
* reboot to workaround a boot hiccup.
*/
@ -466,7 +465,7 @@ static VbError_t recovery_ui(struct vb2_context *ctx, VbCommonParams *cparams)
* us stuck in recovery mode.
*/
vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST,
VBNV_RECOVERY_NOT_REQUESTED);
VB2_RECOVERY_NOT_REQUESTED);
if (VBERROR_SUCCESS == retval)
break; /* Found a recovery kernel */

19
firmware/lib/vboot_ui_menu.c
View File

@ -23,7 +23,6 @@
#include "vboot_common.h"
#include "vboot_display.h"
#include "vboot_kernel.h"
#include "vboot_nvstorage.h"
static void VbAllowUsbBootMenu(struct vb2_context *ctx)
{
@ -84,7 +83,7 @@ uint32_t VbTryUsbMenu(struct vb2_context *ctx, VbCommonParams *cparams)
* recovery mode.
*/
vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST,
VBNV_RECOVERY_NOT_REQUESTED);
VB2_RECOVERY_NOT_REQUESTED);
}
return retval;
}
@ -355,13 +354,13 @@ VbError_t vb2_update_menu(struct vb2_context *ctx)
switch(current_menu_idx) {
case VB_WARN_OPTIONS:
switch(default_boot) {
case VBNV_DEV_DEFAULT_BOOT_DISK:
case VB2_DEV_DEFAULT_BOOT_DISK:
next_menu_idx = VB_DEV_DISK;
break;
case VBNV_DEV_DEFAULT_BOOT_USB:
case VB2_DEV_DEFAULT_BOOT_USB:
next_menu_idx = VB_DEV_USB;
break;
case VBNV_DEV_DEFAULT_BOOT_LEGACY:
case VB2_DEV_DEFAULT_BOOT_LEGACY:
next_menu_idx = VB_DEV_LEGACY;
break;
}
@ -675,9 +674,9 @@ VbError_t vb2_developer_menu(struct vb2_context *ctx, VbCommonParams *cparams)
/* Check if the default is to boot using disk, usb, or legacy */
default_boot = vb2_nv_get(ctx, VB2_NV_DEV_DEFAULT_BOOT);
if(default_boot == VBNV_DEV_DEFAULT_BOOT_USB)
if(default_boot == VB2_DEV_DEFAULT_BOOT_USB)
use_usb = 1;
if(default_boot == VBNV_DEV_DEFAULT_BOOT_LEGACY)
if(default_boot == VB2_DEV_DEFAULT_BOOT_LEGACY)
use_legacy = 1;
/* Handle GBB flag override */
@ -990,8 +989,8 @@ static VbError_t recovery_ui(struct vb2_context *ctx, VbCommonParams *cparams)
/*
* We have to save the reason here so that it will survive
* coming up three-finger-salute. We're saving it in
* VBNV_RECOVERY_SUBCODE to avoid a recovery loop.
* If we save the reason in VBNV_RECOVERY_REQUEST, we will come
* VB2_RECOVERY_SUBCODE to avoid a recovery loop.
* If we save the reason in VB2_RECOVERY_REQUEST, we will come
* back here, thus, we won't be able to give a user a chance to
* reboot to workaround a boot hiccup.
*/
@ -1040,7 +1039,7 @@ static VbError_t recovery_ui(struct vb2_context *ctx, VbCommonParams *cparams)
* us stuck in recovery mode.
*/
vb2_nv_set(ctx, VB2_NV_RECOVERY_REQUEST,
VBNV_RECOVERY_NOT_REQUESTED);
VB2_RECOVERY_NOT_REQUESTED);
if (VBERROR_SUCCESS == retval)
break; /* Found a recovery kernel */

6
firmware/linktest/main.c
View File

@ -11,7 +11,6 @@
#include "tlcl.h"
#include "vboot_common.h"
#include "vboot_kernel.h"
#include "vboot_nvstorage.h"
int main(void)
@ -71,10 +70,5 @@ int main(void)
VbSharedDataReserve(0, 0);
VbSharedDataSetKernelKey(0, 0);
VbNvSetup(0);
VbNvGet(0, 0, 0);
VbNvSet(0, 0, 0);
VbNvTeardown(0);
return 0;
}

30
host/arch/arm/lib/crossystem_arch.c
View File

@ -20,7 +20,6 @@
#include <netinet/in.h>
#include "vboot_common.h"
#include "vboot_nvstorage.h"
#include "host_common.h"
#include "crossystem.h"
#include "crossystem_arch.h"
@ -245,8 +244,7 @@ out:
return ret;
}
static int VbReadNvStorage_disk(VbNvContext* vnc)
static int vb2_read_nv_storage_disk(struct vb2_context *ctx)
{
int nvctx_fd = -1;
uint8_t sector[SECTOR_SIZE];
@ -262,7 +260,7 @@ static int VbReadNvStorage_disk(VbNvContext* vnc)
return E_FAIL;
snprintf(nvctx_path, sizeof(nvctx_path), NVCTX_PATH, emmc_dev);
if (size != sizeof(vnc->raw) || (size + offset > SECTOR_SIZE))
if (size != sizeof(ctx->nvdata) || (size + offset > SECTOR_SIZE))
return E_FAIL;
nvctx_fd = open(nvctx_path, O_RDONLY);
@ -279,7 +277,7 @@ static int VbReadNvStorage_disk(VbNvContext* vnc)
__FUNCTION__, nvctx_path);
goto out;
}
memcpy(vnc->raw, sector+offset, size);
memcpy(ctx->nvdata, sector+offset, size);
rv = 0;
out:
@ -289,7 +287,7 @@ out:
return rv;
}
static int VbWriteNvStorage_disk(VbNvContext* vnc)
static int vb2_write_nv_storage_disk(struct vb2_context *ctx)
{
int nvctx_fd = -1;
uint8_t sector[SECTOR_SIZE];
@ -305,7 +303,7 @@ static int VbWriteNvStorage_disk(VbNvContext* vnc)
return E_FAIL;
snprintf(nvctx_path, sizeof(nvctx_path), NVCTX_PATH, emmc_dev);
if (size != sizeof(vnc->raw) || (size + offset > SECTOR_SIZE))
if (size != sizeof(ctx->nvdata) || (size + offset > SECTOR_SIZE))
return E_FAIL;
do {
@ -323,7 +321,7 @@ static int VbWriteNvStorage_disk(VbNvContext* vnc)
__FUNCTION__, nvctx_path);
break;
}
memcpy(sector+offset, vnc->raw, size);
memcpy(sector+offset, ctx->nvdata, size);
lseek(nvctx_fd, lba * SECTOR_SIZE, SEEK_SET);
rv = write(nvctx_fd, sector, SECTOR_SIZE);
if (rv <= 0) {
@ -351,35 +349,35 @@ static int VbWriteNvStorage_disk(VbNvContext* vnc)
return rv;
}
int VbReadNvStorage(VbNvContext* vnc)
int vb2_read_nv_storage(struct vb2_context *ctx)
{
/* Default to disk for older firmware which does not provide storage
* type */
char *media;
if (!FdtPropertyExist(FDT_NVSTORAGE_TYPE_PROP))
return VbReadNvStorage_disk(vnc);
return vb2_read_nv_storage_disk(ctx);
media = ReadFdtString(FDT_NVSTORAGE_TYPE_PROP);
if (!strcmp(media, "disk"))
return VbReadNvStorage_disk(vnc);
return vb2_read_nv_storage_disk(ctx);
if (!strcmp(media, "cros-ec") || !strcmp(media, "mkbp") ||
!strcmp(media, "flash"))
return VbReadNvStorage_mosys(vnc);
return vb2_read_nv_storage_mosys(ctx);
return -1;
}
int VbWriteNvStorage(VbNvContext* vnc)
int vb2_write_nv_storage(struct vb2_context *ctx)
{
/* Default to disk for older firmware which does not provide storage
* type */
char *media;
if (!FdtPropertyExist(FDT_NVSTORAGE_TYPE_PROP))
return VbWriteNvStorage_disk(vnc);
return vb2_write_nv_storage_disk(ctx);
media = ReadFdtString(FDT_NVSTORAGE_TYPE_PROP);
if (!strcmp(media, "disk"))
return VbWriteNvStorage_disk(vnc);
return vb2_write_nv_storage_disk(ctx);
if (!strcmp(media, "cros-ec") || !strcmp(media, "mkbp") ||
!strcmp(media, "flash"))
return VbWriteNvStorage_mosys(vnc);
return vb2_write_nv_storage_mosys(ctx);
return -1;
}

5
host/arch/mips/lib/crossystem_arch.c
View File

@ -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;
}

43
host/arch/x86/lib/crossystem_arch.c
View File

@ -22,7 +22,6 @@
#include "host_common.h"
#include "utility.h"
#include "vboot_common.h"
#include "vboot_nvstorage.h"
#include "vboot_struct.h"
@ -156,7 +155,7 @@ static int VbCmosWrite(unsigned offs, size_t size, const void *ptr)
}
int VbReadNvStorage(VbNvContext* vnc)
int vb2_read_nv_storage(struct vb2_context *ctx)
{
unsigned offs, blksz;
@ -168,18 +167,18 @@ int VbReadNvStorage(VbNvContext* vnc)
if (VBNV_BLOCK_SIZE > blksz)
return -1; /* NV storage block is too small */
if (0 != VbCmosRead(offs, VBNV_BLOCK_SIZE, vnc->raw))
if (0 != VbCmosRead(offs, sizeof(ctx->nvdata), ctx->nvdata))
return -1;
return 0;
}
int VbWriteNvStorage(VbNvContext* vnc)
int vb2_write_nv_storage(struct vb2_context *ctx)
{
unsigned offs, blksz;
if (!vnc->raw_changed)
if (!(ctx->flags & VB2_CONTEXT_NVDATA_CHANGED))
return 0; /* Nothing changed, so no need to write */
/* Get the byte offset from VBNV */
@ -190,14 +189,14 @@ int VbWriteNvStorage(VbNvContext* vnc)
if (VBNV_BLOCK_SIZE > blksz)
return -1; /* NV storage block is too small */
if (0 != VbCmosWrite(offs, VBNV_BLOCK_SIZE, vnc->raw))
if (0 != VbCmosWrite(offs, sizeof(ctx->nvdata), ctx->nvdata))
return -1;
/* Also attempt to write using mosys if using vboot2 */
VbSharedDataHeader *sh = VbSharedDataRead();
if (sh) {
if (sh->flags & VBSD_BOOT_FIRMWARE_VBOOT2)
VbWriteNvStorage_mosys(vnc);
vb2_write_nv_storage_mosys(ctx);
free(sh);
}
@ -453,19 +452,19 @@ static int VbGetRecoveryReason(void)
switch(value) {
case BINF0_NORMAL:
case BINF0_DEVELOPER:
return VBNV_RECOVERY_NOT_REQUESTED;
return VB2_RECOVERY_NOT_REQUESTED;
case BINF0_RECOVERY_BUTTON:
return VBNV_RECOVERY_RO_MANUAL;
return VB2_RECOVERY_RO_MANUAL;
case BINF0_RECOVERY_DEV_SCREEN_KEY:
return VBNV_RECOVERY_RW_DEV_SCREEN;
return VB2_RECOVERY_RW_DEV_SCREEN;
case BINF0_RECOVERY_RW_FW_BAD:
return VBNV_RECOVERY_RO_INVALID_RW;
return VB2_RECOVERY_RO_INVALID_RW;
case BINF0_RECOVERY_NO_OS:
return VBNV_RECOVERY_RW_NO_OS;
return VB2_RECOVERY_RW_NO_OS;
case BINF0_RECOVERY_BAD_OS:
return VBNV_RECOVERY_RW_INVALID_OS;
return VB2_RECOVERY_RW_INVALID_OS;
case BINF0_RECOVERY_OS_INITIATED:
return VBNV_RECOVERY_LEGACY;
return VB2_RECOVERY_LEGACY;
default:
/* Other values don't map cleanly to firmware type. */
return -1;
@ -817,15 +816,15 @@ int VbGetArchPropertyInt(const char* name)
/* NV storage values. If unable to get from NV storage, fall back to
* the CMOS reboot field used by older BIOS (e.g. Mario). */
if (!strcasecmp(name,"recovery_request")) {
value = VbGetNvStorage(VBNV_RECOVERY_REQUEST);
value = vb2_get_nv_storage(VB2_NV_RECOVERY_REQUEST);
if (-1 == value)
value = VbGetCmosRebootField(CMOSRF_RECOVERY);
} else if (!strcasecmp(name,"dbg_reset")) {
value = VbGetNvStorage(VBNV_DEBUG_RESET_MODE);
value = vb2_get_nv_storage(VB2_NV_DEBUG_RESET_MODE);
if (-1 == value)
value = VbGetCmosRebootField(CMOSRF_DEBUG_RESET);
} else if (!strcasecmp(name,"fwb_tries")) {
value = VbGetNvStorage(VBNV_TRY_B_COUNT);
value = vb2_get_nv_storage(VB2_NV_TRY_COUNT);
if (-1 == value)
value = VbGetCmosRebootField(CMOSRF_TRY_B);
}
@ -835,7 +834,7 @@ int VbGetArchPropertyInt(const char* name)
* stateful partition. */
if (!strcasecmp(name,"fwupdate_tries")) {
unsigned fwupdate_value;
if (-1 != VbGetNvStorage(VBNV_KERNEL_FIELD))
if (-1 != vb2_get_nv_storage(VB2_NV_KERNEL_FIELD))
return -1; /* NvStorage supported; fail through
* arch-specific implementation to normal
* implementation. */
@ -900,15 +899,15 @@ int VbSetArchPropertyInt(const char* name, int value)
/* NV storage values. If unable to get from NV storage, fall back to
* the CMOS reboot field used by older BIOS. */
if (!strcasecmp(name,"recovery_request")) {
if (0 == VbSetNvStorage(VBNV_RECOVERY_REQUEST, value))
if (0 == vb2_set_nv_storage(VB2_NV_RECOVERY_REQUEST, value))
return 0;
return VbSetCmosRebootField(CMOSRF_RECOVERY, value);
} else if (!strcasecmp(name,"dbg_reset")) {
if (0 == VbSetNvStorage(VBNV_DEBUG_RESET_MODE, value))
if (0 == vb2_set_nv_storage(VB2_NV_DEBUG_RESET_MODE, value))
return 0;
return VbSetCmosRebootField(CMOSRF_DEBUG_RESET, value);
} else if (!strcasecmp(name,"fwb_tries")) {
if (0 == VbSetNvStorage(VBNV_TRY_B_COUNT, value))
if (0 == vb2_set_nv_storage(VB2_NV_TRY_COUNT, value))
return 0;
return VbSetCmosRebootField(CMOSRF_TRY_B, value);
}
@ -916,7 +915,7 @@ int VbSetArchPropertyInt(const char* name, int value)
* older systems where it's not, it was stored in a file in the
* stateful partition. */
else if (!strcasecmp(name,"fwupdate_tries")) {
if (-1 != VbGetNvStorage(VBNV_KERNEL_FIELD))
if (-1 != vb2_get_nv_storage(VB2_NV_KERNEL_FIELD))
return -1; /* NvStorage supported; fail through
* arch-specific implementation to normal
* implementation */

10
host/include/crossystem_vbnv.h
View File

@ -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
}

235
host/lib/crossystem.c
View File

@ -16,6 +16,10 @@
#include <fcntl.h>
#include <unistd.h>
#include "2sysincludes.h"
#include "2api.h"
#include "2nvstorage.h"
#include "host_common.h"
#include "crossystem.h"
@ -23,7 +27,6 @@
#include "crossystem_vbnv.h"
#include "utility.h"
#include "vboot_common.h"
#include "vboot_nvstorage.h"
#include "vboot_struct.h"
/* Filename for kernel command line */
@ -93,75 +96,58 @@ int FwidStartsWith(const char *start)
static int vnc_read;
int VbGetNvStorage(VbNvParam param)
int vb2_get_nv_storage(enum vb2_nv_param param)
{
uint32_t value;
int retval;
static VbNvContext cached_vnc;
static struct vb2_context cached_ctx;
/* TODO: locking around NV access */
if (!vnc_read) {
if (0 != VbReadNvStorage(&cached_vnc))
memset(&cached_ctx, 0, sizeof(cached_ctx));
if (0 != vb2_read_nv_storage(&cached_ctx))
return -1;
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 @@ int VbGetSystemPropertyInt(const char *name)
/* NV storage values */
else if (!strcasecmp(name,"kern_nv")) {
value = VbGetNvStorage(VBNV_KERNEL_FIELD);
value = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD);
} else if (!strcasecmp(name,"nvram_cleared")) {
value = VbGetNvStorage(VBNV_KERNEL_SETTINGS_RESET);
value = vb2_get_nv_storage(VB2_NV_KERNEL_SETTINGS_RESET);
} else if (!strcasecmp(name,"recovery_request")) {
value = VbGetNvStorage(VBNV_RECOVERY_REQUEST);
value = vb2_get_nv_storage(VB2_NV_RECOVERY_REQUEST);
} else if (!strcasecmp(name,"dbg_reset")) {
value = VbGetNvStorage(VBNV_DEBUG_RESET_MODE);
value = vb2_get_nv_storage(VB2_NV_DEBUG_RESET_MODE);
} else if (!strcasecmp(name,"disable_dev_request")) {
value = VbGetNvStorage(VBNV_DISABLE_DEV_REQUEST);
value = vb2_get_nv_storage(VB2_NV_DISABLE_DEV_REQUEST);
} else if (!strcasecmp(name,"clear_tpm_owner_request")) {
value = VbGetNvStorage(VBNV_CLEAR_TPM_OWNER_REQUEST);
value = vb2_get_nv_storage(VB2_NV_CLEAR_TPM_OWNER_REQUEST);
} else if (!strcasecmp(name,"clear_tpm_owner_done")) {
value = VbGetNvStorage(VBNV_CLEAR_TPM_OWNER_DONE);
value = vb2_get_nv_storage(VB2_NV_CLEAR_TPM_OWNER_DONE);
} else if (!strcasecmp(name,"tpm_rebooted")) {
value = VbGetNvStorage(VBNV_TPM_REQUESTED_REBOOT);
} else if (!strcasecmp(name,"fwb_tries")) {
value = VbGetNvStorage(VBNV_TRY_B_COUNT);
value = vb2_get_nv_storage(VB2_NV_TPM_REQUESTED_REBOOT);
} else if (!strcasecmp(name,"fwb_tries") ||
!strcasecmp(name,"fw_try_count")) {
value = vb2_get_nv_storage(VB2_NV_TRY_COUNT);
} else if (!strcasecmp(name,"fw_vboot2")) {
value = GetVdatInt(VDAT_INT_FW_BOOT2);
} else if (!strcasecmp(name,"fw_try_count")) {
value = VbGetNvStorage(VBNV_FW_TRY_COUNT);
} else if (!strcasecmp(name,"fwupdate_tries")) {
value = VbGetNvStorage(VBNV_KERNEL_FIELD);
value = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD);
if (value != -1)
value &= KERN_NV_FWUPDATE_TRIES_MASK;
} else if (!strcasecmp(name,"block_devmode")) {
value = VbGetNvStorage(VBNV_KERNEL_FIELD);
value = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD);
if (value != -1) {
value &= KERN_NV_BLOCK_DEVMODE_FLAG;
value = !!value;
}
} else if (!strcasecmp(name,"tpm_attack")) {
value = VbGetNvStorage(VBNV_KERNEL_FIELD);
value = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD);
if (value != -1) {
value &= KERN_NV_TPM_ATTACK_FLAG;
value = !!value;
}
} else if (!strcasecmp(name,"loc_idx")) {
value = VbGetNvStorage(VBNV_LOCALIZATION_INDEX);
value = vb2_get_nv_storage(VB2_NV_LOCALIZATION_INDEX);
} else if (!strcasecmp(name,"backup_nvram_request")) {
value = VbGetNvStorage(VBNV_BACKUP_NVRAM_REQUEST);
value = vb2_get_nv_storage(VB2_NV_BACKUP_NVRAM_REQUEST);
} else if (!strcasecmp(name,"dev_boot_usb")) {
value = VbGetNvStorage(VBNV_DEV_BOOT_USB);
value = vb2_get_nv_storage(VB2_NV_DEV_BOOT_USB);
} else if (!strcasecmp(name,"dev_boot_legacy")) {
value = VbGetNvStorage(VBNV_DEV_BOOT_LEGACY);
value = vb2_get_nv_storage(VB2_NV_DEV_BOOT_LEGACY);
} else if (!strcasecmp(name,"dev_boot_signed_only")) {
value = VbGetNvStorage(VBNV_DEV_BOOT_SIGNED_ONLY);
value = vb2_get_nv_storage(VB2_NV_DEV_BOOT_SIGNED_ONLY);
} else if (!strcasecmp(name,"dev_boot_fastboot_full_cap")) {
value = VbGetNvStorage(VBNV_DEV_BOOT_FASTBOOT_FULL_CAP);
value = vb2_get_nv_storage(VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP);
} else if (!strcasecmp(name,"oprom_needed")) {
value = VbGetNvStorage(VBNV_OPROM_NEEDED);
value = vb2_get_nv_storage(VB2_NV_OPROM_NEEDED);
} else if (!strcasecmp(name,"recovery_subcode")) {
value = VbGetNvStorage(VBNV_RECOVERY_SUBCODE);
value = vb2_get_nv_storage(VB2_NV_RECOVERY_SUBCODE);
} else if (!strcasecmp(name,"wipeout_request")) {
value = VbGetNvStorage(VBNV_FW_REQ_WIPEOUT);
value = vb2_get_nv_storage(VB2_NV_REQ_WIPEOUT);
} else if (!strcasecmp(name,"kernel_max_rollforward")) {
value = VbGetNvStorage(VBNV_KERNEL_MAX_ROLLFORWARD);
value = vb2_get_nv_storage(VB2_NV_KERNEL_MAX_ROLLFORWARD);
}
/* Other parameters */
else if (!strcasecmp(name,"cros_debug")) {
@ -550,13 +535,13 @@ int VbGetSystemPropertyInt(const char *name)
} else if (!strcasecmp(name,"recovery_reason")) {
value = GetVdatInt(VDAT_INT_RECOVERY_REASON);
} else if (!strcasecmp(name, "fastboot_unlock_in_fw")) {
value = VbGetNvStorage(VBNV_FASTBOOT_UNLOCK_IN_FW);
value = vb2_get_nv_storage(VB2_NV_FASTBOOT_UNLOCK_IN_FW);
} else if (!strcasecmp(name, "boot_on_ac_detect")) {
value = VbGetNvStorage(VBNV_BOOT_ON_AC_DETECT);
value = vb2_get_nv_storage(VB2_NV_BOOT_ON_AC_DETECT);
} else if (!strcasecmp(name, "try_ro_sync")) {
value = VbGetNvStorage(VBNV_TRY_RO_SYNC);
value = vb2_get_nv_storage(VB2_NV_TRY_RO_SYNC);
} else if (!strcasecmp(name, "battery_cutoff_request")) {
value = VbGetNvStorage(VBNV_BATTERY_CUTOFF_REQUEST);
value = vb2_get_nv_storage(VB2_NV_BATTERY_CUTOFF_REQUEST);
} else if (!strcasecmp(name, "inside_vm")) {
/* Detect if the host is a VM. If there is no HWID and the
* firmware type is "nonchrome", then assume it is a VM. If
@ -604,25 +589,25 @@ const char *VbGetSystemPropertyString(const char *name, char *dest,
} else if (!strcasecmp(name, "vdat_lkdebug")) {
return GetVdatString(dest, size, VDAT_STRING_LOAD_KERNEL_DEBUG);
} else if (!strcasecmp(name, "fw_try_next")) {
return VbGetNvStorage(VBNV_FW_TRY_NEXT) ? "B" : "A";
return vb2_get_nv_storage(VB2_NV_TRY_NEXT) ? "B" : "A";
} else if (!strcasecmp(name, "fw_tried")) {
return VbGetNvStorage(VBNV_FW_TRIED) ? "B" : "A";
return vb2_get_nv_storage(VB2_NV_FW_TRIED) ? "B" : "A";
} else if (!strcasecmp(name, "fw_result")) {
int v = VbGetNvStorage(VBNV_FW_RESULT);
int v = vb2_get_nv_storage(VB2_NV_FW_RESULT);
if (v < ARRAY_SIZE(fw_results))
return fw_results[v];
else
return "unknown";
} else if (!strcasecmp(name, "fw_prev_tried")) {
return VbGetNvStorage(VBNV_FW_PREV_TRIED) ? "B" : "A";
return vb2_get_nv_storage(VB2_NV_FW_PREV_TRIED) ? "B" : "A";
} else if (!strcasecmp(name, "fw_prev_result")) {
int v = VbGetNvStorage(VBNV_FW_PREV_RESULT);
int v = vb2_get_nv_storage(VB2_NV_FW_PREV_RESULT);
if (v < ARRAY_SIZE(fw_results))
return fw_results[v];
else
return "unknown";
} else if (!strcasecmp(name,"dev_default_boot")) {
int v = VbGetNvStorage(VBNV_DEV_DEFAULT_BOOT);
int v = vb2_get_nv_storage(VB2_NV_DEV_DEFAULT_BOOT);
if (v < ARRAY_SIZE(default_boot))
return default_boot[v];
else
@ -644,82 +629,89 @@ int VbSetSystemPropertyInt(const char *name, int value)
if (!strcasecmp(name,"nvram_cleared")) {
/* Can only clear this flag; it's set inside the NV storage
* library. */
return VbSetNvStorage(VBNV_KERNEL_SETTINGS_RESET, 0);
return vb2_set_nv_storage(VB2_NV_KERNEL_SETTINGS_RESET, 0);
} else if (!strcasecmp(name,"recovery_request")) {
return VbSetNvStorage(VBNV_RECOVERY_REQUEST, value);
return vb2_set_nv_storage(VB2_NV_RECOVERY_REQUEST, value);
} else if (!strcasecmp(name,"recovery_subcode")) {
return VbSetNvStorage(VBNV_RECOVERY_SUBCODE, value);
return vb2_set_nv_storage(VB2_NV_RECOVERY_SUBCODE, value);
} else if (!strcasecmp(name,"dbg_reset")) {
return VbSetNvStorage(VBNV_DEBUG_RESET_MODE, value);
return vb2_set_nv_storage(VB2_NV_DEBUG_RESET_MODE, value);
} else if (!strcasecmp(name,"disable_dev_request")) {
return VbSetNvStorage(VBNV_DISABLE_DEV_REQUEST, value);
return vb2_set_nv_storage(VB2_NV_DISABLE_DEV_REQUEST, value);
} else if (!strcasecmp(name,"clear_tpm_owner_request")) {
return VbSetNvStorage(VBNV_CLEAR_TPM_OWNER_REQUEST, value);
return vb2_set_nv_storage(VB2_NV_CLEAR_TPM_OWNER_REQUEST, value);
} else if (!strcasecmp(name,"clear_tpm_owner_done")) {
/* Can only clear this flag; it's set by firmware. */
return VbSetNvStorage(VBNV_CLEAR_TPM_OWNER_DONE, 0);
} else if (!strcasecmp(name,"fwb_tries")) {
return VbSetNvStorage(VBNV_TRY_B_COUNT, value);
} else if (!strcasecmp(name,"fw_try_count")) {
return VbSetNvStorage(VBNV_FW_TRY_COUNT, value);
return vb2_set_nv_storage(VB2_NV_CLEAR_TPM_OWNER_DONE, 0);
} else if (!strcasecmp(name,"fwb_tries") ||
!strcasecmp(name,"fw_try_count")) {
return vb2_set_nv_storage(VB2_NV_TRY_COUNT, value);
} else if (!strcasecmp(name,"oprom_needed")) {
return VbSetNvStorage(VBNV_OPROM_NEEDED, value);
return vb2_set_nv_storage(VB2_NV_OPROM_NEEDED, value);
} else if (!strcasecmp(name,"wipeout_request")) {
/* Can only clear this flag, set only by firmware. */
return VbSetNvStorage(VBNV_FW_REQ_WIPEOUT, 0);
return vb2_set_nv_storage(VB2_NV_REQ_WIPEOUT, 0);
} else if (!strcasecmp(name,"backup_nvram_request")) {
/* Best-effort only, since it requires firmware and TPM
* support. */
return VbSetNvStorage(VBNV_BACKUP_NVRAM_REQUEST, value);
return vb2_set_nv_storage(VB2_NV_BACKUP_NVRAM_REQUEST, value);
} else if (!strcasecmp(name,"fwupdate_tries")) {
int kern_nv = VbGetNvStorage(VBNV_KERNEL_FIELD);
int kern_nv = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD);
if (kern_nv == -1)
return -1;
kern_nv &= ~KERN_NV_FWUPDATE_TRIES_MASK;
kern_nv |= (value & KERN_NV_FWUPDATE_TRIES_MASK);
return VbSetNvStorage_WithBackup(VBNV_KERNEL_FIELD, kern_nv);
return vb2_set_nv_storage_with_backup(VB2_NV_KERNEL_FIELD,
kern_nv);
} else if (!strcasecmp(name,"block_devmode")) {
int kern_nv = VbGetNvStorage(VBNV_KERNEL_FIELD);
int kern_nv = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD);
if (kern_nv == -1)
return -1;
kern_nv &= ~KERN_NV_BLOCK_DEVMODE_FLAG;
if (value)
kern_nv |= KERN_NV_BLOCK_DEVMODE_FLAG;
return VbSetNvStorage_WithBackup(VBNV_KERNEL_FIELD, kern_nv);
return vb2_set_nv_storage_with_backup(VB2_NV_KERNEL_FIELD,
kern_nv);
} else if (!strcasecmp(name,"tpm_attack")) {
/* This value should only be read and cleared, but we allow
* setting it to 1 for testing. */
int kern_nv = VbGetNvStorage(VBNV_KERNEL_FIELD);
int kern_nv = vb2_get_nv_storage(VB2_NV_KERNEL_FIELD);
if (kern_nv == -1)
return -1;
kern_nv &= ~KERN_NV_TPM_ATTACK_FLAG;
if (value)
kern_nv |= KERN_NV_TPM_ATTACK_FLAG;
return VbSetNvStorage_WithBackup(VBNV_KERNEL_FIELD, kern_nv);
return vb2_set_nv_storage_with_backup(
VB2_NV_KERNEL_FIELD, kern_nv);
} else if (!strcasecmp(name,"loc_idx")) {
return VbSetNvStorage_WithBackup(VBNV_LOCALIZATION_INDEX,
return vb2_set_nv_storage_with_backup(
VB2_NV_LOCALIZATION_INDEX,
value);
} else if (!strcasecmp(name,"dev_boot_usb")) {
return VbSetNvStorage_WithBackup(VBNV_DEV_BOOT_USB, value);
return vb2_set_nv_storage_with_backup(
VB2_NV_DEV_BOOT_USB, value);
} else if (!strcasecmp(name,"dev_boot_legacy")) {
return VbSetNvStorage_WithBackup(VBNV_DEV_BOOT_LEGACY, value);
return vb2_set_nv_storage_with_backup(
VB2_NV_DEV_BOOT_LEGACY, value);
} else if (!strcasecmp(name,"dev_boot_signed_only")) {
return VbSetNvStorage_WithBackup(VBNV_DEV_BOOT_SIGNED_ONLY,
value);
return vb2_set_nv_storage_with_backup(
VB2_NV_DEV_BOOT_SIGNED_ONLY, value);
} else if (!strcasecmp(name,"dev_boot_fastboot_full_cap")) {
return VbSetNvStorage_WithBackup(
VBNV_DEV_BOOT_FASTBOOT_FULL_CAP, value);
return vb2_set_nv_storage_with_backup(
VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP, value);
} else if (!strcasecmp(name, "fastboot_unlock_in_fw")) {
return VbSetNvStorage_WithBackup(VBNV_FASTBOOT_UNLOCK_IN_FW,
value);
return vb2_set_nv_storage_with_backup(
VB2_NV_FASTBOOT_UNLOCK_IN_FW, value);
} else if (!strcasecmp(name, "boot_on_ac_detect")) {
return VbSetNvStorage_WithBackup(VBNV_BOOT_ON_AC_DETECT, value);
return vb2_set_nv_storage_with_backup(
VB2_NV_BOOT_ON_AC_DETECT, value);
} else if (!strcasecmp(name, "try_ro_sync")) {
return VbSetNvStorage_WithBackup(VBNV_TRY_RO_SYNC, value);
return vb2_set_nv_storage_with_backup(
VB2_NV_TRY_RO_SYNC, value);
} else if (!strcasecmp(name, "battery_cutoff_request")) {
return VbSetNvStorage(VBNV_BATTERY_CUTOFF_REQUEST, value);
return vb2_set_nv_storage(VB2_NV_BATTERY_CUTOFF_REQUEST, value);
} else if (!strcasecmp(name,"kernel_max_rollforward")) {
return VbSetNvStorage(VBNV_KERNEL_MAX_ROLLFORWARD, value);
return vb2_set_nv_storage(VB2_NV_KERNEL_MAX_ROLLFORWARD, value);
}
return -1;
@ -733,9 +725,9 @@ int VbSetSystemPropertyString(const char* name, const char* value)
if (!strcasecmp(name, "fw_try_next")) {
if (!strcasecmp(value, "A"))
return VbSetNvStorage(VBNV_FW_TRY_NEXT, 0);
return vb2_set_nv_storage(VB2_NV_TRY_NEXT, 0);
else if (!strcasecmp(value, "B"))
return VbSetNvStorage(VBNV_FW_TRY_NEXT, 1);
return vb2_set_nv_storage(VB2_NV_TRY_NEXT, 1);
else
return -1;
@ -744,7 +736,7 @@ int VbSetSystemPropertyString(const char* name, const char* value)
for (i = 0; i < ARRAY_SIZE(fw_results); i++) {
if (!strcasecmp(value, fw_results[i]))
return VbSetNvStorage(VBNV_FW_RESULT, i);
return vb2_set_nv_storage(VB2_NV_FW_RESULT, i);
}
return -1;
} else if (!strcasecmp(name, "dev_default_boot")) {
@ -752,7 +744,8 @@ int VbSetSystemPropertyString(const char* name, const char* value)
for (i = 0; i < ARRAY_SIZE(default_boot); i++) {
if (!strcasecmp(value, default_boot[i]))
return VbSetNvStorage(VBNV_DEV_DEFAULT_BOOT, i);
return vb2_set_nv_storage(
VB2_NV_DEV_DEFAULT_BOOT, i);
}
return -1;
}
@ -839,7 +832,7 @@ static int ExecuteMosys(char * const argv[], char *buf, size_t bufsize)
return 0;
}
int VbReadNvStorage_mosys(VbNvContext *vnc)
int vb2_read_nv_storage_mosys(struct vb2_context *ctx)
{
char hexstring[VBNV_BLOCK_SIZE * 2 + 32]; /* Reserve extra 32 bytes */
char * const argv[] = {
@ -855,12 +848,12 @@ int VbReadNvStorage_mosys(VbNvContext *vnc)
for (i = 0; i < VBNV_BLOCK_SIZE; i++) {
hexdigit[0] = hexstring[i * 2];
hexdigit[1] = hexstring[i * 2 + 1];
vnc->raw[i] = strtol(hexdigit, NULL, 16);
ctx->nvdata[i] = strtol(hexdigit, NULL, 16);
}
return 0;
}
int VbWriteNvStorage_mosys(VbNvContext* vnc)
int vb2_write_nv_storage_mosys(struct vb2_context *ctx)
{
char hexstring[VBNV_BLOCK_SIZE * 2 + 1];
char * const argv[] = {
@ -870,7 +863,7 @@ int VbWriteNvStorage_mosys(VbNvContext* vnc)
int i;
for (i = 0; i < VBNV_BLOCK_SIZE; i++)
snprintf(hexstring + i * 2, 3, "%02x", vnc->raw[i]);
snprintf(hexstring + i * 2, 3, "%02x", ctx->nvdata[i]);
hexstring[sizeof(hexstring) - 1] = '\0';
if (ExecuteMosys(argv, NULL, 0))
return -1;

12
host/lib/include/crossystem_arch.h
View File

@ -10,7 +10,9 @@
#include <stddef.h>
#include "vboot_nvstorage.h"
#include "2sysincludes.h"
#include "2api.h"
#include "2nvstorage.h"
#include "vboot_struct.h"
/* Firmware types from BINF.3. Placed in the common file because both x86 and
@ -28,12 +30,12 @@
/* Read an integer property from VbNvStorage.
*
* Returns the parameter value, or -1 if error. */
int VbGetNvStorage(VbNvParam param);
int vb2_get_nv_storage(enum vb2_nv_param param);
/* Write an integer property to VbNvStorage.
*
* Returns 0 if success, -1 if error. */
int VbSetNvStorage(VbNvParam param, int value);
int vb2_set_nv_storage(enum vb2_nv_param param, int value);
/* Return true if the FWID starts with the specified string. */
int FwidStartsWith(const char *start);
@ -46,12 +48,12 @@ int VbSharedDataVersion(void);
/* Read the non-volatile context from NVRAM.
*
* Returns 0 if success, -1 if error. */
int VbReadNvStorage(VbNvContext* vnc);
int vb2_read_nv_storage(struct vb2_context *ctx);
/* Write the non-volatile context to NVRAM.
*
* Returns 0 if success, -1 if error. */
int VbWriteNvStorage(VbNvContext* vnc);
int vb2_write_nv_storage(struct vb2_context *ctx);
/* Read the VbSharedData buffer.
*

19
tests/ec_sync_tests.c
View File

@ -23,7 +23,6 @@
#include "vboot_common.h"
#include "vboot_display.h"
#include "vboot_kernel.h"
#include "vboot_nvstorage.h"
#include "vboot_struct.h"
/* Mock data */
@ -250,28 +249,28 @@ static void VbSoftwareSyncTest(void)
ResetMocks();
in_rw_retval = VBERROR_SIMULATED;
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
VBNV_RECOVERY_EC_UNKNOWN_IMAGE, "Unknown EC image");
VB2_RECOVERY_EC_UNKNOWN_IMAGE, "Unknown EC image");
/* Calculate hashes */
ResetMocks();
mock_ec_rw_hash_size = 0;
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
VBNV_RECOVERY_EC_HASH_FAILED, "Bad EC hash");
VB2_RECOVERY_EC_HASH_FAILED, "Bad EC hash");
ResetMocks();
mock_ec_rw_hash_size = 16;
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
VBNV_RECOVERY_EC_HASH_SIZE, "Bad EC hash size");
VB2_RECOVERY_EC_HASH_SIZE, "Bad EC hash size");
ResetMocks();
want_ec_hash_size = 0;
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
VBNV_RECOVERY_EC_EXPECTED_HASH, "Bad precalculated hash");
VB2_RECOVERY_EC_EXPECTED_HASH, "Bad precalculated hash");
ResetMocks();
want_ec_hash_size = 16;
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
VBNV_RECOVERY_EC_HASH_SIZE,
VB2_RECOVERY_EC_HASH_SIZE,
"Hash size mismatch");
ResetMocks();
@ -343,7 +342,7 @@ static void VbSoftwareSyncTest(void)
mock_ec_rw_hash[0]++;
update_hash++;
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
VBNV_RECOVERY_EC_UPDATE, "updated hash mismatch");
VB2_RECOVERY_EC_UPDATE, "updated hash mismatch");
TEST_EQ(ec_rw_protected, 0, " ec rw protected");
TEST_EQ(ec_run_image, 0, " ec run image");
TEST_EQ(ec_rw_updated, 1, " ec rw updated");
@ -362,7 +361,7 @@ static void VbSoftwareSyncTest(void)
mock_ec_rw_hash[0]++;
update_retval = VBERROR_SIMULATED;
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
VBNV_RECOVERY_EC_UPDATE, "Update failed");
VB2_RECOVERY_EC_UPDATE, "Update failed");
ResetMocks();
mock_ec_rw_hash[0]++;
@ -386,7 +385,7 @@ static void VbSoftwareSyncTest(void)
ResetMocks();
run_retval = VBERROR_SIMULATED;
test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
VBNV_RECOVERY_EC_JUMP_RW, "Jump to RW fail");
VB2_RECOVERY_EC_JUMP_RW, "Jump to RW fail");
ResetMocks();
run_retval = VBERROR_EC_REBOOT_TO_RO_REQUIRED;
@ -396,7 +395,7 @@ static void VbSoftwareSyncTest(void)
ResetMocks();
protect_retval = VBERROR_SIMULATED;
test_ssync(VBERROR_SIMULATED,
VBNV_RECOVERY_EC_PROTECT, "Protect error");
VB2_RECOVERY_EC_PROTECT, "Protect error");
/* No longer check for shutdown requested */
ResetMocks();

10
tests/vboot_api_devmode_tests.c
View File

@ -12,6 +12,7 @@
#include "2sysincludes.h"
#include "2api.h"
#include "2nvstorage.h"
#include "crc32.h"
#include "gbb_header.h"
#include "host_common.h"
@ -21,7 +22,6 @@
#include "vboot_common.h"
#include "vboot_display.h"
#include "vboot_kernel.h"
#include "vboot_nvstorage.h"
#include "vboot_struct.h"
@ -135,7 +135,6 @@ test_case_t test[] = {
/* Mock data */
static VbCommonParams cparams;
static struct vb2_context ctx;
static VbNvContext vnc;
static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
static VbSharedDataHeader* shared = (VbSharedDataHeader*)shared_data;
static GoogleBinaryBlockHeader gbb;
@ -161,10 +160,7 @@ static void ResetMocks(void) {
cparams.gbb = &gbb;
memset(&ctx, 0, sizeof(ctx));
memset(&vnc, 0, sizeof(vnc));
VbNvSetup(&vnc);
VbNvTeardown(&vnc); /* So CRC gets generated */
vb2_nv_init(&ctx);
memset(&shared_data, 0, sizeof(shared_data));
VbSharedDataInit(shared, sizeof(shared_data));
@ -193,12 +189,10 @@ static void ResetMocks(void) {
/* Mocked verification functions */
VbError_t VbExNvStorageRead(uint8_t* buf) {
memcpy(buf, vnc.raw, sizeof(vnc.raw));
return VBERROR_SUCCESS;
}
VbError_t VbExNvStorageWrite(const uint8_t* buf) {
memcpy(vnc.raw, buf, sizeof(vnc.raw));
return VBERROR_SUCCESS;
}

13
tests/vboot_api_kernel2_tests.c
View File

@ -22,7 +22,6 @@
#include "vboot_common.h"
#include "vboot_display.h"
#include "vboot_kernel.h"
#include "vboot_nvstorage.h"
#include "vboot_struct.h"
/* Mock data */
@ -307,7 +306,7 @@ static void VbBootDevTest(void)
* legacy are set */
ResetMocks();
vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT,
VBNV_DEV_DEFAULT_BOOT_LEGACY);
VB2_DEV_DEFAULT_BOOT_LEGACY);
vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
TEST_EQ(VbBootDeveloper(&ctx, &cparams), 1002, "Timeout");
TEST_EQ(vbexlegacy_called, 1, " try legacy");
@ -315,7 +314,7 @@ static void VbBootDevTest(void)
/* Proceed to legacy boot mode only if enabled */
ResetMocks();
vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT,
VBNV_DEV_DEFAULT_BOOT_LEGACY);
VB2_DEV_DEFAULT_BOOT_LEGACY);
TEST_EQ(VbBootDeveloper(&ctx, &cparams), 1002, "Timeout");
TEST_EQ(vbexlegacy_called, 0, " not legacy");
@ -323,7 +322,7 @@ static void VbBootDevTest(void)
* usb are set */
ResetMocks();
vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT,
VBNV_DEV_DEFAULT_BOOT_USB);
VB2_DEV_DEFAULT_BOOT_USB);
vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
vbtlk_retval = VBERROR_SUCCESS - VB_DISK_FLAG_REMOVABLE;
TEST_EQ(VbBootDeveloper(&ctx, &cparams), 0, "Ctrl+U USB");
@ -331,14 +330,14 @@ static void VbBootDevTest(void)
/* Proceed to usb boot mode only if enabled */
ResetMocks();
vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT,
VBNV_DEV_DEFAULT_BOOT_USB);
VB2_DEV_DEFAULT_BOOT_USB);
TEST_EQ(VbBootDeveloper(&ctx, &cparams), 1002, "Timeout");
/* If no USB tries fixed disk */
ResetMocks();
vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT,
VBNV_DEV_DEFAULT_BOOT_USB);
VB2_DEV_DEFAULT_BOOT_USB);
TEST_EQ(VbBootDeveloper(&ctx, &cparams), 1002, "Ctrl+U enabled");
TEST_EQ(vbexlegacy_called, 0, " not legacy");
@ -369,7 +368,7 @@ static void VbBootDevTest(void)
VBERROR_LOAD_KERNEL_RECOVERY,
"Space = recovery");
TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
VBNV_RECOVERY_RW_DEV_SCREEN, " recovery reason");
VB2_RECOVERY_RW_DEV_SCREEN, " recovery reason");
/* Space asks to disable virtual dev switch */
ResetMocks();

40
tests/vboot_api_kernel4_tests.c
View File

@ -9,6 +9,9 @@
#include <stdio.h>
#include <stdlib.h>
#include "2sysincludes.h"
#include "2api.h"
#include "2nvstorage.h"
#include "ec_sync.h"
#include "gbb_header.h"
#include "host_common.h"
@ -18,13 +21,12 @@
#include "vboot_audio.h"
#include "vboot_common.h"
#include "vboot_kernel.h"
#include "vboot_nvstorage.h"
#include "vboot_struct.h"
/* Mock data */
static struct vb2_context ctx;
static VbCommonParams cparams;
static VbSelectAndLoadKernelParams kparams;
static VbNvContext vnc;
static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
static GoogleBinaryBlockHeader gbb;
@ -51,10 +53,9 @@ static void ResetMocks(void)
gbb.minor_version = GBB_MINOR_VER;
gbb.flags = 0;
memset(&vnc, 0, sizeof(vnc));
VbNvSetup(&vnc);
VbNvSet(&vnc, VBNV_KERNEL_MAX_ROLLFORWARD, 0xffffffff);
VbNvTeardown(&vnc); /* So CRC gets generated */
memset(&ctx, 0, sizeof(ctx));
vb2_nv_init(&ctx);
vb2_nv_set(&ctx, VB2_NV_KERNEL_MAX_ROLLFORWARD, 0xffffffff);
memset(&shared_data, 0, sizeof(shared_data));
VbSharedDataInit(shared, sizeof(shared_data));
@ -71,13 +72,13 @@ static void ResetMocks(void)
VbError_t VbExNvStorageRead(uint8_t *buf)
{
memcpy(buf, vnc.raw, sizeof(vnc.raw));
memcpy(buf, ctx.nvdata, sizeof(ctx.nvdata));
return VBERROR_SUCCESS;
}
VbError_t VbExNvStorageWrite(const uint8_t *buf)
{
memcpy(vnc.raw, buf, sizeof(vnc.raw));
memcpy(ctx.nvdata, buf, sizeof(ctx.nvdata));
return VBERROR_SUCCESS;
}
@ -137,11 +138,9 @@ VbError_t VbBootRecovery(struct vb2_context *ctx, VbCommonParams *cparams)
static void test_slk(VbError_t retval, int recovery_reason, const char *desc)
{
uint32_t u;
TEST_EQ(VbSelectAndLoadKernel(&cparams, &kparams), retval, desc);
VbNvGet(&vnc, VBNV_RECOVERY_REQUEST, &u);
TEST_EQ(u, recovery_reason, " recovery reason");
TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
recovery_reason, " recovery reason");
}
/* Tests */
@ -169,7 +168,7 @@ static void VbSlkTest(void)
ResetMocks();
rkr_retval = 123;
test_slk(VBERROR_TPM_READ_KERNEL,
VBNV_RECOVERY_RW_TPM_R_ERROR, "Read kernel rollback");
VB2_RECOVERY_RW_TPM_R_ERROR, "Read kernel rollback");
ResetMocks();
new_version = 0x20003;
@ -184,23 +183,20 @@ static void VbSlkTest(void)
TEST_EQ(rkr_version, 0x10002, " version");
ResetMocks();
VbNvSet(&vnc, VBNV_KERNEL_MAX_ROLLFORWARD, 0x30005);
VbNvTeardown(&vnc);
vb2_nv_set(&ctx, VB2_NV_KERNEL_MAX_ROLLFORWARD, 0x30005);
new_version = 0x40006;
test_slk(0, 0, "Limit max roll forward");
TEST_EQ(rkr_version, 0x30005, " version");
ResetMocks();
VbNvSet(&vnc, VBNV_KERNEL_MAX_ROLLFORWARD, 0x10001);
VbNvTeardown(&vnc);
vb2_nv_set(&ctx, VB2_NV_KERNEL_MAX_ROLLFORWARD, 0x10001);
new_version = 0x40006;
test_slk(0, 0, "Max roll forward can't rollback");
TEST_EQ(rkr_version, 0x10002, " version");
ResetMocks();
vbboot_retval = VBERROR_INVALID_KERNEL_FOUND;
VbNvSet(&vnc, VBNV_RECOVERY_REQUEST, 123);
VbNvTeardown(&vnc);
vb2_nv_set(&ctx, VB2_NV_RECOVERY_REQUEST, 123);
shared->flags |= VBSD_FWB_TRIED;
shared->firmware_index = 1;
test_slk(VBERROR_INVALID_KERNEL_FOUND,
@ -210,12 +206,12 @@ static void VbSlkTest(void)
new_version = 0x20003;
rkw_retval = 123;
test_slk(VBERROR_TPM_WRITE_KERNEL,
VBNV_RECOVERY_RW_TPM_W_ERROR, "Write kernel rollback");
VB2_RECOVERY_RW_TPM_W_ERROR, "Write kernel rollback");
ResetMocks();
rkl_retval = 123;
test_slk(VBERROR_TPM_LOCK_KERNEL,
VBNV_RECOVERY_RW_TPM_L_ERROR, "Lock kernel rollback");
VB2_RECOVERY_RW_TPM_L_ERROR, "Lock kernel rollback");
/* Boot normal */
ResetMocks();
@ -252,7 +248,7 @@ static void VbSlkTest(void)
test_slk(0, 0, "Recovery ignore TPM errors");
ResetMocks();
shared->recovery_reason = VBNV_RECOVERY_TRAIN_AND_REBOOT;
shared->recovery_reason = VB2_RECOVERY_TRAIN_AND_REBOOT;
test_slk(VBERROR_REBOOT_REQUIRED, 0, "Recovery train and reboot");
// todo: rkr/w/l fail ignored if recovery

15
tests/vboot_api_kernel5_tests.c
View File

@ -11,7 +11,9 @@
#include <string.h>
#include "2sysincludes.h"
#include "2api.h"
#include "2common.h"
#include "2nvstorage.h"
#include "2rsa.h"
#include "gbb_header.h"
#include "host_common.h"
@ -21,10 +23,10 @@
#include "vboot_api.h"
#include "vboot_common.h"
#include "vboot_kernel.h"
#include "vboot_nvstorage.h"
#include "vboot_struct.h"
/* Mock data */
static struct vb2_context ctx;
static VbCommonParams cparams;
static VbSelectAndLoadKernelParams kparams;
static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
@ -37,7 +39,6 @@ static int preamble_verify_fail;
static int verify_data_fail;
static int unpack_key_fail;
static VbNvContext vnc;
static VbKeyBlockHeader kbh;
static VbKernelPreambleHeader kph;
@ -61,9 +62,8 @@ static void ResetMocks(void)
gbb.minor_version = GBB_MINOR_VER;
gbb.flags = 0;
memset(&vnc, 0, sizeof(vnc));
VbNvSetup(&vnc);
VbNvTeardown(&vnc); /* So CRC gets generated */
memset(&ctx, 0, sizeof(ctx));
vb2_nv_init(&ctx);
memset(&shared_data, 0, sizeof(shared_data));
VbSharedDataInit(shared, sizeof(shared_data));
@ -162,7 +162,7 @@ int vb2_verify_data(const uint8_t *data,
VbError_t VbExNvStorageRead(uint8_t *buf)
{
memcpy(buf, vnc.raw, sizeof(vnc.raw));
memcpy(buf, ctx.nvdata, sizeof(ctx.nvdata));
return VBERROR_SUCCESS;
}
@ -225,8 +225,7 @@ static void VerifyMemoryBootImageTest(void)
ResetMocks();
shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
key_block_verify_fail = 1;
VbNvSet(&vnc, VBNV_DEV_BOOT_FASTBOOT_FULL_CAP, 1);
VbNvTeardown(&vnc);
vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP, 1);
TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer,
kernel_buffer_size),
VBERROR_INVALID_KERNEL_FOUND, "Key verify failed");

1
tests/vboot_api_kernel6_tests.c
View File

@ -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;

12
tests/vboot_api_kernel_tests.c
View File

@ -84,7 +84,7 @@ test_case_t test[] = {
.loadkernel_return_val = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1,},
.external_expected = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
.expected_recovery_request_val = VBNV_RECOVERY_NOT_REQUESTED,
.expected_recovery_request_val = VB2_RECOVERY_NOT_REQUESTED,
.expected_to_find_disk = pickme,
.expected_to_load_disk = pickme,
.expected_return_val = VBERROR_SUCCESS
@ -102,7 +102,7 @@ test_case_t test[] = {
.diskgetinfo_return_val = VBERROR_SUCCESS,
.loadkernel_return_val = {1, 0, 1, 1, 1, 1, 1, 1, 1, 1,},
.expected_recovery_request_val = VBNV_RECOVERY_NOT_REQUESTED,
.expected_recovery_request_val = VB2_RECOVERY_NOT_REQUESTED,
.expected_to_find_disk = pickme,
.expected_to_load_disk = pickme,
.expected_return_val = VBERROR_SUCCESS
@ -132,7 +132,7 @@ test_case_t test[] = {
.diskgetinfo_return_val = VBERROR_SUCCESS,
.loadkernel_return_val = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1,},
.expected_recovery_request_val = VBNV_RECOVERY_NOT_REQUESTED,
.expected_recovery_request_val = VB2_RECOVERY_NOT_REQUESTED,
.expected_to_find_disk = pickme,
.expected_to_load_disk = pickme,
.expected_return_val = VBERROR_SUCCESS
@ -145,7 +145,7 @@ test_case_t test[] = {
.diskgetinfo_return_val = VBERROR_SUCCESS,
.loadkernel_return_val = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1,},
.expected_recovery_request_val = VBNV_RECOVERY_RW_NO_DISK,
.expected_recovery_request_val = VB2_RECOVERY_RW_NO_DISK,
.expected_to_find_disk = 0,
.expected_to_load_disk = 0,
.expected_return_val = VBERROR_NO_DISK_FOUND
@ -173,7 +173,7 @@ test_case_t test[] = {
.diskgetinfo_return_val = VBERROR_SUCCESS,
.loadkernel_return_val = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1,},
.expected_recovery_request_val = VBNV_RECOVERY_RW_NO_KERNEL,
.expected_recovery_request_val = VB2_RECOVERY_RW_NO_KERNEL,
.expected_to_find_disk = DONT_CARE,
.expected_to_load_disk = 0,
.expected_return_val = 1
@ -205,7 +205,7 @@ static void ResetMocks(int i)
memset(&mock_disks, 0, sizeof(mock_disks));
load_kernel_calls = 0;
got_recovery_request_val = VBNV_RECOVERY_NOT_REQUESTED;
got_recovery_request_val = VB2_RECOVERY_NOT_REQUESTED;
got_find_disk = 0;
got_load_disk = 0;
got_return_val = 0xdeadbeef;

1
tests/vboot_audio_tests.c
View File

@ -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"

1
tests/vboot_display_tests.c
View File

@ -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;

36
tests/vboot_kernel_tests.c
View File

@ -14,6 +14,7 @@
#include "2api.h"
#include "2common.h"
#include "2misc.h"
#include "2nvstorage.h"
#include "2sha.h"
#include "cgptlib.h"
#include "cgptlib_internal.h"
@ -28,7 +29,6 @@
#include "vboot_api.h"
#include "vboot_common.h"
#include "vboot_kernel.h"
#include "vboot_nvstorage.h"
#define LOGCALL(fmt, args...) sprintf(call_log + strlen(call_log), fmt, ##args)
#define TEST_CALLS(expect_log) TEST_STR_EQ(call_log, expect_log, " calls")
@ -62,7 +62,6 @@ static int gpt_flag_external;
static uint8_t gbb_data[sizeof(GoogleBinaryBlockHeader) + 2048];
static GoogleBinaryBlockHeader *gbb = (GoogleBinaryBlockHeader*)gbb_data;
static VbExDiskHandle_t handle;
static VbNvContext vnc;
static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
static LoadKernelParams lkp;
@ -152,12 +151,7 @@ static void ResetMocks(void)
cparams.gbb_size = sizeof(gbb_data);
cparams.shared_data_blob = shared;
memset(&vnc, 0, sizeof(vnc));
VbNvSetup(&vnc);
VbNvTeardown(&vnc); /* So CRC gets generated */
memset(&lkp, 0, sizeof(lkp));
lkp.nv_context = &vnc;
lkp.bytes_per_lba = 512;
lkp.streaming_lba_count = 1024;
lkp.gpt_lba_count = 1024;
@ -186,9 +180,10 @@ static void ResetMocks(void)
mock_part_next = 0;
memset(&ctx, 0, sizeof(ctx));
memcpy(ctx.nvdata, vnc.raw, VB2_NVDATA_SIZE);
ctx.workbuf = workbuf;
ctx.workbuf_size = sizeof(workbuf);
vb2_nv_init(&ctx);
// TODO: more workbuf fields - flags, secdata, secdatak
}
@ -574,15 +569,7 @@ static void ReadWriteGptTest(void)
static void TestLoadKernel(int expect_retval, char *test_name)
{
memcpy(ctx.nvdata, vnc.raw, VB2_NVDATA_SIZE);
TEST_EQ(LoadKernel(&ctx, &lkp, &cparams), expect_retval, test_name);
if (ctx.flags & VB2_CONTEXT_NVDATA_CHANGED) {
memcpy(vnc.raw, ctx.nvdata, VB2_NVDATA_SIZE);
vnc.raw_changed = 1;
ctx.flags &= ~VB2_CONTEXT_NVDATA_CHANGED;
}
}
/**
@ -602,8 +589,6 @@ static void InvalidParamsTest(void)
static void LoadKernelTest(void)
{
uint32_t u;
ResetMocks();
TestLoadKernel(0, "First kernel good");
@ -612,8 +597,8 @@ static void LoadKernelTest(void)
TEST_EQ(lkp.bootloader_size, 0x1234, " bootloader size");
TEST_STR_EQ((char *)lkp.partition_guid, "FakeGuid", " guid");
TEST_EQ(gpt_flag_external, 0, "GPT was internal");
VbNvGet(&vnc, VBNV_RECOVERY_REQUEST, &u);
TEST_EQ(u, 0, " recovery request");
TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
0, " recovery request");
ResetMocks();
mock_parts[1].start = 300;
@ -626,15 +611,15 @@ static void LoadKernelTest(void)
ResetMocks();
mock_parts[0].size = 0;
TestLoadKernel(VBERROR_NO_KERNEL_FOUND, "No kernels");
VbNvGet(&vnc, VBNV_RECOVERY_REQUEST, &u);
TEST_EQ(u, VBNV_RECOVERY_RW_NO_OS, " recovery request");
TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
VB2_RECOVERY_RW_NO_OS, " recovery request");
/* Skip kernels which are too small */
ResetMocks();
mock_parts[0].size = 10;
TestLoadKernel(VBERROR_INVALID_KERNEL_FOUND, "Too small");
VbNvGet(&vnc, VBNV_RECOVERY_REQUEST, &u);
TEST_EQ(u, VBNV_RECOVERY_RW_INVALID_OS, " recovery request");
TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
VB2_RECOVERY_RW_INVALID_OS, " recovery request");
ResetMocks();
disk_read_to_fail = 100;
@ -660,8 +645,7 @@ static void LoadKernelTest(void)
/* In dev mode and requiring signed kernel, fail if sig is bad */
ResetMocks();
ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
VbNvSet(&vnc, VBNV_DEV_BOOT_SIGNED_ONLY, 1);
VbNvTeardown(&vnc);
vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_SIGNED_ONLY, 1);
key_block_verify_fail = 1;
TestLoadKernel(VBERROR_INVALID_KERNEL_FOUND, "Fail key block dev sig");

208
tests/vboot_nvstorage_test.c
View File

@ -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;
}

10
tests/vboot_region_tests.c
View File

@ -16,12 +16,12 @@
#include "rollback_index.h"
#include "test_common.h"
#include "vboot_common.h"
#include "vboot_nvstorage.h"
#include "vboot_struct.h"
typedef struct VbNvContext VbNvContext;
/* Mock data */
static VbCommonParams cparams;
static VbNvContext vnc;
static VbSelectFirmwareParams fparams;
VbSelectAndLoadKernelParams kparams;
static char gbb_data[4096 + sizeof(GoogleBinaryBlockHeader)];
@ -45,10 +45,6 @@ static void ResetMocks(void) {
ScreenLayout *layout;
int gbb_used;
memset(&vnc, 0, sizeof(vnc));
VbNvSetup(&vnc);
VbNvTeardown(&vnc); /* So CRC gets generated */
memset(&cparams, 0, sizeof(cparams));
cparams.shared_data_size = sizeof(shared_data);
cparams.shared_data_blob = shared_data;
@ -116,12 +112,10 @@ static void ResetMocks(void) {
/* Mocked verification functions */
VbError_t VbExNvStorageRead(uint8_t* buf) {
memcpy(buf, vnc.raw, sizeof(vnc.raw));
return VBERROR_SUCCESS;
}
VbError_t VbExNvStorageWrite(const uint8_t* buf) {
memcpy(vnc.raw, buf, sizeof(vnc.raw));
return VBERROR_SUCCESS;
}

19
tests/verify_kernel.c
View File

@ -12,6 +12,7 @@
#include "2sysincludes.h"
#include "2api.h"
#include "2misc.h"
#include "2nvstorage.h"
#include "host_common.h"
#include "util_misc.h"
#include "vboot_common.h"
@ -22,7 +23,6 @@ static uint8_t *diskbuf;
static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
static VbNvContext nvc;
static LoadKernelParams params;
static VbCommonParams cparams;
@ -110,13 +110,6 @@ int main(int argc, char *argv[])
/* TODO(chromium:441893): support dev-mode flag and external gpt flag */
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.
*
@ -124,7 +117,7 @@ int main(int argc, char *argv[])
*/
struct vb2_context ctx;
memset(&ctx, 0, sizeof(ctx));
/* No need to initialize ctx->nvdata[]; defaults are fine */
/* TODO(chromium:441893): support dev-mode flag and external gpt flag */
ctx.workbuf = malloc(VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE);
if (!ctx.workbuf) {
@ -139,6 +132,12 @@ int main(int argc, char *argv[])
return 1;
}
/*
* LoadKernel() cares only about VBNV_DEV_BOOT_SIGNED_ONLY, and only in
* dev mode. So just use defaults for nv storage.
*/
vb2_nv_init(&ctx);
/* Try loading kernel */
rv = LoadKernel(&ctx, &params, &cparams);
if (rv != VBERROR_SUCCESS) {
@ -151,7 +150,7 @@ int main(int argc, char *argv[])
printf("Bootloader address: 0x%" PRIx64 "\n",
params.bootloader_address);
/* TODO: print other things (partition GUID, nv_context, shared_data) */
/* TODO: print other things (partition GUID, shared_data) */
printf("Yaay!\n");
return 0;

4
utility/load_kernel_test.c
View File

@ -30,7 +30,6 @@
/* Global variables for stub functions */
static LoadKernelParams lkp;
static VbCommonParams cparams;
static VbNvContext vnc;
static FILE *image_file = NULL;
@ -97,9 +96,6 @@ int main(int argc, char* argv[]) {
memset(&lkp, 0, sizeof(LoadKernelParams));
lkp.bytes_per_lba = LBA_BYTES;
int boot_flags = BOOT_FLAG_RECOVERY;
memset(&vnc, 0, sizeof(VbNvContext));
VbNvSetup(&vnc);
lkp.nv_context = &vnc;
memset(&cparams, 0, sizeof(VbCommonParams));
/* Parse options */