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 code takes all variables accessible from EFI runtime and
8 * exports them via sysfs
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
26 * 17 May 2004 - Matt Domsch <Matt_Domsch@dell.com>
27 * remove check for efi_enabled in exit
30 * 26 Apr 2004 - Matt Domsch <Matt_Domsch@dell.com>
33 * 21 Apr 2004 - Matt Tolentino <matthew.e.tolentino@intel.com)
34 * converted driver to export variable information via sysfs
35 * and moved to drivers/firmware directory
36 * bumped revision number to v0.07 to reflect conversion & move
38 * 10 Dec 2002 - Matt Domsch <Matt_Domsch@dell.com>
39 * fix locking per Peter Chubb's findings
41 * 25 Mar 2002 - Matt Domsch <Matt_Domsch@dell.com>
42 * move uuid_unparse() to include/asm-ia64/efi.h:efi_guid_unparse()
44 * 12 Feb 2002 - Matt Domsch <Matt_Domsch@dell.com>
45 * use list_for_each_safe when deleting vars.
46 * remove ifdef CONFIG_SMP around include <linux/smp.h>
47 * v0.04 release to linux-ia64@linuxia64.org
49 * 20 April 2001 - Matt Domsch <Matt_Domsch@dell.com>
50 * Moved vars from /proc/efi to /proc/efi/vars, and made
51 * efi.c own the /proc/efi directory.
52 * v0.03 release to linux-ia64@linuxia64.org
54 * 26 March 2001 - Matt Domsch <Matt_Domsch@dell.com>
55 * At the request of Stephane, moved ownership of /proc/efi
56 * to efi.c, and now efivars lives under /proc/efi/vars.
58 * 12 March 2001 - Matt Domsch <Matt_Domsch@dell.com>
59 * Feedback received from Stephane Eranian incorporated.
60 * efivar_write() checks copy_from_user() return value.
61 * efivar_read/write() returns proper errno.
62 * v0.02 release to linux-ia64@linuxia64.org
64 * 26 February 2001 - Matt Domsch <Matt_Domsch@dell.com>
65 * v0.01 release to linux-ia64@linuxia64.org
68 #include <linux/efi.h>
69 #include <linux/module.h>
70 #include <linux/slab.h>
71 #include <linux/ucs2_string.h>
72 #include <linux/compat.h>
74 #define EFIVARS_VERSION "0.08"
75 #define EFIVARS_DATE "2004-May-17"
77 MODULE_AUTHOR("Matt Domsch <Matt_Domsch@Dell.com>");
78 MODULE_DESCRIPTION("sysfs interface to EFI Variables");
79 MODULE_LICENSE("GPL");
80 MODULE_VERSION(EFIVARS_VERSION
);
82 LIST_HEAD(efivar_sysfs_list
);
83 EXPORT_SYMBOL_GPL(efivar_sysfs_list
);
85 static struct kset
*efivars_kset
;
87 static struct bin_attribute
*efivars_new_var
;
88 static struct bin_attribute
*efivars_del_var
;
90 struct compat_efi_variable
{
91 efi_char16_t VariableName
[EFI_VAR_NAME_LEN
/sizeof(efi_char16_t
)];
92 efi_guid_t VendorGuid
;
99 struct efivar_attribute
{
100 struct attribute attr
;
101 ssize_t (*show
) (struct efivar_entry
*entry
, char *buf
);
102 ssize_t (*store
)(struct efivar_entry
*entry
, const char *buf
, size_t count
);
105 #define EFIVAR_ATTR(_name, _mode, _show, _store) \
106 struct efivar_attribute efivar_attr_##_name = { \
107 .attr = {.name = __stringify(_name), .mode = _mode}, \
112 #define to_efivar_attr(_attr) container_of(_attr, struct efivar_attribute, attr)
113 #define to_efivar_entry(obj) container_of(obj, struct efivar_entry, kobj)
116 * Prototype for sysfs creation function
119 efivar_create_sysfs_entry(struct efivar_entry
*new_var
);
122 efivar_guid_read(struct efivar_entry
*entry
, char *buf
)
124 struct efi_variable
*var
= &entry
->var
;
130 efi_guid_unparse(&var
->VendorGuid
, str
);
132 str
+= sprintf(str
, "\n");
138 efivar_attr_read(struct efivar_entry
*entry
, char *buf
)
140 struct efi_variable
*var
= &entry
->var
;
146 var
->DataSize
= 1024;
147 if (efivar_entry_get(entry
, &var
->Attributes
, &var
->DataSize
, var
->Data
))
150 if (var
->Attributes
& EFI_VARIABLE_NON_VOLATILE
)
151 str
+= sprintf(str
, "EFI_VARIABLE_NON_VOLATILE\n");
152 if (var
->Attributes
& EFI_VARIABLE_BOOTSERVICE_ACCESS
)
153 str
+= sprintf(str
, "EFI_VARIABLE_BOOTSERVICE_ACCESS\n");
154 if (var
->Attributes
& EFI_VARIABLE_RUNTIME_ACCESS
)
155 str
+= sprintf(str
, "EFI_VARIABLE_RUNTIME_ACCESS\n");
156 if (var
->Attributes
& EFI_VARIABLE_HARDWARE_ERROR_RECORD
)
157 str
+= sprintf(str
, "EFI_VARIABLE_HARDWARE_ERROR_RECORD\n");
158 if (var
->Attributes
& EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS
)
160 "EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS\n");
161 if (var
->Attributes
&
162 EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS
)
164 "EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS\n");
165 if (var
->Attributes
& EFI_VARIABLE_APPEND_WRITE
)
166 str
+= sprintf(str
, "EFI_VARIABLE_APPEND_WRITE\n");
171 efivar_size_read(struct efivar_entry
*entry
, char *buf
)
173 struct efi_variable
*var
= &entry
->var
;
179 var
->DataSize
= 1024;
180 if (efivar_entry_get(entry
, &var
->Attributes
, &var
->DataSize
, var
->Data
))
183 str
+= sprintf(str
, "0x%lx\n", var
->DataSize
);
188 efivar_data_read(struct efivar_entry
*entry
, char *buf
)
190 struct efi_variable
*var
= &entry
->var
;
195 var
->DataSize
= 1024;
196 if (efivar_entry_get(entry
, &var
->Attributes
, &var
->DataSize
, var
->Data
))
199 memcpy(buf
, var
->Data
, var
->DataSize
);
200 return var
->DataSize
;
204 sanity_check(struct efi_variable
*var
, efi_char16_t
*name
, efi_guid_t vendor
,
205 unsigned long size
, u32 attributes
, u8
*data
)
208 * If only updating the variable data, then the name
209 * and guid should remain the same
211 if (memcmp(name
, var
->VariableName
, sizeof(var
->VariableName
)) ||
212 efi_guidcmp(vendor
, var
->VendorGuid
)) {
213 printk(KERN_ERR
"efivars: Cannot edit the wrong variable!\n");
217 if ((size
<= 0) || (attributes
== 0)){
218 printk(KERN_ERR
"efivars: DataSize & Attributes must be valid!\n");
222 if ((attributes
& ~EFI_VARIABLE_MASK
) != 0 ||
223 efivar_validate(name
, data
, size
) == false) {
224 printk(KERN_ERR
"efivars: Malformed variable content\n");
231 static inline bool is_compat(void)
233 if (IS_ENABLED(CONFIG_COMPAT
) && is_compat_task())
240 copy_out_compat(struct efi_variable
*dst
, struct compat_efi_variable
*src
)
242 memcpy(dst
->VariableName
, src
->VariableName
, EFI_VAR_NAME_LEN
);
243 memcpy(dst
->Data
, src
->Data
, sizeof(src
->Data
));
245 dst
->VendorGuid
= src
->VendorGuid
;
246 dst
->DataSize
= src
->DataSize
;
247 dst
->Attributes
= src
->Attributes
;
251 * We allow each variable to be edited via rewriting the
252 * entire efi variable structure.
255 efivar_store_raw(struct efivar_entry
*entry
, const char *buf
, size_t count
)
257 struct efi_variable
*new_var
, *var
= &entry
->var
;
266 struct compat_efi_variable
*compat
;
268 if (count
!= sizeof(*compat
))
271 compat
= (struct compat_efi_variable
*)buf
;
272 attributes
= compat
->Attributes
;
273 vendor
= compat
->VendorGuid
;
274 name
= compat
->VariableName
;
275 size
= compat
->DataSize
;
278 err
= sanity_check(var
, name
, vendor
, size
, attributes
, data
);
282 copy_out_compat(&entry
->var
, compat
);
284 if (count
!= sizeof(struct efi_variable
))
287 new_var
= (struct efi_variable
*)buf
;
289 attributes
= new_var
->Attributes
;
290 vendor
= new_var
->VendorGuid
;
291 name
= new_var
->VariableName
;
292 size
= new_var
->DataSize
;
293 data
= new_var
->Data
;
295 err
= sanity_check(var
, name
, vendor
, size
, attributes
, data
);
299 memcpy(&entry
->var
, new_var
, count
);
302 err
= efivar_entry_set(entry
, attributes
, size
, data
, NULL
);
304 printk(KERN_WARNING
"efivars: set_variable() failed: status=%d\n", err
);
312 efivar_show_raw(struct efivar_entry
*entry
, char *buf
)
314 struct efi_variable
*var
= &entry
->var
;
315 struct compat_efi_variable
*compat
;
321 var
->DataSize
= 1024;
322 if (efivar_entry_get(entry
, &entry
->var
.Attributes
,
323 &entry
->var
.DataSize
, entry
->var
.Data
))
327 compat
= (struct compat_efi_variable
*)buf
;
329 size
= sizeof(*compat
);
330 memcpy(compat
->VariableName
, var
->VariableName
,
332 memcpy(compat
->Data
, var
->Data
, sizeof(compat
->Data
));
334 compat
->VendorGuid
= var
->VendorGuid
;
335 compat
->DataSize
= var
->DataSize
;
336 compat
->Attributes
= var
->Attributes
;
339 memcpy(buf
, var
, size
);
346 * Generic read/write functions that call the specific functions of
349 static ssize_t
efivar_attr_show(struct kobject
*kobj
, struct attribute
*attr
,
352 struct efivar_entry
*var
= to_efivar_entry(kobj
);
353 struct efivar_attribute
*efivar_attr
= to_efivar_attr(attr
);
356 if (!capable(CAP_SYS_ADMIN
))
359 if (efivar_attr
->show
) {
360 ret
= efivar_attr
->show(var
, buf
);
365 static ssize_t
efivar_attr_store(struct kobject
*kobj
, struct attribute
*attr
,
366 const char *buf
, size_t count
)
368 struct efivar_entry
*var
= to_efivar_entry(kobj
);
369 struct efivar_attribute
*efivar_attr
= to_efivar_attr(attr
);
372 if (!capable(CAP_SYS_ADMIN
))
375 if (efivar_attr
->store
)
376 ret
= efivar_attr
->store(var
, buf
, count
);
381 static const struct sysfs_ops efivar_attr_ops
= {
382 .show
= efivar_attr_show
,
383 .store
= efivar_attr_store
,
386 static void efivar_release(struct kobject
*kobj
)
388 struct efivar_entry
*var
= container_of(kobj
, struct efivar_entry
, kobj
);
392 static EFIVAR_ATTR(guid
, 0400, efivar_guid_read
, NULL
);
393 static EFIVAR_ATTR(attributes
, 0400, efivar_attr_read
, NULL
);
394 static EFIVAR_ATTR(size
, 0400, efivar_size_read
, NULL
);
395 static EFIVAR_ATTR(data
, 0400, efivar_data_read
, NULL
);
396 static EFIVAR_ATTR(raw_var
, 0600, efivar_show_raw
, efivar_store_raw
);
398 static struct attribute
*def_attrs
[] = {
399 &efivar_attr_guid
.attr
,
400 &efivar_attr_size
.attr
,
401 &efivar_attr_attributes
.attr
,
402 &efivar_attr_data
.attr
,
403 &efivar_attr_raw_var
.attr
,
407 static struct kobj_type efivar_ktype
= {
408 .release
= efivar_release
,
409 .sysfs_ops
= &efivar_attr_ops
,
410 .default_attrs
= def_attrs
,
413 static ssize_t
efivar_create(struct file
*filp
, struct kobject
*kobj
,
414 struct bin_attribute
*bin_attr
,
415 char *buf
, loff_t pos
, size_t count
)
417 struct compat_efi_variable
*compat
= (struct compat_efi_variable
*)buf
;
418 struct efi_variable
*new_var
= (struct efi_variable
*)buf
;
419 struct efivar_entry
*new_entry
;
420 bool need_compat
= is_compat();
427 if (!capable(CAP_SYS_ADMIN
))
431 if (count
!= sizeof(*compat
))
434 attributes
= compat
->Attributes
;
435 name
= compat
->VariableName
;
436 size
= compat
->DataSize
;
439 if (count
!= sizeof(*new_var
))
442 attributes
= new_var
->Attributes
;
443 name
= new_var
->VariableName
;
444 size
= new_var
->DataSize
;
445 data
= new_var
->Data
;
448 if ((attributes
& ~EFI_VARIABLE_MASK
) != 0 ||
449 efivar_validate(name
, data
, size
) == false) {
450 printk(KERN_ERR
"efivars: Malformed variable content\n");
454 new_entry
= kzalloc(sizeof(*new_entry
), GFP_KERNEL
);
459 copy_out_compat(&new_entry
->var
, compat
);
461 memcpy(&new_entry
->var
, new_var
, sizeof(*new_var
));
463 err
= efivar_entry_set(new_entry
, attributes
, size
,
464 data
, &efivar_sysfs_list
);
471 if (efivar_create_sysfs_entry(new_entry
)) {
472 printk(KERN_WARNING
"efivars: failed to create sysfs entry.\n");
482 static ssize_t
efivar_delete(struct file
*filp
, struct kobject
*kobj
,
483 struct bin_attribute
*bin_attr
,
484 char *buf
, loff_t pos
, size_t count
)
486 struct efi_variable
*del_var
= (struct efi_variable
*)buf
;
487 struct compat_efi_variable
*compat
;
488 struct efivar_entry
*entry
;
493 if (!capable(CAP_SYS_ADMIN
))
497 if (count
!= sizeof(*compat
))
500 compat
= (struct compat_efi_variable
*)buf
;
501 name
= compat
->VariableName
;
502 vendor
= compat
->VendorGuid
;
504 if (count
!= sizeof(*del_var
))
507 name
= del_var
->VariableName
;
508 vendor
= del_var
->VendorGuid
;
511 efivar_entry_iter_begin();
512 entry
= efivar_entry_find(name
, vendor
, &efivar_sysfs_list
, true);
515 else if (__efivar_entry_delete(entry
))
519 efivar_entry_iter_end();
523 if (!entry
->scanning
) {
524 efivar_entry_iter_end();
525 efivar_unregister(entry
);
527 efivar_entry_iter_end();
529 /* It's dead Jim.... */
534 * efivar_create_sysfs_entry - create a new entry in sysfs
535 * @new_var: efivar entry to create
537 * Returns 1 on failure, 0 on success
540 efivar_create_sysfs_entry(struct efivar_entry
*new_var
)
542 int i
, short_name_size
;
544 unsigned long variable_name_size
;
545 efi_char16_t
*variable_name
;
547 variable_name
= new_var
->var
.VariableName
;
548 variable_name_size
= ucs2_strlen(variable_name
) * sizeof(efi_char16_t
);
551 * Length of the variable bytes in ASCII, plus the '-' separator,
552 * plus the GUID, plus trailing NUL
554 short_name_size
= variable_name_size
/ sizeof(efi_char16_t
)
555 + 1 + EFI_VARIABLE_GUID_LEN
+ 1;
557 short_name
= kzalloc(short_name_size
, GFP_KERNEL
);
562 /* Convert Unicode to normal chars (assume top bits are 0),
564 for (i
=0; i
< (int)(variable_name_size
/ sizeof(efi_char16_t
)); i
++) {
565 short_name
[i
] = variable_name
[i
] & 0xFF;
567 /* This is ugly, but necessary to separate one vendor's
568 private variables from another's. */
570 *(short_name
+ strlen(short_name
)) = '-';
571 efi_guid_unparse(&new_var
->var
.VendorGuid
,
572 short_name
+ strlen(short_name
));
574 new_var
->kobj
.kset
= efivars_kset
;
576 i
= kobject_init_and_add(&new_var
->kobj
, &efivar_ktype
,
577 NULL
, "%s", short_name
);
582 kobject_uevent(&new_var
->kobj
, KOBJ_ADD
);
583 efivar_entry_add(new_var
, &efivar_sysfs_list
);
589 create_efivars_bin_attributes(void)
591 struct bin_attribute
*attr
;
595 attr
= kzalloc(sizeof(*attr
), GFP_KERNEL
);
599 attr
->attr
.name
= "new_var";
600 attr
->attr
.mode
= 0200;
601 attr
->write
= efivar_create
;
602 efivars_new_var
= attr
;
605 attr
= kzalloc(sizeof(*attr
), GFP_KERNEL
);
610 attr
->attr
.name
= "del_var";
611 attr
->attr
.mode
= 0200;
612 attr
->write
= efivar_delete
;
613 efivars_del_var
= attr
;
615 sysfs_bin_attr_init(efivars_new_var
);
616 sysfs_bin_attr_init(efivars_del_var
);
619 error
= sysfs_create_bin_file(&efivars_kset
->kobj
, efivars_new_var
);
621 printk(KERN_ERR
"efivars: unable to create new_var sysfs file"
622 " due to error %d\n", error
);
626 error
= sysfs_create_bin_file(&efivars_kset
->kobj
, efivars_del_var
);
628 printk(KERN_ERR
"efivars: unable to create del_var sysfs file"
629 " due to error %d\n", error
);
630 sysfs_remove_bin_file(&efivars_kset
->kobj
, efivars_new_var
);
636 kfree(efivars_del_var
);
637 efivars_del_var
= NULL
;
638 kfree(efivars_new_var
);
639 efivars_new_var
= NULL
;
643 static int efivar_update_sysfs_entry(efi_char16_t
*name
, efi_guid_t vendor
,
644 unsigned long name_size
, void *data
)
646 struct efivar_entry
*entry
= data
;
648 if (efivar_entry_find(name
, vendor
, &efivar_sysfs_list
, false))
651 memcpy(entry
->var
.VariableName
, name
, name_size
);
652 memcpy(&(entry
->var
.VendorGuid
), &vendor
, sizeof(efi_guid_t
));
657 static void efivar_update_sysfs_entries(struct work_struct
*work
)
659 struct efivar_entry
*entry
;
662 /* Add new sysfs entries */
664 entry
= kzalloc(sizeof(*entry
), GFP_KERNEL
);
668 err
= efivar_init(efivar_update_sysfs_entry
, entry
,
669 true, false, &efivar_sysfs_list
);
673 efivar_create_sysfs_entry(entry
);
679 static int efivars_sysfs_callback(efi_char16_t
*name
, efi_guid_t vendor
,
680 unsigned long name_size
, void *data
)
682 struct efivar_entry
*entry
;
684 entry
= kzalloc(sizeof(*entry
), GFP_KERNEL
);
688 memcpy(entry
->var
.VariableName
, name
, name_size
);
689 memcpy(&(entry
->var
.VendorGuid
), &vendor
, sizeof(efi_guid_t
));
691 efivar_create_sysfs_entry(entry
);
696 static int efivar_sysfs_destroy(struct efivar_entry
*entry
, void *data
)
698 efivar_entry_remove(entry
);
699 efivar_unregister(entry
);
703 static void efivars_sysfs_exit(void)
705 /* Remove all entries and destroy */
706 __efivar_entry_iter(efivar_sysfs_destroy
, &efivar_sysfs_list
, NULL
, NULL
);
709 sysfs_remove_bin_file(&efivars_kset
->kobj
, efivars_new_var
);
711 sysfs_remove_bin_file(&efivars_kset
->kobj
, efivars_del_var
);
712 kfree(efivars_new_var
);
713 kfree(efivars_del_var
);
714 kset_unregister(efivars_kset
);
717 int efivars_sysfs_init(void)
719 struct kobject
*parent_kobj
= efivars_kobject();
722 if (!efi_enabled(EFI_RUNTIME_SERVICES
))
725 /* No efivars has been registered yet */
729 printk(KERN_INFO
"EFI Variables Facility v%s %s\n", EFIVARS_VERSION
,
732 efivars_kset
= kset_create_and_add("vars", NULL
, parent_kobj
);
734 printk(KERN_ERR
"efivars: Subsystem registration failed.\n");
738 efivar_init(efivars_sysfs_callback
, NULL
, false,
739 true, &efivar_sysfs_list
);
741 error
= create_efivars_bin_attributes();
743 efivars_sysfs_exit();
747 INIT_WORK(&efivar_work
, efivar_update_sysfs_entries
);
751 EXPORT_SYMBOL_GPL(efivars_sysfs_init
);
753 module_init(efivars_sysfs_init
);
754 module_exit(efivars_sysfs_exit
);