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/fs_context.h> 11 #include <linux/module.h> 12 #include <linux/pagemap.h> 13 #include <linux/ucs2_string.h> 14 #include <linux/slab.h> 15 #include <linux/magic.h> 16 17 #include "internal.h" 18 19 LIST_HEAD(efivarfs_list); 20 21 static void efivarfs_evict_inode(struct inode *inode) 22 { 23 clear_inode(inode); 24 } 25 26 static const struct super_operations efivarfs_ops = { 27 .statfs = simple_statfs, 28 .drop_inode = generic_delete_inode, 29 .evict_inode = efivarfs_evict_inode, 30 }; 31 32 /* 33 * Compare two efivarfs file names. 34 * 35 * An efivarfs filename is composed of two parts, 36 * 37 * 1. A case-sensitive variable name 38 * 2. A case-insensitive GUID 39 * 40 * So we need to perform a case-sensitive match on part 1 and a 41 * case-insensitive match on part 2. 42 */ 43 static int efivarfs_d_compare(const struct dentry *dentry, 44 unsigned int len, const char *str, 45 const struct qstr *name) 46 { 47 int guid = len - EFI_VARIABLE_GUID_LEN; 48 49 if (name->len != len) 50 return 1; 51 52 /* Case-sensitive compare for the variable name */ 53 if (memcmp(str, name->name, guid)) 54 return 1; 55 56 /* Case-insensitive compare for the GUID */ 57 return strncasecmp(name->name + guid, str + guid, EFI_VARIABLE_GUID_LEN); 58 } 59 60 static int efivarfs_d_hash(const struct dentry *dentry, struct qstr *qstr) 61 { 62 unsigned long hash = init_name_hash(dentry); 63 const unsigned char *s = qstr->name; 64 unsigned int len = qstr->len; 65 66 if (!efivarfs_valid_name(s, len)) 67 return -EINVAL; 68 69 while (len-- > EFI_VARIABLE_GUID_LEN) 70 hash = partial_name_hash(*s++, hash); 71 72 /* GUID is case-insensitive. */ 73 while (len--) 74 hash = partial_name_hash(tolower(*s++), hash); 75 76 qstr->hash = end_name_hash(hash); 77 return 0; 78 } 79 80 static const struct dentry_operations efivarfs_d_ops = { 81 .d_compare = efivarfs_d_compare, 82 .d_hash = efivarfs_d_hash, 83 .d_delete = always_delete_dentry, 84 }; 85 86 static struct dentry *efivarfs_alloc_dentry(struct dentry *parent, char *name) 87 { 88 struct dentry *d; 89 struct qstr q; 90 int err; 91 92 q.name = name; 93 q.len = strlen(name); 94 95 err = efivarfs_d_hash(parent, &q); 96 if (err) 97 return ERR_PTR(err); 98 99 d = d_alloc(parent, &q); 100 if (d) 101 return d; 102 103 return ERR_PTR(-ENOMEM); 104 } 105 106 static int efivarfs_callback(efi_char16_t *name16, efi_guid_t vendor, 107 unsigned long name_size, void *data) 108 { 109 struct super_block *sb = (struct super_block *)data; 110 struct efivar_entry *entry; 111 struct inode *inode = NULL; 112 struct dentry *dentry, *root = sb->s_root; 113 unsigned long size = 0; 114 char *name; 115 int len; 116 int err = -ENOMEM; 117 bool is_removable = false; 118 119 if (guid_equal(&vendor, &LINUX_EFI_RANDOM_SEED_TABLE_GUID)) 120 return 0; 121 122 entry = kzalloc(sizeof(*entry), GFP_KERNEL); 123 if (!entry) 124 return err; 125 126 memcpy(entry->var.VariableName, name16, name_size); 127 memcpy(&(entry->var.VendorGuid), &vendor, sizeof(efi_guid_t)); 128 129 len = ucs2_utf8size(entry->var.VariableName); 130 131 /* name, plus '-', plus GUID, plus NUL*/ 132 name = kmalloc(len + 1 + EFI_VARIABLE_GUID_LEN + 1, GFP_KERNEL); 133 if (!name) 134 goto fail; 135 136 ucs2_as_utf8(name, entry->var.VariableName, len); 137 138 if (efivar_variable_is_removable(entry->var.VendorGuid, name, len)) 139 is_removable = true; 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 /* replace invalid slashes like kobject_set_name_vargs does for /sys/firmware/efi/vars. */ 148 strreplace(name, '/', '!'); 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 __efivar_entry_get(entry, NULL, &size, NULL); 162 __efivar_entry_add(entry, &efivarfs_list); 163 164 /* copied by the above to local storage in the dentry. */ 165 kfree(name); 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, struct fs_context *fc) 192 { 193 struct inode *inode = NULL; 194 struct dentry *root; 195 int err; 196 197 if (!efivar_is_available()) 198 return -EOPNOTSUPP; 199 200 sb->s_maxbytes = MAX_LFS_FILESIZE; 201 sb->s_blocksize = PAGE_SIZE; 202 sb->s_blocksize_bits = PAGE_SHIFT; 203 sb->s_magic = EFIVARFS_MAGIC; 204 sb->s_op = &efivarfs_ops; 205 sb->s_d_op = &efivarfs_d_ops; 206 sb->s_time_gran = 1; 207 208 if (!efivar_supports_writes()) 209 sb->s_flags |= SB_RDONLY; 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); 226 227 return err; 228 } 229 230 static int efivarfs_get_tree(struct fs_context *fc) 231 { 232 return get_tree_single(fc, efivarfs_fill_super); 233 } 234 235 static const struct fs_context_operations efivarfs_context_ops = { 236 .get_tree = efivarfs_get_tree, 237 }; 238 239 static int efivarfs_init_fs_context(struct fs_context *fc) 240 { 241 fc->ops = &efivarfs_context_ops; 242 return 0; 243 } 244 245 static void efivarfs_kill_sb(struct super_block *sb) 246 { 247 kill_litter_super(sb); 248 249 if (!efivar_is_available()) 250 return; 251 252 /* Remove all entries and destroy */ 253 efivar_entry_iter(efivarfs_destroy, &efivarfs_list, NULL); 254 } 255 256 static struct file_system_type efivarfs_type = { 257 .owner = THIS_MODULE, 258 .name = "efivarfs", 259 .init_fs_context = efivarfs_init_fs_context, 260 .kill_sb = efivarfs_kill_sb, 261 }; 262 263 static __init int efivarfs_init(void) 264 { 265 return register_filesystem(&efivarfs_type); 266 } 267 268 static __exit void efivarfs_exit(void) 269 { 270 unregister_filesystem(&efivarfs_type); 271 } 272 273 MODULE_AUTHOR("Matthew Garrett, Jeremy Kerr"); 274 MODULE_DESCRIPTION("EFI Variable Filesystem"); 275 MODULE_LICENSE("GPL"); 276 MODULE_ALIAS_FS("efivarfs"); 277 278 module_init(efivarfs_init); 279 module_exit(efivarfs_exit); 280