lib/efi_selftest/efi_selftest_watchdog.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * efi_selftest_watchdog
   4  *
   5  * Copyright (c) 2017 Heinrich Schuchardt <[email protected]>
   6  *
   7  * The 'watchdog timer' unit test checks that the watchdog timer
   8  * will not cause a system restart during the timeout period after
   9  * a timer reset.
  10  *
  11  * The 'watchdog reboot' unit test checks that the watchdog timer
  12  * actually reboots the system after a timeout. The test is only
  13  * executed on explicit request. Use the following commands:
  14  *
  15  *      setenv efi_selftest watchdog reboot
  16  *      bootefi selftest
  17  */
  18
  19 #include <efi_selftest.h>
  20
  21 /*
  22  * This is the communication structure for the notification function.
  23  */
  24 struct notify_context {
  25         /* Status code returned when resetting watchdog */
  26         efi_status_t status;
  27         /* Number of invocations of the notification function */
  28         unsigned int timer_ticks;
  29 };
  30
  31 static struct efi_event *event_notify;
  32 static struct efi_event *event_wait;
  33 static struct efi_boot_services *boottime;
  34 static struct notify_context notification_context;
  35 static bool watchdog_reset;
  36
  37 /*
  38  * Notification function, increments the notfication count if parameter
  39  * context is provided.
  40  *
  41  * @event       notified event
  42  * @context     pointer to the timeout
  43  */
  44 static void EFIAPI notify(struct efi_event *event, void *context)
  45 {
  46         struct notify_context *notify_context = context;
  47         efi_status_t ret = EFI_SUCCESS;
  48
  49         if (!notify_context)
  50                 return;
  51
  52         /* Reset watchdog timer to one second */
  53         ret = boottime->set_watchdog_timer(1, 0, 0, NULL);
  54         if (ret != EFI_SUCCESS)
  55                 notify_context->status = ret;
  56         /* Count number of calls */
  57         notify_context->timer_ticks++;
  58 }
  59
  60 /*
  61  * Setup unit test.
  62  *
  63  * Create two timer events.
  64  * One with EVT_NOTIFY_SIGNAL, the other with EVT_NOTIFY_WAIT.
  65  *
  66  * @handle:     handle of the loaded image
  67  * @systable:   system table
  68  * @return:     EFI_ST_SUCCESS for success
  69  */
  70 static int setup(const efi_handle_t handle,
  71                  const struct efi_system_table *systable)
  72 {
  73         efi_status_t ret;
  74
  75         boottime = systable->boottime;
  76
  77         notification_context.status = EFI_SUCCESS;
  78         notification_context.timer_ticks = 0;
  79         ret = boottime->create_event(EVT_TIMER | EVT_NOTIFY_SIGNAL,
  80                                      TPL_CALLBACK, notify,
  81                                      (void *)&notification_context,
  82                                      &event_notify);
  83         if (ret != EFI_SUCCESS) {
  84                 efi_st_error("could not create event\n");
  85                 return EFI_ST_FAILURE;
  86         }
  87         ret = boottime->create_event(EVT_TIMER | EVT_NOTIFY_WAIT,
  88                                      TPL_CALLBACK, notify, NULL, &event_wait);
  89         if (ret != EFI_SUCCESS) {
  90                 efi_st_error("could not create event\n");
  91                 return EFI_ST_FAILURE;
  92         }
  93         return EFI_ST_SUCCESS;
  94 }
  95
  96 /*
  97  * Execute the test resetting the watchdog in a timely manner. No reboot occurs.
  98  *
  99  * @handle:     handle of the loaded image
 100  * @systable:   system table
 101  * @return:     EFI_ST_SUCCESS for success
 102  */
 103 static int setup_timer(const efi_handle_t handle,
 104                        const struct efi_system_table *systable)
 105 {
 106         watchdog_reset = true;
 107         return setup(handle, systable);
 108 }
 109
 110 /*
 111  * Execute the test without resetting the watchdog. A system reboot occurs.
 112  *
 113  * @handle:     handle of the loaded image
 114  * @systable:   system table
 115  * @return:     EFI_ST_SUCCESS for success
 116  */
 117 static int setup_reboot(const efi_handle_t handle,
 118                         const struct efi_system_table *systable)
 119 {
 120         watchdog_reset = false;
 121         return setup(handle, systable);
 122 }
 123
 124 /*
 125  * Tear down unit test.
 126  *
 127  * Close the events created in setup.
 128  *
 129  * @return:     EFI_ST_SUCCESS for success
 130  */
 131 static int teardown(void)
 132 {
 133         efi_status_t ret;
 134
 135         /* Set the watchdog timer to the five minute default value */
 136         ret = boottime->set_watchdog_timer(300, 0, 0, NULL);
 137         if (ret != EFI_SUCCESS) {
 138                 efi_st_error("Setting watchdog timer failed\n");
 139                 return EFI_ST_FAILURE;
 140         }
 141         if (event_notify) {
 142                 ret = boottime->close_event(event_notify);
 143                 event_notify = NULL;
 144                 if (ret != EFI_SUCCESS) {
 145                         efi_st_error("Could not close event\n");
 146                         return EFI_ST_FAILURE;
 147                 }
 148         }
 149         if (event_wait) {
 150                 ret = boottime->close_event(event_wait);
 151                 event_wait = NULL;
 152                 if (ret != EFI_SUCCESS) {
 153                         efi_st_error("Could not close event\n");
 154                         return EFI_ST_FAILURE;
 155                 }
 156         }
 157         return EFI_ST_SUCCESS;
 158 }
 159
 160 /*
 161  * Execute unit test.
 162  *
 163  * Run a 600 ms periodic timer that resets the watchdog to one second
 164  * on every timer tick.
 165  *
 166  * Run a 1350 ms single shot timer and check that the 600ms timer has
 167  * been called 2 times.
 168  *
 169  * @return:     EFI_ST_SUCCESS for success
 170  */
 171 static int execute(void)
 172 {
 173         size_t index;
 174         efi_status_t ret;
 175
 176         /* Set the watchdog timeout to one second */
 177         ret = boottime->set_watchdog_timer(1, 0, 0, NULL);
 178         if (ret != EFI_SUCCESS) {
 179                 efi_st_error("Setting watchdog timer failed\n");
 180                 return EFI_ST_FAILURE;
 181         }
 182         if (watchdog_reset) {
 183                 /* Set 600 ms timer */
 184                 ret = boottime->set_timer(event_notify, EFI_TIMER_PERIODIC,
 185                                           6000000);
 186                 if (ret != EFI_SUCCESS) {
 187                         efi_st_error("Could not set timer\n");
 188                         return EFI_ST_FAILURE;
 189                 }
 190         }
 191         /* Set 1350 ms timer */
 192         ret = boottime->set_timer(event_wait, EFI_TIMER_RELATIVE, 13500000);
 193         if (ret != EFI_SUCCESS) {
 194                 efi_st_error("Could not set timer\n");
 195                 return EFI_ST_FAILURE;
 196         }
 197
 198         ret = boottime->wait_for_event(1, &event_wait, &index);
 199         if (ret != EFI_SUCCESS) {
 200                 efi_st_error("Could not wait for event\n");
 201                 return EFI_ST_FAILURE;
 202         }
 203         if (notification_context.status != EFI_SUCCESS) {
 204                 efi_st_error("Setting watchdog timer failed\n");
 205                 return EFI_ST_FAILURE;
 206         }
 207         if (notification_context.timer_ticks != 2) {
 208                 efi_st_error("The timer was called %u times, expected 2.\n",
 209                              notification_context.timer_ticks);
 210                 return EFI_ST_FAILURE;
 211         }
 212         return EFI_ST_SUCCESS;
 213 }
 214
 215 EFI_UNIT_TEST(watchdog1) = {
 216         .name = "watchdog timer",
 217         .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
 218         .setup = setup_timer,
 219         .execute = execute,
 220         .teardown = teardown,
 221 };
 222
 223 EFI_UNIT_TEST(watchdog2) = {
 224         .name = "watchdog reboot",
 225         .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
 226         .setup = setup_reboot,
 227         .execute = execute,
 228         .teardown = teardown,
 229         .on_request = true,
 230 };