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