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