mmzone.h 32.4 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
#ifndef _LINUX_MMZONE_H
#define _LINUX_MMZONE_H

#ifndef __ASSEMBLY__
5
#ifndef __GENERATING_BOUNDS_H
Linus Torvalds's avatar
Linus Torvalds committed
6
7
8
9

#include <linux/spinlock.h>
#include <linux/list.h>
#include <linux/wait.h>
10
#include <linux/bitops.h>
Linus Torvalds's avatar
Linus Torvalds committed
11
12
13
14
#include <linux/cache.h>
#include <linux/threads.h>
#include <linux/numa.h>
#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>
Linus Torvalds's avatar
Linus Torvalds committed
19
#include <asm/atomic.h>
Ralf Baechle's avatar
Ralf Baechle committed
20
#include <asm/page.h>
Linus Torvalds's avatar
Linus Torvalds committed
21
22
23
24
25
26
27

/* Free memory management - zoned buddy allocator.  */
#ifndef CONFIG_FORCE_MAX_ZONEORDER
#define MAX_ORDER 11
#else
#define MAX_ORDER CONFIG_FORCE_MAX_ZONEORDER
#endif
28
#define MAX_ORDER_NR_PAGES (1 << (MAX_ORDER - 1))
Linus Torvalds's avatar
Linus Torvalds committed
29

Andy Whitcroft's avatar
Andy Whitcroft committed
30
31
32
33
34
35
36
37
/*
 * PAGE_ALLOC_COSTLY_ORDER is the order at which allocations are deemed
 * costly to service.  That is between allocation orders which should
 * coelesce naturally under reasonable reclaim pressure and those which
 * will not.
 */
#define PAGE_ALLOC_COSTLY_ORDER 3

38
#define MIGRATE_UNMOVABLE     0
39
40
#define MIGRATE_RECLAIMABLE   1
#define MIGRATE_MOVABLE       2
41
#define MIGRATE_RESERVE       3
42
43
#define MIGRATE_ISOLATE       4 /* can't allocate from here */
#define MIGRATE_TYPES         5
44
45
46
47
48

#define for_each_migratetype_order(order, type) \
	for (order = 0; order < MAX_ORDER; order++) \
		for (type = 0; type < MIGRATE_TYPES; type++)

49
50
51
52
53
54
55
56
57
58
extern int page_group_by_mobility_disabled;

static inline int get_pageblock_migratetype(struct page *page)
{
	if (unlikely(page_group_by_mobility_disabled))
		return MIGRATE_UNMOVABLE;

	return get_pageblock_flags_group(page, PB_migrate, PB_migrate_end);
}

Linus Torvalds's avatar
Linus Torvalds committed
59
struct free_area {
60
	struct list_head	free_list[MIGRATE_TYPES];
Linus Torvalds's avatar
Linus Torvalds committed
61
62
63
64
65
66
67
68
69
70
71
72
73
74
	unsigned long		nr_free;
};

struct pglist_data;

/*
 * zone->lock and zone->lru_lock are two of the hottest locks in the kernel.
 * So add a wild amount of padding here to ensure that they fall into separate
 * cachelines.  There are very few zone structures in the machine, so space
 * consumption is not a concern here.
 */
#if defined(CONFIG_SMP)
struct zone_padding {
	char x[0];
75
} ____cacheline_internodealigned_in_smp;
Linus Torvalds's avatar
Linus Torvalds committed
76
77
78
79
80
#define ZONE_PADDING(name)	struct zone_padding name;
#else
#define ZONE_PADDING(name)
#endif

81
enum zone_stat_item {
82
	/* First 128 byte cacheline (assuming 64 bit words) */
83
	NR_FREE_PAGES,
84
	NR_LRU_BASE,
85
86
87
88
	NR_INACTIVE_ANON = NR_LRU_BASE, /* must match order of LRU_[IN]ACTIVE */
	NR_ACTIVE_ANON,		/*  "     "     "   "       "         */
	NR_INACTIVE_FILE,	/*  "     "     "   "       "         */
	NR_ACTIVE_FILE,		/*  "     "     "   "       "         */
89
90
	NR_ANON_PAGES,	/* Mapped anonymous pages */
	NR_FILE_MAPPED,	/* pagecache pages mapped into pagetables.
91
			   only modified from process context */
92
	NR_FILE_PAGES,
93
	NR_FILE_DIRTY,
94
	NR_WRITEBACK,
95
96
97
	NR_SLAB_RECLAIMABLE,
	NR_SLAB_UNRECLAIMABLE,
	NR_PAGETABLE,		/* used for pagetables */
98
	NR_UNSTABLE_NFS,	/* NFS unstable pages */
99
	NR_BOUNCE,
100
	NR_VMSCAN_WRITE,
101
	/* Second 128 byte cacheline */
102
	NR_WRITEBACK_TEMP,	/* Writeback using temporary buffers */
103
104
105
106
107
108
109
110
#ifdef CONFIG_NUMA
	NUMA_HIT,		/* allocated in intended node */
	NUMA_MISS,		/* allocated in non intended node */
	NUMA_FOREIGN,		/* was intended here, hit elsewhere */
	NUMA_INTERLEAVE_HIT,	/* interleaver preferred this zone */
	NUMA_LOCAL,		/* allocation from local node */
	NUMA_OTHER,		/* allocation from other node */
#endif
111
112
	NR_VM_ZONE_STAT_ITEMS };

113
114
115
116
117
118
119
120
121
122
123
124
125
/*
 * We do arithmetic on the LRU lists in various places in the code,
 * so it is important to keep the active lists LRU_ACTIVE higher in
 * the array than the corresponding inactive lists, and to keep
 * the *_FILE lists LRU_FILE higher than the corresponding _ANON lists.
 *
 * This has to be kept in sync with the statistics in zone_stat_item
 * above and the descriptions in vmstat_text in mm/vmstat.c
 */
