[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>

/*
 * Constants for test step bitmap
 */
#define EFI_ST_SETUP	1
#define EFI_ST_EXECUTE	2
#define EFI_ST_TEARDOWN	4

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)
{
	efi_uintn_t map_size = 0;
	efi_uintn_t map_key;
	efi_uintn_t 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_printc(EFI_WHITE, "\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_printc(EFI_LIGHTBLUE, "\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_printc(EFI_LIGHTGREEN,
			      "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_printc(EFI_LIGHTBLUE, "\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_printc(EFI_LIGHTGREEN,
			      "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_printc(EFI_LIGHTBLUE, "\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_printc(EFI_LIGHTGREEN,
			      "Tearing down '%s' succeeded\n", test->name);
	}
	return ret;
}

/*
 * Check that a test exists.
 *
 * @testname:	name of the test
 * @return:	test
 */
static struct efi_unit_test *find_test(const u16 *testname)
{
	struct efi_unit_test *test;

	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 (!efi_st_strcmp_16_8(testname, test->name))
			return test;
	}
	efi_st_printf("\nTest '%ps' not found\n", testname);
	return NULL;
}

/*
 * List all available tests.
 */
static void list_all_tests(void)
{
	struct efi_unit_test *test;

	/* List all tests */
	efi_st_printf("\nAvailable tests:\n");
	for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
	     test < ll_entry_end(struct efi_unit_test, efi_unit_test); ++test) {
		efi_st_printf("'%s'%s\n", test->name,
			      test->on_request ? " - on request" : "");
	}
}

/*
 * Execute test steps of one phase.
 *
 * @testname	name of a single selected test or NULL
 * @phase	test phase
 * @steps	steps to execute
 * failures	returns EFI_ST_SUCCESS if all test steps succeeded
 */
void efi_st_do_tests(const u16 *testname, unsigned int phase,
		     unsigned int steps, unsigned int *failures)
{
	struct efi_unit_test *test;

	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 (testname ?
		    efi_st_strcmp_16_8(testname, test->name) : test->on_request)
			continue;
		if (test->phase != phase)
			continue;
		if (steps & EFI_ST_SETUP)
			setup(test, failures);
		if (steps & EFI_ST_EXECUTE)
			execute(test, failures);
		if (steps & EFI_ST_TEARDOWN)
			teardown(test, failures);
	}
}

