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

Pull x86 EFI changes from Ingo Molnar:
 "The main changes:

  - Add debug code to the dump EFI pagetable - Borislav Petkov

  - Make 1:1 runtime mapping robust when booting on machines with lots
    of memory - Borislav Petkov

  - Move the EFI facilities bits out of 'x86_efi_facility' and into
    efi.flags which is the standard architecture independent place to
    keep EFI state, by Matt Fleming.

  - Add 'EFI mixed mode' support: this allows 64-bit kernels to be
    booted from 32-bit firmware.  This needs a bootloader that supports
    the 'EFI handover protocol'.  By Matt Fleming"

* 'x86-efi-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/tip/tip: (31 commits)
  x86, efi: Abstract x86 efi_early calls
  x86/efi: Restore 'attr' argument to query_variable_info()
  x86/efi: Rip out phys_efi_get_time()
  x86/efi: Preserve segment registers in mixed mode
  x86/boot: Fix non-EFI build
  x86, tools: Fix up compiler warnings
  x86/efi: Re-disable interrupts after calling firmware services
  x86/boot: Don't overwrite cr4 when enabling PAE
  x86/efi: Wire up CONFIG_EFI_MIXED
  x86/efi: Add mixed runtime services support
  x86/efi: Firmware agnostic handover entry points
  x86/efi: Split the boot stub into 32/64 code paths
  x86/efi: Add early thunk code to go from 64-bit to 32-bit
  x86/efi: Build our own EFI services pointer table
  efi: Add separate 32-bit/64-bit definitions
  x86/efi: Delete dead code when checking for non-native
  x86/mm/pageattr: Always dump the right page table in an oops
  x86, tools: Consolidate #ifdef code
  x86/boot: Cleanup header.S by removing some #ifdefs
  efi: Use NULL instead of 0 for pointer
  ...

3 files changed, 99 insertions, 48 deletions

