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 */ 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 */ 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 */ 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 */ 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 */ 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 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 */ 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 */ 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