mm, page_alloc: enable pcpu_drain with zone capability
[sfrench/cifs-2.6.git] / mm / page_alloc.c
1 /*
2  *  linux/mm/page_alloc.c
3  *
4  *  Manages the free list, the system allocates free pages here.
5  *  Note that kmalloc() lives in slab.c
6  *
7  *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
8  *  Swap reorganised 29.12.95, Stephen Tweedie
9  *  Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
10  *  Reshaped it to be a zoned allocator, Ingo Molnar, Red Hat, 1999
11  *  Discontiguous memory support, Kanoj Sarcar, SGI, Nov 1999
12  *  Zone balancing, Kanoj Sarcar, SGI, Jan 2000
13  *  Per cpu hot/cold page lists, bulk allocation, Martin J. Bligh, Sept 2002
14  *          (lots of bits borrowed from Ingo Molnar & Andrew Morton)
15  */
16
17 #include <linux/stddef.h>
18 #include <linux/mm.h>
19 #include <linux/highmem.h>
20 #include <linux/swap.h>
21 #include <linux/interrupt.h>
22 #include <linux/pagemap.h>
23 #include <linux/jiffies.h>
24 #include <linux/memblock.h>
25 #include <linux/compiler.h>
26 #include <linux/kernel.h>
27 #include <linux/kasan.h>
28 #include <linux/module.h>
29 #include <linux/suspend.h>
30 #include <linux/pagevec.h>
31 #include <linux/blkdev.h>
32 #include <linux/slab.h>
33 #include <linux/ratelimit.h>
34 #include <linux/oom.h>
35 #include <linux/topology.h>
36 #include <linux/sysctl.h>
37 #include <linux/cpu.h>
38 #include <linux/cpuset.h>
39 #include <linux/memory_hotplug.h>
40 #include <linux/nodemask.h>
41 #include <linux/vmalloc.h>
42 #include <linux/vmstat.h>
43 #include <linux/mempolicy.h>
44 #include <linux/memremap.h>
45 #include <linux/stop_machine.h>
46 #include <linux/sort.h>
47 #include <linux/pfn.h>
48 #include <linux/backing-dev.h>
49 #include <linux/fault-inject.h>
50 #include <linux/page-isolation.h>
51 #include <linux/page_ext.h>
52 #include <linux/debugobjects.h>
53 #include <linux/kmemleak.h>
54 #include <linux/compaction.h>
55 #include <trace/events/kmem.h>
56 #include <trace/events/oom.h>
57 #include <linux/prefetch.h>
58 #include <linux/mm_inline.h>
59 #include <linux/migrate.h>
60 #include <linux/hugetlb.h>
61 #include <linux/sched/rt.h>
62 #include <linux/sched/mm.h>
63 #include <linux/page_owner.h>
64 #include <linux/kthread.h>
65 #include <linux/memcontrol.h>
66 #include <linux/ftrace.h>
67 #include <linux/lockdep.h>
68 #include <linux/nmi.h>
69 #include <linux/psi.h>
70
71 #include <asm/sections.h>
72 #include <asm/tlbflush.h>
73 #include <asm/div64.h>
74 #include "internal.h"
75
76 /* prevent >1 _updater_ of zone percpu pageset ->high and ->batch fields */
77 static DEFINE_MUTEX(pcp_batch_high_lock);
78 #define MIN_PERCPU_PAGELIST_FRACTION    (8)
79
80 #ifdef CONFIG_USE_PERCPU_NUMA_NODE_ID
81 DEFINE_PER_CPU(int, numa_node);
82 EXPORT_PER_CPU_SYMBOL(numa_node);
83 #endif
84
85 DEFINE_STATIC_KEY_TRUE(vm_numa_stat_key);
86
87 #ifdef CONFIG_HAVE_MEMORYLESS_NODES
88 /*
89  * N.B., Do NOT reference the '_numa_mem_' per cpu variable directly.
90  * It will not be defined when CONFIG_HAVE_MEMORYLESS_NODES is not defined.
91  * Use the accessor functions set_numa_mem(), numa_mem_id() and cpu_to_mem()
92  * defined in <linux/topology.h>.
93  */
94 DEFINE_PER_CPU(int, _numa_mem_);                /* Kernel "local memory" node */
95 EXPORT_PER_CPU_SYMBOL(_numa_mem_);
96 int _node_numa_mem_[MAX_NUMNODES];
97 #endif
98
99 /* work_structs for global per-cpu drains */
100 struct pcpu_drain {
101         struct zone *zone;
102         struct work_struct work;
103 };
104 DEFINE_MUTEX(pcpu_drain_mutex);
105 DEFINE_PER_CPU(struct pcpu_drain, pcpu_drain);
106
107 #ifdef CONFIG_GCC_PLUGIN_LATENT_ENTROPY
108 volatile unsigned long latent_entropy __latent_entropy;
109 EXPORT_SYMBOL(latent_entropy);
110 #endif
111
112 /*
113  * Array of node states.
114  */
115 nodemask_t node_states[NR_NODE_STATES] __read_mostly = {
116         [N_POSSIBLE] = NODE_MASK_ALL,
117         [N_ONLINE] = { { [0] = 1UL } },
118 #ifndef CONFIG_NUMA
119         [N_NORMAL_MEMORY] = { { [0] = 1UL } },
120 #ifdef CONFIG_HIGHMEM
121         [N_HIGH_MEMORY] = { { [0] = 1UL } },
122 #endif
123         [N_MEMORY] = { { [0] = 1UL } },
124         [N_CPU] = { { [0] = 1UL } },
125 #endif  /* NUMA */
126 };
127 EXPORT_SYMBOL(node_states);
128
129 atomic_long_t _totalram_pages __read_mostly;
130 EXPORT_SYMBOL(_totalram_pages);
131 unsigned long totalreserve_pages __read_mostly;
132 unsigned long totalcma_pages __read_mostly;
133
134 int percpu_pagelist_fraction;
135 gfp_t gfp_allowed_mask __read_mostly = GFP_BOOT_MASK;
136
137 /*
138  * A cached value of the page's pageblock's migratetype, used when the page is
139  * put on a pcplist. Used to avoid the pageblock migratetype lookup when
140  * freeing from pcplists in most cases, at the cost of possibly becoming stale.
141  * Also the migratetype set in the page does not necessarily match the pcplist
142  * index, e.g. page might have MIGRATE_CMA set but be on a pcplist with any
143  * other index - this ensures that it will be put on the correct CMA freelist.
144  */
145 static inline int get_pcppage_migratetype(struct page *page)
146 {
147         return page->index;
148 }
149
150 static inline void set_pcppage_migratetype(struct page *page, int migratetype)
151 {
152         page->index = migratetype;
153 }
154
155 #ifdef CONFIG_PM_SLEEP
156 /*
157  * The following functions are used by the suspend/hibernate code to temporarily
158  * change gfp_allowed_mask in order to avoid using I/O during memory allocations
159  * while devices are suspended.  To avoid races with the suspend/hibernate code,
160  * they should always be called with system_transition_mutex held
161  * (gfp_allowed_mask also should only be modified with system_transition_mutex
162  * held, unless the suspend/hibernate code is guaranteed not to run in parallel
163  * with that modification).
164  */
165
166 static gfp_t saved_gfp_mask;
167
168 void pm_restore_gfp_mask(void)
169 {
170         WARN_ON(!mutex_is_locked(&system_transition_mutex));
171         if (saved_gfp_mask) {
172                 gfp_allowed_mask = saved_gfp_mask;
173                 saved_gfp_mask = 0;
174         }
175 }
176
177 void pm_restrict_gfp_mask(void)
178 {
179         WARN_ON(!mutex_is_locked(&system_transition_mutex));
180         WARN_ON(saved_gfp_mask);
181         saved_gfp_mask = gfp_allowed_mask;
182         gfp_allowed_mask &= ~(__GFP_IO | __GFP_FS);
183 }
184
185 bool pm_suspended_storage(void)
186 {
187         if ((gfp_allowed_mask & (__GFP_IO | __GFP_FS)) == (__GFP_IO | __GFP_FS))
188                 return false;
189         return true;
190 }
191 #endif /* CONFIG_PM_SLEEP */
192
193 #ifdef CONFIG_HUGETLB_PAGE_SIZE_VARIABLE
194 unsigned int pageblock_order __read_mostly;
195 #endif
196
197 static void __free_pages_ok(struct page *page, unsigned int order);
198
199 /*
200  * results with 256, 32 in the lowmem_reserve sysctl:
201  *      1G machine -> (16M dma, 800M-16M normal, 1G-800M high)
202  *      1G machine -> (16M dma, 784M normal, 224M high)
203  *      NORMAL allocation will leave 784M/256 of ram reserved in the ZONE_DMA
204  *      HIGHMEM allocation will leave 224M/32 of ram reserved in ZONE_NORMAL
205  *      HIGHMEM allocation will leave (224M+784M)/256 of ram reserved in ZONE_DMA
206  *
207  * TBD: should special case ZONE_DMA32 machines here - in those we normally
208  * don't need any ZONE_NORMAL reservation
209  */
210 int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES] = {
211 #ifdef CONFIG_ZONE_DMA
212         [ZONE_DMA] = 256,
213 #endif
214 #ifdef CONFIG_ZONE_DMA32
215         [ZONE_DMA32] = 256,
216 #endif
217         [ZONE_NORMAL] = 32,
218 #ifdef CONFIG_HIGHMEM
219         [ZONE_HIGHMEM] = 0,
220 #endif
221         [ZONE_MOVABLE] = 0,
222 };
223
224 EXPORT_SYMBOL(totalram_pages);
225
226 static char * const zone_names[MAX_NR_ZONES] = {
227 #ifdef CONFIG_ZONE_DMA
228          "DMA",
229 #endif
230 #ifdef CONFIG_ZONE_DMA32
231          "DMA32",
232 #endif
233          "Normal",
234 #ifdef CONFIG_HIGHMEM
235          "HighMem",
236 #endif
237          "Movable",
238 #ifdef CONFIG_ZONE_DEVICE
239          "Device",
240 #endif
241 };
242
243 const char * const migratetype_names[MIGRATE_TYPES] = {
244         "Unmovable",
245         "Movable",
246         "Reclaimable",
247         "HighAtomic",
248 #ifdef CONFIG_CMA
249         "CMA",
250 #endif
251 #ifdef CONFIG_MEMORY_ISOLATION
252         "Isolate",
253 #endif
254 };
255
256 compound_page_dtor * const compound_page_dtors[] = {
257         NULL,
258         free_compound_page,
259 #ifdef CONFIG_HUGETLB_PAGE
260         free_huge_page,
261 #endif
262 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
263         free_transhuge_page,
264 #endif
265 };
266
267 int min_free_kbytes = 1024;
268 int user_min_free_kbytes = -1;
269 int watermark_boost_factor __read_mostly = 15000;
270 int watermark_scale_factor = 10;
271
272 static unsigned long nr_kernel_pages __initdata;
273 static unsigned long nr_all_pages __initdata;
274 static unsigned long dma_reserve __initdata;
275
276 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
277 static unsigned long arch_zone_lowest_possible_pfn[MAX_NR_ZONES] __initdata;
278 static unsigned long arch_zone_highest_possible_pfn[MAX_NR_ZONES] __initdata;
279 static unsigned long required_kernelcore __initdata;
280 static unsigned long required_kernelcore_percent __initdata;
281 static unsigned long required_movablecore __initdata;
282 static unsigned long required_movablecore_percent __initdata;
283 static unsigned long zone_movable_pfn[MAX_NUMNODES] __initdata;
284 static bool mirrored_kernelcore __meminitdata;
285
286 /* movable_zone is the "real" zone pages in ZONE_MOVABLE are taken from */
287 int movable_zone;
288 EXPORT_SYMBOL(movable_zone);
289 #endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
290
291 #if MAX_NUMNODES > 1
292 int nr_node_ids __read_mostly = MAX_NUMNODES;
293 int nr_online_nodes __read_mostly = 1;
294 EXPORT_SYMBOL(nr_node_ids);
295 EXPORT_SYMBOL(nr_online_nodes);
296 #endif
297
298 int page_group_by_mobility_disabled __read_mostly;
299
300 #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
301 /*
302  * During boot we initialize deferred pages on-demand, as needed, but once
303  * page_alloc_init_late() has finished, the deferred pages are all initialized,
304  * and we can permanently disable that path.
305  */
306 static DEFINE_STATIC_KEY_TRUE(deferred_pages);
307
308 /*
309  * Calling kasan_free_pages() only after deferred memory initialization
310  * has completed. Poisoning pages during deferred memory init will greatly
311  * lengthen the process and cause problem in large memory systems as the
312  * deferred pages initialization is done with interrupt disabled.
313  *
314  * Assuming that there will be no reference to those newly initialized
315  * pages before they are ever allocated, this should have no effect on
316  * KASAN memory tracking as the poison will be properly inserted at page
317  * allocation time. The only corner case is when pages are allocated by
318  * on-demand allocation and then freed again before the deferred pages
319  * initialization is done, but this is not likely to happen.
320  */
321 static inline void kasan_free_nondeferred_pages(struct page *page, int order)
322 {
323         if (!static_branch_unlikely(&deferred_pages))
324                 kasan_free_pages(page, order);
325 }
326
327 /* Returns true if the struct page for the pfn is uninitialised */
328 static inline bool __meminit early_page_uninitialised(unsigned long pfn)
329 {
330         int nid = early_pfn_to_nid(pfn);
331
332         if (node_online(nid) && pfn >= NODE_DATA(nid)->first_deferred_pfn)
333                 return true;
334
335         return false;
336 }
337
338 /*
339  * Returns true when the remaining initialisation should be deferred until
340  * later in the boot cycle when it can be parallelised.
341  */
342 static bool __meminit
343 defer_init(int nid, unsigned long pfn, unsigned long end_pfn)
344 {
345         static unsigned long prev_end_pfn, nr_initialised;
346
347         /*
348          * prev_end_pfn static that contains the end of previous zone
349          * No need to protect because called very early in boot before smp_init.
350          */
351         if (prev_end_pfn != end_pfn) {
352                 prev_end_pfn = end_pfn;
353                 nr_initialised = 0;
354         }
355
356         /* Always populate low zones for address-constrained allocations */
357         if (end_pfn < pgdat_end_pfn(NODE_DATA(nid)))
358                 return false;
359
360         /*
361          * We start only with one section of pages, more pages are added as
362          * needed until the rest of deferred pages are initialized.
363          */
364         nr_initialised++;
365         if ((nr_initialised > PAGES_PER_SECTION) &&
366             (pfn & (PAGES_PER_SECTION - 1)) == 0) {
367                 NODE_DATA(nid)->first_deferred_pfn = pfn;
368                 return true;
369         }
370         return false;
371 }
372 #else
373 #define kasan_free_nondeferred_pages(p, o)      kasan_free_pages(p, o)
374
375 static inline bool early_page_uninitialised(unsigned long pfn)
376 {
377         return false;
378 }
379
380 static inline bool defer_init(int nid, unsigned long pfn, unsigned long end_pfn)
381 {
382         return false;
383 }
384 #endif
385
386 /* Return a pointer to the bitmap storing bits affecting a block of pages */
387 static inline unsigned long *get_pageblock_bitmap(struct page *page,
388                                                         unsigned long pfn)
389 {
390 #ifdef CONFIG_SPARSEMEM
391         return __pfn_to_section(pfn)->pageblock_flags;
392 #else
393         return page_zone(page)->pageblock_flags;
394 #endif /* CONFIG_SPARSEMEM */
395 }
396
397 static inline int pfn_to_bitidx(struct page *page, unsigned long pfn)
398 {
399 #ifdef CONFIG_SPARSEMEM
400         pfn &= (PAGES_PER_SECTION-1);
401         return (pfn >> pageblock_order) * NR_PAGEBLOCK_BITS;
402 #else
403         pfn = pfn - round_down(page_zone(page)->zone_start_pfn, pageblock_nr_pages);
404         return (pfn >> pageblock_order) * NR_PAGEBLOCK_BITS;
405 #endif /* CONFIG_SPARSEMEM */
406 }
407
408 /**
409  * get_pfnblock_flags_mask - Return the requested group of flags for the pageblock_nr_pages block of pages
410  * @page: The page within the block of interest
411  * @pfn: The target page frame number
412  * @end_bitidx: The last bit of interest to retrieve
413  * @mask: mask of bits that the caller is interested in
414  *
415  * Return: pageblock_bits flags
416  */
417 static __always_inline unsigned long __get_pfnblock_flags_mask(struct page *page,
418                                         unsigned long pfn,
419                                         unsigned long end_bitidx,
420                                         unsigned long mask)
421 {
422         unsigned long *bitmap;
423         unsigned long bitidx, word_bitidx;
424         unsigned long word;
425
426         bitmap = get_pageblock_bitmap(page, pfn);
427         bitidx = pfn_to_bitidx(page, pfn);
428         word_bitidx = bitidx / BITS_PER_LONG;
429         bitidx &= (BITS_PER_LONG-1);
430
431         word = bitmap[word_bitidx];
432         bitidx += end_bitidx;
433         return (word >> (BITS_PER_LONG - bitidx - 1)) & mask;
434 }
435
436 unsigned long get_pfnblock_flags_mask(struct page *page, unsigned long pfn,
437                                         unsigned long end_bitidx,
438                                         unsigned long mask)
439 {
440         return __get_pfnblock_flags_mask(page, pfn, end_bitidx, mask);
441 }
442
443 static __always_inline int get_pfnblock_migratetype(struct page *page, unsigned long pfn)
444 {
445         return __get_pfnblock_flags_mask(page, pfn, PB_migrate_end, MIGRATETYPE_MASK);
446 }
447
448 /**
449  * set_pfnblock_flags_mask - Set the requested group of flags for a pageblock_nr_pages block of pages
450  * @page: The page within the block of interest
451  * @flags: The flags to set
452  * @pfn: The target page frame number
453  * @end_bitidx: The last bit of interest
454  * @mask: mask of bits that the caller is interested in
455  */
456 void set_pfnblock_flags_mask(struct page *page, unsigned long flags,
457                                         unsigned long pfn,
458                                         unsigned long end_bitidx,
459                                         unsigned long mask)
460 {
461         unsigned long *bitmap;
462         unsigned long bitidx, word_bitidx;
463         unsigned long old_word, word;
464
465         BUILD_BUG_ON(NR_PAGEBLOCK_BITS != 4);
466         BUILD_BUG_ON(MIGRATE_TYPES > (1 << PB_migratetype_bits));
467
468         bitmap = get_pageblock_bitmap(page, pfn);
469         bitidx = pfn_to_bitidx(page, pfn);
470         word_bitidx = bitidx / BITS_PER_LONG;
471         bitidx &= (BITS_PER_LONG-1);
472
473         VM_BUG_ON_PAGE(!zone_spans_pfn(page_zone(page), pfn), page);
474
475         bitidx += end_bitidx;
476         mask <<= (BITS_PER_LONG - bitidx - 1);
477         flags <<= (BITS_PER_LONG - bitidx - 1);
478
479         word = READ_ONCE(bitmap[word_bitidx]);
480         for (;;) {
481                 old_word = cmpxchg(&bitmap[word_bitidx], word, (word & ~mask) | flags);
482                 if (word == old_word)
483                         break;
484                 word = old_word;
485         }
486 }
487
488 void set_pageblock_migratetype(struct page *page, int migratetype)
489 {
490         if (unlikely(page_group_by_mobility_disabled &&
491                      migratetype < MIGRATE_PCPTYPES))
492                 migratetype = MIGRATE_UNMOVABLE;
493
494         set_pageblock_flags_group(page, (unsigned long)migratetype,
495                                         PB_migrate, PB_migrate_end);
496 }
497
498 #ifdef CONFIG_DEBUG_VM
499 static int page_outside_zone_boundaries(struct zone *zone, struct page *page)
500 {
501         int ret = 0;
502         unsigned seq;
503         unsigned long pfn = page_to_pfn(page);
504         unsigned long sp, start_pfn;
505
506         do {
507                 seq = zone_span_seqbegin(zone);
508                 start_pfn = zone->zone_start_pfn;
509                 sp = zone->spanned_pages;
510                 if (!zone_spans_pfn(zone, pfn))
511                         ret = 1;
512         } while (zone_span_seqretry(zone, seq));
513
514         if (ret)
515                 pr_err("page 0x%lx outside node %d zone %s [ 0x%lx - 0x%lx ]\n",
516                         pfn, zone_to_nid(zone), zone->name,
517                         start_pfn, start_pfn + sp);
518
519         return ret;
520 }
521
522 static int page_is_consistent(struct zone *zone, struct page *page)
523 {
524         if (!pfn_valid_within(page_to_pfn(page)))
525                 return 0;
526         if (zone != page_zone(page))
527                 return 0;
528
529         return 1;
530 }
531 /*
532  * Temporary debugging check for pages not lying within a given zone.
533  */
534 static int __maybe_unused bad_range(struct zone *zone, struct page *page)
535 {
536         if (page_outside_zone_boundaries(zone, page))
537                 return 1;
538         if (!page_is_consistent(zone, page))
539                 return 1;
540
541         return 0;
542 }
543 #else
544 static inline int __maybe_unused bad_range(struct zone *zone, struct page *page)
545 {
546         return 0;
547 }
548 #endif
549
550 static void bad_page(struct page *page, const char *reason,
551                 unsigned long bad_flags)
552 {
553         static unsigned long resume;
554         static unsigned long nr_shown;
555         static unsigned long nr_unshown;
556
557         /*
558          * Allow a burst of 60 reports, then keep quiet for that minute;
559          * or allow a steady drip of one report per second.
560          */
561         if (nr_shown == 60) {
562                 if (time_before(jiffies, resume)) {
563                         nr_unshown++;
564                         goto out;
565                 }
566                 if (nr_unshown) {
567                         pr_alert(
568                               "BUG: Bad page state: %lu messages suppressed\n",
569                                 nr_unshown);
570                         nr_unshown = 0;
571                 }
572                 nr_shown = 0;
573         }
574         if (nr_shown++ == 0)
575                 resume = jiffies + 60 * HZ;
576
577         pr_alert("BUG: Bad page state in process %s  pfn:%05lx\n",
578                 current->comm, page_to_pfn(page));
579         __dump_page(page, reason);
580         bad_flags &= page->flags;
581         if (bad_flags)
582                 pr_alert("bad because of flags: %#lx(%pGp)\n",
583                                                 bad_flags, &bad_flags);
584         dump_page_owner(page);
585
586         print_modules();
587         dump_stack();
588 out:
589         /* Leave bad fields for debug, except PageBuddy could make trouble */
590         page_mapcount_reset(page); /* remove PageBuddy */
591         add_taint(TAINT_BAD_PAGE, LOCKDEP_NOW_UNRELIABLE);
592 }
593
594 /*
595  * Higher-order pages are called "compound pages".  They are structured thusly:
596  *
597  * The first PAGE_SIZE page is called the "head page" and have PG_head set.
598  *
599  * The remaining PAGE_SIZE pages are called "tail pages". PageTail() is encoded
600  * in bit 0 of page->compound_head. The rest of bits is pointer to head page.
601  *
602  * The first tail page's ->compound_dtor holds the offset in array of compound
603  * page destructors. See compound_page_dtors.
604  *
605  * The first tail page's ->compound_order holds the order of allocation.
606  * This usage means that zero-order pages may not be compound.
607  */
608
609 void free_compound_page(struct page *page)
610 {
611         __free_pages_ok(page, compound_order(page));
612 }
613
614 void prep_compound_page(struct page *page, unsigned int order)
615 {
616         int i;
617         int nr_pages = 1 << order;
618
619         set_compound_page_dtor(page, COMPOUND_PAGE_DTOR);
620         set_compound_order(page, order);
621         __SetPageHead(page);
622         for (i = 1; i < nr_pages; i++) {
623                 struct page *p = page + i;
624                 set_page_count(p, 0);
625                 p->mapping = TAIL_MAPPING;
626                 set_compound_head(p, page);
627         }
628         atomic_set(compound_mapcount_ptr(page), -1);
629 }
630
631 #ifdef CONFIG_DEBUG_PAGEALLOC
632 unsigned int _debug_guardpage_minorder;
633 bool _debug_pagealloc_enabled __read_mostly
634                         = IS_ENABLED(CONFIG_DEBUG_PAGEALLOC_ENABLE_DEFAULT);
635 EXPORT_SYMBOL(_debug_pagealloc_enabled);
636 bool _debug_guardpage_enabled __read_mostly;
637
638 static int __init early_debug_pagealloc(char *buf)
639 {
640         if (!buf)
641                 return -EINVAL;
642         return kstrtobool(buf, &_debug_pagealloc_enabled);
643 }
644 early_param("debug_pagealloc", early_debug_pagealloc);
645
646 static bool need_debug_guardpage(void)
647 {
648         /* If we don't use debug_pagealloc, we don't need guard page */
649         if (!debug_pagealloc_enabled())
650                 return false;
651
652         if (!debug_guardpage_minorder())
653                 return false;
654
655         return true;
656 }
657
658 static void init_debug_guardpage(void)
659 {
660         if (!debug_pagealloc_enabled())
661                 return;
662
663         if (!debug_guardpage_minorder())
664                 return;
665
666         _debug_guardpage_enabled = true;
667 }
668
669 struct page_ext_operations debug_guardpage_ops = {
670         .need = need_debug_guardpage,
671         .init = init_debug_guardpage,
672 };
673
674 static int __init debug_guardpage_minorder_setup(char *buf)
675 {
676         unsigned long res;
677
678         if (kstrtoul(buf, 10, &res) < 0 ||  res > MAX_ORDER / 2) {
679                 pr_err("Bad debug_guardpage_minorder value\n");
680                 return 0;
681         }
682         _debug_guardpage_minorder = res;
683         pr_info("Setting debug_guardpage_minorder to %lu\n", res);
684         return 0;
685 }
686 early_param("debug_guardpage_minorder", debug_guardpage_minorder_setup);
687
688 static inline bool set_page_guard(struct zone *zone, struct page *page,
689                                 unsigned int order, int migratetype)
690 {
691         struct page_ext *page_ext;
692
693         if (!debug_guardpage_enabled())
694                 return false;
695
696         if (order >= debug_guardpage_minorder())
697                 return false;
698
699         page_ext = lookup_page_ext(page);
700         if (unlikely(!page_ext))
701                 return false;
702
703         __set_bit(PAGE_EXT_DEBUG_GUARD, &page_ext->flags);
704
705         INIT_LIST_HEAD(&page->lru);
706         set_page_private(page, order);
707         /* Guard pages are not available for any usage */
708         __mod_zone_freepage_state(zone, -(1 << order), migratetype);
709
710         return true;
711 }
712
713 static inline void clear_page_guard(struct zone *zone, struct page *page,
714                                 unsigned int order, int migratetype)
715 {
716         struct page_ext *page_ext;
717
718         if (!debug_guardpage_enabled())
719                 return;
720
721         page_ext = lookup_page_ext(page);
722         if (unlikely(!page_ext))
723                 return;
724
725         __clear_bit(PAGE_EXT_DEBUG_GUARD, &page_ext->flags);
726
727         set_page_private(page, 0);
728         if (!is_migrate_isolate(migratetype))
729                 __mod_zone_freepage_state(zone, (1 << order), migratetype);
730 }
731 #else
732 struct page_ext_operations debug_guardpage_ops;
733 static inline bool set_page_guard(struct zone *zone, struct page *page,
734                         unsigned int order, int migratetype) { return false; }
735 static inline void clear_page_guard(struct zone *zone, struct page *page,
736                                 unsigned int order, int migratetype) {}
737 #endif
738
739 static inline void set_page_order(struct page *page, unsigned int order)
740 {
741         set_page_private(page, order);
742         __SetPageBuddy(page);
743 }
744
745 static inline void rmv_page_order(struct page *page)
746 {
747         __ClearPageBuddy(page);
748         set_page_private(page, 0);
749 }
750
751 /*
752  * This function checks whether a page is free && is the buddy
753  * we can coalesce a page and its buddy if
754  * (a) the buddy is not in a hole (check before calling!) &&
755  * (b) the buddy is in the buddy system &&
756  * (c) a page and its buddy have the same order &&
757  * (d) a page and its buddy are in the same zone.
758  *
759  * For recording whether a page is in the buddy system, we set PageBuddy.
760  * Setting, clearing, and testing PageBuddy is serialized by zone->lock.
761  *
762  * For recording page's order, we use page_private(page).
763  */
764 static inline int page_is_buddy(struct page *page, struct page *buddy,
765                                                         unsigned int order)
766 {
767         if (page_is_guard(buddy) && page_order(buddy) == order) {
768                 if (page_zone_id(page) != page_zone_id(buddy))
769                         return 0;
770
771                 VM_BUG_ON_PAGE(page_count(buddy) != 0, buddy);
772
773                 return 1;
774         }
775
776         if (PageBuddy(buddy) && page_order(buddy) == order) {
777                 /*
778                  * zone check is done late to avoid uselessly
779                  * calculating zone/node ids for pages that could
780                  * never merge.
781                  */
782                 if (page_zone_id(page) != page_zone_id(buddy))
783                         return 0;
784
785                 VM_BUG_ON_PAGE(page_count(buddy) != 0, buddy);
786
787                 return 1;
788         }
789         return 0;
790 }
791
792 /*
793  * Freeing function for a buddy system allocator.
794  *
795  * The concept of a buddy system is to maintain direct-mapped table
796  * (containing bit values) for memory blocks of various "orders".
797  * The bottom level table contains the map for the smallest allocatable
798  * units of memory (here, pages), and each level above it describes
799  * pairs of units from the levels below, hence, "buddies".
800  * At a high level, all that happens here is marking the table entry
801  * at the bottom level available, and propagating the changes upward
802  * as necessary, plus some accounting needed to play nicely with other
803  * parts of the VM system.
804  * At each level, we keep a list of pages, which are heads of continuous
805  * free pages of length of (1 << order) and marked with PageBuddy.
806  * Page's order is recorded in page_private(page) field.
807  * So when we are allocating or freeing one, we can derive the state of the
808  * other.  That is, if we allocate a small block, and both were
809  * free, the remainder of the region must be split into blocks.
810  * If a block is freed, and its buddy is also free, then this
811  * triggers coalescing into a block of larger size.
812  *
813  * -- nyc
814  */
815
816 static inline void __free_one_page(struct page *page,
817                 unsigned long pfn,
818                 struct zone *zone, unsigned int order,
819                 int migratetype)
820 {
821         unsigned long combined_pfn;
822         unsigned long uninitialized_var(buddy_pfn);
823         struct page *buddy;
824         unsigned int max_order;
825
826         max_order = min_t(unsigned int, MAX_ORDER, pageblock_order + 1);
827
828         VM_BUG_ON(!zone_is_initialized(zone));
829         VM_BUG_ON_PAGE(page->flags & PAGE_FLAGS_CHECK_AT_PREP, page);
830
831         VM_BUG_ON(migratetype == -1);
832         if (likely(!is_migrate_isolate(migratetype)))
833                 __mod_zone_freepage_state(zone, 1 << order, migratetype);
834
835         VM_BUG_ON_PAGE(pfn & ((1 << order) - 1), page);
836         VM_BUG_ON_PAGE(bad_range(zone, page), page);
837
838 continue_merging:
839         while (order < max_order - 1) {
840                 buddy_pfn = __find_buddy_pfn(pfn, order);
841                 buddy = page + (buddy_pfn - pfn);
842
843                 if (!pfn_valid_within(buddy_pfn))
844                         goto done_merging;
845                 if (!page_is_buddy(page, buddy, order))
846                         goto done_merging;
847                 /*
848                  * Our buddy is free or it is CONFIG_DEBUG_PAGEALLOC guard page,
849                  * merge with it and move up one order.
850                  */
851                 if (page_is_guard(buddy)) {
852                         clear_page_guard(zone, buddy, order, migratetype);
853                 } else {
854                         list_del(&buddy->lru);
855                         zone->free_area[order].nr_free--;
856                         rmv_page_order(buddy);
857                 }
858                 combined_pfn = buddy_pfn & pfn;
859                 page = page + (combined_pfn - pfn);
860                 pfn = combined_pfn;
861                 order++;
862         }
863         if (max_order < MAX_ORDER) {
864                 /* If we are here, it means order is >= pageblock_order.
865                  * We want to prevent merge between freepages on isolate
866                  * pageblock and normal pageblock. Without this, pageblock
867                  * isolation could cause incorrect freepage or CMA accounting.
868                  *
869                  * We don't want to hit this code for the more frequent
870                  * low-order merging.
871                  */
872                 if (unlikely(has_isolate_pageblock(zone))) {
873                         int buddy_mt;
874
875                         buddy_pfn = __find_buddy_pfn(pfn, order);
876                         buddy = page + (buddy_pfn - pfn);
877                         buddy_mt = get_pageblock_migratetype(buddy);
878
879                         if (migratetype != buddy_mt
880                                         && (is_migrate_isolate(migratetype) ||
881                                                 is_migrate_isolate(buddy_mt)))
882                                 goto done_merging;
883                 }
884                 max_order++;
885                 goto continue_merging;
886         }
887
888 done_merging:
889         set_page_order(page, order);
890
891         /*
892          * If this is not the largest possible page, check if the buddy
893          * of the next-highest order is free. If it is, it's possible
894          * that pages are being freed that will coalesce soon. In case,
895          * that is happening, add the free page to the tail of the list
896          * so it's less likely to be used soon and more likely to be merged
897          * as a higher order page
898          */
899         if ((order < MAX_ORDER-2) && pfn_valid_within(buddy_pfn)) {
900                 struct page *higher_page, *higher_buddy;
901                 combined_pfn = buddy_pfn & pfn;
902                 higher_page = page + (combined_pfn - pfn);
903                 buddy_pfn = __find_buddy_pfn(combined_pfn, order + 1);
904                 higher_buddy = higher_page + (buddy_pfn - combined_pfn);
905                 if (pfn_valid_within(buddy_pfn) &&
906                     page_is_buddy(higher_page, higher_buddy, order + 1)) {
907                         list_add_tail(&page->lru,
908                                 &zone->free_area[order].free_list[migratetype]);
909                         goto out;
910                 }
911         }
912
913         list_add(&page->lru, &zone->free_area[order].free_list[migratetype]);
914 out:
915         zone->free_area[order].nr_free++;
916 }
917
918 /*
919  * A bad page could be due to a number of fields. Instead of multiple branches,
920  * try and check multiple fields with one check. The caller must do a detailed
921  * check if necessary.
922  */
923 static inline bool page_expected_state(struct page *page,
924                                         unsigned long check_flags)
925 {
926         if (unlikely(atomic_read(&page->_mapcount) != -1))
927                 return false;
928
929         if (unlikely((unsigned long)page->mapping |
930                         page_ref_count(page) |
931 #ifdef CONFIG_MEMCG
932                         (unsigned long)page->mem_cgroup |
933 #endif
934                         (page->flags & check_flags)))
935                 return false;
936
937         return true;
938 }
939
940 static void free_pages_check_bad(struct page *page)
941 {
942         const char *bad_reason;
943         unsigned long bad_flags;
944
945         bad_reason = NULL;
946         bad_flags = 0;
947
948         if (unlikely(atomic_read(&page->_mapcount) != -1))
949                 bad_reason = "nonzero mapcount";
950         if (unlikely(page->mapping != NULL))
951                 bad_reason = "non-NULL mapping";
952         if (unlikely(page_ref_count(page) != 0))
953                 bad_reason = "nonzero _refcount";
954         if (unlikely(page->flags & PAGE_FLAGS_CHECK_AT_FREE)) {
955                 bad_reason = "PAGE_FLAGS_CHECK_AT_FREE flag(s) set";
956                 bad_flags = PAGE_FLAGS_CHECK_AT_FREE;
957         }
958 #ifdef CONFIG_MEMCG
959         if (unlikely(page->mem_cgroup))
960                 bad_reason = "page still charged to cgroup";
961 #endif
962         bad_page(page, bad_reason, bad_flags);
963 }
964
965 static inline int free_pages_check(struct page *page)
966 {
967         if (likely(page_expected_state(page, PAGE_FLAGS_CHECK_AT_FREE)))
968                 return 0;
969
970         /* Something has gone sideways, find it */
971         free_pages_check_bad(page);
972         return 1;
973 }
974
975 static int free_tail_pages_check(struct page *head_page, struct page *page)
976 {
977         int ret = 1;
978
979         /*
980          * We rely page->lru.next never has bit 0 set, unless the page
981          * is PageTail(). Let's make sure that's true even for poisoned ->lru.
982          */
983         BUILD_BUG_ON((unsigned long)LIST_POISON1 & 1);
984
985         if (!IS_ENABLED(CONFIG_DEBUG_VM)) {
986                 ret = 0;
987                 goto out;
988         }
989         switch (page - head_page) {
990         case 1:
991                 /* the first tail page: ->mapping may be compound_mapcount() */
992                 if (unlikely(compound_mapcount(page))) {
993                         bad_page(page, "nonzero compound_mapcount", 0);
994                         goto out;
995                 }
996                 break;
997         case 2:
998                 /*
999                  * the second tail page: ->mapping is
1000                  * deferred_list.next -- ignore value.
1001                  */
1002                 break;
1003         default:
1004                 if (page->mapping != TAIL_MAPPING) {
1005                         bad_page(page, "corrupted mapping in tail page", 0);
1006                         goto out;
1007                 }
1008                 break;
1009         }
1010         if (unlikely(!PageTail(page))) {
1011                 bad_page(page, "PageTail not set", 0);
1012                 goto out;
1013         }
1014         if (unlikely(compound_head(page) != head_page)) {
1015                 bad_page(page, "compound_head not consistent", 0);
1016                 goto out;
1017         }
1018         ret = 0;
1019 out:
1020         page->mapping = NULL;
1021         clear_compound_head(page);
1022         return ret;
1023 }
1024
1025 static __always_inline bool free_pages_prepare(struct page *page,
1026                                         unsigned int order, bool check_free)
1027 {
1028         int bad = 0;
1029
1030         VM_BUG_ON_PAGE(PageTail(page), page);
1031
1032         trace_mm_page_free(page, order);
1033
1034         /*
1035          * Check tail pages before head page information is cleared to
1036          * avoid checking PageCompound for order-0 pages.
1037          */
1038         if (unlikely(order)) {
1039                 bool compound = PageCompound(page);
1040                 int i;
1041
1042                 VM_BUG_ON_PAGE(compound && compound_order(page) != order, page);
1043
1044                 if (compound)
1045                         ClearPageDoubleMap(page);
1046                 for (i = 1; i < (1 << order); i++) {
1047                         if (compound)
1048                                 bad += free_tail_pages_check(page, page + i);
1049                         if (unlikely(free_pages_check(page + i))) {
1050                                 bad++;
1051                                 continue;
1052                         }
1053                         (page + i)->flags &= ~PAGE_FLAGS_CHECK_AT_PREP;
1054                 }
1055         }
1056         if (PageMappingFlags(page))
1057                 page->mapping = NULL;
1058         if (memcg_kmem_enabled() && PageKmemcg(page))
1059                 memcg_kmem_uncharge(page, order);
1060         if (check_free)
1061                 bad += free_pages_check(page);
1062         if (bad)
1063                 return false;
1064
1065         page_cpupid_reset_last(page);
1066         page->flags &= ~PAGE_FLAGS_CHECK_AT_PREP;
1067         reset_page_owner(page, order);
1068
1069         if (!PageHighMem(page)) {
1070                 debug_check_no_locks_freed(page_address(page),
1071                                            PAGE_SIZE << order);
1072                 debug_check_no_obj_freed(page_address(page),
1073                                            PAGE_SIZE << order);
1074         }
1075         arch_free_page(page, order);
1076         kernel_poison_pages(page, 1 << order, 0);
1077         kernel_map_pages(page, 1 << order, 0);
1078         kasan_free_nondeferred_pages(page, order);
1079
1080         return true;
1081 }
1082
1083 #ifdef CONFIG_DEBUG_VM
1084 static inline bool free_pcp_prepare(struct page *page)
1085 {
1086         return free_pages_prepare(page, 0, true);
1087 }
1088
1089 static inline bool bulkfree_pcp_prepare(struct page *page)
1090 {
1091         return false;
1092 }
1093 #else
1094 static bool free_pcp_prepare(struct page *page)
1095 {
1096         return free_pages_prepare(page, 0, false);
1097 }
1098
1099 static bool bulkfree_pcp_prepare(struct page *page)
1100 {
1101         return free_pages_check(page);
1102 }
1103 #endif /* CONFIG_DEBUG_VM */
1104
1105 static inline void prefetch_buddy(struct page *page)
1106 {
1107         unsigned long pfn = page_to_pfn(page);
1108         unsigned long buddy_pfn = __find_buddy_pfn(pfn, 0);
1109         struct page *buddy = page + (buddy_pfn - pfn);
1110
1111         prefetch(buddy);
1112 }
1113
1114 /*
1115  * Frees a number of pages from the PCP lists
1116  * Assumes all pages on list are in same zone, and of same order.
1117  * count is the number of pages to free.
1118  *
1119  * If the zone was previously in an "all pages pinned" state then look to
1120  * see if this freeing clears that state.
1121  *
1122  * And clear the zone's pages_scanned counter, to hold off the "all pages are
1123  * pinned" detection logic.
1124  */
1125 static void free_pcppages_bulk(struct zone *zone, int count,
1126                                         struct per_cpu_pages *pcp)
1127 {
1128         int migratetype = 0;
1129         int batch_free = 0;
1130         int prefetch_nr = 0;
1131         bool isolated_pageblocks;
1132         struct page *page, *tmp;
1133         LIST_HEAD(head);
1134
1135         while (count) {
1136                 struct list_head *list;
1137
1138                 /*
1139                  * Remove pages from lists in a round-robin fashion. A
1140                  * batch_free count is maintained that is incremented when an
1141                  * empty list is encountered.  This is so more pages are freed
1142                  * off fuller lists instead of spinning excessively around empty
1143                  * lists
1144                  */
1145                 do {
1146                         batch_free++;
1147                         if (++migratetype == MIGRATE_PCPTYPES)
1148                                 migratetype = 0;
1149                         list = &pcp->lists[migratetype];
1150                 } while (list_empty(list));
1151
1152                 /* This is the only non-empty list. Free them all. */
1153                 if (batch_free == MIGRATE_PCPTYPES)
1154                         batch_free = count;
1155
1156                 do {
1157                         page = list_last_entry(list, struct page, lru);
1158                         /* must delete to avoid corrupting pcp list */
1159                         list_del(&page->lru);
1160                         pcp->count--;
1161
1162                         if (bulkfree_pcp_prepare(page))
1163                                 continue;
1164
1165                         list_add_tail(&page->lru, &head);
1166
1167                         /*
1168                          * We are going to put the page back to the global
1169                          * pool, prefetch its buddy to speed up later access
1170                          * under zone->lock. It is believed the overhead of
1171                          * an additional test and calculating buddy_pfn here
1172                          * can be offset by reduced memory latency later. To
1173                          * avoid excessive prefetching due to large count, only
1174                          * prefetch buddy for the first pcp->batch nr of pages.
1175                          */
1176                         if (prefetch_nr++ < pcp->batch)
1177                                 prefetch_buddy(page);
1178                 } while (--count && --batch_free && !list_empty(list));
1179         }
1180
1181         spin_lock(&zone->lock);
1182         isolated_pageblocks = has_isolate_pageblock(zone);
1183
1184         /*
1185          * Use safe version since after __free_one_page(),
1186          * page->lru.next will not point to original list.
1187          */
1188         list_for_each_entry_safe(page, tmp, &head, lru) {
1189                 int mt = get_pcppage_migratetype(page);
1190                 /* MIGRATE_ISOLATE page should not go to pcplists */
1191                 VM_BUG_ON_PAGE(is_migrate_isolate(mt), page);
1192                 /* Pageblock could have been isolated meanwhile */
1193                 if (unlikely(isolated_pageblocks))
1194                         mt = get_pageblock_migratetype(page);
1195
1196                 __free_one_page(page, page_to_pfn(page), zone, 0, mt);
1197                 trace_mm_page_pcpu_drain(page, 0, mt);
1198         }
1199         spin_unlock(&zone->lock);
1200 }
1201
1202 static void free_one_page(struct zone *zone,
1203                                 struct page *page, unsigned long pfn,
1204                                 unsigned int order,
1205                                 int migratetype)
1206 {
1207         spin_lock(&zone->lock);
1208         if (unlikely(has_isolate_pageblock(zone) ||
1209                 is_migrate_isolate(migratetype))) {
1210                 migratetype = get_pfnblock_migratetype(page, pfn);
1211         }
1212         __free_one_page(page, pfn, zone, order, migratetype);
1213         spin_unlock(&zone->lock);
1214 }
1215
1216 static void __meminit __init_single_page(struct page *page, unsigned long pfn,
1217                                 unsigned long zone, int nid)
1218 {
1219         mm_zero_struct_page(page);
1220         set_page_links(page, zone, nid, pfn);
1221         init_page_count(page);
1222         page_mapcount_reset(page);
1223         page_cpupid_reset_last(page);
1224         page_kasan_tag_reset(page);
1225
1226         INIT_LIST_HEAD(&page->lru);
1227 #ifdef WANT_PAGE_VIRTUAL
1228         /* The shift won't overflow because ZONE_NORMAL is below 4G. */
1229         if (!is_highmem_idx(zone))
1230                 set_page_address(page, __va(pfn << PAGE_SHIFT));
1231 #endif
1232 }
1233
1234 #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
1235 static void __meminit init_reserved_page(unsigned long pfn)
1236 {
1237         pg_data_t *pgdat;
1238         int nid, zid;
1239
1240         if (!early_page_uninitialised(pfn))
1241                 return;
1242
1243         nid = early_pfn_to_nid(pfn);
1244         pgdat = NODE_DATA(nid);
1245
1246         for (zid = 0; zid < MAX_NR_ZONES; zid++) {
1247                 struct zone *zone = &pgdat->node_zones[zid];
1248
1249                 if (pfn >= zone->zone_start_pfn && pfn < zone_end_pfn(zone))
1250                         break;
1251         }
1252         __init_single_page(pfn_to_page(pfn), pfn, zid, nid);
1253 }
1254 #else
1255 static inline void init_reserved_page(unsigned long pfn)
1256 {
1257 }
1258 #endif /* CONFIG_DEFERRED_STRUCT_PAGE_INIT */
1259
1260 /*
1261  * Initialised pages do not have PageReserved set. This function is
1262  * called for each range allocated by the bootmem allocator and
1263  * marks the pages PageReserved. The remaining valid pages are later
1264  * sent to the buddy page allocator.
1265  */
1266 void __meminit reserve_bootmem_region(phys_addr_t start, phys_addr_t end)
1267 {
1268         unsigned long start_pfn = PFN_DOWN(start);
1269         unsigned long end_pfn = PFN_UP(end);
1270
1271         for (; start_pfn < end_pfn; start_pfn++) {
1272                 if (pfn_valid(start_pfn)) {
1273                         struct page *page = pfn_to_page(start_pfn);
1274
1275                         init_reserved_page(start_pfn);
1276
1277                         /* Avoid false-positive PageTail() */
1278                         INIT_LIST_HEAD(&page->lru);
1279
1280                         /*
1281                          * no need for atomic set_bit because the struct
1282                          * page is not visible yet so nobody should
1283                          * access it yet.
1284                          */
1285                         __SetPageReserved(page);
1286                 }
1287         }
1288 }
1289
1290 static void __free_pages_ok(struct page *page, unsigned int order)
1291 {
1292         unsigned long flags;
1293         int migratetype;
1294         unsigned long pfn = page_to_pfn(page);
1295
1296         if (!free_pages_prepare(page, order, true))
1297                 return;
1298
1299         migratetype = get_pfnblock_migratetype(page, pfn);
1300         local_irq_save(flags);
1301         __count_vm_events(PGFREE, 1 << order);
1302         free_one_page(page_zone(page), page, pfn, order, migratetype);
1303         local_irq_restore(flags);
1304 }
1305
1306 static void __init __free_pages_boot_core(struct page *page, unsigned int order)
1307 {
1308         unsigned int nr_pages = 1 << order;
1309         struct page *p = page;
1310         unsigned int loop;
1311
1312         prefetchw(p);
1313         for (loop = 0; loop < (nr_pages - 1); loop++, p++) {
1314                 prefetchw(p + 1);
1315                 __ClearPageReserved(p);
1316                 set_page_count(p, 0);
1317         }
1318         __ClearPageReserved(p);
1319         set_page_count(p, 0);
1320
1321         atomic_long_add(nr_pages, &page_zone(page)->managed_pages);
1322         set_page_refcounted(page);
1323         __free_pages(page, order);
1324 }
1325
1326 #if defined(CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID) || \
1327         defined(CONFIG_HAVE_MEMBLOCK_NODE_MAP)
1328
1329 static struct mminit_pfnnid_cache early_pfnnid_cache __meminitdata;
1330
1331 int __meminit early_pfn_to_nid(unsigned long pfn)
1332 {
1333         static DEFINE_SPINLOCK(early_pfn_lock);
1334         int nid;
1335
1336         spin_lock(&early_pfn_lock);
1337         nid = __early_pfn_to_nid(pfn, &early_pfnnid_cache);
1338         if (nid < 0)
1339                 nid = first_online_node;
1340         spin_unlock(&early_pfn_lock);
1341
1342         return nid;
1343 }
1344 #endif
1345
1346 #ifdef CONFIG_NODES_SPAN_OTHER_NODES
1347 static inline bool __meminit __maybe_unused
1348 meminit_pfn_in_nid(unsigned long pfn, int node,
1349                    struct mminit_pfnnid_cache *state)
1350 {
1351         int nid;
1352
1353         nid = __early_pfn_to_nid(pfn, state);
1354         if (nid >= 0 && nid != node)
1355                 return false;
1356         return true;
1357 }
1358
1359 /* Only safe to use early in boot when initialisation is single-threaded */
1360 static inline bool __meminit early_pfn_in_nid(unsigned long pfn, int node)
1361 {
1362         return meminit_pfn_in_nid(pfn, node, &early_pfnnid_cache);
1363 }
1364
1365 #else
1366
1367 static inline bool __meminit early_pfn_in_nid(unsigned long pfn, int node)
1368 {
1369         return true;
1370 }
1371 static inline bool __meminit  __maybe_unused
1372 meminit_pfn_in_nid(unsigned long pfn, int node,
1373                    struct mminit_pfnnid_cache *state)
1374 {
1375         return true;
1376 }
1377 #endif
1378
1379
1380 void __init memblock_free_pages(struct page *page, unsigned long pfn,
1381                                                         unsigned int order)
1382 {
1383         if (early_page_uninitialised(pfn))
1384                 return;
1385         return __free_pages_boot_core(page, order);
1386 }
1387
1388 /*
1389  * Check that the whole (or subset of) a pageblock given by the interval of
1390  * [start_pfn, end_pfn) is valid and within the same zone, before scanning it
1391  * with the migration of free compaction scanner. The scanners then need to
1392  * use only pfn_valid_within() check for arches that allow holes within
1393  * pageblocks.
1394  *
1395  * Return struct page pointer of start_pfn, or NULL if checks were not passed.
1396  *
1397  * It's possible on some configurations to have a setup like node0 node1 node0
1398  * i.e. it's possible that all pages within a zones range of pages do not
1399  * belong to a single zone. We assume that a border between node0 and node1
1400  * can occur within a single pageblock, but not a node0 node1 node0
1401  * interleaving within a single pageblock. It is therefore sufficient to check
1402  * the first and last page of a pageblock and avoid checking each individual
1403  * page in a pageblock.
1404  */
1405 struct page *__pageblock_pfn_to_page(unsigned long start_pfn,
1406                                      unsigned long end_pfn, struct zone *zone)
1407 {
1408         struct page *start_page;
1409         struct page *end_page;
1410
1411         /* end_pfn is one past the range we are checking */
1412         end_pfn--;
1413
1414         if (!pfn_valid(start_pfn) || !pfn_valid(end_pfn))
1415                 return NULL;
1416
1417         start_page = pfn_to_online_page(start_pfn);
1418         if (!start_page)
1419                 return NULL;
1420
1421         if (page_zone(start_page) != zone)
1422                 return NULL;
1423
1424         end_page = pfn_to_page(end_pfn);
1425
1426         /* This gives a shorter code than deriving page_zone(end_page) */
1427         if (page_zone_id(start_page) != page_zone_id(end_page))
1428                 return NULL;
1429
1430         return start_page;
1431 }
1432
1433 void set_zone_contiguous(struct zone *zone)
1434 {
1435         unsigned long block_start_pfn = zone->zone_start_pfn;
1436         unsigned long block_end_pfn;
1437
1438         block_end_pfn = ALIGN(block_start_pfn + 1, pageblock_nr_pages);
1439         for (; block_start_pfn < zone_end_pfn(zone);
1440                         block_start_pfn = block_end_pfn,
1441                          block_end_pfn += pageblock_nr_pages) {
1442
1443                 block_end_pfn = min(block_end_pfn, zone_end_pfn(zone));
1444
1445                 if (!__pageblock_pfn_to_page(block_start_pfn,
1446                                              block_end_pfn, zone))
1447                         return;
1448         }
1449
1450         /* We confirm that there is no hole */
1451         zone->contiguous = true;
1452 }
1453
1454 void clear_zone_contiguous(struct zone *zone)
1455 {
1456         zone->contiguous = false;
1457 }
1458
1459 #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
1460 static void __init deferred_free_range(unsigned long pfn,
1461                                        unsigned long nr_pages)
1462 {
1463         struct page *page;
1464         unsigned long i;
1465
1466         if (!nr_pages)
1467                 return;
1468
1469         page = pfn_to_page(pfn);
1470
1471         /* Free a large naturally-aligned chunk if possible */
1472         if (nr_pages == pageblock_nr_pages &&
1473             (pfn & (pageblock_nr_pages - 1)) == 0) {
1474                 set_pageblock_migratetype(page, MIGRATE_MOVABLE);
1475                 __free_pages_boot_core(page, pageblock_order);
1476                 return;
1477         }
1478
1479         for (i = 0; i < nr_pages; i++, page++, pfn++) {
1480                 if ((pfn & (pageblock_nr_pages - 1)) == 0)
1481                         set_pageblock_migratetype(page, MIGRATE_MOVABLE);
1482                 __free_pages_boot_core(page, 0);
1483         }
1484 }
1485
1486 /* Completion tracking for deferred_init_memmap() threads */
1487 static atomic_t pgdat_init_n_undone __initdata;
1488 static __initdata DECLARE_COMPLETION(pgdat_init_all_done_comp);
1489
1490 static inline void __init pgdat_init_report_one_done(void)
1491 {
1492         if (atomic_dec_and_test(&pgdat_init_n_undone))
1493                 complete(&pgdat_init_all_done_comp);
1494 }
1495
1496 /*
1497  * Returns true if page needs to be initialized or freed to buddy allocator.
1498  *
1499  * First we check if pfn is valid on architectures where it is possible to have
1500  * holes within pageblock_nr_pages. On systems where it is not possible, this
1501  * function is optimized out.
1502  *
1503  * Then, we check if a current large page is valid by only checking the validity
1504  * of the head pfn.
1505  *
1506  * Finally, meminit_pfn_in_nid is checked on systems where pfns can interleave
1507  * within a node: a pfn is between start and end of a node, but does not belong
1508  * to this memory node.
1509  */
1510 static inline bool __init
1511 deferred_pfn_valid(int nid, unsigned long pfn,
1512                    struct mminit_pfnnid_cache *nid_init_state)
1513 {
1514         if (!pfn_valid_within(pfn))
1515                 return false;
1516         if (!(pfn & (pageblock_nr_pages - 1)) && !pfn_valid(pfn))
1517                 return false;
1518         if (!meminit_pfn_in_nid(pfn, nid, nid_init_state))
1519                 return false;
1520         return true;
1521 }
1522
1523 /*
1524  * Free pages to buddy allocator. Try to free aligned pages in
1525  * pageblock_nr_pages sizes.
1526  */
1527 static void __init deferred_free_pages(int nid, int zid, unsigned long pfn,
1528                                        unsigned long end_pfn)
1529 {
1530         struct mminit_pfnnid_cache nid_init_state = { };
1531         unsigned long nr_pgmask = pageblock_nr_pages - 1;
1532         unsigned long nr_free = 0;
1533
1534         for (; pfn < end_pfn; pfn++) {
1535                 if (!deferred_pfn_valid(nid, pfn, &nid_init_state)) {
1536                         deferred_free_range(pfn - nr_free, nr_free);
1537                         nr_free = 0;
1538                 } else if (!(pfn & nr_pgmask)) {
1539                         deferred_free_range(pfn - nr_free, nr_free);
1540                         nr_free = 1;
1541                         touch_nmi_watchdog();
1542                 } else {
1543                         nr_free++;
1544                 }
1545         }
1546         /* Free the last block of pages to allocator */
1547         deferred_free_range(pfn - nr_free, nr_free);
1548 }
1549
1550 /*
1551  * Initialize struct pages.  We minimize pfn page lookups and scheduler checks
1552  * by performing it only once every pageblock_nr_pages.
1553  * Return number of pages initialized.
1554  */
1555 static unsigned long  __init deferred_init_pages(int nid, int zid,
1556                                                  unsigned long pfn,
1557                                                  unsigned long end_pfn)
1558 {
1559         struct mminit_pfnnid_cache nid_init_state = { };
1560         unsigned long nr_pgmask = pageblock_nr_pages - 1;
1561         unsigned long nr_pages = 0;
1562         struct page *page = NULL;
1563
1564         for (; pfn < end_pfn; pfn++) {
1565                 if (!deferred_pfn_valid(nid, pfn, &nid_init_state)) {
1566                         page = NULL;
1567                         continue;
1568                 } else if (!page || !(pfn & nr_pgmask)) {
1569                         page = pfn_to_page(pfn);
1570                         touch_nmi_watchdog();
1571                 } else {
1572                         page++;
1573                 }
1574                 __init_single_page(page, pfn, zid, nid);
1575                 nr_pages++;
1576         }
1577         return (nr_pages);
1578 }
1579
1580 /* Initialise remaining memory on a node */
1581 static int __init deferred_init_memmap(void *data)
1582 {
1583         pg_data_t *pgdat = data;
1584         int nid = pgdat->node_id;
1585         unsigned long start = jiffies;
1586         unsigned long nr_pages = 0;
1587         unsigned long spfn, epfn, first_init_pfn, flags;
1588         phys_addr_t spa, epa;
1589         int zid;
1590         struct zone *zone;
1591         const struct cpumask *cpumask = cpumask_of_node(pgdat->node_id);
1592         u64 i;
1593
1594         /* Bind memory initialisation thread to a local node if possible */
1595         if (!cpumask_empty(cpumask))
1596                 set_cpus_allowed_ptr(current, cpumask);
1597
1598         pgdat_resize_lock(pgdat, &flags);
1599         first_init_pfn = pgdat->first_deferred_pfn;
1600         if (first_init_pfn == ULONG_MAX) {
1601                 pgdat_resize_unlock(pgdat, &flags);
1602                 pgdat_init_report_one_done();
1603                 return 0;
1604         }
1605
1606         /* Sanity check boundaries */
1607         BUG_ON(pgdat->first_deferred_pfn < pgdat->node_start_pfn);
1608         BUG_ON(pgdat->first_deferred_pfn > pgdat_end_pfn(pgdat));
1609         pgdat->first_deferred_pfn = ULONG_MAX;
1610
1611         /* Only the highest zone is deferred so find it */
1612         for (zid = 0; zid < MAX_NR_ZONES; zid++) {
1613                 zone = pgdat->node_zones + zid;
1614                 if (first_init_pfn < zone_end_pfn(zone))
1615                         break;
1616         }
1617         first_init_pfn = max(zone->zone_start_pfn, first_init_pfn);
1618
1619         /*
1620          * Initialize and free pages. We do it in two loops: first we initialize
1621          * struct page, than free to buddy allocator, because while we are
1622          * freeing pages we can access pages that are ahead (computing buddy
1623          * page in __free_one_page()).
1624          */
1625         for_each_free_mem_range(i, nid, MEMBLOCK_NONE, &spa, &epa, NULL) {
1626                 spfn = max_t(unsigned long, first_init_pfn, PFN_UP(spa));
1627                 epfn = min_t(unsigned long, zone_end_pfn(zone), PFN_DOWN(epa));
1628                 nr_pages += deferred_init_pages(nid, zid, spfn, epfn);
1629         }
1630         for_each_free_mem_range(i, nid, MEMBLOCK_NONE, &spa, &epa, NULL) {
1631                 spfn = max_t(unsigned long, first_init_pfn, PFN_UP(spa));
1632                 epfn = min_t(unsigned long, zone_end_pfn(zone), PFN_DOWN(epa));
1633                 deferred_free_pages(nid, zid, spfn, epfn);
1634         }
1635         pgdat_resize_unlock(pgdat, &flags);
1636
1637         /* Sanity check that the next zone really is unpopulated */
1638         WARN_ON(++zid < MAX_NR_ZONES && populated_zone(++zone));
1639
1640         pr_info("node %d initialised, %lu pages in %ums\n", nid, nr_pages,
1641                                         jiffies_to_msecs(jiffies - start));
1642
1643         pgdat_init_report_one_done();
1644         return 0;
1645 }
1646
1647 /*
1648  * If this zone has deferred pages, try to grow it by initializing enough
1649  * deferred pages to satisfy the allocation specified by order, rounded up to
1650  * the nearest PAGES_PER_SECTION boundary.  So we're adding memory in increments
1651  * of SECTION_SIZE bytes by initializing struct pages in increments of
1652  * PAGES_PER_SECTION * sizeof(struct page) bytes.
1653  *
1654  * Return true when zone was grown, otherwise return false. We return true even
1655  * when we grow less than requested, to let the caller decide if there are
1656  * enough pages to satisfy the allocation.
1657  *
1658  * Note: We use noinline because this function is needed only during boot, and
1659  * it is called from a __ref function _deferred_grow_zone. This way we are
1660  * making sure that it is not inlined into permanent text section.
1661  */
1662 static noinline bool __init
1663 deferred_grow_zone(struct zone *zone, unsigned int order)
1664 {
1665         int zid = zone_idx(zone);
1666         int nid = zone_to_nid(zone);
1667         pg_data_t *pgdat = NODE_DATA(nid);
1668         unsigned long nr_pages_needed = ALIGN(1 << order, PAGES_PER_SECTION);
1669         unsigned long nr_pages = 0;
1670         unsigned long first_init_pfn, spfn, epfn, t, flags;
1671         unsigned long first_deferred_pfn = pgdat->first_deferred_pfn;
1672         phys_addr_t spa, epa;
1673         u64 i;
1674
1675         /* Only the last zone may have deferred pages */
1676         if (zone_end_pfn(zone) != pgdat_end_pfn(pgdat))
1677                 return false;
1678
1679         pgdat_resize_lock(pgdat, &flags);
1680
1681         /*
1682          * If deferred pages have been initialized while we were waiting for
1683          * the lock, return true, as the zone was grown.  The caller will retry
1684          * this zone.  We won't return to this function since the caller also
1685          * has this static branch.
1686          */
1687         if (!static_branch_unlikely(&deferred_pages)) {
1688                 pgdat_resize_unlock(pgdat, &flags);
1689                 return true;
1690         }
1691
1692         /*
1693          * If someone grew this zone while we were waiting for spinlock, return
1694          * true, as there might be enough pages already.
1695          */
1696         if (first_deferred_pfn != pgdat->first_deferred_pfn) {
1697                 pgdat_resize_unlock(pgdat, &flags);
1698                 return true;
1699         }
1700
1701         first_init_pfn = max(zone->zone_start_pfn, first_deferred_pfn);
1702
1703         if (first_init_pfn >= pgdat_end_pfn(pgdat)) {
1704                 pgdat_resize_unlock(pgdat, &flags);
1705                 return false;
1706         }
1707
1708         for_each_free_mem_range(i, nid, MEMBLOCK_NONE, &spa, &epa, NULL) {
1709                 spfn = max_t(unsigned long, first_init_pfn, PFN_UP(spa));
1710                 epfn = min_t(unsigned long, zone_end_pfn(zone), PFN_DOWN(epa));
1711
1712                 while (spfn < epfn && nr_pages < nr_pages_needed) {
1713                         t = ALIGN(spfn + PAGES_PER_SECTION, PAGES_PER_SECTION);
1714                         first_deferred_pfn = min(t, epfn);
1715                         nr_pages += deferred_init_pages(nid, zid, spfn,
1716                                                         first_deferred_pfn);
1717                         spfn = first_deferred_pfn;
1718                 }
1719
1720                 if (nr_pages >= nr_pages_needed)
1721                         break;
1722         }
1723
1724         for_each_free_mem_range(i, nid, MEMBLOCK_NONE, &spa, &epa, NULL) {
1725                 spfn = max_t(unsigned long, first_init_pfn, PFN_UP(spa));
1726                 epfn = min_t(unsigned long, first_deferred_pfn, PFN_DOWN(epa));
1727                 deferred_free_pages(nid, zid, spfn, epfn);
1728
1729                 if (first_deferred_pfn == epfn)
1730                         break;
1731         }
1732         pgdat->first_deferred_pfn = first_deferred_pfn;
1733         pgdat_resize_unlock(pgdat, &flags);
1734
1735         return nr_pages > 0;
1736 }
1737
1738 /*
1739  * deferred_grow_zone() is __init, but it is called from
1740  * get_page_from_freelist() during early boot until deferred_pages permanently
1741  * disables this call. This is why we have refdata wrapper to avoid warning,
1742  * and to ensure that the function body gets unloaded.
1743  */
1744 static bool __ref
1745 _deferred_grow_zone(struct zone *zone, unsigned int order)
1746 {
1747         return deferred_grow_zone(zone, order);
1748 }
1749
1750 #endif /* CONFIG_DEFERRED_STRUCT_PAGE_INIT */
1751
1752 void __init page_alloc_init_late(void)
1753 {
1754         struct zone *zone;
1755
1756 #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
1757         int nid;
1758
1759         /* There will be num_node_state(N_MEMORY) threads */
1760         atomic_set(&pgdat_init_n_undone, num_node_state(N_MEMORY));
1761         for_each_node_state(nid, N_MEMORY) {
1762                 kthread_run(deferred_init_memmap, NODE_DATA(nid), "pgdatinit%d", nid);
1763         }
1764
1765         /* Block until all are initialised */
1766         wait_for_completion(&pgdat_init_all_done_comp);
1767
1768         /*
1769          * We initialized the rest of the deferred pages.  Permanently disable
1770          * on-demand struct page initialization.
1771          */
1772         static_branch_disable(&deferred_pages);
1773
1774         /* Reinit limits that are based on free pages after the kernel is up */
1775         files_maxfiles_init();
1776 #endif
1777 #ifdef CONFIG_ARCH_DISCARD_MEMBLOCK
1778         /* Discard memblock private memory */
1779         memblock_discard();
1780 #endif
1781
1782         for_each_populated_zone(zone)
1783                 set_zone_contiguous(zone);
1784 }
1785
1786 #ifdef CONFIG_CMA
1787 /* Free whole pageblock and set its migration type to MIGRATE_CMA. */
1788 void __init init_cma_reserved_pageblock(struct page *page)
1789 {
1790         unsigned i = pageblock_nr_pages;
1791         struct page *p = page;
1792
1793         do {
1794                 __ClearPageReserved(p);
1795                 set_page_count(p, 0);
1796         } while (++p, --i);
1797
1798         set_pageblock_migratetype(page, MIGRATE_CMA);
1799
1800         if (pageblock_order >= MAX_ORDER) {
1801                 i = pageblock_nr_pages;
1802                 p = page;
1803                 do {
1804                         set_page_refcounted(p);
1805                         __free_pages(p, MAX_ORDER - 1);
1806                         p += MAX_ORDER_NR_PAGES;
1807                 } while (i -= MAX_ORDER_NR_PAGES);
1808         } else {
1809                 set_page_refcounted(page);
1810                 __free_pages(page, pageblock_order);
1811         }
1812
1813         adjust_managed_page_count(page, pageblock_nr_pages);
1814 }
1815 #endif
1816
1817 /*
1818  * The order of subdivision here is critical for the IO subsystem.
1819  * Please do not alter this order without good reasons and regression
1820  * testing. Specifically, as large blocks of memory are subdivided,
1821  * the order in which smaller blocks are delivered depends on the order
1822  * they're subdivided in this function. This is the primary factor
1823  * influencing the order in which pages are delivered to the IO
1824  * subsystem according to empirical testing, and this is also justified
1825  * by considering the behavior of a buddy system containing a single
1826  * large block of memory acted on by a series of small allocations.
1827  * This behavior is a critical factor in sglist merging's success.
1828  *
1829  * -- nyc
1830  */
1831 static inline void expand(struct zone *zone, struct page *page,
1832         int low, int high, struct free_area *area,
1833         int migratetype)
1834 {
1835         unsigned long size = 1 << high;
1836
1837         while (high > low) {
1838                 area--;
1839                 high--;
1840                 size >>= 1;
1841                 VM_BUG_ON_PAGE(bad_range(zone, &page[size]), &page[size]);
1842
1843                 /*
1844                  * Mark as guard pages (or page), that will allow to
1845                  * merge back to allocator when buddy will be freed.
1846                  * Corresponding page table entries will not be touched,
1847                  * pages will stay not present in virtual address space
1848                  */
1849                 if (set_page_guard(zone, &page[size], high, migratetype))
1850                         continue;
1851
1852                 list_add(&page[size].lru, &area->free_list[migratetype]);
1853                 area->nr_free++;
1854                 set_page_order(&page[size], high);
1855         }
1856 }
1857
1858 static void check_new_page_bad(struct page *page)
1859 {
1860         const char *bad_reason = NULL;
1861         unsigned long bad_flags = 0;
1862
1863         if (unlikely(atomic_read(&page->_mapcount) != -1))
1864                 bad_reason = "nonzero mapcount";
1865         if (unlikely(page->mapping != NULL))
1866                 bad_reason = "non-NULL mapping";
1867         if (unlikely(page_ref_count(page) != 0))
1868                 bad_reason = "nonzero _count";
1869         if (unlikely(page->flags & __PG_HWPOISON)) {
1870                 bad_reason = "HWPoisoned (hardware-corrupted)";
1871                 bad_flags = __PG_HWPOISON;
1872                 /* Don't complain about hwpoisoned pages */
1873                 page_mapcount_reset(page); /* remove PageBuddy */
1874                 return;
1875         }
1876         if (unlikely(page->flags & PAGE_FLAGS_CHECK_AT_PREP)) {
1877                 bad_reason = "PAGE_FLAGS_CHECK_AT_PREP flag set";
1878                 bad_flags = PAGE_FLAGS_CHECK_AT_PREP;
1879         }
1880 #ifdef CONFIG_MEMCG
1881         if (unlikely(page->mem_cgroup))
1882                 bad_reason = "page still charged to cgroup";
1883 #endif
1884         bad_page(page, bad_reason, bad_flags);
1885 }
1886
1887 /*
1888  * This page is about to be returned from the page allocator
1889  */
1890 static inline int check_new_page(struct page *page)
1891 {
1892         if (likely(page_expected_state(page,
1893                                 PAGE_FLAGS_CHECK_AT_PREP|__PG_HWPOISON)))
1894                 return 0;
1895
1896         check_new_page_bad(page);
1897         return 1;
1898 }
1899
1900 static inline bool free_pages_prezeroed(void)
1901 {
1902         return IS_ENABLED(CONFIG_PAGE_POISONING_ZERO) &&
1903                 page_poisoning_enabled();
1904 }
1905
1906 #ifdef CONFIG_DEBUG_VM
1907 static bool check_pcp_refill(struct page *page)
1908 {
1909         return false;
1910 }
1911
1912 static bool check_new_pcp(struct page *page)
1913 {
1914         return check_new_page(page);
1915 }
1916 #else
1917 static bool check_pcp_refill(struct page *page)
1918 {
1919         return check_new_page(page);
1920 }
1921 static bool check_new_pcp(struct page *page)
1922 {
1923         return false;
1924 }
1925 #endif /* CONFIG_DEBUG_VM */
1926
1927 static bool check_new_pages(struct page *page, unsigned int order)
1928 {
1929         int i;
1930         for (i = 0; i < (1 << order); i++) {
1931                 struct page *p = page + i;
1932
1933                 if (unlikely(check_new_page(p)))
1934                         return true;
1935         }
1936
1937         return false;
1938 }
1939
1940 inline void post_alloc_hook(struct page *page, unsigned int order,
1941                                 gfp_t gfp_flags)
1942 {
1943         set_page_private(page, 0);
1944         set_page_refcounted(page);
1945
1946         arch_alloc_page(page, order);
1947         kernel_map_pages(page, 1 << order, 1);
1948         kernel_poison_pages(page, 1 << order, 1);
1949         kasan_alloc_pages(page, order);
1950         set_page_owner(page, order, gfp_flags);
1951 }
1952
1953 static void prep_new_page(struct page *page, unsigned int order, gfp_t gfp_flags,
1954                                                         unsigned int alloc_flags)
1955 {
1956         int i;
1957
1958         post_alloc_hook(page, order, gfp_flags);
1959
1960         if (!free_pages_prezeroed() && (gfp_flags & __GFP_ZERO))
1961                 for (i = 0; i < (1 << order); i++)
1962                         clear_highpage(page + i);
1963
1964         if (order && (gfp_flags & __GFP_COMP))
1965                 prep_compound_page(page, order);
1966
1967         /*
1968          * page is set pfmemalloc when ALLOC_NO_WATERMARKS was necessary to
1969          * allocate the page. The expectation is that the caller is taking
1970          * steps that will free more memory. The caller should avoid the page
1971          * being used for !PFMEMALLOC purposes.
1972          */
1973         if (alloc_flags & ALLOC_NO_WATERMARKS)
1974                 set_page_pfmemalloc(page);
1975         else
1976                 clear_page_pfmemalloc(page);
1977 }
1978
1979 /*
1980  * Go through the free lists for the given migratetype and remove
1981  * the smallest available page from the freelists
1982  */
1983 static __always_inline
1984 struct page *__rmqueue_smallest(struct zone *zone, unsigned int order,
1985                                                 int migratetype)
1986 {
1987         unsigned int current_order;
1988         struct free_area *area;
1989         struct page *page;
1990
1991         /* Find a page of the appropriate size in the preferred list */
1992         for (current_order = order; current_order < MAX_ORDER; ++current_order) {
1993                 area = &(zone->free_area[current_order]);
1994                 page = list_first_entry_or_null(&area->free_list[migratetype],
1995                                                         struct page, lru);
1996                 if (!page)
1997                         continue;
1998                 list_del(&page->lru);
1999                 rmv_page_order(page);
2000                 area->nr_free--;
2001                 expand(zone, page, order, current_order, area, migratetype);
2002                 set_pcppage_migratetype(page, migratetype);
2003                 return page;
2004         }
2005
2006         return NULL;
2007 }
2008
2009
2010 /*
2011  * This array describes the order lists are fallen back to when
2012  * the free lists for the desirable migrate type are depleted
2013  */
2014 static int fallbacks[MIGRATE_TYPES][4] = {
2015         [MIGRATE_UNMOVABLE]   = { MIGRATE_RECLAIMABLE, MIGRATE_MOVABLE,   MIGRATE_TYPES },
2016         [MIGRATE_MOVABLE]     = { MIGRATE_RECLAIMABLE, MIGRATE_UNMOVABLE, MIGRATE_TYPES },
2017         [MIGRATE_RECLAIMABLE] = { MIGRATE_UNMOVABLE,   MIGRATE_MOVABLE,   MIGRATE_TYPES },
2018 #ifdef CONFIG_CMA
2019         [MIGRATE_CMA]         = { MIGRATE_TYPES }, /* Never used */
2020 #endif
2021 #ifdef CONFIG_MEMORY_ISOLATION
2022         [MIGRATE_ISOLATE]     = { MIGRATE_TYPES }, /* Never used */
2023 #endif
2024 };
2025
2026 #ifdef CONFIG_CMA
2027 static __always_inline struct page *__rmqueue_cma_fallback(struct zone *zone,
2028                                         unsigned int order)
2029 {
2030         return __rmqueue_smallest(zone, order, MIGRATE_CMA);
2031 }
2032 #else
2033 static inline struct page *__rmqueue_cma_fallback(struct zone *zone,
2034                                         unsigned int order) { return NULL; }
2035 #endif
2036
2037 /*
2038  * Move the free pages in a range to the free lists of the requested type.
2039  * Note that start_page and end_pages are not aligned on a pageblock
2040  * boundary. If alignment is required, use move_freepages_block()
2041  */
2042 static int move_freepages(struct zone *zone,
2043                           struct page *start_page, struct page *end_page,
2044                           int migratetype, int *num_movable)
2045 {
2046         struct page *page;
2047         unsigned int order;
2048         int pages_moved = 0;
2049
2050 #ifndef CONFIG_HOLES_IN_ZONE
2051         /*
2052          * page_zone is not safe to call in this context when
2053          * CONFIG_HOLES_IN_ZONE is set. This bug check is probably redundant
2054          * anyway as we check zone boundaries in move_freepages_block().
2055          * Remove at a later date when no bug reports exist related to
2056          * grouping pages by mobility
2057          */
2058         VM_BUG_ON(pfn_valid(page_to_pfn(start_page)) &&
2059                   pfn_valid(page_to_pfn(end_page)) &&
2060                   page_zone(start_page) != page_zone(end_page));
2061 #endif
2062         for (page = start_page; page <= end_page;) {
2063                 if (!pfn_valid_within(page_to_pfn(page))) {
2064                         page++;
2065                         continue;
2066                 }
2067
2068                 /* Make sure we are not inadvertently changing nodes */
2069                 VM_BUG_ON_PAGE(page_to_nid(page) != zone_to_nid(zone), page);
2070
2071                 if (!PageBuddy(page)) {
2072                         /*
2073                          * We assume that pages that could be isolated for
2074                          * migration are movable. But we don't actually try
2075                          * isolating, as that would be expensive.
2076                          */
2077                         if (num_movable &&
2078                                         (PageLRU(page) || __PageMovable(page)))
2079                                 (*num_movable)++;
2080
2081                         page++;
2082                         continue;
2083                 }
2084
2085                 order = page_order(page);
2086                 list_move(&page->lru,
2087                           &zone->free_area[order].free_list[migratetype]);
2088                 page += 1 << order;
2089                 pages_moved += 1 << order;
2090         }
2091
2092         return pages_moved;
2093 }
2094
2095 int move_freepages_block(struct zone *zone, struct page *page,
2096                                 int migratetype, int *num_movable)
2097 {
2098         unsigned long start_pfn, end_pfn;
2099         struct page *start_page, *end_page;
2100
2101         if (num_movable)
2102                 *num_movable = 0;
2103
2104         start_pfn = page_to_pfn(page);
2105         start_pfn = start_pfn & ~(pageblock_nr_pages-1);
2106         start_page = pfn_to_page(start_pfn);
2107         end_page = start_page + pageblock_nr_pages - 1;
2108         end_pfn = start_pfn + pageblock_nr_pages - 1;
2109
2110         /* Do not cross zone boundaries */
2111         if (!zone_spans_pfn(zone, start_pfn))
2112                 start_page = page;
2113         if (!zone_spans_pfn(zone, end_pfn))
2114                 return 0;
2115
2116         return move_freepages(zone, start_page, end_page, migratetype,
2117                                                                 num_movable);
2118 }
2119
2120 static void change_pageblock_range(struct page *pageblock_page,
2121                                         int start_order, int migratetype)
2122 {
2123         int nr_pageblocks = 1 << (start_order - pageblock_order);
2124
2125         while (nr_pageblocks--) {
2126                 set_pageblock_migratetype(pageblock_page, migratetype);
2127                 pageblock_page += pageblock_nr_pages;
2128         }
2129 }
2130
2131 /*
2132  * When we are falling back to another migratetype during allocation, try to
2133  * steal extra free pages from the same pageblocks to satisfy further
2134  * allocations, instead of polluting multiple pageblocks.
2135  *
2136  * If we are stealing a relatively large buddy page, it is likely there will
2137  * be more free pages in the pageblock, so try to steal them all. For
2138  * reclaimable and unmovable allocations, we steal regardless of page size,
2139  * as fragmentation caused by those allocations polluting movable pageblocks
2140  * is worse than movable allocations stealing from unmovable and reclaimable
2141  * pageblocks.
2142  */
2143 static bool can_steal_fallback(unsigned int order, int start_mt)
2144 {
2145         /*
2146          * Leaving this order check is intended, although there is
2147          * relaxed order check in next check. The reason is that
2148          * we can actually steal whole pageblock if this condition met,
2149          * but, below check doesn't guarantee it and that is just heuristic
2150          * so could be changed anytime.
2151          */
2152         if (order >= pageblock_order)
2153                 return true;
2154
2155         if (order >= pageblock_order / 2 ||
2156                 start_mt == MIGRATE_RECLAIMABLE ||
2157                 start_mt == MIGRATE_UNMOVABLE ||
2158                 page_group_by_mobility_disabled)
2159                 return true;
2160
2161         return false;
2162 }
2163
2164 static inline void boost_watermark(struct zone *zone)
2165 {
2166         unsigned long max_boost;
2167
2168         if (!watermark_boost_factor)
2169                 return;
2170
2171         max_boost = mult_frac(zone->_watermark[WMARK_HIGH],
2172                         watermark_boost_factor, 10000);
2173         max_boost = max(pageblock_nr_pages, max_boost);
2174
2175         zone->watermark_boost = min(zone->watermark_boost + pageblock_nr_pages,
2176                 max_boost);
2177 }
2178
2179 /*
2180  * This function implements actual steal behaviour. If order is large enough,
2181  * we can steal whole pageblock. If not, we first move freepages in this
2182  * pageblock to our migratetype and determine how many already-allocated pages
2183  * are there in the pageblock with a compatible migratetype. If at least half
2184  * of pages are free or compatible, we can change migratetype of the pageblock
2185  * itself, so pages freed in the future will be put on the correct free list.
2186  */
2187 static void steal_suitable_fallback(struct zone *zone, struct page *page,
2188                 unsigned int alloc_flags, int start_type, bool whole_block)
2189 {
2190         unsigned int current_order = page_order(page);
2191         struct free_area *area;
2192         int free_pages, movable_pages, alike_pages;
2193         int old_block_type;
2194
2195         old_block_type = get_pageblock_migratetype(page);
2196
2197         /*
2198          * This can happen due to races and we want to prevent broken
2199          * highatomic accounting.
2200          */
2201         if (is_migrate_highatomic(old_block_type))
2202                 goto single_page;
2203
2204         /* Take ownership for orders >= pageblock_order */
2205         if (current_order >= pageblock_order) {
2206                 change_pageblock_range(page, current_order, start_type);
2207                 goto single_page;
2208         }
2209
2210         /*
2211          * Boost watermarks to increase reclaim pressure to reduce the
2212          * likelihood of future fallbacks. Wake kswapd now as the node
2213          * may be balanced overall and kswapd will not wake naturally.
2214          */
2215         boost_watermark(zone);
2216         if (alloc_flags & ALLOC_KSWAPD)
2217                 wakeup_kswapd(zone, 0, 0, zone_idx(zone));
2218
2219         /* We are not allowed to try stealing from the whole block */
2220         if (!whole_block)
2221                 goto single_page;
2222
2223         free_pages = move_freepages_block(zone, page, start_type,
2224                                                 &movable_pages);
2225         /*
2226          * Determine how many pages are compatible with our allocation.
2227          * For movable allocation, it's the number of movable pages which
2228          * we just obtained. For other types it's a bit more tricky.
2229          */
2230         if (start_type == MIGRATE_MOVABLE) {
2231                 alike_pages = movable_pages;
2232         } else {
2233                 /*
2234                  * If we are falling back a RECLAIMABLE or UNMOVABLE allocation
2235                  * to MOVABLE pageblock, consider all non-movable pages as
2236                  * compatible. If it's UNMOVABLE falling back to RECLAIMABLE or
2237                  * vice versa, be conservative since we can't distinguish the
2238                  * exact migratetype of non-movable pages.
2239                  */
2240                 if (old_block_type == MIGRATE_MOVABLE)
2241                         alike_pages = pageblock_nr_pages
2242                                                 - (free_pages + movable_pages);
2243                 else
2244                         alike_pages = 0;
2245         }
2246
2247         /* moving whole block can fail due to zone boundary conditions */
2248         if (!free_pages)
2249                 goto single_page;
2250
2251         /*
2252          * If a sufficient number of pages in the block are either free or of
2253          * comparable migratability as our allocation, claim the whole block.
2254          */
2255         if (free_pages + alike_pages >= (1 << (pageblock_order-1)) ||
2256                         page_group_by_mobility_disabled)
2257                 set_pageblock_migratetype(page, start_type);
2258
2259         return;
2260
2261 single_page:
2262         area = &zone->free_area[current_order];
2263         list_move(&page->lru, &area->free_list[start_type]);
2264 }
2265
2266 /*
2267  * Check whether there is a suitable fallback freepage with requested order.
2268  * If only_stealable is true, this function returns fallback_mt only if
2269  * we can steal other freepages all together. This would help to reduce
2270  * fragmentation due to mixed migratetype pages in one pageblock.
2271  */
2272 int find_suitable_fallback(struct free_area *area, unsigned int order,
2273                         int migratetype, bool only_stealable, bool *can_steal)
2274 {
2275         int i;
2276         int fallback_mt;
2277
2278         if (area->nr_free == 0)
2279                 return -1;
2280
2281         *can_steal = false;
2282         for (i = 0;; i++) {
2283                 fallback_mt = fallbacks[migratetype][i];
2284                 if (fallback_mt == MIGRATE_TYPES)
2285                         break;
2286
2287                 if (list_empty(&area->free_list[fallback_mt]))
2288                         continue;
2289
2290                 if (can_steal_fallback(order, migratetype))
2291                         *can_steal = true;
2292
2293                 if (!only_stealable)
2294                         return fallback_mt;
2295
2296                 if (*can_steal)
2297                         return fallback_mt;
2298         }
2299
2300         return -1;
2301 }
2302
2303 /*
2304  * Reserve a pageblock for exclusive use of high-order atomic allocations if
2305  * there are no empty page blocks that contain a page with a suitable order
2306  */
2307 static void reserve_highatomic_pageblock(struct page *page, struct zone *zone,
2308                                 unsigned int alloc_order)
2309 {
2310         int mt;
2311         unsigned long max_managed, flags;
2312
2313         /*
2314          * Limit the number reserved to 1 pageblock or roughly 1% of a zone.
2315          * Check is race-prone but harmless.
2316          */
2317         max_managed = (zone_managed_pages(zone) / 100) + pageblock_nr_pages;
2318         if (zone->nr_reserved_highatomic >= max_managed)
2319                 return;
2320
2321         spin_lock_irqsave(&zone->lock, flags);
2322
2323         /* Recheck the nr_reserved_highatomic limit under the lock */
2324         if (zone->nr_reserved_highatomic >= max_managed)
2325                 goto out_unlock;
2326
2327         /* Yoink! */
2328         mt = get_pageblock_migratetype(page);
2329         if (!is_migrate_highatomic(mt) && !is_migrate_isolate(mt)
2330             && !is_migrate_cma(mt)) {
2331                 zone->nr_reserved_highatomic += pageblock_nr_pages;
2332                 set_pageblock_migratetype(page, MIGRATE_HIGHATOMIC);
2333                 move_freepages_block(zone, page, MIGRATE_HIGHATOMIC, NULL);
2334         }
2335
2336 out_unlock:
2337         spin_unlock_irqrestore(&zone->lock, flags);
2338 }
2339
2340 /*
2341  * Used when an allocation is about to fail under memory pressure. This
2342  * potentially hurts the reliability of high-order allocations when under
2343  * intense memory pressure but failed atomic allocations should be easier
2344  * to recover from than an OOM.
2345  *
2346  * If @force is true, try to unreserve a pageblock even though highatomic
2347  * pageblock is exhausted.
2348  */
2349 static bool unreserve_highatomic_pageblock(const struct alloc_context *ac,
2350                                                 bool force)
2351 {
2352         struct zonelist *zonelist = ac->zonelist;
2353         unsigned long flags;
2354         struct zoneref *z;
2355         struct zone *zone;
2356         struct page *page;
2357         int order;
2358         bool ret;
2359
2360         for_each_zone_zonelist_nodemask(zone, z, zonelist, ac->high_zoneidx,
2361                                                                 ac->nodemask) {
2362                 /*
2363                  * Preserve at least one pageblock unless memory pressure
2364                  * is really high.
2365                  */
2366                 if (!force && zone->nr_reserved_highatomic <=
2367                                         pageblock_nr_pages)
2368                         continue;
2369
2370                 spin_lock_irqsave(&zone->lock, flags);
2371                 for (order = 0; order < MAX_ORDER; order++) {
2372                         struct free_area *area = &(zone->free_area[order]);
2373
2374                         page = list_first_entry_or_null(
2375                                         &area->free_list[MIGRATE_HIGHATOMIC],
2376                                         struct page, lru);
2377                         if (!page)
2378                                 continue;
2379
2380                         /*
2381                          * In page freeing path, migratetype change is racy so
2382                          * we can counter several free pages in a pageblock
2383                          * in this loop althoug we changed the pageblock type
2384                          * from highatomic to ac->migratetype. So we should
2385                          * adjust the count once.
2386                          */
2387                         if (is_migrate_highatomic_page(page)) {
2388                                 /*
2389                                  * It should never happen but changes to
2390                                  * locking could inadvertently allow a per-cpu
2391                                  * drain to add pages to MIGRATE_HIGHATOMIC
2392                                  * while unreserving so be safe and watch for
2393                                  * underflows.
2394                                  */
2395                                 zone->nr_reserved_highatomic -= min(
2396                                                 pageblock_nr_pages,
2397                                                 zone->nr_reserved_highatomic);
2398                         }
2399
2400                         /*
2401                          * Convert to ac->migratetype and avoid the normal
2402                          * pageblock stealing heuristics. Minimally, the caller
2403                          * is doing the work and needs the pages. More
2404                          * importantly, if the block was always converted to
2405                          * MIGRATE_UNMOVABLE or another type then the number
2406                          * of pageblocks that cannot be completely freed
2407                          * may increase.
2408                          */
2409                         set_pageblock_migratetype(page, ac->migratetype);
2410                         ret = move_freepages_block(zone, page, ac->migratetype,
2411                                                                         NULL);
2412                         if (ret) {
2413                                 spin_unlock_irqrestore(&zone->lock, flags);
2414                                 return ret;
2415                         }
2416                 }
2417                 spin_unlock_irqrestore(&zone->lock, flags);
2418         }
2419
2420         return false;
2421 }
2422
2423 /*
2424  * Try finding a free buddy page on the fallback list and put it on the free
2425  * list of requested migratetype, possibly along with other pages from the same
2426  * block, depending on fragmentation avoidance heuristics. Returns true if
2427  * fallback was found so that __rmqueue_smallest() can grab it.
2428  *
2429  * The use of signed ints for order and current_order is a deliberate
2430  * deviation from the rest of this file, to make the for loop
2431  * condition simpler.
2432  */
2433 static __always_inline bool
2434 __rmqueue_fallback(struct zone *zone, int order, int start_migratetype,
2435                                                 unsigned int alloc_flags)
2436 {
2437         struct free_area *area;
2438         int current_order;
2439         int min_order = order;
2440         struct page *page;
2441         int fallback_mt;
2442         bool can_steal;
2443
2444         /*
2445          * Do not steal pages from freelists belonging to other pageblocks
2446          * i.e. orders < pageblock_order. If there are no local zones free,
2447          * the zonelists will be reiterated without ALLOC_NOFRAGMENT.
2448          */
2449         if (alloc_flags & ALLOC_NOFRAGMENT)
2450                 min_order = pageblock_order;
2451
2452         /*
2453          * Find the largest available free page in the other list. This roughly
2454          * approximates finding the pageblock with the most free pages, which
2455          * would be too costly to do exactly.
2456          */
2457         for (current_order = MAX_ORDER - 1; current_order >= min_order;
2458                                 --current_order) {
2459                 area = &(zone->free_area[current_order]);
2460                 fallback_mt = find_suitable_fallback(area, current_order,
2461                                 start_migratetype, false, &can_steal);
2462                 if (fallback_mt == -1)
2463                         continue;
2464
2465                 /*
2466                  * We cannot steal all free pages from the pageblock and the
2467                  * requested migratetype is movable. In that case it's better to
2468                  * steal and split the smallest available page instead of the
2469                  * largest available page, because even if the next movable
2470                  * allocation falls back into a different pageblock than this
2471                  * one, it won't cause permanent fragmentation.
2472                  */
2473                 if (!can_steal && start_migratetype == MIGRATE_MOVABLE
2474                                         && current_order > order)
2475                         goto find_smallest;
2476
2477                 goto do_steal;
2478         }
2479
2480         return false;
2481
2482 find_smallest:
2483         for (current_order = order; current_order < MAX_ORDER;
2484                                                         current_order++) {
2485                 area = &(zone->free_area[current_order]);
2486                 fallback_mt = find_suitable_fallback(area, current_order,
2487                                 start_migratetype, false, &can_steal);
2488                 if (fallback_mt != -1)
2489                         break;
2490         }
2491
2492         /*
2493          * This should not happen - we already found a suitable fallback
2494          * when looking for the largest page.
2495          */
2496         VM_BUG_ON(current_order == MAX_ORDER);
2497
2498 do_steal:
2499         page = list_first_entry(&area->free_list[fallback_mt],
2500                                                         struct page, lru);
2501
2502         steal_suitable_fallback(zone, page, alloc_flags, start_migratetype,
2503                                                                 can_steal);
2504
2505         trace_mm_page_alloc_extfrag(page, order, current_order,
2506                 start_migratetype, fallback_mt);
2507
2508         return true;
2509
2510 }
2511
2512 /*
2513  * Do the hard work of removing an element from the buddy allocator.
2514  * Call me with the zone->lock already held.
2515  */
2516 static __always_inline struct page *
2517 __rmqueue(struct zone *zone, unsigned int order, int migratetype,
2518                                                 unsigned int alloc_flags)
2519 {
2520         struct page *page;
2521
2522 retry:
2523         page = __rmqueue_smallest(zone, order, migratetype);
2524         if (unlikely(!page)) {
2525                 if (migratetype == MIGRATE_MOVABLE)
2526                         page = __rmqueue_cma_fallback(zone, order);
2527
2528                 if (!page && __rmqueue_fallback(zone, order, migratetype,
2529                                                                 alloc_flags))
2530                         goto retry;
2531         }
2532
2533         trace_mm_page_alloc_zone_locked(page, order, migratetype);
2534         return page;
2535 }
2536
2537 /*
2538  * Obtain a specified number of elements from the buddy allocator, all under
2539  * a single hold of the lock, for efficiency.  Add them to the supplied list.
2540  * Returns the number of new pages which were placed at *list.
2541  */
2542 static int rmqueue_bulk(struct zone *zone, unsigned int order,
2543                         unsigned long count, struct list_head *list,
2544                         int migratetype, unsigned int alloc_flags)
2545 {
2546         int i, alloced = 0;
2547
2548         spin_lock(&zone->lock);
2549         for (i = 0; i < count; ++i) {
2550                 struct page *page = __rmqueue(zone, order, migratetype,
2551                                                                 alloc_flags);
2552                 if (unlikely(page == NULL))
2553                         break;
2554
2555                 if (unlikely(check_pcp_refill(page)))
2556                         continue;
2557
2558                 /*
2559                  * Split buddy pages returned by expand() are received here in
2560                  * physical page order. The page is added to the tail of
2561                  * caller's list. From the callers perspective, the linked list
2562                  * is ordered by page number under some conditions. This is
2563                  * useful for IO devices that can forward direction from the
2564                  * head, thus also in the physical page order. This is useful
2565                  * for IO devices that can merge IO requests if the physical
2566                  * pages are ordered properly.
2567                  */
2568                 list_add_tail(&page->lru, list);
2569                 alloced++;
2570                 if (is_migrate_cma(get_pcppage_migratetype(page)))
2571                         __mod_zone_page_state(zone, NR_FREE_CMA_PAGES,
2572                                               -(1 << order));
2573         }
2574
2575         /*
2576          * i pages were removed from the buddy list even if some leak due
2577          * to check_pcp_refill failing so adjust NR_FREE_PAGES based
2578          * on i. Do not confuse with 'alloced' which is the number of
2579          * pages added to the pcp list.
2580          */
2581         __mod_zone_page_state(zone, NR_FREE_PAGES, -(i << order));
2582         spin_unlock(&zone->lock);
2583         return alloced;
2584 }
2585
2586 #ifdef CONFIG_NUMA
2587 /*
2588  * Called from the vmstat counter updater to drain pagesets of this
2589  * currently executing processor on remote nodes after they have
2590  * expired.
2591  *
2592  * Note that this function must be called with the thread pinned to
2593  * a single processor.
2594  */
2595 void drain_zone_pages(struct zone *zone, struct per_cpu_pages *pcp)
2596 {
2597         unsigned long flags;
2598         int to_drain, batch;
2599
2600         local_irq_save(flags);
2601         batch = READ_ONCE(pcp->batch);
2602         to_drain = min(pcp->count, batch);
2603         if (to_drain > 0)
2604                 free_pcppages_bulk(zone, to_drain, pcp);
2605         local_irq_restore(flags);
2606 }
2607 #endif
2608
2609 /*
2610  * Drain pcplists of the indicated processor and zone.
2611  *
2612  * The processor must either be the current processor and the
2613  * thread pinned to the current processor or a processor that
2614  * is not online.
2615  */
2616 static void drain_pages_zone(unsigned int cpu, struct zone *zone)
2617 {
2618         unsigned long flags;
2619         struct per_cpu_pageset *pset;
2620         struct per_cpu_pages *pcp;
2621
2622         local_irq_save(flags);
2623         pset = per_cpu_ptr(zone->pageset, cpu);
2624
2625         pcp = &pset->pcp;
2626         if (pcp->count)
2627                 free_pcppages_bulk(zone, pcp->count, pcp);
2628         local_irq_restore(flags);
2629 }
2630
2631 /*
2632  * Drain pcplists of all zones on the indicated processor.
2633  *
2634  * The processor must either be the current processor and the
2635  * thread pinned to the current processor or a processor that
2636  * is not online.
2637  */
2638 static void drain_pages(unsigned int cpu)
2639 {
2640         struct zone *zone;
2641
2642         for_each_populated_zone(zone) {
2643                 drain_pages_zone(cpu, zone);
2644         }
2645 }
2646
2647 /*
2648  * Spill all of this CPU's per-cpu pages back into the buddy allocator.
2649  *
2650  * The CPU has to be pinned. When zone parameter is non-NULL, spill just
2651  * the single zone's pages.
2652  */
2653 void drain_local_pages(struct zone *zone)
2654 {
2655         int cpu = smp_processor_id();
2656
2657         if (zone)
2658                 drain_pages_zone(cpu, zone);
2659         else
2660                 drain_pages(cpu);
2661 }
2662
2663 static void drain_local_pages_wq(struct work_struct *work)
2664 {
2665         struct pcpu_drain *drain;
2666
2667         drain = container_of(work, struct pcpu_drain, work);
2668
2669         /*
2670          * drain_all_pages doesn't use proper cpu hotplug protection so
2671          * we can race with cpu offline when the WQ can move this from
2672          * a cpu pinned worker to an unbound one. We can operate on a different
2673          * cpu which is allright but we also have to make sure to not move to
2674          * a different one.
2675          */
2676         preempt_disable();
2677         drain_local_pages(drain->zone);
2678         preempt_enable();
2679 }
2680
2681 /*
2682  * Spill all the per-cpu pages from all CPUs back into the buddy allocator.
2683  *
2684  * When zone parameter is non-NULL, spill just the single zone's pages.
2685  *
2686  * Note that this can be extremely slow as the draining happens in a workqueue.
2687  */
2688 void drain_all_pages(struct zone *zone)
2689 {
2690         int cpu;
2691
2692         /*
2693          * Allocate in the BSS so we wont require allocation in
2694          * direct reclaim path for CONFIG_CPUMASK_OFFSTACK=y
2695          */
2696         static cpumask_t cpus_with_pcps;
2697
2698         /*
2699          * Make sure nobody triggers this path before mm_percpu_wq is fully
2700          * initialized.
2701          */
2702         if (WARN_ON_ONCE(!mm_percpu_wq))
2703                 return;
2704
2705         /*
2706          * Do not drain if one is already in progress unless it's specific to
2707          * a zone. Such callers are primarily CMA and memory hotplug and need
2708          * the drain to be complete when the call returns.
2709          */
2710         if (unlikely(!mutex_trylock(&pcpu_drain_mutex))) {
2711                 if (!zone)
2712                         return;
2713                 mutex_lock(&pcpu_drain_mutex);
2714         }
2715
2716         /*
2717          * We don't care about racing with CPU hotplug event
2718          * as offline notification will cause the notified
2719          * cpu to drain that CPU pcps and on_each_cpu_mask
2720          * disables preemption as part of its processing
2721          */
2722         for_each_online_cpu(cpu) {
2723                 struct per_cpu_pageset *pcp;
2724                 struct zone *z;
2725                 bool has_pcps = false;
2726
2727                 if (zone) {
2728                         pcp = per_cpu_ptr(zone->pageset, cpu);
2729                         if (pcp->pcp.count)
2730                                 has_pcps = true;
2731                 } else {
2732                         for_each_populated_zone(z) {
2733                                 pcp = per_cpu_ptr(z->pageset, cpu);
2734                                 if (pcp->pcp.count) {
2735                                         has_pcps = true;
2736                                         break;
2737                                 }
2738                         }
2739                 }
2740
2741                 if (has_pcps)
2742                         cpumask_set_cpu(cpu, &cpus_with_pcps);
2743                 else
2744                         cpumask_clear_cpu(cpu, &cpus_with_pcps);
2745         }
2746
2747         for_each_cpu(cpu, &cpus_with_pcps) {
2748                 struct pcpu_drain *drain = per_cpu_ptr(&pcpu_drain, cpu);
2749
2750                 drain->zone = zone;
2751                 INIT_WORK(&drain->work, drain_local_pages_wq);
2752                 queue_work_on(cpu, mm_percpu_wq, &drain->work);
2753         }
2754         for_each_cpu(cpu, &cpus_with_pcps)
2755                 flush_work(&per_cpu_ptr(&pcpu_drain, cpu)->work);
2756
2757         mutex_unlock(&pcpu_drain_mutex);
2758 }
2759
2760 #ifdef CONFIG_HIBERNATION
2761
2762 /*
2763  * Touch the watchdog for every WD_PAGE_COUNT pages.
2764  */
2765 #define WD_PAGE_COUNT   (128*1024)
2766
2767 void mark_free_pages(struct zone *zone)
2768 {
2769         unsigned long pfn, max_zone_pfn, page_count = WD_PAGE_COUNT;
2770         unsigned long flags;
2771         unsigned int order, t;
2772         struct page *page;
2773
2774         if (zone_is_empty(zone))
2775                 return;
2776
2777         spin_lock_irqsave(&zone->lock, flags);
2778
2779         max_zone_pfn = zone_end_pfn(zone);
2780         for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
2781                 if (pfn_valid(pfn)) {
2782                         page = pfn_to_page(pfn);
2783
2784                         if (!--page_count) {
2785                                 touch_nmi_watchdog();
2786                                 page_count = WD_PAGE_COUNT;
2787                         }
2788
2789                         if (page_zone(page) != zone)
2790                                 continue;
2791
2792                         if (!swsusp_page_is_forbidden(page))
2793                                 swsusp_unset_page_free(page);
2794                 }
2795
2796         for_each_migratetype_order(order, t) {
2797                 list_for_each_entry(page,
2798                                 &zone->free_area[order].free_list[t], lru) {
2799                         unsigned long i;
2800
2801                         pfn = page_to_pfn(page);
2802                         for (i = 0; i < (1UL << order); i++) {
2803                                 if (!--page_count) {
2804                                         touch_nmi_watchdog();
2805                                         page_count = WD_PAGE_COUNT;
2806                                 }
2807                                 swsusp_set_page_free(pfn_to_page(pfn + i));
2808                         }
2809                 }
2810         }
2811         spin_unlock_irqrestore(&zone->lock, flags);
2812 }
2813 #endif /* CONFIG_PM */
2814
2815 static bool free_unref_page_prepare(struct page *page, unsigned long pfn)
2816 {
2817         int migratetype;
2818
2819         if (!free_pcp_prepare(page))
2820                 return false;
2821
2822         migratetype = get_pfnblock_migratetype(page, pfn);
2823         set_pcppage_migratetype(page, migratetype);
2824         return true;
2825 }
2826
2827 static void free_unref_page_commit(struct page *page, unsigned long pfn)
2828 {
2829         struct zone *zone = page_zone(page);
2830         struct per_cpu_pages *pcp;
2831         int migratetype;
2832
2833         migratetype = get_pcppage_migratetype(page);
2834         __count_vm_event(PGFREE);
2835
2836         /*
2837          * We only track unmovable, reclaimable and movable on pcp lists.
2838          * Free ISOLATE pages back to the allocator because they are being
2839          * offlined but treat HIGHATOMIC as movable pages so we can get those
2840          * areas back if necessary. Otherwise, we may have to free
2841          * excessively into the page allocator
2842          */
2843         if (migratetype >= MIGRATE_PCPTYPES) {
2844                 if (unlikely(is_migrate_isolate(migratetype))) {
2845                         free_one_page(zone, page, pfn, 0, migratetype);
2846                         return;
2847                 }
2848                 migratetype = MIGRATE_MOVABLE;
2849         }
2850
2851         pcp = &this_cpu_ptr(zone->pageset)->pcp;
2852         list_add(&page->lru, &pcp->lists[migratetype]);
2853         pcp->count++;
2854         if (pcp->count >= pcp->high) {
2855                 unsigned long batch = READ_ONCE(pcp->batch);
2856                 free_pcppages_bulk(zone, batch, pcp);
2857         }
2858 }
2859
2860 /*
2861  * Free a 0-order page
2862  */
2863 void free_unref_page(struct page *page)
2864 {
2865         unsigned long flags;
2866         unsigned long pfn = page_to_pfn(page);
2867
2868         if (!free_unref_page_prepare(page, pfn))
2869                 return;
2870
2871         local_irq_save(flags);
2872         free_unref_page_commit(page, pfn);
2873         local_irq_restore(flags);
2874 }
2875
2876 /*
2877  * Free a list of 0-order pages
2878  */
2879 void free_unref_page_list(struct list_head *list)
2880 {
2881         struct page *page, *next;
2882         unsigned long flags, pfn;
2883         int batch_count = 0;
2884
2885         /* Prepare pages for freeing */
2886         list_for_each_entry_safe(page, next, list, lru) {
2887                 pfn = page_to_pfn(page);
2888                 if (!free_unref_page_prepare(page, pfn))
2889                         list_del(&page->lru);
2890                 set_page_private(page, pfn);
2891         }
2892
2893         local_irq_save(flags);
2894         list_for_each_entry_safe(page, next, list, lru) {
2895                 unsigned long pfn = page_private(page);
2896
2897                 set_page_private(page, 0);
2898                 trace_mm_page_free_batched(page);
2899                 free_unref_page_commit(page, pfn);
2900
2901                 /*
2902                  * Guard against excessive IRQ disabled times when we get
2903                  * a large list of pages to free.
2904                  */
2905                 if (++batch_count == SWAP_CLUSTER_MAX) {
2906                         local_irq_restore(flags);
2907                         batch_count = 0;
2908                         local_irq_save(flags);
2909                 }
2910         }
2911         local_irq_restore(flags);
2912 }
2913
2914 /*
2915  * split_page takes a non-compound higher-order page, and splits it into
2916  * n (1<<order) sub-pages: page[0..n]
2917  * Each sub-page must be freed individually.
2918  *
2919  * Note: this is probably too low level an operation for use in drivers.
2920  * Please consult with lkml before using this in your driver.
2921  */
2922 void split_page(struct page *page, unsigned int order)
2923 {
2924         int i;
2925
2926         VM_BUG_ON_PAGE(PageCompound(page), page);
2927         VM_BUG_ON_PAGE(!page_count(page), page);
2928
2929         for (i = 1; i < (1 << order); i++)
2930                 set_page_refcounted(page + i);
2931         split_page_owner(page, order);
2932 }
2933 EXPORT_SYMBOL_GPL(split_page);
2934
2935 int __isolate_free_page(struct page *page, unsigned int order)
2936 {
2937         unsigned long watermark;
2938         struct zone *zone;
2939         int mt;
2940
2941         BUG_ON(!PageBuddy(page));
2942
2943         zone = page_zone(page);
2944         mt = get_pageblock_migratetype(page);
2945
2946         if (!is_migrate_isolate(mt)) {
2947                 /*
2948                  * Obey watermarks as if the page was being allocated. We can
2949                  * emulate a high-order watermark check with a raised order-0
2950                  * watermark, because we already know our high-order page
2951                  * exists.
2952                  */
2953                 watermark = min_wmark_pages(zone) + (1UL << order);
2954                 if (!zone_watermark_ok(zone, 0, watermark, 0, ALLOC_CMA))
2955                         return 0;
2956
2957                 __mod_zone_freepage_state(zone, -(1UL << order), mt);
2958         }
2959
2960         /* Remove page from free list */
2961         list_del(&page->lru);
2962         zone->free_area[order].nr_free--;
2963         rmv_page_order(page);
2964
2965         /*
2966          * Set the pageblock if the isolated page is at least half of a
2967          * pageblock
2968          */
2969         if (order >= pageblock_order - 1) {
2970                 struct page *endpage = page + (1 << order) - 1;
2971                 for (; page < endpage; page += pageblock_nr_pages) {
2972                         int mt = get_pageblock_migratetype(page);
2973                         if (!is_migrate_isolate(mt) && !is_migrate_cma(mt)
2974                             && !is_migrate_highatomic(mt))
2975                                 set_pageblock_migratetype(page,
2976                                                           MIGRATE_MOVABLE);
2977                 }
2978         }
2979
2980
2981         return 1UL << order;
2982 }
2983
2984 /*
2985  * Update NUMA hit/miss statistics
2986  *
2987  * Must be called with interrupts disabled.
2988  */
2989 static inline void zone_statistics(struct zone *preferred_zone, struct zone *z)
2990 {
2991 #ifdef CONFIG_NUMA
2992         enum numa_stat_item local_stat = NUMA_LOCAL;
2993
2994         /* skip numa counters update if numa stats is disabled */
2995         if (!static_branch_likely(&vm_numa_stat_key))
2996                 return;
2997
2998         if (zone_to_nid(z) != numa_node_id())
2999                 local_stat = NUMA_OTHER;
3000
3001         if (zone_to_nid(z) == zone_to_nid(preferred_zone))
3002                 __inc_numa_state(z, NUMA_HIT);
3003         else {
3004                 __inc_numa_state(z, NUMA_MISS);
3005                 __inc_numa_state(preferred_zone, NUMA_FOREIGN);
3006         }
3007         __inc_numa_state(z, local_stat);
3008 #endif
3009 }
3010
3011 /* Remove page from the per-cpu list, caller must protect the list */
3012 static struct page *__rmqueue_pcplist(struct zone *zone, int migratetype,
3013                         unsigned int alloc_flags,
3014                         struct per_cpu_pages *pcp,
3015                         struct list_head *list)
3016 {
3017         struct page *page;
3018
3019         do {
3020                 if (list_empty(list)) {
3021                         pcp->count += rmqueue_bulk(zone, 0,
3022                                         pcp->batch, list,
3023                                         migratetype, alloc_flags);
3024                         if (unlikely(list_empty(list)))
3025                                 return NULL;
3026                 }
3027
3028                 page = list_first_entry(list, struct page, lru);
3029                 list_del(&page->lru);
3030                 pcp->count--;
3031         } while (check_new_pcp(page));
3032
3033         return page;
3034 }
3035
3036 /* Lock and remove page from the per-cpu list */
3037 static struct page *rmqueue_pcplist(struct zone *preferred_zone,
3038                         struct zone *zone, unsigned int order,
3039                         gfp_t gfp_flags, int migratetype,
3040                         unsigned int alloc_flags)
3041 {
3042         struct per_cpu_pages *pcp;
3043         struct list_head *list;
3044         struct page *page;
3045         unsigned long flags;
3046
3047         local_irq_save(flags);
3048         pcp = &this_cpu_ptr(zone->pageset)->pcp;
3049         list = &pcp->lists[migratetype];
3050         page = __rmqueue_pcplist(zone,  migratetype, alloc_flags, pcp, list);
3051         if (page) {
3052                 __count_zid_vm_events(PGALLOC, page_zonenum(page), 1 << order);
3053                 zone_statistics(preferred_zone, zone);
3054         }
3055         local_irq_restore(flags);
3056         return page;
3057 }
3058
3059 /*
3060  * Allocate a page from the given zone. Use pcplists for order-0 allocations.
3061  */
3062 static inline
3063 struct page *rmqueue(struct zone *preferred_zone,
3064                         struct zone *zone, unsigned int order,
3065                         gfp_t gfp_flags, unsigned int alloc_flags,
3066                         int migratetype)
3067 {
3068         unsigned long flags;
3069         struct page *page;
3070
3071         if (likely(order == 0)) {
3072                 page = rmqueue_pcplist(preferred_zone, zone, order,
3073                                 gfp_flags, migratetype, alloc_flags);
3074                 goto out;
3075         }
3076
3077         /*
3078          * We most definitely don't want callers attempting to
3079          * allocate greater than order-1 page units with __GFP_NOFAIL.
3080          */
3081         WARN_ON_ONCE((gfp_flags & __GFP_NOFAIL) && (order > 1));
3082         spin_lock_irqsave(&zone->lock, flags);
3083
3084         do {
3085                 page = NULL;
3086                 if (alloc_flags & ALLOC_HARDER) {
3087                         page = __rmqueue_smallest(zone, order, MIGRATE_HIGHATOMIC);
3088                         if (page)
3089                                 trace_mm_page_alloc_zone_locked(page, order, migratetype);
3090                 }
3091                 if (!page)
3092                         page = __rmqueue(zone, order, migratetype, alloc_flags);
3093         } while (page && check_new_pages(page, order));
3094         spin_unlock(&zone->lock);
3095         if (!page)
3096                 goto failed;
3097         __mod_zone_freepage_state(zone, -(1 << order),
3098                                   get_pcppage_migratetype(page));
3099
3100         __count_zid_vm_events(PGALLOC, page_zonenum(page), 1 << order);
3101         zone_statistics(preferred_zone, zone);
3102         local_irq_restore(flags);
3103
3104 out:
3105         VM_BUG_ON_PAGE(page && bad_range(zone, page), page);
3106         return page;
3107
3108 failed:
3109         local_irq_restore(flags);
3110         return NULL;
3111 }
3112
3113 #ifdef CONFIG_FAIL_PAGE_ALLOC
3114
3115 static struct {
3116         struct fault_attr attr;
3117
3118         bool ignore_gfp_highmem;
3119         bool ignore_gfp_reclaim;
3120         u32 min_order;
3121 } fail_page_alloc = {
3122         .attr = FAULT_ATTR_INITIALIZER,
3123         .ignore_gfp_reclaim = true,
3124         .ignore_gfp_highmem = true,
3125         .min_order = 1,
3126 };
3127
3128 static int __init setup_fail_page_alloc(char *str)
3129 {
3130         return setup_fault_attr(&fail_page_alloc.attr, str);
3131 }
3132 __setup("fail_page_alloc=", setup_fail_page_alloc);
3133
3134 static bool should_fail_alloc_page(gfp_t gfp_mask, unsigned int order)
3135 {
3136         if (order < fail_page_alloc.min_order)
3137                 return false;
3138         if (gfp_mask & __GFP_NOFAIL)
3139                 return false;
3140         if (fail_page_alloc.ignore_gfp_highmem && (gfp_mask & __GFP_HIGHMEM))
3141                 return false;
3142         if (fail_page_alloc.ignore_gfp_reclaim &&
3143                         (gfp_mask & __GFP_DIRECT_RECLAIM))
3144                 return false;
3145
3146         return should_fail(&fail_page_alloc.attr, 1 << order);
3147 }
3148
3149 #ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
3150
3151 static int __init fail_page_alloc_debugfs(void)
3152 {
3153         umode_t mode = S_IFREG | 0600;
3154         struct dentry *dir;
3155
3156         dir = fault_create_debugfs_attr("fail_page_alloc", NULL,
3157                                         &fail_page_alloc.attr);
3158         if (IS_ERR(dir))
3159                 return PTR_ERR(dir);
3160
3161         if (!debugfs_create_bool("ignore-gfp-wait", mode, dir,
3162                                 &fail_page_alloc.ignore_gfp_reclaim))
3163                 goto fail;
3164         if (!debugfs_create_bool("ignore-gfp-highmem", mode, dir,
3165                                 &fail_page_alloc.ignore_gfp_highmem))
3166                 goto fail;
3167         if (!debugfs_create_u32("min-order", mode, dir,
3168                                 &fail_page_alloc.min_order))
3169                 goto fail;
3170
3171         return 0;
3172 fail:
3173         debugfs_remove_recursive(dir);
3174
3175         return -ENOMEM;
3176 }
3177
3178 late_initcall(fail_page_alloc_debugfs);
3179
3180 #endif /* CONFIG_FAULT_INJECTION_DEBUG_FS */
3181
3182 #else /* CONFIG_FAIL_PAGE_ALLOC */
3183
3184 static inline bool should_fail_alloc_page(gfp_t gfp_mask, unsigned int order)
3185 {
3186         return false;
3187 }
3188
3189 #endif /* CONFIG_FAIL_PAGE_ALLOC */
3190
3191 /*
3192  * Return true if free base pages are above 'mark'. For high-order checks it
3193  * will return true of the order-0 watermark is reached and there is at least
3194  * one free page of a suitable size. Checking now avoids taking the zone lock
3195  * to check in the allocation paths if no pages are free.
3196  */
3197 bool __zone_watermark_ok(struct zone *z, unsigned int order, unsigned long mark,
3198                          int classzone_idx, unsigned int alloc_flags,
3199                          long free_pages)
3200 {
3201         long min = mark;
3202         int o;
3203         const bool alloc_harder = (alloc_flags & (ALLOC_HARDER|ALLOC_OOM));
3204
3205         /* free_pages may go negative - that's OK */
3206         free_pages -= (1 << order) - 1;
3207
3208         if (alloc_flags & ALLOC_HIGH)
3209                 min -= min / 2;
3210
3211         /*
3212          * If the caller does not have rights to ALLOC_HARDER then subtract
3213          * the high-atomic reserves. This will over-estimate the size of the
3214          * atomic reserve but it avoids a search.
3215          */
3216         if (likely(!alloc_harder)) {
3217                 free_pages -= z->nr_reserved_highatomic;
3218         } else {
3219                 /*
3220                  * OOM victims can try even harder than normal ALLOC_HARDER
3221                  * users on the grounds that it's definitely going to be in
3222                  * the exit path shortly and free memory. Any allocation it
3223                  * makes during the free path will be small and short-lived.
3224                  */
3225                 if (alloc_flags & ALLOC_OOM)
3226                         min -= min / 2;
3227                 else
3228                         min -= min / 4;
3229         }
3230
3231
3232 #ifdef CONFIG_CMA
3233         /* If allocation can't use CMA areas don't use free CMA pages */
3234         if (!(alloc_flags & ALLOC_CMA))
3235                 free_pages -= zone_page_state(z, NR_FREE_CMA_PAGES);
3236 #endif
3237
3238         /*
3239          * Check watermarks for an order-0 allocation request. If these
3240          * are not met, then a high-order request also cannot go ahead
3241          * even if a suitable page happened to be free.
3242          */
3243         if (free_pages <= min + z->lowmem_reserve[classzone_idx])
3244                 return false;
3245
3246         /* If this is an order-0 request then the watermark is fine */
3247         if (!order)
3248                 return true;
3249
3250         /* For a high-order request, check at least one suitable page is free */
3251         for (o = order; o < MAX_ORDER; o++) {
3252                 struct free_area *area = &z->free_area[o];
3253                 int mt;
3254
3255                 if (!area->nr_free)
3256                         continue;
3257
3258                 for (mt = 0; mt < MIGRATE_PCPTYPES; mt++) {
3259                         if (!list_empty(&area->free_list[mt]))
3260                                 return true;
3261                 }
3262
3263 #ifdef CONFIG_CMA
3264                 if ((alloc_flags & ALLOC_CMA) &&
3265                     !list_empty(&area->free_list[MIGRATE_CMA])) {
3266                         return true;
3267                 }
3268 #endif
3269                 if (alloc_harder &&
3270                         !list_empty(&area->free_list[MIGRATE_HIGHATOMIC]))
3271                         return true;
3272         }
3273         return false;
3274 }
3275
3276 bool zone_watermark_ok(struct zone *z, unsigned int order, unsigned long mark,
3277                       int classzone_idx, unsigned int alloc_flags)
3278 {
3279         return __zone_watermark_ok(z, order, mark, classzone_idx, alloc_flags,
3280                                         zone_page_state(z, NR_FREE_PAGES));
3281 }
3282
3283 static inline bool zone_watermark_fast(struct zone *z, unsigned int order,
3284                 unsigned long mark, int classzone_idx, unsigned int alloc_flags)
3285 {
3286         long free_pages = zone_page_state(z, NR_FREE_PAGES);
3287         long cma_pages = 0;
3288
3289 #ifdef CONFIG_CMA
3290         /* If allocation can't use CMA areas don't use free CMA pages */
3291         if (!(alloc_flags & ALLOC_CMA))
3292                 cma_pages = zone_page_state(z, NR_FREE_CMA_PAGES);
3293 #endif
3294
3295         /*
3296          * Fast check for order-0 only. If this fails then the reserves
3297          * need to be calculated. There is a corner case where the check
3298          * passes but only the high-order atomic reserve are free. If
3299          * the caller is !atomic then it'll uselessly search the free
3300          * list. That corner case is then slower but it is harmless.
3301          */
3302         if (!order && (free_pages - cma_pages) > mark + z->lowmem_reserve[classzone_idx])
3303                 return true;
3304
3305         return __zone_watermark_ok(z, order, mark, classzone_idx, alloc_flags,
3306                                         free_pages);
3307 }
3308
3309 bool zone_watermark_ok_safe(struct zone *z, unsigned int order,
3310                         unsigned long mark, int classzone_idx)
3311 {
3312         long free_pages = zone_page_state(z, NR_FREE_PAGES);
3313
3314         if (z->percpu_drift_mark && free_pages < z->percpu_drift_mark)
3315                 free_pages = zone_page_state_snapshot(z, NR_FREE_PAGES);
3316
3317         return __zone_watermark_ok(z, order, mark, classzone_idx, 0,
3318                                                                 free_pages);
3319 }
3320
3321 #ifdef CONFIG_NUMA
3322 static bool zone_allows_reclaim(struct zone *local_zone, struct zone *zone)
3323 {
3324         return node_distance(zone_to_nid(local_zone), zone_to_nid(zone)) <=
3325                                 RECLAIM_DISTANCE;
3326 }
3327 #else   /* CONFIG_NUMA */
3328 static bool zone_allows_reclaim(struct zone *local_zone, struct zone *zone)
3329 {
3330         return true;
3331 }
3332 #endif  /* CONFIG_NUMA */
3333
3334 /*
3335  * The restriction on ZONE_DMA32 as being a suitable zone to use to avoid
3336  * fragmentation is subtle. If the preferred zone was HIGHMEM then
3337  * premature use of a lower zone may cause lowmem pressure problems that
3338  * are worse than fragmentation. If the next zone is ZONE_DMA then it is
3339  * probably too small. It only makes sense to spread allocations to avoid
3340  * fragmentation between the Normal and DMA32 zones.
3341  */
3342 static inline unsigned int
3343 alloc_flags_nofragment(struct zone *zone, gfp_t gfp_mask)
3344 {
3345         unsigned int alloc_flags = 0;
3346
3347         if (gfp_mask & __GFP_KSWAPD_RECLAIM)
3348                 alloc_flags |= ALLOC_KSWAPD;
3349
3350 #ifdef CONFIG_ZONE_DMA32
3351         if (zone_idx(zone) != ZONE_NORMAL)
3352                 goto out;
3353
3354         /*
3355          * If ZONE_DMA32 exists, assume it is the one after ZONE_NORMAL and
3356          * the pointer is within zone->zone_pgdat->node_zones[]. Also assume
3357          * on UMA that if Normal is populated then so is DMA32.
3358          */
3359         BUILD_BUG_ON(ZONE_NORMAL - ZONE_DMA32 != 1);
3360         if (nr_online_nodes > 1 && !populated_zone(--zone))
3361                 goto out;
3362
3363 out:
3364 #endif /* CONFIG_ZONE_DMA32 */
3365         return alloc_flags;
3366 }
3367
3368 /*
3369  * get_page_from_freelist goes through the zonelist trying to allocate
3370  * a page.
3371  */
3372 static struct page *
3373 get_page_from_freelist(gfp_t gfp_mask, unsigned int order, int alloc_flags,
3374                                                 const struct alloc_context *ac)
3375 {
3376         struct zoneref *z;
3377         struct zone *zone;
3378         struct pglist_data *last_pgdat_dirty_limit = NULL;
3379         bool no_fallback;
3380
3381 retry:
3382         /*
3383          * Scan zonelist, looking for a zone with enough free.