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

13 files changed, 69 insertions, 316 deletions

diff --git a/tests/ec_sync_tests.c b/tests/ec_sync_tests.c
index 1d5f8c1b..a8c9b78c 100644
--- a/tests/ec_sync_tests.c
+++ b/tests/ec_sync_tests.c
@@ -23,7 +23,6 @@
 #include "vboot_common.h"
 #include "vboot_display.h"
 #include "vboot_kernel.h"
-#include "vboot_nvstorage.h"
 #include "vboot_struct.h"
 
 /* Mock data */
@@ -250,28 +249,28 @@ static void VbSoftwareSyncTest(void)
 	ResetMocks();
 	in_rw_retval = VBERROR_SIMULATED;
 	test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
-		   VBNV_RECOVERY_EC_UNKNOWN_IMAGE, "Unknown EC image");
+		   VB2_RECOVERY_EC_UNKNOWN_IMAGE, "Unknown EC image");
 
 	/* Calculate hashes */
 	ResetMocks();
 	mock_ec_rw_hash_size = 0;
 	test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
-		   VBNV_RECOVERY_EC_HASH_FAILED, "Bad EC hash");
+		   VB2_RECOVERY_EC_HASH_FAILED, "Bad EC hash");
 
 	ResetMocks();
 	mock_ec_rw_hash_size = 16;
 	test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
-		   VBNV_RECOVERY_EC_HASH_SIZE, "Bad EC hash size");
+		   VB2_RECOVERY_EC_HASH_SIZE, "Bad EC hash size");
 
 	ResetMocks();
 	want_ec_hash_size = 0;
 	test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
-		   VBNV_RECOVERY_EC_EXPECTED_HASH, "Bad precalculated hash");
+		   VB2_RECOVERY_EC_EXPECTED_HASH, "Bad precalculated hash");
 
 	ResetMocks();
 	want_ec_hash_size = 16;
 	test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
-		   VBNV_RECOVERY_EC_HASH_SIZE,
+		   VB2_RECOVERY_EC_HASH_SIZE,
 		   "Hash size mismatch");
 
 	ResetMocks();
@@ -343,7 +342,7 @@ static void VbSoftwareSyncTest(void)
 	mock_ec_rw_hash[0]++;
 	update_hash++;
 	test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
-		   VBNV_RECOVERY_EC_UPDATE, "updated hash mismatch");
+		   VB2_RECOVERY_EC_UPDATE, "updated hash mismatch");
 	TEST_EQ(ec_rw_protected, 0, "  ec rw protected");
 	TEST_EQ(ec_run_image, 0, "  ec run image");
 	TEST_EQ(ec_rw_updated, 1, "  ec rw updated");
@@ -362,7 +361,7 @@ static void VbSoftwareSyncTest(void)
 	mock_ec_rw_hash[0]++;
 	update_retval = VBERROR_SIMULATED;
 	test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
-		   VBNV_RECOVERY_EC_UPDATE, "Update failed");
+		   VB2_RECOVERY_EC_UPDATE, "Update failed");
 
 	ResetMocks();
 	mock_ec_rw_hash[0]++;
@@ -386,7 +385,7 @@ static void VbSoftwareSyncTest(void)
 	ResetMocks();
 	run_retval = VBERROR_SIMULATED;
 	test_ssync(VBERROR_EC_REBOOT_TO_RO_REQUIRED,
-		   VBNV_RECOVERY_EC_JUMP_RW, "Jump to RW fail");
+		   VB2_RECOVERY_EC_JUMP_RW, "Jump to RW fail");
 
 	ResetMocks();
 	run_retval = VBERROR_EC_REBOOT_TO_RO_REQUIRED;
@@ -396,7 +395,7 @@ static void VbSoftwareSyncTest(void)
 	ResetMocks();
 	protect_retval = VBERROR_SIMULATED;
 	test_ssync(VBERROR_SIMULATED,
-		   VBNV_RECOVERY_EC_PROTECT, "Protect error");
+		   VB2_RECOVERY_EC_PROTECT, "Protect error");
 
 	/* No longer check for shutdown requested */
 	ResetMocks();
diff --git a/tests/vboot_api_devmode_tests.c b/tests/vboot_api_devmode_tests.c
index 6ec74b29..a65fc269 100644
--- a/tests/vboot_api_devmode_tests.c
+++ b/tests/vboot_api_devmode_tests.c
@@ -12,6 +12,7 @@
 
 #include "2sysincludes.h"
 #include "2api.h"
+#include "2nvstorage.h"
 #include "crc32.h"
 #include "gbb_header.h"
 #include "host_common.h"
@@ -21,7 +22,6 @@
 #include "vboot_common.h"
 #include "vboot_display.h"
 #include "vboot_kernel.h"
-#include "vboot_nvstorage.h"
 #include "vboot_struct.h"
 
 
