1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * efi.c - EFI subsystem
4 *
5 * Copyright (C) 2001,2003,2004 Dell <Matt_Domsch@dell.com>
6 * Copyright (C) 2004 Intel Corporation <matthew.e.tolentino@intel.com>
7 * Copyright (C) 2013 Tom Gundersen <teg@jklm.no>
8 *
9 * This code registers /sys/firmware/efi{,/efivars} when EFI is supported,
10 * allowing the efivarfs to be mounted or the efivars module to be loaded.
11 * The existance of /sys/firmware/efi may also be used by userspace to
12 * determine that the system supports EFI.
13 */
14
15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
16
17 #include <linux/kobject.h>
18 #include <linux/module.h>
19 #include <linux/init.h>
20 #include <linux/debugfs.h>
21 #include <linux/device.h>
22 #include <linux/efi.h>
23 #include <linux/of.h>
24 #include <linux/io.h>
25 #include <linux/kexec.h>
26 #include <linux/platform_device.h>
27 #include <linux/random.h>
28 #include <linux/reboot.h>
29 #include <linux/slab.h>
30 #include <linux/acpi.h>
31 #include <linux/ucs2_string.h>
32 #include <linux/memblock.h>
33 #include <linux/security.h>
34
35 #include <asm/early_ioremap.h>
36
37 struct efi __read_mostly efi = {
38 .runtime_supported_mask = EFI_RT_SUPPORTED_ALL,
39 .acpi = EFI_INVALID_TABLE_ADDR,
40 .acpi20 = EFI_INVALID_TABLE_ADDR,
41 .smbios = EFI_INVALID_TABLE_ADDR,
42 .smbios3 = EFI_INVALID_TABLE_ADDR,
43 .esrt = EFI_INVALID_TABLE_ADDR,
44 .tpm_log = EFI_INVALID_TABLE_ADDR,
45 .tpm_final_log = EFI_INVALID_TABLE_ADDR,
46 #ifdef CONFIG_LOAD_UEFI_KEYS
47 .mokvar_table = EFI_INVALID_TABLE_ADDR,
48 #endif
49 };
50 EXPORT_SYMBOL(efi);
51
52 unsigned long __ro_after_init efi_rng_seed = EFI_INVALID_TABLE_ADDR;
53 static unsigned long __initdata mem_reserve = EFI_INVALID_TABLE_ADDR;
54 static unsigned long __initdata rt_prop = EFI_INVALID_TABLE_ADDR;
55
56 struct mm_struct efi_mm = {
57 .mm_rb = RB_ROOT,
58 .mm_users = ATOMIC_INIT(2),
59 .mm_count = ATOMIC_INIT(1),
60 MMAP_LOCK_INITIALIZER(efi_mm)
61 .page_table_lock = __SPIN_LOCK_UNLOCKED(efi_mm.page_table_lock),
62 .mmlist = LIST_HEAD_INIT(efi_mm.mmlist),
63 .cpu_bitmap = { [BITS_TO_LONGS(NR_CPUS)] = 0},
64 };
65
66 struct workqueue_struct *efi_rts_wq;
67
68 static bool disable_runtime;
setup_noefi(char * arg)69 static int __init setup_noefi(char *arg)
70 {
71 disable_runtime = true;
72 return 0;
73 }
74 early_param("noefi", setup_noefi);
75
efi_runtime_disabled(void)76 bool efi_runtime_disabled(void)
77 {
78 return disable_runtime;
79 }
80
__efi_soft_reserve_enabled(void)81 bool __pure __efi_soft_reserve_enabled(void)
82 {
83 return !efi_enabled(EFI_MEM_NO_SOFT_RESERVE);
84 }
85
parse_efi_cmdline(char * str)86 static int __init parse_efi_cmdline(char *str)
87 {
88 if (!str) {
89 pr_warn("need at least one option\n");
90 return -EINVAL;
91 }
92
93 if (parse_option_str(str, "debug"))
94 set_bit(EFI_DBG, &efi.flags);
95
96 if (parse_option_str(str, "noruntime"))
97 disable_runtime = true;
98
99 if (parse_option_str(str, "nosoftreserve"))
100 set_bit(EFI_MEM_NO_SOFT_RESERVE, &efi.flags);
101
102 return 0;
103 }
104 early_param("efi", parse_efi_cmdline);
105
106 struct kobject *efi_kobj;
107
108 /*
109 * Let's not leave out systab information that snuck into
110 * the efivars driver
111 * Note, do not add more fields in systab sysfs file as it breaks sysfs
112 * one value per file rule!
113 */
systab_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)114 static ssize_t systab_show(struct kobject *kobj,
115 struct kobj_attribute *attr, char *buf)
116 {
117 char *str = buf;
118
119 if (!kobj || !buf)
120 return -EINVAL;
121
122 if (efi.acpi20 != EFI_INVALID_TABLE_ADDR)
123 str += sprintf(str, "ACPI20=0x%lx\n", efi.acpi20);
124 if (efi.acpi != EFI_INVALID_TABLE_ADDR)
125 str += sprintf(str, "ACPI=0x%lx\n", efi.acpi);
126 /*
127 * If both SMBIOS and SMBIOS3 entry points are implemented, the
128 * SMBIOS3 entry point shall be preferred, so we list it first to
129 * let applications stop parsing after the first match.
130 */
131 if (efi.smbios3 != EFI_INVALID_TABLE_ADDR)
132 str += sprintf(str, "SMBIOS3=0x%lx\n", efi.smbios3);
133 if (efi.smbios != EFI_INVALID_TABLE_ADDR)
134 str += sprintf(str, "SMBIOS=0x%lx\n", efi.smbios);
135
136 if (IS_ENABLED(CONFIG_IA64) || IS_ENABLED(CONFIG_X86))
137 str = efi_systab_show_arch(str);
138
139 return str - buf;
140 }
141
142 static struct kobj_attribute efi_attr_systab = __ATTR_RO_MODE(systab, 0400);
143
fw_platform_size_show(struct kobject * kobj,struct kobj_attribute * attr,char * buf)144 static ssize_t fw_platform_size_show(struct kobject *kobj,
145 struct kobj_attribute *attr, char *buf)
146 {
147 return sprintf(buf, "%d\n", efi_enabled(EFI_64BIT) ? 64 : 32);
148 }
149
150 extern __weak struct kobj_attribute efi_attr_fw_vendor;
151 extern __weak struct kobj_attribute efi_attr_runtime;
152 extern __weak struct kobj_attribute efi_attr_config_table;
153 static struct kobj_attribute efi_attr_fw_platform_size =
154 __ATTR_RO(fw_platform_size);
155
156 static struct attribute *efi_subsys_attrs[] = {
157 &efi_attr_systab.attr,
158 &efi_attr_fw_platform_size.attr,
159 &efi_attr_fw_vendor.attr,
160 &efi_attr_runtime.attr,
161 &efi_attr_config_table.attr,
162 NULL,
163 };
164
efi_attr_is_visible(struct kobject * kobj,struct attribute * attr,int n)165 umode_t __weak efi_attr_is_visible(struct kobject *kobj, struct attribute *attr,
166 int n)
167 {
168 return attr->mode;
169 }
170
171 static const struct attribute_group efi_subsys_attr_group = {
172 .attrs = efi_subsys_attrs,
173 .is_visible = efi_attr_is_visible,
174 };
175
176 static struct efivars generic_efivars;
177 static struct efivar_operations generic_ops;
178
generic_ops_register(void)179 static int generic_ops_register(void)
180 {
181 generic_ops.get_variable = efi.get_variable;
182 generic_ops.get_next_variable = efi.get_next_variable;
183 generic_ops.query_variable_store = efi_query_variable_store;
184
185 if (efi_rt_services_supported(EFI_RT_SUPPORTED_SET_VARIABLE)) {
186 generic_ops.set_variable = efi.set_variable;
187 generic_ops.set_variable_nonblocking = efi.set_variable_nonblocking;
188 }
189 return efivars_register(&generic_efivars, &generic_ops, efi_kobj);
190 }
191
generic_ops_unregister(void)192 static void generic_ops_unregister(void)
193 {
194 efivars_unregister(&generic_efivars);
195 }
196
197 #ifdef CONFIG_EFI_CUSTOM_SSDT_OVERLAYS
198 #define EFIVAR_SSDT_NAME_MAX 16
199 static char efivar_ssdt[EFIVAR_SSDT_NAME_MAX] __initdata;
efivar_ssdt_setup(char * str)200 static int __init efivar_ssdt_setup(char *str)
201 {
202 int ret = security_locked_down(LOCKDOWN_ACPI_TABLES);
203
204 if (ret)
205 return ret;
206
207 if (strlen(str) < sizeof(efivar_ssdt))
208 memcpy(efivar_ssdt, str, strlen(str));
209 else
210 pr_warn("efivar_ssdt: name too long: %s\n", str);
211 return 0;
212 }
213 __setup("efivar_ssdt=", efivar_ssdt_setup);
214
efivar_ssdt_iter(efi_char16_t * name,efi_guid_t vendor,unsigned long name_size,void * data)215 static __init int efivar_ssdt_iter(efi_char16_t *name, efi_guid_t vendor,
216 unsigned long name_size, void *data)
217 {
218 struct efivar_entry *entry;
219 struct list_head *list = data;
220 char utf8_name[EFIVAR_SSDT_NAME_MAX];
221 int limit = min_t(unsigned long, EFIVAR_SSDT_NAME_MAX, name_size);
222
223 ucs2_as_utf8(utf8_name, name, limit - 1);
224 if (strncmp(utf8_name, efivar_ssdt, limit) != 0)
225 return 0;
226
227 entry = kmalloc(sizeof(*entry), GFP_KERNEL);
228 if (!entry)
229 return 0;
230
231 memcpy(entry->var.VariableName, name, name_size);
232 memcpy(&entry->var.VendorGuid, &vendor, sizeof(efi_guid_t));
233
234 efivar_entry_add(entry, list);
235
236 return 0;
237 }
238
efivar_ssdt_load(void)239 static __init int efivar_ssdt_load(void)
240 {
241 LIST_HEAD(entries);
242 struct efivar_entry *entry, *aux;
243 unsigned long size;
244 void *data;
245 int ret;
246
247 if (!efivar_ssdt[0])
248 return 0;
249
250 ret = efivar_init(efivar_ssdt_iter, &entries, true, &entries);
251
252 list_for_each_entry_safe(entry, aux, &entries, list) {
253 pr_info("loading SSDT from variable %s-%pUl\n", efivar_ssdt,
254 &entry->var.VendorGuid);
255
256 list_del(&entry->list);
257
258 ret = efivar_entry_size(entry, &size);
259 if (ret) {
260 pr_err("failed to get var size\n");
261 goto free_entry;
262 }
263
264 data = kmalloc(size, GFP_KERNEL);
265 if (!data) {
266 ret = -ENOMEM;
267 goto free_entry;
268 }
269
270 ret = efivar_entry_get(entry, NULL, &size, data);
271 if (ret) {
272 pr_err("failed to get var data\n");
273 goto free_data;
274 }
275
276 ret = acpi_load_table(data, NULL);
277 if (ret) {
278 pr_err("failed to load table: %d\n", ret);
279 goto free_data;
280 }
281
282 goto free_entry;
283
284 free_data:
285 kfree(data);
286
287 free_entry:
288 kfree(entry);
289 }
290
291 return ret;
292 }
293 #else
efivar_ssdt_load(void)294 static inline int efivar_ssdt_load(void) { return 0; }
295 #endif
296
297 #ifdef CONFIG_DEBUG_FS
298
299 #define EFI_DEBUGFS_MAX_BLOBS 32
300
301 static struct debugfs_blob_wrapper debugfs_blob[EFI_DEBUGFS_MAX_BLOBS];
302
efi_debugfs_init(void)303 static void __init efi_debugfs_init(void)
304 {
305 struct dentry *efi_debugfs;
306 efi_memory_desc_t *md;
307 char name[32];
308 int type_count[EFI_BOOT_SERVICES_DATA + 1] = {};
309 int i = 0;
310
311 efi_debugfs = debugfs_create_dir("efi", NULL);
312 if (IS_ERR_OR_NULL(efi_debugfs))
313 return;
314
315 for_each_efi_memory_desc(md) {
316 switch (md->type) {
317 case EFI_BOOT_SERVICES_CODE:
318 snprintf(name, sizeof(name), "boot_services_code%d",
319 type_count[md->type]++);
320 break;
321 case EFI_BOOT_SERVICES_DATA:
322 snprintf(name, sizeof(name), "boot_services_data%d",
323 type_count[md->type]++);
324 break;
325 default:
326 continue;
327 }
328
329 if (i >= EFI_DEBUGFS_MAX_BLOBS) {
330 pr_warn("More then %d EFI boot service segments, only showing first %d in debugfs\n",
331 EFI_DEBUGFS_MAX_BLOBS, EFI_DEBUGFS_MAX_BLOBS);
332 break;
333 }
334
335 debugfs_blob[i].size = md->num_pages << EFI_PAGE_SHIFT;
336 debugfs_blob[i].data = memremap(md->phys_addr,
337 debugfs_blob[i].size,
338 MEMREMAP_WB);
339 if (!debugfs_blob[i].data)
340 continue;
341
342 debugfs_create_blob(name, 0400, efi_debugfs, &debugfs_blob[i]);
343 i++;
344 }
345 }
346 #else
efi_debugfs_init(void)347 static inline void efi_debugfs_init(void) {}
348 #endif
349
350 /*
351 * We register the efi subsystem with the firmware subsystem and the
352 * efivars subsystem with the efi subsystem, if the system was booted with
353 * EFI.
354 */
efisubsys_init(void)355 static int __init efisubsys_init(void)
356 {
357 int error;
358
359 if (!efi_enabled(EFI_RUNTIME_SERVICES))
360 efi.runtime_supported_mask = 0;
361
362 if (!efi_enabled(EFI_BOOT))
363 return 0;
364
365 if (efi.runtime_supported_mask) {
366 /*
367 * Since we process only one efi_runtime_service() at a time, an
368 * ordered workqueue (which creates only one execution context)
369 * should suffice for all our needs.
370 */
371 efi_rts_wq = alloc_ordered_workqueue("efi_rts_wq", 0);
372 if (!efi_rts_wq) {
373 pr_err("Creating efi_rts_wq failed, EFI runtime services disabled.\n");
374 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
375 efi.runtime_supported_mask = 0;
376 return 0;
377 }
378 }
379
380 if (efi_rt_services_supported(EFI_RT_SUPPORTED_TIME_SERVICES))
381 platform_device_register_simple("rtc-efi", 0, NULL, 0);
382
383 /* We register the efi directory at /sys/firmware/efi */
384 efi_kobj = kobject_create_and_add("efi", firmware_kobj);
385 if (!efi_kobj) {
386 pr_err("efi: Firmware registration failed.\n");
387 destroy_workqueue(efi_rts_wq);
388 return -ENOMEM;
389 }
390
391 if (efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE |
392 EFI_RT_SUPPORTED_GET_NEXT_VARIABLE_NAME)) {
393 error = generic_ops_register();
394 if (error)
395 goto err_put;
396 efivar_ssdt_load();
397 platform_device_register_simple("efivars", 0, NULL, 0);
398 }
399
400 error = sysfs_create_group(efi_kobj, &efi_subsys_attr_group);
401 if (error) {
402 pr_err("efi: Sysfs attribute export failed with error %d.\n",
403 error);
404 goto err_unregister;
405 }
406
407 error = efi_runtime_map_init(efi_kobj);
408 if (error)
409 goto err_remove_group;
410
411 /* and the standard mountpoint for efivarfs */
412 error = sysfs_create_mount_point(efi_kobj, "efivars");
413 if (error) {
414 pr_err("efivars: Subsystem registration failed.\n");
415 goto err_remove_group;
416 }
417
418 if (efi_enabled(EFI_DBG) && efi_enabled(EFI_PRESERVE_BS_REGIONS))
419 efi_debugfs_init();
420
421 return 0;
422
423 err_remove_group:
424 sysfs_remove_group(efi_kobj, &efi_subsys_attr_group);
425 err_unregister:
426 if (efi_rt_services_supported(EFI_RT_SUPPORTED_GET_VARIABLE |
427 EFI_RT_SUPPORTED_GET_NEXT_VARIABLE_NAME))
428 generic_ops_unregister();
429 err_put:
430 kobject_put(efi_kobj);
431 destroy_workqueue(efi_rts_wq);
432 return error;
433 }
434
435 subsys_initcall(efisubsys_init);
436
437 /*
438 * Find the efi memory descriptor for a given physical address. Given a
439 * physical address, determine if it exists within an EFI Memory Map entry,
440 * and if so, populate the supplied memory descriptor with the appropriate
441 * data.
442 */
efi_mem_desc_lookup(u64 phys_addr,efi_memory_desc_t * out_md)443 int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md)
444 {
445 efi_memory_desc_t *md;
446
447 if (!efi_enabled(EFI_MEMMAP)) {
448 pr_err_once("EFI_MEMMAP is not enabled.\n");
449 return -EINVAL;
450 }
451
452 if (!out_md) {
453 pr_err_once("out_md is null.\n");
454 return -EINVAL;
455 }
456
457 for_each_efi_memory_desc(md) {
458 u64 size;
459 u64 end;
460
461 size = md->num_pages << EFI_PAGE_SHIFT;
462 end = md->phys_addr + size;
463 if (phys_addr >= md->phys_addr && phys_addr < end) {
464 memcpy(out_md, md, sizeof(*out_md));
465 return 0;
466 }
467 }
468 return -ENOENT;
469 }
470
471 /*
472 * Calculate the highest address of an efi memory descriptor.
473 */
efi_mem_desc_end(efi_memory_desc_t * md)474 u64 __init efi_mem_desc_end(efi_memory_desc_t *md)
475 {
476 u64 size = md->num_pages << EFI_PAGE_SHIFT;
477 u64 end = md->phys_addr + size;
478 return end;
479 }
480
efi_arch_mem_reserve(phys_addr_t addr,u64 size)481 void __init __weak efi_arch_mem_reserve(phys_addr_t addr, u64 size) {}
482
483 /**
484 * efi_mem_reserve - Reserve an EFI memory region
485 * @addr: Physical address to reserve
486 * @size: Size of reservation
487 *
488 * Mark a region as reserved from general kernel allocation and
489 * prevent it being released by efi_free_boot_services().
490 *
491 * This function should be called drivers once they've parsed EFI
492 * configuration tables to figure out where their data lives, e.g.
493 * efi_esrt_init().
494 */
efi_mem_reserve(phys_addr_t addr,u64 size)495 void __init efi_mem_reserve(phys_addr_t addr, u64 size)
496 {
497 if (!memblock_is_region_reserved(addr, size))
498 memblock_reserve(addr, size);
499
500 /*
501 * Some architectures (x86) reserve all boot services ranges
502 * until efi_free_boot_services() because of buggy firmware
503 * implementations. This means the above memblock_reserve() is
504 * superfluous on x86 and instead what it needs to do is
505 * ensure the @start, @size is not freed.
506 */
507 efi_arch_mem_reserve(addr, size);
508 }
509
510 static const efi_config_table_type_t common_tables[] __initconst = {
511 {ACPI_20_TABLE_GUID, &efi.acpi20, "ACPI 2.0" },
512 {ACPI_TABLE_GUID, &efi.acpi, "ACPI" },
513 {SMBIOS_TABLE_GUID, &efi.smbios, "SMBIOS" },
514 {SMBIOS3_TABLE_GUID, &efi.smbios3, "SMBIOS 3.0" },
515 {EFI_SYSTEM_RESOURCE_TABLE_GUID, &efi.esrt, "ESRT" },
516 {EFI_MEMORY_ATTRIBUTES_TABLE_GUID, &efi_mem_attr_table, "MEMATTR" },
517 {LINUX_EFI_RANDOM_SEED_TABLE_GUID, &efi_rng_seed, "RNG" },
518 {LINUX_EFI_TPM_EVENT_LOG_GUID, &efi.tpm_log, "TPMEventLog" },
519 {LINUX_EFI_TPM_FINAL_LOG_GUID, &efi.tpm_final_log, "TPMFinalLog" },
520 {LINUX_EFI_MEMRESERVE_TABLE_GUID, &mem_reserve, "MEMRESERVE" },
521 {EFI_RT_PROPERTIES_TABLE_GUID, &rt_prop, "RTPROP" },
522 #ifdef CONFIG_EFI_RCI2_TABLE
523 {DELLEMC_EFI_RCI2_TABLE_GUID, &rci2_table_phys },
524 #endif
525 #ifdef CONFIG_LOAD_UEFI_KEYS
526 {LINUX_EFI_MOK_VARIABLE_TABLE_GUID, &efi.mokvar_table, "MOKvar" },
527 #endif
528 {},
529 };
530
match_config_table(const efi_guid_t * guid,unsigned long table,const efi_config_table_type_t * table_types)531 static __init int match_config_table(const efi_guid_t *guid,
532 unsigned long table,
533 const efi_config_table_type_t *table_types)
534 {
535 int i;
536
537 for (i = 0; efi_guidcmp(table_types[i].guid, NULL_GUID); i++) {
538 if (!efi_guidcmp(*guid, table_types[i].guid)) {
539 *(table_types[i].ptr) = table;
540 if (table_types[i].name[0])
541 pr_cont("%s=0x%lx ",
542 table_types[i].name, table);
543 return 1;
544 }
545 }
546
547 return 0;
548 }
549
efi_config_parse_tables(const efi_config_table_t * config_tables,int count,const efi_config_table_type_t * arch_tables)550 int __init efi_config_parse_tables(const efi_config_table_t *config_tables,
551 int count,
552 const efi_config_table_type_t *arch_tables)
553 {
554 const efi_config_table_64_t *tbl64 = (void *)config_tables;
555 const efi_config_table_32_t *tbl32 = (void *)config_tables;
556 const efi_guid_t *guid;
557 unsigned long table;
558 int i;
559
560 pr_info("");
561 for (i = 0; i < count; i++) {
562 if (!IS_ENABLED(CONFIG_X86)) {
563 guid = &config_tables[i].guid;
564 table = (unsigned long)config_tables[i].table;
565 } else if (efi_enabled(EFI_64BIT)) {
566 guid = &tbl64[i].guid;
567 table = tbl64[i].table;
568
569 if (IS_ENABLED(CONFIG_X86_32) &&
570 tbl64[i].table > U32_MAX) {
571 pr_cont("\n");
572 pr_err("Table located above 4GB, disabling EFI.\n");
573 return -EINVAL;
574 }
575 } else {
576 guid = &tbl32[i].guid;
577 table = tbl32[i].table;
578 }
579
580 if (!match_config_table(guid, table, common_tables) && arch_tables)
581 match_config_table(guid, table, arch_tables);
582 }
583 pr_cont("\n");
584 set_bit(EFI_CONFIG_TABLES, &efi.flags);
585
586 if (efi_rng_seed != EFI_INVALID_TABLE_ADDR) {
587 struct linux_efi_random_seed *seed;
588 u32 size = 0;
589
590 seed = early_memremap(efi_rng_seed, sizeof(*seed));
591 if (seed != NULL) {
592 size = READ_ONCE(seed->size);
593 early_memunmap(seed, sizeof(*seed));
594 } else {
595 pr_err("Could not map UEFI random seed!\n");
596 }
597 if (size > 0) {
598 seed = early_memremap(efi_rng_seed,
599 sizeof(*seed) + size);
600 if (seed != NULL) {
601 pr_notice("seeding entropy pool\n");
602 add_bootloader_randomness(seed->bits, size);
603 early_memunmap(seed, sizeof(*seed) + size);
604 } else {
605 pr_err("Could not map UEFI random seed!\n");
606 }
607 }
608 }
609
610 if (!IS_ENABLED(CONFIG_X86_32) && efi_enabled(EFI_MEMMAP))
611 efi_memattr_init();
612
613 efi_tpm_eventlog_init();
614
615 if (mem_reserve != EFI_INVALID_TABLE_ADDR) {
616 unsigned long prsv = mem_reserve;
617
618 while (prsv) {
619 struct linux_efi_memreserve *rsv;
620 u8 *p;
621
622 /*
623 * Just map a full page: that is what we will get
624 * anyway, and it permits us to map the entire entry
625 * before knowing its size.
626 */
627 p = early_memremap(ALIGN_DOWN(prsv, PAGE_SIZE),
628 PAGE_SIZE);
629 if (p == NULL) {
630 pr_err("Could not map UEFI memreserve entry!\n");
631 return -ENOMEM;
632 }
633
634 rsv = (void *)(p + prsv % PAGE_SIZE);
635
636 /* reserve the entry itself */
637 memblock_reserve(prsv,
638 struct_size(rsv, entry, rsv->size));
639
640 for (i = 0; i < atomic_read(&rsv->count); i++) {
641 memblock_reserve(rsv->entry[i].base,
642 rsv->entry[i].size);
643 }
644
645 prsv = rsv->next;
646 early_memunmap(p, PAGE_SIZE);
647 }
648 }
649
650 if (rt_prop != EFI_INVALID_TABLE_ADDR) {
651 efi_rt_properties_table_t *tbl;
652
653 tbl = early_memremap(rt_prop, sizeof(*tbl));
654 if (tbl) {
655 efi.runtime_supported_mask &= tbl->runtime_services_supported;
656 early_memunmap(tbl, sizeof(*tbl));
657 }
658 }
659
660 return 0;
661 }
662
efi_systab_check_header(const efi_table_hdr_t * systab_hdr,int min_major_version)663 int __init efi_systab_check_header(const efi_table_hdr_t *systab_hdr,
664 int min_major_version)
665 {
666 if (systab_hdr->signature != EFI_SYSTEM_TABLE_SIGNATURE) {
667 pr_err("System table signature incorrect!\n");
668 return -EINVAL;
669 }
670
671 if ((systab_hdr->revision >> 16) < min_major_version)
672 pr_err("Warning: System table version %d.%02d, expected %d.00 or greater!\n",
673 systab_hdr->revision >> 16,
674 systab_hdr->revision & 0xffff,
675 min_major_version);
676
677 return 0;
678 }
679
680 #ifndef CONFIG_IA64
map_fw_vendor(unsigned long fw_vendor,size_t size)681 static const efi_char16_t *__init map_fw_vendor(unsigned long fw_vendor,
682 size_t size)
683 {
684 const efi_char16_t *ret;
685
686 ret = early_memremap_ro(fw_vendor, size);
687 if (!ret)
688 pr_err("Could not map the firmware vendor!\n");
689 return ret;
690 }
691
unmap_fw_vendor(const void * fw_vendor,size_t size)692 static void __init unmap_fw_vendor(const void *fw_vendor, size_t size)
693 {
694 early_memunmap((void *)fw_vendor, size);
695 }
696 #else
697 #define map_fw_vendor(p, s) __va(p)
698 #define unmap_fw_vendor(v, s)
699 #endif
700
efi_systab_report_header(const efi_table_hdr_t * systab_hdr,unsigned long fw_vendor)701 void __init efi_systab_report_header(const efi_table_hdr_t *systab_hdr,
702 unsigned long fw_vendor)
703 {
704 char vendor[100] = "unknown";
705 const efi_char16_t *c16;
706 size_t i;
707
708 c16 = map_fw_vendor(fw_vendor, sizeof(vendor) * sizeof(efi_char16_t));
709 if (c16) {
710 for (i = 0; i < sizeof(vendor) - 1 && c16[i]; ++i)
711 vendor[i] = c16[i];
712 vendor[i] = '\0';
713
714 unmap_fw_vendor(c16, sizeof(vendor) * sizeof(efi_char16_t));
715 }
716
717 pr_info("EFI v%u.%.02u by %s\n",
718 systab_hdr->revision >> 16,
719 systab_hdr->revision & 0xffff,
720 vendor);
721 }
722
723 static __initdata char memory_type_name[][13] = {
724 "Reserved",
725 "Loader Code",
726 "Loader Data",
727 "Boot Code",
728 "Boot Data",
729 "Runtime Code",
730 "Runtime Data",
731 "Conventional",
732 "Unusable",
733 "ACPI Reclaim",
734 "ACPI Mem NVS",
735 "MMIO",
736 "MMIO Port",
737 "PAL Code",
738 "Persistent",
739 };
740
efi_md_typeattr_format(char * buf,size_t size,const efi_memory_desc_t * md)741 char * __init efi_md_typeattr_format(char *buf, size_t size,
742 const efi_memory_desc_t *md)
743 {
744 char *pos;
745 int type_len;
746 u64 attr;
747
748 pos = buf;
749 if (md->type >= ARRAY_SIZE(memory_type_name))
750 type_len = snprintf(pos, size, "[type=%u", md->type);
751 else
752 type_len = snprintf(pos, size, "[%-*s",
753 (int)(sizeof(memory_type_name[0]) - 1),
754 memory_type_name[md->type]);
755 if (type_len >= size)
756 return buf;
757
758 pos += type_len;
759 size -= type_len;
760
761 attr = md->attribute;
762 if (attr & ~(EFI_MEMORY_UC | EFI_MEMORY_WC | EFI_MEMORY_WT |
763 EFI_MEMORY_WB | EFI_MEMORY_UCE | EFI_MEMORY_RO |
764 EFI_MEMORY_WP | EFI_MEMORY_RP | EFI_MEMORY_XP |
765 EFI_MEMORY_NV | EFI_MEMORY_SP | EFI_MEMORY_CPU_CRYPTO |
766 EFI_MEMORY_RUNTIME | EFI_MEMORY_MORE_RELIABLE))
767 snprintf(pos, size, "|attr=0x%016llx]",
768 (unsigned long long)attr);
769 else
770 snprintf(pos, size,
771 "|%3s|%2s|%2s|%2s|%2s|%2s|%2s|%2s|%2s|%3s|%2s|%2s|%2s|%2s]",
772 attr & EFI_MEMORY_RUNTIME ? "RUN" : "",
773 attr & EFI_MEMORY_MORE_RELIABLE ? "MR" : "",
774 attr & EFI_MEMORY_CPU_CRYPTO ? "CC" : "",
775 attr & EFI_MEMORY_SP ? "SP" : "",
776 attr & EFI_MEMORY_NV ? "NV" : "",
777 attr & EFI_MEMORY_XP ? "XP" : "",
778 attr & EFI_MEMORY_RP ? "RP" : "",
779 attr & EFI_MEMORY_WP ? "WP" : "",
780 attr & EFI_MEMORY_RO ? "RO" : "",
781 attr & EFI_MEMORY_UCE ? "UCE" : "",
782 attr & EFI_MEMORY_WB ? "WB" : "",
783 attr & EFI_MEMORY_WT ? "WT" : "",
784 attr & EFI_MEMORY_WC ? "WC" : "",
785 attr & EFI_MEMORY_UC ? "UC" : "");
786 return buf;
787 }
788
789 /*
790 * IA64 has a funky EFI memory map that doesn't work the same way as
791 * other architectures.
792 */
793 #ifndef CONFIG_IA64
794 /*
795 * efi_mem_attributes - lookup memmap attributes for physical address
796 * @phys_addr: the physical address to lookup
797 *
798 * Search in the EFI memory map for the region covering
799 * @phys_addr. Returns the EFI memory attributes if the region
800 * was found in the memory map, 0 otherwise.
801 */
efi_mem_attributes(unsigned long phys_addr)802 u64 efi_mem_attributes(unsigned long phys_addr)
803 {
804 efi_memory_desc_t *md;
805
806 if (!efi_enabled(EFI_MEMMAP))
807 return 0;
808
809 for_each_efi_memory_desc(md) {
810 if ((md->phys_addr <= phys_addr) &&
811 (phys_addr < (md->phys_addr +
812 (md->num_pages << EFI_PAGE_SHIFT))))
813 return md->attribute;
814 }
815 return 0;
816 }
817
818 /*
819 * efi_mem_type - lookup memmap type for physical address
820 * @phys_addr: the physical address to lookup
821 *
822 * Search in the EFI memory map for the region covering @phys_addr.
823 * Returns the EFI memory type if the region was found in the memory
824 * map, -EINVAL otherwise.
825 */
efi_mem_type(unsigned long phys_addr)826 int efi_mem_type(unsigned long phys_addr)
827 {
828 const efi_memory_desc_t *md;
829
830 if (!efi_enabled(EFI_MEMMAP))
831 return -ENOTSUPP;
832
833 for_each_efi_memory_desc(md) {
834 if ((md->phys_addr <= phys_addr) &&
835 (phys_addr < (md->phys_addr +
836 (md->num_pages << EFI_PAGE_SHIFT))))
837 return md->type;
838 }
839 return -EINVAL;
840 }
841 #endif
842
efi_status_to_err(efi_status_t status)843 int efi_status_to_err(efi_status_t status)
844 {
845 int err;
846
847 switch (status) {
848 case EFI_SUCCESS:
849 err = 0;
850 break;
851 case EFI_INVALID_PARAMETER:
852 err = -EINVAL;
853 break;
854 case EFI_OUT_OF_RESOURCES:
855 err = -ENOSPC;
856 break;
857 case EFI_DEVICE_ERROR:
858 err = -EIO;
859 break;
860 case EFI_WRITE_PROTECTED:
861 err = -EROFS;
862 break;
863 case EFI_SECURITY_VIOLATION:
864 err = -EACCES;
865 break;
866 case EFI_NOT_FOUND:
867 err = -ENOENT;
868 break;
869 case EFI_ABORTED:
870 err = -EINTR;
871 break;
872 default:
873 err = -EINVAL;
874 }
875
876 return err;
877 }
878
879 static DEFINE_SPINLOCK(efi_mem_reserve_persistent_lock);
880 static struct linux_efi_memreserve *efi_memreserve_root __ro_after_init;
881
efi_memreserve_map_root(void)882 static int __init efi_memreserve_map_root(void)
883 {
884 if (mem_reserve == EFI_INVALID_TABLE_ADDR)
885 return -ENODEV;
886
887 efi_memreserve_root = memremap(mem_reserve,
888 sizeof(*efi_memreserve_root),
889 MEMREMAP_WB);
890 if (WARN_ON_ONCE(!efi_memreserve_root))
891 return -ENOMEM;
892 return 0;
893 }
894
efi_mem_reserve_iomem(phys_addr_t addr,u64 size)895 static int efi_mem_reserve_iomem(phys_addr_t addr, u64 size)
896 {
897 struct resource *res, *parent;
898
899 res = kzalloc(sizeof(struct resource), GFP_ATOMIC);
900 if (!res)
901 return -ENOMEM;
902
903 res->name = "reserved";
904 res->flags = IORESOURCE_MEM;
905 res->start = addr;
906 res->end = addr + size - 1;
907
908 /* we expect a conflict with a 'System RAM' region */
909 parent = request_resource_conflict(&iomem_resource, res);
910 return parent ? request_resource(parent, res) : 0;
911 }
912
efi_mem_reserve_persistent(phys_addr_t addr,u64 size)913 int __ref efi_mem_reserve_persistent(phys_addr_t addr, u64 size)
914 {
915 struct linux_efi_memreserve *rsv;
916 unsigned long prsv;
917 int rc, index;
918
919 if (efi_memreserve_root == (void *)ULONG_MAX)
920 return -ENODEV;
921
922 if (!efi_memreserve_root) {
923 rc = efi_memreserve_map_root();
924 if (rc)
925 return rc;
926 }
927
928 /* first try to find a slot in an existing linked list entry */
929 for (prsv = efi_memreserve_root->next; prsv; prsv = rsv->next) {
930 rsv = memremap(prsv, sizeof(*rsv), MEMREMAP_WB);
931 index = atomic_fetch_add_unless(&rsv->count, 1, rsv->size);
932 if (index < rsv->size) {
933 rsv->entry[index].base = addr;
934 rsv->entry[index].size = size;
935
936 memunmap(rsv);
937 return efi_mem_reserve_iomem(addr, size);
938 }
939 memunmap(rsv);
940 }
941
942 /* no slot found - allocate a new linked list entry */
943 rsv = (struct linux_efi_memreserve *)__get_free_page(GFP_ATOMIC);
944 if (!rsv)
945 return -ENOMEM;
946
947 rc = efi_mem_reserve_iomem(__pa(rsv), SZ_4K);
948 if (rc) {
949 free_page((unsigned long)rsv);
950 return rc;
951 }
952
953 /*
954 * The memremap() call above assumes that a linux_efi_memreserve entry
955 * never crosses a page boundary, so let's ensure that this remains true
956 * even when kexec'ing a 4k pages kernel from a >4k pages kernel, by
957 * using SZ_4K explicitly in the size calculation below.
958 */
959 rsv->size = EFI_MEMRESERVE_COUNT(SZ_4K);
960 atomic_set(&rsv->count, 1);
961 rsv->entry[0].base = addr;
962 rsv->entry[0].size = size;
963
964 spin_lock(&efi_mem_reserve_persistent_lock);
965 rsv->next = efi_memreserve_root->next;
966 efi_memreserve_root->next = __pa(rsv);
967 spin_unlock(&efi_mem_reserve_persistent_lock);
968
969 return efi_mem_reserve_iomem(addr, size);
970 }
971
efi_memreserve_root_init(void)972 static int __init efi_memreserve_root_init(void)
973 {
974 if (efi_memreserve_root)
975 return 0;
976 if (efi_memreserve_map_root())
977 efi_memreserve_root = (void *)ULONG_MAX;
978 return 0;
979 }
980 early_initcall(efi_memreserve_root_init);
981
982 #ifdef CONFIG_KEXEC
update_efi_random_seed(struct notifier_block * nb,unsigned long code,void * unused)983 static int update_efi_random_seed(struct notifier_block *nb,
984 unsigned long code, void *unused)
985 {
986 struct linux_efi_random_seed *seed;
987 u32 size = 0;
988
989 if (!kexec_in_progress)
990 return NOTIFY_DONE;
991
992 seed = memremap(efi_rng_seed, sizeof(*seed), MEMREMAP_WB);
993 if (seed != NULL) {
994 size = min(seed->size, EFI_RANDOM_SEED_SIZE);
995 memunmap(seed);
996 } else {
997 pr_err("Could not map UEFI random seed!\n");
998 }
999 if (size > 0) {
1000 seed = memremap(efi_rng_seed, sizeof(*seed) + size,
1001 MEMREMAP_WB);
1002 if (seed != NULL) {
1003 seed->size = size;
1004 get_random_bytes(seed->bits, seed->size);
1005 memunmap(seed);
1006 } else {
1007 pr_err("Could not map UEFI random seed!\n");
1008 }
1009 }
1010 return NOTIFY_DONE;
1011 }
1012
1013 static struct notifier_block efi_random_seed_nb = {
1014 .notifier_call = update_efi_random_seed,
1015 };
1016
register_update_efi_random_seed(void)1017 static int __init register_update_efi_random_seed(void)
1018 {
1019 if (efi_rng_seed == EFI_INVALID_TABLE_ADDR)
1020 return 0;
1021 return register_reboot_notifier(&efi_random_seed_nb);
1022 }
1023 late_initcall(register_update_efi_random_seed);
1024 #endif
1025