6 files changed, 82 insertions, 17 deletions

diff --git a/arch/ia64/mm/Makefile b/arch/ia64/mm/Makefile
index 7078f67887ec..d78d20f0a0f0 100644
--- a/arch/ia64/mm/Makefile
+++ b/arch/ia64/mm/Makefile
@@ -7,6 +7,5 @@ obj-y := init.o fault.o tlb.o extable.o
 obj-$(CONFIG_HUGETLB_PAGE) += hugetlbpage.o
 obj-$(CONFIG_NUMA)         += numa.o
 obj-$(CONFIG_DISCONTIGMEM) += discontig.o
-ifndef CONFIG_DISCONTIGMEM
-obj-y += contig.o
-endif
+obj-$(CONFIG_SPARSEMEM)    += discontig.o
+obj-$(CONFIG_FLATMEM)      += contig.o
diff --git a/arch/ia64/mm/contig.c b/arch/ia64/mm/contig.c
index 91a055f5731f..acaaec4e4681 100644
--- a/arch/ia64/mm/contig.c
+++ b/arch/ia64/mm/contig.c
@@ -269,7 +269,7 @@ paging_init (void)
         efi_memmap_walk(find_largest_hole, (u64 *)&max_gap);
         if (max_gap < LARGE_GAP) {
                 vmem_map = (struct page *) 0;
-                free_area_init_node(0, &contig_page_data, zones_size, 0,
+                free_area_init_node(0, NODE_DATA(0), zones_size, 0,
                                     zholes_size);
         } else {
                 unsigned long map_size;
@@ -282,7 +282,7 @@ paging_init (void)
                 efi_memmap_walk(create_mem_map_page_table, NULL);
 
                 NODE_DATA(0)->node_mem_map = vmem_map;
-                free_area_init_node(0, &contig_page_data, zones_size,
+                free_area_init_node(0, NODE_DATA(0), zones_size,
                                     0, zholes_size);
 
                 printk("Virtual mem_map starts at 0x%p\n", mem_map);
diff --git a/arch/ia64/mm/discontig.c b/arch/ia64/mm/discontig.c
index b5c90e548195..a3788fb84809 100644
--- a/arch/ia64/mm/discontig.c
+++ b/arch/ia64/mm/discontig.c
@@ -421,6 +421,37 @@ static void __init memory_less_nodes(void)
         return;
 }
 
+#ifdef CONFIG_SPARSEMEM
+/**
+ * register_sparse_mem - notify SPARSEMEM that this memory range exists.
+ * @start: physical start of range
+ * @end: physical end of range
+ * @arg: unused
+ *
+ * Simply calls SPARSEMEM to register memory section(s).
+ */
+static int __init register_sparse_mem(unsigned long start, unsigned long end,
+        void *arg)
+{
+        int nid;
+
+        start = __pa(start) >> PAGE_SHIFT;
+        end = __pa(end) >> PAGE_SHIFT;
+        nid = early_pfn_to_nid(start);
+        memory_present(nid, start, end);
+
+        return 0;
+}
+
+static void __init arch_sparse_init(void)
+{
+        efi_memmap_walk(register_sparse_mem, NULL);
+        sparse_init();
+}
+#else
+#define arch_sparse_init() do {} while (0)
+#endif
+
 /**
  * find_memory - walk the EFI memory map and setup the bootmem allocator
  *
@@ -528,8 +559,10 @@ void show_mem(void)
                 int shared = 0, cached = 0, reserved = 0;
                 printk("Node ID: %d\n", pgdat->node_id);
                 for(i = 0; i < pgdat->node_spanned_pages; i++) {
-                        struct page *page = pgdat_page_nr(pgdat, i);
-                        if (!ia64_pfn_valid(pgdat->node_start_pfn+i))
+                        struct page *page;
+                        if (pfn_valid(pgdat->node_start_pfn + i))
+                                page = pfn_to_page(pgdat->node_start_pfn + i);
+                        else
                                 continue;
                         if (PageReserved(page))
                                 reserved++;
@@ -648,12 +681,16 @@ void __init paging_init(void)
 
         max_dma = virt_to_phys((void *) MAX_DMA_ADDRESS) >> PAGE_SHIFT;
 
+        arch_sparse_init();
+
         efi_memmap_walk(filter_rsvd_memory, count_node_pages);
 
+#ifdef CONFIG_VIRTUAL_MEM_MAP
         vmalloc_end -= PAGE_ALIGN(max_low_pfn * sizeof(struct page));
         vmem_map = (struct page *) vmalloc_end;
         efi_memmap_walk(create_mem_map_page_table, NULL);
         printk("Virtual mem_map starts at 0x%p\n", vmem_map);
+#endif
 
         for_each_online_node(node) {
                 memset(zones_size, 0, sizeof(zones_size));
@@ -690,7 +727,9 @@ void __init paging_init(void)
 
                 pfn_offset = mem_data[node].min_pfn;
 
+#ifdef CONFIG_VIRTUAL_MEM_MAP
                 NODE_DATA(node)->node_mem_map = vmem_map + pfn_offset;
+#endif
                 free_area_init_node(node, NODE_DATA(node), zones_size,
                                     pfn_offset, zholes_size);
         }
diff --git a/arch/ia64/mm/init.c b/arch/ia64/mm/init.c
index 1281c609ee98..98246acd4991 100644
--- a/arch/ia64/mm/init.c
+++ b/arch/ia64/mm/init.c
@@ -593,7 +593,7 @@ mem_init (void)
         platform_dma_init();
 #endif
 
-#ifndef CONFIG_DISCONTIGMEM
+#ifdef CONFIG_FLATMEM
         if (!mem_map)
                 BUG();
         max_mapnr = max_low_pfn;
diff --git a/arch/ia64/mm/numa.c b/arch/ia64/mm/numa.c
index 77118bbf3d8b..4e5c8b36ad93 100644
--- a/arch/ia64/mm/numa.c
+++ b/arch/ia64/mm/numa.c
@@ -47,3 +47,27 @@ paddr_to_nid(unsigned long paddr)
 
         return (i < num_node_memblks) ? node_memblk[i].nid : (num_node_memblks ? -1 : 0);
 }
+
+#if defined(CONFIG_SPARSEMEM) && defined(CONFIG_NUMA)
+/*
+ * Because of holes evaluate on section limits.
+ * If the section of memory exists, then return the node where the section
+ * resides.  Otherwise return node 0 as the default.  This is used by
+ * SPARSEMEM to allocate the SPARSEMEM sectionmap on the NUMA node where
+ * the section resides.
+ */
+int early_pfn_to_nid(unsigned long pfn)
+{
+        int i, section = pfn >> PFN_SECTION_SHIFT, ssec, esec;
+
+        for (i = 0; i < num_node_memblks; i++) {
+                ssec = node_memblk[i].start_paddr >> PA_SECTION_SHIFT;
+                esec = (node_memblk[i].start_paddr + node_memblk[i].size +
+                        ((1L << PA_SECTION_SHIFT) - 1)) >> PA_SECTION_SHIFT;
+                if (section >= ssec && section < esec)
+                        return node_memblk[i].nid;
+        }
+
+        return 0;
+}
+#endif
diff --git a/arch/ia64/mm/tlb.c b/arch/ia64/mm/tlb.c
index 464557e4ed82..c93e0f2b5fea 100644
--- a/arch/ia64/mm/tlb.c
+++ b/arch/ia64/mm/tlb.c
@@ -77,19 +77,25 @@ wrap_mmu_context (struct mm_struct *mm)
         /* can't call flush_tlb_all() here because of race condition with O(1) scheduler [EF] */
         {
                 int cpu = get_cpu(); /* prevent preemption/migration */
-                for (i = 0; i < NR_CPUS; ++i)
-                        if (cpu_online(i) && (i != cpu))
+                for_each_online_cpu(i) {
+                        if (i != cpu)
                                 per_cpu(ia64_need_tlb_flush, i) = 1;
+                }
                 put_cpu();
         }
         local_flush_tlb_all();
 }
 
 void
-ia64_global_tlb_purge (unsigned long start, unsigned long end, unsigned long nbits)
+ia64_global_tlb_purge (struct mm_struct *mm, unsigned long start, unsigned long end, unsigned long nbits)
 {
         static DEFINE_SPINLOCK(ptcg_lock);
 
+        if (mm != current->active_mm) {
+                flush_tlb_all();
+                return;
+        }
+
         /* HW requires global serialization of ptc.ga.  */
         spin_lock(&ptcg_lock);
         {
@@ -135,15 +141,12 @@ flush_tlb_range (struct vm_area_struct *vma, unsigned long start, unsigned long
         unsigned long size = end - start;
         unsigned long nbits;
 
+#ifndef CONFIG_SMP
         if (mm != current->active_mm) {
-                /* this does happen, but perhaps it's not worth optimizing for? */
-#ifdef CONFIG_SMP
-                flush_tlb_all();
-#else
                 mm->context = 0;
-#endif
                 return;
         }
+#endif
 
         nbits = ia64_fls(size + 0xfff);
         while (unlikely (((1UL << nbits) & purge.mask) == 0) && (nbits < purge.max_bits))
@@ -153,7 +156,7 @@ flush_tlb_range (struct vm_area_struct *vma, unsigned long start, unsigned long
         start &= ~((1UL << nbits) - 1);
 
 # ifdef CONFIG_SMP
-        platform_global_tlb_purge(start, end, nbits);
+        platform_global_tlb_purge(mm, start, end, nbits);
 # else
         do {
                 ia64_ptcl(start, (nbits<<2));