1 files changed, 116 insertions, 68 deletions

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 253a450c400d..423db0db7c02 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -37,6 +37,7 @@
 #include <linux/nodemask.h>
 #include <linux/vmalloc.h>
 #include <linux/mempolicy.h>
+#include <linux/stop_machine.h>
 
 #include <asm/tlbflush.h>
 #include <asm/div64.h>
@@ -83,8 +84,8 @@ EXPORT_SYMBOL(zone_table);
 static char *zone_names[MAX_NR_ZONES] = { "DMA", "DMA32", "Normal", "HighMem" };
 int min_free_kbytes = 1024;
 
-unsigned long __initdata nr_kernel_pages;
-unsigned long __initdata nr_all_pages;
+unsigned long __meminitdata nr_kernel_pages;
+unsigned long __meminitdata nr_all_pages;
 
 #ifdef CONFIG_DEBUG_VM
 static int page_outside_zone_boundaries(struct zone *zone, struct page *page)
@@ -286,22 +287,27 @@ __find_combined_index(unsigned long page_idx, unsigned int order)
  * we can do coalesce a page and its buddy if
  * (a) the buddy is not in a hole &&
  * (b) the buddy is in the buddy system &&
- * (c) a page and its buddy have the same order.
+ * (c) a page and its buddy have the same order &&
+ * (d) a page and its buddy are in the same zone.
  *
  * For recording whether a page is in the buddy system, we use PG_buddy.
  * Setting, clearing, and testing PG_buddy is serialized by zone->lock.
  *
  * For recording page's order, we use page_private(page).
  */
