Merge branch 'efi-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip

Pull EFI updates from Ingo Molnar:
 "The main changes are:

   - Use separate EFI page tables when executing EFI firmware code.
     This isolates the EFI context from the rest of the kernel, which
     has security and general robustness advantages.  (Matt Fleming)

   - Run regular UEFI firmware with interrupts enabled.  This is already
     the status quo under other OSs.  (Ard Biesheuvel)

   - Various x86 EFI enhancements, such as the use of non-executable
     attributes for EFI memory mappings.  (Sai Praneeth Prakhya)

   - Various arm64 UEFI enhancements.  (Ard Biesheuvel)

   - ... various fixes and cleanups.

  The separate EFI page tables feature got delayed twice already,
  because it's an intrusive change and we didn't feel confident about
  it - third time's the charm we hope!"

* 'efi-core-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (37 commits)
  x86/mm/pat: Fix boot crash when 1GB pages are not supported by the CPU
  x86/efi: Only map kernel text for EFI mixed mode
  x86/efi: Map EFI_MEMORY_{XP,RO} memory region bits to EFI page tables
  x86/mm/pat: Don't implicitly allow _PAGE_RW in kernel_map_pages_in_pgd()
  efi/arm*: Perform hardware compatibility check
  efi/arm64: Check for h/w support before booting a >4 KB granular kernel
  efi/arm: Check for LPAE support before booting a LPAE kernel
  efi/arm-init: Use read-only early mappings
  efi/efistub: Prevent __init annotations from being used
  arm64/vmlinux.lds.S: Handle .init.rodata.xxx and .init.bss sections
  efi/arm64: Drop __init annotation from handle_kernel_image()
  x86/mm/pat: Use _PAGE_GLOBAL bit for EFI page table mappings
  efi/runtime-wrappers: Run UEFI Runtime Services with interrupts enabled
  efi: Reformat GUID tables to follow the format in UEFI spec
  efi: Add Persistent Memory type name
  efi: Add NV memory attribute
  x86/efi: Show actual ending addresses in efi_print_memmap
  x86/efi/bgrt: Don't ignore the BGRT if the 'valid' bit is 0
  efivars: Use to_efivar_entry
  efi: Runtime-wrapper: Get rid of the rtc_lock spinlock
  ...

6 files changed, 268 insertions, 144 deletions

diff --git a/arch/x86/platform/efi/efi-bgrt.c b/arch/x86/platform/efi/efi-bgrt.c
index ea48449b2e63..a2433817c987 100644
--- a/arch/x86/platform/efi/efi-bgrt.c
+++ b/arch/x86/platform/efi/efi-bgrt.c
@@ -10,6 +10,9 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/acpi.h>
@@ -28,8 +31,7 @@ struct bmp_header {
 void __init efi_bgrt_init(void)
 {
         acpi_status status;
-        void __iomem *image;
-        bool ioremapped = false;
+        void *image;
         struct bmp_header bmp_header;
 
         if (acpi_disabled)
@@ -55,11 +57,6 @@ void __init efi_bgrt_init(void)
                        bgrt_tab->status);
                 return;
         }
-        if (bgrt_tab->status != 1) {
-                pr_debug("Ignoring BGRT: invalid status %u (expected 1)\n",
-                         bgrt_tab->status);
-                return;
-        }
         if (bgrt_tab->image_type != 0) {
                 pr_err("Ignoring BGRT: invalid image type %u (expected 0)\n",
                        bgrt_tab->image_type);
@@ -70,20 +67,19 @@ void __init efi_bgrt_init(void)
                 return;
         }
 
-        image = efi_lookup_mapped_addr(bgrt_tab->image_address);
+        image = memremap(bgrt_tab->image_address, sizeof(bmp_header), MEMREMAP_WB);
         if (!image) {
-                image = early_ioremap(bgrt_tab->image_address,
-                                       sizeof(bmp_header));
-                ioremapped = true;
-                if (!image) {
-                        pr_err("Ignoring BGRT: failed to map image header memory\n");
-                        return;
-                }
+                pr_err("Ignoring BGRT: failed to map image header memory\n");
+                return;
         }
 
-        memcpy_fromio(&bmp_header, image, sizeof(bmp_header));
-        if (ioremapped)
-                early_iounmap(image, sizeof(bmp_header));
+        memcpy(&bmp_header, image, sizeof(bmp_header));
+        memunmap(image);
+        if (bmp_header.id != 0x4d42) {
+                pr_err("Ignoring BGRT: Incorrect BMP magic number 0x%x (expected 0x4d42)\n",
+                        bmp_header.id);
+                return;
+        }
         bgrt_image_size = bmp_header.size;
 
         bgrt_image = kmalloc(bgrt_image_size, GFP_KERNEL | __GFP_NOWARN);
@@ -93,18 +89,14 @@ void __init efi_bgrt_init(void)
                 return;
         }
 
-        if (ioremapped) {
-                image = early_ioremap(bgrt_tab->image_address,
-                                       bmp_header.size);
-                if (!image) {
-                        pr_err("Ignoring BGRT: failed to map image memory\n");
-                        kfree(bgrt_image);
-                        bgrt_image = NULL;
-                        return;
-                }
+        image = memremap(bgrt_tab->image_address, bmp_header.size, MEMREMAP_WB);
+        if (!image) {
+                pr_err("Ignoring BGRT: failed to map image memory\n");
+                kfree(bgrt_image);
+                bgrt_image = NULL;
+                return;
         }
 
-        memcpy_fromio(bgrt_image, image, bgrt_image_size);
-        if (ioremapped)
-                early_iounmap(image, bmp_header.size);
+        memcpy(bgrt_image, image, bgrt_image_size);
+        memunmap(image);
 }
diff --git a/arch/x86/platform/efi/efi.c b/arch/x86/platform/efi/efi.c
index ad285404ea7f..994a7df84a7b 100644
--- a/arch/x86/platform/efi/efi.c
+++ b/arch/x86/platform/efi/efi.c
@@ -235,10 +235,10 @@ void __init efi_print_memmap(void)
                 char buf[64];
 
                 md = p;
-                pr_info("mem%02u: %s range=[0x%016llx-0x%016llx) (%lluMB)\n",
+                pr_info("mem%02u: %s range=[0x%016llx-0x%016llx] (%lluMB)\n",
                         i, efi_md_typeattr_format(buf, sizeof(buf), md),
                         md->phys_addr,
-                        md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT),
+                        md->phys_addr + (md->num_pages << EFI_PAGE_SHIFT) - 1,
                         (md->num_pages >> (20 - EFI_PAGE_SHIFT)));
         }
 #endif  /*  EFI_DEBUG  */
@@ -815,6 +815,7 @@ static void __init kexec_enter_virtual_mode(void)
 {
 #ifdef CONFIG_KEXEC_CORE
         efi_memory_desc_t *md;
+        unsigned int num_pages;
         void *p;
 
         efi.systab = NULL;
@@ -829,6 +830,12 @@ static void __init kexec_enter_virtual_mode(void)
                 return;
         }
 
