1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) 2012 Red Hat, Inc. 4 * Copyright (C) 2012 Jeremy Kerr <jeremy.kerr@canonical.com> 5 */ 6 7 #include <linux/ctype.h> 8 #include <linux/efi.h> 9 #include <linux/fs.h> 10 #include <linux/module.h> 11 #include <linux/pagemap.h> 12 #include <linux/ucs2_string.h> 13 #include <linux/slab.h> 14 #include <linux/magic.h> 15 16 #include "internal.h" 17 18 LIST_HEAD(efivarfs_list); 19 20 static void efivarfs_evict_inode(struct inode *inode) 21 { 22 clear_inode(inode); 23 } 24 25 static const struct super_operations efivarfs_ops = { 26 .statfs = simple_statfs, 27 .drop_inode = generic_delete_inode, 28 .evict_inode = efivarfs_evict_inode, 29 }; 30 31 static struct super_block *efivarfs_sb; 32 33 /* 34 * Compare two efivarfs file names. 35 * 36 * An efivarfs filename is composed of two parts, 37 * 38 * 1. A case-sensitive variable name 39 * 2. A case-insensitive GUID 40 * 41 * So we need to perform a case-sensitive match on part 1 and a 42 * case-insensitive match on part 2. 43 */ 44 static int efivarfs_d_compare(const struct dentry *dentry, 45 unsigned int len, const char *str, 46 const struct qstr *name) 47 { 48 int guid = len - EFI_VARIABLE_GUID_LEN; 49 50 if (name->len != len) 51 return 1; 52 53 /* Case-sensitive compare for the variable name */ 54 if (memcmp(str, name->name, guid)) 55 return 1; 56 57 /* Case-insensitive compare for the GUID */ 58 return strncasecmp(name->name + guid, str + guid, EFI_VARIABLE_GUID_LEN); 59 } 60 61 static int efivarfs_d_hash(const struct dentry *dentry, struct qstr *qstr) 62 { 63 unsigned long hash = init_name_hash(dentry); 64 const unsigned char *s = qstr->name; 65 unsigned int len = qstr->len; 66 67 if (!efivarfs_valid_name(s, len)) 68 return -EINVAL; 69 70 while (len-- > EFI_VARIABLE_GUID_LEN) 71 hash = partial_name_hash(*s++, hash); 72 73 /* GUID is case-insensitive. */ 74 while (len--) 75 hash = partial_name_hash(tolower(*s++), hash); 76 77 qstr->hash = end_name_hash(hash); 78 return 0; 79 } 80 81 static const struct dentry_operations efivarfs_d_ops = { 82 .d_compare = efivarfs_d_compare, 83 .d_hash = efivarfs_d_hash, 84 .d_delete = always_delete_dentry, 85 }; 86 87 static struct dentry *efivarfs_alloc_dentry(struct dentry *parent, char *name) 88 { 89 struct dentry *d; 90 struct qstr q; 91 int err; 92 93 q.name = name; 94 q.len = strlen(name); 95 96 err = efivarfs_d_hash(parent, &q); 97 if (err) 98 return ERR_PTR(err); 99 100 d = d_alloc(parent, &q); 101 if (d) 102 return d; 103 104 return ERR_PTR(-ENOMEM); 105 } 106 107 static int efivarfs_callback(efi_char16_t *name16, efi_guid_t vendor, 108 unsigned long name_size, void *data) 109 { 110 struct super_block *sb = (struct super_block *)data; 111 struct efivar_entry *entry; 112 struct inode *inode = NULL; 113 struct dentry *dentry, *root = sb->s_root; 114 unsigned long size = 0; 115 char *name; 116 int len; 117 int err = -ENOMEM; 118 bool is_removable = false; 119 120 entry = kzalloc(sizeof(*entry), GFP_KERNEL); 121 if (!entry) 122 return err; 123 124 memcpy(entry->var.VariableName, name16, name_size); 125 memcpy(&(entry->var.VendorGuid), &vendor, sizeof(efi_guid_t)); 126 127 len = ucs2_utf8size(entry->var.VariableName); 128 129 /* name, plus '-', plus GUID, plus NUL*/ 130 name = kmalloc(len + 1 + EFI_VARIABLE_GUID_LEN + 1, GFP_KERNEL); 131 if (!name) 132 goto fail; 133 134 ucs2_as_utf8(name, entry->var.VariableName, len); 135 136 if (efivar_variable_is_removable(entry->var.VendorGuid, name, len)) 137 is_removable = true; 138 139 name[len] = '-'; 140 141 efi_guid_to_str(&entry->var.VendorGuid, name + len + 1); 142 143 name[len + EFI_VARIABLE_GUID_LEN+1] = '\0'; 144 145 inode = efivarfs_get_inode(sb, d_inode(root), S_IFREG | 0644, 0, 146 is_removable); 147 if (!inode) 148 goto fail_name; 149 150 dentry = efivarfs_alloc_dentry(root, name); 151 if (IS_ERR(dentry)) { 152 err = PTR_ERR(dentry); 153 goto fail_inode; 154 } 155 156 efivar_entry_size(entry, &size); 157 err = efivar_entry_add(entry, &efivarfs_list); 158 if (err) 159 goto fail_inode; 160 161 /* copied by the above to local storage in the dentry. */ 162 kfree(name); 163 164 inode_lock(inode); 165 inode->i_private = entry; 166 i_size_write(inode, size + sizeof(entry->var.Attributes)); 167 inode_unlock(inode); 168 d_add(dentry, inode); 169 170 return 0; 171 172 fail_inode: 173 iput(inode); 174 fail_name: 175 kfree(name); 176 fail: 177 kfree(entry); 178 return err; 179 } 180 181 static int efivarfs_destroy(struct efivar_entry *entry, void *data) 182 { 183 int err = efivar_entry_remove(entry); 184 185 if (err) 186 return err; 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