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, i; 122 int err = -ENOMEM; 123 124 entry = kmalloc(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_strlen(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 for (i = 0; i < len; i++) 139 name[i] = entry->var.VariableName[i] & 0xFF; 140 141 name[len] = '-'; 142 143 efi_guid_to_str(&entry->var.VendorGuid, name + len + 1); 144 145 name[len + EFI_VARIABLE_GUID_LEN+1] = '\0'; 146 147 inode = efivarfs_get_inode(sb, d_inode(root), S_IFREG | 0644, 0); 148 if (!inode) 149 goto fail_name; 150 151 dentry = efivarfs_alloc_dentry(root, name); 152 if (IS_ERR(dentry)) { 153 err = PTR_ERR(dentry); 154 goto fail_inode; 155 } 156 157 /* copied by the above to local storage in the dentry. */ 158 kfree(name); 159 160 efivar_entry_size(entry, &size); 161 efivar_entry_add(entry, &efivarfs_list); 162 163 mutex_lock(&inode->i_mutex); 164 inode->i_private = entry; 165 i_size_write(inode, size + sizeof(entry->var.Attributes)); 166 mutex_unlock(&inode->i_mutex); 167 d_add(dentry, inode); 168 169 return 0; 170 171 fail_inode: 172 iput(inode); 173 fail_name: 174 kfree(name); 175 fail: 176 kfree(entry); 177 return err; 178 } 179 180 static int efivarfs_destroy(struct efivar_entry *entry, void *data) 181 { 182 efivar_entry_remove(entry); 183 kfree(entry); 184 return 0; 185 } 186 187 static int efivarfs_fill_super(struct super_block *sb, void *data, int silent) 188 { 189 struct inode *inode = NULL; 190 struct dentry *root; 191 int err; 192 193 efivarfs_sb = sb; 194 195 sb->s_maxbytes = MAX_LFS_FILESIZE; 196 sb->s_blocksize = PAGE_CACHE_SIZE; 197 sb->s_blocksize_bits = PAGE_CACHE_SHIFT; 198 sb->s_magic = EFIVARFS_MAGIC; 199 sb->s_op = &efivarfs_ops; 200 sb->s_d_op = &efivarfs_d_ops; 201 sb->s_time_gran = 1; 202 203 inode = efivarfs_get_inode(sb, NULL, S_IFDIR | 0755, 0); 204 if (!inode) 205 return -ENOMEM; 206 inode->i_op = &efivarfs_dir_inode_operations; 207 208 root = d_make_root(inode); 209 sb->s_root = root; 210 if (!root) 211 return -ENOMEM; 212 213 INIT_LIST_HEAD(&efivarfs_list); 214 215 err = efivar_init(efivarfs_callback, (void *)sb, false, 216 true, &efivarfs_list); 217 if (err) 218 __efivar_entry_iter(efivarfs_destroy, &efivarfs_list, NULL, NULL); 219 220 return err; 221 } 222 223 static struct dentry *efivarfs_mount(struct file_system_type *fs_type, 224 int flags, const char *dev_name, void *data) 225 { 226 return mount_single(fs_type, flags, data, efivarfs_fill_super); 227 } 228 229 static void efivarfs_kill_sb(struct super_block *sb) 230 { 231 kill_litter_super(sb); 232 efivarfs_sb = NULL; 233 234 /* Remove all entries and destroy */ 235 __efivar_entry_iter(efivarfs_destroy, &efivarfs_list, NULL, NULL); 236 } 237 238 static struct file_system_type efivarfs_type = { 239 .owner = THIS_MODULE, 240 .name = "efivarfs", 241 .mount = efivarfs_mount, 242 .kill_sb = efivarfs_kill_sb, 243 }; 244 245 static __init int efivarfs_init(void) 246 { 247 if (!efi_enabled(EFI_RUNTIME_SERVICES)) 248 return -ENODEV; 249 250 if (!efivars_kobject()) 251 return -ENODEV; 252 253 return register_filesystem(&efivarfs_type); 254 } 255 256 static __exit void efivarfs_exit(void) 257 { 258 unregister_filesystem(&efivarfs_type); 259 } 260 261 MODULE_AUTHOR("Matthew Garrett, Jeremy Kerr"); 262 MODULE_DESCRIPTION("EFI Variable Filesystem"); 263 MODULE_LICENSE("GPL"); 264 MODULE_ALIAS_FS("efivarfs"); 265 266 module_init(efivarfs_init); 267 module_exit(efivarfs_exit); 268