~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/efivarfs/super.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp