path: root/test/nvmem_vars.c

/* Copyright 2016 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.
 *
 * Test of the key=val variable implementation (set, get, delete, etc).
 */

#include "common.h"
#include "compile_time_macros.h"
#include "nvmem.h"
#include "nvmem_vars.h"
#include "printf.h"
#include "shared_mem.h"
#include "test_util.h"

/* Declare the user regions (see test_config.h) */
uint32_t nvmem_user_sizes[] = {
	CONFIG_FLASH_NVMEM_VARS_USER_SIZE,
};
BUILD_ASSERT(ARRAY_SIZE(nvmem_user_sizes) == NVMEM_NUM_USERS);

/****************************************************************************/
/* Mock the flash storage */

static uint8_t ram_buffer[CONFIG_FLASH_NVMEM_VARS_USER_SIZE];
static uint8_t flash_buffer[CONFIG_FLASH_NVMEM_VARS_USER_SIZE];

extern char *rbuf;

/* Internal functions exported for test */
void release_local_copy(void)
{
	rbuf = NULL;
}

int get_local_copy(void)
{
	if (!rbuf) {
		memcpy(ram_buffer, flash_buffer, sizeof(ram_buffer));
		rbuf = (char *)ram_buffer;
	}
	return EC_SUCCESS;
}

int nvmem_read(uint32_t startOffset, uint32_t size,
	       void *data_, enum nvmem_users user)
{
	/* Our mocks make some assumptions */
	if (startOffset != 0 ||
	    size > CONFIG_FLASH_NVMEM_VARS_USER_SIZE ||
	    user != CONFIG_FLASH_NVMEM_VARS_USER_NUM)
		return EC_ERROR_UNIMPLEMENTED;

	if (!data_)
		return EC_ERROR_INVAL;

	memcpy(data_, flash_buffer, size);

	return EC_SUCCESS;
}

int nvmem_write(uint32_t startOffset, uint32_t size,
		void *data_, enum nvmem_users user)
{
	/* Our mocks make some assumptions */
	if (startOffset != 0 ||
	    size > CONFIG_FLASH_NVMEM_VARS_USER_SIZE ||
	    user != CONFIG_FLASH_NVMEM_VARS_USER_NUM)
		return EC_ERROR_UNIMPLEMENTED;

	if (!data_)
		return EC_ERROR_INVAL;

	memcpy(ram_buffer, data_, size);

	return EC_SUCCESS;
}

int nvmem_commit(void)
{
	memcpy(flash_buffer, ram_buffer, CONFIG_FLASH_NVMEM_VARS_USER_SIZE);
	return EC_SUCCESS;
}

int nvmem_erase_user_data(enum nvmem_users user)
{
	memset(ram_buffer, 0xff, sizeof(ram_buffer));
	memset(flash_buffer, 0xff, sizeof(flash_buffer));
	return EC_SUCCESS;
}

/****************************************************************************/
/* Helper routines */

static void erase_flash(void)
{
	/* Invalidate the RAM cache */
	release_local_copy();

	/* Zero flash */
	memset(flash_buffer, 0xff, sizeof(flash_buffer));
}

/* Erase flash, then copy data_ over it */
static void load_flash(const uint8_t *data_, size_t data_len)
{
	erase_flash();
	memcpy(flash_buffer, data_, data_len);
}

/* Return true if flash matches data_, and is followed by 0xff to the end */
static int verify_flash(const uint8_t *data_, size_t data_len)
{
	size_t i;

	/* mismatch means false */
	if (memcmp(flash_buffer, data_, data_len))
		return 0;

	for (i = data_len;
	     i < CONFIG_FLASH_NVMEM_VARS_USER_SIZE - data_len;
	     i++)
		if (flash_buffer[i] != 0xff)
			return 0;
	return 1;
}

/*
 * Treating both as strings, save the <key, value> pair.
 */
int str_setvar(const char *key, const char *val)
{
	/* Only for tests, so assume the length will fit */
	uint8_t key_len, val_len;

	key_len = strlen(key);
	val_len = val ? strlen(val) : 0;

	return setvar(key, key_len, val, val_len);
}

/*
 * Treating both as strings, lookup the key and compare the result with the
 * expected value. Return true if they match.
 */
static int str_matches(const char *key, const char *expected_val)
{
	const struct tuple *t = getvar(key, strlen(key));
	uint8_t expected_len;

	if (!expected_val && !t)
		return 1;

	if (expected_val && !t)
		return 0;

	if (!expected_val && t)
		return 0;

	expected_len = strlen(expected_val);
	return !memcmp(tuple_val(t), expected_val, expected_len);
}

/****************************************************************************/
/* Tests */

static int check_init(void)
{
	/* Valid entries */
	const uint8_t good[] = { 0x01, 0x01, 0x00, 'A', 'a',
				 0x01, 0x01, 0x00, 'B', 'b',
				 0x00 };

	/* Empty variables are 0x00, followed by all 0xff */
	const uint8_t empty[] = { 0x00 };

	/*
	 * This is parsed as though there's only one variable, but it's wrong
	 * because the rest of the storage isn't 0xff.
	 */
	const uint8_t bad_key[] = { 0x01, 0x01, 0x00, 'A', 'a',
				    0x00, 0x01, 0x00, 'B', 'b',
				    0x00 };

	/* Zero-length variables are not allowed */
	const uint8_t bad_val[] = { 0x01, 0x01, 0x00, 'A', 'a',
				    0x01, 0x00, 0x00, 'B', 'b',
				    0x00 };

	/* The next constants use magic numbers based on on the region size */
	BUILD_ASSERT(CONFIG_FLASH_NVMEM_VARS_USER_SIZE == 600);

	/* This is one byte too large */
	const uint8_t too_big[] = { [0] = 0xff, [1] = 0xff, /* 0 - 512 */
				    [513] = 0x01, [514] = 0x53, /* 513 - 599 */
				    [599] = 0x00 };

	/* This should just barely fit */
	const uint8_t just_right[] = { [0] = 0xff, [1] = 0xff, /* 0-512 */
				       [513] = 0x01, [514] = 0x52, /* 513-598 */
				       [599] = 0x00 };

	/* No end marker */
	const uint8_t not_right[] = { [0] = 0xff, [1] = 0xff, /* 0-512 */
				      [513] = 0x01, [514] = 0x52, /* 513-598 */
				      [599] = 0xff };

	load_flash(good, sizeof(good));
	TEST_ASSERT(initvars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(good, sizeof(good)));

	load_flash(empty, sizeof(empty));
	TEST_ASSERT(initvars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(empty, sizeof(empty)));

	/* All 0xff quickly runs off the end of the storage */
	erase_flash();
	TEST_ASSERT(initvars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(empty, sizeof(empty)));

	load_flash(bad_key, sizeof(bad_key));
	TEST_ASSERT(initvars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(empty, sizeof(empty)));

	load_flash(bad_val, sizeof(bad_val));
	TEST_ASSERT(initvars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(empty, sizeof(empty)));

	load_flash(too_big, sizeof(too_big));
	TEST_ASSERT(initvars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(empty, sizeof(empty)));

	load_flash(just_right, sizeof(just_right));
	TEST_ASSERT(initvars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(just_right, sizeof(just_right)));

	load_flash(not_right, sizeof(not_right));
	TEST_ASSERT(initvars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(empty, sizeof(empty)));

	return EC_SUCCESS;
}

