lib/efi_selftest/efi_selftest_variables.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * efi_selftest_variables
   4  *
   5  * Copyright (c) 2018 Heinrich Schuchardt <xypron.glpk@gmx.de>
   6  *
   7  * This unit test checks the runtime services for variables:
   8  * GetVariable, GetNextVariableName, SetVariable, QueryVariableInfo.
   9  */
  10
  11 #include <efi_selftest.h>
  12
  13 #define EFI_ST_MAX_DATA_SIZE 16
  14 #define EFI_ST_MAX_VARNAME_SIZE 40
  15
  16 static struct efi_boot_services *boottime;
  17 static struct efi_runtime_services *runtime;
  18 static const efi_guid_t guid_vendor0 =
  19         EFI_GUID(0x67029eb5, 0x0af2, 0xf6b1,
  20                  0xda, 0x53, 0xfc, 0xb5, 0x66, 0xdd, 0x1c, 0xe6);
  21 static const efi_guid_t guid_vendor1 =
  22         EFI_GUID(0xff629290, 0x1fc1, 0xd73f,
  23                  0x8f, 0xb1, 0x32, 0xf9, 0x0c, 0xa0, 0x42, 0xea);
  24 static const efi_guid_t guid_global =
  25         EFI_GUID(0x8be4df61, 0x93ca, 0x11d2,
  26                  0xaa, 0x0d, 0x00, 0xe0, 0x98, 0x03, 0x2b, 0x8c);
  27
  28 /*
  29  * Setup unit test.
  30  *
  31  * @handle      handle of the loaded image
  32  * @systable    system table
  33  */
  34 static int setup(const efi_handle_t img_handle,
  35                  const struct efi_system_table *systable)
  36 {
  37         boottime = systable->boottime;
  38         runtime = systable->runtime;
  39
  40         return EFI_ST_SUCCESS;
  41 }
  42
  43 /*
  44  * Execute unit test.
  45  */
  46 static int execute(void)
  47 {
  48         efi_status_t ret;
  49         efi_uintn_t len;
  50         u32 attr;
  51         u8 v[16] = {0x5d, 0xd1, 0x5e, 0x51, 0x5a, 0x05, 0xc7, 0x0c,
  52                     0x35, 0x4a, 0xae, 0x87, 0xa5, 0xdf, 0x0f, 0x65,};
  53         u8 data[EFI_ST_MAX_DATA_SIZE];
  54         u16 varname[EFI_ST_MAX_VARNAME_SIZE];
  55         int flag;
  56         efi_guid_t guid;
  57         u64 max_storage, rem_storage, max_size;
  58
  59         ret = runtime->query_variable_info(EFI_VARIABLE_BOOTSERVICE_ACCESS,
  60                                            &max_storage, &rem_storage,
  61                                            &max_size);
  62         if (ret != EFI_SUCCESS) {
  63                 efi_st_todo("QueryVariableInfo failed\n");
  64         } else if (!max_storage || !rem_storage || !max_size) {
  65                 efi_st_error("QueryVariableInfo: wrong info\n");
  66                 return EFI_ST_FAILURE;
  67         }
  68         /* Set variable 0 */
  69         ret = runtime->set_variable(L"efi_st_var0", &guid_vendor0,
  70                                     EFI_VARIABLE_BOOTSERVICE_ACCESS,
  71                                     3, v + 4);
  72         if (ret != EFI_SUCCESS) {
  73                 efi_st_error("SetVariable failed\n");
  74                 return EFI_ST_FAILURE;
  75         }
  76         data[3] = 0xff;
  77         len = 3;
  78         ret = runtime->get_variable(L"efi_st_var0", &guid_vendor0,
  79                                     &attr, &len, data);
  80         if (ret != EFI_SUCCESS) {
  81                 efi_st_error("GetVariable failed\n");
  82                 return EFI_ST_FAILURE;
  83         }
  84         if (memcmp(data, v + 4, 3)) {
  85                 efi_st_error("GetVariable returned wrong value\n");
  86                 return EFI_ST_FAILURE;
  87         }
  88         if (data[3] != 0xff) {
  89                 efi_st_error("GetVariable wrote past the end of the buffer\n");
  90                 return EFI_ST_FAILURE;
  91         }
  92         /* Set variable 1 */
  93         ret = runtime->set_variable(L"efi_st_var1", &guid_vendor1,
  94                                     EFI_VARIABLE_BOOTSERVICE_ACCESS,
  95                                     8, v);
  96         if (ret != EFI_SUCCESS) {
  97                 efi_st_error("SetVariable failed\n");
  98                 return EFI_ST_FAILURE;
  99         }
 100         len = EFI_ST_MAX_DATA_SIZE;
 101         ret = runtime->get_variable(L"efi_st_var1", &guid_vendor1,
 102                                     &attr, &len, data);
 103         if (ret != EFI_SUCCESS) {
 104                 efi_st_error("GetVariable failed\n");
 105                 return EFI_ST_FAILURE;
 106         }
 107         if (len != 8) {
 108                 efi_st_error("GetVariable returned wrong length %u\n",
 109                              (unsigned int)len);
 110                 return EFI_ST_FAILURE;
 111         }
 112         if (memcmp(data, v, 8)) {
 113                 efi_st_error("GetVariable returned wrong value\n");
 114                 return EFI_ST_FAILURE;
 115         }
 116         /* Append variable 1 */
 117         ret = runtime->set_variable(L"efi_st_var1", &guid_vendor1,
 118                                     EFI_VARIABLE_BOOTSERVICE_ACCESS |
 119                                     EFI_VARIABLE_APPEND_WRITE,
 120                                     7, v + 8);
 121         if (ret != EFI_SUCCESS) {
 122                 efi_st_error("SetVariable(APPEND_WRITE) failed\n");
 123         } else {
 124                 len = EFI_ST_MAX_DATA_SIZE;
 125                 ret = runtime->get_variable(L"efi_st_var1", &guid_vendor1,
 126                                             &attr, &len, data);
 127                 if (ret != EFI_SUCCESS) {
 128                         efi_st_error("GetVariable failed\n");
 129                         return EFI_ST_FAILURE;
 130                 }
 131                 if (len != 15)
 132                         efi_st_todo("GetVariable returned wrong length %u\n",
 133                                     (unsigned int)len);
 134                 if (memcmp(data, v, len))
 135                         efi_st_todo("GetVariable returned wrong value\n");
 136         }
 137         /* Append variable 2 */
 138         ret = runtime->set_variable(L"efi_none", &guid_vendor1,
 139                                     EFI_VARIABLE_BOOTSERVICE_ACCESS |
 140                                     EFI_VARIABLE_APPEND_WRITE,
 141                                     15, v);
 142         if (ret != EFI_NOT_FOUND)
 143                 efi_st_error("SetVariable(APPEND_WRITE) with size 0 to non-existent variable returns wrong code\n");
 144         /* Append variable 3 */
 145         ret = runtime->set_variable(L"PlatformLangCodes", &guid_global,
 146                                     EFI_VARIABLE_BOOTSERVICE_ACCESS |
 147                                     EFI_VARIABLE_RUNTIME_ACCESS |
 148                                     EFI_VARIABLE_APPEND_WRITE,
 149                                     15, v);
 150         if (ret != EFI_WRITE_PROTECTED)
 151                 efi_st_todo("SetVariable(APPEND_WRITE) to read-only variable returns wrong code\n");
 152         /* Enumerate variables */
 153         boottime->set_mem(&guid, 16, 0);
 154         *varname = 0;
 155         flag = 0;
 156         for (;;) {
 157                 len = EFI_ST_MAX_VARNAME_SIZE;
 158                 ret = runtime->get_next_variable_name(&len, varname, &guid);
 159                 if (ret == EFI_NOT_FOUND)
 160                         break;
 161                 if (ret != EFI_SUCCESS) {
 162                         efi_st_error("GetNextVariableName failed (%u)\n",
 163                                      (unsigned int)ret);
 164                         return EFI_ST_FAILURE;
 165                 }
 166                 if (!memcmp(&guid, &guid_vendor0, sizeof(efi_guid_t)) &&
 167                     !efi_st_strcmp_16_8(varname, "efi_st_var0"))
 168                         flag |= 1;
 169                 if (!memcmp(&guid, &guid_vendor1, sizeof(efi_guid_t)) &&
 170                     !efi_st_strcmp_16_8(varname, "efi_st_var1"))
 171                         flag |= 2;
 172         }
 173         if (flag != 3) {
 174                 efi_st_error(
 175                         "GetNextVariableName did not return all variables\n");
 176                 return EFI_ST_FAILURE;
 177         }
 178         /* Delete variable 1 */
 179         ret = runtime->set_variable(L"efi_st_var1", &guid_vendor1,
 180                                     0, 0, NULL);
 181         if (ret != EFI_SUCCESS) {
 182                 efi_st_error("SetVariable failed\n");
 183                 return EFI_ST_FAILURE;
 184         }
 185         len = EFI_ST_MAX_DATA_SIZE;
 186         ret = runtime->get_variable(L"efi_st_var1", &guid_vendor1,
 187                                     &attr, &len, data);
 188         if (ret != EFI_NOT_FOUND) {
 189                 efi_st_error("Variable was not deleted\n");
 190                 return EFI_ST_FAILURE;
 191         }
 192         /* Delete variable 0 */
 193         ret = runtime->set_variable(L"efi_st_var0", &guid_vendor0,
 194                                     0, 0, NULL);
 195         if (ret != EFI_SUCCESS) {
 196                 efi_st_error("SetVariable failed\n");
 197                 return EFI_ST_FAILURE;
 198         }
 199         len = EFI_ST_MAX_DATA_SIZE;
 200         ret = runtime->get_variable(L"efi_st_var0", &guid_vendor0,
 201                                     &attr, &len, data);
 202         if (ret != EFI_NOT_FOUND) {
 203                 efi_st_error("Variable was not deleted\n");
 204                 return EFI_ST_FAILURE;
 205         }
 206
 207         return EFI_ST_SUCCESS;
 208 }
 209
 210 EFI_UNIT_TEST(variables) = {
 211         .name = "variables",
 212         .phase = EFI_EXECUTE_BEFORE_BOOTTIME_EXIT,
 213         .setup = setup,
 214         .execute = execute,
 215 };