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