~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/x86/platform/efi/efi.c

Version: ~ [ linux-5.3 ] ~ [ linux-5.2.15 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.73 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.144 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.193 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.193 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.73 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * Common EFI (Extensible Firmware Interface) support functions
  3  * Based on Extensible Firmware Interface Specification version 1.0
  4  *
  5  * Copyright (C) 1999 VA Linux Systems
  6  * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
  7  * Copyright (C) 1999-2002 Hewlett-Packard Co.
  8  *      David Mosberger-Tang <davidm@hpl.hp.com>
  9  *      Stephane Eranian <eranian@hpl.hp.com>
 10  * Copyright (C) 2005-2008 Intel Co.
 11  *      Fenghua Yu <fenghua.yu@intel.com>
 12  *      Bibo Mao <bibo.mao@intel.com>
 13  *      Chandramouli Narayanan <mouli@linux.intel.com>
 14  *      Huang Ying <ying.huang@intel.com>
 15  * Copyright (C) 2013 SuSE Labs
 16  *      Borislav Petkov <bp@suse.de> - runtime services VA mapping
 17  *
 18  * Copied from efi_32.c to eliminate the duplicated code between EFI
 19  * 32/64 support code. --ying 2007-10-26
 20  *
 21  * All EFI Runtime Services are not implemented yet as EFI only
 22  * supports physical mode addressing on SoftSDV. This is to be fixed
 23  * in a future version.  --drummond 1999-07-20
 24  *
 25  * Implemented EFI runtime services and virtual mode calls.  --davidm
 26  *
 27  * Goutham Rao: <goutham.rao@intel.com>
 28  *      Skip non-WB memory and ignore empty memory ranges.
 29  */
 30 
 31 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 32 
 33 #include <linux/kernel.h>
 34 #include <linux/init.h>
 35 #include <linux/efi.h>
 36 #include <linux/efi-bgrt.h>
 37 #include <linux/export.h>
 38 #include <linux/bootmem.h>
 39 #include <linux/slab.h>
 40 #include <linux/memblock.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/time.h>
 51 #include <asm/cacheflush.h>
 52 #include <asm/tlbflush.h>
 53 #include <asm/x86_init.h>
 54 #include <asm/rtc.h>
 55 #include <asm/uv/uv.h>
 56 
 57 #define EFI_DEBUG
 58 
 59 struct efi_memory_map memmap;
 60 
 61 static struct efi efi_phys __initdata;
 62 static efi_system_table_t efi_systab __initdata;
 63 
 64 static efi_config_table_type_t arch_tables[] __initdata = {
 65 #ifdef CONFIG_X86_UV
 66         {UV_SYSTEM_TABLE_GUID, "UVsystab", &efi.uv_systab},
 67 #endif
 68         {NULL_GUID, NULL, NULL},
 69 };
 70 
 71 u64 efi_setup;          /* efi setup_data physical address */
 72 
 73 static int add_efi_memmap __initdata;
 74 static int __init setup_add_efi_memmap(char *arg)
 75 {
 76         add_efi_memmap = 1;
 77         return 0;
 78 }
 79 early_param("add_efi_memmap", setup_add_efi_memmap);
 80 
 81 static efi_status_t __init phys_efi_set_virtual_address_map(
 82         unsigned long memory_map_size,
 83         unsigned long descriptor_size,
 84         u32 descriptor_version,
 85         efi_memory_desc_t *virtual_map)
 86 {
 87         efi_status_t status;
 88         unsigned long flags;
 89         pgd_t *save_pgd;
 90 
 91         save_pgd = efi_call_phys_prolog();
 92 
 93         /* Disable interrupts around EFI calls: */
 94         local_irq_save(flags);
 95         status = efi_call_phys(efi_phys.set_virtual_address_map,
 96                                memory_map_size, descriptor_size,
 97                                descriptor_version, virtual_map);
 98         local_irq_restore(flags);
 99 
100         efi_call_phys_epilog(save_pgd);
101 
102         return status;
103 }
104 
105 void efi_get_time(struct timespec *now)
106 {
107         efi_status_t status;
108         efi_time_t eft;
109         efi_time_cap_t cap;
110 
111         status = efi.get_time(&eft, &cap);
112         if (status != EFI_SUCCESS)
113                 pr_err("Oops: efitime: can't read time!\n");
114 
115         now->tv_sec = mktime(eft.year, eft.month, eft.day, eft.hour,
116                              eft.minute, eft.second);
117         now->tv_nsec = 0;
118 }
119 
120 void __init efi_find_mirror(void)
121 {
122         void *p;
123         u64 mirror_size = 0, total_size = 0;
124 
125         for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
126                 efi_memory_desc_t *md = p;
127                 unsigned long long start = md->phys_addr;
128                 unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;
129 
130                 total_size += size;
131                 if (md->attribute & EFI_MEMORY_MORE_RELIABLE) {
132                         memblock_mark_mirror(start, size);
133                         mirror_size += size;
134                 }
135         }
136         if (mirror_size)
137                 pr_info("Memory: %lldM/%lldM mirrored memory\n",
138                         mirror_size>>20, total_size>>20);
139 }
140 
141 /*
142  * Tell the kernel about the EFI memory map.  This might include
143  * more than the max 128 entries that can fit in the e820 legacy
144  * (zeropage) memory map.
145  */
146 
147 static void __init do_add_efi_memmap(void)
148 {
149         void *p;
150 
151         for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
152                 efi_memory_desc_t *md = p;
153                 unsigned long long start = md->phys_addr;
154                 unsigned long long size = md->num_pages << EFI_PAGE_SHIFT;
155                 int e820_type;
156 
157                 switch (md->type) {
158                 case EFI_LOADER_CODE:
159                 case EFI_LOADER_DATA:
160                 case EFI_BOOT_SERVICES_CODE:
161                 case EFI_BOOT_SERVICES_DATA:
162                 case EFI_CONVENTIONAL_MEMORY:
163                         if (md->attribute & EFI_MEMORY_WB)
164                                 e820_type = E820_RAM;
165                         else
166                                 e820_type = E820_RESERVED;
167                         break;
168                 case EFI_ACPI_RECLAIM_MEMORY:
169                         e820_type = E820_ACPI;
170                         break;
171                 case EFI_ACPI_MEMORY_NVS:
172                         e820_type = E820_NVS;
173                         break;
174                 case EFI_UNUSABLE_MEMORY:
175                         e820_type = E820_UNUSABLE;
176                         break;
177                 case EFI_PERSISTENT_MEMORY:
178                         e820_type = E820_PMEM;
179                         break;
180                 default:
181                         /*
182                          * EFI_RESERVED_TYPE EFI_RUNTIME_SERVICES_CODE
183                          * EFI_RUNTIME_SERVICES_DATA EFI_MEMORY_MAPPED_IO
184                          * EFI_MEMORY_MAPPED_IO_PORT_SPACE EFI_PAL_CODE
185                          */
186                         e820_type = E820_RESERVED;
187                         break;
188                 }
189                 e820_add_region(start, size, e820_type);
190         }
191         sanitize_e820_map(e820.map, ARRAY_SIZE(e820.map), &e820.nr_map);
192 }
193 
194 int __init efi_memblock_x86_reserve_range(void)
195 {
196         struct efi_info *e = &boot_params.efi_info;
197         unsigned long pmap;
198 
199         if (efi_enabled(EFI_PARAVIRT))
200                 return 0;
201 
202 #ifdef CONFIG_X86_32
203         /* Can't handle data above 4GB at this time */
204         if (e->efi_memmap_hi) {
205                 pr_err("Memory map is above 4GB, disabling EFI.\n");
206                 return -EINVAL;
207         }
208         pmap =  e->efi_memmap;
209 #else
210         pmap = (e->efi_memmap | ((__u64)e->efi_memmap_hi << 32));
211 #endif
212         memmap.phys_map         = (void *)pmap;
213         memmap.nr_map           = e->efi_memmap_size /
214                                   e->efi_memdesc_size;
215         memmap.desc_size        = e->efi_memdesc_size;
216         memmap.desc_version     = e->efi_memdesc_version;
217 
218         memblock_reserve(pmap, memmap.nr_map * memmap.desc_size);
219 
220         efi.memmap = &memmap;
221 
222         return 0;
223 }
224 
225 static void __init print_efi_memmap(void)
226 {
227 #ifdef EFI_DEBUG
228         efi_memory_desc_t *md;
229         void *p;
230         int i;
231 
232         for (p = memmap.map, i = 0;
233              p < memmap.map_end;
234              p += memmap.desc_size, i++) {
235                 char buf[64];
236 
237                 md = p;
238                 pr_info("mem%02u: %s range=[0x%016llx-0x%016llx) (%lluMB)\n",
239                         i, efi_md_typeattr_format(buf, sizeof(buf), md),
240                         md->phys_addr,
241                         md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT),
242                         (md->num_pages >> (20 - EFI_PAGE_SHIFT)));
243         }
244 #endif  /*  EFI_DEBUG  */
245 }
246 
247 void __init efi_unmap_memmap(void)
248 {
249         clear_bit(EFI_MEMMAP, &efi.flags);
250         if (memmap.map) {
251                 early_memunmap(memmap.map, memmap.nr_map * memmap.desc_size);
252                 memmap.map = NULL;
253         }
254 }
255 
256 static int __init efi_systab_init(void *phys)
257 {
258         if (efi_enabled(EFI_64BIT)) {
259                 efi_system_table_64_t *systab64;
260                 struct efi_setup_data *data = NULL;
261                 u64 tmp = 0;
262 
263                 if (efi_setup) {
264                         data = early_memremap(efi_setup, sizeof(*data));
265                         if (!data)
266                                 return -ENOMEM;
267                 }
268                 systab64 = early_memremap((unsigned long)phys,
269                                          sizeof(*systab64));
270                 if (systab64 == NULL) {
271                         pr_err("Couldn't map the system table!\n");
272                         if (data)
273                                 early_memunmap(data, sizeof(*data));
274                         return -ENOMEM;
275                 }
276 
277                 efi_systab.hdr = systab64->hdr;
278                 efi_systab.fw_vendor = data ? (unsigned long)data->fw_vendor :
279                                               systab64->fw_vendor;
280                 tmp |= data ? data->fw_vendor : systab64->fw_vendor;
281                 efi_systab.fw_revision = systab64->fw_revision;
282                 efi_systab.con_in_handle = systab64->con_in_handle;
283                 tmp |= systab64->con_in_handle;
284                 efi_systab.con_in = systab64->con_in;
285                 tmp |= systab64->con_in;
286                 efi_systab.con_out_handle = systab64->con_out_handle;
287                 tmp |= systab64->con_out_handle;
288                 efi_systab.con_out = systab64->con_out;
289                 tmp |= systab64->con_out;
290                 efi_systab.stderr_handle = systab64->stderr_handle;
291                 tmp |= systab64->stderr_handle;
292                 efi_systab.stderr = systab64->stderr;
293                 tmp |= systab64->stderr;
294                 efi_systab.runtime = data ?
295                                      (void *)(unsigned long)data->runtime :
296                                      (void *)(unsigned long)systab64->runtime;
297                 tmp |= data ? data->runtime : systab64->runtime;
298                 efi_systab.boottime = (void *)(unsigned long)systab64->boottime;
299                 tmp |= systab64->boottime;
300                 efi_systab.nr_tables = systab64->nr_tables;
301                 efi_systab.tables = data ? (unsigned long)data->tables :
302                                            systab64->tables;
303                 tmp |= data ? data->tables : systab64->tables;
304 
305                 early_memunmap(systab64, sizeof(*systab64));
306                 if (data)
307                         early_memunmap(data, sizeof(*data));
308 #ifdef CONFIG_X86_32
309                 if (tmp >> 32) {
310                         pr_err("EFI data located above 4GB, disabling EFI.\n");
311                         return -EINVAL;
312                 }
313 #endif
314         } else {
315                 efi_system_table_32_t *systab32;
316 
317                 systab32 = early_memremap((unsigned long)phys,
318                                          sizeof(*systab32));
319                 if (systab32 == NULL) {
320                         pr_err("Couldn't map the system table!\n");
321                         return -ENOMEM;
322                 }
323 
324                 efi_systab.hdr = systab32->hdr;
325                 efi_systab.fw_vendor = systab32->fw_vendor;
326                 efi_systab.fw_revision = systab32->fw_revision;
327                 efi_systab.con_in_handle = systab32->con_in_handle;
328                 efi_systab.con_in = systab32->con_in;
329                 efi_systab.con_out_handle = systab32->con_out_handle;
330                 efi_systab.con_out = systab32->con_out;
331                 efi_systab.stderr_handle = systab32->stderr_handle;
332                 efi_systab.stderr = systab32->stderr;
333                 efi_systab.runtime = (void *)(unsigned long)systab32->runtime;
334                 efi_systab.boottime = (void *)(unsigned long)systab32->boottime;
335                 efi_systab.nr_tables = systab32->nr_tables;
336                 efi_systab.tables = systab32->tables;
337 
338                 early_memunmap(systab32, sizeof(*systab32));
339         }
340 
341         efi.systab = &efi_systab;
342 
343         /*
344          * Verify the EFI Table
345          */
346         if (efi.systab->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE) {
347                 pr_err("System table signature incorrect!\n");
348                 return -EINVAL;
349         }
350         if ((efi.systab->hdr.revision >> 16) == 0)
351                 pr_err("Warning: System table version %d.%02d, expected 1.00 or greater!\n",
352                        efi.systab->hdr.revision >> 16,
353                        efi.systab->hdr.revision & 0xffff);
354 
355         set_bit(EFI_SYSTEM_TABLES, &efi.flags);
356 
357         return 0;
358 }
359 
360 static int __init efi_runtime_init32(void)
361 {
362         efi_runtime_services_32_t *runtime;
363 
364         runtime = early_memremap((unsigned long)efi.systab->runtime,
365                         sizeof(efi_runtime_services_32_t));
366         if (!runtime) {
367                 pr_err("Could not map the runtime service table!\n");
368                 return -ENOMEM;
369         }
370 
371         /*
372          * We will only need *early* access to the SetVirtualAddressMap
373          * EFI runtime service. All other runtime services will be called
374          * via the virtual mapping.
375          */
376         efi_phys.set_virtual_address_map =
377                         (efi_set_virtual_address_map_t *)
378                         (unsigned long)runtime->set_virtual_address_map;
379         early_memunmap(runtime, sizeof(efi_runtime_services_32_t));
380 
381         return 0;
382 }
383 
384 static int __init efi_runtime_init64(void)
385 {
386         efi_runtime_services_64_t *runtime;
387 
388         runtime = early_memremap((unsigned long)efi.systab->runtime,
389                         sizeof(efi_runtime_services_64_t));
390         if (!runtime) {
391                 pr_err("Could not map the runtime service table!\n");
392                 return -ENOMEM;
393         }
394 
395         /*
396          * We will only need *early* access to the SetVirtualAddressMap
397          * EFI runtime service. All other runtime services will be called
398          * via the virtual mapping.
399          */
400         efi_phys.set_virtual_address_map =
401                         (efi_set_virtual_address_map_t *)
402                         (unsigned long)runtime->set_virtual_address_map;
403         early_memunmap(runtime, sizeof(efi_runtime_services_64_t));
404 
405         return 0;
406 }
407 
408 static int __init efi_runtime_init(void)
409 {
410         int rv;
411 
412         /*
413          * Check out the runtime services table. We need to map
414          * the runtime services table so that we can grab the physical
415          * address of several of the EFI runtime functions, needed to
416          * set the firmware into virtual mode.
417          *
418          * When EFI_PARAVIRT is in force then we could not map runtime
419          * service memory region because we do not have direct access to it.
420          * However, runtime services are available through proxy functions
421          * (e.g. in case of Xen dom0 EFI implementation they call special
422          * hypercall which executes relevant EFI functions) and that is why
423          * they are always enabled.
424          */
425 
426         if (!efi_enabled(EFI_PARAVIRT)) {
427                 if (efi_enabled(EFI_64BIT))
428                         rv = efi_runtime_init64();
429                 else
430                         rv = efi_runtime_init32();
431 
432                 if (rv)
433                         return rv;
434         }
435 
436         set_bit(EFI_RUNTIME_SERVICES, &efi.flags);
437 
438         return 0;
439 }
440 
441 static int __init efi_memmap_init(void)
442 {
443         if (efi_enabled(EFI_PARAVIRT))
444                 return 0;
445 
446         /* Map the EFI memory map */
447         memmap.map = early_memremap((unsigned long)memmap.phys_map,
448                                    memmap.nr_map * memmap.desc_size);
449         if (memmap.map == NULL) {
450                 pr_err("Could not map the memory map!\n");
451                 return -ENOMEM;
452         }
453         memmap.map_end = memmap.map + (memmap.nr_map * memmap.desc_size);
454 
455         if (add_efi_memmap)
456                 do_add_efi_memmap();
457 
458         set_bit(EFI_MEMMAP, &efi.flags);
459 
460         return 0;
461 }
462 
463 void __init efi_init(void)
464 {
465         efi_char16_t *c16;
466         char vendor[100] = "unknown";
467         int i = 0;
468         void *tmp;
469 
470 #ifdef CONFIG_X86_32
471         if (boot_params.efi_info.efi_systab_hi ||
472             boot_params.efi_info.efi_memmap_hi) {
473                 pr_info("Table located above 4GB, disabling EFI.\n");
474                 return;
475         }
476         efi_phys.systab = (efi_system_table_t *)boot_params.efi_info.efi_systab;
477 #else
478         efi_phys.systab = (efi_system_table_t *)
479                           (boot_params.efi_info.efi_systab |
480                           ((__u64)boot_params.efi_info.efi_systab_hi<<32));
481 #endif
482 
483         if (efi_systab_init(efi_phys.systab))
484                 return;
485 
486         efi.config_table = (unsigned long)efi.systab->tables;
487         efi.fw_vendor    = (unsigned long)efi.systab->fw_vendor;
488         efi.runtime      = (unsigned long)efi.systab->runtime;
489 
490         /*
491          * Show what we know for posterity
492          */
493         c16 = tmp = early_memremap(efi.systab->fw_vendor, 2);
494         if (c16) {
495                 for (i = 0; i < sizeof(vendor) - 1 && *c16; ++i)
496                         vendor[i] = *c16++;
497                 vendor[i] = '\0';
498         } else
499                 pr_err("Could not map the firmware vendor!\n");
500         early_memunmap(tmp, 2);
501 
502         pr_info("EFI v%u.%.02u by %s\n",
503                 efi.systab->hdr.revision >> 16,
504                 efi.systab->hdr.revision & 0xffff, vendor);
505 
506         if (efi_reuse_config(efi.systab->tables, efi.systab->nr_tables))
507                 return;
508 
509         if (efi_config_init(arch_tables))
510                 return;
511 
512         /*
513          * Note: We currently don't support runtime services on an EFI
514          * that doesn't match the kernel 32/64-bit mode.
515          */
516 
517         if (!efi_runtime_supported())
518                 pr_info("No EFI runtime due to 32/64-bit mismatch with kernel\n");
519         else {
520                 if (efi_runtime_disabled() || efi_runtime_init())
521                         return;
522         }
523         if (efi_memmap_init())
524                 return;
525 
526         if (efi_enabled(EFI_DBG))
527                 print_efi_memmap();
528 
529         efi_esrt_init();
530 }
531 
532 void __init efi_late_init(void)
533 {
534         efi_bgrt_init();
535 }
536 
537 void __init efi_set_executable(efi_memory_desc_t *md, bool executable)
538 {
539         u64 addr, npages;
540 
541         addr = md->virt_addr;
542         npages = md->num_pages;
543 
544         memrange_efi_to_native(&addr, &npages);
545 
546         if (executable)
547                 set_memory_x(addr, npages);
548         else
549                 set_memory_nx(addr, npages);
550 }
551 
552 void __init runtime_code_page_mkexec(void)
553 {
554         efi_memory_desc_t *md;
555         void *p;
556 
557         /* Make EFI runtime service code area executable */
558         for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
559                 md = p;
560 
561                 if (md->type != EFI_RUNTIME_SERVICES_CODE)
562                         continue;
563 
564                 efi_set_executable(md, true);
565         }
566 }
567 
568 void __init efi_memory_uc(u64 addr, unsigned long size)
569 {
570         unsigned long page_shift = 1UL << EFI_PAGE_SHIFT;
571         u64 npages;
572 
573         npages = round_up(size, page_shift) / page_shift;
574         memrange_efi_to_native(&addr, &npages);
575         set_memory_uc(addr, npages);
576 }
577 
578 void __init old_map_region(efi_memory_desc_t *md)
579 {
580         u64 start_pfn, end_pfn, end;
581         unsigned long size;
582         void *va;
583 
584         start_pfn = PFN_DOWN(md->phys_addr);
585         size      = md->num_pages << PAGE_SHIFT;
586         end       = md->phys_addr + size;
587         end_pfn   = PFN_UP(end);
588 
589         if (pfn_range_is_mapped(start_pfn, end_pfn)) {
590                 va = __va(md->phys_addr);
591 
592                 if (!(md->attribute & EFI_MEMORY_WB))
593                         efi_memory_uc((u64)(unsigned long)va, size);
594         } else
595                 va = efi_ioremap(md->phys_addr, size,
596                                  md->type, md->attribute);
597 
598         md->virt_addr = (u64) (unsigned long) va;
599         if (!va)
600                 pr_err("ioremap of 0x%llX failed!\n",
601                        (unsigned long long)md->phys_addr);
602 }
603 
604 /* Merge contiguous regions of the same type and attribute */
605 static void __init efi_merge_regions(void)
606 {
607         void *p;
608         efi_memory_desc_t *md, *prev_md = NULL;
609 
610         for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
611                 u64 prev_size;
612                 md = p;
613 
614                 if (!prev_md) {
615                         prev_md = md;
616                         continue;
617                 }
618 
619                 if (prev_md->type != md->type ||
620                     prev_md->attribute != md->attribute) {
621                         prev_md = md;
622                         continue;
623                 }
624 
625                 prev_size = prev_md->num_pages << EFI_PAGE_SHIFT;
626 
627                 if (md->phys_addr == (prev_md->phys_addr + prev_size)) {
628                         prev_md->num_pages += md->num_pages;
629                         md->type = EFI_RESERVED_TYPE;
630                         md->attribute = 0;
631                         continue;
632                 }
633                 prev_md = md;
634         }
635 }
636 
637 static void __init get_systab_virt_addr(efi_memory_desc_t *md)
638 {
639         unsigned long size;
640         u64 end, systab;
641 
642         size = md->num_pages << EFI_PAGE_SHIFT;
643         end = md->phys_addr + size;
644         systab = (u64)(unsigned long)efi_phys.systab;
645         if (md->phys_addr <= systab && systab < end) {
646                 systab += md->virt_addr - md->phys_addr;
647                 efi.systab = (efi_system_table_t *)(unsigned long)systab;
648         }
649 }
650 
651 static void __init save_runtime_map(void)
652 {
653 #ifdef CONFIG_KEXEC_CORE
654         efi_memory_desc_t *md;
655         void *tmp, *p, *q = NULL;
656         int count = 0;
657 
658         if (efi_enabled(EFI_OLD_MEMMAP))
659                 return;
660 
661         for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
662                 md = p;
663 
664                 if (!(md->attribute & EFI_MEMORY_RUNTIME) ||
665                     (md->type == EFI_BOOT_SERVICES_CODE) ||
666                     (md->type == EFI_BOOT_SERVICES_DATA))
667                         continue;
668                 tmp = krealloc(q, (count + 1) * memmap.desc_size, GFP_KERNEL);
669                 if (!tmp)
670                         goto out;
671                 q = tmp;
672 
673                 memcpy(q + count * memmap.desc_size, md, memmap.desc_size);
674                 count++;
675         }
676 
677         efi_runtime_map_setup(q, count, memmap.desc_size);
678         return;
679 
680 out:
681         kfree(q);
682         pr_err("Error saving runtime map, efi runtime on kexec non-functional!!\n");
683 #endif
684 }
685 
686 static void *realloc_pages(void *old_memmap, int old_shift)
687 {
688         void *ret;
689 
690         ret = (void *)__get_free_pages(GFP_KERNEL, old_shift + 1);
691         if (!ret)
692                 goto out;
693 
694         /*
695          * A first-time allocation doesn't have anything to copy.
696          */
697         if (!old_memmap)
698                 return ret;
699 
700         memcpy(ret, old_memmap, PAGE_SIZE << old_shift);
701 
702 out:
703         free_pages((unsigned long)old_memmap, old_shift);
704         return ret;
705 }
706 
707 /*
708  * Iterate the EFI memory map in reverse order because the regions
709  * will be mapped top-down. The end result is the same as if we had
710  * mapped things forward, but doesn't require us to change the
711  * existing implementation of efi_map_region().
712  */
713 static inline void *efi_map_next_entry_reverse(void *entry)
714 {
715         /* Initial call */
716         if (!entry)
717                 return memmap.map_end - memmap.desc_size;
718 
719         entry -= memmap.desc_size;
720         if (entry < memmap.map)
721                 return NULL;
722 
723         return entry;
724 }
725 
726 /*
727  * efi_map_next_entry - Return the next EFI memory map descriptor
728  * @entry: Previous EFI memory map descriptor
729  *
730  * This is a helper function to iterate over the EFI memory map, which
731  * we do in different orders depending on the current configuration.
732  *
733  * To begin traversing the memory map @entry must be %NULL.
734  *
735  * Returns %NULL when we reach the end of the memory map.
736  */
737 static void *efi_map_next_entry(void *entry)
738 {
739         if (!efi_enabled(EFI_OLD_MEMMAP) && efi_enabled(EFI_64BIT)) {
740                 /*
741                  * Starting in UEFI v2.5 the EFI_PROPERTIES_TABLE
742                  * config table feature requires us to map all entries
743                  * in the same order as they appear in the EFI memory
744                  * map. That is to say, entry N must have a lower
745                  * virtual address than entry N+1. This is because the
746                  * firmware toolchain leaves relative references in
747                  * the code/data sections, which are split and become
748                  * separate EFI memory regions. Mapping things
749                  * out-of-order leads to the firmware accessing
750                  * unmapped addresses.
751                  *
752                  * Since we need to map things this way whether or not
753                  * the kernel actually makes use of
754                  * EFI_PROPERTIES_TABLE, let's just switch to this
755                  * scheme by default for 64-bit.
756                  */
757                 return efi_map_next_entry_reverse(entry);
758         }
759 
760         /* Initial call */
761         if (!entry)
762                 return memmap.map;
763 
764         entry += memmap.desc_size;
765         if (entry >= memmap.map_end)
766                 return NULL;
767 
768         return entry;
769 }
770 
771 /*
772  * Map the efi memory ranges of the runtime services and update new_mmap with
773  * virtual addresses.
774  */
775 static void * __init efi_map_regions(int *count, int *pg_shift)
776 {
777         void *p, *new_memmap = NULL;
778         unsigned long left = 0;
779         efi_memory_desc_t *md;
780 
781         p = NULL;
782         while ((p = efi_map_next_entry(p))) {
783                 md = p;
784                 if (!(md->attribute & EFI_MEMORY_RUNTIME)) {
785 #ifdef CONFIG_X86_64
786                         if (md->type != EFI_BOOT_SERVICES_CODE &&
787                             md->type != EFI_BOOT_SERVICES_DATA)
788 #endif
789                                 continue;
790                 }
791 
792                 efi_map_region(md);
793                 get_systab_virt_addr(md);
794 
795                 if (left < memmap.desc_size) {
796                         new_memmap = realloc_pages(new_memmap, *pg_shift);
797                         if (!new_memmap)
798                                 return NULL;
799 
800                         left += PAGE_SIZE << *pg_shift;
801                         (*pg_shift)++;
802                 }
803 
804                 memcpy(new_memmap + (*count * memmap.desc_size), md,
805                        memmap.desc_size);
806 
807                 left -= memmap.desc_size;
808                 (*count)++;
809         }
810 
811         return new_memmap;
812 }
813 
814 static void __init kexec_enter_virtual_mode(void)
815 {
816 #ifdef CONFIG_KEXEC_CORE
817         efi_memory_desc_t *md;
818         void *p;
819 
820         efi.systab = NULL;
821 
822         /*
823          * We don't do virtual mode, since we don't do runtime services, on
824          * non-native EFI
825          */
826         if (!efi_is_native()) {
827                 efi_unmap_memmap();
828                 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
829                 return;
830         }
831 
832         /*
833         * Map efi regions which were passed via setup_data. The virt_addr is a
834         * fixed addr which was used in first kernel of a kexec boot.
835         */
836         for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
837                 md = p;
838                 efi_map_region_fixed(md); /* FIXME: add error handling */
839                 get_systab_virt_addr(md);
840         }
841 
842         save_runtime_map();
843 
844         BUG_ON(!efi.systab);
845 
846         efi_sync_low_kernel_mappings();
847 
848         /*
849          * Now that EFI is in virtual mode, update the function
850          * pointers in the runtime service table to the new virtual addresses.
851          *
852          * Call EFI services through wrapper functions.
853          */
854         efi.runtime_version = efi_systab.hdr.revision;
855 
856         efi_native_runtime_setup();
857 
858         efi.set_virtual_address_map = NULL;
859 
860         if (efi_enabled(EFI_OLD_MEMMAP) && (__supported_pte_mask & _PAGE_NX))
861                 runtime_code_page_mkexec();
862 
863         /* clean DUMMY object */
864         efi_delete_dummy_variable();
865 #endif
866 }
867 
868 /*
869  * This function will switch the EFI runtime services to virtual mode.
870  * Essentially, we look through the EFI memmap and map every region that
871  * has the runtime attribute bit set in its memory descriptor into the
872  * ->trampoline_pgd page table using a top-down VA allocation scheme.
873  *
874  * The old method which used to update that memory descriptor with the
875  * virtual address obtained from ioremap() is still supported when the
876  * kernel is booted with efi=old_map on its command line. Same old
877  * method enabled the runtime services to be called without having to
878  * thunk back into physical mode for every invocation.
879  *
880  * The new method does a pagetable switch in a preemption-safe manner
881  * so that we're in a different address space when calling a runtime
882  * function. For function arguments passing we do copy the PGDs of the
883  * kernel page table into ->trampoline_pgd prior to each call.
884  *
885  * Specially for kexec boot, efi runtime maps in previous kernel should
886  * be passed in via setup_data. In that case runtime ranges will be mapped
887  * to the same virtual addresses as the first kernel, see
888  * kexec_enter_virtual_mode().
889  */
890 static void __init __efi_enter_virtual_mode(void)
891 {
892         int count = 0, pg_shift = 0;
893         void *new_memmap = NULL;
894         efi_status_t status;
895 
896         efi.systab = NULL;
897 
898         efi_merge_regions();
899         new_memmap = efi_map_regions(&count, &pg_shift);
900         if (!new_memmap) {
901                 pr_err("Error reallocating memory, EFI runtime non-functional!\n");
902                 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
903                 return;
904         }
905 
906         save_runtime_map();
907 
908         BUG_ON(!efi.systab);
909 
910         if (efi_setup_page_tables(__pa(new_memmap), 1 << pg_shift)) {
911                 clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
912                 return;
913         }
914 
915         efi_sync_low_kernel_mappings();
916         efi_dump_pagetable();
917 
918         if (efi_is_native()) {
919                 status = phys_efi_set_virtual_address_map(
920                                 memmap.desc_size * count,
921                                 memmap.desc_size,
922                                 memmap.desc_version,
923                                 (efi_memory_desc_t *)__pa(new_memmap));
924         } else {
925                 status = efi_thunk_set_virtual_address_map(
926                                 efi_phys.set_virtual_address_map,
927                                 memmap.desc_size * count,
928                                 memmap.desc_size,
929                                 memmap.desc_version,
930                                 (efi_memory_desc_t *)__pa(new_memmap));
931         }
932 
933         if (status != EFI_SUCCESS) {
934                 pr_alert("Unable to switch EFI into virtual mode (status=%lx)!\n",
935                          status);
936                 panic("EFI call to SetVirtualAddressMap() failed!");
937         }
938 
939         /*
940          * Now that EFI is in virtual mode, update the function
941          * pointers in the runtime service table to the new virtual addresses.
942          *
943          * Call EFI services through wrapper functions.
944          */
945         efi.runtime_version = efi_systab.hdr.revision;
946 
947         if (efi_is_native())
948                 efi_native_runtime_setup();
949         else
950                 efi_thunk_runtime_setup();
951 
952         efi.set_virtual_address_map = NULL;
953 
954         efi_runtime_mkexec();
955 
956         /*
957          * We mapped the descriptor array into the EFI pagetable above but we're
958          * not unmapping it here. Here's why:
959          *
960          * We're copying select PGDs from the kernel page table to the EFI page
961          * table and when we do so and make changes to those PGDs like unmapping
962          * stuff from them, those changes appear in the kernel page table and we
963          * go boom.
964          *
965          * From setup_real_mode():
966          *
967          * ...
968          * trampoline_pgd[0] = init_level4_pgt[pgd_index(__PAGE_OFFSET)].pgd;
969          *
970          * In this particular case, our allocation is in PGD 0 of the EFI page
971          * table but we've copied that PGD from PGD[272] of the EFI page table:
972          *
973          *      pgd_index(__PAGE_OFFSET = 0xffff880000000000) = 272
974          *
975          * where the direct memory mapping in kernel space is.
976          *
977          * new_memmap's VA comes from that direct mapping and thus clearing it,
978          * it would get cleared in the kernel page table too.
979          *
980          * efi_cleanup_page_tables(__pa(new_memmap), 1 << pg_shift);
981          */
982         free_pages((unsigned long)new_memmap, pg_shift);
983 
984         /* clean DUMMY object */
985         efi_delete_dummy_variable();
986 }
987 
988 void __init efi_enter_virtual_mode(void)
989 {
990         if (efi_enabled(EFI_PARAVIRT))
991                 return;
992 
993         if (efi_setup)
994                 kexec_enter_virtual_mode();
995         else
996                 __efi_enter_virtual_mode();
997 }
998 
999 /*
1000  * Convenience functions to obtain memory types and attributes
1001  */
1002 u32 efi_mem_type(unsigned long phys_addr)
1003 {
1004         efi_memory_desc_t *md;
1005         void *p;
1006 
1007         if (!efi_enabled(EFI_MEMMAP))
1008                 return 0;
1009 
1010         for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
1011                 md = p;
1012                 if ((md->phys_addr <= phys_addr) &&
1013                     (phys_addr < (md->phys_addr +
1014                                   (md->num_pages << EFI_PAGE_SHIFT))))
1015                         return md->type;
1016         }
1017         return 0;
1018 }
1019 
1020 u64 efi_mem_attributes(unsigned long phys_addr)
1021 {
1022         efi_memory_desc_t *md;
1023         void *p;
1024 
1025         if (!efi_enabled(EFI_MEMMAP))
1026                 return 0;
1027 
1028         for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
1029                 md = p;
1030                 if ((md->phys_addr <= phys_addr) &&
1031                     (phys_addr < (md->phys_addr +
1032                                   (md->num_pages << EFI_PAGE_SHIFT))))
1033                         return md->attribute;
1034         }
1035         return 0;
1036 }
1037 
1038 static int __init arch_parse_efi_cmdline(char *str)
1039 {
1040         if (!str) {
1041                 pr_warn("need at least one option\n");
1042                 return -EINVAL;
1043         }
1044 
1045         if (parse_option_str(str, "old_map"))
1046                 set_bit(EFI_OLD_MEMMAP, &efi.flags);
1047         if (parse_option_str(str, "debug"))
1048                 set_bit(EFI_DBG, &efi.flags);
1049 
1050         return 0;
1051 }
1052 early_param("efi", arch_parse_efi_cmdline);
1053 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp