[J-u-boot.git] / lib / efi_selftest / efi_selftest.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * EFI efi_selftest
 *
 * Copyright (c) 2017 Heinrich Schuchardt <[email protected]>
 */

#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";
static int *setup_status;

/*
 * Exit the boot services.
 *
 * The size of the memory map is determined.
 * Pool memory is allocated to copy the memory map.
 * The memory map 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, or NULL if not found
 */
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 (mask with bits from EFI_ST_...)
 * 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)
{
	int i = 0;
	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, ++i) {
		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_status[i] = setup(test, failures);
		if (steps & EFI_ST_EXECUTE && setup_status[i] == EFI_ST_SUCCESS)
			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));

	/* Allocate buffer for setup results */
	ret = boottime->allocate_pool(EFI_RUNTIME_SERVICES_DATA, sizeof(int) *
				      ll_entry_count(struct efi_unit_test,
						     efi_unit_test),
				      (void **)&setup_status);
	if (ret != EFI_SUCCESS) {
		efi_st_error("Allocate pool failed\n");
		return ret;
	}

	/* 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
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
623b3a57 HS	2	/*
	3	* EFI efi_selftest
	4	*
	5	* Copyright (c) 2017 Heinrich Schuchardt <[email protected]>
623b3a57 HS	6	*/
	7
	8	#include <efi_selftest.h>
	9	#include <vsprintf.h>
	10
404ea593	11	/* Constants for test step bitmap */
1f66a12e HS	12	#define EFI_ST_SETUP 1
	13	#define EFI_ST_EXECUTE 2
	14	#define EFI_ST_TEARDOWN 4
	15
623b3a57 HS	16	static const struct efi_system_table *systable;
	17	static const struct efi_boot_services *boottime;
	18	static const struct efi_runtime_services *runtime;
	19	static efi_handle_t handle;
	20	static u16 reset_message[] = L"Selftest completed";