@@ -135,7 +135,6 @@ test_case_t test[] = {
 /* Mock data */
 static VbCommonParams cparams;
 static struct vb2_context ctx;
-static VbNvContext vnc;
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader* shared = (VbSharedDataHeader*)shared_data;
 static GoogleBinaryBlockHeader gbb;
@@ -161,10 +160,7 @@ static void ResetMocks(void) {
   cparams.gbb = &gbb;
 
   memset(&ctx, 0, sizeof(ctx));
-
-  memset(&vnc, 0, sizeof(vnc));
-  VbNvSetup(&vnc);
-  VbNvTeardown(&vnc);  /* So CRC gets generated */
+  vb2_nv_init(&ctx);
 
   memset(&shared_data, 0, sizeof(shared_data));
   VbSharedDataInit(shared, sizeof(shared_data));
@@ -193,12 +189,10 @@ static void ResetMocks(void) {
 /* Mocked verification functions */
 
 VbError_t VbExNvStorageRead(uint8_t* buf) {
-  memcpy(buf, vnc.raw, sizeof(vnc.raw));
   return VBERROR_SUCCESS;
 }
 
 VbError_t VbExNvStorageWrite(const uint8_t* buf) {
-  memcpy(vnc.raw, buf, sizeof(vnc.raw));
   return VBERROR_SUCCESS;
 }
 
diff --git a/tests/vboot_api_kernel2_tests.c b/tests/vboot_api_kernel2_tests.c
index 384c978d..da0af9b5 100644
--- a/tests/vboot_api_kernel2_tests.c
+++ b/tests/vboot_api_kernel2_tests.c
@@ -22,7 +22,6 @@
 #include "vboot_common.h"
 #include "vboot_display.h"
 #include "vboot_kernel.h"
-#include "vboot_nvstorage.h"
 #include "vboot_struct.h"
 
 /* Mock data */
@@ -307,7 +306,7 @@ static void VbBootDevTest(void)
 	 * legacy are set */
 	ResetMocks();
 	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VBNV_DEV_DEFAULT_BOOT_LEGACY);
+		   VB2_DEV_DEFAULT_BOOT_LEGACY);
 	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_LEGACY, 1);
 	TEST_EQ(VbBootDeveloper(&ctx, &cparams), 1002, "Timeout");
 	TEST_EQ(vbexlegacy_called, 1, "  try legacy");
@@ -315,7 +314,7 @@ static void VbBootDevTest(void)
 	/* Proceed to legacy boot mode only if enabled */
 	ResetMocks();
 	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VBNV_DEV_DEFAULT_BOOT_LEGACY);
+		   VB2_DEV_DEFAULT_BOOT_LEGACY);
 	TEST_EQ(VbBootDeveloper(&ctx, &cparams), 1002, "Timeout");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 
@@ -323,7 +322,7 @@ static void VbBootDevTest(void)
 	 * usb are set */
 	ResetMocks();
 	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VBNV_DEV_DEFAULT_BOOT_USB);
+		   VB2_DEV_DEFAULT_BOOT_USB);
 	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
 	vbtlk_retval = VBERROR_SUCCESS - VB_DISK_FLAG_REMOVABLE;
 	TEST_EQ(VbBootDeveloper(&ctx, &cparams), 0, "Ctrl+U USB");
@@ -331,14 +330,14 @@ static void VbBootDevTest(void)
 	/* Proceed to usb boot mode only if enabled */
 	ResetMocks();
 	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VBNV_DEV_DEFAULT_BOOT_USB);
+		   VB2_DEV_DEFAULT_BOOT_USB);
 	TEST_EQ(VbBootDeveloper(&ctx, &cparams), 1002, "Timeout");
 
 	/* If no USB tries fixed disk */
 	ResetMocks();
 	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_USB, 1);
 	vb2_nv_set(&ctx, VB2_NV_DEV_DEFAULT_BOOT,
-		   VBNV_DEV_DEFAULT_BOOT_USB);
+		   VB2_DEV_DEFAULT_BOOT_USB);
 	TEST_EQ(VbBootDeveloper(&ctx, &cparams), 1002, "Ctrl+U enabled");
 	TEST_EQ(vbexlegacy_called, 0, "  not legacy");
 
@@ -369,7 +368,7 @@ static void VbBootDevTest(void)
 		VBERROR_LOAD_KERNEL_RECOVERY,
 		"Space = recovery");
 	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
-		VBNV_RECOVERY_RW_DEV_SCREEN, "  recovery reason");
+		VB2_RECOVERY_RW_DEV_SCREEN, "  recovery reason");
 
 	/* Space asks to disable virtual dev switch */
 	ResetMocks();
diff --git a/tests/vboot_api_kernel4_tests.c b/tests/vboot_api_kernel4_tests.c
index e00c928a..e239192c 100644
--- a/tests/vboot_api_kernel4_tests.c
+++ b/tests/vboot_api_kernel4_tests.c
@@ -9,6 +9,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 
+#include "2sysincludes.h"
+#include "2api.h"
+#include "2nvstorage.h"
 #include "ec_sync.h"
 #include "gbb_header.h"
 #include "host_common.h"
@@ -18,13 +21,12 @@
 #include "vboot_audio.h"
 #include "vboot_common.h"
 #include "vboot_kernel.h"
-#include "vboot_nvstorage.h"
 #include "vboot_struct.h"
 
 /* Mock data */
+static struct vb2_context ctx;
 static VbCommonParams cparams;
 static VbSelectAndLoadKernelParams kparams;
-static VbNvContext vnc;
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
 static GoogleBinaryBlockHeader gbb;
@@ -51,10 +53,9 @@ static void ResetMocks(void)
 	gbb.minor_version = GBB_MINOR_VER;
 	gbb.flags = 0;
 
-	memset(&vnc, 0, sizeof(vnc));
-	VbNvSetup(&vnc);
-	VbNvSet(&vnc, VBNV_KERNEL_MAX_ROLLFORWARD, 0xffffffff);
-	VbNvTeardown(&vnc);                   /* So CRC gets generated */
+	memset(&ctx, 0, sizeof(ctx));
+	vb2_nv_init(&ctx);
+	vb2_nv_set(&ctx, VB2_NV_KERNEL_MAX_ROLLFORWARD, 0xffffffff);
 
 	memset(&shared_data, 0, sizeof(shared_data));
 	VbSharedDataInit(shared, sizeof(shared_data));
@@ -71,13 +72,13 @@ static void ResetMocks(void)
 
 VbError_t VbExNvStorageRead(uint8_t *buf)
 {
-	memcpy(buf, vnc.raw, sizeof(vnc.raw));
+	memcpy(buf, ctx.nvdata, sizeof(ctx.nvdata));
 	return VBERROR_SUCCESS;
 }
 
 VbError_t VbExNvStorageWrite(const uint8_t *buf)
 {
-	memcpy(vnc.raw, buf, sizeof(vnc.raw));
+	memcpy(ctx.nvdata, buf, sizeof(ctx.nvdata));
 	return VBERROR_SUCCESS;
 }
 
@@ -137,11 +138,9 @@ VbError_t VbBootRecovery(struct vb2_context *ctx, VbCommonParams *cparams)
 
 static void test_slk(VbError_t retval, int recovery_reason, const char *desc)
 {
-	uint32_t u;
-
 	TEST_EQ(VbSelectAndLoadKernel(&cparams, &kparams), retval, desc);
-	VbNvGet(&vnc, VBNV_RECOVERY_REQUEST, &u);
-	TEST_EQ(u, recovery_reason, "  recovery reason");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
+		recovery_reason, "  recovery reason");
 }
 
 /* Tests */
@@ -169,7 +168,7 @@ static void VbSlkTest(void)
 	ResetMocks();
 	rkr_retval = 123;
 	test_slk(VBERROR_TPM_READ_KERNEL,
-		 VBNV_RECOVERY_RW_TPM_R_ERROR, "Read kernel rollback");
+		 VB2_RECOVERY_RW_TPM_R_ERROR, "Read kernel rollback");
 
 	ResetMocks();
 	new_version = 0x20003;
@@ -184,23 +183,20 @@ static void VbSlkTest(void)
 	TEST_EQ(rkr_version, 0x10002, "  version");
 
 	ResetMocks();
-	VbNvSet(&vnc, VBNV_KERNEL_MAX_ROLLFORWARD, 0x30005);
-	VbNvTeardown(&vnc);
+	vb2_nv_set(&ctx, VB2_NV_KERNEL_MAX_ROLLFORWARD, 0x30005);
 	new_version = 0x40006;
 	test_slk(0, 0, "Limit max roll forward");
 	TEST_EQ(rkr_version, 0x30005, "  version");
 
 	ResetMocks();
-	VbNvSet(&vnc, VBNV_KERNEL_MAX_ROLLFORWARD, 0x10001);
-	VbNvTeardown(&vnc);
+	vb2_nv_set(&ctx, VB2_NV_KERNEL_MAX_ROLLFORWARD, 0x10001);
 	new_version = 0x40006;
 	test_slk(0, 0, "Max roll forward can't rollback");
 	TEST_EQ(rkr_version, 0x10002, "  version");
 
 	ResetMocks();
 	vbboot_retval = VBERROR_INVALID_KERNEL_FOUND;
-	VbNvSet(&vnc, VBNV_RECOVERY_REQUEST, 123);
-	VbNvTeardown(&vnc);
+	vb2_nv_set(&ctx, VB2_NV_RECOVERY_REQUEST, 123);
 	shared->flags |= VBSD_FWB_TRIED;
 	shared->firmware_index = 1;
 	test_slk(VBERROR_INVALID_KERNEL_FOUND,
@@ -210,12 +206,12 @@ static void VbSlkTest(void)
 	new_version = 0x20003;
 	rkw_retval = 123;
 	test_slk(VBERROR_TPM_WRITE_KERNEL,
-		 VBNV_RECOVERY_RW_TPM_W_ERROR, "Write kernel rollback");
+		 VB2_RECOVERY_RW_TPM_W_ERROR, "Write kernel rollback");
 
 	ResetMocks();
 	rkl_retval = 123;
 	test_slk(VBERROR_TPM_LOCK_KERNEL,
-		 VBNV_RECOVERY_RW_TPM_L_ERROR, "Lock kernel rollback");
+		 VB2_RECOVERY_RW_TPM_L_ERROR, "Lock kernel rollback");
 
 	/* Boot normal */
 	ResetMocks();
@@ -252,7 +248,7 @@ static void VbSlkTest(void)
 	test_slk(0, 0, "Recovery ignore TPM errors");
 
 	ResetMocks();
-	shared->recovery_reason = VBNV_RECOVERY_TRAIN_AND_REBOOT;
+	shared->recovery_reason = VB2_RECOVERY_TRAIN_AND_REBOOT;
 	test_slk(VBERROR_REBOOT_REQUIRED, 0, "Recovery train and reboot");
 
 	// todo: rkr/w/l fail ignored if recovery
diff --git a/tests/vboot_api_kernel5_tests.c b/tests/vboot_api_kernel5_tests.c
index 077c07a4..2d7c2e76 100644
--- a/tests/vboot_api_kernel5_tests.c
+++ b/tests/vboot_api_kernel5_tests.c
@@ -11,7 +11,9 @@
 #include <string.h>
 
 #include "2sysincludes.h"
+#include "2api.h"
 #include "2common.h"
+#include "2nvstorage.h"
 #include "2rsa.h"
 #include "gbb_header.h"
 #include "host_common.h"
@@ -21,10 +23,10 @@
 #include "vboot_api.h"
 #include "vboot_common.h"
 #include "vboot_kernel.h"
-#include "vboot_nvstorage.h"
 #include "vboot_struct.h"
 
 /* Mock data */
+static struct vb2_context ctx;
 static VbCommonParams cparams;
 static VbSelectAndLoadKernelParams kparams;
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
@@ -37,7 +39,6 @@ static int preamble_verify_fail;
 static int verify_data_fail;
 static int unpack_key_fail;
 
-static VbNvContext vnc;
 static VbKeyBlockHeader kbh;
 static VbKernelPreambleHeader kph;
 
@@ -61,9 +62,8 @@ static void ResetMocks(void)
 	gbb.minor_version = GBB_MINOR_VER;
 	gbb.flags = 0;
 
-	memset(&vnc, 0, sizeof(vnc));
-	VbNvSetup(&vnc);
-	VbNvTeardown(&vnc);                   /* So CRC gets generated */
+	memset(&ctx, 0, sizeof(ctx));
+	vb2_nv_init(&ctx);
 
 	memset(&shared_data, 0, sizeof(shared_data));
 	VbSharedDataInit(shared, sizeof(shared_data));
@@ -162,7 +162,7 @@ int vb2_verify_data(const uint8_t *data,
 
 VbError_t VbExNvStorageRead(uint8_t *buf)
 {
-	memcpy(buf, vnc.raw, sizeof(vnc.raw));
+	memcpy(buf, ctx.nvdata, sizeof(ctx.nvdata));
 	return VBERROR_SUCCESS;
 }
 
@@ -225,8 +225,7 @@ static void VerifyMemoryBootImageTest(void)
 	ResetMocks();
 	shared->flags = VBSD_BOOT_DEV_SWITCH_ON;
 	key_block_verify_fail = 1;
-	VbNvSet(&vnc, VBNV_DEV_BOOT_FASTBOOT_FULL_CAP, 1);
-	VbNvTeardown(&vnc);
+	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_FASTBOOT_FULL_CAP, 1);
 	TEST_EQ(VbVerifyMemoryBootImage(&cparams, &kparams, kernel_buffer,
 					kernel_buffer_size),
 		VBERROR_INVALID_KERNEL_FOUND, "Key verify failed");
diff --git a/tests/vboot_api_kernel6_tests.c b/tests/vboot_api_kernel6_tests.c
index a24cde80..801ff727 100644
--- a/tests/vboot_api_kernel6_tests.c
+++ b/tests/vboot_api_kernel6_tests.c
@@ -12,7 +12,6 @@
 
 #include "test_common.h"
 #include "vboot_api.h"
-#include "vboot_nvstorage.h"
 
 /* Mock data */
 static uint32_t virtual_dev_mode_fail;
diff --git a/tests/vboot_api_kernel_tests.c b/tests/vboot_api_kernel_tests.c
index 3214d442..dd63bb4b 100644
--- a/tests/vboot_api_kernel_tests.c
+++ b/tests/vboot_api_kernel_tests.c
@@ -84,7 +84,7 @@ test_case_t test[] = {
 		.loadkernel_return_val = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1,},
 		.external_expected = {1, 0, 0, 0, 0, 0, 0, 0, 0, 0,},
 
-		.expected_recovery_request_val = VBNV_RECOVERY_NOT_REQUESTED,
+		.expected_recovery_request_val = VB2_RECOVERY_NOT_REQUESTED,
 		.expected_to_find_disk = pickme,
 		.expected_to_load_disk = pickme,
 		.expected_return_val = VBERROR_SUCCESS