#define LRU_BASE 0
#define LRU_ACTIVE 1
#define LRU_FILE 2

126
enum lru_list {
127
128
129
130
	LRU_INACTIVE_ANON = LRU_BASE,
	LRU_ACTIVE_ANON = LRU_BASE + LRU_ACTIVE,
	LRU_INACTIVE_FILE = LRU_BASE + LRU_FILE,
	LRU_ACTIVE_FILE = LRU_BASE + LRU_FILE + LRU_ACTIVE,
131
132
133
134
	NR_LRU_LISTS };

#define for_each_lru(l) for (l = 0; l < NR_LRU_LISTS; l++)

135
136
137
138
139
static inline int is_file_lru(enum lru_list l)
{
	return (l == LRU_INACTIVE_FILE || l == LRU_ACTIVE_FILE);
}

140
141
static inline int is_active_lru(enum lru_list l)
{
142
	return (l == LRU_ACTIVE_ANON || l == LRU_ACTIVE_FILE);
143
144
}

Linus Torvalds's avatar
Linus Torvalds committed
145
146
147
148
149
150
151
152
struct per_cpu_pages {
	int count;		/* number of pages in the list */
	int high;		/* high watermark, emptying needed */
	int batch;		/* chunk size for buddy add/remove */
	struct list_head list;	/* the list of pages */
};

struct per_cpu_pageset {
153
	struct per_cpu_pages pcp;
154
155
156
#ifdef CONFIG_NUMA
	s8 expire;
#endif
157
#ifdef CONFIG_SMP
158
	s8 stat_threshold;
159
160
	s8 vm_stat_diff[NR_VM_ZONE_STAT_ITEMS];
#endif
Linus Torvalds's avatar
Linus Torvalds committed
161
162
} ____cacheline_aligned_in_smp;

163
164
165
166
167
168
#ifdef CONFIG_NUMA
#define zone_pcp(__z, __cpu) ((__z)->pageset[(__cpu)])
#else
#define zone_pcp(__z, __cpu) (&(__z)->pageset[(__cpu)])
#endif

169
170
#endif /* !__GENERATING_BOUNDS.H */

171
enum zone_type {
172
#ifdef CONFIG_ZONE_DMA
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
	/*
	 * ZONE_DMA is used when there are devices that are not able
	 * to do DMA to all of addressable memory (ZONE_NORMAL). Then we
	 * carve out the portion of memory that is needed for these devices.
	 * The range is arch specific.
	 *
	 * Some examples
	 *
	 * Architecture		Limit
	 * ---------------------------
	 * parisc, ia64, sparc	<4G
	 * s390			<2G
	 * arm			Various
	 * alpha		Unlimited or 0-16MB.
	 *
	 * i386, x86_64 and multiple other arches
	 * 			<16M.
	 */
	ZONE_DMA,
192
#endif
193
#ifdef CONFIG_ZONE_DMA32
194
195
196
197
198
199
	/*
	 * x86_64 needs two ZONE_DMAs because it supports devices that are
	 * only able to do DMA to the lower 16M but also 32 bit devices that
	 * can only do DMA areas below 4G.
	 */
	ZONE_DMA32,
200
#endif
201
202
203
204
205
206
	/*
	 * Normal addressable memory is in ZONE_NORMAL. DMA operations can be
	 * performed on pages in ZONE_NORMAL if the DMA devices support
	 * transfers to all addressable memory.
	 */
	ZONE_NORMAL,
207
#ifdef CONFIG_HIGHMEM
208
209
210
211
212
213
214
215
216
	/*
	 * A memory area that is only addressable by the kernel through
	 * mapping portions into its own address space. This is for example
	 * used by i386 to allow the kernel to address the memory beyond
	 * 900MB. The kernel will set up special mappings (page
	 * table entries on i386) for each page that the kernel needs to
	 * access.
	 */
	ZONE_HIGHMEM,
217
#endif
Mel Gorman's avatar
Mel Gorman committed
218
	ZONE_MOVABLE,
219
	__MAX_NR_ZONES
220
};
Linus Torvalds's avatar
Linus Torvalds committed
221

222
223
#ifndef __GENERATING_BOUNDS_H

Linus Torvalds's avatar
Linus Torvalds committed
224
225
226
227
228
/*
 * When a memory allocation must conform to specific limitations (such
 * as being suitable for DMA) the caller will pass in hints to the
 * allocator in the gfp_mask, in the zone modifier bits.  These bits
 * are used to select a priority ordered list of memory zones which
229
 * match the requested limits. See gfp_zone() in include/linux/gfp.h
Linus Torvalds's avatar
Linus Torvalds committed
230
 */
231

232
#if MAX_NR_ZONES < 2
233
#define ZONES_SHIFT 0
234
#elif MAX_NR_ZONES <= 2
235
#define ZONES_SHIFT 1
236
#elif MAX_NR_ZONES <= 4
237
#define ZONES_SHIFT 2
238
239
#else
#error ZONES_SHIFT -- too many zones configured adjust calculation
240
#endif
Linus Torvalds's avatar
Linus Torvalds committed
241
242
243
244
245
246
247
248
249
250
251
252
253
254

