Merge git://git.kernel.org/pub/scm/linux/kernel/git/rusty/linux-2.6-cpumask
[linux-2.6.git] / include / linux / mmzone.h
1 #ifndef _LINUX_MMZONE_H
2 #define _LINUX_MMZONE_H
3
4 #ifndef __ASSEMBLY__
5 #ifndef __GENERATING_BOUNDS_H
6
7 #include <linux/spinlock.h>
8 #include <linux/list.h>
9 #include <linux/wait.h>
10 #include <linux/bitops.h>
11 #include <linux/cache.h>
12 #include <linux/threads.h>
13 #include <linux/numa.h>
14 #include <linux/init.h>
15 #include <linux/seqlock.h>
16 #include <linux/nodemask.h>
17 #include <linux/pageblock-flags.h>
18 #include <linux/bounds.h>
19 #include <asm/atomic.h>
20 #include <asm/page.h>
21
22 /* Free memory management - zoned buddy allocator.  */
23 #ifndef CONFIG_FORCE_MAX_ZONEORDER
24 #define MAX_ORDER 11
25 #else
26 #define MAX_ORDER CONFIG_FORCE_MAX_ZONEORDER
27 #endif
28 #define MAX_ORDER_NR_PAGES (1 << (MAX_ORDER - 1))
29
30 /*
31  * PAGE_ALLOC_COSTLY_ORDER is the order at which allocations are deemed
32  * costly to service.  That is between allocation orders which should
33  * coelesce naturally under reasonable reclaim pressure and those which
34  * will not.
35  */
36 #define PAGE_ALLOC_COSTLY_ORDER 3
37
38 #define MIGRATE_UNMOVABLE     0
39 #define MIGRATE_RECLAIMABLE   1
40 #define MIGRATE_MOVABLE       2
41 #define MIGRATE_RESERVE       3
42 #define MIGRATE_ISOLATE       4 /* can't allocate from here */
43 #define MIGRATE_TYPES         5
44
45 #define for_each_migratetype_order(order, type) \
46         for (order = 0; order < MAX_ORDER; order++) \
47                 for (type = 0; type < MIGRATE_TYPES; type++)
48
49 extern int page_group_by_mobility_disabled;
50
51 static inline int get_pageblock_migratetype(struct page *page)
52 {
53         if (unlikely(page_group_by_mobility_disabled))
54                 return MIGRATE_UNMOVABLE;
55
56         return get_pageblock_flags_group(page, PB_migrate, PB_migrate_end);
57 }
58
59 struct free_area {
60         struct list_head        free_list[MIGRATE_TYPES];
61         unsigned long           nr_free;
62 };
63
64 struct pglist_data;
65
66 /*
67  * zone->lock and zone->lru_lock are two of the hottest locks in the kernel.
68  * So add a wild amount of padding here to ensure that they fall into separate
69  * cachelines.  There are very few zone structures in the machine, so space
70  * consumption is not a concern here.
71  */
72 #if defined(CONFIG_SMP)
73 struct zone_padding {
74         char x[0];
75 } ____cacheline_internodealigned_in_smp;
76 #define ZONE_PADDING(name)      struct zone_padding name;
77 #else
78 #define ZONE_PADDING(name)
79 #endif
80
81 enum zone_stat_item {
82         /* First 128 byte cacheline (assuming 64 bit words) */
83         NR_FREE_PAGES,
84         NR_LRU_BASE,
85         NR_INACTIVE_ANON = NR_LRU_BASE, /* must match order of LRU_[IN]ACTIVE */
86         NR_ACTIVE_ANON,         /*  "     "     "   "       "         */
87         NR_INACTIVE_FILE,       /*  "     "     "   "       "         */
88         NR_ACTIVE_FILE,         /*  "     "     "   "       "         */
89 #ifdef CONFIG_UNEVICTABLE_LRU
90         NR_UNEVICTABLE,         /*  "     "     "   "       "         */
91         NR_MLOCK,               /* mlock()ed pages found and moved off LRU */
92 #else
93         NR_UNEVICTABLE = NR_ACTIVE_FILE, /* avoid compiler errors in dead code */
94         NR_MLOCK = NR_ACTIVE_FILE,
95 #endif
96         NR_ANON_PAGES,  /* Mapped anonymous pages */
97         NR_FILE_MAPPED, /* pagecache pages mapped into pagetables.
98                            only modified from process context */
99         NR_FILE_PAGES,
100         NR_FILE_DIRTY,
101         NR_WRITEBACK,
102         NR_SLAB_RECLAIMABLE,
103         NR_SLAB_UNRECLAIMABLE,
104         NR_PAGETABLE,           /* used for pagetables */
105         NR_UNSTABLE_NFS,        /* NFS unstable pages */
106         NR_BOUNCE,
107         NR_VMSCAN_WRITE,
108         /* Second 128 byte cacheline */
109         NR_WRITEBACK_TEMP,      /* Writeback using temporary buffers */
110 #ifdef CONFIG_NUMA
111         NUMA_HIT,               /* allocated in intended node */
112         NUMA_MISS,              /* allocated in non intended node */
113         NUMA_FOREIGN,           /* was intended here, hit elsewhere */
114         NUMA_INTERLEAVE_HIT,    /* interleaver preferred this zone */
115         NUMA_LOCAL,             /* allocation from local node */
116         NUMA_OTHER,             /* allocation from other node */
117 #endif
118         NR_VM_ZONE_STAT_ITEMS };
119
120 /*
121  * We do arithmetic on the LRU lists in various places in the code,
122  * so it is important to keep the active lists LRU_ACTIVE higher in
123  * the array than the corresponding inactive lists, and to keep
124  * the *_FILE lists LRU_FILE higher than the corresponding _ANON lists.
125  *
126  * This has to be kept in sync with the statistics in zone_stat_item
127  * above and the descriptions in vmstat_text in mm/vmstat.c
128  */
129 #define LRU_BASE 0
130 #define LRU_ACTIVE 1
131 #define LRU_FILE 2
132
133 enum lru_list {
134         LRU_INACTIVE_ANON = LRU_BASE,
135         LRU_ACTIVE_ANON = LRU_BASE + LRU_ACTIVE,
136         LRU_INACTIVE_FILE = LRU_BASE + LRU_FILE,
137         LRU_ACTIVE_FILE = LRU_BASE + LRU_FILE + LRU_ACTIVE,
138 #ifdef CONFIG_UNEVICTABLE_LRU
139         LRU_UNEVICTABLE,
140 #else
141         LRU_UNEVICTABLE = LRU_ACTIVE_FILE, /* avoid compiler errors in dead code */
142 #endif
143         NR_LRU_LISTS
144 };
145
146 #define for_each_lru(l) for (l = 0; l < NR_LRU_LISTS; l++)
147
148 #define for_each_evictable_lru(l) for (l = 0; l <= LRU_ACTIVE_FILE; l++)
149
150 static inline int is_file_lru(enum lru_list l)
151 {
152         return (l == LRU_INACTIVE_FILE || l == LRU_ACTIVE_FILE);
153 }
154
155 static inline int is_active_lru(enum lru_list l)
156 {
157         return (l == LRU_ACTIVE_ANON || l == LRU_ACTIVE_FILE);
158 }
159
160 static inline int is_unevictable_lru(enum lru_list l)
161 {
162 #ifdef CONFIG_UNEVICTABLE_LRU
163         return (l == LRU_UNEVICTABLE);
164 #else
165         return 0;
166 #endif
167 }
168
169 struct per_cpu_pages {
170         int count;              /* number of pages in the list */
171         int high;               /* high watermark, emptying needed */
172         int batch;              /* chunk size for buddy add/remove */
173         struct list_head list;  /* the list of pages */
174 };
175
176 struct per_cpu_pageset {
177         struct per_cpu_pages pcp;
178 #ifdef CONFIG_NUMA
179         s8 expire;
180 #endif
181 #ifdef CONFIG_SMP
182         s8 stat_threshold;
183         s8 vm_stat_diff[NR_VM_ZONE_STAT_ITEMS];
184 #endif
185 } ____cacheline_aligned_in_smp;
186
187 #ifdef CONFIG_NUMA
188 #define zone_pcp(__z, __cpu) ((__z)->pageset[(__cpu)])
189 #else
190 #define zone_pcp(__z, __cpu) (&(__z)->pageset[(__cpu)])
191 #endif
192
193 #endif /* !__GENERATING_BOUNDS.H */
194
195 enum zone_type {
196 #ifdef CONFIG_ZONE_DMA
197         /*
198          * ZONE_DMA is used when there are devices that are not able
199          * to do DMA to all of addressable memory (ZONE_NORMAL). Then we
200          * carve out the portion of memory that is needed for these devices.
201          * The range is arch specific.
202          *
203          * Some examples
204          *
205          * Architecture         Limit
206          * ---------------------------
207          * parisc, ia64, sparc  <4G
208          * s390                 <2G
209          * arm                  Various
210          * alpha                Unlimited or 0-16MB.
211          *
212          * i386, x86_64 and multiple other arches
213          *                      <16M.
214          */
215         ZONE_DMA,
216 #endif
217 #ifdef CONFIG_ZONE_DMA32
218         /*
219          * x86_64 needs two ZONE_DMAs because it supports devices that are
220          * only able to do DMA to the lower 16M but also 32 bit devices that
221          * can only do DMA areas below 4G.
222          */
223         ZONE_DMA32,
224 #endif
225         /*
226          * Normal addressable memory is in ZONE_NORMAL. DMA operations can be
227          * performed on pages in ZONE_NORMAL if the DMA devices support
228          * transfers to all addressable memory.
229          */
230         ZONE_NORMAL,
231 #ifdef CONFIG_HIGHMEM
232         /*
233          * A memory area that is only addressable by the kernel through
234          * mapping portions into its own address space. This is for example
235          * used by i386 to allow the kernel to address the memory beyond
236          * 900MB. The kernel will set up special mappings (page
237          * table entries on i386) for each page that the kernel needs to
238          * access.
239          */
240         ZONE_HIGHMEM,
241 #endif
242         ZONE_MOVABLE,
243         __MAX_NR_ZONES
244 };
245
246 #ifndef __GENERATING_BOUNDS_H
247
248 /*
249  * When a memory allocation must conform to specific limitations (such
250  * as being suitable for DMA) the caller will pass in hints to the
251  * allocator in the gfp_mask, in the zone modifier bits.  These bits
252  * are used to select a priority ordered list of memory zones which
253  * match the requested limits. See gfp_zone() in include/linux/gfp.h
254  */
255
256 #if MAX_NR_ZONES < 2
257 #define ZONES_SHIFT 0
258 #elif MAX_NR_ZONES <= 2
259 #define ZONES_SHIFT 1
260 #elif MAX_NR_ZONES <= 4
261 #define ZONES_SHIFT 2
262 #else
263 #error ZONES_SHIFT -- too many zones configured adjust calculation
264 #endif
265
266 struct zone_reclaim_stat {
267         /*
268          * The pageout code in vmscan.c keeps track of how many of the
269          * mem/swap backed and file backed pages are refeferenced.
270          * The higher the rotated/scanned ratio, the more valuable
271          * that cache is.
272          *
273          * The anon LRU stats live in [0], file LRU stats in [1]
274          */
275         unsigned long           recent_rotated[2];
276         unsigned long           recent_scanned[2];
277 };
278
279 struct zone {
280         /* Fields commonly accessed by the page allocator */
281         unsigned long           pages_min, pages_low, pages_high;
282         /*
283          * We don't know if the memory that we're going to allocate will be freeable
284          * or/and it will be released eventually, so to avoid totally wasting several
285          * GB of ram we must reserve some of the lower zone memory (otherwise we risk
286          * to run OOM on the lower zones despite there's tons of freeable ram
287          * on the higher zones). This array is recalculated at runtime if the
288          * sysctl_lowmem_reserve_ratio sysctl changes.
289          */
290         unsigned long           lowmem_reserve[MAX_NR_ZONES];
291
292 #ifdef CONFIG_NUMA
293         int node;
294         /*
295          * zone reclaim becomes active if more unmapped pages exist.
296          */
297         unsigned long           min_unmapped_pages;
298         unsigned long           min_slab_pages;
299         struct per_cpu_pageset  *pageset[NR_CPUS];
300 #else
301         struct per_cpu_pageset  pageset[NR_CPUS];
302 #endif
303         /*
304          * free areas of different sizes
305          */
306         spinlock_t              lock;
307 #ifdef CONFIG_MEMORY_HOTPLUG
308         /* see spanned/present_pages for more description */
309         seqlock_t               span_seqlock;
310 #endif
311         struct free_area        free_area[MAX_ORDER];
312
313 #ifndef CONFIG_SPARSEMEM
314         /*
315          * Flags for a pageblock_nr_pages block. See pageblock-flags.h.
316          * In SPARSEMEM, this map is stored in struct mem_section
317          */
318         unsigned long           *pageblock_flags;
319 #endif /* CONFIG_SPARSEMEM */
320
321
322         ZONE_PADDING(_pad1_)
323
324         /* Fields commonly accessed by the page reclaim scanner */
325         spinlock_t              lru_lock;       
326         struct {
327                 struct list_head list;
328                 unsigned long nr_scan;
329         } lru[NR_LRU_LISTS];
330
331         struct zone_reclaim_stat reclaim_stat;
332
333         unsigned long           pages_scanned;     /* since last reclaim */
334         unsigned long           flags;             /* zone flags, see below */
335
336         /* Zone statistics */
337         atomic_long_t           vm_stat[NR_VM_ZONE_STAT_ITEMS];
338
339         /*
340          * prev_priority holds the scanning priority for this zone.  It is
341          * defined as the scanning priority at which we achieved our reclaim
342          * target at the previous try_to_free_pages() or balance_pgdat()
343          * invokation.
344          *
345          * We use prev_priority as a measure of how much stress page reclaim is
346          * under - it drives the swappiness decision: whether to unmap mapped
347          * pages.
348          *
349          * Access to both this field is quite racy even on uniprocessor.  But
350          * it is expected to average out OK.
351          */
352         int prev_priority;
353
354         /*
355          * The target ratio of ACTIVE_ANON to INACTIVE_ANON pages on
356          * this zone's LRU.  Maintained by the pageout code.
357          */
358         unsigned int inactive_ratio;
359
360
361         ZONE_PADDING(_pad2_)
362         /* Rarely used or read-mostly fields */
363
364         /*
365          * wait_table           -- the array holding the hash table
366          * wait_table_hash_nr_entries   -- the size of the hash table array
367          * wait_table_bits      -- wait_table_size == (1 << wait_table_bits)
368          *
369          * The purpose of all these is to keep track of the people
370          * waiting for a page to become available and make them
371          * runnable again when possible. The trouble is that this
372          * consumes a lot of space, especially when so few things
373          * wait on pages at a given time. So instead of using
374          * per-page waitqueues, we use a waitqueue hash table.
375          *
376          * The bucket discipline is to sleep on the same queue when
377          * colliding and wake all in that wait queue when removing.
378          * When something wakes, it must check to be sure its page is
379          * truly available, a la thundering herd. The cost of a
380          * collision is great, but given the expected load of the
381          * table, they should be so rare as to be outweighed by the
382          * benefits from the saved space.
383          *
384          * __wait_on_page_locked() and unlock_page() in mm/filemap.c, are the
385          * primary users of these fields, and in mm/page_alloc.c
386          * free_area_init_core() performs the initialization of them.
387          */
388         wait_queue_head_t       * wait_table;
389         unsigned long           wait_table_hash_nr_entries;
390         unsigned long           wait_table_bits;
391
392         /*
393          * Discontig memory support fields.
394          */
395         struct pglist_data      *zone_pgdat;
396         /* zone_start_pfn == zone_start_paddr >> PAGE_SHIFT */
397         unsigned long           zone_start_pfn;
398
399         /*
400          * zone_start_pfn, spanned_pages and present_pages are all
401          * protected by span_seqlock.  It is a seqlock because it has
402          * to be read outside of zone->lock, and it is done in the main
403          * allocator path.  But, it is written quite infrequently.
404          *
405          * The lock is declared along with zone->lock because it is
406          * frequently read in proximity to zone->lock.  It's good to
407          * give them a chance of being in the same cacheline.
408          */
409         unsigned long           spanned_pages;  /* total size, including holes */
410         unsigned long           present_pages;  /* amount of memory (excluding holes) */
411
412         /*
413          * rarely used fields:
414          */
415         const char              *name;
416 } ____cacheline_internodealigned_in_smp;
417
418 typedef enum {
419         ZONE_ALL_UNRECLAIMABLE,         /* all pages pinned */
420         ZONE_RECLAIM_LOCKED,            /* prevents concurrent reclaim */
421         ZONE_OOM_LOCKED,                /* zone is in OOM killer zonelist */
422 } zone_flags_t;
423
424 static inline void zone_set_flag(struct zone *zone, zone_flags_t flag)
425 {
426         set_bit(flag, &zone->flags);
427 }
428
429 static inline int zone_test_and_set_flag(struct zone *zone, zone_flags_t flag)
430 {
431         return test_and_set_bit(flag, &zone->flags);
432 }
433
434 static inline void zone_clear_flag(struct zone *zone, zone_flags_t flag)
435 {
436         clear_bit(flag, &zone->flags);
437 }
438
439 static inline int zone_is_all_unreclaimable(const struct zone *zone)
440 {
441         return test_bit(ZONE_ALL_UNRECLAIMABLE, &zone->flags);
442 }
443
444 static inline int zone_is_reclaim_locked(const struct zone *zone)
445 {
446         return test_bit(ZONE_RECLAIM_LOCKED, &zone->flags);
447 }
448
449 static inline int zone_is_oom_locked(const struct zone *zone)
450 {
451         return test_bit(ZONE_OOM_LOCKED, &zone->flags);
452 }
453
454 /*
455  * The "priority" of VM scanning is how much of the queues we will scan in one
456  * go. A value of 12 for DEF_PRIORITY implies that we will scan 1/4096th of the
457  * queues ("queue_length >> 12") during an aging round.
458  */
459 #define DEF_PRIORITY 12
460
461 /* Maximum number of zones on a zonelist */
462 #define MAX_ZONES_PER_ZONELIST (MAX_NUMNODES * MAX_NR_ZONES)
463
464 #ifdef CONFIG_NUMA
465
466 /*
467  * The NUMA zonelists are doubled becausse we need zonelists that restrict the
468  * allocations to a single node for GFP_THISNODE.
469  *
470  * [0]  : Zonelist with fallback
471  * [1]  : No fallback (GFP_THISNODE)
472  */
473 #define MAX_ZONELISTS 2
474
475
476 /*
477  * We cache key information from each zonelist for smaller cache
478  * footprint when scanning for free pages in get_page_from_freelist().
479  *
480  * 1) The BITMAP fullzones tracks which zones in a zonelist have come
481  *    up short of free memory since the last time (last_fullzone_zap)
482  *    we zero'd fullzones.
483  * 2) The array z_to_n[] maps each zone in the zonelist to its node
484  *    id, so that we can efficiently evaluate whether that node is
485  *    set in the current tasks mems_allowed.
486  *
487  * Both fullzones and z_to_n[] are one-to-one with the zonelist,
488  * indexed by a zones offset in the zonelist zones[] array.
489  *
490  * The get_page_from_freelist() routine does two scans.  During the
491  * first scan, we skip zones whose corresponding bit in 'fullzones'
492  * is set or whose corresponding node in current->mems_allowed (which
493  * comes from cpusets) is not set.  During the second scan, we bypass
494  * this zonelist_cache, to ensure we look methodically at each zone.
495  *
496  * Once per second, we zero out (zap) fullzones, forcing us to
497  * reconsider nodes that might have regained more free memory.
498  * The field last_full_zap is the time we last zapped fullzones.
499  *
500  * This mechanism reduces the amount of time we waste repeatedly
501  * reexaming zones for free memory when they just came up low on
502  * memory momentarilly ago.
503  *
504  * The zonelist_cache struct members logically belong in struct
505  * zonelist.  However, the mempolicy zonelists constructed for
506  * MPOL_BIND are intentionally variable length (and usually much
507  * shorter).  A general purpose mechanism for handling structs with
508  * multiple variable length members is more mechanism than we want
509  * here.  We resort to some special case hackery instead.
510  *
511  * The MPOL_BIND zonelists don't need this zonelist_cache (in good
512  * part because they are shorter), so we put the fixed length stuff
513  * at the front of the zonelist struct, ending in a variable length
514  * zones[], as is needed by MPOL_BIND.
515  *
516  * Then we put the optional zonelist cache on the end of the zonelist
517  * struct.  This optional stuff is found by a 'zlcache_ptr' pointer in
518  * the fixed length portion at the front of the struct.  This pointer
519  * both enables us to find the zonelist cache, and in the case of
520  * MPOL_BIND zonelists, (which will just set the zlcache_ptr to NULL)
521  * to know that the zonelist cache is not there.
522  *
523  * The end result is that struct zonelists come in two flavors:
524  *  1) The full, fixed length version, shown below, and
525  *  2) The custom zonelists for MPOL_BIND.
526  * The custom MPOL_BIND zonelists have a NULL zlcache_ptr and no zlcache.
527  *
528  * Even though there may be multiple CPU cores on a node modifying
529  * fullzones or last_full_zap in the same zonelist_cache at the same
530  * time, we don't lock it.  This is just hint data - if it is wrong now
531  * and then, the allocator will still function, perhaps a bit slower.
532  */
533
534
535 struct zonelist_cache {
536         unsigned short z_to_n[MAX_ZONES_PER_ZONELIST];          /* zone->nid */
537         DECLARE_BITMAP(fullzones, MAX_ZONES_PER_ZONELIST);      /* zone full? */
538         unsigned long last_full_zap;            /* when last zap'd (jiffies) */
539 };
540 #else
541 #define MAX_ZONELISTS 1
542 struct zonelist_cache;
543 #endif
544
545 /*
546  * This struct contains information about a zone in a zonelist. It is stored
547  * here to avoid dereferences into large structures and lookups of tables
548  */
549 struct zoneref {
550         struct zone *zone;      /* Pointer to actual zone */
551         int zone_idx;           /* zone_idx(zoneref->zone) */
552 };
553
554 /*
555  * One allocation request operates on a zonelist. A zonelist
556  * is a list of zones, the first one is the 'goal' of the
557  * allocation, the other zones are fallback zones, in decreasing
558  * priority.
559  *
560  * If zlcache_ptr is not NULL, then it is just the address of zlcache,
561  * as explained above.  If zlcache_ptr is NULL, there is no zlcache.
562  * *
563  * To speed the reading of the zonelist, the zonerefs contain the zone index
564  * of the entry being read. Helper functions to access information given
565  * a struct zoneref are
566  *
567  * zonelist_zone()      - Return the struct zone * for an entry in _zonerefs
568  * zonelist_zone_idx()  - Return the index of the zone for an entry
569  * zonelist_node_idx()  - Return the index of the node for an entry
570  */
571 struct zonelist {
572         struct zonelist_cache *zlcache_ptr;                  // NULL or &zlcache
573         struct zoneref _zonerefs[MAX_ZONES_PER_ZONELIST + 1];
574 #ifdef CONFIG_NUMA
575         struct zonelist_cache zlcache;                       // optional ...
576 #endif
577 };
578
579 #ifdef CONFIG_ARCH_POPULATES_NODE_MAP
580 struct node_active_region {
581         unsigned long start_pfn;
582         unsigned long end_pfn;
583         int nid;
584 };
585 #endif /* CONFIG_ARCH_POPULATES_NODE_MAP */
586
587 #ifndef CONFIG_DISCONTIGMEM
588 /* The array of struct pages - for discontigmem use pgdat->lmem_map */
589 extern struct page *mem_map;
590 #endif
591
592 /*
593  * The pg_data_t structure is used in machines with CONFIG_DISCONTIGMEM
594  * (mostly NUMA machines?) to denote a higher-level memory zone than the
595  * zone denotes.
596  *
597  * On NUMA machines, each NUMA node would have a pg_data_t to describe
598  * it's memory layout.
599  *
600  * Memory statistics and page replacement data structures are maintained on a
601  * per-zone basis.
602  */
603 struct bootmem_data;
604 typedef struct pglist_data {
605         struct zone node_zones[MAX_NR_ZONES];
606         struct zonelist node_zonelists[MAX_ZONELISTS];
607         int nr_zones;
608 #ifdef CONFIG_FLAT_NODE_MEM_MAP /* means !SPARSEMEM */
609         struct page *node_mem_map;
610 #ifdef CONFIG_CGROUP_MEM_RES_CTLR
611         struct page_cgroup *node_page_cgroup;
612 #endif
613 #endif
614         struct bootmem_data *bdata;
615 #ifdef CONFIG_MEMORY_HOTPLUG
616         /*
617          * Must be held any time you expect node_start_pfn, node_present_pages
618          * or node_spanned_pages stay constant.  Holding this will also
619          * guarantee that any pfn_valid() stays that way.
620          *
621          * Nests above zone->lock and zone->size_seqlock.
622          */
623         spinlock_t node_size_lock;
624 #endif
625         unsigned long node_start_pfn;
626         unsigned long node_present_pages; /* total number of physical pages */
627         unsigned long node_spanned_pages; /* total size of physical page
628                                              range, including holes */
629         int node_id;
630         wait_queue_head_t kswapd_wait;
631         struct task_struct *kswapd;
632         int kswapd_max_order;
633 } pg_data_t;
634
635 #define node_present_pages(nid) (NODE_DATA(nid)->node_present_pages)
636 #define node_spanned_pages(nid) (NODE_DATA(nid)->node_spanned_pages)
637 #ifdef CONFIG_FLAT_NODE_MEM_MAP
638 #define pgdat_page_nr(pgdat, pagenr)    ((pgdat)->node_mem_map + (pagenr))
639 #else
640 #define pgdat_page_nr(pgdat, pagenr)    pfn_to_page((pgdat)->node_start_pfn + (pagenr))
641 #endif
642 #define nid_page_nr(nid, pagenr)        pgdat_page_nr(NODE_DATA(nid),(pagenr))
643
644 #include <linux/memory_hotplug.h>
645
646 void get_zone_counts(unsigned long *active, unsigned long *inactive,
647                         unsigned long *free);
648 void build_all_zonelists(void);
649 void wakeup_kswapd(struct zone *zone, int order);
650 int zone_watermark_ok(struct zone *z, int order, unsigned long mark,
651                 int classzone_idx, int alloc_flags);
652 enum memmap_context {
653         MEMMAP_EARLY,
654         MEMMAP_HOTPLUG,
655 };
656 extern int init_currently_empty_zone(struct zone *zone, unsigned long start_pfn,
657                                      unsigned long size,
658                                      enum memmap_context context);
659
660 #ifdef CONFIG_HAVE_MEMORY_PRESENT
661 void memory_present(int nid, unsigned long start, unsigned long end);
662 #else
663 static inline void memory_present(int nid, unsigned long start, unsigned long end) {}
664 #endif
665
666 #ifdef CONFIG_NEED_NODE_MEMMAP_SIZE
667 unsigned long __init node_memmap_size_bytes(int, unsigned long, unsigned long);
668 #endif
669
670 /*
671  * zone_idx() returns 0 for the ZONE_DMA zone, 1 for the ZONE_NORMAL zone, etc.
672  */
673 #define zone_idx(zone)          ((zone) - (zone)->zone_pgdat->node_zones)
674
675 static inline int populated_zone(struct zone *zone)
676 {
677         return (!!zone->present_pages);
678 }
679
680 extern int movable_zone;
681
682 static inline int zone_movable_is_highmem(void)
683 {
684 #if defined(CONFIG_HIGHMEM) && defined(CONFIG_ARCH_POPULATES_NODE_MAP)
685         return movable_zone == ZONE_HIGHMEM;
686 #else
687         return 0;
688 #endif
689 }
690
691 static inline int is_highmem_idx(enum zone_type idx)
692 {
693 #ifdef CONFIG_HIGHMEM
694         return (idx == ZONE_HIGHMEM ||
695                 (idx == ZONE_MOVABLE && zone_movable_is_highmem()));
696 #else
697         return 0;
698 #endif
699 }
700
701 static inline int is_normal_idx(enum zone_type idx)
702 {
703         return (idx == ZONE_NORMAL);
704 }
705
706 /**
707  * is_highmem - helper function to quickly check if a struct zone is a 
708  *              highmem zone or not.  This is an attempt to keep references
709  *              to ZONE_{DMA/NORMAL/HIGHMEM/etc} in general code to a minimum.
710  * @zone - pointer to struct zone variable
711  */
712 static inline int is_highmem(struct zone *zone)
713 {
714 #ifdef CONFIG_HIGHMEM
715         int zone_off = (char *)zone - (char *)zone->zone_pgdat->node_zones;
716         return zone_off == ZONE_HIGHMEM * sizeof(*zone) ||
717                (zone_off == ZONE_MOVABLE * sizeof(*zone) &&
718                 zone_movable_is_highmem());
719 #else
720         return 0;
721 #endif
722 }
723
724 static inline int is_normal(struct zone *zone)
725 {
726         return zone == zone->zone_pgdat->node_zones + ZONE_NORMAL;
727 }
728
729 static inline int is_dma32(struct zone *zone)
730 {
731 #ifdef CONFIG_ZONE_DMA32
732         return zone == zone->zone_pgdat->node_zones + ZONE_DMA32;
733 #else
734         return 0;
735 #endif
736 }
737
738 static inline int is_dma(struct zone *zone)
739 {
740 #ifdef CONFIG_ZONE_DMA
741         return zone == zone->zone_pgdat->node_zones + ZONE_DMA;
742 #else
743         return 0;
744 #endif
745 }
746
747 /* These two functions are used to setup the per zone pages min values */
748 struct ctl_table;
749 struct file;
750 int min_free_kbytes_sysctl_handler(struct ctl_table *, int, struct file *, 
751                                         void __user *, size_t *, loff_t *);
752 extern int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES-1];
753 int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int, struct file *,
754                                         void __user *, size_t *, loff_t *);
755 int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *, int, struct file *,
756                                         void __user *, size_t *, loff_t *);
757 int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *, int,
758                         struct file *, void __user *, size_t *, loff_t *);
759 int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *, int,
760                         struct file *, void __user *, size_t *, loff_t *);
761
762 extern int numa_zonelist_order_handler(struct ctl_table *, int,
763                         struct file *, void __user *, size_t *, loff_t *);
764 extern char numa_zonelist_order[];
765 #define NUMA_ZONELIST_ORDER_LEN 16      /* string buffer size */
766
767 #ifndef CONFIG_NEED_MULTIPLE_NODES
768
769 extern struct pglist_data contig_page_data;
770 #define NODE_DATA(nid)          (&contig_page_data)
771 #define NODE_MEM_MAP(nid)       mem_map
772
773 #else /* CONFIG_NEED_MULTIPLE_NODES */
774
775 #include <asm/mmzone.h>
776
777 #endif /* !CONFIG_NEED_MULTIPLE_NODES */
778
779 extern struct pglist_data *first_online_pgdat(void);
780 extern struct pglist_data *next_online_pgdat(struct pglist_data *pgdat);
781 extern struct zone *next_zone(struct zone *zone);
782
783 /**
784  * for_each_online_pgdat - helper macro to iterate over all online nodes
785  * @pgdat - pointer to a pg_data_t variable
786  */
787 #define for_each_online_pgdat(pgdat)                    \
788         for (pgdat = first_online_pgdat();              \
789              pgdat;                                     \
790              pgdat = next_online_pgdat(pgdat))
791 /**
792  * for_each_zone - helper macro to iterate over all memory zones
793  * @zone - pointer to struct zone variable
794  *
795  * The user only needs to declare the zone variable, for_each_zone
796  * fills it in.
797  */
798 #define for_each_zone(zone)                             \
799         for (zone = (first_online_pgdat())->node_zones; \
800              zone;                                      \
801              zone = next_zone(zone))
802
803 #define for_each_populated_zone(zone)                   \
804         for (zone = (first_online_pgdat())->node_zones; \
805              zone;                                      \
806              zone = next_zone(zone))                    \
807                 if (!populated_zone(zone))              \
808                         ; /* do nothing */              \
809                 else
810
811 static inline struct zone *zonelist_zone(struct zoneref *zoneref)
812 {
813         return zoneref->zone;
814 }
815
816 static inline int zonelist_zone_idx(struct zoneref *zoneref)
817 {
818         return zoneref->zone_idx;
819 }
820
821 static inline int zonelist_node_idx(struct zoneref *zoneref)
822 {
823 #ifdef CONFIG_NUMA
824         /* zone_to_nid not available in this context */
825         return zoneref->zone->node;
826 #else
827         return 0;
828 #endif /* CONFIG_NUMA */
829 }
830
831 /**
832  * next_zones_zonelist - Returns the next zone at or below highest_zoneidx within the allowed nodemask using a cursor within a zonelist as a starting point
833  * @z - The cursor used as a starting point for the search
834  * @highest_zoneidx - The zone index of the highest zone to return
835  * @nodes - An optional nodemask to filter the zonelist with
836  * @zone - The first suitable zone found is returned via this parameter
837  *
838  * This function returns the next zone at or below a given zone index that is
839  * within the allowed nodemask using a cursor as the starting point for the
840  * search. The zoneref returned is a cursor that represents the current zone
841  * being examined. It should be advanced by one before calling
842  * next_zones_zonelist again.
843  */
844 struct zoneref *next_zones_zonelist(struct zoneref *z,
845                                         enum zone_type highest_zoneidx,
846                                         nodemask_t *nodes,
847                                         struct zone **zone);
848
849 /**
850  * first_zones_zonelist - Returns the first zone at or below highest_zoneidx within the allowed nodemask in a zonelist
851  * @zonelist - The zonelist to search for a suitable zone
852  * @highest_zoneidx - The zone index of the highest zone to return
853  * @nodes - An optional nodemask to filter the zonelist with
854  * @zone - The first suitable zone found is returned via this parameter
855  *
856  * This function returns the first zone at or below a given zone index that is
857  * within the allowed nodemask. The zoneref returned is a cursor that can be
858  * used to iterate the zonelist with next_zones_zonelist by advancing it by
859  * one before calling.
860  */
861 static inline struct zoneref *first_zones_zonelist(struct zonelist *zonelist,
862                                         enum zone_type highest_zoneidx,
863                                         nodemask_t *nodes,
864                                         struct zone **zone)
865 {
866         return next_zones_zonelist(zonelist->_zonerefs, highest_zoneidx, nodes,
867                                                                 zone);
868 }
869
870 /**
871  * for_each_zone_zonelist_nodemask - helper macro to iterate over valid zones in a zonelist at or below a given zone index and within a nodemask
872  * @zone - The current zone in the iterator
873  * @z - The current pointer within zonelist->zones being iterated
874  * @zlist - The zonelist being iterated
875  * @highidx - The zone index of the highest zone to return
876  * @nodemask - Nodemask allowed by the allocator
877  *
878  * This iterator iterates though all zones at or below a given zone index and
879  * within a given nodemask
880  */
881 #define for_each_zone_zonelist_nodemask(zone, z, zlist, highidx, nodemask) \
882         for (z = first_zones_zonelist(zlist, highidx, nodemask, &zone); \
883                 zone;                                                   \
884                 z = next_zones_zonelist(++z, highidx, nodemask, &zone)) \
885
886 /**
887  * for_each_zone_zonelist - helper macro to iterate over valid zones in a zonelist at or below a given zone index
888  * @zone - The current zone in the iterator
889  * @z - The current pointer within zonelist->zones being iterated
890  * @zlist - The zonelist being iterated
891  * @highidx - The zone index of the highest zone to return
892  *
893  * This iterator iterates though all zones at or below a given zone index.
894  */
895 #define for_each_zone_zonelist(zone, z, zlist, highidx) \
896         for_each_zone_zonelist_nodemask(zone, z, zlist, highidx, NULL)
897
898 #ifdef CONFIG_SPARSEMEM
899 #include <asm/sparsemem.h>
900 #endif
901
902 #if !defined(CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID) && \
903         !defined(CONFIG_ARCH_POPULATES_NODE_MAP)
904 static inline unsigned long early_pfn_to_nid(unsigned long pfn)
905 {
906         return 0;
907 }
908 #endif
909
910 #ifdef CONFIG_FLATMEM
911 #define pfn_to_nid(pfn)         (0)
912 #endif
913
914 #define pfn_to_section_nr(pfn) ((pfn) >> PFN_SECTION_SHIFT)
915 #define section_nr_to_pfn(sec) ((sec) << PFN_SECTION_SHIFT)
916
917 #ifdef CONFIG_SPARSEMEM
918
919 /*
920  * SECTION_SHIFT                #bits space required to store a section #
921  *
922  * PA_SECTION_SHIFT             physical address to/from section number
923  * PFN_SECTION_SHIFT            pfn to/from section number
924  */
925 #define SECTIONS_SHIFT          (MAX_PHYSMEM_BITS - SECTION_SIZE_BITS)
926
927 #define PA_SECTION_SHIFT        (SECTION_SIZE_BITS)
928 #define PFN_SECTION_SHIFT       (SECTION_SIZE_BITS - PAGE_SHIFT)
929
930 #define NR_MEM_SECTIONS         (1UL << SECTIONS_SHIFT)
931
932 #define PAGES_PER_SECTION       (1UL << PFN_SECTION_SHIFT)
933 #define PAGE_SECTION_MASK       (~(PAGES_PER_SECTION-1))
934
935 #define SECTION_BLOCKFLAGS_BITS \
936         ((1UL << (PFN_SECTION_SHIFT - pageblock_order)) * NR_PAGEBLOCK_BITS)
937
938 #if (MAX_ORDER - 1 + PAGE_SHIFT) > SECTION_SIZE_BITS
939 #error Allocator MAX_ORDER exceeds SECTION_SIZE
940 #endif
941
942 struct page;
943 struct page_cgroup;
944 struct mem_section {
945         /*
946          * This is, logically, a pointer to an array of struct
947          * pages.  However, it is stored with some other magic.
948          * (see sparse.c::sparse_init_one_section())
949          *
950          * Additionally during early boot we encode node id of
951          * the location of the section here to guide allocation.
952          * (see sparse.c::memory_present())
953          *
954          * Making it a UL at least makes someone do a cast
955          * before using it wrong.
956          */
957         unsigned long section_mem_map;
958
959         /* See declaration of similar field in struct zone */
960         unsigned long *pageblock_flags;
961 #ifdef CONFIG_CGROUP_MEM_RES_CTLR
962         /*
963          * If !SPARSEMEM, pgdat doesn't have page_cgroup pointer. We use
964          * section. (see memcontrol.h/page_cgroup.h about this.)
965          */
966         struct page_cgroup *page_cgroup;
967         unsigned long pad;
968 #endif
969 };
970
971 #ifdef CONFIG_SPARSEMEM_EXTREME
972 #define SECTIONS_PER_ROOT       (PAGE_SIZE / sizeof (struct mem_section))
973 #else
974 #define SECTIONS_PER_ROOT       1
975 #endif
976
977 #define SECTION_NR_TO_ROOT(sec) ((sec) / SECTIONS_PER_ROOT)
978 #define NR_SECTION_ROOTS        (NR_MEM_SECTIONS / SECTIONS_PER_ROOT)
979 #define SECTION_ROOT_MASK       (SECTIONS_PER_ROOT - 1)
980
981 #ifdef CONFIG_SPARSEMEM_EXTREME
982 extern struct mem_section *mem_section[NR_SECTION_ROOTS];
983 #else
984 extern struct mem_section mem_section[NR_SECTION_ROOTS][SECTIONS_PER_ROOT];
985 #endif
986
987 static inline struct mem_section *__nr_to_section(unsigned long nr)
988 {
989         if (!mem_section[SECTION_NR_TO_ROOT(nr)])
990                 return NULL;
991         return &mem_section[SECTION_NR_TO_ROOT(nr)][nr & SECTION_ROOT_MASK];
992 }
993 extern int __section_nr(struct mem_section* ms);
994 extern unsigned long usemap_size(void);
995
996 /*
997  * We use the lower bits of the mem_map pointer to store
998  * a little bit of information.  There should be at least
999  * 3 bits here due to 32-bit alignment.
1000  */
1001 #define SECTION_MARKED_PRESENT  (1UL<<0)
1002 #define SECTION_HAS_MEM_MAP     (1UL<<1)
1003 #define SECTION_MAP_LAST_BIT    (1UL<<2)
1004 #define SECTION_MAP_MASK        (~(SECTION_MAP_LAST_BIT-1))
1005 #define SECTION_NID_SHIFT       2
1006
1007 static inline struct page *__section_mem_map_addr(struct mem_section *section)
1008 {
1009         unsigned long map = section->section_mem_map;
1010         map &= SECTION_MAP_MASK;
1011         return (struct page *)map;
1012 }
1013
1014 static inline int present_section(struct mem_section *section)
1015 {
1016         return (section && (section->section_mem_map & SECTION_MARKED_PRESENT));
1017 }
1018
1019 static inline int present_section_nr(unsigned long nr)
1020 {
1021         return present_section(__nr_to_section(nr));
1022 }
1023
1024 static inline int valid_section(struct mem_section *section)
1025 {
1026         return (section && (section->section_mem_map & SECTION_HAS_MEM_MAP));
1027 }
1028
1029 static inline int valid_section_nr(unsigned long nr)
1030 {
1031         return valid_section(__nr_to_section(nr));
1032 }
1033
1034 static inline struct mem_section *__pfn_to_section(unsigned long pfn)
1035 {
1036         return __nr_to_section(pfn_to_section_nr(pfn));
1037 }
1038
1039 static inline int pfn_valid(unsigned long pfn)
1040 {
1041         if (pfn_to_section_nr(pfn) >= NR_MEM_SECTIONS)
1042                 return 0;
1043         return valid_section(__nr_to_section(pfn_to_section_nr(pfn)));
1044 }
1045
1046 static inline int pfn_present(unsigned long pfn)
1047 {
1048         if (pfn_to_section_nr(pfn) >= NR_MEM_SECTIONS)
1049                 return 0;
1050         return present_section(__nr_to_section(pfn_to_section_nr(pfn)));
1051 }
1052
1053 /*
1054  * These are _only_ used during initialisation, therefore they
1055  * can use __initdata ...  They could have names to indicate
1056  * this restriction.
1057  */
1058 #ifdef CONFIG_NUMA
1059 #define pfn_to_nid(pfn)                                                 \
1060 ({                                                                      \
1061         unsigned long __pfn_to_nid_pfn = (pfn);                         \
1062         page_to_nid(pfn_to_page(__pfn_to_nid_pfn));                     \
1063 })
1064 #else
1065 #define pfn_to_nid(pfn)         (0)
1066 #endif
1067
1068 #define early_pfn_valid(pfn)    pfn_valid(pfn)
1069 void sparse_init(void);
1070 #else
1071 #define sparse_init()   do {} while (0)
1072 #define sparse_index_init(_sec, _nid)  do {} while (0)
1073 #endif /* CONFIG_SPARSEMEM */
1074
1075 #ifdef CONFIG_NODES_SPAN_OTHER_NODES
1076 bool early_pfn_in_nid(unsigned long pfn, int nid);
1077 #else
1078 #define early_pfn_in_nid(pfn, nid)      (1)
1079 #endif
1080
1081 #ifndef early_pfn_valid
1082 #define early_pfn_valid(pfn)    (1)
1083 #endif
1084
1085 void memory_present(int nid, unsigned long start, unsigned long end);
1086 unsigned long __init node_memmap_size_bytes(int, unsigned long, unsigned long);
1087
1088 /*
1089  * If it is possible to have holes within a MAX_ORDER_NR_PAGES, then we
1090  * need to check pfn validility within that MAX_ORDER_NR_PAGES block.
1091  * pfn_valid_within() should be used in this case; we optimise this away
1092  * when we have no holes within a MAX_ORDER_NR_PAGES block.
1093  */
1094 #ifdef CONFIG_HOLES_IN_ZONE
1095 #define pfn_valid_within(pfn) pfn_valid(pfn)
1096 #else
1097 #define pfn_valid_within(pfn) (1)
1098 #endif
1099
1100 #endif /* !__GENERATING_BOUNDS.H */
1101 #endif /* !__ASSEMBLY__ */
1102 #endif /* _LINUX_MMZONE_H */