[people/ms/u-boot.git] / lib / efi_selftest / efi_selftest.c

/*
 * EFI efi_selftest
 *
 * Copyright (c) 2017 Heinrich Schuchardt <xypron.glpk@gmx.de>
 *
 * SPDX-License-Identifier:     GPL-2.0+
 */

#include <efi_selftest.h>
#include <vsprintf.h>

static const struct efi_system_table *systable;
static const struct efi_boot_services *boottime;
static const struct efi_runtime_services *runtime;
static efi_handle_t handle;
static u16 reset_message[] = L"Selftest completed";

/*
 * Exit the boot services.
 *
 * The size of the memory map is determined.
 * Pool memory is allocated to copy the memory map.
 * The memory amp is copied and the map key is obtained.
 * The map key is used to exit the boot services.
 */
void efi_st_exit_boot_services(void)
{
	unsigned long  map_size = 0;
	unsigned long  map_key;
	unsigned long desc_size;
	u32 desc_version;
	efi_status_t ret;
	struct efi_mem_desc *memory_map;

	ret = boottime->get_memory_map(&map_size, NULL, &map_key, &desc_size,
				       &desc_version);
	if (ret != EFI_BUFFER_TOO_SMALL) {
		efi_st_error(
			"GetMemoryMap did not return EFI_BUFFER_TOO_SMALL\n");
		return;
	}
	/* Allocate extra space for newly allocated memory */
	map_size += sizeof(struct efi_mem_desc);
	ret = boottime->allocate_pool(EFI_BOOT_SERVICES_DATA, map_size,
				      (void **)&memory_map);
	if (ret != EFI_SUCCESS) {
		efi_st_error("AllocatePool did not return EFI_SUCCESS\n");
		return;
	}
	ret = boottime->get_memory_map(&map_size, memory_map, &map_key,
				       &desc_size, &desc_version);
	if (ret != EFI_SUCCESS) {
		efi_st_error("GetMemoryMap did not return EFI_SUCCESS\n");
		return;
	}
	ret = boottime->exit_boot_services(handle, map_key);
	if (ret != EFI_SUCCESS) {
		efi_st_error("ExitBootServices did not return EFI_SUCCESS\n");
		return;
	}
	efi_st_printf("\nBoot services terminated\n");
}

/*
 * Set up a test.
 *
 * @test	the test to be executed
 * @failures	counter that will be incremented if a failure occurs
 * @return	EFI_ST_SUCCESS for success
 */
static int setup(struct efi_unit_test *test, unsigned int *failures)
{
	int ret;

	if (!test->setup)
		return EFI_ST_SUCCESS;
	efi_st_printf("\nSetting up '%s'\n", test->name);
	ret = test->setup(handle, systable);
	if (ret != EFI_ST_SUCCESS) {
		efi_st_error("Setting up '%s' failed\n", test->name);
		++*failures;
	} else {
		efi_st_printf("Setting up '%s' succeeded\n", test->name);
	}
	return ret;
}

/*
 * Execute a test.
 *
 * @test	the test to be executed
 * @failures	counter that will be incremented if a failure occurs
 * @return	EFI_ST_SUCCESS for success
 */
static int execute(struct efi_unit_test *test, unsigned int *failures)
{
	int ret;

	if (!test->execute)
		return EFI_ST_SUCCESS;
	efi_st_printf("\nExecuting '%s'\n", test->name);
	ret = test->execute();
	if (ret != EFI_ST_SUCCESS) {
		efi_st_error("Executing '%s' failed\n", test->name);
		++*failures;
	} else {
		efi_st_printf("Executing '%s' succeeded\n", test->name);
	}
	return ret;
}

/*
 * Tear down a test.
 *
 * @test	the test to be torn down
 * @failures	counter that will be incremented if a failure occurs
 * @return	EFI_ST_SUCCESS for success
 */