static int simple_search(void)
{
	const uint8_t preload[] = {
		0x02, 0x02, 0x00, 'h', 'o',  'y', 'o',
		0x02, 0x4,  0x00, 'y', 'o',  'h', 'o', 'y', 'o',
		0x02, 0x06, 0x00, 'm', 'o',  'y', 'o', 'h', 'o', 'y', 'o',
		0x00 };

	load_flash(preload, sizeof(preload));
	TEST_ASSERT(initvars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(preload, sizeof(preload)));

	TEST_ASSERT(str_matches("no", 0));
	TEST_ASSERT(str_matches("ho", "yo"));
	TEST_ASSERT(str_matches("yo", "hoyo"));
	TEST_ASSERT(str_matches("mo", "yohoyo"));

	return EC_SUCCESS;
}

static int simple_write(void)
{
	const uint8_t after_one[] = {
		0x02, 0x02, 0x00, 'h', 'o',  'y', 'o',
		0x00 };

	const uint8_t after_two[] = {
		0x02, 0x02, 0x00, 'h', 'o',  'y', 'o',
		0x02, 0x4,  0x00, 'y', 'o',  'h', 'o', 'y', 'o',
		0x00 };

	const uint8_t after_three[] = {
		0x02, 0x02, 0x00, 'h', 'o',  'y', 'o',
		0x02, 0x4,  0x00, 'y', 'o',  'h', 'o', 'y', 'o',
		0x02, 0x06, 0x00, 'm', 'o',  'y', 'o', 'h', 'o', 'y', 'o',
		0x00 };

	erase_flash();
	TEST_ASSERT(initvars() == EC_SUCCESS);

	TEST_ASSERT(setvar("ho", 2, "yo", 2) == EC_SUCCESS);
	TEST_ASSERT(writevars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(after_one, sizeof(after_one)));

	TEST_ASSERT(setvar("yo", 2, "hoyo", 4) == EC_SUCCESS);
	TEST_ASSERT(writevars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(after_two, sizeof(after_two)));

	TEST_ASSERT(setvar("mo", 2, "yohoyo", 6) == EC_SUCCESS);
	TEST_ASSERT(writevars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(after_three, sizeof(after_three)));

	return EC_SUCCESS;
}

static int simple_delete(void)
{
	const char start_with[] = {
		0x01, 0x05, 0x00, 'A', 'a',  'a', 'a', 'a', 'a',
		0x02, 0x03, 0x00, 'B', 'B',  'b', 'b', 'b',
		0x03, 0x06, 0x00, 'C', 'C',  'C', 'x', 'y', 'z', 'p', 'd', 'q',
		0x01, 0x03, 0x00, 'M', 'm',  '0', 'm',
		0x04, 0x01, 0x00, 'N', 'N',  'N', 'N', 'n',
		0x00 };

	const char after_one[] = {
		0x02, 0x03, 0x00, 'B', 'B',  'b', 'b', 'b',
		0x03, 0x06, 0x00, 'C', 'C',  'C', 'x', 'y', 'z', 'p', 'd', 'q',
		0x01, 0x03, 0x00, 'M', 'm',  '0', 'm',
		0x04, 0x01, 0x00, 'N', 'N',  'N', 'N', 'n',
		0x00 };

	const char after_two[] = {
		0x02, 0x03, 0x00, 'B', 'B',  'b', 'b', 'b',
		0x03, 0x06, 0x00, 'C', 'C',  'C', 'x', 'y', 'z', 'p', 'd', 'q',
		0x01, 0x03, 0x00, 'M', 'm',  '0', 'm',
		0x00 };

	const char after_three[] = {
		0x02, 0x03, 0x00, 'B', 'B',  'b', 'b', 'b',
		0x01, 0x03, 0x00, 'M', 'm',  '0', 'm',
		0x00 };

	const char empty[] = { 0x00 };

	erase_flash();
	TEST_ASSERT(initvars() == EC_SUCCESS);

	TEST_ASSERT(setvar("A", 1, "aaaaa", 5) == EC_SUCCESS);
	TEST_ASSERT(setvar("BB", 2, "bbb", 3) == EC_SUCCESS);
	TEST_ASSERT(setvar("CCC", 3, "xyzpdq", 6) == EC_SUCCESS);
	TEST_ASSERT(setvar("M", 1, "m0m", 3) == EC_SUCCESS);
	TEST_ASSERT(setvar("NNNN", 4, "n", 1) == EC_SUCCESS);
	TEST_ASSERT(writevars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(start_with, sizeof(start_with)));

	/* Zap first variable by setting var_len to 0 */
	TEST_ASSERT(setvar("A", 1, "yohoyo", 0) == EC_SUCCESS);
	TEST_ASSERT(writevars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(after_one, sizeof(after_one)));

	/* Zap last variable by passing null pointer */
	TEST_ASSERT(setvar("NNNN", 4, 0, 3) == EC_SUCCESS);
	TEST_ASSERT(writevars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(after_two, sizeof(after_two)));

	/* Ensure that zapping nonexistant variable does nothing */
	TEST_ASSERT(setvar("XXX", 3, 0, 0) == EC_SUCCESS);
	TEST_ASSERT(writevars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(after_two, sizeof(after_two)));

	/* Zap variable in the middle */
	TEST_ASSERT(setvar("CCC", 3, 0, 0) == EC_SUCCESS);
	TEST_ASSERT(writevars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(after_three, sizeof(after_three)));

	/* Zap the rest */
	TEST_ASSERT(setvar("BB", 2, 0, 0) == EC_SUCCESS);
	TEST_ASSERT(setvar("M", 1, 0, 0) == EC_SUCCESS);
	TEST_ASSERT(writevars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(empty, sizeof(empty)));

	/* Zapping a nonexistant variable still does nothing */
	TEST_ASSERT(setvar("XXX", 3, 0, 0) == EC_SUCCESS);
	TEST_ASSERT(writevars() == EC_SUCCESS);
	TEST_ASSERT(verify_flash(empty, sizeof(empty)));

	return EC_SUCCESS;
}

