mmzone.h 40.3 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/page-flags-layout.h>
Arun Sharma's avatar
Arun Sharma committed
19
#include <linux/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
/*
 * PAGE_ALLOC_COSTLY_ORDER is the order at which allocations are deemed
 * costly to service.  That is between allocation orders which should
33
 * coalesce naturally under reasonable reclaim pressure and those which
Andy Whitcroft's avatar
Andy Whitcroft committed
34
35
36
37
 * will not.
 */
#define PAGE_ALLOC_COSTLY_ORDER 3

38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
enum {
	MIGRATE_UNMOVABLE,
	MIGRATE_RECLAIMABLE,
	MIGRATE_MOVABLE,
	MIGRATE_PCPTYPES,	/* the number of types on the pcp lists */
	MIGRATE_RESERVE = MIGRATE_PCPTYPES,
#ifdef CONFIG_CMA
	/*
	 * MIGRATE_CMA migration type is designed to mimic the way
	 * ZONE_MOVABLE works.  Only movable pages can be allocated
	 * from MIGRATE_CMA pageblocks and page allocator never
	 * implicitly change migration type of MIGRATE_CMA pageblock.
	 *
	 * The way to use it is to change migratetype of a range of
	 * pageblocks to MIGRATE_CMA which can be done by
	 * __free_pageblock_cma() function.  What is important though
	 * is that a range of pageblocks must be aligned to
	 * MAX_ORDER_NR_PAGES should biggest page be bigger then
	 * a single pageblock.
	 */
	MIGRATE_CMA,
#endif
60
#ifdef CONFIG_MEMORY_ISOLATION
61
	MIGRATE_ISOLATE,	/* can't allocate from here */
62
#endif
63
64
65
66
67
68
69
70
	MIGRATE_TYPES
};

#ifdef CONFIG_CMA
#  define is_migrate_cma(migratetype) unlikely((migratetype) == MIGRATE_CMA)
#else
#  define is_migrate_cma(migratetype) false
#endif
71
72
73
74
75

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

76
77
78
79
80
81
82
extern int page_group_by_mobility_disabled;

static inline int get_pageblock_migratetype(struct page *page)
{
	return get_pageblock_flags_group(page, PB_migrate, PB_migrate_end);
}

Linus Torvalds's avatar
Linus Torvalds committed
83
struct free_area {
84
	struct list_head	free_list[MIGRATE_TYPES];
Linus Torvalds's avatar
Linus Torvalds committed
85
86
87
88
89
90
91
92
93
94
95
96
97
98
	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];
99
} ____cacheline_internodealigned_in_smp;
Linus Torvalds's avatar
Linus Torvalds committed
100
101
102
103
104
#define ZONE_PADDING(name)	struct zone_padding name;
#else
#define ZONE_PADDING(name)
#endif

105
enum zone_stat_item {
106
	/* First 128 byte cacheline (assuming 64 bit words) */
107
	NR_FREE_PAGES,
108
	NR_LRU_BASE,
109
110
111
112
	NR_INACTIVE_ANON = NR_LRU_BASE, /* must match order of LRU_[IN]ACTIVE */
	NR_ACTIVE_ANON,		/*  "     "     "   "       "         */
	NR_INACTIVE_FILE,	/*  "     "     "   "       "         */
	NR_ACTIVE_FILE,		/*  "     "     "   "       "         */
113
	NR_UNEVICTABLE,		/*  "     "     "   "       "         */
Nick Piggin's avatar
Nick Piggin committed
114
	NR_MLOCK,		/* mlock()ed pages found and moved off LRU */
115
116
	NR_ANON_PAGES,	/* Mapped anonymous pages */
	NR_FILE_MAPPED,	/* pagecache pages mapped into pagetables.
117
			   only modified from process context */
118
	NR_FILE_PAGES,
119
	NR_FILE_DIRTY,
120
	NR_WRITEBACK,
121
122
123
	NR_SLAB_RECLAIMABLE,
	NR_SLAB_UNRECLAIMABLE,
	NR_PAGETABLE,		/* used for pagetables */
124
125
	NR_KERNEL_STACK,
	/* Second 128 byte cacheline */
126
	NR_UNSTABLE_NFS,	/* NFS unstable pages */
127
	NR_BOUNCE,
128
	NR_VMSCAN_WRITE,
129
	NR_VMSCAN_IMMEDIATE,	/* Prioritise for reclaim when writeback ends */
130
	NR_WRITEBACK_TEMP,	/* Writeback using temporary buffers */
131
132
	NR_ISOLATED_ANON,	/* Temporary isolated pages from anon lru */
	NR_ISOLATED_FILE,	/* Temporary isolated pages from file lru */
133
	NR_SHMEM,		/* shmem pages (included tmpfs/GEM pages) */
134
135
	NR_DIRTIED,		/* page dirtyings since bootup */
	NR_WRITTEN,		/* page writings since bootup */
136
137
138
139
140
141
142
143
#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
144
	NR_ANON_TRANSPARENT_HUGEPAGES,
145
	NR_FREE_CMA_PAGES,
146
147
	NR_VM_ZONE_STAT_ITEMS };

