x86: construct 32-bit boot time page tables in native format.

Specifically the boot time page tables in a CONFIG_X86_PAE=y enabled
kernel are in PAE format.

early_ioremap is updated to use the standard page table accessors.

Clear any mappings beyond max_low_pfn from the boot page tables in
native_pagetable_setup_start because the initial mappings can extend
beyond the range of physical memory and into the vmalloc area.

Derived from patches by Eric Biederman and H. Peter Anvin.

[ jeremy@goop.org: PAE swapper_pg_dir needs to be page-sized fix ]

Signed-off-by: Ian Campbell <ijc@hellion.org.uk>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Eric W. Biederman <ebiederm@xmission.com>
Cc: Andi Kleen <andi@firstfloor.org>
Cc: Mika Penttilä <mika.penttila@kolumbus.fi>
Cc: Jeremy Fitzhardinge <jeremy@goop.org>
Signed-off-by: Ingo Molnar <mingo@elte.hu>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>

2 files changed, 58 insertions, 69 deletions

diff --git a/arch/x86/mm/init_32.c b/arch/x86/mm/init_32.c
index d1bc04006d16..54aba3cf9efe 100644
--- a/arch/x86/mm/init_32.c
+++ b/arch/x86/mm/init_32.c
@@ -46,6 +46,7 @@
 #include <asm/pgalloc.h>
 #include <asm/sections.h>
 #include <asm/paravirt.h>
+#include <asm/setup.h>
 
 unsigned int __VMALLOC_RESERVE = 128 << 20;
 
@@ -328,44 +329,38 @@ pteval_t __PAGE_KERNEL_EXEC = _PAGE_KERNEL_EXEC;
 
 void __init native_pagetable_setup_start(pgd_t *base)
 {
-#ifdef CONFIG_X86_PAE
-        int i;
+        unsigned long pfn, va;
+        pgd_t *pgd;
+        pud_t *pud;
+        pmd_t *pmd;
+        pte_t *pte;
 
         /*
-         * Init entries of the first-level page table to the
-         * zero page, if they haven't already been set up.
-         *
-         * In a normal native boot, we'll be running on a
-         * pagetable rooted in swapper_pg_dir, but not in PAE
-         * mode, so this will end up clobbering the mappings
-         * for the lower 24Mbytes of the address space,
-         * without affecting the kernel address space.
+         * Remove any mappings which extend past the end of physical
+         * memory from the boot time page table:
          */
-        for (i = 0; i < USER_PTRS_PER_PGD; i++)
-                set_pgd(&base[i],
-                        __pgd(__pa(empty_zero_page) | _PAGE_PRESENT));
-
-        /* Make sure kernel address space is empty so that a pagetable
-           will be allocated for it. */
-        memset(&base[USER_PTRS_PER_PGD], 0,
-               KERNEL_PGD_PTRS * sizeof(pgd_t));
-#else
+        for (pfn = max_low_pfn + 1; pfn < 1<<(32-PAGE_SHIFT); pfn++) {
+                va = PAGE_OFFSET + (pfn<<PAGE_SHIFT);
+                pgd = base + pgd_index(va);
+                if (!pgd_present(*pgd))
+                        break;
+
+                pud = pud_offset(pgd, va);
+                pmd = pmd_offset(pud, va);
+                if (!pmd_present(*pmd))
+                        break;
+
+                pte = pte_offset_kernel(pmd, va);
+                if (!pte_present(*pte))
+                        break;
+
+                pte_clear(NULL, va, pte);
+        }
         paravirt_alloc_pd(&init_mm, __pa(base) >> PAGE_SHIFT);
-#endif
 }
 
 void __init native_pagetable_setup_done(pgd_t *base)
 {
-#ifdef CONFIG_X86_PAE
-        /*
-         * Add low memory identity-mappings - SMP needs it when
-         * starting up on an AP from real-mode. In the non-PAE
-         * case we already have these mappings through head.S.
-         * All user-space mappings are explicitly cleared after
-         * SMP startup.
-         */
-        set_pgd(&base[0], base[USER_PTRS_PER_PGD]);
-#endif
 }
 
 /*
@@ -374,9 +369,8 @@ void __init native_pagetable_setup_done(pgd_t *base)
  * the boot process.
  *
  * If we're booting on native hardware, this will be a pagetable
- * constructed in arch/i386/kernel/head.S, and not running in PAE mode
- * (even if we'll end up running in PAE).  The root of the pagetable
- * will be swapper_pg_dir.
+ * constructed in arch/x86/kernel/head_32.S.  The root of the
+ * pagetable will be swapper_pg_dir.
  *
  * If we're booting paravirtualized under a hypervisor, then there are
  * more options: we may already be running PAE, and the pagetable may
@@ -537,14 +531,6 @@ void __init paging_init(void)
 
         load_cr3(swapper_pg_dir);
 
-#ifdef CONFIG_X86_PAE
-        /*
-         * We will bail out later - printk doesn't work right now so
-         * the user would just see a hanging kernel.
-         */
-        if (cpu_has_pae)
-                set_in_cr4(X86_CR4_PAE);
-#endif
         __flush_tlb_all();
 
         kmap_init();
