1 files changed, 63 insertions, 17 deletions

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index dc523a1f270d..123c60586740 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -51,6 +51,7 @@ nodemask_t node_possible_map __read_mostly = NODE_MASK_ALL;
 EXPORT_SYMBOL(node_possible_map);
 unsigned long totalram_pages __read_mostly;
 unsigned long totalhigh_pages __read_mostly;
+unsigned long totalreserve_pages __read_mostly;
 long nr_swap_pages;
 int percpu_pagelist_fraction;
 
@@ -151,7 +152,8 @@ static void bad_page(struct page *page)
                         1 << PG_reclaim |
                         1 << PG_slab    |
                         1 << PG_swapcache |
-                        1 << PG_writeback );
+                        1 << PG_writeback |
+                        1 << PG_buddy );
         set_page_count(page, 0);
         reset_page_mapcount(page);
         page->mapping = NULL;
@@ -230,18 +232,20 @@ static inline void prep_zero_page(struct page *page, int order, gfp_t gfp_flags)
  * zone->lock is already acquired when we use these.
  * So, we don't need atomic page->flags operations here.
  */
-static inline unsigned long page_order(struct page *page) {
+static inline unsigned long page_order(struct page *page)
+{
         return page_private(page);
 }
 
-static inline void set_page_order(struct page *page, int order) {
+static inline void set_page_order(struct page *page, int order)
+{
         set_page_private(page, order);
-        __SetPagePrivate(page);
+        __SetPageBuddy(page);
 }
 
 static inline void rmv_page_order(struct page *page)
 {
-        __ClearPagePrivate(page);
+        __ClearPageBuddy(page);
         set_page_private(page, 0);
 }
 
@@ -280,11 +284,13 @@ __find_combined_index(unsigned long page_idx, unsigned int order)
  * This function checks whether a page is free && is the buddy
  * we can do coalesce a page and its buddy if
  * (a) the buddy is not in a hole &&
- * (b) the buddy is free &&
- * (c) the buddy is on the buddy system &&
- * (d) a page and its buddy have the same order.
- * for recording page's order, we use page_private(page) and PG_private.
+ * (b) the buddy is in the buddy system &&
+ * (c) a page and its buddy have the same order.
  *
+ * 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)
 {
@@ -293,11 +299,11 @@ static inline int page_is_buddy(struct page *page, int order)
                 return 0;
 #endif
 
-       if (PagePrivate(page)           &&
-           (page_order(page) == order) &&
-            page_count(page) == 0)
-               return 1;
-       return 0;
+        if (PageBuddy(page) && page_order(page) == order) {
+                BUG_ON(page_count(page) != 0);
+                return 1;
+        }
+        return 0;
 }
 
 /*
@@ -313,7 +319,7 @@ static inline int page_is_buddy(struct page *page, int order)
  * as necessary, plus some accounting needed to play nicely with other
  * parts of the VM system.
  * At each level, we keep a list of pages, which are heads of continuous
- * free pages of length of (1 << order) and marked with PG_Private.Page's
+ * free pages of length of (1 << order) and marked with PG_buddy. Page's
  * order is recorded in page_private(page) field.
  * So when we are allocating or freeing one, we can derive the state of the
  * other.  That is, if we allocate a small block, and both were   
@@ -376,7 +382,8 @@ static inline int free_pages_check(struct page *page)
                         1 << PG_slab    |
                         1 << PG_swapcache |
                         1 << PG_writeback |
-                        1 << PG_reserved ))))
+                        1 << PG_reserved |
+                        1 << PG_buddy ))))
                 bad_page(page);
         if (PageDirty(page))
                 __ClearPageDirty(page);
@@ -524,7 +531,8 @@ static int prep_new_page(struct page *page, int order, gfp_t gfp_flags)
                         1 << PG_slab    |
                         1 << PG_swapcache |
                         1 << PG_writeback |
-                        1 << PG_reserved ))))
+                        1 << PG_reserved |
+                        1 << PG_buddy ))))
                 bad_page(page);
 
         /*
@@ -2472,6 +2480,38 @@ void __init page_alloc_init(void)
 }
 
 /*
+ * calculate_totalreserve_pages - called when sysctl_lower_zone_reserve_ratio
+ *      or min_free_kbytes changes.
+ */
+static void calculate_totalreserve_pages(void)
+{
+        struct pglist_data *pgdat;
+        unsigned long reserve_pages = 0;
+        int i, j;
+
+        for_each_online_pgdat(pgdat) {
+                for (i = 0; i < MAX_NR_ZONES; i++) {
+                        struct zone *zone = pgdat->node_zones + i;
+                        unsigned long max = 0;
+
+                        /* Find valid and maximum lowmem_reserve in the zone */
+                        for (j = i; j < MAX_NR_ZONES; j++) {
+                                if (zone->lowmem_reserve[j] > max)
+                                        max = zone->lowmem_reserve[j];
+                        }
+
+                        /* we treat pages_high as reserved pages. */
+                        max += zone->pages_high;
+
+                        if (max > zone->present_pages)
+                                max = zone->present_pages;
+                        reserve_pages += max;
+                }
+        }
+        totalreserve_pages = reserve_pages;
+}
+
+/*
  * setup_per_zone_lowmem_reserve - called whenever
  *      sysctl_lower_zone_reserve_ratio changes.  Ensures that each zone
  *      has a correct pages reserved value, so an adequate number of
@@ -2502,6 +2542,9 @@ static void setup_per_zone_lowmem_reserve(void)
                         }
                 }
         }
+
+        /* update totalreserve_pages */
+        calculate_totalreserve_pages();
 }
 
 /*
@@ -2556,6 +2599,9 @@ void setup_per_zone_pages_min(void)
                 zone->pages_high  = zone->pages_min + tmp / 2;
                 spin_unlock_irqrestore(&zone->lru_lock, flags);
         }
+
+        /* update totalreserve_pages */
+        calculate_totalreserve_pages();
 }
 
 /*