12 files changed, 172 insertions, 43 deletions

diff --git a/arch/x86/mm/extable.c b/arch/x86/mm/extable.c
index 1fb85dbe390a..903ec1e9c326 100644
--- a/arch/x86/mm/extable.c
+++ b/arch/x86/mm/extable.c
@@ -1,11 +1,23 @@
 #include <linux/module.h>
 #include <linux/spinlock.h>
+#include <linux/sort.h>
 #include <asm/uaccess.h>
 
+static inline unsigned long
+ex_insn_addr(const struct exception_table_entry *x)
+{
+        return (unsigned long)&x->insn + x->insn;
+}
+static inline unsigned long
+ex_fixup_addr(const struct exception_table_entry *x)
+{
+        return (unsigned long)&x->fixup + x->fixup;
+}
 
 int fixup_exception(struct pt_regs *regs)
 {
         const struct exception_table_entry *fixup;
+        unsigned long new_ip;
 
 #ifdef CONFIG_PNPBIOS
         if (unlikely(SEGMENT_IS_PNP_CODE(regs->cs))) {
@@ -23,15 +35,135 @@ int fixup_exception(struct pt_regs *regs)
 
         fixup = search_exception_tables(regs->ip);
         if (fixup) {
-                /* If fixup is less than 16, it means uaccess error */
-                if (fixup->fixup < 16) {
+                new_ip = ex_fixup_addr(fixup);
+
+                if (fixup->fixup - fixup->insn >= 0x7ffffff0 - 4) {
+                        /* Special hack for uaccess_err */
                         current_thread_info()->uaccess_err = 1;
-                        regs->ip += fixup->fixup;
-                        return 1;
+                        new_ip -= 0x7ffffff0;
                 }
-                regs->ip = fixup->fixup;
+                regs->ip = new_ip;
                 return 1;
         }
 
         return 0;
 }
+
+/* Restricted version used during very early boot */
+int __init early_fixup_exception(unsigned long *ip)
+{
+        const struct exception_table_entry *fixup;
+        unsigned long new_ip;
+
+        fixup = search_exception_tables(*ip);
+        if (fixup) {
+                new_ip = ex_fixup_addr(fixup);
+
+                if (fixup->fixup - fixup->insn >= 0x7ffffff0 - 4) {
+                        /* uaccess handling not supported during early boot */
+                        return 0;
+                }
+
+                *ip = new_ip;
+                return 1;
+        }
+
+        return 0;
+}
+
+/*
+ * Search one exception table for an entry corresponding to the
+ * given instruction address, and return the address of the entry,
+ * or NULL if none is found.
+ * We use a binary search, and thus we assume that the table is
+ * already sorted.
+ */
+const struct exception_table_entry *
+search_extable(const struct exception_table_entry *first,
+               const struct exception_table_entry *last,
+               unsigned long value)
+{
+        while (first <= last) {
+                const struct exception_table_entry *mid;
+                unsigned long addr;
+
+                mid = ((last - first) >> 1) + first;
+                addr = ex_insn_addr(mid);
+                if (addr < value)
+                        first = mid + 1;
+                else if (addr > value)
+                        last = mid - 1;
+                else
+                        return mid;
+        }
+        return NULL;
+}
+
+/*
+ * The exception table needs to be sorted so that the binary
+ * search that we use to find entries in it works properly.
+ * This is used both for the kernel exception table and for
+ * the exception tables of modules that get loaded.
+ *
+ */
+static int cmp_ex(const void *a, const void *b)
+{
+        const struct exception_table_entry *x = a, *y = b;
+
+        /*
+         * This value will always end up fittin in an int, because on
+         * both i386 and x86-64 the kernel symbol-reachable address
+         * space is < 2 GiB.
+         *
+         * This compare is only valid after normalization.
+         */
+        return x->insn - y->insn;
+}
+
+void sort_extable(struct exception_table_entry *start,
+                  struct exception_table_entry *finish)
+{
+        struct exception_table_entry *p;
+        int i;
+
+        /* Convert all entries to being relative to the start of the section */
+        i = 0;
+        for (p = start; p < finish; p++) {
+                p->insn += i;
+                i += 4;
+                p->fixup += i;
+                i += 4;
+        }
+
+        sort(start, finish - start, sizeof(struct exception_table_entry),
+             cmp_ex, NULL);
+
+        /* Denormalize all entries */
+        i = 0;
+        for (p = start; p < finish; p++) {
+                p->insn -= i;
+                i += 4;
+                p->fixup -= i;
+                i += 4;
+        }
+}
+
+#ifdef CONFIG_MODULES
+/*
+ * If the exception table is sorted, any referring to the module init
+ * will be at the beginning or the end.
+ */
+void trim_init_extable(struct module *m)
+{
+        /*trim the beginning*/
+        while (m->num_exentries &&
+               within_module_init(ex_insn_addr(&m->extable[0]), m)) {
+                m->extable++;
+                m->num_exentries--;
+        }
+        /*trim the end*/
+        while (m->num_exentries &&
+               within_module_init(ex_insn_addr(&m->extable[m->num_exentries-1]), m))
+                m->num_exentries--;
+}
+#endif /* CONFIG_MODULES */
diff --git a/arch/x86/mm/fault.c b/arch/x86/mm/fault.c
index f0b4caf85c1a..3ecfd1aaf214 100644
--- a/arch/x86/mm/fault.c
+++ b/arch/x86/mm/fault.c
@@ -615,7 +615,7 @@ pgtable_bad(struct pt_regs *regs, unsigned long error_code,
         dump_pagetable(address);
 
         tsk->thread.cr2         = address;
-        tsk->thread.trap_no     = 14;
+        tsk->thread.trap_nr     = X86_TRAP_PF;
         tsk->thread.error_code  = error_code;
 
         if (__die("Bad pagetable", regs, error_code))
@@ -636,7 +636,7 @@ no_context(struct pt_regs *regs, unsigned long error_code,
         /* Are we prepared to handle this kernel fault? */
         if (fixup_exception(regs)) {
                 if (current_thread_info()->sig_on_uaccess_error && signal) {
-                        tsk->thread.trap_no = 14;
+                        tsk->thread.trap_nr = X86_TRAP_PF;
                         tsk->thread.error_code = error_code | PF_USER;
                         tsk->thread.cr2 = address;
 
@@ -676,7 +676,7 @@ no_context(struct pt_regs *regs, unsigned long error_code,
                 printk(KERN_EMERG "Thread overran stack, or stack corrupted\n");
 
         tsk->thread.cr2         = address;
-        tsk->thread.trap_no     = 14;
+        tsk->thread.trap_nr     = X86_TRAP_PF;
         tsk->thread.error_code  = error_code;
 
         sig = SIGKILL;
@@ -754,7 +754,7 @@ __bad_area_nosemaphore(struct pt_regs *regs, unsigned long error_code,
                 /* Kernel addresses are always protection faults: */
                 tsk->thread.cr2         = address;
                 tsk->thread.error_code  = error_code | (address >= TASK_SIZE);
-                tsk->thread.trap_no     = 14;
+                tsk->thread.trap_nr     = X86_TRAP_PF;
 
                 force_sig_info_fault(SIGSEGV, si_code, address, tsk, 0);
 
@@ -838,7 +838,7 @@ do_sigbus(struct pt_regs *regs, unsigned long error_code, unsigned long address,
 
         tsk->thread.cr2         = address;
         tsk->thread.error_code  = error_code;
-        tsk->thread.trap_no     = 14;
+        tsk->thread.trap_nr     = X86_TRAP_PF;
 
 #ifdef CONFIG_MEMORY_FAILURE
         if (fault & (VM_FAULT_HWPOISON|VM_FAULT_HWPOISON_LARGE)) {
diff --git a/arch/x86/mm/highmem_32.c b/arch/x86/mm/highmem_32.c
index f4f29b19fac5..6f31ee56c008 100644
--- a/arch/x86/mm/highmem_32.c
+++ b/arch/x86/mm/highmem_32.c
@@ -51,11 +51,11 @@ void *kmap_atomic_prot(struct page *page, pgprot_t prot)
 }
 EXPORT_SYMBOL(kmap_atomic_prot);
 
-void *__kmap_atomic(struct page *page)
+void *kmap_atomic(struct page *page)
 {
         return kmap_atomic_prot(page, kmap_prot);
 }
-EXPORT_SYMBOL(__kmap_atomic);
+EXPORT_SYMBOL(kmap_atomic);
 
 /*
  * This is the same as kmap_atomic() but can map memory that doesn't
diff --git a/arch/x86/mm/hugetlbpage.c b/arch/x86/mm/hugetlbpage.c
index f581a18c0d4d..f6679a7fb8ca 100644
--- a/arch/x86/mm/hugetlbpage.c
+++ b/arch/x86/mm/hugetlbpage.c
@@ -308,10 +308,11 @@ static unsigned long hugetlb_get_unmapped_area_topdown(struct file *file,
 {
         struct hstate *h = hstate_file(file);
         struct mm_struct *mm = current->mm;
-        struct vm_area_struct *vma, *prev_vma;
-        unsigned long base = mm->mmap_base, addr = addr0;
+        struct vm_area_struct *vma;
+        unsigned long base = mm->mmap_base;
+        unsigned long addr = addr0;
         unsigned long largest_hole = mm->cached_hole_size;
-        int first_time = 1;
+        unsigned long start_addr;
 
         /* don't allow allocations above current base */
         if (mm->free_area_cache > base)
@@ -322,6 +323,8 @@ static unsigned long hugetlb_get_unmapped_area_topdown(struct file *file,
                 mm->free_area_cache  = base;
         }
 try_again:
+        start_addr = mm->free_area_cache;
+
         /* make sure it can fit in the remaining address space */
         if (mm->free_area_cache < len)
                 goto fail;
@@ -333,24 +336,18 @@ try_again:
                  * Lookup failure means no vma is above this address,
                  * i.e. return with success:
                  */
-                if (!(vma = find_vma_prev(mm, addr, &prev_vma)))
+                vma = find_vma(mm, addr);
+                if (!vma)
                         return addr;
 
-                /*
-                 * new region fits between prev_vma->vm_end and
-                 * vma->vm_start, use it:
-                 */
-                if (addr + len <= vma->vm_start &&
-                            (!prev_vma || (addr >= prev_vma->vm_end))) {
+                if (addr + len <= vma->vm_start) {
                         /* remember the address as a hint for next time */
                         mm->cached_hole_size = largest_hole;
                         return (mm->free_area_cache = addr);
-                } else {
+                } else if (mm->free_area_cache == vma->vm_end) {
                         /* pull free_area_cache down to the first hole */
-                        if (mm->free_area_cache == vma->vm_end) {
-                                mm->free_area_cache = vma->vm_start;
-                                mm->cached_hole_size = largest_hole;
-                        }
+                        mm->free_area_cache = vma->vm_start;
+                        mm->cached_hole_size = largest_hole;
                 }
 
                 /* remember the largest hole we saw so far */
@@ -366,10 +363,9 @@ fail:
          * if hint left us with no space for the requested
          * mapping then try again:
          */
-        if (first_time) {
+        if (start_addr != base) {
                 mm->free_area_cache = base;
                 largest_hole = 0;
-                first_time = 0;
                 goto try_again;
         }
         /*
diff --git a/arch/x86/mm/init.c b/arch/x86/mm/init.c
index 2e92fdcbea86..319b6f2fb8b9 100644
--- a/arch/x86/mm/init.c
+++ b/arch/x86/mm/init.c
@@ -12,7 +12,6 @@
 #include <asm/page_types.h>
 #include <asm/sections.h>
 #include <asm/setup.h>
-#include <asm/system.h>
 #include <asm/tlbflush.h>
 #include <asm/tlb.h>
 #include <asm/proto.h>
diff --git a/arch/x86/mm/init_32.c b/arch/x86/mm/init_32.c
index 8663f6c47ccb..575d86f85ce4 100644
--- a/arch/x86/mm/init_32.c
+++ b/arch/x86/mm/init_32.c
@@ -35,7 +35,6 @@
 #include <asm/asm.h>
 #include <asm/bios_ebda.h>
 #include <asm/processor.h>
-#include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
 #include <asm/dma.h>
diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c
index f9476a0f8cb6..2b6b4a3c8beb 100644
--- a/arch/x86/mm/init_64.c
+++ b/arch/x86/mm/init_64.c
@@ -35,7 +35,6 @@
 
 #include <asm/processor.h>
 #include <asm/bios_ebda.h>
-#include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>
diff --git a/arch/x86/mm/kmemcheck/selftest.c b/arch/x86/mm/kmemcheck/selftest.c
index 036efbea8b28..aef7140c0063 100644
--- a/arch/x86/mm/kmemcheck/selftest.c
+++ b/arch/x86/mm/kmemcheck/selftest.c
@@ -1,3 +1,4 @@
+#include <linux/bug.h>
 #include <linux/kernel.h>
 
 #include "opcode.h"
diff --git a/arch/x86/mm/numa_emulation.c b/arch/x86/mm/numa_emulation.c
index 46db56845f18..871dd8868170 100644
--- a/arch/x86/mm/numa_emulation.c
+++ b/arch/x86/mm/numa_emulation.c
@@ -28,7 +28,7 @@ static int __init emu_find_memblk_by_nid(int nid, const struct numa_meminfo *mi)
         return -ENOENT;
 }
 
-static u64 mem_hole_size(u64 start, u64 end)
+static u64 __init mem_hole_size(u64 start, u64 end)
 {
         unsigned long start_pfn = PFN_UP(start);
         unsigned long end_pfn = PFN_DOWN(end);
@@ -60,7 +60,7 @@ static int __init emu_setup_memblk(struct numa_meminfo *ei,
         eb->nid = nid;
 
         if (emu_nid_to_phys[nid] == NUMA_NO_NODE)
-                emu_nid_to_phys[nid] = pb->nid;
+                emu_nid_to_phys[nid] = nid;
 
         pb->start += size;
         if (pb->start >= pb->end) {
@@ -339,9 +339,11 @@ void __init numa_emulation(struct numa_meminfo *numa_meminfo, int numa_dist_cnt)
         } else {
                 unsigned long n;
 
-                n = simple_strtoul(emu_cmdline, NULL, 0);
+                n = simple_strtoul(emu_cmdline, &emu_cmdline, 0);
                 ret = split_nodes_interleave(&ei, &pi, 0, max_addr, n);
         }
+        if (*emu_cmdline == ':')
+                emu_cmdline++;
 
         if (ret < 0)
                 goto no_emu;
@@ -418,7 +420,9 @@ void __init numa_emulation(struct numa_meminfo *numa_meminfo, int numa_dist_cnt)
                         int physj = emu_nid_to_phys[j];
                         int dist;
 
-                        if (physi >= numa_dist_cnt || physj >= numa_dist_cnt)
+                        if (get_option(&emu_cmdline, &dist) == 2)
+                                ;
+                        else if (physi >= numa_dist_cnt || physj >= numa_dist_cnt)
                                 dist = physi == physj ?
                                         LOCAL_DISTANCE : REMOTE_DISTANCE;
                         else
diff --git a/arch/x86/mm/pgtable_32.c b/arch/x86/mm/pgtable_32.c
index cac718499256..a69bcb8c7621 100644
--- a/arch/x86/mm/pgtable_32.c
+++ b/arch/x86/mm/pgtable_32.c
@@ -10,7 +10,6 @@
 #include <linux/spinlock.h>
 #include <linux/module.h>
 
-#include <asm/system.h>
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>
 #include <asm/fixmap.h>
diff --git a/arch/x86/mm/srat.c b/arch/x86/mm/srat.c
index 1c1c4f46a7c1..efb5b4b93711 100644
--- a/arch/x86/mm/srat.c
+++ b/arch/x86/mm/srat.c
@@ -70,7 +70,7 @@ acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity *pa)
                 return;
         pxm = pa->proximity_domain;
         apic_id = pa->apic_id;
-        if (!cpu_has_x2apic && (apic_id >= 0xff)) {
+        if (!apic->apic_id_valid(apic_id)) {
                 printk(KERN_INFO "SRAT: PXM %u -> X2APIC 0x%04x ignored\n",
                          pxm, apic_id);
                 return;
diff --git a/arch/x86/mm/tlb.c b/arch/x86/mm/tlb.c
index 125bcad1b757..5e57e113b72c 100644
--- a/arch/x86/mm/tlb.c
+++ b/arch/x86/mm/tlb.c
@@ -61,8 +61,8 @@ static DEFINE_PER_CPU_READ_MOSTLY(int, tlb_vector_offset);
  */
 void leave_mm(int cpu)
 {
-        struct mm_struct *active_mm = percpu_read(cpu_tlbstate.active_mm);
-        if (percpu_read(cpu_tlbstate.state) == TLBSTATE_OK)
+        struct mm_struct *active_mm = this_cpu_read(cpu_tlbstate.active_mm);
+        if (this_cpu_read(cpu_tlbstate.state) == TLBSTATE_OK)
                 BUG();
         if (cpumask_test_cpu(cpu, mm_cpumask(active_mm))) {
                 cpumask_clear_cpu(cpu, mm_cpumask(active_mm));
@@ -154,8 +154,8 @@ void smp_invalidate_interrupt(struct pt_regs *regs)
                  * BUG();
                  */
 
-        if (f->flush_mm == percpu_read(cpu_tlbstate.active_mm)) {
-                if (percpu_read(cpu_tlbstate.state) == TLBSTATE_OK) {
+        if (f->flush_mm == this_cpu_read(cpu_tlbstate.active_mm)) {
+                if (this_cpu_read(cpu_tlbstate.state) == TLBSTATE_OK) {
                         if (f->flush_va == TLB_FLUSH_ALL)
                                 local_flush_tlb();
                         else
@@ -324,7 +324,7 @@ void flush_tlb_page(struct vm_area_struct *vma, unsigned long va)
 static void do_flush_tlb_all(void *info)
 {
         __flush_tlb_all();
-        if (percpu_read(cpu_tlbstate.state) == TLBSTATE_LAZY)
+        if (this_cpu_read(cpu_tlbstate.state) == TLBSTATE_LAZY)
                 leave_mm(smp_processor_id());
 }