148
149
150
151
152
153
154
155
156
157
158
159
160
/*
 * 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

161
enum lru_list {
162
163
164
165
	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,
166
167
168
	LRU_UNEVICTABLE,
	NR_LRU_LISTS
};
169

Hugh Dickins's avatar
Hugh Dickins committed
170
#define for_each_lru(lru) for (lru = 0; lru < NR_LRU_LISTS; lru++)
171

Hugh Dickins's avatar
Hugh Dickins committed
172
#define for_each_evictable_lru(lru) for (lru = 0; lru <= LRU_ACTIVE_FILE; lru++)
173

Hugh Dickins's avatar
Hugh Dickins committed
174
static inline int is_file_lru(enum lru_list lru)
175
{
Hugh Dickins's avatar
Hugh Dickins committed
176
	return (lru == LRU_INACTIVE_FILE || lru == LRU_ACTIVE_FILE);
177
178
}

Hugh Dickins's avatar
Hugh Dickins committed
179
static inline int is_active_lru(enum lru_list lru)
180
{
Hugh Dickins's avatar
Hugh Dickins committed
181
	return (lru == LRU_ACTIVE_ANON || lru == LRU_ACTIVE_FILE);
182
183
}

Hugh Dickins's avatar
Hugh Dickins committed
184
static inline int is_unevictable_lru(enum lru_list lru)
185
{
Hugh Dickins's avatar
Hugh Dickins committed
186
	return (lru == LRU_UNEVICTABLE);
187
188
}

189
190
191
struct zone_reclaim_stat {
	/*
	 * The pageout code in vmscan.c keeps track of how many of the
192
	 * mem/swap backed and file backed pages are referenced.
193
194
195
196
197
198
199
200
201
	 * 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];
};

202
203
struct lruvec {
	struct list_head lists[NR_LRU_LISTS];
204
	struct zone_reclaim_stat reclaim_stat;
Andrew Morton's avatar
Andrew Morton committed
205
#ifdef CONFIG_MEMCG
206
207
	struct zone *zone;
#endif
208
209
};

210
211
212
213
214
/* Mask used at gathering information at once (see memcontrol.c) */
#define LRU_ALL_FILE (BIT(LRU_INACTIVE_FILE) | BIT(LRU_ACTIVE_FILE))
#define LRU_ALL_ANON (BIT(LRU_INACTIVE_ANON) | BIT(LRU_ACTIVE_ANON))
#define LRU_ALL	     ((1 << NR_LRU_LISTS) - 1)

215
/* Isolate clean file */
216
#define ISOLATE_CLEAN		((__force isolate_mode_t)0x1)
217
/* Isolate unmapped file */
218
#define ISOLATE_UNMAPPED	((__force isolate_mode_t)0x2)
219
/* Isolate for asynchronous migration */
220
#define ISOLATE_ASYNC_MIGRATE	((__force isolate_mode_t)0x4)
Minchan Kim's avatar
Minchan Kim committed
221
222
/* Isolate unevictable pages */
#define ISOLATE_UNEVICTABLE	((__force isolate_mode_t)0x8)
223
224
225
226

/* LRU Isolation modes. */
typedef unsigned __bitwise__ isolate_mode_t;

227
228
229
230
231
232
233
234
235
236
237
enum zone_watermarks {
	WMARK_MIN,
	WMARK_LOW,
	WMARK_HIGH,
	NR_WMARK
};

#define min_wmark_pages(z) (z->watermark[WMARK_MIN])
#define low_wmark_pages(z) (z->watermark[WMARK_LOW])
#define high_wmark_pages(z) (z->watermark[WMARK_HIGH])

Linus Torvalds's avatar
Linus Torvalds committed
238
239
240
241
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 */
242
243
244

	/* Lists of pages, one per migrate type stored on the pcp-lists */
	struct list_head lists[MIGRATE_PCPTYPES];
Linus Torvalds's avatar
Linus Torvalds committed
245
246
247
};

struct per_cpu_pageset {
248
	struct per_cpu_pages pcp;
249
250
251
#ifdef CONFIG_NUMA
	s8 expire;
#endif
252
#ifdef CONFIG_SMP
253
	s8 stat_threshold;
254
255
	s8 vm_stat_diff[NR_VM_ZONE_STAT_ITEMS];
#endif
256
};
257

258
259
#endif /* !__GENERATING_BOUNDS.H */

