You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
204 lines
7.4 KiB
204 lines
7.4 KiB
/* 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, 0x12345678, 0xFEDCBA98, "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_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_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"},
|
|
{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");
|
|
VbNvTeardown(&c);
|
|
}
|
|
|
|
|
|
int main(int argc, char* argv[]) {
|
|
int error_code = 0;
|
|
|
|
VbNvStorageTest();
|
|
|
|
if (vboot_api_stub_check_memory())
|
|
error_code = 255;
|
|
if (!gTestSuccess)
|
|
error_code = 255;
|
|
|
|
return error_code;
|
|
}
|