+        if (efi_alloc_page_tables()) {
+                pr_err("Failed to allocate EFI page tables\n");
+                clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
+                return;
+        }
+
         /*
         * Map efi regions which were passed via setup_data. The virt_addr is a
         * fixed addr which was used in first kernel of a kexec boot.
@@ -843,6 +850,14 @@ static void __init kexec_enter_virtual_mode(void)
 
         BUG_ON(!efi.systab);
 
+        num_pages = ALIGN(memmap.nr_map * memmap.desc_size, PAGE_SIZE);
+        num_pages >>= PAGE_SHIFT;
+
+        if (efi_setup_page_tables(memmap.phys_map, num_pages)) {
+                clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
+                return;
+        }
+
         efi_sync_low_kernel_mappings();
 
         /*
@@ -869,7 +884,7 @@ static void __init kexec_enter_virtual_mode(void)
  * This function will switch the EFI runtime services to virtual mode.
  * Essentially, we look through the EFI memmap and map every region that
  * has the runtime attribute bit set in its memory descriptor into the
- * ->trampoline_pgd page table using a top-down VA allocation scheme.
+ * efi_pgd page table.
  *
  * The old method which used to update that memory descriptor with the
  * virtual address obtained from ioremap() is still supported when the
@@ -879,8 +894,8 @@ static void __init kexec_enter_virtual_mode(void)
  *
  * The new method does a pagetable switch in a preemption-safe manner
  * so that we're in a different address space when calling a runtime
- * function. For function arguments passing we do copy the PGDs of the
- * kernel page table into ->trampoline_pgd prior to each call.
+ * function. For function arguments passing we do copy the PUDs of the
+ * kernel page table into efi_pgd prior to each call.
  *
  * Specially for kexec boot, efi runtime maps in previous kernel should
  * be passed in via setup_data. In that case runtime ranges will be mapped
@@ -895,6 +910,12 @@ static void __init __efi_enter_virtual_mode(void)
 
         efi.systab = NULL;
 
+        if (efi_alloc_page_tables()) {
+                pr_err("Failed to allocate EFI page tables\n");
+                clear_bit(EFI_RUNTIME_SERVICES, &efi.flags);
+                return;
+        }
+
         efi_merge_regions();
         new_memmap = efi_map_regions(&count, &pg_shift);
         if (!new_memmap) {
@@ -913,7 +934,6 @@ static void __init __efi_enter_virtual_mode(void)
         }
 
         efi_sync_low_kernel_mappings();
-        efi_dump_pagetable();
 
         if (efi_is_native()) {
                 status = phys_efi_set_virtual_address_map(
@@ -951,31 +971,20 @@ static void __init __efi_enter_virtual_mode(void)
 
         efi.set_virtual_address_map = NULL;
 
-        efi_runtime_mkexec();
+        /*
+         * Apply more restrictive page table mapping attributes now that
+         * SVAM() has been called and the firmware has performed all
+         * necessary relocation fixups for the new virtual addresses.
+         */
+        efi_runtime_update_mappings();
+        efi_dump_pagetable();
 
         /*
-         * We mapped the descriptor array into the EFI pagetable above but we're
-         * not unmapping it here. Here's why:
-         *
-         * We're copying select PGDs from the kernel page table to the EFI page
-         * table and when we do so and make changes to those PGDs like unmapping
-         * stuff from them, those changes appear in the kernel page table and we
-         * go boom.
-         *
-         * From setup_real_mode():
-         *
-         * ...
-         * trampoline_pgd[0] = init_level4_pgt[pgd_index(__PAGE_OFFSET)].pgd;
-         *
-         * In this particular case, our allocation is in PGD 0 of the EFI page
-         * table but we've copied that PGD from PGD[272] of the EFI page table:
-         *
-         *      pgd_index(__PAGE_OFFSET = 0xffff880000000000) = 272
-         *
-         * where the direct memory mapping in kernel space is.
-         *
-         * new_memmap's VA comes from that direct mapping and thus clearing it,
-         * it would get cleared in the kernel page table too.
+         * We mapped the descriptor array into the EFI pagetable above
+         * but we're not unmapping it here because if we're running in
+         * EFI mixed mode we need all of memory to be accessible when
+         * we pass parameters to the EFI runtime services in the
+         * thunking code.
          *
          * efi_cleanup_page_tables(__pa(new_memmap), 1 << pg_shift);
          */
diff --git a/arch/x86/platform/efi/efi_32.c b/arch/x86/platform/efi/efi_32.c
index ed5b67338294..338402b91d2e 100644
--- a/arch/x86/platform/efi/efi_32.c
+++ b/arch/x86/platform/efi/efi_32.c
@@ -38,6 +38,11 @@
  * say 0 - 3G.
  */
 
+int __init efi_alloc_page_tables(void)
+{
+        return 0;
+}
+
 void efi_sync_low_kernel_mappings(void) {}
 void __init efi_dump_pagetable(void) {}
 int __init efi_setup_page_tables(unsigned long pa_memmap, unsigned num_pages)
