1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * Common EFI (Extensible Firmware Interface) support functions |
4 | * Based on Extensible Firmware Interface Specification version 1.0 |
5 | * |
6 | * Copyright (C) 1999 VA Linux Systems |
7 | * Copyright (C) 1999 Walt Drummond <drummond@valinux.com> |
8 | * Copyright (C) 1999-2002 Hewlett-Packard Co. |
9 | * David Mosberger-Tang <davidm@hpl.hp.com> |
10 | * Stephane Eranian <eranian@hpl.hp.com> |
11 | * Copyright (C) 2005-2008 Intel Co. |
12 | * Fenghua Yu <fenghua.yu@intel.com> |
13 | * Bibo Mao <bibo.mao@intel.com> |
14 | * Chandramouli Narayanan <mouli@linux.intel.com> |
15 | * Huang Ying <ying.huang@intel.com> |
16 | * Copyright (C) 2013 SuSE Labs |
17 | * Borislav Petkov <bp@suse.de> - runtime services VA mapping |
18 | * |
19 | * Copied from efi_32.c to eliminate the duplicated code between EFI |
20 | * 32/64 support code. --ying 2007-10-26 |
21 | * |
22 | * All EFI Runtime Services are not implemented yet as EFI only |
23 | * supports physical mode addressing on SoftSDV. This is to be fixed |
24 | * in a future version. --drummond 1999-07-20 |
25 | * |
26 | * Implemented EFI runtime services and virtual mode calls. --davidm |
27 | * |
28 | * Goutham Rao: <goutham.rao@intel.com> |
29 | * Skip non-WB memory and ignore empty memory ranges. |
30 | */ |
31 | |
32 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
33 | |
34 | #include <linux/kernel.h> |
35 | #include <linux/init.h> |
36 | #include <linux/efi.h> |
37 | #include <linux/efi-bgrt.h> |
38 | #include <linux/export.h> |
39 | #include <linux/memblock.h> |
40 | #include <linux/slab.h> |
41 | #include <linux/spinlock.h> |
42 | #include <linux/uaccess.h> |
43 | #include <linux/time.h> |
44 | #include <linux/io.h> |
45 | #include <linux/reboot.h> |
46 | #include <linux/bcd.h> |
47 | |
48 | #include <asm/setup.h> |
49 | #include <asm/efi.h> |
50 | #include <asm/e820/api.h> |
51 | #include <asm/time.h> |
52 | #include <asm/tlbflush.h> |
53 | #include <asm/x86_init.h> |
54 | #include <asm/uv/uv.h> |
55 | |
56 | static unsigned long efi_systab_phys __initdata; |
57 | static unsigned long prop_phys = EFI_INVALID_TABLE_ADDR; |
58 | static unsigned long uga_phys = EFI_INVALID_TABLE_ADDR; |
59 | static unsigned long efi_runtime, efi_nr_tables; |
60 | |
61 | unsigned long efi_fw_vendor, efi_config_table; |
62 | |
63 | static const efi_config_table_type_t arch_tables[] __initconst = { |
64 | {EFI_PROPERTIES_TABLE_GUID, &prop_phys, "PROP" }, |
65 | {UGA_IO_PROTOCOL_GUID, &uga_phys, "UGA" }, |
66 | #ifdef CONFIG_X86_UV |
67 | {UV_SYSTEM_TABLE_GUID, &uv_systab_phys, "UVsystab" }, |
68 | #endif |
69 | {}, |
70 | }; |
71 | |
72 | static const unsigned long * const efi_tables[] = { |
73 | &efi.acpi, |
74 | &efi.acpi20, |
75 | &efi.smbios, |
76 | &efi.smbios3, |
77 | &uga_phys, |
78 | #ifdef CONFIG_X86_UV |
79 | &uv_systab_phys, |
80 | #endif |
81 | &efi_fw_vendor, |
82 | &efi_runtime, |
83 | &efi_config_table, |
84 | &efi.esrt, |
85 | &prop_phys, |
86 | &efi_mem_attr_table, |
87 | #ifdef CONFIG_EFI_RCI2_TABLE |
88 | &rci2_table_phys, |
89 | #endif |
90 | &efi.tpm_log, |
91 | &efi.tpm_final_log, |
92 | &efi_rng_seed, |
93 | #ifdef CONFIG_LOAD_UEFI_KEYS |
94 | &efi.mokvar_table, |
95 | #endif |
96 | #ifdef CONFIG_EFI_COCO_SECRET |
97 | &efi.coco_secret, |
98 | #endif |
99 | #ifdef CONFIG_UNACCEPTED_MEMORY |
100 | &efi.unaccepted, |
101 | #endif |
102 | }; |
103 | |
104 | u64 efi_setup; /* efi setup_data physical address */ |
105 | |
106 | static int add_efi_memmap __initdata; |
107 | static int __init setup_add_efi_memmap(char *arg) |
108 | { |
109 | add_efi_memmap = 1; |
110 | return 0; |
111 | } |
112 | early_param("add_efi_memmap" , setup_add_efi_memmap); |
113 | |
114 | /* |
115 | * Tell the kernel about the EFI memory map. This might include |
116 | * more than the max 128 entries that can fit in the passed in e820 |
117 | * legacy (zeropage) memory map, but the kernel's e820 table can hold |
118 | * E820_MAX_ENTRIES. |
119 | */ |
120 | |
121 | static void __init do_add_efi_memmap(void) |
122 | { |
123 | efi_memory_desc_t *md; |
124 | |
125 | if (!efi_enabled(EFI_MEMMAP)) |
126 | return; |
127 | |
128 | for_each_efi_memory_desc(md) { |
129 | unsigned long long start = md->phys_addr; |
130 | unsigned long long size = md->num_pages << EFI_PAGE_SHIFT; |
131 | int e820_type; |
132 | |
133 | switch (md->type) { |
134 | case EFI_LOADER_CODE: |
135 | case EFI_LOADER_DATA: |
136 | case EFI_BOOT_SERVICES_CODE: |
137 | case EFI_BOOT_SERVICES_DATA: |
138 | case EFI_CONVENTIONAL_MEMORY: |
139 | if (efi_soft_reserve_enabled() |
140 | && (md->attribute & EFI_MEMORY_SP)) |
141 | e820_type = E820_TYPE_SOFT_RESERVED; |
142 | else if (md->attribute & EFI_MEMORY_WB) |
143 | e820_type = E820_TYPE_RAM; |
144 | else |
145 | e820_type = E820_TYPE_RESERVED; |
146 | break; |
147 | case EFI_ACPI_RECLAIM_MEMORY: |
148 | e820_type = E820_TYPE_ACPI; |
149 | break; |
150 | case EFI_ACPI_MEMORY_NVS: |
151 | e820_type = E820_TYPE_NVS; |
152 | break; |
153 | case EFI_UNUSABLE_MEMORY: |
154 | e820_type = E820_TYPE_UNUSABLE; |
155 | break; |
156 | case EFI_PERSISTENT_MEMORY: |
157 | e820_type = E820_TYPE_PMEM; |
158 | break; |
159 | default: |
160 | /* |
161 | * EFI_RESERVED_TYPE EFI_RUNTIME_SERVICES_CODE |
162 | * EFI_RUNTIME_SERVICES_DATA EFI_MEMORY_MAPPED_IO |
163 | * EFI_MEMORY_MAPPED_IO_PORT_SPACE EFI_PAL_CODE |
164 | */ |
165 | e820_type = E820_TYPE_RESERVED; |
166 | break; |
167 | } |
168 | |
169 | e820__range_add(start, size, type: e820_type); |
170 | } |
171 | e820__update_table(table: e820_table); |
172 | } |
173 | |
174 | /* |
175 | * Given add_efi_memmap defaults to 0 and there is no alternative |
176 | * e820 mechanism for soft-reserved memory, import the full EFI memory |
177 | * map if soft reservations are present and enabled. Otherwise, the |
178 | * mechanism to disable the kernel's consideration of EFI_MEMORY_SP is |
179 | * the efi=nosoftreserve option. |
180 | */ |
181 | static bool do_efi_soft_reserve(void) |
182 | { |
183 | efi_memory_desc_t *md; |
184 | |
185 | if (!efi_enabled(EFI_MEMMAP)) |
186 | return false; |
187 | |
188 | if (!efi_soft_reserve_enabled()) |
189 | return false; |
190 | |
191 | for_each_efi_memory_desc(md) |
192 | if (md->type == EFI_CONVENTIONAL_MEMORY && |
193 | (md->attribute & EFI_MEMORY_SP)) |
194 | return true; |
195 | return false; |
196 | } |
197 | |
198 | int __init efi_memblock_x86_reserve_range(void) |
199 | { |
200 | struct efi_info *e = &boot_params.efi_info; |
201 | struct efi_memory_map_data data; |
202 | phys_addr_t pmap; |
203 | int rv; |
204 | |
205 | if (efi_enabled(EFI_PARAVIRT)) |
206 | return 0; |
207 | |
208 | /* Can't handle firmware tables above 4GB on i386 */ |
209 | if (IS_ENABLED(CONFIG_X86_32) && e->efi_memmap_hi > 0) { |
210 | pr_err("Memory map is above 4GB, disabling EFI.\n" ); |
211 | return -EINVAL; |
212 | } |
213 | pmap = (phys_addr_t)(e->efi_memmap | ((u64)e->efi_memmap_hi << 32)); |
214 | |
215 | data.phys_map = pmap; |
216 | data.size = e->efi_memmap_size; |
217 | data.desc_size = e->efi_memdesc_size; |
218 | data.desc_version = e->efi_memdesc_version; |
219 | |
220 | if (!efi_enabled(EFI_PARAVIRT)) { |
221 | rv = efi_memmap_init_early(data: &data); |
222 | if (rv) |
223 | return rv; |
224 | } |
225 | |
226 | if (add_efi_memmap || do_efi_soft_reserve()) |
227 | do_add_efi_memmap(); |
228 | |
229 | efi_fake_memmap_early(); |
230 | |
231 | WARN(efi.memmap.desc_version != 1, |
232 | "Unexpected EFI_MEMORY_DESCRIPTOR version %ld" , |
233 | efi.memmap.desc_version); |
234 | |
235 | memblock_reserve(base: pmap, size: efi.memmap.nr_map * efi.memmap.desc_size); |
236 | set_bit(EFI_PRESERVE_BS_REGIONS, addr: &efi.flags); |
237 | |
238 | return 0; |
239 | } |
240 | |
241 | #define OVERFLOW_ADDR_SHIFT (64 - EFI_PAGE_SHIFT) |
242 | #define OVERFLOW_ADDR_MASK (U64_MAX << OVERFLOW_ADDR_SHIFT) |
243 | #define U64_HIGH_BIT (~(U64_MAX >> 1)) |
244 | |
245 | static bool __init efi_memmap_entry_valid(const efi_memory_desc_t *md, int i) |
246 | { |
247 | u64 end = (md->num_pages << EFI_PAGE_SHIFT) + md->phys_addr - 1; |
248 | u64 end_hi = 0; |
249 | char buf[64]; |
250 | |
251 | if (md->num_pages == 0) { |
252 | end = 0; |
253 | } else if (md->num_pages > EFI_PAGES_MAX || |
254 | EFI_PAGES_MAX - md->num_pages < |
255 | (md->phys_addr >> EFI_PAGE_SHIFT)) { |
256 | end_hi = (md->num_pages & OVERFLOW_ADDR_MASK) |
257 | >> OVERFLOW_ADDR_SHIFT; |
258 | |
259 | if ((md->phys_addr & U64_HIGH_BIT) && !(end & U64_HIGH_BIT)) |
260 | end_hi += 1; |
261 | } else { |
262 | return true; |
263 | } |
264 | |
265 | pr_warn_once(FW_BUG "Invalid EFI memory map entries:\n" ); |
266 | |
267 | if (end_hi) { |
268 | pr_warn("mem%02u: %s range=[0x%016llx-0x%llx%016llx] (invalid)\n" , |
269 | i, efi_md_typeattr_format(buf, sizeof(buf), md), |
270 | md->phys_addr, end_hi, end); |
271 | } else { |
272 | pr_warn("mem%02u: %s range=[0x%016llx-0x%016llx] (invalid)\n" , |
273 | i, efi_md_typeattr_format(buf, sizeof(buf), md), |
274 | md->phys_addr, end); |
275 | } |
276 | return false; |
277 | } |
278 | |
279 | static void __init efi_clean_memmap(void) |
280 | { |
281 | efi_memory_desc_t *out = efi.memmap.map; |
282 | const efi_memory_desc_t *in = out; |
283 | const efi_memory_desc_t *end = efi.memmap.map_end; |
284 | int i, n_removal; |
285 | |
286 | for (i = n_removal = 0; in < end; i++) { |
287 | if (efi_memmap_entry_valid(md: in, i)) { |
288 | if (out != in) |
289 | memcpy(out, in, efi.memmap.desc_size); |
290 | out = (void *)out + efi.memmap.desc_size; |
291 | } else { |
292 | n_removal++; |
293 | } |
294 | in = (void *)in + efi.memmap.desc_size; |
295 | } |
296 | |
297 | if (n_removal > 0) { |
298 | struct efi_memory_map_data data = { |
299 | .phys_map = efi.memmap.phys_map, |
300 | .desc_version = efi.memmap.desc_version, |
301 | .desc_size = efi.memmap.desc_size, |
302 | .size = efi.memmap.desc_size * (efi.memmap.nr_map - n_removal), |
303 | .flags = 0, |
304 | }; |
305 | |
306 | pr_warn("Removing %d invalid memory map entries.\n" , n_removal); |
307 | efi_memmap_install(data: &data); |
308 | } |
309 | } |
310 | |
311 | /* |
312 | * Firmware can use EfiMemoryMappedIO to request that MMIO regions be |
313 | * mapped by the OS so they can be accessed by EFI runtime services, but |
314 | * should have no other significance to the OS (UEFI r2.10, sec 7.2). |
315 | * However, most bootloaders and EFI stubs convert EfiMemoryMappedIO |
316 | * regions to E820_TYPE_RESERVED entries, which prevent Linux from |
317 | * allocating space from them (see remove_e820_regions()). |
318 | * |
319 | * Some platforms use EfiMemoryMappedIO entries for PCI MMCONFIG space and |
320 | * PCI host bridge windows, which means Linux can't allocate BAR space for |
321 | * hot-added devices. |
322 | * |
323 | * Remove large EfiMemoryMappedIO regions from the E820 map to avoid this |
324 | * problem. |
325 | * |
326 | * Retain small EfiMemoryMappedIO regions because on some platforms, these |
327 | * describe non-window space that's included in host bridge _CRS. If we |
328 | * assign that space to PCI devices, they don't work. |
329 | */ |
330 | static void __init efi_remove_e820_mmio(void) |
331 | { |
332 | efi_memory_desc_t *md; |
333 | u64 size, start, end; |
334 | int i = 0; |
335 | |
336 | for_each_efi_memory_desc(md) { |
337 | if (md->type == EFI_MEMORY_MAPPED_IO) { |
338 | size = md->num_pages << EFI_PAGE_SHIFT; |
339 | start = md->phys_addr; |
340 | end = start + size - 1; |
341 | if (size >= 256*1024) { |
342 | pr_info("Remove mem%02u: MMIO range=[0x%08llx-0x%08llx] (%lluMB) from e820 map\n" , |
343 | i, start, end, size >> 20); |
344 | e820__range_remove(start, size, |
345 | old_type: E820_TYPE_RESERVED, check_type: 1); |
346 | } else { |
347 | pr_info("Not removing mem%02u: MMIO range=[0x%08llx-0x%08llx] (%lluKB) from e820 map\n" , |
348 | i, start, end, size >> 10); |
349 | } |
350 | } |
351 | i++; |
352 | } |
353 | } |
354 | |
355 | void __init efi_print_memmap(void) |
356 | { |
357 | efi_memory_desc_t *md; |
358 | int i = 0; |
359 | |
360 | for_each_efi_memory_desc(md) { |
361 | char buf[64]; |
362 | |
363 | pr_info("mem%02u: %s range=[0x%016llx-0x%016llx] (%lluMB)\n" , |
364 | i++, efi_md_typeattr_format(buf, sizeof(buf), md), |
365 | md->phys_addr, |
366 | md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) - 1, |
367 | (md->num_pages >> (20 - EFI_PAGE_SHIFT))); |
368 | } |
369 | } |
370 | |
371 | static int __init efi_systab_init(unsigned long phys) |
372 | { |
373 | int size = efi_enabled(EFI_64BIT) ? sizeof(efi_system_table_64_t) |
374 | : sizeof(efi_system_table_32_t); |
375 | const efi_table_hdr_t *hdr; |
376 | bool over4g = false; |
377 | void *p; |
378 | int ret; |
379 | |
380 | hdr = p = early_memremap_ro(phys_addr: phys, size); |
381 | if (p == NULL) { |
382 | pr_err("Couldn't map the system table!\n" ); |
383 | return -ENOMEM; |
384 | } |
385 | |
386 | ret = efi_systab_check_header(systab_hdr: hdr); |
387 | if (ret) { |
388 | early_memunmap(addr: p, size); |
389 | return ret; |
390 | } |
391 | |
392 | if (efi_enabled(EFI_64BIT)) { |
393 | const efi_system_table_64_t *systab64 = p; |
394 | |
395 | efi_runtime = systab64->runtime; |
396 | over4g = systab64->runtime > U32_MAX; |
397 | |
398 | if (efi_setup) { |
399 | struct efi_setup_data *data; |
400 | |
401 | data = early_memremap_ro(phys_addr: efi_setup, size: sizeof(*data)); |
402 | if (!data) { |
403 | early_memunmap(addr: p, size); |
404 | return -ENOMEM; |
405 | } |
406 | |
407 | efi_fw_vendor = (unsigned long)data->fw_vendor; |
408 | efi_config_table = (unsigned long)data->tables; |
409 | |
410 | over4g |= data->fw_vendor > U32_MAX || |
411 | data->tables > U32_MAX; |
412 | |
413 | early_memunmap(addr: data, size: sizeof(*data)); |
414 | } else { |
415 | efi_fw_vendor = systab64->fw_vendor; |
416 | efi_config_table = systab64->tables; |
417 | |
418 | over4g |= systab64->fw_vendor > U32_MAX || |
419 | systab64->tables > U32_MAX; |
420 | } |
421 | efi_nr_tables = systab64->nr_tables; |
422 | } else { |
423 | const efi_system_table_32_t *systab32 = p; |
424 | |
425 | efi_fw_vendor = systab32->fw_vendor; |
426 | efi_runtime = systab32->runtime; |
427 | efi_config_table = systab32->tables; |
428 | efi_nr_tables = systab32->nr_tables; |
429 | } |
430 | |
431 | efi.runtime_version = hdr->revision; |
432 | |
433 | efi_systab_report_header(systab_hdr: hdr, fw_vendor: efi_fw_vendor); |
434 | early_memunmap(addr: p, size); |
435 | |
436 | if (IS_ENABLED(CONFIG_X86_32) && over4g) { |
437 | pr_err("EFI data located above 4GB, disabling EFI.\n" ); |
438 | return -EINVAL; |
439 | } |
440 | |
441 | return 0; |
442 | } |
443 | |
444 | static int __init efi_config_init(const efi_config_table_type_t *arch_tables) |
445 | { |
446 | void *config_tables; |
447 | int sz, ret; |
448 | |
449 | if (efi_nr_tables == 0) |
450 | return 0; |
451 | |
452 | if (efi_enabled(EFI_64BIT)) |
453 | sz = sizeof(efi_config_table_64_t); |
454 | else |
455 | sz = sizeof(efi_config_table_32_t); |
456 | |
457 | /* |
458 | * Let's see what config tables the firmware passed to us. |
459 | */ |
460 | config_tables = early_memremap(phys_addr: efi_config_table, size: efi_nr_tables * sz); |
461 | if (config_tables == NULL) { |
462 | pr_err("Could not map Configuration table!\n" ); |
463 | return -ENOMEM; |
464 | } |
465 | |
466 | ret = efi_config_parse_tables(config_tables, count: efi_nr_tables, |
467 | arch_tables); |
468 | |
469 | early_memunmap(addr: config_tables, size: efi_nr_tables * sz); |
470 | return ret; |
471 | } |
472 | |
473 | void __init efi_init(void) |
474 | { |
475 | if (IS_ENABLED(CONFIG_X86_32) && |
476 | (boot_params.efi_info.efi_systab_hi || |
477 | boot_params.efi_info.efi_memmap_hi)) { |
478 | pr_info("Table located above 4GB, disabling EFI.\n" ); |
479 | return; |
480 | } |
481 | |
482 | efi_systab_phys = boot_params.efi_info.efi_systab | |
483 | ((__u64)boot_params.efi_info.efi_systab_hi << 32); |
484 | |
485 | if (efi_systab_init(phys: efi_systab_phys)) |
486 | return; |
487 | |
488 | if (efi_reuse_config(tables: efi_config_table, nr_tables: efi_nr_tables)) |
489 | return; |
490 | |
491 | if (efi_config_init(arch_tables)) |
492 | return; |
493 | |
494 | /* |
495 | * Note: We currently don't support runtime services on an EFI |
496 | * that doesn't match the kernel 32/64-bit mode. |
497 | */ |
498 | |
499 | if (!efi_runtime_supported()) |
500 | pr_err("No EFI runtime due to 32/64-bit mismatch with kernel\n" ); |
501 | |
502 | if (!efi_runtime_supported() || efi_runtime_disabled()) { |
503 | efi_memmap_unmap(); |
504 | return; |
505 | } |
506 | |
507 | /* Parse the EFI Properties table if it exists */ |
508 | if (prop_phys != EFI_INVALID_TABLE_ADDR) { |
509 | efi_properties_table_t *tbl; |
510 | |
511 | tbl = early_memremap_ro(phys_addr: prop_phys, size: sizeof(*tbl)); |
512 | if (tbl == NULL) { |
513 | pr_err("Could not map Properties table!\n" ); |
514 | } else { |
515 | if (tbl->memory_protection_attribute & |
516 | EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA) |
517 | set_bit(EFI_NX_PE_DATA, addr: &efi.flags); |
518 | |
519 | early_memunmap(addr: tbl, size: sizeof(*tbl)); |
520 | } |
521 | } |
522 | |
523 | set_bit(EFI_RUNTIME_SERVICES, addr: &efi.flags); |
524 | efi_clean_memmap(); |
525 | |
526 | efi_remove_e820_mmio(); |
527 | |
528 | if (efi_enabled(EFI_DBG)) |
529 | efi_print_memmap(); |
530 | } |
531 | |
532 | /* Merge contiguous regions of the same type and attribute */ |
533 | static void __init efi_merge_regions(void) |
534 | { |
535 | efi_memory_desc_t *md, *prev_md = NULL; |
536 | |
537 | for_each_efi_memory_desc(md) { |
538 | u64 prev_size; |
539 | |
540 | if (!prev_md) { |
541 | prev_md = md; |
542 | continue; |
543 | } |
544 | |
545 | if (prev_md->type != md->type || |
546 | prev_md->attribute != md->attribute) { |
547 | prev_md = md; |
548 | continue; |
549 | } |
550 | |
551 | prev_size = prev_md->num_pages << EFI_PAGE_SHIFT; |
552 | |
553 | if (md->phys_addr == (prev_md->phys_addr + prev_size)) { |
554 | prev_md->num_pages += md->num_pages; |
555 | md->type = EFI_RESERVED_TYPE; |
556 | md->attribute = 0; |
557 | continue; |
558 | } |
559 | prev_md = md; |
560 | } |
561 | } |
562 | |
563 | static void *realloc_pages(void *old_memmap, int old_shift) |
564 | { |
565 | void *ret; |
566 | |
567 | ret = (void *)__get_free_pages(GFP_KERNEL, order: old_shift + 1); |
568 | if (!ret) |
569 | goto out; |
570 | |
571 | /* |
572 | * A first-time allocation doesn't have anything to copy. |
573 | */ |
574 | if (!old_memmap) |
575 | return ret; |
576 | |
577 | memcpy(ret, old_memmap, PAGE_SIZE << old_shift); |
578 | |
579 | out: |
580 | free_pages(addr: (unsigned long)old_memmap, order: old_shift); |
581 | return ret; |
582 | } |
583 | |
584 | /* |
585 | * Iterate the EFI memory map in reverse order because the regions |
586 | * will be mapped top-down. The end result is the same as if we had |
587 | * mapped things forward, but doesn't require us to change the |
588 | * existing implementation of efi_map_region(). |
589 | */ |
590 | static inline void *efi_map_next_entry_reverse(void *entry) |
591 | { |
592 | /* Initial call */ |
593 | if (!entry) |
594 | return efi.memmap.map_end - efi.memmap.desc_size; |
595 | |
596 | entry -= efi.memmap.desc_size; |
597 | if (entry < efi.memmap.map) |
598 | return NULL; |
599 | |
600 | return entry; |
601 | } |
602 | |
603 | /* |
604 | * efi_map_next_entry - Return the next EFI memory map descriptor |
605 | * @entry: Previous EFI memory map descriptor |
606 | * |
607 | * This is a helper function to iterate over the EFI memory map, which |
608 | * we do in different orders depending on the current configuration. |
609 | * |
610 | * To begin traversing the memory map @entry must be %NULL. |
611 | * |
612 | * Returns %NULL when we reach the end of the memory map. |
613 | */ |
614 | static void *efi_map_next_entry(void *entry) |
615 | { |
616 | if (efi_enabled(EFI_64BIT)) { |
617 | /* |
618 | * Starting in UEFI v2.5 the EFI_PROPERTIES_TABLE |
619 | * config table feature requires us to map all entries |
620 | * in the same order as they appear in the EFI memory |
621 | * map. That is to say, entry N must have a lower |
622 | * virtual address than entry N+1. This is because the |
623 | * firmware toolchain leaves relative references in |
624 | * the code/data sections, which are split and become |
625 | * separate EFI memory regions. Mapping things |
626 | * out-of-order leads to the firmware accessing |
627 | * unmapped addresses. |
628 | * |
629 | * Since we need to map things this way whether or not |
630 | * the kernel actually makes use of |
631 | * EFI_PROPERTIES_TABLE, let's just switch to this |
632 | * scheme by default for 64-bit. |
633 | */ |
634 | return efi_map_next_entry_reverse(entry); |
635 | } |
636 | |
637 | /* Initial call */ |
638 | if (!entry) |
639 | return efi.memmap.map; |
640 | |
641 | entry += efi.memmap.desc_size; |
642 | if (entry >= efi.memmap.map_end) |
643 | return NULL; |
644 | |
645 | return entry; |
646 | } |
647 | |
648 | static bool should_map_region(efi_memory_desc_t *md) |
649 | { |
650 | /* |
651 | * Runtime regions always require runtime mappings (obviously). |
652 | */ |
653 | if (md->attribute & EFI_MEMORY_RUNTIME) |
654 | return true; |
655 | |
656 | /* |
657 | * 32-bit EFI doesn't suffer from the bug that requires us to |
658 | * reserve boot services regions, and mixed mode support |
659 | * doesn't exist for 32-bit kernels. |
660 | */ |
661 | if (IS_ENABLED(CONFIG_X86_32)) |
662 | return false; |
663 | |
664 | /* |
665 | * EFI specific purpose memory may be reserved by default |
666 | * depending on kernel config and boot options. |
667 | */ |
668 | if (md->type == EFI_CONVENTIONAL_MEMORY && |
669 | efi_soft_reserve_enabled() && |
670 | (md->attribute & EFI_MEMORY_SP)) |
671 | return false; |
672 | |
673 | /* |
674 | * Map all of RAM so that we can access arguments in the 1:1 |
675 | * mapping when making EFI runtime calls. |
676 | */ |
677 | if (efi_is_mixed()) { |
678 | if (md->type == EFI_CONVENTIONAL_MEMORY || |
679 | md->type == EFI_LOADER_DATA || |
680 | md->type == EFI_LOADER_CODE) |
681 | return true; |
682 | } |
683 | |
684 | /* |
685 | * Map boot services regions as a workaround for buggy |
686 | * firmware that accesses them even when they shouldn't. |
687 | * |
688 | * See efi_{reserve,free}_boot_services(). |
689 | */ |
690 | if (md->type == EFI_BOOT_SERVICES_CODE || |
691 | md->type == EFI_BOOT_SERVICES_DATA) |
692 | return true; |
693 | |
694 | return false; |
695 | } |
696 | |
697 | /* |
698 | * Map the efi memory ranges of the runtime services and update new_mmap with |
699 | * virtual addresses. |
700 | */ |
701 | static void * __init efi_map_regions(int *count, int *pg_shift) |
702 | { |
703 | void *p, *new_memmap = NULL; |
704 | unsigned long left = 0; |
705 | unsigned long desc_size; |
706 | efi_memory_desc_t *md; |
707 | |
708 | desc_size = efi.memmap.desc_size; |
709 | |
710 | p = NULL; |
711 | while ((p = efi_map_next_entry(entry: p))) { |
712 | md = p; |
713 | |
714 | if (!should_map_region(md)) |
715 | continue; |
716 | |
717 | efi_map_region(md); |
718 | |
719 | if (left < desc_size) { |
720 | new_memmap = realloc_pages(old_memmap: new_memmap, old_shift: *pg_shift); |
721 | if (!new_memmap) |
722 | return NULL; |
723 | |
724 | left += PAGE_SIZE << *pg_shift; |
725 | (*pg_shift)++; |
726 | } |
727 | |
728 | memcpy(new_memmap + (*count * desc_size), md, desc_size); |
729 | |
730 | left -= desc_size; |
731 | (*count)++; |
732 | } |
733 | |
734 | return new_memmap; |
735 | } |
736 | |
737 | static void __init kexec_enter_virtual_mode(void) |
738 | { |
739 | #ifdef CONFIG_KEXEC_CORE |
740 | efi_memory_desc_t *md; |
741 | unsigned int num_pages; |
742 | |
743 | /* |
744 | * We don't do virtual mode, since we don't do runtime services, on |
745 | * non-native EFI. |
746 | */ |
747 | if (efi_is_mixed()) { |
748 | efi_memmap_unmap(); |
749 | clear_bit(EFI_RUNTIME_SERVICES, addr: &efi.flags); |
750 | return; |
751 | } |
752 | |
753 | if (efi_alloc_page_tables()) { |
754 | pr_err("Failed to allocate EFI page tables\n" ); |
755 | clear_bit(EFI_RUNTIME_SERVICES, addr: &efi.flags); |
756 | return; |
757 | } |
758 | |
759 | /* |
760 | * Map efi regions which were passed via setup_data. The virt_addr is a |
761 | * fixed addr which was used in first kernel of a kexec boot. |
762 | */ |
763 | for_each_efi_memory_desc(md) |
764 | efi_map_region_fixed(md); /* FIXME: add error handling */ |
765 | |
766 | /* |
767 | * Unregister the early EFI memmap from efi_init() and install |
768 | * the new EFI memory map. |
769 | */ |
770 | efi_memmap_unmap(); |
771 | |
772 | if (efi_memmap_init_late(addr: efi.memmap.phys_map, |
773 | size: efi.memmap.desc_size * efi.memmap.nr_map)) { |
774 | pr_err("Failed to remap late EFI memory map\n" ); |
775 | clear_bit(EFI_RUNTIME_SERVICES, addr: &efi.flags); |
776 | return; |
777 | } |
778 | |
779 | num_pages = ALIGN(efi.memmap.nr_map * efi.memmap.desc_size, PAGE_SIZE); |
780 | num_pages >>= PAGE_SHIFT; |
781 | |
782 | if (efi_setup_page_tables(pa_memmap: efi.memmap.phys_map, num_pages)) { |
783 | clear_bit(EFI_RUNTIME_SERVICES, addr: &efi.flags); |
784 | return; |
785 | } |
786 | |
787 | efi_sync_low_kernel_mappings(); |
788 | efi_native_runtime_setup(); |
789 | #endif |
790 | } |
791 | |
792 | /* |
793 | * This function will switch the EFI runtime services to virtual mode. |
794 | * Essentially, we look through the EFI memmap and map every region that |
795 | * has the runtime attribute bit set in its memory descriptor into the |
796 | * efi_pgd page table. |
797 | * |
798 | * The new method does a pagetable switch in a preemption-safe manner |
799 | * so that we're in a different address space when calling a runtime |
800 | * function. For function arguments passing we do copy the PUDs of the |
801 | * kernel page table into efi_pgd prior to each call. |
802 | * |
803 | * Specially for kexec boot, efi runtime maps in previous kernel should |
804 | * be passed in via setup_data. In that case runtime ranges will be mapped |
805 | * to the same virtual addresses as the first kernel, see |
806 | * kexec_enter_virtual_mode(). |
807 | */ |
808 | static void __init __efi_enter_virtual_mode(void) |
809 | { |
810 | int count = 0, pg_shift = 0; |
811 | void *new_memmap = NULL; |
812 | efi_status_t status; |
813 | unsigned long pa; |
814 | |
815 | if (efi_alloc_page_tables()) { |
816 | pr_err("Failed to allocate EFI page tables\n" ); |
817 | goto err; |
818 | } |
819 | |
820 | efi_merge_regions(); |
821 | new_memmap = efi_map_regions(count: &count, pg_shift: &pg_shift); |
822 | if (!new_memmap) { |
823 | pr_err("Error reallocating memory, EFI runtime non-functional!\n" ); |
824 | goto err; |
825 | } |
826 | |
827 | pa = __pa(new_memmap); |
828 | |
829 | /* |
830 | * Unregister the early EFI memmap from efi_init() and install |
831 | * the new EFI memory map that we are about to pass to the |
832 | * firmware via SetVirtualAddressMap(). |
833 | */ |
834 | efi_memmap_unmap(); |
835 | |
836 | if (efi_memmap_init_late(addr: pa, size: efi.memmap.desc_size * count)) { |
837 | pr_err("Failed to remap late EFI memory map\n" ); |
838 | goto err; |
839 | } |
840 | |
841 | if (efi_enabled(EFI_DBG)) { |
842 | pr_info("EFI runtime memory map:\n" ); |
843 | efi_print_memmap(); |
844 | } |
845 | |
846 | if (efi_setup_page_tables(pa_memmap: pa, num_pages: 1 << pg_shift)) |
847 | goto err; |
848 | |
849 | efi_sync_low_kernel_mappings(); |
850 | |
851 | status = efi_set_virtual_address_map(memory_map_size: efi.memmap.desc_size * count, |
852 | descriptor_size: efi.memmap.desc_size, |
853 | descriptor_version: efi.memmap.desc_version, |
854 | virtual_map: (efi_memory_desc_t *)pa, |
855 | systab_phys: efi_systab_phys); |
856 | if (status != EFI_SUCCESS) { |
857 | pr_err("Unable to switch EFI into virtual mode (status=%lx)!\n" , |
858 | status); |
859 | goto err; |
860 | } |
861 | |
862 | efi_check_for_embedded_firmwares(); |
863 | efi_free_boot_services(); |
864 | |
865 | if (!efi_is_mixed()) |
866 | efi_native_runtime_setup(); |
867 | else |
868 | efi_thunk_runtime_setup(); |
869 | |
870 | /* |
871 | * Apply more restrictive page table mapping attributes now that |
872 | * SVAM() has been called and the firmware has performed all |
873 | * necessary relocation fixups for the new virtual addresses. |
874 | */ |
875 | efi_runtime_update_mappings(); |
876 | |
877 | /* clean DUMMY object */ |
878 | efi_delete_dummy_variable(); |
879 | return; |
880 | |
881 | err: |
882 | clear_bit(EFI_RUNTIME_SERVICES, addr: &efi.flags); |
883 | } |
884 | |
885 | void __init efi_enter_virtual_mode(void) |
886 | { |
887 | if (efi_enabled(EFI_PARAVIRT)) |
888 | return; |
889 | |
890 | efi.runtime = (efi_runtime_services_t *)efi_runtime; |
891 | |
892 | if (efi_setup) |
893 | kexec_enter_virtual_mode(); |
894 | else |
895 | __efi_enter_virtual_mode(); |
896 | |
897 | efi_dump_pagetable(); |
898 | } |
899 | |
900 | bool efi_is_table_address(unsigned long phys_addr) |
901 | { |
902 | unsigned int i; |
903 | |
904 | if (phys_addr == EFI_INVALID_TABLE_ADDR) |
905 | return false; |
906 | |
907 | for (i = 0; i < ARRAY_SIZE(efi_tables); i++) |
908 | if (*(efi_tables[i]) == phys_addr) |
909 | return true; |
910 | |
911 | return false; |
912 | } |
913 | |
914 | char *efi_systab_show_arch(char *str) |
915 | { |
916 | if (uga_phys != EFI_INVALID_TABLE_ADDR) |
917 | str += sprintf(buf: str, fmt: "UGA=0x%lx\n" , uga_phys); |
918 | return str; |
919 | } |
920 | |
921 | #define EFI_FIELD(var) efi_ ## var |
922 | |
923 | #define EFI_ATTR_SHOW(name) \ |
924 | static ssize_t name##_show(struct kobject *kobj, \ |
925 | struct kobj_attribute *attr, char *buf) \ |
926 | { \ |
927 | return sprintf(buf, "0x%lx\n", EFI_FIELD(name)); \ |
928 | } |
929 | |
930 | EFI_ATTR_SHOW(fw_vendor); |
931 | EFI_ATTR_SHOW(runtime); |
932 | EFI_ATTR_SHOW(config_table); |
933 | |
934 | struct kobj_attribute efi_attr_fw_vendor = __ATTR_RO(fw_vendor); |
935 | struct kobj_attribute efi_attr_runtime = __ATTR_RO(runtime); |
936 | struct kobj_attribute efi_attr_config_table = __ATTR_RO(config_table); |
937 | |
938 | umode_t efi_attr_is_visible(struct kobject *kobj, struct attribute *attr, int n) |
939 | { |
940 | if (attr == &efi_attr_fw_vendor.attr) { |
941 | if (efi_enabled(EFI_PARAVIRT) || |
942 | efi_fw_vendor == EFI_INVALID_TABLE_ADDR) |
943 | return 0; |
944 | } else if (attr == &efi_attr_runtime.attr) { |
945 | if (efi_runtime == EFI_INVALID_TABLE_ADDR) |
946 | return 0; |
947 | } else if (attr == &efi_attr_config_table.attr) { |
948 | if (efi_config_table == EFI_INVALID_TABLE_ADDR) |
949 | return 0; |
950 | } |
951 | return attr->mode; |
952 | } |
953 | |
954 | enum efi_secureboot_mode __x86_ima_efi_boot_mode(void) |
955 | { |
956 | return boot_params.secure_boot; |
957 | } |
958 | |