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

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

Version: ~ [ linux-5.15-rc5 ] ~ [ linux-5.14.11 ] ~ [ linux-5.13.19 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.72 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.152 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.210 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.250 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.286 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.288 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ 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 *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_unparse(&entry->var.VendorGuid, name + len + 1);
147 
148         name[len + EFI_VARIABLE_GUID_LEN+1] = '\0';
149 
150         inode = efivarfs_get_inode(sb, root->d_inode, 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         mutex_lock(&inode->i_mutex);
168         inode->i_private = entry;
169         i_size_write(inode, size + sizeof(entry->var.Attributes));
170         mutex_unlock(&inode->i_mutex);
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_CACHE_SIZE;
201         sb->s_blocksize_bits    = PAGE_CACHE_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, false,
220                           true, &efivarfs_list);
221         if (err)
222                 __efivar_entry_iter(efivarfs_destroy, &efivarfs_list, NULL, NULL);
223 
224         return err;
225 }
226 
227 static struct dentry *efivarfs_mount(struct file_system_type *fs_type,
228                                     int flags, const char *dev_name, void *data)
229 {
230         return mount_single(fs_type, flags, data, efivarfs_fill_super);
231 }
232 
233 static void efivarfs_kill_sb(struct super_block *sb)
234 {
235         kill_litter_super(sb);
236         efivarfs_sb = NULL;
237 
238         /* Remove all entries and destroy */
239         __efivar_entry_iter(efivarfs_destroy, &efivarfs_list, NULL, NULL);
240 }
241 
242 static struct file_system_type efivarfs_type = {
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 0;
252 
253         if (!efivars_kobject())
254                 return 0;
255 
256         return register_filesystem(&efivarfs_type);
257 }
258 
259 MODULE_AUTHOR("Matthew Garrett, Jeremy Kerr");
260 MODULE_DESCRIPTION("EFI Variable Filesystem");
261 MODULE_LICENSE("GPL");
262 MODULE_ALIAS_FS("efivarfs");
263 
264 module_init(efivarfs_init);
265 

~ [ 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