mmzone.h 27.1 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13
#ifndef _LINUX_MMZONE_H
#define _LINUX_MMZONE_H

#ifdef __KERNEL__
#ifndef __ASSEMBLY__

#include <linux/spinlock.h>
#include <linux/list.h>
#include <linux/wait.h>
#include <linux/cache.h>
#include <linux/threads.h>
#include <linux/numa.h>
#include <linux/init.h>
14
#include <linux/seqlock.h>
15
#include <linux/nodemask.h>
16
#include <linux/pageblock-flags.h>
L
Linus Torvalds 已提交
17
#include <asm/atomic.h>
R
Ralf Baechle 已提交
18
#include <asm/page.h>
L
Linus Torvalds 已提交
19 20 21 22 23 24 25

/* Free memory management - zoned buddy allocator.  */
#ifndef CONFIG_FORCE_MAX_ZONEORDER
#define MAX_ORDER 11
#else
#define MAX_ORDER CONFIG_FORCE_MAX_ZONEORDER
#endif
26
#define MAX_ORDER_NR_PAGES (1 << (MAX_ORDER - 1))
L
Linus Torvalds 已提交
27

A
Andy Whitcroft 已提交
28 29 30 31 32 33 34 35
/*
 * 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

36
#define MIGRATE_UNMOVABLE     0
37 38
#define MIGRATE_RECLAIMABLE   1
#define MIGRATE_MOVABLE       2
39 40
#define MIGRATE_RESERVE       3
#define MIGRATE_TYPES         4
41 42 43 44 45

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

46 47 48 49 50 51 52 53 54 55
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);
}

L
Linus Torvalds 已提交
56
struct free_area {
57
	struct list_head	free_list[MIGRATE_TYPES];
L
Linus Torvalds 已提交
58 59 60 61 62 63 64 65 66 67 68 69 70 71
	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];
72
} ____cacheline_internodealigned_in_smp;
L
Linus Torvalds 已提交
73 74 75 76 77
#define ZONE_PADDING(name)	struct zone_padding name;
#else
#define ZONE_PADDING(name)
#endif

78
enum zone_stat_item {
79
	/* First 128 byte cacheline (assuming 64 bit words) */
80
	NR_FREE_PAGES,
81 82
	NR_INACTIVE,
	NR_ACTIVE,
83 84
	NR_ANON_PAGES,	/* Mapped anonymous pages */
	NR_FILE_MAPPED,	/* pagecache pages mapped into pagetables.
85
			   only modified from process context */
86
	NR_FILE_PAGES,
87
	NR_FILE_DIRTY,
88
	NR_WRITEBACK,
89 90 91 92
	/* Second 128 byte cacheline */
	NR_SLAB_RECLAIMABLE,
	NR_SLAB_UNRECLAIMABLE,
	NR_PAGETABLE,		/* used for pagetables */
93
	NR_UNSTABLE_NFS,	/* NFS unstable pages */
94
	NR_BOUNCE,
95
	NR_VMSCAN_WRITE,
96 97 98 99 100 101 102 103
#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
104 105
	NR_VM_ZONE_STAT_ITEMS };

L
Linus Torvalds 已提交
106 107 108 109 110 111 112 113 114
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 {
	struct per_cpu_pages pcp[2];	/* 0: hot.  1: cold */
115 116 117
#ifdef CONFIG_NUMA
	s8 expire;
#endif
118
#ifdef CONFIG_SMP
119
	s8 stat_threshold;
120 121
	s8 vm_stat_diff[NR_VM_ZONE_STAT_ITEMS];
#endif
L
Linus Torvalds 已提交
122 123
} ____cacheline_aligned_in_smp;

124 125 126 127 128 129
#ifdef CONFIG_NUMA
#define zone_pcp(__z, __cpu) ((__z)->pageset[(__cpu)])
#else
#define zone_pcp(__z, __cpu) (&(__z)->pageset[(__cpu)])
#endif

130
enum zone_type {
131
#ifdef CONFIG_ZONE_DMA
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
	/*
	 * 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,
151
#endif
152
#ifdef CONFIG_ZONE_DMA32
153 154 155 156 157 158
	/*
	 * 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,
159
#endif
160 161 162 163 164 165
	/*
	 * 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,
166
#ifdef CONFIG_HIGHMEM
167 168 169 170 171 172 173 174 175
	/*
	 * 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,
176
#endif
M
Mel Gorman 已提交
177
	ZONE_MOVABLE,
178 179
	MAX_NR_ZONES
};
L
Linus Torvalds 已提交
180 181 182 183 184 185

/*
 * 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
186
 * match the requested limits. See gfp_zone() in include/linux/gfp.h
L
Linus Torvalds 已提交
187
 */
188

189 190 191 192 193 194 195 196 197 198
/*
 * Count the active zones.  Note that the use of defined(X) outside
 * #if and family is not necessarily defined so ensure we cannot use
 * it later.  Use __ZONE_COUNT to work out how many shift bits we need.
 */
#define __ZONE_COUNT (			\
	  defined(CONFIG_ZONE_DMA)	\
	+ defined(CONFIG_ZONE_DMA32)	\
	+ 1				\
	+ defined(CONFIG_HIGHMEM)	\
M
Mel Gorman 已提交
199
	+ 1				\
200 201 202 203
)
#if __ZONE_COUNT < 2
#define ZONES_SHIFT 0
#elif __ZONE_COUNT <= 2
204
#define ZONES_SHIFT 1
205
#elif __ZONE_COUNT <= 4
206
#define ZONES_SHIFT 2
207 208
#else
#error ZONES_SHIFT -- too many zones configured adjust calculation
209
#endif
210
#undef __ZONE_COUNT
L
Linus Torvalds 已提交
211 212 213 214 215 216 217 218 219 220 221 222 223 224

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

225
#ifdef CONFIG_NUMA
226
	int node;
227 228 229
	/*
	 * zone reclaim becomes active if more unmapped pages exist.
	 */
230
	unsigned long		min_unmapped_pages;
231
	unsigned long		min_slab_pages;
232 233
	struct per_cpu_pageset	*pageset[NR_CPUS];
#else
L
Linus Torvalds 已提交
234
	struct per_cpu_pageset	pageset[NR_CPUS];
235
#endif
L
Linus Torvalds 已提交
236 237 238 239
	/*
	 * free areas of different sizes
	 */
	spinlock_t		lock;
240 241 242 243
#ifdef CONFIG_MEMORY_HOTPLUG
	/* see spanned/present_pages for more description */
	seqlock_t		span_seqlock;
#endif
L
Linus Torvalds 已提交
244 245
	struct free_area	free_area[MAX_ORDER];

246 247
#ifndef CONFIG_SPARSEMEM
	/*
248
	 * Flags for a pageblock_nr_pages block. See pageblock-flags.h.
249 250 251 252 253
	 * In SPARSEMEM, this map is stored in struct mem_section
	 */
	unsigned long		*pageblock_flags;
#endif /* CONFIG_SPARSEMEM */

L
Linus Torvalds 已提交
254 255 256 257 258 259 260 261 262 263 264 265

	ZONE_PADDING(_pad1_)

	/* Fields commonly accessed by the page reclaim scanner */
	spinlock_t		lru_lock;	
	struct list_head	active_list;
	struct list_head	inactive_list;
	unsigned long		nr_scan_active;
	unsigned long		nr_scan_inactive;
	unsigned long		pages_scanned;	   /* since last reclaim */
	int			all_unreclaimable; /* All pages pinned */

266 267
	/* A count of how many reclaimers are scanning this zone */
	atomic_t		reclaim_in_progress;
M
Martin Hicks 已提交
268

269 270
	/* Zone statistics */
	atomic_long_t		vm_stat[NR_VM_ZONE_STAT_ITEMS];
271

L
Linus Torvalds 已提交
272 273 274 275 276 277 278 279 280 281
	/*
	 * 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.
	 *
282
	 * Access to both this field is quite racy even on uniprocessor.  But
L
Linus Torvalds 已提交
283 284 285 286 287 288 289 290 291 292
	 * 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
293
	 * wait_table_hash_nr_entries	-- the size of the hash table array
L
Linus Torvalds 已提交
294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
	 * 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;
316
	unsigned long		wait_table_hash_nr_entries;
L
Linus Torvalds 已提交
317 318 319 320 321 322 323 324 325
	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;

326 327 328 329 330 331 332 333 334 335
	/*
	 * 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.
	 */
L
Linus Torvalds 已提交
336 337 338 339 340 341
	unsigned long		spanned_pages;	/* total size, including holes */
	unsigned long		present_pages;	/* amount of memory (excluding holes) */

	/*
	 * rarely used fields:
	 */
342
	const char		*name;
343
} ____cacheline_internodealigned_in_smp;
L
Linus Torvalds 已提交
344 345 346 347 348 349 350 351

/*
 * 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

352 353 354 355
/* Maximum number of zones on a zonelist */
#define MAX_ZONES_PER_ZONELIST (MAX_NUMNODES * MAX_NR_ZONES)

#ifdef CONFIG_NUMA
356 357 358 359 360 361 362 363 364 365 366

/*
 * The NUMA zonelists are doubled becausse we need zonelists that restrict the
 * allocations to a single node for GFP_THISNODE.
 *
 * [0 .. MAX_NR_ZONES -1] 		: Zonelists with fallback
 * [MAZ_NR_ZONES ... MAZ_ZONELISTS -1]  : No fallback (GFP_THISNODE)
 */
#define MAX_ZONELISTS (2 * MAX_NR_ZONES)


367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427
/*
 * 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 */
428
	DECLARE_BITMAP(fullzones, MAX_ZONES_PER_ZONELIST);	/* zone full? */
429 430 431
	unsigned long last_full_zap;		/* when last zap'd (jiffies) */
};
#else
432
#define MAX_ZONELISTS MAX_NR_ZONES
433 434 435
struct zonelist_cache;
#endif

L
Linus Torvalds 已提交
436 437 438 439 440 441
/*
 * 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.
 *
442 443
 * 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.
L
Linus Torvalds 已提交
444
 */
445

L
Linus Torvalds 已提交
446
struct zonelist {
447 448 449 450 451
	struct zonelist_cache *zlcache_ptr;		     // NULL or &zlcache
	struct zone *zones[MAX_ZONES_PER_ZONELIST + 1];      // NULL delimited
#ifdef CONFIG_NUMA
	struct zonelist_cache zlcache;			     // optional ...
#endif
L
Linus Torvalds 已提交
452 453
};

454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471
#ifdef CONFIG_NUMA
/*
 * Only custom zonelists like MPOL_BIND need to be filtered as part of
 * policies. As described in the comment for struct zonelist_cache, these
 * zonelists will not have a zlcache so zlcache_ptr will not be set. Use
 * that to determine if the zonelists needs to be filtered or not.
 */
static inline int alloc_should_filter_zonelist(struct zonelist *zonelist)
{
	return !zonelist->zlcache_ptr;
}
#else
static inline int alloc_should_filter_zonelist(struct zonelist *zonelist)
{
	return 0;
}
#endif /* CONFIG_NUMA */

472 473 474 475 476 477 478
#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 */
L
Linus Torvalds 已提交
479

480 481 482 483 484
#ifndef CONFIG_DISCONTIGMEM
/* The array of struct pages - for discontigmem use pgdat->lmem_map */
extern struct page *mem_map;
#endif

L
Linus Torvalds 已提交
485 486 487 488 489 490 491 492 493 494 495 496 497 498
/*
 * 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];
499
	struct zonelist node_zonelists[MAX_ZONELISTS];
L
Linus Torvalds 已提交
500
	int nr_zones;
A
Andy Whitcroft 已提交
501
#ifdef CONFIG_FLAT_NODE_MEM_MAP
L
Linus Torvalds 已提交
502
	struct page *node_mem_map;
A
Andy Whitcroft 已提交
503
#endif
L
Linus Torvalds 已提交
504
	struct bootmem_data *bdata;
505 506 507 508 509 510 511 512 513 514
#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
L
Linus Torvalds 已提交
515 516 517 518 519 520 521 522 523 524 525 526
	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)
A
Andy Whitcroft 已提交
527
#ifdef CONFIG_FLAT_NODE_MEM_MAP
528
#define pgdat_page_nr(pgdat, pagenr)	((pgdat)->node_mem_map + (pagenr))
A
Andy Whitcroft 已提交
529 530 531
#else
#define pgdat_page_nr(pgdat, pagenr)	pfn_to_page((pgdat)->node_start_pfn + (pagenr))
#endif
532
#define nid_page_nr(nid, pagenr) 	pgdat_page_nr(NODE_DATA(nid),(pagenr))
L
Linus Torvalds 已提交
533

534 535
#include <linux/memory_hotplug.h>

L
Linus Torvalds 已提交
536 537 538 539 540
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,
R
Rohit Seth 已提交
541
		int classzone_idx, int alloc_flags);
D
Dave Hansen 已提交
542 543 544 545
enum memmap_context {
	MEMMAP_EARLY,
	MEMMAP_HOTPLUG,
};
546
extern int init_currently_empty_zone(struct zone *zone, unsigned long start_pfn,
D
Dave Hansen 已提交
547 548
				     unsigned long size,
				     enum memmap_context context);
549

L
Linus Torvalds 已提交
550 551 552 553 554 555 556 557 558 559 560 561 562 563 564
#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)

565 566 567 568 569
static inline int populated_zone(struct zone *zone)
{
	return (!!zone->present_pages);
}

M
Mel Gorman 已提交
570 571 572 573 574 575 576 577 578 579 580
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
}

581
static inline int is_highmem_idx(enum zone_type idx)
L
Linus Torvalds 已提交
582
{
583
#ifdef CONFIG_HIGHMEM
M
Mel Gorman 已提交
584 585
	return (idx == ZONE_HIGHMEM ||
		(idx == ZONE_MOVABLE && zone_movable_is_highmem()));
586 587 588
#else
	return 0;
#endif
L
Linus Torvalds 已提交
589 590
}

591
static inline int is_normal_idx(enum zone_type idx)
L
Linus Torvalds 已提交
592 593 594
{
	return (idx == ZONE_NORMAL);
}
N
Nick Piggin 已提交
595

L
Linus Torvalds 已提交
596 597 598 599 600 601 602 603
/**
 * 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)
{
604
#ifdef CONFIG_HIGHMEM
M
Mel Gorman 已提交
605 606 607
	int zone_idx = zone - zone->zone_pgdat->node_zones;
	return zone_idx == ZONE_HIGHMEM ||
		(zone_idx == ZONE_MOVABLE && zone_movable_is_highmem());
608 609 610
#else
	return 0;
#endif
L
Linus Torvalds 已提交
611 612 613 614 615 616 617
}

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

N
Nick Piggin 已提交
618 619
static inline int is_dma32(struct zone *zone)
{
620
#ifdef CONFIG_ZONE_DMA32
N
Nick Piggin 已提交
621
	return zone == zone->zone_pgdat->node_zones + ZONE_DMA32;
622 623 624
#else
	return 0;
#endif
N
Nick Piggin 已提交
625 626 627 628
}

static inline int is_dma(struct zone *zone)
{
629
#ifdef CONFIG_ZONE_DMA
N
Nick Piggin 已提交
630
	return zone == zone->zone_pgdat->node_zones + ZONE_DMA;
631 632 633
#else
	return 0;
#endif
N
Nick Piggin 已提交
634 635
}

L
Linus Torvalds 已提交
636 637 638 639 640 641 642 643
/* 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 *);
644 645
int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *, int, struct file *,
					void __user *, size_t *, loff_t *);
646 647
int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *, int,
			struct file *, void __user *, size_t *, loff_t *);
648 649
int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *, int,
			struct file *, void __user *, size_t *, loff_t *);
L
Linus Torvalds 已提交
650

651 652 653 654 655
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 */

L
Linus Torvalds 已提交
656 657
#include <linux/topology.h>
/* Returns the number of the current Node. */
658
#ifndef numa_node_id
I
Ingo Molnar 已提交
659
#define numa_node_id()		(cpu_to_node(raw_smp_processor_id()))
660
#endif
L
Linus Torvalds 已提交
661

662
#ifndef CONFIG_NEED_MULTIPLE_NODES
L
Linus Torvalds 已提交
663 664 665 666 667 668

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

669
#else /* CONFIG_NEED_MULTIPLE_NODES */
L
Linus Torvalds 已提交
670 671 672

#include <asm/mmzone.h>

673
#endif /* !CONFIG_NEED_MULTIPLE_NODES */
674

675 676 677
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);
678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698

/**
 * for_each_pgdat - helper macro to iterate over all nodes
 * @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))

A
Andy Whitcroft 已提交
699 700 701 702
#ifdef CONFIG_SPARSEMEM
#include <asm/sparsemem.h>
#endif

703
#if BITS_PER_LONG == 32
L
Linus Torvalds 已提交
704
/*
A
Andi Kleen 已提交
705 706
 * with 32 bit page->flags field, we reserve 9 bits for node/zone info.
 * there are 4 zones (3 bits) and this leaves 9-3=6 bits for nodes.
L
Linus Torvalds 已提交
707
 */
A
Andi Kleen 已提交
708
#define FLAGS_RESERVED		9
709

L
Linus Torvalds 已提交
710 711 712 713
#elif BITS_PER_LONG == 64
/*
 * with 64 bit flags field, there's plenty of room.
 */
714
#define FLAGS_RESERVED		32
L
Linus Torvalds 已提交
715

716
#else
L
Linus Torvalds 已提交
717

718
#error BITS_PER_LONG not defined
L
Linus Torvalds 已提交
719 720 721

#endif

722 723
#if !defined(CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID) && \
	!defined(CONFIG_ARCH_POPULATES_NODE_MAP)
724 725 726
#define early_pfn_to_nid(nid)  (0UL)
#endif

727 728 729 730
#ifdef CONFIG_FLATMEM
#define pfn_to_nid(pfn)		(0)
#endif

A
Andy Whitcroft 已提交
731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751
#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))

752
#define SECTION_BLOCKFLAGS_BITS \
753
	((1UL << (PFN_SECTION_SHIFT - pageblock_order)) * NR_PAGEBLOCK_BITS)
754

A
Andy Whitcroft 已提交
755 756 757 758 759 760
#if (MAX_ORDER - 1 + PAGE_SHIFT) > SECTION_SIZE_BITS
#error Allocator MAX_ORDER exceeds SECTION_SIZE
#endif

struct page;
struct mem_section {
A
Andy Whitcroft 已提交
761 762 763 764 765
	/*
	 * 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())
	 *
766 767 768 769
	 * Additionally during early boot we encode node id of
	 * the location of the section here to guide allocation.
	 * (see sparse.c::memory_present())
	 *
A
Andy Whitcroft 已提交
770 771 772 773
	 * Making it a UL at least makes someone do a cast
	 * before using it wrong.
	 */
	unsigned long section_mem_map;
774 775 776

	/* See declaration of similar field in struct zone */
	unsigned long *pageblock_flags;
A
Andy Whitcroft 已提交
777 778
};

