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