260
enum zone_type {
261
#ifdef CONFIG_ZONE_DMA
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
	/*
	 * 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,
281
#endif
282
#ifdef CONFIG_ZONE_DMA32
283
284
285
286
287
288
	/*
	 * 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,
289
#endif
290
291
292
293
294
295
	/*
	 * 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,
296
#ifdef CONFIG_HIGHMEM
297
298
299
300
301
302
303
304
305
	/*
	 * 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,
306
#endif
Mel Gorman's avatar
Mel Gorman committed
307
	ZONE_MOVABLE,
308
	__MAX_NR_ZONES
309
};
Linus Torvalds's avatar
Linus Torvalds committed
310

311
312
#ifndef __GENERATING_BOUNDS_H

Linus Torvalds's avatar
Linus Torvalds committed
313
314
struct zone {
	/* Fields commonly accessed by the page allocator */
315
316
317
318

	/* zone watermarks, access with *_wmark_pages(zone) macros */
	unsigned long watermark[NR_WMARK];

319
320
321
322
323
324
325
	/*
	 * When free pages are below this point, additional steps are taken
	 * when reading the number of free pages to avoid per-cpu counter
	 * drift allowing watermarks to be breached
	 */
	unsigned long percpu_drift_mark;

Linus Torvalds's avatar
Linus Torvalds committed
326
327
328
329
330
331
332
333
334
335
	/*
	 * 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];

336
337
338
339
340
341
	/*
	 * This is a per-zone reserve of pages that should not be
	 * considered dirtyable memory.
	 */
	unsigned long		dirty_balance_reserve;

342
#ifdef CONFIG_NUMA
343
	int node;
344
345
346
	/*
	 * zone reclaim becomes active if more unmapped pages exist.
	 */
347
	unsigned long		min_unmapped_pages;
348
	unsigned long		min_slab_pages;
349
#endif
350
	struct per_cpu_pageset __percpu *pageset;
Linus Torvalds's avatar
Linus Torvalds committed
351
352
353
354
	/*
	 * free areas of different sizes
	 */
	spinlock_t		lock;
355
	int                     all_unreclaimable; /* All pages pinned */
356
#if defined CONFIG_COMPACTION || defined CONFIG_CMA
357
358
	/* Set to true when the PG_migrate_skip bits should be cleared */
	bool			compact_blockskip_flush;
359
360
361
362

	/* pfns where compaction scanners should start */
	unsigned long		compact_cached_free_pfn;
	unsigned long		compact_cached_migrate_pfn;
363
#endif
364
365
366
367
#ifdef CONFIG_MEMORY_HOTPLUG
	/* see spanned/present_pages for more description */
	seqlock_t		span_seqlock;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
368
369
	struct free_area	free_area[MAX_ORDER];

370
371
#ifndef CONFIG_SPARSEMEM
	/*
372
	 * Flags for a pageblock_nr_pages block. See pageblock-flags.h.
373
374
375
376
377
	 * In SPARSEMEM, this map is stored in struct mem_section
	 */
	unsigned long		*pageblock_flags;
#endif /* CONFIG_SPARSEMEM */

378
379
380
381
382
383
384
385
#ifdef CONFIG_COMPACTION
	/*
	 * On compaction failure, 1<<compact_defer_shift compactions
	 * are skipped before trying again. The number attempted since
	 * last failure is tracked with compact_considered.
	 */
	unsigned int		compact_considered;
	unsigned int		compact_defer_shift;
386
	int			compact_order_failed;
387
#endif
Linus Torvalds's avatar
Linus Torvalds committed
388
389
390
391

	ZONE_PADDING(_pad1_)

	/* Fields commonly accessed by the page reclaim scanner */
392
393
	spinlock_t		lru_lock;
	struct lruvec		lruvec;
394

Linus Torvalds's avatar
Linus Torvalds committed
395
	unsigned long		pages_scanned;	   /* since last reclaim */
396
	unsigned long		flags;		   /* zone flags, see below */
Martin Hicks's avatar
Martin Hicks committed
397

398
399
	/* Zone statistics */
	atomic_long_t		vm_stat[NR_VM_ZONE_STAT_ITEMS];
400

401
402
403
404
405
406
	/*
	 * The target ratio of ACTIVE_ANON to INACTIVE_ANON pages on
	 * this zone's LRU.  Maintained by the pageout code.
	 */
	unsigned int inactive_ratio;

Linus Torvalds's avatar
Linus Torvalds committed
407
408
409
410
411
412

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

	/*
	 * wait_table		-- the array holding the hash table
413
	 * wait_table_hash_nr_entries	-- the size of the hash table array
Linus Torvalds's avatar
Linus Torvalds committed
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
	 * 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;
436
	unsigned long		wait_table_hash_nr_entries;
Linus Torvalds's avatar
Linus Torvalds committed
437
438
439
440
441
442
443
444
445
	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;

446
	/*
447
448
449
	 * spanned_pages is the total pages spanned by the zone, including
	 * holes, which is calculated as:
	 * 	spanned_pages = zone_end_pfn - zone_start_pfn;
450
	 *
451
452
	 * present_pages is physical pages existing within the zone, which
	 * is calculated as:
453
	 *	present_pages = spanned_pages - absent_pages(pages in holes);
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
	 *
	 * managed_pages is present pages managed by the buddy system, which
	 * is calculated as (reserved_pages includes pages allocated by the
	 * bootmem allocator):
	 *	managed_pages = present_pages - reserved_pages;
	 *
	 * So present_pages may be used by memory hotplug or memory power
	 * management logic to figure out unmanaged pages by checking
	 * (present_pages - managed_pages). And managed_pages should be used
	 * by page allocator and vm scanner to calculate all kinds of watermarks
	 * and thresholds.
	 *
	 * Locking rules:
	 *
	 * zone_start_pfn and spanned_pages are 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 span_seq lock is declared along with zone->lock because it is
474
475
	 * frequently read in proximity to zone->lock.  It's good to
	 * give them a chance of being in the same cacheline.
476
	 *
477
478
479
480
481
482
483
484
485
486
	 * Write access to present_pages at runtime should be protected by
	 * lock_memory_hotplug()/unlock_memory_hotplug().  Any reader who can't
	 * tolerant drift of present_pages should hold memory hotplug lock to
	 * get a stable value.
	 *
	 * Read access to managed_pages should be safe because it's unsigned
	 * long. Write access to zone->managed_pages and totalram_pages are
	 * protected by managed_page_count_lock at runtime. Idealy only
	 * adjust_managed_page_count() should be used instead of directly
	 * touching zone->managed_pages and totalram_pages.
487
	 */
488
489
490
	unsigned long		spanned_pages;
	unsigned long		present_pages;
	unsigned long		managed_pages;
Linus Torvalds's avatar
Linus Torvalds committed
491
492
493
494

	/*
	 * rarely used fields:
	 */
495
	const char		*name;
496
} ____cacheline_internodealigned_in_smp;
Linus Torvalds's avatar
Linus Torvalds committed
497

498
499
typedef enum {
	ZONE_RECLAIM_LOCKED,		/* prevents concurrent reclaim */
David Rientjes's avatar
David Rientjes committed
500
	ZONE_OOM_LOCKED,		/* zone is in OOM killer zonelist */
501
502
503
	ZONE_CONGESTED,			/* zone has many dirty pages backed by
					 * a congested BDI
					 */
504
505
506
507
	ZONE_TAIL_LRU_DIRTY,		/* reclaim scanning has recently found
					 * many dirty file pages at the tail
					 * of the LRU.
					 */
508
509
510
	ZONE_WRITEBACK,			/* reclaim scanning has recently found
					 * many pages under writeback
					 */
511
512
513
514
515
516
} zone_flags_t;

static inline void zone_set_flag(struct zone *zone, zone_flags_t flag)
{
	set_bit(flag, &zone->flags);
}
517
518
519
520
521
522

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

523
524
525
526
527
static inline void zone_clear_flag(struct zone *zone, zone_flags_t flag)
{
	clear_bit(flag, &zone->flags);
}

528
529
530
531
532
static inline int zone_is_reclaim_congested(const struct zone *zone)
{
	return test_bit(ZONE_CONGESTED, &zone->flags);
}

533
534
535
536
537
static inline int zone_is_reclaim_dirty(const struct zone *zone)
{
	return test_bit(ZONE_TAIL_LRU_DIRTY, &zone->flags);
}

538
539
540
541
542
static inline int zone_is_reclaim_writeback(const struct zone *zone)
{
	return test_bit(ZONE_WRITEBACK, &zone->flags);
}

543
544
545
546
static inline int zone_is_reclaim_locked(const struct zone *zone)
{
	return test_bit(ZONE_RECLAIM_LOCKED, &zone->flags);
}
547

David Rientjes's avatar
David Rientjes committed
548
549
550
551
static inline int zone_is_oom_locked(const struct zone *zone)
{
	return test_bit(ZONE_OOM_LOCKED, &zone->flags);
}
552

Russ Anderson's avatar
Russ Anderson committed
553
static inline unsigned long zone_end_pfn(const struct zone *zone)
554
555
556
557
558
559
560
561
562
{
	return zone->zone_start_pfn + zone->spanned_pages;
}

static inline bool zone_spans_pfn(const struct zone *zone, unsigned long pfn)
{
	return zone->zone_start_pfn <= pfn && pfn < zone_end_pfn(zone);
}

