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