@@ -675,10 +661,6 @@ void __init mem_init(void)
         BUG_ON((unsigned long)high_memory               > VMALLOC_START);
 #endif /* double-sanity-check paranoia */
 
-#ifdef CONFIG_X86_PAE
-        if (!cpu_has_pae)
-                panic("cannot execute a PAE-enabled kernel on a PAE-less CPU!");
-#endif
         if (boot_cpu_data.wp_works_ok < 0)
                 test_wp_bit();
 
diff --git a/arch/x86/mm/ioremap.c b/arch/x86/mm/ioremap.c
index ee6648fe6b15..1106b7f477bd 100644
--- a/arch/x86/mm/ioremap.c
+++ b/arch/x86/mm/ioremap.c
@@ -260,41 +260,46 @@ static int __init early_ioremap_debug_setup(char *str)
 early_param("early_ioremap_debug", early_ioremap_debug_setup);
 
 static __initdata int after_paging_init;
-static __initdata unsigned long bm_pte[1024]
+static __initdata pte_t bm_pte[PAGE_SIZE/sizeof(pte_t)]
                                 __attribute__((aligned(PAGE_SIZE)));
 
-static inline unsigned long * __init early_ioremap_pgd(unsigned long addr)
+static inline pmd_t * __init early_ioremap_pmd(unsigned long addr)
 {
-        return (unsigned long *)swapper_pg_dir + ((addr >> 22) & 1023);
+        pgd_t *pgd = &swapper_pg_dir[pgd_index(addr)];
+        pud_t *pud = pud_offset(pgd, addr);
+        pmd_t *pmd = pmd_offset(pud, addr);
+
+        return pmd;
 }
 
