Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound
[linux-2.6.git] / 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 #include <linux/slab.h>
81 #include <linux/pstore.h>
82
83 #include <asm/uaccess.h>
84
85 #define EFIVARS_VERSION "0.08"
86 #define EFIVARS_DATE "2004-May-17"
87
88 MODULE_AUTHOR("Matt Domsch <Matt_Domsch@Dell.com>");
89 MODULE_DESCRIPTION("sysfs interface to EFI Variables");
90 MODULE_LICENSE("GPL");
91 MODULE_VERSION(EFIVARS_VERSION);
92
93 #define DUMP_NAME_LEN 52
94
95 /*
96  * The maximum size of VariableName + Data = 1024
97  * Therefore, it's reasonable to save that much
98  * space in each part of the structure,
99  * and we use a page for reading/writing.
100  */
101
102 struct efi_variable {
103         efi_char16_t  VariableName[1024/sizeof(efi_char16_t)];
104         efi_guid_t    VendorGuid;
105         unsigned long DataSize;
106         __u8          Data[1024];
107         efi_status_t  Status;
108         __u32         Attributes;
109 } __attribute__((packed));
110
111
112 struct efivar_entry {
113         struct efivars *efivars;
114         struct efi_variable var;
115         struct list_head list;
116         struct kobject kobj;
117 };
118
119 struct efivar_attribute {
120         struct attribute attr;
121         ssize_t (*show) (struct efivar_entry *entry, char *buf);
122         ssize_t (*store)(struct efivar_entry *entry, const char *buf, size_t count);
123 };
124
125 #define PSTORE_EFI_ATTRIBUTES \
126         (EFI_VARIABLE_NON_VOLATILE | \
127          EFI_VARIABLE_BOOTSERVICE_ACCESS | \
128          EFI_VARIABLE_RUNTIME_ACCESS)
129
130 #define EFIVAR_ATTR(_name, _mode, _show, _store) \
131 struct efivar_attribute efivar_attr_##_name = { \
132         .attr = {.name = __stringify(_name), .mode = _mode}, \
133         .show = _show, \
134         .store = _store, \
135 };
136
137 #define to_efivar_attr(_attr) container_of(_attr, struct efivar_attribute, attr)
138 #define to_efivar_entry(obj)  container_of(obj, struct efivar_entry, kobj)
139
140 /*
141  * Prototype for sysfs creation function
142  */
143 static int
144 efivar_create_sysfs_entry(struct efivars *efivars,
145                           unsigned long variable_name_size,
146                           efi_char16_t *variable_name,
147                           efi_guid_t *vendor_guid);
148
149 /* Return the number of unicode characters in data */
150 static unsigned long
151 utf16_strnlen(efi_char16_t *s, size_t maxlength)
152 {
153         unsigned long length = 0;
154
155         while (*s++ != 0 && length < maxlength)
156                 length++;
157         return length;
158 }
159
160 static inline unsigned long
161 utf16_strlen(efi_char16_t *s)
162 {
163         return utf16_strnlen(s, ~0UL);
164 }
165
166 /*
167  * Return the number of bytes is the length of this string
168  * Note: this is NOT the same as the number of unicode characters
169  */
170 static inline unsigned long
171 utf16_strsize(efi_char16_t *data, unsigned long maxlength)
172 {
173         return utf16_strnlen(data, maxlength/sizeof(efi_char16_t)) * sizeof(efi_char16_t);
174 }
175
176 static inline int
177 utf16_strncmp(const efi_char16_t *a, const efi_char16_t *b, size_t len)
178 {
179         while (1) {
180                 if (len == 0)
181                         return 0;
182                 if (*a < *b)
183                         return -1;
184                 if (*a > *b)
185                         return 1;
186                 if (*a == 0) /* implies *b == 0 */
187                         return 0;
188                 a++;
189                 b++;
190                 len--;
191         }
192 }
193
194 static efi_status_t
195 get_var_data_locked(struct efivars *efivars, struct efi_variable *var)
196 {
197         efi_status_t status;
198
199         var->DataSize = 1024;
200         status = efivars->ops->get_variable(var->VariableName,
201                                             &var->VendorGuid,
202                                             &var->Attributes,
203                                             &var->DataSize,
204                                             var->Data);
205         return status;
206 }
207
208 static efi_status_t
209 get_var_data(struct efivars *efivars, struct efi_variable *var)
210 {
211         efi_status_t status;
212
213         spin_lock(&efivars->lock);
214         status = get_var_data_locked(efivars, var);
215         spin_unlock(&efivars->lock);
216
217         if (status != EFI_SUCCESS) {
218                 printk(KERN_WARNING "efivars: get_variable() failed 0x%lx!\n",
219                         status);
220         }
221         return status;
222 }
223
224 static ssize_t
225 efivar_guid_read(struct efivar_entry *entry, char *buf)
226 {
227         struct efi_variable *var = &entry->var;
228         char *str = buf;
229
230         if (!entry || !buf)
231                 return 0;
232
233         efi_guid_unparse(&var->VendorGuid, str);
234         str += strlen(str);
235         str += sprintf(str, "\n");
236
237         return str - buf;
238 }
239
240 static ssize_t
241 efivar_attr_read(struct efivar_entry *entry, char *buf)
242 {
243         struct efi_variable *var = &entry->var;
244         char *str = buf;
245         efi_status_t status;
246
247         if (!entry || !buf)
248                 return -EINVAL;
249
250         status = get_var_data(entry->efivars, var);
251         if (status != EFI_SUCCESS)
252                 return -EIO;
253
254         if (var->Attributes & 0x1)
255                 str += sprintf(str, "EFI_VARIABLE_NON_VOLATILE\n");
256         if (var->Attributes & 0x2)
257                 str += sprintf(str, "EFI_VARIABLE_BOOTSERVICE_ACCESS\n");
258         if (var->Attributes & 0x4)
259                 str += sprintf(str, "EFI_VARIABLE_RUNTIME_ACCESS\n");
260         return str - buf;
261 }
262
263 static ssize_t
264 efivar_size_read(struct efivar_entry *entry, char *buf)
265 {
266         struct efi_variable *var = &entry->var;
267         char *str = buf;
268         efi_status_t status;
269
270         if (!entry || !buf)
271                 return -EINVAL;
272
273         status = get_var_data(entry->efivars, var);
274         if (status != EFI_SUCCESS)
275                 return -EIO;
276
277         str += sprintf(str, "0x%lx\n", var->DataSize);
278         return str - buf;
279 }
280
281 static ssize_t
282 efivar_data_read(struct efivar_entry *entry, char *buf)
283 {
284         struct efi_variable *var = &entry->var;
285         efi_status_t status;
286
287         if (!entry || !buf)
288                 return -EINVAL;
289
290         status = get_var_data(entry->efivars, var);
291         if (status != EFI_SUCCESS)
292                 return -EIO;
293
294         memcpy(buf, var->Data, var->DataSize);
295         return var->DataSize;
296 }
297 /*
298  * We allow each variable to be edited via rewriting the
299  * entire efi variable structure.
300  */
301 static ssize_t
302 efivar_store_raw(struct efivar_entry *entry, const char *buf, size_t count)
303 {
304         struct efi_variable *new_var, *var = &entry->var;
305         struct efivars *efivars = entry->efivars;
306         efi_status_t status = EFI_NOT_FOUND;
307
308         if (count != sizeof(struct efi_variable))
309                 return -EINVAL;
310
311         new_var = (struct efi_variable *)buf;
312         /*
313          * If only updating the variable data, then the name
314          * and guid should remain the same
315          */
316         if (memcmp(new_var->VariableName, var->VariableName, sizeof(var->VariableName)) ||
317                 efi_guidcmp(new_var->VendorGuid, var->VendorGuid)) {
318                 printk(KERN_ERR "efivars: Cannot edit the wrong variable!\n");
319                 return -EINVAL;
320         }
321
322         if ((new_var->DataSize <= 0) || (new_var->Attributes == 0)){
323                 printk(KERN_ERR "efivars: DataSize & Attributes must be valid!\n");
324                 return -EINVAL;
325         }
326
327         spin_lock(&efivars->lock);
328         status = efivars->ops->set_variable(new_var->VariableName,
329                                             &new_var->VendorGuid,
330                                             new_var->Attributes,
331                                             new_var->DataSize,
332                                             new_var->Data);
333
334         spin_unlock(&efivars->lock);
335
336         if (status != EFI_SUCCESS) {
337                 printk(KERN_WARNING "efivars: set_variable() failed: status=%lx\n",
338                         status);
339                 return -EIO;
340         }
341
342         memcpy(&entry->var, new_var, count);
343         return count;
344 }
345
346 static ssize_t
347 efivar_show_raw(struct efivar_entry *entry, char *buf)
348 {
349         struct efi_variable *var = &entry->var;
350         efi_status_t status;
351
352         if (!entry || !buf)
353                 return 0;
354
355         status = get_var_data(entry->efivars, var);
356         if (status != EFI_SUCCESS)
357                 return -EIO;
358
359         memcpy(buf, var, sizeof(*var));
360         return sizeof(*var);
361 }
362
363 /*
364  * Generic read/write functions that call the specific functions of
365  * the attributes...
366  */
367 static ssize_t efivar_attr_show(struct kobject *kobj, struct attribute *attr,
368                                 char *buf)
369 {
370         struct efivar_entry *var = to_efivar_entry(kobj);
371         struct efivar_attribute *efivar_attr = to_efivar_attr(attr);
372         ssize_t ret = -EIO;
373
374         if (!capable(CAP_SYS_ADMIN))
375                 return -EACCES;
376
377         if (efivar_attr->show) {
378                 ret = efivar_attr->show(var, buf);
379         }
380         return ret;
381 }
382
383 static ssize_t efivar_attr_store(struct kobject *kobj, struct attribute *attr,
384                                 const char *buf, size_t count)
385 {
386         struct efivar_entry *var = to_efivar_entry(kobj);
387         struct efivar_attribute *efivar_attr = to_efivar_attr(attr);
388         ssize_t ret = -EIO;
389
390         if (!capable(CAP_SYS_ADMIN))
391                 return -EACCES;
392
393         if (efivar_attr->store)
394                 ret = efivar_attr->store(var, buf, count);
395
396         return ret;
397 }
398
399 static const struct sysfs_ops efivar_attr_ops = {
400         .show = efivar_attr_show,
401         .store = efivar_attr_store,
402 };
403
404 static void efivar_release(struct kobject *kobj)
405 {
406         struct efivar_entry *var = container_of(kobj, struct efivar_entry, kobj);
407         kfree(var);
408 }
409
410 static EFIVAR_ATTR(guid, 0400, efivar_guid_read, NULL);
411 static EFIVAR_ATTR(attributes, 0400, efivar_attr_read, NULL);
412 static EFIVAR_ATTR(size, 0400, efivar_size_read, NULL);
413 static EFIVAR_ATTR(data, 0400, efivar_data_read, NULL);
414 static EFIVAR_ATTR(raw_var, 0600, efivar_show_raw, efivar_store_raw);
415
416 static struct attribute *def_attrs[] = {
417         &efivar_attr_guid.attr,
418         &efivar_attr_size.attr,
419         &efivar_attr_attributes.attr,
420         &efivar_attr_data.attr,
421         &efivar_attr_raw_var.attr,
422         NULL,
423 };
424
425 static struct kobj_type efivar_ktype = {
426         .release = efivar_release,
427         .sysfs_ops = &efivar_attr_ops,
428         .default_attrs = def_attrs,
429 };
430
431 static struct pstore_info efi_pstore_info;
432
433 static inline void
434 efivar_unregister(struct efivar_entry *var)
435 {
436         kobject_put(&var->kobj);
437 }
438
439 #ifdef CONFIG_PSTORE
440
441 static int efi_pstore_open(struct pstore_info *psi)
442 {
443         struct efivars *efivars = psi->data;
444
445         spin_lock(&efivars->lock);
446         efivars->walk_entry = list_first_entry(&efivars->list,
447                                                struct efivar_entry, list);
448         return 0;
449 }
450
451 static int efi_pstore_close(struct pstore_info *psi)
452 {
453         struct efivars *efivars = psi->data;
454
455         spin_unlock(&efivars->lock);
456         return 0;
457 }
458
459 static ssize_t efi_pstore_read(u64 *id, enum pstore_type_id *type,
460                                struct timespec *timespec,
461                                char **buf, struct pstore_info *psi)
462 {
463         efi_guid_t vendor = LINUX_EFI_CRASH_GUID;
464         struct efivars *efivars = psi->data;
465         char name[DUMP_NAME_LEN];
466         int i;
467         unsigned int part, size;
468         unsigned long time;
469
470         while (&efivars->walk_entry->list != &efivars->list) {
471                 if (!efi_guidcmp(efivars->walk_entry->var.VendorGuid,
472                                  vendor)) {
473                         for (i = 0; i < DUMP_NAME_LEN; i++) {
474                                 name[i] = efivars->walk_entry->var.VariableName[i];
475                         }
476                         if (sscanf(name, "dump-type%u-%u-%lu", type, &part, &time) == 3) {
477                                 *id = part;
478                                 timespec->tv_sec = time;
479                                 timespec->tv_nsec = 0;
480                                 get_var_data_locked(efivars, &efivars->walk_entry->var);
481                                 size = efivars->walk_entry->var.DataSize;
482                                 *buf = kmalloc(size, GFP_KERNEL);
483                                 if (*buf == NULL)
484                                         return -ENOMEM;
485                                 memcpy(*buf, efivars->walk_entry->var.Data,
486                                        size);
487                                 efivars->walk_entry = list_entry(efivars->walk_entry->list.next,
488                                                    struct efivar_entry, list);
489                                 return size;
490                         }
491                 }
492                 efivars->walk_entry = list_entry(efivars->walk_entry->list.next,
493                                                  struct efivar_entry, list);
494         }
495         return 0;
496 }
497
498 static int efi_pstore_write(enum pstore_type_id type, u64 *id,
499                 unsigned int part, size_t size, struct pstore_info *psi)
500 {
501         char name[DUMP_NAME_LEN];
502         char stub_name[DUMP_NAME_LEN];
503         efi_char16_t efi_name[DUMP_NAME_LEN];
504         efi_guid_t vendor = LINUX_EFI_CRASH_GUID;
505         struct efivars *efivars = psi->data;
506         struct efivar_entry *entry, *found = NULL;
507         int i, ret = 0;
508
509         sprintf(stub_name, "dump-type%u-%u-", type, part);
510         sprintf(name, "%s%lu", stub_name, get_seconds());
511
512         spin_lock(&efivars->lock);
513
514         for (i = 0; i < DUMP_NAME_LEN; i++)
515                 efi_name[i] = stub_name[i];
516
517         /*
518          * Clean up any entries with the same name
519          */
520
521         list_for_each_entry(entry, &efivars->list, list) {
522                 get_var_data_locked(efivars, &entry->var);
523
524                 if (efi_guidcmp(entry->var.VendorGuid, vendor))
525                         continue;
526                 if (utf16_strncmp(entry->var.VariableName, efi_name,
527                                   utf16_strlen(efi_name)))
528                         continue;
529                 /* Needs to be a prefix */
530                 if (entry->var.VariableName[utf16_strlen(efi_name)] == 0)
531                         continue;
532
533                 /* found */
534                 found = entry;
535                 efivars->ops->set_variable(entry->var.VariableName,
536                                            &entry->var.VendorGuid,
537                                            PSTORE_EFI_ATTRIBUTES,
538                                            0, NULL);
539         }
540
541         if (found)
542                 list_del(&found->list);
543
544         for (i = 0; i < DUMP_NAME_LEN; i++)
545                 efi_name[i] = name[i];
546
547         efivars->ops->set_variable(efi_name, &vendor, PSTORE_EFI_ATTRIBUTES,
548                                    size, psi->buf);
549
550         spin_unlock(&efivars->lock);
551
552         if (found)
553                 efivar_unregister(found);
554
555         if (size)
556                 ret = efivar_create_sysfs_entry(efivars,
557                                           utf16_strsize(efi_name,
558                                                         DUMP_NAME_LEN * 2),
559                                           efi_name, &vendor);
560
561         *id = part;
562         return ret;
563 };
564
565 static int efi_pstore_erase(enum pstore_type_id type, u64 id,
566                             struct pstore_info *psi)
567 {
568         efi_pstore_write(type, &id, (unsigned int)id, 0, psi);
569
570         return 0;
571 }
572 #else
573 static int efi_pstore_open(struct pstore_info *psi)
574 {
575         return 0;
576 }
577
578 static int efi_pstore_close(struct pstore_info *psi)
579 {
580         return 0;
581 }
582
583 static ssize_t efi_pstore_read(u64 *id, enum pstore_type_id *type,
584                                struct timespec *timespec,
585                                char **buf, struct pstore_info *psi)
586 {
587         return -1;
588 }
589
590 static int efi_pstore_write(enum pstore_type_id type, u64 *id,
591                 unsigned int part, size_t size, struct pstore_info *psi)
592 {
593         return 0;
594 }
595
596 static int efi_pstore_erase(enum pstore_type_id type, u64 id,
597                             struct pstore_info *psi)
598 {
599         return 0;
600 }
601 #endif
602
603 static struct pstore_info efi_pstore_info = {
604         .owner          = THIS_MODULE,
605         .name           = "efi",
606         .open           = efi_pstore_open,
607         .close          = efi_pstore_close,
608         .read           = efi_pstore_read,
609         .write          = efi_pstore_write,
610         .erase          = efi_pstore_erase,
611 };
612
613 static ssize_t efivar_create(struct file *filp, struct kobject *kobj,
614                              struct bin_attribute *bin_attr,
615                              char *buf, loff_t pos, size_t count)
616 {
617         struct efi_variable *new_var = (struct efi_variable *)buf;
618         struct efivars *efivars = bin_attr->private;
619         struct efivar_entry *search_efivar, *n;
620         unsigned long strsize1, strsize2;
621         efi_status_t status = EFI_NOT_FOUND;
622         int found = 0;
623
624         if (!capable(CAP_SYS_ADMIN))
625                 return -EACCES;
626
627         spin_lock(&efivars->lock);
628
629         /*
630          * Does this variable already exist?
631          */
632         list_for_each_entry_safe(search_efivar, n, &efivars->list, list) {
633                 strsize1 = utf16_strsize(search_efivar->var.VariableName, 1024);
634                 strsize2 = utf16_strsize(new_var->VariableName, 1024);
635                 if (strsize1 == strsize2 &&
636                         !memcmp(&(search_efivar->var.VariableName),
637                                 new_var->VariableName, strsize1) &&
638                         !efi_guidcmp(search_efivar->var.VendorGuid,
639                                 new_var->VendorGuid)) {
640                         found = 1;
641                         break;
642                 }
643         }
644         if (found) {
645                 spin_unlock(&efivars->lock);
646                 return -EINVAL;
647         }
648
649         /* now *really* create the variable via EFI */
650         status = efivars->ops->set_variable(new_var->VariableName,
651                                             &new_var->VendorGuid,
652                                             new_var->Attributes,
653                                             new_var->DataSize,
654                                             new_var->Data);
655
656         if (status != EFI_SUCCESS) {
657                 printk(KERN_WARNING "efivars: set_variable() failed: status=%lx\n",
658                         status);
659                 spin_unlock(&efivars->lock);
660                 return -EIO;
661         }
662         spin_unlock(&efivars->lock);
663
664         /* Create the entry in sysfs.  Locking is not required here */
665         status = efivar_create_sysfs_entry(efivars,
666                                            utf16_strsize(new_var->VariableName,
667                                                          1024),
668                                            new_var->VariableName,
669                                            &new_var->VendorGuid);
670         if (status) {
671                 printk(KERN_WARNING "efivars: variable created, but sysfs entry wasn't.\n");
672         }
673         return count;
674 }
675
676 static ssize_t efivar_delete(struct file *filp, struct kobject *kobj,
677                              struct bin_attribute *bin_attr,
678                              char *buf, loff_t pos, size_t count)
679 {
680         struct efi_variable *del_var = (struct efi_variable *)buf;
681         struct efivars *efivars = bin_attr->private;
682         struct efivar_entry *search_efivar, *n;
683         unsigned long strsize1, strsize2;
684         efi_status_t status = EFI_NOT_FOUND;
685         int found = 0;
686
687         if (!capable(CAP_SYS_ADMIN))
688                 return -EACCES;
689
690         spin_lock(&efivars->lock);
691
692         /*
693          * Does this variable already exist?
694          */
695         list_for_each_entry_safe(search_efivar, n, &efivars->list, list) {
696                 strsize1 = utf16_strsize(search_efivar->var.VariableName, 1024);
697                 strsize2 = utf16_strsize(del_var->VariableName, 1024);
698                 if (strsize1 == strsize2 &&
699                         !memcmp(&(search_efivar->var.VariableName),
700                                 del_var->VariableName, strsize1) &&
701                         !efi_guidcmp(search_efivar->var.VendorGuid,
702                                 del_var->VendorGuid)) {
703                         found = 1;
704                         break;
705                 }
706         }
707         if (!found) {
708                 spin_unlock(&efivars->lock);
709                 return -EINVAL;
710         }
711         /* force the Attributes/DataSize to 0 to ensure deletion */
712         del_var->Attributes = 0;
713         del_var->DataSize = 0;
714
715         status = efivars->ops->set_variable(del_var->VariableName,
716                                             &del_var->VendorGuid,
717                                             del_var->Attributes,
718                                             del_var->DataSize,
719                                             del_var->Data);
720
721         if (status != EFI_SUCCESS) {
722                 printk(KERN_WARNING "efivars: set_variable() failed: status=%lx\n",
723                         status);
724                 spin_unlock(&efivars->lock);
725                 return -EIO;
726         }
727         list_del(&search_efivar->list);
728         /* We need to release this lock before unregistering. */
729         spin_unlock(&efivars->lock);
730         efivar_unregister(search_efivar);
731
732         /* It's dead Jim.... */
733         return count;
734 }
735
736 /*
737  * Let's not leave out systab information that snuck into
738  * the efivars driver
739  */
740 static ssize_t systab_show(struct kobject *kobj,
741                            struct kobj_attribute *attr, char *buf)
742 {
743         char *str = buf;
744
745         if (!kobj || !buf)
746                 return -EINVAL;
747
748         if (efi.mps != EFI_INVALID_TABLE_ADDR)
749                 str += sprintf(str, "MPS=0x%lx\n", efi.mps);
750         if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
751                 str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
752         if (efi.acpi != EFI_INVALID_TABLE_ADDR)
753                 str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
754         if (efi.smbios != EFI_INVALID_TABLE_ADDR)
755                 str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
756         if (efi.hcdp != EFI_INVALID_TABLE_ADDR)
757                 str += sprintf(str, "HCDP=0x%lx\n", efi.hcdp);
758         if (efi.boot_info != EFI_INVALID_TABLE_ADDR)
759                 str += sprintf(str, "BOOTINFO=0x%lx\n", efi.boot_info);
760         if (efi.uga != EFI_INVALID_TABLE_ADDR)
761                 str += sprintf(str, "UGA=0x%lx\n", efi.uga);
762
763         return str - buf;
764 }
765
766 static struct kobj_attribute efi_attr_systab =
767                         __ATTR(systab, 0400, systab_show, NULL);
768
769 static struct attribute *efi_subsys_attrs[] = {
770         &efi_attr_systab.attr,
771         NULL,   /* maybe more in the future? */
772 };
773
774 static struct attribute_group efi_subsys_attr_group = {
775         .attrs = efi_subsys_attrs,
776 };
777
778 static struct kobject *efi_kobj;
779
780 /*
781  * efivar_create_sysfs_entry()
782  * Requires:
783  *    variable_name_size = number of bytes required to hold
784  *                         variable_name (not counting the NULL
785  *                         character at the end.
786  *    efivars->lock is not held on entry or exit.
787  * Returns 1 on failure, 0 on success
788  */
789 static int
790 efivar_create_sysfs_entry(struct efivars *efivars,
791                           unsigned long variable_name_size,
792                           efi_char16_t *variable_name,
793                           efi_guid_t *vendor_guid)
794 {
795         int i, short_name_size = variable_name_size / sizeof(efi_char16_t) + 38;
796         char *short_name;
797         struct efivar_entry *new_efivar;
798
799         short_name = kzalloc(short_name_size + 1, GFP_KERNEL);
800         new_efivar = kzalloc(sizeof(struct efivar_entry), GFP_KERNEL);
801
802         if (!short_name || !new_efivar)  {
803                 kfree(short_name);
804                 kfree(new_efivar);
805                 return 1;
806         }
807
808         new_efivar->efivars = efivars;
809         memcpy(new_efivar->var.VariableName, variable_name,
810                 variable_name_size);
811         memcpy(&(new_efivar->var.VendorGuid), vendor_guid, sizeof(efi_guid_t));
812
813         /* Convert Unicode to normal chars (assume top bits are 0),
814            ala UTF-8 */
815         for (i=0; i < (int)(variable_name_size / sizeof(efi_char16_t)); i++) {
816                 short_name[i] = variable_name[i] & 0xFF;
817         }
818         /* This is ugly, but necessary to separate one vendor's
819            private variables from another's.         */
820
821         *(short_name + strlen(short_name)) = '-';
822         efi_guid_unparse(vendor_guid, short_name + strlen(short_name));
823
824         new_efivar->kobj.kset = efivars->kset;
825         i = kobject_init_and_add(&new_efivar->kobj, &efivar_ktype, NULL,
826                                  "%s", short_name);
827         if (i) {
828                 kfree(short_name);
829                 kfree(new_efivar);
830                 return 1;
831         }
832
833         kobject_uevent(&new_efivar->kobj, KOBJ_ADD);
834         kfree(short_name);
835         short_name = NULL;
836
837         spin_lock(&efivars->lock);
838         list_add(&new_efivar->list, &efivars->list);
839         spin_unlock(&efivars->lock);
840
841         return 0;
842 }
843
844 static int
845 create_efivars_bin_attributes(struct efivars *efivars)
846 {
847         struct bin_attribute *attr;
848         int error;
849
850         /* new_var */
851         attr = kzalloc(sizeof(*attr), GFP_KERNEL);
852         if (!attr)
853                 return -ENOMEM;
854
855         attr->attr.name = "new_var";
856         attr->attr.mode = 0200;
857         attr->write = efivar_create;
858         attr->private = efivars;
859         efivars->new_var = attr;
860
861         /* del_var */
862         attr = kzalloc(sizeof(*attr), GFP_KERNEL);
863         if (!attr) {
864                 error = -ENOMEM;
865                 goto out_free;
866         }
867         attr->attr.name = "del_var";
868         attr->attr.mode = 0200;
869         attr->write = efivar_delete;
870         attr->private = efivars;
871         efivars->del_var = attr;
872
873         sysfs_bin_attr_init(efivars->new_var);
874         sysfs_bin_attr_init(efivars->del_var);
875
876         /* Register */
877         error = sysfs_create_bin_file(&efivars->kset->kobj,
878                                       efivars->new_var);
879         if (error) {
880                 printk(KERN_ERR "efivars: unable to create new_var sysfs file"
881                         " due to error %d\n", error);
882                 goto out_free;
883         }
884         error = sysfs_create_bin_file(&efivars->kset->kobj,
885                                       efivars->del_var);
886         if (error) {
887                 printk(KERN_ERR "efivars: unable to create del_var sysfs file"
888                         " due to error %d\n", error);
889                 sysfs_remove_bin_file(&efivars->kset->kobj,
890                                       efivars->new_var);
891                 goto out_free;
892         }
893
894         return 0;
895 out_free:
896         kfree(efivars->del_var);
897         efivars->del_var = NULL;
898         kfree(efivars->new_var);
899         efivars->new_var = NULL;
900         return error;
901 }
902
903 void unregister_efivars(struct efivars *efivars)
904 {
905         struct efivar_entry *entry, *n;
906
907         list_for_each_entry_safe(entry, n, &efivars->list, list) {
908                 spin_lock(&efivars->lock);
909                 list_del(&entry->list);
910                 spin_unlock(&efivars->lock);
911                 efivar_unregister(entry);
912         }
913         if (efivars->new_var)
914                 sysfs_remove_bin_file(&efivars->kset->kobj, efivars->new_var);
915         if (efivars->del_var)
916                 sysfs_remove_bin_file(&efivars->kset->kobj, efivars->del_var);
917         kfree(efivars->new_var);
918         kfree(efivars->del_var);
919         kset_unregister(efivars->kset);
920 }
921 EXPORT_SYMBOL_GPL(unregister_efivars);
922
923 int register_efivars(struct efivars *efivars,
924                      const struct efivar_operations *ops,
925                      struct kobject *parent_kobj)
926 {
927         efi_status_t status = EFI_NOT_FOUND;
928         efi_guid_t vendor_guid;
929         efi_char16_t *variable_name;
930         unsigned long variable_name_size = 1024;
931         int error = 0;
932
933         variable_name = kzalloc(variable_name_size, GFP_KERNEL);
934         if (!variable_name) {
935                 printk(KERN_ERR "efivars: Memory allocation failed.\n");
936                 return -ENOMEM;
937         }
938
939         spin_lock_init(&efivars->lock);
940         INIT_LIST_HEAD(&efivars->list);
941         efivars->ops = ops;
942
943         efivars->kset = kset_create_and_add("vars", NULL, parent_kobj);
944         if (!efivars->kset) {
945                 printk(KERN_ERR "efivars: Subsystem registration failed.\n");
946                 error = -ENOMEM;
947                 goto out;
948         }
949
950         /*
951          * Per EFI spec, the maximum storage allocated for both
952          * the variable name and variable data is 1024 bytes.
953          */
954
955         do {
956                 variable_name_size = 1024;
957
958                 status = ops->get_next_variable(&variable_name_size,
959                                                 variable_name,
960                                                 &vendor_guid);
961                 switch (status) {
962                 case EFI_SUCCESS:
963                         efivar_create_sysfs_entry(efivars,
964                                                   variable_name_size,
965                                                   variable_name,
966                                                   &vendor_guid);
967                         break;
968                 case EFI_NOT_FOUND:
969                         break;
970                 default:
971                         printk(KERN_WARNING "efivars: get_next_variable: status=%lx\n",
972                                 status);
973                         status = EFI_NOT_FOUND;
974                         break;
975                 }
976         } while (status != EFI_NOT_FOUND);
977
978         error = create_efivars_bin_attributes(efivars);
979         if (error)
980                 unregister_efivars(efivars);
981
982         efivars->efi_pstore_info = efi_pstore_info;
983
984         efivars->efi_pstore_info.buf = kmalloc(4096, GFP_KERNEL);
985         if (efivars->efi_pstore_info.buf) {
986                 efivars->efi_pstore_info.bufsize = 1024;
987                 efivars->efi_pstore_info.data = efivars;
988                 spin_lock_init(&efivars->efi_pstore_info.buf_lock);
989                 pstore_register(&efivars->efi_pstore_info);
990         }
991
992 out:
993         kfree(variable_name);
994
995         return error;
996 }
997 EXPORT_SYMBOL_GPL(register_efivars);
998
999 static struct efivars __efivars;
1000 static struct efivar_operations ops;
1001
1002 /*
1003  * For now we register the efi subsystem with the firmware subsystem
1004  * and the vars subsystem with the efi subsystem.  In the future, it
1005  * might make sense to split off the efi subsystem into its own
1006  * driver, but for now only efivars will register with it, so just
1007  * include it here.
1008  */
1009
1010 static int __init
1011 efivars_init(void)
1012 {
1013         int error = 0;
1014
1015         printk(KERN_INFO "EFI Variables Facility v%s %s\n", EFIVARS_VERSION,
1016                EFIVARS_DATE);
1017
1018         if (!efi_enabled)
1019                 return 0;
1020
1021         /* For now we'll register the efi directory at /sys/firmware/efi */
1022         efi_kobj = kobject_create_and_add("efi", firmware_kobj);
1023         if (!efi_kobj) {
1024                 printk(KERN_ERR "efivars: Firmware registration failed.\n");
1025                 return -ENOMEM;
1026         }
1027
1028         ops.get_variable = efi.get_variable;
1029         ops.set_variable = efi.set_variable;
1030         ops.get_next_variable = efi.get_next_variable;
1031         error = register_efivars(&__efivars, &ops, efi_kobj);
1032         if (error)
1033                 goto err_put;
1034
1035         /* Don't forget the systab entry */
1036         error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
1037         if (error) {
1038                 printk(KERN_ERR
1039                        "efivars: Sysfs attribute export failed with error %d.\n",
1040                        error);
1041                 goto err_unregister;
1042         }
1043
1044         return 0;
1045
1046 err_unregister:
1047         unregister_efivars(&__efivars);
1048 err_put:
1049         kobject_put(efi_kobj);
1050         return error;
1051 }
1052
1053 static void __exit
1054 efivars_exit(void)
1055 {
1056         if (efi_enabled) {
1057                 unregister_efivars(&__efivars);
1058                 kobject_put(efi_kobj);
1059         }
1060 }
1061
1062 module_init(efivars_init);
1063 module_exit(efivars_exit);
1064