struct zone {
	/* Fields commonly accessed by the page allocator */
	unsigned long		pages_min, pages_low, pages_high;
	/*
	 * We don't know if the memory that we're going to allocate will be freeable
	 * or/and it will be released eventually, so to avoid totally wasting several
	 * GB of ram we must reserve some of the lower zone memory (otherwise we risk
	 * to run OOM on the lower zones despite there's tons of freeable ram
	 * on the higher zones). This array is recalculated at runtime if the
	 * sysctl_lowmem_reserve_ratio sysctl changes.
	 */
	unsigned long		lowmem_reserve[MAX_NR_ZONES];

255
#ifdef CONFIG_NUMA
256
	int node;
257
258
259
	/*
	 * zone reclaim becomes active if more unmapped pages exist.
	 */
260
	unsigned long		min_unmapped_pages;
261
	unsigned long		min_slab_pages;
262
263
	struct per_cpu_pageset	*pageset[NR_CPUS];
#else
Linus Torvalds's avatar
Linus Torvalds committed
264
	struct per_cpu_pageset	pageset[NR_CPUS];
265
#endif
Linus Torvalds's avatar
Linus Torvalds committed
266
267
268
269
	/*
	 * free areas of different sizes
	 */
	spinlock_t		lock;
270
271
272
273
#ifdef CONFIG_MEMORY_HOTPLUG
	/* see spanned/present_pages for more description */
	seqlock_t		span_seqlock;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
274
275
	struct free_area	free_area[MAX_ORDER];

276
277
#ifndef CONFIG_SPARSEMEM
	/*
278
	 * Flags for a pageblock_nr_pages block. See pageblock-flags.h.
279
280
281
282
283
	 * In SPARSEMEM, this map is stored in struct mem_section
	 */
	unsigned long		*pageblock_flags;
#endif /* CONFIG_SPARSEMEM */

Linus Torvalds's avatar
Linus Torvalds committed
284
285
286
287
288

	ZONE_PADDING(_pad1_)

	/* Fields commonly accessed by the page reclaim scanner */
	spinlock_t		lru_lock;	
289
290
291
292
	struct {
		struct list_head list;
		unsigned long nr_scan;
	} lru[NR_LRU_LISTS];
293
294
295
296
297
298
299
300
301
302
303
304

	/*
	 * The pageout code in vmscan.c keeps track of how many of the
	 * mem/swap backed and file backed pages are refeferenced.
	 * The higher the rotated/scanned ratio, the more valuable
	 * that cache is.
	 *
	 * The anon LRU stats live in [0], file LRU stats in [1]
	 */
	unsigned long		recent_rotated[2];
	unsigned long		recent_scanned[2];

Linus Torvalds's avatar
Linus Torvalds committed
305
	unsigned long		pages_scanned;	   /* since last reclaim */
306
	unsigned long		flags;		   /* zone flags, see below */
Martin Hicks's avatar
Martin Hicks committed
307

308
309
	/* Zone statistics */
	atomic_long_t		vm_stat[NR_VM_ZONE_STAT_ITEMS];
310

Linus Torvalds's avatar
Linus Torvalds committed
311
312
313
314
315
316
317
318
319
320
	/*
	 * prev_priority holds the scanning priority for this zone.  It is
	 * defined as the scanning priority at which we achieved our reclaim
	 * target at the previous try_to_free_pages() or balance_pgdat()
	 * invokation.
	 *
	 * We use prev_priority as a measure of how much stress page reclaim is
	 * under - it drives the swappiness decision: whether to unmap mapped
	 * pages.
	 *
321
	 * Access to both this field is quite racy even on uniprocessor.  But
Linus Torvalds's avatar
Linus Torvalds committed
322
323
324
325
326
327
328
329
330
331
	 * it is expected to average out OK.
	 */
	int prev_priority;


	ZONE_PADDING(_pad2_)
	/* Rarely used or read-mostly fields */

	/*
	 * wait_table		-- the array holding the hash table
332
	 * wait_table_hash_nr_entries	-- the size of the hash table array
Linus Torvalds's avatar
Linus Torvalds committed
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
	 * wait_table_bits	-- wait_table_size == (1 << wait_table_bits)
	 *
	 * The purpose of all these is to keep track of the people
	 * waiting for a page to become available and make them
	 * runnable again when possible. The trouble is that this
	 * consumes a lot of space, especially when so few things
	 * wait on pages at a given time. So instead of using
	 * per-page waitqueues, we use a waitqueue hash table.
	 *
	 * The bucket discipline is to sleep on the same queue when
	 * colliding and wake all in that wait queue when removing.
	 * When something wakes, it must check to be sure its page is
	 * truly available, a la thundering herd. The cost of a
	 * collision is great, but given the expected load of the
	 * table, they should be so rare as to be outweighed by the
	 * benefits from the saved space.
	 *
	 * __wait_on_page_locked() and unlock_page() in mm/filemap.c, are the
	 * primary users of these fields, and in mm/page_alloc.c
	 * free_area_init_core() performs the initialization of them.
	 */
	wait_queue_head_t	* wait_table;
355
	unsigned long		wait_table_hash_nr_entries;
Linus Torvalds's avatar
Linus Torvalds committed
356
357
358
359
360
361
362
363
364
	unsigned long		wait_table_bits;

	/*
	 * Discontig memory support fields.
	 */
	struct pglist_data	*zone_pgdat;
	/* zone_start_pfn == zone_start_paddr >> PAGE_SHIFT */
	unsigned long		zone_start_pfn;

365
366
367
368
369
370
371
372
373
374
	/*
	 * zone_start_pfn, spanned_pages and present_pages are all
	 * protected by span_seqlock.  It is a seqlock because it has
	 * to be read outside of zone->lock, and it is done in the main
	 * allocator path.  But, it is written quite infrequently.
	 *
	 * The lock is declared along with zone->lock because it is
	 * frequently read in proximity to zone->lock.  It's good to
	 * give them a chance of being in the same cacheline.
	 */
Linus Torvalds's avatar
Linus Torvalds committed
375
376
377
378
379
380
	unsigned long		spanned_pages;	/* total size, including holes */
	unsigned long		present_pages;	/* amount of memory (excluding holes) */

	/*
	 * rarely used fields:
	 */
381
	const char		*name;
382
} ____cacheline_internodealigned_in_smp;
Linus Torvalds's avatar
Linus Torvalds committed
383

384
385
386
typedef enum {
	ZONE_ALL_UNRECLAIMABLE,		/* all pages pinned */
	ZONE_RECLAIM_LOCKED,		/* prevents concurrent reclaim */
David Rientjes's avatar
David Rientjes committed
387
	ZONE_OOM_LOCKED,		/* zone is in OOM killer zonelist */
388
389
390
391
392
393
} zone_flags_t;

