Merge branch 'linus' into tracing/mmiotrace

5 files changed, 40 insertions, 61 deletions

diff --git a/arch/x86/mm/fault.c b/arch/x86/mm/fault.c
index 8c828a68d3b6..0a778e3c43ee 100644
--- a/arch/x86/mm/fault.c
+++ b/arch/x86/mm/fault.c
@@ -508,6 +508,11 @@ static int vmalloc_fault(unsigned long address)
         unsigned long pgd_paddr;
         pmd_t *pmd_k;
         pte_t *pte_k;
+
+        /* Make sure we are in vmalloc area */
+        if (!(address >= VMALLOC_START && address < VMALLOC_END))
+                return -1;
+
         /*
          * Synchronize this task's top level page-table
          * with the 'reference' page table.
diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c
index 295be1d07b82..17c0a6138a53 100644
--- a/arch/x86/mm/init_64.c
+++ b/arch/x86/mm/init_64.c
@@ -135,7 +135,7 @@ static __init void *spp_getpage(void)
         return ptr;
 }
 
-static void
+static __init void
 set_pte_phys(unsigned long vaddr, unsigned long phys, pgprot_t prot)
 {
         pgd_t *pgd;
@@ -206,7 +206,7 @@ void __init cleanup_highmap(void)
         pmd_t *last_pmd = pmd + PTRS_PER_PMD;
 
         for (; pmd < last_pmd; pmd++, vaddr += PMD_SIZE) {
-                if (!pmd_present(*pmd))
+                if (pmd_none(*pmd))
                         continue;
                 if (vaddr < (unsigned long) _text || vaddr > end)
                         set_pmd(pmd, __pmd(0));
@@ -214,7 +214,7 @@ void __init cleanup_highmap(void)
 }
 
 /* NOTE: this is meant to be run only at boot */
