efi_selftest: simplify efi_selftest_variables_runtime

Use global st_boottime and st_runtime.

Signed-off-by: Heinrich Schuchardt <heinrich.schuchardt@canonical.com>

diff --git a/lib/efi_selftest/efi_selftest_variables_runtime.c b/lib/efi_selftest/efi_selftest_variables_runtime.c
index 4be37efc1fc7c0f910c94b14d86ed4607b723975..0886b4894b8df326f64dd8dada1be1f833f0e9f7 100644 (file)
--- a/lib/efi_selftest/efi_selftest_variables_runtime.c
+++ b/lib/efi_selftest/efi_selftest_variables_runtime.c
@@ -16,26 +16,9 @@
 #define EFI_ST_MAX_DATA_SIZE 16
 #define EFI_ST_MAX_VARNAME_SIZE 40
 
-static struct efi_boot_services *boottime;
-static struct efi_runtime_services *runtime;
 static const efi_guid_t guid_vendor0 = EFI_GLOBAL_VARIABLE_GUID;
 static const efi_guid_t __efi_runtime_data efi_rt_var_guid =
-                                               U_BOOT_EFI_RT_VAR_FILE_GUID;
-
-/*
- * Setup unit test.
- *
- * @handle     handle of the loaded image
- * @systable   system table
- */
-static int setup(const efi_handle_t img_handle,
-                const struct efi_system_table *systable)
-{
-       boottime = systable->boottime;
-       runtime = systable->runtime;
-
-       return EFI_ST_SUCCESS;
-}
+       U_BOOT_EFI_RT_VAR_FILE_GUID;
 
 /**
  * execute() - execute unit test
@@ -60,26 +43,27 @@ static int execute(void)
        memset(v2, 0x1, sizeof(v2));
 
        if (IS_ENABLED(CONFIG_EFI_VARIABLE_FILE_STORE)) {
-               test_ret = efi_st_query_variable_common(EFI_VARIABLE_BOOTSERVICE_ACCESS |
-                                                       EFI_VARIABLE_RUNTIME_ACCESS);
+               test_ret = efi_st_query_variable_common(
+                       EFI_VARIABLE_BOOTSERVICE_ACCESS |
+                       EFI_VARIABLE_RUNTIME_ACCESS);
                if (test_ret != EFI_ST_SUCCESS) {
                        efi_st_error("QueryVariableInfo failed\n");
                        return EFI_ST_FAILURE;
                }
        } else {
-               ret = runtime->query_variable_info(EFI_VARIABLE_BOOTSERVICE_ACCESS,
-                                          &max_storage, &rem_storage,
-                                          &max_size);
+               ret = st_runtime->query_variable_info(
+                       EFI_VARIABLE_BOOTSERVICE_ACCESS, &max_storage,
+                       &rem_storage, &max_size);
                if (ret != EFI_UNSUPPORTED) {
                        efi_st_error("QueryVariableInfo failed\n");
                        return EFI_ST_FAILURE;
                }
        }
 
-       ret = runtime->set_variable(u"efi_st_var0", &guid_vendor0,
-                                   EFI_VARIABLE_BOOTSERVICE_ACCESS |
-                                   EFI_VARIABLE_RUNTIME_ACCESS,
-                                   3, v + 4);
+       ret = st_runtime->set_variable(u"efi_st_var0", &guid_vendor0,
+                                      EFI_VARIABLE_BOOTSERVICE_ACCESS |
+                                              EFI_VARIABLE_RUNTIME_ACCESS,
+                                      3, v + 4);
        if (IS_ENABLED(CONFIG_EFI_RT_VOLATILE_STORE)) {
                efi_uintn_t prev_len, delta;
                struct efi_var_entry *var;
@@ -91,20 +75,21 @@ static int execute(void)
                        return EFI_ST_FAILURE;
                }
 
-               /* runtime atttribute must be set */
-               ret = runtime->set_variable(u"efi_st_var0", &guid_vendor0,
-                                           EFI_VARIABLE_BOOTSERVICE_ACCESS |
-                                           EFI_VARIABLE_NON_VOLATILE,
-                                           3, v + 4);
+               /* runtime attribute must be set */
+               ret = st_runtime->set_variable(
+                       u"efi_st_var0", &guid_vendor0,
+                       EFI_VARIABLE_BOOTSERVICE_ACCESS |
+                               EFI_VARIABLE_NON_VOLATILE,
+                       3, v + 4);
                if (ret != EFI_INVALID_PARAMETER) {
                        efi_st_error("SetVariable failed\n");
                        return EFI_ST_FAILURE;
                }
 
                len = sizeof(data);