563
564
565
566
567
568
569
570
571
572
static inline bool zone_is_initialized(struct zone *zone)
{
	return !!zone->wait_table;
}

static inline bool zone_is_empty(struct zone *zone)
{
	return zone->spanned_pages == 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
573
574
575
576
577
578
579
/*
 * 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

580
581
582
583
/* Maximum number of zones on a zonelist */
#define MAX_ZONES_PER_ZONELIST (MAX_NUMNODES * MAX_NR_ZONES)

#ifdef CONFIG_NUMA
584
585

/*
586
 * The NUMA zonelists are doubled because we need zonelists that restrict the
587
588
 * allocations to a single node for GFP_THISNODE.
 *
589
590
 * [0]	: Zonelist with fallback
 * [1]	: No fallback (GFP_THISNODE)
591
 */
592
#define MAX_ZONELISTS 2
593
594


595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
/*
 * 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 */
656
	DECLARE_BITMAP(fullzones, MAX_ZONES_PER_ZONELIST);	/* zone full? */
657
658
659
	unsigned long last_full_zap;		/* when last zap'd (jiffies) */
};
#else
660
#define MAX_ZONELISTS 1
661
662
663
struct zonelist_cache;
#endif

664
665
666
667
668
669
670
671
672
/*
 * 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
673
674
675
676
677
678
/*
 * 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.
 *
679
680
 * 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.
681
682
683
684
685
686
687
688
 * *
 * 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
689
690
 */
struct zonelist {
691
	struct zonelist_cache *zlcache_ptr;		     // NULL or &zlcache
692
	struct zoneref _zonerefs[MAX_ZONES_PER_ZONELIST + 1];
693
694
695
#ifdef CONFIG_NUMA
	struct zonelist_cache zlcache;			     // optional ...
#endif
Linus Torvalds's avatar
Linus Torvalds committed
696
697
};

Tejun Heo's avatar
Tejun Heo committed
698
#ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
699
700
701
702
703
struct node_active_region {
	unsigned long start_pfn;
	unsigned long end_pfn;
	int nid;
};
Tejun Heo's avatar
Tejun Heo committed
704
#endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
Linus Torvalds's avatar
Linus Torvalds committed
705

706
707
708
709
710
#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
711
712
713
714
715
716
717
718
719
720
721
722
723
724
/*
 * 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];
725
	struct zonelist node_zonelists[MAX_ZONELISTS];
Linus Torvalds's avatar
Linus Torvalds committed
726
	int nr_zones;
727
#ifdef CONFIG_FLAT_NODE_MEM_MAP	/* means !SPARSEMEM */
Linus Torvalds's avatar
Linus Torvalds committed
728
	struct page *node_mem_map;
Andrew Morton's avatar
Andrew Morton committed
729
#ifdef CONFIG_MEMCG
730
731
	struct page_cgroup *node_page_cgroup;
#endif
732
#endif
733
#ifndef CONFIG_NO_BOOTMEM
Linus Torvalds's avatar
Linus Torvalds committed
734
	struct bootmem_data *bdata;
735
#endif
736
737
738
739
740
741
#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.
	 *
742
743
744
	 * pgdat_resize_lock() and pgdat_resize_unlock() are provided to
	 * manipulate node_size_lock without checking for CONFIG_MEMORY_HOTPLUG.
	 *
745
	 * Nests above zone->lock and zone->span_seqlock
746
747
748
	 */
	spinlock_t node_size_lock;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
749
750
751
752
753
	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;
754
	nodemask_t reclaim_nodes;	/* Nodes allowed to reclaim from */
Linus Torvalds's avatar
Linus Torvalds committed
755
	wait_queue_head_t kswapd_wait;
756
	wait_queue_head_t pfmemalloc_wait;
757
	struct task_struct *kswapd;	/* Protected by lock_memory_hotplug() */
Linus Torvalds's avatar
Linus Torvalds committed
758
	int kswapd_max_order;
759
	enum zone_type classzone_idx;
760
761
762
763
764
765
766
767
768
769
770
771
772
#ifdef CONFIG_NUMA_BALANCING
	/*
	 * Lock serializing the per destination node AutoNUMA memory
	 * migration rate limiting data.
	 */
	spinlock_t numabalancing_migrate_lock;

	/* Rate limiting time interval */
	unsigned long numabalancing_migrate_next_window;

	/* Number of pages migrated during the rate limiting time interval */
	unsigned long numabalancing_migrate_nr_pages;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
