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 { LINUX_EFI_CRASH_GUID
, "*", NULL
},
202 { NULL_GUID
, "", NULL
},
206 * Check if @var_name matches the pattern given in @match_name.
208 * @var_name: an array of @len non-NUL characters.
209 * @match_name: a NUL-terminated pattern string, optionally ending in "*". A
210 * final "*" character matches any trailing characters @var_name,
211 * including the case when there are none left in @var_name.
212 * @match: on output, the number of non-wildcard characters in @match_name
213 * that @var_name matches, regardless of the return value.
214 * @return: whether @var_name fully matches @match_name.
217 variable_matches(const char *var_name
, size_t len
, const char *match_name
,
220 for (*match
= 0; ; (*match
)++) {
221 char c
= match_name
[*match
];
225 /* Wildcard in @match_name means we've matched. */
229 /* @match_name has ended. Has @var_name too? */
230 return (*match
== len
);
234 * We've reached a non-wildcard char in @match_name.
235 * Continue only if there's an identical character in
238 if (*match
< len
&& c
== var_name
[*match
])
246 efivar_validate(efi_guid_t vendor
, efi_char16_t
*var_name
, u8
*data
,
247 unsigned long data_size
)
250 unsigned long utf8_size
;
253 utf8_size
= ucs2_utf8size(var_name
);
254 utf8_name
= kmalloc(utf8_size
+ 1, GFP_KERNEL
);
258 ucs2_as_utf8(utf8_name
, var_name
, utf8_size
);
259 utf8_name
[utf8_size
] = '\0';
261 for (i
= 0; variable_validate
[i
].name
[0] != '\0'; i
++) {
262 const char *name
= variable_validate
[i
].name
;
265 if (efi_guidcmp(vendor
, variable_validate
[i
].vendor
))
268 if (variable_matches(utf8_name
, utf8_size
+1, name
, &match
)) {
269 if (variable_validate
[i
].validate
== NULL
)
272 return variable_validate
[i
].validate(var_name
, match
,
279 EXPORT_SYMBOL_GPL(efivar_validate
);
282 efivar_variable_is_removable(efi_guid_t vendor
, const char *var_name
,
290 * Check if our variable is in the validated variables list
292 for (i
= 0; variable_validate
[i
].name
[0] != '\0'; i
++) {
293 if (efi_guidcmp(variable_validate
[i
].vendor
, vendor
))
296 if (variable_matches(var_name
, len
,
297 variable_validate
[i
].name
, &match
)) {
304 * If it's in our list, it is removable.
308 EXPORT_SYMBOL_GPL(efivar_variable_is_removable
);
311 check_var_size(u32 attributes
, unsigned long size
)
313 const struct efivar_operations
*fops
= __efivars
->ops
;
315 if (!fops
->query_variable_store
)
316 return EFI_UNSUPPORTED
;
318 return fops
->query_variable_store(attributes
, size
, false);
322 check_var_size_nonblocking(u32 attributes
, unsigned long size
)
324 const struct efivar_operations
*fops
= __efivars
->ops
;
326 if (!fops
->query_variable_store
)
327 return EFI_UNSUPPORTED
;
329 return fops
->query_variable_store(attributes
, size
, true);
332 static bool variable_is_present(efi_char16_t
*variable_name
, efi_guid_t
*vendor
,
333 struct list_head
*head
)
335 struct efivar_entry
*entry
, *n
;
336 unsigned long strsize1
, strsize2
;
339 strsize1
= ucs2_strsize(variable_name
, 1024);
340 list_for_each_entry_safe(entry
, n
, head
, list
) {
341 strsize2
= ucs2_strsize(entry
->var
.VariableName
, 1024);
342 if (strsize1
== strsize2
&&
343 !memcmp(variable_name
, &(entry
->var
.VariableName
),
345 !efi_guidcmp(entry
->var
.VendorGuid
,
355 * Returns the size of variable_name, in bytes, including the
356 * terminating NULL character, or variable_name_size if no NULL
357 * character is found among the first variable_name_size bytes.
359 static unsigned long var_name_strnsize(efi_char16_t
*variable_name
,
360 unsigned long variable_name_size
)
366 * The variable name is, by definition, a NULL-terminated
367 * string, so make absolutely sure that variable_name_size is
368 * the value we expect it to be. If not, return the real size.
370 for (len
= 2; len
<= variable_name_size
; len
+= sizeof(c
)) {
371 c
= variable_name
[(len
/ sizeof(c
)) - 1];
376 return min(len
, variable_name_size
);
380 * Print a warning when duplicate EFI variables are encountered and
381 * disable the sysfs workqueue since the firmware is buggy.
383 static void dup_variable_bug(efi_char16_t
*str16
, efi_guid_t
*vendor_guid
,
386 size_t i
, len8
= len16
/ sizeof(efi_char16_t
);
390 * Disable the workqueue since the algorithm it uses for
391 * detecting new variables won't work with this buggy
392 * implementation of GetNextVariableName().
394 efivar_wq_enabled
= false;
396 str8
= kzalloc(len8
, GFP_KERNEL
);
400 for (i
= 0; i
< len8
; i
++)
403 printk(KERN_WARNING
"efivars: duplicate variable: %s-%pUl\n",
409 * efivar_init - build the initial list of EFI variables
410 * @func: callback function to invoke for every variable
411 * @data: function-specific data to pass to @func
412 * @atomic: do we need to execute the @func-loop atomically?
413 * @duplicates: error if we encounter duplicates on @head?
414 * @head: initialised head of variable list
416 * Get every EFI variable from the firmware and invoke @func. @func
417 * should call efivar_entry_add() to build the list of variables.
419 * Returns 0 on success, or a kernel error code on failure.
421 int efivar_init(int (*func
)(efi_char16_t
*, efi_guid_t
, unsigned long, void *),
422 void *data
, bool atomic
, bool duplicates
,
423 struct list_head
*head
)
425 const struct efivar_operations
*ops
= __efivars
->ops
;
426 unsigned long variable_name_size
= 1024;
427 efi_char16_t
*variable_name
;
429 efi_guid_t vendor_guid
;
432 variable_name
= kzalloc(variable_name_size
, GFP_KERNEL
);
433 if (!variable_name
) {
434 printk(KERN_ERR
"efivars: Memory allocation failed.\n");
438 spin_lock_irq(&__efivars
->lock
);
441 * Per EFI spec, the maximum storage allocated for both
442 * the variable name and variable data is 1024 bytes.
446 variable_name_size
= 1024;
448 status
= ops
->get_next_variable(&variable_name_size
,
454 spin_unlock_irq(&__efivars
->lock
);
456 variable_name_size
= var_name_strnsize(variable_name
,
460 * Some firmware implementations return the
461 * same variable name on multiple calls to
462 * get_next_variable(). Terminate the loop
463 * immediately as there is no guarantee that
464 * we'll ever see a different variable name,
465 * and may end up looping here forever.
468 variable_is_present(variable_name
, &vendor_guid
, head
)) {
469 dup_variable_bug(variable_name
, &vendor_guid
,
472 spin_lock_irq(&__efivars
->lock
);
474 status
= EFI_NOT_FOUND
;
478 err
= func(variable_name
, vendor_guid
, variable_name_size
, data
);
480 status
= EFI_NOT_FOUND
;
483 spin_lock_irq(&__efivars
->lock
);
489 printk(KERN_WARNING
"efivars: get_next_variable: status=%lx\n",
491 status
= EFI_NOT_FOUND
;
495 } while (status
!= EFI_NOT_FOUND
);
497 spin_unlock_irq(&__efivars
->lock
);
499 kfree(variable_name
);
503 EXPORT_SYMBOL_GPL(efivar_init
);
506 * efivar_entry_add - add entry to variable list
507 * @entry: entry to add to list
510 void efivar_entry_add(struct efivar_entry
*entry
, struct list_head
*head
)
512 spin_lock_irq(&__efivars
->lock
);
513 list_add(&entry
->list
, head
);
514 spin_unlock_irq(&__efivars
->lock
);
516 EXPORT_SYMBOL_GPL(efivar_entry_add
);
519 * efivar_entry_remove - remove entry from variable list
520 * @entry: entry to remove from list
522 void efivar_entry_remove(struct efivar_entry
*entry
)
524 spin_lock_irq(&__efivars
->lock
);
525 list_del(&entry
->list
);
526 spin_unlock_irq(&__efivars
->lock
);
528 EXPORT_SYMBOL_GPL(efivar_entry_remove
);
531 * efivar_entry_list_del_unlock - remove entry from variable list
532 * @entry: entry to remove
534 * Remove @entry from the variable list and release the list lock.
536 * NOTE: slightly weird locking semantics here - we expect to be
537 * called with the efivars lock already held, and we release it before
538 * returning. This is because this function is usually called after
539 * set_variable() while the lock is still held.
541 static void efivar_entry_list_del_unlock(struct efivar_entry
*entry
)
543 lockdep_assert_held(&__efivars
->lock
);
545 list_del(&entry
->list
);
546 spin_unlock_irq(&__efivars
->lock
);
550 * __efivar_entry_delete - delete an EFI variable
551 * @entry: entry containing EFI variable to delete
553 * Delete the variable from the firmware but leave @entry on the
556 * This function differs from efivar_entry_delete() because it does
557 * not remove @entry from the variable list. Also, it is safe to be
558 * called from within a efivar_entry_iter_begin() and
559 * efivar_entry_iter_end() region, unlike efivar_entry_delete().
561 * Returns 0 on success, or a converted EFI status code if
562 * set_variable() fails.
564 int __efivar_entry_delete(struct efivar_entry
*entry
)
566 const struct efivar_operations
*ops
= __efivars
->ops
;
569 lockdep_assert_held(&__efivars
->lock
);
571 status
= ops
->set_variable(entry
->var
.VariableName
,
572 &entry
->var
.VendorGuid
,
575 return efi_status_to_err(status
);
577 EXPORT_SYMBOL_GPL(__efivar_entry_delete
);
580 * efivar_entry_delete - delete variable and remove entry from list
581 * @entry: entry containing variable to delete
583 * Delete the variable from the firmware and remove @entry from the
584 * variable list. It is the caller's responsibility to free @entry
587 * Returns 0 on success, or a converted EFI status code if
588 * set_variable() fails.
590 int efivar_entry_delete(struct efivar_entry
*entry
)
592 const struct efivar_operations
*ops
= __efivars
->ops
;
595 spin_lock_irq(&__efivars
->lock
);
596 status
= ops
->set_variable(entry
->var
.VariableName
,
597 &entry
->var
.VendorGuid
,
599 if (!(status
== EFI_SUCCESS
|| status
== EFI_NOT_FOUND
)) {
600 spin_unlock_irq(&__efivars
->lock
);
601 return efi_status_to_err(status
);
604 efivar_entry_list_del_unlock(entry
);
607 EXPORT_SYMBOL_GPL(efivar_entry_delete
);
610 * efivar_entry_set - call set_variable()
611 * @entry: entry containing the EFI variable to write
612 * @attributes: variable attributes
613 * @size: size of @data buffer
614 * @data: buffer containing variable data
615 * @head: head of variable list
617 * Calls set_variable() for an EFI variable. If creating a new EFI
618 * variable, this function is usually followed by efivar_entry_add().
620 * Before writing the variable, the remaining EFI variable storage
621 * space is checked to ensure there is enough room available.
623 * If @head is not NULL a lookup is performed to determine whether
624 * the entry is already on the list.
626 * Returns 0 on success, -EEXIST if a lookup is performed and the entry
627 * already exists on the list, or a converted EFI status code if
628 * set_variable() fails.
630 int efivar_entry_set(struct efivar_entry
*entry
, u32 attributes
,
631 unsigned long size
, void *data
, struct list_head
*head
)
633 const struct efivar_operations
*ops
= __efivars
->ops
;
635 efi_char16_t
*name
= entry
->var
.VariableName
;
636 efi_guid_t vendor
= entry
->var
.VendorGuid
;
638 spin_lock_irq(&__efivars
->lock
);
640 if (head
&& efivar_entry_find(name
, vendor
, head
, false)) {
641 spin_unlock_irq(&__efivars
->lock
);
645 status
= check_var_size(attributes
, size
+ ucs2_strsize(name
, 1024));
646 if (status
== EFI_SUCCESS
|| status
== EFI_UNSUPPORTED
)
647 status
= ops
->set_variable(name
, &vendor
,
648 attributes
, size
, data
);
650 spin_unlock_irq(&__efivars
->lock
);
652 return efi_status_to_err(status
);
655 EXPORT_SYMBOL_GPL(efivar_entry_set
);
658 * efivar_entry_set_nonblocking - call set_variable_nonblocking()
660 * This function is guaranteed to not block and is suitable for calling
661 * from crash/panic handlers.
663 * Crucially, this function will not block if it cannot acquire
664 * __efivars->lock. Instead, it returns -EBUSY.
667 efivar_entry_set_nonblocking(efi_char16_t
*name
, efi_guid_t vendor
,
668 u32 attributes
, unsigned long size
, void *data
)
670 const struct efivar_operations
*ops
= __efivars
->ops
;
674 if (!spin_trylock_irqsave(&__efivars
->lock
, flags
))
677 status
= check_var_size_nonblocking(attributes
,
678 size
+ ucs2_strsize(name
, 1024));
679 if (status
!= EFI_SUCCESS
) {
680 spin_unlock_irqrestore(&__efivars
->lock
, flags
);
684 status
= ops
->set_variable_nonblocking(name
, &vendor
, attributes
,
687 spin_unlock_irqrestore(&__efivars
->lock
, flags
);
688 return efi_status_to_err(status
);
692 * efivar_entry_set_safe - call set_variable() if enough space in firmware
693 * @name: buffer containing the variable name
694 * @vendor: variable vendor guid
695 * @attributes: variable attributes
696 * @block: can we block in this context?
697 * @size: size of @data buffer
698 * @data: buffer containing variable data
700 * Ensures there is enough free storage in the firmware for this variable, and
701 * if so, calls set_variable(). If creating a new EFI variable, this function
702 * is usually followed by efivar_entry_add().
704 * Returns 0 on success, -ENOSPC if the firmware does not have enough
705 * space for set_variable() to succeed, or a converted EFI status code
706 * if set_variable() fails.
708 int efivar_entry_set_safe(efi_char16_t
*name
, efi_guid_t vendor
, u32 attributes
,
709 bool block
, unsigned long size
, void *data
)
711 const struct efivar_operations
*ops
= __efivars
->ops
;
715 if (!ops
->query_variable_store
)
719 * If the EFI variable backend provides a non-blocking
720 * ->set_variable() operation and we're in a context where we
721 * cannot block, then we need to use it to avoid live-locks,
722 * since the implication is that the regular ->set_variable()
725 * If no ->set_variable_nonblocking() is provided then
726 * ->set_variable() is assumed to be non-blocking.
728 if (!block
&& ops
->set_variable_nonblocking
)
729 return efivar_entry_set_nonblocking(name
, vendor
, attributes
,
733 if (!spin_trylock_irqsave(&__efivars
->lock
, flags
))
736 spin_lock_irqsave(&__efivars
->lock
, flags
);
739 status
= check_var_size(attributes
, size
+ ucs2_strsize(name
, 1024));
740 if (status
!= EFI_SUCCESS
) {
741 spin_unlock_irqrestore(&__efivars
->lock
, flags
);
745 status
= ops
->set_variable(name
, &vendor
, attributes
, size
, data
);
747 spin_unlock_irqrestore(&__efivars
->lock
, flags
);
749 return efi_status_to_err(status
);
751 EXPORT_SYMBOL_GPL(efivar_entry_set_safe
);
754 * efivar_entry_find - search for an entry
755 * @name: the EFI variable name
756 * @guid: the EFI variable vendor's guid
757 * @head: head of the variable list
758 * @remove: should we remove the entry from the list?
760 * Search for an entry on the variable list that has the EFI variable
761 * name @name and vendor guid @guid. If an entry is found on the list
762 * and @remove is true, the entry is removed from the list.
764 * The caller MUST call efivar_entry_iter_begin() and
765 * efivar_entry_iter_end() before and after the invocation of this
766 * function, respectively.
768 * Returns the entry if found on the list, %NULL otherwise.
770 struct efivar_entry
*efivar_entry_find(efi_char16_t
*name
, efi_guid_t guid
,
771 struct list_head
*head
, bool remove
)
773 struct efivar_entry
*entry
, *n
;
774 int strsize1
, strsize2
;
777 lockdep_assert_held(&__efivars
->lock
);
779 list_for_each_entry_safe(entry
, n
, head
, list
) {
780 strsize1
= ucs2_strsize(name
, 1024);
781 strsize2
= ucs2_strsize(entry
->var
.VariableName
, 1024);
782 if (strsize1
== strsize2
&&
783 !memcmp(name
, &(entry
->var
.VariableName
), strsize1
) &&
784 !efi_guidcmp(guid
, entry
->var
.VendorGuid
)) {
794 if (entry
->scanning
) {
796 * The entry will be deleted
797 * after scanning is completed.
799 entry
->deleting
= true;
801 list_del(&entry
->list
);
806 EXPORT_SYMBOL_GPL(efivar_entry_find
);
809 * efivar_entry_size - obtain the size of a variable
810 * @entry: entry for this variable
811 * @size: location to store the variable's size
813 int efivar_entry_size(struct efivar_entry
*entry
, unsigned long *size
)
815 const struct efivar_operations
*ops
= __efivars
->ops
;
820 spin_lock_irq(&__efivars
->lock
);
821 status
= ops
->get_variable(entry
->var
.VariableName
,
822 &entry
->var
.VendorGuid
, NULL
, size
, NULL
);
823 spin_unlock_irq(&__efivars
->lock
);
825 if (status
!= EFI_BUFFER_TOO_SMALL
)
826 return efi_status_to_err(status
);
830 EXPORT_SYMBOL_GPL(efivar_entry_size
);
833 * __efivar_entry_get - call get_variable()
834 * @entry: read data for this variable
835 * @attributes: variable attributes
836 * @size: size of @data buffer
837 * @data: buffer to store variable data
839 * The caller MUST call efivar_entry_iter_begin() and
840 * efivar_entry_iter_end() before and after the invocation of this
841 * function, respectively.
843 int __efivar_entry_get(struct efivar_entry
*entry
, u32
*attributes
,
844 unsigned long *size
, void *data
)
846 const struct efivar_operations
*ops
= __efivars
->ops
;
849 lockdep_assert_held(&__efivars
->lock
);
851 status
= ops
->get_variable(entry
->var
.VariableName
,
852 &entry
->var
.VendorGuid
,
853 attributes
, size
, data
);
855 return efi_status_to_err(status
);
857 EXPORT_SYMBOL_GPL(__efivar_entry_get
);
860 * efivar_entry_get - call get_variable()
861 * @entry: read data for this variable
862 * @attributes: variable attributes
863 * @size: size of @data buffer
864 * @data: buffer to store variable data
866 int efivar_entry_get(struct efivar_entry
*entry
, u32
*attributes
,
867 unsigned long *size
, void *data
)
869 const struct efivar_operations
*ops
= __efivars
->ops
;
872 spin_lock_irq(&__efivars
->lock
);
873 status
= ops
->get_variable(entry
->var
.VariableName
,
874 &entry
->var
.VendorGuid
,
875 attributes
, size
, data
);
876 spin_unlock_irq(&__efivars
->lock
);
878 return efi_status_to_err(status
);
880 EXPORT_SYMBOL_GPL(efivar_entry_get
);
883 * efivar_entry_set_get_size - call set_variable() and get new size (atomic)
884 * @entry: entry containing variable to set and get
885 * @attributes: attributes of variable to be written
886 * @size: size of data buffer
887 * @data: buffer containing data to write
888 * @set: did the set_variable() call succeed?
890 * This is a pretty special (complex) function. See efivarfs_file_write().
892 * Atomically call set_variable() for @entry and if the call is
893 * successful, return the new size of the variable from get_variable()
894 * in @size. The success of set_variable() is indicated by @set.
896 * Returns 0 on success, -EINVAL if the variable data is invalid,
897 * -ENOSPC if the firmware does not have enough available space, or a
898 * converted EFI status code if either of set_variable() or
899 * get_variable() fail.
901 * If the EFI variable does not exist when calling set_variable()
902 * (EFI_NOT_FOUND), @entry is removed from the variable list.
904 int efivar_entry_set_get_size(struct efivar_entry
*entry
, u32 attributes
,
905 unsigned long *size
, void *data
, bool *set
)
907 const struct efivar_operations
*ops
= __efivars
->ops
;
908 efi_char16_t
*name
= entry
->var
.VariableName
;
909 efi_guid_t
*vendor
= &entry
->var
.VendorGuid
;
915 if (efivar_validate(*vendor
, name
, data
, *size
) == false)
919 * The lock here protects the get_variable call, the conditional
920 * set_variable call, and removal of the variable from the efivars
921 * list (in the case of an authenticated delete).
923 spin_lock_irq(&__efivars
->lock
);
926 * Ensure that the available space hasn't shrunk below the safe level
928 status
= check_var_size(attributes
, *size
+ ucs2_strsize(name
, 1024));
929 if (status
!= EFI_SUCCESS
) {
930 if (status
!= EFI_UNSUPPORTED
) {
931 err
= efi_status_to_err(status
);
941 status
= ops
->set_variable(name
, vendor
, attributes
, *size
, data
);
942 if (status
!= EFI_SUCCESS
) {
943 err
= efi_status_to_err(status
);
950 * Writing to the variable may have caused a change in size (which
951 * could either be an append or an overwrite), or the variable to be
952 * deleted. Perform a GetVariable() so we can tell what actually
956 status
= ops
->get_variable(entry
->var
.VariableName
,
957 &entry
->var
.VendorGuid
,
960 if (status
== EFI_NOT_FOUND
)
961 efivar_entry_list_del_unlock(entry
);
963 spin_unlock_irq(&__efivars
->lock
);
965 if (status
&& status
!= EFI_BUFFER_TOO_SMALL
)
966 return efi_status_to_err(status
);
971 spin_unlock_irq(&__efivars
->lock
);
975 EXPORT_SYMBOL_GPL(efivar_entry_set_get_size
);
978 * efivar_entry_iter_begin - begin iterating the variable list
980 * Lock the variable list to prevent entry insertion and removal until
981 * efivar_entry_iter_end() is called. This function is usually used in
982 * conjunction with __efivar_entry_iter() or efivar_entry_iter().
984 void efivar_entry_iter_begin(void)
986 spin_lock_irq(&__efivars
->lock
);
988 EXPORT_SYMBOL_GPL(efivar_entry_iter_begin
);
991 * efivar_entry_iter_end - finish iterating the variable list
993 * Unlock the variable list and allow modifications to the list again.
995 void efivar_entry_iter_end(void)
997 spin_unlock_irq(&__efivars
->lock
);
999 EXPORT_SYMBOL_GPL(efivar_entry_iter_end
);
1002 * __efivar_entry_iter - iterate over variable list
1003 * @func: callback function
1004 * @head: head of the variable list
1005 * @data: function-specific data to pass to callback
1006 * @prev: entry to begin iterating from
1008 * Iterate over the list of EFI variables and call @func with every
1009 * entry on the list. It is safe for @func to remove entries in the
1010 * list via efivar_entry_delete().
1012 * You MUST call efivar_enter_iter_begin() before this function, and
1013 * efivar_entry_iter_end() afterwards.
1015 * It is possible to begin iteration from an arbitrary entry within
1016 * the list by passing @prev. @prev is updated on return to point to
1017 * the last entry passed to @func. To begin iterating from the
1018 * beginning of the list @prev must be %NULL.
1020 * The restrictions for @func are the same as documented for
1021 * efivar_entry_iter().
1023 int __efivar_entry_iter(int (*func
)(struct efivar_entry
*, void *),
1024 struct list_head
*head
, void *data
,
1025 struct efivar_entry
**prev
)
1027 struct efivar_entry
*entry
, *n
;
1030 if (!prev
|| !*prev
) {
1031 list_for_each_entry_safe(entry
, n
, head
, list
) {
1032 err
= func(entry
, data
);
1044 list_for_each_entry_safe_continue((*prev
), n
, head
, list
) {
1045 err
= func(*prev
, data
);
1052 EXPORT_SYMBOL_GPL(__efivar_entry_iter
);
1055 * efivar_entry_iter - iterate over variable list
1056 * @func: callback function
1057 * @head: head of variable list
1058 * @data: function-specific data to pass to callback
1060 * Iterate over the list of EFI variables and call @func with every
1061 * entry on the list. It is safe for @func to remove entries in the
1062 * list via efivar_entry_delete() while iterating.
1064 * Some notes for the callback function:
1065 * - a non-zero return value indicates an error and terminates the loop
1066 * - @func is called from atomic context
1068 int efivar_entry_iter(int (*func
)(struct efivar_entry
*, void *),
1069 struct list_head
*head
, void *data
)
1073 efivar_entry_iter_begin();
1074 err
= __efivar_entry_iter(func
, head
, data
, NULL
);
1075 efivar_entry_iter_end();
1079 EXPORT_SYMBOL_GPL(efivar_entry_iter
);
1082 * efivars_kobject - get the kobject for the registered efivars
1084 * If efivars_register() has not been called we return NULL,
1085 * otherwise return the kobject used at registration time.
1087 struct kobject
*efivars_kobject(void)
1092 return __efivars
->kobject
;
1094 EXPORT_SYMBOL_GPL(efivars_kobject
);
1097 * efivar_run_worker - schedule the efivar worker thread
1099 void efivar_run_worker(void)
1101 if (efivar_wq_enabled
)
1102 schedule_work(&efivar_work
);
1104 EXPORT_SYMBOL_GPL(efivar_run_worker
);
1107 * efivars_register - register an efivars
1108 * @efivars: efivars to register
1109 * @ops: efivars operations
1110 * @kobject: @efivars-specific kobject
1112 * Only a single efivars can be registered at any time.
1114 int efivars_register(struct efivars
*efivars
,
1115 const struct efivar_operations
*ops
,
1116 struct kobject
*kobject
)
1118 spin_lock_init(&efivars
->lock
);
1120 efivars
->kobject
= kobject
;
1122 __efivars
= efivars
;
1126 EXPORT_SYMBOL_GPL(efivars_register
);
1129 * efivars_unregister - unregister an efivars
1130 * @efivars: efivars to unregister
1132 * The caller must have already removed every entry from the list,
1133 * failure to do so is an error.
1135 int efivars_unregister(struct efivars
*efivars
)
1140 printk(KERN_ERR
"efivars not registered\n");
1145 if (__efivars
!= efivars
) {
1156 EXPORT_SYMBOL_GPL(efivars_unregister
);