-               ret = runtime->get_variable(u"RTStorageVolatile",
-                                           &efi_rt_var_guid,
-                                           &attr, &len, data);
+               ret = st_runtime->get_variable(u"RTStorageVolatile",
+                                              &efi_rt_var_guid, &attr, &len,
+                                              data);
                if (ret != EFI_SUCCESS) {
                        efi_st_error("GetVariable failed\n");
                        return EFI_ST_FAILURE;
@@ -118,8 +103,8 @@ static int execute(void)
                }
 
                len = sizeof(data2);
-               ret = runtime->get_variable(u"VarToFile", &efi_rt_var_guid,
-                                           &attr, &len, data2);
+               ret = st_runtime->get_variable(u"VarToFile", &efi_rt_var_guid,
+                                              &attr, &len, data2);
                if (ret != EFI_SUCCESS) {
                        efi_st_error("GetVariable failed\n");
                        return EFI_ST_FAILURE;
@@ -129,12 +114,12 @@ static int execute(void)
                 * Store it now, we'll use it later
                 */
                prev_len = len;
-               ret = runtime->set_variable(u"efi_st_var0", &guid_vendor0,
-                                           EFI_VARIABLE_BOOTSERVICE_ACCESS |
-                                           EFI_VARIABLE_RUNTIME_ACCESS |
-                                           EFI_VARIABLE_NON_VOLATILE,
-                                           sizeof(v2),
-                                           v2);
+               ret = st_runtime->set_variable(
+                       u"efi_st_var0", &guid_vendor0,
+                       EFI_VARIABLE_BOOTSERVICE_ACCESS |
+                               EFI_VARIABLE_RUNTIME_ACCESS |
+                               EFI_VARIABLE_NON_VOLATILE,
+                       sizeof(v2), v2);
                /*
                 * This will try to update VarToFile as well and must fail,
                 * without changing or deleting VarToFile
@@ -144,60 +129,64 @@ static int execute(void)
                        return EFI_ST_FAILURE;
                }
                len = sizeof(data2);
-               ret = runtime->get_variable(u"VarToFile", &efi_rt_var_guid,
-                                           &attr, &len, data2);
+               ret = st_runtime->get_variable(u"VarToFile", &efi_rt_var_guid,
+                                              &attr, &len, data2);
                if (ret != EFI_SUCCESS || prev_len != len) {
                        efi_st_error("Get/SetVariable failed\n");
                        return EFI_ST_FAILURE;
                }
 
                /* Add an 8byte aligned variable */
-               ret = runtime->set_variable(u"efi_st_var0", &guid_vendor0,
-                                           EFI_VARIABLE_BOOTSERVICE_ACCESS |
-                                           EFI_VARIABLE_RUNTIME_ACCESS |
-                                           EFI_VARIABLE_NON_VOLATILE,
-                                           sizeof(v), v);
+               ret = st_runtime->set_variable(
+                       u"efi_st_var0", &guid_vendor0,
+                       EFI_VARIABLE_BOOTSERVICE_ACCESS |
+                               EFI_VARIABLE_RUNTIME_ACCESS |
+                               EFI_VARIABLE_NON_VOLATILE,
+                       sizeof(v), v);
                if (ret != EFI_SUCCESS) {
                        efi_st_error("SetVariable failed\n");
                        return EFI_ST_FAILURE;
                }
 
                /* Delete it by setting the attrs to 0 */
-               ret = runtime->set_variable(u"efi_st_var0", &guid_vendor0,
-                                           0, sizeof(v), v);
+               ret = st_runtime->set_variable(u"efi_st_var0", &guid_vendor0, 0,
+                                              sizeof(v), v);
                if (ret != EFI_SUCCESS) {
                        efi_st_error("SetVariable failed\n");
                        return EFI_ST_FAILURE;
                }
 
                /* Add it back */
-               ret = runtime->set_variable(u"efi_st_var0", &guid_vendor0,
-                                           EFI_VARIABLE_BOOTSERVICE_ACCESS |
-                                           EFI_VARIABLE_RUNTIME_ACCESS |
-                                           EFI_VARIABLE_NON_VOLATILE,
-                                           sizeof(v), v);
+               ret = st_runtime->set_variable(
+                       u"efi_st_var0", &guid_vendor0,
+                       EFI_VARIABLE_BOOTSERVICE_ACCESS |
+                               EFI_VARIABLE_RUNTIME_ACCESS |
+                               EFI_VARIABLE_NON_VOLATILE,
+                       sizeof(v), v);
                if (ret != EFI_SUCCESS) {
                        efi_st_error("SetVariable failed\n");
                        return EFI_ST_FAILURE;
                }
 
                /* Delete it again by setting the size to 0 */
-               ret = runtime->set_variable(u"efi_st_var0", &guid_vendor0,
-                                           EFI_VARIABLE_BOOTSERVICE_ACCESS |
-                                           EFI_VARIABLE_RUNTIME_ACCESS |
-                                           EFI_VARIABLE_NON_VOLATILE,
-                                           0, NULL);
+               ret = st_runtime->set_variable(
+                       u"efi_st_var0", &guid_vendor0,
+                       EFI_VARIABLE_BOOTSERVICE_ACCESS |
+                               EFI_VARIABLE_RUNTIME_ACCESS |
+                               EFI_VARIABLE_NON_VOLATILE,
+                       0, NULL);
                if (ret != EFI_SUCCESS) {
                        efi_st_error("SetVariable failed\n");
                        return EFI_ST_FAILURE;
                }
 
                /* Delete it again and make sure it's not there */
-               ret = runtime->set_variable(u"efi_st_var0", &guid_vendor0,
-                                           EFI_VARIABLE_BOOTSERVICE_ACCESS |
-                                           EFI_VARIABLE_RUNTIME_ACCESS |
-                                           EFI_VARIABLE_NON_VOLATILE,
-                                           0, NULL);
+               ret = st_runtime->set_variable(
+                       u"efi_st_var0", &guid_vendor0,
+                       EFI_VARIABLE_BOOTSERVICE_ACCESS |
+                               EFI_VARIABLE_RUNTIME_ACCESS |
+                               EFI_VARIABLE_NON_VOLATILE,
+                       0, NULL);
                if (ret != EFI_NOT_FOUND) {
                        efi_st_error("SetVariable failed\n");
                        return EFI_ST_FAILURE;
@@ -207,11 +196,12 @@ static int execute(void)
                 * Add a non-aligned variable
                 * VarToFile updates must include efi_st_var0
                 */
-               ret = runtime->set_variable(u"efi_st_var0", &guid_vendor0,
-                                           EFI_VARIABLE_BOOTSERVICE_ACCESS |
-                                           EFI_VARIABLE_RUNTIME_ACCESS |
-                                           EFI_VARIABLE_NON_VOLATILE,
-                                           9, v + 4);
+               ret = st_runtime->set_variable(
+                       u"efi_st_var0", &guid_vendor0,
+                       EFI_VARIABLE_BOOTSERVICE_ACCESS |
+                               EFI_VARIABLE_RUNTIME_ACCESS |
+                               EFI_VARIABLE_NON_VOLATILE,
+                       9, v + 4);
                if (ret != EFI_SUCCESS) {
                        efi_st_error("SetVariable failed\n");
                        return EFI_ST_FAILURE;
@@ -223,8 +213,8 @@ static int execute(void)
                }
                delta = efi_var_entry_len(var);
                len = sizeof(data2);
-               ret = runtime->get_variable(u"VarToFile", &efi_rt_var_guid,
-                                           &attr, &len, data2);
+               ret = st_runtime->get_variable(u"VarToFile", &efi_rt_var_guid,
+                                              &attr, &len, data2);
                if (ret != EFI_SUCCESS || prev_len + delta != len) {
                        efi_st_error("Get/SetVariable failed\n");
                        return EFI_ST_FAILURE;
@@ -237,25 +227,27 @@ static int execute(void)
                 */
                prev_len = len;
                avail = efi_var_entry_len(var) -
-                       (sizeof(u16) * (u16_strlen(var->name) + 1) + sizeof(*var)) -
+                       (sizeof(u16) * (u16_strlen(var->name) + 1) +
+                        sizeof(*var)) -
                        var->length;
                if (avail >= append_len)
                        delta = 0;
                else
                        delta = ALIGN(append_len - avail, 8);
-               ret = runtime->set_variable(u"efi_st_var0", &guid_vendor0,
-                                           EFI_VARIABLE_BOOTSERVICE_ACCESS |
-                                           EFI_VARIABLE_RUNTIME_ACCESS |
-                                           EFI_VARIABLE_APPEND_WRITE |
-                                           EFI_VARIABLE_NON_VOLATILE,
-                                           append_len, v2);
+               ret = st_runtime->set_variable(
+                       u"efi_st_var0", &guid_vendor0,
+                       EFI_VARIABLE_BOOTSERVICE_ACCESS |
+                               EFI_VARIABLE_RUNTIME_ACCESS |
+                               EFI_VARIABLE_APPEND_WRITE |
+                               EFI_VARIABLE_NON_VOLATILE,
+                       append_len, v2);
                if (ret != EFI_SUCCESS) {
                        efi_st_error("SetVariable failed\n");
                        return EFI_ST_FAILURE;
                }
                len = sizeof(data2);
-               ret = runtime->get_variable(u"VarToFile", &efi_rt_var_guid,
-                                           &attr, &len, data2);
+               ret = st_runtime->get_variable(u"VarToFile", &efi_rt_var_guid,
+                                              &attr, &len, data2);
                if (ret != EFI_SUCCESS) {
                        efi_st_error("GetVariable failed\n");
                        return EFI_ST_FAILURE;
@@ -267,20 +259,22 @@ static int execute(void)
 
                /* Make sure that variable contains a valid file */
                hdr = (struct efi_var_file *)data2;
-               if (hdr->magic != EFI_VAR_FILE_MAGIC ||
-                   len != hdr->length ||
-                   hdr->crc32 != crc32(0, (u8 *)((uintptr_t)data2 + sizeof(struct efi_var_file)),
+               if (hdr->magic != EFI_VAR_FILE_MAGIC || len != hdr->length ||
+                   hdr->crc32 != crc32(0,
+                                       (u8 *)((uintptr_t)data2 +
+                                              sizeof(struct efi_var_file)),
                                        len - sizeof(struct efi_var_file))) {
                        efi_st_error("VarToFile invalid header\n");
                        return EFI_ST_FAILURE;
                }
 
                /* Variables that are BS, RT and volatile are RO after EBS */
-               ret = runtime->set_variable(u"VarToFile", &efi_rt_var_guid,
-                                           EFI_VARIABLE_BOOTSERVICE_ACCESS |
-                                           EFI_VARIABLE_RUNTIME_ACCESS |
-                                           EFI_VARIABLE_NON_VOLATILE,
-                                           sizeof(v), v);
+               ret = st_runtime->set_variable(
+                       u"VarToFile", &efi_rt_var_guid,
+                       EFI_VARIABLE_BOOTSERVICE_ACCESS |
+                               EFI_VARIABLE_RUNTIME_ACCESS |
+                               EFI_VARIABLE_NON_VOLATILE,
+                       sizeof(v), v);
                if (ret != EFI_WRITE_PROTECTED) {
                        efi_st_error("Get/SetVariable failed\n");
                        return EFI_ST_FAILURE;
@@ -292,8 +286,8 @@ static int execute(void)
                }
        }
        len = EFI_ST_MAX_DATA_SIZE;
-       ret = runtime->get_variable(u"PlatformLangCodes", &guid_vendor0,
-                                   &attr, &len, data);
+       ret = st_runtime->get_variable(u"PlatformLangCodes", &guid_vendor0,
+                                      &attr, &len, data);
        if (ret != EFI_SUCCESS) {
                efi_st_error("GetVariable failed\n");
                return EFI_ST_FAILURE;
@@ -301,7 +295,7 @@ static int execute(void)
        memset(&guid, 0, 16);
        *varname = 0;
        len = 2 * EFI_ST_MAX_VARNAME_SIZE;
-       ret = runtime->get_next_variable_name(&len, varname, &guid);
+       ret = st_runtime->get_next_variable_name(&len, varname, &guid);
        if (ret != EFI_SUCCESS) {
                efi_st_error("GetNextVariableName failed\n");
                return EFI_ST_FAILURE;
@@ -313,6 +307,5 @@ static int execute(void)
 EFI_UNIT_TEST(variables_run) = {
        .name = "variables at runtime",
        .phase = EFI_SETUP_BEFORE_BOOTTIME_EXIT,
-       .setup = setup,
        .execute = execute,
 };