From: Matt Tolentino Second efivars driver update patch that adds efivars into the drivers/firmware directory. --- 25-akpm/arch/ia64/Kconfig | 2 25-akpm/drivers/firmware/Kconfig | 18 25-akpm/drivers/firmware/Makefile | 1 25-akpm/drivers/firmware/efivars.c | 740 +++++++++++++++++++++++++++++++++++++ 4 files changed, 761 insertions(+) diff -puN arch/ia64/Kconfig~efivars-add-to-drivers-firmware arch/ia64/Kconfig --- 25/arch/ia64/Kconfig~efivars-add-to-drivers-firmware Thu Apr 22 14:07:55 2004 +++ 25-akpm/arch/ia64/Kconfig Thu Apr 22 14:07:55 2004 @@ -294,6 +294,8 @@ config IA64_PALINFO To use this option, you have to ensure that the "/proc file system support" (CONFIG_PROC_FS) is enabled, too. +source "drivers/firmware/Kconfig" + source "fs/Kconfig.binfmt" endmenu diff -puN /dev/null drivers/firmware/efivars.c --- /dev/null Thu Apr 11 07:25:15 2002 +++ 25-akpm/drivers/firmware/efivars.c Thu Apr 22 14:07:55 2004 @@ -0,0 +1,740 @@ +/* + * EFI Variables - efivars.c + * + * Copyright (C) 2001,2003 Dell + * Copyright (C) 2004 Intel Corporation + * + * This code takes all variables accessible from EFI runtime and + * exports them via sysfs + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + * Changelog: + * + * 21 Apr 2004 - Matt Tolentino + * fix locking per Peter Chubb's findings + * + * 25 Mar 2002 - Matt Domsch + * move uuid_unparse() to include/asm-ia64/efi.h:efi_guid_unparse() + * + * 12 Feb 2002 - Matt Domsch + * use list_for_each_safe when deleting vars. + * remove ifdef CONFIG_SMP around include + * v0.04 release to linux-ia64@linuxia64.org + * + * 20 April 2001 - Matt Domsch + * Moved vars from /proc/efi to /proc/efi/vars, and made + * efi.c own the /proc/efi directory. + * v0.03 release to linux-ia64@linuxia64.org + * + * 26 March 2001 - Matt Domsch + * At the request of Stephane, moved ownership of /proc/efi + * to efi.c, and now efivars lives under /proc/efi/vars. + * + * 12 March 2001 - Matt Domsch + * Feedback received from Stephane Eranian incorporated. + * efivar_write() checks copy_from_user() return value. + * efivar_read/write() returns proper errno. + * v0.02 release to linux-ia64@linuxia64.org + * + * 26 February 2001 - Matt Domsch + * v0.01 release to linux-ia64@linuxia64.org + */ + +#include +#include +#include +#include +#include /* for capable() */ +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +MODULE_AUTHOR("Matt Domsch "); +MODULE_DESCRIPTION("sysfs interface to EFI Variables"); +MODULE_LICENSE("GPL"); + +#define EFIVARS_VERSION "0.07 2003-Aug-29" + +/* + * efivars_lock protects two things: + * 1) efivar_list - adds, removals, reads, writes + * 2) efi.[gs]et_variable() calls. + * It must not be held when creating sysfs entries or calling kmalloc. + * efi.get_next_variable() is only called from efivars_init(), + * which is protected by the BKL, so that path is safe. + */ +static spinlock_t efivars_lock = SPIN_LOCK_UNLOCKED; +static LIST_HEAD(efivar_list); + +/* + * The maximum size of VariableName + Data = 1024 + * Therefore, it's reasonable to save that much + * space in each part of the structure, + * and we use a page for reading/writing. + */ + +struct efi_variable { + efi_char16_t VariableName[1024/sizeof(efi_char16_t)]; + efi_guid_t VendorGuid; + unsigned long DataSize; + __u8 Data[1024]; + efi_status_t Status; + __u32 Attributes; +} __attribute__((packed)); + + +struct efivar_entry { + struct efi_variable var; + struct list_head list; + struct kobject kobj; +}; + +#define get_efivar_entry(n) list_entry(n, struct efivar_entry, list) + +struct efivar_attribute { + struct attribute attr; + ssize_t (*show) (struct efivar_entry *entry, char *buf); + ssize_t (*store)(struct efivar_entry *entry, const char *buf, size_t count); +}; + + +#define EFI_ATTR(_name, _mode, _show, _store) \ +struct subsys_attribute efi_attr_##_name = { \ + .attr {.name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE}, \ + .show = _show, \ + .store = _store, \ +}; + +#define EFIVAR_ATTR(_name, _mode, _show, _store) \ +struct efivar_attribute efivar_attr_##_name = { \ + .attr = {.name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE}, \ + .show = _show, \ + .store = _store, \ +}; + +#define VAR_SUBSYS_ATTR(_name, _mode, _show, _store) \ +struct subsys_attribute var_subsys_attr_##_name = { \ + .attr = {.name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE}, \ + .show = _show, \ + .store = _store, \ +}; + +#define to_efivar_attr(_attr) container_of(_attr, struct efivar_attribute, attr) +#define to_efivar_entry(obj) container_of(obj, struct efivar_entry, kobj) + +/* + * Prototype for sysfs creation function + */ +static int +efivar_create_sysfs_entry(unsigned long variable_name_size, + efi_char16_t *variable_name, + efi_guid_t *vendor_guid); + +/* Return the number of unicode characters in data */ +static unsigned long +utf8_strlen(efi_char16_t *data, unsigned long maxlength) +{ + unsigned long length = 0; + + while (*data++ != 0 && length < maxlength) + length++; + return length; +} + +/* + * Return the number of bytes is the length of this string + * Note: this is NOT the same as the number of unicode characters + */ +static inline unsigned long +utf8_strsize(efi_char16_t *data, unsigned long maxlength) +{ + return utf8_strlen(data, maxlength/sizeof(efi_char16_t)) * sizeof(efi_char16_t); +} + +static efi_status_t +get_var_data(struct efi_variable *var) +{ + efi_status_t status; + + spin_lock(&efivars_lock); + var->DataSize = 1024; + status = efi.get_variable(var->VariableName, + &var->VendorGuid, + &var->Attributes, + &var->DataSize, + var->Data); + spin_unlock(&efivars_lock); + if (status != EFI_SUCCESS) { + printk(KERN_WARNING "efivars: get_variable() failed 0x%lx!\n", + status); + } + return status; +} + +static ssize_t +efivar_guid_read(struct efivar_entry *entry, char *buf) +{ + struct efi_variable *var = &entry->var; + char *str = buf; + + if (!entry || !buf) + return 0; + + efi_guid_unparse(&var->VendorGuid, str); + str += strlen(str); + str += sprintf(str, "\n"); + + return str - buf; +} + +static ssize_t +efivar_attr_read(struct efivar_entry *entry, char *buf) +{ + struct efi_variable *var = &entry->var; + char *str = buf; + efi_status_t status; + + if (!entry || !buf) + return -EINVAL; + + status = get_var_data(var); + if (status != EFI_SUCCESS) + return -EIO; + + if (var->Attributes & 0x1) + str += sprintf(str, "EFI_VARIABLE_NON_VOLATILE\n"); + if (var->Attributes & 0x2) + str += sprintf(str, "EFI_VARIABLE_BOOTSERVICE_ACCESS\n"); + if (var->Attributes & 0x4) + str += sprintf(str, "EFI_VARIABLE_RUNTIME_ACCESS\n"); + return str - buf; +} + +static ssize_t +efivar_size_read(struct efivar_entry *entry, char *buf) +{ + struct efi_variable *var = &entry->var; + char *str = buf; + efi_status_t status; + + if (!entry || !buf) + return -EINVAL; + + status = get_var_data(var); + if (status != EFI_SUCCESS) + return -EIO; + + str += sprintf(str, "0x%lx\n", var->DataSize); + return str - buf; +} + +static ssize_t +efivar_data_read(struct efivar_entry *entry, char *buf) +{ + struct efi_variable *var = &entry->var; + efi_status_t status; + + if (!entry || !buf) + return -EINVAL; + + status = get_var_data(var); + if (status != EFI_SUCCESS) + return -EIO; + + memcpy(buf, var->Data, var->DataSize); + return var->DataSize; +} +/* + * We allow each variable to be edited via rewriting the + * entire efi variable structure. + */ +static ssize_t +efivar_store_raw(struct efivar_entry *entry, const char *buf, size_t count) +{ + struct efi_variable *new_var, *var = &entry->var; + efi_status_t status = EFI_NOT_FOUND; + + if (count != sizeof(struct efi_variable)) + return -EINVAL; + + new_var = (struct efi_variable *)buf; + /* + * If only updating the variable data, then the name + * and guid should remain the same + */ + if (memcmp(new_var->VariableName, var->VariableName, sizeof(var->VariableName)) || + efi_guidcmp(new_var->VendorGuid, var->VendorGuid)) { + printk(KERN_ERR "efivars: Cannot edit the wrong variable!\n"); + return -EINVAL; + } + + if ((new_var->DataSize <= 0) || (new_var->Attributes == 0)){ + printk(KERN_ERR "efivars: DataSize & Attributes must be valid!\n"); + return -EINVAL; + } + + spin_lock(&efivars_lock); + status = efi.set_variable(new_var->VariableName, + &new_var->VendorGuid, + new_var->Attributes, + new_var->DataSize, + new_var->Data); + + spin_unlock(&efivars_lock); + + if (status != EFI_SUCCESS) { + printk(KERN_WARNING "efivars: set_variable() failed: status=%lx\n", + status); + return -EIO; + } + + memcpy(&entry->var, new_var, count); + return count; +} + +static ssize_t +efivar_show_raw(struct efivar_entry *entry, char *buf) +{ + struct efi_variable *var = &entry->var; + efi_status_t status; + + if (!entry || !buf) + return 0; + + status = get_var_data(var); + if (status != EFI_SUCCESS) + return -EIO; + + memcpy(buf, var, sizeof(*var)); + return sizeof(*var); +} + +/* + * Generic read/write functions that call the specific functions of + * the atttributes... + */ +static ssize_t efivar_attr_show(struct kobject *kobj, struct attribute *attr, + char *buf) +{ + struct efivar_entry *var = to_efivar_entry(kobj); + struct efivar_attribute *efivar_attr = to_efivar_attr(attr); + ssize_t ret = 0; + + if (!capable(CAP_SYS_ADMIN)) + return -EACCES; + + if (efivar_attr->show) { + ret = efivar_attr->show(var, buf); + } + return ret; +} + +static ssize_t efivar_attr_store(struct kobject *kobj, struct attribute *attr, + const char *buf, size_t count) +{ + struct efivar_entry *var = to_efivar_entry(kobj); + struct efivar_attribute *efivar_attr = to_efivar_attr(attr); + ssize_t ret = 0; + + if (!capable(CAP_SYS_ADMIN)) + return -EACCES; + + if (efivar_attr->store) + ret = efivar_attr->store(var, buf, count); + + return ret; +} + +static struct sysfs_ops efivar_attr_ops = { + .show = efivar_attr_show, + .store = efivar_attr_store, +}; + +static void efivar_release(struct kobject *kobj) +{ + struct efivar_entry *var = container_of(kobj, struct efivar_entry, kobj); + spin_lock(&efivars_lock); + list_del(&var->list); + spin_unlock(&efivars_lock); + kfree(var); +} + +static EFIVAR_ATTR(guid, 0400, efivar_guid_read, NULL); +static EFIVAR_ATTR(attributes, 0400, efivar_attr_read, NULL); +static EFIVAR_ATTR(size, 0400, efivar_size_read, NULL); +static EFIVAR_ATTR(data, 0400, efivar_data_read, NULL); +static EFIVAR_ATTR(raw_var, 0600, efivar_show_raw, efivar_store_raw); + +static struct attribute *def_attrs[] = { + &efivar_attr_guid.attr, + &efivar_attr_size.attr, + &efivar_attr_attributes.attr, + &efivar_attr_data.attr, + &efivar_attr_raw_var.attr, + NULL, +}; + +static struct kobj_type ktype_efivar = { + .release = efivar_release, + .sysfs_ops = &efivar_attr_ops, + .default_attrs = def_attrs, +}; + +static ssize_t +dummy(struct subsystem *sub, char *buf) +{ + return 0; +} + +static inline void +efivar_unregister(struct efivar_entry *var) +{ + kobject_unregister(&var->kobj); +} + + +static ssize_t +efivar_create(struct subsystem *sub, const char *buf, size_t count) +{ + struct efi_variable *new_var = (struct efi_variable *)buf; + struct efivar_entry *search_efivar = NULL; + unsigned long strsize1, strsize2; + struct list_head *pos, *n; + efi_status_t status = EFI_NOT_FOUND; + int found = 0; + + if (!capable(CAP_SYS_ADMIN)) + return -EACCES; + + spin_lock(&efivars_lock); + + /* + * Does this variable already exist? + */ + list_for_each_safe(pos, n, &efivar_list) { + search_efivar = get_efivar_entry(pos); + strsize1 = utf8_strsize(search_efivar->var.VariableName, 1024); + strsize2 = utf8_strsize(new_var->VariableName, 1024); + if (strsize1 == strsize2 && + !memcmp(&(search_efivar->var.VariableName), + new_var->VariableName, strsize1) && + !efi_guidcmp(search_efivar->var.VendorGuid, + new_var->VendorGuid)) { + found = 1; + break; + } + } + if (found) { + spin_unlock(&efivars_lock); + return -EINVAL; + } + + /* now *really* create the variable via EFI */ + status = efi.set_variable(new_var->VariableName, + &new_var->VendorGuid, + new_var->Attributes, + new_var->DataSize, + new_var->Data); + + if (status != EFI_SUCCESS) { + printk(KERN_WARNING "efivars: set_variable() failed: status=%lx\n", + status); + spin_unlock(&efivars_lock); + return -EIO; + } + spin_unlock(&efivars_lock); + + /* Create the entry in sysfs. Locking is not required here */ + status = efivar_create_sysfs_entry(utf8_strsize(new_var->VariableName, + 1024), new_var->VariableName, &new_var->VendorGuid); + return status; +} + +static ssize_t +efivar_delete(struct subsystem *sub, const char *buf, size_t count) +{ + struct efi_variable *del_var = (struct efi_variable *)buf; + struct efivar_entry *search_efivar = NULL; + unsigned long strsize1, strsize2; + struct list_head *pos, *n; + efi_status_t status = EFI_NOT_FOUND; + int found = 0; + + if (!capable(CAP_SYS_ADMIN)) + return -EACCES; + + spin_lock(&efivars_lock); + + /* + * Does this variable already exist? + */ + list_for_each_safe(pos, n, &efivar_list) { + search_efivar = get_efivar_entry(pos); + strsize1 = utf8_strsize(search_efivar->var.VariableName, 1024); + strsize2 = utf8_strsize(del_var->VariableName, 1024); + if (strsize1 == strsize2 && + !memcmp(&(search_efivar->var.VariableName), + del_var->VariableName, strsize1) && + !efi_guidcmp(search_efivar->var.VendorGuid, + del_var->VendorGuid)) { + found = 1; + break; + } + } + if (!found) { + spin_unlock(&efivars_lock); + return -EINVAL; + } + /* force the Attributes/DataSize to 0 to ensure deletion */ + del_var->Attributes = 0; + del_var->DataSize = 0; + + status = efi.set_variable(del_var->VariableName, + &del_var->VendorGuid, + del_var->Attributes, + del_var->DataSize, + del_var->Data); + + if (status != EFI_SUCCESS) { + printk(KERN_WARNING "efivars: set_variable() failed: status=%lx\n", + status); + spin_unlock(&efivars_lock); + return -EIO; + } + /* We need to release this lock before unregistering. */ + spin_unlock(&efivars_lock); + + efivar_unregister(search_efivar); + + /* It's dead Jim.... */ + return status; +} + +static VAR_SUBSYS_ATTR(new_var, 0200, dummy, efivar_create); +static VAR_SUBSYS_ATTR(del_var, 0200, dummy, efivar_delete); + +static struct subsys_attribute *var_subsys_attrs[] = { + &var_subsys_attr_new_var, + &var_subsys_attr_del_var, + NULL, +}; + +/* + * Let's not leave out systab information that snuck into + * the efivars driver + */ +static ssize_t +systab_read(struct subsystem *entry, char *buf) +{ + char *str = buf; + + if (!entry || !buf) + return -EINVAL; + + if (efi.mps) + str += sprintf(str, "MPS=0x%lx\n", __pa(efi.mps)); + if (efi.acpi20) + str += sprintf(str, "ACPI20=0x%lx\n", __pa(efi.acpi20)); + if (efi.acpi) + str += sprintf(str, "ACPI=0x%lx\n", __pa(efi.acpi)); + if (efi.smbios) + str += sprintf(str, "SMBIOS=0x%lx\n", __pa(efi.smbios)); + if (efi.hcdp) + str += sprintf(str, "HCDP=0x%lx\n", __pa(efi.hcdp)); + if (efi.boot_info) + str += sprintf(str, "BOOTINFO=0x%lx\n", __pa(efi.boot_info)); + if (efi.uga) + str += sprintf(str, "UGA=0x%lx\n", __pa(efi.uga)); + + return str - buf; +} + +static EFI_ATTR(systab, 0400, systab_read, NULL); + +static struct subsys_attribute *efi_subsys_attrs[] = { + &efi_attr_systab, + NULL, /* maybe more in the future? */ +}; + +static decl_subsys(vars, &ktype_efivar, NULL); +static decl_subsys(efi, NULL, NULL); + +/* + * efivar_create_sysfs_entry() + * Requires: + * variable_name_size = number of bytes required to hold + * variable_name (not counting the NULL + * character at the end. + * efivars_lock is not held on entry or exit. + * Returns 1 on failure, 0 on success + */ +static int +efivar_create_sysfs_entry(unsigned long variable_name_size, + efi_char16_t *variable_name, + efi_guid_t *vendor_guid) +{ + int i, short_name_size = variable_name_size / sizeof(efi_char16_t) + 38; + char *short_name; + struct efivar_entry *new_efivar; + + short_name = kmalloc(short_name_size + 1, GFP_KERNEL); + new_efivar = kmalloc(sizeof(struct efivar_entry), GFP_KERNEL); + + if (!short_name || !new_efivar) { + if (short_name) kfree(short_name); + if (new_efivar) kfree(new_efivar); + return 1; + } + memset(short_name, 0, short_name_size+1); + memset(new_efivar, 0, sizeof(struct efivar_entry)); + + memcpy(new_efivar->var.VariableName, variable_name, + variable_name_size); + memcpy(&(new_efivar->var.VendorGuid), vendor_guid, sizeof(efi_guid_t)); + + /* Convert Unicode to normal chars (assume top bits are 0), + ala UTF-8 */ + for (i=0; i < (int)(variable_name_size / sizeof(efi_char16_t)); i++) { + short_name[i] = variable_name[i] & 0xFF; + } + /* This is ugly, but necessary to separate one vendor's + private variables from another's. */ + + *(short_name + strlen(short_name)) = '-'; + efi_guid_unparse(vendor_guid, short_name + strlen(short_name)); + *(short_name + strlen(short_name)) = ' '; + + kobject_set_name(&new_efivar->kobj, short_name); + kobj_set_kset_s(new_efivar, vars_subsys); + kobject_register(&new_efivar->kobj); + + kfree(short_name); short_name = NULL; + + spin_lock(&efivars_lock); + list_add(&new_efivar->list, &efivar_list); + spin_unlock(&efivars_lock); + + return 0; +} +/* + * For now we register the efi subsystem with the firmware subsystem + * and the vars subsystem with the efi subsystem. In the future, it + * might make sense to split off the efi subsystem into its own + * driver, but for now only efivars will register with it, so just + * include it here. + */ + +static int __init +efivars_init(void) +{ + efi_status_t status = EFI_NOT_FOUND; + efi_guid_t vendor_guid; + efi_char16_t *variable_name = kmalloc(1024, GFP_KERNEL); + struct subsys_attribute *attr; + unsigned long variable_name_size = 1024; + int i, rc = 0, error = 0; + + printk(KERN_INFO "EFI Variables Facility v%s\n", EFIVARS_VERSION); + + /* + * For now we'll register the efi subsys within this driver + */ + + rc = firmware_register(&efi_subsys); + + if (rc) + return rc; + + kset_set_kset_s(&vars_subsys, efi_subsys); + subsystem_register(&vars_subsys); + + /* + * Per EFI spec, the maximum storage allocated for both + * the variable name and variable data is 1024 bytes. + */ + + memset(variable_name, 0, 1024); + + do { + variable_name_size = 1024; + + status = efi.get_next_variable(&variable_name_size, + variable_name, + &vendor_guid); + switch (status) { + case EFI_SUCCESS: + efivar_create_sysfs_entry(variable_name_size, + variable_name, + &vendor_guid); + break; + case EFI_NOT_FOUND: + break; + default: + printk(KERN_WARNING "efivars: get_next_variable: status=%lx\n", + status); + status = EFI_NOT_FOUND; + break; + } + } while (status != EFI_NOT_FOUND); + + /* + * Now add attributes to allow creation of new vars + * and deletion of existing ones... + */ + + for (i = 0; (attr = var_subsys_attrs[i]) && !error; i++) { + if (attr->show && attr->store) + error = subsys_create_file(&vars_subsys, attr); + } + + /* Don't forget the systab entry */ + + for (i = 0; (attr = efi_subsys_attrs[i]) && !error; i++) { + if (attr->show) + error = subsys_create_file(&efi_subsys, attr); + } + + kfree(variable_name); + return 0; +} + +static void __exit +efivars_exit(void) +{ + struct list_head *pos, *n; + + list_for_each_safe(pos, n, &efivar_list) + efivar_unregister(get_efivar_entry(pos)); + + subsystem_unregister(&vars_subsys); + firmware_unregister(&efi_subsys); +} + +module_init(efivars_init); +module_exit(efivars_exit); + diff -puN drivers/firmware/Kconfig~efivars-add-to-drivers-firmware drivers/firmware/Kconfig --- 25/drivers/firmware/Kconfig~efivars-add-to-drivers-firmware Thu Apr 22 14:07:55 2004 +++ 25-akpm/drivers/firmware/Kconfig Thu Apr 22 14:07:55 2004 @@ -8,6 +8,7 @@ menu "Firmware Drivers" config EDD tristate "BIOS Enhanced Disk Drive calls determine boot disk (EXPERIMENTAL)" depends on EXPERIMENTAL + depends on !IA64 help Say Y or M here if you want to enable BIOS Enhanced Disk Drive Services real mode BIOS calls to determine which disk @@ -16,4 +17,21 @@ config EDD This option is experimental, but believed to be safe, and most disk controller BIOS vendors do not yet implement this feature. +config EFI_VARS + tristate "EFI Variable Support via sysfs" + depends on EFI + default n + help + If you say Y here, you are able to get EFI (Extensible Firmware + Interface) variable information via sysfs. You may read, + write, create, and destroy EFI variables through this interface. + + Note that using this driver in concert with efibootmgr requires + at least test release version 0.5.0-test1 or later, which is + available from Matt Domsch's website located at: + http://domsch.com/linux/ia64/efibootmgr/testing/efibootmgr-0.5.0-test1.tar.gz + + Subsequent efibootmgr releases may be found at: + http://domsch.com/linux/ia64/efibootmgr + endmenu diff -puN drivers/firmware/Makefile~efivars-add-to-drivers-firmware drivers/firmware/Makefile --- 25/drivers/firmware/Makefile~efivars-add-to-drivers-firmware Thu Apr 22 14:07:55 2004 +++ 25-akpm/drivers/firmware/Makefile Thu Apr 22 14:07:55 2004 @@ -2,3 +2,4 @@ # Makefile for the linux kernel. # obj-$(CONFIG_EDD) += edd.o +obj-$(CONFIG_EFI_VARS) += efivars.o _