efi: split efisubsystem from efivars

This registers /sys/firmware/efi/{,systab,efivars/} whenever EFI is enabled
and the system is booted with EFI.

This allows
 *) userspace to check for the existence of /sys/firmware/efi as a way
    to determine whether or it is running on an EFI system.
 *) 'mount -t efivarfs none /sys/firmware/efi/efivars' without manually
    loading any modules.

[ Also, move the efivar API into vars.c and unconditionally compile it.
  This allows us to move efivars.c, which now only contains the sysfs
  variable code, into the firmware/efi directory. Note that the efivars.c
  filename is kept to maintain backwards compatability with the old
  efivars.ko module. With this patch it is now possible for efivarfs
  to be built without CONFIG_EFI_VARS - Matt ]

Cc: Seiji Aguchi <seiji.aguchi@hds.com>
Cc: Tony Luck <tony.luck@intel.com>
Cc: Mike Waychison <mikew@google.com>
Cc: Kay Sievers <kay@vrfy.org>
Cc: Jeremy Kerr <jk@ozlabs.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Chun-Yi Lee <jlee@suse.com>
Cc: Andy Whitcroft <apw@canonical.com>
Cc: Tobias Powalowski <tpowa@archlinux.org>
Signed-off-by: Tom Gundersen <teg@jklm.no>
Signed-off-by: Matt Fleming <matt.fleming@intel.com>

5 files changed, 765 insertions, 758 deletions

diff --git a/drivers/firmware/Makefile b/drivers/firmware/Makefile
index 31bf68c93593..299fad6b5867 100644
--- a/drivers/firmware/Makefile
+++ b/drivers/firmware/Makefile
@@ -4,7 +4,6 @@
 obj-$(CONFIG_DMI)               += dmi_scan.o
 obj-$(CONFIG_DMI_SYSFS)         += dmi-sysfs.o
 obj-$(CONFIG_EDD)               += edd.o
-obj-$(CONFIG_EFI_VARS)          += efivars.o
 obj-$(CONFIG_EFI_PCDP)          += pcdp.o
 obj-$(CONFIG_DELL_RBU)          += dell_rbu.o
 obj-$(CONFIG_DCDBAS)            += dcdbas.o
diff --git a/drivers/firmware/efi/Makefile b/drivers/firmware/efi/Makefile
index e03cd51525c2..99245ab5a79c 100644
--- a/drivers/firmware/efi/Makefile
+++ b/drivers/firmware/efi/Makefile
@@ -1,4 +1,6 @@
 #
 # Makefile for linux kernel
 #
+obj-y                                   += efi.o vars.o
+obj-$(CONFIG_EFI_VARS)                  += efivars.o
 obj-$(CONFIG_EFI_VARS_PSTORE)           += efi-pstore.o
