lib/efi_selftest/efi_selftest_tpl.c

   1 /*
   2  * efi_selftest_events
   3  *
   4  * Copyright (c) 2017 Heinrich Schuchardt <xypron.glpk@gmx.de>
   5  *
   6  * SPDX-License-Identifier:     GPL-2.0+
   7  *
   8  * This unit test uses timer events to check the handling of
   9  * task priority levels.
  10  */
  11
  12 #include <efi_selftest.h>
  13
  14 static struct efi_event *event_notify;
  15 static struct efi_event *event_wait;
  16 static unsigned int counter;
  17 static struct efi_boot_services *boottime;
  18
  19 /*
  20  * Notification function, increments a counter.
  21  *
  22  * @event       notified event
  23  * @context     pointer to the counter
  24  */
  25 static void EFIAPI notify(struct efi_event *event, void *context)
  26 {
  27         if (!context)
  28                 return;
  29         ++*(unsigned int *)context;
  30 }
  31
  32 /*
  33  * Setup unit test.
  34  *
  35  * Create two timer events.
  36  * One with EVT_NOTIFY_SIGNAL, the other with EVT_NOTIFY_WAIT.
  37  *
  38  * @handle:     handle of the loaded image
  39  * @systable:   system table
  40  */
  41 static int setup(const efi_handle_t handle,
  42                  const struct efi_system_table *systable)
  43 {
  44         efi_status_t ret;
  45
  46         boottime = systable->boottime;
  47
  48         ret = boottime->create_event(EVT_TIMER | EVT_NOTIFY_SIGNAL,
  49                                      TPL_CALLBACK, notify, (void *)&counter,
  50                                      &event_notify);
  51         if (ret != EFI_SUCCESS) {
  52                 efi_st_error("could not create event\n");
  53                 return 1;
  54         }
  55         ret = boottime->create_event(EVT_TIMER | EVT_NOTIFY_WAIT,
  56                                      TPL_HIGH_LEVEL, notify, NULL, &event_wait);
  57         if (ret != EFI_SUCCESS) {
  58                 efi_st_error("could not create event\n");
  59                 return 1;
  60         }
  61         return 0;
  62 }
  63
  64 /*
  65  * Tear down unit test.
  66  *
  67  * Close the events created in setup.
  68  */
  69 static int teardown(void)
  70 {
  71         efi_status_t ret;
  72
  73         if (event_notify) {
  74                 ret = boottime->close_event(event_notify);
  75                 event_notify = NULL;
  76                 if (ret != EFI_SUCCESS) {
  77                         efi_st_error("could not close event\n");
  78                         return 1;
  79                 }
  80         }
  81         if (event_wait) {
  82                 ret = boottime->close_event(event_wait);
  83                 event_wait = NULL;
  84                 if (ret != EFI_SUCCESS) {
  85                         efi_st_error("could not close event\n");
  86                         return 1;
  87                 }
  88         }
  89         boottime->restore_tpl(TPL_APPLICATION);
  90         return 0;
  91 }
  92
  93 /*
  94  * Execute unit test.
  95  *
  96  * Run a 10 ms periodic timer and check that it is called 10 times
  97  * while waiting for 100 ms single shot timer.
  98  *
  99  * Raise the TPL level to the level of the 10 ms timer and observe
 100  * that the notification function is not called again.
 101  *
 102  * Lower the TPL level and check that the queued notification
 103  * function is called.
 104  */
 105 static int execute(void)
 106 {
 107         unsigned long index;
 108         efi_status_t ret;
 109         UINTN old_tpl;
 110
 111         /* Set 10 ms timer */
 112         counter = 0;
 113         ret = boottime->set_timer(event_notify, EFI_TIMER_PERIODIC, 100000);
 114         if (ret != EFI_SUCCESS) {
 115                 efi_st_error("Could not set timer\n");
 116                 return 1;
 117         }
 118         /* Set 100 ms timer */
 119         ret = boottime->set_timer(event_wait, EFI_TIMER_RELATIVE, 1000000);
 120         if (ret != EFI_SUCCESS) {
 121                 efi_st_error("Could not set timer\n");
 122                 return 1;
 123         }
 124         index = 5;
 125         ret = boottime->wait_for_event(1, &event_wait, &index);
 126         if (ret != EFI_SUCCESS) {
 127                 efi_st_error("Could not wait for event\n");
 128                 return 1;
 129         }
 130         ret = boottime->check_event(event_wait);
 131         if (ret != EFI_NOT_READY) {
 132                 efi_st_error("Signaled state was not cleared.\n");
 133                 efi_st_printf("ret = %u\n", (unsigned int)ret);
 134                 return 1;
 135         }
 136         if (index != 0) {
 137                 efi_st_error("WaitForEvent returned wrong index\n");
 138                 return 1;
 139         }
 140         efi_st_printf("Counter with TPL level TPL_APPLICATION: %u\n", counter);
 141         if (counter < 8 || counter > 12) {
 142                 efi_st_error("Incorrect timing of events\n");
 143                 return 1;
 144         }
 145         ret = boottime->set_timer(event_notify, EFI_TIMER_STOP, 0);
 146         if (index != 0) {
 147                 efi_st_error("Could not cancel timer\n");
 148                 return 1;
 149         }
 150         /* Raise TPL level */
 151         old_tpl = boottime->raise_tpl(TPL_CALLBACK);
 152         if (old_tpl != TPL_APPLICATION) {
 153                 efi_st_error("Initial TPL level was not TPL_APPLICATION");
 154                 return 1;
 155         }
 156         /* Set 10 ms timer */
 157         counter = 0;
 158         ret = boottime->set_timer(event_notify, EFI_TIMER_PERIODIC, 100000);
 159         if (index != 0) {
 160                 efi_st_error("Could not set timer\n");
 161                 return 1;
 162         }
 163         /* Set 100 ms timer */
 164         ret = boottime->set_timer(event_wait, EFI_TIMER_RELATIVE, 1000000);
 165         if (ret != EFI_SUCCESS) {
 166                 efi_st_error("Could not set timer\n");
 167                 return 1;
 168         }
 169         do {
 170                 ret = boottime->check_event(event_wait);
 171         } while (ret == EFI_NOT_READY);
 172         if (ret != EFI_SUCCESS) {
 173                 efi_st_error("Could not check event\n");
 174                 return 1;
 175         }
 176         efi_st_printf("Counter with TPL level TPL_CALLBACK: %u\n", counter);
 177         if (counter != 0) {
 178                 efi_st_error("Suppressed timer fired\n");
 179                 return 1;
 180         }
 181         /* Set 1 ms timer */
 182         ret = boottime->set_timer(event_wait, EFI_TIMER_RELATIVE, 1000);
 183         if (ret != EFI_SUCCESS) {
 184                 efi_st_error("Could not set timer\n");
 185                 return 1;
 186         }
 187         /* Restore the old TPL level */
 188         boottime->restore_tpl(TPL_APPLICATION);
 189         ret = boottime->wait_for_event(1, &event_wait, &index);
 190         if (ret != EFI_SUCCESS) {
 191                 efi_st_error("Could not wait for event\n");
 192                 return 1;
 193         }
 194         efi_st_printf("Counter with TPL level TPL_APPLICATION: %u\n", counter);
 195         if (counter < 1) {
 196                 efi_st_error("Queued timer event did not fire\n");
 197                 return 1;
 198         }
 199         ret = boottime->set_timer(event_wait, EFI_TIMER_STOP, 0);
 200         if (index != 0) {
 201                 efi_st_error("Could not cancel timer\n");
 202                 return 1;
 203         }
 204
 205         return 0;
 206 }
 207
 208 EFI_UNIT_TEST(tpl) = {
 209         .name = "task priority levels",
 210         .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
 211         .setup = setup,
 212         .execute = execute,
 213         .teardown = teardown,
 214 };