static int complex_write(void)
{
	erase_flash();
	TEST_ASSERT(initvars() == EC_SUCCESS);

	/* Do a bunch of writes and erases */
	str_setvar("ho", "aa");
	str_setvar("zo", "nn");
	str_setvar("yo", "CCCCCCCC");
	str_setvar("zooo", "yyyyyyy");
	str_setvar("yo", "AA");
	str_setvar("ho", 0);
	str_setvar("yi", "BBB");
	str_setvar("yi", "AA");
	str_setvar("hixx", 0);
	str_setvar("yo", "BBB");
	str_setvar("zo", "");
	str_setvar("hi", "bbb");
	str_setvar("ho", "cccccc");
	str_setvar("yo", "");
	str_setvar("zo", "ggggg");

	/* What do we expect to find? */
	TEST_ASSERT(str_matches("hi", "bbb"));
	TEST_ASSERT(str_matches("hixx", 0));
	TEST_ASSERT(str_matches("ho", "cccccc"));
	TEST_ASSERT(str_matches("yi", "AA"));
	TEST_ASSERT(str_matches("yo", 0));
	TEST_ASSERT(str_matches("zo", "ggggg"));
	TEST_ASSERT(str_matches("zooo", "yyyyyyy"));

	return EC_SUCCESS;
}

static int weird_keys(void)
{
	uint8_t keyA[255];
	uint8_t keyB[255];
	const char *valA = "this is A";
	const char *valB = "THIS IS b";
	int i;
	const struct tuple *t;

	erase_flash();
	TEST_ASSERT(initvars() == EC_SUCCESS);

	for (i = 0; i < 255; i++) {
		keyA[i] = i;
		keyB[i] = 255 - i;
	}

	TEST_ASSERT(setvar(keyA, sizeof(keyA),
			   valA, strlen(valA)) == EC_SUCCESS);

	TEST_ASSERT(setvar(keyB, sizeof(keyB),
			   valB, strlen(valB)) == EC_SUCCESS);

	TEST_ASSERT(writevars() == EC_SUCCESS);

	t = getvar(keyA, sizeof(keyA));
	TEST_ASSERT(t);
	TEST_ASSERT(t->val_len == strlen(valA));
	TEST_ASSERT(memcmp(tuple_val(t), valA, strlen(valA)) == 0);

	t = getvar(keyB, sizeof(keyB));
	TEST_ASSERT(t);
	TEST_ASSERT(t->val_len == strlen(valB));
	TEST_ASSERT(memcmp(tuple_val(t), valB, strlen(valB)) == 0);

	return EC_SUCCESS;
}