diff --git a/drivers/firmware/efi/efi.c b/drivers/firmware/efi/efi.c
new file mode 100644
index 000000000000..32bdf4f8e432
--- /dev/null
+++ b/drivers/firmware/efi/efi.c
@@ -0,0 +1,134 @@
+/*
+ * efi.c - EFI subsystem
+ *
+ * Copyright (C) 2001,2003,2004 Dell <Matt_Domsch@dell.com>
+ * Copyright (C) 2004 Intel Corporation <matthew.e.tolentino@intel.com>
+ * Copyright (C) 2013 Tom Gundersen <teg@jklm.no>
+ *
+ * This code registers /sys/firmware/efi{,/efivars} when EFI is supported,
+ * allowing the efivarfs to be mounted or the efivars module to be loaded.
+ * The existance of /sys/firmware/efi may also be used by userspace to
+ * determine that the system supports EFI.
+ *
+ * This file is released under the GPLv2.
+ */
+
+#include <linux/kobject.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/device.h>
+#include <linux/efi.h>
+
+static struct kobject *efi_kobj;
+static struct kobject *efivars_kobj;
+
+/*
+ * Let's not leave out systab information that snuck into
+ * the efivars driver
+ */
+static ssize_t systab_show(struct kobject *kobj,
+                           struct kobj_attribute *attr, char *buf)
+{
+        char *str = buf;
+
+        if (!kobj || !buf)
+                return -EINVAL;
+
+        if (efi.mps != EFI_INVALID_TABLE_ADDR)
+                str += sprintf(str, "MPS=0x%lx\n", efi.mps);
+        if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
+                str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
+        if (efi.acpi != EFI_INVALID_TABLE_ADDR)
+                str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
+        if (efi.smbios != EFI_INVALID_TABLE_ADDR)
+                str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
+        if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
+                str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
+        if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
+                str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
+        if (efi.uga != EFI_INVALID_TABLE_ADDR)
+                str += sprintf(str, "UGA=0x%lx\n", efi.uga);
+
+        return str - buf;
+}
+
+static struct kobj_attribute efi_attr_systab =
+                        __ATTR(systab, 0400, systab_show, NULL);
+
+static struct attribute *efi_subsys_attrs[] = {
+        &efi_attr_systab.attr,
+        NULL,   /* maybe more in the future? */
+};
+
+static struct attribute_group efi_subsys_attr_group = {
+        .attrs = efi_subsys_attrs,
+};
+
+static struct efivars generic_efivars;
+static struct efivar_operations generic_ops;
+
+static int generic_ops_register(void)
+{
+        generic_ops.get_variable = efi.get_variable;
+        generic_ops.set_variable = efi.set_variable;
+        generic_ops.get_next_variable = efi.get_next_variable;
+        generic_ops.query_variable_info = efi.query_variable_info;
+
+        return efivars_register(&generic_efivars, &generic_ops, efi_kobj);
+}
+
+static void generic_ops_unregister(void)
+{
+        efivars_unregister(&generic_efivars);
+}
+
+/*
+ * We register the efi subsystem with the firmware subsystem and the
+ * efivars subsystem with the efi subsystem, if the system was booted with
+ * EFI.
+ */
+static int __init efisubsys_init(void)
+{
+        int error;
+
+        if (!efi_enabled(EFI_BOOT))
+                return 0;
+
+        /* We register the efi directory at /sys/firmware/efi */
+        efi_kobj = kobject_create_and_add("efi", firmware_kobj);
+        if (!efi_kobj) {
+                pr_err("efi: Firmware registration failed.\n");
+                return -ENOMEM;
+        }
+
+        error = generic_ops_register();
+        if (error)
+                goto err_put;
+
+        error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
+        if (error) {
+                pr_err("efi: Sysfs attribute export failed with error %d.\n",
+                       error);
+                goto err_unregister;
+        }
+
+        /* and the standard mountpoint for efivarfs */
+        efivars_kobj = kobject_create_and_add("efivars", efi_kobj);
+        if (!efivars_kobj) {
+                pr_err("efivars: Subsystem registration failed.\n");
+                error = -ENOMEM;
+                goto err_remove_group;
+        }
+
+        return 0;
+
+err_remove_group:
+        sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
+err_unregister:
+        generic_ops_unregister();
+err_put:
+        kobject_put(efi_kobj);
+        return error;
+}
+
+subsys_initcall(efisubsys_init);
diff --git a/drivers/firmware/efi/efivars.c b/drivers/firmware/efi/efivars.c
new file mode 100644
index 000000000000..70635b3b59d3
--- /dev/null
+++ b/drivers/firmware/efi/efivars.c
@@ -0,0 +1,617 @@
+/*
+ * Originally from efivars.c,
+ *
+ * Copyright (C) 2001,2003,2004 Dell <Matt_Domsch@dell.com>
+ * Copyright (C) 2004 Intel Corporation <matthew.e.tolentino@intel.com>
+ *
+ * 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:
+ *
+ *  17 May 2004 - Matt Domsch <Matt_Domsch@dell.com>
+ *   remove check for efi_enabled in exit
+ *   add MODULE_VERSION
+ *
+ *  26 Apr 2004 - Matt Domsch <Matt_Domsch@dell.com>
+ *   minor bug fixes
+ *
+ *  21 Apr 2004 - Matt Tolentino <matthew.e.tolentino@intel.com)
+ *   converted driver to export variable information via sysfs
+ *   and moved to drivers/firmware directory
+ *   bumped revision number to v0.07 to reflect conversion & move
+ *
+ *  10 Dec 2002 - Matt Domsch <Matt_Domsch@dell.com>
+ *   fix locking per Peter Chubb's findings
+ *
+ *  25 Mar 2002 - Matt Domsch <Matt_Domsch@dell.com>
+ *   move uuid_unparse() to include/asm-ia64/efi.h:efi_guid_unparse()
+ *
+ *  12 Feb 2002 - Matt Domsch <Matt_Domsch@dell.com>
+ *   use list_for_each_safe when deleting vars.
+ *   remove ifdef CONFIG_SMP around include <linux/smp.h>
+ *   v0.04 release to linux-ia64@linuxia64.org
+ *
+ *  20 April 2001 - Matt Domsch <Matt_Domsch@dell.com>
+ *   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 <Matt_Domsch@dell.com>
+ *   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 <Matt_Domsch@dell.com>
+ *   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 <Matt_Domsch@dell.com>
+ *   v0.01 release to linux-ia64@linuxia64.org
+ */
+
+#include <linux/efi.h>
+#include <linux/module.h>
+
+#define EFIVARS_VERSION "0.08"
+#define EFIVARS_DATE "2004-May-17"
+
+MODULE_AUTHOR("Matt Domsch <Matt_Domsch@Dell.com>");
+MODULE_DESCRIPTION("sysfs interface to EFI Variables");
+MODULE_LICENSE("GPL");
+MODULE_VERSION(EFIVARS_VERSION);
+
+LIST_HEAD(efivar_sysfs_list);
+EXPORT_SYMBOL_GPL(efivar_sysfs_list);
+
+static struct kset *efivars_kset;
+
+static struct bin_attribute *efivars_new_var;
+static struct bin_attribute *efivars_del_var;
+
+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 EFIVAR_ATTR(_name, _mode, _show, _store) \
+struct efivar_attribute efivar_attr_##_name = { \
+        .attr = {.name = __stringify(_name), .mode = _mode}, \
+        .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(struct efivar_entry *new_var);
+
+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;
+
+        if (!entry || !buf)
+                return -EINVAL;
+
+        var->DataSize = 1024;
+        if (efivar_entry_get(entry, &var->Attributes, &var->DataSize, var->Data))
+                return -EIO;
+
+        if (var->Attributes & EFI_VARIABLE_NON_VOLATILE)
+                str += sprintf(str, "EFI_VARIABLE_NON_VOLATILE\n");
+        if (var->Attributes & EFI_VARIABLE_BOOTSERVICE_ACCESS)
+                str += sprintf(str, "EFI_VARIABLE_BOOTSERVICE_ACCESS\n");
+        if (var->Attributes & EFI_VARIABLE_RUNTIME_ACCESS)
+                str += sprintf(str, "EFI_VARIABLE_RUNTIME_ACCESS\n");
+        if (var->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD)
+                str += sprintf(str, "EFI_VARIABLE_HARDWARE_ERROR_RECORD\n");
+        if (var->Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS)
+                str += sprintf(str,
+                        "EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS\n");
+        if (var->Attributes &
+                        EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS)
+                str += sprintf(str,
+                        "EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS\n");
+        if (var->Attributes & EFI_VARIABLE_APPEND_WRITE)
+                str += sprintf(str, "EFI_VARIABLE_APPEND_WRITE\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;
+
+        if (!entry || !buf)
+                return -EINVAL;
+
+        var->DataSize = 1024;
+        if (efivar_entry_get(entry, &var->Attributes, &var->DataSize, var->Data))
+                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;
+
+        if (!entry || !buf)
+                return -EINVAL;
+
+        var->DataSize = 1024;
+        if (efivar_entry_get(entry, &var->Attributes, &var->DataSize, var->Data))
+                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;
+        int err;
+
+        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;
+        }
+
+        if ((new_var->Attributes & ~EFI_VARIABLE_MASK) != 0 ||
+            efivar_validate(new_var, new_var->Data, new_var->DataSize) == false) {
+                printk(KERN_ERR "efivars: Malformed variable content\n");
+                return -EINVAL;
+        }
+
+        memcpy(&entry->var, new_var, count);
+
+        err = efivar_entry_set(entry, new_var->Attributes,
+                               new_var->DataSize, new_var->Data, false);
+        if (err) {
+                printk(KERN_WARNING "efivars: set_variable() failed: status=%d\n", err);
+                return -EIO;
+        }
+
+        return count;
+}
+
+static ssize_t
+efivar_show_raw(struct efivar_entry *entry, char *buf)
+{
+        struct efi_variable *var = &entry->var;
+
+        if (!entry || !buf)
+                return 0;
+
+        var->DataSize = 1024;
+        if (efivar_entry_get(entry, &entry->var.Attributes,
+                             &entry->var.DataSize, entry->var.Data))
+                return -EIO;
+
+        memcpy(buf, var, sizeof(*var));
+
+        return sizeof(*var);
+}
+
+/*
+ * Generic read/write functions that call the specific functions of
+ * the attributes...
+ */
+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 = -EIO;
+
+        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 = -EIO;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EACCES;
+
+        if (efivar_attr->store)
+                ret = efivar_attr->store(var, buf, count);
+
+        return ret;
+}
+
+static const 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);
+        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 efivar_ktype = {
+        .release = efivar_release,
+        .sysfs_ops = &efivar_attr_ops,
+        .default_attrs = def_attrs,
+};
+
+static ssize_t efivar_create(struct file *filp, struct kobject *kobj,
+                             struct bin_attribute *bin_attr,
+                             char *buf, loff_t pos, size_t count)
+{
+        struct efi_variable *new_var = (struct efi_variable *)buf;
+        struct efivar_entry *new_entry;
+        int err;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EACCES;
+
+        if ((new_var->Attributes & ~EFI_VARIABLE_MASK) != 0 ||
+            efivar_validate(new_var, new_var->Data, new_var->DataSize) == false) {
+                printk(KERN_ERR "efivars: Malformed variable content\n");
+                return -EINVAL;
+        }
+
+        new_entry = kzalloc(sizeof(*new_entry), GFP_KERNEL);
+        if (!new_entry)
+                return -ENOMEM;
+
+        memcpy(&new_entry->var, new_var, sizeof(*new_var));
+
+        err = efivar_entry_set(new_entry, new_var->Attributes, new_var->DataSize,
+                               new_var->Data, &efivar_sysfs_list);
+        if (err) {
+                if (err == -EEXIST)
+                        err = -EINVAL;
+                goto out;
+        }
+
+        if (efivar_create_sysfs_entry(new_entry)) {
+                printk(KERN_WARNING "efivars: failed to create sysfs entry.\n");
+                kfree(new_entry);
+        }
+        return count;
+
+out:
+        kfree(new_entry);
+        return err;
+}
+
+static ssize_t efivar_delete(struct file *filp, struct kobject *kobj,
+                             struct bin_attribute *bin_attr,
+                             char *buf, loff_t pos, size_t count)
+{
+        struct efi_variable *del_var = (struct efi_variable *)buf;
+        struct efivar_entry *entry;
+        int err = 0;
+
+        if (!capable(CAP_SYS_ADMIN))
+                return -EACCES;
+
+        efivar_entry_iter_begin();
+        entry = efivar_entry_find(del_var->VariableName, del_var->VendorGuid,
+                                  &efivar_sysfs_list, true);
+        if (!entry)
+                err = -EINVAL;
+        else if (__efivar_entry_delete(entry))
+                err = -EIO;
+
+        efivar_entry_iter_end();
+
+        if (err)
+                return err;
+
+        efivar_unregister(entry);
+
+        /* It's dead Jim.... */
+        return count;
+}
+
+/**
+ * efivar_create_sysfs_entry - create a new entry in sysfs
+ * @new_var: efivar entry to create
+ *
+ * Returns 1 on failure, 0 on success
+ */
+static int
+efivar_create_sysfs_entry(struct efivar_entry *new_var)
+{
+        int i, short_name_size;
+        char *short_name;
+        unsigned long variable_name_size;
+        efi_char16_t *variable_name;
+
+        variable_name = new_var->var.VariableName;
+        variable_name_size = utf16_strlen(variable_name) * sizeof(efi_char16_t);
+
+        /*
+         * Length of the variable bytes in ASCII, plus the '-' separator,
+         * plus the GUID, plus trailing NUL
+         */
+        short_name_size = variable_name_size / sizeof(efi_char16_t)
+                                + 1 + EFI_VARIABLE_GUID_LEN + 1;
+
+        short_name = kzalloc(short_name_size, GFP_KERNEL);
+
+        if (!short_name) {
+                kfree(short_name);
+                return 1;
+        }
+
+        /* 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(&new_var->var.VendorGuid,
+                         short_name + strlen(short_name));
+
+        new_var->kobj.kset = efivars_kset;
+
+        i = kobject_init_and_add(&new_var->kobj, &efivar_ktype,
+                                   NULL, "%s", short_name);
+        kfree(short_name);
+        if (i)
+                return 1;
+
+        kobject_uevent(&new_var->kobj, KOBJ_ADD);
+        efivar_entry_add(new_var, &efivar_sysfs_list);
+
+        return 0;
+}
+
+static int
+create_efivars_bin_attributes(void)
+{
+        struct bin_attribute *attr;
+        int error;
+
+        /* new_var */
+        attr = kzalloc(sizeof(*attr), GFP_KERNEL);
+        if (!attr)
+                return -ENOMEM;
+
+        attr->attr.name = "new_var";
+        attr->attr.mode = 0200;
+        attr->write = efivar_create;
+        efivars_new_var = attr;
+
+        /* del_var */
+        attr = kzalloc(sizeof(*attr), GFP_KERNEL);
+        if (!attr) {
+                error = -ENOMEM;
+                goto out_free;
+        }
+        attr->attr.name = "del_var";
+        attr->attr.mode = 0200;
+        attr->write = efivar_delete;
+        efivars_del_var = attr;
+
+        sysfs_bin_attr_init(efivars_new_var);
+        sysfs_bin_attr_init(efivars_del_var);
+
+        /* Register */
+        error = sysfs_create_bin_file(&efivars_kset->kobj, efivars_new_var);
+        if (error) {
+                printk(KERN_ERR "efivars: unable to create new_var sysfs file"
+                        " due to error %d\n", error);
+                goto out_free;
+        }
+
+        error = sysfs_create_bin_file(&efivars_kset->kobj, efivars_del_var);
+        if (error) {
+                printk(KERN_ERR "efivars: unable to create del_var sysfs file"
+                        " due to error %d\n", error);
+                sysfs_remove_bin_file(&efivars_kset->kobj, efivars_new_var);
+                goto out_free;
+        }
+
+        return 0;
+out_free:
+        kfree(efivars_del_var);
+        efivars_del_var = NULL;
+        kfree(efivars_new_var);
+        efivars_new_var = NULL;
+        return error;
+}
+
+static int efivar_update_sysfs_entry(efi_char16_t *name, efi_guid_t vendor,
+                                     unsigned long name_size, void *data)
+{
+        struct efivar_entry *entry = data;
+
+        if (efivar_entry_find(name, vendor, &efivar_sysfs_list, false))
+                return 0;
+
+        memcpy(entry->var.VariableName, name, name_size);
+        memcpy(&(entry->var.VendorGuid), &vendor, sizeof(efi_guid_t));
+
+        return 1;
+}
+
+static void efivar_update_sysfs_entries(struct work_struct *work)
+{
+        struct efivar_entry *entry;
+        int err;
+
+        entry = kzalloc(sizeof(*entry), GFP_KERNEL);
+        if (!entry)
+                return;
+
+        /* Add new sysfs entries */
+        while (1) {
+                memset(entry, 0, sizeof(*entry));
+
+                err = efivar_init(efivar_update_sysfs_entry, entry,
+                                  true, false, &efivar_sysfs_list);
+                if (!err)
+                        break;
+
+                efivar_create_sysfs_entry(entry);
+        }
+
+        kfree(entry);
+}
+
+static int efivars_sysfs_callback(efi_char16_t *name, efi_guid_t vendor,
+                                  unsigned long name_size, void *data)
+{
+        struct efivar_entry *entry;
+
+        entry = kzalloc(sizeof(*entry), GFP_KERNEL);
+        if (!entry)
+                return -ENOMEM;
+
+        memcpy(entry->var.VariableName, name, name_size);
+        memcpy(&(entry->var.VendorGuid), &vendor, sizeof(efi_guid_t));
+
+        efivar_create_sysfs_entry(entry);
+
+        return 0;
+}
+
+static int efivar_sysfs_destroy(struct efivar_entry *entry, void *data)
+{
+        efivar_entry_remove(entry);
+        efivar_unregister(entry);
+        return 0;
+}
+
+void efivars_sysfs_exit(void)
+{
+        /* Remove all entries and destroy */
+        __efivar_entry_iter(efivar_sysfs_destroy, &efivar_sysfs_list, NULL, NULL);
+
+        if (efivars_new_var)
+                sysfs_remove_bin_file(&efivars_kset->kobj, efivars_new_var);
+        if (efivars_del_var)
+                sysfs_remove_bin_file(&efivars_kset->kobj, efivars_del_var);
+        kfree(efivars_new_var);
+        kfree(efivars_del_var);
+        kset_unregister(efivars_kset);
+}
+
+int efivars_sysfs_init(void)
+{
+        struct kobject *parent_kobj = efivars_kobject();
+        int error = 0;
+
+        /* No efivars has been registered yet */
+        if (!parent_kobj)
+                return 0;
+
+        printk(KERN_INFO "EFI Variables Facility v%s %s\n", EFIVARS_VERSION,
+               EFIVARS_DATE);
+
+        efivars_kset = kset_create_and_add("vars", NULL, parent_kobj);
+        if (!efivars_kset) {
+                printk(KERN_ERR "efivars: Subsystem registration failed.\n");
+                return -ENOMEM;
+        }
+
+        efivar_init(efivars_sysfs_callback, NULL, false,
+                    true, &efivar_sysfs_list);
+
+        error = create_efivars_bin_attributes();
+        if (error) {
+                efivars_sysfs_exit();
+                return error;
+        }
+
+        INIT_WORK(&efivar_work, efivar_update_sysfs_entries);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(efivars_sysfs_init);
+
+module_init(efivars_sysfs_init);
+module_exit(efivars_sysfs_exit);
diff --git a/drivers/firmware/efivars.c b/drivers/firmware/efi/vars.c
index af396758482f..dd1c20a426fa 100644
--- a/drivers/firmware/efivars.c
+++ b/drivers/firmware/efi/vars.c
@@ -1,12 +1,9 @@
 /*
- * EFI Variables - efivars.c
+ * Originally from efivars.c
  *
  * Copyright (C) 2001,2003,2004 Dell <Matt_Domsch@dell.com>
  * Copyright (C) 2004 Intel Corporation <matthew.e.tolentino@intel.com>
  *
- * 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
@@ -20,49 +17,6 @@
  *  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:
- *
- *  17 May 2004 - Matt Domsch <Matt_Domsch@dell.com>
- *   remove check for efi_enabled in exit
- *   add MODULE_VERSION
- *
- *  26 Apr 2004 - Matt Domsch <Matt_Domsch@dell.com>
- *   minor bug fixes
- *
- *  21 Apr 2004 - Matt Tolentino <matthew.e.tolentino@intel.com)
- *   converted driver to export variable information via sysfs
- *   and moved to drivers/firmware directory
- *   bumped revision number to v0.07 to reflect conversion & move
- *
- *  10 Dec 2002 - Matt Domsch <Matt_Domsch@dell.com>
- *   fix locking per Peter Chubb's findings
- *
- *  25 Mar 2002 - Matt Domsch <Matt_Domsch@dell.com>
- *   move uuid_unparse() to include/asm-ia64/efi.h:efi_guid_unparse()
- *
- *  12 Feb 2002 - Matt Domsch <Matt_Domsch@dell.com>
- *   use list_for_each_safe when deleting vars.
- *   remove ifdef CONFIG_SMP around include <linux/smp.h>
- *   v0.04 release to linux-ia64@linuxia64.org
- *
- *  20 April 2001 - Matt Domsch <Matt_Domsch@dell.com>
- *   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 <Matt_Domsch@dell.com>
- *   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 <Matt_Domsch@dell.com>
- *   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 <Matt_Domsch@dell.com>
- *   v0.01 release to linux-ia64@linuxia64.org
  */
 
 #include <linux/capability.h>
@@ -75,65 +29,16 @@
 #include <linux/smp.h>
 #include <linux/efi.h>
 #include <linux/sysfs.h>
-#include <linux/kobject.h>
 #include <linux/device.h>
 #include <linux/slab.h>
 #include <linux/ctype.h>
 
-#include <linux/fs.h>
-#include <linux/ramfs.h>
-#include <linux/pagemap.h>
-
-#include <asm/uaccess.h>
-
-#define EFIVARS_VERSION "0.08"
-#define EFIVARS_DATE "2004-May-17"
-
-MODULE_AUTHOR("Matt Domsch <Matt_Domsch@Dell.com>");
-MODULE_DESCRIPTION("sysfs interface to EFI Variables");
-MODULE_LICENSE("GPL");
-MODULE_VERSION(EFIVARS_VERSION);
-
-LIST_HEAD(efivar_sysfs_list);
-EXPORT_SYMBOL_GPL(efivar_sysfs_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);
-};
-
 /* Private pointer to registered efivars */
 static struct efivars *__efivars;
 