static inline void zone_set_flag(struct zone *zone, zone_flags_t flag)
{
	set_bit(flag, &zone->flags);
}
394
395
396
397
398
399

static inline int zone_test_and_set_flag(struct zone *zone, zone_flags_t flag)
{
	return test_and_set_bit(flag, &zone->flags);
}

400
401
402
403
404
405
406
407
408
static inline void zone_clear_flag(struct zone *zone, zone_flags_t flag)
{
	clear_bit(flag, &zone->flags);
}

static inline int zone_is_all_unreclaimable(const struct zone *zone)
{
	return test_bit(ZONE_ALL_UNRECLAIMABLE, &zone->flags);
}
409

410
411
412
413
static inline int zone_is_reclaim_locked(const struct zone *zone)
{
	return test_bit(ZONE_RECLAIM_LOCKED, &zone->flags);
}
414

David Rientjes's avatar
David Rientjes committed
415
416
417
418
static inline int zone_is_oom_locked(const struct zone *zone)
{
	return test_bit(ZONE_OOM_LOCKED, &zone->flags);
}
419

Linus Torvalds's avatar
Linus Torvalds committed
420
421
422
423
424
425
426
/*
 * The "priority" of VM scanning is how much of the queues we will scan in one
 * go. A value of 12 for DEF_PRIORITY implies that we will scan 1/4096th of the
 * queues ("queue_length >> 12") during an aging round.
 */
#define DEF_PRIORITY 12

427
428
429
430
/* Maximum number of zones on a zonelist */
#define MAX_ZONES_PER_ZONELIST (MAX_NUMNODES * MAX_NR_ZONES)

#ifdef CONFIG_NUMA
431
432
433
434
435

/*
 * The NUMA zonelists are doubled becausse we need zonelists that restrict the
 * allocations to a single node for GFP_THISNODE.
 *
436
437
 * [0]	: Zonelist with fallback
 * [1]	: No fallback (GFP_THISNODE)
438
 */
439
#define MAX_ZONELISTS 2
440
441


442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
/*
 * We cache key information from each zonelist for smaller cache
 * footprint when scanning for free pages in get_page_from_freelist().
 *
 * 1) The BITMAP fullzones tracks which zones in a zonelist have come
 *    up short of free memory since the last time (last_fullzone_zap)
 *    we zero'd fullzones.
 * 2) The array z_to_n[] maps each zone in the zonelist to its node
 *    id, so that we can efficiently evaluate whether that node is
 *    set in the current tasks mems_allowed.
 *
 * Both fullzones and z_to_n[] are one-to-one with the zonelist,
 * indexed by a zones offset in the zonelist zones[] array.
 *
 * The get_page_from_freelist() routine does two scans.  During the
 * first scan, we skip zones whose corresponding bit in 'fullzones'
 * is set or whose corresponding node in current->mems_allowed (which
 * comes from cpusets) is not set.  During the second scan, we bypass
 * this zonelist_cache, to ensure we look methodically at each zone.
 *
 * Once per second, we zero out (zap) fullzones, forcing us to
 * reconsider nodes that might have regained more free memory.
 * The field last_full_zap is the time we last zapped fullzones.
 *
 * This mechanism reduces the amount of time we waste repeatedly
 * reexaming zones for free memory when they just came up low on
 * memory momentarilly ago.
 *
 * The zonelist_cache struct members logically belong in struct
 * zonelist.  However, the mempolicy zonelists constructed for
 * MPOL_BIND are intentionally variable length (and usually much
 * shorter).  A general purpose mechanism for handling structs with
 * multiple variable length members is more mechanism than we want
 * here.  We resort to some special case hackery instead.
 *
 * The MPOL_BIND zonelists don't need this zonelist_cache (in good
 * part because they are shorter), so we put the fixed length stuff
 * at the front of the zonelist struct, ending in a variable length
 * zones[], as is needed by MPOL_BIND.
 *
 * Then we put the optional zonelist cache on the end of the zonelist
 * struct.  This optional stuff is found by a 'zlcache_ptr' pointer in
 * the fixed length portion at the front of the struct.  This pointer
 * both enables us to find the zonelist cache, and in the case of
 * MPOL_BIND zonelists, (which will just set the zlcache_ptr to NULL)
 * to know that the zonelist cache is not there.
 *
 * The end result is that struct zonelists come in two flavors:
 *  1) The full, fixed length version, shown below, and
 *  2) The custom zonelists for MPOL_BIND.
 * The custom MPOL_BIND zonelists have a NULL zlcache_ptr and no zlcache.
 *
 * Even though there may be multiple CPU cores on a node modifying
 * fullzones or last_full_zap in the same zonelist_cache at the same
 * time, we don't lock it.  This is just hint data - if it is wrong now
 * and then, the allocator will still function, perhaps a bit slower.
 */


struct zonelist_cache {
	unsigned short z_to_n[MAX_ZONES_PER_ZONELIST];		/* zone->nid */
503
	DECLARE_BITMAP(fullzones, MAX_ZONES_PER_ZONELIST);	/* zone full? */
504
505
506
	unsigned long last_full_zap;		/* when last zap'd (jiffies) */
};
#else
507
#define MAX_ZONELISTS 1
508
509
510
struct zonelist_cache;
#endif

511
512
513
514
515
516
517
518
519
/*
 * This struct contains information about a zone in a zonelist. It is stored
 * here to avoid dereferences into large structures and lookups of tables
 */
struct zoneref {
	struct zone *zone;	/* Pointer to actual zone */
	int zone_idx;		/* zone_idx(zoneref->zone) */
};

Linus Torvalds's avatar
Linus Torvalds committed
520
521
522
523
524
525
/*
 * One allocation request operates on a zonelist. A zonelist
 * is a list of zones, the first one is the 'goal' of the
 * allocation, the other zones are fallback zones, in decreasing
 * priority.
 *
526
527
 * If zlcache_ptr is not NULL, then it is just the address of zlcache,
 * as explained above.  If zlcache_ptr is NULL, there is no zlcache.
528
529
530
531
532
533
534
535
 * *
 * To speed the reading of the zonelist, the zonerefs contain the zone index
 * of the entry being read. Helper functions to access information given
 * a struct zoneref are
 *
 * zonelist_zone()	- Return the struct zone * for an entry in _zonerefs
 * zonelist_zone_idx()	- Return the index of the zone for an entry
 * zonelist_node_idx()	- Return the index of the node for an entry
Linus Torvalds's avatar
Linus Torvalds committed
536
537
 */
struct zonelist {
538
	struct zonelist_cache *zlcache_ptr;		     // NULL or &zlcache
539
	struct zoneref _zonerefs[MAX_ZONES_PER_ZONELIST + 1];
540
541
542
#ifdef CONFIG_NUMA
	struct zonelist_cache zlcache;			     // optional ...
#endif
Linus Torvalds's avatar
Linus Torvalds committed
543
544
};

545
546
547
548
549
550
551
#ifdef CONFIG_ARCH_POPULATES_NODE_MAP
struct node_active_region {
	unsigned long start_pfn;
	unsigned long end_pfn;
	int nid;
};
#endif /* CONFIG_ARCH_POPULATES_NODE_MAP */
Linus Torvalds's avatar
Linus Torvalds committed
552

553
554
555
556
557
#ifndef CONFIG_DISCONTIGMEM
/* The array of struct pages - for discontigmem use pgdat->lmem_map */
extern struct page *mem_map;
#endif

Linus Torvalds's avatar
Linus Torvalds committed
558
559
560
561
562
563
564
565
566
567
568
569
570
571
/*
 * The pg_data_t structure is used in machines with CONFIG_DISCONTIGMEM
 * (mostly NUMA machines?) to denote a higher-level memory zone than the
 * zone denotes.
 *
 * On NUMA machines, each NUMA node would have a pg_data_t to describe
 * it's memory layout.
 *
 * Memory statistics and page replacement data structures are maintained on a
 * per-zone basis.
 */
struct bootmem_data;
typedef struct pglist_data {
	struct zone node_zones[MAX_NR_ZONES];
572
	struct zonelist node_zonelists[MAX_ZONELISTS];
Linus Torvalds's avatar
Linus Torvalds committed
573
	int nr_zones;
574
#ifdef CONFIG_FLAT_NODE_MEM_MAP
Linus Torvalds's avatar
Linus Torvalds committed
575
	struct page *node_mem_map;
576
#endif
Linus Torvalds's avatar
Linus Torvalds committed
577
	struct bootmem_data *bdata;
578
579
580
581
582
583
584
585
586
587
#ifdef CONFIG_MEMORY_HOTPLUG
	/*
	 * Must be held any time you expect node_start_pfn, node_present_pages
	 * or node_spanned_pages stay constant.  Holding this will also
	 * guarantee that any pfn_valid() stays that way.
	 *
	 * Nests above zone->lock and zone->size_seqlock.
	 */
	spinlock_t node_size_lock;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
588
589
590
591
592
593
594
595
596
597
598
599
	unsigned long node_start_pfn;
	unsigned long node_present_pages; /* total number of physical pages */
	unsigned long node_spanned_pages; /* total size of physical page
					     range, including holes */
	int node_id;
	wait_queue_head_t kswapd_wait;
	struct task_struct *kswapd;
	int kswapd_max_order;
} pg_data_t;

#define node_present_pages(nid)	(NODE_DATA(nid)->node_present_pages)
#define node_spanned_pages(nid)	(NODE_DATA(nid)->node_spanned_pages)
600
#ifdef CONFIG_FLAT_NODE_MEM_MAP
601
#define pgdat_page_nr(pgdat, pagenr)	((pgdat)->node_mem_map + (pagenr))
602
603
604
#else
#define pgdat_page_nr(pgdat, pagenr)	pfn_to_page((pgdat)->node_start_pfn + (pagenr))
#endif
605
#define nid_page_nr(nid, pagenr) 	pgdat_page_nr(NODE_DATA(nid),(pagenr))
Linus Torvalds's avatar
Linus Torvalds committed
606

607
608
#include <linux/memory_hotplug.h>

Linus Torvalds's avatar
Linus Torvalds committed
609
610
611
612
613
void get_zone_counts(unsigned long *active, unsigned long *inactive,
			unsigned long *free);
void build_all_zonelists(void);
void wakeup_kswapd(struct zone *zone, int order);
int zone_watermark_ok(struct zone *z, int order, unsigned long mark,
Rohit Seth's avatar
Rohit Seth committed
614
		int classzone_idx, int alloc_flags);
Dave Hansen's avatar
Dave Hansen committed
615
616
617
618
enum memmap_context {
	MEMMAP_EARLY,
	MEMMAP_HOTPLUG,
};
619
extern int init_currently_empty_zone(struct zone *zone, unsigned long start_pfn,
Dave Hansen's avatar
Dave Hansen committed
620
621
				     unsigned long size,
				     enum memmap_context context);
622

Linus Torvalds's avatar
Linus Torvalds committed
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
#ifdef CONFIG_HAVE_MEMORY_PRESENT
void memory_present(int nid, unsigned long start, unsigned long end);
#else
static inline void memory_present(int nid, unsigned long start, unsigned long end) {}
#endif

#ifdef CONFIG_NEED_NODE_MEMMAP_SIZE
unsigned long __init node_memmap_size_bytes(int, unsigned long, unsigned long);
#endif

/*
 * zone_idx() returns 0 for the ZONE_DMA zone, 1 for the ZONE_NORMAL zone, etc.
 */
#define zone_idx(zone)		((zone) - (zone)->zone_pgdat->node_zones)

638
639
640
641
642
static inline int populated_zone(struct zone *zone)
{
	return (!!zone->present_pages);
}

Mel Gorman's avatar
Mel Gorman committed
643
644
645
646
647
648
649
650
651
652
653
extern int movable_zone;

static inline int zone_movable_is_highmem(void)
{
#if defined(CONFIG_HIGHMEM) && defined(CONFIG_ARCH_POPULATES_NODE_MAP)
	return movable_zone == ZONE_HIGHMEM;
#else
	return 0;
#endif
}

654
static inline int is_highmem_idx(enum zone_type idx)
Linus Torvalds's avatar
Linus Torvalds committed
655
{
656
#ifdef CONFIG_HIGHMEM
Mel Gorman's avatar
Mel Gorman committed
657
658
	return (idx == ZONE_HIGHMEM ||
		(idx == ZONE_MOVABLE && zone_movable_is_highmem()));
659
660
661
#else
	return 0;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
662
663
}

664
static inline int is_normal_idx(enum zone_type idx)
Linus Torvalds's avatar
Linus Torvalds committed
665
666
667
{
	return (idx == ZONE_NORMAL);
}
668

Linus Torvalds's avatar
Linus Torvalds committed
669
670
671
672
673
674
675
676
/**
 * is_highmem - helper function to quickly check if a struct zone is a 
 *              highmem zone or not.  This is an attempt to keep references
 *              to ZONE_{DMA/NORMAL/HIGHMEM/etc} in general code to a minimum.
 * @zone - pointer to struct zone variable
 */
static inline int is_highmem(struct zone *zone)
{
677
#ifdef CONFIG_HIGHMEM
678
679
680
681
	int zone_off = (char *)zone - (char *)zone->zone_pgdat->node_zones;
	return zone_off == ZONE_HIGHMEM * sizeof(*zone) ||
	       (zone_off == ZONE_MOVABLE * sizeof(*zone) &&
		zone_movable_is_highmem());
682
683
684
#else
	return 0;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
685
686
687
688
689
690
691
}

static inline int is_normal(struct zone *zone)
{
	return zone == zone->zone_pgdat->node_zones + ZONE_NORMAL;
}

692
693
static inline int is_dma32(struct zone *zone)
{
694
#ifdef CONFIG_ZONE_DMA32
695
	return zone == zone->zone_pgdat->node_zones + ZONE_DMA32;
696
697
698
#else
	return 0;
#endif
699
700
701
702
}

static inline int is_dma(struct zone *zone)
{
703
#ifdef CONFIG_ZONE_DMA
704
	return zone == zone->zone_pgdat->node_zones + ZONE_DMA;
705
706
707
#else
	return 0;
#endif
708
709
}

Linus Torvalds's avatar
Linus Torvalds committed
710
711
712
713
714
715
716
717
/* These two functions are used to setup the per zone pages min values */
struct ctl_table;
struct file;
int min_free_kbytes_sysctl_handler(struct ctl_table *, int, struct file *, 
					void __user *, size_t *, loff_t *);
extern int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES-1];
int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int, struct file *,
					void __user *, size_t *, loff_t *);
718
719
int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *, int, struct file *,
					void __user *, size_t *, loff_t *);
720
721
int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *, int,
			struct file *, void __user *, size_t *, loff_t *);
722
723
int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *, int,
			struct file *, void __user *, size_t *, loff_t *);
Linus Torvalds's avatar
Linus Torvalds committed
724

725
726
727
728
729
extern int numa_zonelist_order_handler(struct ctl_table *, int,
			struct file *, void __user *, size_t *, loff_t *);
extern char numa_zonelist_order[];
#define NUMA_ZONELIST_ORDER_LEN 16	/* string buffer size */

Linus Torvalds's avatar
Linus Torvalds committed
730
731
#include <linux/topology.h>
/* Returns the number of the current Node. */
732
#ifndef numa_node_id
733
#define numa_node_id()		(cpu_to_node(raw_smp_processor_id()))
734
#endif
Linus Torvalds's avatar
Linus Torvalds committed
735

736
#ifndef CONFIG_NEED_MULTIPLE_NODES
Linus Torvalds's avatar
Linus Torvalds committed
737
738
739
740
741

extern struct pglist_data contig_page_data;
#define NODE_DATA(nid)		(&contig_page_data)
#define NODE_MEM_MAP(nid)	mem_map

742
#else /* CONFIG_NEED_MULTIPLE_NODES */
Linus Torvalds's avatar
Linus Torvalds committed
743
744
745

#include <asm/mmzone.h>

746
#endif /* !CONFIG_NEED_MULTIPLE_NODES */
747

748
749
750
extern struct pglist_data *first_online_pgdat(void);
extern struct pglist_data *next_online_pgdat(struct pglist_data *pgdat);
extern struct zone *next_zone(struct zone *zone);
751
752

/**
753
 * for_each_online_pgdat - helper macro to iterate over all online nodes
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
 * @pgdat - pointer to a pg_data_t variable
 */
#define for_each_online_pgdat(pgdat)			\
	for (pgdat = first_online_pgdat();		\
	     pgdat;					\
	     pgdat = next_online_pgdat(pgdat))
/**
 * for_each_zone - helper macro to iterate over all memory zones
 * @zone - pointer to struct zone variable
 *
 * The user only needs to declare the zone variable, for_each_zone
 * fills it in.
 */
#define for_each_zone(zone)			        \
	for (zone = (first_online_pgdat())->node_zones; \
	     zone;					\
	     zone = next_zone(zone))

772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
static inline struct zone *zonelist_zone(struct zoneref *zoneref)
{
	return zoneref->zone;
}

static inline int zonelist_zone_idx(struct zoneref *zoneref)
{
	return zoneref->zone_idx;
}

