drivers/firmware/efivars.c

   1 /*
   2  * EFI Variables - efivars.c
   3  *
   4  * Copyright (C) 2001,2003,2004 Dell <Matt_Domsch@dell.com>
   5  * Copyright (C) 2004 Intel Corporation <matthew.e.tolentino@intel.com>
   6  *
   7  * This code takes all variables accessible from EFI runtime and
   8  *  exports them via sysfs
   9  *
  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.
  14  *
  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.
  19  *
  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
  23  *
  24  * Changelog:
  25  *
  26  *  17 May 2004 - Matt Domsch <Matt_Domsch@dell.com>
  27  *   remove check for efi_enabled in exit
  28  *   add MODULE_VERSION
  29  *
  30  *  26 Apr 2004 - Matt Domsch <Matt_Domsch@dell.com>
  31  *   minor bug fixes
  32  *
  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
  37  *
  38  *  10 Dec 2002 - Matt Domsch <Matt_Domsch@dell.com>
  39  *   fix locking per Peter Chubb's findings
  40  *
  41  *  25 Mar 2002 - Matt Domsch <Matt_Domsch@dell.com>
  42  *   move uuid_unparse() to include/asm-ia64/efi.h:efi_guid_unparse()
  43  *
  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
  48  *
  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
  53  *
  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.
  57  *
  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
  63  *
  64  *  26 February 2001 - Matt Domsch <Matt_Domsch@dell.com>
  65  *   v0.01 release to linux-ia64@linuxia64.org
  66  */
  67
  68 #include <linux/capability.h>
  69 #include <linux/types.h>
  70 #include <linux/errno.h>
  71 #include <linux/init.h>
  72 #include <linux/mm.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
  81 #include <asm/uaccess.h>
  82
  83 #define EFIVARS_VERSION "0.08"
  84 #define EFIVARS_DATE "2004-May-17"
  85
  86 MODULE_AUTHOR("Matt Domsch <Matt_Domsch@Dell.com>");
  87 MODULE_DESCRIPTION("sysfs interface to EFI Variables");
  88 MODULE_LICENSE("GPL");
  89 MODULE_VERSION(EFIVARS_VERSION);
  90
  91 /*
  92  * efivars_lock protects two things:
  93  * 1) efivar_list - adds, removals, reads, writes
  94  * 2) efi.[gs]et_variable() calls.
  95  * It must not be held when creating sysfs entries or calling kmalloc.
  96  * efi.get_next_variable() is only called from efivars_init(),
  97  * which is protected by the BKL, so that path is safe.
  98  */
  99 static DEFINE_SPINLOCK(efivars_lock);
 100 static LIST_HEAD(efivar_list);
 101
 102 /*
 103  * The maximum size of VariableName + Data = 1024
 104  * Therefore, it's reasonable to save that much
 105  * space in each part of the structure,
 106  * and we use a page for reading/writing.
 107  */
 108
 109 struct efi_variable {
 110         efi_char16_t  VariableName[1024/sizeof(efi_char16_t)];
 111         efi_guid_t    VendorGuid;
 112         unsigned long DataSize;
 113         __u8          Data[1024];
 114         efi_status_t  Status;
 115         __u32         Attributes;
 116 } __attribute__((packed));
 117
 118
 119 struct efivar_entry {
 120         struct efi_variable var;
 121         struct list_head list;
 122         struct kobject kobj;
 123 };
 124
 125 #define get_efivar_entry(n) list_entry(n, struct efivar_entry, list)
 126
 127 struct efivar_attribute {
 128         struct attribute attr;
 129         ssize_t (*show) (struct efivar_entry *entry, char *buf);
 130         ssize_t (*store)(struct efivar_entry *entry, const char *buf, size_t count);
 131 };
 132
 133
 134 #define EFI_ATTR(_name, _mode, _show, _store) \
 135 struct subsys_attribute efi_attr_##_name = { \
 136         .attr = {.name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE}, \
 137         .show = _show, \
 138         .store = _store, \
 139 };
 140
 141 #define EFIVAR_ATTR(_name, _mode, _show, _store) \
 142 struct efivar_attribute efivar_attr_##_name = { \
 143         .attr = {.name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE}, \
 144         .show = _show, \
 145         .store = _store, \
 146 };
 147
 148 #define VAR_SUBSYS_ATTR(_name, _mode, _show, _store) \
 149 struct subsys_attribute var_subsys_attr_##_name = { \
 150         .attr = {.name = __stringify(_name), .mode = _mode, .owner = THIS_MODULE}, \
 151         .show = _show, \
 152         .store = _store, \
 153 };
 154
 155 #define to_efivar_attr(_attr) container_of(_attr, struct efivar_attribute, attr)
 156 #define to_efivar_entry(obj)  container_of(obj, struct efivar_entry, kobj)
 157
 158 /*
 159  * Prototype for sysfs creation function
 160  */
 161 static int
 162 efivar_create_sysfs_entry(unsigned long variable_name_size,
 163                                 efi_char16_t *variable_name,
 164                                 efi_guid_t *vendor_guid);
 165
 166 /* Return the number of unicode characters in data */
 167 static unsigned long
 168 utf8_strlen(efi_char16_t *data, unsigned long maxlength)
 169 {
 170         unsigned long length = 0;
 171
 172         while (*data++ != 0 && length < maxlength)
 173                 length++;
 174         return length;
 175 }
 176
 177 /*
 178  * Return the number of bytes is the length of this string
 179  * Note: this is NOT the same as the number of unicode characters
 180  */
 181 static inline unsigned long
 182 utf8_strsize(efi_char16_t *data, unsigned long maxlength)
 183 {
 184         return utf8_strlen(data, maxlength/sizeof(efi_char16_t)) * sizeof(efi_char16_t);
 185 }
 186
 187 static efi_status_t
 188 get_var_data(struct efi_variable *var)
 189 {
 190         efi_status_t status;
 191
 192         spin_lock(&efivars_lock);
 193         var->DataSize = 1024;
 194         status = efi.get_variable(var->VariableName,
 195                                 &var->VendorGuid,
 196                                 &var->Attributes,
 197                                 &var->DataSize,
 198                                 var->Data);
 199         spin_unlock(&efivars_lock);
 200         if (status != EFI_SUCCESS) {
 201                 printk(KERN_WARNING "efivars: get_variable() failed 0x%lx!\n",
 202                         status);
 203         }
 204         return status;
 205 }
 206
 207 static ssize_t
 208 efivar_guid_read(struct efivar_entry *entry, char *buf)
 209 {
 210         struct efi_variable *var = &entry->var;
 211         char *str = buf;
 212
 213         if (!entry || !buf)
 214                 return 0;
 215
 216         efi_guid_unparse(&var->VendorGuid, str);
 217         str += strlen(str);
 218         str += sprintf(str, "\n");
 219
 220         return str - buf;
 221 }
 222
 223 static ssize_t
 224 efivar_attr_read(struct efivar_entry *entry, char *buf)
 225 {
 226         struct efi_variable *var = &entry->var;
 227         char *str = buf;
 228         efi_status_t status;
 229
 230         if (!entry || !buf)
 231                 return -EINVAL;
 232
 233         status = get_var_data(var);
 234         if (status != EFI_SUCCESS)
 235                 return -EIO;
 236
 237         if (var->Attributes & 0x1)
 238                 str += sprintf(str, "EFI_VARIABLE_NON_VOLATILE\n");
 239         if (var->Attributes & 0x2)
 240                 str += sprintf(str, "EFI_VARIABLE_BOOTSERVICE_ACCESS\n");
 241         if (var->Attributes & 0x4)
 242                 str += sprintf(str, "EFI_VARIABLE_RUNTIME_ACCESS\n");
 243         return str - buf;
 244 }
 245
 246 static ssize_t
 247 efivar_size_read(struct efivar_entry *entry, char *buf)
 248 {
 249         struct efi_variable *var = &entry->var;
 250         char *str = buf;
 251         efi_status_t status;
 252
 253         if (!entry || !buf)
 254                 return -EINVAL;
 255
 256         status = get_var_data(var);
 257         if (status != EFI_SUCCESS)
 258                 return -EIO;
 259
 260         str += sprintf(str, "0x%lx\n", var->DataSize);
 261         return str - buf;
 262 }
 263
 264 static ssize_t
 265 efivar_data_read(struct efivar_entry *entry, char *buf)
 266 {
 267         struct efi_variable *var = &entry->var;
 268         efi_status_t status;
 269
 270         if (!entry || !buf)
 271                 return -EINVAL;
 272
 273         status = get_var_data(var);
 274         if (status != EFI_SUCCESS)
 275                 return -EIO;
 276
 277         memcpy(buf, var->Data, var->DataSize);
 278         return var->DataSize;
 279 }
 280 /*
 281  * We allow each variable to be edited via rewriting the
 282  * entire efi variable structure.
 283  */
 284 static ssize_t
 285 efivar_store_raw(struct efivar_entry *entry, const char *buf, size_t count)
 286 {
 287         struct efi_variable *new_var, *var = &entry->var;
 288         efi_status_t status = EFI_NOT_FOUND;
 289
 290         if (count != sizeof(struct efi_variable))
 291                 return -EINVAL;
 292
 293         new_var = (struct efi_variable *)buf;
 294         /*
 295          * If only updating the variable data, then the name
 296          * and guid should remain the same
 297          */
 298         if (memcmp(new_var->VariableName, var->VariableName, sizeof(var->VariableName)) ||
 299                 efi_guidcmp(new_var->VendorGuid, var->VendorGuid)) {
 300                 printk(KERN_ERR "efivars: Cannot edit the wrong variable!\n");
 301                 return -EINVAL;
 302         }
 303
 304         if ((new_var->DataSize <= 0) || (new_var->Attributes == 0)){
 305                 printk(KERN_ERR "efivars: DataSize & Attributes must be valid!\n");
 306                 return -EINVAL;
 307         }
 308
 309         spin_lock(&efivars_lock);
 310         status = efi.set_variable(new_var->VariableName,
 311                                         &new_var->VendorGuid,
 312                                         new_var->Attributes,
 313                                         new_var->DataSize,
 314                                         new_var->Data);
 315
 316         spin_unlock(&efivars_lock);
 317
 318         if (status != EFI_SUCCESS) {
 319                 printk(KERN_WARNING "efivars: set_variable() failed: status=%lx\n",
 320                         status);
 321                 return -EIO;
 322         }
 323
 324         memcpy(&entry->var, new_var, count);
 325         return count;
 326 }
 327
 328 static ssize_t
 329 efivar_show_raw(struct efivar_entry *entry, char *buf)
 330 {
 331         struct efi_variable *var = &entry->var;
 332         efi_status_t status;
 333
 334         if (!entry || !buf)
 335                 return 0;
 336
 337         status = get_var_data(var);
 338         if (status != EFI_SUCCESS)
 339                 return -EIO;
 340
 341         memcpy(buf, var, sizeof(*var));
 342         return sizeof(*var);
 343 }
 344
 345 /*
 346  * Generic read/write functions that call the specific functions of
 347  * the atttributes...
 348  */
 349 static ssize_t efivar_attr_show(struct kobject *kobj, struct attribute *attr,
 350                                 char *buf)
 351 {
 352         struct efivar_entry *var = to_efivar_entry(kobj);
 353         struct efivar_attribute *efivar_attr = to_efivar_attr(attr);
 354         ssize_t ret = -EIO;
 355
 356         if (!capable(CAP_SYS_ADMIN))
 357                 return -EACCES;
 358
 359         if (efivar_attr->show) {
 360                 ret = efivar_attr->show(var, buf);
 361         }
 362         return ret;
 363 }
 364
 365 static ssize_t efivar_attr_store(struct kobject *kobj, struct attribute *attr,
 366                                 const char *buf, size_t count)
 367 {
 368         struct efivar_entry *var = to_efivar_entry(kobj);
 369         struct efivar_attribute *efivar_attr = to_efivar_attr(attr);
 370         ssize_t ret = -EIO;
 371
 372         if (!capable(CAP_SYS_ADMIN))
 373                 return -EACCES;
 374
 375         if (efivar_attr->store)
 376                 ret = efivar_attr->store(var, buf, count);
 377
 378         return ret;
 379 }
 380
 381 static struct sysfs_ops efivar_attr_ops = {
 382         .show = efivar_attr_show,
 383         .store = efivar_attr_store,
 384 };
 385
 386 static void efivar_release(struct kobject *kobj)
 387 {
 388         struct efivar_entry *var = container_of(kobj, struct efivar_entry, kobj);
 389         spin_lock(&efivars_lock);
 390         list_del(&var->list);
 391         spin_unlock(&efivars_lock);
 392         kfree(var);
 393 }
 394
 395 static EFIVAR_ATTR(guid, 0400, efivar_guid_read, NULL);
 396 static EFIVAR_ATTR(attributes, 0400, efivar_attr_read, NULL);
 397 static EFIVAR_ATTR(size, 0400, efivar_size_read, NULL);
 398 static EFIVAR_ATTR(data, 0400, efivar_data_read, NULL);
 399 static EFIVAR_ATTR(raw_var, 0600, efivar_show_raw, efivar_store_raw);
 400
 401 static struct attribute *def_attrs[] = {
 402         &efivar_attr_guid.attr,
 403         &efivar_attr_size.attr,
 404         &efivar_attr_attributes.attr,
 405         &efivar_attr_data.attr,
 406         &efivar_attr_raw_var.attr,
 407         NULL,
 408 };
 409
 410 static struct kobj_type ktype_efivar = {
 411         .release = efivar_release,
 412         .sysfs_ops = &efivar_attr_ops,
 413         .default_attrs = def_attrs,
 414 };
 415
 416 static ssize_t
 417 dummy(struct subsystem *sub, char *buf)
 418 {
 419         return -ENODEV;
 420 }
 421
 422 static inline void
 423 efivar_unregister(struct efivar_entry *var)
 424 {
 425         kobject_unregister(&var->kobj);
 426 }
 427
 428
 429 static ssize_t
 430 efivar_create(struct subsystem *sub, const char *buf, size_t count)
 431 {
 432         struct efi_variable *new_var = (struct efi_variable *)buf;
 433         struct efivar_entry *search_efivar = NULL;
 434         unsigned long strsize1, strsize2;
 435         struct list_head *pos, *n;
 436         efi_status_t status = EFI_NOT_FOUND;
 437         int found = 0;
 438
 439         if (!capable(CAP_SYS_ADMIN))
 440                 return -EACCES;
 441
 442         spin_lock(&efivars_lock);
 443
 444         /*
 445          * Does this variable already exist?
 446          */
 447         list_for_each_safe(pos, n, &efivar_list) {
 448                 search_efivar = get_efivar_entry(pos);
 449                 strsize1 = utf8_strsize(search_efivar->var.VariableName, 1024);
 450                 strsize2 = utf8_strsize(new_var->VariableName, 1024);
 451                 if (strsize1 == strsize2 &&
 452                         !memcmp(&(search_efivar->var.VariableName),
 453                                 new_var->VariableName, strsize1) &&
 454                         !efi_guidcmp(search_efivar->var.VendorGuid,
 455                                 new_var->VendorGuid)) {
 456                         found = 1;
 457                         break;
 458                 }
 459         }
 460         if (found) {
 461                 spin_unlock(&efivars_lock);
 462                 return -EINVAL;
 463         }
 464
 465         /* now *really* create the variable via EFI */
 466         status = efi.set_variable(new_var->VariableName,
 467                         &new_var->VendorGuid,
 468                         new_var->Attributes,
 469                         new_var->DataSize,
 470                         new_var->Data);
 471
 472         if (status != EFI_SUCCESS) {
 473                 printk(KERN_WARNING "efivars: set_variable() failed: status=%lx\n",
 474                         status);
 475                 spin_unlock(&efivars_lock);
 476                 return -EIO;
 477         }
 478         spin_unlock(&efivars_lock);
 479
 480         /* Create the entry in sysfs.  Locking is not required here */
 481         status = efivar_create_sysfs_entry(utf8_strsize(new_var->VariableName,
 482                         1024), new_var->VariableName, &new_var->VendorGuid);
 483         if (status) {
 484                 printk(KERN_WARNING "efivars: variable created, but sysfs entry wasn't.\n");
 485         }
 486         return count;
 487 }
 488
 489 static ssize_t
 490 efivar_delete(struct subsystem *sub, const char *buf, size_t count)
 491 {
 492         struct efi_variable *del_var = (struct efi_variable *)buf;
 493         struct efivar_entry *search_efivar = NULL;
 494         unsigned long strsize1, strsize2;
 495         struct list_head *pos, *n;
 496         efi_status_t status = EFI_NOT_FOUND;
 497         int found = 0;
 498
 499         if (!capable(CAP_SYS_ADMIN))
 500                 return -EACCES;
 501
 502         spin_lock(&efivars_lock);
 503
 504         /*
 505          * Does this variable already exist?
 506          */
 507         list_for_each_safe(pos, n, &efivar_list) {
 508                 search_efivar = get_efivar_entry(pos);
 509                 strsize1 = utf8_strsize(search_efivar->var.VariableName, 1024);
 510                 strsize2 = utf8_strsize(del_var->VariableName, 1024);
 511                 if (strsize1 == strsize2 &&
 512                         !memcmp(&(search_efivar->var.VariableName),
 513                                 del_var->VariableName, strsize1) &&
 514                         !efi_guidcmp(search_efivar->var.VendorGuid,
 515                                 del_var->VendorGuid)) {
 516                         found = 1;
 517                         break;
 518                 }
 519         }
 520         if (!found) {
 521                 spin_unlock(&efivars_lock);
 522                 return -EINVAL;
 523         }
 524         /* force the Attributes/DataSize to 0 to ensure deletion */
 525         del_var->Attributes = 0;
 526         del_var->DataSize = 0;
 527
 528         status = efi.set_variable(del_var->VariableName,
 529                         &del_var->VendorGuid,
 530                         del_var->Attributes,
 531                         del_var->DataSize,
 532                         del_var->Data);
 533
 534         if (status != EFI_SUCCESS) {
 535                 printk(KERN_WARNING "efivars: set_variable() failed: status=%lx\n",
 536                         status);
 537                 spin_unlock(&efivars_lock);
 538                 return -EIO;
 539         }
 540         /* We need to release this lock before unregistering. */
 541         spin_unlock(&efivars_lock);
 542
 543         efivar_unregister(search_efivar);
 544
 545         /* It's dead Jim.... */
 546         return count;
 547 }
 548
 549 static VAR_SUBSYS_ATTR(new_var, 0200, dummy, efivar_create);
 550 static VAR_SUBSYS_ATTR(del_var, 0200, dummy, efivar_delete);
 551
 552 static struct subsys_attribute *var_subsys_attrs[] = {
 553         &var_subsys_attr_new_var,
 554         &var_subsys_attr_del_var,
 555         NULL,
 556 };
 557
 558 /*
 559  * Let's not leave out systab information that snuck into
 560  * the efivars driver
 561  */
 562 static ssize_t
 563 systab_read(struct subsystem *entry, char *buf)
 564 {
 565         char *str = buf;
 566
 567         if (!entry || !buf)
 568                 return -EINVAL;
 569
 570         if (efi.mps != EFI_INVALID_TABLE_ADDR)
 571                 str += sprintf(str, "MPS=0x%lx\n", efi.mps);
 572         if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
 573                 str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
 574         if (efi.acpi != EFI_INVALID_TABLE_ADDR)
 575                 str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
 576         if (efi.smbios != EFI_INVALID_TABLE_ADDR)
 577                 str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
 578         if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
 579                 str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
 580         if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
 581                 str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
 582         if (efi.uga != EFI_INVALID_TABLE_ADDR)
 583                 str += sprintf(str, "UGA=0x%lx\n", efi.uga);
 584
 585         return str - buf;
 586 }
 587
 588 static EFI_ATTR(systab, 0400, systab_read, NULL);
 589
 590 static struct subsys_attribute *efi_subsys_attrs[] = {
 591         &efi_attr_systab,
 592         NULL,   /* maybe more in the future? */
 593 };
 594
 595 static decl_subsys(vars, &ktype_efivar, NULL);
 596 static decl_subsys(efi, NULL, NULL);
 597
 598 /*
 599  * efivar_create_sysfs_entry()
 600  * Requires:
 601  *    variable_name_size = number of bytes required to hold
 602  *                         variable_name (not counting the NULL
 603  *                         character at the end.
 604  *    efivars_lock is not held on entry or exit.
 605  * Returns 1 on failure, 0 on success
 606  */
 607 static int
 608 efivar_create_sysfs_entry(unsigned long variable_name_size,
 609                         efi_char16_t *variable_name,
 610                         efi_guid_t *vendor_guid)
 611 {
 612         int i, short_name_size = variable_name_size / sizeof(efi_char16_t) + 38;
 613         char *short_name;
 614         struct efivar_entry *new_efivar;
 615
 616         short_name = kzalloc(short_name_size + 1, GFP_KERNEL);
 617         new_efivar = kzalloc(sizeof(struct efivar_entry), GFP_KERNEL);
 618
 619         if (!short_name || !new_efivar)  {
 620                 kfree(short_name);
 621                 kfree(new_efivar);
 622                 return 1;
 623         }
 624
 625         memcpy(new_efivar->var.VariableName, variable_name,
 626                 variable_name_size);
 627         memcpy(&(new_efivar->var.VendorGuid), vendor_guid, sizeof(efi_guid_t));
 628
 629         /* Convert Unicode to normal chars (assume top bits are 0),
 630            ala UTF-8 */
 631         for (i=0; i < (int)(variable_name_size / sizeof(efi_char16_t)); i++) {
 632                 short_name[i] = variable_name[i] & 0xFF;
 633         }
 634         /* This is ugly, but necessary to separate one vendor's
 635            private variables from another's.         */
 636
 637         *(short_name + strlen(short_name)) = '-';
 638         efi_guid_unparse(vendor_guid, short_name + strlen(short_name));
 639
 640         kobject_set_name(&new_efivar->kobj, "%s", short_name);
 641         kobj_set_kset_s(new_efivar, vars_subsys);
 642         kobject_register(&new_efivar->kobj);
 643
 644         kfree(short_name);
 645         short_name = NULL;
 646
 647         spin_lock(&efivars_lock);
 648         list_add(&new_efivar->list, &efivar_list);
 649         spin_unlock(&efivars_lock);
 650
 651         return 0;
 652 }
 653 /*
 654  * For now we register the efi subsystem with the firmware subsystem
 655  * and the vars subsystem with the efi subsystem.  In the future, it
 656  * might make sense to split off the efi subsystem into its own
 657  * driver, but for now only efivars will register with it, so just
 658  * include it here.
 659  */
 660
 661 static int __init
 662 efivars_init(void)
 663 {
 664         efi_status_t status = EFI_NOT_FOUND;
 665         efi_guid_t vendor_guid;
 666         efi_char16_t *variable_name;
 667         struct subsys_attribute *attr;
 668         unsigned long variable_name_size = 1024;
 669         int i, error = 0;
 670
 671         if (!efi_enabled)
 672                 return -ENODEV;
 673
 674         variable_name = kzalloc(variable_name_size, GFP_KERNEL);
 675         if (!variable_name) {
 676                 printk(KERN_ERR "efivars: Memory allocation failed.\n");
 677                 return -ENOMEM;
 678         }
 679
 680         printk(KERN_INFO "EFI Variables Facility v%s %s\n", EFIVARS_VERSION,
 681                EFIVARS_DATE);
 682
 683         /*
 684          * For now we'll register the efi subsys within this driver
 685          */
 686
 687         error = firmware_register(&efi_subsys);
 688
 689         if (error) {
 690                 printk(KERN_ERR "efivars: Firmware registration failed with error %d.\n", error);
 691                 goto out_free;
 692         }
 693
 694         kset_set_kset_s(&vars_subsys, efi_subsys);
 695
 696         error = subsystem_register(&vars_subsys);
 697
 698         if (error) {
 699                 printk(KERN_ERR "efivars: Subsystem registration failed with error %d.\n", error);
 700                 goto out_firmware_unregister;
 701         }
 702
 703         /*
 704          * Per EFI spec, the maximum storage allocated for both
 705          * the variable name and variable data is 1024 bytes.
 706          */
 707
 708         do {
 709                 variable_name_size = 1024;
 710
 711                 status = efi.get_next_variable(&variable_name_size,
 712                                                 variable_name,
 713                                                 &vendor_guid);
 714                 switch (status) {
 715                 case EFI_SUCCESS:
 716                         efivar_create_sysfs_entry(variable_name_size,
 717                                                         variable_name,
 718                                                         &vendor_guid);
 719                         break;
 720                 case EFI_NOT_FOUND:
 721                         break;
 722                 default:
 723                         printk(KERN_WARNING "efivars: get_next_variable: status=%lx\n",
 724                                 status);
 725                         status = EFI_NOT_FOUND;
 726                         break;
 727                 }
 728         } while (status != EFI_NOT_FOUND);
 729
 730         /*
 731          * Now add attributes to allow creation of new vars
 732          * and deletion of existing ones...
 733          */
 734
 735         for (i = 0; (attr = var_subsys_attrs[i]) && !error; i++) {
 736                 if (attr->show && attr->store)
 737                         error = subsys_create_file(&vars_subsys, attr);
 738         }
 739
 740         /* Don't forget the systab entry */
 741
 742         for (i = 0; (attr = efi_subsys_attrs[i]) && !error; i++) {
 743                 if (attr->show)
 744                         error = subsys_create_file(&efi_subsys, attr);
 745         }
 746
 747         if (error)
 748                 printk(KERN_ERR "efivars: Sysfs attribute export failed with error %d.\n", error);
 749         else
 750                 goto out_free;
 751
 752         subsystem_unregister(&vars_subsys);
 753
 754 out_firmware_unregister:
 755         firmware_unregister(&efi_subsys);
 756
 757 out_free:
 758         kfree(variable_name);
 759
 760         return error;
 761 }
 762
 763 static void __exit
 764 efivars_exit(void)
 765 {
 766         struct list_head *pos, *n;
 767
 768         list_for_each_safe(pos, n, &efivar_list)
 769                 efivar_unregister(get_efivar_entry(pos));
 770
 771         subsystem_unregister(&vars_subsys);
 772         firmware_unregister(&efi_subsys);
 773 }
 774
 775 module_init(efivars_init);
 776 module_exit(efivars_exit);
 777