Merge branch 'x86-efi-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip into next

Pull x86 EFI updates from Peter Anvin:
 "A collection of EFI changes.  The perhaps most important one is to
  fully save and restore the FPU state around each invocation of EFI
  runtime, and to not choke on non-ASCII characters in the boot stub"

* 'x86-efi-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip:
  efivars: Add compatibility code for compat tasks
  efivars: Refactor sanity checking code into separate function
  efivars: Stop passing a struct argument to efivar_validate()
  efivars: Check size of user object
  efivars: Use local variables instead of a pointer dereference
  x86/efi: Save and restore FPU context around efi_calls (i386)
  x86/efi: Save and restore FPU context around efi_calls (x86_64)
  x86/efi: Implement a __efi_call_virt macro
  x86, fpu: Extend the use of static_cpu_has_safe
  x86/efi: Delete most of the efi_call* macros
  efi: x86: Handle arbitrary Unicode characters
  efi: Add get_dram_base() helper function
  efi: Add shared printk wrapper for consistent prefixing
  efi: create memory map iteration helper
  efi: efi-stub-helper cleanup

3 files changed, 284 insertions, 82 deletions

diff --git a/drivers/firmware/efi/efi-stub-helper.c b/drivers/firmware/efi/efi-stub-helper.c
index 2c41eaece2c1..eb6d4be9e722 100644
--- a/drivers/firmware/efi/efi-stub-helper.c
+++ b/drivers/firmware/efi/efi-stub-helper.c
@@ -11,6 +11,10 @@
  */
 #define EFI_READ_CHUNK_SIZE     (1024 * 1024)
 
+/* error code which can't be mistaken for valid address */
+#define EFI_ERROR       (~0UL)
+
+
 struct file_info {
         efi_file_handle_t *handle;
         u64 size;
@@ -33,6 +37,9 @@ static void efi_printk(efi_system_table_t *sys_table_arg, char *str)
         }
 }
 
+#define pr_efi(sys_table, msg)     efi_printk(sys_table, "EFI stub: "msg)
+#define pr_efi_err(sys_table, msg) efi_printk(sys_table, "EFI stub: ERROR: "msg)
+
 
 static efi_status_t efi_get_memory_map(efi_system_table_t *sys_table_arg,
                                        efi_memory_desc_t **map,
@@ -80,6 +87,32 @@ fail:
         return status;
 }
 
+
+static unsigned long __init get_dram_base(efi_system_table_t *sys_table_arg)
+{
+        efi_status_t status;
+        unsigned long map_size;
+        unsigned long membase  = EFI_ERROR;
+        struct efi_memory_map map;
+        efi_memory_desc_t *md;
+
+        status = efi_get_memory_map(sys_table_arg, (efi_memory_desc_t **)&map.map,
+                                    &map_size, &map.desc_size, NULL, NULL);
+        if (status != EFI_SUCCESS)
+                return membase;
+
+        map.map_end = map.map + map_size;
+
+        for_each_efi_memory_desc(&map, md)
+                if (md->attribute & EFI_MEMORY_WB)
+                        if (membase > md->phys_addr)
+                                membase = md->phys_addr;
+
+        efi_call_early(free_pool, map.map);
+
+        return membase;
+}
+
 /*
  * Allocate at the highest possible address that is not above 'max'.
  */
