]> git.ipfire.org Git - thirdparty/linux.git/blob - drivers/firmware/efi/efi.c
projects / thirdparty / linux.git / blob
? search:


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