779 780 781 782 783
#ifdef CONFIG_SPARSEMEM_EXTREME
#define SECTIONS_PER_ROOT       (PAGE_SIZE / sizeof (struct mem_section))
#else
#define SECTIONS_PER_ROOT	1
#endif
B
Bob Picco 已提交
784

785 786 787
#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)
B
Bob Picco 已提交
788

789 790
#ifdef CONFIG_SPARSEMEM_EXTREME
extern struct mem_section *mem_section[NR_SECTION_ROOTS];
B
Bob Picco 已提交
791
#else
792 793
extern struct mem_section mem_section[NR_SECTION_ROOTS][SECTIONS_PER_ROOT];
#endif
A
Andy Whitcroft 已提交
794

A
Andy Whitcroft 已提交
795 796
static inline struct mem_section *__nr_to_section(unsigned long nr)
{
797 798 799
	if (!mem_section[SECTION_NR_TO_ROOT(nr)])
		return NULL;
	return &mem_section[SECTION_NR_TO_ROOT(nr)][nr & SECTION_ROOT_MASK];
A
Andy Whitcroft 已提交
800
}
801
extern int __section_nr(struct mem_section* ms);
A
Andy Whitcroft 已提交
802 803 804 805 806 807 808 809 810 811

/*
 * 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))
812
#define SECTION_NID_SHIFT	2
A
Andy Whitcroft 已提交
813 814 815 816 817 818 819 820

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

821
static inline int present_section(struct mem_section *section)
A
Andy Whitcroft 已提交
822
{
B
Bob Picco 已提交
823
	return (section && (section->section_mem_map & SECTION_MARKED_PRESENT));
A
Andy Whitcroft 已提交
824 825
}

826 827 828 829 830 831
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)
A
Andy Whitcroft 已提交
832
{
B
Bob Picco 已提交
833
	return (section && (section->section_mem_map & SECTION_HAS_MEM_MAP));
A
Andy Whitcroft 已提交
834 835 836 837 838 839 840
}

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

A
Andy Whitcroft 已提交
841 842
static inline struct mem_section *__pfn_to_section(unsigned long pfn)
{
A
Andy Whitcroft 已提交
843
	return __nr_to_section(pfn_to_section_nr(pfn));
A
Andy Whitcroft 已提交
844 845 846 847 848 849
}

static inline int pfn_valid(unsigned long pfn)
{
	if (pfn_to_section_nr(pfn) >= NR_MEM_SECTIONS)
		return 0;
A
Andy Whitcroft 已提交
850
	return valid_section(__nr_to_section(pfn_to_section_nr(pfn)));
A
Andy Whitcroft 已提交
851 852
}

853 854 855 856 857 858 859
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)));
}

A
Andy Whitcroft 已提交
860 861 862 863 864 865
/*
 * These are _only_ used during initialisation, therefore they
 * can use __initdata ...  They could have names to indicate
 * this restriction.
 */
#ifdef CONFIG_NUMA
866 867 868 869 870
#define pfn_to_nid(pfn)							\
({									\
	unsigned long __pfn_to_nid_pfn = (pfn);				\
	page_to_nid(pfn_to_page(__pfn_to_nid_pfn));			\
})
871 872
#else
#define pfn_to_nid(pfn)		(0)
A
Andy Whitcroft 已提交
873 874 875 876 877 878
#endif

#define early_pfn_valid(pfn)	pfn_valid(pfn)
void sparse_init(void);
#else
#define sparse_init()	do {} while (0)
879
#define sparse_index_init(_sec, _nid)  do {} while (0)
A
Andy Whitcroft 已提交
880 881
#endif /* CONFIG_SPARSEMEM */

882 883 884 885 886 887
#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

A
Andy Whitcroft 已提交
888 889 890 891 892 893 894
#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);

895 896 897 898 899 900 901 902 903 904 905 906
/*
 * 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

L
Linus Torvalds 已提交
907 908 909
#endif /* !__ASSEMBLY__ */
#endif /* __KERNEL__ */
#endif /* _LINUX_MMZONE_H */