3c2c54ca	21	static int *setup_status;
623b3a57 HS	22
	23	/*
	24	* Exit the boot services.
	25	*
	26	* The size of the memory map is determined.
	27	* Pool memory is allocated to copy the memory map.
404ea593	28	* The memory map is copied and the map key is obtained.
623b3a57 HS	29	* The map key is used to exit the boot services.
	30	*/
	31	void efi_st_exit_boot_services(void)
	32	{
f5a2a938 HS	33	efi_uintn_t map_size = 0;
	34	efi_uintn_t map_key;
	35	efi_uintn_t desc_size;
623b3a57 HS	36	u32 desc_version;
	37	efi_status_t ret;
	38	struct efi_mem_desc *memory_map;
	39
	40	ret = boottime->get_memory_map(&map_size, NULL, &map_key, &desc_size,
	41	&desc_version);
	42	if (ret != EFI_BUFFER_TOO_SMALL) {
037ee6f9 HS	43	efi_st_error(
037ee6f9 HS	44	"GetMemoryMap did not return EFI_BUFFER_TOO_SMALL\n");
623b3a57 HS	45	return;
	46	}
	47	/* Allocate extra space for newly allocated memory */
	48	map_size += sizeof(struct efi_mem_desc);
	49	ret = boottime->allocate_pool(EFI_BOOT_SERVICES_DATA, map_size,
	50	(void **)&memory_map);
	51	if (ret != EFI_SUCCESS) {
037ee6f9	52	efi_st_error("AllocatePool did not return EFI_SUCCESS\n");
623b3a57 HS	53	return;
	54	}
	55	ret = boottime->get_memory_map(&map_size, memory_map, &map_key,
	56	&desc_size, &desc_version);
	57	if (ret != EFI_SUCCESS) {
037ee6f9	58	efi_st_error("GetMemoryMap did not return EFI_SUCCESS\n");
623b3a57 HS	59	return;
	60	}
	61	ret = boottime->exit_boot_services(handle, map_key);
	62	if (ret != EFI_SUCCESS) {
037ee6f9	63	efi_st_error("ExitBootServices did not return EFI_SUCCESS\n");
623b3a57 HS	64	return;
623b3a57 HS	65	}
853540c8	66	efi_st_printc(EFI_WHITE, "\nBoot services terminated\n");
623b3a57 HS	67	}
	68
	69	/*
	70	* Set up a test.
	71	*
	72	* @test the test to be executed
	73	* @failures counter that will be incremented if a failure occurs
e67e7249	74	* @return EFI_ST_SUCCESS for success
623b3a57 HS	75	*/
	76	static int setup(struct efi_unit_test test, unsigned int failures)
	77	{
4c174394 HS	78	int ret;
	79
	80	if (!test->setup)
e67e7249	81	return EFI_ST_SUCCESS;
853540c8	82	efi_st_printc(EFI_LIGHTBLUE, "\nSetting up '%s'\n", test->name);
4c174394 HS	83	ret = test->setup(handle, systable);
4c174394 HS	84	if (ret != EFI_ST_SUCCESS) {
037ee6f9	85	efi_st_error("Setting up '%s' failed\n", test->name);
623b3a57 HS	86	++*failures;
623b3a57 HS	87	} else {
853540c8 HS	88	efi_st_printc(EFI_LIGHTGREEN,
853540c8 HS	89	"Setting up '%s' succeeded\n", test->name);
623b3a57	90	}
4c174394	91	return ret;
623b3a57 HS	92	}
	93
	94	/*
	95	* Execute a test.
	96	*
	97	* @test the test to be executed
	98	* @failures counter that will be incremented if a failure occurs
e67e7249	99	* @return EFI_ST_SUCCESS for success
623b3a57 HS	100	*/
	101	static int execute(struct efi_unit_test test, unsigned int failures)
	102	{
	103	int ret;
	104
	105	if (!test->execute)
e67e7249	106	return EFI_ST_SUCCESS;
853540c8	107	efi_st_printc(EFI_LIGHTBLUE, "\nExecuting '%s'\n", test->name);
623b3a57	108	ret = test->execute();
e67e7249	109	if (ret != EFI_ST_SUCCESS) {
037ee6f9	110	efi_st_error("Executing '%s' failed\n", test->name);
623b3a57 HS	111	++*failures;
623b3a57 HS	112	} else {
853540c8 HS	113	efi_st_printc(EFI_LIGHTGREEN,
853540c8 HS	114	"Executing '%s' succeeded\n", test->name);
623b3a57 HS	115	}
	116	return ret;
	117	}
	118
	119	/*
	120	* Tear down a test.
	121	*
	122	* @test the test to be torn down
	123	* @failures counter that will be incremented if a failure occurs
e67e7249	124	* @return EFI_ST_SUCCESS for success
623b3a57 HS	125	*/
	126	static int teardown(struct efi_unit_test test, unsigned int failures)
	127	{
	128	int ret;
	129
	130	if (!test->teardown)
e67e7249	131	return EFI_ST_SUCCESS;
853540c8	132	efi_st_printc(EFI_LIGHTBLUE, "\nTearing down '%s'\n", test->name);
623b3a57	133	ret = test->teardown();
e67e7249	134	if (ret != EFI_ST_SUCCESS) {
037ee6f9	135	efi_st_error("Tearing down '%s' failed\n", test->name);
623b3a57 HS	136	++*failures;
623b3a57 HS	137	} else {
853540c8 HS	138	efi_st_printc(EFI_LIGHTGREEN,
853540c8 HS	139	"Tearing down '%s' succeeded\n", test->name);
623b3a57 HS	140	}
	141	return ret;
	142	}
	143
d78e40d6 HS	144	/*
	145	* Check that a test exists.
	146	*
	147	* @testname: name of the test
404ea593	148	* @return: test, or NULL if not found
d78e40d6 HS	149	*/
	150	static struct efi_unit_test find_test(const u16 testname)
	151	{
	152	struct efi_unit_test *test;
	153
	154	for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
	155	test < ll_entry_end(struct efi_unit_test, efi_unit_test); ++test) {
	156	if (!efi_st_strcmp_16_8(testname, test->name))
	157	return test;
	158	}
	159	efi_st_printf("\nTest '%ps' not found\n", testname);
	160	return NULL;
	161	}
	162
	163	/*
	164	* List all available tests.
	165	*/
	166	static void list_all_tests(void)
	167	{
	168	struct efi_unit_test *test;
	169
	170	/* List all tests */
	171	efi_st_printf("\nAvailable tests:\n");
	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	efi_st_printf("'%s'%s\n", test->name,
	175	test->on_request ? " - on request" : "");
	176	}
	177	}
	178
1f66a12e HS	179	/*
	180	* Execute test steps of one phase.
	181	*
d78e40d6	182	* @testname name of a single selected test or NULL
1f66a12e	183	* @phase test phase
404ea593	184	* @steps steps to execute (mask with bits from EFI_ST_...)
1f66a12e HS	185	* failures returns EFI_ST_SUCCESS if all test steps succeeded
1f66a12e HS	186	*/
d78e40d6 HS	187	void efi_st_do_tests(const u16 *testname, unsigned int phase,
d78e40d6 HS	188	unsigned int steps, unsigned int *failures)
1f66a12e	189	{
4c174394	190	int i = 0;
1f66a12e HS	191	struct efi_unit_test *test;
	192
	193	for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
4c174394 HS	194	test < ll_entry_end(struct efi_unit_test, efi_unit_test);
4c174394 HS	195	++test, ++i) {
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)
3c2c54ca HS	202	setup_status[i] = setup(test, failures);
3c2c54ca HS	203	if (steps & EFI_ST_EXECUTE && setup_status[i] == EFI_ST_SUCCESS)
1f66a12e HS	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	276
4c174394 HS	277	/* Allocate buffer for setup results */
	278	ret = boottime->allocate_pool(EFI_RUNTIME_SERVICES_DATA, sizeof(int) *
	279	ll_entry_count(struct efi_unit_test,
	280	efi_unit_test),
3c2c54ca	281	(void **)&setup_status);
4c174394 HS	282	if (ret != EFI_SUCCESS) {
	283	efi_st_error("Allocate pool failed\n");
	284	return ret;
	285	}
	286
623b3a57	287	/* Execute boottime tests */
d78e40d6	288	efi_st_do_tests(testname, EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
1f66a12e HS	289	EFI_ST_SETUP \| EFI_ST_EXECUTE \| EFI_ST_TEARDOWN,
1f66a12e HS	290	&failures);
623b3a57 HS	291
623b3a57 HS	292	/* Execute mixed tests */
d78e40d6	293	efi_st_do_tests(testname, EFI_SETUP_BEFORE_BOOTTIME_EXIT,
1f66a12e	294	EFI_ST_SETUP, &failures);
623b3a57 HS	295
	296	efi_st_exit_boot_services();
	297
d78e40d6	298	efi_st_do_tests(testname, EFI_SETUP_BEFORE_BOOTTIME_EXIT,
1f66a12e	299	EFI_ST_EXECUTE \| EFI_ST_TEARDOWN, &failures);
623b3a57 HS	300
623b3a57 HS	301	/* Execute runtime tests */
d78e40d6	302	efi_st_do_tests(testname, EFI_SETUP_AFTER_BOOTTIME_EXIT,
1f66a12e HS	303	EFI_ST_SETUP \| EFI_ST_EXECUTE \| EFI_ST_TEARDOWN,
1f66a12e HS	304	&failures);
623b3a57 HS	305
623b3a57 HS	306	/* Give feedback */
853540c8	307	efi_st_printc(EFI_WHITE, "\nSummary: %u failures\n\n", failures);
623b3a57 HS	308
623b3a57 HS	309	/* Reset system */
404ea593	310	efi_st_printf("Preparing for reset. Press any key...\n");
623b3a57 HS	311	efi_st_get_key();
	312	runtime->reset_system(EFI_RESET_WARM, EFI_NOT_READY,
	313	sizeof(reset_message), reset_message);
037ee6f9	314	efi_st_printf("\n");
404ea593	315	efi_st_error("Reset failed\n");
623b3a57 HS	316
	317	return EFI_UNSUPPORTED;
	318	}