git.sur5r.net Git - u-boot/blob - 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 static const struct efi_system_table *systable;
  13 static const struct efi_boot_services *boottime;
  14 static const struct efi_runtime_services *runtime;
  15 static efi_handle_t handle;
  16 static u16 reset_message[] = L"Selftest completed";
  17
  18 /*
  19  * Exit the boot services.
  20  *
  21  * The size of the memory map is determined.
  22  * Pool memory is allocated to copy the memory map.
  23  * The memory amp is copied and the map key is obtained.
  24  * The map key is used to exit the boot services.
  25  */
  26 void efi_st_exit_boot_services(void)
  27 {
  28         unsigned long  map_size = 0;
  29         unsigned long  map_key;
  30         unsigned long desc_size;
  31         u32 desc_version;
  32         efi_status_t ret;
  33         struct efi_mem_desc *memory_map;
  34
  35         ret = boottime->get_memory_map(&map_size, NULL, &map_key, &desc_size,
  36                                        &desc_version);
  37         if (ret != EFI_BUFFER_TOO_SMALL) {
  38                 efi_st_printf("ERROR: GetMemoryMap did not return "
  39                               "EFI_BUFFER_TOO_SMALL\n");
  40                 return;
  41         }
  42         /* Allocate extra space for newly allocated memory */
  43         map_size += sizeof(struct efi_mem_desc);
  44         ret = boottime->allocate_pool(EFI_BOOT_SERVICES_DATA, map_size,
  45                                       (void **)&memory_map);
  46         if (ret != EFI_SUCCESS) {
  47                 efi_st_printf("ERROR: AllocatePool did not return "
  48                               "EFI_SUCCESS\n");
  49                 return;
  50         }
  51         ret = boottime->get_memory_map(&map_size, memory_map, &map_key,
  52                                        &desc_size, &desc_version);
  53         if (ret != EFI_SUCCESS) {
  54                 efi_st_printf("ERROR: GetMemoryMap did not return "
  55                               "EFI_SUCCESS\n");
  56                 return;
  57         }
  58         ret = boottime->exit_boot_services(handle, map_key);
  59         if (ret != EFI_SUCCESS) {
  60                 efi_st_printf("ERROR: ExitBootServices did not return "
  61                               "EFI_SUCCESS\n");
  62                 return;
  63         }
  64         efi_st_printf("\nBoot services terminated\n");
  65 }
  66
  67 /*
  68  * Set up a test.
  69  *
  70  * @test        the test to be executed
  71  * @failures    counter that will be incremented if a failure occurs
  72  */
  73 static int setup(struct efi_unit_test *test, unsigned int *failures)
  74 {
  75         int ret;
  76
  77         if (!test->setup)
  78                 return 0;
  79         efi_st_printf("\nSetting up '%s'\n", test->name);
  80         ret = test->setup(handle, systable);
  81         if (ret) {
  82                 efi_st_printf("ERROR: Setting up '%s' failed\n", test->name);
  83                 ++*failures;
  84         } else {
  85                 efi_st_printf("Setting up '%s' succeeded\n", test->name);
  86         }
  87         return ret;
  88 }
  89
  90 /*
  91  * Execute a test.
  92  *
  93  * @test        the test to be executed
  94  * @failures    counter that will be incremented if a failure occurs
  95  */
  96 static int execute(struct efi_unit_test *test, unsigned int *failures)
  97 {
  98         int ret;
  99
 100         if (!test->execute)
 101                 return 0;
 102         efi_st_printf("\nExecuting '%s'\n", test->name);
 103         ret = test->execute();
 104         if (ret) {
 105                 efi_st_printf("ERROR: Executing '%s' failed\n", test->name);
 106                 ++*failures;
 107         } else {
 108                 efi_st_printf("Executing '%s' succeeded\n", test->name);
 109         }
 110         return ret;
 111 }
 112
 113 /*
 114  * Tear down a test.
 115  *
 116  * @test        the test to be torn down
 117  * @failures    counter that will be incremented if a failure occurs
 118  */
 119 static int teardown(struct efi_unit_test *test, unsigned int *failures)
 120 {
 121         int ret;
 122
 123         if (!test->teardown)
 124                 return 0;
 125         efi_st_printf("\nTearing down '%s'\n", test->name);
 126         ret = test->teardown();
 127         if (ret) {
 128                 efi_st_printf("ERROR: Tearing down '%s' failed\n", test->name);
 129                 ++*failures;
 130         } else {
 131                 efi_st_printf("Tearing down '%s' succeeded\n", test->name);
 132         }
 133         return ret;
 134 }
 135
 136 /*
 137  * Execute selftest of the EFI API
 138  *
 139  * This is the main entry point of the EFI selftest application.
 140  *
 141  * All tests use a driver model and are run in three phases:
 142  * setup, execute, teardown.
 143  *
 144  * A test may be setup and executed at boottime,
 145  * it may be setup at boottime and executed at runtime,
 146  * or it may be setup and executed at runtime.
 147  *
 148  * After executing all tests the system is reset.
 149  *
 150  * @image_handle:       handle of the loaded EFI image
 151  * @systab:             EFI system table
 152  */
 153 efi_status_t EFIAPI efi_selftest(efi_handle_t image_handle,
 154                                  struct efi_system_table *systab)
 155 {
 156         struct efi_unit_test *test;
 157         unsigned int failures = 0;
 158
 159         systable = systab;
 160         boottime = systable->boottime;
 161         runtime = systable->runtime;
 162         handle = image_handle;
 163         con_out = systable->con_out;
 164         con_in = systable->con_in;
 165
 166         efi_st_printf("\nTesting EFI API implementation\n");
 167
 168         efi_st_printf("\nNumber of tests to execute: %u\n",
 169                       ll_entry_count(struct efi_unit_test, efi_unit_test));
 170
 171         /* Execute boottime tests */
 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                 if (test->phase == EFI_EXECUTE_BEFORE_BOOTTIME_EXIT) {
 175                         setup(test, &failures);
 176                         execute(test, &failures);
 177                         teardown(test, &failures);
 178                 }
 179         }
 180
 181         /* Execute mixed tests */
 182         for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
 183              test < ll_entry_end(struct efi_unit_test, efi_unit_test); ++test) {
 184                 if (test->phase == EFI_SETUP_BEFORE_BOOTTIME_EXIT)
 185                         setup(test, &failures);
 186         }
 187
 188         efi_st_exit_boot_services();
 189
 190         for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
 191              test < ll_entry_end(struct efi_unit_test, efi_unit_test); ++test) {
 192                 if (test->phase == EFI_SETUP_BEFORE_BOOTTIME_EXIT) {
 193                         execute(test, &failures);
 194                         teardown(test, &failures);
 195                 }
 196         }
 197
 198         /* Execute runtime tests */
 199         for (test = ll_entry_start(struct efi_unit_test, efi_unit_test);
 200              test < ll_entry_end(struct efi_unit_test, efi_unit_test); ++test) {
 201                 if (test->phase == EFI_SETUP_AFTER_BOOTTIME_EXIT) {
 202                         setup(test, &failures);
 203                         execute(test, &failures);
 204                         teardown(test, &failures);
 205                 }
 206         }
 207
 208         /* Give feedback */
 209         efi_st_printf("\nSummary: %u failures\n\n", failures);
 210
 211         /* Reset system */
 212         efi_st_printf("Preparing for reset. Press any key.\n");
 213         efi_st_get_key();
 214         runtime->reset_system(EFI_RESET_WARM, EFI_NOT_READY,
 215                               sizeof(reset_message), reset_message);
 216         efi_st_printf("\nERROR: reset failed.\n");
 217
 218         return EFI_UNSUPPORTED;
 219 }