8 files changed, 39 insertions, 30 deletions

diff --git a/arch/x86/mm/discontig_32.c b/arch/x86/mm/discontig_32.c
index eba0bbede7a6..18378850e25a 100644
--- a/arch/x86/mm/discontig_32.c
+++ b/arch/x86/mm/discontig_32.c
@@ -120,7 +120,7 @@ int __init get_memcfg_numa_flat(void)
         printk("NUMA - single node, flat memory mode\n");
 
         /* Run the memory configuration and find the top of memory. */
-        find_max_pfn();
+        propagate_e820_map();
         node_start_pfn[0] = 0;
         node_end_pfn[0] = max_pfn;
         memory_present(0, 0, max_pfn);
@@ -134,7 +134,7 @@ int __init get_memcfg_numa_flat(void)
 /*
  * Find the highest page frame number we have available for the node
  */
-static void __init find_max_pfn_node(int nid)
+static void __init propagate_e820_map_node(int nid)
 {
         if (node_end_pfn[nid] > max_pfn)
                 node_end_pfn[nid] = max_pfn;
@@ -379,7 +379,7 @@ unsigned long __init setup_memory(void)
         printk("High memory starts at vaddr %08lx\n",
                         (ulong) pfn_to_kaddr(highstart_pfn));
         for_each_online_node(nid)
-                find_max_pfn_node(nid);
+                propagate_e820_map_node(nid);
 
         memset(NODE_DATA(0), 0, sizeof(struct pglist_data));
         NODE_DATA(0)->bdata = &node0_bdata;
diff --git a/arch/x86/mm/init_32.c b/arch/x86/mm/init_32.c
index 1500dc8d63e4..9ec62da85fd7 100644
--- a/arch/x86/mm/init_32.c
+++ b/arch/x86/mm/init_32.c
@@ -1,5 +1,4 @@
 /*
- *  linux/arch/i386/mm/init.c
  *
  *  Copyright (C) 1995  Linus Torvalds
  *
diff --git a/arch/x86/mm/init_64.c b/arch/x86/mm/init_64.c
index 1076097dcab2..1ff7906a9a4d 100644
--- a/arch/x86/mm/init_64.c
+++ b/arch/x86/mm/init_64.c
@@ -47,9 +47,6 @@
 #include <asm/numa.h>
 #include <asm/cacheflush.h>
 
-const struct dma_mapping_ops *dma_ops;
-EXPORT_SYMBOL(dma_ops);
-
 static unsigned long dma_reserve __initdata;
 
 DEFINE_PER_CPU(struct mmu_gather, mmu_gathers);
diff --git a/arch/x86/mm/ioremap.c b/arch/x86/mm/ioremap.c
index c590fd200e29..3a4baf95e24d 100644
--- a/arch/x86/mm/ioremap.c
+++ b/arch/x86/mm/ioremap.c
@@ -134,7 +134,7 @@ static void __iomem *__ioremap(resource_size_t phys_addr, unsigned long size,
 
         if (!phys_addr_valid(phys_addr)) {
                 printk(KERN_WARNING "ioremap: invalid physical address %llx\n",
-                       phys_addr);
+                       (unsigned long long)phys_addr);
                 WARN_ON_ONCE(1);
                 return NULL;
         }
@@ -187,7 +187,8 @@ static void __iomem *__ioremap(resource_size_t phys_addr, unsigned long size,
                      new_prot_val == _PAGE_CACHE_WB)) {
                         pr_debug(
                 "ioremap error for 0x%llx-0x%llx, requested 0x%lx, got 0x%lx\n",
-                                phys_addr, phys_addr + size,
+                                (unsigned long long)phys_addr,
+                                (unsigned long long)(phys_addr + size),
                                 prot_val, new_prot_val);
                         free_memtype(phys_addr, phys_addr + size);
                         return NULL;
diff --git a/arch/x86/mm/k8topology_64.c b/arch/x86/mm/k8topology_64.c
index 7a2ebce87df5..86808e666f9c 100644
--- a/arch/x86/mm/k8topology_64.c
+++ b/arch/x86/mm/k8topology_64.c
@@ -164,7 +164,7 @@ int __init k8_scan_nodes(unsigned long start, unsigned long end)
         if (!found)
                 return -1;
 
-        memnode_shift = compute_hash_shift(nodes, 8);
+        memnode_shift = compute_hash_shift(nodes, 8, NULL);
         if (memnode_shift < 0) {
                 printk(KERN_ERR "No NUMA node hash function found. Contact maintainer\n");
                 return -1;
diff --git a/arch/x86/mm/numa_64.c b/arch/x86/mm/numa_64.c
index 2ea56f48f29b..cb3170186355 100644
--- a/arch/x86/mm/numa_64.c
+++ b/arch/x86/mm/numa_64.c
@@ -60,7 +60,7 @@ unsigned long __initdata nodemap_size;
  * -1 if node overlap or lost ram (shift too big)
  */
 static int __init populate_memnodemap(const struct bootnode *nodes,
-                                      int numnodes, int shift)
+                                      int numnodes, int shift, int *nodeids)
 {
         unsigned long addr, end;
         int i, res = -1;
@@ -76,7 +76,12 @@ static int __init populate_memnodemap(const struct bootnode *nodes,
                 do {
                         if (memnodemap[addr >> shift] != NUMA_NO_NODE)
                                 return -1;
-                        memnodemap[addr >> shift] = i;
+
+                        if (!nodeids)
+                                memnodemap[addr >> shift] = i;
+                        else
+                                memnodemap[addr >> shift] = nodeids[i];
+
                         addr += (1UL << shift);
                 } while (addr < end);
                 res = 1;
@@ -139,7 +144,8 @@ static int __init extract_lsb_from_nodes(const struct bootnode *nodes,
         return i;
 }
 
-int __init compute_hash_shift(struct bootnode *nodes, int numnodes)
+int __init compute_hash_shift(struct bootnode *nodes, int numnodes,
+                              int *nodeids)
 {
         int shift;
 
@@ -149,7 +155,7 @@ int __init compute_hash_shift(struct bootnode *nodes, int numnodes)
         printk(KERN_DEBUG "NUMA: Using %d for the hash shift.\n",
                 shift);
 
-        if (populate_memnodemap(nodes, numnodes, shift) != 1) {
+        if (populate_memnodemap(nodes, numnodes, shift, nodeids) != 1) {
                 printk(KERN_INFO "Your memory is not aligned you need to "
                        "rebuild your kernel with a bigger NODEMAPSIZE "
                        "shift=%d\n", shift);
@@ -462,7 +468,7 @@ done:
                 }
         }
 out:
-        memnode_shift = compute_hash_shift(nodes, num_nodes);
+        memnode_shift = compute_hash_shift(nodes, num_nodes, NULL);
         if (memnode_shift < 0) {
                 memnode_shift = 0;
                 printk(KERN_ERR "No NUMA hash function found.  NUMA emulation "
diff --git a/arch/x86/mm/pgtable_32.c b/arch/x86/mm/pgtable_32.c
index 3165ec0672bd..6fb9e7c6893f 100644
--- a/arch/x86/mm/pgtable_32.c
+++ b/arch/x86/mm/pgtable_32.c
@@ -1,7 +1,3 @@
-/*
- *  linux/arch/i386/mm/pgtable.c
- */
-
 #include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
diff --git a/arch/x86/mm/srat_64.c b/arch/x86/mm/srat_64.c
index 1bae9c855ceb..fb43d89f46f3 100644
--- a/arch/x86/mm/srat_64.c
+++ b/arch/x86/mm/srat_64.c
@@ -32,6 +32,10 @@ static struct bootnode nodes_add[MAX_NUMNODES];
 static int found_add_area __initdata;
 int hotadd_percent __initdata = 0;
 
+static int num_node_memblks __initdata;
+static struct bootnode node_memblk_range[NR_NODE_MEMBLKS] __initdata;
+static int memblk_nodeid[NR_NODE_MEMBLKS] __initdata;
+
 /* Too small nodes confuse the VM badly. Usually they result
    from BIOS bugs. */
 #define NODE_MIN_SIZE (4*1024*1024)
@@ -41,17 +45,17 @@ static __init int setup_node(int pxm)
         return acpi_map_pxm_to_node(pxm);
 }
 
-static __init int conflicting_nodes(unsigned long start, unsigned long end)
+static __init int conflicting_memblks(unsigned long start, unsigned long end)
 {
         int i;
-        for_each_node_mask(i, nodes_parsed) {
-                struct bootnode *nd = &nodes[i];
+        for (i = 0; i < num_node_memblks; i++) {
+                struct bootnode *nd = &node_memblk_range[i];
                 if (nd->start == nd->end)
                         continue;
                 if (nd->end > start && nd->start < end)
-                        return i;
+                        return memblk_nodeid[i];
                 if (nd->end == end && nd->start == start)
-                        return i;
+                        return memblk_nodeid[i];
         }
         return -1;
 }
@@ -258,7 +262,7 @@ acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
                 bad_srat();
                 return;
         }
-        i = conflicting_nodes(start, end);
+        i = conflicting_memblks(start, end);
         if (i == node) {
                 printk(KERN_WARNING
                 "SRAT: Warning: PXM %d (%lx-%lx) overlaps with itself (%Lx-%Lx)\n",
@@ -283,10 +287,10 @@ acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
                         nd->end = end;
         }
 
-        printk(KERN_INFO "SRAT: Node %u PXM %u %Lx-%Lx\n", node, pxm,
-               nd->start, nd->end);
-        e820_register_active_regions(node, nd->start >> PAGE_SHIFT,
-                                                nd->end >> PAGE_SHIFT);
+        printk(KERN_INFO "SRAT: Node %u PXM %u %lx-%lx\n", node, pxm,
+               start, end);
+        e820_register_active_regions(node, start >> PAGE_SHIFT,
+                                     end >> PAGE_SHIFT);
         push_node_boundaries(node, nd->start >> PAGE_SHIFT,
                                                 nd->end >> PAGE_SHIFT);
 
@@ -298,6 +302,11 @@ acpi_numa_memory_affinity_init(struct acpi_srat_mem_affinity *ma)
                 if ((nd->start | nd->end) == 0)
                         node_clear(node, nodes_parsed);
         }
+
+        node_memblk_range[num_node_memblks].start = start;
+        node_memblk_range[num_node_memblks].end = end;
+        memblk_nodeid[num_node_memblks] = node;
+        num_node_memblks++;
 }
 
 /* Sanity check to catch more bad SRATs (they are amazingly common).
@@ -368,7 +377,8 @@ int __init acpi_scan_nodes(unsigned long start, unsigned long end)
                 return -1;
         }
 
-        memnode_shift = compute_hash_shift(nodes, MAX_NUMNODES);
+        memnode_shift = compute_hash_shift(node_memblk_range, num_node_memblks,
+                                           memblk_nodeid);
         if (memnode_shift < 0) {
                 printk(KERN_ERR
                      "SRAT: No NUMA node hash function found. Contact maintainer\n");