static int teardown(struct efi_unit_test *test, unsigned int *failures)
{
	int ret;

	if (!test->teardown)
		return EFI_ST_SUCCESS;
	efi_st_printf("\nTearing down '%s'\n", test->name);
	ret = test->teardown();
	if (ret != EFI_ST_SUCCESS) {
		efi_st_error("Tearing down '%s' failed\n", test->name);
		++*failures;
	} else {
		efi_st_printf("Tearing down '%s' succeeded\n", test->name);
	}
	return ret;
}

/*
 * Execute selftest of the EFI API
 *
 * This is the main entry point of the EFI selftest application.
 *
 * All tests use a driver model and are run in three phases:
 * setup, execute, teardown.
 *
 * A test may be setup and executed at boottime,
 * it may be setup at boottime and executed at runtime,
 * or it may be setup and executed at runtime.
 *
 * After executing all tests the system is reset.
 *
 * @image_handle:	handle of the loaded EFI image
 * @systab:		EFI system table
 */
efi_status_t EFIAPI efi_selftest(efi_handle_t image_handle,
				 struct efi_system_table *systab)
{
	struct efi_unit_test *test;
	unsigned int failures = 0;

	systable = systab;
	boottime = systable->boottime;
	runtime = systable->runtime;
	handle = image_handle;
	con_out = systable->con_out;
	con_in = systable->con_in;

	efi_st_printf("\nTesting EFI API implementation\n");

	efi_st_printf("\nNumber of tests to execute: %u\n",
		      ll_entry_count(struct efi_unit_test, efi_unit_test));

