lib/efi_selftest/efi_selftest.c

   1 /*
   2  * EFI efi_selftest
   3  *
   4  * Copyright (c) 2017 Heinrich Schuchardt <xypron.glpk@gmx.de>
   5  *
   6  * SPDX-License-Identifier:     GPL-2.0+
   7  */
   8
   9 #include <efi_selftest.h>
  10 #include <vsprintf.h>
  11
  12 /*
  13  * Constants for test step bitmap
  14  */
  15 #define EFI_ST_SETUP    1
  16 #define EFI_ST_EXECUTE  2
  17 #define EFI_ST_TEARDOWN 4
  18
  19 static const struct efi_system_table *systable;
  20 static const struct efi_boot_services *boottime;
  21 static const struct efi_runtime_services *runtime;
  22 static efi_handle_t handle;
  23 static u16 reset_message[] = L"Selftest completed";
  24
  25 /*
  26  * Exit the boot services.
  27  *
  28  * The size of the memory map is determined.
  29  * Pool memory is allocated to copy the memory map.
  30  * The memory amp is copied and the map key is obtained.
  31  * The map key is used to exit the boot services.
  32  */
  33 void efi_st_exit_boot_services(void)
  34 {
  35         efi_uintn_t map_size = 0;
  36         efi_uintn_t map_key;
  37         efi_uintn_t desc_size;
  38         u32 desc_version;
  39         efi_status_t ret;
  40         struct efi_mem_desc *memory_map;
  41
  42         ret = boottime->get_memory_map(&map_size, NULL, &map_key, &desc_size,
  43                                        &desc_version);
  44         if (ret != EFI_BUFFER_TOO_SMALL) {
  45                 efi_st_error(
  46                         "GetMemoryMap did not return EFI_BUFFER_TOO_SMALL\n");
  47                 return;
  48         }
  49         /* Allocate extra space for newly allocated memory */
  50         map_size += sizeof(struct efi_mem_desc);
  51         ret = boottime->allocate_pool(EFI_BOOT_SERVICES_DATA, map_size,
  52                                       (void **)&memory_map);
  53         if (ret != EFI_SUCCESS) {
  54                 efi_st_error("AllocatePool did not return EFI_SUCCESS\n");
  55                 return;
  56         }
  57         ret = boottime->get_memory_map(&map_size, memory_map, &map_key,
  58                                        &desc_size, &desc_version);
  59         if (ret != EFI_SUCCESS) {
  60                 efi_st_error("GetMemoryMap did not return EFI_SUCCESS\n");
  61                 return;
  62         }
  63         ret = boottime->exit_boot_services(handle, map_key);
  64         if (ret != EFI_SUCCESS) {
  65                 efi_st_error("ExitBootServices did not return EFI_SUCCESS\n");
  66                 return;
  67         }
  68         efi_st_printf("\nBoot services terminated\n");
  69 }
  70
  71 /*
  72  * Set up a test.
  73  *
  74  * @test        the test to be executed
  75  * @failures    counter that will be incremented if a failure occurs
  76  * @return      EFI_ST_SUCCESS for success
  77  */
  78 static int setup(struct efi_unit_test *test, unsigned int *failures)
  79 {
  80         int ret;
  81
  82         if (!test->setup)
  83                 return EFI_ST_SUCCESS;
  84         efi_st_printf("\nSetting up '%s'\n", test->name);
  85         ret = test->setup(handle, systable);
  86         if (ret != EFI_ST_SUCCESS) {
  87                 efi_st_error("Setting up '%s' failed\n", test->name);
  88                 ++*failures;
  89         } else {
  90                 efi_st_printf("Setting up '%s' succeeded\n", test->name);
  91         }
  92         return ret;
  93 }
  94
  95 /*
  96  * Execute a test.
  97  *
  98  * @test        the test to be executed
  99  * @failures    counter that will be incremented if a failure occurs
 100  * @return      EFI_ST_SUCCESS for success
 101  */
 102 static int execute(struct efi_unit_test *test, unsigned int *failures)
 103 {
 104         int ret;
 105
 106         if (!test->execute)
 107                 return EFI_ST_SUCCESS;
 108         efi_st_printf("\nExecuting '%s'\n", test->name);
 109         ret = test->execute();
 110         if (ret != EFI_ST_SUCCESS) {
 111                 efi_st_error("Executing '%s' failed\n", test->name);
 112                 ++*failures;
 113         } else {
 114                 efi_st_printf("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_printf("\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_printf("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
 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
 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)
 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_printf("\nTesting EFI API implementation\n");
 266
 267         if (testname)
 268                 efi_st_printf("\nSelected test: '%ps'\n", testname);
 269         else
 270                 efi_st_printf("\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_printf("\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 }