-static inline unsigned long * __init early_ioremap_pte(unsigned long addr)
+static inline pte_t * __init early_ioremap_pte(unsigned long addr)
 {
-        return bm_pte + ((addr >> PAGE_SHIFT) & 1023);
+        return &bm_pte[pte_index(addr)];
 }
 
 void __init early_ioremap_init(void)
 {
-        unsigned long *pgd;
+        pmd_t *pmd;
 
         if (early_ioremap_debug)
                 printk(KERN_INFO "early_ioremap_init()\n");
 
-        pgd = early_ioremap_pgd(fix_to_virt(FIX_BTMAP_BEGIN));
-        *pgd = __pa(bm_pte) | _PAGE_TABLE;
+        pmd = early_ioremap_pmd(fix_to_virt(FIX_BTMAP_BEGIN));
         memset(bm_pte, 0, sizeof(bm_pte));
+        set_pmd(pmd, __pmd(__pa(bm_pte) | _PAGE_TABLE));
+
         /*
-         * The boot-ioremap range spans multiple pgds, for which
+         * The boot-ioremap range spans multiple pmds, for which
          * we are not prepared:
          */
-        if (pgd != early_ioremap_pgd(fix_to_virt(FIX_BTMAP_END))) {
+        if (pmd != early_ioremap_pmd(fix_to_virt(FIX_BTMAP_END))) {
                 WARN_ON(1);
-                printk(KERN_WARNING "pgd %p != %p\n",
-                       pgd, early_ioremap_pgd(fix_to_virt(FIX_BTMAP_END)));
+                printk(KERN_WARNING "pmd %p != %p\n",
+                       pmd, early_ioremap_pmd(fix_to_virt(FIX_BTMAP_END)));
                 printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_BEGIN): %08lx\n",
-                       fix_to_virt(FIX_BTMAP_BEGIN));
+                        fix_to_virt(FIX_BTMAP_BEGIN));
                 printk(KERN_WARNING "fix_to_virt(FIX_BTMAP_END):   %08lx\n",
-                       fix_to_virt(FIX_BTMAP_END));
+                        fix_to_virt(FIX_BTMAP_END));
 
                 printk(KERN_WARNING "FIX_BTMAP_END:       %d\n", FIX_BTMAP_END);
                 printk(KERN_WARNING "FIX_BTMAP_BEGIN:     %d\n",
@@ -304,28 +309,29 @@ void __init early_ioremap_init(void)
 
 void __init early_ioremap_clear(void)
 {
-        unsigned long *pgd;
+        pmd_t *pmd;
 
         if (early_ioremap_debug)
                 printk(KERN_INFO "early_ioremap_clear()\n");
 
-        pgd = early_ioremap_pgd(fix_to_virt(FIX_BTMAP_BEGIN));
-        *pgd = 0;
-        paravirt_release_pt(__pa(pgd) >> PAGE_SHIFT);
+        pmd = early_ioremap_pmd(fix_to_virt(FIX_BTMAP_BEGIN));
+        pmd_clear(pmd);
+        paravirt_release_pt(__pa(pmd) >> PAGE_SHIFT);
         __flush_tlb_all();
 }
 
 void __init early_ioremap_reset(void)
 {
         enum fixed_addresses idx;
-        unsigned long *pte, phys, addr;
+        unsigned long addr, phys;
+        pte_t *pte;
 
         after_paging_init = 1;
         for (idx = FIX_BTMAP_BEGIN; idx >= FIX_BTMAP_END; idx--) {
                 addr = fix_to_virt(idx);
                 pte = early_ioremap_pte(addr);
-                if (*pte & _PAGE_PRESENT) {
-                        phys = *pte & PAGE_MASK;
+                if (pte_present(*pte)) {
+                        phys = pte_val(*pte) & PAGE_MASK;
                         set_fixmap(idx, phys);
                 }
         }
@@ -334,7 +340,8 @@ void __init early_ioremap_reset(void)
 static void __init __early_set_fixmap(enum fixed_addresses idx,
                                    unsigned long phys, pgprot_t flags)
 {
-        unsigned long *pte, addr = __fix_to_virt(idx);
+        unsigned long addr = __fix_to_virt(idx);
+        pte_t *pte;
 
         if (idx >= __end_of_fixed_addresses) {
                 BUG();
@@ -342,9 +349,9 @@ static void __init __early_set_fixmap(enum fixed_addresses idx,
         }
         pte = early_ioremap_pte(addr);
         if (pgprot_val(flags))
-                *pte = (phys & PAGE_MASK) | pgprot_val(flags);
+                set_pte(pte, pfn_pte(phys >> PAGE_SHIFT, flags));
         else
-                *pte = 0;
+                pte_clear(NULL, addr, pte);
         __flush_tlb_one(addr);
 }