mm: workingset: tell cache transitions from workingset thrashing
[muen/linux.git] / include / linux / mmzone.h
1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef _LINUX_MMZONE_H
3 #define _LINUX_MMZONE_H
4
5 #ifndef __ASSEMBLY__
6 #ifndef __GENERATING_BOUNDS_H
7
8 #include <linux/spinlock.h>
9 #include <linux/list.h>
10 #include <linux/wait.h>
11 #include <linux/bitops.h>
12 #include <linux/cache.h>
13 #include <linux/threads.h>
14 #include <linux/numa.h>
15 #include <linux/init.h>
16 #include <linux/seqlock.h>
17 #include <linux/nodemask.h>
18 #include <linux/pageblock-flags.h>
19 #include <linux/page-flags-layout.h>
20 #include <linux/atomic.h>
21 #include <asm/page.h>
22
23 /* Free memory management - zoned buddy allocator.  */
24 #ifndef CONFIG_FORCE_MAX_ZONEORDER
25 #define MAX_ORDER 11
26 #else
27 #define MAX_ORDER CONFIG_FORCE_MAX_ZONEORDER
28 #endif
29 #define MAX_ORDER_NR_PAGES (1 << (MAX_ORDER - 1))
30
31 /*
32  * PAGE_ALLOC_COSTLY_ORDER is the order at which allocations are deemed
33  * costly to service.  That is between allocation orders which should
34  * coalesce naturally under reasonable reclaim pressure and those which
35  * will not.
36  */
37 #define PAGE_ALLOC_COSTLY_ORDER 3
38
39 enum migratetype {
40         MIGRATE_UNMOVABLE,
41         MIGRATE_MOVABLE,
42         MIGRATE_RECLAIMABLE,
43         MIGRATE_PCPTYPES,       /* the number of types on the pcp lists */
44         MIGRATE_HIGHATOMIC = MIGRATE_PCPTYPES,
45 #ifdef CONFIG_CMA
46         /*
47          * MIGRATE_CMA migration type is designed to mimic the way
48          * ZONE_MOVABLE works.  Only movable pages can be allocated
49          * from MIGRATE_CMA pageblocks and page allocator never
50          * implicitly change migration type of MIGRATE_CMA pageblock.
51          *
52          * The way to use it is to change migratetype of a range of
53          * pageblocks to MIGRATE_CMA which can be done by
54          * __free_pageblock_cma() function.  What is important though
55          * is that a range of pageblocks must be aligned to
56          * MAX_ORDER_NR_PAGES should biggest page be bigger then
57          * a single pageblock.
58          */
59         MIGRATE_CMA,
60 #endif
61 #ifdef CONFIG_MEMORY_ISOLATION
62         MIGRATE_ISOLATE,        /* can't allocate from here */
63 #endif
64         MIGRATE_TYPES
65 };
66
67 /* In mm/page_alloc.c; keep in sync also with show_migration_types() there */
68 extern char * const migratetype_names[MIGRATE_TYPES];
69
70 #ifdef CONFIG_CMA
71 #  define is_migrate_cma(migratetype) unlikely((migratetype) == MIGRATE_CMA)
72 #  define is_migrate_cma_page(_page) (get_pageblock_migratetype(_page) == MIGRATE_CMA)
73 #else
74 #  define is_migrate_cma(migratetype) false
75 #  define is_migrate_cma_page(_page) false
76 #endif
77
78 static inline bool is_migrate_movable(int mt)
79 {
80         return is_migrate_cma(mt) || mt == MIGRATE_MOVABLE;
81 }
82
83 #define for_each_migratetype_order(order, type) \
84         for (order = 0; order < MAX_ORDER; order++) \
85                 for (type = 0; type < MIGRATE_TYPES; type++)
86
87 extern int page_group_by_mobility_disabled;
88
89 #define NR_MIGRATETYPE_BITS (PB_migrate_end - PB_migrate + 1)
90 #define MIGRATETYPE_MASK ((1UL << NR_MIGRATETYPE_BITS) - 1)
91
92 #define get_pageblock_migratetype(page)                                 \
93         get_pfnblock_flags_mask(page, page_to_pfn(page),                \
94                         PB_migrate_end, MIGRATETYPE_MASK)
95
96 struct free_area {
97         struct list_head        free_list[MIGRATE_TYPES];
98         unsigned long           nr_free;
99 };
100
101 struct pglist_data;
102
103 /*
104  * zone->lock and the zone lru_lock are two of the hottest locks in the kernel.
105  * So add a wild amount of padding here to ensure that they fall into separate
106  * cachelines.  There are very few zone structures in the machine, so space
107  * consumption is not a concern here.
108  */
109 #if defined(CONFIG_SMP)
110 struct zone_padding {
111         char x[0];
112 } ____cacheline_internodealigned_in_smp;
113 #define ZONE_PADDING(name)      struct zone_padding name;
114 #else
115 #define ZONE_PADDING(name)
116 #endif
117
118 #ifdef CONFIG_NUMA
119 enum numa_stat_item {
120         NUMA_HIT,               /* allocated in intended node */
121         NUMA_MISS,              /* allocated in non intended node */
122         NUMA_FOREIGN,           /* was intended here, hit elsewhere */
123         NUMA_INTERLEAVE_HIT,    /* interleaver preferred this zone */
124         NUMA_LOCAL,             /* allocation from local node */
125         NUMA_OTHER,             /* allocation from other node */
126         NR_VM_NUMA_STAT_ITEMS
127 };
128 #else
129 #define NR_VM_NUMA_STAT_ITEMS 0
130 #endif
131
132 enum zone_stat_item {
133         /* First 128 byte cacheline (assuming 64 bit words) */
134         NR_FREE_PAGES,
135         NR_ZONE_LRU_BASE, /* Used only for compaction and reclaim retry */
136         NR_ZONE_INACTIVE_ANON = NR_ZONE_LRU_BASE,
137         NR_ZONE_ACTIVE_ANON,
138         NR_ZONE_INACTIVE_FILE,
139         NR_ZONE_ACTIVE_FILE,
140         NR_ZONE_UNEVICTABLE,
141         NR_ZONE_WRITE_PENDING,  /* Count of dirty, writeback and unstable pages */
142         NR_MLOCK,               /* mlock()ed pages found and moved off LRU */
143         NR_PAGETABLE,           /* used for pagetables */
144         NR_KERNEL_STACK_KB,     /* measured in KiB */
145         /* Second 128 byte cacheline */
146         NR_BOUNCE,
147 #if IS_ENABLED(CONFIG_ZSMALLOC)
148         NR_ZSPAGES,             /* allocated in zsmalloc */
149 #endif
150         NR_FREE_CMA_PAGES,
151         NR_VM_ZONE_STAT_ITEMS };
152
153 enum node_stat_item {
154         NR_LRU_BASE,
155         NR_INACTIVE_ANON = NR_LRU_BASE, /* must match order of LRU_[IN]ACTIVE */
156         NR_ACTIVE_ANON,         /*  "     "     "   "       "         */
157         NR_INACTIVE_FILE,       /*  "     "     "   "       "         */
158         NR_ACTIVE_FILE,         /*  "     "     "   "       "         */
159         NR_UNEVICTABLE,         /*  "     "     "   "       "         */
160         NR_SLAB_RECLAIMABLE,
161         NR_SLAB_UNRECLAIMABLE,
162         NR_ISOLATED_ANON,       /* Temporary isolated pages from anon lru */
163         NR_ISOLATED_FILE,       /* Temporary isolated pages from file lru */
164         WORKINGSET_REFAULT,
165         WORKINGSET_ACTIVATE,
166         WORKINGSET_RESTORE,
167         WORKINGSET_NODERECLAIM,
168         NR_ANON_MAPPED, /* Mapped anonymous pages */
169         NR_FILE_MAPPED, /* pagecache pages mapped into pagetables.
170                            only modified from process context */
171         NR_FILE_PAGES,
172         NR_FILE_DIRTY,
173         NR_WRITEBACK,
174         NR_WRITEBACK_TEMP,      /* Writeback using temporary buffers */
175         NR_SHMEM,               /* shmem pages (included tmpfs/GEM pages) */
176         NR_SHMEM_THPS,
177         NR_SHMEM_PMDMAPPED,
178         NR_ANON_THPS,
179         NR_UNSTABLE_NFS,        /* NFS unstable pages */
180         NR_VMSCAN_WRITE,
181         NR_VMSCAN_IMMEDIATE,    /* Prioritise for reclaim when writeback ends */
182         NR_DIRTIED,             /* page dirtyings since bootup */
183         NR_WRITTEN,             /* page writings since bootup */
184         NR_KERNEL_MISC_RECLAIMABLE,     /* reclaimable non-slab kernel pages */
185         NR_VM_NODE_STAT_ITEMS
186 };
187
188 /*
189  * We do arithmetic on the LRU lists in various places in the code,
190  * so it is important to keep the active lists LRU_ACTIVE higher in
191  * the array than the corresponding inactive lists, and to keep
192  * the *_FILE lists LRU_FILE higher than the corresponding _ANON lists.
193  *
194  * This has to be kept in sync with the statistics in zone_stat_item
195  * above and the descriptions in vmstat_text in mm/vmstat.c
196  */
197 #define LRU_BASE 0
198 #define LRU_ACTIVE 1
199 #define LRU_FILE 2
200
201 enum lru_list {
202         LRU_INACTIVE_ANON = LRU_BASE,
203         LRU_ACTIVE_ANON = LRU_BASE + LRU_ACTIVE,
204         LRU_INACTIVE_FILE = LRU_BASE + LRU_FILE,
205         LRU_ACTIVE_FILE = LRU_BASE + LRU_FILE + LRU_ACTIVE,
206         LRU_UNEVICTABLE,
207         NR_LRU_LISTS
208 };
209
210 #define for_each_lru(lru) for (lru = 0; lru < NR_LRU_LISTS; lru++)
211
212 #define for_each_evictable_lru(lru) for (lru = 0; lru <= LRU_ACTIVE_FILE; lru++)
213
214 static inline int is_file_lru(enum lru_list lru)
215 {
216         return (lru == LRU_INACTIVE_FILE || lru == LRU_ACTIVE_FILE);
217 }
218
219 static inline int is_active_lru(enum lru_list lru)
220 {
221         return (lru == LRU_ACTIVE_ANON || lru == LRU_ACTIVE_FILE);
222 }
223
224 struct zone_reclaim_stat {
225         /*
226          * The pageout code in vmscan.c keeps track of how many of the
227          * mem/swap backed and file backed pages are referenced.
228          * The higher the rotated/scanned ratio, the more valuable
229          * that cache is.
230          *
231          * The anon LRU stats live in [0], file LRU stats in [1]
232          */
233         unsigned long           recent_rotated[2];
234         unsigned long           recent_scanned[2];
235 };
236
237 struct lruvec {
238         struct list_head                lists[NR_LRU_LISTS];
239         struct zone_reclaim_stat        reclaim_stat;
240         /* Evictions & activations on the inactive file list */
241         atomic_long_t                   inactive_age;
242         /* Refaults at the time of last reclaim cycle */
243         unsigned long                   refaults;
244 #ifdef CONFIG_MEMCG
245         struct pglist_data *pgdat;
246 #endif
247 };
248
249 /* Mask used at gathering information at once (see memcontrol.c) */
250 #define LRU_ALL_FILE (BIT(LRU_INACTIVE_FILE) | BIT(LRU_ACTIVE_FILE))
251 #define LRU_ALL_ANON (BIT(LRU_INACTIVE_ANON) | BIT(LRU_ACTIVE_ANON))
252 #define LRU_ALL      ((1 << NR_LRU_LISTS) - 1)
253
254 /* Isolate unmapped file */
255 #define ISOLATE_UNMAPPED        ((__force isolate_mode_t)0x2)
256 /* Isolate for asynchronous migration */
257 #define ISOLATE_ASYNC_MIGRATE   ((__force isolate_mode_t)0x4)
258 /* Isolate unevictable pages */
259 #define ISOLATE_UNEVICTABLE     ((__force isolate_mode_t)0x8)
260
261 /* LRU Isolation modes. */
262 typedef unsigned __bitwise isolate_mode_t;
263
264 enum zone_watermarks {
265         WMARK_MIN,
266         WMARK_LOW,
267         WMARK_HIGH,
268         NR_WMARK
269 };
270
271 #define min_wmark_pages(z) (z->watermark[WMARK_MIN])
272 #define low_wmark_pages(z) (z->watermark[WMARK_LOW])
273 #define high_wmark_pages(z) (z->watermark[WMARK_HIGH])
274
275 struct per_cpu_pages {
276         int count;              /* number of pages in the list */
277         int high;               /* high watermark, emptying needed */
278         int batch;              /* chunk size for buddy add/remove */
279
280         /* Lists of pages, one per migrate type stored on the pcp-lists */
281         struct list_head lists[MIGRATE_PCPTYPES];
282 };
283
284 struct per_cpu_pageset {
285         struct per_cpu_pages pcp;
286 #ifdef CONFIG_NUMA
287         s8 expire;
288         u16 vm_numa_stat_diff[NR_VM_NUMA_STAT_ITEMS];
289 #endif
290 #ifdef CONFIG_SMP
291         s8 stat_threshold;
292         s8 vm_stat_diff[NR_VM_ZONE_STAT_ITEMS];
293 #endif
294 };
295
296 struct per_cpu_nodestat {
297         s8 stat_threshold;
298         s8 vm_node_stat_diff[NR_VM_NODE_STAT_ITEMS];
299 };
300
301 #endif /* !__GENERATING_BOUNDS.H */
302
303 enum zone_type {
304 #ifdef CONFIG_ZONE_DMA
305         /*
306          * ZONE_DMA is used when there are devices that are not able
307          * to do DMA to all of addressable memory (ZONE_NORMAL). Then we
308          * carve out the portion of memory that is needed for these devices.
309          * The range is arch specific.
310          *
311          * Some examples
312          *
313          * Architecture         Limit
314          * ---------------------------
315          * parisc, ia64, sparc  <4G
316          * s390                 <2G
317          * arm                  Various
318          * alpha                Unlimited or 0-16MB.
319          *
320          * i386, x86_64 and multiple other arches
321          *                      <16M.
322          */
323         ZONE_DMA,
324 #endif
325 #ifdef CONFIG_ZONE_DMA32
326         /*
327          * x86_64 needs two ZONE_DMAs because it supports devices that are
328          * only able to do DMA to the lower 16M but also 32 bit devices that
329          * can only do DMA areas below 4G.
330          */
331         ZONE_DMA32,
332 #endif
333         /*
334          * Normal addressable memory is in ZONE_NORMAL. DMA operations can be
335          * performed on pages in ZONE_NORMAL if the DMA devices support
336          * transfers to all addressable memory.
337          */
338         ZONE_NORMAL,
339 #ifdef CONFIG_HIGHMEM
340         /*
341          * A memory area that is only addressable by the kernel through
342          * mapping portions into its own address space. This is for example
343          * used by i386 to allow the kernel to address the memory beyond
344          * 900MB. The kernel will set up special mappings (page
345          * table entries on i386) for each page that the kernel needs to
346          * access.
347          */
348         ZONE_HIGHMEM,
349 #endif
350         ZONE_MOVABLE,
351 #ifdef CONFIG_ZONE_DEVICE
352         ZONE_DEVICE,
353 #endif
354         __MAX_NR_ZONES
355
356 };
357
358 #ifndef __GENERATING_BOUNDS_H
359
360 struct zone {
361         /* Read-mostly fields */
362
363         /* zone watermarks, access with *_wmark_pages(zone) macros */
364         unsigned long watermark[NR_WMARK];
365
366         unsigned long nr_reserved_highatomic;
367
368         /*
369          * We don't know if the memory that we're going to allocate will be
370          * freeable or/and it will be released eventually, so to avoid totally
371          * wasting several GB of ram we must reserve some of the lower zone
372          * memory (otherwise we risk to run OOM on the lower zones despite
373          * there being tons of freeable ram on the higher zones).  This array is
374          * recalculated at runtime if the sysctl_lowmem_reserve_ratio sysctl
375          * changes.
376          */
377         long lowmem_reserve[MAX_NR_ZONES];
378
379 #ifdef CONFIG_NUMA
380         int node;
381 #endif
382         struct pglist_data      *zone_pgdat;
383         struct per_cpu_pageset __percpu *pageset;
384
385 #ifndef CONFIG_SPARSEMEM
386         /*
387          * Flags for a pageblock_nr_pages block. See pageblock-flags.h.
388          * In SPARSEMEM, this map is stored in struct mem_section
389          */
390         unsigned long           *pageblock_flags;
391 #endif /* CONFIG_SPARSEMEM */
392
393         /* zone_start_pfn == zone_start_paddr >> PAGE_SHIFT */
394         unsigned long           zone_start_pfn;
395
396         /*
397          * spanned_pages is the total pages spanned by the zone, including
398          * holes, which is calculated as:
399          *      spanned_pages = zone_end_pfn - zone_start_pfn;
400          *
401          * present_pages is physical pages existing within the zone, which
402          * is calculated as:
403          *      present_pages = spanned_pages - absent_pages(pages in holes);
404          *
405          * managed_pages is present pages managed by the buddy system, which
406          * is calculated as (reserved_pages includes pages allocated by the
407          * bootmem allocator):
408          *      managed_pages = present_pages - reserved_pages;
409          *
410          * So present_pages may be used by memory hotplug or memory power
411          * management logic to figure out unmanaged pages by checking
412          * (present_pages - managed_pages). And managed_pages should be used
413          * by page allocator and vm scanner to calculate all kinds of watermarks
414          * and thresholds.
415          *
416          * Locking rules:
417          *
418          * zone_start_pfn and spanned_pages are protected by span_seqlock.
419          * It is a seqlock because it has to be read outside of zone->lock,
420          * and it is done in the main allocator path.  But, it is written
421          * quite infrequently.
422          *
423          * The span_seq lock is declared along with zone->lock because it is
424          * frequently read in proximity to zone->lock.  It's good to
425          * give them a chance of being in the same cacheline.
426          *
427          * Write access to present_pages at runtime should be protected by
428          * mem_hotplug_begin/end(). Any reader who can't tolerant drift of
429          * present_pages should get_online_mems() to get a stable value.
430          *
431          * Read access to managed_pages should be safe because it's unsigned
432          * long. Write access to zone->managed_pages and totalram_pages are
433          * protected by managed_page_count_lock at runtime. Idealy only
434          * adjust_managed_page_count() should be used instead of directly
435          * touching zone->managed_pages and totalram_pages.
436          */
437         unsigned long           managed_pages;
438         unsigned long           spanned_pages;
439         unsigned long           present_pages;
440
441         const char              *name;
442
443 #ifdef CONFIG_MEMORY_ISOLATION
444         /*
445          * Number of isolated pageblock. It is used to solve incorrect
446          * freepage counting problem due to racy retrieving migratetype
447          * of pageblock. Protected by zone->lock.
448          */
449         unsigned long           nr_isolate_pageblock;
450 #endif
451
452 #ifdef CONFIG_MEMORY_HOTPLUG
453         /* see spanned/present_pages for more description */
454         seqlock_t               span_seqlock;
455 #endif
456
457         int initialized;
458
459         /* Write-intensive fields used from the page allocator */
460         ZONE_PADDING(_pad1_)
461
462         /* free areas of different sizes */
463         struct free_area        free_area[MAX_ORDER];
464
465         /* zone flags, see below */
466         unsigned long           flags;
467
468         /* Primarily protects free_area */
469         spinlock_t              lock;
470
471         /* Write-intensive fields used by compaction and vmstats. */
472         ZONE_PADDING(_pad2_)
473
474         /*
475          * When free pages are below this point, additional steps are taken
476          * when reading the number of free pages to avoid per-cpu counter
477          * drift allowing watermarks to be breached
478          */
479         unsigned long percpu_drift_mark;
480
481 #if defined CONFIG_COMPACTION || defined CONFIG_CMA
482         /* pfn where compaction free scanner should start */
483         unsigned long           compact_cached_free_pfn;
484         /* pfn where async and sync compaction migration scanner should start */
485         unsigned long           compact_cached_migrate_pfn[2];
486 #endif
487
488 #ifdef CONFIG_COMPACTION
489         /*
490          * On compaction failure, 1<<compact_defer_shift compactions
491          * are skipped before trying again. The number attempted since
492          * last failure is tracked with compact_considered.
493          */
494         unsigned int            compact_considered;
495         unsigned int            compact_defer_shift;
496         int                     compact_order_failed;
497 #endif
498
499 #if defined CONFIG_COMPACTION || defined CONFIG_CMA
500         /* Set to true when the PG_migrate_skip bits should be cleared */
501         bool                    compact_blockskip_flush;
502 #endif
503
504         bool                    contiguous;
505
506         ZONE_PADDING(_pad3_)
507         /* Zone statistics */
508         atomic_long_t           vm_stat[NR_VM_ZONE_STAT_ITEMS];
509         atomic_long_t           vm_numa_stat[NR_VM_NUMA_STAT_ITEMS];
510 } ____cacheline_internodealigned_in_smp;
511
512 enum pgdat_flags {
513         PGDAT_CONGESTED,                /* pgdat has many dirty pages backed by
514                                          * a congested BDI
515                                          */
516         PGDAT_DIRTY,                    /* reclaim scanning has recently found
517                                          * many dirty file pages at the tail
518                                          * of the LRU.
519                                          */
520         PGDAT_WRITEBACK,                /* reclaim scanning has recently found
521                                          * many pages under writeback
522                                          */
523         PGDAT_RECLAIM_LOCKED,           /* prevents concurrent reclaim */
524 };
525
526 static inline unsigned long zone_end_pfn(const struct zone *zone)
527 {
528         return zone->zone_start_pfn + zone->spanned_pages;
529 }
530
531 static inline bool zone_spans_pfn(const struct zone *zone, unsigned long pfn)
532 {
533         return zone->zone_start_pfn <= pfn && pfn < zone_end_pfn(zone);
534 }
535
536 static inline bool zone_is_initialized(struct zone *zone)
537 {
538         return zone->initialized;
539 }
540
541 static inline bool zone_is_empty(struct zone *zone)
542 {
543         return zone->spanned_pages == 0;
544 }
545
546 /*
547  * Return true if [start_pfn, start_pfn + nr_pages) range has a non-empty
548  * intersection with the given zone
549  */
550 static inline bool zone_intersects(struct zone *zone,
551                 unsigned long start_pfn, unsigned long nr_pages)
552 {
553         if (zone_is_empty(zone))
554                 return false;
555         if (start_pfn >= zone_end_pfn(zone) ||
556             start_pfn + nr_pages <= zone->zone_start_pfn)
557                 return false;
558
559         return true;
560 }
561
562 /*
563  * The "priority" of VM scanning is how much of the queues we will scan in one
564  * go. A value of 12 for DEF_PRIORITY implies that we will scan 1/4096th of the
565  * queues ("queue_length >> 12") during an aging round.
566  */
567 #define DEF_PRIORITY 12
568
569 /* Maximum number of zones on a zonelist */
570 #define MAX_ZONES_PER_ZONELIST (MAX_NUMNODES * MAX_NR_ZONES)
571
572 enum {
573         ZONELIST_FALLBACK,      /* zonelist with fallback */
574 #ifdef CONFIG_NUMA
575         /*
576          * The NUMA zonelists are doubled because we need zonelists that
577          * restrict the allocations to a single node for __GFP_THISNODE.
578          */
579         ZONELIST_NOFALLBACK,    /* zonelist without fallback (__GFP_THISNODE) */
580 #endif
581         MAX_ZONELISTS
582 };
583
584 /*
585  * This struct contains information about a zone in a zonelist. It is stored
586  * here to avoid dereferences into large structures and lookups of tables
587  */
588 struct zoneref {
589         struct zone *zone;      /* Pointer to actual zone */
590         int zone_idx;           /* zone_idx(zoneref->zone) */
591 };
592
593 /*
594  * One allocation request operates on a zonelist. A zonelist
595  * is a list of zones, the first one is the 'goal' of the
596  * allocation, the other zones are fallback zones, in decreasing
597  * priority.
598  *
599  * To speed the reading of the zonelist, the zonerefs contain the zone index
600  * of the entry being read. Helper functions to access information given
601  * a struct zoneref are
602  *
603  * zonelist_zone()      - Return the struct zone * for an entry in _zonerefs
604  * zonelist_zone_idx()  - Return the index of the zone for an entry
605  * zonelist_node_idx()  - Return the index of the node for an entry
606  */
607 struct zonelist {
608         struct zoneref _zonerefs[MAX_ZONES_PER_ZONELIST + 1];
609 };
610
611 #ifndef CONFIG_DISCONTIGMEM
612 /* The array of struct pages - for discontigmem use pgdat->lmem_map */
613 extern struct page *mem_map;
614 #endif
615
616 /*
617  * On NUMA machines, each NUMA node would have a pg_data_t to describe
618  * it's memory layout. On UMA machines there is a single pglist_data which
619  * describes the whole memory.
620  *
621  * Memory statistics and page replacement data structures are maintained on a
622  * per-zone basis.
623  */
624 struct bootmem_data;
625 typedef struct pglist_data {
626         struct zone node_zones[MAX_NR_ZONES];
627         struct zonelist node_zonelists[MAX_ZONELISTS];
628         int nr_zones;
629 #ifdef CONFIG_FLAT_NODE_MEM_MAP /* means !SPARSEMEM */
630         struct page *node_mem_map;
631 #ifdef CONFIG_PAGE_EXTENSION
632         struct page_ext *node_page_ext;
633 #endif
634 #endif
635 #ifndef CONFIG_NO_BOOTMEM
636         struct bootmem_data *bdata;
637 #endif
638 #if defined(CONFIG_MEMORY_HOTPLUG) || defined(CONFIG_DEFERRED_STRUCT_PAGE_INIT)
639         /*
640          * Must be held any time you expect node_start_pfn, node_present_pages
641          * or node_spanned_pages stay constant.  Holding this will also
642          * guarantee that any pfn_valid() stays that way.
643          *
644          * pgdat_resize_lock() and pgdat_resize_unlock() are provided to
645          * manipulate node_size_lock without checking for CONFIG_MEMORY_HOTPLUG
646          * or CONFIG_DEFERRED_STRUCT_PAGE_INIT.
647          *
648          * Nests above zone->lock and zone->span_seqlock
649          */
650         spinlock_t node_size_lock;
651 #endif
652         unsigned long node_start_pfn;
653         unsigned long node_present_pages; /* total number of physical pages */
654         unsigned long node_spanned_pages; /* total size of physical page
655                                              range, including holes */
656         int node_id;
657         wait_queue_head_t kswapd_wait;
658         wait_queue_head_t pfmemalloc_wait;
659         struct task_struct *kswapd;     /* Protected by
660                                            mem_hotplug_begin/end() */
661         int kswapd_order;
662         enum zone_type kswapd_classzone_idx;
663
664         int kswapd_failures;            /* Number of 'reclaimed == 0' runs */
665
666 #ifdef CONFIG_COMPACTION
667         int kcompactd_max_order;
668         enum zone_type kcompactd_classzone_idx;
669         wait_queue_head_t kcompactd_wait;
670         struct task_struct *kcompactd;
671 #endif
672         /*
673          * This is a per-node reserve of pages that are not available
674          * to userspace allocations.
675          */
676         unsigned long           totalreserve_pages;
677
678 #ifdef CONFIG_NUMA
679         /*
680          * zone reclaim becomes active if more unmapped pages exist.
681          */
682         unsigned long           min_unmapped_pages;
683         unsigned long           min_slab_pages;
684 #endif /* CONFIG_NUMA */
685
686         /* Write-intensive fields used by page reclaim */
687         ZONE_PADDING(_pad1_)
688         spinlock_t              lru_lock;
689
690 #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
691         /*
692          * If memory initialisation on large machines is deferred then this
693          * is the first PFN that needs to be initialised.
694          */
695         unsigned long first_deferred_pfn;
696         /* Number of non-deferred pages */
697         unsigned long static_init_pgcnt;
698 #endif /* CONFIG_DEFERRED_STRUCT_PAGE_INIT */
699
700 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
701         spinlock_t split_queue_lock;
702         struct list_head split_queue;
703         unsigned long split_queue_len;
704 #endif
705
706         /* Fields commonly accessed by the page reclaim scanner */
707         struct lruvec           lruvec;
708
709         unsigned long           flags;
710
711         ZONE_PADDING(_pad2_)
712
713         /* Per-node vmstats */
714         struct per_cpu_nodestat __percpu *per_cpu_nodestats;
715         atomic_long_t           vm_stat[NR_VM_NODE_STAT_ITEMS];
716 } pg_data_t;
717
718 #define node_present_pages(nid) (NODE_DATA(nid)->node_present_pages)
719 #define node_spanned_pages(nid) (NODE_DATA(nid)->node_spanned_pages)
720 #ifdef CONFIG_FLAT_NODE_MEM_MAP
721 #define pgdat_page_nr(pgdat, pagenr)    ((pgdat)->node_mem_map + (pagenr))
722 #else
723 #define pgdat_page_nr(pgdat, pagenr)    pfn_to_page((pgdat)->node_start_pfn + (pagenr))
724 #endif
725 #define nid_page_nr(nid, pagenr)        pgdat_page_nr(NODE_DATA(nid),(pagenr))
726
727 #define node_start_pfn(nid)     (NODE_DATA(nid)->node_start_pfn)
728 #define node_end_pfn(nid) pgdat_end_pfn(NODE_DATA(nid))
729 static inline spinlock_t *zone_lru_lock(struct zone *zone)
730 {
731         return &zone->zone_pgdat->lru_lock;
732 }
733
734 static inline struct lruvec *node_lruvec(struct pglist_data *pgdat)
735 {
736         return &pgdat->lruvec;
737 }
738
739 static inline unsigned long pgdat_end_pfn(pg_data_t *pgdat)
740 {
741         return pgdat->node_start_pfn + pgdat->node_spanned_pages;
742 }
743
744 static inline bool pgdat_is_empty(pg_data_t *pgdat)
745 {
746         return !pgdat->node_start_pfn && !pgdat->node_spanned_pages;
747 }
748
749 #include <linux/memory_hotplug.h>
750
751 void build_all_zonelists(pg_data_t *pgdat);
752 void wakeup_kswapd(struct zone *zone, gfp_t gfp_mask, int order,
753                    enum zone_type classzone_idx);
754 bool __zone_watermark_ok(struct zone *z, unsigned int order, unsigned long mark,
755                          int classzone_idx, unsigned int alloc_flags,
756                          long free_pages);
757 bool zone_watermark_ok(struct zone *z, unsigned int order,
758                 unsigned long mark, int classzone_idx,
759                 unsigned int alloc_flags);
760 bool zone_watermark_ok_safe(struct zone *z, unsigned int order,
761                 unsigned long mark, int classzone_idx);
762 enum memmap_context {
763         MEMMAP_EARLY,
764         MEMMAP_HOTPLUG,
765 };
766 extern void init_currently_empty_zone(struct zone *zone, unsigned long start_pfn,
767                                      unsigned long size);
768
769 extern void lruvec_init(struct lruvec *lruvec);
770
771 static inline struct pglist_data *lruvec_pgdat(struct lruvec *lruvec)
772 {
773 #ifdef CONFIG_MEMCG
774         return lruvec->pgdat;
775 #else
776         return container_of(lruvec, struct pglist_data, lruvec);
777 #endif
778 }
779
780 extern unsigned long lruvec_lru_size(struct lruvec *lruvec, enum lru_list lru, int zone_idx);
781
782 #ifdef CONFIG_HAVE_MEMORY_PRESENT
783 void memory_present(int nid, unsigned long start, unsigned long end);
784 #else
785 static inline void memory_present(int nid, unsigned long start, unsigned long end) {}
786 #endif
787
788 #ifdef CONFIG_HAVE_MEMORYLESS_NODES
789 int local_memory_node(int node_id);
790 #else
791 static inline int local_memory_node(int node_id) { return node_id; };
792 #endif
793
794 /*
795  * zone_idx() returns 0 for the ZONE_DMA zone, 1 for the ZONE_NORMAL zone, etc.
796  */
797 #define zone_idx(zone)          ((zone) - (zone)->zone_pgdat->node_zones)
798
799 #ifdef CONFIG_ZONE_DEVICE
800 static inline bool is_dev_zone(const struct zone *zone)
801 {
802         return zone_idx(zone) == ZONE_DEVICE;
803 }
804 #else
805 static inline bool is_dev_zone(const struct zone *zone)
806 {
807         return false;
808 }
809 #endif
810
811 /*
812  * Returns true if a zone has pages managed by the buddy allocator.
813  * All the reclaim decisions have to use this function rather than
814  * populated_zone(). If the whole zone is reserved then we can easily
815  * end up with populated_zone() && !managed_zone().
816  */
817 static inline bool managed_zone(struct zone *zone)
818 {
819         return zone->managed_pages;
820 }
821
822 /* Returns true if a zone has memory */
823 static inline bool populated_zone(struct zone *zone)
824 {
825         return zone->present_pages;
826 }
827
828 #ifdef CONFIG_NUMA
829 static inline int zone_to_nid(struct zone *zone)
830 {
831         return zone->node;
832 }
833
834 static inline void zone_set_nid(struct zone *zone, int nid)
835 {
836         zone->node = nid;
837 }
838 #else
839 static inline int zone_to_nid(struct zone *zone)
840 {
841         return 0;
842 }
843
844 static inline void zone_set_nid(struct zone *zone, int nid) {}
845 #endif
846
847 extern int movable_zone;
848
849 #ifdef CONFIG_HIGHMEM
850 static inline int zone_movable_is_highmem(void)
851 {
852 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
853         return movable_zone == ZONE_HIGHMEM;
854 #else
855         return (ZONE_MOVABLE - 1) == ZONE_HIGHMEM;
856 #endif
857 }
858 #endif
859
860 static inline int is_highmem_idx(enum zone_type idx)
861 {
862 #ifdef CONFIG_HIGHMEM
863         return (idx == ZONE_HIGHMEM ||
864                 (idx == ZONE_MOVABLE && zone_movable_is_highmem()));
865 #else
866         return 0;
867 #endif
868 }
869
870 /**
871  * is_highmem - helper function to quickly check if a struct zone is a 
872  *              highmem zone or not.  This is an attempt to keep references
873  *              to ZONE_{DMA/NORMAL/HIGHMEM/etc} in general code to a minimum.
874  * @zone - pointer to struct zone variable
875  */
876 static inline int is_highmem(struct zone *zone)
877 {
878 #ifdef CONFIG_HIGHMEM
879         return is_highmem_idx(zone_idx(zone));
880 #else
881         return 0;
882 #endif
883 }
884
885 /* These two functions are used to setup the per zone pages min values */
886 struct ctl_table;
887 int min_free_kbytes_sysctl_handler(struct ctl_table *, int,
888                                         void __user *, size_t *, loff_t *);
889 int watermark_scale_factor_sysctl_handler(struct ctl_table *, int,
890                                         void __user *, size_t *, loff_t *);
891 extern int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES];
892 int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int,
893                                         void __user *, size_t *, loff_t *);
894 int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *, int,
895                                         void __user *, size_t *, loff_t *);
896 int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *, int,
897                         void __user *, size_t *, loff_t *);
898 int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *, int,
899                         void __user *, size_t *, loff_t *);
900
901 extern int numa_zonelist_order_handler(struct ctl_table *, int,
902                         void __user *, size_t *, loff_t *);
903 extern char numa_zonelist_order[];
904 #define NUMA_ZONELIST_ORDER_LEN 16
905
906 #ifndef CONFIG_NEED_MULTIPLE_NODES
907
908 extern struct pglist_data contig_page_data;
909 #define NODE_DATA(nid)          (&contig_page_data)
910 #define NODE_MEM_MAP(nid)       mem_map
911
912 #else /* CONFIG_NEED_MULTIPLE_NODES */
913
914 #include <asm/mmzone.h>
915
916 #endif /* !CONFIG_NEED_MULTIPLE_NODES */
917
918 extern struct pglist_data *first_online_pgdat(void);
919 extern struct pglist_data *next_online_pgdat(struct pglist_data *pgdat);
920 extern struct zone *next_zone(struct zone *zone);
921
922 /**
923  * for_each_online_pgdat - helper macro to iterate over all online nodes
924  * @pgdat - pointer to a pg_data_t variable
925  */
926 #define for_each_online_pgdat(pgdat)                    \
927         for (pgdat = first_online_pgdat();              \
928              pgdat;                                     \
929              pgdat = next_online_pgdat(pgdat))
930 /**
931  * for_each_zone - helper macro to iterate over all memory zones
932  * @zone - pointer to struct zone variable
933  *
934  * The user only needs to declare the zone variable, for_each_zone
935  * fills it in.
936  */
937 #define for_each_zone(zone)                             \
938         for (zone = (first_online_pgdat())->node_zones; \
939              zone;                                      \
940              zone = next_zone(zone))
941
942 #define for_each_populated_zone(zone)                   \
943         for (zone = (first_online_pgdat())->node_zones; \
944              zone;                                      \
945              zone = next_zone(zone))                    \
946                 if (!populated_zone(zone))              \
947                         ; /* do nothing */              \
948                 else
949
950 static inline struct zone *zonelist_zone(struct zoneref *zoneref)
951 {
952         return zoneref->zone;
953 }
954
955 static inline int zonelist_zone_idx(struct zoneref *zoneref)
956 {
957         return zoneref->zone_idx;
958 }
959
960 static inline int zonelist_node_idx(struct zoneref *zoneref)
961 {
962         return zone_to_nid(zoneref->zone);
963 }
964
965 struct zoneref *__next_zones_zonelist(struct zoneref *z,
966                                         enum zone_type highest_zoneidx,
967                                         nodemask_t *nodes);
968
969 /**
970  * 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
971  * @z - The cursor used as a starting point for the search
972  * @highest_zoneidx - The zone index of the highest zone to return
973  * @nodes - An optional nodemask to filter the zonelist with
974  *
975  * This function returns the next zone at or below a given zone index that is
976  * within the allowed nodemask using a cursor as the starting point for the
977  * search. The zoneref returned is a cursor that represents the current zone
978  * being examined. It should be advanced by one before calling
979  * next_zones_zonelist again.
980  */
981 static __always_inline struct zoneref *next_zones_zonelist(struct zoneref *z,
982                                         enum zone_type highest_zoneidx,
983                                         nodemask_t *nodes)
984 {
985         if (likely(!nodes && zonelist_zone_idx(z) <= highest_zoneidx))
986                 return z;
987         return __next_zones_zonelist(z, highest_zoneidx, nodes);
988 }
989
990 /**
991  * first_zones_zonelist - Returns the first zone at or below highest_zoneidx within the allowed nodemask in a zonelist
992  * @zonelist - The zonelist to search for a suitable zone
993  * @highest_zoneidx - The zone index of the highest zone to return
994  * @nodes - An optional nodemask to filter the zonelist with
995  * @return - Zoneref pointer for the first suitable zone found (see below)
996  *
997  * This function returns the first zone at or below a given zone index that is
998  * within the allowed nodemask. The zoneref returned is a cursor that can be
999  * used to iterate the zonelist with next_zones_zonelist by advancing it by
1000  * one before calling.
1001  *
1002  * When no eligible zone is found, zoneref->zone is NULL (zoneref itself is
1003  * never NULL). This may happen either genuinely, or due to concurrent nodemask
1004  * update due to cpuset modification.
1005  */
1006 static inline struct zoneref *first_zones_zonelist(struct zonelist *zonelist,
1007                                         enum zone_type highest_zoneidx,
1008                                         nodemask_t *nodes)
1009 {
1010         return next_zones_zonelist(zonelist->_zonerefs,
1011                                                         highest_zoneidx, nodes);
1012 }
1013
1014 /**
1015  * 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
1016  * @zone - The current zone in the iterator
1017  * @z - The current pointer within zonelist->zones being iterated
1018  * @zlist - The zonelist being iterated
1019  * @highidx - The zone index of the highest zone to return
1020  * @nodemask - Nodemask allowed by the allocator
1021  *
1022  * This iterator iterates though all zones at or below a given zone index and
1023  * within a given nodemask
1024  */
1025 #define for_each_zone_zonelist_nodemask(zone, z, zlist, highidx, nodemask) \
1026         for (z = first_zones_zonelist(zlist, highidx, nodemask), zone = zonelist_zone(z);       \
1027                 zone;                                                   \
1028                 z = next_zones_zonelist(++z, highidx, nodemask),        \
1029                         zone = zonelist_zone(z))
1030
1031 #define for_next_zone_zonelist_nodemask(zone, z, zlist, highidx, nodemask) \
1032         for (zone = z->zone;    \
1033                 zone;                                                   \
1034                 z = next_zones_zonelist(++z, highidx, nodemask),        \
1035                         zone = zonelist_zone(z))
1036
1037
1038 /**
1039  * for_each_zone_zonelist - helper macro to iterate over valid zones in a zonelist at or below a given zone index
1040  * @zone - The current zone in the iterator
1041  * @z - The current pointer within zonelist->zones being iterated
1042  * @zlist - The zonelist being iterated
1043  * @highidx - The zone index of the highest zone to return
1044  *
1045  * This iterator iterates though all zones at or below a given zone index.
1046  */
1047 #define for_each_zone_zonelist(zone, z, zlist, highidx) \
1048         for_each_zone_zonelist_nodemask(zone, z, zlist, highidx, NULL)
1049
1050 #ifdef CONFIG_SPARSEMEM
1051 #include <asm/sparsemem.h>
1052 #endif
1053
1054 #if !defined(CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID) && \
1055         !defined(CONFIG_HAVE_MEMBLOCK_NODE_MAP)
1056 static inline unsigned long early_pfn_to_nid(unsigned long pfn)
1057 {
1058         BUILD_BUG_ON(IS_ENABLED(CONFIG_NUMA));
1059         return 0;
1060 }
1061 #endif
1062
1063 #ifdef CONFIG_FLATMEM
1064 #define pfn_to_nid(pfn)         (0)
1065 #endif
1066
1067 #ifdef CONFIG_SPARSEMEM
1068
1069 /*
1070  * SECTION_SHIFT                #bits space required to store a section #
1071  *
1072  * PA_SECTION_SHIFT             physical address to/from section number
1073  * PFN_SECTION_SHIFT            pfn to/from section number
1074  */
1075 #define PA_SECTION_SHIFT        (SECTION_SIZE_BITS)
1076 #define PFN_SECTION_SHIFT       (SECTION_SIZE_BITS - PAGE_SHIFT)
1077
1078 #define NR_MEM_SECTIONS         (1UL << SECTIONS_SHIFT)
1079
1080 #define PAGES_PER_SECTION       (1UL << PFN_SECTION_SHIFT)
1081 #define PAGE_SECTION_MASK       (~(PAGES_PER_SECTION-1))
1082
1083 #define SECTION_BLOCKFLAGS_BITS \
1084         ((1UL << (PFN_SECTION_SHIFT - pageblock_order)) * NR_PAGEBLOCK_BITS)
1085
1086 #if (MAX_ORDER - 1 + PAGE_SHIFT) > SECTION_SIZE_BITS
1087 #error Allocator MAX_ORDER exceeds SECTION_SIZE
1088 #endif
1089
1090 static inline unsigned long pfn_to_section_nr(unsigned long pfn)
1091 {
1092         return pfn >> PFN_SECTION_SHIFT;
1093 }
1094 static inline unsigned long section_nr_to_pfn(unsigned long sec)
1095 {
1096         return sec << PFN_SECTION_SHIFT;
1097 }
1098
1099 #define SECTION_ALIGN_UP(pfn)   (((pfn) + PAGES_PER_SECTION - 1) & PAGE_SECTION_MASK)
1100 #define SECTION_ALIGN_DOWN(pfn) ((pfn) & PAGE_SECTION_MASK)
1101
1102 struct page;
1103 struct page_ext;
1104 struct mem_section {
1105         /*
1106          * This is, logically, a pointer to an array of struct
1107          * pages.  However, it is stored with some other magic.
1108          * (see sparse.c::sparse_init_one_section())
1109          *
1110          * Additionally during early boot we encode node id of
1111          * the location of the section here to guide allocation.
1112          * (see sparse.c::memory_present())
1113          *
1114          * Making it a UL at least makes someone do a cast
1115          * before using it wrong.
1116          */
1117         unsigned long section_mem_map;
1118
1119         /* See declaration of similar field in struct zone */
1120         unsigned long *pageblock_flags;
1121 #ifdef CONFIG_PAGE_EXTENSION
1122         /*
1123          * If SPARSEMEM, pgdat doesn't have page_ext pointer. We use
1124          * section. (see page_ext.h about this.)
1125          */
1126         struct page_ext *page_ext;
1127         unsigned long pad;
1128 #endif
1129         /*
1130          * WARNING: mem_section must be a power-of-2 in size for the
1131          * calculation and use of SECTION_ROOT_MASK to make sense.
1132          */
1133 };
1134
1135 #ifdef CONFIG_SPARSEMEM_EXTREME
1136 #define SECTIONS_PER_ROOT       (PAGE_SIZE / sizeof (struct mem_section))
1137 #else
1138 #define SECTIONS_PER_ROOT       1
1139 #endif
1140
1141 #define SECTION_NR_TO_ROOT(sec) ((sec) / SECTIONS_PER_ROOT)
1142 #define NR_SECTION_ROOTS        DIV_ROUND_UP(NR_MEM_SECTIONS, SECTIONS_PER_ROOT)
1143 #define SECTION_ROOT_MASK       (SECTIONS_PER_ROOT - 1)
1144
1145 #ifdef CONFIG_SPARSEMEM_EXTREME
1146 extern struct mem_section **mem_section;
1147 #else
1148 extern struct mem_section mem_section[NR_SECTION_ROOTS][SECTIONS_PER_ROOT];
1149 #endif
1150
1151 static inline struct mem_section *__nr_to_section(unsigned long nr)
1152 {
1153 #ifdef CONFIG_SPARSEMEM_EXTREME
1154         if (!mem_section)
1155                 return NULL;
1156 #endif
1157         if (!mem_section[SECTION_NR_TO_ROOT(nr)])
1158                 return NULL;
1159         return &mem_section[SECTION_NR_TO_ROOT(nr)][nr & SECTION_ROOT_MASK];
1160 }
1161 extern int __section_nr(struct mem_section* ms);
1162 extern unsigned long usemap_size(void);
1163
1164 /*
1165  * We use the lower bits of the mem_map pointer to store
1166  * a little bit of information.  The pointer is calculated
1167  * as mem_map - section_nr_to_pfn(pnum).  The result is
1168  * aligned to the minimum alignment of the two values:
1169  *   1. All mem_map arrays are page-aligned.
1170  *   2. section_nr_to_pfn() always clears PFN_SECTION_SHIFT
1171  *      lowest bits.  PFN_SECTION_SHIFT is arch-specific
1172  *      (equal SECTION_SIZE_BITS - PAGE_SHIFT), and the
1173  *      worst combination is powerpc with 256k pages,
1174  *      which results in PFN_SECTION_SHIFT equal 6.
1175  * To sum it up, at least 6 bits are available.
1176  */
1177 #define SECTION_MARKED_PRESENT  (1UL<<0)
1178 #define SECTION_HAS_MEM_MAP     (1UL<<1)
1179 #define SECTION_IS_ONLINE       (1UL<<2)
1180 #define SECTION_MAP_LAST_BIT    (1UL<<3)
1181 #define SECTION_MAP_MASK        (~(SECTION_MAP_LAST_BIT-1))
1182 #define SECTION_NID_SHIFT       3
1183
1184 static inline struct page *__section_mem_map_addr(struct mem_section *section)
1185 {
1186         unsigned long map = section->section_mem_map;
1187         map &= SECTION_MAP_MASK;
1188         return (struct page *)map;
1189 }
1190
1191 static inline int present_section(struct mem_section *section)
1192 {
1193         return (section && (section->section_mem_map & SECTION_MARKED_PRESENT));
1194 }
1195
1196 static inline int present_section_nr(unsigned long nr)
1197 {
1198         return present_section(__nr_to_section(nr));
1199 }
1200
1201 static inline int valid_section(struct mem_section *section)
1202 {
1203         return (section && (section->section_mem_map & SECTION_HAS_MEM_MAP));
1204 }
1205
1206 static inline int valid_section_nr(unsigned long nr)
1207 {
1208         return valid_section(__nr_to_section(nr));
1209 }
1210
1211 static inline int online_section(struct mem_section *section)
1212 {
1213         return (section && (section->section_mem_map & SECTION_IS_ONLINE));
1214 }
1215
1216 static inline int online_section_nr(unsigned long nr)
1217 {
1218         return online_section(__nr_to_section(nr));
1219 }
1220
1221 #ifdef CONFIG_MEMORY_HOTPLUG
1222 void online_mem_sections(unsigned long start_pfn, unsigned long end_pfn);
1223 #ifdef CONFIG_MEMORY_HOTREMOVE
1224 void offline_mem_sections(unsigned long start_pfn, unsigned long end_pfn);
1225 #endif
1226 #endif
1227
1228 static inline struct mem_section *__pfn_to_section(unsigned long pfn)
1229 {
1230         return __nr_to_section(pfn_to_section_nr(pfn));
1231 }
1232
1233 extern int __highest_present_section_nr;
1234
1235 #ifndef CONFIG_HAVE_ARCH_PFN_VALID
1236 static inline int pfn_valid(unsigned long pfn)
1237 {
1238         if (pfn_to_section_nr(pfn) >= NR_MEM_SECTIONS)
1239                 return 0;
1240         return valid_section(__nr_to_section(pfn_to_section_nr(pfn)));
1241 }
1242 #endif
1243
1244 static inline int pfn_present(unsigned long pfn)
1245 {
1246         if (pfn_to_section_nr(pfn) >= NR_MEM_SECTIONS)
1247                 return 0;
1248         return present_section(__nr_to_section(pfn_to_section_nr(pfn)));
1249 }
1250
1251 /*
1252  * These are _only_ used during initialisation, therefore they
1253  * can use __initdata ...  They could have names to indicate
1254  * this restriction.
1255  */
1256 #ifdef CONFIG_NUMA
1257 #define pfn_to_nid(pfn)                                                 \
1258 ({                                                                      \
1259         unsigned long __pfn_to_nid_pfn = (pfn);                         \
1260         page_to_nid(pfn_to_page(__pfn_to_nid_pfn));                     \
1261 })
1262 #else
1263 #define pfn_to_nid(pfn)         (0)
1264 #endif
1265
1266 #define early_pfn_valid(pfn)    pfn_valid(pfn)
1267 void sparse_init(void);
1268 #else
1269 #define sparse_init()   do {} while (0)
1270 #define sparse_index_init(_sec, _nid)  do {} while (0)
1271 #endif /* CONFIG_SPARSEMEM */
1272
1273 /*
1274  * During memory init memblocks map pfns to nids. The search is expensive and
1275  * this caches recent lookups. The implementation of __early_pfn_to_nid
1276  * may treat start/end as pfns or sections.
1277  */
1278 struct mminit_pfnnid_cache {
1279         unsigned long last_start;
1280         unsigned long last_end;
1281         int last_nid;
1282 };
1283
1284 #ifndef early_pfn_valid
1285 #define early_pfn_valid(pfn)    (1)
1286 #endif
1287
1288 void memory_present(int nid, unsigned long start, unsigned long end);
1289
1290 /*
1291  * If it is possible to have holes within a MAX_ORDER_NR_PAGES, then we
1292  * need to check pfn validility within that MAX_ORDER_NR_PAGES block.
1293  * pfn_valid_within() should be used in this case; we optimise this away
1294  * when we have no holes within a MAX_ORDER_NR_PAGES block.
1295  */
1296 #ifdef CONFIG_HOLES_IN_ZONE
1297 #define pfn_valid_within(pfn) pfn_valid(pfn)
1298 #else
1299 #define pfn_valid_within(pfn) (1)
1300 #endif
1301
1302 #ifdef CONFIG_ARCH_HAS_HOLES_MEMORYMODEL
1303 /*
1304  * pfn_valid() is meant to be able to tell if a given PFN has valid memmap
1305  * associated with it or not. This means that a struct page exists for this
1306  * pfn. The caller cannot assume the page is fully initialized in general.
1307  * Hotplugable pages might not have been onlined yet. pfn_to_online_page()
1308  * will ensure the struct page is fully online and initialized. Special pages
1309  * (e.g. ZONE_DEVICE) are never onlined and should be treated accordingly.
1310  *
1311  * In FLATMEM, it is expected that holes always have valid memmap as long as
1312  * there is valid PFNs either side of the hole. In SPARSEMEM, it is assumed
1313  * that a valid section has a memmap for the entire section.
1314  *
1315  * However, an ARM, and maybe other embedded architectures in the future
1316  * free memmap backing holes to save memory on the assumption the memmap is
1317  * never used. The page_zone linkages are then broken even though pfn_valid()
1318  * returns true. A walker of the full memmap must then do this additional
1319  * check to ensure the memmap they are looking at is sane by making sure
1320  * the zone and PFN linkages are still valid. This is expensive, but walkers
1321  * of the full memmap are extremely rare.
1322  */
1323 bool memmap_valid_within(unsigned long pfn,
1324                                         struct page *page, struct zone *zone);
1325 #else
1326 static inline bool memmap_valid_within(unsigned long pfn,
1327                                         struct page *page, struct zone *zone)
1328 {
1329         return true;
1330 }
1331 #endif /* CONFIG_ARCH_HAS_HOLES_MEMORYMODEL */
1332
1333 #endif /* !__GENERATING_BOUNDS.H */
1334 #endif /* !__ASSEMBLY__ */
1335 #endif /* _LINUX_MMZONE_H */