773
774
775
776
} 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)
777
#ifdef CONFIG_FLAT_NODE_MEM_MAP
778
#define pgdat_page_nr(pgdat, pagenr)	((pgdat)->node_mem_map + (pagenr))
779
780
781
#else
#define pgdat_page_nr(pgdat, pagenr)	pfn_to_page((pgdat)->node_start_pfn + (pagenr))
#endif
782
#define nid_page_nr(nid, pagenr) 	pgdat_page_nr(NODE_DATA(nid),(pagenr))
Linus Torvalds's avatar
Linus Torvalds committed
783

784
#define node_start_pfn(nid)	(NODE_DATA(nid)->node_start_pfn)
785
#define node_end_pfn(nid) pgdat_end_pfn(NODE_DATA(nid))
786

787
788
789
790
791
792
793
794
795
static inline unsigned long pgdat_end_pfn(pg_data_t *pgdat)
{
	return pgdat->node_start_pfn + pgdat->node_spanned_pages;
}

static inline bool pgdat_is_empty(pg_data_t *pgdat)
{
	return !pgdat->node_start_pfn && !pgdat->node_spanned_pages;
}
796

797
798
#include <linux/memory_hotplug.h>

799
extern struct mutex zonelists_mutex;
800
void build_all_zonelists(pg_data_t *pgdat, struct zone *zone);
801
void wakeup_kswapd(struct zone *zone, int order, enum zone_type classzone_idx);
802
803
804
bool zone_watermark_ok(struct zone *z, int order, unsigned long mark,
		int classzone_idx, int alloc_flags);
bool zone_watermark_ok_safe(struct zone *z, int order, unsigned long mark,
Rohit Seth's avatar
Rohit Seth committed
805
		int classzone_idx, int alloc_flags);
Dave Hansen's avatar
Dave Hansen committed
806
807
808
809
enum memmap_context {
	MEMMAP_EARLY,
	MEMMAP_HOTPLUG,
};
810
extern int init_currently_empty_zone(struct zone *zone, unsigned long start_pfn,
Dave Hansen's avatar
Dave Hansen committed
811
812
				     unsigned long size,
				     enum memmap_context context);
813

814
extern void lruvec_init(struct lruvec *lruvec);
815
816
817

static inline struct zone *lruvec_zone(struct lruvec *lruvec)
{
Andrew Morton's avatar
Andrew Morton committed
818
#ifdef CONFIG_MEMCG
819
820
821
822
823
824
	return lruvec->zone;
#else
	return container_of(lruvec, struct zone, lruvec);
#endif
}

Linus Torvalds's avatar
Linus Torvalds committed
825
826
827
828
829
830
#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

831
832
833
834
835
836
#ifdef CONFIG_HAVE_MEMORYLESS_NODES
int local_memory_node(int node_id);
#else
static inline int local_memory_node(int node_id) { return node_id; };
#endif

Linus Torvalds's avatar
Linus Torvalds committed
837
838
839
840
841
842
843
844
845
#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)

846
847
848
849
850
static inline int populated_zone(struct zone *zone)
{
	return (!!zone->present_pages);
}

Mel Gorman's avatar
Mel Gorman committed
851
852
853
854
extern int movable_zone;

static inline int zone_movable_is_highmem(void)
{
855
#if defined(CONFIG_HIGHMEM) && defined(CONFIG_HAVE_MEMBLOCK_NODE_MAP)
Mel Gorman's avatar
Mel Gorman committed
856
857
858
859
860
861
	return movable_zone == ZONE_HIGHMEM;
#else
	return 0;
#endif
}

862
static inline int is_highmem_idx(enum zone_type idx)
Linus Torvalds's avatar
Linus Torvalds committed
863
{
864
#ifdef CONFIG_HIGHMEM
Mel Gorman's avatar
Mel Gorman committed
865
866
	return (idx == ZONE_HIGHMEM ||
		(idx == ZONE_MOVABLE && zone_movable_is_highmem()));
867
868
869
#else
	return 0;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
870
871
}

872
static inline int is_normal_idx(enum zone_type idx)
Linus Torvalds's avatar
Linus Torvalds committed
873
874
875
{
	return (idx == ZONE_NORMAL);
}
876

Linus Torvalds's avatar
Linus Torvalds committed
877
878
879
880
881
882
883
884
/**
 * 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)
{
885
#ifdef CONFIG_HIGHMEM
886
887
888
889
	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());
890
891
892
#else
	return 0;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
893
894
895
896
897
898
899
}

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

900
901
static inline int is_dma32(struct zone *zone)
{
902
#ifdef CONFIG_ZONE_DMA32
903
	return zone == zone->zone_pgdat->node_zones + ZONE_DMA32;
904
905
906
#else
	return 0;
#endif
907
908
909
910
}

static inline int is_dma(struct zone *zone)
{
911
#ifdef CONFIG_ZONE_DMA
912
	return zone == zone->zone_pgdat->node_zones + ZONE_DMA;
913
914
915
#else
	return 0;
#endif
916
917
}

Linus Torvalds's avatar
Linus Torvalds committed
918
919
/* These two functions are used to setup the per zone pages min values */
struct ctl_table;
920
int min_free_kbytes_sysctl_handler(struct ctl_table *, int,
Linus Torvalds's avatar
Linus Torvalds committed
921
922
					void __user *, size_t *, loff_t *);