static inline int zonelist_node_idx(struct zoneref *zoneref)
{
#ifdef CONFIG_NUMA
	/* zone_to_nid not available in this context */
	return zoneref->zone->node;
#else
	return 0;
#endif /* CONFIG_NUMA */
}

792
793
794
795
796
797
798
799
800
/**
 * 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
 * @z - The cursor used as a starting point for the search
 * @highest_zoneidx - The zone index of the highest zone to return
 * @nodes - An optional nodemask to filter the zonelist with
 * @zone - The first suitable zone found is returned via this parameter
 *
 * This function returns the next zone at or below a given zone index that is
 * within the allowed nodemask using a cursor as the starting point for the
801
802
803
 * search. The zoneref returned is a cursor that represents the current zone
 * being examined. It should be advanced by one before calling
 * next_zones_zonelist again.
804
805
806
807
808
 */
struct zoneref *next_zones_zonelist(struct zoneref *z,
					enum zone_type highest_zoneidx,
					nodemask_t *nodes,
					struct zone **zone);
809

810
811
812
813
814
815
816
817
818
/**
 * first_zones_zonelist - Returns the first zone at or below highest_zoneidx within the allowed nodemask in a zonelist
 * @zonelist - The zonelist to search for a suitable zone
 * @highest_zoneidx - The zone index of the highest zone to return
 * @nodes - An optional nodemask to filter the zonelist with
 * @zone - The first suitable zone found is returned via this parameter
 *
 * This function returns the first zone at or below a given zone index that is
 * within the allowed nodemask. The zoneref returned is a cursor that can be
819
820
 * used to iterate the zonelist with next_zones_zonelist by advancing it by
 * one before calling.
821
 */
822
static inline struct zoneref *first_zones_zonelist(struct zonelist *zonelist,
823
824
825
					enum zone_type highest_zoneidx,
					nodemask_t *nodes,
					struct zone **zone)
826
{
827
828
	return next_zones_zonelist(zonelist->_zonerefs, highest_zoneidx, nodes,
								zone);
829
830
}

831
832
833
834
835
836
837
838
839
840
841
842
843
844
/**
 * 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
 * @zone - The current zone in the iterator
 * @z - The current pointer within zonelist->zones being iterated
 * @zlist - The zonelist being iterated
 * @highidx - The zone index of the highest zone to return
 * @nodemask - Nodemask allowed by the allocator
 *
 * This iterator iterates though all zones at or below a given zone index and
 * within a given nodemask
 */
#define for_each_zone_zonelist_nodemask(zone, z, zlist, highidx, nodemask) \
	for (z = first_zones_zonelist(zlist, highidx, nodemask, &zone);	\
		zone;							\
845
		z = next_zones_zonelist(++z, highidx, nodemask, &zone))	\
846
847
848
849
850
851
852
853
854
855
856

/**
 * for_each_zone_zonelist - helper macro to iterate over valid zones in a zonelist at or below a given zone index
 * @zone - The current zone in the iterator
 * @z - The current pointer within zonelist->zones being iterated
 * @zlist - The zonelist being iterated
 * @highidx - The zone index of the highest zone to return
 *
 * This iterator iterates though all zones at or below a given zone index.
 */
#define for_each_zone_zonelist(zone, z, zlist, highidx) \
857
	for_each_zone_zonelist_nodemask(zone, z, zlist, highidx, NULL)
858

859
860
861
862
#ifdef CONFIG_SPARSEMEM
#include <asm/sparsemem.h>
#endif

863
864
#if !defined(CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID) && \
	!defined(CONFIG_ARCH_POPULATES_NODE_MAP)
865
866
867
868
static inline unsigned long early_pfn_to_nid(unsigned long pfn)
{
	return 0;
}
869
870
#endif

871
872
873
874
#ifdef CONFIG_FLATMEM
#define pfn_to_nid(pfn)		(0)
#endif

875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
#define pfn_to_section_nr(pfn) ((pfn) >> PFN_SECTION_SHIFT)
#define section_nr_to_pfn(sec) ((sec) << PFN_SECTION_SHIFT)

#ifdef CONFIG_SPARSEMEM

/*
 * SECTION_SHIFT    		#bits space required to store a section #
 *
 * PA_SECTION_SHIFT		physical address to/from section number
 * PFN_SECTION_SHIFT		pfn to/from section number
 */
#define SECTIONS_SHIFT		(MAX_PHYSMEM_BITS - SECTION_SIZE_BITS)

#define PA_SECTION_SHIFT	(SECTION_SIZE_BITS)
#define PFN_SECTION_SHIFT	(SECTION_SIZE_BITS - PAGE_SHIFT)

#define NR_MEM_SECTIONS		(1UL << SECTIONS_SHIFT)

#define PAGES_PER_SECTION       (1UL << PFN_SECTION_SHIFT)
#define PAGE_SECTION_MASK	(~(PAGES_PER_SECTION-1))

896
#define SECTION_BLOCKFLAGS_BITS \
897
	((1UL << (PFN_SECTION_SHIFT - pageblock_order)) * NR_PAGEBLOCK_BITS)
898

899
900
901
902
903
904
#if (MAX_ORDER - 1 + PAGE_SHIFT) > SECTION_SIZE_BITS
#error Allocator MAX_ORDER exceeds SECTION_SIZE
#endif

struct page;
struct mem_section {
905
906
907
908
909
	/*
	 * This is, logically, a pointer to an array of struct
	 * pages.  However, it is stored with some other magic.
	 * (see sparse.c::sparse_init_one_section())
	 *
910
911
912
913
	 * Additionally during early boot we encode node id of
	 * the location of the section here to guide allocation.
	 * (see sparse.c::memory_present())
	 *
914
915
916
917
	 * Making it a UL at least makes someone do a cast
	 * before using it wrong.
	 */
	unsigned long section_mem_map;
918
919
920

	/* See declaration of similar field in struct zone */
	unsigned long *pageblock_flags;
921
922
};