@@ -85,7 +90,7 @@ void __init efi_call_phys_epilog(pgd_t *save_pgd)
         __flush_tlb_all();
 }
 
-void __init efi_runtime_mkexec(void)
+void __init efi_runtime_update_mappings(void)
 {
         if (__supported_pte_mask & _PAGE_NX)
                 runtime_code_page_mkexec();
diff --git a/arch/x86/platform/efi/efi_64.c b/arch/x86/platform/efi/efi_64.c
index a0ac0f9c307f..49e4dd4a1f58 100644
--- a/arch/x86/platform/efi/efi_64.c
+++ b/arch/x86/platform/efi/efi_64.c
@@ -15,6 +15,8 @@
  *
  */
 
+#define pr_fmt(fmt) "efi: " fmt
+
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/mm.h>
@@ -40,6 +42,7 @@
 #include <asm/fixmap.h>
 #include <asm/realmode.h>
 #include <asm/time.h>
+#include <asm/pgalloc.h>
 
 /*
  * We allocate runtime services regions bottom-up, starting from -4G, i.e.
@@ -47,16 +50,7 @@
  */
 static u64 efi_va = EFI_VA_START;
 
-/*
- * Scratch space used for switching the pagetable in the EFI stub
- */
-struct efi_scratch {
-        u64 r15;
-        u64 prev_cr3;
-        pgd_t *efi_pgt;
-        bool use_pgd;
-        u64 phys_stack;
-} __packed;
+struct efi_scratch efi_scratch;
 
 static void __init early_code_mapping_set_exec(int executable)
 {
@@ -83,8 +77,11 @@ pgd_t * __init efi_call_phys_prolog(void)
         int pgd;
         int n_pgds;
 
-        if (!efi_enabled(EFI_OLD_MEMMAP))
-                return NULL;
+        if (!efi_enabled(EFI_OLD_MEMMAP)) {
+                save_pgd = (pgd_t *)read_cr3();
+                write_cr3((unsigned long)efi_scratch.efi_pgt);
+                goto out;
+        }
 
         early_code_mapping_set_exec(1);
 
@@ -96,6 +93,7 @@ pgd_t * __init efi_call_phys_prolog(void)
                 vaddress = (unsigned long)__va(pgd * PGDIR_SIZE);
                 set_pgd(pgd_offset_k(pgd * PGDIR_SIZE), *pgd_offset_k(vaddress));
         }
+out:
         __flush_tlb_all();
 
         return save_pgd;
@@ -109,8 +107,11 @@ void __init efi_call_phys_epilog(pgd_t *save_pgd)
         int pgd_idx;
         int nr_pgds;
 
-        if (!save_pgd)
+        if (!efi_enabled(EFI_OLD_MEMMAP)) {
+                write_cr3((unsigned long)save_pgd);
+                __flush_tlb_all();
                 return;
+        }
 
         nr_pgds = DIV_ROUND_UP((max_pfn << PAGE_SHIFT) , PGDIR_SIZE);
 
@@ -123,27 +124,98 @@ void __init efi_call_phys_epilog(pgd_t *save_pgd)
         early_code_mapping_set_exec(0);
 }
 