@@ -102,7 +102,7 @@ test_case_t test[] = {
 		.diskgetinfo_return_val = VBERROR_SUCCESS,
 		.loadkernel_return_val = {1, 0, 1, 1, 1, 1, 1, 1, 1, 1,},
 
-		.expected_recovery_request_val = VBNV_RECOVERY_NOT_REQUESTED,
+		.expected_recovery_request_val = VB2_RECOVERY_NOT_REQUESTED,
 		.expected_to_find_disk = pickme,
 		.expected_to_load_disk = pickme,
 		.expected_return_val = VBERROR_SUCCESS
@@ -132,7 +132,7 @@ test_case_t test[] = {
 		.diskgetinfo_return_val = VBERROR_SUCCESS,
 		.loadkernel_return_val = {0, 1, 1, 1, 1, 1, 1, 1, 1, 1,},
 
-		.expected_recovery_request_val = VBNV_RECOVERY_NOT_REQUESTED,
+		.expected_recovery_request_val = VB2_RECOVERY_NOT_REQUESTED,
 		.expected_to_find_disk = pickme,
 		.expected_to_load_disk = pickme,
 		.expected_return_val = VBERROR_SUCCESS
@@ -145,7 +145,7 @@ test_case_t test[] = {
 		.diskgetinfo_return_val = VBERROR_SUCCESS,
 		.loadkernel_return_val = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1,},
 
-		.expected_recovery_request_val = VBNV_RECOVERY_RW_NO_DISK,
+		.expected_recovery_request_val = VB2_RECOVERY_RW_NO_DISK,
 		.expected_to_find_disk = 0,
 		.expected_to_load_disk = 0,
 		.expected_return_val = VBERROR_NO_DISK_FOUND
@@ -173,7 +173,7 @@ test_case_t test[] = {
 		.diskgetinfo_return_val = VBERROR_SUCCESS,
 		.loadkernel_return_val = {1, 1, 1, 1, 1, 1, 1, 1, 1, 1,},
 
-		.expected_recovery_request_val = VBNV_RECOVERY_RW_NO_KERNEL,
+		.expected_recovery_request_val = VB2_RECOVERY_RW_NO_KERNEL,
 		.expected_to_find_disk = DONT_CARE,
 		.expected_to_load_disk = 0,
 		.expected_return_val = 1
@@ -205,7 +205,7 @@ static void ResetMocks(int i)
 	memset(&mock_disks, 0, sizeof(mock_disks));
 	load_kernel_calls = 0;
 
-	got_recovery_request_val = VBNV_RECOVERY_NOT_REQUESTED;
+	got_recovery_request_val = VB2_RECOVERY_NOT_REQUESTED;
 	got_find_disk = 0;
 	got_load_disk = 0;
 	got_return_val = 0xdeadbeef;
diff --git a/tests/vboot_audio_tests.c b/tests/vboot_audio_tests.c
index 99d9bd4f..94bbb0ac 100644
--- a/tests/vboot_audio_tests.c
+++ b/tests/vboot_audio_tests.c
@@ -20,7 +20,6 @@
 #include "vboot_audio_private.h"
 #include "vboot_common.h"
 #include "vboot_display.h"
-#include "vboot_nvstorage.h"
 #include "vboot_struct.h"
 
 
diff --git a/tests/vboot_display_tests.c b/tests/vboot_display_tests.c
index 33421b5b..a0f9eade 100644
--- a/tests/vboot_display_tests.c
+++ b/tests/vboot_display_tests.c
@@ -22,7 +22,6 @@
 #include "vboot_common.h"
 #include "vboot_display.h"
 #include "vboot_kernel.h"
-#include "vboot_nvstorage.h"
 
 /* Mock data */
 static VbCommonParams cparams;
diff --git a/tests/vboot_kernel_tests.c b/tests/vboot_kernel_tests.c
index b1e1635e..d581b373 100644
--- a/tests/vboot_kernel_tests.c
+++ b/tests/vboot_kernel_tests.c
@@ -14,6 +14,7 @@
 #include "2api.h"
 #include "2common.h"
 #include "2misc.h"
+#include "2nvstorage.h"
 #include "2sha.h"
 #include "cgptlib.h"
 #include "cgptlib_internal.h"
@@ -28,7 +29,6 @@
 #include "vboot_api.h"
 #include "vboot_common.h"
 #include "vboot_kernel.h"
-#include "vboot_nvstorage.h"
 
 #define LOGCALL(fmt, args...) sprintf(call_log + strlen(call_log), fmt, ##args)
 #define TEST_CALLS(expect_log) TEST_STR_EQ(call_log, expect_log, "  calls")
@@ -62,7 +62,6 @@ static int gpt_flag_external;
 static uint8_t gbb_data[sizeof(GoogleBinaryBlockHeader) + 2048];
 static GoogleBinaryBlockHeader *gbb = (GoogleBinaryBlockHeader*)gbb_data;
 static VbExDiskHandle_t handle;
-static VbNvContext vnc;
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
 static LoadKernelParams lkp;
@@ -152,12 +151,7 @@ static void ResetMocks(void)
 	cparams.gbb_size = sizeof(gbb_data);
 	cparams.shared_data_blob = shared;
 
-	memset(&vnc, 0, sizeof(vnc));
-	VbNvSetup(&vnc);
-	VbNvTeardown(&vnc);                   /* So CRC gets generated */
-
 	memset(&lkp, 0, sizeof(lkp));
-	lkp.nv_context = &vnc;
 	lkp.bytes_per_lba = 512;
 	lkp.streaming_lba_count = 1024;
 	lkp.gpt_lba_count = 1024;
@@ -186,9 +180,10 @@ static void ResetMocks(void)
 	mock_part_next = 0;
 
 	memset(&ctx, 0, sizeof(ctx));
-	memcpy(ctx.nvdata, vnc.raw, VB2_NVDATA_SIZE);
 	ctx.workbuf = workbuf;
 	ctx.workbuf_size = sizeof(workbuf);
+	vb2_nv_init(&ctx);
+
 	// TODO: more workbuf fields - flags, secdata, secdatak
 }
 
@@ -574,15 +569,7 @@ static void ReadWriteGptTest(void)
 
 static void TestLoadKernel(int expect_retval, char *test_name)
 {
-	memcpy(ctx.nvdata, vnc.raw, VB2_NVDATA_SIZE);
-
 	TEST_EQ(LoadKernel(&ctx, &lkp, &cparams), expect_retval, test_name);
-
-	if (ctx.flags & VB2_CONTEXT_NVDATA_CHANGED) {
-		memcpy(vnc.raw, ctx.nvdata, VB2_NVDATA_SIZE);
-		vnc.raw_changed = 1;
-		ctx.flags &= ~VB2_CONTEXT_NVDATA_CHANGED;
-	}
 }
 
 /**
@@ -602,8 +589,6 @@ static void InvalidParamsTest(void)
 
 static void LoadKernelTest(void)
 {
-	uint32_t u;
-
 	ResetMocks();
 
 	TestLoadKernel(0, "First kernel good");
@@ -612,8 +597,8 @@ static void LoadKernelTest(void)
 	TEST_EQ(lkp.bootloader_size, 0x1234, "  bootloader size");
 	TEST_STR_EQ((char *)lkp.partition_guid, "FakeGuid", "  guid");
 	TEST_EQ(gpt_flag_external, 0, "GPT was internal");
-	VbNvGet(&vnc, VBNV_RECOVERY_REQUEST, &u);
-	TEST_EQ(u, 0, "  recovery request");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
+		0, "  recovery request");
 
 	ResetMocks();
 	mock_parts[1].start = 300;
@@ -626,15 +611,15 @@ static void LoadKernelTest(void)
 	ResetMocks();
 	mock_parts[0].size = 0;
 	TestLoadKernel(VBERROR_NO_KERNEL_FOUND, "No kernels");
-	VbNvGet(&vnc, VBNV_RECOVERY_REQUEST, &u);
-	TEST_EQ(u, VBNV_RECOVERY_RW_NO_OS, "  recovery request");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
+		VB2_RECOVERY_RW_NO_OS, "  recovery request");
 
 	/* Skip kernels which are too small */
 	ResetMocks();
 	mock_parts[0].size = 10;
 	TestLoadKernel(VBERROR_INVALID_KERNEL_FOUND, "Too small");
-	VbNvGet(&vnc, VBNV_RECOVERY_REQUEST, &u);
-	TEST_EQ(u, VBNV_RECOVERY_RW_INVALID_OS, "  recovery request");
+	TEST_EQ(vb2_nv_get(&ctx, VB2_NV_RECOVERY_REQUEST),
+		VB2_RECOVERY_RW_INVALID_OS, "  recovery request");
 
 	ResetMocks();
 	disk_read_to_fail = 100;
@@ -660,8 +645,7 @@ static void LoadKernelTest(void)
 	/* In dev mode and requiring signed kernel, fail if sig is bad */
 	ResetMocks();
 	ctx.flags |= VB2_CONTEXT_DEVELOPER_MODE;
-	VbNvSet(&vnc, VBNV_DEV_BOOT_SIGNED_ONLY, 1);
-	VbNvTeardown(&vnc);
+	vb2_nv_set(&ctx, VB2_NV_DEV_BOOT_SIGNED_ONLY, 1);
 	key_block_verify_fail = 1;
 	TestLoadKernel(VBERROR_INVALID_KERNEL_FOUND, "Fail key block dev sig");
 
diff --git a/tests/vboot_nvstorage_test.c b/tests/vboot_nvstorage_test.c
deleted file mode 100644
index c461978f..00000000
--- a/tests/vboot_nvstorage_test.c
+++ /dev/null
@@ -1,208 +0,0 @@
-/* Copyright (c) 2013 The Chromium OS Authors. All rights reserved.
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- *
- * Tests for firmware NV storage library.
- */
-
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "test_common.h"
-#include "vboot_common.h"
-#include "vboot_nvstorage.h"
-
-/* Single NV storage field to test */
-typedef struct VbNvField {
-  VbNvParam param;          /* Parameter index */
-  uint32_t default_value;   /* Expected default value */
-  uint32_t test_value;      /* Value to test writing */
-  uint32_t test_value2;     /* Second value to test writing */
-  char* desc;               /* Field description */
-} VbNvField;
-
-/* Array of fields to test, terminated with a field with desc==NULL. */
-static VbNvField nvfields[] = {
-  {VBNV_DEBUG_RESET_MODE, 0, 1, 0, "debug reset mode"},
-  {VBNV_TRY_B_COUNT, 0, 6, 15, "try B count"},
-  {VBNV_RECOVERY_REQUEST, 0, 0x42, 0xED, "recovery request"},
-  {VBNV_LOCALIZATION_INDEX, 0, 0x69, 0xB0, "localization index"},
-  {VBNV_KERNEL_FIELD, 0, 0x1234, 0xFEDC, "kernel field"},
-  {VBNV_DEV_BOOT_USB, 0, 1, 0, "dev boot usb"},
-  {VBNV_DEV_BOOT_LEGACY, 0, 1, 0, "dev boot legacy"},
-  {VBNV_DEV_BOOT_SIGNED_ONLY, 0, 1, 0, "dev boot custom"},
-  {VBNV_DEV_BOOT_FASTBOOT_FULL_CAP, 0, 1, 0, "dev boot fastboot full cap"},
-  {VBNV_DEV_DEFAULT_BOOT, 0, 1, 2, "dev default boot"},
-  {VBNV_DISABLE_DEV_REQUEST, 0, 1, 0, "disable dev request"},
-  {VBNV_CLEAR_TPM_OWNER_REQUEST, 0, 1, 0, "clear tpm owner request"},
-  {VBNV_CLEAR_TPM_OWNER_DONE, 0, 1, 0, "clear tpm owner done"},
-  {VBNV_TPM_REQUESTED_REBOOT, 0, 1, 0, "tpm requested reboot"},
-  {VBNV_OPROM_NEEDED, 0, 1, 0, "oprom needed"},
-  {VBNV_FW_TRY_COUNT, 0, 8, 15, "try count"},
-  {VBNV_FW_TRY_NEXT, 0, 1, 0, "try next"},
-  {VBNV_FW_TRIED, 0, 1, 0, "firmware tried"},
-  {VBNV_FW_RESULT, VBNV_FW_RESULT_UNKNOWN, 1, 2, "firmware result"},
-  {VBNV_FW_PREV_TRIED, 0, 1, 0, "firmware prev tried"},
-  {VBNV_FW_PREV_RESULT, VBNV_FW_RESULT_UNKNOWN, 1, 3, "firmware prev result"},
-  {VBNV_FASTBOOT_UNLOCK_IN_FW, 0, 1, 0, "fastboot unlock in firmware"},
-  {VBNV_BOOT_ON_AC_DETECT, 0, 1, 0, "boot on ac detect"},
-  {VBNV_TRY_RO_SYNC, 0, 1, 0, "try read only software sync"},
-  {VBNV_KERNEL_MAX_ROLLFORWARD, 0, 0x12345678, 0xFEDCBA98,
-   "kernel max rollforward"},
-  {0, 0, 0, 0, NULL}
-};
-
-static void VbNvStorageTest(void) {
-
-  VbNvField* vnf;
-  VbNvContext c;
-  uint8_t goodcrc;
-  uint32_t data;
-
-  memset(&c, 0xA6, sizeof(c));
-
-  /* Open with invalid data should set defaults */
-  TEST_EQ(VbNvSetup(&c), 0, "VbNvSetup()");
-  TEST_EQ(c.raw[0], 0x70, "VbNvSetup() reset header byte");
-  /* Close then regenerates the CRC */
-  TEST_EQ(VbNvTeardown(&c), 0, "VbNvTeardown()");
-  TEST_NEQ(c.raw[15], 0, "VbNvTeardown() CRC");
-  TEST_EQ(c.raw_changed, 1, "VbNvTeardown() changed");
-  goodcrc = c.raw[15];
-  /* Another open-close pair should not cause further changes */
-  VbNvSetup(&c);
-  VbNvTeardown(&c);
-  TEST_EQ(c.raw_changed, 0, "VbNvTeardown() didn't change");
-  TEST_EQ(c.raw[15], goodcrc, "VbNvTeardown() CRC same");
-
-  /* Perturbing the header should force defaults */
-  c.raw[0] ^= 0x40;
-  VbNvSetup(&c);
-  TEST_EQ(c.raw[0], 0x70, "VbNvSetup() reset header byte again");
-  /* Close then regenerates the CRC */
-  VbNvTeardown(&c);
-  TEST_EQ(c.raw_changed, 1, "VbNvTeardown() changed again");
-  TEST_EQ(c.raw[15], goodcrc, "VbNvTeardown() CRC same again");
-
-  /* So should perturbing some other byte */
-  TEST_EQ(c.raw[11], 0, "Kernel byte starts at 0");
-  c.raw[11] = 12;
-  VbNvSetup(&c);
-  TEST_EQ(c.raw[11], 0, "VbNvSetup() reset kernel byte");
-  /* Close then regenerates the CRC */
-  VbNvTeardown(&c);
-  TEST_EQ(c.raw_changed, 1, "VbNvTeardown() changed again");
-  TEST_EQ(c.raw[15], goodcrc, "VbNvTeardown() CRC same again");
-
-  /* Clear the kernel and firmware flags */
-  VbNvSetup(&c);
-  TEST_EQ(VbNvGet(&c, VBNV_FIRMWARE_SETTINGS_RESET, &data), 0,
-          "Get firmware settings reset");
-  TEST_EQ(data, 1, "Firmware settings are reset");
-  TEST_EQ(VbNvSet(&c, VBNV_FIRMWARE_SETTINGS_RESET, 0), 0,
-          "Clear firmware settings reset");
-  VbNvGet(&c, VBNV_FIRMWARE_SETTINGS_RESET, &data);
-  TEST_EQ(data, 0, "Firmware settings are clear");
-
-  TEST_EQ(VbNvGet(&c, VBNV_KERNEL_SETTINGS_RESET, &data), 0,
-          "Get kernel settings reset");
-  TEST_EQ(data, 1, "Kernel settings are reset");
-  TEST_EQ(VbNvSet(&c, VBNV_KERNEL_SETTINGS_RESET, 0), 0,
-          "Clear kernel settings reset");
-  VbNvGet(&c, VBNV_KERNEL_SETTINGS_RESET, &data);
-  TEST_EQ(data, 0, "Kernel settings are clear");
-  TEST_EQ(c.raw[0], 0x40, "Header byte now just has the header bit");
-  VbNvTeardown(&c);
-  /* That should have changed the CRC */
-  TEST_NEQ(c.raw[15], goodcrc, "VbNvTeardown() CRC changed due to flags clear");
-
-  /* Test explicitly setting the reset flags again */
-  VbNvSetup(&c);
-  VbNvSet(&c, VBNV_FIRMWARE_SETTINGS_RESET, 1);
-  VbNvGet(&c, VBNV_FIRMWARE_SETTINGS_RESET, &data);
-  TEST_EQ(data, 1, "Firmware settings forced reset");
-  VbNvSet(&c, VBNV_FIRMWARE_SETTINGS_RESET, 0);
-
-  VbNvSet(&c, VBNV_KERNEL_SETTINGS_RESET, 1);
-  VbNvGet(&c, VBNV_KERNEL_SETTINGS_RESET, &data);
-  TEST_EQ(data, 1, "Kernel settings forced reset");
-  VbNvSet(&c, VBNV_KERNEL_SETTINGS_RESET, 0);
-  VbNvTeardown(&c);
-
-  /* Get/set an invalid field */
-  VbNvSetup(&c);
-  TEST_EQ(VbNvGet(&c, -1, &data), 1, "Get invalid setting");
-  TEST_EQ(VbNvSet(&c, -1, 0), 1, "Set invalid setting");
-  VbNvTeardown(&c);
-
-  /* Test other fields */
-  VbNvSetup(&c);
-  /* Test all defaults first, since some fields alias onto others */
-  for (vnf = nvfields; vnf->desc; vnf++) {
-    printf("Testing field: %s\n", vnf->desc);
-    TEST_EQ(VbNvGet(&c, vnf->param, &data), 0, "  get");
-    TEST_EQ(data, vnf->default_value, "  default");
-  }
-  /* Now test get/set */
-  for (vnf = nvfields; vnf->desc; vnf++) {
-    printf("Testing field: %s\n", vnf->desc);
-    TEST_EQ(VbNvSet(&c, vnf->param, vnf->test_value), 0, "  set 1");
-    TEST_EQ(VbNvGet(&c, vnf->param, &data), 0, "  get 1");
-    TEST_EQ(data, vnf->test_value, "  value 1");
-
-    TEST_EQ(VbNvSet(&c, vnf->param, vnf->test_value2), 0, "  set 2");
-    TEST_EQ(VbNvGet(&c, vnf->param, &data), 0, "  get 2");
-    TEST_EQ(data, vnf->test_value2, "  value 2");
-  }
-  VbNvTeardown(&c);
-
-  /* None of those changes should have caused a reset to defaults */
-  VbNvSetup(&c);
-  VbNvGet(&c, VBNV_FIRMWARE_SETTINGS_RESET, &data);
-  TEST_EQ(data, 0, "Firmware settings are still clear");
-  VbNvGet(&c, VBNV_KERNEL_SETTINGS_RESET, &data);
-  TEST_EQ(data, 0, "Kernel settings are still clear");
-  VbNvTeardown(&c);
-
-  /* Verify writing identical settings doesn't cause the CRC to regenerate */
-  VbNvSetup(&c);
-  TEST_EQ(c.regenerate_crc, 0, "No regen CRC on open");
-  for (vnf = nvfields; vnf->desc; vnf++)
-    TEST_EQ(VbNvSet(&c, vnf->param, vnf->test_value2), 0, vnf->desc);
-  TEST_EQ(c.regenerate_crc, 0, "No regen CRC if data not changed");
-  VbNvTeardown(&c);
-  TEST_EQ(c.raw_changed, 0, "No raw change if data not changed");
-
-  /* Test out-of-range fields mapping to defaults */
-  VbNvSetup(&c);
-  VbNvSet(&c, VBNV_TRY_B_COUNT, 16);
-  VbNvGet(&c, VBNV_TRY_B_COUNT, &data);
-  TEST_EQ(data, 15, "Try b count out of range");
-  VbNvSetup(&c);
-  VbNvSet(&c, VBNV_FW_TRY_COUNT, 16);
-  VbNvGet(&c, VBNV_FW_TRY_COUNT, &data);
-  TEST_EQ(data, 15, "Try count out of range");
-  VbNvSet(&c, VBNV_RECOVERY_REQUEST, 0x101);
-  VbNvGet(&c, VBNV_RECOVERY_REQUEST, &data);
-  TEST_EQ(data, VBNV_RECOVERY_LEGACY, "Recovery request out of range");
-  VbNvSet(&c, VBNV_LOCALIZATION_INDEX, 0x102);
-  VbNvGet(&c, VBNV_LOCALIZATION_INDEX, &data);
-  TEST_EQ(data, 0, "Localization index out of range");
-  VbNvSet(&c, VBNV_FW_RESULT, VBNV_FW_RESULT_UNKNOWN + 100);
-  VbNvGet(&c, VBNV_FW_RESULT, &data);
-  TEST_EQ(data, VBNV_FW_RESULT_UNKNOWN, "Firmware result out of range");
-  VbNvSet(&c, VBNV_DEV_DEFAULT_BOOT, VBNV_DEV_DEFAULT_BOOT_DISK + 100);
-  VbNvGet(&c, VBNV_DEV_DEFAULT_BOOT, &data);
-  TEST_EQ(data, VBNV_DEV_DEFAULT_BOOT_DISK, "Firmware result out of range");
-  VbNvTeardown(&c);
-}
-
-
-int main(int argc, char* argv[])
-{
-  VbNvStorageTest();
-
-  return gTestSuccess ? 0 : 255;
-}
diff --git a/tests/vboot_region_tests.c b/tests/vboot_region_tests.c
index 464461c7..a08daede 100644
--- a/tests/vboot_region_tests.c
+++ b/tests/vboot_region_tests.c
@@ -16,12 +16,12 @@
 #include "rollback_index.h"
 #include "test_common.h"
 #include "vboot_common.h"
-#include "vboot_nvstorage.h"
 #include "vboot_struct.h"
 
+typedef struct VbNvContext VbNvContext;
+
 /* Mock data */
 static VbCommonParams cparams;
-static VbNvContext vnc;
 static VbSelectFirmwareParams fparams;
 VbSelectAndLoadKernelParams kparams;
 static char gbb_data[4096 + sizeof(GoogleBinaryBlockHeader)];
@@ -45,10 +45,6 @@ static void ResetMocks(void) {
 	ScreenLayout *layout;
 	int gbb_used;
 
-	memset(&vnc, 0, sizeof(vnc));
-	VbNvSetup(&vnc);
-	VbNvTeardown(&vnc);                   /* So CRC gets generated */
-
 	memset(&cparams, 0, sizeof(cparams));
 	cparams.shared_data_size = sizeof(shared_data);
 	cparams.shared_data_blob = shared_data;
@@ -116,12 +112,10 @@ static void ResetMocks(void) {
 /* Mocked verification functions */
 
 VbError_t VbExNvStorageRead(uint8_t* buf) {
-  memcpy(buf, vnc.raw, sizeof(vnc.raw));
   return VBERROR_SUCCESS;
 }
 
 VbError_t VbExNvStorageWrite(const uint8_t* buf) {
-  memcpy(vnc.raw, buf, sizeof(vnc.raw));
   return VBERROR_SUCCESS;
 }
 
diff --git a/tests/verify_kernel.c b/tests/verify_kernel.c
index 5c48781b..58c01ad9 100644
--- a/tests/verify_kernel.c
+++ b/tests/verify_kernel.c
@@ -12,6 +12,7 @@
 #include "2sysincludes.h"
 #include "2api.h"
 #include "2misc.h"
+#include "2nvstorage.h"
 #include "host_common.h"
 #include "util_misc.h"
 #include "vboot_common.h"
@@ -22,7 +23,6 @@ static uint8_t *diskbuf;
 
 static uint8_t shared_data[VB_SHARED_DATA_MIN_SIZE];
 static VbSharedDataHeader *shared = (VbSharedDataHeader *)shared_data;
-static VbNvContext nvc;
 
 static LoadKernelParams params;
 static VbCommonParams cparams;
@@ -111,20 +111,13 @@ int main(int argc, char *argv[])
 	params.boot_flags = 0;
 
 	/*
-	 * LoadKernel() cares only about VBNV_DEV_BOOT_SIGNED_ONLY, and only in
-	 * dev mode.  So just use defaults.
-	 */
-	VbNvSetup(&nvc);
-	params.nv_context = &nvc;
-
-	/*
 	 * Set up vboot context.
 	 *
 	 * TODO: Propagate this up to higher API levels
 	 */
 	struct vb2_context ctx;
 	memset(&ctx, 0, sizeof(ctx));
-	/* No need to initialize ctx->nvdata[]; defaults are fine */
+
 	/* TODO(chromium:441893): support dev-mode flag and external gpt flag */
 	ctx.workbuf = malloc(VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE);
 	if (!ctx.workbuf) {
@@ -139,6 +132,12 @@ int main(int argc, char *argv[])
 		return 1;
 	}
 
+	/*
+	 * LoadKernel() cares only about VBNV_DEV_BOOT_SIGNED_ONLY, and only in
+	 * dev mode.  So just use defaults for nv storage.
+	 */
+	vb2_nv_init(&ctx);
+
 	/* Try loading kernel */
 	rv = LoadKernel(&ctx, &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;