2 * Originally from efivars.c
4 * Copyright (C) 2001,2003,2004 Dell <Matt_Domsch@dell.com>
5 * Copyright (C) 2004 Intel Corporation <matthew.e.tolentino@intel.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/capability.h>
23 #include <linux/types.h>
24 #include <linux/errno.h>
25 #include <linux/init.h>
27 #include <linux/module.h>
28 #include <linux/string.h>
29 #include <linux/smp.h>
30 #include <linux/efi.h>
31 #include <linux/sysfs.h>
32 #include <linux/device.h>
33 #include <linux/slab.h>
34 #include <linux/ctype.h>
35 #include <linux/ucs2_string.h>
37 /* Private pointer to registered efivars */
38 static struct efivars
*__efivars
;
40 static bool efivar_wq_enabled
= true;
41 DECLARE_WORK(efivar_work
, NULL
);
42 EXPORT_SYMBOL_GPL(efivar_work
);
45 validate_device_path(efi_char16_t
*var_name
, int match
, u8
*buffer
,
48 struct efi_generic_dev_path
*node
;
51 node
= (struct efi_generic_dev_path
*)buffer
;
53 if (len
< sizeof(*node
))
56 while (offset
<= len
- sizeof(*node
) &&
57 node
->length
>= sizeof(*node
) &&
58 node
->length
<= len
- offset
) {
59 offset
+= node
->length
;
61 if ((node
->type
== EFI_DEV_END_PATH
||
62 node
->type
== EFI_DEV_END_PATH2
) &&
63 node
->sub_type
== EFI_DEV_END_ENTIRE
)
66 node
= (struct efi_generic_dev_path
*)(buffer
+ offset
);
70 * If we're here then either node->length pointed past the end
71 * of the buffer or we reached the end of the buffer without
72 * finding a device path end node.
78 validate_boot_order(efi_char16_t
*var_name
, int match
, u8
*buffer
,
81 /* An array of 16-bit integers */
89 validate_load_option(efi_char16_t
*var_name
, int match
, u8
*buffer
,
93 int i
, desclength
= 0, namelen
;
95 namelen
= ucs2_strnlen(var_name
, EFI_VAR_NAME_LEN
);
97 /* Either "Boot" or "Driver" followed by four digits of hex */
98 for (i
= match
; i
< match
+4; i
++) {
99 if (var_name
[i
] > 127 ||
100 hex_to_bin(var_name
[i
] & 0xff) < 0)
104 /* Reject it if there's 4 digits of hex and then further content */
105 if (namelen
> match
+ 4)
108 /* A valid entry must be at least 8 bytes */
112 filepathlength
= buffer
[4] | buffer
[5] << 8;
115 * There's no stored length for the description, so it has to be
118 desclength
= ucs2_strsize((efi_char16_t
*)(buffer
+ 6), len
- 6) + 2;
120 /* Each boot entry must have a descriptor */
125 * If the sum of the length of the description, the claimed filepath
126 * length and the original header are greater than the length of the
127 * variable, it's malformed
129 if ((desclength
+ filepathlength
+ 6) > len
)
133 * And, finally, check the filepath
135 return validate_device_path(var_name
, match
, buffer
+ desclength
+ 6,
140 validate_uint16(efi_char16_t
*var_name
, int match
, u8
*buffer
,
143 /* A single 16-bit integer */
151 validate_ascii_string(efi_char16_t
*var_name
, int match
, u8
*buffer
,
156 for (i
= 0; i
< len
; i
++) {
167 struct variable_validate
{
170 bool (*validate
)(efi_char16_t
*var_name
, int match
, u8
*data
,
175 * This is the list of variables we need to validate, as well as the
176 * whitelist for what we think is safe not to default to immutable.
178 * If it has a validate() method that's not NULL, it'll go into the
179 * validation routine. If not, it is assumed valid, but still used for
182 * Note that it's sorted by {vendor,name}, but globbed names must come after
183 * any other name with the same prefix.
185 static const struct variable_validate variable_validate
[] = {
186 { EFI_GLOBAL_VARIABLE_GUID
, "BootNext", validate_uint16
},
187 { EFI_GLOBAL_VARIABLE_GUID
, "BootOrder", validate_boot_order
},
188 { EFI_GLOBAL_VARIABLE_GUID
, "Boot*", validate_load_option
},
189 { EFI_GLOBAL_VARIABLE_GUID
, "DriverOrder", validate_boot_order
},
190 { EFI_GLOBAL_VARIABLE_GUID
, "Driver*", validate_load_option
},
191 { EFI_GLOBAL_VARIABLE_GUID
, "ConIn", validate_device_path
},
192 { EFI_GLOBAL_VARIABLE_GUID
, "ConInDev", validate_device_path
},
193 { EFI_GLOBAL_VARIABLE_GUID
, "ConOut", validate_device_path
},
194 { EFI_GLOBAL_VARIABLE_GUID
, "ConOutDev", validate_device_path
},
195 { EFI_GLOBAL_VARIABLE_GUID
, "ErrOut", validate_device_path
},
196 { EFI_GLOBAL_VARIABLE_GUID
, "ErrOutDev", validate_device_path
},
197 { EFI_GLOBAL_VARIABLE_GUID
, "Lang", validate_ascii_string
},
198 { EFI_GLOBAL_VARIABLE_GUID
, "OsIndications", NULL
},
199 { EFI_GLOBAL_VARIABLE_GUID
, "PlatformLang", validate_ascii_string
},
200 { EFI_GLOBAL_VARIABLE_GUID
, "Timeout", validate_uint16
},
201 { NULL_GUID
, "", NULL
},
205 variable_matches(const char *var_name
, size_t len
, const char *match_name
,
208 for (*match
= 0; ; (*match
)++) {
209 char c
= match_name
[*match
];
210 char u
= var_name
[*match
];
212 /* Wildcard in the matching name means we've matched */
216 /* Case sensitive match */
217 if (!c
&& *match
== len
)
230 efivar_validate(efi_guid_t vendor
, efi_char16_t
*var_name
, u8
*data
,
231 unsigned long data_size
)
234 unsigned long utf8_size
;
237 utf8_size
= ucs2_utf8size(var_name
);
238 utf8_name
= kmalloc(utf8_size
+ 1, GFP_KERNEL
);
242 ucs2_as_utf8(utf8_name
, var_name
, utf8_size
);
243 utf8_name
[utf8_size
] = '\0';
245 for (i
= 0; variable_validate
[i
].name
[0] != '\0'; i
++) {
246 const char *name
= variable_validate
[i
].name
;
249 if (efi_guidcmp(vendor
, variable_validate
[i
].vendor
))
252 if (variable_matches(utf8_name
, utf8_size
+1, name
, &match
)) {
253 if (variable_validate
[i
].validate
== NULL
)
256 return variable_validate
[i
].validate(var_name
, match
,
263 EXPORT_SYMBOL_GPL(efivar_validate
);
266 efivar_variable_is_removable(efi_guid_t vendor
, const char *var_name
,
274 * Check if our variable is in the validated variables list
276 for (i
= 0; variable_validate
[i
].name
[0] != '\0'; i
++) {
277 if (efi_guidcmp(variable_validate
[i
].vendor
, vendor
))
280 if (variable_matches(var_name
, len
,
281 variable_validate
[i
].name
, &match
)) {
288 * If it's in our list, it is removable.
292 EXPORT_SYMBOL_GPL(efivar_variable_is_removable
);
295 check_var_size(u32 attributes
, unsigned long size
)
297 const struct efivar_operations
*fops
= __efivars
->ops
;
299 if (!fops
->query_variable_store
)
300 return EFI_UNSUPPORTED
;
302 return fops
->query_variable_store(attributes
, size
);
305 static int efi_status_to_err(efi_status_t status
)
313 case EFI_INVALID_PARAMETER
:
316 case EFI_OUT_OF_RESOURCES
:
319 case EFI_DEVICE_ERROR
:
322 case EFI_WRITE_PROTECTED
:
325 case EFI_SECURITY_VIOLATION
:
338 static bool variable_is_present(efi_char16_t
*variable_name
, efi_guid_t
*vendor
,
339 struct list_head
*head
)
341 struct efivar_entry
*entry
, *n
;
342 unsigned long strsize1
, strsize2
;
345 strsize1
= ucs2_strsize(variable_name
, 1024);
346 list_for_each_entry_safe(entry
, n
, head
, list
) {
347 strsize2
= ucs2_strsize(entry
->var
.VariableName
, 1024);
348 if (strsize1
== strsize2
&&
349 !memcmp(variable_name
, &(entry
->var
.VariableName
),
351 !efi_guidcmp(entry
->var
.VendorGuid
,
361 * Returns the size of variable_name, in bytes, including the
362 * terminating NULL character, or variable_name_size if no NULL
363 * character is found among the first variable_name_size bytes.
365 static unsigned long var_name_strnsize(efi_char16_t
*variable_name
,
366 unsigned long variable_name_size
)
372 * The variable name is, by definition, a NULL-terminated
373 * string, so make absolutely sure that variable_name_size is
374 * the value we expect it to be. If not, return the real size.
376 for (len
= 2; len
<= variable_name_size
; len
+= sizeof(c
)) {
377 c
= variable_name
[(len
/ sizeof(c
)) - 1];
382 return min(len
, variable_name_size
);
386 * Print a warning when duplicate EFI variables are encountered and
387 * disable the sysfs workqueue since the firmware is buggy.
389 static void dup_variable_bug(efi_char16_t
*s16
, efi_guid_t
*vendor_guid
,
392 size_t i
, len8
= len16
/ sizeof(efi_char16_t
);
396 * Disable the workqueue since the algorithm it uses for
397 * detecting new variables won't work with this buggy
398 * implementation of GetNextVariableName().
400 efivar_wq_enabled
= false;
402 s8
= kzalloc(len8
, GFP_KERNEL
);
406 for (i
= 0; i
< len8
; i
++)
409 printk(KERN_WARNING
"efivars: duplicate variable: %s-%pUl\n",
415 * efivar_init - build the initial list of EFI variables
416 * @func: callback function to invoke for every variable
417 * @data: function-specific data to pass to @func
418 * @atomic: do we need to execute the @func-loop atomically?
419 * @duplicates: error if we encounter duplicates on @head?
420 * @head: initialised head of variable list
422 * Get every EFI variable from the firmware and invoke @func. @func
423 * should call efivar_entry_add() to build the list of variables.
425 * Returns 0 on success, or a kernel error code on failure.
427 int efivar_init(int (*func
)(efi_char16_t
*, efi_guid_t
, unsigned long, void *),
428 void *data
, bool atomic
, bool duplicates
,
429 struct list_head
*head
)
431 const struct efivar_operations
*ops
= __efivars
->ops
;
432 unsigned long variable_name_size
= 1024;
433 efi_char16_t
*variable_name
;
435 efi_guid_t vendor_guid
;
438 variable_name
= kzalloc(variable_name_size
, GFP_KERNEL
);
439 if (!variable_name
) {
440 printk(KERN_ERR
"efivars: Memory allocation failed.\n");
444 spin_lock_irq(&__efivars
->lock
);
447 * Per EFI spec, the maximum storage allocated for both
448 * the variable name and variable data is 1024 bytes.
452 variable_name_size
= 1024;
454 status
= ops
->get_next_variable(&variable_name_size
,
460 spin_unlock_irq(&__efivars
->lock
);
462 variable_name_size
= var_name_strnsize(variable_name
,
466 * Some firmware implementations return the
467 * same variable name on multiple calls to
468 * get_next_variable(). Terminate the loop
469 * immediately as there is no guarantee that
470 * we'll ever see a different variable name,
471 * and may end up looping here forever.
474 variable_is_present(variable_name
, &vendor_guid
, head
)) {
475 dup_variable_bug(variable_name
, &vendor_guid
,
478 spin_lock_irq(&__efivars
->lock
);
480 status
= EFI_NOT_FOUND
;
484 err
= func(variable_name
, vendor_guid
, variable_name_size
, data
);
486 status
= EFI_NOT_FOUND
;
489 spin_lock_irq(&__efivars
->lock
);
495 printk(KERN_WARNING
"efivars: get_next_variable: status=%lx\n",
497 status
= EFI_NOT_FOUND
;
501 } while (status
!= EFI_NOT_FOUND
);
503 spin_unlock_irq(&__efivars
->lock
);
505 kfree(variable_name
);
509 EXPORT_SYMBOL_GPL(efivar_init
);
512 * efivar_entry_add - add entry to variable list
513 * @entry: entry to add to list
516 void efivar_entry_add(struct efivar_entry
*entry
, struct list_head
*head
)
518 spin_lock_irq(&__efivars
->lock
);
519 list_add(&entry
->list
, head
);
520 spin_unlock_irq(&__efivars
->lock
);
522 EXPORT_SYMBOL_GPL(efivar_entry_add
);
525 * efivar_entry_remove - remove entry from variable list
526 * @entry: entry to remove from list
528 void efivar_entry_remove(struct efivar_entry
*entry
)
530 spin_lock_irq(&__efivars
->lock
);
531 list_del(&entry
->list
);
532 spin_unlock_irq(&__efivars
->lock
);
534 EXPORT_SYMBOL_GPL(efivar_entry_remove
);
537 * efivar_entry_list_del_unlock - remove entry from variable list
538 * @entry: entry to remove
540 * Remove @entry from the variable list and release the list lock.
542 * NOTE: slightly weird locking semantics here - we expect to be
543 * called with the efivars lock already held, and we release it before
544 * returning. This is because this function is usually called after
545 * set_variable() while the lock is still held.
547 static void efivar_entry_list_del_unlock(struct efivar_entry
*entry
)
549 lockdep_assert_held(&__efivars
->lock
);
551 list_del(&entry
->list
);
552 spin_unlock_irq(&__efivars
->lock
);
556 * __efivar_entry_delete - delete an EFI variable
557 * @entry: entry containing EFI variable to delete
559 * Delete the variable from the firmware but leave @entry on the
562 * This function differs from efivar_entry_delete() because it does
563 * not remove @entry from the variable list. Also, it is safe to be
564 * called from within a efivar_entry_iter_begin() and
565 * efivar_entry_iter_end() region, unlike efivar_entry_delete().
567 * Returns 0 on success, or a converted EFI status code if
568 * set_variable() fails.
570 int __efivar_entry_delete(struct efivar_entry
*entry
)
572 const struct efivar_operations
*ops
= __efivars
->ops
;
575 lockdep_assert_held(&__efivars
->lock
);
577 status
= ops
->set_variable(entry
->var
.VariableName
,
578 &entry
->var
.VendorGuid
,
581 return efi_status_to_err(status
);
583 EXPORT_SYMBOL_GPL(__efivar_entry_delete
);
586 * efivar_entry_delete - delete variable and remove entry from list
587 * @entry: entry containing variable to delete
589 * Delete the variable from the firmware and remove @entry from the
590 * variable list. It is the caller's responsibility to free @entry
593 * Returns 0 on success, or a converted EFI status code if
594 * set_variable() fails.
596 int efivar_entry_delete(struct efivar_entry
*entry
)
598 const struct efivar_operations
*ops
= __efivars
->ops
;
601 spin_lock_irq(&__efivars
->lock
);
602 status
= ops
->set_variable(entry
->var
.VariableName
,
603 &entry
->var
.VendorGuid
,
605 if (!(status
== EFI_SUCCESS
|| status
== EFI_NOT_FOUND
)) {
606 spin_unlock_irq(&__efivars
->lock
);
607 return efi_status_to_err(status
);
610 efivar_entry_list_del_unlock(entry
);
613 EXPORT_SYMBOL_GPL(efivar_entry_delete
);
616 * efivar_entry_set - call set_variable()
617 * @entry: entry containing the EFI variable to write
618 * @attributes: variable attributes
619 * @size: size of @data buffer
620 * @data: buffer containing variable data
621 * @head: head of variable list
623 * Calls set_variable() for an EFI variable. If creating a new EFI
624 * variable, this function is usually followed by efivar_entry_add().
626 * Before writing the variable, the remaining EFI variable storage
627 * space is checked to ensure there is enough room available.
629 * If @head is not NULL a lookup is performed to determine whether
630 * the entry is already on the list.
632 * Returns 0 on success, -EEXIST if a lookup is performed and the entry
633 * already exists on the list, or a converted EFI status code if
634 * set_variable() fails.
636 int efivar_entry_set(struct efivar_entry
*entry
, u32 attributes
,
637 unsigned long size
, void *data
, struct list_head
*head
)
639 const struct efivar_operations
*ops
= __efivars
->ops
;
641 efi_char16_t
*name
= entry
->var
.VariableName
;
642 efi_guid_t vendor
= entry
->var
.VendorGuid
;
644 spin_lock_irq(&__efivars
->lock
);
646 if (head
&& efivar_entry_find(name
, vendor
, head
, false)) {
647 spin_unlock_irq(&__efivars
->lock
);
651 status
= check_var_size(attributes
, size
+ ucs2_strsize(name
, 1024));
652 if (status
== EFI_SUCCESS
|| status
== EFI_UNSUPPORTED
)
653 status
= ops
->set_variable(name
, &vendor
,
654 attributes
, size
, data
);
656 spin_unlock_irq(&__efivars
->lock
);
658 return efi_status_to_err(status
);
661 EXPORT_SYMBOL_GPL(efivar_entry_set
);
664 * efivar_entry_set_safe - call set_variable() if enough space in firmware
665 * @name: buffer containing the variable name
666 * @vendor: variable vendor guid
667 * @attributes: variable attributes
668 * @block: can we block in this context?
669 * @size: size of @data buffer
670 * @data: buffer containing variable data
672 * Ensures there is enough free storage in the firmware for this variable, and
673 * if so, calls set_variable(). If creating a new EFI variable, this function
674 * is usually followed by efivar_entry_add().
676 * Returns 0 on success, -ENOSPC if the firmware does not have enough
677 * space for set_variable() to succeed, or a converted EFI status code
678 * if set_variable() fails.
680 int efivar_entry_set_safe(efi_char16_t
*name
, efi_guid_t vendor
, u32 attributes
,
681 bool block
, unsigned long size
, void *data
)
683 const struct efivar_operations
*ops
= __efivars
->ops
;
687 if (!ops
->query_variable_store
)
691 if (!spin_trylock_irqsave(&__efivars
->lock
, flags
))
694 spin_lock_irqsave(&__efivars
->lock
, flags
);
697 status
= check_var_size(attributes
, size
+ ucs2_strsize(name
, 1024));
698 if (status
!= EFI_SUCCESS
) {
699 spin_unlock_irqrestore(&__efivars
->lock
, flags
);
703 status
= ops
->set_variable(name
, &vendor
, attributes
, size
, data
);
705 spin_unlock_irqrestore(&__efivars
->lock
, flags
);
707 return efi_status_to_err(status
);
709 EXPORT_SYMBOL_GPL(efivar_entry_set_safe
);
712 * efivar_entry_find - search for an entry
713 * @name: the EFI variable name
714 * @guid: the EFI variable vendor's guid
715 * @head: head of the variable list
716 * @remove: should we remove the entry from the list?
718 * Search for an entry on the variable list that has the EFI variable
719 * name @name and vendor guid @guid. If an entry is found on the list
720 * and @remove is true, the entry is removed from the list.
722 * The caller MUST call efivar_entry_iter_begin() and
723 * efivar_entry_iter_end() before and after the invocation of this
724 * function, respectively.
726 * Returns the entry if found on the list, %NULL otherwise.
728 struct efivar_entry
*efivar_entry_find(efi_char16_t
*name
, efi_guid_t guid
,
729 struct list_head
*head
, bool remove
)
731 struct efivar_entry
*entry
, *n
;
732 int strsize1
, strsize2
;
735 lockdep_assert_held(&__efivars
->lock
);
737 list_for_each_entry_safe(entry
, n
, head
, list
) {
738 strsize1
= ucs2_strsize(name
, 1024);
739 strsize2
= ucs2_strsize(entry
->var
.VariableName
, 1024);
740 if (strsize1
== strsize2
&&
741 !memcmp(name
, &(entry
->var
.VariableName
), strsize1
) &&
742 !efi_guidcmp(guid
, entry
->var
.VendorGuid
)) {
752 list_del(&entry
->list
);
756 EXPORT_SYMBOL_GPL(efivar_entry_find
);
759 * efivar_entry_size - obtain the size of a variable
760 * @entry: entry for this variable
761 * @size: location to store the variable's size
763 int efivar_entry_size(struct efivar_entry
*entry
, unsigned long *size
)
765 const struct efivar_operations
*ops
= __efivars
->ops
;
770 spin_lock_irq(&__efivars
->lock
);
771 status
= ops
->get_variable(entry
->var
.VariableName
,
772 &entry
->var
.VendorGuid
, NULL
, size
, NULL
);
773 spin_unlock_irq(&__efivars
->lock
);
775 if (status
!= EFI_BUFFER_TOO_SMALL
)
776 return efi_status_to_err(status
);
780 EXPORT_SYMBOL_GPL(efivar_entry_size
);
783 * __efivar_entry_get - call get_variable()
784 * @entry: read data for this variable
785 * @attributes: variable attributes
786 * @size: size of @data buffer
787 * @data: buffer to store variable data
789 * The caller MUST call efivar_entry_iter_begin() and
790 * efivar_entry_iter_end() before and after the invocation of this
791 * function, respectively.
793 int __efivar_entry_get(struct efivar_entry
*entry
, u32
*attributes
,
794 unsigned long *size
, void *data
)
796 const struct efivar_operations
*ops
= __efivars
->ops
;
799 lockdep_assert_held(&__efivars
->lock
);
801 status
= ops
->get_variable(entry
->var
.VariableName
,
802 &entry
->var
.VendorGuid
,
803 attributes
, size
, data
);
805 return efi_status_to_err(status
);
807 EXPORT_SYMBOL_GPL(__efivar_entry_get
);
810 * efivar_entry_get - call get_variable()
811 * @entry: read data for this variable
812 * @attributes: variable attributes
813 * @size: size of @data buffer
814 * @data: buffer to store variable data
816 int efivar_entry_get(struct efivar_entry
*entry
, u32
*attributes
,
817 unsigned long *size
, void *data
)
819 const struct efivar_operations
*ops
= __efivars
->ops
;
822 spin_lock_irq(&__efivars
->lock
);
823 status
= ops
->get_variable(entry
->var
.VariableName
,
824 &entry
->var
.VendorGuid
,
825 attributes
, size
, data
);
826 spin_unlock_irq(&__efivars
->lock
);
828 return efi_status_to_err(status
);
830 EXPORT_SYMBOL_GPL(efivar_entry_get
);
833 * efivar_entry_set_get_size - call set_variable() and get new size (atomic)
834 * @entry: entry containing variable to set and get
835 * @attributes: attributes of variable to be written
836 * @size: size of data buffer
837 * @data: buffer containing data to write
838 * @set: did the set_variable() call succeed?
840 * This is a pretty special (complex) function. See efivarfs_file_write().
842 * Atomically call set_variable() for @entry and if the call is
843 * successful, return the new size of the variable from get_variable()
844 * in @size. The success of set_variable() is indicated by @set.
846 * Returns 0 on success, -EINVAL if the variable data is invalid,
847 * -ENOSPC if the firmware does not have enough available space, or a
848 * converted EFI status code if either of set_variable() or
849 * get_variable() fail.
851 * If the EFI variable does not exist when calling set_variable()
852 * (EFI_NOT_FOUND), @entry is removed from the variable list.
854 int efivar_entry_set_get_size(struct efivar_entry
*entry
, u32 attributes
,
855 unsigned long *size
, void *data
, bool *set
)
857 const struct efivar_operations
*ops
= __efivars
->ops
;
858 efi_char16_t
*name
= entry
->var
.VariableName
;
859 efi_guid_t
*vendor
= &entry
->var
.VendorGuid
;
865 if (efivar_validate(*vendor
, name
, data
, *size
) == false)
869 * The lock here protects the get_variable call, the conditional
870 * set_variable call, and removal of the variable from the efivars
871 * list (in the case of an authenticated delete).
873 spin_lock_irq(&__efivars
->lock
);
876 * Ensure that the available space hasn't shrunk below the safe level
878 status
= check_var_size(attributes
, *size
+ ucs2_strsize(name
, 1024));
879 if (status
!= EFI_SUCCESS
) {
880 if (status
!= EFI_UNSUPPORTED
) {
881 err
= efi_status_to_err(status
);
891 status
= ops
->set_variable(name
, vendor
, attributes
, *size
, data
);
892 if (status
!= EFI_SUCCESS
) {
893 err
= efi_status_to_err(status
);
900 * Writing to the variable may have caused a change in size (which
901 * could either be an append or an overwrite), or the variable to be
902 * deleted. Perform a GetVariable() so we can tell what actually
906 status
= ops
->get_variable(entry
->var
.VariableName
,
907 &entry
->var
.VendorGuid
,
910 if (status
== EFI_NOT_FOUND
)
911 efivar_entry_list_del_unlock(entry
);
913 spin_unlock_irq(&__efivars
->lock
);
915 if (status
&& status
!= EFI_BUFFER_TOO_SMALL
)
916 return efi_status_to_err(status
);
921 spin_unlock_irq(&__efivars
->lock
);
925 EXPORT_SYMBOL_GPL(efivar_entry_set_get_size
);
928 * efivar_entry_iter_begin - begin iterating the variable list
930 * Lock the variable list to prevent entry insertion and removal until
931 * efivar_entry_iter_end() is called. This function is usually used in
932 * conjunction with __efivar_entry_iter() or efivar_entry_iter().
934 void efivar_entry_iter_begin(void)
936 spin_lock_irq(&__efivars
->lock
);
938 EXPORT_SYMBOL_GPL(efivar_entry_iter_begin
);
941 * efivar_entry_iter_end - finish iterating the variable list
943 * Unlock the variable list and allow modifications to the list again.
945 void efivar_entry_iter_end(void)
947 spin_unlock_irq(&__efivars
->lock
);
949 EXPORT_SYMBOL_GPL(efivar_entry_iter_end
);
952 * __efivar_entry_iter - iterate over variable list
953 * @func: callback function
954 * @head: head of the variable list
955 * @data: function-specific data to pass to callback
956 * @prev: entry to begin iterating from
958 * Iterate over the list of EFI variables and call @func with every
959 * entry on the list. It is safe for @func to remove entries in the
960 * list via efivar_entry_delete().
962 * You MUST call efivar_enter_iter_begin() before this function, and
963 * efivar_entry_iter_end() afterwards.
965 * It is possible to begin iteration from an arbitrary entry within
966 * the list by passing @prev. @prev is updated on return to point to
967 * the last entry passed to @func. To begin iterating from the
968 * beginning of the list @prev must be %NULL.
970 * The restrictions for @func are the same as documented for
971 * efivar_entry_iter().
973 int __efivar_entry_iter(int (*func
)(struct efivar_entry
*, void *),
974 struct list_head
*head
, void *data
,
975 struct efivar_entry
**prev
)
977 struct efivar_entry
*entry
, *n
;
980 if (!prev
|| !*prev
) {
981 list_for_each_entry_safe(entry
, n
, head
, list
) {
982 err
= func(entry
, data
);
994 list_for_each_entry_safe_continue((*prev
), n
, head
, list
) {
995 err
= func(*prev
, data
);
1002 EXPORT_SYMBOL_GPL(__efivar_entry_iter
);
1005 * efivar_entry_iter - iterate over variable list
1006 * @func: callback function
1007 * @head: head of variable list
1008 * @data: function-specific data to pass to callback
1010 * Iterate over the list of EFI variables and call @func with every
1011 * entry on the list. It is safe for @func to remove entries in the
1012 * list via efivar_entry_delete() while iterating.
1014 * Some notes for the callback function:
1015 * - a non-zero return value indicates an error and terminates the loop
1016 * - @func is called from atomic context
1018 int efivar_entry_iter(int (*func
)(struct efivar_entry
*, void *),
1019 struct list_head
*head
, void *data
)
1023 efivar_entry_iter_begin();
1024 err
= __efivar_entry_iter(func
, head
, data
, NULL
);
1025 efivar_entry_iter_end();
1029 EXPORT_SYMBOL_GPL(efivar_entry_iter
);
1032 * efivars_kobject - get the kobject for the registered efivars
1034 * If efivars_register() has not been called we return NULL,
1035 * otherwise return the kobject used at registration time.
1037 struct kobject
*efivars_kobject(void)
1042 return __efivars
->kobject
;
1044 EXPORT_SYMBOL_GPL(efivars_kobject
);
1047 * efivar_run_worker - schedule the efivar worker thread
1049 void efivar_run_worker(void)
1051 if (efivar_wq_enabled
)
1052 schedule_work(&efivar_work
);
1054 EXPORT_SYMBOL_GPL(efivar_run_worker
);
1057 * efivars_register - register an efivars
1058 * @efivars: efivars to register
1059 * @ops: efivars operations
1060 * @kobject: @efivars-specific kobject
1062 * Only a single efivars can be registered at any time.
1064 int efivars_register(struct efivars
*efivars
,
1065 const struct efivar_operations
*ops
,
1066 struct kobject
*kobject
)
1068 spin_lock_init(&efivars
->lock
);
1070 efivars
->kobject
= kobject
;
1072 __efivars
= efivars
;
1076 EXPORT_SYMBOL_GPL(efivars_register
);
1079 * efivars_unregister - unregister an efivars
1080 * @efivars: efivars to unregister
1082 * The caller must have already removed every entry from the list,
1083 * failure to do so is an error.
1085 int efivars_unregister(struct efivars
*efivars
)
1090 printk(KERN_ERR
"efivars not registered\n");
1095 if (__efivars
!= efivars
) {
1106 EXPORT_SYMBOL_GPL(efivars_unregister
);