blob: 834615f13f3e32f5f79498a109949ff77d301741 [file] [log] [blame]
Matt Flemingd68772b2013-02-08 16:27:24 +00001/*
2 * Copyright (C) 2012 Red Hat, Inc.
3 * Copyright (C) 2012 Jeremy Kerr <jeremy.kerr@canonical.com>
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 */
9
10#include <linux/ctype.h>
11#include <linux/efi.h>
12#include <linux/fs.h>
13#include <linux/module.h>
14#include <linux/pagemap.h>
Matt Fleminga614e192013-04-30 11:30:24 +010015#include <linux/ucs2_string.h>
Linus Torvalds20b4fb42013-05-01 17:51:54 -070016#include <linux/slab.h>
17#include <linux/magic.h>
Matt Flemingd68772b2013-02-08 16:27:24 +000018
19#include "internal.h"
20
21LIST_HEAD(efivarfs_list);
22
23static void efivarfs_evict_inode(struct inode *inode)
24{
25 clear_inode(inode);
26}
27
28static const struct super_operations efivarfs_ops = {
29 .statfs = simple_statfs,
30 .drop_inode = generic_delete_inode,
31 .evict_inode = efivarfs_evict_inode,
Matt Flemingd68772b2013-02-08 16:27:24 +000032};
33
34static struct super_block *efivarfs_sb;
35
36/*
37 * Compare two efivarfs file names.
38 *
39 * An efivarfs filename is composed of two parts,
40 *
41 * 1. A case-sensitive variable name
42 * 2. A case-insensitive GUID
43 *
44 * So we need to perform a case-sensitive match on part 1 and a
45 * case-insensitive match on part 2.
46 */
Al Viro6fa67e72016-07-31 16:37:25 -040047static int efivarfs_d_compare(const struct dentry *dentry,
Matt Flemingd68772b2013-02-08 16:27:24 +000048 unsigned int len, const char *str,
49 const struct qstr *name)
50{
51 int guid = len - EFI_VARIABLE_GUID_LEN;
52
53 if (name->len != len)
54 return 1;
55
56 /* Case-sensitive compare for the variable name */
57 if (memcmp(str, name->name, guid))
58 return 1;
59
60 /* Case-insensitive compare for the GUID */
61 return strncasecmp(name->name + guid, str + guid, EFI_VARIABLE_GUID_LEN);
62}
63
Linus Torvaldsda53be12013-05-21 15:22:44 -070064static int efivarfs_d_hash(const struct dentry *dentry, struct qstr *qstr)
Matt Flemingd68772b2013-02-08 16:27:24 +000065{
Linus Torvalds8387ff22016-06-10 07:51:30 -070066 unsigned long hash = init_name_hash(dentry);
Matt Flemingd68772b2013-02-08 16:27:24 +000067 const unsigned char *s = qstr->name;
68 unsigned int len = qstr->len;
69
70 if (!efivarfs_valid_name(s, len))
71 return -EINVAL;
72
73 while (len-- > EFI_VARIABLE_GUID_LEN)
74 hash = partial_name_hash(*s++, hash);
75
76 /* GUID is case-insensitive. */
77 while (len--)
78 hash = partial_name_hash(tolower(*s++), hash);
79
80 qstr->hash = end_name_hash(hash);
81 return 0;
82}
83
Fabian Fredericke37dcbf2014-06-04 16:11:14 -070084static const struct dentry_operations efivarfs_d_ops = {
Matt Flemingd68772b2013-02-08 16:27:24 +000085 .d_compare = efivarfs_d_compare,
86 .d_hash = efivarfs_d_hash,
Al Virob26d4cd2013-10-25 18:47:37 -040087 .d_delete = always_delete_dentry,
Matt Flemingd68772b2013-02-08 16:27:24 +000088};
89
90static struct dentry *efivarfs_alloc_dentry(struct dentry *parent, char *name)
91{
92 struct dentry *d;
93 struct qstr q;
94 int err;
95
96 q.name = name;
97 q.len = strlen(name);
98
Linus Torvalds8387ff22016-06-10 07:51:30 -070099 err = efivarfs_d_hash(parent, &q);
Matt Flemingd68772b2013-02-08 16:27:24 +0000100 if (err)
101 return ERR_PTR(err);
102
103 d = d_alloc(parent, &q);
104 if (d)
105 return d;
106
107 return ERR_PTR(-ENOMEM);
108}
109
110static int efivarfs_callback(efi_char16_t *name16, efi_guid_t vendor,
111 unsigned long name_size, void *data)
112{
113 struct super_block *sb = (struct super_block *)data;
114 struct efivar_entry *entry;
115 struct inode *inode = NULL;
116 struct dentry *dentry, *root = sb->s_root;
117 unsigned long size = 0;
118 char *name;
Peter Jonese0d64e62016-02-08 14:48:12 -0500119 int len;
Matt Flemingd68772b2013-02-08 16:27:24 +0000120 int err = -ENOMEM;
Peter Jonesed8b0de2016-02-08 14:48:15 -0500121 bool is_removable = false;
Matt Flemingd68772b2013-02-08 16:27:24 +0000122
Ross Lagerwallc57dcb52015-04-02 08:39:00 +0100123 entry = kzalloc(sizeof(*entry), GFP_KERNEL);
Matt Flemingd68772b2013-02-08 16:27:24 +0000124 if (!entry)
125 return err;
126
127 memcpy(entry->var.VariableName, name16, name_size);
128 memcpy(&(entry->var.VendorGuid), &vendor, sizeof(efi_guid_t));
129
Peter Jonese0d64e62016-02-08 14:48:12 -0500130 len = ucs2_utf8size(entry->var.VariableName);
Matt Flemingd68772b2013-02-08 16:27:24 +0000131
132 /* name, plus '-', plus GUID, plus NUL*/
133 name = kmalloc(len + 1 + EFI_VARIABLE_GUID_LEN + 1, GFP_KERNEL);
134 if (!name)
135 goto fail;
136
Peter Jonese0d64e62016-02-08 14:48:12 -0500137 ucs2_as_utf8(name, entry->var.VariableName, len);
Matt Flemingd68772b2013-02-08 16:27:24 +0000138
Peter Jonesed8b0de2016-02-08 14:48:15 -0500139 if (efivar_variable_is_removable(entry->var.VendorGuid, name, len))
140 is_removable = true;
141
Matt Flemingd68772b2013-02-08 16:27:24 +0000142 name[len] = '-';
143
Borislav Petkov26e02272014-12-18 16:02:17 +0100144 efi_guid_to_str(&entry->var.VendorGuid, name + len + 1);
Matt Flemingd68772b2013-02-08 16:27:24 +0000145
146 name[len + EFI_VARIABLE_GUID_LEN+1] = '\0';
147
Michael Schaller917acdf2020-09-25 09:45:02 +0200148 /* replace invalid slashes like kobject_set_name_vargs does for /sys/firmware/efi/vars. */
149 strreplace(name, '/', '!');
150
Peter Jonesed8b0de2016-02-08 14:48:15 -0500151 inode = efivarfs_get_inode(sb, d_inode(root), S_IFREG | 0644, 0,
152 is_removable);
Matt Flemingd68772b2013-02-08 16:27:24 +0000153 if (!inode)
154 goto fail_name;
155
156 dentry = efivarfs_alloc_dentry(root, name);
157 if (IS_ERR(dentry)) {
158 err = PTR_ERR(dentry);
159 goto fail_inode;
160 }
161
Matt Flemingd68772b2013-02-08 16:27:24 +0000162 efivar_entry_size(entry, &size);
Sylvain Chouleur21b3ddd2016-07-15 21:36:30 +0200163 err = efivar_entry_add(entry, &efivarfs_list);
164 if (err)
165 goto fail_inode;
Matt Flemingd68772b2013-02-08 16:27:24 +0000166
Matt Fleming22c2b772016-08-15 15:29:20 +0100167 /* copied by the above to local storage in the dentry. */
168 kfree(name);
169
Al Viro59551022016-01-22 15:40:57 -0500170 inode_lock(inode);
Matt Flemingd68772b2013-02-08 16:27:24 +0000171 inode->i_private = entry;
172 i_size_write(inode, size + sizeof(entry->var.Attributes));
Al Viro59551022016-01-22 15:40:57 -0500173 inode_unlock(inode);
Matt Flemingd68772b2013-02-08 16:27:24 +0000174 d_add(dentry, inode);
175
176 return 0;
177
178fail_inode:
179 iput(inode);
180fail_name:
181 kfree(name);
182fail:
183 kfree(entry);
184 return err;
185}
186
187static int efivarfs_destroy(struct efivar_entry *entry, void *data)
188{
Sylvain Chouleur21b3ddd2016-07-15 21:36:30 +0200189 int err = efivar_entry_remove(entry);
190
191 if (err)
192 return err;
Matt Flemingd68772b2013-02-08 16:27:24 +0000193 kfree(entry);
194 return 0;
195}
196
197static int efivarfs_fill_super(struct super_block *sb, void *data, int silent)
198{
199 struct inode *inode = NULL;
200 struct dentry *root;
201 int err;
202
203 efivarfs_sb = sb;
204
205 sb->s_maxbytes = MAX_LFS_FILESIZE;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300206 sb->s_blocksize = PAGE_SIZE;
207 sb->s_blocksize_bits = PAGE_SHIFT;
Matt Flemingd68772b2013-02-08 16:27:24 +0000208 sb->s_magic = EFIVARFS_MAGIC;
209 sb->s_op = &efivarfs_ops;
210 sb->s_d_op = &efivarfs_d_ops;
211 sb->s_time_gran = 1;
212
Peter Jonesed8b0de2016-02-08 14:48:15 -0500213 inode = efivarfs_get_inode(sb, NULL, S_IFDIR | 0755, 0, true);
Matt Flemingd68772b2013-02-08 16:27:24 +0000214 if (!inode)
215 return -ENOMEM;
216 inode->i_op = &efivarfs_dir_inode_operations;
217
218 root = d_make_root(inode);
219 sb->s_root = root;
220 if (!root)
221 return -ENOMEM;
222
223 INIT_LIST_HEAD(&efivarfs_list);
224
Julia Lawall1cfd6312016-05-06 22:39:30 +0100225 err = efivar_init(efivarfs_callback, (void *)sb, true, &efivarfs_list);
Matt Flemingd68772b2013-02-08 16:27:24 +0000226 if (err)
227 __efivar_entry_iter(efivarfs_destroy, &efivarfs_list, NULL, NULL);
228
229 return err;
230}
231
232static struct dentry *efivarfs_mount(struct file_system_type *fs_type,
233 int flags, const char *dev_name, void *data)
234{
235 return mount_single(fs_type, flags, data, efivarfs_fill_super);
236}
237
238static void efivarfs_kill_sb(struct super_block *sb)
239{
240 kill_litter_super(sb);
241 efivarfs_sb = NULL;
242
243 /* Remove all entries and destroy */
244 __efivar_entry_iter(efivarfs_destroy, &efivarfs_list, NULL, NULL);
245}
246
247static struct file_system_type efivarfs_type = {
Mathias Krauseaf5a29a2014-10-23 23:20:37 +0200248 .owner = THIS_MODULE,
Matt Flemingd68772b2013-02-08 16:27:24 +0000249 .name = "efivarfs",
250 .mount = efivarfs_mount,
251 .kill_sb = efivarfs_kill_sb,
252};
253
254static __init int efivarfs_init(void)
255{
256 if (!efi_enabled(EFI_RUNTIME_SERVICES))
Mathias Krauseaf5a29a2014-10-23 23:20:37 +0200257 return -ENODEV;
Matt Flemingd68772b2013-02-08 16:27:24 +0000258
259 if (!efivars_kobject())
Mathias Krauseaf5a29a2014-10-23 23:20:37 +0200260 return -ENODEV;
Matt Flemingd68772b2013-02-08 16:27:24 +0000261
262 return register_filesystem(&efivarfs_type);
263}
264
Mathias Krauseaf5a29a2014-10-23 23:20:37 +0200265static __exit void efivarfs_exit(void)
266{
267 unregister_filesystem(&efivarfs_type);
268}
269
Matt Flemingd68772b2013-02-08 16:27:24 +0000270MODULE_AUTHOR("Matthew Garrett, Jeremy Kerr");
271MODULE_DESCRIPTION("EFI Variable Filesystem");
272MODULE_LICENSE("GPL");
273MODULE_ALIAS_FS("efivarfs");
274
275module_init(efivarfs_init);
Mathias Krauseaf5a29a2014-10-23 23:20:37 +0200276module_exit(efivarfs_exit);