static int weird_values(void)
{
	const char *keyA = "this is A";
	const char *keyB = "THIS IS b";
	char valA[255];
	char valB[255];
	int i;
	const struct tuple *t;

	erase_flash();
	TEST_ASSERT(initvars() == EC_SUCCESS);

	for (i = 0; i < 255; i++) {
		valA[i] = i;
		valB[i] = 255 - i;
	}

	TEST_ASSERT(setvar(keyA, strlen(keyA),
			   valA, sizeof(valA)) == EC_SUCCESS);
	TEST_ASSERT(str_setvar("c", "CcC") == EC_SUCCESS);
	TEST_ASSERT(setvar(keyB, strlen(keyB),
			   valB, sizeof(valB)) == EC_SUCCESS);
	TEST_ASSERT(str_setvar("d", "dDd") == EC_SUCCESS);

	TEST_ASSERT(writevars() == EC_SUCCESS);

	t = getvar(keyA, strlen(keyA));
	TEST_ASSERT(t);
	TEST_ASSERT(memcmp(tuple_val(t), valA, sizeof(valA)) == 0);

	t = getvar(keyB, strlen(keyB));
	TEST_ASSERT(t);
	TEST_ASSERT(memcmp(tuple_val(t), valB, sizeof(valB)) == 0);

	TEST_ASSERT(str_matches("c", "CcC"));
	TEST_ASSERT(str_matches("d", "dDd"));

	return EC_SUCCESS;
}

static int fill_it_up(void)
{
	int i, n;
	char key[20];

	erase_flash();
	TEST_ASSERT(initvars() == EC_SUCCESS);

	/*
	 * Some magic numbers here, because we want to use up 10 bytes at a
	 * time and end up with exactly 9 free bytes left.
	 */
	TEST_ASSERT(CONFIG_FLASH_NVMEM_VARS_USER_SIZE % 10 == 0);
	n = CONFIG_FLASH_NVMEM_VARS_USER_SIZE / 10;
	TEST_ASSERT(n < 1000);

	/* Fill up the storage */
	for (i = 0; i < n - 1; i++) {
		/* 3-byte header, 5-char key, 2-char val, == 10 chars */
		snprintf(key, sizeof(key), "kk%03d", i);
		TEST_ASSERT(setvar(key, 5, "aa", 2) == EC_SUCCESS);
	}

	/*
	 * Should be nine bytes left in rbuf (because we need one more '\0' at
	 * the end). This won't fit.
	 */
	TEST_ASSERT(setvar("kk999", 5, "aa", 2) == EC_ERROR_OVERFLOW);
	/* But this will. */
	TEST_ASSERT(setvar("kk999", 5, "a", 1) == EC_SUCCESS);
	/* And this, because it replaces a previous entry */
	TEST_ASSERT(setvar("kk000", 5, "bc", 2) == EC_SUCCESS);
	/* But this still won't fit */
	TEST_ASSERT(setvar("kk999", 5, "de", 2) == EC_ERROR_OVERFLOW);

	return EC_SUCCESS;
}

void run_test(void)
{
	test_reset();

	RUN_TEST(check_init);
	RUN_TEST(simple_write);
	RUN_TEST(simple_search);
	RUN_TEST(simple_delete);
	RUN_TEST(complex_write);
	RUN_TEST(weird_keys);
	RUN_TEST(weird_values);
	RUN_TEST(fill_it_up);

	test_print_result();
}