mm, treewide: redefine MAX_ORDER sanely

[sfrench/cifs-2.6.git] / mm / page_alloc.c

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 0936bde1d486f5955f5f1e3b2b1dad1c2373b090..c3e49d028a7ac5eb920b9e5ed49166cabad9aa72 100644 (file)
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -1063,7 +1063,7 @@ buddy_merge_likely(unsigned long pfn, unsigned long buddy_pfn,
        unsigned long higher_page_pfn;
        struct page *higher_page;
 
-       if (order >= MAX_ORDER - 2)
+       if (order >= MAX_ORDER - 1)
                return false;
 
        higher_page_pfn = buddy_pfn & pfn;
@@ -1118,7 +1118,7 @@ static inline void __free_one_page(struct page *page,
        VM_BUG_ON_PAGE(pfn & ((1 << order) - 1), page);
        VM_BUG_ON_PAGE(bad_range(zone, page), page);
 
-       while (order < MAX_ORDER - 1) {
+       while (order < MAX_ORDER) {
                if (compaction_capture(capc, page, order, migratetype)) {
                        __mod_zone_freepage_state(zone, -(1 << order),
                                                                migratetype);
@@ -2499,7 +2499,7 @@ struct page *__rmqueue_smallest(struct zone *zone, unsigned int order,
        struct page *page;
 
        /* Find a page of the appropriate size in the preferred list */
-       for (current_order = order; current_order < MAX_ORDER; ++current_order) {
+       for (current_order = order; current_order <= MAX_ORDER; ++current_order) {
                area = &(zone->free_area[current_order]);
                page = get_page_from_free_area(area, migratetype);
                if (!page)
@@ -2871,7 +2871,7 @@ static bool unreserve_highatomic_pageblock(const struct alloc_context *ac,
                        continue;
 
                spin_lock_irqsave(&zone->lock, flags);
-               for (order = 0; order < MAX_ORDER; order++) {
+               for (order = 0; order <= MAX_ORDER; order++) {
                        struct free_area *area = &(zone->free_area[order]);
 
                        page = get_page_from_free_area(area, MIGRATE_HIGHATOMIC);
@@ -2955,7 +2955,7 @@ __rmqueue_fallback(struct zone *zone, int order, int start_migratetype,
         * approximates finding the pageblock with the most free pages, which
         * would be too costly to do exactly.
         */
-       for (current_order = MAX_ORDER - 1; current_order >= min_order;
+       for (current_order = MAX_ORDER; current_order >= min_order;
                                --current_order) {
                area = &(zone->free_area[current_order]);
                fallback_mt = find_suitable_fallback(area, current_order,
@@ -2981,7 +2981,7 @@ __rmqueue_fallback(struct zone *zone, int order, int start_migratetype,
        return false;
 
 find_smallest:
-       for (current_order = order; current_order < MAX_ORDER;
+       for (current_order = order; current_order <= MAX_ORDER;
                                                        current_order++) {
                area = &(zone->free_area[current_order]);
                fallback_mt = find_suitable_fallback(area, current_order,
@@ -2994,7 +2994,7 @@ find_smallest:
         * This should not happen - we already found a suitable fallback
         * when looking for the largest page.
         */
-       VM_BUG_ON(current_order == MAX_ORDER);
+       VM_BUG_ON(current_order > MAX_ORDER);
 
 do_steal:
        page = get_page_from_free_area(area, fallback_mt);
@@ -3955,7 +3955,7 @@ bool __zone_watermark_ok(struct zone *z, unsigned int order, unsigned long mark,
                return true;
 
        /* For a high-order request, check at least one suitable page is free */
-       for (o = order; o < MAX_ORDER; o++) {
+       for (o = order; o <= MAX_ORDER; o++) {
                struct free_area *area = &z->free_area[o];
                int mt;
 
@@ -5475,7 +5475,7 @@ struct page *__alloc_pages(gfp_t gfp, unsigned int order, int preferred_nid,
         * There are several places where we assume that the order value is sane
         * so bail out early if the request is out of bound.
         */
-       if (WARN_ON_ONCE_GFP(order >= MAX_ORDER, gfp))
+       if (WARN_ON_ONCE_GFP(order > MAX_ORDER, gfp))
                return NULL;
 
        gfp &= gfp_allowed_mask;
@@ -6205,8 +6205,8 @@ void __show_free_areas(unsigned int filter, nodemask_t *nodemask, int max_zone_i
 
        for_each_populated_zone(zone) {
                unsigned int order;
-               unsigned long nr[MAX_ORDER], flags, total = 0;
-               unsigned char types[MAX_ORDER];
+               unsigned long nr[MAX_ORDER + 1], flags, total = 0;
+               unsigned char types[MAX_ORDER + 1];
 
                if (zone_idx(zone) > max_zone_idx)
                        continue;
@@ -6216,7 +6216,7 @@ void __show_free_areas(unsigned int filter, nodemask_t *nodemask, int max_zone_i
                printk(KERN_CONT "%s: ", zone->name);
 
                spin_lock_irqsave(&zone->lock, flags);
-               for (order = 0; order < MAX_ORDER; order++) {
+               for (order = 0; order <= MAX_ORDER; order++) {
                        struct free_area *area = &zone->free_area[order];
                        int type;
 
@@ -6230,7 +6230,7 @@ void __show_free_areas(unsigned int filter, nodemask_t *nodemask, int max_zone_i
                        }
                }
                spin_unlock_irqrestore(&zone->lock, flags);
-               for (order = 0; order < MAX_ORDER; order++) {
+               for (order = 0; order <= MAX_ORDER; order++) {
                        printk(KERN_CONT "%lu*%lukB ",
                               nr[order], K(1UL) << order);
                        if (nr[order])
@@ -7581,7 +7581,7 @@ static inline void setup_usemap(struct zone *zone) {}
 /* Initialise the number of pages represented by NR_PAGEBLOCK_BITS */
 void __init set_pageblock_order(void)
 {
-       unsigned int order = MAX_ORDER - 1;
+       unsigned int order = MAX_ORDER;
 
        /* Check that pageblock_nr_pages has not already been setup */
        if (pageblock_order)
@@ -9076,7 +9076,7 @@ void *__init alloc_large_system_hash(const char *tablename,
                        else
                                table = memblock_alloc_raw(size,
                                                           SMP_CACHE_BYTES);
-               } else if (get_order(size) >= MAX_ORDER || hashdist) {
+               } else if (get_order(size) > MAX_ORDER || hashdist) {
                        table = vmalloc_huge(size, gfp_flags);
                        virt = true;
                        if (table)
@@ -9290,7 +9290,7 @@ int alloc_contig_range(unsigned long start, unsigned long end,
        order = 0;
        outer_start = start;
        while (!PageBuddy(pfn_to_page(outer_start))) {
-               if (++order >= MAX_ORDER) {
+               if (++order > MAX_ORDER) {
                        outer_start = start;
                        break;
                }
@@ -9540,7 +9540,7 @@ bool is_free_buddy_page(struct page *page)
        unsigned long pfn = page_to_pfn(page);
        unsigned int order;
 
-       for (order = 0; order < MAX_ORDER; order++) {
+       for (order = 0; order <= MAX_ORDER; order++) {
                struct page *page_head = page - (pfn & ((1 << order) - 1));
 
                if (PageBuddy(page_head) &&
@@ -9548,7 +9548,7 @@ bool is_free_buddy_page(struct page *page)
                        break;
        }
 
-       return order < MAX_ORDER;
+       return order <= MAX_ORDER;
 }
 EXPORT_SYMBOL(is_free_buddy_page);
 
@@ -9599,7 +9599,7 @@ bool take_page_off_buddy(struct page *page)
        bool ret = false;
 
        spin_lock_irqsave(&zone->lock, flags);
-       for (order = 0; order < MAX_ORDER; order++) {
+       for (order = 0; order <= MAX_ORDER; order++) {
                struct page *page_head = page - (pfn & ((1 << order) - 1));
                int page_order = buddy_order(page_head);