+static pgd_t *efi_pgd;
+
+/*
+ * We need our own copy of the higher levels of the page tables
+ * because we want to avoid inserting EFI region mappings (EFI_VA_END
+ * to EFI_VA_START) into the standard kernel page tables. Everything
+ * else can be shared, see efi_sync_low_kernel_mappings().
+ */
+int __init efi_alloc_page_tables(void)
+{
+        pgd_t *pgd;
+        pud_t *pud;
+        gfp_t gfp_mask;
+
+        if (efi_enabled(EFI_OLD_MEMMAP))
+                return 0;
+
+        gfp_mask = GFP_KERNEL | __GFP_NOTRACK | __GFP_REPEAT | __GFP_ZERO;
+        efi_pgd = (pgd_t *)__get_free_page(gfp_mask);
+        if (!efi_pgd)
+                return -ENOMEM;
+
+        pgd = efi_pgd + pgd_index(EFI_VA_END);
+
+        pud = pud_alloc_one(NULL, 0);
+        if (!pud) {
+                free_page((unsigned long)efi_pgd);
+                return -ENOMEM;
+        }
+
+        pgd_populate(NULL, pgd, pud);
+
+        return 0;
+}
+
 /*
  * Add low kernel mappings for passing arguments to EFI functions.
  */
 void efi_sync_low_kernel_mappings(void)
 {
-        unsigned num_pgds;
-        pgd_t *pgd = (pgd_t *)__va(real_mode_header->trampoline_pgd);
+        unsigned num_entries;
+        pgd_t *pgd_k, *pgd_efi;
+        pud_t *pud_k, *pud_efi;
 
         if (efi_enabled(EFI_OLD_MEMMAP))
                 return;
 
-        num_pgds = pgd_index(MODULES_END - 1) - pgd_index(PAGE_OFFSET);
+        /*
+         * We can share all PGD entries apart from the one entry that
+         * covers the EFI runtime mapping space.
+         *
+         * Make sure the EFI runtime region mappings are guaranteed to
+         * only span a single PGD entry and that the entry also maps
+         * other important kernel regions.
+         */
+        BUILD_BUG_ON(pgd_index(EFI_VA_END) != pgd_index(MODULES_END));
+        BUILD_BUG_ON((EFI_VA_START & PGDIR_MASK) !=
+                        (EFI_VA_END & PGDIR_MASK));
+
+        pgd_efi = efi_pgd + pgd_index(PAGE_OFFSET);
+        pgd_k = pgd_offset_k(PAGE_OFFSET);
 
-        memcpy(pgd + pgd_index(PAGE_OFFSET),
-                init_mm.pgd + pgd_index(PAGE_OFFSET),
-                sizeof(pgd_t) * num_pgds);
+        num_entries = pgd_index(EFI_VA_END) - pgd_index(PAGE_OFFSET);
+        memcpy(pgd_efi, pgd_k, sizeof(pgd_t) * num_entries);
+
+        /*
+         * We share all the PUD entries apart from those that map the
+         * EFI regions. Copy around them.
+         */
+        BUILD_BUG_ON((EFI_VA_START & ~PUD_MASK) != 0);
+        BUILD_BUG_ON((EFI_VA_END & ~PUD_MASK) != 0);
+
+        pgd_efi = efi_pgd + pgd_index(EFI_VA_END);
+        pud_efi = pud_offset(pgd_efi, 0);
+
+        pgd_k = pgd_offset_k(EFI_VA_END);
+        pud_k = pud_offset(pgd_k, 0);
+
+        num_entries = pud_index(EFI_VA_END);
+        memcpy(pud_efi, pud_k, sizeof(pud_t) * num_entries);
+
+        pud_efi = pud_offset(pgd_efi, EFI_VA_START);
+        pud_k = pud_offset(pgd_k, EFI_VA_START);
+
+        num_entries = PTRS_PER_PUD - pud_index(EFI_VA_START);
+        memcpy(pud_efi, pud_k, sizeof(pud_t) * num_entries);
 }
 
 int __init efi_setup_page_tables(unsigned long pa_memmap, unsigned num_pages)
 {
-        unsigned long text;
+        unsigned long pfn, text;
+        efi_memory_desc_t *md;
         struct page *page;
         unsigned npages;
         pgd_t *pgd;
@@ -151,8 +223,8 @@ int __init efi_setup_page_tables(unsigned long pa_memmap, unsigned num_pages)
         if (efi_enabled(EFI_OLD_MEMMAP))
                 return 0;
 
-        efi_scratch.efi_pgt = (pgd_t *)(unsigned long)real_mode_header->trampoline_pgd;
-        pgd = __va(efi_scratch.efi_pgt);
+        efi_scratch.efi_pgt = (pgd_t *)__pa(efi_pgd);
+        pgd = efi_pgd;
 
         /*
          * It can happen that the physical address of new_memmap lands in memory
@@ -160,7 +232,8 @@ int __init efi_setup_page_tables(unsigned long pa_memmap, unsigned num_pages)
          * and ident-map those pages containing the map before calling
          * phys_efi_set_virtual_address_map().
          */
-        if (kernel_map_pages_in_pgd(pgd, pa_memmap, pa_memmap, num_pages, _PAGE_NX)) {
+        pfn = pa_memmap >> PAGE_SHIFT;
+        if (kernel_map_pages_in_pgd(pgd, pfn, pa_memmap, num_pages, _PAGE_NX | _PAGE_RW)) {
                 pr_err("Error ident-mapping new memmap (0x%lx)!\n", pa_memmap);
                 return 1;
         }
@@ -176,6 +249,25 @@ int __init efi_setup_page_tables(unsigned long pa_memmap, unsigned num_pages)
         if (!IS_ENABLED(CONFIG_EFI_MIXED))
                 return 0;
 
+        /*
+         * Map all of RAM so that we can access arguments in the 1:1
+         * mapping when making EFI runtime calls.
+         */
+        for_each_efi_memory_desc(&memmap, md) {
+                if (md->type != EFI_CONVENTIONAL_MEMORY &&
+                    md->type != EFI_LOADER_DATA &&
+                    md->type != EFI_LOADER_CODE)
+                        continue;
+
+                pfn = md->phys_addr >> PAGE_SHIFT;
+                npages = md->num_pages;
+
+                if (kernel_map_pages_in_pgd(pgd, pfn, md->phys_addr, npages, _PAGE_RW)) {
+                        pr_err("Failed to map 1:1 memory\n");
+                        return 1;
+                }
+        }
+
         page = alloc_page(GFP_KERNEL|__GFP_DMA32);
         if (!page)
                 panic("Unable to allocate EFI runtime stack < 4GB\n");
@@ -183,10 +275,11 @@ int __init efi_setup_page_tables(unsigned long pa_memmap, unsigned num_pages)
         efi_scratch.phys_stack = virt_to_phys(page_address(page));
         efi_scratch.phys_stack += PAGE_SIZE; /* stack grows down */
 
-        npages = (_end - _text) >> PAGE_SHIFT;
+        npages = (_etext - _text) >> PAGE_SHIFT;
         text = __pa(_text);
+        pfn = text >> PAGE_SHIFT;
 
-        if (kernel_map_pages_in_pgd(pgd, text >> PAGE_SHIFT, text, npages, 0)) {
+        if (kernel_map_pages_in_pgd(pgd, pfn, text, npages, _PAGE_RW)) {
                 pr_err("Failed to map kernel text 1:1\n");
                 return 1;
         }
@@ -196,20 +289,20 @@ int __init efi_setup_page_tables(unsigned long pa_memmap, unsigned num_pages)
 
 void __init efi_cleanup_page_tables(unsigned long pa_memmap, unsigned num_pages)
 {
-        pgd_t *pgd = (pgd_t *)__va(real_mode_header->trampoline_pgd);
-
-        kernel_unmap_pages_in_pgd(pgd, pa_memmap, num_pages);
+        kernel_unmap_pages_in_pgd(efi_pgd, pa_memmap, num_pages);
 }
 
 static void __init __map_region(efi_memory_desc_t *md, u64 va)
 {
-        pgd_t *pgd = (pgd_t *)__va(real_mode_header->trampoline_pgd);
-        unsigned long pf = 0;
+        unsigned long flags = _PAGE_RW;
+        unsigned long pfn;
+        pgd_t *pgd = efi_pgd;
 
         if (!(md->attribute & EFI_MEMORY_WB))
-                pf |= _PAGE_PCD;
+                flags |= _PAGE_PCD;
 
-        if (kernel_map_pages_in_pgd(pgd, md->phys_addr, va, md->num_pages, pf))
+        pfn = md->phys_addr >> PAGE_SHIFT;
+        if (kernel_map_pages_in_pgd(pgd, pfn, va, md->num_pages, flags))
                 pr_warn("Error mapping PA 0x%llx -> VA 0x%llx!\n",
                            md->phys_addr, va);
 }
@@ -300,21 +393,56 @@ void __init parse_efi_setup(u64 phys_addr, u32 data_len)
         efi_setup = phys_addr + sizeof(struct setup_data);
 }
 
-void __init efi_runtime_mkexec(void)
+void __init efi_runtime_update_mappings(void)
 {
-        if (!efi_enabled(EFI_OLD_MEMMAP))
+        unsigned long pfn;
+        pgd_t *pgd = efi_pgd;
+        efi_memory_desc_t *md;
+        void *p;
+
+        if (efi_enabled(EFI_OLD_MEMMAP)) {
+                if (__supported_pte_mask & _PAGE_NX)
+                        runtime_code_page_mkexec();
                 return;
+        }
+
+        if (!efi_enabled(EFI_NX_PE_DATA))
+                return;
+
+        for (p = memmap.map; p < memmap.map_end; p += memmap.desc_size) {
+                unsigned long pf = 0;
+                md = p;
+
+                if (!(md->attribute & EFI_MEMORY_RUNTIME))
+                        continue;
 
-        if (__supported_pte_mask & _PAGE_NX)
-                runtime_code_page_mkexec();
+                if (!(md->attribute & EFI_MEMORY_WB))
+                        pf |= _PAGE_PCD;
+
+                if ((md->attribute & EFI_MEMORY_XP) ||
+                        (md->type == EFI_RUNTIME_SERVICES_DATA))
+                        pf |= _PAGE_NX;
+
+                if (!(md->attribute & EFI_MEMORY_RO) &&
+                        (md->type != EFI_RUNTIME_SERVICES_CODE))
+                        pf |= _PAGE_RW;
+
+                /* Update the 1:1 mapping */
+                pfn = md->phys_addr >> PAGE_SHIFT;
+                if (kernel_map_pages_in_pgd(pgd, pfn, md->phys_addr, md->num_pages, pf))
+                        pr_warn("Error mapping PA 0x%llx -> VA 0x%llx!\n",
+                                   md->phys_addr, md->virt_addr);
+
+                if (kernel_map_pages_in_pgd(pgd, pfn, md->virt_addr, md->num_pages, pf))
+                        pr_warn("Error mapping PA 0x%llx -> VA 0x%llx!\n",
+                                   md->phys_addr, md->virt_addr);
+        }
 }
 
 void __init efi_dump_pagetable(void)
 {
 #ifdef CONFIG_EFI_PGT_DUMP
-        pgd_t *pgd = (pgd_t *)__va(real_mode_header->trampoline_pgd);
-
-        ptdump_walk_pgd_level(NULL, pgd);
+        ptdump_walk_pgd_level(NULL, efi_pgd);
 #endif
 }
 
diff --git a/arch/x86/platform/efi/efi_stub_64.S b/arch/x86/platform/efi/efi_stub_64.S
index 0df2dcc18404..92723aeae0f9 100644
--- a/arch/x86/platform/efi/efi_stub_64.S
+++ b/arch/x86/platform/efi/efi_stub_64.S
@@ -39,41 +39,6 @@
         mov %rsi, %cr0;                 \
         mov (%rsp), %rsp
 
-        /* stolen from gcc */
-        .macro FLUSH_TLB_ALL
-        movq %r15, efi_scratch(%rip)
-        movq %r14, efi_scratch+8(%rip)
-        movq %cr4, %r15
-        movq %r15, %r14
-        andb $0x7f, %r14b
-        movq %r14, %cr4
-        movq %r15, %cr4
-        movq efi_scratch+8(%rip), %r14
-        movq efi_scratch(%rip), %r15
-        .endm
-
-        .macro SWITCH_PGT
-        cmpb $0, efi_scratch+24(%rip)
-        je 1f
-        movq %r15, efi_scratch(%rip)            # r15
-        # save previous CR3
-        movq %cr3, %r15
-        movq %r15, efi_scratch+8(%rip)          # prev_cr3
-        movq efi_scratch+16(%rip), %r15         # EFI pgt
-        movq %r15, %cr3
-        1:
-        .endm
-
-        .macro RESTORE_PGT
-        cmpb $0, efi_scratch+24(%rip)
-        je 2f
-        movq efi_scratch+8(%rip), %r15
-        movq %r15, %cr3
-        movq efi_scratch(%rip), %r15
-        FLUSH_TLB_ALL
-        2:
-        .endm
-
 ENTRY(efi_call)
         FRAME_BEGIN
         SAVE_XMM
@@ -85,17 +50,9 @@ ENTRY(efi_call)
         mov %r8, %r9
         mov %rcx, %r8
         mov %rsi, %rcx
-        SWITCH_PGT
         call *%rdi
-        RESTORE_PGT
         addq $48, %rsp
         RESTORE_XMM
         FRAME_END
         ret
 ENDPROC(efi_call)
-
-        .data
-ENTRY(efi_scratch)
-        .fill 3,8,0
-        .byte 0
-        .quad 0
diff --git a/arch/x86/platform/efi/quirks.c b/arch/x86/platform/efi/quirks.c
index ed30e79347e8..ab50ada1d56e 100644
--- a/arch/x86/platform/efi/quirks.c
+++ b/arch/x86/platform/efi/quirks.c
@@ -1,3 +1,5 @@
+#define pr_fmt(fmt) "efi: " fmt
+
 #include <linux/init.h>
 #include <linux/kernel.h>
 #include <linux/string.h>
@@ -55,13 +57,41 @@ void efi_delete_dummy_variable(void)
 }
 
 /*
+ * In the nonblocking case we do not attempt to perform garbage
+ * collection if we do not have enough free space. Rather, we do the
+ * bare minimum check and give up immediately if the available space
+ * is below EFI_MIN_RESERVE.
+ *
+ * This function is intended to be small and simple because it is
+ * invoked from crash handler paths.
+ */
+static efi_status_t
+query_variable_store_nonblocking(u32 attributes, unsigned long size)
+{
+        efi_status_t status;
+        u64 storage_size, remaining_size, max_size;
+
+        status = efi.query_variable_info_nonblocking(attributes, &storage_size,
+                                                     &remaining_size,
+                                                     &max_size);
+        if (status != EFI_SUCCESS)
+                return status;
+
+        if (remaining_size - size < EFI_MIN_RESERVE)
+                return EFI_OUT_OF_RESOURCES;
+
+        return EFI_SUCCESS;
+}
+
+/*
  * Some firmware implementations refuse to boot if there's insufficient space
  * in the variable store. Ensure that we never use more than a safe limit.
  *
  * Return EFI_SUCCESS if it is safe to write 'size' bytes to the variable
  * store.
  */
-efi_status_t efi_query_variable_store(u32 attributes, unsigned long size)
+efi_status_t efi_query_variable_store(u32 attributes, unsigned long size,
+                                      bool nonblocking)
 {
         efi_status_t status;
         u64 storage_size, remaining_size, max_size;
@@ -69,6 +99,9 @@ efi_status_t efi_query_variable_store(u32 attributes, unsigned long size)
         if (!(attributes & EFI_VARIABLE_NON_VOLATILE))
                 return 0;
 
+        if (nonblocking)
+                return query_variable_store_nonblocking(attributes, size);
+
         status = efi.query_variable_info(attributes, &storage_size,
                                          &remaining_size, &max_size);
         if (status != EFI_SUCCESS)
@@ -312,7 +345,7 @@ void __init efi_apply_memmap_quirks(void)
          * services.
          */
         if (!efi_runtime_supported()) {
-                pr_info("efi: Setup done, disabling due to 32/64-bit mismatch\n");
+                pr_info("Setup done, disabling due to 32/64-bit mismatch\n");
                 efi_unmap_memmap();
         }