1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * EFI efi_selftest
4  *
5  * Copyright (c) 2017 Heinrich Schuchardt <xypron.glpk@gmx.de>
6  */
7 
8 #include <efi_selftest.h>
9 #include <vsprintf.h>
10 
11 /* Constants for test step bitmap */
12 #define EFI_ST_SETUP	1
13 #define EFI_ST_EXECUTE	2
14 #define EFI_ST_TEARDOWN	4
15 
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";
21 static int *setup_status;
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.
28  * The memory map is copied and the map key is obtained.
29  * The map key is used to exit the boot services.
30  */
efi_st_exit_boot_services(void)31 void efi_st_exit_boot_services(void)
32 {
33 	efi_uintn_t map_size = 0;
34 	efi_uintn_t map_key;
35 	efi_uintn_t desc_size;
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) {
43 		efi_st_error(
44 			"GetMemoryMap did not return EFI_BUFFER_TOO_SMALL\n");
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) {
52 		efi_st_error("AllocatePool did not return EFI_SUCCESS\n");
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) {
58 		efi_st_error("GetMemoryMap did not return EFI_SUCCESS\n");
59 		return;
60 	}
61 	ret = boottime->exit_boot_services(handle, map_key);
62 	if (ret != EFI_SUCCESS) {
63 		efi_st_error("ExitBootServices did not return EFI_SUCCESS\n");
64 		return;
65 	}
66 	efi_st_printc(EFI_WHITE, "\nBoot services terminated\n");
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
74  * @return	EFI_ST_SUCCESS for success
75  */
setup(struct efi_unit_test * test,unsigned int * failures)76 static int setup(struct efi_unit_test *test, unsigned int *failures)
77 {
78 	int ret;
79 
80 	if (!test->setup)
81 		return EFI_ST_SUCCESS;
82 	efi_st_printc(EFI_LIGHTBLUE, "\nSetting up '%s'\n", test->name);
83 	ret = test->setup(handle, systable);
84 	if (ret != EFI_ST_SUCCESS) {
85 		efi_st_error("Setting up '%s' failed\n", test->name);
86 		++*failures;
87 	} else {
88 		efi_st_printc(EFI_LIGHTGREEN,
89 			      "Setting up '%s' succeeded\n", test->name);
90 	}
91 	return ret;
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
99  * @return	EFI_ST_SUCCESS for success
100  */
execute(struct efi_unit_test * test,unsigned int * failures)101 static int execute(struct efi_unit_test *test, unsigned int *failures)
102 {
103 	int ret;
104 
105 	if (!test->execute)
106 		return EFI_ST_SUCCESS;
107 	efi_st_printc(EFI_LIGHTBLUE, "\nExecuting '%s'\n", test->name);
108 	ret = test->execute();
109 	if (ret != EFI_ST_SUCCESS) {
110 		efi_st_error("Executing '%s' failed\n", test->name);
111 		++*failures;
112 	} else {
113 		efi_st_printc(EFI_LIGHTGREEN,
114 			      "Executing '%s' succeeded\n", test->name);
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
124  * @return	EFI_ST_SUCCESS for success
125  */
teardown(struct efi_unit_test * test,unsigned int * failures)126 static int teardown(struct efi_unit_test *test, unsigned int *failures)
127 {
128 	int ret;
129 
130 	if (!test->teardown)
131 		return EFI_ST_SUCCESS;
132 	efi_st_printc(EFI_LIGHTBLUE, "\nTearing down '%s'\n", test->name);
133 	ret = test->teardown();
134 	if (ret != EFI_ST_SUCCESS) {
135 		efi_st_error("Tearing down '%s' failed\n", test->name);
136 		++*failures;
137 	} else {
138 		efi_st_printc(EFI_LIGHTGREEN,
139 			      "Tearing down '%s' succeeded\n", test->name);
140 	}
141 	return ret;
142 }
143 
144 /*
145  * Check that a test exists.
146  *
147  * @testname:	name of the test
148  * @return:	test, or NULL if not found
149  */
find_test(const u16 * testname)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  */
list_all_tests(void)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 
179 /*
180  * Execute test steps of one phase.
181  *
182  * @testname	name of a single selected test or NULL
183  * @phase	test phase
184  * @steps	steps to execute (mask with bits from EFI_ST_...)
185  * failures	returns EFI_ST_SUCCESS if all test steps succeeded
186  */
efi_st_do_tests(const u16 * testname,unsigned int phase,unsigned int steps,unsigned int * failures)187 void efi_st_do_tests(const u16 *testname, unsigned int phase,
188 		     unsigned int steps, unsigned int *failures)
189 {
190 	int i = 0;
191 	struct efi_unit_test *test;
192 
193 	for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
194 	     test < ll_entry_end(struct efi_unit_test, efi_unit_test);
195 	     ++test, ++i) {
196 		if (testname ?
197 		    efi_st_strcmp_16_8(testname, test->name) : test->on_request)
198 			continue;
199 		if (test->phase != phase)
200 			continue;
201 		if (steps & EFI_ST_SETUP)
202 			setup_status[i] = setup(test, failures);
203 		if (steps & EFI_ST_EXECUTE && setup_status[i] == EFI_ST_SUCCESS)
204 			execute(test, failures);
205 		if (steps & EFI_ST_TEARDOWN)
206 			teardown(test, failures);
207 	}
208 }
209 
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  */
efi_selftest(efi_handle_t image_handle,struct efi_system_table * systab)227 efi_status_t EFIAPI efi_selftest(efi_handle_t image_handle,
228 				 struct efi_system_table *systab)
229 {
230 	unsigned int failures = 0;
231 	const u16 *testname = NULL;
232 	struct efi_loaded_image *loaded_image;
233 	efi_status_t ret;
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 
242 	ret = boottime->handle_protocol(image_handle, &efi_guid_loaded_image,
243 					(void **)&loaded_image);
244 	if (ret != EFI_SUCCESS) {
245 		efi_st_error("Cannot open loaded image protocol\n");
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 
268 	efi_st_printc(EFI_WHITE, "\nTesting EFI API implementation\n");
269 
270 	if (testname)
271 		efi_st_printc(EFI_WHITE, "\nSelected test: '%ps'\n", testname);
272 	else
273 		efi_st_printc(EFI_WHITE, "\nNumber of tests to execute: %u\n",
274 			      ll_entry_count(struct efi_unit_test,
275 					     efi_unit_test));
276 
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),
281 				      (void **)&setup_status);
282 	if (ret != EFI_SUCCESS) {
283 		efi_st_error("Allocate pool failed\n");
284 		return ret;
285 	}
286 
287 	/* Execute boottime tests */
288 	efi_st_do_tests(testname, EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
289 			EFI_ST_SETUP | EFI_ST_EXECUTE | EFI_ST_TEARDOWN,
290 			&failures);
291 
292 	/* Execute mixed tests */
293 	efi_st_do_tests(testname, EFI_SETUP_BEFORE_BOOTTIME_EXIT,
294 			EFI_ST_SETUP, &failures);
295 
296 	efi_st_exit_boot_services();
297 
298 	efi_st_do_tests(testname, EFI_SETUP_BEFORE_BOOTTIME_EXIT,
299 			EFI_ST_EXECUTE | EFI_ST_TEARDOWN, &failures);
300 
301 	/* Execute runtime tests */
302 	efi_st_do_tests(testname, EFI_SETUP_AFTER_BOOTTIME_EXIT,
303 			EFI_ST_SETUP | EFI_ST_EXECUTE | EFI_ST_TEARDOWN,
304 			&failures);
305 
306 	/* Give feedback */
307 	efi_st_printc(EFI_WHITE, "\nSummary: %u failures\n\n", failures);
308 
309 	/* Reset system */
310 	efi_st_printf("Preparing for reset. Press any key...\n");
311 	efi_st_get_key();
312 	runtime->reset_system(EFI_RESET_WARM, EFI_NOT_READY,
313 			      sizeof(reset_message), reset_message);
314 	efi_st_printf("\n");
315 	efi_st_error("Reset failed\n");
316 
317 	return EFI_UNSUPPORTED;
318 }
319