LCOV - code coverage report
Current view: top level - mm - page_alloc.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 1277 2467 51.8 %
Date: 2022-03-28 15:32:58 Functions: 100 172 58.1 %
Branches: 466 1877 24.8 %

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

Generated by: LCOV version 1.14