xref: /openbmc/linux/fs/efivarfs/super.c (revision 0edbfea5) 
1 /*
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>
15 #include <linux/ucs2_string.h>
16 #include <linux/slab.h>
17 #include <linux/magic.h>
18 
19 #include "internal.h"
20 
21 LIST_HEAD(efivarfs_list);
22 
23 static void efivarfs_evict_inode(struct inode *inode)
24 {
25 	clear_inode(inode);
26 }
27 
28 static const struct super_operations efivarfs_ops = {
29 	.statfs = simple_statfs,
30 	.drop_inode = generic_delete_inode,
31 	.evict_inode = efivarfs_evict_inode,
32 	.show_options = generic_show_options,
33 };
34 
35 static struct super_block *efivarfs_sb;
36 
37 /*
38  * Compare two efivarfs file names.
39  *
40  * An efivarfs filename is composed of two parts,
41  *
42  *	1. A case-sensitive variable name
43  *	2. A case-insensitive GUID
44  *
45  * So we need to perform a case-sensitive match on part 1 and a
46  * case-insensitive match on part 2.
47  */
48 static int efivarfs_d_compare(const struct dentry *parent,
49 			      const struct dentry *dentry,
50 			      unsigned int len, const char *str,
51 			      const struct qstr *name)
52 {
53 	int guid = len - EFI_VARIABLE_GUID_LEN;
54 
55 	if (name->len != len)
56 		return 1;
57 
58 	/* Case-sensitive compare for the variable name */
59 	if (memcmp(str, name->name, guid))
60 		return 1;
61 
62 	/* Case-insensitive compare for the GUID */
63 	return strncasecmp(name->name + guid, str + guid, EFI_VARIABLE_GUID_LEN);
64 }
65 
66 static int efivarfs_d_hash(const struct dentry *dentry, struct qstr *qstr)
67 {
68 	unsigned long hash = init_name_hash();
69 	const unsigned char *s = qstr->name;
70 	unsigned int len = qstr->len;
71 
72 	if (!efivarfs_valid_name(s, len))
73 		return -EINVAL;
74 
75 	while (len-- > EFI_VARIABLE_GUID_LEN)
76 		hash = partial_name_hash(*s++, hash);
77 
78 	/* GUID is case-insensitive. */
79 	while (len--)
80 		hash = partial_name_hash(tolower(*s++), hash);
81 
82 	qstr->hash = end_name_hash(hash);
83 	return 0;
84 }
85 
86 static const struct dentry_operations efivarfs_d_ops = {
87 	.d_compare = efivarfs_d_compare,
88 	.d_hash = efivarfs_d_hash,
89 	.d_delete = always_delete_dentry,
90 };
91 
92 static struct dentry *efivarfs_alloc_dentry(struct dentry *parent, char *name)
93 {
94 	struct dentry *d;
95 	struct qstr q;
96 	int err;
97 
98 	q.name = name;
99 	q.len = strlen(name);
100 
101 	err = efivarfs_d_hash(NULL, &q);
102 	if (err)
103 		return ERR_PTR(err);
104 
105 	d = d_alloc(parent, &q);
106 	if (d)
107 		return d;
108 
109 	return ERR_PTR(-ENOMEM);
110 }
111 
112 static int efivarfs_callback(efi_char16_t *name16, efi_guid_t vendor,
113 			     unsigned long name_size, void *data)
114 {
115 	struct super_block *sb = (struct super_block *)data;
116 	struct efivar_entry *entry;
117 	struct inode *inode = NULL;
118 	struct dentry *dentry, *root = sb->s_root;
119 	unsigned long size = 0;
120 	char *name;
121 	int len;
122 	int err = -ENOMEM;
123 	bool is_removable = false;
124 
125 	entry = kzalloc(sizeof(*entry), GFP_KERNEL);
126 	if (!entry)
127 		return err;
128 
129 	memcpy(entry->var.VariableName, name16, name_size);
130 	memcpy(&(entry->var.VendorGuid), &vendor, sizeof(efi_guid_t));
131 
132 	len = ucs2_utf8size(entry->var.VariableName);
133 
134 	/* name, plus '-', plus GUID, plus NUL*/
135 	name = kmalloc(len + 1 + EFI_VARIABLE_GUID_LEN + 1, GFP_KERNEL);
136 	if (!name)
137 		goto fail;
138 
139 	ucs2_as_utf8(name, entry->var.VariableName, len);
140 
141 	if (efivar_variable_is_removable(entry->var.VendorGuid, name, len))
142 		is_removable = true;
143 
144 	name[len] = '-';
145 
146 	efi_guid_to_str(&entry->var.VendorGuid, name + len + 1);
147 
148 	name[len + EFI_VARIABLE_GUID_LEN+1] = '\0';
149 
150 	inode = efivarfs_get_inode(sb, d_inode(root), S_IFREG | 0644, 0,
151 				   is_removable);
152 	if (!inode)
153 		goto fail_name;
154 
155 	dentry = efivarfs_alloc_dentry(root, name);
156 	if (IS_ERR(dentry)) {
157 		err = PTR_ERR(dentry);
158 		goto fail_inode;
159 	}
160 
161 	/* copied by the above to local storage in the dentry. */
162 	kfree(name);
163 
164 	efivar_entry_size(entry, &size);
165 	efivar_entry_add(entry, &efivarfs_list);
166 
167 	inode_lock(inode);
168 	inode->i_private = entry;
169 	i_size_write(inode, size + sizeof(entry->var.Attributes));
170 	inode_unlock(inode);
171 	d_add(dentry, inode);
172 
173 	return 0;
174 
175 fail_inode:
176 	iput(inode);
177 fail_name:
178 	kfree(name);
179 fail:
180 	kfree(entry);
181 	return err;
182 }
183 
184 static int efivarfs_destroy(struct efivar_entry *entry, void *data)
185 {
186 	efivar_entry_remove(entry);
187 	kfree(entry);
188 	return 0;
189 }
190 
191 static int efivarfs_fill_super(struct super_block *sb, void *data, int silent)
192 {
193 	struct inode *inode = NULL;
194 	struct dentry *root;
195 	int err;
196 
197 	efivarfs_sb = sb;
198 
199 	sb->s_maxbytes          = MAX_LFS_FILESIZE;
200 	sb->s_blocksize         = PAGE_SIZE;
201 	sb->s_blocksize_bits    = PAGE_SHIFT;
202 	sb->s_magic             = EFIVARFS_MAGIC;
203 	sb->s_op                = &efivarfs_ops;
204 	sb->s_d_op		= &efivarfs_d_ops;
205 	sb->s_time_gran         = 1;
206 
207 	inode = efivarfs_get_inode(sb, NULL, S_IFDIR | 0755, 0, true);
208 	if (!inode)
209 		return -ENOMEM;
210 	inode->i_op = &efivarfs_dir_inode_operations;
211 
212 	root = d_make_root(inode);
213 	sb->s_root = root;
214 	if (!root)
215 		return -ENOMEM;
216 
217 	INIT_LIST_HEAD(&efivarfs_list);
218 
219 	err = efivar_init(efivarfs_callback, (void *)sb, true, &efivarfs_list);
220 	if (err)
221 		__efivar_entry_iter(efivarfs_destroy, &efivarfs_list, NULL, NULL);
222 
223 	return err;
224 }
225 
226 static struct dentry *efivarfs_mount(struct file_system_type *fs_type,
227 				    int flags, const char *dev_name, void *data)
228 {
229 	return mount_single(fs_type, flags, data, efivarfs_fill_super);
230 }
231 
232 static void efivarfs_kill_sb(struct super_block *sb)
233 {
234 	kill_litter_super(sb);
235 	efivarfs_sb = NULL;
236 
237 	/* Remove all entries and destroy */
238 	__efivar_entry_iter(efivarfs_destroy, &efivarfs_list, NULL, NULL);
239 }
240 
241 static struct file_system_type efivarfs_type = {
242 	.owner   = THIS_MODULE,
243 	.name    = "efivarfs",
244 	.mount   = efivarfs_mount,
245 	.kill_sb = efivarfs_kill_sb,
246 };
247 
248 static __init int efivarfs_init(void)
249 {
250 	if (!efi_enabled(EFI_RUNTIME_SERVICES))
251 		return -ENODEV;
252 
253 	if (!efivars_kobject())
254 		return -ENODEV;
255 
256 	return register_filesystem(&efivarfs_type);
257 }
258 
259 static __exit void efivarfs_exit(void)
260 {
261 	unregister_filesystem(&efivarfs_type);
262 }
263 
264 MODULE_AUTHOR("Matthew Garrett, Jeremy Kerr");
265 MODULE_DESCRIPTION("EFI Variable Filesystem");
266 MODULE_LICENSE("GPL");
267 MODULE_ALIAS_FS("efivarfs");
268 
269 module_init(efivarfs_init);
270 module_exit(efivarfs_exit);
271