/*
 * 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)
{
	unsigned int failures = 0;
	const u16 *testname = NULL;
	struct efi_loaded_image *loaded_image;
	efi_status_t ret;

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

	ret = boottime->handle_protocol(image_handle, &efi_guid_loaded_image,
					(void **)&loaded_image);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Cannot open loaded image protocol\n");
		return ret;
	}

	if (loaded_image->load_options)
		testname = (u16 *)loaded_image->load_options;

	if (testname) {
		if (!efi_st_strcmp_16_8(testname, "list") ||
		    !find_test(testname)) {
			list_all_tests();
			/*
			 * TODO:
			 * Once the Exit boottime service is correctly
			 * implemented we should call
			 *   boottime->exit(image_handle, EFI_SUCCESS, 0, NULL);
			 * here, cf.
			 * https://lists.denx.de/pipermail/u-boot/2017-October/308720.html
			 */
			return EFI_SUCCESS;
		}
	}

	efi_st_printc(EFI_WHITE, "\nTesting EFI API implementation\n");

	if (testname)
		efi_st_printc(EFI_WHITE, "\nSelected test: '%ps'\n", testname);
	else
		efi_st_printc(EFI_WHITE, "\nNumber of tests to execute: %u\n",
			      ll_entry_count(struct efi_unit_test,
					     efi_unit_test));

	/* Execute boottime tests */
	efi_st_do_tests(testname, EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
			EFI_ST_SETUP | EFI_ST_EXECUTE | EFI_ST_TEARDOWN,
			&failures);

	/* Execute mixed tests */
	efi_st_do_tests(testname, EFI_SETUP_BEFORE_BOOTTIME_EXIT,
			EFI_ST_SETUP, &failures);

	efi_st_exit_boot_services();

	efi_st_do_tests(testname, EFI_SETUP_BEFORE_BOOTTIME_EXIT,
			EFI_ST_EXECUTE | EFI_ST_TEARDOWN, &failures);

	/* Execute runtime tests */
	efi_st_do_tests(testname, EFI_SETUP_AFTER_BOOTTIME_EXIT,
			EFI_ST_SETUP | EFI_ST_EXECUTE | EFI_ST_TEARDOWN,
			&failures);

	/* Give feedback */
	efi_st_printc(EFI_WHITE, "\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
1f66a12e HS	12	/*
	13	* Constants for test step bitmap
	14	*/
	15	#define EFI_ST_SETUP 1
	16	#define EFI_ST_EXECUTE 2
	17	#define EFI_ST_TEARDOWN 4
	18
623b3a57 HS	19	static const struct efi_system_table *systable;
	20	static const struct efi_boot_services *boottime;
	21	static const struct efi_runtime_services *runtime;
	22	static efi_handle_t handle;
	23	static u16 reset_message[] = L"Selftest completed";
	24
	25	/*
	26	* Exit the boot services.
	27	*
	28	* The size of the memory map is determined.
	29	* Pool memory is allocated to copy the memory map.
	30	* The memory amp is copied and the map key is obtained.
	31	* The map key is used to exit the boot services.
	32	*/
	33	void efi_st_exit_boot_services(void)
	34	{
f5a2a938 HS	35	efi_uintn_t map_size = 0;
	36	efi_uintn_t map_key;
	37	efi_uintn_t desc_size;
623b3a57 HS	38	u32 desc_version;
	39	efi_status_t ret;
	40	struct efi_mem_desc *memory_map;
	41
	42	ret = boottime->get_memory_map(&map_size, NULL, &map_key, &desc_size,
	43	&desc_version);
	44	if (ret != EFI_BUFFER_TOO_SMALL) {
037ee6f9 HS	45	efi_st_error(
037ee6f9 HS	46	"GetMemoryMap did not return EFI_BUFFER_TOO_SMALL\n");
623b3a57 HS	47	return;
	48	}
	49	/* Allocate extra space for newly allocated memory */
	50	map_size += sizeof(struct efi_mem_desc);
	51	ret = boottime->allocate_pool(EFI_BOOT_SERVICES_DATA, map_size,
	52	(void **)&memory_map);
	53	if (ret != EFI_SUCCESS) {
037ee6f9	54	efi_st_error("AllocatePool did not return EFI_SUCCESS\n");
623b3a57 HS	55	return;
	56	}
	57	ret = boottime->get_memory_map(&map_size, memory_map, &map_key,
	58	&desc_size, &desc_version);
	59	if (ret != EFI_SUCCESS) {
037ee6f9	60	efi_st_error("GetMemoryMap did not return EFI_SUCCESS\n");
623b3a57 HS	61	return;
	62	}
	63	ret = boottime->exit_boot_services(handle, map_key);
	64	if (ret != EFI_SUCCESS) {
037ee6f9	65	efi_st_error("ExitBootServices did not return EFI_SUCCESS\n");
623b3a57 HS	66	return;
623b3a57 HS	67	}
853540c8	68	efi_st_printc(EFI_WHITE, "\nBoot services terminated\n");
623b3a57 HS	69	}
	70
	71	/*
	72	* Set up a test.
	73	*
	74	* @test the test to be executed
	75	* @failures counter that will be incremented if a failure occurs
e67e7249	76	* @return EFI_ST_SUCCESS for success
623b3a57 HS	77	*/
	78	static int setup(struct efi_unit_test test, unsigned int failures)
	79	{
	80	int ret;
	81
	82	if (!test->setup)
e67e7249	83	return EFI_ST_SUCCESS;
853540c8	84	efi_st_printc(EFI_LIGHTBLUE, "\nSetting up '%s'\n", test->name);
623b3a57	85	ret = test->setup(handle, systable);
e67e7249	86	if (ret != EFI_ST_SUCCESS) {
037ee6f9	87	efi_st_error("Setting up '%s' failed\n", test->name);
623b3a57 HS	88	++*failures;
623b3a57 HS	89	} else {
853540c8 HS	90	efi_st_printc(EFI_LIGHTGREEN,
853540c8 HS	91	"Setting up '%s' succeeded\n", test->name);
623b3a57 HS	92	}
	93	return ret;
	94	}
	95
	96	/*
	97	* Execute a test.
	98	*
	99	* @test the test to be executed
	100	* @failures counter that will be incremented if a failure occurs
e67e7249	101	* @return EFI_ST_SUCCESS for success
623b3a57 HS	102	*/
	103	static int execute(struct efi_unit_test test, unsigned int failures)
	104	{
	105	int ret;
	106
	107	if (!test->execute)
e67e7249	108	return EFI_ST_SUCCESS;
853540c8	109	efi_st_printc(EFI_LIGHTBLUE, "\nExecuting '%s'\n", test->name);
623b3a57	110	ret = test->execute();
e67e7249	111	if (ret != EFI_ST_SUCCESS) {
037ee6f9	112	efi_st_error("Executing '%s' failed\n", test->name);
623b3a57 HS	113	++*failures;
623b3a57 HS	114	} else {
853540c8 HS	115	efi_st_printc(EFI_LIGHTGREEN,
853540c8 HS	116	"Executing '%s' succeeded\n", test->name);
623b3a57 HS	117	}
	118	return ret;
	119	}
	120
	121	/*
	122	* Tear down a test.
	123	*
	124	* @test the test to be torn down
	125	* @failures counter that will be incremented if a failure occurs
e67e7249	126	* @return EFI_ST_SUCCESS for success
623b3a57 HS	127	*/
	128	static int teardown(struct efi_unit_test test, unsigned int failures)
	129	{
	130	int ret;
	131
	132	if (!test->teardown)
e67e7249	133	return EFI_ST_SUCCESS;
853540c8	134	efi_st_printc(EFI_LIGHTBLUE, "\nTearing down '%s'\n", test->name);
623b3a57	135	ret = test->teardown();
e67e7249	136	if (ret != EFI_ST_SUCCESS) {
037ee6f9	137	efi_st_error("Tearing down '%s' failed\n", test->name);
623b3a57 HS	138	++*failures;
623b3a57 HS	139	} else {
853540c8 HS	140	efi_st_printc(EFI_LIGHTGREEN,
853540c8 HS	141	"Tearing down '%s' succeeded\n", test->name);
623b3a57 HS	142	}
	143	return ret;
	144	}
	145
d78e40d6 HS	146	/*
	147	* Check that a test exists.
	148	*
	149	* @testname: name of the test
	150	* @return: test
	151	*/
	152	static struct efi_unit_test find_test(const u16 testname)
	153	{
	154	struct efi_unit_test *test;
	155
	156	for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
	157	test < ll_entry_end(struct efi_unit_test, efi_unit_test); ++test) {
	158	if (!efi_st_strcmp_16_8(testname, test->name))
	159	return test;
	160	}
	161	efi_st_printf("\nTest '%ps' not found\n", testname);
	162	return NULL;
	163	}
	164
	165	/*
	166	* List all available tests.
	167	*/
	168	static void list_all_tests(void)
	169	{
	170	struct efi_unit_test *test;
	171
	172	/* List all tests */
	173	efi_st_printf("\nAvailable tests:\n");
	174	for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
	175	test < ll_entry_end(struct efi_unit_test, efi_unit_test); ++test) {
	176	efi_st_printf("'%s'%s\n", test->name,
	177	test->on_request ? " - on request" : "");
	178	}
	179	}
	180