extern int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES-1];
923
int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int,
Linus Torvalds's avatar
Linus Torvalds committed
924
					void __user *, size_t *, loff_t *);
925
int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *, int,
926
					void __user *, size_t *, loff_t *);
927
int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *, int,
928
			void __user *, size_t *, loff_t *);
929
int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *, int,
930
			void __user *, size_t *, loff_t *);
Linus Torvalds's avatar
Linus Torvalds committed
931

932
extern int numa_zonelist_order_handler(struct ctl_table *, int,
933
			void __user *, size_t *, loff_t *);
934
935
936
extern char numa_zonelist_order[];
#define NUMA_ZONELIST_ORDER_LEN 16	/* string buffer size */

937
#ifndef CONFIG_NEED_MULTIPLE_NODES
Linus Torvalds's avatar
Linus Torvalds committed
938
939
940
941
942

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

943
#else /* CONFIG_NEED_MULTIPLE_NODES */
Linus Torvalds's avatar
Linus Torvalds committed
944
945
946

#include <asm/mmzone.h>

947
#endif /* !CONFIG_NEED_MULTIPLE_NODES */
948

949
950
951
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);
952
953

/**
954
 * for_each_online_pgdat - helper macro to iterate over all online nodes
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
 * @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))

973
974
975
976
977
978
979
980
#define for_each_populated_zone(zone)		        \
	for (zone = (first_online_pgdat())->node_zones; \
	     zone;					\
	     zone = next_zone(zone))			\
		if (!populated_zone(zone))		\
			; /* do nothing */		\
		else

981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
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 */
}

1001
1002
1003
1004
1005
1006
1007
1008
1009
/**
 * 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
1010
1011
1012
 * 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.
1013
1014
1015
1016
1017
 */
struct zoneref *next_zones_zonelist(struct zoneref *z,
					enum zone_type highest_zoneidx,
					nodemask_t *nodes,
					struct zone **zone);
1018

1019
1020
1021
1022
1023
1024
1025
1026
1027
/**
 * 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
1028
1029
 * used to iterate the zonelist with next_zones_zonelist by advancing it by
 * one before calling.
1030
 */
1031
static inline struct zoneref *first_zones_zonelist(struct zonelist *zonelist,
1032
1033
1034
					enum zone_type highest_zoneidx,
					nodemask_t *nodes,
					struct zone **zone)
1035
{
1036
1037
	return next_zones_zonelist(zonelist->_zonerefs, highest_zoneidx, nodes,
								zone);
1038
1039
}

1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
/**
 * 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;							\
1054
		z = next_zones_zonelist(++z, highidx, nodemask, &zone))	\
1055
1056
1057
1058
1059
1060
1061
1062
1063
1064
1065

/**
 * 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) \
1066
	for_each_zone_zonelist_nodemask(zone, z, zlist, highidx, NULL)
1067

1068
1069
1070
1071
#ifdef CONFIG_SPARSEMEM
#include <asm/sparsemem.h>
#endif

1072
#if !defined(CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID) && \
Tejun Heo's avatar
Tejun Heo committed
1073
	!defined(CONFIG_HAVE_MEMBLOCK_NODE_MAP)
1074
1075
1076
1077
static inline unsigned long early_pfn_to_nid(unsigned long pfn)
{
	return 0;
}
1078
1079
#endif

1080
1081
1082
1083
#ifdef CONFIG_FLATMEM
#define pfn_to_nid(pfn)		(0)
#endif

1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
#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 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))

1100
#define SECTION_BLOCKFLAGS_BITS \
1101
	((1UL << (PFN_SECTION_SHIFT - pageblock_order)) * NR_PAGEBLOCK_BITS)
1102

1103
1104
1105
1106
#if (MAX_ORDER - 1 + PAGE_SHIFT) > SECTION_SIZE_BITS
#error Allocator MAX_ORDER exceeds SECTION_SIZE
#endif

1107
1108
1109
#define pfn_to_section_nr(pfn) ((pfn) >> PFN_SECTION_SHIFT)
#define section_nr_to_pfn(sec) ((sec) << PFN_SECTION_SHIFT)

1110
1111
1112
#define SECTION_ALIGN_UP(pfn)	(((pfn) + PAGES_PER_SECTION - 1) & PAGE_SECTION_MASK)
#define SECTION_ALIGN_DOWN(pfn)	((pfn) & PAGE_SECTION_MASK)

1113
struct page;
1114
struct page_cgroup;
1115
struct mem_section {
1116
1117
1118
1119
1120
	/*
	 * 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())
	 *
1121
1122
1123
1124
	 * Additionally during early boot we encode node id of
	 * the location of the section here to guide allocation.
	 * (see sparse.c::memory_present())
	 *
1125
1126
1127
1128
	 * Making it a UL at least makes someone do a cast
	 * before using it wrong.
	 */
	unsigned long section_mem_map;
1129
1130
1131

	/* See declaration of similar field in struct zone */
	unsigned long *pageblock_flags;
Andrew Morton's avatar
Andrew Morton committed
1132
#ifdef CONFIG_MEMCG
1133
1134
1135
1136
1137
1138
1139
	/*
	 * If !SPARSEMEM, pgdat doesn't have page_cgroup pointer. We use
	 * section. (see memcontrol.h/page_cgroup.h about this.)
	 */
	struct page_cgroup *page_cgroup;
	unsigned long pad;
#endif
1140
1141
1142
1143
	/*
	 * WARNING: mem_section must be a power-of-2 in size for the
	 * calculation and use of SECTION_ROOT_MASK to make sense.
	 */
1144
1145
};

1146
1147
1148
1149
1150
#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
1151

1152
#define SECTION_NR_TO_ROOT(sec)	((sec) / SECTIONS_PER_ROOT)
1153
#define NR_SECTION_ROOTS	DIV_ROUND_UP(NR_MEM_SECTIONS, SECTIONS_PER_ROOT)
1154
#define SECTION_ROOT_MASK	(SECTIONS_PER_ROOT - 1)
Bob Picco's avatar
Bob Picco committed
1155

1156
1157
#ifdef CONFIG_SPARSEMEM_EXTREME
extern struct mem_section *mem_section[NR_SECTION_ROOTS];
Bob Picco's avatar
Bob Picco committed
1158
#else
1159
1160
extern struct mem_section mem_section[NR_SECTION_ROOTS][SECTIONS_PER_ROOT];
#endif
1161

1162
1163
static inline struct mem_section *__nr_to_section(unsigned long nr)
{
1164
1165
1166
	if (!mem_section[SECTION_NR_TO_ROOT(nr)])
		return NULL;
	return &mem_section[SECTION_NR_TO_ROOT(nr)][nr & SECTION_ROOT_MASK];
1167
}
1168
extern int __section_nr(struct mem_section* ms);
1169
extern unsigned long usemap_size(void);
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179

/*
 * 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))
1180
#define SECTION_NID_SHIFT	2
1181
1182
1183
1184
1185
1186
1187
1188

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;
}

1189
static inline int present_section(struct mem_section *section)
1190
{
Bob Picco's avatar
Bob Picco committed
1191
	return (section && (section->section_mem_map & SECTION_MARKED_PRESENT));
1192
1193
}

1194
1195
1196
1197
1198
1199
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)
1200
{
Bob Picco's avatar
Bob Picco committed
1201
	return (section && (section->section_mem_map & SECTION_HAS_MEM_MAP));
1202
1203
1204
1205
1206
1207
1208
}

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

1209
1210
static inline struct mem_section *__pfn_to_section(unsigned long pfn)
{
1211
	return __nr_to_section(pfn_to_section_nr(pfn));
1212
1213
}

1214
#ifndef CONFIG_HAVE_ARCH_PFN_VALID
1215
1216
1217
1218
static inline int pfn_valid(unsigned long pfn)
{
	if (pfn_to_section_nr(pfn) >= NR_MEM_SECTIONS)
		return 0;
1219
	return valid_section(__nr_to_section(pfn_to_section_nr(pfn)));
1220
}
1221
#endif
1222

1223
1224
1225
1226
1227
1228
1229
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)));
}

1230
1231
1232
1233
1234
1235
/*
 * These are _only_ used during initialisation, therefore they
 * can use __initdata ...  They could have names to indicate
 * this restriction.
 */
#ifdef CONFIG_NUMA
1236
1237
1238
1239
1240
#define pfn_to_nid(pfn)							\
({									\
	unsigned long __pfn_to_nid_pfn = (pfn);				\
	page_to_nid(pfn_to_page(__pfn_to_nid_pfn));			\
})
1241
1242
#else
#define pfn_to_nid(pfn)		(0)
1243
1244
1245
1246
1247
1248
#endif

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

1252
#ifdef CONFIG_NODES_SPAN_OTHER_NODES
1253
bool early_pfn_in_nid(unsigned long pfn, int nid);
1254
1255
1256
1257
#else
#define early_pfn_in_nid(pfn, nid)	(1)
#endif

1258
1259
1260
1261
1262
1263
1264
#ifndef early_pfn_valid