-void __set_fixmap(enum fixed_addresses idx, unsigned long phys, pgprot_t prot)
+void __init __set_fixmap(enum fixed_addresses idx, unsigned long phys, pgprot_t prot)
 {
         unsigned long address = __fix_to_virt(idx);
 
@@ -506,7 +506,7 @@ early_param("memtest", parse_memtest);
 
 static void __init early_memtest(unsigned long start, unsigned long end)
 {
-        unsigned long t_start, t_size;
+        u64 t_start, t_size;
         unsigned pattern;
 
         if (!memtest_pattern)
@@ -525,8 +525,9 @@ static void __init early_memtest(unsigned long start, unsigned long end)
                         if (t_start + t_size > end)
                                 t_size = end - t_start;
 
-                        printk(KERN_CONT "\n  %016lx - %016lx pattern %d",
-                                t_start, t_start + t_size, pattern);
+                        printk(KERN_CONT "\n  %016llx - %016llx pattern %d",
+                                (unsigned long long)t_start,
+                                (unsigned long long)t_start + t_size, pattern);
 
                         memtest(t_start, t_size, pattern);
 
diff --git a/arch/x86/mm/ioremap.c b/arch/x86/mm/ioremap.c
index a7c80a6e8622..e92aa461f4d6 100644
--- a/arch/x86/mm/ioremap.c
+++ b/arch/x86/mm/ioremap.c
@@ -602,10 +602,11 @@ void __init early_iounmap(void *addr, unsigned long size)
         unsigned long offset;
         unsigned int nrpages;
         enum fixed_addresses idx;
-        unsigned int nesting;
+        int nesting;
 
         nesting = --early_ioremap_nested;
-        WARN_ON(nesting < 0);
+        if (WARN_ON(nesting < 0))
+                return;
 
         if (early_ioremap_debug) {
                 printk(KERN_INFO "early_iounmap(%p, %08lx) [%d]\n", addr,
diff --git a/arch/x86/mm/pat.c b/arch/x86/mm/pat.c
index de3a99812450..06b7a1c90fb8 100644
--- a/arch/x86/mm/pat.c
+++ b/arch/x86/mm/pat.c
@@ -34,7 +34,7 @@ void __cpuinit pat_disable(char *reason)
         printk(KERN_INFO "%s\n", reason);
 }
 
-static int nopat(char *str)
+static int __init nopat(char *str)
 {
         pat_disable("PAT support disabled.");
         return 0;
@@ -151,32 +151,33 @@ static int pat_x_mtrr_type(u64 start, u64 end, unsigned long prot,
         unsigned long pat_type;
         u8 mtrr_type;
 
-        mtrr_type = mtrr_type_lookup(start, end);
-        if (mtrr_type == 0xFF) {                /* MTRR not enabled */
-                *ret_prot = prot;
-                return 0;
-        }
-        if (mtrr_type == 0xFE) {                /* MTRR match error */
-                *ret_prot = _PAGE_CACHE_UC;
-                return -1;
-        }
-        if (mtrr_type != MTRR_TYPE_UNCACHABLE &&
-            mtrr_type != MTRR_TYPE_WRBACK &&
-            mtrr_type != MTRR_TYPE_WRCOMB) {    /* MTRR type unhandled */
-                *ret_prot = _PAGE_CACHE_UC;
-                return -1;
-        }
-
         pat_type = prot & _PAGE_CACHE_MASK;
         prot &= (~_PAGE_CACHE_MASK);
 
-        /* Currently doing intersection by hand. Optimize it later. */
+        /*
+         * We return the PAT request directly for types where PAT takes
+         * precedence with respect to MTRR and for UC_MINUS.
+         * Consistency checks with other PAT requests is done later
+         * while going through memtype list.
+         */
         if (pat_type == _PAGE_CACHE_WC) {
                 *ret_prot = prot | _PAGE_CACHE_WC;
+                return 0;
         } else if (pat_type == _PAGE_CACHE_UC_MINUS) {
                 *ret_prot = prot | _PAGE_CACHE_UC_MINUS;
-        } else if (pat_type == _PAGE_CACHE_UC ||
-                   mtrr_type == MTRR_TYPE_UNCACHABLE) {
+                return 0;
+        } else if (pat_type == _PAGE_CACHE_UC) {
+                *ret_prot = prot | _PAGE_CACHE_UC;
+                return 0;
+        }
+
+        /*
+         * Look for MTRR hint to get the effective type in case where PAT
+         * request is for WB.
+         */
+        mtrr_type = mtrr_type_lookup(start, end);
+
+        if (mtrr_type == MTRR_TYPE_UNCACHABLE) {
                 *ret_prot = prot | _PAGE_CACHE_UC;
         } else if (mtrr_type == MTRR_TYPE_WRCOMB) {
                 *ret_prot = prot | _PAGE_CACHE_WC;
@@ -233,14 +234,12 @@ int reserve_memtype(u64 start, u64 end, unsigned long req_type,
 
         if (req_type == -1) {
                 /*
-                 * Special case where caller wants to inherit from mtrr or
-                 * existing pat mapping, defaulting to UC_MINUS in case of
-                 * no match.
+                 * Call mtrr_lookup to get the type hint. This is an
+                 * optimization for /dev/mem mmap'ers into WB memory (BIOS
+                 * tools and ACPI tools). Use WB request for WB memory and use
+                 * UC_MINUS otherwise.
                  */
                 u8 mtrr_type = mtrr_type_lookup(start, end);
-                if (mtrr_type == 0xFE) { /* MTRR match error */
-                        err = -1;
-                }
 
                 if (mtrr_type == MTRR_TYPE_WRBACK) {
                         req_type = _PAGE_CACHE_WB;
diff --git a/arch/x86/mm/srat_64.c b/arch/x86/mm/srat_64.c
index 3890234e5b26..99649dccad28 100644
--- a/arch/x86/mm/srat_64.c
+++ b/arch/x86/mm/srat_64.c
@@ -97,36 +97,9 @@ static __init inline int srat_disabled(void)
         return numa_off || acpi_numa < 0;
 }
 
-/*
- * A lot of BIOS fill in 10 (= no distance) everywhere. This messes
- * up the NUMA heuristics which wants the local node to have a smaller
- * distance than the others.
- * Do some quick checks here and only use the SLIT if it passes.
- */
-static __init int slit_valid(struct acpi_table_slit *slit)
-{
-        int i, j;
-        int d = slit->locality_count;
-        for (i = 0; i < d; i++) {
-                for (j = 0; j < d; j++)  {
-                        u8 val = slit->entry[d*i + j];
-                        if (i == j) {
-                                if (val != LOCAL_DISTANCE)
-                                        return 0;
-                        } else if (val <= LOCAL_DISTANCE)
-                                return 0;
-                }
-        }
-        return 1;
-}
-
 /* Callback for SLIT parsing */
 void __init acpi_numa_slit_init(struct acpi_table_slit *slit)
 {
-        if (!slit_valid(slit)) {
-                printk(KERN_INFO "ACPI: SLIT table looks invalid. Not used.\n");
-                return;
-        }
         acpi_slit = slit;
 }