	/* Execute boottime tests */
	for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
	     test < ll_entry_end(struct efi_unit_test, efi_unit_test); ++test) {
		if (test->phase == EFI_EXECUTE_BEFORE_BOOTTIME_EXIT) {
			setup(test, &failures);
			execute(test, &failures);
			teardown(test, &failures);
		}
	}

	/* Execute mixed tests */
	for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
	     test < ll_entry_end(struct efi_unit_test, efi_unit_test); ++test) {
		if (test->phase == EFI_SETUP_BEFORE_BOOTTIME_EXIT)
			setup(test, &failures);
	}

	efi_st_exit_boot_services();

	for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
	     test < ll_entry_end(struct efi_unit_test, efi_unit_test); ++test) {
		if (test->phase == EFI_SETUP_BEFORE_BOOTTIME_EXIT) {
			execute(test, &failures);
			teardown(test, &failures);
		}
	}

	/* Execute runtime tests */
	for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
	     test < ll_entry_end(struct efi_unit_test, efi_unit_test); ++test) {
		if (test->phase == EFI_SETUP_AFTER_BOOTTIME_EXIT) {
			setup(test, &failures);
			execute(test, &failures);
			teardown(test, &failures);
		}
	}

	/* Give feedback */
	efi_st_printf("\nSummary: %u failures\n\n", failures);

	/* Reset system */
	efi_st_printf("Preparing for reset. Press any key.\n");
	efi_st_get_key();
	runtime->reset_system(EFI_RESET_WARM, EFI_NOT_READY,
			      sizeof(reset_message), reset_message);
	efi_st_printf("\n");
	efi_st_error("Reset failed.\n");

	return EFI_UNSUPPORTED;
}
Commit	Line	Data
623b3a57 HS	1	/*
	2	* EFI efi_selftest
	3	*
	4	* Copyright (c) 2017 Heinrich Schuchardt <xypron.glpk@gmx.de>
	5	*
	6	* SPDX-License-Identifier: GPL-2.0+
	7	*/
	8
	9	#include <efi_selftest.h>
	10	#include <vsprintf.h>
	11
	12	static const struct efi_system_table *systable;
	13	static const struct efi_boot_services *boottime;
	14	static const struct efi_runtime_services *runtime;
	15	static efi_handle_t handle;
	16	static u16 reset_message[] = L"Selftest completed";
	17
	18	/*
	19	* Exit the boot services.
	20	*
	21	* The size of the memory map is determined.
	22	* Pool memory is allocated to copy the memory map.
	23	* The memory amp is copied and the map key is obtained.
	24	* The map key is used to exit the boot services.
	25	*/
	26	void efi_st_exit_boot_services(void)
	27	{
	28	unsigned long map_size = 0;
	29	unsigned long map_key;
	30	unsigned long desc_size;
	31	u32 desc_version;
	32	efi_status_t ret;
	33	struct efi_mem_desc *memory_map;
	34
	35	ret = boottime->get_memory_map(&map_size, NULL, &map_key, &desc_size,
	36	&desc_version);
	37	if (ret != EFI_BUFFER_TOO_SMALL) {
037ee6f9 HS	38	efi_st_error(
037ee6f9 HS	39	"GetMemoryMap did not return EFI_BUFFER_TOO_SMALL\n");
623b3a57 HS	40	return;
	41	}
	42	/* Allocate extra space for newly allocated memory */
	43	map_size += sizeof(struct efi_mem_desc);
	44	ret = boottime->allocate_pool(EFI_BOOT_SERVICES_DATA, map_size,
	45	(void **)&memory_map);
	46	if (ret != EFI_SUCCESS) {
037ee6f9	47	efi_st_error("AllocatePool did not return EFI_SUCCESS\n");
623b3a57 HS	48	return;
	49	}
	50	ret = boottime->get_memory_map(&map_size, memory_map, &map_key,
	51	&desc_size, &desc_version);
	52	if (ret != EFI_SUCCESS) {
037ee6f9	53	efi_st_error("GetMemoryMap did not return EFI_SUCCESS\n");
623b3a57 HS	54	return;
	55	}
	56	ret = boottime->exit_boot_services(handle, map_key);
	57	if (ret != EFI_SUCCESS) {
037ee6f9	58	efi_st_error("ExitBootServices did not return EFI_SUCCESS\n");
623b3a57 HS	59	return;
	60	}
	61	efi_st_printf("\nBoot services terminated\n");
	62	}
	63
	64	/*
	65	* Set up a test.
	66	*
	67	* @test the test to be executed
	68	* @failures counter that will be incremented if a failure occurs
e67e7249	69	* @return EFI_ST_SUCCESS for success
623b3a57 HS	70	*/
	71	static int setup(struct efi_unit_test test, unsigned int failures)
	72	{
	73	int ret;
	74
	75	if (!test->setup)
e67e7249	76	return EFI_ST_SUCCESS;
623b3a57 HS	77	efi_st_printf("\nSetting up '%s'\n", test->name);
623b3a57 HS	78	ret = test->setup(handle, systable);
e67e7249	79	if (ret != EFI_ST_SUCCESS) {
037ee6f9	80	efi_st_error("Setting up '%s' failed\n", test->name);
623b3a57 HS	81	++*failures;
	82	} else {
	83	efi_st_printf("Setting up '%s' succeeded\n", test->name);
	84	}
	85	return ret;
	86	}
	87
	88	/*
	89	* Execute a test.
	90	*
	91	* @test the test to be executed
	92	* @failures counter that will be incremented if a failure occurs
e67e7249	93	* @return EFI_ST_SUCCESS for success
623b3a57 HS	94	*/
	95	static int execute(struct efi_unit_test test, unsigned int failures)
	96	{
	97	int ret;
	98
	99	if (!test->execute)
e67e7249	100	return EFI_ST_SUCCESS;
623b3a57 HS	101	efi_st_printf("\nExecuting '%s'\n", test->name);
623b3a57 HS	102	ret = test->execute();
e67e7249	103	if (ret != EFI_ST_SUCCESS) {
037ee6f9	104	efi_st_error("Executing '%s' failed\n", test->name);
623b3a57 HS	105	++*failures;
	106	} else {
	107	efi_st_printf("Executing '%s' succeeded\n", test->name);
	108	}
	109	return ret;
	110	}
	111
	112	/*
	113	* Tear down a test.
	114	*
	115	* @test the test to be torn down
	116	* @failures counter that will be incremented if a failure occurs
e67e7249	117	* @return EFI_ST_SUCCESS for success
623b3a57 HS	118	*/
	119	static int teardown(struct efi_unit_test test, unsigned int failures)
	120	{
	121	int ret;
	122
	123	if (!test->teardown)
e67e7249	124	return EFI_ST_SUCCESS;
623b3a57 HS	125	efi_st_printf("\nTearing down '%s'\n", test->name);
623b3a57 HS	126	ret = test->teardown();
e67e7249	127	if (ret != EFI_ST_SUCCESS) {
037ee6f9	128	efi_st_error("Tearing down '%s' failed\n", test->name);
623b3a57 HS	129	++*failures;
	130	} else {
	131	efi_st_printf("Tearing down '%s' succeeded\n", test->name);
	132	}
	133	return ret;
	134	}
	135
	136	/*
	137	* Execute selftest of the EFI API
	138	*
	139	* This is the main entry point of the EFI selftest application.
	140	*
	141	* All tests use a driver model and are run in three phases:
	142	* setup, execute, teardown.
	143	*
	144	* A test may be setup and executed at boottime,
	145	* it may be setup at boottime and executed at runtime,
	146	* or it may be setup and executed at runtime.
	147	*
	148	* After executing all tests the system is reset.
	149	*
	150	* @image_handle: handle of the loaded EFI image
	151	* @systab: EFI system table
	152	*/
	153	efi_status_t EFIAPI efi_selftest(efi_handle_t image_handle,
	154	struct efi_system_table *systab)
	155	{
	156	struct efi_unit_test *test;
	157	unsigned int failures = 0;
	158
	159	systable = systab;
	160	boottime = systable->boottime;
	161	runtime = systable->runtime;
	162	handle = image_handle;
	163	con_out = systable->con_out;
	164	con_in = systable->con_in;
	165
	166	efi_st_printf("\nTesting EFI API implementation\n");
	167
	168	efi_st_printf("\nNumber of tests to execute: %u\n",
	169	ll_entry_count(struct efi_unit_test, efi_unit_test));
	170
	171	/* Execute boottime tests */
	172	for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
	173	test < ll_entry_end(struct efi_unit_test, efi_unit_test); ++test) {
	174	if (test->phase == EFI_EXECUTE_BEFORE_BOOTTIME_EXIT) {
	175	setup(test, &failures);
	176	execute(test, &failures);
	177	teardown(test, &failures);
	178	}
	179	}
	180
	181	/* Execute mixed tests */
	182	for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
	183	test < ll_entry_end(struct efi_unit_test, efi_unit_test); ++test) {
	184	if (test->phase == EFI_SETUP_BEFORE_BOOTTIME_EXIT)
	185	setup(test, &failures);
	186	}
	187
	188	efi_st_exit_boot_services();
	189
	190	for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
	191	test < ll_entry_end(struct efi_unit_test, efi_unit_test); ++test) {
	192	if (test->phase == EFI_SETUP_BEFORE_BOOTTIME_EXIT) {
193	execute(test, &failures);
194	teardown(test, &failures);
195	}
196	}
197
198	/* Execute runtime tests */
199	for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
200	test < ll_entry_end(struct efi_unit_test, efi_unit_test); ++test) {
201	if (test->phase == EFI_SETUP_AFTER_BOOTTIME_EXIT) {
202	setup(test, &failures);
203	execute(test, &failures);
204	teardown(test, &failures);
205	}
206	}
207
208	/* Give feedback */
209	efi_st_printf("\nSummary: %u failures\n\n", failures);
210
211	/* Reset system */
212	efi_st_printf("Preparing for reset. Press any key.\n");
213	efi_st_get_key();
214	runtime->reset_system(EFI_RESET_WARM, EFI_NOT_READY,
215	sizeof(reset_message), reset_message);
037ee6f9 HS	216	efi_st_printf("\n");
037ee6f9 HS	217	efi_st_error("Reset failed.\n");
623b3a57 HS	218
	219	return EFI_UNSUPPORTED;
	220	}