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