923
924
925
926
927
#ifdef CONFIG_SPARSEMEM_EXTREME
#define SECTIONS_PER_ROOT       (PAGE_SIZE / sizeof (struct mem_section))
#else
#define SECTIONS_PER_ROOT	1
#endif
Bob Picco's avatar
Bob Picco committed
928

929
930
931
#define SECTION_NR_TO_ROOT(sec)	((sec) / SECTIONS_PER_ROOT)
#define NR_SECTION_ROOTS	(NR_MEM_SECTIONS / SECTIONS_PER_ROOT)
#define SECTION_ROOT_MASK	(SECTIONS_PER_ROOT - 1)
Bob Picco's avatar
Bob Picco committed
932

933
934
#ifdef CONFIG_SPARSEMEM_EXTREME
extern struct mem_section *mem_section[NR_SECTION_ROOTS];
Bob Picco's avatar
Bob Picco committed
935
#else
936
937
extern struct mem_section mem_section[NR_SECTION_ROOTS][SECTIONS_PER_ROOT];
#endif
938

939
940
static inline struct mem_section *__nr_to_section(unsigned long nr)
{
941
942
943
	if (!mem_section[SECTION_NR_TO_ROOT(nr)])
		return NULL;
	return &mem_section[SECTION_NR_TO_ROOT(nr)][nr & SECTION_ROOT_MASK];
944
}
945
extern int __section_nr(struct mem_section* ms);
946
extern unsigned long usemap_size(void);
947
948
949
950
951
952
953
954
955
956

/*
 * We use the lower bits of the mem_map pointer to store
 * a little bit of information.  There should be at least
 * 3 bits here due to 32-bit alignment.
 */
#define	SECTION_MARKED_PRESENT	(1UL<<0)
#define SECTION_HAS_MEM_MAP	(1UL<<1)
#define SECTION_MAP_LAST_BIT	(1UL<<2)
#define SECTION_MAP_MASK	(~(SECTION_MAP_LAST_BIT-1))
957
#define SECTION_NID_SHIFT	2
958
959
960
961
962
963
964
965

static inline struct page *__section_mem_map_addr(struct mem_section *section)
{
	unsigned long map = section->section_mem_map;
	map &= SECTION_MAP_MASK;
	return (struct page *)map;
}

966
static inline int present_section(struct mem_section *section)
967
{
Bob Picco's avatar
Bob Picco committed
968
	return (section && (section->section_mem_map & SECTION_MARKED_PRESENT));
969
970
}

971
972
973
974
975
976
static inline int present_section_nr(unsigned long nr)
{
	return present_section(__nr_to_section(nr));
}

static inline int valid_section(struct mem_section *section)
977
{
Bob Picco's avatar
Bob Picco committed
978
	return (section && (section->section_mem_map & SECTION_HAS_MEM_MAP));
979
980
981
982
983
984
985
}

static inline int valid_section_nr(unsigned long nr)
{
	return valid_section(__nr_to_section(nr));
}

986
987
static inline struct mem_section *__pfn_to_section(unsigned long pfn)
{
988
	return __nr_to_section(pfn_to_section_nr(pfn));
989
990
991
992
993
994
}

static inline int pfn_valid(unsigned long pfn)
{
	if (pfn_to_section_nr(pfn) >= NR_MEM_SECTIONS)
		return 0;
995
	return valid_section(__nr_to_section(pfn_to_section_nr(pfn)));
996
997
}

998
999
1000
1001
1002
1003
1004
static inline int pfn_present(unsigned long pfn)
{
	if (pfn_to_section_nr(pfn) >= NR_MEM_SECTIONS)
		return 0;
	return present_section(__nr_to_section(pfn_to_section_nr(pfn)));
}

1005
1006
1007
1008
1009
1010
/*
 * These are _only_ used during initialisation, therefore they
 * can use __initdata ...  They could have names to indicate
 * this restriction.
 */
#ifdef CONFIG_NUMA
1011
1012
1013
1014
1015
#define pfn_to_nid(pfn)							\
({									\
	unsigned long __pfn_to_nid_pfn = (pfn);				\
	page_to_nid(pfn_to_page(__pfn_to_nid_pfn));			\
})
1016
1017
#else
#define pfn_to_nid(pfn)		(0)
1018
1019
1020
1021
1022
1023
#endif

#define early_pfn_valid(pfn)	pfn_valid(pfn)
void sparse_init(void);
#else
#define sparse_init()	do {} while (0)
1024
#define sparse_index_init(_sec, _nid)  do {} while (0)
1025
1026
#endif /* CONFIG_SPARSEMEM */

1027
1028
1029
1030
1031
1032
#ifdef CONFIG_NODES_SPAN_OTHER_NODES
#define early_pfn_in_nid(pfn, nid)	(early_pfn_to_nid(pfn) == (nid))
#else
#define early_pfn_in_nid(pfn, nid)	(1)
#endif

1033
1034
1035
1036
1037
1038
1039
#ifndef early_pfn_valid
#define early_pfn_valid(pfn)	(1)
#endif

void memory_present(int nid, unsigned long start, unsigned long end);
unsigned long __init node_memmap_size_bytes(int, unsigned long, unsigned long);

1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
/*
 * If it is possible to have holes within a MAX_ORDER_NR_PAGES, then we
 * need to check pfn validility within that MAX_ORDER_NR_PAGES block.
 * pfn_valid_within() should be used in this case; we optimise this away
 * when we have no holes within a MAX_ORDER_NR_PAGES block.
 */
#ifdef CONFIG_HOLES_IN_ZONE
#define pfn_valid_within(pfn) pfn_valid(pfn)
#else
#define pfn_valid_within(pfn) (1)
#endif

1052
#endif /* !__GENERATING_BOUNDS.H */
Linus Torvalds's avatar
Linus Torvalds committed
1053
1054
#endif /* !__ASSEMBLY__ */
#endif /* _LINUX_MMZONE_H */