arch/x86/platform/efi/efi.c

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