-static struct kset *efivars_kset;
-
-static struct bin_attribute *efivars_new_var;
-static struct bin_attribute *efivars_del_var;
-
-#define EFIVAR_ATTR(_name, _mode, _show, _store) \
-struct efivar_attribute efivar_attr_##_name = { \
-        .attr = {.name = __stringify(_name), .mode = _mode}, \
-        .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(struct efivar_entry *new_var);
-
-/*
- * Prototype for workqueue functions updating sysfs entry
- */
-
-static void efivar_update_sysfs_entries(struct work_struct *);
-static DECLARE_WORK(efivar_work, efivar_update_sysfs_entries);
 static bool efivar_wq_enabled = true;
+DECLARE_WORK(efivar_work, NULL);
+EXPORT_SYMBOL_GPL(efivar_work);
 
 static bool
 validate_device_path(struct efi_variable *var, int match, u8 *buffer,
@@ -343,220 +248,6 @@ check_var_size(u32 attributes, unsigned long size)
         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;
-
-        if (!entry || !buf)
-                return -EINVAL;
-
-        var->DataSize = 1024;
-        if (efivar_entry_get(entry, &var->Attributes, &var->DataSize, var->Data))
-                return -EIO;
-
-        if (var->Attributes & EFI_VARIABLE_NON_VOLATILE)
-                str += sprintf(str, "EFI_VARIABLE_NON_VOLATILE\n");
-        if (var->Attributes & EFI_VARIABLE_BOOTSERVICE_ACCESS)
-                str += sprintf(str, "EFI_VARIABLE_BOOTSERVICE_ACCESS\n");
-        if (var->Attributes & EFI_VARIABLE_RUNTIME_ACCESS)
-                str += sprintf(str, "EFI_VARIABLE_RUNTIME_ACCESS\n");
-        if (var->Attributes & EFI_VARIABLE_HARDWARE_ERROR_RECORD)
-                str += sprintf(str, "EFI_VARIABLE_HARDWARE_ERROR_RECORD\n");
-        if (var->Attributes & EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS)
-                str += sprintf(str,
-                        "EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS\n");
-        if (var->Attributes &
-                        EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS)
-                str += sprintf(str,
-                        "EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS\n");
-        if (var->Attributes & EFI_VARIABLE_APPEND_WRITE)
-                str += sprintf(str, "EFI_VARIABLE_APPEND_WRITE\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;
-
-        if (!entry || !buf)
-                return -EINVAL;
-
-        var->DataSize = 1024;
-        if (efivar_entry_get(entry, &var->Attributes, &var->DataSize, var->Data))
-                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;
-
-        if (!entry || !buf)
-                return -EINVAL;
-
-        var->DataSize = 1024;
-        if (efivar_entry_get(entry, &var->Attributes, &var->DataSize, var->Data))
-                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;
-        int err;
-
-        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;
-        }
-
-        if ((new_var->Attributes & ~EFI_VARIABLE_MASK) != 0 ||
-            efivar_validate(new_var, new_var->Data, new_var->DataSize) == false) {
-                printk(KERN_ERR "efivars: Malformed variable content\n");
-                return -EINVAL;
-        }
-
-        memcpy(&entry->var, new_var, count);
-
-        err = efivar_entry_set(entry, new_var->Attributes,
-                               new_var->DataSize, new_var->Data, false);
-        if (err) {
-                printk(KERN_WARNING "efivars: set_variable() failed: status=%d\n", err);
-                return -EIO;
-        }
-
-        return count;
-}
-
-static ssize_t
-efivar_show_raw(struct efivar_entry *entry, char *buf)
-{
-        struct efi_variable *var = &entry->var;
-
-        if (!entry || !buf)
-                return 0;
-
-        var->DataSize = 1024;
-        if (efivar_entry_get(entry, &entry->var.Attributes,
-                             &entry->var.DataSize, entry->var.Data))
-                return -EIO;
-
-        memcpy(buf, var, sizeof(*var));
-
-        return sizeof(*var);
-}
-
-/*
- * Generic read/write functions that call the specific functions of
- * the attributes...
- */
-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 = -EIO;
-
-        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 = -EIO;
-
-        if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
-
-        if (efivar_attr->store)
-                ret = efivar_attr->store(var, buf, count);
-
-        return ret;
-}
-
-static const 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);
-        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 efivar_ktype = {
-        .release = efivar_release,
-        .sysfs_ops = &efivar_attr_ops,
-        .default_attrs = def_attrs,
-};
-
 static int efi_status_to_err(efi_status_t status)
 {
         int err;
@@ -590,78 +281,6 @@ static int efi_status_to_err(efi_status_t status)
         return err;
 }
 
-static ssize_t efivar_create(struct file *filp, struct kobject *kobj,
-                             struct bin_attribute *bin_attr,
-                             char *buf, loff_t pos, size_t count)
-{
-        struct efi_variable *new_var = (struct efi_variable *)buf;
-        struct efivar_entry *new_entry;
-        int err;
-
-        if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
-
-        if ((new_var->Attributes & ~EFI_VARIABLE_MASK) != 0 ||
-            efivar_validate(new_var, new_var->Data, new_var->DataSize) == false) {
-                printk(KERN_ERR "efivars: Malformed variable content\n");
-                return -EINVAL;
-        }
-
-        new_entry = kzalloc(sizeof(*new_entry), GFP_KERNEL);
-        if (!new_entry)
-                return -ENOMEM;
-
-        memcpy(&new_entry->var, new_var, sizeof(*new_var));
-
-        err = efivar_entry_set(new_entry, new_var->Attributes, new_var->DataSize,
-                               new_var->Data, &efivar_sysfs_list);
-        if (err) {
-                if (err == -EEXIST)
-                        err = -EINVAL;
-                goto out;
-        }
-
-        if (efivar_create_sysfs_entry(new_entry)) {
-                printk(KERN_WARNING "efivars: failed to create sysfs entry.\n");
-                kfree(new_entry);
-        }
-        return count;
-
-out:
-        kfree(new_entry);
-        return err;
-}
-
-static ssize_t efivar_delete(struct file *filp, struct kobject *kobj,
-                             struct bin_attribute *bin_attr,
-                             char *buf, loff_t pos, size_t count)
-{
-        struct efi_variable *del_var = (struct efi_variable *)buf;
-        struct efivar_entry *entry;
-        int err = 0;
-
-        if (!capable(CAP_SYS_ADMIN))
-                return -EACCES;
-
-        efivar_entry_iter_begin();
-        entry = efivar_entry_find(del_var->VariableName, del_var->VendorGuid,
-                                  &efivar_sysfs_list, true);
-        if (!entry)
-                err = -EINVAL;
-        else if (__efivar_entry_delete(entry))
-                err = -EIO;
-
-        efivar_entry_iter_end();
-
-        if (err)
-                return err;
-
-        efivar_unregister(entry);
-
-        /* It's dead Jim.... */
-        return count;
-}
-
 static bool variable_is_present(efi_char16_t *variable_name, efi_guid_t *vendor,
                                 struct list_head *head)
 {
@@ -684,20 +303,6 @@ static bool variable_is_present(efi_char16_t *variable_name, efi_guid_t *vendor,
         return found;
 }
 
-static int efivar_update_sysfs_entry(efi_char16_t *name, efi_guid_t vendor,
-                                     unsigned long name_size, void *data)
-{
-        struct efivar_entry *entry = data;
-
-        if (efivar_entry_find(name, vendor, &efivar_sysfs_list, false))
-                return 0;
-
-        memcpy(entry->var.VariableName, name, name_size);
-        memcpy(&(entry->var.VendorGuid), &vendor, sizeof(efi_guid_t));
-
-        return 1;
-}
-
 /*
  * Returns the size of variable_name, in bytes, including the
  * terminating NULL character, or variable_name_size if no NULL
@@ -723,210 +328,6 @@ static unsigned long var_name_strnsize(efi_char16_t *variable_name,
         return min(len, variable_name_size);
 }
 
-static void efivar_update_sysfs_entries(struct work_struct *work)
-{
-        struct efivar_entry *entry;
-        int err;
-
-        entry = kzalloc(sizeof(*entry), GFP_KERNEL);
-        if (!entry)
-                return;
-
-        /* Add new sysfs entries */
-        while (1) {
-                memset(entry, 0, sizeof(*entry));
-
-                err = efivar_init(efivar_update_sysfs_entry, entry,
-                                  true, false, &efivar_sysfs_list);
-                if (!err)
-                        break;
-
-                efivar_create_sysfs_entry(entry);
-        }
-
-        kfree(entry);
-}
-
-/*
- * Let's not leave out systab information that snuck into
- * the efivars driver
- */
-static ssize_t systab_show(struct kobject *kobj,
-                           struct kobj_attribute *attr, char *buf)
-{
-        char *str = buf;
-
-        if (!kobj || !buf)
-                return -EINVAL;
-
-        if (efi.mps != EFI_INVALID_TABLE_ADDR)
-                str += sprintf(str, "MPS=0x%lx\n", efi.mps);
-        if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
-                str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
-        if (efi.acpi != EFI_INVALID_TABLE_ADDR)
-                str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
-        if (efi.smbios != EFI_INVALID_TABLE_ADDR)
-                str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
-        if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
-                str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
-        if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
-                str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
-        if (efi.uga != EFI_INVALID_TABLE_ADDR)
-                str += sprintf(str, "UGA=0x%lx\n", efi.uga);
-
-        return str - buf;
-}
-
-static struct kobj_attribute efi_attr_systab =
-                        __ATTR(systab, 0400, systab_show, NULL);
-
-static struct attribute *efi_subsys_attrs[] = {
-        &efi_attr_systab.attr,
-        NULL,   /* maybe more in the future? */
-};
-
-static struct attribute_group efi_subsys_attr_group = {
-        .attrs = efi_subsys_attrs,
-};
-
-static struct kobject *efi_kobj;
-
-/**
- * efivar_create_sysfs_entry - create a new entry in sysfs
- * @new_var: efivar entry to create
- *
- * Returns 1 on failure, 0 on success
- */
-static int
-efivar_create_sysfs_entry(struct efivar_entry *new_var)
-{
-        int i, short_name_size;
-        char *short_name;
-        unsigned long variable_name_size;
-        efi_char16_t *variable_name;
-
-        variable_name = new_var->var.VariableName;
-        variable_name_size = utf16_strlen(variable_name) * sizeof(efi_char16_t);
-
-        /*
-         * Length of the variable bytes in ASCII, plus the '-' separator,
-         * plus the GUID, plus trailing NUL
-         */
-        short_name_size = variable_name_size / sizeof(efi_char16_t)
-                                + 1 + EFI_VARIABLE_GUID_LEN + 1;
-
-        short_name = kzalloc(short_name_size, GFP_KERNEL);
-
-        if (!short_name) {
-                kfree(short_name);
-                return 1;
-        }
-
-        /* 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(&new_var->var.VendorGuid,
-                         short_name + strlen(short_name));
-
-        new_var->kobj.kset = efivars_kset;
-
-        i = kobject_init_and_add(&new_var->kobj, &efivar_ktype,
-                                   NULL, "%s", short_name);
-        kfree(short_name);
-        if (i)
-                return 1;
-
-        kobject_uevent(&new_var->kobj, KOBJ_ADD);
-        efivar_entry_add(new_var, &efivar_sysfs_list);
-
-        return 0;
-}
-
-static int
-create_efivars_bin_attributes(void)
-{
-        struct bin_attribute *attr;
-        int error;
-
-        /* new_var */
-        attr = kzalloc(sizeof(*attr), GFP_KERNEL);
-        if (!attr)
-                return -ENOMEM;
-
-        attr->attr.name = "new_var";
-        attr->attr.mode = 0200;
-        attr->write = efivar_create;
-        efivars_new_var = attr;
-
-        /* del_var */
-        attr = kzalloc(sizeof(*attr), GFP_KERNEL);
-        if (!attr) {
-                error = -ENOMEM;
-                goto out_free;
-        }
-        attr->attr.name = "del_var";
-        attr->attr.mode = 0200;
-        attr->write = efivar_delete;
-        efivars_del_var = attr;
-
-        sysfs_bin_attr_init(efivars_new_var);
-        sysfs_bin_attr_init(efivars_del_var);
-
-        /* Register */
-        error = sysfs_create_bin_file(&efivars_kset->kobj, efivars_new_var);
-        if (error) {
-                printk(KERN_ERR "efivars: unable to create new_var sysfs file"
-                        " due to error %d\n", error);
-                goto out_free;
-        }
-
-        error = sysfs_create_bin_file(&efivars_kset->kobj, efivars_del_var);
-        if (error) {
-                printk(KERN_ERR "efivars: unable to create del_var sysfs file"
-                        " due to error %d\n", error);
-                sysfs_remove_bin_file(&efivars_kset->kobj, efivars_new_var);
-                goto out_free;
-        }
-
-        return 0;
-out_free:
-        kfree(efivars_del_var);
-        efivars_del_var = NULL;
-        kfree(efivars_new_var);
-        efivars_new_var = NULL;
-        return error;
-}
-
-static int efivars_sysfs_callback(efi_char16_t *name, efi_guid_t vendor,
-                                  unsigned long name_size, void *data)
-{
-        struct efivar_entry *entry;
-
-        entry = kzalloc(sizeof(*entry), GFP_KERNEL);
-        if (!entry)
-                return -ENOMEM;
-
-        memcpy(entry->var.VariableName, name, name_size);
-        memcpy(&(entry->var.VendorGuid), &vendor, sizeof(efi_guid_t));
-
-        efivar_create_sysfs_entry(entry);
-
-        return 0;
-}
-
-static int efivar_sysfs_destroy(struct efivar_entry *entry, void *data)
-{
-        efivar_entry_remove(entry);
-        efivar_unregister(entry);
-        return 0;
-}
-
 /*
  * Print a warning when duplicate EFI variables are encountered and
  * disable the sysfs workqueue since the firmware is buggy.
@@ -956,59 +357,6 @@ static void dup_variable_bug(efi_char16_t *s16, efi_guid_t *vendor_guid,
         kfree(s8);
 }
 
-static struct kobject *efivars_kobj;
-
-void efivars_sysfs_exit(void)
-{
-        /* Remove all entries and destroy */
-        __efivar_entry_iter(efivar_sysfs_destroy, &efivar_sysfs_list, NULL, NULL);
-
-        if (efivars_new_var)
-                sysfs_remove_bin_file(&efivars_kset->kobj, efivars_new_var);
-        if (efivars_del_var)
-                sysfs_remove_bin_file(&efivars_kset->kobj, efivars_del_var);
-        kfree(efivars_new_var);
-        kfree(efivars_del_var);
-        kobject_put(efivars_kobj);
-        kset_unregister(efivars_kset);
-}
-
-int efivars_sysfs_init(void)
-{
-        struct kobject *parent_kobj = efivars_kobject();
-        int error = 0;
-
-        /* No efivars has been registered yet */
-        if (!parent_kobj)
-                return 0;
-
-        printk(KERN_INFO "EFI Variables Facility v%s %s\n", EFIVARS_VERSION,
-               EFIVARS_DATE);
-
-        efivars_kset = kset_create_and_add("vars", NULL, parent_kobj);
-        if (!efivars_kset) {
-                printk(KERN_ERR "efivars: Subsystem registration failed.\n");
-                return -ENOMEM;
-        }
-
-        efivars_kobj = kobject_create_and_add("efivars", parent_kobj);
-        if (!efivars_kobj) {
-                pr_err("efivars: Subsystem registration failed.\n");
-                kset_unregister(efivars_kset);
-                return -ENOMEM;
-        }
-
-        efivar_init(efivars_sysfs_callback, NULL, false,
-                    true, &efivar_sysfs_list);
-
-        error = create_efivars_bin_attributes();
-        if (error)
-                efivars_sysfs_exit();
-
-        return error;
-}
-EXPORT_SYMBOL_GPL(efivars_sysfs_init);
-
 /**
  * efivar_init - build the initial list of EFI variables
  * @func: callback function to invoke for every variable
@@ -1154,17 +502,16 @@ static void efivar_entry_list_del_unlock(struct efivar_entry *entry)
  * __efivar_entry_delete - delete an EFI variable
  * @entry: entry containing EFI variable to delete
  *
- * Delete the variable from the firmware and remove @entry from the
- * variable list. It is the caller's responsibility to free @entry
- * once we return.
+ * Delete the variable from the firmware but leave @entry on the
+ * variable list.
  *
- * This function differs from efivar_entry_delete() because it is
- * safe to be called from within a efivar_entry_iter_begin() and
+ * This function differs from efivar_entry_delete() because it does
+ * not remove @entry from the variable list. Also, it is safe to be
+ * called from within a efivar_entry_iter_begin() and
  * efivar_entry_iter_end() region, unlike efivar_entry_delete().
  *
  * Returns 0 on success, or a converted EFI status code if
- * set_variable() fails. If set_variable() fails the entry remains
- * on the list.
+ * set_variable() fails.
  */
 int __efivar_entry_delete(struct efivar_entry *entry)
 {
@@ -1176,12 +523,8 @@ int __efivar_entry_delete(struct efivar_entry *entry)
         status = ops->set_variable(entry->var.VariableName,
                                    &entry->var.VendorGuid,
                                    0, 0, NULL);
-        if (status)
-                return efi_status_to_err(status);
-
-        list_del(&entry->list);
 
-        return 0;
+        return efi_status_to_err(status);
 }
 EXPORT_SYMBOL_GPL(__efivar_entry_delete);
 
