v2.4.8 -> v2.4.8.1
[opensuse:kernel.git] / mm / page_alloc.c
1 /*
2  *  linux/mm/page_alloc.c
3  *
4  *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
5  *  Swap reorganised 29.12.95, Stephen Tweedie
6  *  Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
7  *  Reshaped it to be a zoned allocator, Ingo Molnar, Red Hat, 1999
8  *  Discontiguous memory support, Kanoj Sarcar, SGI, Nov 1999
9  *  Zone balancing, Kanoj Sarcar, SGI, Jan 2000
10  */
11
12 #include <linux/config.h>
13 #include <linux/mm.h>
14 #include <linux/swap.h>
15 #include <linux/swapctl.h>
16 #include <linux/interrupt.h>
17 #include <linux/pagemap.h>
18 #include <linux/bootmem.h>
19 #include <linux/slab.h>
20
21 int nr_swap_pages;
22 int nr_active_pages;
23 int nr_inactive_dirty_pages;
24 pg_data_t *pgdat_list;
25
26 static char *zone_names[MAX_NR_ZONES] = { "DMA", "Normal", "HighMem" };
27 static int zone_balance_ratio[MAX_NR_ZONES] = { 32, 128, 128, };
28 static int zone_balance_min[MAX_NR_ZONES] = { 10 , 10, 10, };
29 static int zone_balance_max[MAX_NR_ZONES] = { 255 , 255, 255, };
30
31 struct list_head active_list;
32 struct list_head inactive_dirty_list;
33 /*
34  * Free_page() adds the page to the free lists. This is optimized for
35  * fast normal cases (no error jumps taken normally).
36  *
37  * The way to optimize jumps for gcc-2.2.2 is to:
38  *  - select the "normal" case and put it inside the if () { XXX }
39  *  - no else-statements if you can avoid them
40  *
41  * With the above two rules, you get a straight-line execution path
42  * for the normal case, giving better asm-code.
43  */
44
45 #define memlist_init(x) INIT_LIST_HEAD(x)
46 #define memlist_add_head list_add
47 #define memlist_add_tail list_add_tail
48 #define memlist_del list_del
49 #define memlist_entry list_entry
50 #define memlist_next(x) ((x)->next)
51 #define memlist_prev(x) ((x)->prev)
52
53 /*
54  * Temporary debugging check.
55  */
56 #define BAD_RANGE(zone,x) (((zone) != (x)->zone) || (((x)-mem_map) < (zone)->zone_start_mapnr) || (((x)-mem_map) >= (zone)->zone_start_mapnr+(zone)->size))
57
58 /*
59  * Buddy system. Hairy. You really aren't expected to understand this
60  *
61  * Hint: -mask = 1+~mask
62  */
63
64 static void FASTCALL(__free_pages_ok (struct page *page, unsigned long order));
65 static void __free_pages_ok (struct page *page, unsigned long order)
66 {
67         unsigned long index, page_idx, mask, flags;
68         free_area_t *area;
69         struct page *base;
70         zone_t *zone;
71
72         if (page->buffers)
73                 BUG();
74         if (page->mapping)
75                 BUG();
76         if (!VALID_PAGE(page))
77                 BUG();
78         if (PageSwapCache(page))
79                 BUG();
80         if (PageLocked(page))
81                 BUG();
82         if (PageDecrAfter(page))
83                 BUG();
84         if (PageActive(page))
85                 BUG();
86         if (PageInactiveDirty(page))
87                 BUG();
88         if (PageInactiveClean(page))
89                 BUG();
90
91         page->flags &= ~((1<<PG_referenced) | (1<<PG_dirty));
92         page->age = PAGE_AGE_START;
93         
94         zone = page->zone;
95
96         mask = (~0UL) << order;
97         base = zone->zone_mem_map;
98         page_idx = page - base;
99         if (page_idx & ~mask)
100                 BUG();
101         index = page_idx >> (1 + order);
102
103         area = zone->free_area + order;
104
105         spin_lock_irqsave(&zone->lock, flags);
106
107         zone->free_pages -= mask;
108
109         while (mask + (1 << (MAX_ORDER-1))) {
110                 struct page *buddy1, *buddy2;
111
112                 if (area >= zone->free_area + MAX_ORDER)
113                         BUG();
114                 if (!__test_and_change_bit(index, area->map))
115                         /*
116                          * the buddy page is still allocated.
117                          */
118                         break;
119                 /*
120                  * Move the buddy up one level.
121                  */
122                 buddy1 = base + (page_idx ^ -mask);
123                 buddy2 = base + page_idx;
124                 if (BAD_RANGE(zone,buddy1))
125                         BUG();
126                 if (BAD_RANGE(zone,buddy2))
127                         BUG();
128
129                 memlist_del(&buddy1->list);
130                 mask <<= 1;
131                 area++;
132                 index >>= 1;
133                 page_idx &= mask;
134         }
135         memlist_add_head(&(base + page_idx)->list, &area->free_list);
136
137         spin_unlock_irqrestore(&zone->lock, flags);
138
139         /*
140          * We don't want to protect this variable from race conditions
141          * since it's nothing important, but we do want to make sure
142          * it never gets negative.
143          */
144         if (memory_pressure > NR_CPUS)
145                 memory_pressure--;
146 }
147
148 #define MARK_USED(index, order, area) \
149         __change_bit((index) >> (1+(order)), (area)->map)
150
151 static inline struct page * expand (zone_t *zone, struct page *page,
152          unsigned long index, int low, int high, free_area_t * area)
153 {
154         unsigned long size = 1 << high;
155
156         while (high > low) {
157                 if (BAD_RANGE(zone,page))
158                         BUG();
159                 area--;
160                 high--;
161                 size >>= 1;
162                 memlist_add_head(&(page)->list, &(area)->free_list);
163                 MARK_USED(index, high, area);
164                 index += size;
165                 page += size;
166         }
167         if (BAD_RANGE(zone,page))
168                 BUG();
169         return page;
170 }
171
172 static FASTCALL(struct page * rmqueue(zone_t *zone, unsigned long order));
173 static struct page * rmqueue(zone_t *zone, unsigned long order)
174 {
175         free_area_t * area = zone->free_area + order;
176         unsigned long curr_order = order;
177         struct list_head *head, *curr;
178         unsigned long flags;
179         struct page *page;
180
181         spin_lock_irqsave(&zone->lock, flags);
182         do {
183                 head = &area->free_list;
184                 curr = memlist_next(head);
185
186                 if (curr != head) {
187                         unsigned int index;
188
189                         page = memlist_entry(curr, struct page, list);
190                         if (BAD_RANGE(zone,page))
191                                 BUG();
192                         memlist_del(curr);
193                         index = page - zone->zone_mem_map;
194                         if (curr_order != MAX_ORDER-1)
195                                 MARK_USED(index, curr_order, area);
196                         zone->free_pages -= 1 << order;
197
198                         page = expand(zone, page, index, order, curr_order, area);
199                         spin_unlock_irqrestore(&zone->lock, flags);
200
201                         set_page_count(page, 1);
202                         if (BAD_RANGE(zone,page))
203                                 BUG();
204                         DEBUG_ADD_PAGE
205                         return page;    
206                 }
207                 curr_order++;
208                 area++;
209         } while (curr_order < MAX_ORDER);
210         spin_unlock_irqrestore(&zone->lock, flags);
211
212         return NULL;
213 }
214
215 #define PAGES_MIN       0
216 #define PAGES_LOW       1
217 #define PAGES_HIGH      2
218
219 /*
220  * This function does the dirty work for __alloc_pages
221  * and is separated out to keep the code size smaller.
222  * (suggested by Davem at 1:30 AM, typed by Rik at 6 AM)
223  */
224 static struct page * __alloc_pages_limit(zonelist_t *zonelist,
225                         unsigned long order, int limit, int direct_reclaim)
226 {
227         zone_t **zone = zonelist->zones;
228
229         for (;;) {
230                 zone_t *z = *(zone++);
231                 unsigned long water_mark;
232
233                 if (!z)
234                         break;
235                 if (!z->size)
236                         BUG();
237
238                 /*
239                  * We allocate if the number of free + inactive_clean
240                  * pages is above the watermark.
241                  */
242                 switch (limit) {
243                         default:
244                         case PAGES_MIN:
245                                 water_mark = z->pages_min;
246                                 break;
247                         case PAGES_LOW:
248                                 water_mark = z->pages_low;
249                                 break;
250                         case PAGES_HIGH:
251                                 water_mark = z->pages_high;
252                 }
253
254                 if (z->free_pages + z->inactive_clean_pages >= water_mark) {
255                         struct page *page = NULL;
256                         /* If possible, reclaim a page directly. */
257                         if (direct_reclaim)
258                                 page = reclaim_page(z);
259                         /* If that fails, fall back to rmqueue. */
260                         if (!page)
261                                 page = rmqueue(z, order);
262                         if (page)
263                                 return page;
264                 }
265         }
266
267         /* Found nothing. */
268         return NULL;
269 }
270
271 #ifndef CONFIG_DISCONTIGMEM
272 struct page *_alloc_pages(unsigned int gfp_mask, unsigned long order)
273 {
274         return __alloc_pages(gfp_mask, order,
275                 contig_page_data.node_zonelists+(gfp_mask & GFP_ZONEMASK));
276 }
277 #endif
278
279 /*
280  * This is the 'heart' of the zoned buddy allocator:
281  */
282 struct page * __alloc_pages(unsigned int gfp_mask, unsigned long order, zonelist_t *zonelist)
283 {
284         zone_t **zone;
285         int direct_reclaim = 0;
286         struct page * page;
287
288         /*
289          * Allocations put pressure on the VM subsystem.
290          */
291         memory_pressure++;
292
293         /*
294          * (If anyone calls gfp from interrupts nonatomically then it
295          * will sooner or later tripped up by a schedule().)
296          *
297          * We are falling back to lower-level zones if allocation
298          * in a higher zone fails.
299          */
300
301         /*
302          * Can we take pages directly from the inactive_clean
303          * list?
304          */
305         if (order == 0 && (gfp_mask & __GFP_WAIT))
306                 direct_reclaim = 1;
307
308 try_again:
309         /*
310          * First, see if we have any zones with lots of free memory.
311          *
312          * We allocate free memory first because it doesn't contain
313          * any data ... DUH!
314          */
315         zone = zonelist->zones;
316         for (;;) {
317                 zone_t *z = *(zone++);
318                 if (!z)
319                         break;
320                 if (!z->size)
321                         BUG();
322
323                 if (z->free_pages >= z->pages_low) {
324                         page = rmqueue(z, order);
325                         if (page)
326                                 return page;
327                 } else if (z->free_pages < z->pages_min &&
328                                         waitqueue_active(&kreclaimd_wait)) {
329                                 wake_up_interruptible(&kreclaimd_wait);
330                 }
331         }
332
333         /*
334          * Try to allocate a page from a zone with a HIGH
335          * amount of free + inactive_clean pages.
336          *
337          * If there is a lot of activity, inactive_target
338          * will be high and we'll have a good chance of
339          * finding a page using the HIGH limit.
340          */
341         page = __alloc_pages_limit(zonelist, order, PAGES_HIGH, direct_reclaim);
342         if (page)
343                 return page;
344
345         /*
346          * Then try to allocate a page from a zone with more
347          * than zone->pages_low free + inactive_clean pages.
348          *
349          * When the working set is very large and VM activity
350          * is low, we're most likely to have our allocation
351          * succeed here.
352          */
353         page = __alloc_pages_limit(zonelist, order, PAGES_LOW, direct_reclaim);
354         if (page)
355                 return page;
356
357         /*
358          * OK, none of the zones on our zonelist has lots
359          * of pages free.
360          *
361          * We wake up kswapd, in the hope that kswapd will
362          * resolve this situation before memory gets tight.
363          *
364          * We also yield the CPU, because that:
365          * - gives kswapd a chance to do something
366          * - slows down allocations, in particular the
367          *   allocations from the fast allocator that's
368          *   causing the problems ...
369          * - ... which minimises the impact the "bad guys"
370          *   have on the rest of the system
371          * - if we don't have __GFP_IO set, kswapd may be
372          *   able to free some memory we can't free ourselves
373          */
374         wakeup_kswapd();
375         if (gfp_mask & __GFP_WAIT) {
376                 __set_current_state(TASK_RUNNING);
377                 current->policy |= SCHED_YIELD;
378                 schedule();
379         }
380
381         /*
382          * After waking up kswapd, we try to allocate a page
383          * from any zone which isn't critical yet.
384          *
385          * Kswapd should, in most situations, bring the situation
386          * back to normal in no time.
387          */
388         page = __alloc_pages_limit(zonelist, order, PAGES_MIN, direct_reclaim);
389         if (page)
390                 return page;
391
392         /*
393          * Damn, we didn't succeed.
394          *
395          * This can be due to 2 reasons:
396          * - we're doing a higher-order allocation
397          *      --> move pages to the free list until we succeed
398          * - we're /really/ tight on memory
399          *      --> try to free pages ourselves with page_launder
400          */
401         if (!(current->flags & PF_MEMALLOC)) {
402                 /*
403                  * Are we dealing with a higher order allocation?
404                  *
405                  * Move pages from the inactive_clean to the free list
406                  * in the hope of creating a large, physically contiguous
407                  * piece of free memory.
408                  */
409                 if (order > 0 && (gfp_mask & __GFP_WAIT)) {
410                         zone = zonelist->zones;
411                         /* First, clean some dirty pages. */
412                         current->flags |= PF_MEMALLOC;
413                         page_launder(gfp_mask, 1);
414                         current->flags &= ~PF_MEMALLOC;
415                         for (;;) {
416                                 zone_t *z = *(zone++);
417                                 if (!z)
418                                         break;
419                                 if (!z->size)
420                                         continue;
421                                 while (z->inactive_clean_pages) {
422                                         struct page * page;
423                                         /* Move one page to the free list. */
424                                         page = reclaim_page(z);
425                                         if (!page)
426                                                 break;
427                                         __free_page(page);
428                                         /* Try if the allocation succeeds. */
429                                         page = rmqueue(z, order);
430                                         if (page)
431                                                 return page;
432                                 }
433                         }
434                 }
435                 /*
436                  * When we arrive here, we are really tight on memory.
437                  * Since kswapd didn't succeed in freeing pages for us,
438                  * we try to help it.
439                  *
440                  * Single page allocs loop until the allocation succeeds.
441                  * Multi-page allocs can fail due to memory fragmentation;
442                  * in that case we bail out to prevent infinite loops and
443                  * hanging device drivers ...
444                  *
445                  * Another issue are GFP_NOFS allocations; because they
446                  * do not have __GFP_FS set it's possible we cannot make
447                  * any progress freeing pages, in that case it's better
448                  * to give up than to deadlock the kernel looping here.
449                  */
450                 if (gfp_mask & __GFP_WAIT) {
451                         if (!order || free_shortage()) {
452                                 int progress = try_to_free_pages(gfp_mask);
453                                 if (progress || (gfp_mask & __GFP_FS))
454                                         goto try_again;
455                                 /*
456                                  * Fail in case no progress was made and the
457                                  * allocation may not be able to block on IO.
458                                  */
459                                 return NULL;
460                         }
461                 }
462         }
463
464         /*
465          * Final phase: allocate anything we can!
466          *
467          * Higher order allocations, GFP_ATOMIC allocations and
468          * recursive allocations (PF_MEMALLOC) end up here.
469          *
470          * Only recursive allocations can use the very last pages
471          * in the system, otherwise it would be just too easy to
472          * deadlock the system...
473          */
474         zone = zonelist->zones;
475         for (;;) {
476                 zone_t *z = *(zone++);
477                 struct page * page = NULL;
478                 if (!z)
479                         break;
480                 if (!z->size)
481                         BUG();
482
483                 /*
484                  * SUBTLE: direct_reclaim is only possible if the task
485                  * becomes PF_MEMALLOC while looping above. This will
486                  * happen when the OOM killer selects this task for
487                  * instant execution...
488                  */
489                 if (direct_reclaim) {
490                         page = reclaim_page(z);
491                         if (page)
492                                 return page;
493                 }
494
495                 /* XXX: is pages_min/4 a good amount to reserve for this? */
496                 if (z->free_pages < z->pages_min / 4 &&
497                                 !(current->flags & PF_MEMALLOC))
498                         continue;
499                 page = rmqueue(z, order);
500                 if (page)
501                         return page;
502         }
503
504         /* No luck.. */
505         printk(KERN_ERR "__alloc_pages: %lu-order allocation failed.\n", order);
506         return NULL;
507 }
508
509 /*
510  * Common helper functions.
511  */
512 unsigned long __get_free_pages(int gfp_mask, unsigned long order)
513 {
514         struct page * page;
515
516         page = alloc_pages(gfp_mask, order);
517         if (!page)
518                 return 0;
519         return (unsigned long) page_address(page);
520 }
521
522 unsigned long get_zeroed_page(int gfp_mask)
523 {
524         struct page * page;
525
526         page = alloc_pages(gfp_mask, 0);
527         if (page) {
528                 void *address = page_address(page);
529                 clear_page(address);
530                 return (unsigned long) address;
531         }
532         return 0;
533 }
534
535 void __free_pages(struct page *page, unsigned long order)
536 {
537         if (!PageReserved(page) && put_page_testzero(page))
538                 __free_pages_ok(page, order);
539 }
540
541 void free_pages(unsigned long addr, unsigned long order)
542 {
543         if (addr != 0)
544                 __free_pages(virt_to_page(addr), order);
545 }
546
547 /*
548  * Total amount of free (allocatable) RAM:
549  */
550 unsigned int nr_free_pages (void)
551 {
552         unsigned int sum;
553         zone_t *zone;
554         pg_data_t *pgdat = pgdat_list;
555
556         sum = 0;
557         while (pgdat) {
558                 for (zone = pgdat->node_zones; zone < pgdat->node_zones + MAX_NR_ZONES; zone++)
559                         sum += zone->free_pages;
560                 pgdat = pgdat->node_next;
561         }
562         return sum;
563 }
564
565 /*
566  * Total amount of inactive_clean (allocatable) RAM:
567  */
568 unsigned int nr_inactive_clean_pages (void)
569 {
570         unsigned int sum;
571         zone_t *zone;
572         pg_data_t *pgdat = pgdat_list;
573
574         sum = 0;
575         while (pgdat) {
576                 for (zone = pgdat->node_zones; zone < pgdat->node_zones + MAX_NR_ZONES; zone++)
577                         sum += zone->inactive_clean_pages;
578                 pgdat = pgdat->node_next;
579         }
580         return sum;
581 }
582
583 /*
584  * Amount of free RAM allocatable as buffer memory:
585  */
586 unsigned int nr_free_buffer_pages (void)
587 {
588         unsigned int sum = 0;
589         zonelist_t *zonelist;
590         zone_t **zonep, *zone;
591
592         zonelist = contig_page_data.node_zonelists + (GFP_NOFS & GFP_ZONEMASK);
593         zonep = zonelist->zones;
594
595         for (zone = *zonep++; zone; zone = *zonep++) {
596                 unsigned int pages = zone->free_pages +
597                         zone->inactive_clean_pages +
598                         zone->inactive_dirty_pages;
599
600                 /* Allow the buffer cache to fill up at least "pages_high" pages */
601                 if (pages < zone->pages_high)
602                         pages = zone->pages_high;
603                 sum += pages;
604         }
605
606         return sum;
607 }
608
609 #if CONFIG_HIGHMEM
610 unsigned int nr_free_highpages (void)
611 {
612         pg_data_t *pgdat = pgdat_list;
613         unsigned int pages = 0;
614
615         while (pgdat) {
616                 pages += pgdat->node_zones[ZONE_HIGHMEM].free_pages;
617                 pgdat = pgdat->node_next;
618         }
619         return pages;
620 }
621 #endif
622
623 /*
624  * Show free area list (used inside shift_scroll-lock stuff)
625  * We also calculate the percentage fragmentation. We do this by counting the
626  * memory on each free list with the exception of the first item on the list.
627  */
628 void show_free_areas_core(pg_data_t *pgdat)
629 {
630         unsigned long order;
631         unsigned type;
632
633         printk("Free pages:      %6dkB (%6dkB HighMem)\n",
634                 nr_free_pages() << (PAGE_SHIFT-10),
635                 nr_free_highpages() << (PAGE_SHIFT-10));
636
637         printk("( Active: %d, inactive_dirty: %d, inactive_clean: %d, free: %d (%d %d %d) )\n",
638                 nr_active_pages,
639                 nr_inactive_dirty_pages,
640                 nr_inactive_clean_pages(),
641                 nr_free_pages(),
642                 freepages.min,
643                 freepages.low,
644                 freepages.high);
645
646         for (type = 0; type < MAX_NR_ZONES; type++) {
647                 struct list_head *head, *curr;
648                 zone_t *zone = pgdat->node_zones + type;
649                 unsigned long nr, total, flags;
650
651                 total = 0;
652                 if (zone->size) {
653                         spin_lock_irqsave(&zone->lock, flags);
654                         for (order = 0; order < MAX_ORDER; order++) {
655                                 head = &(zone->free_area + order)->free_list;
656                                 curr = head;
657                                 nr = 0;
658                                 for (;;) {
659                                         curr = memlist_next(curr);
660                                         if (curr == head)
661                                                 break;
662                                         nr++;
663                                 }
664                                 total += nr * (1 << order);
665                                 printk("%lu*%lukB ", nr,
666                                                 (PAGE_SIZE>>10) << order);
667                         }
668                         spin_unlock_irqrestore(&zone->lock, flags);
669                 }
670                 printk("= %lukB)\n", total * (PAGE_SIZE>>10));
671         }
672
673 #ifdef SWAP_CACHE_INFO
674         show_swap_cache_info();
675 #endif  
676 }
677
678 void show_free_areas(void)
679 {
680         show_free_areas_core(pgdat_list);
681 }
682
683 /*
684  * Builds allocation fallback zone lists.
685  */
686 static inline void build_zonelists(pg_data_t *pgdat)
687 {
688         int i, j, k;
689
690         for (i = 0; i <= GFP_ZONEMASK; i++) {
691                 zonelist_t *zonelist;
692                 zone_t *zone;
693
694                 zonelist = pgdat->node_zonelists + i;
695                 memset(zonelist, 0, sizeof(*zonelist));
696
697                 j = 0;
698                 k = ZONE_NORMAL;
699                 if (i & __GFP_HIGHMEM)
700                         k = ZONE_HIGHMEM;
701                 if (i & __GFP_DMA)
702                         k = ZONE_DMA;
703
704                 switch (k) {
705                         default:
706                                 BUG();
707                         /*
708                          * fallthrough:
709                          */
710                         case ZONE_HIGHMEM:
711                                 zone = pgdat->node_zones + ZONE_HIGHMEM;
712                                 if (zone->size) {
713 #ifndef CONFIG_HIGHMEM
714                                         BUG();
715 #endif
716                                         zonelist->zones[j++] = zone;
717                                 }
718                         case ZONE_NORMAL:
719                                 zone = pgdat->node_zones + ZONE_NORMAL;
720                                 if (zone->size)
721                                         zonelist->zones[j++] = zone;
722                         case ZONE_DMA:
723                                 zone = pgdat->node_zones + ZONE_DMA;
724                                 if (zone->size)
725                                         zonelist->zones[j++] = zone;
726                 }
727                 zonelist->zones[j++] = NULL;
728         } 
729 }
730
731 #define LONG_ALIGN(x) (((x)+(sizeof(long))-1)&~((sizeof(long))-1))
732
733 /*
734  * Set up the zone data structures:
735  *   - mark all pages reserved
736  *   - mark all memory queues empty
737  *   - clear the memory bitmaps
738  */
739 void __init free_area_init_core(int nid, pg_data_t *pgdat, struct page **gmap,
740         unsigned long *zones_size, unsigned long zone_start_paddr, 
741         unsigned long *zholes_size, struct page *lmem_map)
742 {
743         struct page *p;
744         unsigned long i, j;
745         unsigned long map_size;
746         unsigned long totalpages, offset, realtotalpages;
747         const unsigned long zone_required_alignment = 1UL << (MAX_ORDER-1);
748
749         if (zone_start_paddr & ~PAGE_MASK)
750                 BUG();
751
752         totalpages = 0;
753         for (i = 0; i < MAX_NR_ZONES; i++) {
754                 unsigned long size = zones_size[i];
755                 totalpages += size;
756         }
757         realtotalpages = totalpages;
758         if (zholes_size)
759                 for (i = 0; i < MAX_NR_ZONES; i++)
760                         realtotalpages -= zholes_size[i];
761                         
762         printk("On node %d totalpages: %lu\n", nid, realtotalpages);
763
764         memlist_init(&active_list);
765         memlist_init(&inactive_dirty_list);
766
767         /*
768          * Some architectures (with lots of mem and discontinous memory
769          * maps) have to search for a good mem_map area:
770          * For discontigmem, the conceptual mem map array starts from 
771          * PAGE_OFFSET, we need to align the actual array onto a mem map 
772          * boundary, so that MAP_NR works.
773          */
774         map_size = (totalpages + 1)*sizeof(struct page);
775         if (lmem_map == (struct page *)0) {
776                 lmem_map = (struct page *) alloc_bootmem_node(pgdat, map_size);
777                 lmem_map = (struct page *)(PAGE_OFFSET + 
778                         MAP_ALIGN((unsigned long)lmem_map - PAGE_OFFSET));
779         }
780         *gmap = pgdat->node_mem_map = lmem_map;
781         pgdat->node_size = totalpages;
782         pgdat->node_start_paddr = zone_start_paddr;
783         pgdat->node_start_mapnr = (lmem_map - mem_map);
784
785         /*
786          * Initially all pages are reserved - free ones are freed
787          * up by free_all_bootmem() once the early boot process is
788          * done.
789          */
790         for (p = lmem_map; p < lmem_map + totalpages; p++) {
791                 set_page_count(p, 0);
792                 SetPageReserved(p);
793                 init_waitqueue_head(&p->wait);
794                 memlist_init(&p->list);
795         }
796
797         offset = lmem_map - mem_map;    
798         for (j = 0; j < MAX_NR_ZONES; j++) {
799                 zone_t *zone = pgdat->node_zones + j;
800                 unsigned long mask;
801                 unsigned long size, realsize;
802
803                 realsize = size = zones_size[j];
804                 if (zholes_size)
805                         realsize -= zholes_size[j];
806
807                 printk("zone(%lu): %lu pages.\n", j, size);
808                 zone->size = size;
809                 zone->name = zone_names[j];
810                 zone->lock = SPIN_LOCK_UNLOCKED;
811                 zone->zone_pgdat = pgdat;
812                 zone->free_pages = 0;
813                 zone->inactive_clean_pages = 0;
814                 zone->inactive_dirty_pages = 0;
815                 memlist_init(&zone->inactive_clean_list);
816                 if (!size)
817                         continue;
818
819                 mask = (realsize / zone_balance_ratio[j]);
820                 if (mask < zone_balance_min[j])
821                         mask = zone_balance_min[j];
822                 else if (mask > zone_balance_max[j])
823                         mask = zone_balance_max[j];
824                 zone->pages_min = mask;
825                 zone->pages_low = mask*2;
826                 zone->pages_high = mask*3;
827                 /*
828                  * Add these free targets to the global free target;
829                  * we have to be SURE that freepages.high is higher
830                  * than SUM [zone->pages_min] for all zones, otherwise
831                  * we may have bad bad problems.
832                  *
833                  * This means we cannot make the freepages array writable
834                  * in /proc, but have to add a separate extra_free_target
835                  * for people who require it to catch load spikes in eg.
836                  * gigabit ethernet routing...
837                  */
838                 freepages.min += mask;
839                 freepages.low += mask*2;
840                 freepages.high += mask*3;
841                 zone->zone_mem_map = mem_map + offset;
842                 zone->zone_start_mapnr = offset;
843                 zone->zone_start_paddr = zone_start_paddr;
844
845                 if ((zone_start_paddr >> PAGE_SHIFT) & (zone_required_alignment-1))
846                         printk("BUG: wrong zone alignment, it will crash\n");
847
848                 for (i = 0; i < size; i++) {
849                         struct page *page = mem_map + offset + i;
850                         page->zone = zone;
851                         if (j != ZONE_HIGHMEM)
852                                 page->virtual = __va(zone_start_paddr);
853                         zone_start_paddr += PAGE_SIZE;
854                 }
855
856                 offset += size;
857                 for (i = 0; ; i++) {
858                         unsigned long bitmap_size;
859
860                         memlist_init(&zone->free_area[i].free_list);
861                         if (i == MAX_ORDER-1) {
862                                 zone->free_area[i].map = NULL;
863                                 break;
864                         }
865
866                         /*
867                          * Page buddy system uses "index >> (i+1)",
868                          * where "index" is at most "size-1".
869                          *
870                          * The extra "+3" is to round down to byte
871                          * size (8 bits per byte assumption). Thus
872                          * we get "(size-1) >> (i+4)" as the last byte
873                          * we can access.
874                          *
875                          * The "+1" is because we want to round the
876                          * byte allocation up rather than down. So
877                          * we should have had a "+7" before we shifted
878                          * down by three. Also, we have to add one as
879                          * we actually _use_ the last bit (it's [0,n]
880                          * inclusive, not [0,n[).
881                          *
882                          * So we actually had +7+1 before we shift
883                          * down by 3. But (n+8) >> 3 == (n >> 3) + 1
884                          * (modulo overflows, which we do not have).
885                          *
886                          * Finally, we LONG_ALIGN because all bitmap
887                          * operations are on longs.
888                          */
889                         bitmap_size = (size-1) >> (i+4);
890                         bitmap_size = LONG_ALIGN(bitmap_size+1);
891                         zone->free_area[i].map = 
892                           (unsigned long *) alloc_bootmem_node(pgdat, bitmap_size);
893                 }
894         }
895         build_zonelists(pgdat);
896 }
897
898 void __init free_area_init(unsigned long *zones_size)
899 {
900         free_area_init_core(0, &contig_page_data, &mem_map, zones_size, 0, 0, 0);
901 }
902
903 static int __init setup_mem_frac(char *str)
904 {
905         int j = 0;
906
907         while (get_option(&str, &zone_balance_ratio[j++]) == 2);
908         printk("setup_mem_frac: ");
909         for (j = 0; j < MAX_NR_ZONES; j++) printk("%d  ", zone_balance_ratio[j]);
910         printk("\n");
911         return 1;
912 }
913
914 __setup("memfrac=", setup_mem_frac);