1f66a12e HS	181	/*
	182	* Execute test steps of one phase.
	183	*
d78e40d6	184	* @testname name of a single selected test or NULL
1f66a12e HS	185	* @phase test phase
	186	* @steps steps to execute
	187	* failures returns EFI_ST_SUCCESS if all test steps succeeded
	188	*/
d78e40d6 HS	189	void efi_st_do_tests(const u16 *testname, unsigned int phase,
d78e40d6 HS	190	unsigned int steps, unsigned int *failures)
1f66a12e HS	191	{
	192	struct efi_unit_test *test;
	193
	194	for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
	195	test < ll_entry_end(struct efi_unit_test, efi_unit_test); ++test) {
d78e40d6 HS	196	if (testname ?
	197	efi_st_strcmp_16_8(testname, test->name) : test->on_request)
	198	continue;
1f66a12e HS	199	if (test->phase != phase)
	200	continue;
	201	if (steps & EFI_ST_SETUP)
	202	setup(test, failures);
	203	if (steps & EFI_ST_EXECUTE)
	204	execute(test, failures);
	205	if (steps & EFI_ST_TEARDOWN)
	206	teardown(test, failures);
	207	}
	208	}
	209
623b3a57 HS	210	/*
	211	* Execute selftest of the EFI API
	212	*
	213	* This is the main entry point of the EFI selftest application.
	214	*
	215	* All tests use a driver model and are run in three phases:
	216	* setup, execute, teardown.
	217	*
	218	* A test may be setup and executed at boottime,
	219	* it may be setup at boottime and executed at runtime,
	220	* or it may be setup and executed at runtime.
	221	*
	222	* After executing all tests the system is reset.
	223	*
	224	* @image_handle: handle of the loaded EFI image
	225	* @systab: EFI system table
	226	*/
	227	efi_status_t EFIAPI efi_selftest(efi_handle_t image_handle,
	228	struct efi_system_table *systab)
	229	{
623b3a57	230	unsigned int failures = 0;
d78e40d6 HS	231	const u16 *testname = NULL;
	232	struct efi_loaded_image *loaded_image;
	233	efi_status_t ret;
623b3a57 HS	234
	235	systable = systab;
	236	boottime = systable->boottime;
	237	runtime = systable->runtime;
	238	handle = image_handle;
	239	con_out = systable->con_out;
	240	con_in = systable->con_in;
	241
d78e40d6 HS	242	ret = boottime->handle_protocol(image_handle, &efi_guid_loaded_image,
	243	(void **)&loaded_image);
	244	if (ret != EFI_SUCCESS) {
c51e7df9	245	efi_st_error("Cannot open loaded image protocol\n");
d78e40d6 HS	246	return ret;
	247	}
	248
	249	if (loaded_image->load_options)
	250	testname = (u16 *)loaded_image->load_options;
	251
	252	if (testname) {
	253	if (!efi_st_strcmp_16_8(testname, "list") \|\|
	254	!find_test(testname)) {
	255	list_all_tests();
	256	/*
	257	* TODO:
	258	* Once the Exit boottime service is correctly
	259	* implemented we should call
	260	* boottime->exit(image_handle, EFI_SUCCESS, 0, NULL);
	261	* here, cf.
	262	* https://lists.denx.de/pipermail/u-boot/2017-October/308720.html
	263	*/
	264	return EFI_SUCCESS;
	265	}
	266	}
	267
853540c8	268	efi_st_printc(EFI_WHITE, "\nTesting EFI API implementation\n");
623b3a57	269
d78e40d6	270	if (testname)
853540c8	271	efi_st_printc(EFI_WHITE, "\nSelected test: '%ps'\n", testname);
d78e40d6	272	else
853540c8	273	efi_st_printc(EFI_WHITE, "\nNumber of tests to execute: %u\n",
d78e40d6 HS	274	ll_entry_count(struct efi_unit_test,
d78e40d6 HS	275	efi_unit_test));
623b3a57 HS	276
623b3a57 HS	277	/* Execute boottime tests */
d78e40d6	278	efi_st_do_tests(testname, EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
1f66a12e HS	279	EFI_ST_SETUP \| EFI_ST_EXECUTE \| EFI_ST_TEARDOWN,
1f66a12e HS	280	&failures);
623b3a57 HS	281
623b3a57 HS	282	/* Execute mixed tests */
d78e40d6	283	efi_st_do_tests(testname, EFI_SETUP_BEFORE_BOOTTIME_EXIT,
1f66a12e	284	EFI_ST_SETUP, &failures);
623b3a57 HS	285
	286	efi_st_exit_boot_services();
	287
d78e40d6	288	efi_st_do_tests(testname, EFI_SETUP_BEFORE_BOOTTIME_EXIT,
1f66a12e	289	EFI_ST_EXECUTE \| EFI_ST_TEARDOWN, &failures);
623b3a57 HS	290
623b3a57 HS	291	/* Execute runtime tests */
d78e40d6	292	efi_st_do_tests(testname, EFI_SETUP_AFTER_BOOTTIME_EXIT,
1f66a12e HS	293	EFI_ST_SETUP \| EFI_ST_EXECUTE \| EFI_ST_TEARDOWN,
1f66a12e HS	294	&failures);
623b3a57 HS	295
623b3a57 HS	296	/* Give feedback */
853540c8	297	efi_st_printc(EFI_WHITE, "\nSummary: %u failures\n\n", failures);
623b3a57 HS	298
	299	/* Reset system */
	300	efi_st_printf("Preparing for reset. Press any key.\n");
	301	efi_st_get_key();
	302	runtime->reset_system(EFI_RESET_WARM, EFI_NOT_READY,
	303	sizeof(reset_message), reset_message);
037ee6f9 HS	304	efi_st_printf("\n");
037ee6f9 HS	305	efi_st_error("Reset failed.\n");
623b3a57 HS	306
	307	return EFI_UNSUPPORTED;
	308	}