@@ -1259,6 +602,7 @@ int efivar_entry_set(struct efivar_entry *entry, u32 attributes,
         spin_unlock_irq(&__efivars->lock);
 
         return efi_status_to_err(status);
+
 }
 EXPORT_SYMBOL_GPL(efivar_entry_set);
 
@@ -1289,7 +633,7 @@ int efivar_entry_set_safe(efi_char16_t *name, efi_guid_t vendor, u32 attributes,
         if (!ops->query_variable_info)
                 return -ENOSYS;
 
-        if (!block && !spin_trylock_irqsave(&__efivars->lock, flags))
+        if (!block && spin_trylock_irqsave(&__efivars->lock, flags))
                 return -EBUSY;
         else
                 spin_lock_irqsave(&__efivars->lock, flags);
@@ -1703,92 +1047,3 @@ out:
         return rv;
 }
 EXPORT_SYMBOL_GPL(efivars_unregister);
-
-static struct efivars generic_efivars;
-static struct efivar_operations generic_ops;
-
-static int generic_ops_register(void)
-{
-        int error;
-
-        generic_ops.get_variable = efi.get_variable;
-        generic_ops.set_variable = efi.set_variable;
-        generic_ops.get_next_variable = efi.get_next_variable;
-        generic_ops.query_variable_info = efi.query_variable_info;
-
-        error = efivars_register(&generic_efivars, &generic_ops, efi_kobj);
-        if (error)
-                return error;
-
-        error = efivars_sysfs_init();
-        if (error)
-                efivars_unregister(&generic_efivars);
-
-        return error;
-}
-
-static void generic_ops_unregister(void)
-{
-        efivars_sysfs_exit();
-        efivars_unregister(&generic_efivars);
-}
-
-/*
- * 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)
-{
-        int error;
-
-        if (!efi_enabled(EFI_RUNTIME_SERVICES))
-                return 0;
-
-        /* Register the efi directory at /sys/firmware/efi */
-        efi_kobj = kobject_create_and_add("efi", firmware_kobj);
-        if (!efi_kobj) {
-                printk(KERN_ERR "efivars: Firmware registration failed.\n");
-                return -ENOMEM;
-        }
-
-        error = generic_ops_register();
-        if (error)
-                goto err_put;
-
-        /* Don't forget the systab entry */
-        error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
-        if (error) {
-                printk(KERN_ERR
-                       "efivars: Sysfs attribute export failed with error %d.\n",
-                       error);
-                goto err_unregister;
-        }
-
-        return 0;
-
-err_unregister:
-        generic_ops_unregister();
-err_put:
-        kobject_put(efi_kobj);
-        return error;
-}
-
-static void __exit
-efivars_exit(void)
-{
-        cancel_work_sync(&efivar_work);
-
-        if (efi_enabled(EFI_RUNTIME_SERVICES)) {
-                generic_ops_unregister();
-                kobject_put(efi_kobj);
-        }
-}
-
-module_init(efivars_init);
-module_exit(efivars_exit);
-