@@ -267,7 +300,7 @@ static efi_status_t handle_cmdline_files(efi_system_table_t *sys_table_arg,
         struct file_info *files;
         unsigned long file_addr;
         u64 file_size_total;
-        efi_file_handle_t *fh;
+        efi_file_handle_t *fh = NULL;
         efi_status_t status;
         int nr_files;
         char *str;
@@ -310,7 +343,7 @@ static efi_status_t handle_cmdline_files(efi_system_table_t *sys_table_arg,
         status = efi_call_early(allocate_pool, EFI_LOADER_DATA,
                                 nr_files * sizeof(*files), (void **)&files);
         if (status != EFI_SUCCESS) {
-                efi_printk(sys_table_arg, "Failed to alloc mem for file handle list\n");
+                pr_efi_err(sys_table_arg, "Failed to alloc mem for file handle list\n");
                 goto fail;
         }
 
@@ -374,13 +407,13 @@ static efi_status_t handle_cmdline_files(efi_system_table_t *sys_table_arg,
                 status = efi_high_alloc(sys_table_arg, file_size_total, 0x1000,
                                     &file_addr, max_addr);
                 if (status != EFI_SUCCESS) {
-                        efi_printk(sys_table_arg, "Failed to alloc highmem for files\n");
+                        pr_efi_err(sys_table_arg, "Failed to alloc highmem for files\n");
                         goto close_handles;
                 }
 
                 /* We've run out of free low memory. */
                 if (file_addr > max_addr) {
-                        efi_printk(sys_table_arg, "We've run out of free low memory\n");
+                        pr_efi_err(sys_table_arg, "We've run out of free low memory\n");
                         status = EFI_INVALID_PARAMETER;
                         goto free_file_total;
                 }
@@ -401,7 +434,7 @@ static efi_status_t handle_cmdline_files(efi_system_table_t *sys_table_arg,
                                                        &chunksize,
                                                        (void *)addr);
                                 if (status != EFI_SUCCESS) {
-                                        efi_printk(sys_table_arg, "Failed to read file\n");
+                                        pr_efi_err(sys_table_arg, "Failed to read file\n");
                                         goto free_file_total;
                                 }
                                 addr += chunksize;
@@ -486,7 +519,7 @@ static efi_status_t efi_relocate_kernel(efi_system_table_t *sys_table_arg,
                                        &new_addr);
         }
         if (status != EFI_SUCCESS) {
-                efi_printk(sys_table_arg, "ERROR: Failed to allocate usable memory for kernel.\n");
+                pr_efi_err(sys_table_arg, "Failed to allocate usable memory for kernel.\n");
                 return status;
         }
 
@@ -503,62 +536,99 @@ static efi_status_t efi_relocate_kernel(efi_system_table_t *sys_table_arg,
 }
 
 /*
+ * Get the number of UTF-8 bytes corresponding to an UTF-16 character.
+ * This overestimates for surrogates, but that is okay.
+ */
+static int efi_utf8_bytes(u16 c)
+{
+        return 1 + (c >= 0x80) + (c >= 0x800);
+}
+
+/*
+ * Convert an UTF-16 string, not necessarily null terminated, to UTF-8.
+ */
+static u8 *efi_utf16_to_utf8(u8 *dst, const u16 *src, int n)
+{
+        unsigned int c;
+
+        while (n--) {
+                c = *src++;
+                if (n && c >= 0xd800 && c <= 0xdbff &&
+                    *src >= 0xdc00 && *src <= 0xdfff) {
+                        c = 0x10000 + ((c & 0x3ff) << 10) + (*src & 0x3ff);
+                        src++;
+                        n--;
+                }
+                if (c >= 0xd800 && c <= 0xdfff)
+                        c = 0xfffd; /* Unmatched surrogate */
+                if (c < 0x80) {
+                        *dst++ = c;
+                        continue;
+                }
+                if (c < 0x800) {
+                        *dst++ = 0xc0 + (c >> 6);
+                        goto t1;
+                }
+                if (c < 0x10000) {
+                        *dst++ = 0xe0 + (c >> 12);
+                        goto t2;
+                }
+                *dst++ = 0xf0 + (c >> 18);
+                *dst++ = 0x80 + ((c >> 12) & 0x3f);
+        t2:
+                *dst++ = 0x80 + ((c >> 6) & 0x3f);
+        t1:
+                *dst++ = 0x80 + (c & 0x3f);
+        }
+
+        return dst;
+}
+
+/*
  * Convert the unicode UEFI command line to ASCII to pass to kernel.
  * Size of memory allocated return in *cmd_line_len.
  * Returns NULL on error.
  */
-static char *efi_convert_cmdline_to_ascii(efi_system_table_t *sys_table_arg,
-                                      efi_loaded_image_t *image,
-                                      int *cmd_line_len)
+static char *efi_convert_cmdline(efi_system_table_t *sys_table_arg,
+                                 efi_loaded_image_t *image,
+                                 int *cmd_line_len)
 {
-        u16 *s2;
+        const u16 *s2;
         u8 *s1 = NULL;
         unsigned long cmdline_addr = 0;
-        int load_options_size = image->load_options_size / 2; /* ASCII */
-        void *options = image->load_options;
-        int options_size = 0;
+        int load_options_chars = image->load_options_size / 2; /* UTF-16 */
+        const u16 *options = image->load_options;
+        int options_bytes = 0;  /* UTF-8 bytes */
+        int options_chars = 0;  /* UTF-16 chars */
         efi_status_t status;
-        int i;
         u16 zero = 0;
 
         if (options) {
                 s2 = options;
-                while (*s2 && *s2 != '\n' && options_size < load_options_size) {
-                        s2++;
-                        options_size++;
+                while (*s2 && *s2 != '\n'
+                       && options_chars < load_options_chars) {
+                        options_bytes += efi_utf8_bytes(*s2++);
+                        options_chars++;
                 }
         }
 
-        if (options_size == 0) {
+        if (!options_chars) {
                 /* No command line options, so return empty string*/
-                options_size = 1;
                 options = &zero;
         }
 
-        options_size++;  /* NUL termination */
-#ifdef CONFIG_ARM
-        /*
-         * For ARM, allocate at a high address to avoid reserved
-         * regions at low addresses that we don't know the specfics of
-         * at the time we are processing the command line.
-         */
-        status = efi_high_alloc(sys_table_arg, options_size, 0,
-                            &cmdline_addr, 0xfffff000);
-#else
-        status = efi_low_alloc(sys_table_arg, options_size, 0,
-                            &cmdline_addr);
-#endif
+        options_bytes++;        /* NUL termination */
+
+        status = efi_low_alloc(sys_table_arg, options_bytes, 0, &cmdline_addr);
         if (status != EFI_SUCCESS)
                 return NULL;
 
         s1 = (u8 *)cmdline_addr;
-        s2 = (u16 *)options;
-
-        for (i = 0; i < options_size - 1; i++)
-                *s1++ = *s2++;
+        s2 = (const u16 *)options;
 
+        s1 = efi_utf16_to_utf8(s1, s2, options_chars);
         *s1 = '\0';
 
-        *cmd_line_len = options_size;
+        *cmd_line_len = options_bytes;
         return (char *)cmdline_addr;
 }
diff --git a/drivers/firmware/efi/efivars.c b/drivers/firmware/efi/efivars.c
index 50ea412a25e6..463c56545ae8 100644
--- a/drivers/firmware/efi/efivars.c
+++ b/drivers/firmware/efi/efivars.c
@@ -69,6 +69,7 @@
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/ucs2_string.h>
+#include <linux/compat.h>
 
 #define EFIVARS_VERSION "0.08"
 #define EFIVARS_DATE "2004-May-17"
@@ -86,6 +87,15 @@ static struct kset *efivars_kset;
 static struct bin_attribute *efivars_new_var;
 static struct bin_attribute *efivars_del_var;
 
+struct compat_efi_variable {
+        efi_char16_t  VariableName[EFI_VAR_NAME_LEN/sizeof(efi_char16_t)];
+        efi_guid_t    VendorGuid;
+        __u32         DataSize;
+        __u8          Data[1024];
+        __u32         Status;
+        __u32         Attributes;
+} __packed;
+
 struct efivar_attribute {
         struct attribute attr;
         ssize_t (*show) (struct efivar_entry *entry, char *buf);
@@ -189,45 +199,107 @@ efivar_data_read(struct efivar_entry *entry, char *buf)
         memcpy(buf, var->Data, var->DataSize);
         return var->DataSize;
 }
-/*
- * We allow each variable to be edited via rewriting the
- * entire efi variable structure.
- */
-static ssize_t
-efivar_store_raw(struct efivar_entry *entry, const char *buf, size_t count)
-{
-        struct efi_variable *new_var, *var = &entry->var;
-        int err;
 
-        if (count != sizeof(struct efi_variable))
-                return -EINVAL;
-
-        new_var = (struct efi_variable *)buf;
+static inline int
+sanity_check(struct efi_variable *var, efi_char16_t *name, efi_guid_t vendor,
+             unsigned long size, u32 attributes, u8 *data)
+{
         /*
          * If only updating the variable data, then the name
          * and guid should remain the same
          */
-        if (memcmp(new_var->VariableName, var->VariableName, sizeof(var->VariableName)) ||
-                efi_guidcmp(new_var->VendorGuid, var->VendorGuid)) {
+        if (memcmp(name, var->VariableName, sizeof(var->VariableName)) ||
+                efi_guidcmp(vendor, var->VendorGuid)) {
                 printk(KERN_ERR "efivars: Cannot edit the wrong variable!\n");
                 return -EINVAL;
         }
 
-        if ((new_var->DataSize <= 0) || (new_var->Attributes == 0)){
+        if ((size <= 0) || (attributes == 0)){
                 printk(KERN_ERR "efivars: DataSize & Attributes must be valid!\n");
                 return -EINVAL;
         }
 
-        if ((new_var->Attributes & ~EFI_VARIABLE_MASK) != 0 ||
-            efivar_validate(new_var, new_var->Data, new_var->DataSize) == false) {
+        if ((attributes & ~EFI_VARIABLE_MASK) != 0 ||
+            efivar_validate(name, data, size) == false) {
                 printk(KERN_ERR "efivars: Malformed variable content\n");
                 return -EINVAL;
         }
 
-        memcpy(&entry->var, new_var, count);
+        return 0;
+}
+
+static inline bool is_compat(void)
+{
+        if (IS_ENABLED(CONFIG_COMPAT) && is_compat_task())
+                return true;
+
+        return false;
+}
+
+static void
+copy_out_compat(struct efi_variable *dst, struct compat_efi_variable *src)
+{
+        memcpy(dst->VariableName, src->VariableName, EFI_VAR_NAME_LEN);
+        memcpy(dst->Data, src->Data, sizeof(src->Data));
+
+        dst->VendorGuid = src->VendorGuid;
+        dst->DataSize = src->DataSize;
+        dst->Attributes = src->Attributes;
+}
+
+/*
+ * We allow each variable to be edited via rewriting the
+ * entire efi variable structure.
+ */
+static ssize_t
+efivar_store_raw(struct efivar_entry *entry, const char *buf, size_t count)
+{
+        struct efi_variable *new_var, *var = &entry->var;
+        efi_char16_t *name;
+        unsigned long size;
+        efi_guid_t vendor;
+        u32 attributes;
+        u8 *data;
+        int err;
+
+        if (is_compat()) {
+                struct compat_efi_variable *compat;
+
+                if (count != sizeof(*compat))
+                        return -EINVAL;
+
+                compat = (struct compat_efi_variable *)buf;
+                attributes = compat->Attributes;
+                vendor = compat->VendorGuid;
+                name = compat->VariableName;
+                size = compat->DataSize;
+                data = compat->Data;
+
+                err = sanity_check(var, name, vendor, size, attributes, data);
+                if (err)
+                        return err;
+
+                copy_out_compat(&entry->var, compat);
+        } else {
+                if (count != sizeof(struct efi_variable))
+                        return -EINVAL;
+
+                new_var = (struct efi_variable *)buf;
 
-        err = efivar_entry_set(entry, new_var->Attributes,
-                               new_var->DataSize, new_var->Data, NULL);
+                attributes = new_var->Attributes;
+                vendor = new_var->VendorGuid;
+                name = new_var->VariableName;
+                size = new_var->DataSize;
+                data = new_var->Data;
+
+                err = sanity_check(var, name, vendor, size, attributes, data);
+                if (err)
+                        return err;
+
+                memcpy(&entry->var, new_var, count);
+        }
+
+        err = efivar_entry_set(entry, attributes, size, data, NULL);
         if (err) {
                 printk(KERN_WARNING "efivars: set_variable() failed: status=%d\n", err);
                 return -EIO;
@@ -240,6 +312,8 @@ static ssize_t
 efivar_show_raw(struct efivar_entry *entry, char *buf)
 {
         struct efi_variable *var = &entry->var;
+        struct compat_efi_variable *compat;
+        size_t size;
 
         if (!entry || !buf)
                 return 0;
@@ -249,9 +323,23 @@ efivar_show_raw(struct efivar_entry *entry, char *buf)
                              &entry->var.DataSize, entry->var.Data))
                 return -EIO;
 
-        memcpy(buf, var, sizeof(*var));
+        if (is_compat()) {
+                compat = (struct compat_efi_variable *)buf;
+
+                size = sizeof(*compat);
+                memcpy(compat->VariableName, var->VariableName,
+                        EFI_VAR_NAME_LEN);
+                memcpy(compat->Data, var->Data, sizeof(compat->Data));
+
+                compat->VendorGuid = var->VendorGuid;
+                compat->DataSize = var->DataSize;
+                compat->Attributes = var->Attributes;
+        } else {
+                size = sizeof(*var);
+                memcpy(buf, var, size);
+        }
 
-        return sizeof(*var);
+        return size;
 }
 
 /*
@@ -326,15 +414,39 @@ static ssize_t efivar_create(struct file *filp, struct kobject *kobj,
                              struct bin_attribute *bin_attr,
                              char *buf, loff_t pos, size_t count)
 {
+        struct compat_efi_variable *compat = (struct compat_efi_variable *)buf;
         struct efi_variable *new_var = (struct efi_variable *)buf;
         struct efivar_entry *new_entry;
+        bool need_compat = is_compat();
+        efi_char16_t *name;
+        unsigned long size;
+        u32 attributes;
+        u8 *data;
         int err;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
 
-        if ((new_var->Attributes & ~EFI_VARIABLE_MASK) != 0 ||
-            efivar_validate(new_var, new_var->Data, new_var->DataSize) == false) {
+        if (need_compat) {
+                if (count != sizeof(*compat))
+                        return -EINVAL;
+
+                attributes = compat->Attributes;
+                name = compat->VariableName;
+                size = compat->DataSize;
+                data = compat->Data;
+        } else {
+                if (count != sizeof(*new_var))
+                        return -EINVAL;
+
+                attributes = new_var->Attributes;
+                name = new_var->VariableName;
+                size = new_var->DataSize;
+                data = new_var->Data;
+        }
+
+        if ((attributes & ~EFI_VARIABLE_MASK) != 0 ||
+            efivar_validate(name, data, size) == false) {
                 printk(KERN_ERR "efivars: Malformed variable content\n");
                 return -EINVAL;
         }
@@ -343,10 +455,13 @@ static ssize_t efivar_create(struct file *filp, struct kobject *kobj,
         if (!new_entry)
                 return -ENOMEM;
 
-        memcpy(&new_entry->var, new_var, sizeof(*new_var));
+        if (need_compat)
+                copy_out_compat(&new_entry->var, compat);
+        else
+                memcpy(&new_entry->var, new_var, sizeof(*new_var));
 
-        err = efivar_entry_set(new_entry, new_var->Attributes, new_var->DataSize,
-                               new_var->Data, &efivar_sysfs_list);
+        err = efivar_entry_set(new_entry, attributes, size,
+                               data, &efivar_sysfs_list);
         if (err) {
                 if (err == -EEXIST)
                         err = -EINVAL;
@@ -369,15 +484,32 @@ static ssize_t efivar_delete(struct file *filp, struct kobject *kobj,
                              char *buf, loff_t pos, size_t count)
 {
         struct efi_variable *del_var = (struct efi_variable *)buf;
+        struct compat_efi_variable *compat;
         struct efivar_entry *entry;
+        efi_char16_t *name;
+        efi_guid_t vendor;
         int err = 0;
 
         if (!capable(CAP_SYS_ADMIN))
                 return -EACCES;
 
+        if (is_compat()) {
+                if (count != sizeof(*compat))
+                        return -EINVAL;
+
+                compat = (struct compat_efi_variable *)buf;
+                name = compat->VariableName;
+                vendor = compat->VendorGuid;
+        } else {
+                if (count != sizeof(*del_var))
+                        return -EINVAL;
+
+                name = del_var->VariableName;
+                vendor = del_var->VendorGuid;
+        }
+
         efivar_entry_iter_begin();
-        entry = efivar_entry_find(del_var->VariableName, del_var->VendorGuid,
-                                  &efivar_sysfs_list, true);
+        entry = efivar_entry_find(name, vendor, &efivar_sysfs_list, true);
         if (!entry)
                 err = -EINVAL;
         else if (__efivar_entry_delete(entry))
diff --git a/drivers/firmware/efi/vars.c b/drivers/firmware/efi/vars.c
index b22659cccca4..f0a43646a2f3 100644
--- a/drivers/firmware/efi/vars.c
+++ b/drivers/firmware/efi/vars.c
@@ -42,7 +42,7 @@ DECLARE_WORK(efivar_work, NULL);
 EXPORT_SYMBOL_GPL(efivar_work);
 
 static bool
-validate_device_path(struct efi_variable *var, int match, u8 *buffer,
+validate_device_path(efi_char16_t *var_name, int match, u8 *buffer,
                      unsigned long len)
 {
         struct efi_generic_dev_path *node;
@@ -75,7 +75,7 @@ validate_device_path(struct efi_variable *var, int match, u8 *buffer,
 }
 
 static bool
-validate_boot_order(struct efi_variable *var, int match, u8 *buffer,
+validate_boot_order(efi_char16_t *var_name, int match, u8 *buffer,
                     unsigned long len)
 {
         /* An array of 16-bit integers */
@@ -86,18 +86,18 @@ validate_boot_order(struct efi_variable *var, int match, u8 *buffer,
 }
 
 static bool
-validate_load_option(struct efi_variable *var, int match, u8 *buffer,
+validate_load_option(efi_char16_t *var_name, int match, u8 *buffer,
                      unsigned long len)
 {
         u16 filepathlength;
         int i, desclength = 0, namelen;
 
-        namelen = ucs2_strnlen(var->VariableName, sizeof(var->VariableName));
+        namelen = ucs2_strnlen(var_name, EFI_VAR_NAME_LEN);
 
         /* Either "Boot" or "Driver" followed by four digits of hex */
         for (i = match; i < match+4; i++) {
-                if (var->VariableName[i] > 127 ||
-                    hex_to_bin(var->VariableName[i] & 0xff) < 0)
+                if (var_name[i] > 127 ||
+                    hex_to_bin(var_name[i] & 0xff) < 0)
                         return true;
         }
 
@@ -132,12 +132,12 @@ validate_load_option(struct efi_variable *var, int match, u8 *buffer,
         /*
          * And, finally, check the filepath
          */
-        return validate_device_path(var, match, buffer + desclength + 6,
+        return validate_device_path(var_name, match, buffer + desclength + 6,
                                     filepathlength);
 }
 
 static bool
-validate_uint16(struct efi_variable *var, int match, u8 *buffer,
+validate_uint16(efi_char16_t *var_name, int match, u8 *buffer,
                 unsigned long len)
 {
         /* A single 16-bit integer */
@@ -148,7 +148,7 @@ validate_uint16(struct efi_variable *var, int match, u8 *buffer,
 }
 
 static bool
-validate_ascii_string(struct efi_variable *var, int match, u8 *buffer,
+validate_ascii_string(efi_char16_t *var_name, int match, u8 *buffer,
                       unsigned long len)
 {
         int i;
@@ -166,7 +166,7 @@ validate_ascii_string(struct efi_variable *var, int match, u8 *buffer,
 
 struct variable_validate {
         char *name;
-        bool (*validate)(struct efi_variable *var, int match, u8 *data,
+        bool (*validate)(efi_char16_t *var_name, int match, u8 *data,
                          unsigned long len);
 };
 
@@ -189,10 +189,10 @@ static const struct variable_validate variable_validate[] = {
 };
 
 bool
-efivar_validate(struct efi_variable *var, u8 *data, unsigned long len)
+efivar_validate(efi_char16_t *var_name, u8 *data, unsigned long len)
 {
         int i;
-        u16 *unicode_name = var->VariableName;
+        u16 *unicode_name = var_name;
 
         for (i = 0; variable_validate[i].validate != NULL; i++) {
                 const char *name = variable_validate[i].name;
@@ -208,7 +208,7 @@ efivar_validate(struct efi_variable *var, u8 *data, unsigned long len)
 
                         /* Wildcard in the matching name means we've matched */
                         if (c == '*')
-                                return variable_validate[i].validate(var,
+                                return variable_validate[i].validate(var_name,
                                                              match, data, len);
 
                         /* Case sensitive match */
@@ -217,7 +217,7 @@ efivar_validate(struct efi_variable *var, u8 *data, unsigned long len)
 
                         /* Reached the end of the string while matching */
                         if (!c)
-                                return variable_validate[i].validate(var,
+                                return variable_validate[i].validate(var_name,
                                                              match, data, len);
                 }
         }
@@ -805,7 +805,7 @@ int efivar_entry_set_get_size(struct efivar_entry *entry, u32 attributes,
 
         *set = false;
 
-        if (efivar_validate(&entry->var, data, *size) == false)
+        if (efivar_validate(name, data, *size) == false)
                 return -EINVAL;
 
         /*