tests/vboot_api_kernel4_tests.c - third_party/platform/vboot_reference - Git at Google

 /* 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 vboot_api_kernel, part 4 - select and load kernel
  */

 #include "2api.h"
 #include "2common.h"
 #include "2misc.h"
 #include "2nvstorage.h"
 #include "2secdata.h"
 #include "2sysincludes.h"
 #include "2ui.h"
 #include "host_common.h"
 #include "load_kernel_fw.h"
 #include "test_common.h"
 #include "tlcl.h"
 #include "tss_constants.h"
 #include "vboot_kernel.h"
 #include "vboot_struct.h"
 #include "vboot_test.h"

 /* Mock data */

 static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE]
 	__attribute__((aligned(VB2_WORKBUF_ALIGN)));
 static struct vb2_context *ctx;
 static struct vb2_shared_data *sd;
 static VbSelectAndLoadKernelParams kparams;
 static struct vb2_gbb_header gbb;

 static uint32_t kernel_version;
 static uint32_t new_version;
 static vb2_error_t vbboot_retval;
 static int commit_data_called;
 static vb2_error_t secdata_kernel_init_retval;
 static vb2_error_t secdata_fwmp_init_retval;
 static vb2_error_t kernel_phase1_retval;
 static uint32_t current_recovery_reason;
 static uint32_t expected_recovery_reason;

 static int mock_diagnostic_ui_enabled;

 static void reset_common_data(void)
 {
 	memset(&kparams, 0, sizeof(kparams));

 	memset(&gbb, 0, sizeof(gbb));
 	gbb.major_version = VB2_GBB_MAJOR_VER;
 	gbb.minor_version = VB2_GBB_MINOR_VER;
 	gbb.flags = 0;

 	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
 		  "vb2api_init failed");
 	sd = vb2_get_sd(ctx);
 	sd->flags |= VB2_SD_FLAG_DISPLAY_AVAILABLE;
 	ctx->flags |= VB2_CONTEXT_NO_SECDATA_FWMP;
 	sd->preamble_size = 1;

 	vb2_nv_init(ctx);
 	vb2_nv_set(ctx, VB2_NV_KERNEL_MAX_ROLLFORWARD, 0xffffffff);
 	commit_data_called = 0;

 	kernel_version = new_version = 0x10002;
 	vbboot_retval = VB2_SUCCESS;
 	secdata_kernel_init_retval = VB2_SUCCESS;
 	secdata_fwmp_init_retval = VB2_SUCCESS;
 	kernel_phase1_retval = VB2_SUCCESS;
 	current_recovery_reason = 0;
 	expected_recovery_reason = 0;

 	mock_diagnostic_ui_enabled = 0;

 	sd->status |= VB2_SD_STATUS_SECDATA_KERNEL_INIT;
 	sd->status |= VB2_SD_STATUS_SECDATA_FWMP_INIT;
 }

 static void test_slk(vb2_error_t retval, int recovery_reason, const char *desc)
 {
 	if (sd->recovery_reason)
 		ctx->flags |= VB2_CONTEXT_RECOVERY_MODE;

 	expected_recovery_reason = recovery_reason;
 	TEST_EQ(VbSelectAndLoadKernel(ctx, &kparams), retval, desc);
 	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
 		recovery_reason, "  recovery reason");
 }

 /* Mock functions */

 struct vb2_gbb_header *vb2_get_gbb(struct vb2_context *c)
 {
 	return &gbb;
 }

 vb2_error_t vb2api_kernel_phase1(struct vb2_context *c)
 {
 	sd->kernel_version_secdata = kernel_version;
 	sd->kernel_version = kernel_version;
 	return kernel_phase1_retval;
 }

 vb2_error_t vb2ex_commit_data(struct vb2_context *c)
 {
 	current_recovery_reason = vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST);
 	commit_data_called = 1;
 	return VB2_SUCCESS;
 }

 vb2_error_t vb2_secdata_fwmp_init(struct vb2_context *c)
 {
 	return secdata_fwmp_init_retval;
 }

 void vb2_secdata_kernel_set(struct vb2_context *c,
 			    enum vb2_secdata_kernel_param param,
 			    uint32_t value)
 {
 	kernel_version = value;
 }

 vb2_error_t VbTryLoadKernel(struct vb2_context *c, uint32_t get_info_flags)
 {
 	sd->kernel_version = new_version;

 	if (vbboot_retval == -1)
 		return VB2_ERROR_MOCK;

 	return vbboot_retval;
 }

 static vb2_error_t boot_dev(struct vb2_context *c)
 {
 	if (vbboot_retval == -2)
 		return VB2_ERROR_MOCK;

 	return vbboot_retval;
 }

 vb2_error_t vb2_developer_menu(struct vb2_context *c)
 {
 	return boot_dev(c);
 }

 static void rec_check(struct vb2_context *c)
 {
 	TEST_EQ(current_recovery_reason, expected_recovery_reason,
 		"  recovery reason");
 	TEST_TRUE(commit_data_called, "  commit data");
 }

 vb2_error_t vb2_manual_recovery_menu(struct vb2_context *c)
 {
 	rec_check(c);
 	if (vbboot_retval == -3)
 		return VB2_ERROR_MOCK;
 	return vbboot_retval;
 }

 vb2_error_t vb2_broken_recovery_menu(struct vb2_context *c)
 {
 	rec_check(c);
 	if (vbboot_retval == -4)
 		return VB2_ERROR_MOCK;
 	return vbboot_retval;
 }

 vb2_error_t vb2_diagnostic_menu(struct vb2_context *c)
 {
 	if (vbboot_retval == -5)
 		return VB2_ERROR_MOCK;

 	return vbboot_retval;
 }

 int vb2api_diagnostic_ui_enabled(struct vb2_context *c)
 {
 	return mock_diagnostic_ui_enabled;
 }

 vb2_error_t vb2ex_tpm_set_mode(enum vb2_tpm_mode mode_val)
 {
 	return VB2_SUCCESS;
 }

 /* Tests */

 static void select_and_load_kernel_tests(void)
 {
 	/* Normal boot */
 	reset_common_data();
 	test_slk(0, 0, "Normal");
 	TEST_EQ(kernel_version, 0x10002, "  version");
 	TEST_NEQ(sd->status & VB2_SD_STATUS_EC_SYNC_COMPLETE, 0,
 		 "  EC sync complete");
 	TEST_FALSE(commit_data_called, "  no commit data");

 	/* Check EC sync toggling */
 	reset_common_data();
 	ctx->flags |= VB2_CONTEXT_EC_SYNC_SUPPORTED;
 	gbb.flags |= VB2_GBB_FLAG_DISABLE_EC_SOFTWARE_SYNC;
 	test_slk(0, 0, "EC sync disabled by GBB");
 	TEST_NEQ(sd->status & VB2_SD_STATUS_EC_SYNC_COMPLETE, 0,
 		 "  EC sync complete");

 	reset_common_data();
 	ctx->flags |= VB2_CONTEXT_EC_SYNC_SUPPORTED;
 	test_slk(0, 0, "Normal with EC sync");
 	TEST_NEQ(sd->status & VB2_SD_STATUS_EC_SYNC_COMPLETE, 0,
 		 "  EC sync complete");

 	reset_common_data();
 	new_version = 0x20003;
 	test_slk(0, 0, "Roll forward");
 	TEST_EQ(kernel_version, 0x20003, "  version");

 	reset_common_data();
 	vb2_nv_set(ctx, VB2_NV_FW_RESULT, VB2_FW_RESULT_TRYING);
 	new_version = 0x20003;
 	test_slk(0, 0, "Don't roll forward kernel when trying new FW");
 	TEST_EQ(kernel_version, 0x10002, "  version");

 	reset_common_data();
 	vb2_nv_set(ctx, VB2_NV_KERNEL_MAX_ROLLFORWARD, 0x30005);
 	new_version = 0x40006;
 	test_slk(0, 0, "Limit max roll forward");
 	TEST_EQ(kernel_version, 0x30005, "  version");

 	reset_common_data();
 	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(kernel_version, 0x10002, "  version");

 	/* Boot normal */
 	reset_common_data();
 	vbboot_retval = -1;
 	test_slk(VB2_ERROR_MOCK, 0, "Normal boot bad");

 	/* Check that NV_DIAG_REQUEST triggers diagnostic UI */
 	if (DIAGNOSTIC_UI) {
 		reset_common_data();
 		mock_diagnostic_ui_enabled = 1;
 		vb2_nv_set(ctx, VB2_NV_DIAG_REQUEST, 1);
 		vbboot_retval = -5;
 		test_slk(VB2_ERROR_MOCK, 0,
 			 "Normal boot with diag enabled");
 		TEST_EQ(vb2_nv_get(ctx, VB2_NV_DIAG_REQUEST), 0,
 			"  diag not requested");

 		reset_common_data();
 		vb2_nv_set(ctx, VB2_NV_DIAG_REQUEST, 1);
 		test_slk(VB2_REQUEST_REBOOT, 0,
 			 "Normal boot with diag disabled (reboot to "
 			 "unset)");
 	}

 	/* Boot normal - phase1 failure */
 	reset_common_data();
 	kernel_phase1_retval = VB2_ERROR_MOCK;
 	test_slk(VB2_ERROR_MOCK, 0, "Normal phase1 failure");

 	/* Recovery - VB2_ERROR_ESCAPE_NO_BOOT */
 	reset_common_data();
 	ctx->flags |= VB2_CONTEXT_NO_BOOT;
 	test_slk(VB2_ERROR_ESCAPE_NO_BOOT,
 		 VB2_RECOVERY_ESCAPE_NO_BOOT, "Recovery for NO_BOOT escape");

 	/* Boot normal - VB2_ERROR_ESCAPE_NO_BOOT */
 	reset_common_data();
 	ctx->flags |= VB2_CONTEXT_NO_BOOT;
 	gbb.flags |= VB2_GBB_FLAG_DISABLE_EC_SOFTWARE_SYNC;
 	test_slk(VB2_SUCCESS, 0, "DISABLE_EC_SOFTWARE_SYNC ignores NO_BOOT");

 	/* Boot dev */
 	reset_common_data();
 	ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
 	vbboot_retval = -2;
 	test_slk(VB2_ERROR_MOCK, 0, "Dev boot bad");
 	TEST_FALSE(commit_data_called, "  no commit data");

 	reset_common_data();
 	ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
 	new_version = 0x20003;
 	test_slk(0, 0, "Dev doesn't roll forward");
 	TEST_EQ(kernel_version, 0x10002, "  version");

 	/* Boot dev - phase1 failure */
 	reset_common_data();
 	ctx->flags |= VB2_CONTEXT_DEVELOPER_MODE;
 	kernel_phase1_retval = VB2_ERROR_MOCK;
 	test_slk(VB2_ERROR_MOCK, 0, "Dev phase1 failure");

 	/* Boot recovery */
 	reset_common_data();
 	sd->recovery_reason = 123;
 	vbboot_retval = -4;
 	test_slk(VB2_ERROR_MOCK, 0, "Recovery boot bad");
 	TEST_TRUE(commit_data_called, "  commit data");

 	reset_common_data();
 	sd->recovery_reason = 123;
 	new_version = 0x20003;
 	test_slk(0, 0, "Recovery doesn't roll forward");
 	TEST_EQ(kernel_version, 0x10002, "  version");
 	TEST_TRUE(commit_data_called, "  commit data");

 	/* Boot recovery - phase1 failure */
 	reset_common_data();
 	sd->recovery_reason = 123;
 	kernel_phase1_retval = VB2_ERROR_MOCK;
 	test_slk(VB2_ERROR_MOCK, 0, "Recovery phase1 failure");
 	TEST_FALSE(commit_data_called, "  no commit data");

 	/* Boot recovery - memory retraining */
 	reset_common_data();
 	sd->recovery_reason = VB2_RECOVERY_TRAIN_AND_REBOOT;
 	test_slk(VB2_REQUEST_REBOOT, 0, "Recovery train and reboot");
 	TEST_FALSE(commit_data_called, "  no commit data");

 	/* Boot BROKEN recovery */
 	reset_common_data();
 	sd->recovery_reason = 123;
 	vb2_nv_set(ctx, VB2_NV_RECOVERY_SUBCODE, 13);
 	test_slk(0, 0, "BROKEN recovery");
 	TEST_TRUE(commit_data_called, "  commit data");

 	/* Boot manual recovery */
 	reset_common_data();
 	sd->recovery_reason = VB2_RECOVERY_RO_MANUAL;
 	vb2_nv_set(ctx, VB2_NV_RECOVERY_SUBCODE, 13);
 	sd->flags |= VB2_SD_FLAG_MANUAL_RECOVERY;
 	test_slk(0, 0, "Manual recovery");
 	TEST_TRUE(commit_data_called, "  commit data");
 }

 int main(void)
 {
 	select_and_load_kernel_tests();

 	return gTestSuccess ? 0 : 255;
 }
	/* 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 vboot_api_kernel, part 4 - select and load kernel
	*/

	#include "2api.h"
	#include "2common.h"
	#include "2misc.h"
	#include "2nvstorage.h"
	#include "2secdata.h"
	#include "2sysincludes.h"
	#include "2ui.h"
	#include "host_common.h"
	#include "load_kernel_fw.h"
	#include "test_common.h"
	#include "tlcl.h"
	#include "tss_constants.h"
	#include "vboot_kernel.h"
	#include "vboot_struct.h"
	#include "vboot_test.h"

	/* Mock data */

	static uint8_t workbuf[VB2_KERNEL_WORKBUF_RECOMMENDED_SIZE]
	__attribute__((aligned(VB2_WORKBUF_ALIGN)));
	static struct vb2_context *ctx;
	static struct vb2_shared_data *sd;
	static VbSelectAndLoadKernelParams kparams;
	static struct vb2_gbb_header gbb;

	static uint32_t kernel_version;
	static uint32_t new_version;
	static vb2_error_t vbboot_retval;
	static int commit_data_called;
	static vb2_error_t secdata_kernel_init_retval;
	static vb2_error_t secdata_fwmp_init_retval;
	static vb2_error_t kernel_phase1_retval;
	static uint32_t current_recovery_reason;
	static uint32_t expected_recovery_reason;

	static int mock_diagnostic_ui_enabled;

	static void reset_common_data(void)
	{
	memset(&kparams, 0, sizeof(kparams));

	memset(&gbb, 0, sizeof(gbb));
	gbb.major_version = VB2_GBB_MAJOR_VER;
	gbb.minor_version = VB2_GBB_MINOR_VER;
	gbb.flags = 0;

	TEST_SUCC(vb2api_init(workbuf, sizeof(workbuf), &ctx),
	"vb2api_init failed");
	sd = vb2_get_sd(ctx);
	sd->flags \|= VB2_SD_FLAG_DISPLAY_AVAILABLE;
	ctx->flags \|= VB2_CONTEXT_NO_SECDATA_FWMP;
	sd->preamble_size = 1;

	vb2_nv_init(ctx);
	vb2_nv_set(ctx, VB2_NV_KERNEL_MAX_ROLLFORWARD, 0xffffffff);
	commit_data_called = 0;

	kernel_version = new_version = 0x10002;
	vbboot_retval = VB2_SUCCESS;
	secdata_kernel_init_retval = VB2_SUCCESS;
	secdata_fwmp_init_retval = VB2_SUCCESS;
	kernel_phase1_retval = VB2_SUCCESS;
	current_recovery_reason = 0;
	expected_recovery_reason = 0;

	mock_diagnostic_ui_enabled = 0;

	sd->status \|= VB2_SD_STATUS_SECDATA_KERNEL_INIT;
	sd->status \|= VB2_SD_STATUS_SECDATA_FWMP_INIT;
	}

	static void test_slk(vb2_error_t retval, int recovery_reason, const char *desc)
	{
	if (sd->recovery_reason)
	ctx->flags \|= VB2_CONTEXT_RECOVERY_MODE;

	expected_recovery_reason = recovery_reason;
	TEST_EQ(VbSelectAndLoadKernel(ctx, &kparams), retval, desc);
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST),
	recovery_reason, " recovery reason");
	}

	/* Mock functions */

	struct vb2_gbb_header vb2_get_gbb(struct vb2_context c)
	{
	return &gbb;
	}

	vb2_error_t vb2api_kernel_phase1(struct vb2_context *c)
	{
	sd->kernel_version_secdata = kernel_version;
	sd->kernel_version = kernel_version;
	return kernel_phase1_retval;
	}

	vb2_error_t vb2ex_commit_data(struct vb2_context *c)
	{
	current_recovery_reason = vb2_nv_get(ctx, VB2_NV_RECOVERY_REQUEST);
	commit_data_called = 1;
	return VB2_SUCCESS;
	}

	vb2_error_t vb2_secdata_fwmp_init(struct vb2_context *c)
	{
	return secdata_fwmp_init_retval;
	}

	void vb2_secdata_kernel_set(struct vb2_context *c,
	enum vb2_secdata_kernel_param param,
	uint32_t value)
	{
	kernel_version = value;
	}

	vb2_error_t VbTryLoadKernel(struct vb2_context *c, uint32_t get_info_flags)
	{
	sd->kernel_version = new_version;

	if (vbboot_retval == -1)
	return VB2_ERROR_MOCK;

	return vbboot_retval;
	}

	static vb2_error_t boot_dev(struct vb2_context *c)
	{
	if (vbboot_retval == -2)
	return VB2_ERROR_MOCK;

	return vbboot_retval;
	}

	vb2_error_t vb2_developer_menu(struct vb2_context *c)
	{
	return boot_dev(c);
	}

	static void rec_check(struct vb2_context *c)
	{
	TEST_EQ(current_recovery_reason, expected_recovery_reason,
	" recovery reason");
	TEST_TRUE(commit_data_called, " commit data");
	}

	vb2_error_t vb2_manual_recovery_menu(struct vb2_context *c)
	{
	rec_check(c);
	if (vbboot_retval == -3)
	return VB2_ERROR_MOCK;
	return vbboot_retval;
	}

	vb2_error_t vb2_broken_recovery_menu(struct vb2_context *c)
	{
	rec_check(c);
	if (vbboot_retval == -4)
	return VB2_ERROR_MOCK;
	return vbboot_retval;
	}

	vb2_error_t vb2_diagnostic_menu(struct vb2_context *c)
	{
	if (vbboot_retval == -5)
	return VB2_ERROR_MOCK;

	return vbboot_retval;
	}

	int vb2api_diagnostic_ui_enabled(struct vb2_context *c)
	{
	return mock_diagnostic_ui_enabled;
	}

	vb2_error_t vb2ex_tpm_set_mode(enum vb2_tpm_mode mode_val)
	{
	return VB2_SUCCESS;
	}

	/* Tests */

	static void select_and_load_kernel_tests(void)
	{
	/* Normal boot */
	reset_common_data();
	test_slk(0, 0, "Normal");
	TEST_EQ(kernel_version, 0x10002, " version");
	TEST_NEQ(sd->status & VB2_SD_STATUS_EC_SYNC_COMPLETE, 0,
	" EC sync complete");
	TEST_FALSE(commit_data_called, " no commit data");

	/* Check EC sync toggling */
	reset_common_data();
	ctx->flags \|= VB2_CONTEXT_EC_SYNC_SUPPORTED;
	gbb.flags \|= VB2_GBB_FLAG_DISABLE_EC_SOFTWARE_SYNC;
	test_slk(0, 0, "EC sync disabled by GBB");
	TEST_NEQ(sd->status & VB2_SD_STATUS_EC_SYNC_COMPLETE, 0,
	" EC sync complete");

	reset_common_data();
	ctx->flags \|= VB2_CONTEXT_EC_SYNC_SUPPORTED;
	test_slk(0, 0, "Normal with EC sync");
	TEST_NEQ(sd->status & VB2_SD_STATUS_EC_SYNC_COMPLETE, 0,
	" EC sync complete");

	reset_common_data();
	new_version = 0x20003;
	test_slk(0, 0, "Roll forward");
	TEST_EQ(kernel_version, 0x20003, " version");

	reset_common_data();
	vb2_nv_set(ctx, VB2_NV_FW_RESULT, VB2_FW_RESULT_TRYING);
	new_version = 0x20003;
	test_slk(0, 0, "Don't roll forward kernel when trying new FW");
	TEST_EQ(kernel_version, 0x10002, " version");

	reset_common_data();
	vb2_nv_set(ctx, VB2_NV_KERNEL_MAX_ROLLFORWARD, 0x30005);
	new_version = 0x40006;
	test_slk(0, 0, "Limit max roll forward");
	TEST_EQ(kernel_version, 0x30005, " version");

	reset_common_data();
	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(kernel_version, 0x10002, " version");

	/* Boot normal */
	reset_common_data();
	vbboot_retval = -1;
	test_slk(VB2_ERROR_MOCK, 0, "Normal boot bad");

	/* Check that NV_DIAG_REQUEST triggers diagnostic UI */
	if (DIAGNOSTIC_UI) {
	reset_common_data();
	mock_diagnostic_ui_enabled = 1;
	vb2_nv_set(ctx, VB2_NV_DIAG_REQUEST, 1);
	vbboot_retval = -5;
	test_slk(VB2_ERROR_MOCK, 0,
	"Normal boot with diag enabled");
	TEST_EQ(vb2_nv_get(ctx, VB2_NV_DIAG_REQUEST), 0,
	" diag not requested");

	reset_common_data();
	vb2_nv_set(ctx, VB2_NV_DIAG_REQUEST, 1);
	test_slk(VB2_REQUEST_REBOOT, 0,
	"Normal boot with diag disabled (reboot to "
	"unset)");
	}

	/* Boot normal - phase1 failure */
	reset_common_data();
	kernel_phase1_retval = VB2_ERROR_MOCK;
	test_slk(VB2_ERROR_MOCK, 0, "Normal phase1 failure");

	/* Recovery - VB2_ERROR_ESCAPE_NO_BOOT */
	reset_common_data();
	ctx->flags \|= VB2_CONTEXT_NO_BOOT;
	test_slk(VB2_ERROR_ESCAPE_NO_BOOT,
	VB2_RECOVERY_ESCAPE_NO_BOOT, "Recovery for NO_BOOT escape");

	/* Boot normal - VB2_ERROR_ESCAPE_NO_BOOT */
	reset_common_data();
	ctx->flags \|= VB2_CONTEXT_NO_BOOT;
	gbb.flags \|= VB2_GBB_FLAG_DISABLE_EC_SOFTWARE_SYNC;
	test_slk(VB2_SUCCESS, 0, "DISABLE_EC_SOFTWARE_SYNC ignores NO_BOOT");

	/* Boot dev */
	reset_common_data();
	ctx->flags \|= VB2_CONTEXT_DEVELOPER_MODE;
	vbboot_retval = -2;
	test_slk(VB2_ERROR_MOCK, 0, "Dev boot bad");
	TEST_FALSE(commit_data_called, " no commit data");

	reset_common_data();
	ctx->flags \|= VB2_CONTEXT_DEVELOPER_MODE;
	new_version = 0x20003;
	test_slk(0, 0, "Dev doesn't roll forward");
	TEST_EQ(kernel_version, 0x10002, " version");

	/* Boot dev - phase1 failure */
	reset_common_data();
	ctx->flags \|= VB2_CONTEXT_DEVELOPER_MODE;
	kernel_phase1_retval = VB2_ERROR_MOCK;
	test_slk(VB2_ERROR_MOCK, 0, "Dev phase1 failure");

	/* Boot recovery */
	reset_common_data();
	sd->recovery_reason = 123;
	vbboot_retval = -4;
	test_slk(VB2_ERROR_MOCK, 0, "Recovery boot bad");
	TEST_TRUE(commit_data_called, " commit data");

	reset_common_data();
	sd->recovery_reason = 123;
	new_version = 0x20003;
	test_slk(0, 0, "Recovery doesn't roll forward");
	TEST_EQ(kernel_version, 0x10002, " version");
	TEST_TRUE(commit_data_called, " commit data");

	/* Boot recovery - phase1 failure */
	reset_common_data();
	sd->recovery_reason = 123;
	kernel_phase1_retval = VB2_ERROR_MOCK;
	test_slk(VB2_ERROR_MOCK, 0, "Recovery phase1 failure");
	TEST_FALSE(commit_data_called, " no commit data");

	/* Boot recovery - memory retraining */
	reset_common_data();
	sd->recovery_reason = VB2_RECOVERY_TRAIN_AND_REBOOT;
	test_slk(VB2_REQUEST_REBOOT, 0, "Recovery train and reboot");
	TEST_FALSE(commit_data_called, " no commit data");

	/* Boot BROKEN recovery */
	reset_common_data();
	sd->recovery_reason = 123;
	vb2_nv_set(ctx, VB2_NV_RECOVERY_SUBCODE, 13);
	test_slk(0, 0, "BROKEN recovery");
	TEST_TRUE(commit_data_called, " commit data");

	/* Boot manual recovery */
	reset_common_data();
	sd->recovery_reason = VB2_RECOVERY_RO_MANUAL;
	vb2_nv_set(ctx, VB2_NV_RECOVERY_SUBCODE, 13);
	sd->flags \|= VB2_SD_FLAG_MANUAL_RECOVERY;
	test_slk(0, 0, "Manual recovery");
	TEST_TRUE(commit_data_called, " commit data");
	}

	int main(void)
	{
	select_and_load_kernel_tests();

	return gTestSuccess ? 0 : 255;
	}