-static inline int page_is_buddy(struct page *page, int order)
+static inline int page_is_buddy(struct page *page, struct page *buddy,
+                                                                int order)
 {
 #ifdef CONFIG_HOLES_IN_ZONE
-        if (!pfn_valid(page_to_pfn(page)))
+        if (!pfn_valid(page_to_pfn(buddy)))
                 return 0;
 #endif
 
-        if (PageBuddy(page) && page_order(page) == order) {
-                BUG_ON(page_count(page) != 0);
+        if (page_zone_id(page) != page_zone_id(buddy))
+                return 0;
+
+        if (PageBuddy(buddy) && page_order(buddy) == order) {
+                BUG_ON(page_count(buddy) != 0);
                 return 1;
         }
         return 0;
@@ -352,7 +358,7 @@ static inline void __free_one_page(struct page *page,
                 struct page *buddy;
 
                 buddy = __page_find_buddy(page, page_idx, order);
-                if (!page_is_buddy(buddy, order))
+                if (!page_is_buddy(page, buddy, order))
                         break;          /* Move the buddy up one level. */
 
                 list_del(&buddy->lru);
@@ -1485,7 +1491,7 @@ void show_free_areas(void)
         }
 
         for_each_zone(zone) {
-                unsigned long nr, flags, order, total = 0;
+                unsigned long nr[MAX_ORDER], flags, order, total = 0;
 
                 show_node(zone);
                 printk("%s: ", zone->name);
@@ -1496,11 +1502,12 @@ void show_free_areas(void)
 
                 spin_lock_irqsave(&zone->lock, flags);
                 for (order = 0; order < MAX_ORDER; order++) {
-                        nr = zone->free_area[order].nr_free;
-                        total += nr << order;
-                        printk("%lu*%lukB ", nr, K(1UL) << order);
+                        nr[order] = zone->free_area[order].nr_free;
+                        total += nr[order] << order;
                 }
                 spin_unlock_irqrestore(&zone->lock, flags);
+                for (order = 0; order < MAX_ORDER; order++)
+                        printk("%lu*%lukB ", nr[order], K(1UL) << order);
                 printk("= %lukB\n", K(total));
         }
 
@@ -1512,7 +1519,7 @@ void show_free_areas(void)
  *
  * Add all populated zones of a node to the zonelist.
  */
-static int __init build_zonelists_node(pg_data_t *pgdat,
+static int __meminit build_zonelists_node(pg_data_t *pgdat,
                         struct zonelist *zonelist, int nr_zones, int zone_type)
 {
         struct zone *zone;
@@ -1548,7 +1555,7 @@ static inline int highest_zone(int zone_bits)
 
 #ifdef CONFIG_NUMA
 #define MAX_NODE_LOAD (num_online_nodes())
-static int __initdata node_load[MAX_NUMNODES];
+static int __meminitdata node_load[MAX_NUMNODES];
 /**
  * find_next_best_node - find the next node that should appear in a given node's fallback list
  * @node: node whose fallback list we're appending
@@ -1563,7 +1570,7 @@ static int __initdata node_load[MAX_NUMNODES];
  * on them otherwise.
  * It returns -1 if no node is found.
  */
-static int __init find_next_best_node(int node, nodemask_t *used_node_mask)
+static int __meminit find_next_best_node(int node, nodemask_t *used_node_mask)
 {
         int n, val;
         int min_val = INT_MAX;
@@ -1609,7 +1616,7 @@ static int __init find_next_best_node(int node, nodemask_t *used_node_mask)
         return best_node;
 }
 
-static void __init build_zonelists(pg_data_t *pgdat)
+static void __meminit build_zonelists(pg_data_t *pgdat)
 {
         int i, j, k, node, local_node;
         int prev_node, load;
@@ -1661,7 +1668,7 @@ static void __init build_zonelists(pg_data_t *pgdat)
 
 #else   /* CONFIG_NUMA */
 
-static void __init build_zonelists(pg_data_t *pgdat)
+static void __meminit build_zonelists(pg_data_t *pgdat)
 {
         int i, j, k, node, local_node;
 
@@ -1699,14 +1706,29 @@ static void __init build_zonelists(pg_data_t *pgdat)
 
 #endif  /* CONFIG_NUMA */
 
-void __init build_all_zonelists(void)
+/* return values int ....just for stop_machine_run() */
+static int __meminit __build_all_zonelists(void *dummy)
 {
-        int i;
+        int nid;
+        for_each_online_node(nid)
+                build_zonelists(NODE_DATA(nid));
+        return 0;
+}
 
-        for_each_online_node(i)
-                build_zonelists(NODE_DATA(i));
-        printk("Built %i zonelists\n", num_online_nodes());
-        cpuset_init_current_mems_allowed();
+void __meminit build_all_zonelists(void)
+{
+        if (system_state == SYSTEM_BOOTING) {
+                __build_all_zonelists(0);
+                cpuset_init_current_mems_allowed();
+        } else {
+                /* we have to stop all cpus to guaranntee there is no user
+                   of zonelist */
+                stop_machine_run(__build_all_zonelists, NULL, NR_CPUS);
+                /* cpuset refresh routine should be here */
+        }
+        vm_total_pages = nr_free_pagecache_pages();
+        printk("Built %i zonelists.  Total pages: %ld\n",
+                        num_online_nodes(), vm_total_pages);
 }
 
 /*
@@ -1722,7 +1744,8 @@ void __init build_all_zonelists(void)
  */
 #define PAGES_PER_WAITQUEUE     256
 
-static inline unsigned long wait_table_size(unsigned long pages)
+#ifndef CONFIG_MEMORY_HOTPLUG
+static inline unsigned long wait_table_hash_nr_entries(unsigned long pages)
 {
         unsigned long size = 1;
 
@@ -1740,6 +1763,29 @@ static inline unsigned long wait_table_size(unsigned long pages)
 
         return max(size, 4UL);
 }
+#else
+/*
+ * A zone's size might be changed by hot-add, so it is not possible to determine
+ * a suitable size for its wait_table.  So we use the maximum size now.
+ *
+ * The max wait table size = 4096 x sizeof(wait_queue_head_t).   ie:
+ *
+ *    i386 (preemption config)    : 4096 x 16 = 64Kbyte.
+ *    ia64, x86-64 (no preemption): 4096 x 20 = 80Kbyte.
+ *    ia64, x86-64 (preemption)   : 4096 x 24 = 96Kbyte.
+ *
+ * The maximum entries are prepared when a zone's memory is (512K + 256) pages
+ * or more by the traditional way. (See above).  It equals:
+ *
+ *    i386, x86-64, powerpc(4K page size) : =  ( 2G + 1M)byte.
+ *    ia64(16K page size)                 : =  ( 8G + 4M)byte.
+ *    powerpc (64K page size)             : =  (32G +16M)byte.
+ */
+static inline unsigned long wait_table_hash_nr_entries(unsigned long pages)
+{
+        return 4096UL;
+}
+#endif
 
 /*
  * This is an integer logarithm so that shifts can be used later
@@ -2005,23 +2051,46 @@ void __init setup_per_cpu_pageset(void)
 #endif
 
 static __meminit
-void zone_wait_table_init(struct zone *zone, unsigned long zone_size_pages)
+int zone_wait_table_init(struct zone *zone, unsigned long zone_size_pages)
 {
         int i;
         struct pglist_data *pgdat = zone->zone_pgdat;
+        size_t alloc_size;
 
         /*
          * The per-page waitqueue mechanism uses hashed waitqueues
          * per zone.
          */
-        zone->wait_table_size = wait_table_size(zone_size_pages);
-        zone->wait_table_bits = wait_table_bits(zone->wait_table_size);
-        zone->wait_table = (wait_queue_head_t *)
-                alloc_bootmem_node(pgdat, zone->wait_table_size
-                                        * sizeof(wait_queue_head_t));
+        zone->wait_table_hash_nr_entries =
+                 wait_table_hash_nr_entries(zone_size_pages);
+        zone->wait_table_bits =
+                wait_table_bits(zone->wait_table_hash_nr_entries);
+        alloc_size = zone->wait_table_hash_nr_entries
+                                        * sizeof(wait_queue_head_t);
+
+        if (system_state == SYSTEM_BOOTING) {
+                zone->wait_table = (wait_queue_head_t *)
+                        alloc_bootmem_node(pgdat, alloc_size);
+        } else {
+                /*
+                 * This case means that a zone whose size was 0 gets new memory
+                 * via memory hot-add.
+                 * But it may be the case that a new node was hot-added.  In
+                 * this case vmalloc() will not be able to use this new node's
+                 * memory - this wait_table must be initialized to use this new
+                 * node itself as well.
+                 * To use this new node's memory, further consideration will be
+                 * necessary.
+                 */
+                zone->wait_table = (wait_queue_head_t *)vmalloc(alloc_size);
+        }
+        if (!zone->wait_table)
+                return -ENOMEM;
 
-        for(i = 0; i < zone->wait_table_size; ++i)
+        for(i = 0; i < zone->wait_table_hash_nr_entries; ++i)
                 init_waitqueue_head(zone->wait_table + i);
+
+        return 0;
 }
 
 static __meminit void zone_pcp_init(struct zone *zone)
@@ -2043,12 +2112,15 @@ static __meminit void zone_pcp_init(struct zone *zone)
                         zone->name, zone->present_pages, batch);
 }
 
-static __meminit void init_currently_empty_zone(struct zone *zone,
-                unsigned long zone_start_pfn, unsigned long size)
+__meminit int init_currently_empty_zone(struct zone *zone,
+                                        unsigned long zone_start_pfn,
+                                        unsigned long size)
 {
         struct pglist_data *pgdat = zone->zone_pgdat;
-
-        zone_wait_table_init(zone, size);
+        int ret;
+        ret = zone_wait_table_init(zone, size);
+        if (ret)
+                return ret;
         pgdat->nr_zones = zone_idx(zone) + 1;
 
         zone->zone_start_pfn = zone_start_pfn;
@@ -2056,6 +2128,8 @@ static __meminit void init_currently_empty_zone(struct zone *zone,
         memmap_init(size, pgdat->node_id, zone_idx(zone), zone_start_pfn);
 
         zone_init_free_lists(pgdat, zone, zone->spanned_pages);
+
+        return 0;
 }
 
 /*
@@ -2064,12 +2138,13 @@ static __meminit void init_currently_empty_zone(struct zone *zone,
  *   - mark all memory queues empty
  *   - clear the memory bitmaps
  */
-static void __init free_area_init_core(struct pglist_data *pgdat,
+static void __meminit free_area_init_core(struct pglist_data *pgdat,
                 unsigned long *zones_size, unsigned long *zholes_size)
 {
         unsigned long j;
         int nid = pgdat->node_id;
         unsigned long zone_start_pfn = pgdat->node_start_pfn;
+        int ret;
 
         pgdat_resize_init(pgdat);
         pgdat->nr_zones = 0;
@@ -2111,7 +2186,8 @@ static void __init free_area_init_core(struct pglist_data *pgdat,
                         continue;
 
                 zonetable_add(zone, nid, j, zone_start_pfn, size);
-                init_currently_empty_zone(zone, zone_start_pfn, size);
+                ret = init_currently_empty_zone(zone, zone_start_pfn, size);
+                BUG_ON(ret);
                 zone_start_pfn += size;
         }
 }
@@ -2152,7 +2228,7 @@ static void __init alloc_node_mem_map(struct pglist_data *pgdat)
 #endif /* CONFIG_FLAT_NODE_MEM_MAP */
 }
 
-void __init free_area_init_node(int nid, struct pglist_data *pgdat,
+void __meminit free_area_init_node(int nid, struct pglist_data *pgdat,
                 unsigned long *zones_size, unsigned long node_start_pfn,
                 unsigned long *zholes_size)
 {
@@ -2804,42 +2880,14 @@ void *__init alloc_large_system_hash(const char *tablename,
 }
 
 #ifdef CONFIG_OUT_OF_LINE_PFN_TO_PAGE
-/*
- * pfn <-> page translation. out-of-line version.
- * (see asm-generic/memory_model.h)
- */
-#if defined(CONFIG_FLATMEM)
 struct page *pfn_to_page(unsigned long pfn)
 {
-        return mem_map + (pfn - ARCH_PFN_OFFSET);
+        return __pfn_to_page(pfn);
 }
 unsigned long page_to_pfn(struct page *page)
 {
-        return (page - mem_map) + ARCH_PFN_OFFSET;
-}
-#elif defined(CONFIG_DISCONTIGMEM)
-struct page *pfn_to_page(unsigned long pfn)
-{
-        int nid = arch_pfn_to_nid(pfn);
-        return NODE_DATA(nid)->node_mem_map + arch_local_page_offset(pfn,nid);
-}
-unsigned long page_to_pfn(struct page *page)
-{
-        struct pglist_data *pgdat = NODE_DATA(page_to_nid(page));
-        return (page - pgdat->node_mem_map) + pgdat->node_start_pfn;
-}
-#elif defined(CONFIG_SPARSEMEM)
-struct page *pfn_to_page(unsigned long pfn)
-{
-        return __section_mem_map_addr(__pfn_to_section(pfn)) + pfn;
-}
-
-unsigned long page_to_pfn(struct page *page)
-{
-        long section_id = page_to_section(page);
-        return page - __section_mem_map_addr(__nr_to_section(section_id));
+        return __page_to_pfn(page);
 }
-#endif /* CONFIG_FLATMEM/DISCONTIGMME/SPARSEMEM */
 EXPORT_SYMBOL(pfn_to_page);
 EXPORT_SYMBOL(page_to_pfn);
 #endif /* CONFIG_OUT_OF_LINE_PFN_TO_PAGE */