diff --git a/arch/x86/mm/dump_pagetables.c b/arch/x86/mm/dump_pagetables.c
index 0002a3a33081..20621d753d5f 100644
--- a/arch/x86/mm/dump_pagetables.c
+++ b/arch/x86/mm/dump_pagetables.c
@@ -30,6 +30,7 @@ struct pg_state {
         unsigned long start_address;
         unsigned long current_address;
         const struct addr_marker *marker;
+        bool to_dmesg;
 };
 
 struct addr_marker {
@@ -88,10 +89,28 @@ static struct addr_marker address_markers[] = {
 #define PUD_LEVEL_MULT (PTRS_PER_PMD * PMD_LEVEL_MULT)
 #define PGD_LEVEL_MULT (PTRS_PER_PUD * PUD_LEVEL_MULT)
 
+#define pt_dump_seq_printf(m, to_dmesg, fmt, args...)           \
+({                                                              \
+        if (to_dmesg)                                   \
+                printk(KERN_INFO fmt, ##args);                  \
+        else                                                    \
+                if (m)                                          \
+                        seq_printf(m, fmt, ##args);             \
+})
+
+#define pt_dump_cont_printf(m, to_dmesg, fmt, args...)          \
+({                                                              \
+        if (to_dmesg)                                   \
+                printk(KERN_CONT fmt, ##args);                  \
+        else                                                    \
+                if (m)                                          \
+                        seq_printf(m, fmt, ##args);             \
+})
+
 /*
  * Print a readable form of a pgprot_t to the seq_file
  */
-static void printk_prot(struct seq_file *m, pgprot_t prot, int level)
+static void printk_prot(struct seq_file *m, pgprot_t prot, int level, bool dmsg)
 {
         pgprotval_t pr = pgprot_val(prot);
         static const char * const level_name[] =
@@ -99,47 +118,47 @@ static void printk_prot(struct seq_file *m, pgprot_t prot, int level)
 
         if (!pgprot_val(prot)) {
                 /* Not present */
-                seq_printf(m, "                          ");
+                pt_dump_cont_printf(m, dmsg, "                          ");
         } else {
                 if (pr & _PAGE_USER)
-                        seq_printf(m, "USR ");
+                        pt_dump_cont_printf(m, dmsg, "USR ");
                 else
-                        seq_printf(m, "    ");
+                        pt_dump_cont_printf(m, dmsg, "    ");
                 if (pr & _PAGE_RW)
-                        seq_printf(m, "RW ");
+                        pt_dump_cont_printf(m, dmsg, "RW ");
                 else
-                        seq_printf(m, "ro ");
+                        pt_dump_cont_printf(m, dmsg, "ro ");
                 if (pr & _PAGE_PWT)
-                        seq_printf(m, "PWT ");
+                        pt_dump_cont_printf(m, dmsg, "PWT ");
                 else
-                        seq_printf(m, "    ");
+                        pt_dump_cont_printf(m, dmsg, "    ");
                 if (pr & _PAGE_PCD)
-                        seq_printf(m, "PCD ");
+                        pt_dump_cont_printf(m, dmsg, "PCD ");
                 else
-                        seq_printf(m, "    ");
+                        pt_dump_cont_printf(m, dmsg, "    ");
 
                 /* Bit 9 has a different meaning on level 3 vs 4 */
                 if (level <= 3) {
                         if (pr & _PAGE_PSE)
-                                seq_printf(m, "PSE ");
+                                pt_dump_cont_printf(m, dmsg, "PSE ");
                         else
-                                seq_printf(m, "    ");
+                                pt_dump_cont_printf(m, dmsg, "    ");
                 } else {
                         if (pr & _PAGE_PAT)
-                                seq_printf(m, "pat ");
+                                pt_dump_cont_printf(m, dmsg, "pat ");
                         else
-                                seq_printf(m, "    ");
+                                pt_dump_cont_printf(m, dmsg, "    ");
                 }
                 if (pr & _PAGE_GLOBAL)
-                        seq_printf(m, "GLB ");
+                        pt_dump_cont_printf(m, dmsg, "GLB ");
                 else
-                        seq_printf(m, "    ");
+                        pt_dump_cont_printf(m, dmsg, "    ");
                 if (pr & _PAGE_NX)
-                        seq_printf(m, "NX ");
+                        pt_dump_cont_printf(m, dmsg, "NX ");
                 else
-                        seq_printf(m, "x  ");
+                        pt_dump_cont_printf(m, dmsg, "x  ");
         }
-        seq_printf(m, "%s\n", level_name[level]);
+        pt_dump_cont_printf(m, dmsg, "%s\n", level_name[level]);
 }
 
 /*
@@ -178,7 +197,8 @@ static void note_page(struct seq_file *m, struct pg_state *st,
                 st->current_prot = new_prot;
                 st->level = level;
                 st->marker = address_markers;
-                seq_printf(m, "---[ %s ]---\n", st->marker->name);
+                pt_dump_seq_printf(m, st->to_dmesg, "---[ %s ]---\n",
+                                   st->marker->name);
         } else if (prot != cur || level != st->level ||
                    st->current_address >= st->marker[1].start_address) {
                 const char *unit = units;
@@ -188,17 +208,17 @@ static void note_page(struct seq_file *m, struct pg_state *st,
                 /*
                  * Now print the actual finished series
                  */
-                seq_printf(m, "0x%0*lx-0x%0*lx   ",
-                           width, st->start_address,
-                           width, st->current_address);
+                pt_dump_seq_printf(m, st->to_dmesg,  "0x%0*lx-0x%0*lx   ",
+                                   width, st->start_address,
+                                   width, st->current_address);
 
                 delta = (st->current_address - st->start_address) >> 10;
                 while (!(delta & 1023) && unit[1]) {
                         delta >>= 10;
                         unit++;
                 }
-                seq_printf(m, "%9lu%c ", delta, *unit);
-                printk_prot(m, st->current_prot, st->level);
+                pt_dump_cont_printf(m, st->to_dmesg, "%9lu%c ", delta, *unit);
+                printk_prot(m, st->current_prot, st->level, st->to_dmesg);
 
                 /*
                  * We print markers for special areas of address space,
@@ -207,7 +227,8 @@ static void note_page(struct seq_file *m, struct pg_state *st,
                  */
                 if (st->current_address >= st->marker[1].start_address) {
                         st->marker++;
-                        seq_printf(m, "---[ %s ]---\n", st->marker->name);
+                        pt_dump_seq_printf(m, st->to_dmesg, "---[ %s ]---\n",
+                                           st->marker->name);
                 }
 
                 st->start_address = st->current_address;
@@ -296,7 +317,7 @@ static void walk_pud_level(struct seq_file *m, struct pg_state *st, pgd_t addr,
 #define pgd_none(a)  pud_none(__pud(pgd_val(a)))
 #endif
 
-static void walk_pgd_level(struct seq_file *m)
+void ptdump_walk_pgd_level(struct seq_file *m, pgd_t *pgd)
 {
 #ifdef CONFIG_X86_64
         pgd_t *start = (pgd_t *) &init_level4_pgt;
@@ -304,9 +325,12 @@ static void walk_pgd_level(struct seq_file *m)
         pgd_t *start = swapper_pg_dir;
 #endif
         int i;
-        struct pg_state st;
+        struct pg_state st = {};
 
-        memset(&st, 0, sizeof(st));
+        if (pgd) {
+                start = pgd;
+                st.to_dmesg = true;
+        }
 
         for (i = 0; i < PTRS_PER_PGD; i++) {
                 st.current_address = normalize_addr(i * PGD_LEVEL_MULT);
@@ -331,7 +355,7 @@ static void walk_pgd_level(struct seq_file *m)
 
 static int ptdump_show(struct seq_file *m, void *v)
 {
-        walk_pgd_level(m);
+        ptdump_walk_pgd_level(m, NULL);
         return 0;
 }
 
diff --git a/arch/x86/mm/fault.c b/arch/x86/mm/fault.c
index a10c8c792161..8e5722992677 100644
--- a/arch/x86/mm/fault.c
+++ b/arch/x86/mm/fault.c
@@ -584,8 +584,13 @@ show_fault_oops(struct pt_regs *regs, unsigned long error_code,
 
         if (error_code & PF_INSTR) {
                 unsigned int level;
+                pgd_t *pgd;
+                pte_t *pte;
 
-                pte_t *pte = lookup_address(address, &level);
+                pgd = __va(read_cr3() & PHYSICAL_PAGE_MASK);
+                pgd += pgd_index(address);
+
+                pte = lookup_address_in_pgd(pgd, address, &level);
 
                 if (pte && pte_present(*pte) && !pte_exec(*pte))
                         printk(nx_warning, from_kuid(&init_user_ns, current_uid()));
diff --git a/arch/x86/mm/pageattr.c b/arch/x86/mm/pageattr.c
index cf125b301b69..ae242a7c11c7 100644
--- a/arch/x86/mm/pageattr.c
+++ b/arch/x86/mm/pageattr.c
@@ -323,8 +323,12 @@ static inline pgprot_t static_protections(pgprot_t prot, unsigned long address,
         return prot;
 }
 
-static pte_t *__lookup_address_in_pgd(pgd_t *pgd, unsigned long address,
-                                      unsigned int *level)
+/*
+ * Lookup the page table entry for a virtual address in a specific pgd.
+ * Return a pointer to the entry and the level of the mapping.
+ */
+pte_t *lookup_address_in_pgd(pgd_t *pgd, unsigned long address,
+                             unsigned int *level)
 {
         pud_t *pud;
         pmd_t *pmd;
@@ -365,7 +369,7 @@ static pte_t *__lookup_address_in_pgd(pgd_t *pgd, unsigned long address,
  */
 pte_t *lookup_address(unsigned long address, unsigned int *level)
 {
-        return __lookup_address_in_pgd(pgd_offset_k(address), address, level);
+        return lookup_address_in_pgd(pgd_offset_k(address), address, level);
 }
 EXPORT_SYMBOL_GPL(lookup_address);
 
@@ -373,7 +377,7 @@ static pte_t *_lookup_address_cpa(struct cpa_data *cpa, unsigned long address,
                                   unsigned int *level)
 {
         if (cpa->pgd)
-                return __lookup_address_in_pgd(cpa->pgd + pgd_index(address),
+                return lookup_address_in_pgd(cpa->pgd + pgd_index(address),
                                                address, level);
 
         return lookup_address(address, level);
@@ -692,6 +696,18 @@ static bool try_to_free_pmd_page(pmd_t *pmd)
         return true;
 }
 
+static bool try_to_free_pud_page(pud_t *pud)
+{
+        int i;
+
+        for (i = 0; i < PTRS_PER_PUD; i++)
+                if (!pud_none(pud[i]))
+                        return false;
+
+        free_page((unsigned long)pud);
+        return true;
+}
+
 static bool unmap_pte_range(pmd_t *pmd, unsigned long start, unsigned long end)
 {
         pte_t *pte = pte_offset_kernel(pmd, start);
@@ -805,6 +821,16 @@ static void unmap_pud_range(pgd_t *pgd, unsigned long start, unsigned long end)
          */
 }
 
+static void unmap_pgd_range(pgd_t *root, unsigned long addr, unsigned long end)
+{
+        pgd_t *pgd_entry = root + pgd_index(addr);
+
+        unmap_pud_range(pgd_entry, addr, end);
+
+        if (try_to_free_pud_page((pud_t *)pgd_page_vaddr(*pgd_entry)))
+                pgd_clear(pgd_entry);
+}
+
 static int alloc_pte_page(pmd_t *pmd)
 {
         pte_t *pte = (pte_t *)get_zeroed_page(GFP_KERNEL | __GFP_NOTRACK);
@@ -999,9 +1025,8 @@ static int populate_pud(struct cpa_data *cpa, unsigned long start, pgd_t *pgd,
 static int populate_pgd(struct cpa_data *cpa, unsigned long addr)
 {
         pgprot_t pgprot = __pgprot(_KERNPG_TABLE);
-        bool allocd_pgd = false;
-        pgd_t *pgd_entry;
         pud_t *pud = NULL;      /* shut up gcc */
+        pgd_t *pgd_entry;
         int ret;
 
         pgd_entry = cpa->pgd + pgd_index(addr);
@@ -1015,7 +1040,6 @@ static int populate_pgd(struct cpa_data *cpa, unsigned long addr)
                         return -1;
 
                 set_pgd(pgd_entry, __pgd(__pa(pud) | _KERNPG_TABLE));
-                allocd_pgd = true;
         }
 
         pgprot_val(pgprot) &= ~pgprot_val(cpa->mask_clr);
@@ -1023,19 +1047,11 @@ static int populate_pgd(struct cpa_data *cpa, unsigned long addr)
 
         ret = populate_pud(cpa, addr, pgd_entry, pgprot);
         if (ret < 0) {
-                unmap_pud_range(pgd_entry, addr,
+                unmap_pgd_range(cpa->pgd, addr,
                                 addr + (cpa->numpages << PAGE_SHIFT));
-
-                if (allocd_pgd) {
-                        /*
-                         * If I allocated this PUD page, I can just as well
-                         * free it in this error path.
-                         */
-                        pgd_clear(pgd_entry);
-                        free_page((unsigned long)pud);
-                }
                 return ret;
         }
+
         cpa->numpages = ret;
         return 0;
 }
@@ -1861,6 +1877,12 @@ out:
         return retval;
 }
 
+void kernel_unmap_pages_in_pgd(pgd_t *root, unsigned long address,
+                               unsigned numpages)
+{
+        unmap_pgd_range(root, address, address + (numpages << PAGE_SHIFT));
+}
+
 /*
  * The testcases use internal knowledge of the implementation that shouldn't
  * be exposed to the rest of the kernel. Include these directly here.