lib/efi_selftest/efi_selftest.c

   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 }