Merge git://git.kernel.org/pub/scm/linux/kernel/git/bpf/bpf
[linux-2.6-microblaze.git] / mm / page_alloc.c
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  *  linux/mm/page_alloc.c
4  *
5  *  Manages the free list, the system allocates free pages here.
6  *  Note that kmalloc() lives in slab.c
7  *
8  *  Copyright (C) 1991, 1992, 1993, 1994  Linus Torvalds
9  *  Swap reorganised 29.12.95, Stephen Tweedie
10  *  Support of BIGMEM added by Gerhard Wichert, Siemens AG, July 1999
11  *  Reshaped it to be a zoned allocator, Ingo Molnar, Red Hat, 1999
12  *  Discontiguous memory support, Kanoj Sarcar, SGI, Nov 1999
13  *  Zone balancing, Kanoj Sarcar, SGI, Jan 2000
14  *  Per cpu hot/cold page lists, bulk allocation, Martin J. Bligh, Sept 2002
15  *          (lots of bits borrowed from Ingo Molnar & Andrew Morton)
16  */
17
18 #include <linux/stddef.h>
19 #include <linux/mm.h>
20 #include <linux/highmem.h>
21 #include <linux/swap.h>
22 #include <linux/interrupt.h>
23 #include <linux/pagemap.h>
24 #include <linux/jiffies.h>
25 #include <linux/memblock.h>
26 #include <linux/compiler.h>
27 #include <linux/kernel.h>
28 #include <linux/kasan.h>
29 #include <linux/module.h>
30 #include <linux/suspend.h>
31 #include <linux/pagevec.h>
32 #include <linux/blkdev.h>
33 #include <linux/slab.h>
34 #include <linux/ratelimit.h>
35 #include <linux/oom.h>
36 #include <linux/topology.h>
37 #include <linux/sysctl.h>
38 #include <linux/cpu.h>
39 #include <linux/cpuset.h>
40 #include <linux/memory_hotplug.h>
41 #include <linux/nodemask.h>
42 #include <linux/vmalloc.h>
43 #include <linux/vmstat.h>
44 #include <linux/mempolicy.h>
45 #include <linux/memremap.h>
46 #include <linux/stop_machine.h>
47 #include <linux/random.h>
48 #include <linux/sort.h>
49 #include <linux/pfn.h>
50 #include <linux/backing-dev.h>
51 #include <linux/fault-inject.h>
52 #include <linux/page-isolation.h>
53 #include <linux/debugobjects.h>
54 #include <linux/kmemleak.h>
55 #include <linux/compaction.h>
56 #include <trace/events/kmem.h>
57 #include <trace/events/oom.h>
58 #include <linux/prefetch.h>
59 #include <linux/mm_inline.h>
60 #include <linux/migrate.h>
61 #include <linux/hugetlb.h>
62 #include <linux/sched/rt.h>
63 #include <linux/sched/mm.h>
64 #include <linux/page_owner.h>
65 #include <linux/kthread.h>
66 #include <linux/memcontrol.h>
67 #include <linux/ftrace.h>
68 #include <linux/lockdep.h>
69 #include <linux/nmi.h>
70 #include <linux/psi.h>
71
72 #include <asm/sections.h>
73 #include <asm/tlbflush.h>
74 #include <asm/div64.h>
75 #include "internal.h"
76 #include "shuffle.h"
77
78 /* prevent >1 _updater_ of zone percpu pageset ->high and ->batch fields */
79 static DEFINE_MUTEX(pcp_batch_high_lock);
80 #define MIN_PERCPU_PAGELIST_FRACTION    (8)
81
82 #ifdef CONFIG_USE_PERCPU_NUMA_NODE_ID
83 DEFINE_PER_CPU(int, numa_node);
84 EXPORT_PER_CPU_SYMBOL(numa_node);
85 #endif
86
87 DEFINE_STATIC_KEY_TRUE(vm_numa_stat_key);
88
89 #ifdef CONFIG_HAVE_MEMORYLESS_NODES
90 /*
91  * N.B., Do NOT reference the '_numa_mem_' per cpu variable directly.
92  * It will not be defined when CONFIG_HAVE_MEMORYLESS_NODES is not defined.
93  * Use the accessor functions set_numa_mem(), numa_mem_id() and cpu_to_mem()
94  * defined in <linux/topology.h>.
95  */
96 DEFINE_PER_CPU(int, _numa_mem_);                /* Kernel "local memory" node */
97 EXPORT_PER_CPU_SYMBOL(_numa_mem_);
98 int _node_numa_mem_[MAX_NUMNODES];
99 #endif
100
101 /* work_structs for global per-cpu drains */
102 struct pcpu_drain {
103         struct zone *zone;
104         struct work_struct work;
105 };
106 DEFINE_MUTEX(pcpu_drain_mutex);
107 DEFINE_PER_CPU(struct pcpu_drain, pcpu_drain);
108
109 #ifdef CONFIG_GCC_PLUGIN_LATENT_ENTROPY
110 volatile unsigned long latent_entropy __latent_entropy;
111 EXPORT_SYMBOL(latent_entropy);
112 #endif
113
114 /*
115  * Array of node states.
116  */
117 nodemask_t node_states[NR_NODE_STATES] __read_mostly = {
118         [N_POSSIBLE] = NODE_MASK_ALL,
119         [N_ONLINE] = { { [0] = 1UL } },
120 #ifndef CONFIG_NUMA
121         [N_NORMAL_MEMORY] = { { [0] = 1UL } },
122 #ifdef CONFIG_HIGHMEM
123         [N_HIGH_MEMORY] = { { [0] = 1UL } },
124 #endif
125         [N_MEMORY] = { { [0] = 1UL } },
126         [N_CPU] = { { [0] = 1UL } },
127 #endif  /* NUMA */
128 };
129 EXPORT_SYMBOL(node_states);
130
131 atomic_long_t _totalram_pages __read_mostly;
132 EXPORT_SYMBOL(_totalram_pages);
133 unsigned long totalreserve_pages __read_mostly;
134 unsigned long totalcma_pages __read_mostly;
135
136 int percpu_pagelist_fraction;
137 gfp_t gfp_allowed_mask __read_mostly = GFP_BOOT_MASK;
138 #ifdef CONFIG_INIT_ON_ALLOC_DEFAULT_ON
139 DEFINE_STATIC_KEY_TRUE(init_on_alloc);
140 #else
141 DEFINE_STATIC_KEY_FALSE(init_on_alloc);
142 #endif
143 EXPORT_SYMBOL(init_on_alloc);
144
145 #ifdef CONFIG_INIT_ON_FREE_DEFAULT_ON
146 DEFINE_STATIC_KEY_TRUE(init_on_free);
147 #else
148 DEFINE_STATIC_KEY_FALSE(init_on_free);
149 #endif
150 EXPORT_SYMBOL(init_on_free);
151
152 static int __init early_init_on_alloc(char *buf)
153 {
154         int ret;
155         bool bool_result;
156
157         if (!buf)
158                 return -EINVAL;
159         ret = kstrtobool(buf, &bool_result);
160         if (bool_result && page_poisoning_enabled())
161                 pr_info("mem auto-init: CONFIG_PAGE_POISONING is on, will take precedence over init_on_alloc\n");
162         if (bool_result)
163                 static_branch_enable(&init_on_alloc);
164         else
165                 static_branch_disable(&init_on_alloc);
166         return ret;
167 }
168 early_param("init_on_alloc", early_init_on_alloc);
169
170 static int __init early_init_on_free(char *buf)
171 {
172         int ret;
173         bool bool_result;
174
175         if (!buf)
176                 return -EINVAL;
177         ret = kstrtobool(buf, &bool_result);
178         if (bool_result && page_poisoning_enabled())
179                 pr_info("mem auto-init: CONFIG_PAGE_POISONING is on, will take precedence over init_on_free\n");
180         if (bool_result)
181                 static_branch_enable(&init_on_free);
182         else
183                 static_branch_disable(&init_on_free);
184         return ret;
185 }
186 early_param("init_on_free", early_init_on_free);
187
188 /*
189  * A cached value of the page's pageblock's migratetype, used when the page is
190  * put on a pcplist. Used to avoid the pageblock migratetype lookup when
191  * freeing from pcplists in most cases, at the cost of possibly becoming stale.
192  * Also the migratetype set in the page does not necessarily match the pcplist
193  * index, e.g. page might have MIGRATE_CMA set but be on a pcplist with any
194  * other index - this ensures that it will be put on the correct CMA freelist.
195  */
196 static inline int get_pcppage_migratetype(struct page *page)
197 {
198         return page->index;
199 }
200
201 static inline void set_pcppage_migratetype(struct page *page, int migratetype)
202 {
203         page->index = migratetype;
204 }
205
206 #ifdef CONFIG_PM_SLEEP
207 /*
208  * The following functions are used by the suspend/hibernate code to temporarily
209  * change gfp_allowed_mask in order to avoid using I/O during memory allocations
210  * while devices are suspended.  To avoid races with the suspend/hibernate code,
211  * they should always be called with system_transition_mutex held
212  * (gfp_allowed_mask also should only be modified with system_transition_mutex
213  * held, unless the suspend/hibernate code is guaranteed not to run in parallel
214  * with that modification).
215  */
216
217 static gfp_t saved_gfp_mask;
218
219 void pm_restore_gfp_mask(void)
220 {
221         WARN_ON(!mutex_is_locked(&system_transition_mutex));
222         if (saved_gfp_mask) {
223                 gfp_allowed_mask = saved_gfp_mask;
224                 saved_gfp_mask = 0;
225         }
226 }
227
228 void pm_restrict_gfp_mask(void)
229 {
230         WARN_ON(!mutex_is_locked(&system_transition_mutex));
231         WARN_ON(saved_gfp_mask);
232         saved_gfp_mask = gfp_allowed_mask;
233         gfp_allowed_mask &= ~(__GFP_IO | __GFP_FS);
234 }
235
236 bool pm_suspended_storage(void)
237 {
238         if ((gfp_allowed_mask & (__GFP_IO | __GFP_FS)) == (__GFP_IO | __GFP_FS))
239                 return false;
240         return true;
241 }
242 #endif /* CONFIG_PM_SLEEP */
243
244 #ifdef CONFIG_HUGETLB_PAGE_SIZE_VARIABLE
245 unsigned int pageblock_order __read_mostly;
246 #endif
247
248 static void __free_pages_ok(struct page *page, unsigned int order);
249
250 /*
251  * results with 256, 32 in the lowmem_reserve sysctl:
252  *      1G machine -> (16M dma, 800M-16M normal, 1G-800M high)
253  *      1G machine -> (16M dma, 784M normal, 224M high)
254  *      NORMAL allocation will leave 784M/256 of ram reserved in the ZONE_DMA
255  *      HIGHMEM allocation will leave 224M/32 of ram reserved in ZONE_NORMAL
256  *      HIGHMEM allocation will leave (224M+784M)/256 of ram reserved in ZONE_DMA
257  *
258  * TBD: should special case ZONE_DMA32 machines here - in those we normally
259  * don't need any ZONE_NORMAL reservation
260  */
261 int sysctl_lowmem_reserve_ratio[MAX_NR_ZONES] = {
262 #ifdef CONFIG_ZONE_DMA
263         [ZONE_DMA] = 256,
264 #endif
265 #ifdef CONFIG_ZONE_DMA32
266         [ZONE_DMA32] = 256,
267 #endif
268         [ZONE_NORMAL] = 32,
269 #ifdef CONFIG_HIGHMEM
270         [ZONE_HIGHMEM] = 0,
271 #endif
272         [ZONE_MOVABLE] = 0,
273 };
274
275 static char * const zone_names[MAX_NR_ZONES] = {
276 #ifdef CONFIG_ZONE_DMA
277          "DMA",
278 #endif
279 #ifdef CONFIG_ZONE_DMA32
280          "DMA32",
281 #endif
282          "Normal",
283 #ifdef CONFIG_HIGHMEM
284          "HighMem",
285 #endif
286          "Movable",
287 #ifdef CONFIG_ZONE_DEVICE
288          "Device",
289 #endif
290 };
291
292 const char * const migratetype_names[MIGRATE_TYPES] = {
293         "Unmovable",
294         "Movable",
295         "Reclaimable",
296         "HighAtomic",
297 #ifdef CONFIG_CMA
298         "CMA",
299 #endif
300 #ifdef CONFIG_MEMORY_ISOLATION
301         "Isolate",
302 #endif
303 };
304
305 compound_page_dtor * const compound_page_dtors[] = {
306         NULL,
307         free_compound_page,
308 #ifdef CONFIG_HUGETLB_PAGE
309         free_huge_page,
310 #endif
311 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
312         free_transhuge_page,
313 #endif
314 };
315
316 int min_free_kbytes = 1024;
317 int user_min_free_kbytes = -1;
318 #ifdef CONFIG_DISCONTIGMEM
319 /*
320  * DiscontigMem defines memory ranges as separate pg_data_t even if the ranges
321  * are not on separate NUMA nodes. Functionally this works but with
322  * watermark_boost_factor, it can reclaim prematurely as the ranges can be
323  * quite small. By default, do not boost watermarks on discontigmem as in
324  * many cases very high-order allocations like THP are likely to be
325  * unsupported and the premature reclaim offsets the advantage of long-term
326  * fragmentation avoidance.
327  */
328 int watermark_boost_factor __read_mostly;
329 #else
330 int watermark_boost_factor __read_mostly = 15000;
331 #endif
332 int watermark_scale_factor = 10;
333
334 static unsigned long nr_kernel_pages __initdata;
335 static unsigned long nr_all_pages __initdata;
336 static unsigned long dma_reserve __initdata;
337
338 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
339 static unsigned long arch_zone_lowest_possible_pfn[MAX_NR_ZONES] __initdata;
340 static unsigned long arch_zone_highest_possible_pfn[MAX_NR_ZONES] __initdata;
341 static unsigned long required_kernelcore __initdata;
342 static unsigned long required_kernelcore_percent __initdata;
343 static unsigned long required_movablecore __initdata;
344 static unsigned long required_movablecore_percent __initdata;
345 static unsigned long zone_movable_pfn[MAX_NUMNODES] __initdata;
346 static bool mirrored_kernelcore __meminitdata;
347
348 /* movable_zone is the "real" zone pages in ZONE_MOVABLE are taken from */
349 int movable_zone;
350 EXPORT_SYMBOL(movable_zone);
351 #endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
352
353 #if MAX_NUMNODES > 1
354 unsigned int nr_node_ids __read_mostly = MAX_NUMNODES;
355 unsigned int nr_online_nodes __read_mostly = 1;
356 EXPORT_SYMBOL(nr_node_ids);
357 EXPORT_SYMBOL(nr_online_nodes);
358 #endif
359
360 int page_group_by_mobility_disabled __read_mostly;
361
362 #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
363 /*
364  * During boot we initialize deferred pages on-demand, as needed, but once
365  * page_alloc_init_late() has finished, the deferred pages are all initialized,
366  * and we can permanently disable that path.
367  */
368 static DEFINE_STATIC_KEY_TRUE(deferred_pages);
369
370 /*
371  * Calling kasan_free_pages() only after deferred memory initialization
372  * has completed. Poisoning pages during deferred memory init will greatly
373  * lengthen the process and cause problem in large memory systems as the
374  * deferred pages initialization is done with interrupt disabled.
375  *
376  * Assuming that there will be no reference to those newly initialized
377  * pages before they are ever allocated, this should have no effect on
378  * KASAN memory tracking as the poison will be properly inserted at page
379  * allocation time. The only corner case is when pages are allocated by
380  * on-demand allocation and then freed again before the deferred pages
381  * initialization is done, but this is not likely to happen.
382  */
383 static inline void kasan_free_nondeferred_pages(struct page *page, int order)
384 {
385         if (!static_branch_unlikely(&deferred_pages))
386                 kasan_free_pages(page, order);
387 }
388
389 /* Returns true if the struct page for the pfn is uninitialised */
390 static inline bool __meminit early_page_uninitialised(unsigned long pfn)
391 {
392         int nid = early_pfn_to_nid(pfn);
393
394         if (node_online(nid) && pfn >= NODE_DATA(nid)->first_deferred_pfn)
395                 return true;
396
397         return false;
398 }
399
400 /*
401  * Returns true when the remaining initialisation should be deferred until
402  * later in the boot cycle when it can be parallelised.
403  */
404 static bool __meminit
405 defer_init(int nid, unsigned long pfn, unsigned long end_pfn)
406 {
407         static unsigned long prev_end_pfn, nr_initialised;
408
409         /*
410          * prev_end_pfn static that contains the end of previous zone
411          * No need to protect because called very early in boot before smp_init.
412          */
413         if (prev_end_pfn != end_pfn) {
414                 prev_end_pfn = end_pfn;
415                 nr_initialised = 0;
416         }
417
418         /* Always populate low zones for address-constrained allocations */
419         if (end_pfn < pgdat_end_pfn(NODE_DATA(nid)))
420                 return false;
421
422         /*
423          * We start only with one section of pages, more pages are added as
424          * needed until the rest of deferred pages are initialized.
425          */
426         nr_initialised++;
427         if ((nr_initialised > PAGES_PER_SECTION) &&
428             (pfn & (PAGES_PER_SECTION - 1)) == 0) {
429                 NODE_DATA(nid)->first_deferred_pfn = pfn;
430                 return true;
431         }
432         return false;
433 }
434 #else
435 #define kasan_free_nondeferred_pages(p, o)      kasan_free_pages(p, o)
436
437 static inline bool early_page_uninitialised(unsigned long pfn)
438 {
439         return false;
440 }
441
442 static inline bool defer_init(int nid, unsigned long pfn, unsigned long end_pfn)
443 {
444         return false;
445 }
446 #endif
447
448 /* Return a pointer to the bitmap storing bits affecting a block of pages */
449 static inline unsigned long *get_pageblock_bitmap(struct page *page,
450                                                         unsigned long pfn)
451 {
452 #ifdef CONFIG_SPARSEMEM
453         return section_to_usemap(__pfn_to_section(pfn));
454 #else
455         return page_zone(page)->pageblock_flags;
456 #endif /* CONFIG_SPARSEMEM */
457 }
458
459 static inline int pfn_to_bitidx(struct page *page, unsigned long pfn)
460 {
461 #ifdef CONFIG_SPARSEMEM
462         pfn &= (PAGES_PER_SECTION-1);
463         return (pfn >> pageblock_order) * NR_PAGEBLOCK_BITS;
464 #else
465         pfn = pfn - round_down(page_zone(page)->zone_start_pfn, pageblock_nr_pages);
466         return (pfn >> pageblock_order) * NR_PAGEBLOCK_BITS;
467 #endif /* CONFIG_SPARSEMEM */
468 }
469
470 /**
471  * get_pfnblock_flags_mask - Return the requested group of flags for the pageblock_nr_pages block of pages
472  * @page: The page within the block of interest
473  * @pfn: The target page frame number
474  * @end_bitidx: The last bit of interest to retrieve
475  * @mask: mask of bits that the caller is interested in
476  *
477  * Return: pageblock_bits flags
478  */
479 static __always_inline unsigned long __get_pfnblock_flags_mask(struct page *page,
480                                         unsigned long pfn,
481                                         unsigned long end_bitidx,
482                                         unsigned long mask)
483 {
484         unsigned long *bitmap;
485         unsigned long bitidx, word_bitidx;
486         unsigned long word;
487
488         bitmap = get_pageblock_bitmap(page, pfn);
489         bitidx = pfn_to_bitidx(page, pfn);
490         word_bitidx = bitidx / BITS_PER_LONG;
491         bitidx &= (BITS_PER_LONG-1);
492
493         word = bitmap[word_bitidx];
494         bitidx += end_bitidx;
495         return (word >> (BITS_PER_LONG - bitidx - 1)) & mask;
496 }
497
498 unsigned long get_pfnblock_flags_mask(struct page *page, unsigned long pfn,
499                                         unsigned long end_bitidx,
500                                         unsigned long mask)
501 {
502         return __get_pfnblock_flags_mask(page, pfn, end_bitidx, mask);
503 }
504
505 static __always_inline int get_pfnblock_migratetype(struct page *page, unsigned long pfn)
506 {
507         return __get_pfnblock_flags_mask(page, pfn, PB_migrate_end, MIGRATETYPE_MASK);
508 }
509
510 /**
511  * set_pfnblock_flags_mask - Set the requested group of flags for a pageblock_nr_pages block of pages
512  * @page: The page within the block of interest
513  * @flags: The flags to set
514  * @pfn: The target page frame number
515  * @end_bitidx: The last bit of interest
516  * @mask: mask of bits that the caller is interested in
517  */
518 void set_pfnblock_flags_mask(struct page *page, unsigned long flags,
519                                         unsigned long pfn,
520                                         unsigned long end_bitidx,
521                                         unsigned long mask)
522 {
523         unsigned long *bitmap;
524         unsigned long bitidx, word_bitidx;
525         unsigned long old_word, word;
526
527         BUILD_BUG_ON(NR_PAGEBLOCK_BITS != 4);
528         BUILD_BUG_ON(MIGRATE_TYPES > (1 << PB_migratetype_bits));
529
530         bitmap = get_pageblock_bitmap(page, pfn);
531         bitidx = pfn_to_bitidx(page, pfn);
532         word_bitidx = bitidx / BITS_PER_LONG;
533         bitidx &= (BITS_PER_LONG-1);
534
535         VM_BUG_ON_PAGE(!zone_spans_pfn(page_zone(page), pfn), page);
536
537         bitidx += end_bitidx;
538         mask <<= (BITS_PER_LONG - bitidx - 1);
539         flags <<= (BITS_PER_LONG - bitidx - 1);
540
541         word = READ_ONCE(bitmap[word_bitidx]);
542         for (;;) {
543                 old_word = cmpxchg(&bitmap[word_bitidx], word, (word & ~mask) | flags);
544                 if (word == old_word)
545                         break;
546                 word = old_word;
547         }
548 }
549
550 void set_pageblock_migratetype(struct page *page, int migratetype)
551 {
552         if (unlikely(page_group_by_mobility_disabled &&
553                      migratetype < MIGRATE_PCPTYPES))
554                 migratetype = MIGRATE_UNMOVABLE;
555
556         set_pageblock_flags_group(page, (unsigned long)migratetype,
557                                         PB_migrate, PB_migrate_end);
558 }
559
560 #ifdef CONFIG_DEBUG_VM
561 static int page_outside_zone_boundaries(struct zone *zone, struct page *page)
562 {
563         int ret = 0;
564         unsigned seq;
565         unsigned long pfn = page_to_pfn(page);
566         unsigned long sp, start_pfn;
567
568         do {
569                 seq = zone_span_seqbegin(zone);
570                 start_pfn = zone->zone_start_pfn;
571                 sp = zone->spanned_pages;
572                 if (!zone_spans_pfn(zone, pfn))
573                         ret = 1;
574         } while (zone_span_seqretry(zone, seq));
575
576         if (ret)
577                 pr_err("page 0x%lx outside node %d zone %s [ 0x%lx - 0x%lx ]\n",
578                         pfn, zone_to_nid(zone), zone->name,
579                         start_pfn, start_pfn + sp);
580
581         return ret;
582 }
583
584 static int page_is_consistent(struct zone *zone, struct page *page)
585 {
586         if (!pfn_valid_within(page_to_pfn(page)))
587                 return 0;
588         if (zone != page_zone(page))
589                 return 0;
590
591         return 1;
592 }
593 /*
594  * Temporary debugging check for pages not lying within a given zone.
595  */
596 static int __maybe_unused bad_range(struct zone *zone, struct page *page)
597 {
598         if (page_outside_zone_boundaries(zone, page))
599                 return 1;
600         if (!page_is_consistent(zone, page))
601                 return 1;
602
603         return 0;
604 }
605 #else
606 static inline int __maybe_unused bad_range(struct zone *zone, struct page *page)
607 {
608         return 0;
609 }
610 #endif
611
612 static void bad_page(struct page *page, const char *reason,
613                 unsigned long bad_flags)
614 {
615         static unsigned long resume;
616         static unsigned long nr_shown;
617         static unsigned long nr_unshown;
618
619         /*
620          * Allow a burst of 60 reports, then keep quiet for that minute;
621          * or allow a steady drip of one report per second.
622          */
623         if (nr_shown == 60) {
624                 if (time_before(jiffies, resume)) {
625                         nr_unshown++;
626                         goto out;
627                 }
628                 if (nr_unshown) {
629                         pr_alert(
630                               "BUG: Bad page state: %lu messages suppressed\n",
631                                 nr_unshown);
632                         nr_unshown = 0;
633                 }
634                 nr_shown = 0;
635         }
636         if (nr_shown++ == 0)
637                 resume = jiffies + 60 * HZ;
638
639         pr_alert("BUG: Bad page state in process %s  pfn:%05lx\n",
640                 current->comm, page_to_pfn(page));
641         __dump_page(page, reason);
642         bad_flags &= page->flags;
643         if (bad_flags)
644                 pr_alert("bad because of flags: %#lx(%pGp)\n",
645                                                 bad_flags, &bad_flags);
646         dump_page_owner(page);
647
648         print_modules();
649         dump_stack();
650 out:
651         /* Leave bad fields for debug, except PageBuddy could make trouble */
652         page_mapcount_reset(page); /* remove PageBuddy */
653         add_taint(TAINT_BAD_PAGE, LOCKDEP_NOW_UNRELIABLE);
654 }
655
656 /*
657  * Higher-order pages are called "compound pages".  They are structured thusly:
658  *
659  * The first PAGE_SIZE page is called the "head page" and have PG_head set.
660  *
661  * The remaining PAGE_SIZE pages are called "tail pages". PageTail() is encoded
662  * in bit 0 of page->compound_head. The rest of bits is pointer to head page.
663  *
664  * The first tail page's ->compound_dtor holds the offset in array of compound
665  * page destructors. See compound_page_dtors.
666  *
667  * The first tail page's ->compound_order holds the order of allocation.
668  * This usage means that zero-order pages may not be compound.
669  */
670
671 void free_compound_page(struct page *page)
672 {
673         mem_cgroup_uncharge(page);
674         __free_pages_ok(page, compound_order(page));
675 }
676
677 void prep_compound_page(struct page *page, unsigned int order)
678 {
679         int i;
680         int nr_pages = 1 << order;
681
682         set_compound_page_dtor(page, COMPOUND_PAGE_DTOR);
683         set_compound_order(page, order);
684         __SetPageHead(page);
685         for (i = 1; i < nr_pages; i++) {
686                 struct page *p = page + i;
687                 set_page_count(p, 0);
688                 p->mapping = TAIL_MAPPING;
689                 set_compound_head(p, page);
690         }
691         atomic_set(compound_mapcount_ptr(page), -1);
692 }
693
694 #ifdef CONFIG_DEBUG_PAGEALLOC
695 unsigned int _debug_guardpage_minorder;
696
697 #ifdef CONFIG_DEBUG_PAGEALLOC_ENABLE_DEFAULT
698 DEFINE_STATIC_KEY_TRUE(_debug_pagealloc_enabled);
699 #else
700 DEFINE_STATIC_KEY_FALSE(_debug_pagealloc_enabled);
701 #endif
702 EXPORT_SYMBOL(_debug_pagealloc_enabled);
703
704 DEFINE_STATIC_KEY_FALSE(_debug_guardpage_enabled);
705
706 static int __init early_debug_pagealloc(char *buf)
707 {
708         bool enable = false;
709
710         if (kstrtobool(buf, &enable))
711                 return -EINVAL;
712
713         if (enable)
714                 static_branch_enable(&_debug_pagealloc_enabled);
715
716         return 0;
717 }
718 early_param("debug_pagealloc", early_debug_pagealloc);
719
720 static void init_debug_guardpage(void)
721 {
722         if (!debug_pagealloc_enabled())
723                 return;
724
725         if (!debug_guardpage_minorder())
726                 return;
727
728         static_branch_enable(&_debug_guardpage_enabled);
729 }
730
731 static int __init debug_guardpage_minorder_setup(char *buf)
732 {
733         unsigned long res;
734
735         if (kstrtoul(buf, 10, &res) < 0 ||  res > MAX_ORDER / 2) {
736                 pr_err("Bad debug_guardpage_minorder value\n");
737                 return 0;
738         }
739         _debug_guardpage_minorder = res;
740         pr_info("Setting debug_guardpage_minorder to %lu\n", res);
741         return 0;
742 }
743 early_param("debug_guardpage_minorder", debug_guardpage_minorder_setup);
744
745 static inline bool set_page_guard(struct zone *zone, struct page *page,
746                                 unsigned int order, int migratetype)
747 {
748         if (!debug_guardpage_enabled())
749                 return false;
750
751         if (order >= debug_guardpage_minorder())
752                 return false;
753
754         __SetPageGuard(page);
755         INIT_LIST_HEAD(&page->lru);
756         set_page_private(page, order);
757         /* Guard pages are not available for any usage */
758         __mod_zone_freepage_state(zone, -(1 << order), migratetype);
759
760         return true;
761 }
762
763 static inline void clear_page_guard(struct zone *zone, struct page *page,
764                                 unsigned int order, int migratetype)
765 {
766         if (!debug_guardpage_enabled())
767                 return;
768
769         __ClearPageGuard(page);
770
771         set_page_private(page, 0);
772         if (!is_migrate_isolate(migratetype))
773                 __mod_zone_freepage_state(zone, (1 << order), migratetype);
774 }
775 #else
776 static inline bool set_page_guard(struct zone *zone, struct page *page,
777                         unsigned int order, int migratetype) { return false; }
778 static inline void clear_page_guard(struct zone *zone, struct page *page,
779                                 unsigned int order, int migratetype) {}
780 #endif
781
782 static inline void set_page_order(struct page *page, unsigned int order)
783 {
784         set_page_private(page, order);
785         __SetPageBuddy(page);
786 }
787
788 /*
789  * This function checks whether a page is free && is the buddy
790  * we can coalesce a page and its buddy if
791  * (a) the buddy is not in a hole (check before calling!) &&
792  * (b) the buddy is in the buddy system &&
793  * (c) a page and its buddy have the same order &&
794  * (d) a page and its buddy are in the same zone.
795  *
796  * For recording whether a page is in the buddy system, we set PageBuddy.
797  * Setting, clearing, and testing PageBuddy is serialized by zone->lock.
798  *
799  * For recording page's order, we use page_private(page).
800  */
801 static inline int page_is_buddy(struct page *page, struct page *buddy,
802                                                         unsigned int order)
803 {
804         if (page_is_guard(buddy) && page_order(buddy) == order) {
805                 if (page_zone_id(page) != page_zone_id(buddy))
806                         return 0;
807
808                 VM_BUG_ON_PAGE(page_count(buddy) != 0, buddy);
809
810                 return 1;
811         }
812
813         if (PageBuddy(buddy) && page_order(buddy) == order) {
814                 /*
815                  * zone check is done late to avoid uselessly
816                  * calculating zone/node ids for pages that could
817                  * never merge.
818                  */
819                 if (page_zone_id(page) != page_zone_id(buddy))
820                         return 0;
821
822                 VM_BUG_ON_PAGE(page_count(buddy) != 0, buddy);
823
824                 return 1;
825         }
826         return 0;
827 }
828
829 #ifdef CONFIG_COMPACTION
830 static inline struct capture_control *task_capc(struct zone *zone)
831 {
832         struct capture_control *capc = current->capture_control;
833
834         return capc &&
835                 !(current->flags & PF_KTHREAD) &&
836                 !capc->page &&
837                 capc->cc->zone == zone &&
838                 capc->cc->direct_compaction ? capc : NULL;
839 }
840
841 static inline bool
842 compaction_capture(struct capture_control *capc, struct page *page,
843                    int order, int migratetype)
844 {
845         if (!capc || order != capc->cc->order)
846                 return false;
847
848         /* Do not accidentally pollute CMA or isolated regions*/
849         if (is_migrate_cma(migratetype) ||
850             is_migrate_isolate(migratetype))
851                 return false;
852
853         /*
854          * Do not let lower order allocations polluate a movable pageblock.
855          * This might let an unmovable request use a reclaimable pageblock
856          * and vice-versa but no more than normal fallback logic which can
857          * have trouble finding a high-order free page.
858          */
859         if (order < pageblock_order && migratetype == MIGRATE_MOVABLE)
860                 return false;
861
862         capc->page = page;
863         return true;
864 }
865
866 #else
867 static inline struct capture_control *task_capc(struct zone *zone)
868 {
869         return NULL;
870 }
871
872 static inline bool
873 compaction_capture(struct capture_control *capc, struct page *page,
874                    int order, int migratetype)
875 {
876         return false;
877 }
878 #endif /* CONFIG_COMPACTION */
879
880 /*
881  * Freeing function for a buddy system allocator.
882  *
883  * The concept of a buddy system is to maintain direct-mapped table
884  * (containing bit values) for memory blocks of various "orders".
885  * The bottom level table contains the map for the smallest allocatable
886  * units of memory (here, pages), and each level above it describes
887  * pairs of units from the levels below, hence, "buddies".
888  * At a high level, all that happens here is marking the table entry
889  * at the bottom level available, and propagating the changes upward
890  * as necessary, plus some accounting needed to play nicely with other
891  * parts of the VM system.
892  * At each level, we keep a list of pages, which are heads of continuous
893  * free pages of length of (1 << order) and marked with PageBuddy.
894  * Page's order is recorded in page_private(page) field.
895  * So when we are allocating or freeing one, we can derive the state of the
896  * other.  That is, if we allocate a small block, and both were
897  * free, the remainder of the region must be split into blocks.
898  * If a block is freed, and its buddy is also free, then this
899  * triggers coalescing into a block of larger size.
900  *
901  * -- nyc
902  */
903
904 static inline void __free_one_page(struct page *page,
905                 unsigned long pfn,
906                 struct zone *zone, unsigned int order,
907                 int migratetype)
908 {
909         unsigned long combined_pfn;
910         unsigned long uninitialized_var(buddy_pfn);
911         struct page *buddy;
912         unsigned int max_order;
913         struct capture_control *capc = task_capc(zone);
914
915         max_order = min_t(unsigned int, MAX_ORDER, pageblock_order + 1);
916
917         VM_BUG_ON(!zone_is_initialized(zone));
918         VM_BUG_ON_PAGE(page->flags & PAGE_FLAGS_CHECK_AT_PREP, page);
919
920         VM_BUG_ON(migratetype == -1);
921         if (likely(!is_migrate_isolate(migratetype)))
922                 __mod_zone_freepage_state(zone, 1 << order, migratetype);
923
924         VM_BUG_ON_PAGE(pfn & ((1 << order) - 1), page);
925         VM_BUG_ON_PAGE(bad_range(zone, page), page);
926
927 continue_merging:
928         while (order < max_order - 1) {
929                 if (compaction_capture(capc, page, order, migratetype)) {
930                         __mod_zone_freepage_state(zone, -(1 << order),
931                                                                 migratetype);
932                         return;
933                 }
934                 buddy_pfn = __find_buddy_pfn(pfn, order);
935                 buddy = page + (buddy_pfn - pfn);
936
937                 if (!pfn_valid_within(buddy_pfn))
938                         goto done_merging;
939                 if (!page_is_buddy(page, buddy, order))
940                         goto done_merging;
941                 /*
942                  * Our buddy is free or it is CONFIG_DEBUG_PAGEALLOC guard page,
943                  * merge with it and move up one order.
944                  */
945                 if (page_is_guard(buddy))
946                         clear_page_guard(zone, buddy, order, migratetype);
947                 else
948                         del_page_from_free_area(buddy, &zone->free_area[order]);
949                 combined_pfn = buddy_pfn & pfn;
950                 page = page + (combined_pfn - pfn);
951                 pfn = combined_pfn;
952                 order++;
953         }
954         if (max_order < MAX_ORDER) {
955                 /* If we are here, it means order is >= pageblock_order.
956                  * We want to prevent merge between freepages on isolate
957                  * pageblock and normal pageblock. Without this, pageblock
958                  * isolation could cause incorrect freepage or CMA accounting.
959                  *
960                  * We don't want to hit this code for the more frequent
961                  * low-order merging.
962                  */
963                 if (unlikely(has_isolate_pageblock(zone))) {
964                         int buddy_mt;
965
966                         buddy_pfn = __find_buddy_pfn(pfn, order);
967                         buddy = page + (buddy_pfn - pfn);
968                         buddy_mt = get_pageblock_migratetype(buddy);
969
970                         if (migratetype != buddy_mt
971                                         && (is_migrate_isolate(migratetype) ||
972                                                 is_migrate_isolate(buddy_mt)))
973                                 goto done_merging;
974                 }
975                 max_order++;
976                 goto continue_merging;
977         }
978
979 done_merging:
980         set_page_order(page, order);
981
982         /*
983          * If this is not the largest possible page, check if the buddy
984          * of the next-highest order is free. If it is, it's possible
985          * that pages are being freed that will coalesce soon. In case,
986          * that is happening, add the free page to the tail of the list
987          * so it's less likely to be used soon and more likely to be merged
988          * as a higher order page
989          */
990         if ((order < MAX_ORDER-2) && pfn_valid_within(buddy_pfn)
991                         && !is_shuffle_order(order)) {
992                 struct page *higher_page, *higher_buddy;
993                 combined_pfn = buddy_pfn & pfn;
994                 higher_page = page + (combined_pfn - pfn);
995                 buddy_pfn = __find_buddy_pfn(combined_pfn, order + 1);
996                 higher_buddy = higher_page + (buddy_pfn - combined_pfn);
997                 if (pfn_valid_within(buddy_pfn) &&
998                     page_is_buddy(higher_page, higher_buddy, order + 1)) {
999                         add_to_free_area_tail(page, &zone->free_area[order],
1000                                               migratetype);
1001                         return;
1002                 }
1003         }
1004
1005         if (is_shuffle_order(order))
1006                 add_to_free_area_random(page, &zone->free_area[order],
1007                                 migratetype);
1008         else
1009                 add_to_free_area(page, &zone->free_area[order], migratetype);
1010
1011 }
1012
1013 /*
1014  * A bad page could be due to a number of fields. Instead of multiple branches,
1015  * try and check multiple fields with one check. The caller must do a detailed
1016  * check if necessary.
1017  */
1018 static inline bool page_expected_state(struct page *page,
1019                                         unsigned long check_flags)
1020 {
1021         if (unlikely(atomic_read(&page->_mapcount) != -1))
1022                 return false;
1023
1024         if (unlikely((unsigned long)page->mapping |
1025                         page_ref_count(page) |
1026 #ifdef CONFIG_MEMCG
1027                         (unsigned long)page->mem_cgroup |
1028 #endif
1029                         (page->flags & check_flags)))
1030                 return false;
1031
1032         return true;
1033 }
1034
1035 static void free_pages_check_bad(struct page *page)
1036 {
1037         const char *bad_reason;
1038         unsigned long bad_flags;
1039
1040         bad_reason = NULL;
1041         bad_flags = 0;
1042
1043         if (unlikely(atomic_read(&page->_mapcount) != -1))
1044                 bad_reason = "nonzero mapcount";
1045         if (unlikely(page->mapping != NULL))
1046                 bad_reason = "non-NULL mapping";
1047         if (unlikely(page_ref_count(page) != 0))
1048                 bad_reason = "nonzero _refcount";
1049         if (unlikely(page->flags & PAGE_FLAGS_CHECK_AT_FREE)) {
1050                 bad_reason = "PAGE_FLAGS_CHECK_AT_FREE flag(s) set";
1051                 bad_flags = PAGE_FLAGS_CHECK_AT_FREE;
1052         }
1053 #ifdef CONFIG_MEMCG
1054         if (unlikely(page->mem_cgroup))
1055                 bad_reason = "page still charged to cgroup";
1056 #endif
1057         bad_page(page, bad_reason, bad_flags);
1058 }
1059
1060 static inline int free_pages_check(struct page *page)
1061 {
1062         if (likely(page_expected_state(page, PAGE_FLAGS_CHECK_AT_FREE)))
1063                 return 0;
1064
1065         /* Something has gone sideways, find it */
1066         free_pages_check_bad(page);
1067         return 1;
1068 }
1069
1070 static int free_tail_pages_check(struct page *head_page, struct page *page)
1071 {
1072         int ret = 1;
1073
1074         /*
1075          * We rely page->lru.next never has bit 0 set, unless the page
1076          * is PageTail(). Let's make sure that's true even for poisoned ->lru.
1077          */
1078         BUILD_BUG_ON((unsigned long)LIST_POISON1 & 1);
1079
1080         if (!IS_ENABLED(CONFIG_DEBUG_VM)) {
1081                 ret = 0;
1082                 goto out;
1083         }
1084         switch (page - head_page) {
1085         case 1:
1086                 /* the first tail page: ->mapping may be compound_mapcount() */
1087                 if (unlikely(compound_mapcount(page))) {
1088                         bad_page(page, "nonzero compound_mapcount", 0);
1089                         goto out;
1090                 }
1091                 break;
1092         case 2:
1093                 /*
1094                  * the second tail page: ->mapping is
1095                  * deferred_list.next -- ignore value.
1096                  */
1097                 break;
1098         default:
1099                 if (page->mapping != TAIL_MAPPING) {
1100                         bad_page(page, "corrupted mapping in tail page", 0);
1101                         goto out;
1102                 }
1103                 break;
1104         }
1105         if (unlikely(!PageTail(page))) {
1106                 bad_page(page, "PageTail not set", 0);
1107                 goto out;
1108         }
1109         if (unlikely(compound_head(page) != head_page)) {
1110                 bad_page(page, "compound_head not consistent", 0);
1111                 goto out;
1112         }
1113         ret = 0;
1114 out:
1115         page->mapping = NULL;
1116         clear_compound_head(page);
1117         return ret;
1118 }
1119
1120 static void kernel_init_free_pages(struct page *page, int numpages)
1121 {
1122         int i;
1123
1124         for (i = 0; i < numpages; i++)
1125                 clear_highpage(page + i);
1126 }
1127
1128 static __always_inline bool free_pages_prepare(struct page *page,
1129                                         unsigned int order, bool check_free)
1130 {
1131         int bad = 0;
1132
1133         VM_BUG_ON_PAGE(PageTail(page), page);
1134
1135         trace_mm_page_free(page, order);
1136
1137         /*
1138          * Check tail pages before head page information is cleared to
1139          * avoid checking PageCompound for order-0 pages.
1140          */
1141         if (unlikely(order)) {
1142                 bool compound = PageCompound(page);
1143                 int i;
1144
1145                 VM_BUG_ON_PAGE(compound && compound_order(page) != order, page);
1146
1147                 if (compound)
1148                         ClearPageDoubleMap(page);
1149                 for (i = 1; i < (1 << order); i++) {
1150                         if (compound)
1151                                 bad += free_tail_pages_check(page, page + i);
1152                         if (unlikely(free_pages_check(page + i))) {
1153                                 bad++;
1154                                 continue;
1155                         }
1156                         (page + i)->flags &= ~PAGE_FLAGS_CHECK_AT_PREP;
1157                 }
1158         }
1159         if (PageMappingFlags(page))
1160                 page->mapping = NULL;
1161         if (memcg_kmem_enabled() && PageKmemcg(page))
1162                 __memcg_kmem_uncharge(page, order);
1163         if (check_free)
1164                 bad += free_pages_check(page);
1165         if (bad)
1166                 return false;
1167
1168         page_cpupid_reset_last(page);
1169         page->flags &= ~PAGE_FLAGS_CHECK_AT_PREP;
1170         reset_page_owner(page, order);
1171
1172         if (!PageHighMem(page)) {
1173                 debug_check_no_locks_freed(page_address(page),
1174                                            PAGE_SIZE << order);
1175                 debug_check_no_obj_freed(page_address(page),
1176                                            PAGE_SIZE << order);
1177         }
1178         if (want_init_on_free())
1179                 kernel_init_free_pages(page, 1 << order);
1180
1181         kernel_poison_pages(page, 1 << order, 0);
1182         /*
1183          * arch_free_page() can make the page's contents inaccessible.  s390
1184          * does this.  So nothing which can access the page's contents should
1185          * happen after this.
1186          */
1187         arch_free_page(page, order);
1188
1189         if (debug_pagealloc_enabled())
1190                 kernel_map_pages(page, 1 << order, 0);
1191
1192         kasan_free_nondeferred_pages(page, order);
1193
1194         return true;
1195 }
1196
1197 #ifdef CONFIG_DEBUG_VM
1198 /*
1199  * With DEBUG_VM enabled, order-0 pages are checked immediately when being freed
1200  * to pcp lists. With debug_pagealloc also enabled, they are also rechecked when
1201  * moved from pcp lists to free lists.
1202  */
1203 static bool free_pcp_prepare(struct page *page)
1204 {
1205         return free_pages_prepare(page, 0, true);
1206 }
1207
1208 static bool bulkfree_pcp_prepare(struct page *page)
1209 {
1210         if (debug_pagealloc_enabled())
1211                 return free_pages_check(page);
1212         else
1213                 return false;
1214 }
1215 #else
1216 /*
1217  * With DEBUG_VM disabled, order-0 pages being freed are checked only when
1218  * moving from pcp lists to free list in order to reduce overhead. With
1219  * debug_pagealloc enabled, they are checked also immediately when being freed
1220  * to the pcp lists.
1221  */
1222 static bool free_pcp_prepare(struct page *page)
1223 {
1224         if (debug_pagealloc_enabled())
1225                 return free_pages_prepare(page, 0, true);
1226         else
1227                 return free_pages_prepare(page, 0, false);
1228 }
1229
1230 static bool bulkfree_pcp_prepare(struct page *page)
1231 {
1232         return free_pages_check(page);
1233 }
1234 #endif /* CONFIG_DEBUG_VM */
1235
1236 static inline void prefetch_buddy(struct page *page)
1237 {
1238         unsigned long pfn = page_to_pfn(page);
1239         unsigned long buddy_pfn = __find_buddy_pfn(pfn, 0);
1240         struct page *buddy = page + (buddy_pfn - pfn);
1241
1242         prefetch(buddy);
1243 }
1244
1245 /*
1246  * Frees a number of pages from the PCP lists
1247  * Assumes all pages on list are in same zone, and of same order.
1248  * count is the number of pages to free.
1249  *
1250  * If the zone was previously in an "all pages pinned" state then look to
1251  * see if this freeing clears that state.
1252  *
1253  * And clear the zone's pages_scanned counter, to hold off the "all pages are
1254  * pinned" detection logic.
1255  */
1256 static void free_pcppages_bulk(struct zone *zone, int count,
1257                                         struct per_cpu_pages *pcp)
1258 {
1259         int migratetype = 0;
1260         int batch_free = 0;
1261         int prefetch_nr = 0;
1262         bool isolated_pageblocks;
1263         struct page *page, *tmp;
1264         LIST_HEAD(head);
1265
1266         while (count) {
1267                 struct list_head *list;
1268
1269                 /*
1270                  * Remove pages from lists in a round-robin fashion. A
1271                  * batch_free count is maintained that is incremented when an
1272                  * empty list is encountered.  This is so more pages are freed
1273                  * off fuller lists instead of spinning excessively around empty
1274                  * lists
1275                  */
1276                 do {
1277                         batch_free++;
1278                         if (++migratetype == MIGRATE_PCPTYPES)
1279                                 migratetype = 0;
1280                         list = &pcp->lists[migratetype];
1281                 } while (list_empty(list));
1282
1283                 /* This is the only non-empty list. Free them all. */
1284                 if (batch_free == MIGRATE_PCPTYPES)
1285                         batch_free = count;
1286
1287                 do {
1288                         page = list_last_entry(list, struct page, lru);
1289                         /* must delete to avoid corrupting pcp list */
1290                         list_del(&page->lru);
1291                         pcp->count--;
1292
1293                         if (bulkfree_pcp_prepare(page))
1294                                 continue;
1295
1296                         list_add_tail(&page->lru, &head);
1297
1298                         /*
1299                          * We are going to put the page back to the global
1300                          * pool, prefetch its buddy to speed up later access
1301                          * under zone->lock. It is believed the overhead of
1302                          * an additional test and calculating buddy_pfn here
1303                          * can be offset by reduced memory latency later. To
1304                          * avoid excessive prefetching due to large count, only
1305                          * prefetch buddy for the first pcp->batch nr of pages.
1306                          */
1307                         if (prefetch_nr++ < pcp->batch)
1308                                 prefetch_buddy(page);
1309                 } while (--count && --batch_free && !list_empty(list));
1310         }
1311
1312         spin_lock(&zone->lock);
1313         isolated_pageblocks = has_isolate_pageblock(zone);
1314
1315         /*
1316          * Use safe version since after __free_one_page(),
1317          * page->lru.next will not point to original list.
1318          */
1319         list_for_each_entry_safe(page, tmp, &head, lru) {
1320                 int mt = get_pcppage_migratetype(page);
1321                 /* MIGRATE_ISOLATE page should not go to pcplists */
1322                 VM_BUG_ON_PAGE(is_migrate_isolate(mt), page);
1323                 /* Pageblock could have been isolated meanwhile */
1324                 if (unlikely(isolated_pageblocks))
1325                         mt = get_pageblock_migratetype(page);
1326
1327                 __free_one_page(page, page_to_pfn(page), zone, 0, mt);
1328                 trace_mm_page_pcpu_drain(page, 0, mt);
1329         }
1330         spin_unlock(&zone->lock);
1331 }
1332
1333 static void free_one_page(struct zone *zone,
1334                                 struct page *page, unsigned long pfn,
1335                                 unsigned int order,
1336                                 int migratetype)
1337 {
1338         spin_lock(&zone->lock);
1339         if (unlikely(has_isolate_pageblock(zone) ||
1340                 is_migrate_isolate(migratetype))) {
1341                 migratetype = get_pfnblock_migratetype(page, pfn);
1342         }
1343         __free_one_page(page, pfn, zone, order, migratetype);
1344         spin_unlock(&zone->lock);
1345 }
1346
1347 static void __meminit __init_single_page(struct page *page, unsigned long pfn,
1348                                 unsigned long zone, int nid)
1349 {
1350         mm_zero_struct_page(page);
1351         set_page_links(page, zone, nid, pfn);
1352         init_page_count(page);
1353         page_mapcount_reset(page);
1354         page_cpupid_reset_last(page);
1355         page_kasan_tag_reset(page);
1356
1357         INIT_LIST_HEAD(&page->lru);
1358 #ifdef WANT_PAGE_VIRTUAL
1359         /* The shift won't overflow because ZONE_NORMAL is below 4G. */
1360         if (!is_highmem_idx(zone))
1361                 set_page_address(page, __va(pfn << PAGE_SHIFT));
1362 #endif
1363 }
1364
1365 #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
1366 static void __meminit init_reserved_page(unsigned long pfn)
1367 {
1368         pg_data_t *pgdat;
1369         int nid, zid;
1370
1371         if (!early_page_uninitialised(pfn))
1372                 return;
1373
1374         nid = early_pfn_to_nid(pfn);
1375         pgdat = NODE_DATA(nid);
1376
1377         for (zid = 0; zid < MAX_NR_ZONES; zid++) {
1378                 struct zone *zone = &pgdat->node_zones[zid];
1379
1380                 if (pfn >= zone->zone_start_pfn && pfn < zone_end_pfn(zone))
1381                         break;
1382         }
1383         __init_single_page(pfn_to_page(pfn), pfn, zid, nid);
1384 }
1385 #else
1386 static inline void init_reserved_page(unsigned long pfn)
1387 {
1388 }
1389 #endif /* CONFIG_DEFERRED_STRUCT_PAGE_INIT */
1390
1391 /*
1392  * Initialised pages do not have PageReserved set. This function is
1393  * called for each range allocated by the bootmem allocator and
1394  * marks the pages PageReserved. The remaining valid pages are later
1395  * sent to the buddy page allocator.
1396  */
1397 void __meminit reserve_bootmem_region(phys_addr_t start, phys_addr_t end)
1398 {
1399         unsigned long start_pfn = PFN_DOWN(start);
1400         unsigned long end_pfn = PFN_UP(end);
1401
1402         for (; start_pfn < end_pfn; start_pfn++) {
1403                 if (pfn_valid(start_pfn)) {
1404                         struct page *page = pfn_to_page(start_pfn);
1405
1406                         init_reserved_page(start_pfn);
1407
1408                         /* Avoid false-positive PageTail() */
1409                         INIT_LIST_HEAD(&page->lru);
1410
1411                         /*
1412                          * no need for atomic set_bit because the struct
1413                          * page is not visible yet so nobody should
1414                          * access it yet.
1415                          */
1416                         __SetPageReserved(page);
1417                 }
1418         }
1419 }
1420
1421 static void __free_pages_ok(struct page *page, unsigned int order)
1422 {
1423         unsigned long flags;
1424         int migratetype;
1425         unsigned long pfn = page_to_pfn(page);
1426
1427         if (!free_pages_prepare(page, order, true))
1428                 return;
1429
1430         migratetype = get_pfnblock_migratetype(page, pfn);
1431         local_irq_save(flags);
1432         __count_vm_events(PGFREE, 1 << order);
1433         free_one_page(page_zone(page), page, pfn, order, migratetype);
1434         local_irq_restore(flags);
1435 }
1436
1437 void __free_pages_core(struct page *page, unsigned int order)
1438 {
1439         unsigned int nr_pages = 1 << order;
1440         struct page *p = page;
1441         unsigned int loop;
1442
1443         prefetchw(p);
1444         for (loop = 0; loop < (nr_pages - 1); loop++, p++) {
1445                 prefetchw(p + 1);
1446                 __ClearPageReserved(p);
1447                 set_page_count(p, 0);
1448         }
1449         __ClearPageReserved(p);
1450         set_page_count(p, 0);
1451
1452         atomic_long_add(nr_pages, &page_zone(page)->managed_pages);
1453         set_page_refcounted(page);
1454         __free_pages(page, order);
1455 }
1456
1457 #if defined(CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID) || \
1458         defined(CONFIG_HAVE_MEMBLOCK_NODE_MAP)
1459
1460 static struct mminit_pfnnid_cache early_pfnnid_cache __meminitdata;
1461
1462 int __meminit early_pfn_to_nid(unsigned long pfn)
1463 {
1464         static DEFINE_SPINLOCK(early_pfn_lock);
1465         int nid;
1466
1467         spin_lock(&early_pfn_lock);
1468         nid = __early_pfn_to_nid(pfn, &early_pfnnid_cache);
1469         if (nid < 0)
1470                 nid = first_online_node;
1471         spin_unlock(&early_pfn_lock);
1472
1473         return nid;
1474 }
1475 #endif
1476
1477 #ifdef CONFIG_NODES_SPAN_OTHER_NODES
1478 /* Only safe to use early in boot when initialisation is single-threaded */
1479 static inline bool __meminit early_pfn_in_nid(unsigned long pfn, int node)
1480 {
1481         int nid;
1482
1483         nid = __early_pfn_to_nid(pfn, &early_pfnnid_cache);
1484         if (nid >= 0 && nid != node)
1485                 return false;
1486         return true;
1487 }
1488
1489 #else
1490 static inline bool __meminit early_pfn_in_nid(unsigned long pfn, int node)
1491 {
1492         return true;
1493 }
1494 #endif
1495
1496
1497 void __init memblock_free_pages(struct page *page, unsigned long pfn,
1498                                                         unsigned int order)
1499 {
1500         if (early_page_uninitialised(pfn))
1501                 return;
1502         __free_pages_core(page, order);
1503 }
1504
1505 /*
1506  * Check that the whole (or subset of) a pageblock given by the interval of
1507  * [start_pfn, end_pfn) is valid and within the same zone, before scanning it
1508  * with the migration of free compaction scanner. The scanners then need to
1509  * use only pfn_valid_within() check for arches that allow holes within
1510  * pageblocks.
1511  *
1512  * Return struct page pointer of start_pfn, or NULL if checks were not passed.
1513  *
1514  * It's possible on some configurations to have a setup like node0 node1 node0
1515  * i.e. it's possible that all pages within a zones range of pages do not
1516  * belong to a single zone. We assume that a border between node0 and node1
1517  * can occur within a single pageblock, but not a node0 node1 node0
1518  * interleaving within a single pageblock. It is therefore sufficient to check
1519  * the first and last page of a pageblock and avoid checking each individual
1520  * page in a pageblock.
1521  */
1522 struct page *__pageblock_pfn_to_page(unsigned long start_pfn,
1523                                      unsigned long end_pfn, struct zone *zone)
1524 {
1525         struct page *start_page;
1526         struct page *end_page;
1527
1528         /* end_pfn is one past the range we are checking */
1529         end_pfn--;
1530
1531         if (!pfn_valid(start_pfn) || !pfn_valid(end_pfn))
1532                 return NULL;
1533
1534         start_page = pfn_to_online_page(start_pfn);
1535         if (!start_page)
1536                 return NULL;
1537
1538         if (page_zone(start_page) != zone)
1539                 return NULL;
1540
1541         end_page = pfn_to_page(end_pfn);
1542
1543         /* This gives a shorter code than deriving page_zone(end_page) */
1544         if (page_zone_id(start_page) != page_zone_id(end_page))
1545                 return NULL;
1546
1547         return start_page;
1548 }
1549
1550 void set_zone_contiguous(struct zone *zone)
1551 {
1552         unsigned long block_start_pfn = zone->zone_start_pfn;
1553         unsigned long block_end_pfn;
1554
1555         block_end_pfn = ALIGN(block_start_pfn + 1, pageblock_nr_pages);
1556         for (; block_start_pfn < zone_end_pfn(zone);
1557                         block_start_pfn = block_end_pfn,
1558                          block_end_pfn += pageblock_nr_pages) {
1559
1560                 block_end_pfn = min(block_end_pfn, zone_end_pfn(zone));
1561
1562                 if (!__pageblock_pfn_to_page(block_start_pfn,
1563                                              block_end_pfn, zone))
1564                         return;
1565         }
1566
1567         /* We confirm that there is no hole */
1568         zone->contiguous = true;
1569 }
1570
1571 void clear_zone_contiguous(struct zone *zone)
1572 {
1573         zone->contiguous = false;
1574 }
1575
1576 #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
1577 static void __init deferred_free_range(unsigned long pfn,
1578                                        unsigned long nr_pages)
1579 {
1580         struct page *page;
1581         unsigned long i;
1582
1583         if (!nr_pages)
1584                 return;
1585
1586         page = pfn_to_page(pfn);
1587
1588         /* Free a large naturally-aligned chunk if possible */
1589         if (nr_pages == pageblock_nr_pages &&
1590             (pfn & (pageblock_nr_pages - 1)) == 0) {
1591                 set_pageblock_migratetype(page, MIGRATE_MOVABLE);
1592                 __free_pages_core(page, pageblock_order);
1593                 return;
1594         }
1595
1596         for (i = 0; i < nr_pages; i++, page++, pfn++) {
1597                 if ((pfn & (pageblock_nr_pages - 1)) == 0)
1598                         set_pageblock_migratetype(page, MIGRATE_MOVABLE);
1599                 __free_pages_core(page, 0);
1600         }
1601 }
1602
1603 /* Completion tracking for deferred_init_memmap() threads */
1604 static atomic_t pgdat_init_n_undone __initdata;
1605 static __initdata DECLARE_COMPLETION(pgdat_init_all_done_comp);
1606
1607 static inline void __init pgdat_init_report_one_done(void)
1608 {
1609         if (atomic_dec_and_test(&pgdat_init_n_undone))
1610                 complete(&pgdat_init_all_done_comp);
1611 }
1612
1613 /*
1614  * Returns true if page needs to be initialized or freed to buddy allocator.
1615  *
1616  * First we check if pfn is valid on architectures where it is possible to have
1617  * holes within pageblock_nr_pages. On systems where it is not possible, this
1618  * function is optimized out.
1619  *
1620  * Then, we check if a current large page is valid by only checking the validity
1621  * of the head pfn.
1622  */
1623 static inline bool __init deferred_pfn_valid(unsigned long pfn)
1624 {
1625         if (!pfn_valid_within(pfn))
1626                 return false;
1627         if (!(pfn & (pageblock_nr_pages - 1)) && !pfn_valid(pfn))
1628                 return false;
1629         return true;
1630 }
1631
1632 /*
1633  * Free pages to buddy allocator. Try to free aligned pages in
1634  * pageblock_nr_pages sizes.
1635  */
1636 static void __init deferred_free_pages(unsigned long pfn,
1637                                        unsigned long end_pfn)
1638 {
1639         unsigned long nr_pgmask = pageblock_nr_pages - 1;
1640         unsigned long nr_free = 0;
1641
1642         for (; pfn < end_pfn; pfn++) {
1643                 if (!deferred_pfn_valid(pfn)) {
1644                         deferred_free_range(pfn - nr_free, nr_free);
1645                         nr_free = 0;
1646                 } else if (!(pfn & nr_pgmask)) {
1647                         deferred_free_range(pfn - nr_free, nr_free);
1648                         nr_free = 1;
1649                         touch_nmi_watchdog();
1650                 } else {
1651                         nr_free++;
1652                 }
1653         }
1654         /* Free the last block of pages to allocator */
1655         deferred_free_range(pfn - nr_free, nr_free);
1656 }
1657
1658 /*
1659  * Initialize struct pages.  We minimize pfn page lookups and scheduler checks
1660  * by performing it only once every pageblock_nr_pages.
1661  * Return number of pages initialized.
1662  */
1663 static unsigned long  __init deferred_init_pages(struct zone *zone,
1664                                                  unsigned long pfn,
1665                                                  unsigned long end_pfn)
1666 {
1667         unsigned long nr_pgmask = pageblock_nr_pages - 1;
1668         int nid = zone_to_nid(zone);
1669         unsigned long nr_pages = 0;
1670         int zid = zone_idx(zone);
1671         struct page *page = NULL;
1672
1673         for (; pfn < end_pfn; pfn++) {
1674                 if (!deferred_pfn_valid(pfn)) {
1675                         page = NULL;
1676                         continue;
1677                 } else if (!page || !(pfn & nr_pgmask)) {
1678                         page = pfn_to_page(pfn);
1679                         touch_nmi_watchdog();
1680                 } else {
1681                         page++;
1682                 }
1683                 __init_single_page(page, pfn, zid, nid);
1684                 nr_pages++;
1685         }
1686         return (nr_pages);
1687 }
1688
1689 /*
1690  * This function is meant to pre-load the iterator for the zone init.
1691  * Specifically it walks through the ranges until we are caught up to the
1692  * first_init_pfn value and exits there. If we never encounter the value we
1693  * return false indicating there are no valid ranges left.
1694  */
1695 static bool __init
1696 deferred_init_mem_pfn_range_in_zone(u64 *i, struct zone *zone,
1697                                     unsigned long *spfn, unsigned long *epfn,
1698                                     unsigned long first_init_pfn)
1699 {
1700         u64 j;
1701
1702         /*
1703          * Start out by walking through the ranges in this zone that have
1704          * already been initialized. We don't need to do anything with them
1705          * so we just need to flush them out of the system.
1706          */
1707         for_each_free_mem_pfn_range_in_zone(j, zone, spfn, epfn) {
1708                 if (*epfn <= first_init_pfn)
1709                         continue;
1710                 if (*spfn < first_init_pfn)
1711                         *spfn = first_init_pfn;
1712                 *i = j;
1713                 return true;
1714         }
1715
1716         return false;
1717 }
1718
1719 /*
1720  * Initialize and free pages. We do it in two loops: first we initialize
1721  * struct page, then free to buddy allocator, because while we are
1722  * freeing pages we can access pages that are ahead (computing buddy
1723  * page in __free_one_page()).
1724  *
1725  * In order to try and keep some memory in the cache we have the loop
1726  * broken along max page order boundaries. This way we will not cause
1727  * any issues with the buddy page computation.
1728  */
1729 static unsigned long __init
1730 deferred_init_maxorder(u64 *i, struct zone *zone, unsigned long *start_pfn,
1731                        unsigned long *end_pfn)
1732 {
1733         unsigned long mo_pfn = ALIGN(*start_pfn + 1, MAX_ORDER_NR_PAGES);
1734         unsigned long spfn = *start_pfn, epfn = *end_pfn;
1735         unsigned long nr_pages = 0;
1736         u64 j = *i;
1737
1738         /* First we loop through and initialize the page values */
1739         for_each_free_mem_pfn_range_in_zone_from(j, zone, start_pfn, end_pfn) {
1740                 unsigned long t;
1741
1742                 if (mo_pfn <= *start_pfn)
1743                         break;
1744
1745                 t = min(mo_pfn, *end_pfn);
1746                 nr_pages += deferred_init_pages(zone, *start_pfn, t);
1747
1748                 if (mo_pfn < *end_pfn) {
1749                         *start_pfn = mo_pfn;
1750                         break;
1751                 }
1752         }
1753
1754         /* Reset values and now loop through freeing pages as needed */
1755         swap(j, *i);
1756
1757         for_each_free_mem_pfn_range_in_zone_from(j, zone, &spfn, &epfn) {
1758                 unsigned long t;
1759
1760                 if (mo_pfn <= spfn)
1761                         break;
1762
1763                 t = min(mo_pfn, epfn);
1764                 deferred_free_pages(spfn, t);
1765
1766                 if (mo_pfn <= epfn)
1767                         break;
1768         }
1769
1770         return nr_pages;
1771 }
1772
1773 /* Initialise remaining memory on a node */
1774 static int __init deferred_init_memmap(void *data)
1775 {
1776         pg_data_t *pgdat = data;
1777         const struct cpumask *cpumask = cpumask_of_node(pgdat->node_id);
1778         unsigned long spfn = 0, epfn = 0, nr_pages = 0;
1779         unsigned long first_init_pfn, flags;
1780         unsigned long start = jiffies;
1781         struct zone *zone;
1782         int zid;
1783         u64 i;
1784
1785         /* Bind memory initialisation thread to a local node if possible */
1786         if (!cpumask_empty(cpumask))
1787                 set_cpus_allowed_ptr(current, cpumask);
1788
1789         pgdat_resize_lock(pgdat, &flags);
1790         first_init_pfn = pgdat->first_deferred_pfn;
1791         if (first_init_pfn == ULONG_MAX) {
1792                 pgdat_resize_unlock(pgdat, &flags);
1793                 pgdat_init_report_one_done();
1794                 return 0;
1795         }
1796
1797         /* Sanity check boundaries */
1798         BUG_ON(pgdat->first_deferred_pfn < pgdat->node_start_pfn);
1799         BUG_ON(pgdat->first_deferred_pfn > pgdat_end_pfn(pgdat));
1800         pgdat->first_deferred_pfn = ULONG_MAX;
1801
1802         /* Only the highest zone is deferred so find it */
1803         for (zid = 0; zid < MAX_NR_ZONES; zid++) {
1804                 zone = pgdat->node_zones + zid;
1805                 if (first_init_pfn < zone_end_pfn(zone))
1806                         break;
1807         }
1808
1809         /* If the zone is empty somebody else may have cleared out the zone */
1810         if (!deferred_init_mem_pfn_range_in_zone(&i, zone, &spfn, &epfn,
1811                                                  first_init_pfn))
1812                 goto zone_empty;
1813
1814         /*
1815          * Initialize and free pages in MAX_ORDER sized increments so
1816          * that we can avoid introducing any issues with the buddy
1817          * allocator.
1818          */
1819         while (spfn < epfn)
1820                 nr_pages += deferred_init_maxorder(&i, zone, &spfn, &epfn);
1821 zone_empty:
1822         pgdat_resize_unlock(pgdat, &flags);
1823
1824         /* Sanity check that the next zone really is unpopulated */
1825         WARN_ON(++zid < MAX_NR_ZONES && populated_zone(++zone));
1826
1827         pr_info("node %d initialised, %lu pages in %ums\n",
1828                 pgdat->node_id, nr_pages, jiffies_to_msecs(jiffies - start));
1829
1830         pgdat_init_report_one_done();
1831         return 0;
1832 }
1833
1834 /*
1835  * If this zone has deferred pages, try to grow it by initializing enough
1836  * deferred pages to satisfy the allocation specified by order, rounded up to
1837  * the nearest PAGES_PER_SECTION boundary.  So we're adding memory in increments
1838  * of SECTION_SIZE bytes by initializing struct pages in increments of
1839  * PAGES_PER_SECTION * sizeof(struct page) bytes.
1840  *
1841  * Return true when zone was grown, otherwise return false. We return true even
1842  * when we grow less than requested, to let the caller decide if there are
1843  * enough pages to satisfy the allocation.
1844  *
1845  * Note: We use noinline because this function is needed only during boot, and
1846  * it is called from a __ref function _deferred_grow_zone. This way we are
1847  * making sure that it is not inlined into permanent text section.
1848  */
1849 static noinline bool __init
1850 deferred_grow_zone(struct zone *zone, unsigned int order)
1851 {
1852         unsigned long nr_pages_needed = ALIGN(1 << order, PAGES_PER_SECTION);
1853         pg_data_t *pgdat = zone->zone_pgdat;
1854         unsigned long first_deferred_pfn = pgdat->first_deferred_pfn;
1855         unsigned long spfn, epfn, flags;
1856         unsigned long nr_pages = 0;
1857         u64 i;
1858
1859         /* Only the last zone may have deferred pages */
1860         if (zone_end_pfn(zone) != pgdat_end_pfn(pgdat))
1861                 return false;
1862
1863         pgdat_resize_lock(pgdat, &flags);
1864
1865         /*
1866          * If deferred pages have been initialized while we were waiting for
1867          * the lock, return true, as the zone was grown.  The caller will retry
1868          * this zone.  We won't return to this function since the caller also
1869          * has this static branch.
1870          */
1871         if (!static_branch_unlikely(&deferred_pages)) {
1872                 pgdat_resize_unlock(pgdat, &flags);
1873                 return true;
1874         }
1875
1876         /*
1877          * If someone grew this zone while we were waiting for spinlock, return
1878          * true, as there might be enough pages already.
1879          */
1880         if (first_deferred_pfn != pgdat->first_deferred_pfn) {
1881                 pgdat_resize_unlock(pgdat, &flags);
1882                 return true;
1883         }
1884
1885         /* If the zone is empty somebody else may have cleared out the zone */
1886         if (!deferred_init_mem_pfn_range_in_zone(&i, zone, &spfn, &epfn,
1887                                                  first_deferred_pfn)) {
1888                 pgdat->first_deferred_pfn = ULONG_MAX;
1889                 pgdat_resize_unlock(pgdat, &flags);
1890                 /* Retry only once. */
1891                 return first_deferred_pfn != ULONG_MAX;
1892         }
1893
1894         /*
1895          * Initialize and free pages in MAX_ORDER sized increments so
1896          * that we can avoid introducing any issues with the buddy
1897          * allocator.
1898          */
1899         while (spfn < epfn) {
1900                 /* update our first deferred PFN for this section */
1901                 first_deferred_pfn = spfn;
1902
1903                 nr_pages += deferred_init_maxorder(&i, zone, &spfn, &epfn);
1904
1905                 /* We should only stop along section boundaries */
1906                 if ((first_deferred_pfn ^ spfn) < PAGES_PER_SECTION)
1907                         continue;
1908
1909                 /* If our quota has been met we can stop here */
1910                 if (nr_pages >= nr_pages_needed)
1911                         break;
1912         }
1913
1914         pgdat->first_deferred_pfn = spfn;
1915         pgdat_resize_unlock(pgdat, &flags);
1916
1917         return nr_pages > 0;
1918 }
1919
1920 /*
1921  * deferred_grow_zone() is __init, but it is called from
1922  * get_page_from_freelist() during early boot until deferred_pages permanently
1923  * disables this call. This is why we have refdata wrapper to avoid warning,
1924  * and to ensure that the function body gets unloaded.
1925  */
1926 static bool __ref
1927 _deferred_grow_zone(struct zone *zone, unsigned int order)
1928 {
1929         return deferred_grow_zone(zone, order);
1930 }
1931
1932 #endif /* CONFIG_DEFERRED_STRUCT_PAGE_INIT */
1933
1934 void __init page_alloc_init_late(void)
1935 {
1936         struct zone *zone;
1937         int nid;
1938
1939 #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
1940
1941         /* There will be num_node_state(N_MEMORY) threads */
1942         atomic_set(&pgdat_init_n_undone, num_node_state(N_MEMORY));
1943         for_each_node_state(nid, N_MEMORY) {
1944                 kthread_run(deferred_init_memmap, NODE_DATA(nid), "pgdatinit%d", nid);
1945         }
1946
1947         /* Block until all are initialised */
1948         wait_for_completion(&pgdat_init_all_done_comp);
1949
1950         /*
1951          * We initialized the rest of the deferred pages.  Permanently disable
1952          * on-demand struct page initialization.
1953          */
1954         static_branch_disable(&deferred_pages);
1955
1956         /* Reinit limits that are based on free pages after the kernel is up */
1957         files_maxfiles_init();
1958 #endif
1959
1960         /* Discard memblock private memory */
1961         memblock_discard();
1962
1963         for_each_node_state(nid, N_MEMORY)
1964                 shuffle_free_memory(NODE_DATA(nid));
1965
1966         for_each_populated_zone(zone)
1967                 set_zone_contiguous(zone);
1968
1969 #ifdef CONFIG_DEBUG_PAGEALLOC
1970         init_debug_guardpage();
1971 #endif
1972 }
1973
1974 #ifdef CONFIG_CMA
1975 /* Free whole pageblock and set its migration type to MIGRATE_CMA. */
1976 void __init init_cma_reserved_pageblock(struct page *page)
1977 {
1978         unsigned i = pageblock_nr_pages;
1979         struct page *p = page;
1980
1981         do {
1982                 __ClearPageReserved(p);
1983                 set_page_count(p, 0);
1984         } while (++p, --i);
1985
1986         set_pageblock_migratetype(page, MIGRATE_CMA);
1987
1988         if (pageblock_order >= MAX_ORDER) {
1989                 i = pageblock_nr_pages;
1990                 p = page;
1991                 do {
1992                         set_page_refcounted(p);
1993                         __free_pages(p, MAX_ORDER - 1);
1994                         p += MAX_ORDER_NR_PAGES;
1995                 } while (i -= MAX_ORDER_NR_PAGES);
1996         } else {
1997                 set_page_refcounted(page);
1998                 __free_pages(page, pageblock_order);
1999         }
2000
2001         adjust_managed_page_count(page, pageblock_nr_pages);
2002 }
2003 #endif
2004
2005 /*
2006  * The order of subdivision here is critical for the IO subsystem.
2007  * Please do not alter this order without good reasons and regression
2008  * testing. Specifically, as large blocks of memory are subdivided,
2009  * the order in which smaller blocks are delivered depends on the order
2010  * they're subdivided in this function. This is the primary factor
2011  * influencing the order in which pages are delivered to the IO
2012  * subsystem according to empirical testing, and this is also justified
2013  * by considering the behavior of a buddy system containing a single
2014  * large block of memory acted on by a series of small allocations.
2015  * This behavior is a critical factor in sglist merging's success.
2016  *
2017  * -- nyc
2018  */
2019 static inline void expand(struct zone *zone, struct page *page,
2020         int low, int high, struct free_area *area,
2021         int migratetype)
2022 {
2023         unsigned long size = 1 << high;
2024
2025         while (high > low) {
2026                 area--;
2027                 high--;
2028                 size >>= 1;
2029                 VM_BUG_ON_PAGE(bad_range(zone, &page[size]), &page[size]);
2030
2031                 /*
2032                  * Mark as guard pages (or page), that will allow to
2033                  * merge back to allocator when buddy will be freed.
2034                  * Corresponding page table entries will not be touched,
2035                  * pages will stay not present in virtual address space
2036                  */
2037                 if (set_page_guard(zone, &page[size], high, migratetype))
2038                         continue;
2039
2040                 add_to_free_area(&page[size], area, migratetype);
2041                 set_page_order(&page[size], high);
2042         }
2043 }
2044
2045 static void check_new_page_bad(struct page *page)
2046 {
2047         const char *bad_reason = NULL;
2048         unsigned long bad_flags = 0;
2049
2050         if (unlikely(atomic_read(&page->_mapcount) != -1))
2051                 bad_reason = "nonzero mapcount";
2052         if (unlikely(page->mapping != NULL))
2053                 bad_reason = "non-NULL mapping";
2054         if (unlikely(page_ref_count(page) != 0))
2055                 bad_reason = "nonzero _refcount";
2056         if (unlikely(page->flags & __PG_HWPOISON)) {
2057                 bad_reason = "HWPoisoned (hardware-corrupted)";
2058                 bad_flags = __PG_HWPOISON;
2059                 /* Don't complain about hwpoisoned pages */
2060                 page_mapcount_reset(page); /* remove PageBuddy */
2061                 return;
2062         }
2063         if (unlikely(page->flags & PAGE_FLAGS_CHECK_AT_PREP)) {
2064                 bad_reason = "PAGE_FLAGS_CHECK_AT_PREP flag set";
2065                 bad_flags = PAGE_FLAGS_CHECK_AT_PREP;
2066         }
2067 #ifdef CONFIG_MEMCG
2068         if (unlikely(page->mem_cgroup))
2069                 bad_reason = "page still charged to cgroup";
2070 #endif
2071         bad_page(page, bad_reason, bad_flags);
2072 }
2073
2074 /*
2075  * This page is about to be returned from the page allocator
2076  */
2077 static inline int check_new_page(struct page *page)
2078 {
2079         if (likely(page_expected_state(page,
2080                                 PAGE_FLAGS_CHECK_AT_PREP|__PG_HWPOISON)))
2081                 return 0;
2082
2083         check_new_page_bad(page);
2084         return 1;
2085 }
2086
2087 static inline bool free_pages_prezeroed(void)
2088 {
2089         return (IS_ENABLED(CONFIG_PAGE_POISONING_ZERO) &&
2090                 page_poisoning_enabled()) || want_init_on_free();
2091 }
2092
2093 #ifdef CONFIG_DEBUG_VM
2094 /*
2095  * With DEBUG_VM enabled, order-0 pages are checked for expected state when
2096  * being allocated from pcp lists. With debug_pagealloc also enabled, they are
2097  * also checked when pcp lists are refilled from the free lists.
2098  */
2099 static inline bool check_pcp_refill(struct page *page)
2100 {
2101         if (debug_pagealloc_enabled())
2102                 return check_new_page(page);
2103         else
2104                 return false;
2105 }
2106
2107 static inline bool check_new_pcp(struct page *page)
2108 {
2109         return check_new_page(page);
2110 }
2111 #else
2112 /*
2113  * With DEBUG_VM disabled, free order-0 pages are checked for expected state
2114  * when pcp lists are being refilled from the free lists. With debug_pagealloc
2115  * enabled, they are also checked when being allocated from the pcp lists.
2116  */
2117 static inline bool check_pcp_refill(struct page *page)
2118 {
2119         return check_new_page(page);
2120 }
2121 static inline bool check_new_pcp(struct page *page)
2122 {
2123         if (debug_pagealloc_enabled())
2124                 return check_new_page(page);
2125         else
2126                 return false;
2127 }
2128 #endif /* CONFIG_DEBUG_VM */
2129
2130 static bool check_new_pages(struct page *page, unsigned int order)
2131 {
2132         int i;
2133         for (i = 0; i < (1 << order); i++) {
2134                 struct page *p = page + i;
2135
2136                 if (unlikely(check_new_page(p)))
2137                         return true;
2138         }
2139
2140         return false;
2141 }
2142
2143 inline void post_alloc_hook(struct page *page, unsigned int order,
2144                                 gfp_t gfp_flags)
2145 {
2146         set_page_private(page, 0);
2147         set_page_refcounted(page);
2148
2149         arch_alloc_page(page, order);
2150         if (debug_pagealloc_enabled())
2151                 kernel_map_pages(page, 1 << order, 1);
2152         kasan_alloc_pages(page, order);
2153         kernel_poison_pages(page, 1 << order, 1);
2154         set_page_owner(page, order, gfp_flags);
2155 }
2156
2157 static void prep_new_page(struct page *page, unsigned int order, gfp_t gfp_flags,
2158                                                         unsigned int alloc_flags)
2159 {
2160         post_alloc_hook(page, order, gfp_flags);
2161
2162         if (!free_pages_prezeroed() && want_init_on_alloc(gfp_flags))
2163                 kernel_init_free_pages(page, 1 << order);
2164
2165         if (order && (gfp_flags & __GFP_COMP))
2166                 prep_compound_page(page, order);
2167
2168         /*
2169          * page is set pfmemalloc when ALLOC_NO_WATERMARKS was necessary to
2170          * allocate the page. The expectation is that the caller is taking
2171          * steps that will free more memory. The caller should avoid the page
2172          * being used for !PFMEMALLOC purposes.
2173          */
2174         if (alloc_flags & ALLOC_NO_WATERMARKS)
2175                 set_page_pfmemalloc(page);
2176         else
2177                 clear_page_pfmemalloc(page);
2178 }
2179
2180 /*
2181  * Go through the free lists for the given migratetype and remove
2182  * the smallest available page from the freelists
2183  */
2184 static __always_inline
2185 struct page *__rmqueue_smallest(struct zone *zone, unsigned int order,
2186                                                 int migratetype)
2187 {
2188         unsigned int current_order;
2189         struct free_area *area;
2190         struct page *page;
2191
2192         /* Find a page of the appropriate size in the preferred list */
2193         for (current_order = order; current_order < MAX_ORDER; ++current_order) {
2194                 area = &(zone->free_area[current_order]);
2195                 page = get_page_from_free_area(area, migratetype);
2196                 if (!page)
2197                         continue;
2198                 del_page_from_free_area(page, area);
2199                 expand(zone, page, order, current_order, area, migratetype);
2200                 set_pcppage_migratetype(page, migratetype);
2201                 return page;
2202         }
2203
2204         return NULL;
2205 }
2206
2207
2208 /*
2209  * This array describes the order lists are fallen back to when
2210  * the free lists for the desirable migrate type are depleted
2211  */
2212 static int fallbacks[MIGRATE_TYPES][4] = {
2213         [MIGRATE_UNMOVABLE]   = { MIGRATE_RECLAIMABLE, MIGRATE_MOVABLE,   MIGRATE_TYPES },
2214         [MIGRATE_MOVABLE]     = { MIGRATE_RECLAIMABLE, MIGRATE_UNMOVABLE, MIGRATE_TYPES },
2215         [MIGRATE_RECLAIMABLE] = { MIGRATE_UNMOVABLE,   MIGRATE_MOVABLE,   MIGRATE_TYPES },
2216 #ifdef CONFIG_CMA
2217         [MIGRATE_CMA]         = { MIGRATE_TYPES }, /* Never used */
2218 #endif
2219 #ifdef CONFIG_MEMORY_ISOLATION
2220         [MIGRATE_ISOLATE]     = { MIGRATE_TYPES }, /* Never used */
2221 #endif
2222 };
2223
2224 #ifdef CONFIG_CMA
2225 static __always_inline struct page *__rmqueue_cma_fallback(struct zone *zone,
2226                                         unsigned int order)
2227 {
2228         return __rmqueue_smallest(zone, order, MIGRATE_CMA);
2229 }
2230 #else
2231 static inline struct page *__rmqueue_cma_fallback(struct zone *zone,
2232                                         unsigned int order) { return NULL; }
2233 #endif
2234
2235 /*
2236  * Move the free pages in a range to the free lists of the requested type.
2237  * Note that start_page and end_pages are not aligned on a pageblock
2238  * boundary. If alignment is required, use move_freepages_block()
2239  */
2240 static int move_freepages(struct zone *zone,
2241                           struct page *start_page, struct page *end_page,
2242                           int migratetype, int *num_movable)
2243 {
2244         struct page *page;
2245         unsigned int order;
2246         int pages_moved = 0;
2247
2248         for (page = start_page; page <= end_page;) {
2249                 if (!pfn_valid_within(page_to_pfn(page))) {
2250                         page++;
2251                         continue;
2252                 }
2253
2254                 if (!PageBuddy(page)) {
2255                         /*
2256                          * We assume that pages that could be isolated for
2257                          * migration are movable. But we don't actually try
2258                          * isolating, as that would be expensive.
2259                          */
2260                         if (num_movable &&
2261                                         (PageLRU(page) || __PageMovable(page)))
2262                                 (*num_movable)++;
2263
2264                         page++;
2265                         continue;
2266                 }
2267
2268                 /* Make sure we are not inadvertently changing nodes */
2269                 VM_BUG_ON_PAGE(page_to_nid(page) != zone_to_nid(zone), page);
2270                 VM_BUG_ON_PAGE(page_zone(page) != zone, page);
2271
2272                 order = page_order(page);
2273                 move_to_free_area(page, &zone->free_area[order], migratetype);
2274                 page += 1 << order;
2275                 pages_moved += 1 << order;
2276         }
2277
2278         return pages_moved;
2279 }
2280
2281 int move_freepages_block(struct zone *zone, struct page *page,
2282                                 int migratetype, int *num_movable)
2283 {
2284         unsigned long start_pfn, end_pfn;
2285         struct page *start_page, *end_page;
2286
2287         if (num_movable)
2288                 *num_movable = 0;
2289
2290         start_pfn = page_to_pfn(page);
2291         start_pfn = start_pfn & ~(pageblock_nr_pages-1);
2292         start_page = pfn_to_page(start_pfn);
2293         end_page = start_page + pageblock_nr_pages - 1;
2294         end_pfn = start_pfn + pageblock_nr_pages - 1;
2295
2296         /* Do not cross zone boundaries */
2297         if (!zone_spans_pfn(zone, start_pfn))
2298                 start_page = page;
2299         if (!zone_spans_pfn(zone, end_pfn))
2300                 return 0;
2301
2302         return move_freepages(zone, start_page, end_page, migratetype,
2303                                                                 num_movable);
2304 }
2305
2306 static void change_pageblock_range(struct page *pageblock_page,
2307                                         int start_order, int migratetype)
2308 {
2309         int nr_pageblocks = 1 << (start_order - pageblock_order);
2310
2311         while (nr_pageblocks--) {
2312                 set_pageblock_migratetype(pageblock_page, migratetype);
2313                 pageblock_page += pageblock_nr_pages;
2314         }
2315 }
2316
2317 /*
2318  * When we are falling back to another migratetype during allocation, try to
2319  * steal extra free pages from the same pageblocks to satisfy further
2320  * allocations, instead of polluting multiple pageblocks.
2321  *
2322  * If we are stealing a relatively large buddy page, it is likely there will
2323  * be more free pages in the pageblock, so try to steal them all. For
2324  * reclaimable and unmovable allocations, we steal regardless of page size,
2325  * as fragmentation caused by those allocations polluting movable pageblocks
2326  * is worse than movable allocations stealing from unmovable and reclaimable
2327  * pageblocks.
2328  */
2329 static bool can_steal_fallback(unsigned int order, int start_mt)
2330 {
2331         /*
2332          * Leaving this order check is intended, although there is
2333          * relaxed order check in next check. The reason is that
2334          * we can actually steal whole pageblock if this condition met,
2335          * but, below check doesn't guarantee it and that is just heuristic
2336          * so could be changed anytime.
2337          */
2338         if (order >= pageblock_order)
2339                 return true;
2340
2341         if (order >= pageblock_order / 2 ||
2342                 start_mt == MIGRATE_RECLAIMABLE ||
2343                 start_mt == MIGRATE_UNMOVABLE ||
2344                 page_group_by_mobility_disabled)
2345                 return true;
2346
2347         return false;
2348 }
2349
2350 static inline void boost_watermark(struct zone *zone)
2351 {
2352         unsigned long max_boost;
2353
2354         if (!watermark_boost_factor)
2355                 return;
2356
2357         max_boost = mult_frac(zone->_watermark[WMARK_HIGH],
2358                         watermark_boost_factor, 10000);
2359
2360         /*
2361          * high watermark may be uninitialised if fragmentation occurs
2362          * very early in boot so do not boost. We do not fall
2363          * through and boost by pageblock_nr_pages as failing
2364          * allocations that early means that reclaim is not going
2365          * to help and it may even be impossible to reclaim the
2366          * boosted watermark resulting in a hang.
2367          */
2368         if (!max_boost)
2369                 return;
2370
2371         max_boost = max(pageblock_nr_pages, max_boost);
2372
2373         zone->watermark_boost = min(zone->watermark_boost + pageblock_nr_pages,
2374                 max_boost);
2375 }
2376
2377 /*
2378  * This function implements actual steal behaviour. If order is large enough,
2379  * we can steal whole pageblock. If not, we first move freepages in this
2380  * pageblock to our migratetype and determine how many already-allocated pages
2381  * are there in the pageblock with a compatible migratetype. If at least half
2382  * of pages are free or compatible, we can change migratetype of the pageblock
2383  * itself, so pages freed in the future will be put on the correct free list.
2384  */
2385 static void steal_suitable_fallback(struct zone *zone, struct page *page,
2386                 unsigned int alloc_flags, int start_type, bool whole_block)
2387 {
2388         unsigned int current_order = page_order(page);
2389         struct free_area *area;
2390         int free_pages, movable_pages, alike_pages;
2391         int old_block_type;
2392
2393         old_block_type = get_pageblock_migratetype(page);
2394
2395         /*
2396          * This can happen due to races and we want to prevent broken
2397          * highatomic accounting.
2398          */
2399         if (is_migrate_highatomic(old_block_type))
2400                 goto single_page;
2401
2402         /* Take ownership for orders >= pageblock_order */
2403         if (current_order >= pageblock_order) {
2404                 change_pageblock_range(page, current_order, start_type);
2405                 goto single_page;
2406         }
2407
2408         /*
2409          * Boost watermarks to increase reclaim pressure to reduce the
2410          * likelihood of future fallbacks. Wake kswapd now as the node
2411          * may be balanced overall and kswapd will not wake naturally.
2412          */
2413         boost_watermark(zone);
2414         if (alloc_flags & ALLOC_KSWAPD)
2415                 set_bit(ZONE_BOOSTED_WATERMARK, &zone->flags);
2416
2417         /* We are not allowed to try stealing from the whole block */
2418         if (!whole_block)
2419                 goto single_page;
2420
2421         free_pages = move_freepages_block(zone, page, start_type,
2422                                                 &movable_pages);
2423         /*
2424          * Determine how many pages are compatible with our allocation.
2425          * For movable allocation, it's the number of movable pages which
2426          * we just obtained. For other types it's a bit more tricky.
2427          */
2428         if (start_type == MIGRATE_MOVABLE) {
2429                 alike_pages = movable_pages;
2430         } else {
2431                 /*
2432                  * If we are falling back a RECLAIMABLE or UNMOVABLE allocation
2433                  * to MOVABLE pageblock, consider all non-movable pages as
2434                  * compatible. If it's UNMOVABLE falling back to RECLAIMABLE or
2435                  * vice versa, be conservative since we can't distinguish the
2436                  * exact migratetype of non-movable pages.
2437                  */
2438                 if (old_block_type == MIGRATE_MOVABLE)
2439                         alike_pages = pageblock_nr_pages
2440                                                 - (free_pages + movable_pages);
2441                 else
2442                         alike_pages = 0;
2443         }
2444
2445         /* moving whole block can fail due to zone boundary conditions */
2446         if (!free_pages)
2447                 goto single_page;
2448
2449         /*
2450          * If a sufficient number of pages in the block are either free or of
2451          * comparable migratability as our allocation, claim the whole block.
2452          */
2453         if (free_pages + alike_pages >= (1 << (pageblock_order-1)) ||
2454                         page_group_by_mobility_disabled)
2455                 set_pageblock_migratetype(page, start_type);
2456
2457         return;
2458
2459 single_page:
2460         area = &zone->free_area[current_order];
2461         move_to_free_area(page, area, start_type);
2462 }
2463
2464 /*
2465  * Check whether there is a suitable fallback freepage with requested order.
2466  * If only_stealable is true, this function returns fallback_mt only if
2467  * we can steal other freepages all together. This would help to reduce
2468  * fragmentation due to mixed migratetype pages in one pageblock.
2469  */
2470 int find_suitable_fallback(struct free_area *area, unsigned int order,
2471                         int migratetype, bool only_stealable, bool *can_steal)
2472 {
2473         int i;
2474         int fallback_mt;
2475
2476         if (area->nr_free == 0)
2477                 return -1;
2478
2479         *can_steal = false;
2480         for (i = 0;; i++) {
2481                 fallback_mt = fallbacks[migratetype][i];
2482                 if (fallback_mt == MIGRATE_TYPES)
2483                         break;
2484
2485                 if (free_area_empty(area, fallback_mt))
2486                         continue;
2487
2488                 if (can_steal_fallback(order, migratetype))
2489                         *can_steal = true;
2490
2491                 if (!only_stealable)
2492                         return fallback_mt;
2493
2494                 if (*can_steal)
2495                         return fallback_mt;
2496         }
2497
2498         return -1;
2499 }
2500
2501 /*
2502  * Reserve a pageblock for exclusive use of high-order atomic allocations if
2503  * there are no empty page blocks that contain a page with a suitable order
2504  */
2505 static void reserve_highatomic_pageblock(struct page *page, struct zone *zone,
2506                                 unsigned int alloc_order)
2507 {
2508         int mt;
2509         unsigned long max_managed, flags;
2510
2511         /*
2512          * Limit the number reserved to 1 pageblock or roughly 1% of a zone.
2513          * Check is race-prone but harmless.
2514          */
2515         max_managed = (zone_managed_pages(zone) / 100) + pageblock_nr_pages;
2516         if (zone->nr_reserved_highatomic >= max_managed)
2517                 return;
2518
2519         spin_lock_irqsave(&zone->lock, flags);
2520
2521         /* Recheck the nr_reserved_highatomic limit under the lock */
2522         if (zone->nr_reserved_highatomic >= max_managed)
2523                 goto out_unlock;
2524
2525         /* Yoink! */
2526         mt = get_pageblock_migratetype(page);
2527         if (!is_migrate_highatomic(mt) && !is_migrate_isolate(mt)
2528             && !is_migrate_cma(mt)) {
2529                 zone->nr_reserved_highatomic += pageblock_nr_pages;
2530                 set_pageblock_migratetype(page, MIGRATE_HIGHATOMIC);
2531                 move_freepages_block(zone, page, MIGRATE_HIGHATOMIC, NULL);
2532         }
2533
2534 out_unlock:
2535         spin_unlock_irqrestore(&zone->lock, flags);
2536 }
2537
2538 /*
2539  * Used when an allocation is about to fail under memory pressure. This
2540  * potentially hurts the reliability of high-order allocations when under
2541  * intense memory pressure but failed atomic allocations should be easier
2542  * to recover from than an OOM.
2543  *
2544  * If @force is true, try to unreserve a pageblock even though highatomic
2545  * pageblock is exhausted.
2546  */
2547 static bool unreserve_highatomic_pageblock(const struct alloc_context *ac,
2548                                                 bool force)
2549 {
2550         struct zonelist *zonelist = ac->zonelist;
2551         unsigned long flags;
2552         struct zoneref *z;
2553         struct zone *zone;
2554         struct page *page;
2555         int order;
2556         bool ret;
2557
2558         for_each_zone_zonelist_nodemask(zone, z, zonelist, ac->high_zoneidx,
2559                                                                 ac->nodemask) {
2560                 /*
2561                  * Preserve at least one pageblock unless memory pressure
2562                  * is really high.
2563                  */
2564                 if (!force && zone->nr_reserved_highatomic <=
2565                                         pageblock_nr_pages)
2566                         continue;
2567
2568                 spin_lock_irqsave(&zone->lock, flags);
2569                 for (order = 0; order < MAX_ORDER; order++) {
2570                         struct free_area *area = &(zone->free_area[order]);
2571
2572                         page = get_page_from_free_area(area, MIGRATE_HIGHATOMIC);
2573                         if (!page)
2574                                 continue;
2575
2576                         /*
2577                          * In page freeing path, migratetype change is racy so
2578                          * we can counter several free pages in a pageblock
2579                          * in this loop althoug we changed the pageblock type
2580                          * from highatomic to ac->migratetype. So we should
2581                          * adjust the count once.
2582                          */
2583                         if (is_migrate_highatomic_page(page)) {
2584                                 /*
2585                                  * It should never happen but changes to
2586                                  * locking could inadvertently allow a per-cpu
2587                                  * drain to add pages to MIGRATE_HIGHATOMIC
2588                                  * while unreserving so be safe and watch for
2589                                  * underflows.
2590                                  */
2591                                 zone->nr_reserved_highatomic -= min(
2592                                                 pageblock_nr_pages,
2593                                                 zone->nr_reserved_highatomic);
2594                         }
2595
2596                         /*
2597                          * Convert to ac->migratetype and avoid the normal
2598                          * pageblock stealing heuristics. Minimally, the caller
2599                          * is doing the work and needs the pages. More
2600                          * importantly, if the block was always converted to
2601                          * MIGRATE_UNMOVABLE or another type then the number
2602                          * of pageblocks that cannot be completely freed
2603                          * may increase.
2604                          */
2605                         set_pageblock_migratetype(page, ac->migratetype);
2606                         ret = move_freepages_block(zone, page, ac->migratetype,
2607                                                                         NULL);
2608                         if (ret) {
2609                                 spin_unlock_irqrestore(&zone->lock, flags);
2610                                 return ret;
2611                         }
2612                 }
2613                 spin_unlock_irqrestore(&zone->lock, flags);
2614         }
2615
2616         return false;
2617 }
2618
2619 /*
2620  * Try finding a free buddy page on the fallback list and put it on the free
2621  * list of requested migratetype, possibly along with other pages from the same
2622  * block, depending on fragmentation avoidance heuristics. Returns true if
2623  * fallback was found so that __rmqueue_smallest() can grab it.
2624  *
2625  * The use of signed ints for order and current_order is a deliberate
2626  * deviation from the rest of this file, to make the for loop
2627  * condition simpler.
2628  */
2629 static __always_inline bool
2630 __rmqueue_fallback(struct zone *zone, int order, int start_migratetype,
2631                                                 unsigned int alloc_flags)
2632 {
2633         struct free_area *area;
2634         int current_order;
2635         int min_order = order;
2636         struct page *page;
2637         int fallback_mt;
2638         bool can_steal;
2639
2640         /*
2641          * Do not steal pages from freelists belonging to other pageblocks
2642          * i.e. orders < pageblock_order. If there are no local zones free,
2643          * the zonelists will be reiterated without ALLOC_NOFRAGMENT.
2644          */
2645         if (alloc_flags & ALLOC_NOFRAGMENT)
2646                 min_order = pageblock_order;
2647
2648         /*
2649          * Find the largest available free page in the other list. This roughly
2650          * approximates finding the pageblock with the most free pages, which
2651          * would be too costly to do exactly.
2652          */
2653         for (current_order = MAX_ORDER - 1; current_order >= min_order;
2654                                 --current_order) {
2655                 area = &(zone->free_area[current_order]);
2656                 fallback_mt = find_suitable_fallback(area, current_order,
2657                                 start_migratetype, false, &can_steal);
2658                 if (fallback_mt == -1)
2659                         continue;
2660
2661                 /*
2662                  * We cannot steal all free pages from the pageblock and the
2663                  * requested migratetype is movable. In that case it's better to
2664                  * steal and split the smallest available page instead of the
2665                  * largest available page, because even if the next movable
2666                  * allocation falls back into a different pageblock than this
2667                  * one, it won't cause permanent fragmentation.
2668                  */
2669                 if (!can_steal && start_migratetype == MIGRATE_MOVABLE
2670                                         && current_order > order)
2671                         goto find_smallest;
2672
2673                 goto do_steal;
2674         }
2675
2676         return false;
2677
2678 find_smallest:
2679         for (current_order = order; current_order < MAX_ORDER;
2680                                                         current_order++) {
2681                 area = &(zone->free_area[current_order]);
2682                 fallback_mt = find_suitable_fallback(area, current_order,
2683                                 start_migratetype, false, &can_steal);
2684                 if (fallback_mt != -1)
2685                         break;
2686         }
2687
2688         /*
2689          * This should not happen - we already found a suitable fallback
2690          * when looking for the largest page.
2691          */
2692         VM_BUG_ON(current_order == MAX_ORDER);
2693
2694 do_steal:
2695         page = get_page_from_free_area(area, fallback_mt);
2696
2697         steal_suitable_fallback(zone, page, alloc_flags, start_migratetype,
2698                                                                 can_steal);
2699
2700         trace_mm_page_alloc_extfrag(page, order, current_order,
2701                 start_migratetype, fallback_mt);
2702
2703         return true;
2704
2705 }
2706
2707 /*
2708  * Do the hard work of removing an element from the buddy allocator.
2709  * Call me with the zone->lock already held.
2710  */
2711 static __always_inline struct page *
2712 __rmqueue(struct zone *zone, unsigned int order, int migratetype,
2713                                                 unsigned int alloc_flags)
2714 {
2715         struct page *page;
2716
2717 retry:
2718         page = __rmqueue_smallest(zone, order, migratetype);
2719         if (unlikely(!page)) {
2720                 if (migratetype == MIGRATE_MOVABLE)
2721                         page = __rmqueue_cma_fallback(zone, order);
2722
2723                 if (!page && __rmqueue_fallback(zone, order, migratetype,
2724                                                                 alloc_flags))
2725                         goto retry;
2726         }
2727
2728         trace_mm_page_alloc_zone_locked(page, order, migratetype);
2729         return page;
2730 }
2731
2732 /*
2733  * Obtain a specified number of elements from the buddy allocator, all under
2734  * a single hold of the lock, for efficiency.  Add them to the supplied list.
2735  * Returns the number of new pages which were placed at *list.
2736  */
2737 static int rmqueue_bulk(struct zone *zone, unsigned int order,
2738                         unsigned long count, struct list_head *list,
2739                         int migratetype, unsigned int alloc_flags)
2740 {
2741         int i, alloced = 0;
2742
2743         spin_lock(&zone->lock);
2744         for (i = 0; i < count; ++i) {
2745                 struct page *page = __rmqueue(zone, order, migratetype,
2746                                                                 alloc_flags);
2747                 if (unlikely(page == NULL))
2748                         break;
2749
2750                 if (unlikely(check_pcp_refill(page)))
2751                         continue;
2752
2753                 /*
2754                  * Split buddy pages returned by expand() are received here in
2755                  * physical page order. The page is added to the tail of
2756                  * caller's list. From the callers perspective, the linked list
2757                  * is ordered by page number under some conditions. This is
2758                  * useful for IO devices that can forward direction from the
2759                  * head, thus also in the physical page order. This is useful
2760                  * for IO devices that can merge IO requests if the physical
2761                  * pages are ordered properly.
2762                  */
2763                 list_add_tail(&page->lru, list);
2764                 alloced++;
2765                 if (is_migrate_cma(get_pcppage_migratetype(page)))
2766                         __mod_zone_page_state(zone, NR_FREE_CMA_PAGES,
2767                                               -(1 << order));
2768         }
2769
2770         /*
2771          * i pages were removed from the buddy list even if some leak due
2772          * to check_pcp_refill failing so adjust NR_FREE_PAGES based
2773          * on i. Do not confuse with 'alloced' which is the number of
2774          * pages added to the pcp list.
2775          */
2776         __mod_zone_page_state(zone, NR_FREE_PAGES, -(i << order));
2777         spin_unlock(&zone->lock);
2778         return alloced;
2779 }
2780
2781 #ifdef CONFIG_NUMA
2782 /*
2783  * Called from the vmstat counter updater to drain pagesets of this
2784  * currently executing processor on remote nodes after they have
2785  * expired.
2786  *
2787  * Note that this function must be called with the thread pinned to
2788  * a single processor.
2789  */
2790 void drain_zone_pages(struct zone *zone, struct per_cpu_pages *pcp)
2791 {
2792         unsigned long flags;
2793         int to_drain, batch;
2794
2795         local_irq_save(flags);
2796         batch = READ_ONCE(pcp->batch);
2797         to_drain = min(pcp->count, batch);
2798         if (to_drain > 0)
2799                 free_pcppages_bulk(zone, to_drain, pcp);
2800         local_irq_restore(flags);
2801 }
2802 #endif
2803
2804 /*
2805  * Drain pcplists of the indicated processor and zone.
2806  *
2807  * The processor must either be the current processor and the
2808  * thread pinned to the current processor or a processor that
2809  * is not online.
2810  */
2811 static void drain_pages_zone(unsigned int cpu, struct zone *zone)
2812 {
2813         unsigned long flags;
2814         struct per_cpu_pageset *pset;
2815         struct per_cpu_pages *pcp;
2816
2817         local_irq_save(flags);
2818         pset = per_cpu_ptr(zone->pageset, cpu);
2819
2820         pcp = &pset->pcp;
2821         if (pcp->count)
2822                 free_pcppages_bulk(zone, pcp->count, pcp);
2823         local_irq_restore(flags);
2824 }
2825
2826 /*
2827  * Drain pcplists of all zones on the indicated processor.
2828  *
2829  * The processor must either be the current processor and the
2830  * thread pinned to the current processor or a processor that
2831  * is not online.
2832  */
2833 static void drain_pages(unsigned int cpu)
2834 {
2835         struct zone *zone;
2836
2837         for_each_populated_zone(zone) {
2838                 drain_pages_zone(cpu, zone);
2839         }
2840 }
2841
2842 /*
2843  * Spill all of this CPU's per-cpu pages back into the buddy allocator.
2844  *
2845  * The CPU has to be pinned. When zone parameter is non-NULL, spill just
2846  * the single zone's pages.
2847  */
2848 void drain_local_pages(struct zone *zone)
2849 {
2850         int cpu = smp_processor_id();
2851
2852         if (zone)
2853                 drain_pages_zone(cpu, zone);
2854         else
2855                 drain_pages(cpu);
2856 }
2857
2858 static void drain_local_pages_wq(struct work_struct *work)
2859 {
2860         struct pcpu_drain *drain;
2861
2862         drain = container_of(work, struct pcpu_drain, work);
2863
2864         /*
2865          * drain_all_pages doesn't use proper cpu hotplug protection so
2866          * we can race with cpu offline when the WQ can move this from
2867          * a cpu pinned worker to an unbound one. We can operate on a different
2868          * cpu which is allright but we also have to make sure to not move to
2869          * a different one.
2870          */
2871         preempt_disable();
2872         drain_local_pages(drain->zone);
2873         preempt_enable();
2874 }
2875
2876 /*
2877  * Spill all the per-cpu pages from all CPUs back into the buddy allocator.
2878  *
2879  * When zone parameter is non-NULL, spill just the single zone's pages.
2880  *
2881  * Note that this can be extremely slow as the draining happens in a workqueue.
2882  */
2883 void drain_all_pages(struct zone *zone)
2884 {
2885         int cpu;
2886
2887         /*
2888          * Allocate in the BSS so we wont require allocation in
2889          * direct reclaim path for CONFIG_CPUMASK_OFFSTACK=y
2890          */
2891         static cpumask_t cpus_with_pcps;
2892
2893         /*
2894          * Make sure nobody triggers this path before mm_percpu_wq is fully
2895          * initialized.
2896          */
2897         if (WARN_ON_ONCE(!mm_percpu_wq))
2898                 return;
2899
2900         /*
2901          * Do not drain if one is already in progress unless it's specific to
2902          * a zone. Such callers are primarily CMA and memory hotplug and need
2903          * the drain to be complete when the call returns.
2904          */
2905         if (unlikely(!mutex_trylock(&pcpu_drain_mutex))) {
2906                 if (!zone)
2907                         return;
2908                 mutex_lock(&pcpu_drain_mutex);
2909         }
2910
2911         /*
2912          * We don't care about racing with CPU hotplug event
2913          * as offline notification will cause the notified
2914          * cpu to drain that CPU pcps and on_each_cpu_mask
2915          * disables preemption as part of its processing
2916          */
2917         for_each_online_cpu(cpu) {
2918                 struct per_cpu_pageset *pcp;
2919                 struct zone *z;
2920                 bool has_pcps = false;
2921
2922                 if (zone) {
2923                         pcp = per_cpu_ptr(zone->pageset, cpu);
2924                         if (pcp->pcp.count)
2925                                 has_pcps = true;
2926                 } else {
2927                         for_each_populated_zone(z) {
2928                                 pcp = per_cpu_ptr(z->pageset, cpu);
2929                                 if (pcp->pcp.count) {
2930                                         has_pcps = true;
2931                                         break;
2932                                 }
2933                         }
2934                 }
2935
2936                 if (has_pcps)
2937                         cpumask_set_cpu(cpu, &cpus_with_pcps);
2938                 else
2939                         cpumask_clear_cpu(cpu, &cpus_with_pcps);
2940         }
2941
2942         for_each_cpu(cpu, &cpus_with_pcps) {
2943                 struct pcpu_drain *drain = per_cpu_ptr(&pcpu_drain, cpu);
2944
2945                 drain->zone = zone;
2946                 INIT_WORK(&drain->work, drain_local_pages_wq);
2947                 queue_work_on(cpu, mm_percpu_wq, &drain->work);
2948         }
2949         for_each_cpu(cpu, &cpus_with_pcps)
2950                 flush_work(&per_cpu_ptr(&pcpu_drain, cpu)->work);
2951
2952         mutex_unlock(&pcpu_drain_mutex);
2953 }
2954
2955 #ifdef CONFIG_HIBERNATION
2956
2957 /*
2958  * Touch the watchdog for every WD_PAGE_COUNT pages.
2959  */
2960 #define WD_PAGE_COUNT   (128*1024)
2961
2962 void mark_free_pages(struct zone *zone)
2963 {
2964         unsigned long pfn, max_zone_pfn, page_count = WD_PAGE_COUNT;
2965         unsigned long flags;
2966         unsigned int order, t;
2967         struct page *page;
2968
2969         if (zone_is_empty(zone))
2970                 return;
2971
2972         spin_lock_irqsave(&zone->lock, flags);
2973
2974         max_zone_pfn = zone_end_pfn(zone);
2975         for (pfn = zone->zone_start_pfn; pfn < max_zone_pfn; pfn++)
2976                 if (pfn_valid(pfn)) {
2977                         page = pfn_to_page(pfn);
2978
2979                         if (!--page_count) {
2980                                 touch_nmi_watchdog();
2981                                 page_count = WD_PAGE_COUNT;
2982                         }
2983
2984                         if (page_zone(page) != zone)
2985                                 continue;
2986
2987                         if (!swsusp_page_is_forbidden(page))
2988                                 swsusp_unset_page_free(page);
2989                 }
2990
2991         for_each_migratetype_order(order, t) {
2992                 list_for_each_entry(page,
2993                                 &zone->free_area[order].free_list[t], lru) {
2994                         unsigned long i;
2995
2996                         pfn = page_to_pfn(page);
2997                         for (i = 0; i < (1UL << order); i++) {
2998                                 if (!--page_count) {
2999                                         touch_nmi_watchdog();
3000                                         page_count = WD_PAGE_COUNT;
3001                                 }
3002                                 swsusp_set_page_free(pfn_to_page(pfn + i));
3003                         }
3004                 }
3005         }
3006         spin_unlock_irqrestore(&zone->lock, flags);
3007 }
3008 #endif /* CONFIG_PM */
3009
3010 static bool free_unref_page_prepare(struct page *page, unsigned long pfn)
3011 {
3012         int migratetype;
3013
3014         if (!free_pcp_prepare(page))
3015                 return false;
3016
3017         migratetype = get_pfnblock_migratetype(page, pfn);
3018         set_pcppage_migratetype(page, migratetype);
3019         return true;
3020 }
3021
3022 static void free_unref_page_commit(struct page *page, unsigned long pfn)
3023 {
3024         struct zone *zone = page_zone(page);
3025         struct per_cpu_pages *pcp;
3026         int migratetype;
3027
3028         migratetype = get_pcppage_migratetype(page);
3029         __count_vm_event(PGFREE);
3030
3031         /*
3032          * We only track unmovable, reclaimable and movable on pcp lists.
3033          * Free ISOLATE pages back to the allocator because they are being
3034          * offlined but treat HIGHATOMIC as movable pages so we can get those
3035          * areas back if necessary. Otherwise, we may have to free
3036          * excessively into the page allocator
3037          */
3038         if (migratetype >= MIGRATE_PCPTYPES) {
3039                 if (unlikely(is_migrate_isolate(migratetype))) {
3040                         free_one_page(zone, page, pfn, 0, migratetype);
3041                         return;
3042                 }
3043                 migratetype = MIGRATE_MOVABLE;
3044         }
3045
3046         pcp = &this_cpu_ptr(zone->pageset)->pcp;
3047         list_add(&page->lru, &pcp->lists[migratetype]);
3048         pcp->count++;
3049         if (pcp->count >= pcp->high) {
3050                 unsigned long batch = READ_ONCE(pcp->batch);
3051                 free_pcppages_bulk(zone, batch, pcp);
3052         }
3053 }
3054
3055 /*
3056  * Free a 0-order page
3057  */
3058 void free_unref_page(struct page *page)
3059 {
3060         unsigned long flags;
3061         unsigned long pfn = page_to_pfn(page);
3062
3063         if (!free_unref_page_prepare(page, pfn))
3064                 return;
3065
3066         local_irq_save(flags);
3067         free_unref_page_commit(page, pfn);
3068         local_irq_restore(flags);
3069 }
3070
3071 /*
3072  * Free a list of 0-order pages
3073  */
3074 void free_unref_page_list(struct list_head *list)
3075 {
3076         struct page *page, *next;
3077         unsigned long flags, pfn;
3078         int batch_count = 0;
3079
3080         /* Prepare pages for freeing */
3081         list_for_each_entry_safe(page, next, list, lru) {
3082                 pfn = page_to_pfn(page);
3083                 if (!free_unref_page_prepare(page, pfn))
3084                         list_del(&page->lru);
3085                 set_page_private(page, pfn);
3086         }
3087
3088         local_irq_save(flags);
3089         list_for_each_entry_safe(page, next, list, lru) {
3090                 unsigned long pfn = page_private(page);
3091
3092                 set_page_private(page, 0);
3093                 trace_mm_page_free_batched(page);
3094                 free_unref_page_commit(page, pfn);
3095
3096                 /*
3097                  * Guard against excessive IRQ disabled times when we get
3098                  * a large list of pages to free.
3099                  */
3100                 if (++batch_count == SWAP_CLUSTER_MAX) {
3101                         local_irq_restore(flags);
3102                         batch_count = 0;
3103                         local_irq_save(flags);
3104                 }
3105         }
3106         local_irq_restore(flags);
3107 }
3108
3109 /*
3110  * split_page takes a non-compound higher-order page, and splits it into
3111  * n (1<<order) sub-pages: page[0..n]
3112  * Each sub-page must be freed individually.
3113  *
3114  * Note: this is probably too low level an operation for use in drivers.
3115  * Please consult with lkml before using this in your driver.
3116  */
3117 void split_page(struct page *page, unsigned int order)
3118 {
3119         int i;
3120
3121         VM_BUG_ON_PAGE(PageCompound(page), page);
3122         VM_BUG_ON_PAGE(!page_count(page), page);
3123
3124         for (i = 1; i < (1 << order); i++)
3125                 set_page_refcounted(page + i);
3126         split_page_owner(page, order);
3127 }
3128 EXPORT_SYMBOL_GPL(split_page);
3129
3130 int __isolate_free_page(struct page *page, unsigned int order)
3131 {
3132         struct free_area *area = &page_zone(page)->free_area[order];
3133         unsigned long watermark;
3134         struct zone *zone;
3135         int mt;
3136
3137         BUG_ON(!PageBuddy(page));
3138
3139         zone = page_zone(page);
3140         mt = get_pageblock_migratetype(page);
3141
3142         if (!is_migrate_isolate(mt)) {
3143                 /*
3144                  * Obey watermarks as if the page was being allocated. We can
3145                  * emulate a high-order watermark check with a raised order-0
3146                  * watermark, because we already know our high-order page
3147                  * exists.
3148                  */
3149                 watermark = zone->_watermark[WMARK_MIN] + (1UL << order);
3150                 if (!zone_watermark_ok(zone, 0, watermark, 0, ALLOC_CMA))
3151                         return 0;
3152
3153                 __mod_zone_freepage_state(zone, -(1UL << order), mt);
3154         }
3155
3156         /* Remove page from free list */
3157
3158         del_page_from_free_area(page, area);
3159
3160         /*
3161          * Set the pageblock if the isolated page is at least half of a
3162          * pageblock
3163          */
3164         if (order >= pageblock_order - 1) {
3165                 struct page *endpage = page + (1 << order) - 1;
3166                 for (; page < endpage; page += pageblock_nr_pages) {
3167                         int mt = get_pageblock_migratetype(page);
3168                         if (!is_migrate_isolate(mt) && !is_migrate_cma(mt)
3169                             && !is_migrate_highatomic(mt))
3170                                 set_pageblock_migratetype(page,
3171                                                           MIGRATE_MOVABLE);
3172                 }
3173         }
3174
3175
3176         return 1UL << order;
3177 }
3178
3179 /*
3180  * Update NUMA hit/miss statistics
3181  *
3182  * Must be called with interrupts disabled.
3183  */
3184 static inline void zone_statistics(struct zone *preferred_zone, struct zone *z)
3185 {
3186 #ifdef CONFIG_NUMA
3187         enum numa_stat_item local_stat = NUMA_LOCAL;
3188
3189         /* skip numa counters update if numa stats is disabled */
3190         if (!static_branch_likely(&vm_numa_stat_key))
3191                 return;
3192
3193         if (zone_to_nid(z) != numa_node_id())
3194                 local_stat = NUMA_OTHER;
3195
3196         if (zone_to_nid(z) == zone_to_nid(preferred_zone))
3197                 __inc_numa_state(z, NUMA_HIT);
3198         else {
3199                 __inc_numa_state(z, NUMA_MISS);
3200                 __inc_numa_state(preferred_zone, NUMA_FOREIGN);
3201         }
3202         __inc_numa_state(z, local_stat);
3203 #endif
3204 }
3205
3206 /* Remove page from the per-cpu list, caller must protect the list */
3207 static struct page *__rmqueue_pcplist(struct zone *zone, int migratetype,
3208                         unsigned int alloc_flags,
3209                         struct per_cpu_pages *pcp,
3210                         struct list_head *list)
3211 {
3212         struct page *page;
3213
3214         do {
3215                 if (list_empty(list)) {
3216                         pcp->count += rmqueue_bulk(zone, 0,
3217                                         pcp->batch, list,
3218                                         migratetype, alloc_flags);
3219                         if (unlikely(list_empty(list)))
3220                                 return NULL;
3221                 }
3222
3223                 page = list_first_entry(list, struct page, lru);
3224                 list_del(&page->lru);
3225                 pcp->count--;
3226         } while (check_new_pcp(page));
3227
3228         return page;
3229 }
3230
3231 /* Lock and remove page from the per-cpu list */
3232 static struct page *rmqueue_pcplist(struct zone *preferred_zone,
3233                         struct zone *zone, gfp_t gfp_flags,
3234                         int migratetype, unsigned int alloc_flags)
3235 {
3236         struct per_cpu_pages *pcp;
3237         struct list_head *list;
3238         struct page *page;
3239         unsigned long flags;
3240
3241         local_irq_save(flags);
3242         pcp = &this_cpu_ptr(zone->pageset)->pcp;
3243         list = &pcp->lists[migratetype];
3244         page = __rmqueue_pcplist(zone,  migratetype, alloc_flags, pcp, list);
3245         if (page) {
3246                 __count_zid_vm_events(PGALLOC, page_zonenum(page), 1);
3247                 zone_statistics(preferred_zone, zone);
3248         }
3249         local_irq_restore(flags);
3250         return page;
3251 }
3252
3253 /*
3254  * Allocate a page from the given zone. Use pcplists for order-0 allocations.
3255  */
3256 static inline
3257 struct page *rmqueue(struct zone *preferred_zone,
3258                         struct zone *zone, unsigned int order,
3259                         gfp_t gfp_flags, unsigned int alloc_flags,
3260                         int migratetype)
3261 {
3262         unsigned long flags;
3263         struct page *page;
3264
3265         if (likely(order == 0)) {
3266                 page = rmqueue_pcplist(preferred_zone, zone, gfp_flags,
3267                                         migratetype, alloc_flags);
3268                 goto out;
3269         }
3270
3271         /*
3272          * We most definitely don't want callers attempting to
3273          * allocate greater than order-1 page units with __GFP_NOFAIL.
3274          */
3275         WARN_ON_ONCE((gfp_flags & __GFP_NOFAIL) && (order > 1));
3276         spin_lock_irqsave(&zone->lock, flags);
3277
3278         do {
3279                 page = NULL;
3280                 if (alloc_flags & ALLOC_HARDER) {
3281                         page = __rmqueue_smallest(zone, order, MIGRATE_HIGHATOMIC);
3282                         if (page)
3283                                 trace_mm_page_alloc_zone_locked(page, order, migratetype);
3284                 }
3285                 if (!page)
3286                         page = __rmqueue(zone, order, migratetype, alloc_flags);
3287         } while (page && check_new_pages(page, order));
3288         spin_unlock(&zone->lock);
3289         if (!page)
3290                 goto failed;
3291         __mod_zone_freepage_state(zone, -(1 << order),
3292                                   get_pcppage_migratetype(page));
3293
3294         __count_zid_vm_events(PGALLOC, page_zonenum(page), 1 << order);
3295         zone_statistics(preferred_zone, zone);
3296         local_irq_restore(flags);
3297
3298 out:
3299         /* Separate test+clear to avoid unnecessary atomics */
3300         if (test_bit(ZONE_BOOSTED_WATERMARK, &zone->flags)) {
3301                 clear_bit(ZONE_BOOSTED_WATERMARK, &zone->flags);
3302                 wakeup_kswapd(zone, 0, 0, zone_idx(zone));
3303         }
3304
3305         VM_BUG_ON_PAGE(page && bad_range(zone, page), page);
3306         return page;
3307
3308 failed:
3309         local_irq_restore(flags);
3310         return NULL;
3311 }
3312
3313 #ifdef CONFIG_FAIL_PAGE_ALLOC
3314
3315 static struct {
3316         struct fault_attr attr;
3317
3318         bool ignore_gfp_highmem;
3319         bool ignore_gfp_reclaim;
3320         u32 min_order;
3321 } fail_page_alloc = {
3322         .attr = FAULT_ATTR_INITIALIZER,
3323         .ignore_gfp_reclaim = true,
3324         .ignore_gfp_highmem = true,
3325         .min_order = 1,
3326 };
3327
3328 static int __init setup_fail_page_alloc(char *str)
3329 {
3330         return setup_fault_attr(&fail_page_alloc.attr, str);
3331 }
3332 __setup("fail_page_alloc=", setup_fail_page_alloc);
3333
3334 static bool __should_fail_alloc_page(gfp_t gfp_mask, unsigned int order)
3335 {
3336         if (order < fail_page_alloc.min_order)
3337                 return false;
3338         if (gfp_mask & __GFP_NOFAIL)
3339                 return false;
3340         if (fail_page_alloc.ignore_gfp_highmem && (gfp_mask & __GFP_HIGHMEM))
3341                 return false;
3342         if (fail_page_alloc.ignore_gfp_reclaim &&
3343                         (gfp_mask & __GFP_DIRECT_RECLAIM))
3344                 return false;
3345
3346         return should_fail(&fail_page_alloc.attr, 1 << order);
3347 }
3348
3349 #ifdef CONFIG_FAULT_INJECTION_DEBUG_FS
3350
3351 static int __init fail_page_alloc_debugfs(void)
3352 {
3353         umode_t mode = S_IFREG | 0600;
3354         struct dentry *dir;
3355
3356         dir = fault_create_debugfs_attr("fail_page_alloc", NULL,
3357                                         &fail_page_alloc.attr);
3358
3359         debugfs_create_bool("ignore-gfp-wait", mode, dir,
3360                             &fail_page_alloc.ignore_gfp_reclaim);
3361         debugfs_create_bool("ignore-gfp-highmem", mode, dir,
3362                             &fail_page_alloc.ignore_gfp_highmem);
3363         debugfs_create_u32("min-order", mode, dir, &fail_page_alloc.min_order);
3364
3365         return 0;
3366 }
3367
3368 late_initcall(fail_page_alloc_debugfs);
3369
3370 #endif /* CONFIG_FAULT_INJECTION_DEBUG_FS */
3371
3372 #else /* CONFIG_FAIL_PAGE_ALLOC */
3373
3374 static inline bool __should_fail_alloc_page(gfp_t gfp_mask, unsigned int order)
3375 {
3376         return false;
3377 }
3378
3379 #endif /* CONFIG_FAIL_PAGE_ALLOC */
3380
3381 static noinline bool should_fail_alloc_page(gfp_t gfp_mask, unsigned int order)
3382 {
3383         return __should_fail_alloc_page(gfp_mask, order);
3384 }
3385 ALLOW_ERROR_INJECTION(should_fail_alloc_page, TRUE);
3386
3387 /*
3388  * Return true if free base pages are above 'mark'. For high-order checks it
3389  * will return true of the order-0 watermark is reached and there is at least
3390  * one free page of a suitable size. Checking now avoids taking the zone lock
3391  * to check in the allocation paths if no pages are free.
3392  */
3393 bool __zone_watermark_ok(struct zone *z, unsigned int order, unsigned long mark,
3394                          int classzone_idx, unsigned int alloc_flags,
3395                          long free_pages)
3396 {
3397         long min = mark;
3398         int o;
3399         const bool alloc_harder = (alloc_flags & (ALLOC_HARDER|ALLOC_OOM));
3400
3401         /* free_pages may go negative - that's OK */
3402         free_pages -= (1 << order) - 1;
3403
3404         if (alloc_flags & ALLOC_HIGH)
3405                 min -= min / 2;
3406
3407         /*
3408          * If the caller does not have rights to ALLOC_HARDER then subtract
3409          * the high-atomic reserves. This will over-estimate the size of the
3410          * atomic reserve but it avoids a search.
3411          */
3412         if (likely(!alloc_harder)) {
3413                 free_pages -= z->nr_reserved_highatomic;
3414         } else {
3415                 /*
3416                  * OOM victims can try even harder than normal ALLOC_HARDER
3417                  * users on the grounds that it's definitely going to be in
3418                  * the exit path shortly and free memory. Any allocation it
3419                  * makes during the free path will be small and short-lived.
3420                  */
3421                 if (alloc_flags & ALLOC_OOM)
3422                         min -= min / 2;
3423                 else
3424                         min -= min / 4;
3425         }
3426
3427
3428 #ifdef CONFIG_CMA
3429         /* If allocation can't use CMA areas don't use free CMA pages */
3430         if (!(alloc_flags & ALLOC_CMA))
3431                 free_pages -= zone_page_state(z, NR_FREE_CMA_PAGES);
3432 #endif
3433
3434         /*
3435          * Check watermarks for an order-0 allocation request. If these
3436          * are not met, then a high-order request also cannot go ahead
3437          * even if a suitable page happened to be free.
3438          */
3439         if (free_pages <= min + z->lowmem_reserve[classzone_idx])
3440                 return false;
3441
3442         /* If this is an order-0 request then the watermark is fine */
3443         if (!order)
3444                 return true;
3445
3446         /* For a high-order request, check at least one suitable page is free */
3447         for (o = order; o < MAX_ORDER; o++) {
3448                 struct free_area *area = &z->free_area[o];
3449                 int mt;
3450
3451                 if (!area->nr_free)
3452                         continue;
3453
3454                 for (mt = 0; mt < MIGRATE_PCPTYPES; mt++) {
3455                         if (!free_area_empty(area, mt))
3456                                 return true;
3457                 }
3458
3459 #ifdef CONFIG_CMA
3460                 if ((alloc_flags & ALLOC_CMA) &&
3461                     !free_area_empty(area, MIGRATE_CMA)) {
3462                         return true;
3463                 }
3464 #endif
3465                 if (alloc_harder &&
3466                         !list_empty(&area->free_list[MIGRATE_HIGHATOMIC]))
3467                         return true;
3468         }
3469         return false;
3470 }
3471
3472 bool zone_watermark_ok(struct zone *z, unsigned int order, unsigned long mark,
3473                       int classzone_idx, unsigned int alloc_flags)
3474 {
3475         return __zone_watermark_ok(z, order, mark, classzone_idx, alloc_flags,
3476                                         zone_page_state(z, NR_FREE_PAGES));
3477 }
3478
3479 static inline bool zone_watermark_fast(struct zone *z, unsigned int order,
3480                 unsigned long mark, int classzone_idx, unsigned int alloc_flags)
3481 {
3482         long free_pages = zone_page_state(z, NR_FREE_PAGES);
3483         long cma_pages = 0;
3484
3485 #ifdef CONFIG_CMA
3486         /* If allocation can't use CMA areas don't use free CMA pages */
3487         if (!(alloc_flags & ALLOC_CMA))
3488                 cma_pages = zone_page_state(z, NR_FREE_CMA_PAGES);
3489 #endif
3490
3491         /*
3492          * Fast check for order-0 only. If this fails then the reserves
3493          * need to be calculated. There is a corner case where the check
3494          * passes but only the high-order atomic reserve are free. If
3495          * the caller is !atomic then it'll uselessly search the free
3496          * list. That corner case is then slower but it is harmless.
3497          */
3498         if (!order && (free_pages - cma_pages) > mark + z->lowmem_reserve[classzone_idx])
3499                 return true;
3500
3501         return __zone_watermark_ok(z, order, mark, classzone_idx, alloc_flags,
3502                                         free_pages);
3503 }
3504
3505 bool zone_watermark_ok_safe(struct zone *z, unsigned int order,
3506                         unsigned long mark, int classzone_idx)
3507 {
3508         long free_pages = zone_page_state(z, NR_FREE_PAGES);
3509
3510         if (z->percpu_drift_mark && free_pages < z->percpu_drift_mark)
3511                 free_pages = zone_page_state_snapshot(z, NR_FREE_PAGES);
3512
3513         return __zone_watermark_ok(z, order, mark, classzone_idx, 0,
3514                                                                 free_pages);
3515 }
3516
3517 #ifdef CONFIG_NUMA
3518 static bool zone_allows_reclaim(struct zone *local_zone, struct zone *zone)
3519 {
3520         return node_distance(zone_to_nid(local_zone), zone_to_nid(zone)) <=
3521                                 node_reclaim_distance;
3522 }
3523 #else   /* CONFIG_NUMA */
3524 static bool zone_allows_reclaim(struct zone *local_zone, struct zone *zone)
3525 {
3526         return true;
3527 }
3528 #endif  /* CONFIG_NUMA */
3529
3530 /*
3531  * The restriction on ZONE_DMA32 as being a suitable zone to use to avoid
3532  * fragmentation is subtle. If the preferred zone was HIGHMEM then
3533  * premature use of a lower zone may cause lowmem pressure problems that
3534  * are worse than fragmentation. If the next zone is ZONE_DMA then it is
3535  * probably too small. It only makes sense to spread allocations to avoid
3536  * fragmentation between the Normal and DMA32 zones.
3537  */
3538 static inline unsigned int
3539 alloc_flags_nofragment(struct zone *zone, gfp_t gfp_mask)
3540 {
3541         unsigned int alloc_flags = 0;
3542
3543         if (gfp_mask & __GFP_KSWAPD_RECLAIM)
3544                 alloc_flags |= ALLOC_KSWAPD;
3545
3546 #ifdef CONFIG_ZONE_DMA32
3547         if (!zone)
3548                 return alloc_flags;
3549
3550         if (zone_idx(zone) != ZONE_NORMAL)
3551                 return alloc_flags;
3552
3553         /*
3554          * If ZONE_DMA32 exists, assume it is the one after ZONE_NORMAL and
3555          * the pointer is within zone->zone_pgdat->node_zones[]. Also assume
3556          * on UMA that if Normal is populated then so is DMA32.
3557          */
3558         BUILD_BUG_ON(ZONE_NORMAL - ZONE_DMA32 != 1);
3559         if (nr_online_nodes > 1 && !populated_zone(--zone))
3560                 return alloc_flags;
3561
3562         alloc_flags |= ALLOC_NOFRAGMENT;
3563 #endif /* CONFIG_ZONE_DMA32 */
3564         return alloc_flags;
3565 }
3566
3567 /*
3568  * get_page_from_freelist goes through the zonelist trying to allocate
3569  * a page.
3570  */
3571 static struct page *
3572 get_page_from_freelist(gfp_t gfp_mask, unsigned int order, int alloc_flags,
3573                                                 const struct alloc_context *ac)
3574 {
3575         struct zoneref *z;
3576         struct zone *zone;
3577         struct pglist_data *last_pgdat_dirty_limit = NULL;
3578         bool no_fallback;
3579
3580 retry:
3581         /*
3582          * Scan zonelist, looking for a zone with enough free.
3583          * See also __cpuset_node_allowed() comment in kernel/cpuset.c.
3584          */
3585         no_fallback = alloc_flags & ALLOC_NOFRAGMENT;
3586         z = ac->preferred_zoneref;
3587         for_next_zone_zonelist_nodemask(zone, z, ac->zonelist, ac->high_zoneidx,
3588                                                                 ac->nodemask) {
3589                 struct page *page;
3590                 unsigned long mark;
3591
3592                 if (cpusets_enabled() &&
3593                         (alloc_flags & ALLOC_CPUSET) &&
3594                         !__cpuset_zone_allowed(zone, gfp_mask))
3595                                 continue;
3596                 /*
3597                  * When allocating a page cache page for writing, we
3598                  * want to get it from a node that is within its dirty
3599                  * limit, such that no single node holds more than its
3600                  * proportional share of globally allowed dirty pages.
3601                  * The dirty limits take into account the node's
3602                  * lowmem reserves and high watermark so that kswapd
3603                  * should be able to balance it without having to
3604                  * write pages from its LRU list.
3605                  *
3606                  * XXX: For now, allow allocations to potentially
3607                  * exceed the per-node dirty limit in the slowpath
3608                  * (spread_dirty_pages unset) before going into reclaim,
3609                  * which is important when on a NUMA setup the allowed
3610                  * nodes are together not big enough to reach the
3611                  * global limit.  The proper fix for these situations
3612                  * will require awareness of nodes in the
3613                  * dirty-throttling and the flusher threads.
3614                  */
3615                 if (ac->spread_dirty_pages) {
3616                         if (last_pgdat_dirty_limit == zone->zone_pgdat)
3617                                 continue;
3618
3619                         if (!node_dirty_ok(zone->zone_pgdat)) {
3620                                 last_pgdat_dirty_limit = zone->zone_pgdat;
3621                                 continue;
3622                         }
3623                 }
3624
3625                 if (no_fallback && nr_online_nodes > 1 &&
3626                     zone != ac->preferred_zoneref->zone) {
3627                         int local_nid;
3628
3629                         /*
3630                          * If moving to a remote node, retry but allow
3631                          * fragmenting fallbacks. Locality is more important
3632                          * than fragmentation avoidance.
3633                          */
3634                         local_nid = zone_to_nid(ac->preferred_zoneref->zone);
3635                         if (zone_to_nid(zone) != local_nid) {
3636                                 alloc_flags &= ~ALLOC_NOFRAGMENT;
3637                                 goto retry;
3638                         }
3639                 }
3640
3641                 mark = wmark_pages(zone, alloc_flags & ALLOC_WMARK_MASK);
3642                 if (!zone_watermark_fast(zone, order, mark,
3643                                        ac_classzone_idx(ac), alloc_flags)) {
3644                         int ret;
3645
3646 #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
3647                         /*
3648                          * Watermark failed for this zone, but see if we can
3649                          * grow this zone if it contains deferred pages.
3650                          */
3651                         if (static_branch_unlikely(&deferred_pages)) {
3652                                 if (_deferred_grow_zone(zone, order))
3653                                         goto try_this_zone;
3654                         }
3655 #endif
3656                         /* Checked here to keep the fast path fast */
3657                         BUILD_BUG_ON(ALLOC_NO_WATERMARKS < NR_WMARK);
3658                         if (alloc_flags & ALLOC_NO_WATERMARKS)
3659                                 goto try_this_zone;
3660
3661                         if (node_reclaim_mode == 0 ||
3662                             !zone_allows_reclaim(ac->preferred_zoneref->zone, zone))
3663                                 continue;
3664
3665                         ret = node_reclaim(zone->zone_pgdat, gfp_mask, order);
3666                         switch (ret) {
3667                         case NODE_RECLAIM_NOSCAN:
3668                                 /* did not scan */
3669                                 continue;
3670                         case NODE_RECLAIM_FULL:
3671                                 /* scanned but unreclaimable */
3672                                 continue;
3673                         default:
3674                                 /* did we reclaim enough */
3675                                 if (zone_watermark_ok(zone, order, mark,
3676                                                 ac_classzone_idx(ac), alloc_flags))
3677                                         goto try_this_zone;
3678
3679                                 continue;
3680                         }
3681                 }
3682
3683 try_this_zone:
3684                 page = rmqueue(ac->preferred_zoneref->zone, zone, order,
3685                                 gfp_mask, alloc_flags, ac->migratetype);
3686                 if (page) {
3687                         prep_new_page(page, order, gfp_mask, alloc_flags);
3688
3689                         /*
3690                          * If this is a high-order atomic allocation then check
3691                          * if the pageblock should be reserved for the future
3692                          */
3693                         if (unlikely(order && (alloc_flags & ALLOC_HARDER)))
3694                                 reserve_highatomic_pageblock(page, zone, order);
3695
3696                         return page;
3697                 } else {
3698 #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
3699                         /* Try again if zone has deferred pages */
3700                         if (static_branch_unlikely(&deferred_pages)) {
3701                                 if (_deferred_grow_zone(zone, order))
3702                                         goto try_this_zone;
3703                         }
3704 #endif
3705                 }
3706         }
3707
3708         /*
3709          * It's possible on a UMA machine to get through all zones that are
3710          * fragmented. If avoiding fragmentation, reset and try again.
3711          */
3712         if (no_fallback) {
3713                 alloc_flags &= ~ALLOC_NOFRAGMENT;
3714                 goto retry;
3715         }
3716
3717         return NULL;
3718 }
3719
3720 static void warn_alloc_show_mem(gfp_t gfp_mask, nodemask_t *nodemask)
3721 {
3722         unsigned int filter = SHOW_MEM_FILTER_NODES;
3723         static DEFINE_RATELIMIT_STATE(show_mem_rs, HZ, 1);
3724
3725         if (!__ratelimit(&show_mem_rs))
3726                 return;
3727
3728         /*
3729          * This documents exceptions given to allocations in certain
3730          * contexts that are allowed to allocate outside current's set
3731          * of allowed nodes.
3732          */
3733         if (!(gfp_mask & __GFP_NOMEMALLOC))
3734                 if (tsk_is_oom_victim(current) ||
3735                     (current->flags & (PF_MEMALLOC | PF_EXITING)))
3736                         filter &= ~SHOW_MEM_FILTER_NODES;
3737         if (in_interrupt() || !(gfp_mask & __GFP_DIRECT_RECLAIM))
3738                 filter &= ~SHOW_MEM_FILTER_NODES;
3739
3740         show_mem(filter, nodemask);
3741 }
3742
3743 void warn_alloc(gfp_t gfp_mask, nodemask_t *nodemask, const char *fmt, ...)
3744 {
3745         struct va_format vaf;
3746         va_list args;
3747         static DEFINE_RATELIMIT_STATE(nopage_rs, DEFAULT_RATELIMIT_INTERVAL,
3748                                       DEFAULT_RATELIMIT_BURST);
3749
3750         if ((gfp_mask & __GFP_NOWARN) || !__ratelimit(&nopage_rs))
3751                 return;
3752
3753         va_start(args, fmt);
3754         vaf.fmt = fmt;
3755         vaf.va = &args;
3756         pr_warn("%s: %pV, mode:%#x(%pGg), nodemask=%*pbl",
3757                         current->comm, &vaf, gfp_mask, &gfp_mask,
3758                         nodemask_pr_args(nodemask));
3759         va_end(args);
3760
3761         cpuset_print_current_mems_allowed();
3762         pr_cont("\n");
3763         dump_stack();
3764         warn_alloc_show_mem(gfp_mask, nodemask);
3765 }
3766
3767 static inline struct page *
3768 __alloc_pages_cpuset_fallback(gfp_t gfp_mask, unsigned int order,
3769                               unsigned int alloc_flags,
3770                               const struct alloc_context *ac)
3771 {
3772         struct page *page;
3773
3774         page = get_page_from_freelist(gfp_mask, order,
3775                         alloc_flags|ALLOC_CPUSET, ac);
3776         /*
3777          * fallback to ignore cpuset restriction if our nodes
3778          * are depleted
3779          */
3780         if (!page)
3781                 page = get_page_from_freelist(gfp_mask, order,
3782                                 alloc_flags, ac);
3783
3784         return page;
3785 }
3786
3787 static inline struct page *
3788 __alloc_pages_may_oom(gfp_t gfp_mask, unsigned int order,
3789         const struct alloc_context *ac, unsigned long *did_some_progress)
3790 {
3791         struct oom_control oc = {
3792                 .zonelist = ac->zonelist,
3793                 .nodemask = ac->nodemask,
3794                 .memcg = NULL,
3795                 .gfp_mask = gfp_mask,
3796                 .order = order,
3797         };
3798         struct page *page;
3799
3800         *did_some_progress = 0;
3801
3802         /*
3803          * Acquire the oom lock.  If that fails, somebody else is
3804          * making progress for us.
3805          */
3806         if (!mutex_trylock(&oom_lock)) {
3807                 *did_some_progress = 1;
3808                 schedule_timeout_uninterruptible(1);
3809                 return NULL;
3810         }
3811
3812         /*
3813          * Go through the zonelist yet one more time, keep very high watermark
3814          * here, this is only to catch a parallel oom killing, we must fail if
3815          * we're still under heavy pressure. But make sure that this reclaim
3816          * attempt shall not depend on __GFP_DIRECT_RECLAIM && !__GFP_NORETRY
3817          * allocation which will never fail due to oom_lock already held.
3818          */
3819         page = get_page_from_freelist((gfp_mask | __GFP_HARDWALL) &
3820                                       ~__GFP_DIRECT_RECLAIM, order,
3821                                       ALLOC_WMARK_HIGH|ALLOC_CPUSET, ac);
3822         if (page)
3823                 goto out;
3824
3825         /* Coredumps can quickly deplete all memory reserves */
3826         if (current->flags & PF_DUMPCORE)
3827                 goto out;
3828         /* The OOM killer will not help higher order allocs */
3829         if (order > PAGE_ALLOC_COSTLY_ORDER)
3830                 goto out;
3831         /*
3832          * We have already exhausted all our reclaim opportunities without any
3833          * success so it is time to admit defeat. We will skip the OOM killer
3834          * because it is very likely that the caller has a more reasonable
3835          * fallback than shooting a random task.
3836          */
3837         if (gfp_mask & __GFP_RETRY_MAYFAIL)
3838                 goto out;
3839         /* The OOM killer does not needlessly kill tasks for lowmem */
3840         if (ac->high_zoneidx < ZONE_NORMAL)
3841                 goto out;
3842         if (pm_suspended_storage())
3843                 goto out;
3844         /*
3845          * XXX: GFP_NOFS allocations should rather fail than rely on
3846          * other request to make a forward progress.
3847          * We are in an unfortunate situation where out_of_memory cannot
3848          * do much for this context but let's try it to at least get
3849          * access to memory reserved if the current task is killed (see
3850          * out_of_memory). Once filesystems are ready to handle allocation
3851          * failures more gracefully we should just bail out here.
3852          */
3853
3854         /* The OOM killer may not free memory on a specific node */
3855         if (gfp_mask & __GFP_THISNODE)
3856                 goto out;
3857
3858         /* Exhausted what can be done so it's blame time */
3859         if (out_of_memory(&oc) || WARN_ON_ONCE(gfp_mask & __GFP_NOFAIL)) {
3860                 *did_some_progress = 1;
3861
3862                 /*
3863                  * Help non-failing allocations by giving them access to memory
3864                  * reserves
3865                  */
3866                 if (gfp_mask & __GFP_NOFAIL)
3867                         page = __alloc_pages_cpuset_fallback(gfp_mask, order,
3868                                         ALLOC_NO_WATERMARKS, ac);
3869         }
3870 out:
3871         mutex_unlock(&oom_lock);
3872         return page;
3873 }
3874
3875 /*
3876  * Maximum number of compaction retries wit a progress before OOM
3877  * killer is consider as the only way to move forward.
3878  */
3879 #define MAX_COMPACT_RETRIES 16
3880
3881 #ifdef CONFIG_COMPACTION
3882 /* Try memory compaction for high-order allocations before reclaim */
3883 static struct page *
3884 __alloc_pages_direct_compact(gfp_t gfp_mask, unsigned int order,
3885                 unsigned int alloc_flags, const struct alloc_context *ac,
3886                 enum compact_priority prio, enum compact_result *compact_result)
3887 {
3888         struct page *page = NULL;
3889         unsigned long pflags;
3890         unsigned int noreclaim_flag;
3891
3892         if (!order)
3893                 return NULL;
3894
3895         psi_memstall_enter(&pflags);
3896         noreclaim_flag = memalloc_noreclaim_save();
3897
3898         *compact_result = try_to_compact_pages(gfp_mask, order, alloc_flags, ac,
3899                                                                 prio, &page);
3900
3901         memalloc_noreclaim_restore(noreclaim_flag);
3902         psi_memstall_leave(&pflags);
3903
3904         /*
3905          * At least in one zone compaction wasn't deferred or skipped, so let's
3906          * count a compaction stall
3907          */
3908         count_vm_event(COMPACTSTALL);
3909
3910         /* Prep a captured page if available */
3911         if (page)
3912                 prep_new_page(page, order, gfp_mask, alloc_flags);
3913
3914         /* Try get a page from the freelist if available */
3915         if (!page)
3916                 page = get_page_from_freelist(gfp_mask, order, alloc_flags, ac);
3917
3918         if (page) {
3919                 struct zone *zone = page_zone(page);
3920
3921                 zone->compact_blockskip_flush = false;
3922                 compaction_defer_reset(zone, order, true);
3923                 count_vm_event(COMPACTSUCCESS);
3924                 return page;
3925         }
3926
3927         /*
3928          * It's bad if compaction run occurs and fails. The most likely reason
3929          * is that pages exist, but not enough to satisfy watermarks.
3930          */
3931         count_vm_event(COMPACTFAIL);
3932
3933         cond_resched();
3934
3935         return NULL;
3936 }
3937
3938 static inline bool
3939 should_compact_retry(struct alloc_context *ac, int order, int alloc_flags,
3940                      enum compact_result compact_result,
3941                      enum compact_priority *compact_priority,
3942                      int *compaction_retries)
3943 {
3944         int max_retries = MAX_COMPACT_RETRIES;
3945         int min_priority;
3946         bool ret = false;
3947         int retries = *compaction_retries;
3948         enum compact_priority priority = *compact_priority;
3949
3950         if (!order)
3951                 return false;
3952
3953         if (compaction_made_progress(compact_result))
3954                 (*compaction_retries)++;
3955
3956         /*
3957          * compaction considers all the zone as desperately out of memory
3958          * so it doesn't really make much sense to retry except when the
3959          * failure could be caused by insufficient priority
3960          */
3961         if (compaction_failed(compact_result))
3962                 goto check_priority;
3963
3964         /*
3965          * compaction was skipped because there are not enough order-0 pages
3966          * to work with, so we retry only if it looks like reclaim can help.
3967          */
3968         if (compaction_needs_reclaim(compact_result)) {
3969                 ret = compaction_zonelist_suitable(ac, order, alloc_flags);
3970                 goto out;
3971         }
3972
3973         /*
3974          * make sure the compaction wasn't deferred or didn't bail out early
3975          * due to locks contention before we declare that we should give up.
3976          * But the next retry should use a higher priority if allowed, so
3977          * we don't just keep bailing out endlessly.
3978          */
3979         if (compaction_withdrawn(compact_result)) {
3980                 goto check_priority;
3981         }
3982
3983         /*
3984          * !costly requests are much more important than __GFP_RETRY_MAYFAIL
3985          * costly ones because they are de facto nofail and invoke OOM
3986          * killer to move on while costly can fail and users are ready
3987          * to cope with that. 1/4 retries is rather arbitrary but we
3988          * would need much more detailed feedback from compaction to
3989          * make a better decision.
3990          */
3991         if (order > PAGE_ALLOC_COSTLY_ORDER)
3992                 max_retries /= 4;
3993         if (*compaction_retries <= max_retries) {
3994                 ret = true;
3995                 goto out;
3996         }
3997
3998         /*
3999          * Make sure there are attempts at the highest priority if we exhausted
4000          * all retries or failed at the lower priorities.
4001          */
4002 check_priority:
4003         min_priority = (order > PAGE_ALLOC_COSTLY_ORDER) ?
4004                         MIN_COMPACT_COSTLY_PRIORITY : MIN_COMPACT_PRIORITY;
4005
4006         if (*compact_priority > min_priority) {
4007                 (*compact_priority)--;
4008                 *compaction_retries = 0;
4009                 ret = true;
4010         }
4011 out:
4012         trace_compact_retry(order, priority, compact_result, retries, max_retries, ret);
4013         return ret;
4014 }
4015 #else
4016 static inline struct page *
4017 __alloc_pages_direct_compact(gfp_t gfp_mask, unsigned int order,
4018                 unsigned int alloc_flags, const struct alloc_context *ac,
4019                 enum compact_priority prio, enum compact_result *compact_result)
4020 {
4021         *compact_result = COMPACT_SKIPPED;
4022         return NULL;
4023 }
4024
4025 static inline bool
4026 should_compact_retry(struct alloc_context *ac, unsigned int order, int alloc_flags,
4027                      enum compact_result compact_result,
4028                      enum compact_priority *compact_priority,
4029                      int *compaction_retries)
4030 {
4031         struct zone *zone;
4032         struct zoneref *z;
4033
4034         if (!order || order > PAGE_ALLOC_COSTLY_ORDER)
4035                 return false;
4036
4037         /*
4038          * There are setups with compaction disabled which would prefer to loop
4039          * inside the allocator rather than hit the oom killer prematurely.
4040          * Let's give them a good hope and keep retrying while the order-0
4041          * watermarks are OK.
4042          */
4043         for_each_zone_zonelist_nodemask(zone, z, ac->zonelist, ac->high_zoneidx,
4044                                         ac->nodemask) {
4045                 if (zone_watermark_ok(zone, 0, min_wmark_pages(zone),
4046                                         ac_classzone_idx(ac), alloc_flags))
4047                         return true;
4048         }
4049         return false;
4050 }
4051 #endif /* CONFIG_COMPACTION */
4052
4053 #ifdef CONFIG_LOCKDEP
4054 static struct lockdep_map __fs_reclaim_map =
4055         STATIC_LOCKDEP_MAP_INIT("fs_reclaim", &__fs_reclaim_map);
4056
4057 static bool __need_fs_reclaim(gfp_t gfp_mask)
4058 {
4059         gfp_mask = current_gfp_context(gfp_mask);
4060
4061         /* no reclaim without waiting on it */
4062         if (!(gfp_mask & __GFP_DIRECT_RECLAIM))
4063                 return false;
4064
4065         /* this guy won't enter reclaim */
4066         if (current->flags & PF_MEMALLOC)
4067                 return false;
4068
4069         /* We're only interested __GFP_FS allocations for now */
4070         if (!(gfp_mask & __GFP_FS))
4071                 return false;
4072
4073         if (gfp_mask & __GFP_NOLOCKDEP)
4074                 return false;
4075
4076         return true;
4077 }
4078
4079 void __fs_reclaim_acquire(void)
4080 {
4081         lock_map_acquire(&__fs_reclaim_map);
4082 }
4083
4084 void __fs_reclaim_release(void)
4085 {
4086         lock_map_release(&__fs_reclaim_map);
4087 }
4088
4089 void fs_reclaim_acquire(gfp_t gfp_mask)
4090 {
4091         if (__need_fs_reclaim(gfp_mask))
4092                 __fs_reclaim_acquire();
4093 }
4094 EXPORT_SYMBOL_GPL(fs_reclaim_acquire);
4095
4096 void fs_reclaim_release(gfp_t gfp_mask)
4097 {
4098         if (__need_fs_reclaim(gfp_mask))
4099                 __fs_reclaim_release();
4100 }
4101 EXPORT_SYMBOL_GPL(fs_reclaim_release);
4102 #endif
4103
4104 /* Perform direct synchronous page reclaim */
4105 static int
4106 __perform_reclaim(gfp_t gfp_mask, unsigned int order,
4107                                         const struct alloc_context *ac)
4108 {
4109         int progress;
4110         unsigned int noreclaim_flag;
4111         unsigned long pflags;
4112
4113         cond_resched();
4114
4115         /* We now go into synchronous reclaim */
4116         cpuset_memory_pressure_bump();
4117         psi_memstall_enter(&pflags);
4118         fs_reclaim_acquire(gfp_mask);
4119         noreclaim_flag = memalloc_noreclaim_save();
4120
4121         progress = try_to_free_pages(ac->zonelist, order, gfp_mask,
4122                                                                 ac->nodemask);
4123
4124         memalloc_noreclaim_restore(noreclaim_flag);
4125         fs_reclaim_release(gfp_mask);
4126         psi_memstall_leave(&pflags);
4127
4128         cond_resched();
4129
4130         return progress;
4131 }
4132
4133 /* The really slow allocator path where we enter direct reclaim */
4134 static inline struct page *
4135 __alloc_pages_direct_reclaim(gfp_t gfp_mask, unsigned int order,
4136                 unsigned int alloc_flags, const struct alloc_context *ac,
4137                 unsigned long *did_some_progress)
4138 {
4139         struct page *page = NULL;
4140         bool drained = false;
4141
4142         *did_some_progress = __perform_reclaim(gfp_mask, order, ac);
4143         if (unlikely(!(*did_some_progress)))
4144                 return NULL;
4145
4146 retry:
4147         page = get_page_from_freelist(gfp_mask, order, alloc_flags, ac);
4148
4149         /*
4150          * If an allocation failed after direct reclaim, it could be because
4151          * pages are pinned on the per-cpu lists or in high alloc reserves.
4152          * Shrink them them and try again
4153          */
4154         if (!page && !drained) {
4155                 unreserve_highatomic_pageblock(ac, false);
4156                 drain_all_pages(NULL);
4157                 drained = true;
4158                 goto retry;
4159         }
4160
4161         return page;
4162 }
4163
4164 static void wake_all_kswapds(unsigned int order, gfp_t gfp_mask,
4165                              const struct alloc_context *ac)
4166 {
4167         struct zoneref *z;
4168         struct zone *zone;
4169         pg_data_t *last_pgdat = NULL;
4170         enum zone_type high_zoneidx = ac->high_zoneidx;
4171
4172         for_each_zone_zonelist_nodemask(zone, z, ac->zonelist, high_zoneidx,
4173                                         ac->nodemask) {
4174                 if (last_pgdat != zone->zone_pgdat)
4175                         wakeup_kswapd(zone, gfp_mask, order, high_zoneidx);
4176                 last_pgdat = zone->zone_pgdat;
4177         }
4178 }
4179
4180 static inline unsigned int
4181 gfp_to_alloc_flags(gfp_t gfp_mask)
4182 {
4183         unsigned int alloc_flags = ALLOC_WMARK_MIN | ALLOC_CPUSET;
4184
4185         /* __GFP_HIGH is assumed to be the same as ALLOC_HIGH to save a branch. */
4186         BUILD_BUG_ON(__GFP_HIGH != (__force gfp_t) ALLOC_HIGH);
4187
4188         /*
4189          * The caller may dip into page reserves a bit more if the caller
4190          * cannot run direct reclaim, or if the caller has realtime scheduling
4191          * policy or is asking for __GFP_HIGH memory.  GFP_ATOMIC requests will
4192          * set both ALLOC_HARDER (__GFP_ATOMIC) and ALLOC_HIGH (__GFP_HIGH).
4193          */
4194         alloc_flags |= (__force int) (gfp_mask & __GFP_HIGH);
4195
4196         if (gfp_mask & __GFP_ATOMIC) {
4197                 /*
4198                  * Not worth trying to allocate harder for __GFP_NOMEMALLOC even
4199                  * if it can't schedule.
4200                  */
4201                 if (!(gfp_mask & __GFP_NOMEMALLOC))
4202                         alloc_flags |= ALLOC_HARDER;
4203                 /*
4204                  * Ignore cpuset mems for GFP_ATOMIC rather than fail, see the
4205                  * comment for __cpuset_node_allowed().
4206                  */
4207                 alloc_flags &= ~ALLOC_CPUSET;
4208         } else if (unlikely(rt_task(current)) && !in_interrupt())
4209                 alloc_flags |= ALLOC_HARDER;
4210
4211         if (gfp_mask & __GFP_KSWAPD_RECLAIM)
4212                 alloc_flags |= ALLOC_KSWAPD;
4213
4214 #ifdef CONFIG_CMA
4215         if (gfpflags_to_migratetype(gfp_mask) == MIGRATE_MOVABLE)
4216                 alloc_flags |= ALLOC_CMA;
4217 #endif
4218         return alloc_flags;
4219 }
4220
4221 static bool oom_reserves_allowed(struct task_struct *tsk)
4222 {
4223         if (!tsk_is_oom_victim(tsk))
4224                 return false;
4225
4226         /*
4227          * !MMU doesn't have oom reaper so give access to memory reserves
4228          * only to the thread with TIF_MEMDIE set
4229          */
4230         if (!IS_ENABLED(CONFIG_MMU) && !test_thread_flag(TIF_MEMDIE))
4231                 return false;
4232
4233         return true;
4234 }
4235
4236 /*
4237  * Distinguish requests which really need access to full memory
4238  * reserves from oom victims which can live with a portion of it
4239  */
4240 static inline int __gfp_pfmemalloc_flags(gfp_t gfp_mask)
4241 {
4242         if (unlikely(gfp_mask & __GFP_NOMEMALLOC))
4243                 return 0;
4244         if (gfp_mask & __GFP_MEMALLOC)
4245                 return ALLOC_NO_WATERMARKS;
4246         if (in_serving_softirq() && (current->flags & PF_MEMALLOC))
4247                 return ALLOC_NO_WATERMARKS;
4248         if (!in_interrupt()) {
4249                 if (current->flags & PF_MEMALLOC)
4250                         return ALLOC_NO_WATERMARKS;
4251                 else if (oom_reserves_allowed(current))
4252                         return ALLOC_OOM;
4253         }
4254
4255         return 0;
4256 }
4257
4258 bool gfp_pfmemalloc_allowed(gfp_t gfp_mask)
4259 {
4260         return !!__gfp_pfmemalloc_flags(gfp_mask);
4261 }
4262
4263 /*
4264  * Checks whether it makes sense to retry the reclaim to make a forward progress
4265  * for the given allocation request.
4266  *
4267  * We give up when we either have tried MAX_RECLAIM_RETRIES in a row
4268  * without success, or when we couldn't even meet the watermark if we
4269  * reclaimed all remaining pages on the LRU lists.
4270  *
4271  * Returns true if a retry is viable or false to enter the oom path.
4272  */
4273 static inline bool
4274 should_reclaim_retry(gfp_t gfp_mask, unsigned order,
4275                      struct alloc_context *ac, int alloc_flags,
4276                      bool did_some_progress, int *no_progress_loops)
4277 {
4278         struct zone *zone;
4279         struct zoneref *z;
4280         bool ret = false;
4281
4282         /*
4283          * Costly allocations might have made a progress but this doesn't mean
4284          * their order will become available due to high fragmentation so
4285          * always increment the no progress counter for them
4286          */
4287         if (did_some_progress && order <= PAGE_ALLOC_COSTLY_ORDER)
4288                 *no_progress_loops = 0;
4289         else
4290                 (*no_progress_loops)++;
4291
4292         /*
4293          * Make sure we converge to OOM if we cannot make any progress
4294          * several times in the row.
4295          */
4296         if (*no_progress_loops > MAX_RECLAIM_RETRIES) {
4297                 /* Before OOM, exhaust highatomic_reserve */
4298                 return unreserve_highatomic_pageblock(ac, true);
4299         }
4300
4301         /*
4302          * Keep reclaiming pages while there is a chance this will lead
4303          * somewhere.  If none of the target zones can satisfy our allocation
4304          * request even if all reclaimable pages are considered then we are
4305          * screwed and have to go OOM.
4306          */
4307         for_each_zone_zonelist_nodemask(zone, z, ac->zonelist, ac->high_zoneidx,
4308                                         ac->nodemask) {
4309                 unsigned long available;
4310                 unsigned long reclaimable;
4311                 unsigned long min_wmark = min_wmark_pages(zone);
4312                 bool wmark;
4313
4314                 available = reclaimable = zone_reclaimable_pages(zone);
4315                 available += zone_page_state_snapshot(zone, NR_FREE_PAGES);
4316
4317                 /*
4318                  * Would the allocation succeed if we reclaimed all
4319                  * reclaimable pages?
4320                  */
4321                 wmark = __zone_watermark_ok(zone, order, min_wmark,
4322                                 ac_classzone_idx(ac), alloc_flags, available);
4323                 trace_reclaim_retry_zone(z, order, reclaimable,
4324                                 available, min_wmark, *no_progress_loops, wmark);
4325                 if (wmark) {
4326                         /*
4327                          * If we didn't make any progress and have a lot of
4328                          * dirty + writeback pages then we should wait for
4329                          * an IO to complete to slow down the reclaim and
4330                          * prevent from pre mature OOM
4331                          */
4332                         if (!did_some_progress) {
4333                                 unsigned long write_pending;
4334
4335                                 write_pending = zone_page_state_snapshot(zone,
4336                                                         NR_ZONE_WRITE_PENDING);
4337
4338                                 if (2 * write_pending > reclaimable) {
4339                                         congestion_wait(BLK_RW_ASYNC, HZ/10);
4340                                         return true;
4341                                 }
4342                         }
4343
4344                         ret = true;
4345                         goto out;
4346                 }
4347         }
4348
4349 out:
4350         /*
4351          * Memory allocation/reclaim might be called from a WQ context and the
4352          * current implementation of the WQ concurrency control doesn't
4353          * recognize that a particular WQ is congested if the worker thread is
4354          * looping without ever sleeping. Therefore we have to do a short sleep
4355          * here rather than calling cond_resched().
4356          */
4357         if (current->flags & PF_WQ_WORKER)
4358                 schedule_timeout_uninterruptible(1);
4359         else
4360                 cond_resched();
4361         return ret;
4362 }
4363
4364 static inline bool
4365 check_retry_cpuset(int cpuset_mems_cookie, struct alloc_context *ac)
4366 {
4367         /*
4368          * It's possible that cpuset's mems_allowed and the nodemask from
4369          * mempolicy don't intersect. This should be normally dealt with by
4370          * policy_nodemask(), but it's possible to race with cpuset update in
4371          * such a way the check therein was true, and then it became false
4372          * before we got our cpuset_mems_cookie here.
4373          * This assumes that for all allocations, ac->nodemask can come only
4374          * from MPOL_BIND mempolicy (whose documented semantics is to be ignored
4375          * when it does not intersect with the cpuset restrictions) or the
4376          * caller can deal with a violated nodemask.
4377          */
4378         if (cpusets_enabled() && ac->nodemask &&
4379                         !cpuset_nodemask_valid_mems_allowed(ac->nodemask)) {
4380                 ac->nodemask = NULL;
4381                 return true;
4382         }
4383
4384         /*
4385          * When updating a task's mems_allowed or mempolicy nodemask, it is
4386          * possible to race with parallel threads in such a way that our
4387          * allocation can fail while the mask is being updated. If we are about
4388          * to fail, check if the cpuset changed during allocation and if so,
4389          * retry.
4390          */
4391         if (read_mems_allowed_retry(cpuset_mems_cookie))
4392                 return true;
4393
4394         return false;
4395 }
4396
4397 static inline struct page *
4398 __alloc_pages_slowpath(gfp_t gfp_mask, unsigned int order,
4399                                                 struct alloc_context *ac)
4400 {
4401         bool can_direct_reclaim = gfp_mask & __GFP_DIRECT_RECLAIM;
4402         const bool costly_order = order > PAGE_ALLOC_COSTLY_ORDER;
4403         struct page *page = NULL;
4404         unsigned int alloc_flags;
4405         unsigned long did_some_progress;
4406         enum compact_priority compact_priority;
4407         enum compact_result compact_result;
4408         int compaction_retries;
4409         int no_progress_loops;
4410         unsigned int cpuset_mems_cookie;
4411         int reserve_flags;
4412
4413         /*
4414          * We also sanity check to catch abuse of atomic reserves being used by
4415          * callers that are not in atomic context.
4416          */
4417         if (WARN_ON_ONCE((gfp_mask & (__GFP_ATOMIC|__GFP_DIRECT_RECLAIM)) ==
4418                                 (__GFP_ATOMIC|__GFP_DIRECT_RECLAIM)))
4419                 gfp_mask &= ~__GFP_ATOMIC;
4420
4421 retry_cpuset:
4422         compaction_retries = 0;
4423         no_progress_loops = 0;
4424         compact_priority = DEF_COMPACT_PRIORITY;
4425         cpuset_mems_cookie = read_mems_allowed_begin();
4426
4427         /*
4428          * The fast path uses conservative alloc_flags to succeed only until
4429          * kswapd needs to be woken up, and to avoid the cost of setting up
4430          * alloc_flags precisely. So we do that now.
4431          */
4432         alloc_flags = gfp_to_alloc_flags(gfp_mask);
4433
4434         /*
4435          * We need to recalculate the starting point for the zonelist iterator
4436          * because we might have used different nodemask in the fast path, or
4437          * there was a cpuset modification and we are retrying - otherwise we
4438          * could end up iterating over non-eligible zones endlessly.
4439          */
4440         ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,
4441                                         ac->high_zoneidx, ac->nodemask);
4442         if (!ac->preferred_zoneref->zone)
4443                 goto nopage;
4444
4445         if (alloc_flags & ALLOC_KSWAPD)
4446                 wake_all_kswapds(order, gfp_mask, ac);
4447
4448         /*
4449          * The adjusted alloc_flags might result in immediate success, so try
4450          * that first
4451          */
4452         page = get_page_from_freelist(gfp_mask, order, alloc_flags, ac);
4453         if (page)
4454                 goto got_pg;
4455
4456         /*
4457          * For costly allocations, try direct compaction first, as it's likely
4458          * that we have enough base pages and don't need to reclaim. For non-
4459          * movable high-order allocations, do that as well, as compaction will
4460          * try prevent permanent fragmentation by migrating from blocks of the
4461          * same migratetype.
4462          * Don't try this for allocations that are allowed to ignore
4463          * watermarks, as the ALLOC_NO_WATERMARKS attempt didn't yet happen.
4464          */
4465         if (can_direct_reclaim &&
4466                         (costly_order ||
4467                            (order > 0 && ac->migratetype != MIGRATE_MOVABLE))
4468                         && !gfp_pfmemalloc_allowed(gfp_mask)) {
4469                 page = __alloc_pages_direct_compact(gfp_mask, order,
4470                                                 alloc_flags, ac,
4471                                                 INIT_COMPACT_PRIORITY,
4472                                                 &compact_result);
4473                 if (page)
4474                         goto got_pg;
4475
4476                  if (order >= pageblock_order && (gfp_mask & __GFP_IO) &&
4477                      !(gfp_mask & __GFP_RETRY_MAYFAIL)) {
4478                         /*
4479                          * If allocating entire pageblock(s) and compaction
4480                          * failed because all zones are below low watermarks
4481                          * or is prohibited because it recently failed at this
4482                          * order, fail immediately unless the allocator has
4483                          * requested compaction and reclaim retry.
4484                          *
4485                          * Reclaim is
4486                          *  - potentially very expensive because zones are far
4487                          *    below their low watermarks or this is part of very
4488                          *    bursty high order allocations,
4489                          *  - not guaranteed to help because isolate_freepages()
4490                          *    may not iterate over freed pages as part of its
4491                          *    linear scan, and
4492                          *  - unlikely to make entire pageblocks free on its
4493                          *    own.
4494                          */
4495                         if (compact_result == COMPACT_SKIPPED ||
4496                             compact_result == COMPACT_DEFERRED)
4497                                 goto nopage;
4498                 }
4499
4500                 /*
4501                  * Checks for costly allocations with __GFP_NORETRY, which
4502                  * includes THP page fault allocations
4503                  */
4504                 if (costly_order && (gfp_mask & __GFP_NORETRY)) {
4505                         /*
4506                          * If compaction is deferred for high-order allocations,
4507                          * it is because sync compaction recently failed. If
4508                          * this is the case and the caller requested a THP
4509                          * allocation, we do not want to heavily disrupt the
4510                          * system, so we fail the allocation instead of entering
4511                          * direct reclaim.
4512                          */
4513                         if (compact_result == COMPACT_DEFERRED)
4514                                 goto nopage;
4515
4516                         /*
4517                          * Looks like reclaim/compaction is worth trying, but
4518                          * sync compaction could be very expensive, so keep
4519                          * using async compaction.
4520                          */
4521                         compact_priority = INIT_COMPACT_PRIORITY;
4522                 }
4523         }
4524
4525 retry:
4526         /* Ensure kswapd doesn't accidentally go to sleep as long as we loop */
4527         if (alloc_flags & ALLOC_KSWAPD)
4528                 wake_all_kswapds(order, gfp_mask, ac);
4529
4530         reserve_flags = __gfp_pfmemalloc_flags(gfp_mask);
4531         if (reserve_flags)
4532                 alloc_flags = reserve_flags;
4533
4534         /*
4535          * Reset the nodemask and zonelist iterators if memory policies can be
4536          * ignored. These allocations are high priority and system rather than
4537          * user oriented.
4538          */
4539         if (!(alloc_flags & ALLOC_CPUSET) || reserve_flags) {
4540                 ac->nodemask = NULL;
4541                 ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,
4542                                         ac->high_zoneidx, ac->nodemask);
4543         }
4544
4545         /* Attempt with potentially adjusted zonelist and alloc_flags */
4546         page = get_page_from_freelist(gfp_mask, order, alloc_flags, ac);
4547         if (page)
4548                 goto got_pg;
4549
4550         /* Caller is not willing to reclaim, we can't balance anything */
4551         if (!can_direct_reclaim)
4552                 goto nopage;
4553
4554         /* Avoid recursion of direct reclaim */
4555         if (current->flags & PF_MEMALLOC)
4556                 goto nopage;
4557
4558         /* Try direct reclaim and then allocating */
4559         page = __alloc_pages_direct_reclaim(gfp_mask, order, alloc_flags, ac,
4560                                                         &did_some_progress);
4561         if (page)
4562                 goto got_pg;
4563
4564         /* Try direct compaction and then allocating */
4565         page = __alloc_pages_direct_compact(gfp_mask, order, alloc_flags, ac,
4566                                         compact_priority, &compact_result);
4567         if (page)
4568                 goto got_pg;
4569
4570         /* Do not loop if specifically requested */
4571         if (gfp_mask & __GFP_NORETRY)
4572                 goto nopage;
4573
4574         /*
4575          * Do not retry costly high order allocations unless they are
4576          * __GFP_RETRY_MAYFAIL
4577          */
4578         if (costly_order && !(gfp_mask & __GFP_RETRY_MAYFAIL))
4579                 goto nopage;
4580
4581         if (should_reclaim_retry(gfp_mask, order, ac, alloc_flags,
4582                                  did_some_progress > 0, &no_progress_loops))
4583                 goto retry;
4584
4585         /*
4586          * It doesn't make any sense to retry for the compaction if the order-0
4587          * reclaim is not able to make any progress because the current
4588          * implementation of the compaction depends on the sufficient amount
4589          * of free memory (see __compaction_suitable)
4590          */
4591         if (did_some_progress > 0 &&
4592                         should_compact_retry(ac, order, alloc_flags,
4593                                 compact_result, &compact_priority,
4594                                 &compaction_retries))
4595                 goto retry;
4596
4597
4598         /* Deal with possible cpuset update races before we start OOM killing */
4599         if (check_retry_cpuset(cpuset_mems_cookie, ac))
4600                 goto retry_cpuset;
4601
4602         /* Reclaim has failed us, start killing things */
4603         page = __alloc_pages_may_oom(gfp_mask, order, ac, &did_some_progress);
4604         if (page)
4605                 goto got_pg;
4606
4607         /* Avoid allocations with no watermarks from looping endlessly */
4608         if (tsk_is_oom_victim(current) &&
4609             (alloc_flags == ALLOC_OOM ||
4610              (gfp_mask & __GFP_NOMEMALLOC)))
4611                 goto nopage;
4612
4613         /* Retry as long as the OOM killer is making progress */
4614         if (did_some_progress) {
4615                 no_progress_loops = 0;
4616                 goto retry;
4617         }
4618
4619 nopage:
4620         /* Deal with possible cpuset update races before we fail */
4621         if (check_retry_cpuset(cpuset_mems_cookie, ac))
4622                 goto retry_cpuset;
4623
4624         /*
4625          * Make sure that __GFP_NOFAIL request doesn't leak out and make sure
4626          * we always retry
4627          */
4628         if (gfp_mask & __GFP_NOFAIL) {
4629                 /*
4630                  * All existing users of the __GFP_NOFAIL are blockable, so warn
4631                  * of any new users that actually require GFP_NOWAIT
4632                  */
4633                 if (WARN_ON_ONCE(!can_direct_reclaim))
4634                         goto fail;
4635
4636                 /*
4637                  * PF_MEMALLOC request from this context is rather bizarre
4638                  * because we cannot reclaim anything and only can loop waiting
4639                  * for somebody to do a work for us
4640                  */
4641                 WARN_ON_ONCE(current->flags & PF_MEMALLOC);
4642
4643                 /*
4644                  * non failing costly orders are a hard requirement which we
4645                  * are not prepared for much so let's warn about these users
4646                  * so that we can identify them and convert them to something
4647                  * else.
4648                  */
4649                 WARN_ON_ONCE(order > PAGE_ALLOC_COSTLY_ORDER);
4650
4651                 /*
4652                  * Help non-failing allocations by giving them access to memory
4653                  * reserves but do not use ALLOC_NO_WATERMARKS because this
4654                  * could deplete whole memory reserves which would just make
4655                  * the situation worse
4656                  */
4657                 page = __alloc_pages_cpuset_fallback(gfp_mask, order, ALLOC_HARDER, ac);
4658                 if (page)
4659                         goto got_pg;
4660
4661                 cond_resched();
4662                 goto retry;
4663         }
4664 fail:
4665         warn_alloc(gfp_mask, ac->nodemask,
4666                         "page allocation failure: order:%u", order);
4667 got_pg:
4668         return page;
4669 }
4670
4671 static inline bool prepare_alloc_pages(gfp_t gfp_mask, unsigned int order,
4672                 int preferred_nid, nodemask_t *nodemask,
4673                 struct alloc_context *ac, gfp_t *alloc_mask,
4674                 unsigned int *alloc_flags)
4675 {
4676         ac->high_zoneidx = gfp_zone(gfp_mask);
4677         ac->zonelist = node_zonelist(preferred_nid, gfp_mask);
4678         ac->nodemask = nodemask;
4679         ac->migratetype = gfpflags_to_migratetype(gfp_mask);
4680
4681         if (cpusets_enabled()) {
4682                 *alloc_mask |= __GFP_HARDWALL;
4683                 if (!ac->nodemask)
4684                         ac->nodemask = &cpuset_current_mems_allowed;
4685                 else
4686                         *alloc_flags |= ALLOC_CPUSET;
4687         }
4688
4689         fs_reclaim_acquire(gfp_mask);
4690         fs_reclaim_release(gfp_mask);
4691
4692         might_sleep_if(gfp_mask & __GFP_DIRECT_RECLAIM);
4693
4694         if (should_fail_alloc_page(gfp_mask, order))
4695                 return false;
4696
4697         if (IS_ENABLED(CONFIG_CMA) && ac->migratetype == MIGRATE_MOVABLE)
4698                 *alloc_flags |= ALLOC_CMA;
4699
4700         return true;
4701 }
4702
4703 /* Determine whether to spread dirty pages and what the first usable zone */
4704 static inline void finalise_ac(gfp_t gfp_mask, struct alloc_context *ac)
4705 {
4706         /* Dirty zone balancing only done in the fast path */
4707         ac->spread_dirty_pages = (gfp_mask & __GFP_WRITE);
4708
4709         /*
4710          * The preferred zone is used for statistics but crucially it is
4711          * also used as the starting point for the zonelist iterator. It
4712          * may get reset for allocations that ignore memory policies.
4713          */
4714         ac->preferred_zoneref = first_zones_zonelist(ac->zonelist,
4715                                         ac->high_zoneidx, ac->nodemask);
4716 }
4717
4718 /*
4719  * This is the 'heart' of the zoned buddy allocator.
4720  */
4721 struct page *
4722 __alloc_pages_nodemask(gfp_t gfp_mask, unsigned int order, int preferred_nid,
4723                                                         nodemask_t *nodemask)
4724 {
4725         struct page *page;
4726         unsigned int alloc_flags = ALLOC_WMARK_LOW;
4727         gfp_t alloc_mask; /* The gfp_t that was actually used for allocation */
4728         struct alloc_context ac = { };
4729
4730         /*
4731          * There are several places where we assume that the order value is sane
4732          * so bail out early if the request is out of bound.
4733          */
4734         if (unlikely(order >= MAX_ORDER)) {
4735                 WARN_ON_ONCE(!(gfp_mask & __GFP_NOWARN));
4736                 return NULL;
4737         }
4738
4739         gfp_mask &= gfp_allowed_mask;
4740         alloc_mask = gfp_mask;
4741         if (!prepare_alloc_pages(gfp_mask, order, preferred_nid, nodemask, &ac, &alloc_mask, &alloc_flags))
4742                 return NULL;
4743
4744         finalise_ac(gfp_mask, &ac);
4745
4746         /*
4747          * Forbid the first pass from falling back to types that fragment
4748          * memory until all local zones are considered.
4749          */
4750         alloc_flags |= alloc_flags_nofragment(ac.preferred_zoneref->zone, gfp_mask);
4751
4752         /* First allocation attempt */
4753         page = get_page_from_freelist(alloc_mask, order, alloc_flags, &ac);
4754         if (likely(page))
4755                 goto out;
4756
4757         /*
4758          * Apply scoped allocation constraints. This is mainly about GFP_NOFS
4759          * resp. GFP_NOIO which has to be inherited for all allocation requests
4760          * from a particular context which has been marked by
4761          * memalloc_no{fs,io}_{save,restore}.
4762          */
4763         alloc_mask = current_gfp_context(gfp_mask);
4764         ac.spread_dirty_pages = false;
4765
4766         /*
4767          * Restore the original nodemask if it was potentially replaced with
4768          * &cpuset_current_mems_allowed to optimize the fast-path attempt.
4769          */
4770         if (unlikely(ac.nodemask != nodemask))
4771                 ac.nodemask = nodemask;
4772
4773         page = __alloc_pages_slowpath(alloc_mask, order, &ac);
4774
4775 out:
4776         if (memcg_kmem_enabled() && (gfp_mask & __GFP_ACCOUNT) && page &&
4777             unlikely(__memcg_kmem_charge(page, gfp_mask, order) != 0)) {
4778                 __free_pages(page, order);
4779                 page = NULL;
4780         }
4781
4782         trace_mm_page_alloc(page, order, alloc_mask, ac.migratetype);
4783
4784         return page;
4785 }
4786 EXPORT_SYMBOL(__alloc_pages_nodemask);
4787
4788 /*
4789  * Common helper functions. Never use with __GFP_HIGHMEM because the returned
4790  * address cannot represent highmem pages. Use alloc_pages and then kmap if
4791  * you need to access high mem.
4792  */
4793 unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order)
4794 {
4795         struct page *page;
4796
4797         page = alloc_pages(gfp_mask & ~__GFP_HIGHMEM, order);
4798         if (!page)
4799                 return 0;
4800         return (unsigned long) page_address(page);
4801 }
4802 EXPORT_SYMBOL(__get_free_pages);
4803
4804 unsigned long get_zeroed_page(gfp_t gfp_mask)
4805 {
4806         return __get_free_pages(gfp_mask | __GFP_ZERO, 0);
4807 }
4808 EXPORT_SYMBOL(get_zeroed_page);
4809
4810 static inline void free_the_page(struct page *page, unsigned int order)
4811 {
4812         if (order == 0)         /* Via pcp? */
4813                 free_unref_page(page);
4814         else
4815                 __free_pages_ok(page, order);
4816 }
4817
4818 void __free_pages(struct page *page, unsigned int order)
4819 {
4820         if (put_page_testzero(page))
4821                 free_the_page(page, order);
4822 }
4823 EXPORT_SYMBOL(__free_pages);
4824
4825 void free_pages(unsigned long addr, unsigned int order)
4826 {
4827         if (addr != 0) {
4828                 VM_BUG_ON(!virt_addr_valid((void *)addr));
4829                 __free_pages(virt_to_page((void *)addr), order);
4830         }
4831 }
4832
4833 EXPORT_SYMBOL(free_pages);
4834
4835 /*
4836  * Page Fragment:
4837  *  An arbitrary-length arbitrary-offset area of memory which resides
4838  *  within a 0 or higher order page.  Multiple fragments within that page
4839  *  are individually refcounted, in the page's reference counter.
4840  *
4841  * The page_frag functions below provide a simple allocation framework for
4842  * page fragments.  This is used by the network stack and network device
4843  * drivers to provide a backing region of memory for use as either an
4844  * sk_buff->head, or to be used in the "frags" portion of skb_shared_info.
4845  */
4846 static struct page *__page_frag_cache_refill(struct page_frag_cache *nc,
4847                                              gfp_t gfp_mask)
4848 {
4849         struct page *page = NULL;
4850         gfp_t gfp = gfp_mask;
4851
4852 #if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE)
4853         gfp_mask |= __GFP_COMP | __GFP_NOWARN | __GFP_NORETRY |
4854                     __GFP_NOMEMALLOC;
4855         page = alloc_pages_node(NUMA_NO_NODE, gfp_mask,
4856                                 PAGE_FRAG_CACHE_MAX_ORDER);
4857         nc->size = page ? PAGE_FRAG_CACHE_MAX_SIZE : PAGE_SIZE;
4858 #endif
4859         if (unlikely(!page))
4860                 page = alloc_pages_node(NUMA_NO_NODE, gfp, 0);
4861
4862         nc->va = page ? page_address(page) : NULL;
4863
4864         return page;
4865 }
4866
4867 void __page_frag_cache_drain(struct page *page, unsigned int count)
4868 {
4869         VM_BUG_ON_PAGE(page_ref_count(page) == 0, page);
4870
4871         if (page_ref_sub_and_test(page, count))
4872                 free_the_page(page, compound_order(page));
4873 }
4874 EXPORT_SYMBOL(__page_frag_cache_drain);
4875
4876 void *page_frag_alloc(struct page_frag_cache *nc,
4877                       unsigned int fragsz, gfp_t gfp_mask)
4878 {
4879         unsigned int size = PAGE_SIZE;
4880         struct page *page;
4881         int offset;
4882
4883         if (unlikely(!nc->va)) {
4884 refill:
4885                 page = __page_frag_cache_refill(nc, gfp_mask);
4886                 if (!page)
4887                         return NULL;
4888
4889 #if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE)
4890                 /* if size can vary use size else just use PAGE_SIZE */
4891                 size = nc->size;
4892 #endif
4893                 /* Even if we own the page, we do not use atomic_set().
4894                  * This would break get_page_unless_zero() users.
4895                  */
4896                 page_ref_add(page, PAGE_FRAG_CACHE_MAX_SIZE);
4897
4898                 /* reset page count bias and offset to start of new frag */
4899                 nc->pfmemalloc = page_is_pfmemalloc(page);
4900                 nc->pagecnt_bias = PAGE_FRAG_CACHE_MAX_SIZE + 1;
4901                 nc->offset = size;
4902         }
4903
4904         offset = nc->offset - fragsz;
4905         if (unlikely(offset < 0)) {
4906                 page = virt_to_page(nc->va);
4907
4908                 if (!page_ref_sub_and_test(page, nc->pagecnt_bias))
4909                         goto refill;
4910
4911 #if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE)
4912                 /* if size can vary use size else just use PAGE_SIZE */
4913                 size = nc->size;
4914 #endif
4915                 /* OK, page count is 0, we can safely set it */
4916                 set_page_count(page, PAGE_FRAG_CACHE_MAX_SIZE + 1);
4917
4918                 /* reset page count bias and offset to start of new frag */
4919                 nc->pagecnt_bias = PAGE_FRAG_CACHE_MAX_SIZE + 1;
4920                 offset = size - fragsz;
4921         }
4922
4923         nc->pagecnt_bias--;
4924         nc->offset = offset;
4925
4926         return nc->va + offset;
4927 }
4928 EXPORT_SYMBOL(page_frag_alloc);
4929
4930 /*
4931  * Frees a page fragment allocated out of either a compound or order 0 page.
4932  */
4933 void page_frag_free(void *addr)
4934 {
4935         struct page *page = virt_to_head_page(addr);
4936
4937         if (unlikely(put_page_testzero(page)))
4938                 free_the_page(page, compound_order(page));
4939 }
4940 EXPORT_SYMBOL(page_frag_free);
4941
4942 static void *make_alloc_exact(unsigned long addr, unsigned int order,
4943                 size_t size)
4944 {
4945         if (addr) {
4946                 unsigned long alloc_end = addr + (PAGE_SIZE << order);
4947                 unsigned long used = addr + PAGE_ALIGN(size);
4948
4949                 split_page(virt_to_page((void *)addr), order);
4950                 while (used < alloc_end) {
4951                         free_page(used);
4952                         used += PAGE_SIZE;
4953                 }
4954         }
4955         return (void *)addr;
4956 }
4957
4958 /**
4959  * alloc_pages_exact - allocate an exact number physically-contiguous pages.
4960  * @size: the number of bytes to allocate
4961  * @gfp_mask: GFP flags for the allocation, must not contain __GFP_COMP
4962  *
4963  * This function is similar to alloc_pages(), except that it allocates the
4964  * minimum number of pages to satisfy the request.  alloc_pages() can only
4965  * allocate memory in power-of-two pages.
4966  *
4967  * This function is also limited by MAX_ORDER.
4968  *
4969  * Memory allocated by this function must be released by free_pages_exact().
4970  *
4971  * Return: pointer to the allocated area or %NULL in case of error.
4972  */
4973 void *alloc_pages_exact(size_t size, gfp_t gfp_mask)
4974 {
4975         unsigned int order = get_order(size);
4976         unsigned long addr;
4977
4978         if (WARN_ON_ONCE(gfp_mask & __GFP_COMP))
4979                 gfp_mask &= ~__GFP_COMP;
4980
4981         addr = __get_free_pages(gfp_mask, order);
4982         return make_alloc_exact(addr, order, size);
4983 }
4984 EXPORT_SYMBOL(alloc_pages_exact);
4985
4986 /**
4987  * alloc_pages_exact_nid - allocate an exact number of physically-contiguous
4988  *                         pages on a node.
4989  * @nid: the preferred node ID where memory should be allocated
4990  * @size: the number of bytes to allocate
4991  * @gfp_mask: GFP flags for the allocation, must not contain __GFP_COMP
4992  *
4993  * Like alloc_pages_exact(), but try to allocate on node nid first before falling
4994  * back.
4995  *
4996  * Return: pointer to the allocated area or %NULL in case of error.
4997  */
4998 void * __meminit alloc_pages_exact_nid(int nid, size_t size, gfp_t gfp_mask)
4999 {
5000         unsigned int order = get_order(size);
5001         struct page *p;
5002
5003         if (WARN_ON_ONCE(gfp_mask & __GFP_COMP))
5004                 gfp_mask &= ~__GFP_COMP;
5005
5006         p = alloc_pages_node(nid, gfp_mask, order);
5007         if (!p)
5008                 return NULL;
5009         return make_alloc_exact((unsigned long)page_address(p), order, size);
5010 }
5011
5012 /**
5013  * free_pages_exact - release memory allocated via alloc_pages_exact()
5014  * @virt: the value returned by alloc_pages_exact.
5015  * @size: size of allocation, same value as passed to alloc_pages_exact().
5016  *
5017  * Release the memory allocated by a previous call to alloc_pages_exact.
5018  */
5019 void free_pages_exact(void *virt, size_t size)
5020 {
5021         unsigned long addr = (unsigned long)virt;
5022         unsigned long end = addr + PAGE_ALIGN(size);
5023
5024         while (addr < end) {
5025                 free_page(addr);
5026                 addr += PAGE_SIZE;
5027         }
5028 }
5029 EXPORT_SYMBOL(free_pages_exact);
5030
5031 /**
5032  * nr_free_zone_pages - count number of pages beyond high watermark
5033  * @offset: The zone index of the highest zone
5034  *
5035  * nr_free_zone_pages() counts the number of pages which are beyond the
5036  * high watermark within all zones at or below a given zone index.  For each
5037  * zone, the number of pages is calculated as:
5038  *
5039  *     nr_free_zone_pages = managed_pages - high_pages
5040  *
5041  * Return: number of pages beyond high watermark.
5042  */
5043 static unsigned long nr_free_zone_pages(int offset)
5044 {
5045         struct zoneref *z;
5046         struct zone *zone;
5047
5048         /* Just pick one node, since fallback list is circular */
5049         unsigned long sum = 0;
5050
5051         struct zonelist *zonelist = node_zonelist(numa_node_id(), GFP_KERNEL);
5052
5053         for_each_zone_zonelist(zone, z, zonelist, offset) {
5054                 unsigned long size = zone_managed_pages(zone);
5055                 unsigned long high = high_wmark_pages(zone);
5056                 if (size > high)
5057                         sum += size - high;
5058         }
5059
5060         return sum;
5061 }
5062
5063 /**
5064  * nr_free_buffer_pages - count number of pages beyond high watermark
5065  *
5066  * nr_free_buffer_pages() counts the number of pages which are beyond the high
5067  * watermark within ZONE_DMA and ZONE_NORMAL.
5068  *
5069  * Return: number of pages beyond high watermark within ZONE_DMA and
5070  * ZONE_NORMAL.
5071  */
5072 unsigned long nr_free_buffer_pages(void)
5073 {
5074         return nr_free_zone_pages(gfp_zone(GFP_USER));
5075 }
5076 EXPORT_SYMBOL_GPL(nr_free_buffer_pages);
5077
5078 /**
5079  * nr_free_pagecache_pages - count number of pages beyond high watermark
5080  *
5081  * nr_free_pagecache_pages() counts the number of pages which are beyond the
5082  * high watermark within all zones.
5083  *
5084  * Return: number of pages beyond high watermark within all zones.
5085  */
5086 unsigned long nr_free_pagecache_pages(void)
5087 {
5088         return nr_free_zone_pages(gfp_zone(GFP_HIGHUSER_MOVABLE));
5089 }
5090
5091 static inline void show_node(struct zone *zone)
5092 {
5093         if (IS_ENABLED(CONFIG_NUMA))
5094                 printk("Node %d ", zone_to_nid(zone));
5095 }
5096
5097 long si_mem_available(void)
5098 {
5099         long available;
5100         unsigned long pagecache;
5101         unsigned long wmark_low = 0;
5102         unsigned long pages[NR_LRU_LISTS];
5103         unsigned long reclaimable;
5104         struct zone *zone;
5105         int lru;
5106
5107         for (lru = LRU_BASE; lru < NR_LRU_LISTS; lru++)
5108                 pages[lru] = global_node_page_state(NR_LRU_BASE + lru);
5109
5110         for_each_zone(zone)
5111                 wmark_low += low_wmark_pages(zone);
5112
5113         /*
5114          * Estimate the amount of memory available for userspace allocations,
5115          * without causing swapping.
5116          */
5117         available = global_zone_page_state(NR_FREE_PAGES) - totalreserve_pages;
5118
5119         /*
5120          * Not all the page cache can be freed, otherwise the system will
5121          * start swapping. Assume at least half of the page cache, or the
5122          * low watermark worth of cache, needs to stay.
5123          */
5124         pagecache = pages[LRU_ACTIVE_FILE] + pages[LRU_INACTIVE_FILE];
5125         pagecache -= min(pagecache / 2, wmark_low);
5126         available += pagecache;
5127
5128         /*
5129          * Part of the reclaimable slab and other kernel memory consists of
5130          * items that are in use, and cannot be freed. Cap this estimate at the
5131          * low watermark.
5132          */
5133         reclaimable = global_node_page_state(NR_SLAB_RECLAIMABLE) +
5134                         global_node_page_state(NR_KERNEL_MISC_RECLAIMABLE);
5135         available += reclaimable - min(reclaimable / 2, wmark_low);
5136
5137         if (available < 0)
5138                 available = 0;
5139         return available;
5140 }
5141 EXPORT_SYMBOL_GPL(si_mem_available);
5142
5143 void si_meminfo(struct sysinfo *val)
5144 {
5145         val->totalram = totalram_pages();
5146         val->sharedram = global_node_page_state(NR_SHMEM);
5147         val->freeram = global_zone_page_state(NR_FREE_PAGES);
5148         val->bufferram = nr_blockdev_pages();
5149         val->totalhigh = totalhigh_pages();
5150         val->freehigh = nr_free_highpages();
5151         val->mem_unit = PAGE_SIZE;
5152 }
5153
5154 EXPORT_SYMBOL(si_meminfo);
5155
5156 #ifdef CONFIG_NUMA
5157 void si_meminfo_node(struct sysinfo *val, int nid)
5158 {
5159         int zone_type;          /* needs to be signed */
5160         unsigned long managed_pages = 0;
5161         unsigned long managed_highpages = 0;
5162         unsigned long free_highpages = 0;
5163         pg_data_t *pgdat = NODE_DATA(nid);
5164
5165         for (zone_type = 0; zone_type < MAX_NR_ZONES; zone_type++)
5166                 managed_pages += zone_managed_pages(&pgdat->node_zones[zone_type]);
5167         val->totalram = managed_pages;
5168         val->sharedram = node_page_state(pgdat, NR_SHMEM);
5169         val->freeram = sum_zone_node_page_state(nid, NR_FREE_PAGES);
5170 #ifdef CONFIG_HIGHMEM
5171         for (zone_type = 0; zone_type < MAX_NR_ZONES; zone_type++) {
5172                 struct zone *zone = &pgdat->node_zones[zone_type];
5173
5174                 if (is_highmem(zone)) {
5175                         managed_highpages += zone_managed_pages(zone);
5176                         free_highpages += zone_page_state(zone, NR_FREE_PAGES);
5177                 }
5178         }
5179         val->totalhigh = managed_highpages;
5180         val->freehigh = free_highpages;
5181 #else
5182         val->totalhigh = managed_highpages;
5183         val->freehigh = free_highpages;
5184 #endif
5185         val->mem_unit = PAGE_SIZE;
5186 }
5187 #endif
5188
5189 /*
5190  * Determine whether the node should be displayed or not, depending on whether
5191  * SHOW_MEM_FILTER_NODES was passed to show_free_areas().
5192  */
5193 static bool show_mem_node_skip(unsigned int flags, int nid, nodemask_t *nodemask)
5194 {
5195         if (!(flags & SHOW_MEM_FILTER_NODES))
5196                 return false;
5197
5198         /*
5199          * no node mask - aka implicit memory numa policy. Do not bother with
5200          * the synchronization - read_mems_allowed_begin - because we do not
5201          * have to be precise here.
5202          */
5203         if (!nodemask)
5204                 nodemask = &cpuset_current_mems_allowed;
5205
5206         return !node_isset(nid, *nodemask);
5207 }
5208
5209 #define K(x) ((x) << (PAGE_SHIFT-10))
5210
5211 static void show_migration_types(unsigned char type)
5212 {
5213         static const char types[MIGRATE_TYPES] = {
5214                 [MIGRATE_UNMOVABLE]     = 'U',
5215                 [MIGRATE_MOVABLE]       = 'M',
5216                 [MIGRATE_RECLAIMABLE]   = 'E',
5217                 [MIGRATE_HIGHATOMIC]    = 'H',
5218 #ifdef CONFIG_CMA
5219                 [MIGRATE_CMA]           = 'C',
5220 #endif
5221 #ifdef CONFIG_MEMORY_ISOLATION
5222                 [MIGRATE_ISOLATE]       = 'I',
5223 #endif
5224         };
5225         char tmp[MIGRATE_TYPES + 1];
5226         char *p = tmp;
5227         int i;
5228
5229         for (i = 0; i < MIGRATE_TYPES; i++) {
5230                 if (type & (1 << i))
5231                         *p++ = types[i];
5232         }
5233
5234         *p = '\0';
5235         printk(KERN_CONT "(%s) ", tmp);
5236 }
5237
5238 /*
5239  * Show free area list (used inside shift_scroll-lock stuff)
5240  * We also calculate the percentage fragmentation. We do this by counting the
5241  * memory on each free list with the exception of the first item on the list.
5242  *
5243  * Bits in @filter:
5244  * SHOW_MEM_FILTER_NODES: suppress nodes that are not allowed by current's
5245  *   cpuset.
5246  */
5247 void show_free_areas(unsigned int filter, nodemask_t *nodemask)
5248 {
5249         unsigned long free_pcp = 0;
5250         int cpu;
5251         struct zone *zone;
5252         pg_data_t *pgdat;
5253
5254         for_each_populated_zone(zone) {
5255                 if (show_mem_node_skip(filter, zone_to_nid(zone), nodemask))
5256                         continue;
5257
5258                 for_each_online_cpu(cpu)
5259                         free_pcp += per_cpu_ptr(zone->pageset, cpu)->pcp.count;
5260         }
5261
5262         printk("active_anon:%lu inactive_anon:%lu isolated_anon:%lu\n"
5263                 " active_file:%lu inactive_file:%lu isolated_file:%lu\n"
5264                 " unevictable:%lu dirty:%lu writeback:%lu unstable:%lu\n"
5265                 " slab_reclaimable:%lu slab_unreclaimable:%lu\n"
5266                 " mapped:%lu shmem:%lu pagetables:%lu bounce:%lu\n"
5267                 " free:%lu free_pcp:%lu free_cma:%lu\n",
5268                 global_node_page_state(NR_ACTIVE_ANON),
5269                 global_node_page_state(NR_INACTIVE_ANON),
5270                 global_node_page_state(NR_ISOLATED_ANON),
5271                 global_node_page_state(NR_ACTIVE_FILE),
5272                 global_node_page_state(NR_INACTIVE_FILE),
5273                 global_node_page_state(NR_ISOLATED_FILE),
5274                 global_node_page_state(NR_UNEVICTABLE),
5275                 global_node_page_state(NR_FILE_DIRTY),
5276                 global_node_page_state(NR_WRITEBACK),
5277                 global_node_page_state(NR_UNSTABLE_NFS),
5278                 global_node_page_state(NR_SLAB_RECLAIMABLE),
5279                 global_node_page_state(NR_SLAB_UNRECLAIMABLE),
5280                 global_node_page_state(NR_FILE_MAPPED),
5281                 global_node_page_state(NR_SHMEM),
5282                 global_zone_page_state(NR_PAGETABLE),
5283                 global_zone_page_state(NR_BOUNCE),
5284                 global_zone_page_state(NR_FREE_PAGES),
5285                 free_pcp,
5286                 global_zone_page_state(NR_FREE_CMA_PAGES));
5287
5288         for_each_online_pgdat(pgdat) {
5289                 if (show_mem_node_skip(filter, pgdat->node_id, nodemask))
5290                         continue;
5291
5292                 printk("Node %d"
5293                         " active_anon:%lukB"
5294                         " inactive_anon:%lukB"
5295                         " active_file:%lukB"
5296                         " inactive_file:%lukB"
5297                         " unevictable:%lukB"
5298                         " isolated(anon):%lukB"
5299                         " isolated(file):%lukB"
5300                         " mapped:%lukB"
5301                         " dirty:%lukB"
5302                         " writeback:%lukB"
5303                         " shmem:%lukB"
5304 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
5305                         " shmem_thp: %lukB"
5306                         " shmem_pmdmapped: %lukB"
5307                         " anon_thp: %lukB"
5308 #endif
5309                         " writeback_tmp:%lukB"
5310                         " unstable:%lukB"
5311                         " all_unreclaimable? %s"
5312                         "\n",
5313                         pgdat->node_id,
5314                         K(node_page_state(pgdat, NR_ACTIVE_ANON)),
5315                         K(node_page_state(pgdat, NR_INACTIVE_ANON)),
5316                         K(node_page_state(pgdat, NR_ACTIVE_FILE)),
5317                         K(node_page_state(pgdat, NR_INACTIVE_FILE)),
5318                         K(node_page_state(pgdat, NR_UNEVICTABLE)),
5319                         K(node_page_state(pgdat, NR_ISOLATED_ANON)),
5320                         K(node_page_state(pgdat, NR_ISOLATED_FILE)),
5321                         K(node_page_state(pgdat, NR_FILE_MAPPED)),
5322                         K(node_page_state(pgdat, NR_FILE_DIRTY)),
5323                         K(node_page_state(pgdat, NR_WRITEBACK)),
5324                         K(node_page_state(pgdat, NR_SHMEM)),
5325 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
5326                         K(node_page_state(pgdat, NR_SHMEM_THPS) * HPAGE_PMD_NR),
5327                         K(node_page_state(pgdat, NR_SHMEM_PMDMAPPED)
5328                                         * HPAGE_PMD_NR),
5329                         K(node_page_state(pgdat, NR_ANON_THPS) * HPAGE_PMD_NR),
5330 #endif
5331                         K(node_page_state(pgdat, NR_WRITEBACK_TEMP)),
5332                         K(node_page_state(pgdat, NR_UNSTABLE_NFS)),
5333                         pgdat->kswapd_failures >= MAX_RECLAIM_RETRIES ?
5334                                 "yes" : "no");
5335         }
5336
5337         for_each_populated_zone(zone) {
5338                 int i;
5339
5340                 if (show_mem_node_skip(filter, zone_to_nid(zone), nodemask))
5341                         continue;
5342
5343                 free_pcp = 0;
5344                 for_each_online_cpu(cpu)
5345                         free_pcp += per_cpu_ptr(zone->pageset, cpu)->pcp.count;
5346
5347                 show_node(zone);
5348                 printk(KERN_CONT
5349                         "%s"
5350                         " free:%lukB"
5351                         " min:%lukB"
5352                         " low:%lukB"
5353                         " high:%lukB"
5354                         " active_anon:%lukB"
5355                         " inactive_anon:%lukB"
5356                         " active_file:%lukB"
5357                         " inactive_file:%lukB"
5358                         " unevictable:%lukB"
5359                         " writepending:%lukB"
5360                         " present:%lukB"
5361                         " managed:%lukB"
5362                         " mlocked:%lukB"
5363                         " kernel_stack:%lukB"
5364                         " pagetables:%lukB"
5365                         " bounce:%lukB"
5366                         " free_pcp:%lukB"
5367                         " local_pcp:%ukB"
5368                         " free_cma:%lukB"
5369                         "\n",
5370                         zone->name,
5371                         K(zone_page_state(zone, NR_FREE_PAGES)),
5372                         K(min_wmark_pages(zone)),
5373                         K(low_wmark_pages(zone)),
5374                         K(high_wmark_pages(zone)),
5375                         K(zone_page_state(zone, NR_ZONE_ACTIVE_ANON)),
5376                         K(zone_page_state(zone, NR_ZONE_INACTIVE_ANON)),
5377                         K(zone_page_state(zone, NR_ZONE_ACTIVE_FILE)),
5378                         K(zone_page_state(zone, NR_ZONE_INACTIVE_FILE)),
5379                         K(zone_page_state(zone, NR_ZONE_UNEVICTABLE)),
5380                         K(zone_page_state(zone, NR_ZONE_WRITE_PENDING)),
5381                         K(zone->present_pages),
5382                         K(zone_managed_pages(zone)),
5383                         K(zone_page_state(zone, NR_MLOCK)),
5384                         zone_page_state(zone, NR_KERNEL_STACK_KB),
5385                         K(zone_page_state(zone, NR_PAGETABLE)),
5386                         K(zone_page_state(zone, NR_BOUNCE)),
5387                         K(free_pcp),
5388                         K(this_cpu_read(zone->pageset->pcp.count)),
5389                         K(zone_page_state(zone, NR_FREE_CMA_PAGES)));
5390                 printk("lowmem_reserve[]:");
5391                 for (i = 0; i < MAX_NR_ZONES; i++)
5392                         printk(KERN_CONT " %ld", zone->lowmem_reserve[i]);
5393                 printk(KERN_CONT "\n");
5394         }
5395
5396         for_each_populated_zone(zone) {
5397                 unsigned int order;
5398                 unsigned long nr[MAX_ORDER], flags, total = 0;
5399                 unsigned char types[MAX_ORDER];
5400
5401                 if (show_mem_node_skip(filter, zone_to_nid(zone), nodemask))
5402                         continue;
5403                 show_node(zone);
5404                 printk(KERN_CONT "%s: ", zone->name);
5405
5406                 spin_lock_irqsave(&zone->lock, flags);
5407                 for (order = 0; order < MAX_ORDER; order++) {
5408                         struct free_area *area = &zone->free_area[order];
5409                         int type;
5410
5411                         nr[order] = area->nr_free;
5412                         total += nr[order] << order;
5413
5414                         types[order] = 0;
5415                         for (type = 0; type < MIGRATE_TYPES; type++) {
5416                                 if (!free_area_empty(area, type))
5417                                         types[order] |= 1 << type;
5418                         }
5419                 }
5420                 spin_unlock_irqrestore(&zone->lock, flags);
5421                 for (order = 0; order < MAX_ORDER; order++) {
5422                         printk(KERN_CONT "%lu*%lukB ",
5423                                nr[order], K(1UL) << order);
5424                         if (nr[order])
5425                                 show_migration_types(types[order]);
5426                 }
5427                 printk(KERN_CONT "= %lukB\n", K(total));
5428         }
5429
5430         hugetlb_show_meminfo();
5431
5432         printk("%ld total pagecache pages\n", global_node_page_state(NR_FILE_PAGES));
5433
5434         show_swap_cache_info();
5435 }
5436
5437 static void zoneref_set_zone(struct zone *zone, struct zoneref *zoneref)
5438 {
5439         zoneref->zone = zone;
5440         zoneref->zone_idx = zone_idx(zone);
5441 }
5442
5443 /*
5444  * Builds allocation fallback zone lists.
5445  *
5446  * Add all populated zones of a node to the zonelist.
5447  */
5448 static int build_zonerefs_node(pg_data_t *pgdat, struct zoneref *zonerefs)
5449 {
5450         struct zone *zone;
5451         enum zone_type zone_type = MAX_NR_ZONES;
5452         int nr_zones = 0;
5453
5454         do {
5455                 zone_type--;
5456                 zone = pgdat->node_zones + zone_type;
5457                 if (managed_zone(zone)) {
5458                         zoneref_set_zone(zone, &zonerefs[nr_zones++]);
5459                         check_highest_zone(zone_type);
5460                 }
5461         } while (zone_type);
5462
5463         return nr_zones;
5464 }
5465
5466 #ifdef CONFIG_NUMA
5467
5468 static int __parse_numa_zonelist_order(char *s)
5469 {
5470         /*
5471          * We used to support different zonlists modes but they turned
5472          * out to be just not useful. Let's keep the warning in place
5473          * if somebody still use the cmd line parameter so that we do
5474          * not fail it silently
5475          */
5476         if (!(*s == 'd' || *s == 'D' || *s == 'n' || *s == 'N')) {
5477                 pr_warn("Ignoring unsupported numa_zonelist_order value:  %s\n", s);
5478                 return -EINVAL;
5479         }
5480         return 0;
5481 }
5482
5483 static __init int setup_numa_zonelist_order(char *s)
5484 {
5485         if (!s)
5486                 return 0;
5487
5488         return __parse_numa_zonelist_order(s);
5489 }
5490 early_param("numa_zonelist_order", setup_numa_zonelist_order);
5491
5492 char numa_zonelist_order[] = "Node";
5493
5494 /*
5495  * sysctl handler for numa_zonelist_order
5496  */
5497 int numa_zonelist_order_handler(struct ctl_table *table, int write,
5498                 void __user *buffer, size_t *length,
5499                 loff_t *ppos)
5500 {
5501         char *str;
5502         int ret;
5503
5504         if (!write)
5505                 return proc_dostring(table, write, buffer, length, ppos);
5506         str = memdup_user_nul(buffer, 16);
5507         if (IS_ERR(str))
5508                 return PTR_ERR(str);
5509
5510         ret = __parse_numa_zonelist_order(str);
5511         kfree(str);
5512         return ret;
5513 }
5514
5515
5516 #define MAX_NODE_LOAD (nr_online_nodes)
5517 static int node_load[MAX_NUMNODES];
5518
5519 /**
5520  * find_next_best_node - find the next node that should appear in a given node's fallback list
5521  * @node: node whose fallback list we're appending
5522  * @used_node_mask: nodemask_t of already used nodes
5523  *
5524  * We use a number of factors to determine which is the next node that should
5525  * appear on a given node's fallback list.  The node should not have appeared
5526  * already in @node's fallback list, and it should be the next closest node
5527  * according to the distance array (which contains arbitrary distance values
5528  * from each node to each node in the system), and should also prefer nodes
5529  * with no CPUs, since presumably they'll have very little allocation pressure
5530  * on them otherwise.
5531  *
5532  * Return: node id of the found node or %NUMA_NO_NODE if no node is found.
5533  */
5534 static int find_next_best_node(int node, nodemask_t *used_node_mask)
5535 {
5536         int n, val;
5537         int min_val = INT_MAX;
5538         int best_node = NUMA_NO_NODE;
5539         const struct cpumask *tmp = cpumask_of_node(0);
5540
5541         /* Use the local node if we haven't already */
5542         if (!node_isset(node, *used_node_mask)) {
5543                 node_set(node, *used_node_mask);
5544                 return node;
5545         }
5546
5547         for_each_node_state(n, N_MEMORY) {
5548
5549                 /* Don't want a node to appear more than once */
5550                 if (node_isset(n, *used_node_mask))
5551                         continue;
5552
5553                 /* Use the distance array to find the distance */
5554                 val = node_distance(node, n);
5555
5556                 /* Penalize nodes under us ("prefer the next node") */
5557                 val += (n < node);
5558
5559                 /* Give preference to headless and unused nodes */
5560                 tmp = cpumask_of_node(n);
5561                 if (!cpumask_empty(tmp))
5562                         val += PENALTY_FOR_NODE_WITH_CPUS;
5563
5564                 /* Slight preference for less loaded node */
5565                 val *= (MAX_NODE_LOAD*MAX_NUMNODES);
5566                 val += node_load[n];
5567
5568                 if (val < min_val) {
5569                         min_val = val;
5570                         best_node = n;
5571                 }
5572         }
5573
5574         if (best_node >= 0)
5575                 node_set(best_node, *used_node_mask);
5576
5577         return best_node;
5578 }
5579
5580
5581 /*
5582  * Build zonelists ordered by node and zones within node.
5583  * This results in maximum locality--normal zone overflows into local
5584  * DMA zone, if any--but risks exhausting DMA zone.
5585  */
5586 static void build_zonelists_in_node_order(pg_data_t *pgdat, int *node_order,
5587                 unsigned nr_nodes)
5588 {
5589         struct zoneref *zonerefs;
5590         int i;
5591
5592         zonerefs = pgdat->node_zonelists[ZONELIST_FALLBACK]._zonerefs;
5593
5594         for (i = 0; i < nr_nodes; i++) {
5595                 int nr_zones;
5596
5597                 pg_data_t *node = NODE_DATA(node_order[i]);
5598
5599                 nr_zones = build_zonerefs_node(node, zonerefs);
5600                 zonerefs += nr_zones;
5601         }
5602         zonerefs->zone = NULL;
5603         zonerefs->zone_idx = 0;
5604 }
5605
5606 /*
5607  * Build gfp_thisnode zonelists
5608  */
5609 static void build_thisnode_zonelists(pg_data_t *pgdat)
5610 {
5611         struct zoneref *zonerefs;
5612         int nr_zones;
5613
5614         zonerefs = pgdat->node_zonelists[ZONELIST_NOFALLBACK]._zonerefs;
5615         nr_zones = build_zonerefs_node(pgdat, zonerefs);
5616         zonerefs += nr_zones;
5617         zonerefs->zone = NULL;
5618         zonerefs->zone_idx = 0;
5619 }
5620
5621 /*
5622  * Build zonelists ordered by zone and nodes within zones.
5623  * This results in conserving DMA zone[s] until all Normal memory is
5624  * exhausted, but results in overflowing to remote node while memory
5625  * may still exist in local DMA zone.
5626  */
5627
5628 static void build_zonelists(pg_data_t *pgdat)
5629 {
5630         static int node_order[MAX_NUMNODES];
5631         int node, load, nr_nodes = 0;
5632         nodemask_t used_mask;
5633         int local_node, prev_node;
5634
5635         /* NUMA-aware ordering of nodes */
5636         local_node = pgdat->node_id;
5637         load = nr_online_nodes;
5638         prev_node = local_node;
5639         nodes_clear(used_mask);
5640
5641         memset(node_order, 0, sizeof(node_order));
5642         while ((node = find_next_best_node(local_node, &used_mask)) >= 0) {
5643                 /*
5644                  * We don't want to pressure a particular node.
5645                  * So adding penalty to the first node in same
5646                  * distance group to make it round-robin.
5647                  */
5648                 if (node_distance(local_node, node) !=
5649                     node_distance(local_node, prev_node))
5650                         node_load[node] = load;
5651
5652                 node_order[nr_nodes++] = node;
5653                 prev_node = node;
5654                 load--;
5655         }
5656
5657         build_zonelists_in_node_order(pgdat, node_order, nr_nodes);
5658         build_thisnode_zonelists(pgdat);
5659 }
5660
5661 #ifdef CONFIG_HAVE_MEMORYLESS_NODES
5662 /*
5663  * Return node id of node used for "local" allocations.
5664  * I.e., first node id of first zone in arg node's generic zonelist.
5665  * Used for initializing percpu 'numa_mem', which is used primarily
5666  * for kernel allocations, so use GFP_KERNEL flags to locate zonelist.
5667  */
5668 int local_memory_node(int node)
5669 {
5670         struct zoneref *z;
5671
5672         z = first_zones_zonelist(node_zonelist(node, GFP_KERNEL),
5673                                    gfp_zone(GFP_KERNEL),
5674                                    NULL);
5675         return zone_to_nid(z->zone);
5676 }
5677 #endif
5678
5679 static void setup_min_unmapped_ratio(void);
5680 static void setup_min_slab_ratio(void);
5681 #else   /* CONFIG_NUMA */
5682
5683 static void build_zonelists(pg_data_t *pgdat)
5684 {
5685         int node, local_node;
5686         struct zoneref *zonerefs;
5687         int nr_zones;
5688
5689         local_node = pgdat->node_id;
5690
5691         zonerefs = pgdat->node_zonelists[ZONELIST_FALLBACK]._zonerefs;
5692         nr_zones = build_zonerefs_node(pgdat, zonerefs);
5693         zonerefs += nr_zones;
5694
5695         /*
5696          * Now we build the zonelist so that it contains the zones
5697          * of all the other nodes.
5698          * We don't want to pressure a particular node, so when
5699          * building the zones for node N, we make sure that the
5700          * zones coming right after the local ones are those from
5701          * node N+1 (modulo N)
5702          */
5703         for (node = local_node + 1; node < MAX_NUMNODES; node++) {
5704                 if (!node_online(node))
5705                         continue;
5706                 nr_zones = build_zonerefs_node(NODE_DATA(node), zonerefs);
5707                 zonerefs += nr_zones;
5708         }
5709         for (node = 0; node < local_node; node++) {
5710                 if (!node_online(node))
5711                         continue;
5712                 nr_zones = build_zonerefs_node(NODE_DATA(node), zonerefs);
5713                 zonerefs += nr_zones;
5714         }
5715
5716         zonerefs->zone = NULL;
5717         zonerefs->zone_idx = 0;
5718 }
5719
5720 #endif  /* CONFIG_NUMA */
5721
5722 /*
5723  * Boot pageset table. One per cpu which is going to be used for all
5724  * zones and all nodes. The parameters will be set in such a way
5725  * that an item put on a list will immediately be handed over to
5726  * the buddy list. This is safe since pageset manipulation is done
5727  * with interrupts disabled.
5728  *
5729  * The boot_pagesets must be kept even after bootup is complete for
5730  * unused processors and/or zones. They do play a role for bootstrapping
5731  * hotplugged processors.
5732  *
5733  * zoneinfo_show() and maybe other functions do
5734  * not check if the processor is online before following the pageset pointer.
5735  * Other parts of the kernel may not check if the zone is available.
5736  */
5737 static void setup_pageset(struct per_cpu_pageset *p, unsigned long batch);
5738 static DEFINE_PER_CPU(struct per_cpu_pageset, boot_pageset);
5739 static DEFINE_PER_CPU(struct per_cpu_nodestat, boot_nodestats);
5740
5741 static void __build_all_zonelists(void *data)
5742 {
5743         int nid;
5744         int __maybe_unused cpu;
5745         pg_data_t *self = data;
5746         static DEFINE_SPINLOCK(lock);
5747
5748         spin_lock(&lock);
5749
5750 #ifdef CONFIG_NUMA
5751         memset(node_load, 0, sizeof(node_load));
5752 #endif
5753
5754         /*
5755          * This node is hotadded and no memory is yet present.   So just
5756          * building zonelists is fine - no need to touch other nodes.
5757          */
5758         if (self && !node_online(self->node_id)) {
5759                 build_zonelists(self);
5760         } else {
5761                 for_each_online_node(nid) {
5762                         pg_data_t *pgdat = NODE_DATA(nid);
5763
5764                         build_zonelists(pgdat);
5765                 }
5766
5767 #ifdef CONFIG_HAVE_MEMORYLESS_NODES
5768                 /*
5769                  * We now know the "local memory node" for each node--
5770                  * i.e., the node of the first zone in the generic zonelist.
5771                  * Set up numa_mem percpu variable for on-line cpus.  During
5772                  * boot, only the boot cpu should be on-line;  we'll init the
5773                  * secondary cpus' numa_mem as they come on-line.  During
5774                  * node/memory hotplug, we'll fixup all on-line cpus.
5775                  */
5776                 for_each_online_cpu(cpu)
5777                         set_cpu_numa_mem(cpu, local_memory_node(cpu_to_node(cpu)));
5778 #endif
5779         }
5780
5781         spin_unlock(&lock);
5782 }
5783
5784 static noinline void __init
5785 build_all_zonelists_init(void)
5786 {
5787         int cpu;
5788
5789         __build_all_zonelists(NULL);
5790
5791         /*
5792          * Initialize the boot_pagesets that are going to be used
5793          * for bootstrapping processors. The real pagesets for
5794          * each zone will be allocated later when the per cpu
5795          * allocator is available.
5796          *
5797          * boot_pagesets are used also for bootstrapping offline
5798          * cpus if the system is already booted because the pagesets
5799          * are needed to initialize allocators on a specific cpu too.
5800          * F.e. the percpu allocator needs the page allocator which
5801          * needs the percpu allocator in order to allocate its pagesets
5802          * (a chicken-egg dilemma).
5803          */
5804         for_each_possible_cpu(cpu)
5805                 setup_pageset(&per_cpu(boot_pageset, cpu), 0);
5806
5807         mminit_verify_zonelist();
5808         cpuset_init_current_mems_allowed();
5809 }
5810
5811 /*
5812  * unless system_state == SYSTEM_BOOTING.
5813  *
5814  * __ref due to call of __init annotated helper build_all_zonelists_init
5815  * [protected by SYSTEM_BOOTING].
5816  */
5817 void __ref build_all_zonelists(pg_data_t *pgdat)
5818 {
5819         if (system_state == SYSTEM_BOOTING) {
5820                 build_all_zonelists_init();
5821         } else {
5822                 __build_all_zonelists(pgdat);
5823                 /* cpuset refresh routine should be here */
5824         }
5825         vm_total_pages = nr_free_pagecache_pages();
5826         /*
5827          * Disable grouping by mobility if the number of pages in the
5828          * system is too low to allow the mechanism to work. It would be
5829          * more accurate, but expensive to check per-zone. This check is
5830          * made on memory-hotadd so a system can start with mobility
5831          * disabled and enable it later
5832          */
5833         if (vm_total_pages < (pageblock_nr_pages * MIGRATE_TYPES))
5834                 page_group_by_mobility_disabled = 1;
5835         else
5836                 page_group_by_mobility_disabled = 0;
5837
5838         pr_info("Built %u zonelists, mobility grouping %s.  Total pages: %ld\n",
5839                 nr_online_nodes,
5840                 page_group_by_mobility_disabled ? "off" : "on",
5841                 vm_total_pages);
5842 #ifdef CONFIG_NUMA
5843         pr_info("Policy zone: %s\n", zone_names[policy_zone]);
5844 #endif
5845 }
5846
5847 /* If zone is ZONE_MOVABLE but memory is mirrored, it is an overlapped init */
5848 static bool __meminit
5849 overlap_memmap_init(unsigned long zone, unsigned long *pfn)
5850 {
5851 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
5852         static struct memblock_region *r;
5853
5854         if (mirrored_kernelcore && zone == ZONE_MOVABLE) {
5855                 if (!r || *pfn >= memblock_region_memory_end_pfn(r)) {
5856                         for_each_memblock(memory, r) {
5857                                 if (*pfn < memblock_region_memory_end_pfn(r))
5858                                         break;
5859                         }
5860                 }
5861                 if (*pfn >= memblock_region_memory_base_pfn(r) &&
5862                     memblock_is_mirror(r)) {
5863                         *pfn = memblock_region_memory_end_pfn(r);
5864                         return true;
5865                 }
5866         }
5867 #endif
5868         return false;
5869 }
5870
5871 /*
5872  * Initially all pages are reserved - free ones are freed
5873  * up by memblock_free_all() once the early boot process is
5874  * done. Non-atomic initialization, single-pass.
5875  */
5876 void __meminit memmap_init_zone(unsigned long size, int nid, unsigned long zone,
5877                 unsigned long start_pfn, enum memmap_context context,
5878                 struct vmem_altmap *altmap)
5879 {
5880         unsigned long pfn, end_pfn = start_pfn + size;
5881         struct page *page;
5882
5883         if (highest_memmap_pfn < end_pfn - 1)
5884                 highest_memmap_pfn = end_pfn - 1;
5885
5886 #ifdef CONFIG_ZONE_DEVICE
5887         /*
5888          * Honor reservation requested by the driver for this ZONE_DEVICE
5889          * memory. We limit the total number of pages to initialize to just
5890          * those that might contain the memory mapping. We will defer the
5891          * ZONE_DEVICE page initialization until after we have released
5892          * the hotplug lock.
5893          */
5894         if (zone == ZONE_DEVICE) {
5895                 if (!altmap)
5896                         return;
5897
5898                 if (start_pfn == altmap->base_pfn)
5899                         start_pfn += altmap->reserve;
5900                 end_pfn = altmap->base_pfn + vmem_altmap_offset(altmap);
5901         }
5902 #endif
5903
5904         for (pfn = start_pfn; pfn < end_pfn; pfn++) {
5905                 /*
5906                  * There can be holes in boot-time mem_map[]s handed to this
5907                  * function.  They do not exist on hotplugged memory.
5908                  */
5909                 if (context == MEMMAP_EARLY) {
5910                         if (!early_pfn_valid(pfn))
5911                                 continue;
5912                         if (!early_pfn_in_nid(pfn, nid))
5913                                 continue;
5914                         if (overlap_memmap_init(zone, &pfn))
5915                                 continue;
5916                         if (defer_init(nid, pfn, end_pfn))
5917                                 break;
5918                 }
5919
5920                 page = pfn_to_page(pfn);
5921                 __init_single_page(page, pfn, zone, nid);
5922                 if (context == MEMMAP_HOTPLUG)
5923                         __SetPageReserved(page);
5924
5925                 /*
5926                  * Mark the block movable so that blocks are reserved for
5927                  * movable at startup. This will force kernel allocations
5928                  * to reserve their blocks rather than leaking throughout
5929                  * the address space during boot when many long-lived
5930                  * kernel allocations are made.
5931                  *
5932                  * bitmap is created for zone's valid pfn range. but memmap
5933                  * can be created for invalid pages (for alignment)
5934                  * check here not to call set_pageblock_migratetype() against
5935                  * pfn out of zone.
5936                  */
5937                 if (!(pfn & (pageblock_nr_pages - 1))) {
5938                         set_pageblock_migratetype(page, MIGRATE_MOVABLE);
5939                         cond_resched();
5940                 }
5941         }
5942 }
5943
5944 #ifdef CONFIG_ZONE_DEVICE
5945 void __ref memmap_init_zone_device(struct zone *zone,
5946                                    unsigned long start_pfn,
5947                                    unsigned long size,
5948                                    struct dev_pagemap *pgmap)
5949 {
5950         unsigned long pfn, end_pfn = start_pfn + size;
5951         struct pglist_data *pgdat = zone->zone_pgdat;
5952         struct vmem_altmap *altmap = pgmap_altmap(pgmap);
5953         unsigned long zone_idx = zone_idx(zone);
5954         unsigned long start = jiffies;
5955         int nid = pgdat->node_id;
5956
5957         if (WARN_ON_ONCE(!pgmap || zone_idx(zone) != ZONE_DEVICE))
5958                 return;
5959
5960         /*
5961          * The call to memmap_init_zone should have already taken care
5962          * of the pages reserved for the memmap, so we can just jump to
5963          * the end of that region and start processing the device pages.
5964          */
5965         if (altmap) {
5966                 start_pfn = altmap->base_pfn + vmem_altmap_offset(altmap);
5967                 size = end_pfn - start_pfn;
5968         }
5969
5970         for (pfn = start_pfn; pfn < end_pfn; pfn++) {
5971                 struct page *page = pfn_to_page(pfn);
5972
5973                 __init_single_page(page, pfn, zone_idx, nid);
5974
5975                 /*
5976                  * Mark page reserved as it will need to wait for onlining
5977                  * phase for it to be fully associated with a zone.
5978                  *
5979                  * We can use the non-atomic __set_bit operation for setting
5980                  * the flag as we are still initializing the pages.
5981                  */
5982                 __SetPageReserved(page);
5983
5984                 /*
5985                  * ZONE_DEVICE pages union ->lru with a ->pgmap back pointer
5986                  * and zone_device_data.  It is a bug if a ZONE_DEVICE page is
5987                  * ever freed or placed on a driver-private list.
5988                  */
5989                 page->pgmap = pgmap;
5990                 page->zone_device_data = NULL;
5991
5992                 /*
5993                  * Mark the block movable so that blocks are reserved for
5994                  * movable at startup. This will force kernel allocations
5995                  * to reserve their blocks rather than leaking throughout
5996                  * the address space during boot when many long-lived
5997                  * kernel allocations are made.
5998                  *
5999                  * bitmap is created for zone's valid pfn range. but memmap
6000                  * can be created for invalid pages (for alignment)
6001                  * check here not to call set_pageblock_migratetype() against
6002                  * pfn out of zone.
6003                  *
6004                  * Please note that MEMMAP_HOTPLUG path doesn't clear memmap
6005                  * because this is done early in section_activate()
6006                  */
6007                 if (!(pfn & (pageblock_nr_pages - 1))) {
6008                         set_pageblock_migratetype(page, MIGRATE_MOVABLE);
6009                         cond_resched();
6010                 }
6011         }
6012
6013         pr_info("%s initialised %lu pages in %ums\n", __func__,
6014                 size, jiffies_to_msecs(jiffies - start));
6015 }
6016
6017 #endif
6018 static void __meminit zone_init_free_lists(struct zone *zone)
6019 {
6020         unsigned int order, t;
6021         for_each_migratetype_order(order, t) {
6022                 INIT_LIST_HEAD(&zone->free_area[order].free_list[t]);
6023                 zone->free_area[order].nr_free = 0;
6024         }
6025 }
6026
6027 void __meminit __weak memmap_init(unsigned long size, int nid,
6028                                   unsigned long zone, unsigned long start_pfn)
6029 {
6030         memmap_init_zone(size, nid, zone, start_pfn, MEMMAP_EARLY, NULL);
6031 }
6032
6033 static int zone_batchsize(struct zone *zone)
6034 {
6035 #ifdef CONFIG_MMU
6036         int batch;
6037
6038         /*
6039          * The per-cpu-pages pools are set to around 1000th of the
6040          * size of the zone.
6041          */
6042         batch = zone_managed_pages(zone) / 1024;
6043         /* But no more than a meg. */
6044         if (batch * PAGE_SIZE > 1024 * 1024)
6045                 batch = (1024 * 1024) / PAGE_SIZE;
6046         batch /= 4;             /* We effectively *= 4 below */
6047         if (batch < 1)
6048                 batch = 1;
6049
6050         /*
6051          * Clamp the batch to a 2^n - 1 value. Having a power
6052          * of 2 value was found to be more likely to have
6053          * suboptimal cache aliasing properties in some cases.
6054          *
6055          * For example if 2 tasks are alternately allocating
6056          * batches of pages, one task can end up with a lot
6057          * of pages of one half of the possible page colors
6058          * and the other with pages of the other colors.
6059          */
6060         batch = rounddown_pow_of_two(batch + batch/2) - 1;
6061
6062         return batch;
6063
6064 #else
6065         /* The deferral and batching of frees should be suppressed under NOMMU
6066          * conditions.
6067          *
6068          * The problem is that NOMMU needs to be able to allocate large chunks
6069          * of contiguous memory as there's no hardware page translation to
6070          * assemble apparent contiguous memory from discontiguous pages.
6071          *
6072          * Queueing large contiguous runs of pages for batching, however,
6073          * causes the pages to actually be freed in smaller chunks.  As there
6074          * can be a significant delay between the individual batches being
6075          * recycled, this leads to the once large chunks of space being
6076          * fragmented and becoming unavailable for high-order allocations.
6077          */
6078         return 0;
6079 #endif
6080 }
6081
6082 /*
6083  * pcp->high and pcp->batch values are related and dependent on one another:
6084  * ->batch must never be higher then ->high.
6085  * The following function updates them in a safe manner without read side
6086  * locking.
6087  *
6088  * Any new users of pcp->batch and pcp->high should ensure they can cope with
6089  * those fields changing asynchronously (acording the the above rule).
6090  *
6091  * mutex_is_locked(&pcp_batch_high_lock) required when calling this function
6092  * outside of boot time (or some other assurance that no concurrent updaters
6093  * exist).
6094  */
6095 static void pageset_update(struct per_cpu_pages *pcp, unsigned long high,
6096                 unsigned long batch)
6097 {
6098        /* start with a fail safe value for batch */
6099         pcp->batch = 1;
6100         smp_wmb();
6101
6102        /* Update high, then batch, in order */
6103         pcp->high = high;
6104         smp_wmb();
6105
6106         pcp->batch = batch;
6107 }
6108
6109 /* a companion to pageset_set_high() */
6110 static void pageset_set_batch(struct per_cpu_pageset *p, unsigned long batch)
6111 {
6112         pageset_update(&p->pcp, 6 * batch, max(1UL, 1 * batch));
6113 }
6114
6115 static void pageset_init(struct per_cpu_pageset *p)
6116 {
6117         struct per_cpu_pages *pcp;
6118         int migratetype;
6119
6120         memset(p, 0, sizeof(*p));
6121
6122         pcp = &p->pcp;
6123         for (migratetype = 0; migratetype < MIGRATE_PCPTYPES; migratetype++)
6124                 INIT_LIST_HEAD(&pcp->lists[migratetype]);
6125 }
6126
6127 static void setup_pageset(struct per_cpu_pageset *p, unsigned long batch)
6128 {
6129         pageset_init(p);
6130         pageset_set_batch(p, batch);
6131 }
6132
6133 /*
6134  * pageset_set_high() sets the high water mark for hot per_cpu_pagelist
6135  * to the value high for the pageset p.
6136  */
6137 static void pageset_set_high(struct per_cpu_pageset *p,
6138                                 unsigned long high)
6139 {
6140         unsigned long batch = max(1UL, high / 4);
6141         if ((high / 4) > (PAGE_SHIFT * 8))
6142                 batch = PAGE_SHIFT * 8;
6143
6144         pageset_update(&p->pcp, high, batch);
6145 }
6146
6147 static void pageset_set_high_and_batch(struct zone *zone,
6148                                        struct per_cpu_pageset *pcp)
6149 {
6150         if (percpu_pagelist_fraction)
6151                 pageset_set_high(pcp,
6152                         (zone_managed_pages(zone) /
6153                                 percpu_pagelist_fraction));
6154         else
6155                 pageset_set_batch(pcp, zone_batchsize(zone));
6156 }
6157
6158 static void __meminit zone_pageset_init(struct zone *zone, int cpu)
6159 {
6160         struct per_cpu_pageset *pcp = per_cpu_ptr(zone->pageset, cpu);
6161
6162         pageset_init(pcp);
6163         pageset_set_high_and_batch(zone, pcp);
6164 }
6165
6166 void __meminit setup_zone_pageset(struct zone *zone)
6167 {
6168         int cpu;
6169         zone->pageset = alloc_percpu(struct per_cpu_pageset);
6170         for_each_possible_cpu(cpu)
6171                 zone_pageset_init(zone, cpu);
6172 }
6173
6174 /*
6175  * Allocate per cpu pagesets and initialize them.
6176  * Before this call only boot pagesets were available.
6177  */
6178 void __init setup_per_cpu_pageset(void)
6179 {
6180         struct pglist_data *pgdat;
6181         struct zone *zone;
6182
6183         for_each_populated_zone(zone)
6184                 setup_zone_pageset(zone);
6185
6186         for_each_online_pgdat(pgdat)
6187                 pgdat->per_cpu_nodestats =
6188                         alloc_percpu(struct per_cpu_nodestat);
6189 }
6190
6191 static __meminit void zone_pcp_init(struct zone *zone)
6192 {
6193         /*
6194          * per cpu subsystem is not up at this point. The following code
6195          * relies on the ability of the linker to provide the
6196          * offset of a (static) per cpu variable into the per cpu area.
6197          */
6198         zone->pageset = &boot_pageset;
6199
6200         if (populated_zone(zone))
6201                 printk(KERN_DEBUG "  %s zone: %lu pages, LIFO batch:%u\n",
6202                         zone->name, zone->present_pages,
6203                                          zone_batchsize(zone));
6204 }
6205
6206 void __meminit init_currently_empty_zone(struct zone *zone,
6207                                         unsigned long zone_start_pfn,
6208                                         unsigned long size)
6209 {
6210         struct pglist_data *pgdat = zone->zone_pgdat;
6211         int zone_idx = zone_idx(zone) + 1;
6212
6213         if (zone_idx > pgdat->nr_zones)
6214                 pgdat->nr_zones = zone_idx;
6215
6216         zone->zone_start_pfn = zone_start_pfn;
6217
6218         mminit_dprintk(MMINIT_TRACE, "memmap_init",
6219                         "Initialising map node %d zone %lu pfns %lu -> %lu\n",
6220                         pgdat->node_id,
6221                         (unsigned long)zone_idx(zone),
6222                         zone_start_pfn, (zone_start_pfn + size));
6223
6224         zone_init_free_lists(zone);
6225         zone->initialized = 1;
6226 }
6227
6228 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
6229 #ifndef CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID
6230
6231 /*
6232  * Required by SPARSEMEM. Given a PFN, return what node the PFN is on.
6233  */
6234 int __meminit __early_pfn_to_nid(unsigned long pfn,
6235                                         struct mminit_pfnnid_cache *state)
6236 {
6237         unsigned long start_pfn, end_pfn;
6238         int nid;
6239
6240         if (state->last_start <= pfn && pfn < state->last_end)
6241                 return state->last_nid;
6242
6243         nid = memblock_search_pfn_nid(pfn, &start_pfn, &end_pfn);
6244         if (nid != NUMA_NO_NODE) {
6245                 state->last_start = start_pfn;
6246                 state->last_end = end_pfn;
6247                 state->last_nid = nid;
6248         }
6249
6250         return nid;
6251 }
6252 #endif /* CONFIG_HAVE_ARCH_EARLY_PFN_TO_NID */
6253
6254 /**
6255  * free_bootmem_with_active_regions - Call memblock_free_early_nid for each active range
6256  * @nid: The node to free memory on. If MAX_NUMNODES, all nodes are freed.
6257  * @max_low_pfn: The highest PFN that will be passed to memblock_free_early_nid
6258  *
6259  * If an architecture guarantees that all ranges registered contain no holes
6260  * and may be freed, this this function may be used instead of calling
6261  * memblock_free_early_nid() manually.
6262  */
6263 void __init free_bootmem_with_active_regions(int nid, unsigned long max_low_pfn)
6264 {
6265         unsigned long start_pfn, end_pfn;
6266         int i, this_nid;
6267
6268         for_each_mem_pfn_range(i, nid, &start_pfn, &end_pfn, &this_nid) {
6269                 start_pfn = min(start_pfn, max_low_pfn);
6270                 end_pfn = min(end_pfn, max_low_pfn);
6271
6272                 if (start_pfn < end_pfn)
6273                         memblock_free_early_nid(PFN_PHYS(start_pfn),
6274                                         (end_pfn - start_pfn) << PAGE_SHIFT,
6275                                         this_nid);
6276         }
6277 }
6278
6279 /**
6280  * sparse_memory_present_with_active_regions - Call memory_present for each active range
6281  * @nid: The node to call memory_present for. If MAX_NUMNODES, all nodes will be used.
6282  *
6283  * If an architecture guarantees that all ranges registered contain no holes and may
6284  * be freed, this function may be used instead of calling memory_present() manually.
6285  */
6286 void __init sparse_memory_present_with_active_regions(int nid)
6287 {
6288         unsigned long start_pfn, end_pfn;
6289         int i, this_nid;
6290
6291         for_each_mem_pfn_range(i, nid, &start_pfn, &end_pfn, &this_nid)
6292                 memory_present(this_nid, start_pfn, end_pfn);
6293 }
6294
6295 /**
6296  * get_pfn_range_for_nid - Return the start and end page frames for a node
6297  * @nid: The nid to return the range for. If MAX_NUMNODES, the min and max PFN are returned.
6298  * @start_pfn: Passed by reference. On return, it will have the node start_pfn.
6299  * @end_pfn: Passed by reference. On return, it will have the node end_pfn.
6300  *
6301  * It returns the start and end page frame of a node based on information
6302  * provided by memblock_set_node(). If called for a node
6303  * with no available memory, a warning is printed and the start and end
6304  * PFNs will be 0.
6305  */
6306 void __init get_pfn_range_for_nid(unsigned int nid,
6307                         unsigned long *start_pfn, unsigned long *end_pfn)
6308 {
6309         unsigned long this_start_pfn, this_end_pfn;
6310         int i;
6311
6312         *start_pfn = -1UL;
6313         *end_pfn = 0;
6314
6315         for_each_mem_pfn_range(i, nid, &this_start_pfn, &this_end_pfn, NULL) {
6316                 *start_pfn = min(*start_pfn, this_start_pfn);
6317                 *end_pfn = max(*end_pfn, this_end_pfn);
6318         }
6319
6320         if (*start_pfn == -1UL)
6321                 *start_pfn = 0;
6322 }
6323
6324 /*
6325  * This finds a zone that can be used for ZONE_MOVABLE pages. The
6326  * assumption is made that zones within a node are ordered in monotonic
6327  * increasing memory addresses so that the "highest" populated zone is used
6328  */
6329 static void __init find_usable_zone_for_movable(void)
6330 {
6331         int zone_index;
6332         for (zone_index = MAX_NR_ZONES - 1; zone_index >= 0; zone_index--) {
6333                 if (zone_index == ZONE_MOVABLE)
6334                         continue;
6335
6336                 if (arch_zone_highest_possible_pfn[zone_index] >
6337                                 arch_zone_lowest_possible_pfn[zone_index])
6338                         break;
6339         }
6340
6341         VM_BUG_ON(zone_index == -1);
6342         movable_zone = zone_index;
6343 }
6344
6345 /*
6346  * The zone ranges provided by the architecture do not include ZONE_MOVABLE
6347  * because it is sized independent of architecture. Unlike the other zones,
6348  * the starting point for ZONE_MOVABLE is not fixed. It may be different
6349  * in each node depending on the size of each node and how evenly kernelcore
6350  * is distributed. This helper function adjusts the zone ranges
6351  * provided by the architecture for a given node by using the end of the
6352  * highest usable zone for ZONE_MOVABLE. This preserves the assumption that
6353  * zones within a node are in order of monotonic increases memory addresses
6354  */
6355 static void __init adjust_zone_range_for_zone_movable(int nid,
6356                                         unsigned long zone_type,
6357                                         unsigned long node_start_pfn,
6358                                         unsigned long node_end_pfn,
6359                                         unsigned long *zone_start_pfn,
6360                                         unsigned long *zone_end_pfn)
6361 {
6362         /* Only adjust if ZONE_MOVABLE is on this node */
6363         if (zone_movable_pfn[nid]) {
6364                 /* Size ZONE_MOVABLE */
6365                 if (zone_type == ZONE_MOVABLE) {
6366                         *zone_start_pfn = zone_movable_pfn[nid];
6367                         *zone_end_pfn = min(node_end_pfn,
6368                                 arch_zone_highest_possible_pfn[movable_zone]);
6369
6370                 /* Adjust for ZONE_MOVABLE starting within this range */
6371                 } else if (!mirrored_kernelcore &&
6372                         *zone_start_pfn < zone_movable_pfn[nid] &&
6373                         *zone_end_pfn > zone_movable_pfn[nid]) {
6374                         *zone_end_pfn = zone_movable_pfn[nid];
6375
6376                 /* Check if this whole range is within ZONE_MOVABLE */
6377                 } else if (*zone_start_pfn >= zone_movable_pfn[nid])
6378                         *zone_start_pfn = *zone_end_pfn;
6379         }
6380 }
6381
6382 /*
6383  * Return the number of pages a zone spans in a node, including holes
6384  * present_pages = zone_spanned_pages_in_node() - zone_absent_pages_in_node()
6385  */
6386 static unsigned long __init zone_spanned_pages_in_node(int nid,
6387                                         unsigned long zone_type,
6388                                         unsigned long node_start_pfn,
6389                                         unsigned long node_end_pfn,
6390                                         unsigned long *zone_start_pfn,
6391                                         unsigned long *zone_end_pfn,
6392                                         unsigned long *ignored)
6393 {
6394         unsigned long zone_low = arch_zone_lowest_possible_pfn[zone_type];
6395         unsigned long zone_high = arch_zone_highest_possible_pfn[zone_type];
6396         /* When hotadd a new node from cpu_up(), the node should be empty */
6397         if (!node_start_pfn && !node_end_pfn)
6398                 return 0;
6399
6400         /* Get the start and end of the zone */
6401         *zone_start_pfn = clamp(node_start_pfn, zone_low, zone_high);
6402         *zone_end_pfn = clamp(node_end_pfn, zone_low, zone_high);
6403         adjust_zone_range_for_zone_movable(nid, zone_type,
6404                                 node_start_pfn, node_end_pfn,
6405                                 zone_start_pfn, zone_end_pfn);
6406
6407         /* Check that this node has pages within the zone's required range */
6408         if (*zone_end_pfn < node_start_pfn || *zone_start_pfn > node_end_pfn)
6409                 return 0;
6410
6411         /* Move the zone boundaries inside the node if necessary */
6412         *zone_end_pfn = min(*zone_end_pfn, node_end_pfn);
6413         *zone_start_pfn = max(*zone_start_pfn, node_start_pfn);
6414
6415         /* Return the spanned pages */
6416         return *zone_end_pfn - *zone_start_pfn;
6417 }
6418
6419 /*
6420  * Return the number of holes in a range on a node. If nid is MAX_NUMNODES,
6421  * then all holes in the requested range will be accounted for.
6422  */
6423 unsigned long __init __absent_pages_in_range(int nid,
6424                                 unsigned long range_start_pfn,
6425                                 unsigned long range_end_pfn)
6426 {
6427         unsigned long nr_absent = range_end_pfn - range_start_pfn;
6428         unsigned long start_pfn, end_pfn;
6429         int i;
6430
6431         for_each_mem_pfn_range(i, nid, &start_pfn, &end_pfn, NULL) {
6432                 start_pfn = clamp(start_pfn, range_start_pfn, range_end_pfn);
6433                 end_pfn = clamp(end_pfn, range_start_pfn, range_end_pfn);
6434                 nr_absent -= end_pfn - start_pfn;
6435         }
6436         return nr_absent;
6437 }
6438
6439 /**
6440  * absent_pages_in_range - Return number of page frames in holes within a range
6441  * @start_pfn: The start PFN to start searching for holes
6442  * @end_pfn: The end PFN to stop searching for holes
6443  *
6444  * Return: the number of pages frames in memory holes within a range.
6445  */
6446 unsigned long __init absent_pages_in_range(unsigned long start_pfn,
6447                                                         unsigned long end_pfn)
6448 {
6449         return __absent_pages_in_range(MAX_NUMNODES, start_pfn, end_pfn);
6450 }
6451
6452 /* Return the number of page frames in holes in a zone on a node */
6453 static unsigned long __init zone_absent_pages_in_node(int nid,
6454                                         unsigned long zone_type,
6455                                         unsigned long node_start_pfn,
6456                                         unsigned long node_end_pfn,
6457                                         unsigned long *ignored)
6458 {
6459         unsigned long zone_low = arch_zone_lowest_possible_pfn[zone_type];
6460         unsigned long zone_high = arch_zone_highest_possible_pfn[zone_type];
6461         unsigned long zone_start_pfn, zone_end_pfn;
6462         unsigned long nr_absent;
6463
6464         /* When hotadd a new node from cpu_up(), the node should be empty */
6465         if (!node_start_pfn && !node_end_pfn)
6466                 return 0;
6467
6468         zone_start_pfn = clamp(node_start_pfn, zone_low, zone_high);
6469         zone_end_pfn = clamp(node_end_pfn, zone_low, zone_high);
6470
6471         adjust_zone_range_for_zone_movable(nid, zone_type,
6472                         node_start_pfn, node_end_pfn,
6473                         &zone_start_pfn, &zone_end_pfn);
6474         nr_absent = __absent_pages_in_range(nid, zone_start_pfn, zone_end_pfn);
6475
6476         /*
6477          * ZONE_MOVABLE handling.
6478          * Treat pages to be ZONE_MOVABLE in ZONE_NORMAL as absent pages
6479          * and vice versa.
6480          */
6481         if (mirrored_kernelcore && zone_movable_pfn[nid]) {
6482                 unsigned long start_pfn, end_pfn;
6483                 struct memblock_region *r;
6484
6485                 for_each_memblock(memory, r) {
6486                         start_pfn = clamp(memblock_region_memory_base_pfn(r),
6487                                           zone_start_pfn, zone_end_pfn);
6488                         end_pfn = clamp(memblock_region_memory_end_pfn(r),
6489                                         zone_start_pfn, zone_end_pfn);
6490
6491                         if (zone_type == ZONE_MOVABLE &&
6492                             memblock_is_mirror(r))
6493                                 nr_absent += end_pfn - start_pfn;
6494
6495                         if (zone_type == ZONE_NORMAL &&
6496                             !memblock_is_mirror(r))
6497                                 nr_absent += end_pfn - start_pfn;
6498                 }
6499         }
6500
6501         return nr_absent;
6502 }
6503
6504 #else /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
6505 static inline unsigned long __init zone_spanned_pages_in_node(int nid,
6506                                         unsigned long zone_type,
6507                                         unsigned long node_start_pfn,
6508                                         unsigned long node_end_pfn,
6509                                         unsigned long *zone_start_pfn,
6510                                         unsigned long *zone_end_pfn,
6511                                         unsigned long *zones_size)
6512 {
6513         unsigned int zone;
6514
6515         *zone_start_pfn = node_start_pfn;
6516         for (zone = 0; zone < zone_type; zone++)
6517                 *zone_start_pfn += zones_size[zone];
6518
6519         *zone_end_pfn = *zone_start_pfn + zones_size[zone_type];
6520
6521         return zones_size[zone_type];
6522 }
6523
6524 static inline unsigned long __init zone_absent_pages_in_node(int nid,
6525                                                 unsigned long zone_type,
6526                                                 unsigned long node_start_pfn,
6527                                                 unsigned long node_end_pfn,
6528                                                 unsigned long *zholes_size)
6529 {
6530         if (!zholes_size)
6531                 return 0;
6532
6533         return zholes_size[zone_type];
6534 }
6535
6536 #endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
6537
6538 static void __init calculate_node_totalpages(struct pglist_data *pgdat,
6539                                                 unsigned long node_start_pfn,
6540                                                 unsigned long node_end_pfn,
6541                                                 unsigned long *zones_size,
6542                                                 unsigned long *zholes_size)
6543 {
6544         unsigned long realtotalpages = 0, totalpages = 0;
6545         enum zone_type i;
6546
6547         for (i = 0; i < MAX_NR_ZONES; i++) {
6548                 struct zone *zone = pgdat->node_zones + i;
6549                 unsigned long zone_start_pfn, zone_end_pfn;
6550                 unsigned long size, real_size;
6551
6552                 size = zone_spanned_pages_in_node(pgdat->node_id, i,
6553                                                   node_start_pfn,
6554                                                   node_end_pfn,
6555                                                   &zone_start_pfn,
6556                                                   &zone_end_pfn,
6557                                                   zones_size);
6558                 real_size = size - zone_absent_pages_in_node(pgdat->node_id, i,
6559                                                   node_start_pfn, node_end_pfn,
6560                                                   zholes_size);
6561                 if (size)
6562                         zone->zone_start_pfn = zone_start_pfn;
6563                 else
6564                         zone->zone_start_pfn = 0;
6565                 zone->spanned_pages = size;
6566                 zone->present_pages = real_size;
6567
6568                 totalpages += size;
6569                 realtotalpages += real_size;
6570         }
6571
6572         pgdat->node_spanned_pages = totalpages;
6573         pgdat->node_present_pages = realtotalpages;
6574         printk(KERN_DEBUG "On node %d totalpages: %lu\n", pgdat->node_id,
6575                                                         realtotalpages);
6576 }
6577
6578 #ifndef CONFIG_SPARSEMEM
6579 /*
6580  * Calculate the size of the zone->blockflags rounded to an unsigned long
6581  * Start by making sure zonesize is a multiple of pageblock_order by rounding
6582  * up. Then use 1 NR_PAGEBLOCK_BITS worth of bits per pageblock, finally
6583  * round what is now in bits to nearest long in bits, then return it in
6584  * bytes.
6585  */
6586 static unsigned long __init usemap_size(unsigned long zone_start_pfn, unsigned long zonesize)
6587 {
6588         unsigned long usemapsize;
6589
6590         zonesize += zone_start_pfn & (pageblock_nr_pages-1);
6591         usemapsize = roundup(zonesize, pageblock_nr_pages);
6592         usemapsize = usemapsize >> pageblock_order;
6593         usemapsize *= NR_PAGEBLOCK_BITS;
6594         usemapsize = roundup(usemapsize, 8 * sizeof(unsigned long));
6595
6596         return usemapsize / 8;
6597 }
6598
6599 static void __ref setup_usemap(struct pglist_data *pgdat,
6600                                 struct zone *zone,
6601                                 unsigned long zone_start_pfn,
6602                                 unsigned long zonesize)
6603 {
6604         unsigned long usemapsize = usemap_size(zone_start_pfn, zonesize);
6605         zone->pageblock_flags = NULL;
6606         if (usemapsize) {
6607                 zone->pageblock_flags =
6608                         memblock_alloc_node(usemapsize, SMP_CACHE_BYTES,
6609                                             pgdat->node_id);
6610                 if (!zone->pageblock_flags)
6611                         panic("Failed to allocate %ld bytes for zone %s pageblock flags on node %d\n",
6612                               usemapsize, zone->name, pgdat->node_id);
6613         }
6614 }
6615 #else
6616 static inline void setup_usemap(struct pglist_data *pgdat, struct zone *zone,
6617                                 unsigned long zone_start_pfn, unsigned long zonesize) {}
6618 #endif /* CONFIG_SPARSEMEM */
6619
6620 #ifdef CONFIG_HUGETLB_PAGE_SIZE_VARIABLE
6621
6622 /* Initialise the number of pages represented by NR_PAGEBLOCK_BITS */
6623 void __init set_pageblock_order(void)
6624 {
6625         unsigned int order;
6626
6627         /* Check that pageblock_nr_pages has not already been setup */
6628         if (pageblock_order)
6629                 return;
6630
6631         if (HPAGE_SHIFT > PAGE_SHIFT)
6632                 order = HUGETLB_PAGE_ORDER;
6633         else
6634                 order = MAX_ORDER - 1;
6635
6636         /*
6637          * Assume the largest contiguous order of interest is a huge page.
6638          * This value may be variable depending on boot parameters on IA64 and
6639          * powerpc.
6640          */
6641         pageblock_order = order;
6642 }
6643 #else /* CONFIG_HUGETLB_PAGE_SIZE_VARIABLE */
6644
6645 /*
6646  * When CONFIG_HUGETLB_PAGE_SIZE_VARIABLE is not set, set_pageblock_order()
6647  * is unused as pageblock_order is set at compile-time. See
6648  * include/linux/pageblock-flags.h for the values of pageblock_order based on
6649  * the kernel config
6650  */
6651 void __init set_pageblock_order(void)
6652 {
6653 }
6654
6655 #endif /* CONFIG_HUGETLB_PAGE_SIZE_VARIABLE */
6656
6657 static unsigned long __init calc_memmap_size(unsigned long spanned_pages,
6658                                                 unsigned long present_pages)
6659 {
6660         unsigned long pages = spanned_pages;
6661
6662         /*
6663          * Provide a more accurate estimation if there are holes within
6664          * the zone and SPARSEMEM is in use. If there are holes within the
6665          * zone, each populated memory region may cost us one or two extra
6666          * memmap pages due to alignment because memmap pages for each
6667          * populated regions may not be naturally aligned on page boundary.
6668          * So the (present_pages >> 4) heuristic is a tradeoff for that.
6669          */
6670         if (spanned_pages > present_pages + (present_pages >> 4) &&
6671             IS_ENABLED(CONFIG_SPARSEMEM))
6672                 pages = present_pages;
6673
6674         return PAGE_ALIGN(pages * sizeof(struct page)) >> PAGE_SHIFT;
6675 }
6676
6677 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
6678 static void pgdat_init_split_queue(struct pglist_data *pgdat)
6679 {
6680         struct deferred_split *ds_queue = &pgdat->deferred_split_queue;
6681
6682         spin_lock_init(&ds_queue->split_queue_lock);
6683         INIT_LIST_HEAD(&ds_queue->split_queue);
6684         ds_queue->split_queue_len = 0;
6685 }
6686 #else
6687 static void pgdat_init_split_queue(struct pglist_data *pgdat) {}
6688 #endif
6689
6690 #ifdef CONFIG_COMPACTION
6691 static void pgdat_init_kcompactd(struct pglist_data *pgdat)
6692 {
6693         init_waitqueue_head(&pgdat->kcompactd_wait);
6694 }
6695 #else
6696 static void pgdat_init_kcompactd(struct pglist_data *pgdat) {}
6697 #endif
6698
6699 static void __meminit pgdat_init_internals(struct pglist_data *pgdat)
6700 {
6701         pgdat_resize_init(pgdat);
6702
6703         pgdat_init_split_queue(pgdat);
6704         pgdat_init_kcompactd(pgdat);
6705
6706         init_waitqueue_head(&pgdat->kswapd_wait);
6707         init_waitqueue_head(&pgdat->pfmemalloc_wait);
6708
6709         pgdat_page_ext_init(pgdat);
6710         spin_lock_init(&pgdat->lru_lock);
6711         lruvec_init(node_lruvec(pgdat));
6712 }
6713
6714 static void __meminit zone_init_internals(struct zone *zone, enum zone_type idx, int nid,
6715                                                         unsigned long remaining_pages)
6716 {
6717         atomic_long_set(&zone->managed_pages, remaining_pages);
6718         zone_set_nid(zone, nid);
6719         zone->name = zone_names[idx];
6720         zone->zone_pgdat = NODE_DATA(nid);
6721         spin_lock_init(&zone->lock);
6722         zone_seqlock_init(zone);
6723         zone_pcp_init(zone);
6724 }
6725
6726 /*
6727  * Set up the zone data structures
6728  * - init pgdat internals
6729  * - init all zones belonging to this node
6730  *
6731  * NOTE: this function is only called during memory hotplug
6732  */
6733 #ifdef CONFIG_MEMORY_HOTPLUG
6734 void __ref free_area_init_core_hotplug(int nid)
6735 {
6736         enum zone_type z;
6737         pg_data_t *pgdat = NODE_DATA(nid);
6738
6739         pgdat_init_internals(pgdat);
6740         for (z = 0; z < MAX_NR_ZONES; z++)
6741                 zone_init_internals(&pgdat->node_zones[z], z, nid, 0);
6742 }
6743 #endif
6744
6745 /*
6746  * Set up the zone data structures:
6747  *   - mark all pages reserved
6748  *   - mark all memory queues empty
6749  *   - clear the memory bitmaps
6750  *
6751  * NOTE: pgdat should get zeroed by caller.
6752  * NOTE: this function is only called during early init.
6753  */
6754 static void __init free_area_init_core(struct pglist_data *pgdat)
6755 {
6756         enum zone_type j;
6757         int nid = pgdat->node_id;
6758
6759         pgdat_init_internals(pgdat);
6760         pgdat->per_cpu_nodestats = &boot_nodestats;
6761
6762         for (j = 0; j < MAX_NR_ZONES; j++) {
6763                 struct zone *zone = pgdat->node_zones + j;
6764                 unsigned long size, freesize, memmap_pages;
6765                 unsigned long zone_start_pfn = zone->zone_start_pfn;
6766
6767                 size = zone->spanned_pages;
6768                 freesize = zone->present_pages;
6769
6770                 /*
6771                  * Adjust freesize so that it accounts for how much memory
6772                  * is used by this zone for memmap. This affects the watermark
6773                  * and per-cpu initialisations
6774                  */
6775                 memmap_pages = calc_memmap_size(size, freesize);
6776                 if (!is_highmem_idx(j)) {
6777                         if (freesize >= memmap_pages) {
6778                                 freesize -= memmap_pages;
6779                                 if (memmap_pages)
6780                                         printk(KERN_DEBUG
6781                                                "  %s zone: %lu pages used for memmap\n",
6782                                                zone_names[j], memmap_pages);
6783                         } else
6784                                 pr_warn("  %s zone: %lu pages exceeds freesize %lu\n",
6785                                         zone_names[j], memmap_pages, freesize);
6786                 }
6787
6788                 /* Account for reserved pages */
6789                 if (j == 0 && freesize > dma_reserve) {
6790                         freesize -= dma_reserve;
6791                         printk(KERN_DEBUG "  %s zone: %lu pages reserved\n",
6792                                         zone_names[0], dma_reserve);
6793                 }
6794
6795                 if (!is_highmem_idx(j))
6796                         nr_kernel_pages += freesize;
6797                 /* Charge for highmem memmap if there are enough kernel pages */
6798                 else if (nr_kernel_pages > memmap_pages * 2)
6799                         nr_kernel_pages -= memmap_pages;
6800                 nr_all_pages += freesize;
6801
6802                 /*
6803                  * Set an approximate value for lowmem here, it will be adjusted
6804                  * when the bootmem allocator frees pages into the buddy system.
6805                  * And all highmem pages will be managed by the buddy system.
6806                  */
6807                 zone_init_internals(zone, j, nid, freesize);
6808
6809                 if (!size)
6810                         continue;
6811
6812                 set_pageblock_order();
6813                 setup_usemap(pgdat, zone, zone_start_pfn, size);
6814                 init_currently_empty_zone(zone, zone_start_pfn, size);
6815                 memmap_init(size, nid, j, zone_start_pfn);
6816         }
6817 }
6818
6819 #ifdef CONFIG_FLAT_NODE_MEM_MAP
6820 static void __ref alloc_node_mem_map(struct pglist_data *pgdat)
6821 {
6822         unsigned long __maybe_unused start = 0;
6823         unsigned long __maybe_unused offset = 0;
6824
6825         /* Skip empty nodes */
6826         if (!pgdat->node_spanned_pages)
6827                 return;
6828
6829         start = pgdat->node_start_pfn & ~(MAX_ORDER_NR_PAGES - 1);
6830         offset = pgdat->node_start_pfn - start;
6831         /* ia64 gets its own node_mem_map, before this, without bootmem */
6832         if (!pgdat->node_mem_map) {
6833                 unsigned long size, end;
6834                 struct page *map;
6835
6836                 /*
6837                  * The zone's endpoints aren't required to be MAX_ORDER
6838                  * aligned but the node_mem_map endpoints must be in order
6839                  * for the buddy allocator to function correctly.
6840                  */
6841                 end = pgdat_end_pfn(pgdat);
6842                 end = ALIGN(end, MAX_ORDER_NR_PAGES);
6843                 size =  (end - start) * sizeof(struct page);
6844                 map = memblock_alloc_node(size, SMP_CACHE_BYTES,
6845                                           pgdat->node_id);
6846                 if (!map)
6847                         panic("Failed to allocate %ld bytes for node %d memory map\n",
6848                               size, pgdat->node_id);
6849                 pgdat->node_mem_map = map + offset;
6850         }
6851         pr_debug("%s: node %d, pgdat %08lx, node_mem_map %08lx\n",
6852                                 __func__, pgdat->node_id, (unsigned long)pgdat,
6853                                 (unsigned long)pgdat->node_mem_map);
6854 #ifndef CONFIG_NEED_MULTIPLE_NODES
6855         /*
6856          * With no DISCONTIG, the global mem_map is just set as node 0's
6857          */
6858         if (pgdat == NODE_DATA(0)) {
6859                 mem_map = NODE_DATA(0)->node_mem_map;
6860 #if defined(CONFIG_HAVE_MEMBLOCK_NODE_MAP) || defined(CONFIG_FLATMEM)
6861                 if (page_to_pfn(mem_map) != pgdat->node_start_pfn)
6862                         mem_map -= offset;
6863 #endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
6864         }
6865 #endif
6866 }
6867 #else
6868 static void __ref alloc_node_mem_map(struct pglist_data *pgdat) { }
6869 #endif /* CONFIG_FLAT_NODE_MEM_MAP */
6870
6871 #ifdef CONFIG_DEFERRED_STRUCT_PAGE_INIT
6872 static inline void pgdat_set_deferred_range(pg_data_t *pgdat)
6873 {
6874         pgdat->first_deferred_pfn = ULONG_MAX;
6875 }
6876 #else
6877 static inline void pgdat_set_deferred_range(pg_data_t *pgdat) {}
6878 #endif
6879
6880 void __init free_area_init_node(int nid, unsigned long *zones_size,
6881                                    unsigned long node_start_pfn,
6882                                    unsigned long *zholes_size)
6883 {
6884         pg_data_t *pgdat = NODE_DATA(nid);
6885         unsigned long start_pfn = 0;
6886         unsigned long end_pfn = 0;
6887
6888         /* pg_data_t should be reset to zero when it's allocated */
6889         WARN_ON(pgdat->nr_zones || pgdat->kswapd_classzone_idx);
6890
6891         pgdat->node_id = nid;
6892         pgdat->node_start_pfn = node_start_pfn;
6893         pgdat->per_cpu_nodestats = NULL;
6894 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
6895         get_pfn_range_for_nid(nid, &start_pfn, &end_pfn);
6896         pr_info("Initmem setup node %d [mem %#018Lx-%#018Lx]\n", nid,
6897                 (u64)start_pfn << PAGE_SHIFT,
6898                 end_pfn ? ((u64)end_pfn << PAGE_SHIFT) - 1 : 0);
6899 #else
6900         start_pfn = node_start_pfn;
6901 #endif
6902         calculate_node_totalpages(pgdat, start_pfn, end_pfn,
6903                                   zones_size, zholes_size);
6904
6905         alloc_node_mem_map(pgdat);
6906         pgdat_set_deferred_range(pgdat);
6907
6908         free_area_init_core(pgdat);
6909 }
6910
6911 #if !defined(CONFIG_FLAT_NODE_MEM_MAP)
6912 /*
6913  * Zero all valid struct pages in range [spfn, epfn), return number of struct
6914  * pages zeroed
6915  */
6916 static u64 zero_pfn_range(unsigned long spfn, unsigned long epfn)
6917 {
6918         unsigned long pfn;
6919         u64 pgcnt = 0;
6920
6921         for (pfn = spfn; pfn < epfn; pfn++) {
6922                 if (!pfn_valid(ALIGN_DOWN(pfn, pageblock_nr_pages))) {
6923                         pfn = ALIGN_DOWN(pfn, pageblock_nr_pages)
6924                                 + pageblock_nr_pages - 1;
6925                         continue;
6926                 }
6927                 mm_zero_struct_page(pfn_to_page(pfn));
6928                 pgcnt++;
6929         }
6930
6931         return pgcnt;
6932 }
6933
6934 /*
6935  * Only struct pages that are backed by physical memory are zeroed and
6936  * initialized by going through __init_single_page(). But, there are some
6937  * struct pages which are reserved in memblock allocator and their fields
6938  * may be accessed (for example page_to_pfn() on some configuration accesses
6939  * flags). We must explicitly zero those struct pages.
6940  *
6941  * This function also addresses a similar issue where struct pages are left
6942  * uninitialized because the physical address range is not covered by
6943  * memblock.memory or memblock.reserved. That could happen when memblock
6944  * layout is manually configured via memmap=.
6945  */
6946 void __init zero_resv_unavail(void)
6947 {
6948         phys_addr_t start, end;
6949         u64 i, pgcnt;
6950         phys_addr_t next = 0;
6951
6952         /*
6953          * Loop through unavailable ranges not covered by memblock.memory.
6954          */
6955         pgcnt = 0;
6956         for_each_mem_range(i, &memblock.memory, NULL,
6957                         NUMA_NO_NODE, MEMBLOCK_NONE, &start, &end, NULL) {
6958                 if (next < start)
6959                         pgcnt += zero_pfn_range(PFN_DOWN(next), PFN_UP(start));
6960                 next = end;
6961         }
6962         pgcnt += zero_pfn_range(PFN_DOWN(next), max_pfn);
6963
6964         /*
6965          * Struct pages that do not have backing memory. This could be because
6966          * firmware is using some of this memory, or for some other reasons.
6967          */
6968         if (pgcnt)
6969                 pr_info("Zeroed struct page in unavailable ranges: %lld pages", pgcnt);
6970 }
6971 #endif /* !CONFIG_FLAT_NODE_MEM_MAP */
6972
6973 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
6974
6975 #if MAX_NUMNODES > 1
6976 /*
6977  * Figure out the number of possible node ids.
6978  */
6979 void __init setup_nr_node_ids(void)
6980 {
6981         unsigned int highest;
6982
6983         highest = find_last_bit(node_possible_map.bits, MAX_NUMNODES);
6984         nr_node_ids = highest + 1;
6985 }
6986 #endif
6987
6988 /**
6989  * node_map_pfn_alignment - determine the maximum internode alignment
6990  *
6991  * This function should be called after node map is populated and sorted.
6992  * It calculates the maximum power of two alignment which can distinguish
6993  * all the nodes.
6994  *
6995  * For example, if all nodes are 1GiB and aligned to 1GiB, the return value
6996  * would indicate 1GiB alignment with (1 << (30 - PAGE_SHIFT)).  If the
6997  * nodes are shifted by 256MiB, 256MiB.  Note that if only the last node is
6998  * shifted, 1GiB is enough and this function will indicate so.
6999  *
7000  * This is used to test whether pfn -> nid mapping of the chosen memory
7001  * model has fine enough granularity to avoid incorrect mapping for the
7002  * populated node map.
7003  *
7004  * Return: the determined alignment in pfn's.  0 if there is no alignment
7005  * requirement (single node).
7006  */
7007 unsigned long __init node_map_pfn_alignment(void)
7008 {
7009         unsigned long accl_mask = 0, last_end = 0;
7010         unsigned long start, end, mask;
7011         int last_nid = NUMA_NO_NODE;
7012         int i, nid;
7013
7014         for_each_mem_pfn_range(i, MAX_NUMNODES, &start, &end, &nid) {
7015                 if (!start || last_nid < 0 || last_nid == nid) {
7016                         last_nid = nid;
7017                         last_end = end;
7018                         continue;
7019                 }
7020
7021                 /*
7022                  * Start with a mask granular enough to pin-point to the
7023                  * start pfn and tick off bits one-by-one until it becomes
7024                  * too coarse to separate the current node from the last.
7025                  */
7026                 mask = ~((1 << __ffs(start)) - 1);
7027                 while (mask && last_end <= (start & (mask << 1)))
7028                         mask <<= 1;
7029
7030                 /* accumulate all internode masks */
7031                 accl_mask |= mask;
7032         }
7033
7034         /* convert mask to number of pages */
7035         return ~accl_mask + 1;
7036 }
7037
7038 /* Find the lowest pfn for a node */
7039 static unsigned long __init find_min_pfn_for_node(int nid)
7040 {
7041         unsigned long min_pfn = ULONG_MAX;
7042         unsigned long start_pfn;
7043         int i;
7044
7045         for_each_mem_pfn_range(i, nid, &start_pfn, NULL, NULL)
7046                 min_pfn = min(min_pfn, start_pfn);
7047
7048         if (min_pfn == ULONG_MAX) {
7049                 pr_warn("Could not find start_pfn for node %d\n", nid);
7050                 return 0;
7051         }
7052
7053         return min_pfn;
7054 }
7055
7056 /**
7057  * find_min_pfn_with_active_regions - Find the minimum PFN registered
7058  *
7059  * Return: the minimum PFN based on information provided via
7060  * memblock_set_node().
7061  */
7062 unsigned long __init find_min_pfn_with_active_regions(void)
7063 {
7064         return find_min_pfn_for_node(MAX_NUMNODES);
7065 }
7066
7067 /*
7068  * early_calculate_totalpages()
7069  * Sum pages in active regions for movable zone.
7070  * Populate N_MEMORY for calculating usable_nodes.
7071  */
7072 static unsigned long __init early_calculate_totalpages(void)
7073 {
7074         unsigned long totalpages = 0;
7075         unsigned long start_pfn, end_pfn;
7076         int i, nid;
7077
7078         for_each_mem_pfn_range(i, MAX_NUMNODES, &start_pfn, &end_pfn, &nid) {
7079                 unsigned long pages = end_pfn - start_pfn;
7080
7081                 totalpages += pages;
7082                 if (pages)
7083                         node_set_state(nid, N_MEMORY);
7084         }
7085         return totalpages;
7086 }
7087
7088 /*
7089  * Find the PFN the Movable zone begins in each node. Kernel memory
7090  * is spread evenly between nodes as long as the nodes have enough
7091  * memory. When they don't, some nodes will have more kernelcore than
7092  * others
7093  */
7094 static void __init find_zone_movable_pfns_for_nodes(void)
7095 {
7096         int i, nid;
7097         unsigned long usable_startpfn;
7098         unsigned long kernelcore_node, kernelcore_remaining;
7099         /* save the state before borrow the nodemask */
7100         nodemask_t saved_node_state = node_states[N_MEMORY];
7101         unsigned long totalpages = early_calculate_totalpages();
7102         int usable_nodes = nodes_weight(node_states[N_MEMORY]);
7103         struct memblock_region *r;
7104
7105         /* Need to find movable_zone earlier when movable_node is specified. */
7106         find_usable_zone_for_movable();
7107
7108         /*
7109          * If movable_node is specified, ignore kernelcore and movablecore
7110          * options.
7111          */
7112         if (movable_node_is_enabled()) {
7113                 for_each_memblock(memory, r) {
7114                         if (!memblock_is_hotpluggable(r))
7115                                 continue;
7116
7117                         nid = r->nid;
7118
7119                         usable_startpfn = PFN_DOWN(r->base);
7120                         zone_movable_pfn[nid] = zone_movable_pfn[nid] ?
7121                                 min(usable_startpfn, zone_movable_pfn[nid]) :
7122                                 usable_startpfn;
7123                 }
7124
7125                 goto out2;
7126         }
7127
7128         /*
7129          * If kernelcore=mirror is specified, ignore movablecore option
7130          */
7131         if (mirrored_kernelcore) {
7132                 bool mem_below_4gb_not_mirrored = false;
7133
7134                 for_each_memblock(memory, r) {
7135                         if (memblock_is_mirror(r))
7136                                 continue;
7137
7138                         nid = r->nid;
7139
7140                         usable_startpfn = memblock_region_memory_base_pfn(r);
7141
7142                         if (usable_startpfn < 0x100000) {
7143                                 mem_below_4gb_not_mirrored = true;
7144                                 continue;
7145                         }
7146
7147                         zone_movable_pfn[nid] = zone_movable_pfn[nid] ?
7148                                 min(usable_startpfn, zone_movable_pfn[nid]) :
7149                                 usable_startpfn;
7150                 }
7151
7152                 if (mem_below_4gb_not_mirrored)
7153                         pr_warn("This configuration results in unmirrored kernel memory.");
7154
7155                 goto out2;
7156         }
7157
7158         /*
7159          * If kernelcore=nn% or movablecore=nn% was specified, calculate the
7160          * amount of necessary memory.
7161          */
7162         if (required_kernelcore_percent)
7163                 required_kernelcore = (totalpages * 100 * required_kernelcore_percent) /
7164                                        10000UL;
7165         if (required_movablecore_percent)
7166                 required_movablecore = (totalpages * 100 * required_movablecore_percent) /
7167                                         10000UL;
7168
7169         /*
7170          * If movablecore= was specified, calculate what size of
7171          * kernelcore that corresponds so that memory usable for
7172          * any allocation type is evenly spread. If both kernelcore
7173          * and movablecore are specified, then the value of kernelcore
7174          * will be used for required_kernelcore if it's greater than
7175          * what movablecore would have allowed.
7176          */
7177         if (required_movablecore) {
7178                 unsigned long corepages;
7179
7180                 /*
7181                  * Round-up so that ZONE_MOVABLE is at least as large as what
7182                  * was requested by the user
7183                  */
7184                 required_movablecore =
7185                         roundup(required_movablecore, MAX_ORDER_NR_PAGES);
7186                 required_movablecore = min(totalpages, required_movablecore);
7187                 corepages = totalpages - required_movablecore;
7188
7189                 required_kernelcore = max(required_kernelcore, corepages);
7190         }
7191
7192         /*
7193          * If kernelcore was not specified or kernelcore size is larger
7194          * than totalpages, there is no ZONE_MOVABLE.
7195          */
7196         if (!required_kernelcore || required_kernelcore >= totalpages)
7197                 goto out;
7198
7199         /* usable_startpfn is the lowest possible pfn ZONE_MOVABLE can be at */
7200         usable_startpfn = arch_zone_lowest_possible_pfn[movable_zone];
7201
7202 restart:
7203         /* Spread kernelcore memory as evenly as possible throughout nodes */
7204         kernelcore_node = required_kernelcore / usable_nodes;
7205         for_each_node_state(nid, N_MEMORY) {
7206                 unsigned long start_pfn, end_pfn;
7207
7208                 /*
7209                  * Recalculate kernelcore_node if the division per node
7210                  * now exceeds what is necessary to satisfy the requested
7211                  * amount of memory for the kernel
7212                  */
7213                 if (required_kernelcore < kernelcore_node)
7214                         kernelcore_node = required_kernelcore / usable_nodes;
7215
7216                 /*
7217                  * As the map is walked, we track how much memory is usable
7218                  * by the kernel using kernelcore_remaining. When it is
7219                  * 0, the rest of the node is usable by ZONE_MOVABLE
7220                  */
7221                 kernelcore_remaining = kernelcore_node;
7222
7223                 /* Go through each range of PFNs within this node */
7224                 for_each_mem_pfn_range(i, nid, &start_pfn, &end_pfn, NULL) {
7225                         unsigned long size_pages;
7226
7227                         start_pfn = max(start_pfn, zone_movable_pfn[nid]);
7228                         if (start_pfn >= end_pfn)
7229                                 continue;
7230
7231                         /* Account for what is only usable for kernelcore */
7232                         if (start_pfn < usable_startpfn) {
7233                                 unsigned long kernel_pages;
7234                                 kernel_pages = min(end_pfn, usable_startpfn)
7235                                                                 - start_pfn;
7236
7237                                 kernelcore_remaining -= min(kernel_pages,
7238                                                         kernelcore_remaining);
7239                                 required_kernelcore -= min(kernel_pages,
7240                                                         required_kernelcore);
7241
7242                                 /* Continue if range is now fully accounted */
7243                                 if (end_pfn <= usable_startpfn) {
7244
7245                                         /*
7246                                          * Push zone_movable_pfn to the end so
7247                                          * that if we have to rebalance
7248                                          * kernelcore across nodes, we will
7249                                          * not double account here
7250                                          */
7251                                         zone_movable_pfn[nid] = end_pfn;
7252                                         continue;
7253                                 }
7254                                 start_pfn = usable_startpfn;
7255                         }
7256
7257                         /*
7258                          * The usable PFN range for ZONE_MOVABLE is from
7259                          * start_pfn->end_pfn. Calculate size_pages as the
7260                          * number of pages used as kernelcore
7261                          */
7262                         size_pages = end_pfn - start_pfn;
7263                         if (size_pages > kernelcore_remaining)
7264                                 size_pages = kernelcore_remaining;
7265                         zone_movable_pfn[nid] = start_pfn + size_pages;
7266
7267                         /*
7268                          * Some kernelcore has been met, update counts and
7269                          * break if the kernelcore for this node has been
7270                          * satisfied
7271                          */
7272                         required_kernelcore -= min(required_kernelcore,
7273                                                                 size_pages);
7274                         kernelcore_remaining -= size_pages;
7275                         if (!kernelcore_remaining)
7276                                 break;
7277                 }
7278         }
7279
7280         /*
7281          * If there is still required_kernelcore, we do another pass with one
7282          * less node in the count. This will push zone_movable_pfn[nid] further
7283          * along on the nodes that still have memory until kernelcore is
7284          * satisfied
7285          */
7286         usable_nodes--;
7287         if (usable_nodes && required_kernelcore > usable_nodes)
7288                 goto restart;
7289
7290 out2:
7291         /* Align start of ZONE_MOVABLE on all nids to MAX_ORDER_NR_PAGES */
7292         for (nid = 0; nid < MAX_NUMNODES; nid++)
7293                 zone_movable_pfn[nid] =
7294                         roundup(zone_movable_pfn[nid], MAX_ORDER_NR_PAGES);
7295
7296 out:
7297         /* restore the node_state */
7298         node_states[N_MEMORY] = saved_node_state;
7299 }
7300
7301 /* Any regular or high memory on that node ? */
7302 static void check_for_memory(pg_data_t *pgdat, int nid)
7303 {
7304         enum zone_type zone_type;
7305
7306         for (zone_type = 0; zone_type <= ZONE_MOVABLE - 1; zone_type++) {
7307                 struct zone *zone = &pgdat->node_zones[zone_type];
7308                 if (populated_zone(zone)) {
7309                         if (IS_ENABLED(CONFIG_HIGHMEM))
7310                                 node_set_state(nid, N_HIGH_MEMORY);
7311                         if (zone_type <= ZONE_NORMAL)
7312                                 node_set_state(nid, N_NORMAL_MEMORY);
7313                         break;
7314                 }
7315         }
7316 }
7317
7318 /**
7319  * free_area_init_nodes - Initialise all pg_data_t and zone data
7320  * @max_zone_pfn: an array of max PFNs for each zone
7321  *
7322  * This will call free_area_init_node() for each active node in the system.
7323  * Using the page ranges provided by memblock_set_node(), the size of each
7324  * zone in each node and their holes is calculated. If the maximum PFN
7325  * between two adjacent zones match, it is assumed that the zone is empty.
7326  * For example, if arch_max_dma_pfn == arch_max_dma32_pfn, it is assumed
7327  * that arch_max_dma32_pfn has no pages. It is also assumed that a zone
7328  * starts where the previous one ended. For example, ZONE_DMA32 starts
7329  * at arch_max_dma_pfn.
7330  */
7331 void __init free_area_init_nodes(unsigned long *max_zone_pfn)
7332 {
7333         unsigned long start_pfn, end_pfn;
7334         int i, nid;
7335
7336         /* Record where the zone boundaries are */
7337         memset(arch_zone_lowest_possible_pfn, 0,
7338                                 sizeof(arch_zone_lowest_possible_pfn));
7339         memset(arch_zone_highest_possible_pfn, 0,
7340                                 sizeof(arch_zone_highest_possible_pfn));
7341
7342         start_pfn = find_min_pfn_with_active_regions();
7343
7344         for (i = 0; i < MAX_NR_ZONES; i++) {
7345                 if (i == ZONE_MOVABLE)
7346                         continue;
7347
7348                 end_pfn = max(max_zone_pfn[i], start_pfn);
7349                 arch_zone_lowest_possible_pfn[i] = start_pfn;
7350                 arch_zone_highest_possible_pfn[i] = end_pfn;
7351
7352                 start_pfn = end_pfn;
7353         }
7354
7355         /* Find the PFNs that ZONE_MOVABLE begins at in each node */
7356         memset(zone_movable_pfn, 0, sizeof(zone_movable_pfn));
7357         find_zone_movable_pfns_for_nodes();
7358
7359         /* Print out the zone ranges */
7360         pr_info("Zone ranges:\n");
7361         for (i = 0; i < MAX_NR_ZONES; i++) {
7362                 if (i == ZONE_MOVABLE)
7363                         continue;
7364                 pr_info("  %-8s ", zone_names[i]);
7365                 if (arch_zone_lowest_possible_pfn[i] ==
7366                                 arch_zone_highest_possible_pfn[i])
7367                         pr_cont("empty\n");
7368                 else
7369                         pr_cont("[mem %#018Lx-%#018Lx]\n",
7370                                 (u64)arch_zone_lowest_possible_pfn[i]
7371                                         << PAGE_SHIFT,
7372                                 ((u64)arch_zone_highest_possible_pfn[i]
7373                                         << PAGE_SHIFT) - 1);
7374         }
7375
7376         /* Print out the PFNs ZONE_MOVABLE begins at in each node */
7377         pr_info("Movable zone start for each node\n");
7378         for (i = 0; i < MAX_NUMNODES; i++) {
7379                 if (zone_movable_pfn[i])
7380                         pr_info("  Node %d: %#018Lx\n", i,
7381                                (u64)zone_movable_pfn[i] << PAGE_SHIFT);
7382         }
7383
7384         /*
7385          * Print out the early node map, and initialize the
7386          * subsection-map relative to active online memory ranges to
7387          * enable future "sub-section" extensions of the memory map.
7388          */
7389         pr_info("Early memory node ranges\n");
7390         for_each_mem_pfn_range(i, MAX_NUMNODES, &start_pfn, &end_pfn, &nid) {
7391                 pr_info("  node %3d: [mem %#018Lx-%#018Lx]\n", nid,
7392                         (u64)start_pfn << PAGE_SHIFT,
7393                         ((u64)end_pfn << PAGE_SHIFT) - 1);
7394                 subsection_map_init(start_pfn, end_pfn - start_pfn);
7395         }
7396
7397         /* Initialise every node */
7398         mminit_verify_pageflags_layout();
7399         setup_nr_node_ids();
7400         zero_resv_unavail();
7401         for_each_online_node(nid) {
7402                 pg_data_t *pgdat = NODE_DATA(nid);
7403                 free_area_init_node(nid, NULL,
7404                                 find_min_pfn_for_node(nid), NULL);
7405
7406                 /* Any memory on that node */
7407                 if (pgdat->node_present_pages)
7408                         node_set_state(nid, N_MEMORY);
7409                 check_for_memory(pgdat, nid);
7410         }
7411 }
7412
7413 static int __init cmdline_parse_core(char *p, unsigned long *core,
7414                                      unsigned long *percent)
7415 {
7416         unsigned long long coremem;
7417         char *endptr;
7418
7419         if (!p)
7420                 return -EINVAL;
7421
7422         /* Value may be a percentage of total memory, otherwise bytes */
7423         coremem = simple_strtoull(p, &endptr, 0);
7424         if (*endptr == '%') {
7425                 /* Paranoid check for percent values greater than 100 */
7426                 WARN_ON(coremem > 100);
7427
7428                 *percent = coremem;
7429         } else {
7430                 coremem = memparse(p, &p);
7431                 /* Paranoid check that UL is enough for the coremem value */
7432                 WARN_ON((coremem >> PAGE_SHIFT) > ULONG_MAX);
7433
7434                 *core = coremem >> PAGE_SHIFT;
7435                 *percent = 0UL;
7436         }
7437         return 0;
7438 }
7439
7440 /*
7441  * kernelcore=size sets the amount of memory for use for allocations that
7442  * cannot be reclaimed or migrated.
7443  */
7444 static int __init cmdline_parse_kernelcore(char *p)
7445 {
7446         /* parse kernelcore=mirror */
7447         if (parse_option_str(p, "mirror")) {
7448                 mirrored_kernelcore = true;
7449                 return 0;
7450         }
7451
7452         return cmdline_parse_core(p, &required_kernelcore,
7453                                   &required_kernelcore_percent);
7454 }
7455
7456 /*
7457  * movablecore=size sets the amount of memory for use for allocations that
7458  * can be reclaimed or migrated.
7459  */
7460 static int __init cmdline_parse_movablecore(char *p)
7461 {
7462         return cmdline_parse_core(p, &required_movablecore,
7463                                   &required_movablecore_percent);
7464 }
7465
7466 early_param("kernelcore", cmdline_parse_kernelcore);
7467 early_param("movablecore", cmdline_parse_movablecore);
7468
7469 #endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
7470
7471 void adjust_managed_page_count(struct page *page, long count)
7472 {
7473         atomic_long_add(count, &page_zone(page)->managed_pages);
7474         totalram_pages_add(count);
7475 #ifdef CONFIG_HIGHMEM
7476         if (PageHighMem(page))
7477                 totalhigh_pages_add(count);
7478 #endif
7479 }
7480 EXPORT_SYMBOL(adjust_managed_page_count);
7481
7482 unsigned long free_reserved_area(void *start, void *end, int poison, const char *s)
7483 {
7484         void *pos;
7485         unsigned long pages = 0;
7486
7487         start = (void *)PAGE_ALIGN((unsigned long)start);
7488         end = (void *)((unsigned long)end & PAGE_MASK);
7489         for (pos = start; pos < end; pos += PAGE_SIZE, pages++) {
7490                 struct page *page = virt_to_page(pos);
7491                 void *direct_map_addr;
7492
7493                 /*
7494                  * 'direct_map_addr' might be different from 'pos'
7495                  * because some architectures' virt_to_page()
7496                  * work with aliases.  Getting the direct map
7497                  * address ensures that we get a _writeable_
7498                  * alias for the memset().
7499                  */
7500                 direct_map_addr = page_address(page);
7501                 if ((unsigned int)poison <= 0xFF)
7502                         memset(direct_map_addr, poison, PAGE_SIZE);
7503
7504                 free_reserved_page(page);
7505         }
7506
7507         if (pages && s)
7508                 pr_info("Freeing %s memory: %ldK\n",
7509                         s, pages << (PAGE_SHIFT - 10));
7510
7511         return pages;
7512 }
7513
7514 #ifdef  CONFIG_HIGHMEM
7515 void free_highmem_page(struct page *page)
7516 {
7517         __free_reserved_page(page);
7518         totalram_pages_inc();
7519         atomic_long_inc(&page_zone(page)->managed_pages);
7520         totalhigh_pages_inc();
7521 }
7522 #endif
7523
7524
7525 void __init mem_init_print_info(const char *str)
7526 {
7527         unsigned long physpages, codesize, datasize, rosize, bss_size;
7528         unsigned long init_code_size, init_data_size;
7529
7530         physpages = get_num_physpages();
7531         codesize = _etext - _stext;
7532         datasize = _edata - _sdata;
7533         rosize = __end_rodata - __start_rodata;
7534         bss_size = __bss_stop - __bss_start;
7535         init_data_size = __init_end - __init_begin;
7536         init_code_size = _einittext - _sinittext;
7537
7538         /*
7539          * Detect special cases and adjust section sizes accordingly:
7540          * 1) .init.* may be embedded into .data sections
7541          * 2) .init.text.* may be out of [__init_begin, __init_end],
7542          *    please refer to arch/tile/kernel/vmlinux.lds.S.
7543          * 3) .rodata.* may be embedded into .text or .data sections.
7544          */
7545 #define adj_init_size(start, end, size, pos, adj) \
7546         do { \
7547                 if (start <= pos && pos < end && size > adj) \
7548                         size -= adj; \
7549         } while (0)
7550
7551         adj_init_size(__init_begin, __init_end, init_data_size,
7552                      _sinittext, init_code_size);
7553         adj_init_size(_stext, _etext, codesize, _sinittext, init_code_size);
7554         adj_init_size(_sdata, _edata, datasize, __init_begin, init_data_size);
7555         adj_init_size(_stext, _etext, codesize, __start_rodata, rosize);
7556         adj_init_size(_sdata, _edata, datasize, __start_rodata, rosize);
7557
7558 #undef  adj_init_size
7559
7560         pr_info("Memory: %luK/%luK available (%luK kernel code, %luK rwdata, %luK rodata, %luK init, %luK bss, %luK reserved, %luK cma-reserved"
7561 #ifdef  CONFIG_HIGHMEM
7562                 ", %luK highmem"
7563 #endif
7564                 "%s%s)\n",
7565                 nr_free_pages() << (PAGE_SHIFT - 10),
7566                 physpages << (PAGE_SHIFT - 10),
7567                 codesize >> 10, datasize >> 10, rosize >> 10,
7568                 (init_data_size + init_code_size) >> 10, bss_size >> 10,
7569                 (physpages - totalram_pages() - totalcma_pages) << (PAGE_SHIFT - 10),
7570                 totalcma_pages << (PAGE_SHIFT - 10),
7571 #ifdef  CONFIG_HIGHMEM
7572                 totalhigh_pages() << (PAGE_SHIFT - 10),
7573 #endif
7574                 str ? ", " : "", str ? str : "");
7575 }
7576
7577 /**
7578  * set_dma_reserve - set the specified number of pages reserved in the first zone
7579  * @new_dma_reserve: The number of pages to mark reserved
7580  *
7581  * The per-cpu batchsize and zone watermarks are determined by managed_pages.
7582  * In the DMA zone, a significant percentage may be consumed by kernel image
7583  * and other unfreeable allocations which can skew the watermarks badly. This
7584  * function may optionally be used to account for unfreeable pages in the
7585  * first zone (e.g., ZONE_DMA). The effect will be lower watermarks and
7586  * smaller per-cpu batchsize.
7587  */
7588 void __init set_dma_reserve(unsigned long new_dma_reserve)
7589 {
7590         dma_reserve = new_dma_reserve;
7591 }
7592
7593 void __init free_area_init(unsigned long *zones_size)
7594 {
7595         zero_resv_unavail();
7596         free_area_init_node(0, zones_size,
7597                         __pa(PAGE_OFFSET) >> PAGE_SHIFT, NULL);
7598 }
7599
7600 static int page_alloc_cpu_dead(unsigned int cpu)
7601 {
7602
7603         lru_add_drain_cpu(cpu);
7604         drain_pages(cpu);
7605
7606         /*
7607          * Spill the event counters of the dead processor
7608          * into the current processors event counters.
7609          * This artificially elevates the count of the current
7610          * processor.
7611          */
7612         vm_events_fold_cpu(cpu);
7613
7614         /*
7615          * Zero the differential counters of the dead processor
7616          * so that the vm statistics are consistent.
7617          *
7618          * This is only okay since the processor is dead and cannot
7619          * race with what we are doing.
7620          */
7621         cpu_vm_stats_fold(cpu);
7622         return 0;
7623 }
7624
7625 #ifdef CONFIG_NUMA
7626 int hashdist = HASHDIST_DEFAULT;
7627
7628 static int __init set_hashdist(char *str)
7629 {
7630         if (!str)
7631                 return 0;
7632         hashdist = simple_strtoul(str, &str, 0);
7633         return 1;
7634 }
7635 __setup("hashdist=", set_hashdist);
7636 #endif
7637
7638 void __init page_alloc_init(void)
7639 {
7640         int ret;
7641
7642 #ifdef CONFIG_NUMA
7643         if (num_node_state(N_MEMORY) == 1)
7644                 hashdist = 0;
7645 #endif
7646
7647         ret = cpuhp_setup_state_nocalls(CPUHP_PAGE_ALLOC_DEAD,
7648                                         "mm/page_alloc:dead", NULL,
7649                                         page_alloc_cpu_dead);
7650         WARN_ON(ret < 0);
7651 }
7652
7653 /*
7654  * calculate_totalreserve_pages - called when sysctl_lowmem_reserve_ratio
7655  *      or min_free_kbytes changes.
7656  */
7657 static void calculate_totalreserve_pages(void)
7658 {
7659         struct pglist_data *pgdat;
7660         unsigned long reserve_pages = 0;
7661         enum zone_type i, j;
7662
7663         for_each_online_pgdat(pgdat) {
7664
7665                 pgdat->totalreserve_pages = 0;
7666
7667                 for (i = 0; i < MAX_NR_ZONES; i++) {
7668                         struct zone *zone = pgdat->node_zones + i;
7669                         long max = 0;
7670                         unsigned long managed_pages = zone_managed_pages(zone);
7671
7672                         /* Find valid and maximum lowmem_reserve in the zone */
7673                         for (j = i; j < MAX_NR_ZONES; j++) {
7674                                 if (zone->lowmem_reserve[j] > max)
7675                                         max = zone->lowmem_reserve[j];
7676                         }
7677
7678                         /* we treat the high watermark as reserved pages. */
7679                         max += high_wmark_pages(zone);
7680
7681                         if (max > managed_pages)
7682                                 max = managed_pages;
7683
7684                         pgdat->totalreserve_pages += max;
7685
7686                         reserve_pages += max;
7687                 }
7688         }
7689         totalreserve_pages = reserve_pages;
7690 }
7691
7692 /*
7693  * setup_per_zone_lowmem_reserve - called whenever
7694  *      sysctl_lowmem_reserve_ratio changes.  Ensures that each zone
7695  *      has a correct pages reserved value, so an adequate number of
7696  *      pages are left in the zone after a successful __alloc_pages().
7697  */
7698 static void setup_per_zone_lowmem_reserve(void)
7699 {
7700         struct pglist_data *pgdat;
7701         enum zone_type j, idx;
7702
7703         for_each_online_pgdat(pgdat) {
7704                 for (j = 0; j < MAX_NR_ZONES; j++) {
7705                         struct zone *zone = pgdat->node_zones + j;
7706                         unsigned long managed_pages = zone_managed_pages(zone);
7707
7708                         zone->lowmem_reserve[j] = 0;
7709
7710                         idx = j;
7711                         while (idx) {
7712                                 struct zone *lower_zone;
7713
7714                                 idx--;
7715                                 lower_zone = pgdat->node_zones + idx;
7716
7717                                 if (sysctl_lowmem_reserve_ratio[idx] < 1) {
7718                                         sysctl_lowmem_reserve_ratio[idx] = 0;
7719                                         lower_zone->lowmem_reserve[j] = 0;
7720                                 } else {
7721                                         lower_zone->lowmem_reserve[j] =
7722                                                 managed_pages / sysctl_lowmem_reserve_ratio[idx];
7723                                 }
7724                                 managed_pages += zone_managed_pages(lower_zone);
7725                         }
7726                 }
7727         }
7728
7729         /* update totalreserve_pages */
7730         calculate_totalreserve_pages();
7731 }
7732
7733 static void __setup_per_zone_wmarks(void)
7734 {
7735         unsigned long pages_min = min_free_kbytes >> (PAGE_SHIFT - 10);
7736         unsigned long lowmem_pages = 0;
7737         struct zone *zone;
7738         unsigned long flags;
7739
7740         /* Calculate total number of !ZONE_HIGHMEM pages */
7741         for_each_zone(zone) {
7742                 if (!is_highmem(zone))
7743                         lowmem_pages += zone_managed_pages(zone);
7744         }
7745
7746         for_each_zone(zone) {
7747                 u64 tmp;
7748
7749                 spin_lock_irqsave(&zone->lock, flags);
7750                 tmp = (u64)pages_min * zone_managed_pages(zone);
7751                 do_div(tmp, lowmem_pages);
7752                 if (is_highmem(zone)) {
7753                         /*
7754                          * __GFP_HIGH and PF_MEMALLOC allocations usually don't
7755                          * need highmem pages, so cap pages_min to a small
7756                          * value here.
7757                          *
7758                          * The WMARK_HIGH-WMARK_LOW and (WMARK_LOW-WMARK_MIN)
7759                          * deltas control async page reclaim, and so should
7760                          * not be capped for highmem.
7761                          */
7762                         unsigned long min_pages;
7763
7764                         min_pages = zone_managed_pages(zone) / 1024;
7765                         min_pages = clamp(min_pages, SWAP_CLUSTER_MAX, 128UL);
7766                         zone->_watermark[WMARK_MIN] = min_pages;
7767                 } else {
7768                         /*
7769                          * If it's a lowmem zone, reserve a number of pages
7770                          * proportionate to the zone's size.
7771                          */
7772                         zone->_watermark[WMARK_MIN] = tmp;
7773                 }
7774
7775                 /*
7776                  * Set the kswapd watermarks distance according to the
7777                  * scale factor in proportion to available memory, but
7778                  * ensure a minimum size on small systems.
7779                  */
7780                 tmp = max_t(u64, tmp >> 2,
7781                             mult_frac(zone_managed_pages(zone),
7782                                       watermark_scale_factor, 10000));
7783
7784                 zone->_watermark[WMARK_LOW]  = min_wmark_pages(zone) + tmp;
7785                 zone->_watermark[WMARK_HIGH] = min_wmark_pages(zone) + tmp * 2;
7786                 zone->watermark_boost = 0;
7787
7788                 spin_unlock_irqrestore(&zone->lock, flags);
7789         }
7790
7791         /* update totalreserve_pages */
7792         calculate_totalreserve_pages();
7793 }
7794
7795 /**
7796  * setup_per_zone_wmarks - called when min_free_kbytes changes
7797  * or when memory is hot-{added|removed}
7798  *
7799  * Ensures that the watermark[min,low,high] values for each zone are set
7800  * correctly with respect to min_free_kbytes.
7801  */
7802 void setup_per_zone_wmarks(void)
7803 {
7804         static DEFINE_SPINLOCK(lock);
7805
7806         spin_lock(&lock);
7807         __setup_per_zone_wmarks();
7808         spin_unlock(&lock);
7809 }
7810
7811 /*
7812  * Initialise min_free_kbytes.
7813  *
7814  * For small machines we want it small (128k min).  For large machines
7815  * we want it large (64MB max).  But it is not linear, because network
7816  * bandwidth does not increase linearly with machine size.  We use
7817  *
7818  *      min_free_kbytes = 4 * sqrt(lowmem_kbytes), for better accuracy:
7819  *      min_free_kbytes = sqrt(lowmem_kbytes * 16)
7820  *
7821  * which yields
7822  *
7823  * 16MB:        512k
7824  * 32MB:        724k
7825  * 64MB:        1024k
7826  * 128MB:       1448k
7827  * 256MB:       2048k
7828  * 512MB:       2896k
7829  * 1024MB:      4096k
7830  * 2048MB:      5792k
7831  * 4096MB:      8192k
7832  * 8192MB:      11584k
7833  * 16384MB:     16384k
7834  */
7835 int __meminit init_per_zone_wmark_min(void)
7836 {
7837         unsigned long lowmem_kbytes;
7838         int new_min_free_kbytes;
7839
7840         lowmem_kbytes = nr_free_buffer_pages() * (PAGE_SIZE >> 10);
7841         new_min_free_kbytes = int_sqrt(lowmem_kbytes * 16);
7842
7843         if (new_min_free_kbytes > user_min_free_kbytes) {
7844                 min_free_kbytes = new_min_free_kbytes;
7845                 if (min_free_kbytes < 128)
7846                         min_free_kbytes = 128;
7847                 if (min_free_kbytes > 65536)
7848                         min_free_kbytes = 65536;
7849         } else {
7850                 pr_warn("min_free_kbytes is not updated to %d because user defined value %d is preferred\n",
7851                                 new_min_free_kbytes, user_min_free_kbytes);
7852         }
7853         setup_per_zone_wmarks();
7854         refresh_zone_stat_thresholds();
7855         setup_per_zone_lowmem_reserve();
7856
7857 #ifdef CONFIG_NUMA
7858         setup_min_unmapped_ratio();
7859         setup_min_slab_ratio();
7860 #endif
7861
7862         return 0;
7863 }
7864 core_initcall(init_per_zone_wmark_min)
7865
7866 /*
7867  * min_free_kbytes_sysctl_handler - just a wrapper around proc_dointvec() so
7868  *      that we can call two helper functions whenever min_free_kbytes
7869  *      changes.
7870  */
7871 int min_free_kbytes_sysctl_handler(struct ctl_table *table, int write,
7872         void __user *buffer, size_t *length, loff_t *ppos)
7873 {
7874         int rc;
7875
7876         rc = proc_dointvec_minmax(table, write, buffer, length, ppos);
7877         if (rc)
7878                 return rc;
7879
7880         if (write) {
7881                 user_min_free_kbytes = min_free_kbytes;
7882                 setup_per_zone_wmarks();
7883         }
7884         return 0;
7885 }
7886
7887 int watermark_boost_factor_sysctl_handler(struct ctl_table *table, int write,
7888         void __user *buffer, size_t *length, loff_t *ppos)
7889 {
7890         int rc;
7891
7892         rc = proc_dointvec_minmax(table, write, buffer, length, ppos);
7893         if (rc)
7894                 return rc;
7895
7896         return 0;
7897 }
7898
7899 int watermark_scale_factor_sysctl_handler(struct ctl_table *table, int write,
7900         void __user *buffer, size_t *length, loff_t *ppos)
7901 {
7902         int rc;
7903
7904         rc = proc_dointvec_minmax(table, write, buffer, length, ppos);
7905         if (rc)
7906                 return rc;
7907
7908         if (write)
7909                 setup_per_zone_wmarks();
7910
7911         return 0;
7912 }
7913
7914 #ifdef CONFIG_NUMA
7915 static void setup_min_unmapped_ratio(void)
7916 {
7917         pg_data_t *pgdat;
7918         struct zone *zone;
7919
7920         for_each_online_pgdat(pgdat)
7921                 pgdat->min_unmapped_pages = 0;
7922
7923         for_each_zone(zone)
7924                 zone->zone_pgdat->min_unmapped_pages += (zone_managed_pages(zone) *
7925                                                          sysctl_min_unmapped_ratio) / 100;
7926 }
7927
7928
7929 int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *table, int write,
7930         void __user *buffer, size_t *length, loff_t *ppos)
7931 {
7932         int rc;
7933
7934         rc = proc_dointvec_minmax(table, write, buffer, length, ppos);
7935         if (rc)
7936                 return rc;
7937
7938         setup_min_unmapped_ratio();
7939
7940         return 0;
7941 }
7942
7943 static void setup_min_slab_ratio(void)
7944 {
7945         pg_data_t *pgdat;
7946         struct zone *zone;
7947
7948         for_each_online_pgdat(pgdat)
7949                 pgdat->min_slab_pages = 0;
7950
7951         for_each_zone(zone)
7952                 zone->zone_pgdat->min_slab_pages += (zone_managed_pages(zone) *
7953                                                      sysctl_min_slab_ratio) / 100;
7954 }
7955
7956 int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *table, int write,
7957         void __user *buffer, size_t *length, loff_t *ppos)
7958 {
7959         int rc;
7960
7961         rc = proc_dointvec_minmax(table, write, buffer, length, ppos);
7962         if (rc)
7963                 return rc;
7964
7965         setup_min_slab_ratio();
7966
7967         return 0;
7968 }
7969 #endif
7970
7971 /*
7972  * lowmem_reserve_ratio_sysctl_handler - just a wrapper around
7973  *      proc_dointvec() so that we can call setup_per_zone_lowmem_reserve()
7974  *      whenever sysctl_lowmem_reserve_ratio changes.
7975  *
7976  * The reserve ratio obviously has absolutely no relation with the
7977  * minimum watermarks. The lowmem reserve ratio can only make sense
7978  * if in function of the boot time zone sizes.
7979  */
7980 int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *table, int write,
7981         void __user *buffer, size_t *length, loff_t *ppos)
7982 {
7983         proc_dointvec_minmax(table, write, buffer, length, ppos);
7984         setup_per_zone_lowmem_reserve();
7985         return 0;
7986 }
7987
7988 /*
7989  * percpu_pagelist_fraction - changes the pcp->high for each zone on each
7990  * cpu.  It is the fraction of total pages in each zone that a hot per cpu
7991  * pagelist can have before it gets flushed back to buddy allocator.
7992  */
7993 int percpu_pagelist_fraction_sysctl_handler(struct ctl_table *table, int write,
7994         void __user *buffer, size_t *length, loff_t *ppos)
7995 {
7996         struct zone *zone;
7997         int old_percpu_pagelist_fraction;
7998         int ret;
7999
8000         mutex_lock(&pcp_batch_high_lock);
8001         old_percpu_pagelist_fraction = percpu_pagelist_fraction;
8002
8003         ret = proc_dointvec_minmax(table, write, buffer, length, ppos);
8004         if (!write || ret < 0)
8005                 goto out;
8006
8007         /* Sanity checking to avoid pcp imbalance */
8008         if (percpu_pagelist_fraction &&
8009             percpu_pagelist_fraction < MIN_PERCPU_PAGELIST_FRACTION) {
8010                 percpu_pagelist_fraction = old_percpu_pagelist_fraction;
8011                 ret = -EINVAL;
8012                 goto out;
8013         }
8014
8015         /* No change? */
8016         if (percpu_pagelist_fraction == old_percpu_pagelist_fraction)
8017                 goto out;
8018
8019         for_each_populated_zone(zone) {
8020                 unsigned int cpu;
8021
8022                 for_each_possible_cpu(cpu)
8023                         pageset_set_high_and_batch(zone,
8024                                         per_cpu_ptr(zone->pageset, cpu));
8025         }
8026 out:
8027         mutex_unlock(&pcp_batch_high_lock);
8028         return ret;
8029 }
8030
8031 #ifndef __HAVE_ARCH_RESERVED_KERNEL_PAGES
8032 /*
8033  * Returns the number of pages that arch has reserved but
8034  * is not known to alloc_large_system_hash().
8035  */
8036 static unsigned long __init arch_reserved_kernel_pages(void)
8037 {
8038         return 0;
8039 }
8040 #endif
8041
8042 /*
8043  * Adaptive scale is meant to reduce sizes of hash tables on large memory
8044  * machines. As memory size is increased the scale is also increased but at
8045  * slower pace.  Starting from ADAPT_SCALE_BASE (64G), every time memory
8046  * quadruples the scale is increased by one, which means the size of hash table
8047  * only doubles, instead of quadrupling as well.
8048  * Because 32-bit systems cannot have large physical memory, where this scaling
8049  * makes sense, it is disabled on such platforms.
8050  */
8051 #if __BITS_PER_LONG > 32
8052 #define ADAPT_SCALE_BASE        (64ul << 30)
8053 #define ADAPT_SCALE_SHIFT       2
8054 #define ADAPT_SCALE_NPAGES      (ADAPT_SCALE_BASE >> PAGE_SHIFT)
8055 #endif
8056
8057 /*
8058  * allocate a large system hash table from bootmem
8059  * - it is assumed that the hash table must contain an exact power-of-2
8060  *   quantity of entries
8061  * - limit is the number of hash buckets, not the total allocation size
8062  */
8063 void *__init alloc_large_system_hash(const char *tablename,
8064                                      unsigned long bucketsize,
8065                                      unsigned long numentries,
8066                                      int scale,
8067                                      int flags,
8068                                      unsigned int *_hash_shift,
8069                                      unsigned int *_hash_mask,
8070                                      unsigned long low_limit,
8071                                      unsigned long high_limit)
8072 {
8073         unsigned long long max = high_limit;
8074         unsigned long log2qty, size;
8075         void *table = NULL;
8076         gfp_t gfp_flags;
8077         bool virt;
8078
8079         /* allow the kernel cmdline to have a say */
8080         if (!numentries) {
8081                 /* round applicable memory size up to nearest megabyte */
8082                 numentries = nr_kernel_pages;
8083                 numentries -= arch_reserved_kernel_pages();
8084
8085                 /* It isn't necessary when PAGE_SIZE >= 1MB */
8086                 if (PAGE_SHIFT < 20)
8087                         numentries = round_up(numentries, (1<<20)/PAGE_SIZE);
8088
8089 #if __BITS_PER_LONG > 32
8090                 if (!high_limit) {
8091                         unsigned long adapt;
8092
8093                         for (adapt = ADAPT_SCALE_NPAGES; adapt < numentries;
8094                              adapt <<= ADAPT_SCALE_SHIFT)
8095                                 scale++;
8096                 }
8097 #endif
8098
8099                 /* limit to 1 bucket per 2^scale bytes of low memory */
8100                 if (scale > PAGE_SHIFT)
8101                         numentries >>= (scale - PAGE_SHIFT);
8102                 else
8103                         numentries <<= (PAGE_SHIFT - scale);
8104
8105                 /* Make sure we've got at least a 0-order allocation.. */
8106                 if (unlikely(flags & HASH_SMALL)) {
8107                         /* Makes no sense without HASH_EARLY */
8108                         WARN_ON(!(flags & HASH_EARLY));
8109                         if (!(numentries >> *_hash_shift)) {
8110                                 numentries = 1UL << *_hash_shift;
8111                                 BUG_ON(!numentries);
8112                         }
8113                 } else if (unlikely((numentries * bucketsize) < PAGE_SIZE))
8114                         numentries = PAGE_SIZE / bucketsize;
8115         }
8116         numentries = roundup_pow_of_two(numentries);
8117
8118         /* limit allocation size to 1/16 total memory by default */
8119         if (max == 0) {
8120                 max = ((unsigned long long)nr_all_pages << PAGE_SHIFT) >> 4;
8121                 do_div(max, bucketsize);
8122         }
8123         max = min(max, 0x80000000ULL);
8124
8125         if (numentries < low_limit)
8126                 numentries = low_limit;
8127         if (numentries > max)
8128                 numentries = max;
8129
8130         log2qty = ilog2(numentries);
8131
8132         gfp_flags = (flags & HASH_ZERO) ? GFP_ATOMIC | __GFP_ZERO : GFP_ATOMIC;
8133         do {
8134                 virt = false;
8135                 size = bucketsize << log2qty;
8136                 if (flags & HASH_EARLY) {
8137                         if (flags & HASH_ZERO)
8138                                 table = memblock_alloc(size, SMP_CACHE_BYTES);
8139                         else
8140                                 table = memblock_alloc_raw(size,
8141                                                            SMP_CACHE_BYTES);
8142                 } else if (get_order(size) >= MAX_ORDER || hashdist) {
8143                         table = __vmalloc(size, gfp_flags, PAGE_KERNEL);
8144                         virt = true;
8145                 } else {
8146                         /*
8147                          * If bucketsize is not a power-of-two, we may free
8148                          * some pages at the end of hash table which
8149                          * alloc_pages_exact() automatically does
8150                          */
8151                         table = alloc_pages_exact(size, gfp_flags);
8152                         kmemleak_alloc(table, size, 1, gfp_flags);
8153                 }
8154         } while (!table && size > PAGE_SIZE && --log2qty);
8155
8156         if (!table)
8157                 panic("Failed to allocate %s hash table\n", tablename);
8158
8159         pr_info("%s hash table entries: %ld (order: %d, %lu bytes, %s)\n",
8160                 tablename, 1UL << log2qty, ilog2(size) - PAGE_SHIFT, size,
8161                 virt ? "vmalloc" : "linear");
8162
8163         if (_hash_shift)
8164                 *_hash_shift = log2qty;
8165         if (_hash_mask)
8166                 *_hash_mask = (1 << log2qty) - 1;
8167
8168         return table;
8169 }
8170
8171 /*
8172  * This function checks whether pageblock includes unmovable pages or not.
8173  * If @count is not zero, it is okay to include less @count unmovable pages
8174  *
8175  * PageLRU check without isolation or lru_lock could race so that
8176  * MIGRATE_MOVABLE block might include unmovable pages. And __PageMovable
8177  * check without lock_page also may miss some movable non-lru pages at
8178  * race condition. So you can't expect this function should be exact.
8179  */
8180 bool has_unmovable_pages(struct zone *zone, struct page *page, int count,
8181                          int migratetype, int flags)
8182 {
8183         unsigned long found;
8184         unsigned long iter = 0;
8185         unsigned long pfn = page_to_pfn(page);
8186         const char *reason = "unmovable page";
8187
8188         /*
8189          * TODO we could make this much more efficient by not checking every
8190          * page in the range if we know all of them are in MOVABLE_ZONE and
8191          * that the movable zone guarantees that pages are migratable but
8192          * the later is not the case right now unfortunatelly. E.g. movablecore
8193          * can still lead to having bootmem allocations in zone_movable.
8194          */
8195
8196         if (is_migrate_cma_page(page)) {
8197                 /*
8198                  * CMA allocations (alloc_contig_range) really need to mark
8199                  * isolate CMA pageblocks even when they are not movable in fact
8200                  * so consider them movable here.
8201                  */
8202                 if (is_migrate_cma(migratetype))
8203                         return false;
8204
8205                 reason = "CMA page";
8206                 goto unmovable;
8207         }
8208
8209         for (found = 0; iter < pageblock_nr_pages; iter++) {
8210                 unsigned long check = pfn + iter;
8211
8212                 if (!pfn_valid_within(check))
8213                         continue;
8214
8215                 page = pfn_to_page(check);
8216
8217                 if (PageReserved(page))
8218                         goto unmovable;
8219
8220                 /*
8221                  * If the zone is movable and we have ruled out all reserved
8222                  * pages then it should be reasonably safe to assume the rest
8223                  * is movable.
8224                  */
8225                 if (zone_idx(zone) == ZONE_MOVABLE)
8226                         continue;
8227
8228                 /*
8229                  * Hugepages are not in LRU lists, but they're movable.
8230                  * We need not scan over tail pages because we don't
8231                  * handle each tail page individually in migration.
8232                  */
8233                 if (PageHuge(page)) {
8234                         struct page *head = compound_head(page);
8235                         unsigned int skip_pages;
8236
8237                         if (!hugepage_migration_supported(page_hstate(head)))
8238                                 goto unmovable;
8239
8240                         skip_pages = compound_nr(head) - (page - head);
8241                         iter += skip_pages - 1;
8242                         continue;
8243                 }
8244
8245                 /*
8246                  * We can't use page_count without pin a page
8247                  * because another CPU can free compound page.
8248                  * This check already skips compound tails of THP
8249                  * because their page->_refcount is zero at all time.
8250                  */
8251                 if (!page_ref_count(page)) {
8252                         if (PageBuddy(page))
8253                                 iter += (1 << page_order(page)) - 1;
8254                         continue;
8255                 }
8256
8257                 /*
8258                  * The HWPoisoned page may be not in buddy system, and
8259                  * page_count() is not 0.
8260                  */
8261                 if ((flags & SKIP_HWPOISON) && PageHWPoison(page))
8262                         continue;
8263
8264                 if (__PageMovable(page))
8265                         continue;
8266
8267                 if (!PageLRU(page))
8268                         found++;
8269                 /*
8270                  * If there are RECLAIMABLE pages, we need to check
8271                  * it.  But now, memory offline itself doesn't call
8272                  * shrink_node_slabs() and it still to be fixed.
8273                  */
8274                 /*
8275                  * If the page is not RAM, page_count()should be 0.
8276                  * we don't need more check. This is an _used_ not-movable page.
8277                  *
8278                  * The problematic thing here is PG_reserved pages. PG_reserved
8279                  * is set to both of a memory hole page and a _used_ kernel
8280                  * page at boot.
8281                  */
8282                 if (found > count)
8283                         goto unmovable;
8284         }
8285         return false;
8286 unmovable:
8287         WARN_ON_ONCE(zone_idx(zone) == ZONE_MOVABLE);
8288         if (flags & REPORT_FAILURE)
8289                 dump_page(pfn_to_page(pfn + iter), reason);
8290         return true;
8291 }
8292
8293 #ifdef CONFIG_CONTIG_ALLOC
8294 static unsigned long pfn_max_align_down(unsigned long pfn)
8295 {
8296         return pfn & ~(max_t(unsigned long, MAX_ORDER_NR_PAGES,
8297                              pageblock_nr_pages) - 1);
8298 }
8299
8300 static unsigned long pfn_max_align_up(unsigned long pfn)
8301 {
8302         return ALIGN(pfn, max_t(unsigned long, MAX_ORDER_NR_PAGES,
8303                                 pageblock_nr_pages));
8304 }
8305
8306 /* [start, end) must belong to a single zone. */
8307 static int __alloc_contig_migrate_range(struct compact_control *cc,
8308                                         unsigned long start, unsigned long end)
8309 {
8310         /* This function is based on compact_zone() from compaction.c. */
8311         unsigned long nr_reclaimed;
8312         unsigned long pfn = start;
8313         unsigned int tries = 0;
8314         int ret = 0;
8315
8316         migrate_prep();
8317
8318         while (pfn < end || !list_empty(&cc->migratepages)) {
8319                 if (fatal_signal_pending(current)) {
8320                         ret = -EINTR;
8321                         break;
8322                 }
8323
8324                 if (list_empty(&cc->migratepages)) {
8325                         cc->nr_migratepages = 0;
8326                         pfn = isolate_migratepages_range(cc, pfn, end);
8327                         if (!pfn) {
8328                                 ret = -EINTR;
8329                                 break;
8330                         }
8331                         tries = 0;
8332                 } else if (++tries == 5) {
8333                         ret = ret < 0 ? ret : -EBUSY;
8334                         break;
8335                 }
8336
8337                 nr_reclaimed = reclaim_clean_pages_from_list(cc->zone,
8338                                                         &cc->migratepages);
8339                 cc->nr_migratepages -= nr_reclaimed;
8340
8341                 ret = migrate_pages(&cc->migratepages, alloc_migrate_target,
8342                                     NULL, 0, cc->mode, MR_CONTIG_RANGE);
8343         }
8344         if (ret < 0) {
8345                 putback_movable_pages(&cc->migratepages);
8346                 return ret;
8347         }
8348         return 0;
8349 }
8350
8351 /**
8352  * alloc_contig_range() -- tries to allocate given range of pages
8353  * @start:      start PFN to allocate
8354  * @end:        one-past-the-last PFN to allocate
8355  * @migratetype:        migratetype of the underlaying pageblocks (either
8356  *                      #MIGRATE_MOVABLE or #MIGRATE_CMA).  All pageblocks
8357  *                      in range must have the same migratetype and it must
8358  *                      be either of the two.
8359  * @gfp_mask:   GFP mask to use during compaction
8360  *
8361  * The PFN range does not have to be pageblock or MAX_ORDER_NR_PAGES
8362  * aligned.  The PFN range must belong to a single zone.
8363  *
8364  * The first thing this routine does is attempt to MIGRATE_ISOLATE all
8365  * pageblocks in the range.  Once isolated, the pageblocks should not
8366  * be modified by others.
8367  *
8368  * Return: zero on success or negative error code.  On success all
8369  * pages which PFN is in [start, end) are allocated for the caller and
8370  * need to be freed with free_contig_range().
8371  */
8372 int alloc_contig_range(unsigned long start, unsigned long end,
8373                        unsigned migratetype, gfp_t gfp_mask)
8374 {
8375         unsigned long outer_start, outer_end;
8376         unsigned int order;
8377         int ret = 0;
8378
8379         struct compact_control cc = {
8380                 .nr_migratepages = 0,
8381                 .order = -1,
8382                 .zone = page_zone(pfn_to_page(start)),
8383                 .mode = MIGRATE_SYNC,
8384                 .ignore_skip_hint = true,
8385                 .no_set_skip_hint = true,
8386                 .gfp_mask = current_gfp_context(gfp_mask),
8387         };
8388         INIT_LIST_HEAD(&cc.migratepages);
8389
8390         /*
8391          * What we do here is we mark all pageblocks in range as
8392          * MIGRATE_ISOLATE.  Because pageblock and max order pages may
8393          * have different sizes, and due to the way page allocator
8394          * work, we align the range to biggest of the two pages so
8395          * that page allocator won't try to merge buddies from
8396          * different pageblocks and change MIGRATE_ISOLATE to some
8397          * other migration type.
8398          *
8399          * Once the pageblocks are marked as MIGRATE_ISOLATE, we
8400          * migrate the pages from an unaligned range (ie. pages that
8401          * we are interested in).  This will put all the pages in
8402          * range back to page allocator as MIGRATE_ISOLATE.
8403          *
8404          * When this is done, we take the pages in range from page
8405          * allocator removing them from the buddy system.  This way
8406          * page allocator will never consider using them.
8407          *
8408          * This lets us mark the pageblocks back as
8409          * MIGRATE_CMA/MIGRATE_MOVABLE so that free pages in the
8410          * aligned range but not in the unaligned, original range are
8411          * put back to page allocator so that buddy can use them.
8412          */
8413
8414         ret = start_isolate_page_range(pfn_max_align_down(start),
8415                                        pfn_max_align_up(end), migratetype, 0);
8416         if (ret < 0)
8417                 return ret;
8418
8419         /*
8420          * In case of -EBUSY, we'd like to know which page causes problem.
8421          * So, just fall through. test_pages_isolated() has a tracepoint
8422          * which will report the busy page.
8423          *
8424          * It is possible that busy pages could become available before
8425          * the call to test_pages_isolated, and the range will actually be
8426          * allocated.  So, if we fall through be sure to clear ret so that
8427          * -EBUSY is not accidentally used or returned to caller.
8428          */
8429         ret = __alloc_contig_migrate_range(&cc, start, end);
8430         if (ret && ret != -EBUSY)
8431                 goto done;
8432         ret =0;
8433
8434         /*
8435          * Pages from [start, end) are within a MAX_ORDER_NR_PAGES
8436          * aligned blocks that are marked as MIGRATE_ISOLATE.  What's
8437          * more, all pages in [start, end) are free in page allocator.
8438          * What we are going to do is to allocate all pages from
8439          * [start, end) (that is remove them from page allocator).
8440          *
8441          * The only problem is that pages at the beginning and at the
8442          * end of interesting range may be not aligned with pages that
8443          * page allocator holds, ie. they can be part of higher order
8444          * pages.  Because of this, we reserve the bigger range and
8445          * once this is done free the pages we are not interested in.
8446          *
8447          * We don't have to hold zone->lock here because the pages are
8448          * isolated thus they won't get removed from buddy.
8449          */
8450
8451         lru_add_drain_all();
8452
8453         order = 0;
8454         outer_start = start;
8455         while (!PageBuddy(pfn_to_page(outer_start))) {
8456                 if (++order >= MAX_ORDER) {
8457                         outer_start = start;
8458                         break;
8459                 }
8460                 outer_start &= ~0UL << order;
8461         }
8462
8463         if (outer_start != start) {
8464                 order = page_order(pfn_to_page(outer_start));
8465
8466                 /*
8467                  * outer_start page could be small order buddy page and
8468                  * it doesn't include start page. Adjust outer_start
8469                  * in this case to report failed page properly
8470                  * on tracepoint in test_pages_isolated()
8471                  */
8472                 if (outer_start + (1UL << order) <= start)
8473                         outer_start = start;
8474         }
8475
8476         /* Make sure the range is really isolated. */
8477         if (test_pages_isolated(outer_start, end, false)) {
8478                 pr_info_ratelimited("%s: [%lx, %lx) PFNs busy\n",
8479                         __func__, outer_start, end);
8480                 ret = -EBUSY;
8481                 goto done;
8482         }
8483
8484         /* Grab isolated pages from freelists. */
8485         outer_end = isolate_freepages_range(&cc, outer_start, end);
8486         if (!outer_end) {
8487                 ret = -EBUSY;
8488                 goto done;
8489         }
8490
8491         /* Free head and tail (if any) */
8492         if (start != outer_start)
8493                 free_contig_range(outer_start, start - outer_start);
8494         if (end != outer_end)
8495                 free_contig_range(end, outer_end - end);
8496
8497 done:
8498         undo_isolate_page_range(pfn_max_align_down(start),
8499                                 pfn_max_align_up(end), migratetype);
8500         return ret;
8501 }
8502 #endif /* CONFIG_CONTIG_ALLOC */
8503
8504 void free_contig_range(unsigned long pfn, unsigned int nr_pages)
8505 {
8506         unsigned int count = 0;
8507
8508         for (; nr_pages--; pfn++) {
8509                 struct page *page = pfn_to_page(pfn);
8510
8511                 count += page_count(page) != 1;
8512                 __free_page(page);
8513         }
8514         WARN(count != 0, "%d pages are still in use!\n", count);
8515 }
8516
8517 #ifdef CONFIG_MEMORY_HOTPLUG
8518 /*
8519  * The zone indicated has a new number of managed_pages; batch sizes and percpu
8520  * page high values need to be recalulated.
8521  */
8522 void __meminit zone_pcp_update(struct zone *zone)
8523 {
8524         unsigned cpu;
8525         mutex_lock(&pcp_batch_high_lock);
8526         for_each_possible_cpu(cpu)
8527                 pageset_set_high_and_batch(zone,
8528                                 per_cpu_ptr(zone->pageset, cpu));
8529         mutex_unlock(&pcp_batch_high_lock);
8530 }
8531 #endif
8532
8533 void zone_pcp_reset(struct zone *zone)
8534 {
8535         unsigned long flags;
8536         int cpu;
8537         struct per_cpu_pageset *pset;
8538
8539         /* avoid races with drain_pages()  */
8540         local_irq_save(flags);
8541         if (zone->pageset != &boot_pageset) {
8542                 for_each_online_cpu(cpu) {
8543                         pset = per_cpu_ptr(zone->pageset, cpu);
8544                         drain_zonestat(zone, pset);
8545                 }
8546                 free_percpu(zone->pageset);
8547                 zone->pageset = &boot_pageset;
8548         }
8549         local_irq_restore(flags);
8550 }
8551
8552 #ifdef CONFIG_MEMORY_HOTREMOVE
8553 /*
8554  * All pages in the range must be in a single zone and isolated
8555  * before calling this.
8556  */
8557 unsigned long
8558 __offline_isolated_pages(unsigned long start_pfn, unsigned long end_pfn)
8559 {
8560         struct page *page;
8561         struct zone *zone;
8562         unsigned int order, i;
8563         unsigned long pfn;
8564         unsigned long flags;
8565         unsigned long offlined_pages = 0;
8566
8567         /* find the first valid pfn */
8568         for (pfn = start_pfn; pfn < end_pfn; pfn++)
8569                 if (pfn_valid(pfn))
8570                         break;
8571         if (pfn == end_pfn)
8572                 return offlined_pages;
8573
8574         offline_mem_sections(pfn, end_pfn);
8575         zone = page_zone(pfn_to_page(pfn));
8576         spin_lock_irqsave(&zone->lock, flags);
8577         pfn = start_pfn;
8578         while (pfn < end_pfn) {
8579                 if (!pfn_valid(pfn)) {
8580                         pfn++;
8581                         continue;
8582                 }
8583                 page = pfn_to_page(pfn);
8584                 /*
8585                  * The HWPoisoned page may be not in buddy system, and
8586                  * page_count() is not 0.
8587                  */
8588                 if (unlikely(!PageBuddy(page) && PageHWPoison(page))) {
8589                         pfn++;
8590                         SetPageReserved(page);
8591                         offlined_pages++;
8592                         continue;
8593                 }
8594
8595                 BUG_ON(page_count(page));
8596                 BUG_ON(!PageBuddy(page));
8597                 order = page_order(page);
8598                 offlined_pages += 1 << order;
8599 #ifdef CONFIG_DEBUG_VM
8600                 pr_info("remove from free list %lx %d %lx\n",
8601                         pfn, 1 << order, end_pfn);
8602 #endif
8603                 del_page_from_free_area(page, &zone->free_area[order]);
8604                 for (i = 0; i < (1 << order); i++)
8605                         SetPageReserved((page+i));
8606                 pfn += (1 << order);
8607         }
8608         spin_unlock_irqrestore(&zone->lock, flags);
8609
8610         return offlined_pages;
8611 }
8612 #endif
8613
8614 bool is_free_buddy_page(struct page *page)
8615 {
8616         struct zone *zone = page_zone(page);
8617         unsigned long pfn = page_to_pfn(page);
8618         unsigned long flags;
8619         unsigned int order;
8620
8621         spin_lock_irqsave(&zone->lock, flags);
8622         for (order = 0; order < MAX_ORDER; order++) {
8623                 struct page *page_head = page - (pfn & ((1 << order) - 1));
8624
8625                 if (PageBuddy(page_head) && page_order(page_head) >= order)
8626                         break;
8627         }
8628         spin_unlock_irqrestore(&zone->lock, flags);
8629
8630         return order < MAX_ORDER;
8631 }
8632
8633 #ifdef CONFIG_MEMORY_FAILURE
8634 /*
8635  * Set PG_hwpoison flag if a given page is confirmed to be a free page.  This
8636  * test is performed under the zone lock to prevent a race against page
8637  * allocation.
8638  */
8639 bool set_hwpoison_free_buddy_page(struct page *page)
8640 {
8641         struct zone *zone = page_zone(page);
8642         unsigned long pfn = page_to_pfn(page);
8643         unsigned long flags;
8644         unsigned int order;
8645         bool hwpoisoned = false;
8646
8647         spin_lock_irqsave(&zone->lock, flags);
8648         for (order = 0; order < MAX_ORDER; order++) {
8649                 struct page *page_head = page - (pfn & ((1 << order) - 1));
8650
8651                 if (PageBuddy(page_head) && page_order(page_head) >= order) {
8652                         if (!TestSetPageHWPoison(page))
8653                                 hwpoisoned = true;
8654                         break;
8655                 }
8656         }
8657         spin_unlock_irqrestore(&zone->lock, flags);
8658
8659         return hwpoisoned;
8660 }
8661 #endif