2 * EFI Variables - 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/capability.h>
69 #include <linux/types.h>
70 #include <linux/errno.h>
71 #include <linux/init.h>
73 #include <linux/module.h>
74 #include <linux/string.h>
75 #include <linux/smp.h>
76 #include <linux/efi.h>
77 #include <linux/sysfs.h>
78 #include <linux/kobject.h>
79 #include <linux/device.h>
80 #include <linux/slab.h>
81 #include <linux/pstore.h>
83 #include <asm/uaccess.h>
85 #define EFIVARS_VERSION "0.08"
86 #define EFIVARS_DATE "2004-May-17"
88 MODULE_AUTHOR("Matt Domsch <Matt_Domsch@Dell.com>");
89 MODULE_DESCRIPTION("sysfs interface to EFI Variables");
90 MODULE_LICENSE("GPL");
91 MODULE_VERSION(EFIVARS_VERSION
);
93 #define DUMP_NAME_LEN 52
96 * The maximum size of VariableName + Data = 1024
97 * Therefore, it's reasonable to save that much
98 * space in each part of the structure,
99 * and we use a page for reading/writing.
102 struct efi_variable
{
103 efi_char16_t VariableName
[1024/sizeof(efi_char16_t
)];
104 efi_guid_t VendorGuid
;
105 unsigned long DataSize
;
109 } __attribute__((packed
));
112 struct efivar_entry
{
113 struct efivars
*efivars
;
114 struct efi_variable var
;
115 struct list_head list
;
119 struct efivar_attribute
{
120 struct attribute attr
;
121 ssize_t (*show
) (struct efivar_entry
*entry
, char *buf
);
122 ssize_t (*store
)(struct efivar_entry
*entry
, const char *buf
, size_t count
);
125 #define PSTORE_EFI_ATTRIBUTES \
126 (EFI_VARIABLE_NON_VOLATILE | \
127 EFI_VARIABLE_BOOTSERVICE_ACCESS | \
128 EFI_VARIABLE_RUNTIME_ACCESS)
130 #define EFIVAR_ATTR(_name, _mode, _show, _store) \
131 struct efivar_attribute efivar_attr_##_name = { \
132 .attr = {.name = __stringify(_name), .mode = _mode}, \
137 #define to_efivar_attr(_attr) container_of(_attr, struct efivar_attribute, attr)
138 #define to_efivar_entry(obj) container_of(obj, struct efivar_entry, kobj)
141 * Prototype for sysfs creation function
144 efivar_create_sysfs_entry(struct efivars
*efivars
,
145 unsigned long variable_name_size
,
146 efi_char16_t
*variable_name
,
147 efi_guid_t
*vendor_guid
);
149 /* Return the number of unicode characters in data */
151 utf16_strnlen(efi_char16_t
*s
, size_t maxlength
)
153 unsigned long length
= 0;
155 while (*s
++ != 0 && length
< maxlength
)
160 static inline unsigned long
161 utf16_strlen(efi_char16_t
*s
)
163 return utf16_strnlen(s
, ~0UL);
167 * Return the number of bytes is the length of this string
168 * Note: this is NOT the same as the number of unicode characters
170 static inline unsigned long
171 utf16_strsize(efi_char16_t
*data
, unsigned long maxlength
)
173 return utf16_strnlen(data
, maxlength
/sizeof(efi_char16_t
)) * sizeof(efi_char16_t
);
177 utf16_strncmp(const efi_char16_t
*a
, const efi_char16_t
*b
, size_t len
)
186 if (*a
== 0) /* implies *b == 0 */
195 get_var_data_locked(struct efivars
*efivars
, struct efi_variable
*var
)
199 var
->DataSize
= 1024;
200 status
= efivars
->ops
->get_variable(var
->VariableName
,
209 get_var_data(struct efivars
*efivars
, struct efi_variable
*var
)
213 spin_lock(&efivars
->lock
);
214 status
= get_var_data_locked(efivars
, var
);
215 spin_unlock(&efivars
->lock
);
217 if (status
!= EFI_SUCCESS
) {
218 printk(KERN_WARNING
"efivars: get_variable() failed 0x%lx!\n",
225 efivar_guid_read(struct efivar_entry
*entry
, char *buf
)
227 struct efi_variable
*var
= &entry
->var
;
233 efi_guid_unparse(&var
->VendorGuid
, str
);
235 str
+= sprintf(str
, "\n");
241 efivar_attr_read(struct efivar_entry
*entry
, char *buf
)
243 struct efi_variable
*var
= &entry
->var
;
250 status
= get_var_data(entry
->efivars
, var
);
251 if (status
!= EFI_SUCCESS
)
254 if (var
->Attributes
& 0x1)
255 str
+= sprintf(str
, "EFI_VARIABLE_NON_VOLATILE\n");
256 if (var
->Attributes
& 0x2)
257 str
+= sprintf(str
, "EFI_VARIABLE_BOOTSERVICE_ACCESS\n");
258 if (var
->Attributes
& 0x4)
259 str
+= sprintf(str
, "EFI_VARIABLE_RUNTIME_ACCESS\n");
264 efivar_size_read(struct efivar_entry
*entry
, char *buf
)
266 struct efi_variable
*var
= &entry
->var
;
273 status
= get_var_data(entry
->efivars
, var
);
274 if (status
!= EFI_SUCCESS
)
277 str
+= sprintf(str
, "0x%lx\n", var
->DataSize
);
282 efivar_data_read(struct efivar_entry
*entry
, char *buf
)
284 struct efi_variable
*var
= &entry
->var
;
290 status
= get_var_data(entry
->efivars
, var
);
291 if (status
!= EFI_SUCCESS
)
294 memcpy(buf
, var
->Data
, var
->DataSize
);
295 return var
->DataSize
;
298 * We allow each variable to be edited via rewriting the
299 * entire efi variable structure.
302 efivar_store_raw(struct efivar_entry
*entry
, const char *buf
, size_t count
)
304 struct efi_variable
*new_var
, *var
= &entry
->var
;
305 struct efivars
*efivars
= entry
->efivars
;
306 efi_status_t status
= EFI_NOT_FOUND
;
308 if (count
!= sizeof(struct efi_variable
))
311 new_var
= (struct efi_variable
*)buf
;
313 * If only updating the variable data, then the name
314 * and guid should remain the same
316 if (memcmp(new_var
->VariableName
, var
->VariableName
, sizeof(var
->VariableName
)) ||
317 efi_guidcmp(new_var
->VendorGuid
, var
->VendorGuid
)) {
318 printk(KERN_ERR
"efivars: Cannot edit the wrong variable!\n");
322 if ((new_var
->DataSize
<= 0) || (new_var
->Attributes
== 0)){
323 printk(KERN_ERR
"efivars: DataSize & Attributes must be valid!\n");
327 spin_lock(&efivars
->lock
);
328 status
= efivars
->ops
->set_variable(new_var
->VariableName
,
329 &new_var
->VendorGuid
,
334 spin_unlock(&efivars
->lock
);
336 if (status
!= EFI_SUCCESS
) {
337 printk(KERN_WARNING
"efivars: set_variable() failed: status=%lx\n",
342 memcpy(&entry
->var
, new_var
, count
);
347 efivar_show_raw(struct efivar_entry
*entry
, char *buf
)
349 struct efi_variable
*var
= &entry
->var
;
355 status
= get_var_data(entry
->efivars
, var
);
356 if (status
!= EFI_SUCCESS
)
359 memcpy(buf
, var
, sizeof(*var
));
364 * Generic read/write functions that call the specific functions of
367 static ssize_t
efivar_attr_show(struct kobject
*kobj
, struct attribute
*attr
,
370 struct efivar_entry
*var
= to_efivar_entry(kobj
);
371 struct efivar_attribute
*efivar_attr
= to_efivar_attr(attr
);
374 if (!capable(CAP_SYS_ADMIN
))
377 if (efivar_attr
->show
) {
378 ret
= efivar_attr
->show(var
, buf
);
383 static ssize_t
efivar_attr_store(struct kobject
*kobj
, struct attribute
*attr
,
384 const char *buf
, size_t count
)
386 struct efivar_entry
*var
= to_efivar_entry(kobj
);
387 struct efivar_attribute
*efivar_attr
= to_efivar_attr(attr
);
390 if (!capable(CAP_SYS_ADMIN
))
393 if (efivar_attr
->store
)
394 ret
= efivar_attr
->store(var
, buf
, count
);
399 static const struct sysfs_ops efivar_attr_ops
= {
400 .show
= efivar_attr_show
,
401 .store
= efivar_attr_store
,
404 static void efivar_release(struct kobject
*kobj
)
406 struct efivar_entry
*var
= container_of(kobj
, struct efivar_entry
, kobj
);
410 static EFIVAR_ATTR(guid
, 0400, efivar_guid_read
, NULL
);
411 static EFIVAR_ATTR(attributes
, 0400, efivar_attr_read
, NULL
);
412 static EFIVAR_ATTR(size
, 0400, efivar_size_read
, NULL
);
413 static EFIVAR_ATTR(data
, 0400, efivar_data_read
, NULL
);
414 static EFIVAR_ATTR(raw_var
, 0600, efivar_show_raw
, efivar_store_raw
);
416 static struct attribute
*def_attrs
[] = {
417 &efivar_attr_guid
.attr
,
418 &efivar_attr_size
.attr
,
419 &efivar_attr_attributes
.attr
,
420 &efivar_attr_data
.attr
,
421 &efivar_attr_raw_var
.attr
,
425 static struct kobj_type efivar_ktype
= {
426 .release
= efivar_release
,
427 .sysfs_ops
= &efivar_attr_ops
,
428 .default_attrs
= def_attrs
,
431 static struct pstore_info efi_pstore_info
;
434 efivar_unregister(struct efivar_entry
*var
)
436 kobject_put(&var
->kobj
);
441 static int efi_pstore_open(struct pstore_info
*psi
)
443 struct efivars
*efivars
= psi
->data
;
445 spin_lock(&efivars
->lock
);
446 efivars
->walk_entry
= list_first_entry(&efivars
->list
,
447 struct efivar_entry
, list
);
451 static int efi_pstore_close(struct pstore_info
*psi
)
453 struct efivars
*efivars
= psi
->data
;
455 spin_unlock(&efivars
->lock
);
459 static ssize_t
efi_pstore_read(u64
*id
, enum pstore_type_id
*type
,
460 struct timespec
*timespec
, struct pstore_info
*psi
)
462 efi_guid_t vendor
= LINUX_EFI_CRASH_GUID
;
463 struct efivars
*efivars
= psi
->data
;
464 char name
[DUMP_NAME_LEN
];
466 unsigned int part
, size
;
469 while (&efivars
->walk_entry
->list
!= &efivars
->list
) {
470 if (!efi_guidcmp(efivars
->walk_entry
->var
.VendorGuid
,
472 for (i
= 0; i
< DUMP_NAME_LEN
; i
++) {
473 name
[i
] = efivars
->walk_entry
->var
.VariableName
[i
];
475 if (sscanf(name
, "dump-type%u-%u-%lu", type
, &part
, &time
) == 3) {
477 timespec
->tv_sec
= time
;
478 timespec
->tv_nsec
= 0;
479 get_var_data_locked(efivars
, &efivars
->walk_entry
->var
);
480 size
= efivars
->walk_entry
->var
.DataSize
;
481 memcpy(psi
->buf
, efivars
->walk_entry
->var
.Data
, size
);
482 efivars
->walk_entry
= list_entry(efivars
->walk_entry
->list
.next
,
483 struct efivar_entry
, list
);
487 efivars
->walk_entry
= list_entry(efivars
->walk_entry
->list
.next
,
488 struct efivar_entry
, list
);
493 static u64
efi_pstore_write(enum pstore_type_id type
, unsigned int part
,
494 size_t size
, struct pstore_info
*psi
)
496 char name
[DUMP_NAME_LEN
];
497 char stub_name
[DUMP_NAME_LEN
];
498 efi_char16_t efi_name
[DUMP_NAME_LEN
];
499 efi_guid_t vendor
= LINUX_EFI_CRASH_GUID
;
500 struct efivars
*efivars
= psi
->data
;
501 struct efivar_entry
*entry
, *found
= NULL
;
504 sprintf(stub_name
, "dump-type%u-%u-", type
, part
);
505 sprintf(name
, "%s%lu", stub_name
, get_seconds());
507 spin_lock(&efivars
->lock
);
509 for (i
= 0; i
< DUMP_NAME_LEN
; i
++)
510 efi_name
[i
] = stub_name
[i
];
513 * Clean up any entries with the same name
516 list_for_each_entry(entry
, &efivars
->list
, list
) {
517 get_var_data_locked(efivars
, &entry
->var
);
519 if (efi_guidcmp(entry
->var
.VendorGuid
, vendor
))
521 if (utf16_strncmp(entry
->var
.VariableName
, efi_name
,
522 utf16_strlen(efi_name
)))
524 /* Needs to be a prefix */
525 if (entry
->var
.VariableName
[utf16_strlen(efi_name
)] == 0)
530 efivars
->ops
->set_variable(entry
->var
.VariableName
,
531 &entry
->var
.VendorGuid
,
532 PSTORE_EFI_ATTRIBUTES
,
537 list_del(&found
->list
);
539 for (i
= 0; i
< DUMP_NAME_LEN
; i
++)
540 efi_name
[i
] = name
[i
];
542 efivars
->ops
->set_variable(efi_name
, &vendor
, PSTORE_EFI_ATTRIBUTES
,
545 spin_unlock(&efivars
->lock
);
548 efivar_unregister(found
);
551 efivar_create_sysfs_entry(efivars
,
552 utf16_strsize(efi_name
,
559 static int efi_pstore_erase(enum pstore_type_id type
, u64 id
,
560 struct pstore_info
*psi
)
562 efi_pstore_write(type
, id
, 0, psi
);
567 static int efi_pstore_open(struct pstore_info
*psi
)
572 static int efi_pstore_close(struct pstore_info
*psi
)
577 static ssize_t
efi_pstore_read(u64
*id
, enum pstore_type_id
*type
,
578 struct timespec
*time
, struct pstore_info
*psi
)
583 static u64
efi_pstore_write(enum pstore_type_id type
, unsigned int part
,
584 size_t size
, struct pstore_info
*psi
)
589 static int efi_pstore_erase(enum pstore_type_id type
, u64 id
,
590 struct pstore_info
*psi
)
596 static struct pstore_info efi_pstore_info
= {
597 .owner
= THIS_MODULE
,
599 .open
= efi_pstore_open
,
600 .close
= efi_pstore_close
,
601 .read
= efi_pstore_read
,
602 .write
= efi_pstore_write
,
603 .erase
= efi_pstore_erase
,
606 static ssize_t
efivar_create(struct file
*filp
, struct kobject
*kobj
,
607 struct bin_attribute
*bin_attr
,
608 char *buf
, loff_t pos
, size_t count
)
610 struct efi_variable
*new_var
= (struct efi_variable
*)buf
;
611 struct efivars
*efivars
= bin_attr
->private;
612 struct efivar_entry
*search_efivar
, *n
;
613 unsigned long strsize1
, strsize2
;
614 efi_status_t status
= EFI_NOT_FOUND
;
617 if (!capable(CAP_SYS_ADMIN
))
620 spin_lock(&efivars
->lock
);
623 * Does this variable already exist?
625 list_for_each_entry_safe(search_efivar
, n
, &efivars
->list
, list
) {
626 strsize1
= utf16_strsize(search_efivar
->var
.VariableName
, 1024);
627 strsize2
= utf16_strsize(new_var
->VariableName
, 1024);
628 if (strsize1
== strsize2
&&
629 !memcmp(&(search_efivar
->var
.VariableName
),
630 new_var
->VariableName
, strsize1
) &&
631 !efi_guidcmp(search_efivar
->var
.VendorGuid
,
632 new_var
->VendorGuid
)) {
638 spin_unlock(&efivars
->lock
);
642 /* now *really* create the variable via EFI */
643 status
= efivars
->ops
->set_variable(new_var
->VariableName
,
644 &new_var
->VendorGuid
,
649 if (status
!= EFI_SUCCESS
) {
650 printk(KERN_WARNING
"efivars: set_variable() failed: status=%lx\n",
652 spin_unlock(&efivars
->lock
);
655 spin_unlock(&efivars
->lock
);
657 /* Create the entry in sysfs. Locking is not required here */
658 status
= efivar_create_sysfs_entry(efivars
,
659 utf16_strsize(new_var
->VariableName
,
661 new_var
->VariableName
,
662 &new_var
->VendorGuid
);
664 printk(KERN_WARNING
"efivars: variable created, but sysfs entry wasn't.\n");
669 static ssize_t
efivar_delete(struct file
*filp
, struct kobject
*kobj
,
670 struct bin_attribute
*bin_attr
,
671 char *buf
, loff_t pos
, size_t count
)
673 struct efi_variable
*del_var
= (struct efi_variable
*)buf
;
674 struct efivars
*efivars
= bin_attr
->private;
675 struct efivar_entry
*search_efivar
, *n
;
676 unsigned long strsize1
, strsize2
;
677 efi_status_t status
= EFI_NOT_FOUND
;
680 if (!capable(CAP_SYS_ADMIN
))
683 spin_lock(&efivars
->lock
);
686 * Does this variable already exist?
688 list_for_each_entry_safe(search_efivar
, n
, &efivars
->list
, list
) {
689 strsize1
= utf16_strsize(search_efivar
->var
.VariableName
, 1024);
690 strsize2
= utf16_strsize(del_var
->VariableName
, 1024);
691 if (strsize1
== strsize2
&&
692 !memcmp(&(search_efivar
->var
.VariableName
),
693 del_var
->VariableName
, strsize1
) &&
694 !efi_guidcmp(search_efivar
->var
.VendorGuid
,
695 del_var
->VendorGuid
)) {
701 spin_unlock(&efivars
->lock
);
704 /* force the Attributes/DataSize to 0 to ensure deletion */
705 del_var
->Attributes
= 0;
706 del_var
->DataSize
= 0;
708 status
= efivars
->ops
->set_variable(del_var
->VariableName
,
709 &del_var
->VendorGuid
,
714 if (status
!= EFI_SUCCESS
) {
715 printk(KERN_WARNING
"efivars: set_variable() failed: status=%lx\n",
717 spin_unlock(&efivars
->lock
);
720 list_del(&search_efivar
->list
);
721 /* We need to release this lock before unregistering. */
722 spin_unlock(&efivars
->lock
);
723 efivar_unregister(search_efivar
);
725 /* It's dead Jim.... */
730 * Let's not leave out systab information that snuck into
733 static ssize_t
systab_show(struct kobject
*kobj
,
734 struct kobj_attribute
*attr
, char *buf
)
741 if (efi
.mps
!= EFI_INVALID_TABLE_ADDR
)
742 str
+= sprintf(str
, "MPS=0x%lx\n", efi
.mps
);
743 if (efi
.acpi20
!= EFI_INVALID_TABLE_ADDR
)
744 str
+= sprintf(str
, "ACPI20=0x%lx\n", efi
.acpi20
);
745 if (efi
.acpi
!= EFI_INVALID_TABLE_ADDR
)
746 str
+= sprintf(str
, "ACPI=0x%lx\n", efi
.acpi
);
747 if (efi
.smbios
!= EFI_INVALID_TABLE_ADDR
)
748 str
+= sprintf(str
, "SMBIOS=0x%lx\n", efi
.smbios
);
749 if (efi
.hcdp
!= EFI_INVALID_TABLE_ADDR
)
750 str
+= sprintf(str
, "HCDP=0x%lx\n", efi
.hcdp
);
751 if (efi
.boot_info
!= EFI_INVALID_TABLE_ADDR
)
752 str
+= sprintf(str
, "BOOTINFO=0x%lx\n", efi
.boot_info
);
753 if (efi
.uga
!= EFI_INVALID_TABLE_ADDR
)
754 str
+= sprintf(str
, "UGA=0x%lx\n", efi
.uga
);
759 static struct kobj_attribute efi_attr_systab
=
760 __ATTR(systab
, 0400, systab_show
, NULL
);
762 static struct attribute
*efi_subsys_attrs
[] = {
763 &efi_attr_systab
.attr
,
764 NULL
, /* maybe more in the future? */
767 static struct attribute_group efi_subsys_attr_group
= {
768 .attrs
= efi_subsys_attrs
,
771 static struct kobject
*efi_kobj
;
774 * efivar_create_sysfs_entry()
776 * variable_name_size = number of bytes required to hold
777 * variable_name (not counting the NULL
778 * character at the end.
779 * efivars->lock is not held on entry or exit.
780 * Returns 1 on failure, 0 on success
783 efivar_create_sysfs_entry(struct efivars
*efivars
,
784 unsigned long variable_name_size
,
785 efi_char16_t
*variable_name
,
786 efi_guid_t
*vendor_guid
)
788 int i
, short_name_size
= variable_name_size
/ sizeof(efi_char16_t
) + 38;
790 struct efivar_entry
*new_efivar
;
792 short_name
= kzalloc(short_name_size
+ 1, GFP_KERNEL
);
793 new_efivar
= kzalloc(sizeof(struct efivar_entry
), GFP_KERNEL
);
795 if (!short_name
|| !new_efivar
) {
801 new_efivar
->efivars
= efivars
;
802 memcpy(new_efivar
->var
.VariableName
, variable_name
,
804 memcpy(&(new_efivar
->var
.VendorGuid
), vendor_guid
, sizeof(efi_guid_t
));
806 /* Convert Unicode to normal chars (assume top bits are 0),
808 for (i
=0; i
< (int)(variable_name_size
/ sizeof(efi_char16_t
)); i
++) {
809 short_name
[i
] = variable_name
[i
] & 0xFF;
811 /* This is ugly, but necessary to separate one vendor's
812 private variables from another's. */
814 *(short_name
+ strlen(short_name
)) = '-';
815 efi_guid_unparse(vendor_guid
, short_name
+ strlen(short_name
));
817 new_efivar
->kobj
.kset
= efivars
->kset
;
818 i
= kobject_init_and_add(&new_efivar
->kobj
, &efivar_ktype
, NULL
,
826 kobject_uevent(&new_efivar
->kobj
, KOBJ_ADD
);
830 spin_lock(&efivars
->lock
);
831 list_add(&new_efivar
->list
, &efivars
->list
);
832 spin_unlock(&efivars
->lock
);
838 create_efivars_bin_attributes(struct efivars
*efivars
)
840 struct bin_attribute
*attr
;
844 attr
= kzalloc(sizeof(*attr
), GFP_KERNEL
);
848 attr
->attr
.name
= "new_var";
849 attr
->attr
.mode
= 0200;
850 attr
->write
= efivar_create
;
851 attr
->private = efivars
;
852 efivars
->new_var
= attr
;
855 attr
= kzalloc(sizeof(*attr
), GFP_KERNEL
);
860 attr
->attr
.name
= "del_var";
861 attr
->attr
.mode
= 0200;
862 attr
->write
= efivar_delete
;
863 attr
->private = efivars
;
864 efivars
->del_var
= attr
;
866 sysfs_bin_attr_init(efivars
->new_var
);
867 sysfs_bin_attr_init(efivars
->del_var
);
870 error
= sysfs_create_bin_file(&efivars
->kset
->kobj
,
873 printk(KERN_ERR
"efivars: unable to create new_var sysfs file"
874 " due to error %d\n", error
);
877 error
= sysfs_create_bin_file(&efivars
->kset
->kobj
,
880 printk(KERN_ERR
"efivars: unable to create del_var sysfs file"
881 " due to error %d\n", error
);
882 sysfs_remove_bin_file(&efivars
->kset
->kobj
,
889 kfree(efivars
->del_var
);
890 efivars
->del_var
= NULL
;
891 kfree(efivars
->new_var
);
892 efivars
->new_var
= NULL
;
896 void unregister_efivars(struct efivars
*efivars
)
898 struct efivar_entry
*entry
, *n
;
900 list_for_each_entry_safe(entry
, n
, &efivars
->list
, list
) {
901 spin_lock(&efivars
->lock
);
902 list_del(&entry
->list
);
903 spin_unlock(&efivars
->lock
);
904 efivar_unregister(entry
);
906 if (efivars
->new_var
)
907 sysfs_remove_bin_file(&efivars
->kset
->kobj
, efivars
->new_var
);
908 if (efivars
->del_var
)
909 sysfs_remove_bin_file(&efivars
->kset
->kobj
, efivars
->del_var
);
910 kfree(efivars
->new_var
);
911 kfree(efivars
->del_var
);
912 kset_unregister(efivars
->kset
);
914 EXPORT_SYMBOL_GPL(unregister_efivars
);
916 int register_efivars(struct efivars
*efivars
,
917 const struct efivar_operations
*ops
,
918 struct kobject
*parent_kobj
)
920 efi_status_t status
= EFI_NOT_FOUND
;
921 efi_guid_t vendor_guid
;
922 efi_char16_t
*variable_name
;
923 unsigned long variable_name_size
= 1024;
926 variable_name
= kzalloc(variable_name_size
, GFP_KERNEL
);
927 if (!variable_name
) {
928 printk(KERN_ERR
"efivars: Memory allocation failed.\n");
932 spin_lock_init(&efivars
->lock
);
933 INIT_LIST_HEAD(&efivars
->list
);
936 efivars
->kset
= kset_create_and_add("vars", NULL
, parent_kobj
);
937 if (!efivars
->kset
) {
938 printk(KERN_ERR
"efivars: Subsystem registration failed.\n");
944 * Per EFI spec, the maximum storage allocated for both
945 * the variable name and variable data is 1024 bytes.
949 variable_name_size
= 1024;
951 status
= ops
->get_next_variable(&variable_name_size
,
956 efivar_create_sysfs_entry(efivars
,
964 printk(KERN_WARNING
"efivars: get_next_variable: status=%lx\n",
966 status
= EFI_NOT_FOUND
;
969 } while (status
!= EFI_NOT_FOUND
);
971 error
= create_efivars_bin_attributes(efivars
);
973 unregister_efivars(efivars
);
975 efivars
->efi_pstore_info
= efi_pstore_info
;
977 efivars
->efi_pstore_info
.buf
= kmalloc(4096, GFP_KERNEL
);
978 if (efivars
->efi_pstore_info
.buf
) {
979 efivars
->efi_pstore_info
.bufsize
= 1024;
980 efivars
->efi_pstore_info
.data
= efivars
;
981 spin_lock_init(&efivars
->efi_pstore_info
.buf_lock
);
982 pstore_register(&efivars
->efi_pstore_info
);
986 kfree(variable_name
);
990 EXPORT_SYMBOL_GPL(register_efivars
);
992 static struct efivars __efivars
;
993 static struct efivar_operations ops
;
996 * For now we register the efi subsystem with the firmware subsystem
997 * and the vars subsystem with the efi subsystem. In the future, it
998 * might make sense to split off the efi subsystem into its own
999 * driver, but for now only efivars will register with it, so just
1008 printk(KERN_INFO
"EFI Variables Facility v%s %s\n", EFIVARS_VERSION
,
1014 /* For now we'll register the efi directory at /sys/firmware/efi */
1015 efi_kobj
= kobject_create_and_add("efi", firmware_kobj
);
1017 printk(KERN_ERR
"efivars: Firmware registration failed.\n");
1021 ops
.get_variable
= efi
.get_variable
;
1022 ops
.set_variable
= efi
.set_variable
;
1023 ops
.get_next_variable
= efi
.get_next_variable
;
1024 error
= register_efivars(&__efivars
, &ops
, efi_kobj
);
1028 /* Don't forget the systab entry */
1029 error
= sysfs_create_group(efi_kobj
, &efi_subsys_attr_group
);
1032 "efivars: Sysfs attribute export failed with error %d.\n",
1034 goto err_unregister
;
1040 unregister_efivars(&__efivars
);
1042 kobject_put(efi_kobj
);
1050 unregister_efivars(&__efivars
);
1051 kobject_put(efi_kobj
);
1055 module_init(efivars_init
);
1056 module_exit(efivars_exit
);