Group short-lived and reclaimable kernel allocations
[sfrench/cifs-2.6.git] / mm / page_alloc.c
1 /*
2  *  linux/mm/page_alloc.c
3  *
4  *  Manages the free list, the system allocates free pages here.
5  *  Note that kmalloc() lives in slab.c
6  *
7  *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
8  *  Swap reorganised 29.12.95, Stephen Tweedie
9  *  Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
10  *  Reshaped it to be a zoned allocator, Ingo Molnar, Red Hat, 1999
11  *  Discontiguous memory support, Kanoj Sarcar, SGI, Nov 1999
12  *  Zone balancing, Kanoj Sarcar, SGI, Jan 2000
13  *  Per cpu hot/cold page lists, bulk allocation, Martin J. Bligh, Sept 2002
14  *          (lots of bits borrowed from Ingo Molnar & Andrew Morton)
15  */
16
17 #include <linux/stddef.h>
18 #include <linux/mm.h>
19 #include <linux/swap.h>
20 #include <linux/interrupt.h>
21 #include <linux/pagemap.h>
22 #include <linux/bootmem.h>
23 #include <linux/compiler.h>
24 #include <linux/kernel.h>
25 #include <linux/module.h>
26 #include <linux/suspend.h>
27 #include <linux/pagevec.h>
28 #include <linux/blkdev.h>
29 #include <linux/slab.h>
30 #include <linux/notifier.h>
31 #include <linux/topology.h>
32 #include <linux/sysctl.h>
33 #include <linux/cpu.h>
34 #include <linux/cpuset.h>
35 #include <linux/memory_hotplug.h>
36 #include <linux/nodemask.h>
37 #include <linux/vmalloc.h>
38 #include <linux/mempolicy.h>
39 #include <linux/stop_machine.h>
40 #include <linux/sort.h>
41 #include <linux/pfn.h>
42 #include <linux/backing-dev.h>
43 #include <linux/fault-inject.h>
44
45 #include <asm/tlbflush.h>
46 #include <asm/div64.h>
47 #include "internal.h"
48
49 /*
50  * Array of node states.
51  */
52 nodemask_t node_states[NR_NODE_STATES] __read_mostly = {
53         [N_POSSIBLE] = NODE_MASK_ALL,
54         [N_ONLINE] = { { [0] = 1UL } },
55 #ifndef CONFIG_NUMA
56         [N_NORMAL_MEMORY] = { { [0] = 1UL } },
57 #ifdef CONFIG_HIGHMEM
58         [N_HIGH_MEMORY] = { { [0] = 1UL } },
59 #endif
60         [N_CPU] = { { [0] = 1UL } },
61 #endif  /* NUMA */
62 };
63 EXPORT_SYMBOL(node_states);
64
65 unsigned long totalram_pages __read_mostly;
66 unsigned long totalreserve_pages __read_mostly;
67 long nr_swap_pages;
68 int percpu_pagelist_fraction;
69
70 static void __free_pages_ok(struct page *page, unsigned int order);
71
72 /*
73  * results with 256, 32 in the lowmem_reserve sysctl:
74  *      1G machine -> (16M dma, 800M-16M normal, 1G-800M high)
75  *      1G machine -> (16M dma, 784M normal, 224M high)
76  *      NORMAL allocation will leave 784M/256 of ram reserved in the ZONE_DMA
77  *      HIGHMEM allocation will leave 224M/32 of ram reserved in ZONE_NORMAL
78  *      HIGHMEM allocation will (224M+784M)/256 of ram reserved in ZONE_DMA
79  *
80  * TBD: should special case ZONE_DMA32 machines here - in those we normally
81  * don't need any ZONE_NORMAL reservation
82  */
83 int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES-1] = {
84 #ifdef CONFIG_ZONE_DMA
85          256,
86 #endif
87 #ifdef CONFIG_ZONE_DMA32
88          256,
89 #endif
90 #ifdef CONFIG_HIGHMEM
91          32,
92 #endif
93          32,
94 };
95
96 EXPORT_SYMBOL(totalram_pages);
97
98 static char * const zone_names[MAX_NR_ZONES] = {
99 #ifdef CONFIG_ZONE_DMA
100          "DMA",
101 #endif
102 #ifdef CONFIG_ZONE_DMA32
103          "DMA32",
104 #endif
105          "Normal",
106 #ifdef CONFIG_HIGHMEM
107          "HighMem",
108 #endif
109          "Movable",
110 };
111
112 int min_free_kbytes = 1024;
113
114 unsigned long __meminitdata nr_kernel_pages;
115 unsigned long __meminitdata nr_all_pages;
116 static unsigned long __meminitdata dma_reserve;
117
118 #ifdef CONFIG_ARCH_POPULATES_NODE_MAP
119   /*
120    * MAX_ACTIVE_REGIONS determines the maxmimum number of distinct
121    * ranges of memory (RAM) that may be registered with add_active_range().
122    * Ranges passed to add_active_range() will be merged if possible
123    * so the number of times add_active_range() can be called is
124    * related to the number of nodes and the number of holes
125    */
126   #ifdef CONFIG_MAX_ACTIVE_REGIONS
127     /* Allow an architecture to set MAX_ACTIVE_REGIONS to save memory */
128     #define MAX_ACTIVE_REGIONS CONFIG_MAX_ACTIVE_REGIONS
129   #else
130     #if MAX_NUMNODES >= 32
131       /* If there can be many nodes, allow up to 50 holes per node */
132       #define MAX_ACTIVE_REGIONS (MAX_NUMNODES*50)
133     #else
134       /* By default, allow up to 256 distinct regions */
135       #define MAX_ACTIVE_REGIONS 256
136     #endif
137   #endif
138
139   static struct node_active_region __meminitdata early_node_map[MAX_ACTIVE_REGIONS];
140   static int __meminitdata nr_nodemap_entries;
141   static unsigned long __meminitdata arch_zone_lowest_possible_pfn[MAX_NR_ZONES];
142   static unsigned long __meminitdata arch_zone_highest_possible_pfn[MAX_NR_ZONES];
143 #ifdef CONFIG_MEMORY_HOTPLUG_RESERVE
144   static unsigned long __meminitdata node_boundary_start_pfn[MAX_NUMNODES];
145   static unsigned long __meminitdata node_boundary_end_pfn[MAX_NUMNODES];
146 #endif /* CONFIG_MEMORY_HOTPLUG_RESERVE */
147   unsigned long __initdata required_kernelcore;
148   unsigned long __initdata required_movablecore;
149   unsigned long __meminitdata zone_movable_pfn[MAX_NUMNODES];
150
151   /* movable_zone is the "real" zone pages in ZONE_MOVABLE are taken from */
152   int movable_zone;
153   EXPORT_SYMBOL(movable_zone);
154 #endif /* CONFIG_ARCH_POPULATES_NODE_MAP */
155
156 #if MAX_NUMNODES > 1
157 int nr_node_ids __read_mostly = MAX_NUMNODES;
158 EXPORT_SYMBOL(nr_node_ids);
159 #endif
160
161 #ifdef CONFIG_PAGE_GROUP_BY_MOBILITY
162 static inline int get_pageblock_migratetype(struct page *page)
163 {
164         return get_pageblock_flags_group(page, PB_migrate, PB_migrate_end);
165 }
166
167 static void set_pageblock_migratetype(struct page *page, int migratetype)
168 {
169         set_pageblock_flags_group(page, (unsigned long)migratetype,
170                                         PB_migrate, PB_migrate_end);
171 }
172
173 static inline int gfpflags_to_migratetype(gfp_t gfp_flags)
174 {
175         WARN_ON((gfp_flags & GFP_MOVABLE_MASK) == GFP_MOVABLE_MASK);
176
177         return (((gfp_flags & __GFP_MOVABLE) != 0) << 1) |
178                 ((gfp_flags & __GFP_RECLAIMABLE) != 0);
179 }
180
181 #else
182 static inline int get_pageblock_migratetype(struct page *page)
183 {
184         return MIGRATE_UNMOVABLE;
185 }
186
187 static void set_pageblock_migratetype(struct page *page, int migratetype)
188 {
189 }
190
191 static inline int gfpflags_to_migratetype(gfp_t gfp_flags)
192 {
193         return MIGRATE_UNMOVABLE;
194 }
195 #endif /* CONFIG_PAGE_GROUP_BY_MOBILITY */
196
197 #ifdef CONFIG_DEBUG_VM
198 static int page_outside_zone_boundaries(struct zone *zone, struct page *page)
199 {
200         int ret = 0;
201         unsigned seq;
202         unsigned long pfn = page_to_pfn(page);
203
204         do {
205                 seq = zone_span_seqbegin(zone);
206                 if (pfn >= zone->zone_start_pfn + zone->spanned_pages)
207                         ret = 1;
208                 else if (pfn < zone->zone_start_pfn)
209                         ret = 1;
210         } while (zone_span_seqretry(zone, seq));
211
212         return ret;
213 }
214
215 static int page_is_consistent(struct zone *zone, struct page *page)
216 {
217         if (!pfn_valid_within(page_to_pfn(page)))
218                 return 0;
219         if (zone != page_zone(page))
220                 return 0;
221
222         return 1;
223 }
224 /*
225  * Temporary debugging check for pages not lying within a given zone.
226  */
227 static int bad_range(struct zone *zone, struct page *page)
228 {
229         if (page_outside_zone_boundaries(zone, page))
230                 return 1;
231         if (!page_is_consistent(zone, page))
232                 return 1;
233
234         return 0;
235 }
236 #else
237 static inline int bad_range(struct zone *zone, struct page *page)
238 {
239         return 0;
240 }
241 #endif
242
243 static void bad_page(struct page *page)
244 {
245         printk(KERN_EMERG "Bad page state in process '%s'\n"
246                 KERN_EMERG "page:%p flags:0x%0*lx mapping:%p mapcount:%d count:%d\n"
247                 KERN_EMERG "Trying to fix it up, but a reboot is needed\n"
248                 KERN_EMERG "Backtrace:\n",
249                 current->comm, page, (int)(2*sizeof(unsigned long)),
250                 (unsigned long)page->flags, page->mapping,
251                 page_mapcount(page), page_count(page));
252         dump_stack();
253         page->flags &= ~(1 << PG_lru    |
254                         1 << PG_private |
255                         1 << PG_locked  |
256                         1 << PG_active  |
257                         1 << PG_dirty   |
258                         1 << PG_reclaim |
259                         1 << PG_slab    |
260                         1 << PG_swapcache |
261                         1 << PG_writeback |
262                         1 << PG_buddy );
263         set_page_count(page, 0);
264         reset_page_mapcount(page);
265         page->mapping = NULL;
266         add_taint(TAINT_BAD_PAGE);
267 }
268
269 /*
270  * Higher-order pages are called "compound pages".  They are structured thusly:
271  *
272  * The first PAGE_SIZE page is called the "head page".
273  *
274  * The remaining PAGE_SIZE pages are called "tail pages".
275  *
276  * All pages have PG_compound set.  All pages have their ->private pointing at
277  * the head page (even the head page has this).
278  *
279  * The first tail page's ->lru.next holds the address of the compound page's
280  * put_page() function.  Its ->lru.prev holds the order of allocation.
281  * This usage means that zero-order pages may not be compound.
282  */
283
284 static void free_compound_page(struct page *page)
285 {
286         __free_pages_ok(page, compound_order(page));
287 }
288
289 static void prep_compound_page(struct page *page, unsigned long order)
290 {
291         int i;
292         int nr_pages = 1 << order;
293
294         set_compound_page_dtor(page, free_compound_page);
295         set_compound_order(page, order);
296         __SetPageHead(page);
297         for (i = 1; i < nr_pages; i++) {
298                 struct page *p = page + i;
299
300                 __SetPageTail(p);
301                 p->first_page = page;
302         }
303 }
304
305 static void destroy_compound_page(struct page *page, unsigned long order)
306 {
307         int i;
308         int nr_pages = 1 << order;
309
310         if (unlikely(compound_order(page) != order))
311                 bad_page(page);
312
313         if (unlikely(!PageHead(page)))
314                         bad_page(page);
315         __ClearPageHead(page);
316         for (i = 1; i < nr_pages; i++) {
317                 struct page *p = page + i;
318
319                 if (unlikely(!PageTail(p) |
320                                 (p->first_page != page)))
321                         bad_page(page);
322                 __ClearPageTail(p);
323         }
324 }
325
326 static inline void prep_zero_page(struct page *page, int order, gfp_t gfp_flags)
327 {
328         int i;
329
330         VM_BUG_ON((gfp_flags & (__GFP_WAIT | __GFP_HIGHMEM)) == __GFP_HIGHMEM);
331         /*
332          * clear_highpage() will use KM_USER0, so it's a bug to use __GFP_ZERO
333          * and __GFP_HIGHMEM from hard or soft interrupt context.
334          */
335         VM_BUG_ON((gfp_flags & __GFP_HIGHMEM) && in_interrupt());
336         for (i = 0; i < (1 << order); i++)
337                 clear_highpage(page + i);
338 }
339
340 /*
341  * function for dealing with page's order in buddy system.
342  * zone->lock is already acquired when we use these.
343  * So, we don't need atomic page->flags operations here.
344  */
345 static inline unsigned long page_order(struct page *page)
346 {
347         return page_private(page);
348 }
349
350 static inline void set_page_order(struct page *page, int order)
351 {
352         set_page_private(page, order);
353         __SetPageBuddy(page);
354 }
355
356 static inline void rmv_page_order(struct page *page)
357 {
358         __ClearPageBuddy(page);
359         set_page_private(page, 0);
360 }
361
362 /*
363  * Locate the struct page for both the matching buddy in our
364  * pair (buddy1) and the combined O(n+1) page they form (page).
365  *
366  * 1) Any buddy B1 will have an order O twin B2 which satisfies
367  * the following equation:
368  *     B2 = B1 ^ (1 << O)
369  * For example, if the starting buddy (buddy2) is #8 its order
370  * 1 buddy is #10:
371  *     B2 = 8 ^ (1 << 1) = 8 ^ 2 = 10
372  *
373  * 2) Any buddy B will have an order O+1 parent P which
374  * satisfies the following equation:
375  *     P = B & ~(1 << O)
376  *
377  * Assumption: *_mem_map is contiguous at least up to MAX_ORDER
378  */
379 static inline struct page *
380 __page_find_buddy(struct page *page, unsigned long page_idx, unsigned int order)
381 {
382         unsigned long buddy_idx = page_idx ^ (1 << order);
383
384         return page + (buddy_idx - page_idx);
385 }
386
387 static inline unsigned long
388 __find_combined_index(unsigned long page_idx, unsigned int order)
389 {
390         return (page_idx & ~(1 << order));
391 }
392
393 /*
394  * This function checks whether a page is free && is the buddy
395  * we can do coalesce a page and its buddy if
396  * (a) the buddy is not in a hole &&
397  * (b) the buddy is in the buddy system &&
398  * (c) a page and its buddy have the same order &&
399  * (d) a page and its buddy are in the same zone.
400  *
401  * For recording whether a page is in the buddy system, we use PG_buddy.
402  * Setting, clearing, and testing PG_buddy is serialized by zone->lock.
403  *
404  * For recording page's order, we use page_private(page).
405  */
406 static inline int page_is_buddy(struct page *page, struct page *buddy,
407                                                                 int order)
408 {
409         if (!pfn_valid_within(page_to_pfn(buddy)))
410                 return 0;
411
412         if (page_zone_id(page) != page_zone_id(buddy))
413                 return 0;
414
415         if (PageBuddy(buddy) && page_order(buddy) == order) {
416                 BUG_ON(page_count(buddy) != 0);
417                 return 1;
418         }
419         return 0;
420 }
421
422 /*
423  * Freeing function for a buddy system allocator.
424  *
425  * The concept of a buddy system is to maintain direct-mapped table
426  * (containing bit values) for memory blocks of various "orders".
427  * The bottom level table contains the map for the smallest allocatable
428  * units of memory (here, pages), and each level above it describes
429  * pairs of units from the levels below, hence, "buddies".
430  * At a high level, all that happens here is marking the table entry
431  * at the bottom level available, and propagating the changes upward
432  * as necessary, plus some accounting needed to play nicely with other
433  * parts of the VM system.
434  * At each level, we keep a list of pages, which are heads of continuous
435  * free pages of length of (1 << order) and marked with PG_buddy. Page's
436  * order is recorded in page_private(page) field.
437  * So when we are allocating or freeing one, we can derive the state of the
438  * other.  That is, if we allocate a small block, and both were   
439  * free, the remainder of the region must be split into blocks.   
440  * If a block is freed, and its buddy is also free, then this
441  * triggers coalescing into a block of larger size.            
442  *
443  * -- wli
444  */
445
446 static inline void __free_one_page(struct page *page,
447                 struct zone *zone, unsigned int order)
448 {
449         unsigned long page_idx;
450         int order_size = 1 << order;
451         int migratetype = get_pageblock_migratetype(page);
452
453         if (unlikely(PageCompound(page)))
454                 destroy_compound_page(page, order);
455
456         page_idx = page_to_pfn(page) & ((1 << MAX_ORDER) - 1);
457
458         VM_BUG_ON(page_idx & (order_size - 1));
459         VM_BUG_ON(bad_range(zone, page));
460
461         __mod_zone_page_state(zone, NR_FREE_PAGES, order_size);
462         while (order < MAX_ORDER-1) {
463                 unsigned long combined_idx;
464                 struct page *buddy;
465
466                 buddy = __page_find_buddy(page, page_idx, order);
467                 if (!page_is_buddy(page, buddy, order))
468                         break;          /* Move the buddy up one level. */
469
470                 list_del(&buddy->lru);
471                 zone->free_area[order].nr_free--;
472                 rmv_page_order(buddy);
473                 combined_idx = __find_combined_index(page_idx, order);
474                 page = page + (combined_idx - page_idx);
475                 page_idx = combined_idx;
476                 order++;
477         }
478         set_page_order(page, order);
479         list_add(&page->lru,
480                 &zone->free_area[order].free_list[migratetype]);
481         zone->free_area[order].nr_free++;
482 }
483
484 static inline int free_pages_check(struct page *page)
485 {
486         if (unlikely(page_mapcount(page) |
487                 (page->mapping != NULL)  |
488                 (page_count(page) != 0)  |
489                 (page->flags & (
490                         1 << PG_lru     |
491                         1 << PG_private |
492                         1 << PG_locked  |
493                         1 << PG_active  |
494                         1 << PG_slab    |
495                         1 << PG_swapcache |
496                         1 << PG_writeback |
497                         1 << PG_reserved |
498                         1 << PG_buddy ))))
499                 bad_page(page);
500         if (PageDirty(page))
501                 __ClearPageDirty(page);
502         /*
503          * For now, we report if PG_reserved was found set, but do not
504          * clear it, and do not free the page.  But we shall soon need
505          * to do more, for when the ZERO_PAGE count wraps negative.
506          */
507         return PageReserved(page);
508 }
509
510 /*
511  * Frees a list of pages. 
512  * Assumes all pages on list are in same zone, and of same order.
513  * count is the number of pages to free.
514  *
515  * If the zone was previously in an "all pages pinned" state then look to
516  * see if this freeing clears that state.
517  *
518  * And clear the zone's pages_scanned counter, to hold off the "all pages are
519  * pinned" detection logic.
520  */
521 static void free_pages_bulk(struct zone *zone, int count,
522                                         struct list_head *list, int order)
523 {
524         spin_lock(&zone->lock);
525         zone->all_unreclaimable = 0;
526         zone->pages_scanned = 0;
527         while (count--) {
528                 struct page *page;
529
530                 VM_BUG_ON(list_empty(list));
531                 page = list_entry(list->prev, struct page, lru);
532                 /* have to delete it as __free_one_page list manipulates */
533                 list_del(&page->lru);
534                 __free_one_page(page, zone, order);
535         }
536         spin_unlock(&zone->lock);
537 }
538
539 static void free_one_page(struct zone *zone, struct page *page, int order)
540 {
541         spin_lock(&zone->lock);
542         zone->all_unreclaimable = 0;
543         zone->pages_scanned = 0;
544         __free_one_page(page, zone, order);
545         spin_unlock(&zone->lock);
546 }
547
548 static void __free_pages_ok(struct page *page, unsigned int order)
549 {
550         unsigned long flags;
551         int i;
552         int reserved = 0;
553
554         for (i = 0 ; i < (1 << order) ; ++i)
555                 reserved += free_pages_check(page + i);
556         if (reserved)
557                 return;
558
559         if (!PageHighMem(page))
560                 debug_check_no_locks_freed(page_address(page),PAGE_SIZE<<order);
561         arch_free_page(page, order);
562         kernel_map_pages(page, 1 << order, 0);
563
564         local_irq_save(flags);
565         __count_vm_events(PGFREE, 1 << order);
566         free_one_page(page_zone(page), page, order);
567         local_irq_restore(flags);
568 }
569
570 /*
571  * permit the bootmem allocator to evade page validation on high-order frees
572  */
573 void fastcall __init __free_pages_bootmem(struct page *page, unsigned int order)
574 {
575         if (order == 0) {
576                 __ClearPageReserved(page);
577                 set_page_count(page, 0);
578                 set_page_refcounted(page);
579                 __free_page(page);
580         } else {
581                 int loop;
582
583                 prefetchw(page);
584                 for (loop = 0; loop < BITS_PER_LONG; loop++) {
585                         struct page *p = &page[loop];
586
587                         if (loop + 1 < BITS_PER_LONG)
588                                 prefetchw(p + 1);
589                         __ClearPageReserved(p);
590                         set_page_count(p, 0);
591                 }
592
593                 set_page_refcounted(page);
594                 __free_pages(page, order);
595         }
596 }
597
598
599 /*
600  * The order of subdivision here is critical for the IO subsystem.
601  * Please do not alter this order without good reasons and regression
602  * testing. Specifically, as large blocks of memory are subdivided,
603  * the order in which smaller blocks are delivered depends on the order
604  * they're subdivided in this function. This is the primary factor
605  * influencing the order in which pages are delivered to the IO
606  * subsystem according to empirical testing, and this is also justified
607  * by considering the behavior of a buddy system containing a single
608  * large block of memory acted on by a series of small allocations.
609  * This behavior is a critical factor in sglist merging's success.
610  *
611  * -- wli
612  */
613 static inline void expand(struct zone *zone, struct page *page,
614         int low, int high, struct free_area *area,
615         int migratetype)
616 {
617         unsigned long size = 1 << high;
618
619         while (high > low) {
620                 area--;
621                 high--;
622                 size >>= 1;
623                 VM_BUG_ON(bad_range(zone, &page[size]));
624                 list_add(&page[size].lru, &area->free_list[migratetype]);
625                 area->nr_free++;
626                 set_page_order(&page[size], high);
627         }
628 }
629
630 /*
631  * This page is about to be returned from the page allocator
632  */
633 static int prep_new_page(struct page *page, int order, gfp_t gfp_flags)
634 {
635         if (unlikely(page_mapcount(page) |
636                 (page->mapping != NULL)  |
637                 (page_count(page) != 0)  |
638                 (page->flags & (
639                         1 << PG_lru     |
640                         1 << PG_private |
641                         1 << PG_locked  |
642                         1 << PG_active  |
643                         1 << PG_dirty   |
644                         1 << PG_slab    |
645                         1 << PG_swapcache |
646                         1 << PG_writeback |
647                         1 << PG_reserved |
648                         1 << PG_buddy ))))
649                 bad_page(page);
650
651         /*
652          * For now, we report if PG_reserved was found set, but do not
653          * clear it, and do not allocate the page: as a safety net.
654          */
655         if (PageReserved(page))
656                 return 1;
657
658         page->flags &= ~(1 << PG_uptodate | 1 << PG_error | 1 << PG_readahead |
659                         1 << PG_referenced | 1 << PG_arch_1 |
660                         1 << PG_owner_priv_1 | 1 << PG_mappedtodisk);
661         set_page_private(page, 0);
662         set_page_refcounted(page);
663
664         arch_alloc_page(page, order);
665         kernel_map_pages(page, 1 << order, 1);
666
667         if (gfp_flags & __GFP_ZERO)
668                 prep_zero_page(page, order, gfp_flags);
669
670         if (order && (gfp_flags & __GFP_COMP))
671                 prep_compound_page(page, order);
672
673         return 0;
674 }
675
676 #ifdef CONFIG_PAGE_GROUP_BY_MOBILITY
677 /*
678  * This array describes the order lists are fallen back to when
679  * the free lists for the desirable migrate type are depleted
680  */
681 static int fallbacks[MIGRATE_TYPES][MIGRATE_TYPES-1] = {
682         [MIGRATE_UNMOVABLE]   = { MIGRATE_RECLAIMABLE, MIGRATE_MOVABLE   },
683         [MIGRATE_RECLAIMABLE] = { MIGRATE_UNMOVABLE,   MIGRATE_MOVABLE   },
684         [MIGRATE_MOVABLE]     = { MIGRATE_RECLAIMABLE, MIGRATE_UNMOVABLE },
685 };
686
687 /*
688  * Move the free pages in a range to the free lists of the requested type.
689  * Note that start_page and end_pages are not aligned in a MAX_ORDER_NR_PAGES
690  * boundary. If alignment is required, use move_freepages_block()
691  */
692 int move_freepages(struct zone *zone,
693                         struct page *start_page, struct page *end_page,
694                         int migratetype)
695 {
696         struct page *page;
697         unsigned long order;
698         int blocks_moved = 0;
699
700 #ifndef CONFIG_HOLES_IN_ZONE
701         /*
702          * page_zone is not safe to call in this context when
703          * CONFIG_HOLES_IN_ZONE is set. This bug check is probably redundant
704          * anyway as we check zone boundaries in move_freepages_block().
705          * Remove at a later date when no bug reports exist related to
706          * CONFIG_PAGE_GROUP_BY_MOBILITY
707          */
708         BUG_ON(page_zone(start_page) != page_zone(end_page));
709 #endif
710
711         for (page = start_page; page <= end_page;) {
712                 if (!pfn_valid_within(page_to_pfn(page))) {
713                         page++;
714                         continue;
715                 }
716
717                 if (!PageBuddy(page)) {
718                         page++;
719                         continue;
720                 }
721
722                 order = page_order(page);
723                 list_del(&page->lru);
724                 list_add(&page->lru,
725                         &zone->free_area[order].free_list[migratetype]);
726                 page += 1 << order;
727                 blocks_moved++;
728         }
729
730         return blocks_moved;
731 }
732
733 int move_freepages_block(struct zone *zone, struct page *page, int migratetype)
734 {
735         unsigned long start_pfn, end_pfn;
736         struct page *start_page, *end_page;
737
738         start_pfn = page_to_pfn(page);
739         start_pfn = start_pfn & ~(MAX_ORDER_NR_PAGES-1);
740         start_page = pfn_to_page(start_pfn);
741         end_page = start_page + MAX_ORDER_NR_PAGES - 1;
742         end_pfn = start_pfn + MAX_ORDER_NR_PAGES - 1;
743
744         /* Do not cross zone boundaries */
745         if (start_pfn < zone->zone_start_pfn)
746                 start_page = page;
747         if (end_pfn >= zone->zone_start_pfn + zone->spanned_pages)
748                 return 0;
749
750         return move_freepages(zone, start_page, end_page, migratetype);
751 }
752
753 /* Remove an element from the buddy allocator from the fallback list */
754 static struct page *__rmqueue_fallback(struct zone *zone, int order,
755                                                 int start_migratetype)
756 {
757         struct free_area * area;
758         int current_order;
759         struct page *page;
760         int migratetype, i;
761
762         /* Find the largest possible block of pages in the other list */
763         for (current_order = MAX_ORDER-1; current_order >= order;
764                                                 --current_order) {
765                 for (i = 0; i < MIGRATE_TYPES - 1; i++) {
766                         migratetype = fallbacks[start_migratetype][i];
767
768                         area = &(zone->free_area[current_order]);
769                         if (list_empty(&area->free_list[migratetype]))
770                                 continue;
771
772                         page = list_entry(area->free_list[migratetype].next,
773                                         struct page, lru);
774                         area->nr_free--;
775
776                         /*
777                          * If breaking a large block of pages, move all free
778                          * pages to the preferred allocation list
779                          */
780                         if (unlikely(current_order >= MAX_ORDER / 2)) {
781                                 migratetype = start_migratetype;
782                                 move_freepages_block(zone, page, migratetype);
783                         }
784
785                         /* Remove the page from the freelists */
786                         list_del(&page->lru);
787                         rmv_page_order(page);
788                         __mod_zone_page_state(zone, NR_FREE_PAGES,
789                                                         -(1UL << order));
790
791                         if (current_order == MAX_ORDER - 1)
792                                 set_pageblock_migratetype(page,
793                                                         start_migratetype);
794
795                         expand(zone, page, order, current_order, area, migratetype);
796                         return page;
797                 }
798         }
799
800         return NULL;
801 }
802 #else
803 static struct page *__rmqueue_fallback(struct zone *zone, int order,
804                                                 int start_migratetype)
805 {
806         return NULL;
807 }
808 #endif /* CONFIG_PAGE_GROUP_BY_MOBILITY */
809
810 /* 
811  * Do the hard work of removing an element from the buddy allocator.
812  * Call me with the zone->lock already held.
813  */
814 static struct page *__rmqueue(struct zone *zone, unsigned int order,
815                                                 int migratetype)
816 {
817         struct free_area * area;
818         unsigned int current_order;
819         struct page *page;
820
821         /* Find a page of the appropriate size in the preferred list */
822         for (current_order = order; current_order < MAX_ORDER; ++current_order) {
823                 area = &(zone->free_area[current_order]);
824                 if (list_empty(&area->free_list[migratetype]))
825                         continue;
826
827                 page = list_entry(area->free_list[migratetype].next,
828                                                         struct page, lru);
829                 list_del(&page->lru);
830                 rmv_page_order(page);
831                 area->nr_free--;
832                 __mod_zone_page_state(zone, NR_FREE_PAGES, - (1UL << order));
833                 expand(zone, page, order, current_order, area, migratetype);
834                 goto got_page;
835         }
836
837         page = __rmqueue_fallback(zone, order, migratetype);
838
839 got_page:
840
841         return page;
842 }
843
844 /* 
845  * Obtain a specified number of elements from the buddy allocator, all under
846  * a single hold of the lock, for efficiency.  Add them to the supplied list.
847  * Returns the number of new pages which were placed at *list.
848  */
849 static int rmqueue_bulk(struct zone *zone, unsigned int order, 
850                         unsigned long count, struct list_head *list,
851                         int migratetype)
852 {
853         int i;
854         
855         spin_lock(&zone->lock);
856         for (i = 0; i < count; ++i) {
857                 struct page *page = __rmqueue(zone, order, migratetype);
858                 if (unlikely(page == NULL))
859                         break;
860                 list_add(&page->lru, list);
861                 set_page_private(page, migratetype);
862         }
863         spin_unlock(&zone->lock);
864         return i;
865 }
866
867 #ifdef CONFIG_NUMA
868 /*
869  * Called from the vmstat counter updater to drain pagesets of this
870  * currently executing processor on remote nodes after they have
871  * expired.
872  *
873  * Note that this function must be called with the thread pinned to
874  * a single processor.
875  */
876 void drain_zone_pages(struct zone *zone, struct per_cpu_pages *pcp)
877 {
878         unsigned long flags;
879         int to_drain;
880
881         local_irq_save(flags);
882         if (pcp->count >= pcp->batch)
883                 to_drain = pcp->batch;
884         else
885                 to_drain = pcp->count;
886         free_pages_bulk(zone, to_drain, &pcp->list, 0);
887         pcp->count -= to_drain;
888         local_irq_restore(flags);
889 }
890 #endif
891
892 static void __drain_pages(unsigned int cpu)
893 {
894         unsigned long flags;
895         struct zone *zone;
896         int i;
897
898         for_each_zone(zone) {
899                 struct per_cpu_pageset *pset;
900
901                 if (!populated_zone(zone))
902                         continue;
903
904                 pset = zone_pcp(zone, cpu);
905                 for (i = 0; i < ARRAY_SIZE(pset->pcp); i++) {
906                         struct per_cpu_pages *pcp;
907
908                         pcp = &pset->pcp[i];
909                         local_irq_save(flags);
910                         free_pages_bulk(zone, pcp->count, &pcp->list, 0);
911                         pcp->count = 0;
912                         local_irq_restore(flags);
913                 }
914         }
915 }
916
917 #ifdef CONFIG_HIBERNATION
918
919 void mark_free_pages(struct zone *zone)
920 {
921         unsigned long pfn, max_zone_pfn;
922         unsigned long flags;
923         int order, t;
924         struct list_head *curr;
925
926         if (!zone->spanned_pages)
927                 return;
928
929         spin_lock_irqsave(&zone->lock, flags);
930
931         max_zone_pfn = zone->zone_start_pfn + zone->spanned_pages;
932         for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
933                 if (pfn_valid(pfn)) {
934                         struct page *page = pfn_to_page(pfn);
935
936                         if (!swsusp_page_is_forbidden(page))
937                                 swsusp_unset_page_free(page);
938                 }
939
940         for_each_migratetype_order(order, t) {
941                 list_for_each(curr, &zone->free_area[order].free_list[t]) {
942                         unsigned long i;
943
944                         pfn = page_to_pfn(list_entry(curr, struct page, lru));
945                         for (i = 0; i < (1UL << order); i++)
946                                 swsusp_set_page_free(pfn_to_page(pfn + i));
947                 }
948         }
949         spin_unlock_irqrestore(&zone->lock, flags);
950 }
951 #endif /* CONFIG_PM */
952
953 #if defined(CONFIG_HIBERNATION) || defined(CONFIG_PAGE_GROUP_BY_MOBILITY)
954 /*
955  * Spill all of this CPU's per-cpu pages back into the buddy allocator.
956  */
957 void drain_local_pages(void)
958 {
959         unsigned long flags;
960
961         local_irq_save(flags);  
962         __drain_pages(smp_processor_id());
963         local_irq_restore(flags);       
964 }
965
966 void smp_drain_local_pages(void *arg)
967 {
968         drain_local_pages();
969 }
970
971 /*
972  * Spill all the per-cpu pages from all CPUs back into the buddy allocator
973  */
974 void drain_all_local_pages(void)
975 {
976         unsigned long flags;
977
978         local_irq_save(flags);
979         __drain_pages(smp_processor_id());
980         local_irq_restore(flags);
981
982         smp_call_function(smp_drain_local_pages, NULL, 0, 1);
983 }
984 #else
985 void drain_all_local_pages(void) {}
986 #endif /* CONFIG_HIBERNATION || CONFIG_PAGE_GROUP_BY_MOBILITY */
987
988 /*
989  * Free a 0-order page
990  */
991 static void fastcall free_hot_cold_page(struct page *page, int cold)
992 {
993         struct zone *zone = page_zone(page);
994         struct per_cpu_pages *pcp;
995         unsigned long flags;
996
997         if (PageAnon(page))
998                 page->mapping = NULL;
999         if (free_pages_check(page))
1000                 return;
1001
1002         if (!PageHighMem(page))
1003                 debug_check_no_locks_freed(page_address(page), PAGE_SIZE);
1004         arch_free_page(page, 0);
1005         kernel_map_pages(page, 1, 0);
1006
1007         pcp = &zone_pcp(zone, get_cpu())->pcp[cold];
1008         local_irq_save(flags);
1009         __count_vm_event(PGFREE);
1010         list_add(&page->lru, &pcp->list);
1011         set_page_private(page, get_pageblock_migratetype(page));
1012         pcp->count++;
1013         if (pcp->count >= pcp->high) {
1014                 free_pages_bulk(zone, pcp->batch, &pcp->list, 0);
1015                 pcp->count -= pcp->batch;
1016         }
1017         local_irq_restore(flags);
1018         put_cpu();
1019 }
1020
1021 void fastcall free_hot_page(struct page *page)
1022 {
1023         free_hot_cold_page(page, 0);
1024 }
1025         
1026 void fastcall free_cold_page(struct page *page)
1027 {
1028         free_hot_cold_page(page, 1);
1029 }
1030
1031 /*
1032  * split_page takes a non-compound higher-order page, and splits it into
1033  * n (1<<order) sub-pages: page[0..n]
1034  * Each sub-page must be freed individually.
1035  *
1036  * Note: this is probably too low level an operation for use in drivers.
1037  * Please consult with lkml before using this in your driver.
1038  */
1039 void split_page(struct page *page, unsigned int order)
1040 {
1041         int i;
1042
1043         VM_BUG_ON(PageCompound(page));
1044         VM_BUG_ON(!page_count(page));
1045         for (i = 1; i < (1 << order); i++)
1046                 set_page_refcounted(page + i);
1047 }
1048
1049 /*
1050  * Really, prep_compound_page() should be called from __rmqueue_bulk().  But
1051  * we cheat by calling it from here, in the order > 0 path.  Saves a branch
1052  * or two.
1053  */
1054 static struct page *buffered_rmqueue(struct zonelist *zonelist,
1055                         struct zone *zone, int order, gfp_t gfp_flags)
1056 {
1057         unsigned long flags;
1058         struct page *page;
1059         int cold = !!(gfp_flags & __GFP_COLD);
1060         int cpu;
1061         int migratetype = gfpflags_to_migratetype(gfp_flags);
1062
1063 again:
1064         cpu  = get_cpu();
1065         if (likely(order == 0)) {
1066                 struct per_cpu_pages *pcp;
1067
1068                 pcp = &zone_pcp(zone, cpu)->pcp[cold];
1069                 local_irq_save(flags);
1070                 if (!pcp->count) {
1071                         pcp->count = rmqueue_bulk(zone, 0,
1072                                         pcp->batch, &pcp->list, migratetype);
1073                         if (unlikely(!pcp->count))
1074                                 goto failed;
1075                 }
1076
1077 #ifdef CONFIG_PAGE_GROUP_BY_MOBILITY
1078                 /* Find a page of the appropriate migrate type */
1079                 list_for_each_entry(page, &pcp->list, lru)
1080                         if (page_private(page) == migratetype)
1081                                 break;
1082
1083                 /* Allocate more to the pcp list if necessary */
1084                 if (unlikely(&page->lru == &pcp->list)) {
1085                         pcp->count += rmqueue_bulk(zone, 0,
1086                                         pcp->batch, &pcp->list, migratetype);
1087                         page = list_entry(pcp->list.next, struct page, lru);
1088                 }
1089 #else
1090                 page = list_entry(pcp->list.next, struct page, lru);
1091 #endif /* CONFIG_PAGE_GROUP_BY_MOBILITY */
1092
1093                 list_del(&page->lru);
1094                 pcp->count--;
1095         } else {
1096                 spin_lock_irqsave(&zone->lock, flags);
1097                 page = __rmqueue(zone, order, migratetype);
1098                 spin_unlock(&zone->lock);
1099                 if (!page)
1100                         goto failed;
1101         }
1102
1103         __count_zone_vm_events(PGALLOC, zone, 1 << order);
1104         zone_statistics(zonelist, zone);
1105         local_irq_restore(flags);
1106         put_cpu();
1107
1108         VM_BUG_ON(bad_range(zone, page));
1109         if (prep_new_page(page, order, gfp_flags))
1110                 goto again;
1111         return page;
1112
1113 failed:
1114         local_irq_restore(flags);
1115         put_cpu();
1116         return NULL;
1117 }
1118
1119 #define ALLOC_NO_WATERMARKS     0x01 /* don't check watermarks at all */
1120 #define ALLOC_WMARK_MIN         0x02 /* use pages_min watermark */
1121 #define ALLOC_WMARK_LOW         0x04 /* use pages_low watermark */
1122 #define ALLOC_WMARK_HIGH        0x08 /* use pages_high watermark */
1123 #define ALLOC_HARDER            0x10 /* try to alloc harder */
1124 #define ALLOC_HIGH              0x20 /* __GFP_HIGH set */
1125 #define ALLOC_CPUSET            0x40 /* check for correct cpuset */
1126
1127 #ifdef CONFIG_FAIL_PAGE_ALLOC
1128
1129 static struct fail_page_alloc_attr {
1130         struct fault_attr attr;
1131
1132         u32 ignore_gfp_highmem;
1133         u32 ignore_gfp_wait;
1134         u32 min_order;
1135
1136 #ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
1137
1138         struct dentry *ignore_gfp_highmem_file;
1139         struct dentry *ignore_gfp_wait_file;
1140         struct dentry *min_order_file;
1141
1142 #endif /* CONFIG_FAULT_INJECTION_DEBUG_FS */
1143
1144 } fail_page_alloc = {
1145         .attr = FAULT_ATTR_INITIALIZER,
1146         .ignore_gfp_wait = 1,
1147         .ignore_gfp_highmem = 1,
1148         .min_order = 1,
1149 };
1150
1151 static int __init setup_fail_page_alloc(char *str)
1152 {
1153         return setup_fault_attr(&fail_page_alloc.attr, str);
1154 }
1155 __setup("fail_page_alloc=", setup_fail_page_alloc);
1156
1157 static int should_fail_alloc_page(gfp_t gfp_mask, unsigned int order)
1158 {
1159         if (order < fail_page_alloc.min_order)
1160                 return 0;
1161         if (gfp_mask & __GFP_NOFAIL)
1162                 return 0;
1163         if (fail_page_alloc.ignore_gfp_highmem && (gfp_mask & __GFP_HIGHMEM))
1164                 return 0;
1165         if (fail_page_alloc.ignore_gfp_wait && (gfp_mask & __GFP_WAIT))
1166                 return 0;
1167
1168         return should_fail(&fail_page_alloc.attr, 1 << order);
1169 }
1170
1171 #ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
1172
1173 static int __init fail_page_alloc_debugfs(void)
1174 {
1175         mode_t mode = S_IFREG | S_IRUSR | S_IWUSR;
1176         struct dentry *dir;
1177         int err;
1178
1179         err = init_fault_attr_dentries(&fail_page_alloc.attr,
1180                                        "fail_page_alloc");
1181         if (err)
1182                 return err;
1183         dir = fail_page_alloc.attr.dentries.dir;
1184
1185         fail_page_alloc.ignore_gfp_wait_file =
1186                 debugfs_create_bool("ignore-gfp-wait", mode, dir,
1187                                       &fail_page_alloc.ignore_gfp_wait);
1188
1189         fail_page_alloc.ignore_gfp_highmem_file =
1190                 debugfs_create_bool("ignore-gfp-highmem", mode, dir,
1191                                       &fail_page_alloc.ignore_gfp_highmem);
1192         fail_page_alloc.min_order_file =
1193                 debugfs_create_u32("min-order", mode, dir,
1194                                    &fail_page_alloc.min_order);
1195
1196         if (!fail_page_alloc.ignore_gfp_wait_file ||
1197             !fail_page_alloc.ignore_gfp_highmem_file ||
1198             !fail_page_alloc.min_order_file) {
1199                 err = -ENOMEM;
1200                 debugfs_remove(fail_page_alloc.ignore_gfp_wait_file);
1201                 debugfs_remove(fail_page_alloc.ignore_gfp_highmem_file);
1202                 debugfs_remove(fail_page_alloc.min_order_file);
1203                 cleanup_fault_attr_dentries(&fail_page_alloc.attr);
1204         }
1205
1206         return err;
1207 }
1208
1209 late_initcall(fail_page_alloc_debugfs);
1210
1211 #endif /* CONFIG_FAULT_INJECTION_DEBUG_FS */
1212
1213 #else /* CONFIG_FAIL_PAGE_ALLOC */
1214
1215 static inline int should_fail_alloc_page(gfp_t gfp_mask, unsigned int order)
1216 {
1217         return 0;
1218 }
1219
1220 #endif /* CONFIG_FAIL_PAGE_ALLOC */
1221
1222 /*
1223  * Return 1 if free pages are above 'mark'. This takes into account the order
1224  * of the allocation.
1225  */
1226 int zone_watermark_ok(struct zone *z, int order, unsigned long mark,
1227                       int classzone_idx, int alloc_flags)
1228 {
1229         /* free_pages my go negative - that's OK */
1230         long min = mark;
1231         long free_pages = zone_page_state(z, NR_FREE_PAGES) - (1 << order) + 1;
1232         int o;
1233
1234         if (alloc_flags & ALLOC_HIGH)
1235                 min -= min / 2;
1236         if (alloc_flags & ALLOC_HARDER)
1237                 min -= min / 4;
1238
1239         if (free_pages <= min + z->lowmem_reserve[classzone_idx])
1240                 return 0;
1241         for (o = 0; o < order; o++) {
1242                 /* At the next order, this order's pages become unavailable */
1243                 free_pages -= z->free_area[o].nr_free << o;
1244
1245                 /* Require fewer higher order pages to be free */
1246                 min >>= 1;
1247
1248                 if (free_pages <= min)
1249                         return 0;
1250         }
1251         return 1;
1252 }
1253
1254 #ifdef CONFIG_NUMA
1255 /*
1256  * zlc_setup - Setup for "zonelist cache".  Uses cached zone data to
1257  * skip over zones that are not allowed by the cpuset, or that have
1258  * been recently (in last second) found to be nearly full.  See further
1259  * comments in mmzone.h.  Reduces cache footprint of zonelist scans
1260  * that have to skip over alot of full or unallowed zones.
1261  *
1262  * If the zonelist cache is present in the passed in zonelist, then
1263  * returns a pointer to the allowed node mask (either the current
1264  * tasks mems_allowed, or node_states[N_HIGH_MEMORY].)
1265  *
1266  * If the zonelist cache is not available for this zonelist, does
1267  * nothing and returns NULL.
1268  *
1269  * If the fullzones BITMAP in the zonelist cache is stale (more than
1270  * a second since last zap'd) then we zap it out (clear its bits.)
1271  *
1272  * We hold off even calling zlc_setup, until after we've checked the
1273  * first zone in the zonelist, on the theory that most allocations will
1274  * be satisfied from that first zone, so best to examine that zone as
1275  * quickly as we can.
1276  */
1277 static nodemask_t *zlc_setup(struct zonelist *zonelist, int alloc_flags)
1278 {
1279         struct zonelist_cache *zlc;     /* cached zonelist speedup info */
1280         nodemask_t *allowednodes;       /* zonelist_cache approximation */
1281
1282         zlc = zonelist->zlcache_ptr;
1283         if (!zlc)
1284                 return NULL;
1285
1286         if (jiffies - zlc->last_full_zap > 1 * HZ) {
1287                 bitmap_zero(zlc->fullzones, MAX_ZONES_PER_ZONELIST);
1288                 zlc->last_full_zap = jiffies;
1289         }
1290
1291         allowednodes = !in_interrupt() && (alloc_flags & ALLOC_CPUSET) ?
1292                                         &cpuset_current_mems_allowed :
1293                                         &node_states[N_HIGH_MEMORY];
1294         return allowednodes;
1295 }
1296
1297 /*
1298  * Given 'z' scanning a zonelist, run a couple of quick checks to see
1299  * if it is worth looking at further for free memory:
1300  *  1) Check that the zone isn't thought to be full (doesn't have its
1301  *     bit set in the zonelist_cache fullzones BITMAP).
1302  *  2) Check that the zones node (obtained from the zonelist_cache
1303  *     z_to_n[] mapping) is allowed in the passed in allowednodes mask.
1304  * Return true (non-zero) if zone is worth looking at further, or
1305  * else return false (zero) if it is not.
1306  *
1307  * This check -ignores- the distinction between various watermarks,
1308  * such as GFP_HIGH, GFP_ATOMIC, PF_MEMALLOC, ...  If a zone is
1309  * found to be full for any variation of these watermarks, it will
1310  * be considered full for up to one second by all requests, unless
1311  * we are so low on memory on all allowed nodes that we are forced
1312  * into the second scan of the zonelist.
1313  *
1314  * In the second scan we ignore this zonelist cache and exactly
1315  * apply the watermarks to all zones, even it is slower to do so.
1316  * We are low on memory in the second scan, and should leave no stone
1317  * unturned looking for a free page.
1318  */
1319 static int zlc_zone_worth_trying(struct zonelist *zonelist, struct zone **z,
1320                                                 nodemask_t *allowednodes)
1321 {
1322         struct zonelist_cache *zlc;     /* cached zonelist speedup info */
1323         int i;                          /* index of *z in zonelist zones */
1324         int n;                          /* node that zone *z is on */
1325
1326         zlc = zonelist->zlcache_ptr;
1327         if (!zlc)
1328                 return 1;
1329
1330         i = z - zonelist->zones;
1331         n = zlc->z_to_n[i];
1332
1333         /* This zone is worth trying if it is allowed but not full */
1334         return node_isset(n, *allowednodes) && !test_bit(i, zlc->fullzones);
1335 }
1336
1337 /*
1338  * Given 'z' scanning a zonelist, set the corresponding bit in
1339  * zlc->fullzones, so that subsequent attempts to allocate a page
1340  * from that zone don't waste time re-examining it.
1341  */
1342 static void zlc_mark_zone_full(struct zonelist *zonelist, struct zone **z)
1343 {
1344         struct zonelist_cache *zlc;     /* cached zonelist speedup info */
1345         int i;                          /* index of *z in zonelist zones */
1346
1347         zlc = zonelist->zlcache_ptr;
1348         if (!zlc)
1349                 return;
1350
1351         i = z - zonelist->zones;
1352
1353         set_bit(i, zlc->fullzones);
1354 }
1355
1356 #else   /* CONFIG_NUMA */
1357
1358 static nodemask_t *zlc_setup(struct zonelist *zonelist, int alloc_flags)
1359 {
1360         return NULL;
1361 }
1362
1363 static int zlc_zone_worth_trying(struct zonelist *zonelist, struct zone **z,
1364                                 nodemask_t *allowednodes)
1365 {
1366         return 1;
1367 }
1368
1369 static void zlc_mark_zone_full(struct zonelist *zonelist, struct zone **z)
1370 {
1371 }
1372 #endif  /* CONFIG_NUMA */
1373
1374 /*
1375  * get_page_from_freelist goes through the zonelist trying to allocate
1376  * a page.
1377  */
1378 static struct page *
1379 get_page_from_freelist(gfp_t gfp_mask, unsigned int order,
1380                 struct zonelist *zonelist, int alloc_flags)
1381 {
1382         struct zone **z;
1383         struct page *page = NULL;
1384         int classzone_idx = zone_idx(zonelist->zones[0]);
1385         struct zone *zone;
1386         nodemask_t *allowednodes = NULL;/* zonelist_cache approximation */
1387         int zlc_active = 0;             /* set if using zonelist_cache */
1388         int did_zlc_setup = 0;          /* just call zlc_setup() one time */
1389         enum zone_type highest_zoneidx = -1; /* Gets set for policy zonelists */
1390
1391 zonelist_scan:
1392         /*
1393          * Scan zonelist, looking for a zone with enough free.
1394          * See also cpuset_zone_allowed() comment in kernel/cpuset.c.
1395          */
1396         z = zonelist->zones;
1397
1398         do {
1399                 /*
1400                  * In NUMA, this could be a policy zonelist which contains
1401                  * zones that may not be allowed by the current gfp_mask.
1402                  * Check the zone is allowed by the current flags
1403                  */
1404                 if (unlikely(alloc_should_filter_zonelist(zonelist))) {
1405                         if (highest_zoneidx == -1)
1406                                 highest_zoneidx = gfp_zone(gfp_mask);
1407                         if (zone_idx(*z) > highest_zoneidx)
1408                                 continue;
1409                 }
1410
1411                 if (NUMA_BUILD && zlc_active &&
1412                         !zlc_zone_worth_trying(zonelist, z, allowednodes))
1413                                 continue;
1414                 zone = *z;
1415                 if ((alloc_flags & ALLOC_CPUSET) &&
1416                         !cpuset_zone_allowed_softwall(zone, gfp_mask))
1417                                 goto try_next_zone;
1418
1419                 if (!(alloc_flags & ALLOC_NO_WATERMARKS)) {
1420                         unsigned long mark;
1421                         if (alloc_flags & ALLOC_WMARK_MIN)
1422                                 mark = zone->pages_min;
1423                         else if (alloc_flags & ALLOC_WMARK_LOW)
1424                                 mark = zone->pages_low;
1425                         else
1426                                 mark = zone->pages_high;
1427                         if (!zone_watermark_ok(zone, order, mark,
1428                                     classzone_idx, alloc_flags)) {
1429                                 if (!zone_reclaim_mode ||
1430                                     !zone_reclaim(zone, gfp_mask, order))
1431                                         goto this_zone_full;
1432                         }
1433                 }
1434
1435                 page = buffered_rmqueue(zonelist, zone, order, gfp_mask);
1436                 if (page)
1437                         break;
1438 this_zone_full:
1439                 if (NUMA_BUILD)
1440                         zlc_mark_zone_full(zonelist, z);
1441 try_next_zone:
1442                 if (NUMA_BUILD && !did_zlc_setup) {
1443                         /* we do zlc_setup after the first zone is tried */
1444                         allowednodes = zlc_setup(zonelist, alloc_flags);
1445                         zlc_active = 1;
1446                         did_zlc_setup = 1;
1447                 }
1448         } while (*(++z) != NULL);
1449
1450         if (unlikely(NUMA_BUILD && page == NULL && zlc_active)) {
1451                 /* Disable zlc cache for second zonelist scan */
1452                 zlc_active = 0;
1453                 goto zonelist_scan;
1454         }
1455         return page;
1456 }
1457
1458 /*
1459  * This is the 'heart' of the zoned buddy allocator.
1460  */
1461 struct page * fastcall
1462 __alloc_pages(gfp_t gfp_mask, unsigned int order,
1463                 struct zonelist *zonelist)
1464 {
1465         const gfp_t wait = gfp_mask & __GFP_WAIT;
1466         struct zone **z;
1467         struct page *page;
1468         struct reclaim_state reclaim_state;
1469         struct task_struct *p = current;
1470         int do_retry;
1471         int alloc_flags;
1472         int did_some_progress;
1473
1474         might_sleep_if(wait);
1475
1476         if (should_fail_alloc_page(gfp_mask, order))
1477                 return NULL;
1478
1479 restart:
1480         z = zonelist->zones;  /* the list of zones suitable for gfp_mask */
1481
1482         if (unlikely(*z == NULL)) {
1483                 /*
1484                  * Happens if we have an empty zonelist as a result of
1485                  * GFP_THISNODE being used on a memoryless node
1486                  */
1487                 return NULL;
1488         }
1489
1490         page = get_page_from_freelist(gfp_mask|__GFP_HARDWALL, order,
1491                                 zonelist, ALLOC_WMARK_LOW|ALLOC_CPUSET);
1492         if (page)
1493                 goto got_pg;
1494
1495         /*
1496          * GFP_THISNODE (meaning __GFP_THISNODE, __GFP_NORETRY and
1497          * __GFP_NOWARN set) should not cause reclaim since the subsystem
1498          * (f.e. slab) using GFP_THISNODE may choose to trigger reclaim
1499          * using a larger set of nodes after it has established that the
1500          * allowed per node queues are empty and that nodes are
1501          * over allocated.
1502          */
1503         if (NUMA_BUILD && (gfp_mask & GFP_THISNODE) == GFP_THISNODE)
1504                 goto nopage;
1505
1506         for (z = zonelist->zones; *z; z++)
1507                 wakeup_kswapd(*z, order);
1508
1509         /*
1510          * OK, we're below the kswapd watermark and have kicked background
1511          * reclaim. Now things get more complex, so set up alloc_flags according
1512          * to how we want to proceed.
1513          *
1514          * The caller may dip into page reserves a bit more if the caller
1515          * cannot run direct reclaim, or if the caller has realtime scheduling
1516          * policy or is asking for __GFP_HIGH memory.  GFP_ATOMIC requests will
1517          * set both ALLOC_HARDER (!wait) and ALLOC_HIGH (__GFP_HIGH).
1518          */
1519         alloc_flags = ALLOC_WMARK_MIN;
1520         if ((unlikely(rt_task(p)) && !in_interrupt()) || !wait)
1521                 alloc_flags |= ALLOC_HARDER;
1522         if (gfp_mask & __GFP_HIGH)
1523                 alloc_flags |= ALLOC_HIGH;
1524         if (wait)
1525                 alloc_flags |= ALLOC_CPUSET;
1526
1527         /*
1528          * Go through the zonelist again. Let __GFP_HIGH and allocations
1529          * coming from realtime tasks go deeper into reserves.
1530          *
1531          * This is the last chance, in general, before the goto nopage.
1532          * Ignore cpuset if GFP_ATOMIC (!wait) rather than fail alloc.
1533          * See also cpuset_zone_allowed() comment in kernel/cpuset.c.
1534          */
1535         page = get_page_from_freelist(gfp_mask, order, zonelist, alloc_flags);
1536         if (page)
1537                 goto got_pg;
1538
1539         /* This allocation should allow future memory freeing. */
1540
1541 rebalance:
1542         if (((p->flags & PF_MEMALLOC) || unlikely(test_thread_flag(TIF_MEMDIE)))
1543                         && !in_interrupt()) {
1544                 if (!(gfp_mask & __GFP_NOMEMALLOC)) {
1545 nofail_alloc:
1546                         /* go through the zonelist yet again, ignoring mins */
1547                         page = get_page_from_freelist(gfp_mask, order,
1548                                 zonelist, ALLOC_NO_WATERMARKS);
1549                         if (page)
1550                                 goto got_pg;
1551                         if (gfp_mask & __GFP_NOFAIL) {
1552                                 congestion_wait(WRITE, HZ/50);
1553                                 goto nofail_alloc;
1554                         }
1555                 }
1556                 goto nopage;
1557         }
1558
1559         /* Atomic allocations - we can't balance anything */
1560         if (!wait)
1561                 goto nopage;
1562
1563         cond_resched();
1564
1565         /* We now go into synchronous reclaim */
1566         cpuset_memory_pressure_bump();
1567         p->flags |= PF_MEMALLOC;
1568         reclaim_state.reclaimed_slab = 0;
1569         p->reclaim_state = &reclaim_state;
1570
1571         did_some_progress = try_to_free_pages(zonelist->zones, order, gfp_mask);
1572
1573         p->reclaim_state = NULL;
1574         p->flags &= ~PF_MEMALLOC;
1575
1576         cond_resched();
1577
1578         if (order != 0)
1579                 drain_all_local_pages();
1580
1581         if (likely(did_some_progress)) {
1582                 page = get_page_from_freelist(gfp_mask, order,
1583                                                 zonelist, alloc_flags);
1584                 if (page)
1585                         goto got_pg;
1586         } else if ((gfp_mask & __GFP_FS) && !(gfp_mask & __GFP_NORETRY)) {
1587                 /*
1588                  * Go through the zonelist yet one more time, keep
1589                  * very high watermark here, this is only to catch
1590                  * a parallel oom killing, we must fail if we're still
1591                  * under heavy pressure.
1592                  */
1593                 page = get_page_from_freelist(gfp_mask|__GFP_HARDWALL, order,
1594                                 zonelist, ALLOC_WMARK_HIGH|ALLOC_CPUSET);
1595                 if (page)
1596                         goto got_pg;
1597
1598                 /* The OOM killer will not help higher order allocs so fail */
1599                 if (order > PAGE_ALLOC_COSTLY_ORDER)
1600                         goto nopage;
1601
1602                 out_of_memory(zonelist, gfp_mask, order);
1603                 goto restart;
1604         }
1605
1606         /*
1607          * Don't let big-order allocations loop unless the caller explicitly
1608          * requests that.  Wait for some write requests to complete then retry.
1609          *
1610          * In this implementation, __GFP_REPEAT means __GFP_NOFAIL for order
1611          * <= 3, but that may not be true in other implementations.
1612          */
1613         do_retry = 0;
1614         if (!(gfp_mask & __GFP_NORETRY)) {
1615                 if ((order <= PAGE_ALLOC_COSTLY_ORDER) ||
1616                                                 (gfp_mask & __GFP_REPEAT))
1617                         do_retry = 1;
1618                 if (gfp_mask & __GFP_NOFAIL)
1619                         do_retry = 1;
1620         }
1621         if (do_retry) {
1622                 congestion_wait(WRITE, HZ/50);
1623                 goto rebalance;
1624         }
1625
1626 nopage:
1627         if (!(gfp_mask & __GFP_NOWARN) && printk_ratelimit()) {
1628                 printk(KERN_WARNING "%s: page allocation failure."
1629                         " order:%d, mode:0x%x\n",
1630                         p->comm, order, gfp_mask);
1631                 dump_stack();
1632                 show_mem();
1633         }
1634 got_pg:
1635         return page;
1636 }
1637
1638 EXPORT_SYMBOL(__alloc_pages);
1639
1640 /*
1641  * Common helper functions.
1642  */
1643 fastcall unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order)
1644 {
1645         struct page * page;
1646         page = alloc_pages(gfp_mask, order);
1647         if (!page)
1648                 return 0;
1649         return (unsigned long) page_address(page);
1650 }
1651
1652 EXPORT_SYMBOL(__get_free_pages);
1653
1654 fastcall unsigned long get_zeroed_page(gfp_t gfp_mask)
1655 {
1656         struct page * page;
1657
1658         /*
1659          * get_zeroed_page() returns a 32-bit address, which cannot represent
1660          * a highmem page
1661          */
1662         VM_BUG_ON((gfp_mask & __GFP_HIGHMEM) != 0);
1663
1664         page = alloc_pages(gfp_mask | __GFP_ZERO, 0);
1665         if (page)
1666                 return (unsigned long) page_address(page);
1667         return 0;
1668 }
1669
1670 EXPORT_SYMBOL(get_zeroed_page);
1671
1672 void __pagevec_free(struct pagevec *pvec)
1673 {
1674         int i = pagevec_count(pvec);
1675
1676         while (--i >= 0)
1677                 free_hot_cold_page(pvec->pages[i], pvec->cold);
1678 }
1679
1680 fastcall void __free_pages(struct page *page, unsigned int order)
1681 {
1682         if (put_page_testzero(page)) {
1683                 if (order == 0)
1684                         free_hot_page(page);
1685                 else
1686                         __free_pages_ok(page, order);
1687         }
1688 }
1689
1690 EXPORT_SYMBOL(__free_pages);
1691
1692 fastcall void free_pages(unsigned long addr, unsigned int order)
1693 {
1694         if (addr != 0) {
1695                 VM_BUG_ON(!virt_addr_valid((void *)addr));
1696                 __free_pages(virt_to_page((void *)addr), order);
1697         }
1698 }
1699
1700 EXPORT_SYMBOL(free_pages);
1701
1702 static unsigned int nr_free_zone_pages(int offset)
1703 {
1704         /* Just pick one node, since fallback list is circular */
1705         pg_data_t *pgdat = NODE_DATA(numa_node_id());
1706         unsigned int sum = 0;
1707
1708         struct zonelist *zonelist = pgdat->node_zonelists + offset;
1709         struct zone **zonep = zonelist->zones;
1710         struct zone *zone;
1711
1712         for (zone = *zonep++; zone; zone = *zonep++) {
1713                 unsigned long size = zone->present_pages;
1714                 unsigned long high = zone->pages_high;
1715                 if (size > high)
1716                         sum += size - high;
1717         }
1718
1719         return sum;
1720 }
1721
1722 /*
1723  * Amount of free RAM allocatable within ZONE_DMA and ZONE_NORMAL
1724  */
1725 unsigned int nr_free_buffer_pages(void)
1726 {
1727         return nr_free_zone_pages(gfp_zone(GFP_USER));
1728 }
1729 EXPORT_SYMBOL_GPL(nr_free_buffer_pages);
1730
1731 /*
1732  * Amount of free RAM allocatable within all zones
1733  */
1734 unsigned int nr_free_pagecache_pages(void)
1735 {
1736         return nr_free_zone_pages(gfp_zone(GFP_HIGHUSER_MOVABLE));
1737 }
1738
1739 static inline void show_node(struct zone *zone)
1740 {
1741         if (NUMA_BUILD)
1742                 printk("Node %d ", zone_to_nid(zone));
1743 }
1744
1745 void si_meminfo(struct sysinfo *val)
1746 {
1747         val->totalram = totalram_pages;
1748         val->sharedram = 0;
1749         val->freeram = global_page_state(NR_FREE_PAGES);
1750         val->bufferram = nr_blockdev_pages();
1751         val->totalhigh = totalhigh_pages;
1752         val->freehigh = nr_free_highpages();
1753         val->mem_unit = PAGE_SIZE;
1754 }
1755
1756 EXPORT_SYMBOL(si_meminfo);
1757
1758 #ifdef CONFIG_NUMA
1759 void si_meminfo_node(struct sysinfo *val, int nid)
1760 {
1761         pg_data_t *pgdat = NODE_DATA(nid);
1762
1763         val->totalram = pgdat->node_present_pages;
1764         val->freeram = node_page_state(nid, NR_FREE_PAGES);
1765 #ifdef CONFIG_HIGHMEM
1766         val->totalhigh = pgdat->node_zones[ZONE_HIGHMEM].present_pages;
1767         val->freehigh = zone_page_state(&pgdat->node_zones[ZONE_HIGHMEM],
1768                         NR_FREE_PAGES);
1769 #else
1770         val->totalhigh = 0;
1771         val->freehigh = 0;
1772 #endif
1773         val->mem_unit = PAGE_SIZE;
1774 }
1775 #endif
1776
1777 #define K(x) ((x) << (PAGE_SHIFT-10))
1778
1779 /*
1780  * Show free area list (used inside shift_scroll-lock stuff)
1781  * We also calculate the percentage fragmentation. We do this by counting the
1782  * memory on each free list with the exception of the first item on the list.
1783  */
1784 void show_free_areas(void)
1785 {
1786         int cpu;
1787         struct zone *zone;
1788
1789         for_each_zone(zone) {
1790                 if (!populated_zone(zone))
1791                         continue;
1792
1793                 show_node(zone);
1794                 printk("%s per-cpu:\n", zone->name);
1795
1796                 for_each_online_cpu(cpu) {
1797                         struct per_cpu_pageset *pageset;
1798
1799                         pageset = zone_pcp(zone, cpu);
1800
1801                         printk("CPU %4d: Hot: hi:%5d, btch:%4d usd:%4d   "
1802                                "Cold: hi:%5d, btch:%4d usd:%4d\n",
1803                                cpu, pageset->pcp[0].high,
1804                                pageset->pcp[0].batch, pageset->pcp[0].count,
1805                                pageset->pcp[1].high, pageset->pcp[1].batch,
1806                                pageset->pcp[1].count);
1807                 }
1808         }
1809
1810         printk("Active:%lu inactive:%lu dirty:%lu writeback:%lu unstable:%lu\n"
1811                 " free:%lu slab:%lu mapped:%lu pagetables:%lu bounce:%lu\n",
1812                 global_page_state(NR_ACTIVE),
1813                 global_page_state(NR_INACTIVE),
1814                 global_page_state(NR_FILE_DIRTY),
1815                 global_page_state(NR_WRITEBACK),
1816                 global_page_state(NR_UNSTABLE_NFS),
1817                 global_page_state(NR_FREE_PAGES),
1818                 global_page_state(NR_SLAB_RECLAIMABLE) +
1819                         global_page_state(NR_SLAB_UNRECLAIMABLE),
1820                 global_page_state(NR_FILE_MAPPED),
1821                 global_page_state(NR_PAGETABLE),
1822                 global_page_state(NR_BOUNCE));
1823
1824         for_each_zone(zone) {
1825                 int i;
1826
1827                 if (!populated_zone(zone))
1828                         continue;
1829
1830                 show_node(zone);
1831                 printk("%s"
1832                         " free:%lukB"
1833                         " min:%lukB"
1834                         " low:%lukB"
1835                         " high:%lukB"
1836                         " active:%lukB"
1837                         " inactive:%lukB"
1838                         " present:%lukB"
1839                         " pages_scanned:%lu"
1840                         " all_unreclaimable? %s"
1841                         "\n",
1842                         zone->name,
1843                         K(zone_page_state(zone, NR_FREE_PAGES)),
1844                         K(zone->pages_min),
1845                         K(zone->pages_low),
1846                         K(zone->pages_high),
1847                         K(zone_page_state(zone, NR_ACTIVE)),
1848                         K(zone_page_state(zone, NR_INACTIVE)),
1849                         K(zone->present_pages),
1850                         zone->pages_scanned,
1851                         (zone->all_unreclaimable ? "yes" : "no")
1852                         );
1853                 printk("lowmem_reserve[]:");
1854                 for (i = 0; i < MAX_NR_ZONES; i++)
1855                         printk(" %lu", zone->lowmem_reserve[i]);
1856                 printk("\n");
1857         }
1858
1859         for_each_zone(zone) {
1860                 unsigned long nr[MAX_ORDER], flags, order, total = 0;
1861
1862                 if (!populated_zone(zone))
1863                         continue;
1864
1865                 show_node(zone);
1866                 printk("%s: ", zone->name);
1867
1868                 spin_lock_irqsave(&zone->lock, flags);
1869                 for (order = 0; order < MAX_ORDER; order++) {
1870                         nr[order] = zone->free_area[order].nr_free;
1871                         total += nr[order] << order;
1872                 }
1873                 spin_unlock_irqrestore(&zone->lock, flags);
1874                 for (order = 0; order < MAX_ORDER; order++)
1875                         printk("%lu*%lukB ", nr[order], K(1UL) << order);
1876                 printk("= %lukB\n", K(total));
1877         }
1878
1879         show_swap_cache_info();
1880 }
1881
1882 /*
1883  * Builds allocation fallback zone lists.
1884  *
1885  * Add all populated zones of a node to the zonelist.
1886  */
1887 static int build_zonelists_node(pg_data_t *pgdat, struct zonelist *zonelist,
1888                                 int nr_zones, enum zone_type zone_type)
1889 {
1890         struct zone *zone;
1891
1892         BUG_ON(zone_type >= MAX_NR_ZONES);
1893         zone_type++;
1894
1895         do {
1896                 zone_type--;
1897                 zone = pgdat->node_zones + zone_type;
1898                 if (populated_zone(zone)) {
1899                         zonelist->zones[nr_zones++] = zone;
1900                         check_highest_zone(zone_type);
1901                 }
1902
1903         } while (zone_type);
1904         return nr_zones;
1905 }
1906
1907
1908 /*
1909  *  zonelist_order:
1910  *  0 = automatic detection of better ordering.
1911  *  1 = order by ([node] distance, -zonetype)
1912  *  2 = order by (-zonetype, [node] distance)
1913  *
1914  *  If not NUMA, ZONELIST_ORDER_ZONE and ZONELIST_ORDER_NODE will create
1915  *  the same zonelist. So only NUMA can configure this param.
1916  */
1917 #define ZONELIST_ORDER_DEFAULT  0
1918 #define ZONELIST_ORDER_NODE     1
1919 #define ZONELIST_ORDER_ZONE     2
1920
1921 /* zonelist order in the kernel.
1922  * set_zonelist_order() will set this to NODE or ZONE.
1923  */
1924 static int current_zonelist_order = ZONELIST_ORDER_DEFAULT;
1925 static char zonelist_order_name[3][8] = {"Default", "Node", "Zone"};
1926
1927
1928 #ifdef CONFIG_NUMA
1929 /* The value user specified ....changed by config */
1930 static int user_zonelist_order = ZONELIST_ORDER_DEFAULT;
1931 /* string for sysctl */
1932 #define NUMA_ZONELIST_ORDER_LEN 16
1933 char numa_zonelist_order[16] = "default";
1934
1935 /*
1936  * interface for configure zonelist ordering.
1937  * command line option "numa_zonelist_order"
1938  *      = "[dD]efault   - default, automatic configuration.
1939  *      = "[nN]ode      - order by node locality, then by zone within node
1940  *      = "[zZ]one      - order by zone, then by locality within zone
1941  */
1942
1943 static int __parse_numa_zonelist_order(char *s)
1944 {
1945         if (*s == 'd' || *s == 'D') {
1946                 user_zonelist_order = ZONELIST_ORDER_DEFAULT;
1947         } else if (*s == 'n' || *s == 'N') {
1948                 user_zonelist_order = ZONELIST_ORDER_NODE;
1949         } else if (*s == 'z' || *s == 'Z') {
1950                 user_zonelist_order = ZONELIST_ORDER_ZONE;
1951         } else {
1952                 printk(KERN_WARNING
1953                         "Ignoring invalid numa_zonelist_order value:  "
1954                         "%s\n", s);
1955                 return -EINVAL;
1956         }
1957         return 0;
1958 }
1959
1960 static __init int setup_numa_zonelist_order(char *s)
1961 {
1962         if (s)
1963                 return __parse_numa_zonelist_order(s);
1964         return 0;
1965 }
1966 early_param("numa_zonelist_order", setup_numa_zonelist_order);
1967
1968 /*
1969  * sysctl handler for numa_zonelist_order
1970  */
1971 int numa_zonelist_order_handler(ctl_table *table, int write,
1972                 struct file *file, void __user *buffer, size_t *length,
1973                 loff_t *ppos)
1974 {
1975         char saved_string[NUMA_ZONELIST_ORDER_LEN];
1976         int ret;
1977
1978         if (write)
1979                 strncpy(saved_string, (char*)table->data,
1980                         NUMA_ZONELIST_ORDER_LEN);
1981         ret = proc_dostring(table, write, file, buffer, length, ppos);
1982         if (ret)
1983                 return ret;
1984         if (write) {
1985                 int oldval = user_zonelist_order;
1986                 if (__parse_numa_zonelist_order((char*)table->data)) {
1987                         /*
1988                          * bogus value.  restore saved string
1989                          */
1990                         strncpy((char*)table->data, saved_string,
1991                                 NUMA_ZONELIST_ORDER_LEN);
1992                         user_zonelist_order = oldval;
1993                 } else if (oldval != user_zonelist_order)
1994                         build_all_zonelists();
1995         }
1996         return 0;
1997 }
1998
1999
2000 #define MAX_NODE_LOAD (num_online_nodes())
2001 static int node_load[MAX_NUMNODES];
2002
2003 /**
2004  * find_next_best_node - find the next node that should appear in a given node's fallback list
2005  * @node: node whose fallback list we're appending
2006  * @used_node_mask: nodemask_t of already used nodes
2007  *
2008  * We use a number of factors to determine which is the next node that should
2009  * appear on a given node's fallback list.  The node should not have appeared
2010  * already in @node's fallback list, and it should be the next closest node
2011  * according to the distance array (which contains arbitrary distance values
2012  * from each node to each node in the system), and should also prefer nodes
2013  * with no CPUs, since presumably they'll have very little allocation pressure
2014  * on them otherwise.
2015  * It returns -1 if no node is found.
2016  */
2017 static int find_next_best_node(int node, nodemask_t *used_node_mask)
2018 {
2019         int n, val;
2020         int min_val = INT_MAX;
2021         int best_node = -1;
2022
2023         /* Use the local node if we haven't already */
2024         if (!node_isset(node, *used_node_mask)) {
2025                 node_set(node, *used_node_mask);
2026                 return node;
2027         }
2028
2029         for_each_node_state(n, N_HIGH_MEMORY) {
2030                 cpumask_t tmp;
2031
2032                 /* Don't want a node to appear more than once */
2033                 if (node_isset(n, *used_node_mask))
2034                         continue;
2035
2036                 /* Use the distance array to find the distance */
2037                 val = node_distance(node, n);
2038
2039                 /* Penalize nodes under us ("prefer the next node") */
2040                 val += (n < node);
2041
2042                 /* Give preference to headless and unused nodes */
2043                 tmp = node_to_cpumask(n);
2044                 if (!cpus_empty(tmp))
2045                         val += PENALTY_FOR_NODE_WITH_CPUS;
2046
2047                 /* Slight preference for less loaded node */
2048                 val *= (MAX_NODE_LOAD*MAX_NUMNODES);
2049                 val += node_load[n];
2050
2051                 if (val < min_val) {
2052                         min_val = val;
2053                         best_node = n;
2054                 }
2055         }
2056
2057         if (best_node >= 0)
2058                 node_set(best_node, *used_node_mask);
2059
2060         return best_node;
2061 }
2062
2063
2064 /*
2065  * Build zonelists ordered by node and zones within node.
2066  * This results in maximum locality--normal zone overflows into local
2067  * DMA zone, if any--but risks exhausting DMA zone.
2068  */
2069 static void build_zonelists_in_node_order(pg_data_t *pgdat, int node)
2070 {
2071         enum zone_type i;
2072         int j;
2073         struct zonelist *zonelist;
2074
2075         for (i = 0; i < MAX_NR_ZONES; i++) {
2076                 zonelist = pgdat->node_zonelists + i;
2077                 for (j = 0; zonelist->zones[j] != NULL; j++)
2078                         ;
2079                 j = build_zonelists_node(NODE_DATA(node), zonelist, j, i);
2080                 zonelist->zones[j] = NULL;
2081         }
2082 }
2083
2084 /*
2085  * Build gfp_thisnode zonelists
2086  */
2087 static void build_thisnode_zonelists(pg_data_t *pgdat)
2088 {
2089         enum zone_type i;
2090         int j;
2091         struct zonelist *zonelist;
2092
2093         for (i = 0; i < MAX_NR_ZONES; i++) {
2094                 zonelist = pgdat->node_zonelists + MAX_NR_ZONES + i;
2095                 j = build_zonelists_node(pgdat, zonelist, 0, i);
2096                 zonelist->zones[j] = NULL;
2097         }
2098 }
2099
2100 /*
2101  * Build zonelists ordered by zone and nodes within zones.
2102  * This results in conserving DMA zone[s] until all Normal memory is
2103  * exhausted, but results in overflowing to remote node while memory
2104  * may still exist in local DMA zone.
2105  */
2106 static int node_order[MAX_NUMNODES];
2107
2108 static void build_zonelists_in_zone_order(pg_data_t *pgdat, int nr_nodes)
2109 {
2110         enum zone_type i;
2111         int pos, j, node;
2112         int zone_type;          /* needs to be signed */
2113         struct zone *z;
2114         struct zonelist *zonelist;
2115
2116         for (i = 0; i < MAX_NR_ZONES; i++) {
2117                 zonelist = pgdat->node_zonelists + i;
2118                 pos = 0;
2119                 for (zone_type = i; zone_type >= 0; zone_type--) {
2120                         for (j = 0; j < nr_nodes; j++) {
2121                                 node = node_order[j];
2122                                 z = &NODE_DATA(node)->node_zones[zone_type];
2123                                 if (populated_zone(z)) {
2124                                         zonelist->zones[pos++] = z;
2125                                         check_highest_zone(zone_type);
2126                                 }
2127                         }
2128                 }
2129                 zonelist->zones[pos] = NULL;
2130         }
2131 }
2132
2133 static int default_zonelist_order(void)
2134 {
2135         int nid, zone_type;
2136         unsigned long low_kmem_size,total_size;
2137         struct zone *z;
2138         int average_size;
2139         /*
2140          * ZONE_DMA and ZONE_DMA32 can be very small area in the sytem.
2141          * If they are really small and used heavily, the system can fall
2142          * into OOM very easily.
2143          * This function detect ZONE_DMA/DMA32 size and confgigures zone order.
2144          */
2145         /* Is there ZONE_NORMAL ? (ex. ppc has only DMA zone..) */
2146         low_kmem_size = 0;
2147         total_size = 0;
2148         for_each_online_node(nid) {
2149                 for (zone_type = 0; zone_type < MAX_NR_ZONES; zone_type++) {
2150                         z = &NODE_DATA(nid)->node_zones[zone_type];
2151                         if (populated_zone(z)) {
2152                                 if (zone_type < ZONE_NORMAL)
2153                                         low_kmem_size += z->present_pages;
2154                                 total_size += z->present_pages;
2155                         }
2156                 }
2157         }
2158         if (!low_kmem_size ||  /* there are no DMA area. */
2159             low_kmem_size > total_size/2) /* DMA/DMA32 is big. */
2160                 return ZONELIST_ORDER_NODE;
2161         /*
2162          * look into each node's config.
2163          * If there is a node whose DMA/DMA32 memory is very big area on
2164          * local memory, NODE_ORDER may be suitable.
2165          */
2166         average_size = total_size /
2167                                 (nodes_weight(node_states[N_HIGH_MEMORY]) + 1);
2168         for_each_online_node(nid) {
2169                 low_kmem_size = 0;
2170                 total_size = 0;
2171                 for (zone_type = 0; zone_type < MAX_NR_ZONES; zone_type++) {
2172                         z = &NODE_DATA(nid)->node_zones[zone_type];
2173                         if (populated_zone(z)) {
2174                                 if (zone_type < ZONE_NORMAL)
2175                                         low_kmem_size += z->present_pages;
2176                                 total_size += z->present_pages;
2177                         }
2178                 }
2179                 if (low_kmem_size &&
2180                     total_size > average_size && /* ignore small node */
2181                     low_kmem_size > total_size * 70/100)
2182                         return ZONELIST_ORDER_NODE;
2183         }
2184         return ZONELIST_ORDER_ZONE;
2185 }
2186
2187 static void set_zonelist_order(void)
2188 {
2189         if (user_zonelist_order == ZONELIST_ORDER_DEFAULT)
2190                 current_zonelist_order = default_zonelist_order();
2191         else
2192                 current_zonelist_order = user_zonelist_order;
2193 }
2194
2195 static void build_zonelists(pg_data_t *pgdat)
2196 {
2197         int j, node, load;
2198         enum zone_type i;
2199         nodemask_t used_mask;
2200         int local_node, prev_node;
2201         struct zonelist *zonelist;
2202         int order = current_zonelist_order;
2203
2204         /* initialize zonelists */
2205         for (i = 0; i < MAX_ZONELISTS; i++) {
2206                 zonelist = pgdat->node_zonelists + i;
2207                 zonelist->zones[0] = NULL;
2208         }
2209
2210         /* NUMA-aware ordering of nodes */
2211         local_node = pgdat->node_id;
2212         load = num_online_nodes();
2213         prev_node = local_node;
2214         nodes_clear(used_mask);
2215
2216         memset(node_load, 0, sizeof(node_load));
2217         memset(node_order, 0, sizeof(node_order));
2218         j = 0;
2219
2220         while ((node = find_next_best_node(local_node, &used_mask)) >= 0) {
2221                 int distance = node_distance(local_node, node);
2222
2223                 /*
2224                  * If another node is sufficiently far away then it is better
2225                  * to reclaim pages in a zone before going off node.
2226                  */
2227                 if (distance > RECLAIM_DISTANCE)
2228                         zone_reclaim_mode = 1;
2229
2230                 /*
2231                  * We don't want to pressure a particular node.
2232                  * So adding penalty to the first node in same
2233                  * distance group to make it round-robin.
2234                  */
2235                 if (distance != node_distance(local_node, prev_node))
2236                         node_load[node] = load;
2237
2238                 prev_node = node;
2239                 load--;
2240                 if (order == ZONELIST_ORDER_NODE)
2241                         build_zonelists_in_node_order(pgdat, node);
2242                 else
2243                         node_order[j++] = node; /* remember order */
2244         }
2245
2246         if (order == ZONELIST_ORDER_ZONE) {
2247                 /* calculate node order -- i.e., DMA last! */
2248                 build_zonelists_in_zone_order(pgdat, j);
2249         }
2250
2251         build_thisnode_zonelists(pgdat);
2252 }
2253
2254 /* Construct the zonelist performance cache - see further mmzone.h */
2255 static void build_zonelist_cache(pg_data_t *pgdat)
2256 {
2257         int i;
2258
2259         for (i = 0; i < MAX_NR_ZONES; i++) {
2260                 struct zonelist *zonelist;
2261                 struct zonelist_cache *zlc;
2262                 struct zone **z;
2263
2264                 zonelist = pgdat->node_zonelists + i;
2265                 zonelist->zlcache_ptr = zlc = &zonelist->zlcache;
2266                 bitmap_zero(zlc->fullzones, MAX_ZONES_PER_ZONELIST);
2267                 for (z = zonelist->zones; *z; z++)
2268                         zlc->z_to_n[z - zonelist->zones] = zone_to_nid(*z);
2269         }
2270 }
2271
2272
2273 #else   /* CONFIG_NUMA */
2274
2275 static void set_zonelist_order(void)
2276 {
2277         current_zonelist_order = ZONELIST_ORDER_ZONE;
2278 }
2279
2280 static void build_zonelists(pg_data_t *pgdat)
2281 {
2282         int node, local_node;
2283         enum zone_type i,j;
2284
2285         local_node = pgdat->node_id;
2286         for (i = 0; i < MAX_NR_ZONES; i++) {
2287                 struct zonelist *zonelist;
2288
2289                 zonelist = pgdat->node_zonelists + i;
2290
2291                 j = build_zonelists_node(pgdat, zonelist, 0, i);
2292                 /*
2293                  * Now we build the zonelist so that it contains the zones
2294                  * of all the other nodes.
2295                  * We don't want to pressure a particular node, so when
2296                  * building the zones for node N, we make sure that the
2297                  * zones coming right after the local ones are those from
2298                  * node N+1 (modulo N)
2299                  */
2300                 for (node = local_node + 1; node < MAX_NUMNODES; node++) {
2301                         if (!node_online(node))
2302                                 continue;
2303                         j = build_zonelists_node(NODE_DATA(node), zonelist, j, i);
2304                 }
2305                 for (node = 0; node < local_node; node++) {
2306                         if (!node_online(node))
2307                                 continue;
2308                         j = build_zonelists_node(NODE_DATA(node), zonelist, j, i);
2309                 }
2310
2311                 zonelist->zones[j] = NULL;
2312         }
2313 }
2314
2315 /* non-NUMA variant of zonelist performance cache - just NULL zlcache_ptr */
2316 static void build_zonelist_cache(pg_data_t *pgdat)
2317 {
2318         int i;
2319
2320         for (i = 0; i < MAX_NR_ZONES; i++)
2321                 pgdat->node_zonelists[i].zlcache_ptr = NULL;
2322 }
2323
2324 #endif  /* CONFIG_NUMA */
2325
2326 /* return values int ....just for stop_machine_run() */
2327 static int __build_all_zonelists(void *dummy)
2328 {
2329         int nid;
2330
2331         for_each_online_node(nid) {
2332                 pg_data_t *pgdat = NODE_DATA(nid);
2333
2334                 build_zonelists(pgdat);
2335                 build_zonelist_cache(pgdat);
2336         }
2337         return 0;
2338 }
2339
2340 void build_all_zonelists(void)
2341 {
2342         set_zonelist_order();
2343
2344         if (system_state == SYSTEM_BOOTING) {
2345                 __build_all_zonelists(NULL);
2346                 cpuset_init_current_mems_allowed();
2347         } else {
2348                 /* we have to stop all cpus to guaranntee there is no user
2349                    of zonelist */
2350                 stop_machine_run(__build_all_zonelists, NULL, NR_CPUS);
2351                 /* cpuset refresh routine should be here */
2352         }
2353         vm_total_pages = nr_free_pagecache_pages();
2354         printk("Built %i zonelists in %s order.  Total pages: %ld\n",
2355                         num_online_nodes(),
2356                         zonelist_order_name[current_zonelist_order],
2357                         vm_total_pages);
2358 #ifdef CONFIG_NUMA
2359         printk("Policy zone: %s\n", zone_names[policy_zone]);
2360 #endif
2361 }
2362
2363 /*
2364  * Helper functions to size the waitqueue hash table.
2365  * Essentially these want to choose hash table sizes sufficiently
2366  * large so that collisions trying to wait on pages are rare.
2367  * But in fact, the number of active page waitqueues on typical
2368  * systems is ridiculously low, less than 200. So this is even
2369  * conservative, even though it seems large.
2370  *
2371  * The constant PAGES_PER_WAITQUEUE specifies the ratio of pages to
2372  * waitqueues, i.e. the size of the waitq table given the number of pages.
2373  */
2374 #define PAGES_PER_WAITQUEUE     256
2375
2376 #ifndef CONFIG_MEMORY_HOTPLUG
2377 static inline unsigned long wait_table_hash_nr_entries(unsigned long pages)
2378 {
2379         unsigned long size = 1;
2380
2381         pages /= PAGES_PER_WAITQUEUE;
2382
2383         while (size < pages)
2384                 size <<= 1;
2385
2386         /*
2387          * Once we have dozens or even hundreds of threads sleeping
2388          * on IO we've got bigger problems than wait queue collision.
2389          * Limit the size of the wait table to a reasonable size.
2390          */
2391         size = min(size, 4096UL);
2392
2393         return max(size, 4UL);
2394 }
2395 #else
2396 /*
2397  * A zone's size might be changed by hot-add, so it is not possible to determine
2398  * a suitable size for its wait_table.  So we use the maximum size now.
2399  *
2400  * The max wait table size = 4096 x sizeof(wait_queue_head_t).   ie:
2401  *
2402  *    i386 (preemption config)    : 4096 x 16 = 64Kbyte.
2403  *    ia64, x86-64 (no preemption): 4096 x 20 = 80Kbyte.
2404  *    ia64, x86-64 (preemption)   : 4096 x 24 = 96Kbyte.
2405  *
2406  * The maximum entries are prepared when a zone's memory is (512K + 256) pages
2407  * or more by the traditional way. (See above).  It equals:
2408  *
2409  *    i386, x86-64, powerpc(4K page size) : =  ( 2G + 1M)byte.
2410  *    ia64(16K page size)                 : =  ( 8G + 4M)byte.
2411  *    powerpc (64K page size)             : =  (32G +16M)byte.
2412  */
2413 static inline unsigned long wait_table_hash_nr_entries(unsigned long pages)
2414 {
2415         return 4096UL;
2416 }
2417 #endif
2418
2419 /*
2420  * This is an integer logarithm so that shifts can be used later
2421  * to extract the more random high bits from the multiplicative
2422  * hash function before the remainder is taken.
2423  */
2424 static inline unsigned long wait_table_bits(unsigned long size)
2425 {
2426         return ffz(~size);
2427 }
2428
2429 #define LONG_ALIGN(x) (((x)+(sizeof(long))-1)&~((sizeof(long))-1))
2430
2431 /*
2432  * Initially all pages are reserved - free ones are freed
2433  * up by free_all_bootmem() once the early boot process is
2434  * done. Non-atomic initialization, single-pass.
2435  */
2436 void __meminit memmap_init_zone(unsigned long size, int nid, unsigned long zone,
2437                 unsigned long start_pfn, enum memmap_context context)
2438 {
2439         struct page *page;
2440         unsigned long end_pfn = start_pfn + size;
2441         unsigned long pfn;
2442
2443         for (pfn = start_pfn; pfn < end_pfn; pfn++) {
2444                 /*
2445                  * There can be holes in boot-time mem_map[]s
2446                  * handed to this function.  They do not
2447                  * exist on hotplugged memory.
2448                  */
2449                 if (context == MEMMAP_EARLY) {
2450                         if (!early_pfn_valid(pfn))
2451                                 continue;
2452                         if (!early_pfn_in_nid(pfn, nid))
2453                                 continue;
2454                 }
2455                 page = pfn_to_page(pfn);
2456                 set_page_links(page, zone, nid, pfn);
2457                 init_page_count(page);
2458                 reset_page_mapcount(page);
2459                 SetPageReserved(page);
2460
2461                 /*
2462                  * Mark the block movable so that blocks are reserved for
2463                  * movable at startup. This will force kernel allocations
2464                  * to reserve their blocks rather than leaking throughout
2465                  * the address space during boot when many long-lived
2466                  * kernel allocations are made
2467                  */
2468                 set_pageblock_migratetype(page, MIGRATE_MOVABLE);
2469
2470                 INIT_LIST_HEAD(&page->lru);
2471 #ifdef WANT_PAGE_VIRTUAL
2472                 /* The shift won't overflow because ZONE_NORMAL is below 4G. */
2473                 if (!is_highmem_idx(zone))
2474                         set_page_address(page, __va(pfn << PAGE_SHIFT));
2475 #endif
2476         }
2477 }
2478
2479 static void __meminit zone_init_free_lists(struct pglist_data *pgdat,
2480                                 struct zone *zone, unsigned long size)
2481 {
2482         int order, t;
2483         for_each_migratetype_order(order, t) {
2484                 INIT_LIST_HEAD(&zone->free_area[order].free_list[t]);
2485                 zone->free_area[order].nr_free = 0;
2486         }
2487 }
2488
2489 #ifndef __HAVE_ARCH_MEMMAP_INIT
2490 #define memmap_init(size, nid, zone, start_pfn) \
2491         memmap_init_zone((size), (nid), (zone), (start_pfn), MEMMAP_EARLY)
2492 #endif
2493
2494 static int __devinit zone_batchsize(struct zone *zone)
2495 {
2496         int batch;
2497
2498         /*
2499          * The per-cpu-pages pools are set to around 1000th of the
2500          * size of the zone.  But no more than 1/2 of a meg.
2501          *
2502          * OK, so we don't know how big the cache is.  So guess.
2503          */
2504         batch = zone->present_pages / 1024;
2505         if (batch * PAGE_SIZE > 512 * 1024)
2506                 batch = (512 * 1024) / PAGE_SIZE;
2507         batch /= 4;             /* We effectively *= 4 below */
2508         if (batch < 1)
2509                 batch = 1;
2510
2511         /*
2512          * Clamp the batch to a 2^n - 1 value. Having a power
2513          * of 2 value was found to be more likely to have
2514          * suboptimal cache aliasing properties in some cases.
2515          *
2516          * For example if 2 tasks are alternately allocating
2517          * batches of pages, one task can end up with a lot
2518          * of pages of one half of the possible page colors
2519          * and the other with pages of the other colors.
2520          */
2521         batch = (1 << (fls(batch + batch/2)-1)) - 1;
2522
2523         return batch;
2524 }
2525
2526 inline void setup_pageset(struct per_cpu_pageset *p, unsigned long batch)
2527 {
2528         struct per_cpu_pages *pcp;
2529
2530         memset(p, 0, sizeof(*p));
2531
2532         pcp = &p->pcp[0];               /* hot */
2533         pcp->count = 0;
2534         pcp->high = 6 * batch;
2535         pcp->batch = max(1UL, 1 * batch);
2536         INIT_LIST_HEAD(&pcp->list);
2537
2538         pcp = &p->pcp[1];               /* cold*/
2539         pcp->count = 0;
2540         pcp->high = 2 * batch;
2541         pcp->batch = max(1UL, batch/2);
2542         INIT_LIST_HEAD(&pcp->list);
2543 }
2544
2545 /*
2546  * setup_pagelist_highmark() sets the high water mark for hot per_cpu_pagelist
2547  * to the value high for the pageset p.
2548  */
2549
2550 static void setup_pagelist_highmark(struct per_cpu_pageset *p,
2551                                 unsigned long high)
2552 {
2553         struct per_cpu_pages *pcp;
2554
2555         pcp = &p->pcp[0]; /* hot list */
2556         pcp->high = high;
2557         pcp->batch = max(1UL, high/4);
2558         if ((high/4) > (PAGE_SHIFT * 8))
2559                 pcp->batch = PAGE_SHIFT * 8;
2560 }
2561
2562
2563 #ifdef CONFIG_NUMA
2564 /*
2565  * Boot pageset table. One per cpu which is going to be used for all
2566  * zones and all nodes. The parameters will be set in such a way
2567  * that an item put on a list will immediately be handed over to
2568  * the buddy list. This is safe since pageset manipulation is done
2569  * with interrupts disabled.
2570  *
2571  * Some NUMA counter updates may also be caught by the boot pagesets.
2572  *
2573  * The boot_pagesets must be kept even after bootup is complete for
2574  * unused processors and/or zones. They do play a role for bootstrapping
2575  * hotplugged processors.
2576  *
2577  * zoneinfo_show() and maybe other functions do
2578  * not check if the processor is online before following the pageset pointer.
2579  * Other parts of the kernel may not check if the zone is available.
2580  */
2581 static struct per_cpu_pageset boot_pageset[NR_CPUS];
2582
2583 /*
2584  * Dynamically allocate memory for the
2585  * per cpu pageset array in struct zone.
2586  */
2587 static int __cpuinit process_zones(int cpu)
2588 {
2589         struct zone *zone, *dzone;
2590         int node = cpu_to_node(cpu);
2591
2592         node_set_state(node, N_CPU);    /* this node has a cpu */
2593
2594         for_each_zone(zone) {
2595
2596                 if (!populated_zone(zone))
2597                         continue;
2598
2599                 zone_pcp(zone, cpu) = kmalloc_node(sizeof(struct per_cpu_pageset),
2600                                          GFP_KERNEL, node);
2601                 if (!zone_pcp(zone, cpu))
2602                         goto bad;
2603
2604                 setup_pageset(zone_pcp(zone, cpu), zone_batchsize(zone));
2605
2606                 if (percpu_pagelist_fraction)
2607                         setup_pagelist_highmark(zone_pcp(zone, cpu),
2608                                 (zone->present_pages / percpu_pagelist_fraction));
2609         }
2610
2611         return 0;
2612 bad:
2613         for_each_zone(dzone) {
2614                 if (!populated_zone(dzone))
2615                         continue;
2616                 if (dzone == zone)
2617                         break;
2618                 kfree(zone_pcp(dzone, cpu));
2619                 zone_pcp(dzone, cpu) = NULL;
2620         }
2621         return -ENOMEM;
2622 }
2623
2624 static inline void free_zone_pagesets(int cpu)
2625 {
2626         struct zone *zone;
2627
2628         for_each_zone(zone) {
2629                 struct per_cpu_pageset *pset = zone_pcp(zone, cpu);
2630
2631                 /* Free per_cpu_pageset if it is slab allocated */
2632                 if (pset != &boot_pageset[cpu])
2633                         kfree(pset);
2634                 zone_pcp(zone, cpu) = NULL;
2635         }
2636 }
2637
2638 static int __cpuinit pageset_cpuup_callback(struct notifier_block *nfb,
2639                 unsigned long action,
2640                 void *hcpu)
2641 {
2642         int cpu = (long)hcpu;
2643         int ret = NOTIFY_OK;
2644
2645         switch (action) {
2646         case CPU_UP_PREPARE:
2647         case CPU_UP_PREPARE_FROZEN:
2648                 if (process_zones(cpu))
2649                         ret = NOTIFY_BAD;
2650                 break;
2651         case CPU_UP_CANCELED:
2652         case CPU_UP_CANCELED_FROZEN:
2653         case CPU_DEAD:
2654         case CPU_DEAD_FROZEN:
2655                 free_zone_pagesets(cpu);
2656                 break;
2657         default:
2658                 break;
2659         }
2660         return ret;
2661 }
2662
2663 static struct notifier_block __cpuinitdata pageset_notifier =
2664         { &pageset_cpuup_callback, NULL, 0 };
2665
2666 void __init setup_per_cpu_pageset(void)
2667 {
2668         int err;
2669
2670         /* Initialize per_cpu_pageset for cpu 0.
2671          * A cpuup callback will do this for every cpu
2672          * as it comes online
2673          */
2674         err = process_zones(smp_processor_id());
2675         BUG_ON(err);
2676         register_cpu_notifier(&pageset_notifier);
2677 }
2678
2679 #endif
2680
2681 static noinline __init_refok
2682 int zone_wait_table_init(struct zone *zone, unsigned long zone_size_pages)
2683 {
2684         int i;
2685         struct pglist_data *pgdat = zone->zone_pgdat;
2686         size_t alloc_size;
2687
2688         /*
2689          * The per-page waitqueue mechanism uses hashed waitqueues
2690          * per zone.
2691          */
2692         zone->wait_table_hash_nr_entries =
2693                  wait_table_hash_nr_entries(zone_size_pages);
2694         zone->wait_table_bits =
2695                 wait_table_bits(zone->wait_table_hash_nr_entries);
2696         alloc_size = zone->wait_table_hash_nr_entries
2697                                         * sizeof(wait_queue_head_t);
2698
2699         if (system_state == SYSTEM_BOOTING) {
2700                 zone->wait_table = (wait_queue_head_t *)
2701                         alloc_bootmem_node(pgdat, alloc_size);
2702         } else {
2703                 /*
2704                  * This case means that a zone whose size was 0 gets new memory
2705                  * via memory hot-add.
2706                  * But it may be the case that a new node was hot-added.  In
2707                  * this case vmalloc() will not be able to use this new node's
2708                  * memory - this wait_table must be initialized to use this new
2709                  * node itself as well.
2710                  * To use this new node's memory, further consideration will be
2711                  * necessary.
2712                  */
2713                 zone->wait_table = vmalloc(alloc_size);
2714         }
2715         if (!zone->wait_table)
2716                 return -ENOMEM;
2717
2718         for(i = 0; i < zone->wait_table_hash_nr_entries; ++i)
2719                 init_waitqueue_head(zone->wait_table + i);
2720
2721         return 0;
2722 }
2723
2724 static __meminit void zone_pcp_init(struct zone *zone)
2725 {
2726         int cpu;
2727         unsigned long batch = zone_batchsize(zone);
2728
2729         for (cpu = 0; cpu < NR_CPUS; cpu++) {
2730 #ifdef CONFIG_NUMA
2731                 /* Early boot. Slab allocator not functional yet */
2732                 zone_pcp(zone, cpu) = &boot_pageset[cpu];
2733                 setup_pageset(&boot_pageset[cpu],0);
2734 #else
2735                 setup_pageset(zone_pcp(zone,cpu), batch);
2736 #endif
2737         }
2738         if (zone->present_pages)
2739                 printk(KERN_DEBUG "  %s zone: %lu pages, LIFO batch:%lu\n",
2740                         zone->name, zone->present_pages, batch);
2741 }
2742
2743 __meminit int init_currently_empty_zone(struct zone *zone,
2744                                         unsigned long zone_start_pfn,
2745                                         unsigned long size,
2746                                         enum memmap_context context)
2747 {
2748         struct pglist_data *pgdat = zone->zone_pgdat;
2749         int ret;
2750         ret = zone_wait_table_init(zone, size);
2751         if (ret)
2752                 return ret;
2753         pgdat->nr_zones = zone_idx(zone) + 1;
2754
2755         zone->zone_start_pfn = zone_start_pfn;
2756
2757         memmap_init(size, pgdat->node_id, zone_idx(zone), zone_start_pfn);
2758
2759         zone_init_free_lists(pgdat, zone, zone->spanned_pages);
2760
2761         return 0;
2762 }
2763
2764 #ifdef CONFIG_ARCH_POPULATES_NODE_MAP
2765 /*
2766  * Basic iterator support. Return the first range of PFNs for a node
2767  * Note: nid == MAX_NUMNODES returns first region regardless of node
2768  */
2769 static int __meminit first_active_region_index_in_nid(int nid)
2770 {
2771         int i;
2772
2773         for (i = 0; i < nr_nodemap_entries; i++)
2774                 if (nid == MAX_NUMNODES || early_node_map[i].nid == nid)
2775                         return i;
2776
2777         return -1;
2778 }
2779
2780 /*
2781  * Basic iterator support. Return the next active range of PFNs for a node
2782  * Note: nid == MAX_NUMNODES returns next region regardles of node
2783  */
2784 static int __meminit next_active_region_index_in_nid(int index, int nid)
2785 {
2786         for (index = index + 1; index < nr_nodemap_entries; index++)
2787                 if (nid == MAX_NUMNODES || early_node_map[index].nid == nid)
2788                         return index;
2789
2790         return -1;
2791 }
2792
2793 #ifndef CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID
2794 /*
2795  * Required by SPARSEMEM. Given a PFN, return what node the PFN is on.
2796  * Architectures may implement their own version but if add_active_range()
2797  * was used and there are no special requirements, this is a convenient
2798  * alternative
2799  */
2800 int __meminit early_pfn_to_nid(unsigned long pfn)
2801 {
2802         int i;
2803
2804         for (i = 0; i < nr_nodemap_entries; i++) {
2805                 unsigned long start_pfn = early_node_map[i].start_pfn;
2806                 unsigned long end_pfn = early_node_map[i].end_pfn;
2807
2808                 if (start_pfn <= pfn && pfn < end_pfn)
2809                         return early_node_map[i].nid;
2810         }
2811
2812         return 0;
2813 }
2814 #endif /* CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID */
2815
2816 /* Basic iterator support to walk early_node_map[] */
2817 #define for_each_active_range_index_in_nid(i, nid) \
2818         for (i = first_active_region_index_in_nid(nid); i != -1; \
2819                                 i = next_active_region_index_in_nid(i, nid))
2820
2821 /**
2822  * free_bootmem_with_active_regions - Call free_bootmem_node for each active range
2823  * @nid: The node to free memory on. If MAX_NUMNODES, all nodes are freed.
2824  * @max_low_pfn: The highest PFN that will be passed to free_bootmem_node
2825  *
2826  * If an architecture guarantees that all ranges registered with
2827  * add_active_ranges() contain no holes and may be freed, this
2828  * this function may be used instead of calling free_bootmem() manually.
2829  */
2830 void __init free_bootmem_with_active_regions(int nid,
2831                                                 unsigned long max_low_pfn)
2832 {
2833         int i;
2834
2835         for_each_active_range_index_in_nid(i, nid) {
2836                 unsigned long size_pages = 0;
2837                 unsigned long end_pfn = early_node_map[i].end_pfn;
2838
2839                 if (early_node_map[i].start_pfn >= max_low_pfn)
2840                         continue;
2841
2842                 if (end_pfn > max_low_pfn)
2843                         end_pfn = max_low_pfn;
2844
2845                 size_pages = end_pfn - early_node_map[i].start_pfn;
2846                 free_bootmem_node(NODE_DATA(early_node_map[i].nid),
2847                                 PFN_PHYS(early_node_map[i].start_pfn),
2848                                 size_pages << PAGE_SHIFT);
2849         }
2850 }
2851
2852 /**
2853  * sparse_memory_present_with_active_regions - Call memory_present for each active range
2854  * @nid: The node to call memory_present for. If MAX_NUMNODES, all nodes will be used.
2855  *
2856  * If an architecture guarantees that all ranges registered with
2857  * add_active_ranges() contain no holes and may be freed, this
2858  * function may be used instead of calling memory_present() manually.
2859  */
2860 void __init sparse_memory_present_with_active_regions(int nid)
2861 {
2862         int i;
2863
2864         for_each_active_range_index_in_nid(i, nid)
2865                 memory_present(early_node_map[i].nid,
2866                                 early_node_map[i].start_pfn,
2867                                 early_node_map[i].end_pfn);
2868 }
2869
2870 /**
2871  * push_node_boundaries - Push node boundaries to at least the requested boundary
2872  * @nid: The nid of the node to push the boundary for
2873  * @start_pfn: The start pfn of the node
2874  * @end_pfn: The end pfn of the node
2875  *
2876  * In reserve-based hot-add, mem_map is allocated that is unused until hotadd
2877  * time. Specifically, on x86_64, SRAT will report ranges that can potentially
2878  * be hotplugged even though no physical memory exists. This function allows
2879  * an arch to push out the node boundaries so mem_map is allocated that can
2880  * be used later.
2881  */
2882 #ifdef CONFIG_MEMORY_HOTPLUG_RESERVE
2883 void __init push_node_boundaries(unsigned int nid,
2884                 unsigned long start_pfn, unsigned long end_pfn)
2885 {
2886         printk(KERN_DEBUG "Entering push_node_boundaries(%u, %lu, %lu)\n",
2887                         nid, start_pfn, end_pfn);
2888
2889         /* Initialise the boundary for this node if necessary */
2890         if (node_boundary_end_pfn[nid] == 0)
2891                 node_boundary_start_pfn[nid] = -1UL;
2892
2893         /* Update the boundaries */
2894         if (node_boundary_start_pfn[nid] > start_pfn)
2895                 node_boundary_start_pfn[nid] = start_pfn;
2896         if (node_boundary_end_pfn[nid] < end_pfn)
2897                 node_boundary_end_pfn[nid] = end_pfn;
2898 }
2899
2900 /* If necessary, push the node boundary out for reserve hotadd */
2901 static void __meminit account_node_boundary(unsigned int nid,
2902                 unsigned long *start_pfn, unsigned long *end_pfn)
2903 {
2904         printk(KERN_DEBUG "Entering account_node_boundary(%u, %lu, %lu)\n",
2905                         nid, *start_pfn, *end_pfn);
2906
2907         /* Return if boundary information has not been provided */
2908         if (node_boundary_end_pfn[nid] == 0)
2909                 return;
2910
2911         /* Check the boundaries and update if necessary */
2912         if (node_boundary_start_pfn[nid] < *start_pfn)
2913                 *start_pfn = node_boundary_start_pfn[nid];
2914         if (node_boundary_end_pfn[nid] > *end_pfn)
2915                 *end_pfn = node_boundary_end_pfn[nid];
2916 }
2917 #else
2918 void __init push_node_boundaries(unsigned int nid,
2919                 unsigned long start_pfn, unsigned long end_pfn) {}
2920
2921 static void __meminit account_node_boundary(unsigned int nid,
2922                 unsigned long *start_pfn, unsigned long *end_pfn) {}
2923 #endif
2924
2925
2926 /**
2927  * get_pfn_range_for_nid - Return the start and end page frames for a node
2928  * @nid: The nid to return the range for. If MAX_NUMNODES, the min and max PFN are returned.
2929  * @start_pfn: Passed by reference. On return, it will have the node start_pfn.
2930  * @end_pfn: Passed by reference. On return, it will have the node end_pfn.
2931  *
2932  * It returns the start and end page frame of a node based on information
2933  * provided by an arch calling add_active_range(). If called for a node
2934  * with no available memory, a warning is printed and the start and end
2935  * PFNs will be 0.
2936  */
2937 void __meminit get_pfn_range_for_nid(unsigned int nid,
2938                         unsigned long *start_pfn, unsigned long *end_pfn)
2939 {
2940         int i;
2941         *start_pfn = -1UL;
2942         *end_pfn = 0;
2943
2944         for_each_active_range_index_in_nid(i, nid) {
2945                 *start_pfn = min(*start_pfn, early_node_map[i].start_pfn);
2946                 *end_pfn = max(*end_pfn, early_node_map[i].end_pfn);
2947         }
2948
2949         if (*start_pfn == -1UL)
2950                 *start_pfn = 0;
2951
2952         /* Push the node boundaries out if requested */
2953         account_node_boundary(nid, start_pfn, end_pfn);
2954 }
2955
2956 /*
2957  * This finds a zone that can be used for ZONE_MOVABLE pages. The
2958  * assumption is made that zones within a node are ordered in monotonic
2959  * increasing memory addresses so that the "highest" populated zone is used
2960  */
2961 void __init find_usable_zone_for_movable(void)
2962 {
2963         int zone_index;
2964         for (zone_index = MAX_NR_ZONES - 1; zone_index >= 0; zone_index--) {
2965                 if (zone_index == ZONE_MOVABLE)
2966                         continue;
2967
2968                 if (arch_zone_highest_possible_pfn[zone_index] >
2969                                 arch_zone_lowest_possible_pfn[zone_index])
2970                         break;
2971         }
2972
2973         VM_BUG_ON(zone_index == -1);
2974         movable_zone = zone_index;
2975 }
2976
2977 /*
2978  * The zone ranges provided by the architecture do not include ZONE_MOVABLE
2979  * because it is sized independant of architecture. Unlike the other zones,
2980  * the starting point for ZONE_MOVABLE is not fixed. It may be different
2981  * in each node depending on the size of each node and how evenly kernelcore
2982  * is distributed. This helper function adjusts the zone ranges
2983  * provided by the architecture for a given node by using the end of the
2984  * highest usable zone for ZONE_MOVABLE. This preserves the assumption that
2985  * zones within a node are in order of monotonic increases memory addresses
2986  */
2987 void __meminit adjust_zone_range_for_zone_movable(int nid,
2988                                         unsigned long zone_type,
2989                                         unsigned long node_start_pfn,
2990                                         unsigned long node_end_pfn,
2991                                         unsigned long *zone_start_pfn,
2992                                         unsigned long *zone_end_pfn)
2993 {
2994         /* Only adjust if ZONE_MOVABLE is on this node */
2995         if (zone_movable_pfn[nid]) {
2996                 /* Size ZONE_MOVABLE */
2997                 if (zone_type == ZONE_MOVABLE) {
2998                         *zone_start_pfn = zone_movable_pfn[nid];
2999                         *zone_end_pfn = min(node_end_pfn,
3000                                 arch_zone_highest_possible_pfn[movable_zone]);
3001
3002                 /* Adjust for ZONE_MOVABLE starting within this range */
3003                 } else if (*zone_start_pfn < zone_movable_pfn[nid] &&
3004                                 *zone_end_pfn > zone_movable_pfn[nid]) {
3005                         *zone_end_pfn = zone_movable_pfn[nid];
3006
3007                 /* Check if this whole range is within ZONE_MOVABLE */
3008                 } else if (*zone_start_pfn >= zone_movable_pfn[nid])
3009                         *zone_start_pfn = *zone_end_pfn;
3010         }
3011 }
3012
3013 /*
3014  * Return the number of pages a zone spans in a node, including holes
3015  * present_pages = zone_spanned_pages_in_node() - zone_absent_pages_in_node()
3016  */
3017 static unsigned long __meminit zone_spanned_pages_in_node(int nid,
3018                                         unsigned long zone_type,
3019                                         unsigned long *ignored)
3020 {
3021         unsigned long node_start_pfn, node_end_pfn;
3022         unsigned long zone_start_pfn, zone_end_pfn;
3023
3024         /* Get the start and end of the node and zone */
3025         get_pfn_range_for_nid(nid, &node_start_pfn, &node_end_pfn);
3026         zone_start_pfn = arch_zone_lowest_possible_pfn[zone_type];
3027         zone_end_pfn = arch_zone_highest_possible_pfn[zone_type];
3028         adjust_zone_range_for_zone_movable(nid, zone_type,
3029                                 node_start_pfn, node_end_pfn,
3030                                 &zone_start_pfn, &zone_end_pfn);
3031
3032         /* Check that this node has pages within the zone's required range */
3033         if (zone_end_pfn < node_start_pfn || zone_start_pfn > node_end_pfn)
3034                 return 0;
3035
3036         /* Move the zone boundaries inside the node if necessary */
3037         zone_end_pfn = min(zone_end_pfn, node_end_pfn);
3038         zone_start_pfn = max(zone_start_pfn, node_start_pfn);
3039
3040         /* Return the spanned pages */
3041         return zone_end_pfn - zone_start_pfn;
3042 }
3043
3044 /*
3045  * Return the number of holes in a range on a node. If nid is MAX_NUMNODES,
3046  * then all holes in the requested range will be accounted for.
3047  */
3048 unsigned long __meminit __absent_pages_in_range(int nid,
3049                                 unsigned long range_start_pfn,
3050                                 unsigned long range_end_pfn)
3051 {
3052         int i = 0;
3053         unsigned long prev_end_pfn = 0, hole_pages = 0;
3054         unsigned long start_pfn;
3055
3056         /* Find the end_pfn of the first active range of pfns in the node */
3057         i = first_active_region_index_in_nid(nid);
3058         if (i == -1)
3059                 return 0;
3060
3061         prev_end_pfn = min(early_node_map[i].start_pfn, range_end_pfn);
3062
3063         /* Account for ranges before physical memory on this node */
3064         if (early_node_map[i].start_pfn > range_start_pfn)
3065                 hole_pages = prev_end_pfn - range_start_pfn;
3066
3067         /* Find all holes for the zone within the node */
3068         for (; i != -1; i = next_active_region_index_in_nid(i, nid)) {
3069
3070                 /* No need to continue if prev_end_pfn is outside the zone */
3071                 if (prev_end_pfn >= range_end_pfn)
3072                         break;
3073
3074                 /* Make sure the end of the zone is not within the hole */
3075                 start_pfn = min(early_node_map[i].start_pfn, range_end_pfn);
3076                 prev_end_pfn = max(prev_end_pfn, range_start_pfn);
3077
3078                 /* Update the hole size cound and move on */
3079                 if (start_pfn > range_start_pfn) {
3080                         BUG_ON(prev_end_pfn > start_pfn);
3081                         hole_pages += start_pfn - prev_end_pfn;
3082                 }
3083                 prev_end_pfn = early_node_map[i].end_pfn;
3084         }
3085
3086         /* Account for ranges past physical memory on this node */
3087         if (range_end_pfn > prev_end_pfn)
3088                 hole_pages += range_end_pfn -
3089                                 max(range_start_pfn, prev_end_pfn);
3090
3091         return hole_pages;
3092 }
3093
3094 /**
3095  * absent_pages_in_range - Return number of page frames in holes within a range
3096  * @start_pfn: The start PFN to start searching for holes
3097  * @end_pfn: The end PFN to stop searching for holes
3098  *
3099  * It returns the number of pages frames in memory holes within a range.
3100  */
3101 unsigned long __init absent_pages_in_range(unsigned long start_pfn,
3102                                                         unsigned long end_pfn)
3103 {
3104         return __absent_pages_in_range(MAX_NUMNODES, start_pfn, end_pfn);
3105 }
3106
3107 /* Return the number of page frames in holes in a zone on a node */
3108 static unsigned long __meminit zone_absent_pages_in_node(int nid,
3109                                         unsigned long zone_type,
3110                                         unsigned long *ignored)
3111 {
3112         unsigned long node_start_pfn, node_end_pfn;
3113         unsigned long zone_start_pfn, zone_end_pfn;
3114
3115         get_pfn_range_for_nid(nid, &node_start_pfn, &node_end_pfn);
3116         zone_start_pfn = max(arch_zone_lowest_possible_pfn[zone_type],
3117                                                         node_start_pfn);
3118         zone_end_pfn = min(arch_zone_highest_possible_pfn[zone_type],
3119                                                         node_end_pfn);
3120
3121         adjust_zone_range_for_zone_movable(nid, zone_type,
3122                         node_start_pfn, node_end_pfn,
3123                         &zone_start_pfn, &zone_end_pfn);
3124         return __absent_pages_in_range(nid, zone_start_pfn, zone_end_pfn);
3125 }
3126
3127 #else
3128 static inline unsigned long __meminit zone_spanned_pages_in_node(int nid,
3129                                         unsigned long zone_type,
3130                                         unsigned long *zones_size)
3131 {
3132         return zones_size[zone_type];
3133 }
3134
3135 static inline unsigned long __meminit zone_absent_pages_in_node(int nid,
3136                                                 unsigned long zone_type,
3137                                                 unsigned long *zholes_size)
3138 {
3139         if (!zholes_size)
3140                 return 0;
3141
3142         return zholes_size[zone_type];
3143 }
3144
3145 #endif
3146
3147 static void __meminit calculate_node_totalpages(struct pglist_data *pgdat,
3148                 unsigned long *zones_size, unsigned long *zholes_size)
3149 {
3150         unsigned long realtotalpages, totalpages = 0;
3151         enum zone_type i;
3152
3153         for (i = 0; i < MAX_NR_ZONES; i++)
3154                 totalpages += zone_spanned_pages_in_node(pgdat->node_id, i,
3155                                                                 zones_size);
3156         pgdat->node_spanned_pages = totalpages;
3157
3158         realtotalpages = totalpages;
3159         for (i = 0; i < MAX_NR_ZONES; i++)
3160                 realtotalpages -=
3161                         zone_absent_pages_in_node(pgdat->node_id, i,
3162                                                                 zholes_size);
3163         pgdat->node_present_pages = realtotalpages;
3164         printk(KERN_DEBUG "On node %d totalpages: %lu\n", pgdat->node_id,
3165                                                         realtotalpages);
3166 }
3167
3168 #ifndef CONFIG_SPARSEMEM
3169 /*
3170  * Calculate the size of the zone->blockflags rounded to an unsigned long
3171  * Start by making sure zonesize is a multiple of MAX_ORDER-1 by rounding up
3172  * Then figure 1 NR_PAGEBLOCK_BITS worth of bits per MAX_ORDER-1, finally
3173  * round what is now in bits to nearest long in bits, then return it in
3174  * bytes.
3175  */
3176 static unsigned long __init usemap_size(unsigned long zonesize)
3177 {
3178         unsigned long usemapsize;
3179
3180         usemapsize = roundup(zonesize, MAX_ORDER_NR_PAGES);
3181         usemapsize = usemapsize >> (MAX_ORDER-1);
3182         usemapsize *= NR_PAGEBLOCK_BITS;
3183         usemapsize = roundup(usemapsize, 8 * sizeof(unsigned long));
3184
3185         return usemapsize / 8;
3186 }
3187
3188 static void __init setup_usemap(struct pglist_data *pgdat,
3189                                 struct zone *zone, unsigned long zonesize)
3190 {
3191         unsigned long usemapsize = usemap_size(zonesize);
3192         zone->pageblock_flags = NULL;
3193         if (usemapsize) {
3194                 zone->pageblock_flags = alloc_bootmem_node(pgdat, usemapsize);
3195                 memset(zone->pageblock_flags, 0, usemapsize);
3196         }
3197 }
3198 #else
3199 static void inline setup_usemap(struct pglist_data *pgdat,
3200                                 struct zone *zone, unsigned long zonesize) {}
3201 #endif /* CONFIG_SPARSEMEM */
3202
3203 /*
3204  * Set up the zone data structures:
3205  *   - mark all pages reserved
3206  *   - mark all memory queues empty
3207  *   - clear the memory bitmaps
3208  */
3209 static void __meminit free_area_init_core(struct pglist_data *pgdat,
3210                 unsigned long *zones_size, unsigned long *zholes_size)
3211 {
3212         enum zone_type j;
3213         int nid = pgdat->node_id;
3214         unsigned long zone_start_pfn = pgdat->node_start_pfn;
3215         int ret;
3216
3217         pgdat_resize_init(pgdat);
3218         pgdat->nr_zones = 0;
3219         init_waitqueue_head(&pgdat->kswapd_wait);
3220         pgdat->kswapd_max_order = 0;
3221         
3222         for (j = 0; j < MAX_NR_ZONES; j++) {
3223                 struct zone *zone = pgdat->node_zones + j;
3224                 unsigned long size, realsize, memmap_pages;
3225
3226                 size = zone_spanned_pages_in_node(nid, j, zones_size);
3227                 realsize = size - zone_absent_pages_in_node(nid, j,
3228                                                                 zholes_size);
3229
3230                 /*
3231                  * Adjust realsize so that it accounts for how much memory
3232                  * is used by this zone for memmap. This affects the watermark
3233                  * and per-cpu initialisations
3234                  */
3235                 memmap_pages = (size * sizeof(struct page)) >> PAGE_SHIFT;
3236                 if (realsize >= memmap_pages) {
3237                         realsize -= memmap_pages;
3238                         printk(KERN_DEBUG
3239                                 "  %s zone: %lu pages used for memmap\n",
3240                                 zone_names[j], memmap_pages);
3241                 } else
3242                         printk(KERN_WARNING
3243                                 "  %s zone: %lu pages exceeds realsize %lu\n",
3244                                 zone_names[j], memmap_pages, realsize);
3245
3246                 /* Account for reserved pages */
3247                 if (j == 0 && realsize > dma_reserve) {
3248                         realsize -= dma_reserve;
3249                         printk(KERN_DEBUG "  %s zone: %lu pages reserved\n",
3250                                         zone_names[0], dma_reserve);
3251                 }
3252
3253                 if (!is_highmem_idx(j))
3254                         nr_kernel_pages += realsize;
3255                 nr_all_pages += realsize;
3256
3257                 zone->spanned_pages = size;
3258                 zone->present_pages = realsize;
3259 #ifdef CONFIG_NUMA
3260                 zone->node = nid;
3261                 zone->min_unmapped_pages = (realsize*sysctl_min_unmapped_ratio)
3262                                                 / 100;
3263                 zone->min_slab_pages = (realsize * sysctl_min_slab_ratio) / 100;
3264 #endif
3265                 zone->name = zone_names[j];
3266                 spin_lock_init(&zone->lock);
3267                 spin_lock_init(&zone->lru_lock);
3268                 zone_seqlock_init(zone);
3269                 zone->zone_pgdat = pgdat;
3270
3271                 zone->prev_priority = DEF_PRIORITY;
3272
3273                 zone_pcp_init(zone);
3274                 INIT_LIST_HEAD(&zone->active_list);
3275                 INIT_LIST_HEAD(&zone->inactive_list);
3276                 zone->nr_scan_active = 0;
3277                 zone->nr_scan_inactive = 0;
3278                 zap_zone_vm_stats(zone);
3279                 atomic_set(&zone->reclaim_in_progress, 0);
3280                 if (!size)
3281                         continue;
3282
3283                 setup_usemap(pgdat, zone, size);
3284                 ret = init_currently_empty_zone(zone, zone_start_pfn,
3285                                                 size, MEMMAP_EARLY);
3286                 BUG_ON(ret);
3287                 zone_start_pfn += size;
3288         }
3289 }
3290
3291 static void __init_refok alloc_node_mem_map(struct pglist_data *pgdat)
3292 {
3293         /* Skip empty nodes */
3294         if (!pgdat->node_spanned_pages)
3295                 return;
3296
3297 #ifdef CONFIG_FLAT_NODE_MEM_MAP
3298         /* ia64 gets its own node_mem_map, before this, without bootmem */
3299         if (!pgdat->node_mem_map) {
3300                 unsigned long size, start, end;
3301                 struct page *map;
3302
3303                 /*
3304                  * The zone's endpoints aren't required to be MAX_ORDER
3305                  * aligned but the node_mem_map endpoints must be in order
3306                  * for the buddy allocator to function correctly.
3307                  */
3308                 start = pgdat->node_start_pfn & ~(MAX_ORDER_NR_PAGES - 1);
3309                 end = pgdat->node_start_pfn + pgdat->node_spanned_pages;
3310                 end = ALIGN(end, MAX_ORDER_NR_PAGES);
3311                 size =  (end - start) * sizeof(struct page);
3312                 map = alloc_remap(pgdat->node_id, size);
3313                 if (!map)
3314                         map = alloc_bootmem_node(pgdat, size);
3315                 pgdat->node_mem_map = map + (pgdat->node_start_pfn - start);
3316         }
3317 #ifndef CONFIG_NEED_MULTIPLE_NODES
3318         /*
3319          * With no DISCONTIG, the global mem_map is just set as node 0's
3320          */
3321         if (pgdat == NODE_DATA(0)) {
3322                 mem_map = NODE_DATA(0)->node_mem_map;
3323 #ifdef CONFIG_ARCH_POPULATES_NODE_MAP
3324                 if (page_to_pfn(mem_map) != pgdat->node_start_pfn)
3325                         mem_map -= pgdat->node_start_pfn;
3326 #endif /* CONFIG_ARCH_POPULATES_NODE_MAP */
3327         }
3328 #endif
3329 #endif /* CONFIG_FLAT_NODE_MEM_MAP */
3330 }
3331
3332 void __meminit free_area_init_node(int nid, struct pglist_data *pgdat,
3333                 unsigned long *zones_size, unsigned long node_start_pfn,
3334                 unsigned long *zholes_size)
3335 {
3336         pgdat->node_id = nid;
3337         pgdat->node_start_pfn = node_start_pfn;
3338         calculate_node_totalpages(pgdat, zones_size, zholes_size);
3339
3340         alloc_node_mem_map(pgdat);
3341
3342         free_area_init_core(pgdat, zones_size, zholes_size);
3343 }
3344
3345 #ifdef CONFIG_ARCH_POPULATES_NODE_MAP
3346
3347 #if MAX_NUMNODES > 1
3348 /*
3349  * Figure out the number of possible node ids.
3350  */
3351 static void __init setup_nr_node_ids(void)
3352 {
3353         unsigned int node;
3354         unsigned int highest = 0;
3355
3356         for_each_node_mask(node, node_possible_map)
3357                 highest = node;
3358         nr_node_ids = highest + 1;
3359 }
3360 #else
3361 static inline void setup_nr_node_ids(void)
3362 {
3363 }
3364 #endif
3365
<