LCOV - code coverage report
Current view: top level - mm - mempolicy.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 193 1184 16.3 %
Date: 2022-03-28 13:20:08 Functions: 21 84 25.0 %
Branches: 89 819 10.9 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       2                 :            : /*
       3                 :            :  * Simple NUMA memory policy for the Linux kernel.
       4                 :            :  *
       5                 :            :  * Copyright 2003,2004 Andi Kleen, SuSE Labs.
       6                 :            :  * (C) Copyright 2005 Christoph Lameter, Silicon Graphics, Inc.
       7                 :            :  *
       8                 :            :  * NUMA policy allows the user to give hints in which node(s) memory should
       9                 :            :  * be allocated.
      10                 :            :  *
      11                 :            :  * Support four policies per VMA and per process:
      12                 :            :  *
      13                 :            :  * The VMA policy has priority over the process policy for a page fault.
      14                 :            :  *
      15                 :            :  * interleave     Allocate memory interleaved over a set of nodes,
      16                 :            :  *                with normal fallback if it fails.
      17                 :            :  *                For VMA based allocations this interleaves based on the
      18                 :            :  *                offset into the backing object or offset into the mapping
      19                 :            :  *                for anonymous memory. For process policy an process counter
      20                 :            :  *                is used.
      21                 :            :  *
      22                 :            :  * bind           Only allocate memory on a specific set of nodes,
      23                 :            :  *                no fallback.
      24                 :            :  *                FIXME: memory is allocated starting with the first node
      25                 :            :  *                to the last. It would be better if bind would truly restrict
      26                 :            :  *                the allocation to memory nodes instead
      27                 :            :  *
      28                 :            :  * preferred       Try a specific node first before normal fallback.
      29                 :            :  *                As a special case NUMA_NO_NODE here means do the allocation
      30                 :            :  *                on the local CPU. This is normally identical to default,
      31                 :            :  *                but useful to set in a VMA when you have a non default
      32                 :            :  *                process policy.
      33                 :            :  *
      34                 :            :  * default        Allocate on the local node first, or when on a VMA
      35                 :            :  *                use the process policy. This is what Linux always did
      36                 :            :  *                in a NUMA aware kernel and still does by, ahem, default.
      37                 :            :  *
      38                 :            :  * The process policy is applied for most non interrupt memory allocations
      39                 :            :  * in that process' context. Interrupts ignore the policies and always
      40                 :            :  * try to allocate on the local CPU. The VMA policy is only applied for memory
      41                 :            :  * allocations for a VMA in the VM.
      42                 :            :  *
      43                 :            :  * Currently there are a few corner cases in swapping where the policy
      44                 :            :  * is not applied, but the majority should be handled. When process policy
      45                 :            :  * is used it is not remembered over swap outs/swap ins.
      46                 :            :  *
      47                 :            :  * Only the highest zone in the zone hierarchy gets policied. Allocations
      48                 :            :  * requesting a lower zone just use default policy. This implies that
      49                 :            :  * on systems with highmem kernel lowmem allocation don't get policied.
      50                 :            :  * Same with GFP_DMA allocations.
      51                 :            :  *
      52                 :            :  * For shmfs/tmpfs/hugetlbfs shared memory the policy is shared between
      53                 :            :  * all users and remembered even when nobody has memory mapped.
      54                 :            :  */
      55                 :            : 
      56                 :            : /* Notebook:
      57                 :            :    fix mmap readahead to honour policy and enable policy for any page cache
      58                 :            :    object
      59                 :            :    statistics for bigpages
      60                 :            :    global policy for page cache? currently it uses process policy. Requires
      61                 :            :    first item above.
      62                 :            :    handle mremap for shared memory (currently ignored for the policy)
      63                 :            :    grows down?
      64                 :            :    make bind policy root only? It can trigger oom much faster and the
      65                 :            :    kernel is not always grateful with that.
      66                 :            : */
      67                 :            : 
      68                 :            : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
      69                 :            : 
      70                 :            : #include <linux/mempolicy.h>
      71                 :            : #include <linux/pagewalk.h>
      72                 :            : #include <linux/highmem.h>
      73                 :            : #include <linux/hugetlb.h>
      74                 :            : #include <linux/kernel.h>
      75                 :            : #include <linux/sched.h>
      76                 :            : #include <linux/sched/mm.h>
      77                 :            : #include <linux/sched/numa_balancing.h>
      78                 :            : #include <linux/sched/task.h>
      79                 :            : #include <linux/nodemask.h>
      80                 :            : #include <linux/cpuset.h>
      81                 :            : #include <linux/slab.h>
      82                 :            : #include <linux/string.h>
      83                 :            : #include <linux/export.h>
      84                 :            : #include <linux/nsproxy.h>
      85                 :            : #include <linux/interrupt.h>
      86                 :            : #include <linux/init.h>
      87                 :            : #include <linux/compat.h>
      88                 :            : #include <linux/ptrace.h>
      89                 :            : #include <linux/swap.h>
      90                 :            : #include <linux/seq_file.h>
      91                 :            : #include <linux/proc_fs.h>
      92                 :            : #include <linux/migrate.h>
      93                 :            : #include <linux/ksm.h>
      94                 :            : #include <linux/rmap.h>
      95                 :            : #include <linux/security.h>
      96                 :            : #include <linux/syscalls.h>
      97                 :            : #include <linux/ctype.h>
      98                 :            : #include <linux/mm_inline.h>
      99                 :            : #include <linux/mmu_notifier.h>
     100                 :            : #include <linux/printk.h>
     101                 :            : #include <linux/swapops.h>
     102                 :            : 
     103                 :            : #include <asm/tlbflush.h>
     104                 :            : #include <linux/uaccess.h>
     105                 :            : 
     106                 :            : #include "internal.h"
     107                 :            : 
     108                 :            : /* Internal flags */
     109                 :            : #define MPOL_MF_DISCONTIG_OK (MPOL_MF_INTERNAL << 0)      /* Skip checks for continuous vmas */
     110                 :            : #define MPOL_MF_INVERT (MPOL_MF_INTERNAL << 1)            /* Invert check for nodemask */
     111                 :            : 
     112                 :            : static struct kmem_cache *policy_cache;
     113                 :            : static struct kmem_cache *sn_cache;
     114                 :            : 
     115                 :            : /* Highest zone. An specific allocation for a zone below that is not
     116                 :            :    policied. */
     117                 :            : enum zone_type policy_zone = 0;
     118                 :            : 
     119                 :            : /*
     120                 :            :  * run-time system-wide default policy => local allocation
     121                 :            :  */
     122                 :            : static struct mempolicy default_policy = {
     123                 :            :         .refcnt = ATOMIC_INIT(1), /* never free it */
     124                 :            :         .mode = MPOL_PREFERRED,
     125                 :            :         .flags = MPOL_F_LOCAL,
     126                 :            : };
     127                 :            : 
     128                 :            : static struct mempolicy preferred_node_policy[MAX_NUMNODES];
     129                 :            : 
     130                 :    4022407 : struct mempolicy *get_task_policy(struct task_struct *p)
     131                 :            : {
     132                 :    4022407 :         struct mempolicy *pol = p->mempolicy;
     133                 :    4022407 :         int node;
     134                 :            : 
     135   [ +  +  -  -  :    4022407 :         if (pol)
             +  -  -  - ]
     136                 :            :                 return pol;
     137                 :            : 
     138   [ +  -  -  -  :    3834928 :         node = numa_node_id();
             +  -  -  - ]
     139   [ +  -  -  -  :    3834928 :         if (node != NUMA_NO_NODE) {
             +  -  -  - ]
     140                 :    3834928 :                 pol = &preferred_node_policy[node];
     141                 :            :                 /* preferred_node_policy is not initialised early in boot */
     142   [ +  +  -  -  :    3834928 :                 if (pol->mode)
             +  -  -  - ]
     143                 :    3833188 :                         return pol;
     144                 :            :         }
     145                 :            : 
     146                 :            :         return &default_policy;
     147                 :            : }
     148                 :            : 
     149                 :            : static const struct mempolicy_operations {
     150                 :            :         int (*create)(struct mempolicy *pol, const nodemask_t *nodes);
     151                 :            :         void (*rebind)(struct mempolicy *pol, const nodemask_t *nodes);
     152                 :            : } mpol_ops[MPOL_MAX];
     153                 :            : 
     154                 :         30 : static inline int mpol_store_user_nodemask(const struct mempolicy *pol)
     155                 :            : {
     156                 :         30 :         return pol->flags & MPOL_MODE_FLAGS;
     157                 :            : }
     158                 :            : 
     159                 :          0 : static void mpol_relative_nodemask(nodemask_t *ret, const nodemask_t *orig,
     160                 :            :                                    const nodemask_t *rel)
     161                 :            : {
     162                 :          0 :         nodemask_t tmp;
     163                 :          0 :         nodes_fold(tmp, *orig, nodes_weight(*rel));
     164                 :          0 :         nodes_onto(*ret, tmp, *rel);
     165                 :          0 : }
     166                 :            : 
     167                 :         30 : static int mpol_new_interleave(struct mempolicy *pol, const nodemask_t *nodes)
     168                 :            : {
     169         [ +  - ]:         30 :         if (nodes_empty(*nodes))
     170                 :            :                 return -EINVAL;
     171                 :         30 :         pol->v.nodes = *nodes;
     172                 :         30 :         return 0;
     173                 :            : }
     174                 :            : 
     175                 :          0 : static int mpol_new_preferred(struct mempolicy *pol, const nodemask_t *nodes)
     176                 :            : {
     177         [ #  # ]:          0 :         if (!nodes)
     178                 :          0 :                 pol->flags |= MPOL_F_LOCAL;  /* local allocation */
     179         [ #  # ]:          0 :         else if (nodes_empty(*nodes))
     180                 :            :                 return -EINVAL;                 /*  no allowed nodes */
     181                 :            :         else
     182                 :          0 :                 pol->v.preferred_node = first_node(*nodes);
     183                 :            :         return 0;
     184                 :            : }
     185                 :            : 
     186                 :          0 : static int mpol_new_bind(struct mempolicy *pol, const nodemask_t *nodes)
     187                 :            : {
     188         [ #  # ]:          0 :         if (nodes_empty(*nodes))
     189                 :            :                 return -EINVAL;
     190                 :          0 :         pol->v.nodes = *nodes;
     191                 :          0 :         return 0;
     192                 :            : }
     193                 :            : 
     194                 :            : /*
     195                 :            :  * mpol_set_nodemask is called after mpol_new() to set up the nodemask, if
     196                 :            :  * any, for the new policy.  mpol_new() has already validated the nodes
     197                 :            :  * parameter with respect to the policy mode and flags.  But, we need to
     198                 :            :  * handle an empty nodemask with MPOL_PREFERRED here.
     199                 :            :  *
     200                 :            :  * Must be called holding task's alloc_lock to protect task's mems_allowed
     201                 :            :  * and mempolicy.  May also be called holding the mmap_semaphore for write.
     202                 :            :  */
     203                 :         90 : static int mpol_set_nodemask(struct mempolicy *pol,
     204                 :            :                      const nodemask_t *nodes, struct nodemask_scratch *nsc)
     205                 :            : {
     206                 :         90 :         int ret;
     207                 :            : 
     208                 :            :         /* if mode is MPOL_DEFAULT, pol is NULL. This is right. */
     209         [ +  + ]:         90 :         if (pol == NULL)
     210                 :            :                 return 0;
     211                 :            :         /* Check N_MEMORY */
     212                 :         30 :         nodes_and(nsc->mask1,
     213                 :            :                   cpuset_current_mems_allowed, node_states[N_MEMORY]);
     214                 :            : 
     215                 :         30 :         VM_BUG_ON(!nodes);
     216   [ -  +  -  - ]:         30 :         if (pol->mode == MPOL_PREFERRED && nodes_empty(*nodes))
     217                 :            :                 nodes = NULL;   /* explicit local allocation */
     218                 :            :         else {
     219         [ -  + ]:         30 :                 if (pol->flags & MPOL_F_RELATIVE_NODES)
     220                 :          0 :                         mpol_relative_nodemask(&nsc->mask2, nodes, &nsc->mask1);
     221                 :            :                 else
     222                 :         30 :                         nodes_and(nsc->mask2, *nodes, nsc->mask1);
     223                 :            : 
     224         [ -  + ]:         30 :                 if (mpol_store_user_nodemask(pol))
     225                 :          0 :                         pol->w.user_nodemask = *nodes;
     226                 :            :                 else
     227                 :         30 :                         pol->w.cpuset_mems_allowed =
     228                 :            :                                                 cpuset_current_mems_allowed;
     229                 :            :         }
     230                 :            : 
     231         [ +  - ]:         30 :         if (nodes)
     232                 :         30 :                 ret = mpol_ops[pol->mode].create(pol, &nsc->mask2);
     233                 :            :         else
     234                 :          0 :                 ret = mpol_ops[pol->mode].create(pol, NULL);
     235                 :            :         return ret;
     236                 :            : }
     237                 :            : 
     238                 :            : /*
     239                 :            :  * This function just creates a new policy, does some check and simple
     240                 :            :  * initialization. You must invoke mpol_set_nodemask() to set nodes.
     241                 :            :  */
     242                 :         90 : static struct mempolicy *mpol_new(unsigned short mode, unsigned short flags,
     243                 :            :                                   nodemask_t *nodes)
     244                 :            : {
     245                 :         90 :         struct mempolicy *policy;
     246                 :            : 
     247                 :         90 :         pr_debug("setting mode %d flags %d nodes[0] %lx\n",
     248                 :            :                  mode, flags, nodes ? nodes_addr(*nodes)[0] : NUMA_NO_NODE);
     249                 :            : 
     250         [ +  + ]:         90 :         if (mode == MPOL_DEFAULT) {
     251   [ -  +  -  - ]:         60 :                 if (nodes && !nodes_empty(*nodes))
     252                 :            :                         return ERR_PTR(-EINVAL);
     253                 :         60 :                 return NULL;
     254                 :            :         }
     255                 :         30 :         VM_BUG_ON(!nodes);
     256                 :            : 
     257                 :            :         /*
     258                 :            :          * MPOL_PREFERRED cannot be used with MPOL_F_STATIC_NODES or
     259                 :            :          * MPOL_F_RELATIVE_NODES if the nodemask is empty (local allocation).
     260                 :            :          * All other modes require a valid pointer to a non-empty nodemask.
     261                 :            :          */
     262         [ -  + ]:         30 :         if (mode == MPOL_PREFERRED) {
     263         [ #  # ]:          0 :                 if (nodes_empty(*nodes)) {
     264   [ #  #  #  # ]:          0 :                         if (((flags & MPOL_F_STATIC_NODES) ||
     265                 :            :                              (flags & MPOL_F_RELATIVE_NODES)))
     266                 :            :                                 return ERR_PTR(-EINVAL);
     267                 :            :                 }
     268         [ -  + ]:         30 :         } else if (mode == MPOL_LOCAL) {
     269   [ #  #  #  # ]:          0 :                 if (!nodes_empty(*nodes) ||
     270         [ #  # ]:          0 :                     (flags & MPOL_F_STATIC_NODES) ||
     271                 :            :                     (flags & MPOL_F_RELATIVE_NODES))
     272                 :            :                         return ERR_PTR(-EINVAL);
     273                 :            :                 mode = MPOL_PREFERRED;
     274         [ +  - ]:         30 :         } else if (nodes_empty(*nodes))
     275                 :            :                 return ERR_PTR(-EINVAL);
     276                 :         30 :         policy = kmem_cache_alloc(policy_cache, GFP_KERNEL);
     277         [ +  - ]:         30 :         if (!policy)
     278                 :            :                 return ERR_PTR(-ENOMEM);
     279                 :         30 :         atomic_set(&policy->refcnt, 1);
     280                 :         30 :         policy->mode = mode;
     281                 :         30 :         policy->flags = flags;
     282                 :            : 
     283                 :         30 :         return policy;
     284                 :            : }
     285                 :            : 
     286                 :            : /* Slow path of a mpol destructor. */
     287                 :         60 : void __mpol_put(struct mempolicy *p)
     288                 :            : {
     289         [ +  - ]:         60 :         if (!atomic_dec_and_test(&p->refcnt))
     290                 :            :                 return;
     291                 :         60 :         kmem_cache_free(policy_cache, p);
     292                 :            : }
     293                 :            : 
     294                 :          0 : static void mpol_rebind_default(struct mempolicy *pol, const nodemask_t *nodes)
     295                 :            : {
     296                 :          0 : }
     297                 :            : 
     298                 :          0 : static void mpol_rebind_nodemask(struct mempolicy *pol, const nodemask_t *nodes)
     299                 :            : {
     300                 :          0 :         nodemask_t tmp;
     301                 :            : 
     302         [ #  # ]:          0 :         if (pol->flags & MPOL_F_STATIC_NODES)
     303                 :          0 :                 nodes_and(tmp, pol->w.user_nodemask, *nodes);
     304         [ #  # ]:          0 :         else if (pol->flags & MPOL_F_RELATIVE_NODES)
     305                 :          0 :                 mpol_relative_nodemask(&tmp, &pol->w.user_nodemask, nodes);
     306                 :            :         else {
     307                 :          0 :                 nodes_remap(tmp, pol->v.nodes,pol->w.cpuset_mems_allowed,
     308                 :            :                                                                 *nodes);
     309                 :          0 :                 pol->w.cpuset_mems_allowed = *nodes;
     310                 :            :         }
     311                 :            : 
     312         [ #  # ]:          0 :         if (nodes_empty(tmp))
     313                 :          0 :                 tmp = *nodes;
     314                 :            : 
     315                 :          0 :         pol->v.nodes = tmp;
     316                 :          0 : }
     317                 :            : 
     318                 :          0 : static void mpol_rebind_preferred(struct mempolicy *pol,
     319                 :            :                                                 const nodemask_t *nodes)
     320                 :            : {
     321                 :          0 :         nodemask_t tmp;
     322                 :            : 
     323         [ #  # ]:          0 :         if (pol->flags & MPOL_F_STATIC_NODES) {
     324                 :          0 :                 int node = first_node(pol->w.user_nodemask);
     325                 :            : 
     326         [ #  # ]:          0 :                 if (node_isset(node, *nodes)) {
     327                 :          0 :                         pol->v.preferred_node = node;
     328                 :          0 :                         pol->flags &= ~MPOL_F_LOCAL;
     329                 :            :                 } else
     330                 :          0 :                         pol->flags |= MPOL_F_LOCAL;
     331         [ #  # ]:          0 :         } else if (pol->flags & MPOL_F_RELATIVE_NODES) {
     332                 :          0 :                 mpol_relative_nodemask(&tmp, &pol->w.user_nodemask, nodes);
     333                 :          0 :                 pol->v.preferred_node = first_node(tmp);
     334         [ #  # ]:          0 :         } else if (!(pol->flags & MPOL_F_LOCAL)) {
     335                 :          0 :                 pol->v.preferred_node = node_remap(pol->v.preferred_node,
     336                 :            :                                                    pol->w.cpuset_mems_allowed,
     337                 :            :                                                    *nodes);
     338                 :          0 :                 pol->w.cpuset_mems_allowed = *nodes;
     339                 :            :         }
     340                 :          0 : }
     341                 :            : 
     342                 :            : /*
     343                 :            :  * mpol_rebind_policy - Migrate a policy to a different set of nodes
     344                 :            :  *
     345                 :            :  * Per-vma policies are protected by mmap_sem. Allocations using per-task
     346                 :            :  * policies are protected by task->mems_allowed_seq to prevent a premature
     347                 :            :  * OOM/allocation failure due to parallel nodemask modification.
     348                 :            :  */
     349                 :          0 : static void mpol_rebind_policy(struct mempolicy *pol, const nodemask_t *newmask)
     350                 :            : {
     351         [ #  # ]:          0 :         if (!pol)
     352                 :            :                 return;
     353   [ #  #  #  #  :          0 :         if (!mpol_store_user_nodemask(pol) && !(pol->flags & MPOL_F_LOCAL) &&
                   #  # ]
     354                 :            :             nodes_equal(pol->w.cpuset_mems_allowed, *newmask))
     355                 :            :                 return;
     356                 :            : 
     357                 :          0 :         mpol_ops[pol->mode].rebind(pol, newmask);
     358                 :            : }
     359                 :            : 
     360                 :            : /*
     361                 :            :  * Wrapper for mpol_rebind_policy() that just requires task
     362                 :            :  * pointer, and updates task mempolicy.
     363                 :            :  *
     364                 :            :  * Called with task's alloc_lock held.
     365                 :            :  */
     366                 :            : 
     367                 :          0 : void mpol_rebind_task(struct task_struct *tsk, const nodemask_t *new)
     368                 :            : {
     369                 :          0 :         mpol_rebind_policy(tsk->mempolicy, new);
     370                 :          0 : }
     371                 :            : 
     372                 :            : /*
     373                 :            :  * Rebind each vma in mm to new nodemask.
     374                 :            :  *
     375                 :            :  * Call holding a reference to mm.  Takes mm->mmap_sem during call.
     376                 :            :  */
     377                 :            : 
     378                 :          0 : void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new)
     379                 :            : {
     380                 :          0 :         struct vm_area_struct *vma;
     381                 :            : 
     382                 :          0 :         down_write(&mm->mmap_sem);
     383         [ #  # ]:          0 :         for (vma = mm->mmap; vma; vma = vma->vm_next)
     384                 :          0 :                 mpol_rebind_policy(vma->vm_policy, new);
     385                 :          0 :         up_write(&mm->mmap_sem);
     386                 :          0 : }
     387                 :            : 
     388                 :            : static const struct mempolicy_operations mpol_ops[MPOL_MAX] = {
     389                 :            :         [MPOL_DEFAULT] = {
     390                 :            :                 .rebind = mpol_rebind_default,
     391                 :            :         },
     392                 :            :         [MPOL_INTERLEAVE] = {
     393                 :            :                 .create = mpol_new_interleave,
     394                 :            :                 .rebind = mpol_rebind_nodemask,
     395                 :            :         },
     396                 :            :         [MPOL_PREFERRED] = {
     397                 :            :                 .create = mpol_new_preferred,
     398                 :            :                 .rebind = mpol_rebind_preferred,
     399                 :            :         },
     400                 :            :         [MPOL_BIND] = {
     401                 :            :                 .create = mpol_new_bind,
     402                 :            :                 .rebind = mpol_rebind_nodemask,
     403                 :            :         },
     404                 :            : };
     405                 :            : 
     406                 :            : static int migrate_page_add(struct page *page, struct list_head *pagelist,
     407                 :            :                                 unsigned long flags);
     408                 :            : 
     409                 :            : struct queue_pages {
     410                 :            :         struct list_head *pagelist;
     411                 :            :         unsigned long flags;
     412                 :            :         nodemask_t *nmask;
     413                 :            :         unsigned long start;
     414                 :            :         unsigned long end;
     415                 :            :         struct vm_area_struct *first;
     416                 :            : };
     417                 :            : 
     418                 :            : /*
     419                 :            :  * Check if the page's nid is in qp->nmask.
     420                 :            :  *
     421                 :            :  * If MPOL_MF_INVERT is set in qp->flags, check if the nid is
     422                 :            :  * in the invert of qp->nmask.
     423                 :            :  */
     424                 :          0 : static inline bool queue_pages_required(struct page *page,
     425                 :            :                                         struct queue_pages *qp)
     426                 :            : {
     427                 :          0 :         int nid = page_to_nid(page);
     428                 :          0 :         unsigned long flags = qp->flags;
     429                 :            : 
     430                 :          0 :         return node_isset(nid, *qp->nmask) == !(flags & MPOL_MF_INVERT);
     431                 :            : }
     432                 :            : 
     433                 :            : /*
     434                 :            :  * queue_pages_pmd() has four possible return values:
     435                 :            :  * 0 - pages are placed on the right node or queued successfully.
     436                 :            :  * 1 - there is unmovable page, and MPOL_MF_MOVE* & MPOL_MF_STRICT were
     437                 :            :  *     specified.
     438                 :            :  * 2 - THP was split.
     439                 :            :  * -EIO - is migration entry or only MPOL_MF_STRICT was specified and an
     440                 :            :  *        existing page was already on a node that does not follow the
     441                 :            :  *        policy.
     442                 :            :  */
     443                 :            : static int queue_pages_pmd(pmd_t *pmd, spinlock_t *ptl, unsigned long addr,
     444                 :            :                                 unsigned long end, struct mm_walk *walk)
     445                 :            : {
     446                 :            :         int ret = 0;
     447                 :            :         struct page *page;
     448                 :            :         struct queue_pages *qp = walk->private;
     449                 :            :         unsigned long flags;
     450                 :            : 
     451                 :            :         if (unlikely(is_pmd_migration_entry(*pmd))) {
     452                 :            :                 ret = -EIO;
     453                 :            :                 goto unlock;
     454                 :            :         }
     455                 :            :         page = pmd_page(*pmd);
     456                 :            :         if (is_huge_zero_page(page)) {
     457                 :            :                 spin_unlock(ptl);
     458                 :            :                 __split_huge_pmd(walk->vma, pmd, addr, false, NULL);
     459                 :            :                 ret = 2;
     460                 :            :                 goto out;
     461                 :            :         }
     462                 :            :         if (!queue_pages_required(page, qp))
     463                 :            :                 goto unlock;
     464                 :            : 
     465                 :            :         flags = qp->flags;
     466                 :            :         /* go to thp migration */
     467                 :            :         if (flags & (MPOL_MF_MOVE | MPOL_MF_MOVE_ALL)) {
     468                 :            :                 if (!vma_migratable(walk->vma) ||
     469                 :            :                     migrate_page_add(page, qp->pagelist, flags)) {
     470                 :            :                         ret = 1;
     471                 :            :                         goto unlock;
     472                 :            :                 }
     473                 :            :         } else
     474                 :            :                 ret = -EIO;
     475                 :            : unlock:
     476                 :            :         spin_unlock(ptl);
     477                 :            : out:
     478                 :            :         return ret;
     479                 :            : }
     480                 :            : 
     481                 :            : /*
     482                 :            :  * Scan through pages checking if pages follow certain conditions,
     483                 :            :  * and move them to the pagelist if they do.
     484                 :            :  *
     485                 :            :  * queue_pages_pte_range() has three possible return values:
     486                 :            :  * 0 - pages are placed on the right node or queued successfully.
     487                 :            :  * 1 - there is unmovable page, and MPOL_MF_MOVE* & MPOL_MF_STRICT were
     488                 :            :  *     specified.
     489                 :            :  * -EIO - only MPOL_MF_STRICT was specified and an existing page was already
     490                 :            :  *        on a node that does not follow the policy.
     491                 :            :  */
     492                 :          0 : static int queue_pages_pte_range(pmd_t *pmd, unsigned long addr,
     493                 :            :                         unsigned long end, struct mm_walk *walk)
     494                 :            : {
     495                 :          0 :         struct vm_area_struct *vma = walk->vma;
     496                 :          0 :         struct page *page;
     497                 :          0 :         struct queue_pages *qp = walk->private;
     498                 :          0 :         unsigned long flags = qp->flags;
     499                 :          0 :         int ret;
     500                 :          0 :         bool has_unmovable = false;
     501                 :          0 :         pte_t *pte;
     502                 :          0 :         spinlock_t *ptl;
     503                 :            : 
     504         [ #  # ]:          0 :         ptl = pmd_trans_huge_lock(pmd, vma);
     505                 :          0 :         if (ptl) {
     506                 :            :                 ret = queue_pages_pmd(pmd, ptl, addr, end, walk);
     507                 :            :                 if (ret != 2)
     508                 :            :                         return ret;
     509                 :            :         }
     510                 :            :         /* THP was split, fall through to pte walk */
     511                 :            : 
     512         [ #  # ]:          0 :         if (pmd_trans_unstable(pmd))
     513                 :            :                 return 0;
     514                 :            : 
     515         [ #  # ]:          0 :         pte = pte_offset_map_lock(walk->mm, pmd, addr, &ptl);
     516         [ #  # ]:          0 :         for (; addr != end; pte++, addr += PAGE_SIZE) {
     517         [ #  # ]:          0 :                 if (!pte_present(*pte))
     518                 :          0 :                         continue;
     519                 :          0 :                 page = vm_normal_page(vma, addr, *pte);
     520         [ #  # ]:          0 :                 if (!page)
     521                 :          0 :                         continue;
     522                 :            :                 /*
     523                 :            :                  * vm_normal_page() filters out zero pages, but there might
     524                 :            :                  * still be PageReserved pages to skip, perhaps in a VDSO.
     525                 :            :                  */
     526         [ #  # ]:          0 :                 if (PageReserved(page))
     527                 :          0 :                         continue;
     528         [ #  # ]:          0 :                 if (!queue_pages_required(page, qp))
     529                 :          0 :                         continue;
     530         [ #  # ]:          0 :                 if (flags & (MPOL_MF_MOVE | MPOL_MF_MOVE_ALL)) {
     531                 :            :                         /* MPOL_MF_STRICT must be specified if we get here */
     532         [ #  # ]:          0 :                         if (!vma_migratable(vma)) {
     533                 :            :                                 has_unmovable = true;
     534                 :            :                                 break;
     535                 :            :                         }
     536                 :            : 
     537                 :            :                         /*
     538                 :            :                          * Do not abort immediately since there may be
     539                 :            :                          * temporary off LRU pages in the range.  Still
     540                 :            :                          * need migrate other LRU pages.
     541                 :            :                          */
     542         [ #  # ]:          0 :                         if (migrate_page_add(page, qp->pagelist, flags))
     543                 :          0 :                                 has_unmovable = true;
     544                 :            :                 } else
     545                 :            :                         break;
     546                 :            :         }
     547                 :          0 :         pte_unmap_unlock(pte - 1, ptl);
     548                 :          0 :         cond_resched();
     549                 :            : 
     550         [ #  # ]:          0 :         if (has_unmovable)
     551                 :            :                 return 1;
     552                 :            : 
     553         [ #  # ]:          0 :         return addr != end ? -EIO : 0;
     554                 :            : }
     555                 :            : 
     556                 :          0 : static int queue_pages_hugetlb(pte_t *pte, unsigned long hmask,
     557                 :            :                                unsigned long addr, unsigned long end,
     558                 :            :                                struct mm_walk *walk)
     559                 :            : {
     560                 :            : #ifdef CONFIG_HUGETLB_PAGE
     561                 :          0 :         struct queue_pages *qp = walk->private;
     562                 :          0 :         unsigned long flags = qp->flags;
     563                 :          0 :         struct page *page;
     564                 :          0 :         spinlock_t *ptl;
     565                 :          0 :         pte_t entry;
     566                 :            : 
     567                 :          0 :         ptl = huge_pte_lock(hstate_vma(walk->vma), walk->mm, pte);
     568         [ #  # ]:          0 :         entry = huge_ptep_get(pte);
     569         [ #  # ]:          0 :         if (!pte_present(entry))
     570                 :          0 :                 goto unlock;
     571         [ #  # ]:          0 :         page = pte_page(entry);
     572         [ #  # ]:          0 :         if (!queue_pages_required(page, qp))
     573                 :          0 :                 goto unlock;
     574                 :            :         /* With MPOL_MF_MOVE, we migrate only unshared hugepage. */
     575         [ #  # ]:          0 :         if (flags & (MPOL_MF_MOVE_ALL) ||
     576   [ #  #  #  # ]:          0 :             (flags & MPOL_MF_MOVE && page_mapcount(page) == 1))
     577                 :          0 :                 isolate_huge_page(page, qp->pagelist);
     578                 :          0 : unlock:
     579                 :          0 :         spin_unlock(ptl);
     580                 :            : #else
     581                 :            :         BUG();
     582                 :            : #endif
     583                 :          0 :         return 0;
     584                 :            : }
     585                 :            : 
     586                 :            : #ifdef CONFIG_NUMA_BALANCING
     587                 :            : /*
     588                 :            :  * This is used to mark a range of virtual addresses to be inaccessible.
     589                 :            :  * These are later cleared by a NUMA hinting fault. Depending on these
     590                 :            :  * faults, pages may be migrated for better NUMA placement.
     591                 :            :  *
     592                 :            :  * This is assuming that NUMA faults are handled using PROT_NONE. If
     593                 :            :  * an architecture makes a different choice, it will need further
     594                 :            :  * changes to the core.
     595                 :            :  */
     596                 :            : unsigned long change_prot_numa(struct vm_area_struct *vma,
     597                 :            :                         unsigned long addr, unsigned long end)
     598                 :            : {
     599                 :            :         int nr_updated;
     600                 :            : 
     601                 :            :         nr_updated = change_protection(vma, addr, end, PAGE_NONE, 0, 1);
     602                 :            :         if (nr_updated)
     603                 :            :                 count_vm_numa_events(NUMA_PTE_UPDATES, nr_updated);
     604                 :            : 
     605                 :            :         return nr_updated;
     606                 :            : }
     607                 :            : #else
     608                 :            : static unsigned long change_prot_numa(struct vm_area_struct *vma,
     609                 :            :                         unsigned long addr, unsigned long end)
     610                 :            : {
     611                 :            :         return 0;
     612                 :            : }
     613                 :            : #endif /* CONFIG_NUMA_BALANCING */
     614                 :            : 
     615                 :          0 : static int queue_pages_test_walk(unsigned long start, unsigned long end,
     616                 :            :                                 struct mm_walk *walk)
     617                 :            : {
     618                 :          0 :         struct vm_area_struct *vma = walk->vma;
     619                 :          0 :         struct queue_pages *qp = walk->private;
     620                 :          0 :         unsigned long endvma = vma->vm_end;
     621                 :          0 :         unsigned long flags = qp->flags;
     622                 :            : 
     623                 :            :         /* range check first */
     624                 :          0 :         VM_BUG_ON((vma->vm_start > start) || (vma->vm_end < end));
     625                 :            : 
     626         [ #  # ]:          0 :         if (!qp->first) {
     627                 :          0 :                 qp->first = vma;
     628         [ #  # ]:          0 :                 if (!(flags & MPOL_MF_DISCONTIG_OK) &&
     629         [ #  # ]:          0 :                         (qp->start < vma->vm_start))
     630                 :            :                         /* hole at head side of range */
     631                 :            :                         return -EFAULT;
     632                 :            :         }
     633         [ #  # ]:          0 :         if (!(flags & MPOL_MF_DISCONTIG_OK) &&
     634         [ #  # ]:          0 :                 ((vma->vm_end < qp->end) &&
     635   [ #  #  #  # ]:          0 :                 (!vma->vm_next || vma->vm_end < vma->vm_next->vm_start)))
     636                 :            :                 /* hole at middle or tail of range */
     637                 :            :                 return -EFAULT;
     638                 :            : 
     639                 :            :         /*
     640                 :            :          * Need check MPOL_MF_STRICT to return -EIO if possible
     641                 :            :          * regardless of vma_migratable
     642                 :            :          */
     643         [ #  # ]:          0 :         if (!vma_migratable(vma) &&
     644         [ #  # ]:          0 :             !(flags & MPOL_MF_STRICT))
     645                 :            :                 return 1;
     646                 :            : 
     647                 :          0 :         if (endvma > end)
     648                 :            :                 endvma = end;
     649                 :            : 
     650         [ #  # ]:          0 :         if (flags & MPOL_MF_LAZY) {
     651                 :            :                 /* Similar to task_numa_work, skip inaccessible VMAs */
     652                 :            :                 if (!is_vm_hugetlb_page(vma) &&
     653                 :            :                         (vma->vm_flags & (VM_READ | VM_EXEC | VM_WRITE)) &&
     654                 :            :                         !(vma->vm_flags & VM_MIXEDMAP))
     655                 :            :                         change_prot_numa(vma, start, endvma);
     656                 :            :                 return 1;
     657                 :            :         }
     658                 :            : 
     659                 :            :         /* queue pages from current vma */
     660         [ #  # ]:          0 :         if (flags & MPOL_MF_VALID)
     661                 :          0 :                 return 0;
     662                 :            :         return 1;
     663                 :            : }
     664                 :            : 
     665                 :            : static const struct mm_walk_ops queue_pages_walk_ops = {
     666                 :            :         .hugetlb_entry          = queue_pages_hugetlb,
     667                 :            :         .pmd_entry              = queue_pages_pte_range,
     668                 :            :         .test_walk              = queue_pages_test_walk,
     669                 :            : };
     670                 :            : 
     671                 :            : /*
     672                 :            :  * Walk through page tables and collect pages to be migrated.
     673                 :            :  *
     674                 :            :  * If pages found in a given range are on a set of nodes (determined by
     675                 :            :  * @nodes and @flags,) it's isolated and queued to the pagelist which is
     676                 :            :  * passed via @private.
     677                 :            :  *
     678                 :            :  * queue_pages_range() has three possible return values:
     679                 :            :  * 1 - there is unmovable page, but MPOL_MF_MOVE* & MPOL_MF_STRICT were
     680                 :            :  *     specified.
     681                 :            :  * 0 - queue pages successfully or no misplaced page.
     682                 :            :  * errno - i.e. misplaced pages with MPOL_MF_STRICT specified (-EIO) or
     683                 :            :  *         memory range specified by nodemask and maxnode points outside
     684                 :            :  *         your accessible address space (-EFAULT)
     685                 :            :  */
     686                 :            : static int
     687                 :          0 : queue_pages_range(struct mm_struct *mm, unsigned long start, unsigned long end,
     688                 :            :                 nodemask_t *nodes, unsigned long flags,
     689                 :            :                 struct list_head *pagelist)
     690                 :            : {
     691                 :          0 :         int err;
     692                 :          0 :         struct queue_pages qp = {
     693                 :            :                 .pagelist = pagelist,
     694                 :            :                 .flags = flags,
     695                 :            :                 .nmask = nodes,
     696                 :            :                 .start = start,
     697                 :            :                 .end = end,
     698                 :            :                 .first = NULL,
     699                 :            :         };
     700                 :            : 
     701                 :          0 :         err = walk_page_range(mm, start, end, &queue_pages_walk_ops, &qp);
     702                 :            : 
     703         [ #  # ]:          0 :         if (!qp.first)
     704                 :            :                 /* whole range in hole */
     705                 :          0 :                 err = -EFAULT;
     706                 :            : 
     707                 :          0 :         return err;
     708                 :            : }
     709                 :            : 
     710                 :            : /*
     711                 :            :  * Apply policy to a single VMA
     712                 :            :  * This must be called with the mmap_sem held for writing.
     713                 :            :  */
     714                 :          0 : static int vma_replace_policy(struct vm_area_struct *vma,
     715                 :            :                                                 struct mempolicy *pol)
     716                 :            : {
     717                 :          0 :         int err;
     718                 :          0 :         struct mempolicy *old;
     719                 :          0 :         struct mempolicy *new;
     720                 :            : 
     721                 :          0 :         pr_debug("vma %lx-%lx/%lx vm_ops %p vm_file %p set_policy %p\n",
     722                 :            :                  vma->vm_start, vma->vm_end, vma->vm_pgoff,
     723                 :            :                  vma->vm_ops, vma->vm_file,
     724                 :            :                  vma->vm_ops ? vma->vm_ops->set_policy : NULL);
     725                 :            : 
     726         [ #  # ]:          0 :         new = mpol_dup(pol);
     727         [ #  # ]:          0 :         if (IS_ERR(new))
     728                 :          0 :                 return PTR_ERR(new);
     729                 :            : 
     730   [ #  #  #  # ]:          0 :         if (vma->vm_ops && vma->vm_ops->set_policy) {
     731                 :          0 :                 err = vma->vm_ops->set_policy(vma, new);
     732         [ #  # ]:          0 :                 if (err)
     733                 :          0 :                         goto err_out;
     734                 :            :         }
     735                 :            : 
     736                 :          0 :         old = vma->vm_policy;
     737                 :          0 :         vma->vm_policy = new; /* protected by mmap_sem */
     738         [ #  # ]:          0 :         mpol_put(old);
     739                 :            : 
     740                 :            :         return 0;
     741                 :            :  err_out:
     742         [ #  # ]:          0 :         mpol_put(new);
     743                 :            :         return err;
     744                 :            : }
     745                 :            : 
     746                 :            : /* Step 2: apply policy to a range and do splits. */
     747                 :          0 : static int mbind_range(struct mm_struct *mm, unsigned long start,
     748                 :            :                        unsigned long end, struct mempolicy *new_pol)
     749                 :            : {
     750                 :          0 :         struct vm_area_struct *next;
     751                 :          0 :         struct vm_area_struct *prev;
     752                 :          0 :         struct vm_area_struct *vma;
     753                 :          0 :         int err = 0;
     754                 :          0 :         pgoff_t pgoff;
     755                 :          0 :         unsigned long vmstart;
     756                 :          0 :         unsigned long vmend;
     757                 :            : 
     758                 :          0 :         vma = find_vma(mm, start);
     759                 :          0 :         VM_BUG_ON(!vma);
     760                 :            : 
     761                 :          0 :         prev = vma->vm_prev;
     762         [ #  # ]:          0 :         if (start > vma->vm_start)
     763                 :          0 :                 prev = vma;
     764                 :            : 
     765   [ #  #  #  # ]:          0 :         for (; vma && vma->vm_start < end; prev = vma, vma = next) {
     766                 :          0 :                 next = vma->vm_next;
     767                 :          0 :                 vmstart = max(start, vma->vm_start);
     768                 :          0 :                 vmend   = min(end, vma->vm_end);
     769                 :            : 
     770   [ #  #  #  # ]:          0 :                 if (mpol_equal(vma_policy(vma), new_pol))
     771                 :          0 :                         continue;
     772                 :            : 
     773                 :          0 :                 pgoff = vma->vm_pgoff +
     774                 :          0 :                         ((vmstart - vma->vm_start) >> PAGE_SHIFT);
     775                 :          0 :                 prev = vma_merge(mm, prev, vmstart, vmend, vma->vm_flags,
     776                 :            :                                  vma->anon_vma, vma->vm_file, pgoff,
     777                 :            :                                  new_pol, vma->vm_userfaultfd_ctx);
     778         [ #  # ]:          0 :                 if (prev) {
     779                 :          0 :                         vma = prev;
     780                 :          0 :                         next = vma->vm_next;
     781   [ #  #  #  # ]:          0 :                         if (mpol_equal(vma_policy(vma), new_pol))
     782                 :          0 :                                 continue;
     783                 :            :                         /* vma_merge() joined vma && vma->next, case 8 */
     784                 :          0 :                         goto replace;
     785                 :            :                 }
     786         [ #  # ]:          0 :                 if (vma->vm_start != vmstart) {
     787                 :          0 :                         err = split_vma(vma->vm_mm, vma, vmstart, 1);
     788         [ #  # ]:          0 :                         if (err)
     789                 :          0 :                                 goto out;
     790                 :            :                 }
     791         [ #  # ]:          0 :                 if (vma->vm_end != vmend) {
     792                 :          0 :                         err = split_vma(vma->vm_mm, vma, vmend, 0);
     793         [ #  # ]:          0 :                         if (err)
     794                 :          0 :                                 goto out;
     795                 :            :                 }
     796                 :          0 :  replace:
     797                 :          0 :                 err = vma_replace_policy(vma, new_pol);
     798         [ #  # ]:          0 :                 if (err)
     799                 :          0 :                         goto out;
     800                 :            :         }
     801                 :            : 
     802                 :          0 :  out:
     803                 :          0 :         return err;
     804                 :            : }
     805                 :            : 
     806                 :            : /* Set the process memory policy */
     807                 :         90 : static long do_set_mempolicy(unsigned short mode, unsigned short flags,
     808                 :            :                              nodemask_t *nodes)
     809                 :            : {
     810                 :         90 :         struct mempolicy *new, *old;
     811                 :         90 :         NODEMASK_SCRATCH(scratch);
     812                 :         90 :         int ret;
     813                 :            : 
     814                 :         90 :         if (!scratch)
     815                 :            :                 return -ENOMEM;
     816                 :            : 
     817                 :         90 :         new = mpol_new(mode, flags, nodes);
     818         [ -  + ]:         90 :         if (IS_ERR(new)) {
     819                 :          0 :                 ret = PTR_ERR(new);
     820                 :          0 :                 goto out;
     821                 :            :         }
     822                 :            : 
     823                 :         90 :         task_lock(current);
     824                 :         90 :         ret = mpol_set_nodemask(new, nodes, scratch);
     825         [ -  + ]:         90 :         if (ret) {
     826                 :          0 :                 task_unlock(current);
     827         [ #  # ]:          0 :                 mpol_put(new);
     828                 :          0 :                 goto out;
     829                 :            :         }
     830         [ +  + ]:         90 :         old = current->mempolicy;
     831                 :         90 :         current->mempolicy = new;
     832   [ +  +  +  - ]:         90 :         if (new && new->mode == MPOL_INTERLEAVE)
     833                 :         30 :                 current->il_prev = MAX_NUMNODES-1;
     834                 :         90 :         task_unlock(current);
     835         [ +  + ]:         90 :         mpol_put(old);
     836                 :            :         ret = 0;
     837                 :         90 : out:
     838                 :         90 :         NODEMASK_SCRATCH_FREE(scratch);
     839                 :         90 :         return ret;
     840                 :            : }
     841                 :            : 
     842                 :            : /*
     843                 :            :  * Return nodemask for policy for get_mempolicy() query
     844                 :            :  *
     845                 :            :  * Called with task's alloc_lock held
     846                 :            :  */
     847                 :          0 : static void get_policy_nodemask(struct mempolicy *p, nodemask_t *nodes)
     848                 :            : {
     849         [ #  # ]:          0 :         nodes_clear(*nodes);
     850         [ #  # ]:          0 :         if (p == &default_policy)
     851                 :            :                 return;
     852                 :            : 
     853      [ #  #  # ]:          0 :         switch (p->mode) {
     854                 :          0 :         case MPOL_BIND:
     855                 :            :                 /* Fall through */
     856                 :            :         case MPOL_INTERLEAVE:
     857                 :          0 :                 *nodes = p->v.nodes;
     858                 :          0 :                 break;
     859                 :          0 :         case MPOL_PREFERRED:
     860         [ #  # ]:          0 :                 if (!(p->flags & MPOL_F_LOCAL))
     861                 :          0 :                         node_set(p->v.preferred_node, *nodes);
     862                 :            :                 /* else return empty node mask for local allocation */
     863                 :            :                 break;
     864                 :          0 :         default:
     865                 :          0 :                 BUG();
     866                 :            :         }
     867                 :            : }
     868                 :            : 
     869                 :          0 : static int lookup_node(struct mm_struct *mm, unsigned long addr)
     870                 :            : {
     871                 :          0 :         struct page *p;
     872                 :          0 :         int err;
     873                 :            : 
     874                 :          0 :         int locked = 1;
     875                 :          0 :         err = get_user_pages_locked(addr & PAGE_MASK, 1, 0, &p, &locked);
     876         [ #  # ]:          0 :         if (err >= 0) {
     877                 :          0 :                 err = page_to_nid(p);
     878                 :          0 :                 put_page(p);
     879                 :            :         }
     880         [ #  # ]:          0 :         if (locked)
     881                 :          0 :                 up_read(&mm->mmap_sem);
     882                 :          0 :         return err;
     883                 :            : }
     884                 :            : 
     885                 :            : /* Retrieve NUMA policy */
     886                 :          0 : static long do_get_mempolicy(int *policy, nodemask_t *nmask,
     887                 :            :                              unsigned long addr, unsigned long flags)
     888                 :            : {
     889                 :          0 :         int err;
     890         [ #  # ]:          0 :         struct mm_struct *mm = current->mm;
     891                 :          0 :         struct vm_area_struct *vma = NULL;
     892                 :          0 :         struct mempolicy *pol = current->mempolicy, *pol_refcount = NULL;
     893                 :            : 
     894         [ #  # ]:          0 :         if (flags &
     895                 :            :                 ~(unsigned long)(MPOL_F_NODE|MPOL_F_ADDR|MPOL_F_MEMS_ALLOWED))
     896                 :            :                 return -EINVAL;
     897                 :            : 
     898         [ #  # ]:          0 :         if (flags & MPOL_F_MEMS_ALLOWED) {
     899         [ #  # ]:          0 :                 if (flags & (MPOL_F_NODE|MPOL_F_ADDR))
     900                 :            :                         return -EINVAL;
     901                 :          0 :                 *policy = 0;    /* just so it's initialized */
     902                 :          0 :                 task_lock(current);
     903                 :          0 :                 *nmask  = cpuset_current_mems_allowed;
     904                 :          0 :                 task_unlock(current);
     905                 :          0 :                 return 0;
     906                 :            :         }
     907                 :            : 
     908         [ #  # ]:          0 :         if (flags & MPOL_F_ADDR) {
     909                 :            :                 /*
     910                 :            :                  * Do NOT fall back to task policy if the
     911                 :            :                  * vma/shared policy at addr is NULL.  We
     912                 :            :                  * want to return MPOL_DEFAULT in this case.
     913                 :            :                  */
     914                 :          0 :                 down_read(&mm->mmap_sem);
     915                 :          0 :                 vma = find_vma_intersection(mm, addr, addr+1);
     916         [ #  # ]:          0 :                 if (!vma) {
     917                 :          0 :                         up_read(&mm->mmap_sem);
     918                 :          0 :                         return -EFAULT;
     919                 :            :                 }
     920   [ #  #  #  # ]:          0 :                 if (vma->vm_ops && vma->vm_ops->get_policy)
     921                 :          0 :                         pol = vma->vm_ops->get_policy(vma, addr);
     922                 :            :                 else
     923                 :          0 :                         pol = vma->vm_policy;
     924         [ #  # ]:          0 :         } else if (addr)
     925                 :            :                 return -EINVAL;
     926                 :            : 
     927         [ #  # ]:          0 :         if (!pol)
     928                 :          0 :                 pol = &default_policy;      /* indicates default behavior */
     929                 :            : 
     930         [ #  # ]:          0 :         if (flags & MPOL_F_NODE) {
     931         [ #  # ]:          0 :                 if (flags & MPOL_F_ADDR) {
     932                 :            :                         /*
     933                 :            :                          * Take a refcount on the mpol, lookup_node()
     934                 :            :                          * wil drop the mmap_sem, so after calling
     935                 :            :                          * lookup_node() only "pol" remains valid, "vma"
     936                 :            :                          * is stale.
     937                 :            :                          */
     938                 :          0 :                         pol_refcount = pol;
     939                 :          0 :                         vma = NULL;
     940         [ #  # ]:          0 :                         mpol_get(pol);
     941                 :          0 :                         err = lookup_node(mm, addr);
     942         [ #  # ]:          0 :                         if (err < 0)
     943                 :          0 :                                 goto out;
     944                 :          0 :                         *policy = err;
     945         [ #  # ]:          0 :                 } else if (pol == current->mempolicy &&
     946         [ #  # ]:          0 :                                 pol->mode == MPOL_INTERLEAVE) {
     947                 :          0 :                         *policy = next_node_in(current->il_prev, pol->v.nodes);
     948                 :            :                 } else {
     949                 :          0 :                         err = -EINVAL;
     950                 :          0 :                         goto out;
     951                 :            :                 }
     952                 :            :         } else {
     953         [ #  # ]:          0 :                 *policy = pol == &default_policy ? MPOL_DEFAULT :
     954                 :          0 :                                                 pol->mode;
     955                 :            :                 /*
     956                 :            :                  * Internal mempolicy flags must be masked off before exposing
     957                 :            :                  * the policy to userspace.
     958                 :            :                  */
     959                 :          0 :                 *policy |= (pol->flags & MPOL_MODE_FLAGS);
     960                 :            :         }
     961                 :            : 
     962                 :          0 :         err = 0;
     963         [ #  # ]:          0 :         if (nmask) {
     964         [ #  # ]:          0 :                 if (mpol_store_user_nodemask(pol)) {
     965                 :          0 :                         *nmask = pol->w.user_nodemask;
     966                 :            :                 } else {
     967                 :          0 :                         task_lock(current);
     968                 :          0 :                         get_policy_nodemask(pol, nmask);
     969                 :          0 :                         task_unlock(current);
     970                 :            :                 }
     971                 :            :         }
     972                 :            : 
     973                 :          0 :  out:
     974         [ #  # ]:          0 :         mpol_cond_put(pol);
     975         [ #  # ]:          0 :         if (vma)
     976                 :          0 :                 up_read(&mm->mmap_sem);
     977         [ #  # ]:          0 :         if (pol_refcount)
     978                 :          0 :                 mpol_put(pol_refcount);
     979                 :          0 :         return err;
     980                 :            : }
     981                 :            : 
     982                 :            : #ifdef CONFIG_MIGRATION
     983                 :            : /*
     984                 :            :  * page migration, thp tail pages can be passed.
     985                 :            :  */
     986                 :          0 : static int migrate_page_add(struct page *page, struct list_head *pagelist,
     987                 :            :                                 unsigned long flags)
     988                 :            : {
     989         [ #  # ]:          0 :         struct page *head = compound_head(page);
     990                 :            :         /*
     991                 :            :          * Avoid migrating a page that is shared with others.
     992                 :            :          */
     993   [ #  #  #  # ]:          0 :         if ((flags & MPOL_MF_MOVE_ALL) || page_mapcount(head) == 1) {
     994         [ #  # ]:          0 :                 if (!isolate_lru_page(head)) {
     995                 :          0 :                         list_add_tail(&head->lru, pagelist);
     996                 :          0 :                         mod_node_page_state(page_pgdat(head),
     997                 :          0 :                                 NR_ISOLATED_ANON + page_is_file_cache(head),
     998                 :            :                                 hpage_nr_pages(head));
     999         [ #  # ]:          0 :                 } else if (flags & MPOL_MF_STRICT) {
    1000                 :            :                         /*
    1001                 :            :                          * Non-movable page may reach here.  And, there may be
    1002                 :            :                          * temporary off LRU pages or non-LRU movable pages.
    1003                 :            :                          * Treat them as unmovable pages since they can't be
    1004                 :            :                          * isolated, so they can't be moved at the moment.  It
    1005                 :            :                          * should return -EIO for this case too.
    1006                 :            :                          */
    1007                 :          0 :                         return -EIO;
    1008                 :            :                 }
    1009                 :            :         }
    1010                 :            : 
    1011                 :            :         return 0;
    1012                 :            : }
    1013                 :            : 
    1014                 :            : /* page allocation callback for NUMA node migration */
    1015                 :          0 : struct page *alloc_new_node_page(struct page *page, unsigned long node)
    1016                 :            : {
    1017         [ #  # ]:          0 :         if (PageHuge(page))
    1018         [ #  # ]:          0 :                 return alloc_huge_page_node(page_hstate(compound_head(page)),
    1019                 :            :                                         node);
    1020                 :          0 :         else if (PageTransHuge(page)) {
    1021                 :            :                 struct page *thp;
    1022                 :            : 
    1023                 :            :                 thp = alloc_pages_node(node,
    1024                 :            :                         (GFP_TRANSHUGE | __GFP_THISNODE),
    1025                 :            :                         HPAGE_PMD_ORDER);
    1026                 :            :                 if (!thp)
    1027                 :            :                         return NULL;
    1028                 :            :                 prep_transhuge_page(thp);
    1029                 :            :                 return thp;
    1030                 :            :         } else
    1031                 :          0 :                 return __alloc_pages_node(node, GFP_HIGHUSER_MOVABLE |
    1032                 :            :                                                     __GFP_THISNODE, 0);
    1033                 :            : }
    1034                 :            : 
    1035                 :            : /*
    1036                 :            :  * Migrate pages from one node to a target node.
    1037                 :            :  * Returns error or the number of pages not migrated.
    1038                 :            :  */
    1039                 :          0 : static int migrate_to_node(struct mm_struct *mm, int source, int dest,
    1040                 :            :                            int flags)
    1041                 :            : {
    1042                 :          0 :         nodemask_t nmask;
    1043                 :          0 :         LIST_HEAD(pagelist);
    1044                 :          0 :         int err = 0;
    1045                 :            : 
    1046                 :          0 :         nodes_clear(nmask);
    1047                 :          0 :         node_set(source, nmask);
    1048                 :            : 
    1049                 :            :         /*
    1050                 :            :          * This does not "check" the range but isolates all pages that
    1051                 :            :          * need migration.  Between passing in the full user address
    1052                 :            :          * space range and MPOL_MF_DISCONTIG_OK, this call can not fail.
    1053                 :            :          */
    1054                 :          0 :         VM_BUG_ON(!(flags & (MPOL_MF_MOVE | MPOL_MF_MOVE_ALL)));
    1055                 :          0 :         queue_pages_range(mm, mm->mmap->vm_start, mm->task_size, &nmask,
    1056                 :          0 :                         flags | MPOL_MF_DISCONTIG_OK, &pagelist);
    1057                 :            : 
    1058         [ #  # ]:          0 :         if (!list_empty(&pagelist)) {
    1059                 :          0 :                 err = migrate_pages(&pagelist, alloc_new_node_page, NULL, dest,
    1060                 :            :                                         MIGRATE_SYNC, MR_SYSCALL);
    1061         [ #  # ]:          0 :                 if (err)
    1062                 :          0 :                         putback_movable_pages(&pagelist);
    1063                 :            :         }
    1064                 :            : 
    1065                 :          0 :         return err;
    1066                 :            : }
    1067                 :            : 
    1068                 :            : /*
    1069                 :            :  * Move pages between the two nodesets so as to preserve the physical
    1070                 :            :  * layout as much as possible.
    1071                 :            :  *
    1072                 :            :  * Returns the number of page that could not be moved.
    1073                 :            :  */
    1074                 :          0 : int do_migrate_pages(struct mm_struct *mm, const nodemask_t *from,
    1075                 :            :                      const nodemask_t *to, int flags)
    1076                 :            : {
    1077                 :          0 :         int busy = 0;
    1078                 :          0 :         int err;
    1079                 :          0 :         nodemask_t tmp;
    1080                 :            : 
    1081                 :          0 :         err = migrate_prep();
    1082         [ #  # ]:          0 :         if (err)
    1083                 :            :                 return err;
    1084                 :            : 
    1085                 :          0 :         down_read(&mm->mmap_sem);
    1086                 :            : 
    1087                 :            :         /*
    1088                 :            :          * Find a 'source' bit set in 'tmp' whose corresponding 'dest'
    1089                 :            :          * bit in 'to' is not also set in 'tmp'.  Clear the found 'source'
    1090                 :            :          * bit in 'tmp', and return that <source, dest> pair for migration.
    1091                 :            :          * The pair of nodemasks 'to' and 'from' define the map.
    1092                 :            :          *
    1093                 :            :          * If no pair of bits is found that way, fallback to picking some
    1094                 :            :          * pair of 'source' and 'dest' bits that are not the same.  If the
    1095                 :            :          * 'source' and 'dest' bits are the same, this represents a node
    1096                 :            :          * that will be migrating to itself, so no pages need move.
    1097                 :            :          *
    1098                 :            :          * If no bits are left in 'tmp', or if all remaining bits left
    1099                 :            :          * in 'tmp' correspond to the same bit in 'to', return false
    1100                 :            :          * (nothing left to migrate).
    1101                 :            :          *
    1102                 :            :          * This lets us pick a pair of nodes to migrate between, such that
    1103                 :            :          * if possible the dest node is not already occupied by some other
    1104                 :            :          * source node, minimizing the risk of overloading the memory on a
    1105                 :            :          * node that would happen if we migrated incoming memory to a node
    1106                 :            :          * before migrating outgoing memory source that same node.
    1107                 :            :          *
    1108                 :            :          * A single scan of tmp is sufficient.  As we go, we remember the
    1109                 :            :          * most recent <s, d> pair that moved (s != d).  If we find a pair
    1110                 :            :          * that not only moved, but what's better, moved to an empty slot
    1111                 :            :          * (d is not set in tmp), then we break out then, with that pair.
    1112                 :            :          * Otherwise when we finish scanning from_tmp, we at least have the
    1113                 :            :          * most recent <s, d> pair that moved.  If we get all the way through
    1114                 :            :          * the scan of tmp without finding any node that moved, much less
    1115                 :            :          * moved to an empty node, then there is nothing left worth migrating.
    1116                 :            :          */
    1117                 :            : 
    1118                 :          0 :         tmp = *from;
    1119         [ #  # ]:          0 :         while (!nodes_empty(tmp)) {
    1120                 :          0 :                 int s,d;
    1121                 :          0 :                 int source = NUMA_NO_NODE;
    1122                 :          0 :                 int dest = 0;
    1123                 :            : 
    1124         [ #  # ]:          0 :                 for_each_node_mask(s, tmp) {
    1125                 :            : 
    1126                 :            :                         /*
    1127                 :            :                          * do_migrate_pages() tries to maintain the relative
    1128                 :            :                          * node relationship of the pages established between
    1129                 :            :                          * threads and memory areas.
    1130                 :            :                          *
    1131                 :            :                          * However if the number of source nodes is not equal to
    1132                 :            :                          * the number of destination nodes we can not preserve
    1133                 :            :                          * this node relative relationship.  In that case, skip
    1134                 :            :                          * copying memory from a node that is in the destination
    1135                 :            :                          * mask.
    1136                 :            :                          *
    1137                 :            :                          * Example: [2,3,4] -> [3,4,5] moves everything.
    1138                 :            :                          *          [0-7] - > [3,4,5] moves only 0,1,2,6,7.
    1139                 :            :                          */
    1140                 :            : 
    1141   [ #  #  #  # ]:          0 :                         if ((nodes_weight(*from) != nodes_weight(*to)) &&
    1142                 :          0 :                                                 (node_isset(s, *to)))
    1143                 :          0 :                                 continue;
    1144                 :            : 
    1145                 :          0 :                         d = node_remap(s, *from, *to);
    1146         [ #  # ]:          0 :                         if (s == d)
    1147                 :          0 :                                 continue;
    1148                 :            : 
    1149                 :          0 :                         source = s;     /* Node moved. Memorize */
    1150                 :          0 :                         dest = d;
    1151                 :            : 
    1152                 :            :                         /* dest not in remaining from nodes? */
    1153         [ #  # ]:          0 :                         if (!node_isset(dest, tmp))
    1154                 :            :                                 break;
    1155                 :            :                 }
    1156         [ #  # ]:          0 :                 if (source == NUMA_NO_NODE)
    1157                 :            :                         break;
    1158                 :            : 
    1159                 :          0 :                 node_clear(source, tmp);
    1160                 :          0 :                 err = migrate_to_node(mm, source, dest, flags);
    1161         [ #  # ]:          0 :                 if (err > 0)
    1162                 :          0 :                         busy += err;
    1163         [ #  # ]:          0 :                 if (err < 0)
    1164                 :            :                         break;
    1165                 :            :         }
    1166                 :          0 :         up_read(&mm->mmap_sem);
    1167         [ #  # ]:          0 :         if (err < 0)
    1168                 :          0 :                 return err;
    1169                 :            :         return busy;
    1170                 :            : 
    1171                 :            : }
    1172                 :            : 
    1173                 :            : /*
    1174                 :            :  * Allocate a new page for page migration based on vma policy.
    1175                 :            :  * Start by assuming the page is mapped by the same vma as contains @start.
    1176                 :            :  * Search forward from there, if not.  N.B., this assumes that the
    1177                 :            :  * list of pages handed to migrate_pages()--which is how we get here--
    1178                 :            :  * is in virtual address order.
    1179                 :            :  */
    1180                 :          0 : static struct page *new_page(struct page *page, unsigned long start)
    1181                 :            : {
    1182                 :          0 :         struct vm_area_struct *vma;
    1183                 :          0 :         unsigned long uninitialized_var(address);
    1184                 :            : 
    1185                 :          0 :         vma = find_vma(current->mm, start);
    1186         [ #  # ]:          0 :         while (vma) {
    1187                 :          0 :                 address = page_address_in_vma(page, vma);
    1188         [ #  # ]:          0 :                 if (address != -EFAULT)
    1189                 :            :                         break;
    1190                 :          0 :                 vma = vma->vm_next;
    1191                 :            :         }
    1192                 :            : 
    1193         [ #  # ]:          0 :         if (PageHuge(page)) {
    1194         [ #  # ]:          0 :                 return alloc_huge_page_vma(page_hstate(compound_head(page)),
    1195                 :            :                                 vma, address);
    1196                 :          0 :         } else if (PageTransHuge(page)) {
    1197                 :            :                 struct page *thp;
    1198                 :            : 
    1199                 :            :                 thp = alloc_hugepage_vma(GFP_TRANSHUGE, vma, address,
    1200                 :            :                                          HPAGE_PMD_ORDER);
    1201                 :            :                 if (!thp)
    1202                 :            :                         return NULL;
    1203                 :            :                 prep_transhuge_page(thp);
    1204                 :            :                 return thp;
    1205                 :            :         }
    1206                 :            :         /*
    1207                 :            :          * if !vma, alloc_page_vma() will use task or system default policy
    1208                 :            :          */
    1209                 :          0 :         return alloc_page_vma(GFP_HIGHUSER_MOVABLE | __GFP_RETRY_MAYFAIL,
    1210                 :            :                         vma, address);
    1211                 :            : }
    1212                 :            : #else
    1213                 :            : 
    1214                 :            : static int migrate_page_add(struct page *page, struct list_head *pagelist,
    1215                 :            :                                 unsigned long flags)
    1216                 :            : {
    1217                 :            :         return -EIO;
    1218                 :            : }
    1219                 :            : 
    1220                 :            : int do_migrate_pages(struct mm_struct *mm, const nodemask_t *from,
    1221                 :            :                      const nodemask_t *to, int flags)
    1222                 :            : {
    1223                 :            :         return -ENOSYS;
    1224                 :            : }
    1225                 :            : 
    1226                 :            : static struct page *new_page(struct page *page, unsigned long start)
    1227                 :            : {
    1228                 :            :         return NULL;
    1229                 :            : }
    1230                 :            : #endif
    1231                 :            : 
    1232                 :          0 : static long do_mbind(unsigned long start, unsigned long len,
    1233                 :            :                      unsigned short mode, unsigned short mode_flags,
    1234                 :            :                      nodemask_t *nmask, unsigned long flags)
    1235                 :            : {
    1236         [ #  # ]:          0 :         struct mm_struct *mm = current->mm;
    1237                 :          0 :         struct mempolicy *new;
    1238                 :          0 :         unsigned long end;
    1239                 :          0 :         int err;
    1240                 :          0 :         int ret;
    1241                 :          0 :         LIST_HEAD(pagelist);
    1242                 :            : 
    1243         [ #  # ]:          0 :         if (flags & ~(unsigned long)MPOL_MF_VALID)
    1244                 :            :                 return -EINVAL;
    1245   [ #  #  #  # ]:          0 :         if ((flags & MPOL_MF_MOVE_ALL) && !capable(CAP_SYS_NICE))
    1246                 :            :                 return -EPERM;
    1247                 :            : 
    1248         [ #  # ]:          0 :         if (start & ~PAGE_MASK)
    1249                 :            :                 return -EINVAL;
    1250                 :            : 
    1251         [ #  # ]:          0 :         if (mode == MPOL_DEFAULT)
    1252                 :          0 :                 flags &= ~MPOL_MF_STRICT;
    1253                 :            : 
    1254                 :          0 :         len = (len + PAGE_SIZE - 1) & PAGE_MASK;
    1255                 :          0 :         end = start + len;
    1256                 :            : 
    1257         [ #  # ]:          0 :         if (end < start)
    1258                 :            :                 return -EINVAL;
    1259         [ #  # ]:          0 :         if (end == start)
    1260                 :            :                 return 0;
    1261                 :            : 
    1262                 :          0 :         new = mpol_new(mode, mode_flags, nmask);
    1263         [ #  # ]:          0 :         if (IS_ERR(new))
    1264                 :          0 :                 return PTR_ERR(new);
    1265                 :            : 
    1266                 :          0 :         if (flags & MPOL_MF_LAZY)
    1267                 :            :                 new->flags |= MPOL_F_MOF;
    1268                 :            : 
    1269                 :            :         /*
    1270                 :            :          * If we are using the default policy then operation
    1271                 :            :          * on discontinuous address spaces is okay after all
    1272                 :            :          */
    1273         [ #  # ]:          0 :         if (!new)
    1274                 :          0 :                 flags |= MPOL_MF_DISCONTIG_OK;
    1275                 :            : 
    1276                 :          0 :         pr_debug("mbind %lx-%lx mode:%d flags:%d nodes:%lx\n",
    1277                 :            :                  start, start + len, mode, mode_flags,
    1278                 :            :                  nmask ? nodes_addr(*nmask)[0] : NUMA_NO_NODE);
    1279                 :            : 
    1280         [ #  # ]:          0 :         if (flags & (MPOL_MF_MOVE | MPOL_MF_MOVE_ALL)) {
    1281                 :            : 
    1282                 :          0 :                 err = migrate_prep();
    1283         [ #  # ]:          0 :                 if (err)
    1284                 :          0 :                         goto mpol_out;
    1285                 :            :         }
    1286                 :            :         {
    1287                 :          0 :                 NODEMASK_SCRATCH(scratch);
    1288                 :          0 :                 if (scratch) {
    1289                 :          0 :                         down_write(&mm->mmap_sem);
    1290                 :          0 :                         task_lock(current);
    1291                 :          0 :                         err = mpol_set_nodemask(new, nmask, scratch);
    1292                 :          0 :                         task_unlock(current);
    1293         [ #  # ]:          0 :                         if (err)
    1294                 :          0 :                                 up_write(&mm->mmap_sem);
    1295                 :            :                 } else
    1296                 :            :                         err = -ENOMEM;
    1297                 :          0 :                 NODEMASK_SCRATCH_FREE(scratch);
    1298                 :            :         }
    1299         [ #  # ]:          0 :         if (err)
    1300                 :          0 :                 goto mpol_out;
    1301                 :            : 
    1302                 :          0 :         ret = queue_pages_range(mm, start, end, nmask,
    1303                 :            :                           flags | MPOL_MF_INVERT, &pagelist);
    1304                 :            : 
    1305         [ #  # ]:          0 :         if (ret < 0) {
    1306                 :          0 :                 err = ret;
    1307                 :          0 :                 goto up_out;
    1308                 :            :         }
    1309                 :            : 
    1310                 :          0 :         err = mbind_range(mm, start, end, new);
    1311                 :            : 
    1312         [ #  # ]:          0 :         if (!err) {
    1313                 :          0 :                 int nr_failed = 0;
    1314                 :            : 
    1315         [ #  # ]:          0 :                 if (!list_empty(&pagelist)) {
    1316         [ #  # ]:          0 :                         WARN_ON_ONCE(flags & MPOL_MF_LAZY);
    1317                 :          0 :                         nr_failed = migrate_pages(&pagelist, new_page, NULL,
    1318                 :            :                                 start, MIGRATE_SYNC, MR_MEMPOLICY_MBIND);
    1319         [ #  # ]:          0 :                         if (nr_failed)
    1320                 :          0 :                                 putback_movable_pages(&pagelist);
    1321                 :            :                 }
    1322                 :            : 
    1323   [ #  #  #  #  :          0 :                 if ((ret > 0) || (nr_failed && (flags & MPOL_MF_STRICT)))
                   #  # ]
    1324                 :          0 :                         err = -EIO;
    1325                 :            :         } else {
    1326                 :          0 : up_out:
    1327         [ #  # ]:          0 :                 if (!list_empty(&pagelist))
    1328                 :          0 :                         putback_movable_pages(&pagelist);
    1329                 :            :         }
    1330                 :            : 
    1331                 :          0 :         up_write(&mm->mmap_sem);
    1332                 :          0 : mpol_out:
    1333         [ #  # ]:          0 :         mpol_put(new);
    1334                 :          0 :         return err;
    1335                 :            : }
    1336                 :            : 
    1337                 :            : /*
    1338                 :            :  * User space interface with variable sized bitmaps for nodelists.
    1339                 :            :  */
    1340                 :            : 
    1341                 :            : /* Copy a node mask from user space. */
    1342                 :          0 : static int get_nodes(nodemask_t *nodes, const unsigned long __user *nmask,
    1343                 :            :                      unsigned long maxnode)
    1344                 :            : {
    1345                 :          0 :         unsigned long k;
    1346                 :          0 :         unsigned long t;
    1347                 :          0 :         unsigned long nlongs;
    1348                 :          0 :         unsigned long endmask;
    1349                 :            : 
    1350                 :          0 :         --maxnode;
    1351         [ #  # ]:          0 :         nodes_clear(*nodes);
    1352         [ #  # ]:          0 :         if (maxnode == 0 || !nmask)
    1353                 :            :                 return 0;
    1354         [ #  # ]:          0 :         if (maxnode > PAGE_SIZE*BITS_PER_BYTE)
    1355                 :            :                 return -EINVAL;
    1356                 :            : 
    1357                 :          0 :         nlongs = BITS_TO_LONGS(maxnode);
    1358         [ #  # ]:          0 :         if ((maxnode % BITS_PER_LONG) == 0)
    1359                 :            :                 endmask = ~0UL;
    1360                 :            :         else
    1361                 :          0 :                 endmask = (1UL << (maxnode % BITS_PER_LONG)) - 1;
    1362                 :            : 
    1363                 :            :         /*
    1364                 :            :          * When the user specified more nodes than supported just check
    1365                 :            :          * if the non supported part is all zero.
    1366                 :            :          *
    1367                 :            :          * If maxnode have more longs than MAX_NUMNODES, check
    1368                 :            :          * the bits in that area first. And then go through to
    1369                 :            :          * check the rest bits which equal or bigger than MAX_NUMNODES.
    1370                 :            :          * Otherwise, just check bits [MAX_NUMNODES, maxnode).
    1371                 :            :          */
    1372         [ #  # ]:          0 :         if (nlongs > BITS_TO_LONGS(MAX_NUMNODES)) {
    1373         [ #  # ]:          0 :                 for (k = BITS_TO_LONGS(MAX_NUMNODES); k < nlongs; k++) {
    1374         [ #  # ]:          0 :                         if (get_user(t, nmask + k))
    1375                 :            :                                 return -EFAULT;
    1376         [ #  # ]:          0 :                         if (k == nlongs - 1) {
    1377         [ #  # ]:          0 :                                 if (t & endmask)
    1378                 :            :                                         return -EINVAL;
    1379         [ #  # ]:          0 :                         } else if (t)
    1380                 :            :                                 return -EINVAL;
    1381                 :            :                 }
    1382                 :            :                 nlongs = BITS_TO_LONGS(MAX_NUMNODES);
    1383                 :            :                 endmask = ~0UL;
    1384                 :            :         }
    1385                 :            : 
    1386                 :          0 :         if (maxnode > MAX_NUMNODES && MAX_NUMNODES % BITS_PER_LONG != 0) {
    1387                 :            :                 unsigned long valid_mask = endmask;
    1388                 :            : 
    1389                 :            :                 valid_mask &= ~((1UL << (MAX_NUMNODES % BITS_PER_LONG)) - 1);
    1390                 :            :                 if (get_user(t, nmask + nlongs - 1))
    1391                 :            :                         return -EFAULT;
    1392                 :            :                 if (t & valid_mask)
    1393                 :            :                         return -EINVAL;
    1394                 :            :         }
    1395                 :            : 
    1396   [ #  #  #  # ]:          0 :         if (copy_from_user(nodes_addr(*nodes), nmask, nlongs*sizeof(unsigned long)))
    1397                 :            :                 return -EFAULT;
    1398                 :          0 :         nodes_addr(*nodes)[nlongs-1] &= endmask;
    1399                 :          0 :         return 0;
    1400                 :            : }
    1401                 :            : 
    1402                 :            : /* Copy a kernel node mask to user space */
    1403                 :          0 : static int copy_nodes_to_user(unsigned long __user *mask, unsigned long maxnode,
    1404                 :            :                               nodemask_t *nodes)
    1405                 :            : {
    1406                 :          0 :         unsigned long copy = ALIGN(maxnode-1, 64) / 8;
    1407                 :          0 :         unsigned int nbytes = BITS_TO_LONGS(nr_node_ids) * sizeof(long);
    1408                 :            : 
    1409         [ #  # ]:          0 :         if (copy > nbytes) {
    1410         [ #  # ]:          0 :                 if (copy > PAGE_SIZE)
    1411                 :            :                         return -EINVAL;
    1412         [ #  # ]:          0 :                 if (clear_user((char __user *)mask + nbytes, copy - nbytes))
    1413                 :            :                         return -EFAULT;
    1414                 :            :                 copy = nbytes;
    1415                 :            :         }
    1416   [ #  #  #  # ]:          0 :         return copy_to_user(mask, nodes_addr(*nodes), copy) ? -EFAULT : 0;
    1417                 :            : }
    1418                 :            : 
    1419                 :          0 : static long kernel_mbind(unsigned long start, unsigned long len,
    1420                 :            :                          unsigned long mode, const unsigned long __user *nmask,
    1421                 :            :                          unsigned long maxnode, unsigned int flags)
    1422                 :            : {
    1423                 :          0 :         nodemask_t nodes;
    1424                 :          0 :         int err;
    1425                 :          0 :         unsigned short mode_flags;
    1426                 :            : 
    1427                 :          0 :         start = untagged_addr(start);
    1428                 :          0 :         mode_flags = mode & MPOL_MODE_FLAGS;
    1429                 :          0 :         mode &= ~MPOL_MODE_FLAGS;
    1430         [ #  # ]:          0 :         if (mode >= MPOL_MAX)
    1431                 :            :                 return -EINVAL;
    1432   [ #  #  #  # ]:          0 :         if ((mode_flags & MPOL_F_STATIC_NODES) &&
    1433                 :            :             (mode_flags & MPOL_F_RELATIVE_NODES))
    1434                 :            :                 return -EINVAL;
    1435                 :          0 :         err = get_nodes(&nodes, nmask, maxnode);
    1436         [ #  # ]:          0 :         if (err)
    1437                 :          0 :                 return err;
    1438                 :          0 :         return do_mbind(start, len, mode, mode_flags, &nodes, flags);
    1439                 :            : }
    1440                 :            : 
    1441                 :          0 : SYSCALL_DEFINE6(mbind, unsigned long, start, unsigned long, len,
    1442                 :            :                 unsigned long, mode, const unsigned long __user *, nmask,
    1443                 :            :                 unsigned long, maxnode, unsigned int, flags)
    1444                 :            : {
    1445                 :          0 :         return kernel_mbind(start, len, mode, nmask, maxnode, flags);
    1446                 :            : }
    1447                 :            : 
    1448                 :            : /* Set the process memory policy */
    1449                 :          0 : static long kernel_set_mempolicy(int mode, const unsigned long __user *nmask,
    1450                 :            :                                  unsigned long maxnode)
    1451                 :            : {
    1452                 :          0 :         int err;
    1453                 :          0 :         nodemask_t nodes;
    1454                 :          0 :         unsigned short flags;
    1455                 :            : 
    1456                 :          0 :         flags = mode & MPOL_MODE_FLAGS;
    1457                 :          0 :         mode &= ~MPOL_MODE_FLAGS;
    1458         [ #  # ]:          0 :         if ((unsigned int)mode >= MPOL_MAX)
    1459                 :            :                 return -EINVAL;
    1460   [ #  #  #  # ]:          0 :         if ((flags & MPOL_F_STATIC_NODES) && (flags & MPOL_F_RELATIVE_NODES))
    1461                 :            :                 return -EINVAL;
    1462                 :          0 :         err = get_nodes(&nodes, nmask, maxnode);
    1463         [ #  # ]:          0 :         if (err)
    1464                 :          0 :                 return err;
    1465                 :          0 :         return do_set_mempolicy(mode, flags, &nodes);
    1466                 :            : }
    1467                 :            : 
    1468                 :          0 : SYSCALL_DEFINE3(set_mempolicy, int, mode, const unsigned long __user *, nmask,
    1469                 :            :                 unsigned long, maxnode)
    1470                 :            : {
    1471                 :          0 :         return kernel_set_mempolicy(mode, nmask, maxnode);
    1472                 :            : }
    1473                 :            : 
    1474                 :          0 : static int kernel_migrate_pages(pid_t pid, unsigned long maxnode,
    1475                 :            :                                 const unsigned long __user *old_nodes,
    1476                 :            :                                 const unsigned long __user *new_nodes)
    1477                 :            : {
    1478                 :          0 :         struct mm_struct *mm = NULL;
    1479                 :          0 :         struct task_struct *task;
    1480                 :          0 :         nodemask_t task_nodes;
    1481                 :          0 :         int err;
    1482                 :          0 :         nodemask_t *old;
    1483                 :          0 :         nodemask_t *new;
    1484                 :          0 :         NODEMASK_SCRATCH(scratch);
    1485                 :            : 
    1486                 :          0 :         if (!scratch)
    1487                 :            :                 return -ENOMEM;
    1488                 :            : 
    1489                 :          0 :         old = &scratch->mask1;
    1490                 :          0 :         new = &scratch->mask2;
    1491                 :            : 
    1492                 :          0 :         err = get_nodes(old, old_nodes, maxnode);
    1493         [ #  # ]:          0 :         if (err)
    1494                 :          0 :                 goto out;
    1495                 :            : 
    1496                 :          0 :         err = get_nodes(new, new_nodes, maxnode);
    1497         [ #  # ]:          0 :         if (err)
    1498                 :          0 :                 goto out;
    1499                 :            : 
    1500                 :            :         /* Find the mm_struct */
    1501                 :          0 :         rcu_read_lock();
    1502         [ #  # ]:          0 :         task = pid ? find_task_by_vpid(pid) : current;
    1503         [ #  # ]:          0 :         if (!task) {
    1504                 :          0 :                 rcu_read_unlock();
    1505                 :          0 :                 err = -ESRCH;
    1506                 :          0 :                 goto out;
    1507                 :            :         }
    1508                 :          0 :         get_task_struct(task);
    1509                 :            : 
    1510                 :          0 :         err = -EINVAL;
    1511                 :            : 
    1512                 :            :         /*
    1513                 :            :          * Check if this process has the right to modify the specified process.
    1514                 :            :          * Use the regular "ptrace_may_access()" checks.
    1515                 :            :          */
    1516         [ #  # ]:          0 :         if (!ptrace_may_access(task, PTRACE_MODE_READ_REALCREDS)) {
    1517                 :          0 :                 rcu_read_unlock();
    1518                 :          0 :                 err = -EPERM;
    1519                 :          0 :                 goto out_put;
    1520                 :            :         }
    1521                 :          0 :         rcu_read_unlock();
    1522                 :            : 
    1523                 :          0 :         task_nodes = cpuset_mems_allowed(task);
    1524                 :            :         /* Is the user allowed to access the target nodes? */
    1525   [ #  #  #  # ]:          0 :         if (!nodes_subset(*new, task_nodes) && !capable(CAP_SYS_NICE)) {
    1526                 :          0 :                 err = -EPERM;
    1527                 :          0 :                 goto out_put;
    1528                 :            :         }
    1529                 :            : 
    1530                 :          0 :         task_nodes = cpuset_mems_allowed(current);
    1531                 :          0 :         nodes_and(*new, *new, task_nodes);
    1532         [ #  # ]:          0 :         if (nodes_empty(*new))
    1533                 :          0 :                 goto out_put;
    1534                 :            : 
    1535                 :          0 :         err = security_task_movememory(task);
    1536         [ #  # ]:          0 :         if (err)
    1537                 :          0 :                 goto out_put;
    1538                 :            : 
    1539                 :          0 :         mm = get_task_mm(task);
    1540                 :          0 :         put_task_struct(task);
    1541                 :            : 
    1542         [ #  # ]:          0 :         if (!mm) {
    1543                 :          0 :                 err = -EINVAL;
    1544                 :          0 :                 goto out;
    1545                 :            :         }
    1546                 :            : 
    1547         [ #  # ]:          0 :         err = do_migrate_pages(mm, old, new,
    1548                 :          0 :                 capable(CAP_SYS_NICE) ? MPOL_MF_MOVE_ALL : MPOL_MF_MOVE);
    1549                 :            : 
    1550                 :          0 :         mmput(mm);
    1551                 :          0 : out:
    1552                 :          0 :         NODEMASK_SCRATCH_FREE(scratch);
    1553                 :            : 
    1554                 :          0 :         return err;
    1555                 :            : 
    1556                 :          0 : out_put:
    1557                 :          0 :         put_task_struct(task);
    1558                 :          0 :         goto out;
    1559                 :            : 
    1560                 :            : }
    1561                 :            : 
    1562                 :          0 : SYSCALL_DEFINE4(migrate_pages, pid_t, pid, unsigned long, maxnode,
    1563                 :            :                 const unsigned long __user *, old_nodes,
    1564                 :            :                 const unsigned long __user *, new_nodes)
    1565                 :            : {
    1566                 :          0 :         return kernel_migrate_pages(pid, maxnode, old_nodes, new_nodes);
    1567                 :            : }
    1568                 :            : 
    1569                 :            : 
    1570                 :            : /* Retrieve NUMA policy */
    1571                 :          0 : static int kernel_get_mempolicy(int __user *policy,
    1572                 :            :                                 unsigned long __user *nmask,
    1573                 :            :                                 unsigned long maxnode,
    1574                 :            :                                 unsigned long addr,
    1575                 :            :                                 unsigned long flags)
    1576                 :            : {
    1577                 :          0 :         int err;
    1578                 :          0 :         int uninitialized_var(pval);
    1579                 :          0 :         nodemask_t nodes;
    1580                 :            : 
    1581                 :          0 :         addr = untagged_addr(addr);
    1582                 :            : 
    1583   [ #  #  #  # ]:          0 :         if (nmask != NULL && maxnode < nr_node_ids)
    1584                 :            :                 return -EINVAL;
    1585                 :            : 
    1586                 :          0 :         err = do_get_mempolicy(&pval, &nodes, addr, flags);
    1587                 :            : 
    1588         [ #  # ]:          0 :         if (err)
    1589                 :            :                 return err;
    1590                 :            : 
    1591   [ #  #  #  # ]:          0 :         if (policy && put_user(pval, policy))
    1592                 :            :                 return -EFAULT;
    1593                 :            : 
    1594         [ #  # ]:          0 :         if (nmask)
    1595                 :          0 :                 err = copy_nodes_to_user(nmask, maxnode, &nodes);
    1596                 :            : 
    1597                 :            :         return err;
    1598                 :            : }
    1599                 :            : 
    1600                 :          0 : SYSCALL_DEFINE5(get_mempolicy, int __user *, policy,
    1601                 :            :                 unsigned long __user *, nmask, unsigned long, maxnode,
    1602                 :            :                 unsigned long, addr, unsigned long, flags)
    1603                 :            : {
    1604                 :          0 :         return kernel_get_mempolicy(policy, nmask, maxnode, addr, flags);
    1605                 :            : }
    1606                 :            : 
    1607                 :            : #ifdef CONFIG_COMPAT
    1608                 :            : 
    1609                 :          0 : COMPAT_SYSCALL_DEFINE5(get_mempolicy, int __user *, policy,
    1610                 :            :                        compat_ulong_t __user *, nmask,
    1611                 :            :                        compat_ulong_t, maxnode,
    1612                 :            :                        compat_ulong_t, addr, compat_ulong_t, flags)
    1613                 :            : {
    1614                 :          0 :         long err;
    1615                 :          0 :         unsigned long __user *nm = NULL;
    1616                 :          0 :         unsigned long nr_bits, alloc_size;
    1617                 :          0 :         DECLARE_BITMAP(bm, MAX_NUMNODES);
    1618                 :            : 
    1619                 :          0 :         nr_bits = min_t(unsigned long, maxnode-1, nr_node_ids);
    1620                 :          0 :         alloc_size = ALIGN(nr_bits, BITS_PER_LONG) / 8;
    1621                 :            : 
    1622         [ #  # ]:          0 :         if (nmask)
    1623                 :          0 :                 nm = compat_alloc_user_space(alloc_size);
    1624                 :            : 
    1625                 :          0 :         err = kernel_get_mempolicy(policy, nm, nr_bits+1, addr, flags);
    1626                 :            : 
    1627         [ #  # ]:          0 :         if (!err && nmask) {
    1628                 :          0 :                 unsigned long copy_size;
    1629                 :          0 :                 copy_size = min_t(unsigned long, sizeof(bm), alloc_size);
    1630                 :          0 :                 err = copy_from_user(bm, nm, copy_size);
    1631                 :            :                 /* ensure entire bitmap is zeroed */
    1632                 :          0 :                 err |= clear_user(nmask, ALIGN(maxnode-1, 8) / 8);
    1633                 :          0 :                 err |= compat_put_bitmap(nmask, bm, nr_bits);
    1634                 :            :         }
    1635                 :            : 
    1636                 :          0 :         return err;
    1637                 :            : }
    1638                 :            : 
    1639                 :          0 : COMPAT_SYSCALL_DEFINE3(set_mempolicy, int, mode, compat_ulong_t __user *, nmask,
    1640                 :            :                        compat_ulong_t, maxnode)
    1641                 :            : {
    1642                 :          0 :         unsigned long __user *nm = NULL;
    1643                 :          0 :         unsigned long nr_bits, alloc_size;
    1644                 :          0 :         DECLARE_BITMAP(bm, MAX_NUMNODES);
    1645                 :            : 
    1646                 :          0 :         nr_bits = min_t(unsigned long, maxnode-1, MAX_NUMNODES);
    1647                 :          0 :         alloc_size = ALIGN(nr_bits, BITS_PER_LONG) / 8;
    1648                 :            : 
    1649         [ #  # ]:          0 :         if (nmask) {
    1650         [ #  # ]:          0 :                 if (compat_get_bitmap(bm, nmask, nr_bits))
    1651                 :            :                         return -EFAULT;
    1652                 :          0 :                 nm = compat_alloc_user_space(alloc_size);
    1653   [ #  #  #  # ]:          0 :                 if (copy_to_user(nm, bm, alloc_size))
    1654                 :            :                         return -EFAULT;
    1655                 :            :         }
    1656                 :            : 
    1657                 :          0 :         return kernel_set_mempolicy(mode, nm, nr_bits+1);
    1658                 :            : }
    1659                 :            : 
    1660                 :          0 : COMPAT_SYSCALL_DEFINE6(mbind, compat_ulong_t, start, compat_ulong_t, len,
    1661                 :            :                        compat_ulong_t, mode, compat_ulong_t __user *, nmask,
    1662                 :            :                        compat_ulong_t, maxnode, compat_ulong_t, flags)
    1663                 :            : {
    1664                 :          0 :         unsigned long __user *nm = NULL;
    1665                 :          0 :         unsigned long nr_bits, alloc_size;
    1666                 :          0 :         nodemask_t bm;
    1667                 :            : 
    1668                 :          0 :         nr_bits = min_t(unsigned long, maxnode-1, MAX_NUMNODES);
    1669                 :          0 :         alloc_size = ALIGN(nr_bits, BITS_PER_LONG) / 8;
    1670                 :            : 
    1671         [ #  # ]:          0 :         if (nmask) {
    1672         [ #  # ]:          0 :                 if (compat_get_bitmap(nodes_addr(bm), nmask, nr_bits))
    1673                 :            :                         return -EFAULT;
    1674                 :          0 :                 nm = compat_alloc_user_space(alloc_size);
    1675   [ #  #  #  # ]:          0 :                 if (copy_to_user(nm, nodes_addr(bm), alloc_size))
    1676                 :            :                         return -EFAULT;
    1677                 :            :         }
    1678                 :            : 
    1679                 :          0 :         return kernel_mbind(start, len, mode, nm, nr_bits+1, flags);
    1680                 :            : }
    1681                 :            : 
    1682                 :          0 : COMPAT_SYSCALL_DEFINE4(migrate_pages, compat_pid_t, pid,
    1683                 :            :                        compat_ulong_t, maxnode,
    1684                 :            :                        const compat_ulong_t __user *, old_nodes,
    1685                 :            :                        const compat_ulong_t __user *, new_nodes)
    1686                 :            : {
    1687                 :          0 :         unsigned long __user *old = NULL;
    1688                 :          0 :         unsigned long __user *new = NULL;
    1689                 :          0 :         nodemask_t tmp_mask;
    1690                 :          0 :         unsigned long nr_bits;
    1691                 :          0 :         unsigned long size;
    1692                 :            : 
    1693                 :          0 :         nr_bits = min_t(unsigned long, maxnode - 1, MAX_NUMNODES);
    1694                 :          0 :         size = ALIGN(nr_bits, BITS_PER_LONG) / 8;
    1695         [ #  # ]:          0 :         if (old_nodes) {
    1696         [ #  # ]:          0 :                 if (compat_get_bitmap(nodes_addr(tmp_mask), old_nodes, nr_bits))
    1697                 :            :                         return -EFAULT;
    1698         [ #  # ]:          0 :                 old = compat_alloc_user_space(new_nodes ? size * 2 : size);
    1699         [ #  # ]:          0 :                 if (new_nodes)
    1700                 :          0 :                         new = old + size / sizeof(unsigned long);
    1701   [ #  #  #  # ]:          0 :                 if (copy_to_user(old, nodes_addr(tmp_mask), size))
    1702                 :            :                         return -EFAULT;
    1703                 :            :         }
    1704         [ #  # ]:          0 :         if (new_nodes) {
    1705         [ #  # ]:          0 :                 if (compat_get_bitmap(nodes_addr(tmp_mask), new_nodes, nr_bits))
    1706                 :            :                         return -EFAULT;
    1707         [ #  # ]:          0 :                 if (new == NULL)
    1708                 :          0 :                         new = compat_alloc_user_space(size);
    1709   [ #  #  #  # ]:          0 :                 if (copy_to_user(new, nodes_addr(tmp_mask), size))
    1710                 :            :                         return -EFAULT;
    1711                 :            :         }
    1712                 :          0 :         return kernel_migrate_pages(pid, nr_bits + 1, old, new);
    1713                 :            : }
    1714                 :            : 
    1715                 :            : #endif /* CONFIG_COMPAT */
    1716                 :            : 
    1717                 :    1213125 : struct mempolicy *__get_vma_policy(struct vm_area_struct *vma,
    1718                 :            :                                                 unsigned long addr)
    1719                 :            : {
    1720                 :    1213125 :         struct mempolicy *pol = NULL;
    1721                 :            : 
    1722         [ +  - ]:    1213125 :         if (vma) {
    1723   [ +  +  -  + ]:    1213125 :                 if (vma->vm_ops && vma->vm_ops->get_policy) {
    1724                 :          0 :                         pol = vma->vm_ops->get_policy(vma, addr);
    1725         [ -  + ]:    1213125 :                 } else if (vma->vm_policy) {
    1726                 :          0 :                         pol = vma->vm_policy;
    1727                 :            : 
    1728                 :            :                         /*
    1729                 :            :                          * shmem_alloc_page() passes MPOL_F_SHARED policy with
    1730                 :            :                          * a pseudo vma whose vma->vm_ops=NULL. Take a reference
    1731                 :            :                          * count on these policies which will be dropped by
    1732                 :            :                          * mpol_cond_put() later
    1733                 :            :                          */
    1734         [ #  # ]:          0 :                         if (mpol_needs_cond_ref(pol))
    1735                 :          0 :                                 mpol_get(pol);
    1736                 :            :                 }
    1737                 :            :         }
    1738                 :            : 
    1739                 :    1213125 :         return pol;
    1740                 :            : }
    1741                 :            : 
    1742                 :            : /*
    1743                 :            :  * get_vma_policy(@vma, @addr)
    1744                 :            :  * @vma: virtual memory area whose policy is sought
    1745                 :            :  * @addr: address in @vma for shared policy lookup
    1746                 :            :  *
    1747                 :            :  * Returns effective policy for a VMA at specified address.
    1748                 :            :  * Falls back to current->mempolicy or system default policy, as necessary.
    1749                 :            :  * Shared policies [those marked as MPOL_F_SHARED] require an extra reference
    1750                 :            :  * count--added by the get_policy() vm_op, as appropriate--to protect against
    1751                 :            :  * freeing by another task.  It is the caller's responsibility to free the
    1752                 :            :  * extra reference for shared policies.
    1753                 :            :  */
    1754                 :    1213125 : static struct mempolicy *get_vma_policy(struct vm_area_struct *vma,
    1755                 :            :                                                 unsigned long addr)
    1756                 :            : {
    1757                 :    1213125 :         struct mempolicy *pol = __get_vma_policy(vma, addr);
    1758                 :            : 
    1759         [ +  - ]:    1213125 :         if (!pol)
    1760         [ +  - ]:    1213125 :                 pol = get_task_policy(current);
    1761                 :            : 
    1762                 :    1213125 :         return pol;
    1763                 :            : }
    1764                 :            : 
    1765                 :          0 : bool vma_policy_mof(struct vm_area_struct *vma)
    1766                 :            : {
    1767                 :          0 :         struct mempolicy *pol;
    1768                 :            : 
    1769   [ #  #  #  # ]:          0 :         if (vma->vm_ops && vma->vm_ops->get_policy) {
    1770                 :          0 :                 bool ret = false;
    1771                 :            : 
    1772                 :          0 :                 pol = vma->vm_ops->get_policy(vma, vma->vm_start);
    1773   [ #  #  #  # ]:          0 :                 if (pol && (pol->flags & MPOL_F_MOF))
    1774                 :          0 :                         ret = true;
    1775         [ #  # ]:          0 :                 mpol_cond_put(pol);
    1776                 :            : 
    1777                 :          0 :                 return ret;
    1778                 :            :         }
    1779                 :            : 
    1780                 :          0 :         pol = vma->vm_policy;
    1781         [ #  # ]:          0 :         if (!pol)
    1782         [ #  # ]:          0 :                 pol = get_task_policy(current);
    1783                 :            : 
    1784                 :          0 :         return pol->flags & MPOL_F_MOF;
    1785                 :            : }
    1786                 :            : 
    1787                 :          0 : static int apply_policy_zone(struct mempolicy *policy, enum zone_type zone)
    1788                 :            : {
    1789                 :          0 :         enum zone_type dynamic_policy_zone = policy_zone;
    1790                 :            : 
    1791         [ #  # ]:          0 :         BUG_ON(dynamic_policy_zone == ZONE_MOVABLE);
    1792                 :            : 
    1793                 :            :         /*
    1794                 :            :          * if policy->v.nodes has movable memory only,
    1795                 :            :          * we apply policy when gfp_zone(gfp) = ZONE_MOVABLE only.
    1796                 :            :          *
    1797                 :            :          * policy->v.nodes is intersect with node_states[N_MEMORY].
    1798                 :            :          * so if the following test faile, it implies
    1799                 :            :          * policy->v.nodes has movable memory only.
    1800                 :            :          */
    1801         [ #  # ]:          0 :         if (!nodes_intersects(policy->v.nodes, node_states[N_HIGH_MEMORY]))
    1802                 :          0 :                 dynamic_policy_zone = ZONE_MOVABLE;
    1803                 :            : 
    1804                 :          0 :         return zone >= dynamic_policy_zone;
    1805                 :            : }
    1806                 :            : 
    1807                 :            : /*
    1808                 :            :  * Return a nodemask representing a mempolicy for filtering nodes for
    1809                 :            :  * page allocation
    1810                 :            :  */
    1811                 :    3835371 : static nodemask_t *policy_nodemask(gfp_t gfp, struct mempolicy *policy)
    1812                 :            : {
    1813                 :            :         /* Lower zones don't get a nodemask applied for MPOL_BIND */
    1814   [ -  +  -  - ]:    3835371 :         if (unlikely(policy->mode == MPOL_BIND) &&
    1815         [ #  # ]:          0 :                         apply_policy_zone(policy, gfp_zone(gfp)) &&
    1816                 :          0 :                         cpuset_nodemask_valid_mems_allowed(&policy->v.nodes))
    1817                 :          0 :                 return &policy->v.nodes;
    1818                 :            : 
    1819                 :            :         return NULL;
    1820                 :            : }
    1821                 :            : 
    1822                 :            : /* Return the node id preferred by the given mempolicy, or the given id */
    1823                 :    3835338 : static int policy_node(gfp_t gfp, struct mempolicy *policy,
    1824                 :            :                                                                 int nd)
    1825                 :            : {
    1826   [ +  -  +  + ]:    3835338 :         if (policy->mode == MPOL_PREFERRED && !(policy->flags & MPOL_F_LOCAL))
    1827                 :    3833476 :                 nd = policy->v.preferred_node;
    1828                 :            :         else {
    1829                 :            :                 /*
    1830                 :            :                  * __GFP_THISNODE shouldn't even be used with the bind policy
    1831                 :            :                  * because we might easily break the expectation to stay on the
    1832                 :            :                  * requested node and not break the policy.
    1833                 :            :                  */
    1834   [ -  +  -  -  :       3724 :                 WARN_ON_ONCE(policy->mode == MPOL_BIND && (gfp & __GFP_THISNODE));
                   -  + ]
    1835                 :            :         }
    1836                 :            : 
    1837                 :    3835338 :         return nd;
    1838                 :            : }
    1839                 :            : 
    1840                 :            : /* Do dynamic interleaving for a process */
    1841                 :     307878 : static unsigned interleave_nodes(struct mempolicy *policy)
    1842                 :            : {
    1843                 :     307878 :         unsigned next;
    1844                 :     307878 :         struct task_struct *me = current;
    1845                 :            : 
    1846                 :     307878 :         next = next_node_in(me->il_prev, policy->v.nodes);
    1847   [ +  -  -  -  :     307878 :         if (next < MAX_NUMNODES)
                   +  - ]
    1848                 :     307878 :                 me->il_prev = next;
    1849                 :     187479 :         return next;
    1850                 :            : }
    1851                 :            : 
    1852                 :            : /*
    1853                 :            :  * Depending on the memory policy provide a node from which to allocate the
    1854                 :            :  * next slab entry.
    1855                 :            :  */
    1856                 :     748041 : unsigned int mempolicy_slab_node(void)
    1857                 :            : {
    1858                 :     748041 :         struct mempolicy *policy;
    1859         [ +  + ]:     748041 :         int node = numa_mem_id();
    1860                 :            : 
    1861         [ +  + ]:     748041 :         if (in_interrupt())
    1862                 :        119 :                 return node;
    1863                 :            : 
    1864         [ +  + ]:     747922 :         policy = current->mempolicy;
    1865   [ +  +  -  + ]:     747922 :         if (!policy || policy->flags & MPOL_F_LOCAL)
    1866                 :     627523 :                 return node;
    1867                 :            : 
    1868   [ -  +  -  - ]:     120399 :         switch (policy->mode) {
    1869                 :          0 :         case MPOL_PREFERRED:
    1870                 :            :                 /*
    1871                 :            :                  * handled MPOL_F_LOCAL above
    1872                 :            :                  */
    1873                 :          0 :                 return policy->v.preferred_node;
    1874                 :            : 
    1875                 :            :         case MPOL_INTERLEAVE:
    1876                 :     120399 :                 return interleave_nodes(policy);
    1877                 :            : 
    1878                 :            :         case MPOL_BIND: {
    1879                 :          0 :                 struct zoneref *z;
    1880                 :            : 
    1881                 :            :                 /*
    1882                 :            :                  * Follow bind policy behavior and start allocation at the
    1883                 :            :                  * first node.
    1884                 :            :                  */
    1885                 :          0 :                 struct zonelist *zonelist;
    1886         [ #  # ]:          0 :                 enum zone_type highest_zoneidx = gfp_zone(GFP_KERNEL);
    1887                 :          0 :                 zonelist = &NODE_DATA(node)->node_zonelists[ZONELIST_FALLBACK];
    1888         [ #  # ]:          0 :                 z = first_zones_zonelist(zonelist, highest_zoneidx,
    1889                 :            :                                                         &policy->v.nodes);
    1890         [ #  # ]:          0 :                 return z->zone ? zone_to_nid(z->zone) : node;
    1891                 :            :         }
    1892                 :            : 
    1893                 :          0 :         default:
    1894                 :          0 :                 BUG();
    1895                 :            :         }
    1896                 :            : }
    1897                 :            : 
    1898                 :            : /*
    1899                 :            :  * Do static interleaving for a VMA with known offset @n.  Returns the n'th
    1900                 :            :  * node in pol->v.nodes (starting from n=0), wrapping around if n exceeds the
    1901                 :            :  * number of present nodes.
    1902                 :            :  */
    1903                 :          0 : static unsigned offset_il_node(struct mempolicy *pol, unsigned long n)
    1904                 :            : {
    1905                 :          0 :         unsigned nnodes = nodes_weight(pol->v.nodes);
    1906                 :          0 :         unsigned target;
    1907                 :          0 :         int i;
    1908                 :          0 :         int nid;
    1909                 :            : 
    1910         [ #  # ]:          0 :         if (!nnodes)
    1911                 :          0 :                 return numa_node_id();
    1912                 :          0 :         target = (unsigned int)n % nnodes;
    1913                 :          0 :         nid = first_node(pol->v.nodes);
    1914         [ #  # ]:          0 :         for (i = 0; i < target; i++)
    1915                 :          0 :                 nid = next_node(nid, pol->v.nodes);
    1916                 :          0 :         return nid;
    1917                 :            : }
    1918                 :            : 
    1919                 :            : /* Determine a node number for interleave */
    1920                 :          0 : static inline unsigned interleave_nid(struct mempolicy *pol,
    1921                 :            :                  struct vm_area_struct *vma, unsigned long addr, int shift)
    1922                 :            : {
    1923         [ #  # ]:          0 :         if (vma) {
    1924                 :          0 :                 unsigned long off;
    1925                 :            : 
    1926                 :            :                 /*
    1927                 :            :                  * for small pages, there is no difference between
    1928                 :            :                  * shift and PAGE_SHIFT, so the bit-shift is safe.
    1929                 :            :                  * for huge pages, since vm_pgoff is in units of small
    1930                 :            :                  * pages, we need to shift off the always 0 bits to get
    1931                 :            :                  * a useful offset.
    1932                 :            :                  */
    1933         [ #  # ]:          0 :                 BUG_ON(shift < PAGE_SHIFT);
    1934                 :          0 :                 off = vma->vm_pgoff >> (shift - PAGE_SHIFT);
    1935                 :          0 :                 off += (addr - vma->vm_start) >> shift;
    1936                 :          0 :                 return offset_il_node(pol, off);
    1937                 :            :         } else
    1938                 :          0 :                 return interleave_nodes(pol);
    1939                 :            : }
    1940                 :            : 
    1941                 :            : #ifdef CONFIG_HUGETLBFS
    1942                 :            : /*
    1943                 :            :  * huge_node(@vma, @addr, @gfp_flags, @mpol)
    1944                 :            :  * @vma: virtual memory area whose policy is sought
    1945                 :            :  * @addr: address in @vma for shared policy lookup and interleave policy
    1946                 :            :  * @gfp_flags: for requested zone
    1947                 :            :  * @mpol: pointer to mempolicy pointer for reference counted mempolicy
    1948                 :            :  * @nodemask: pointer to nodemask pointer for MPOL_BIND nodemask
    1949                 :            :  *
    1950                 :            :  * Returns a nid suitable for a huge page allocation and a pointer
    1951                 :            :  * to the struct mempolicy for conditional unref after allocation.
    1952                 :            :  * If the effective policy is 'BIND, returns a pointer to the mempolicy's
    1953                 :            :  * @nodemask for filtering the zonelist.
    1954                 :            :  *
    1955                 :            :  * Must be protected by read_mems_allowed_begin()
    1956                 :            :  */
    1957                 :          0 : int huge_node(struct vm_area_struct *vma, unsigned long addr, gfp_t gfp_flags,
    1958                 :            :                                 struct mempolicy **mpol, nodemask_t **nodemask)
    1959                 :            : {
    1960                 :          0 :         int nid;
    1961                 :            : 
    1962                 :          0 :         *mpol = get_vma_policy(vma, addr);
    1963                 :          0 :         *nodemask = NULL;       /* assume !MPOL_BIND */
    1964                 :            : 
    1965         [ #  # ]:          0 :         if (unlikely((*mpol)->mode == MPOL_INTERLEAVE)) {
    1966                 :          0 :                 nid = interleave_nid(*mpol, vma, addr,
    1967                 :          0 :                                         huge_page_shift(hstate_vma(vma)));
    1968                 :            :         } else {
    1969                 :          0 :                 nid = policy_node(gfp_flags, *mpol, numa_node_id());
    1970         [ #  # ]:          0 :                 if ((*mpol)->mode == MPOL_BIND)
    1971                 :          0 :                         *nodemask = &(*mpol)->v.nodes;
    1972                 :            :         }
    1973                 :          0 :         return nid;
    1974                 :            : }
    1975                 :            : 
    1976                 :            : /*
    1977                 :            :  * init_nodemask_of_mempolicy
    1978                 :            :  *
    1979                 :            :  * If the current task's mempolicy is "default" [NULL], return 'false'
    1980                 :            :  * to indicate default policy.  Otherwise, extract the policy nodemask
    1981                 :            :  * for 'bind' or 'interleave' policy into the argument nodemask, or
    1982                 :            :  * initialize the argument nodemask to contain the single node for
    1983                 :            :  * 'preferred' or 'local' policy and return 'true' to indicate presence
    1984                 :            :  * of non-default mempolicy.
    1985                 :            :  *
    1986                 :            :  * We don't bother with reference counting the mempolicy [mpol_get/put]
    1987                 :            :  * because the current task is examining it's own mempolicy and a task's
    1988                 :            :  * mempolicy is only ever changed by the task itself.
    1989                 :            :  *
    1990                 :            :  * N.B., it is the caller's responsibility to free a returned nodemask.
    1991                 :            :  */
    1992                 :          0 : bool init_nodemask_of_mempolicy(nodemask_t *mask)
    1993                 :            : {
    1994                 :          0 :         struct mempolicy *mempolicy;
    1995                 :          0 :         int nid;
    1996                 :            : 
    1997   [ #  #  #  # ]:          0 :         if (!(mask && current->mempolicy))
    1998                 :            :                 return false;
    1999                 :            : 
    2000                 :          0 :         task_lock(current);
    2001      [ #  #  # ]:          0 :         mempolicy = current->mempolicy;
    2002      [ #  #  # ]:          0 :         switch (mempolicy->mode) {
    2003                 :          0 :         case MPOL_PREFERRED:
    2004         [ #  # ]:          0 :                 if (mempolicy->flags & MPOL_F_LOCAL)
    2005                 :          0 :                         nid = numa_node_id();
    2006                 :            :                 else
    2007                 :          0 :                         nid = mempolicy->v.preferred_node;
    2008                 :          0 :                 init_nodemask_of_node(mask, nid);
    2009                 :            :                 break;
    2010                 :            : 
    2011                 :          0 :         case MPOL_BIND:
    2012                 :            :                 /* Fall through */
    2013                 :            :         case MPOL_INTERLEAVE:
    2014                 :          0 :                 *mask =  mempolicy->v.nodes;
    2015                 :          0 :                 break;
    2016                 :            : 
    2017                 :          0 :         default:
    2018                 :          0 :                 BUG();
    2019                 :            :         }
    2020                 :          0 :         task_unlock(current);
    2021                 :            : 
    2022                 :          0 :         return true;
    2023                 :            : }
    2024                 :            : #endif
    2025                 :            : 
    2026                 :            : /*
    2027                 :            :  * mempolicy_nodemask_intersects
    2028                 :            :  *
    2029                 :            :  * If tsk's mempolicy is "default" [NULL], return 'true' to indicate default
    2030                 :            :  * policy.  Otherwise, check for intersection between mask and the policy
    2031                 :            :  * nodemask for 'bind' or 'interleave' policy.  For 'perferred' or 'local'
    2032                 :            :  * policy, always return true since it may allocate elsewhere on fallback.
    2033                 :            :  *
    2034                 :            :  * Takes task_lock(tsk) to prevent freeing of its mempolicy.
    2035                 :            :  */
    2036                 :          0 : bool mempolicy_nodemask_intersects(struct task_struct *tsk,
    2037                 :            :                                         const nodemask_t *mask)
    2038                 :            : {
    2039                 :          0 :         struct mempolicy *mempolicy;
    2040                 :          0 :         bool ret = true;
    2041                 :            : 
    2042         [ #  # ]:          0 :         if (!mask)
    2043                 :            :                 return ret;
    2044                 :          0 :         task_lock(tsk);
    2045                 :          0 :         mempolicy = tsk->mempolicy;
    2046         [ #  # ]:          0 :         if (!mempolicy)
    2047                 :          0 :                 goto out;
    2048                 :            : 
    2049      [ #  #  # ]:          0 :         switch (mempolicy->mode) {
    2050                 :            :         case MPOL_PREFERRED:
    2051                 :            :                 /*
    2052                 :            :                  * MPOL_PREFERRED and MPOL_F_LOCAL are only preferred nodes to
    2053                 :            :                  * allocate from, they may fallback to other nodes when oom.
    2054                 :            :                  * Thus, it's possible for tsk to have allocated memory from
    2055                 :            :                  * nodes in mask.
    2056                 :            :                  */
    2057                 :            :                 break;
    2058                 :          0 :         case MPOL_BIND:
    2059                 :            :         case MPOL_INTERLEAVE:
    2060                 :          0 :                 ret = nodes_intersects(mempolicy->v.nodes, *mask);
    2061                 :          0 :                 break;
    2062                 :          0 :         default:
    2063                 :          0 :                 BUG();
    2064                 :            :         }
    2065                 :          0 : out:
    2066                 :          0 :         task_unlock(tsk);
    2067                 :          0 :         return ret;
    2068                 :            : }
    2069                 :            : 
    2070                 :            : /* Allocate a page in interleaved policy.
    2071                 :            :    Own path because it needs to do special accounting. */
    2072                 :     187479 : static struct page *alloc_page_interleave(gfp_t gfp, unsigned order,
    2073                 :            :                                         unsigned nid)
    2074                 :            : {
    2075                 :     187479 :         struct page *page;
    2076                 :            : 
    2077                 :     187479 :         page = __alloc_pages(gfp, order, nid);
    2078                 :            :         /* skip NUMA_INTERLEAVE_HIT counter update if numa stats is disabled */
    2079   [ +  -  +  - ]:     374958 :         if (!static_branch_likely(&vm_numa_stat_key))
    2080                 :            :                 return page;
    2081   [ +  -  +  - ]:     187479 :         if (page && page_to_nid(page) == nid) {
    2082                 :     187479 :                 preempt_disable();
    2083                 :     187479 :                 __inc_numa_state(page_zone(page), NUMA_INTERLEAVE_HIT);
    2084                 :     187479 :                 preempt_enable();
    2085                 :            :         }
    2086                 :            :         return page;
    2087                 :            : }
    2088                 :            : 
    2089                 :            : /**
    2090                 :            :  *      alloc_pages_vma - Allocate a page for a VMA.
    2091                 :            :  *
    2092                 :            :  *      @gfp:
    2093                 :            :  *      %GFP_USER    user allocation.
    2094                 :            :  *      %GFP_KERNEL  kernel allocations,
    2095                 :            :  *      %GFP_HIGHMEM highmem/user allocations,
    2096                 :            :  *      %GFP_FS      allocation should not call back into a file system.
    2097                 :            :  *      %GFP_ATOMIC  don't sleep.
    2098                 :            :  *
    2099                 :            :  *      @order:Order of the GFP allocation.
    2100                 :            :  *      @vma:  Pointer to VMA or NULL if not available.
    2101                 :            :  *      @addr: Virtual Address of the allocation. Must be inside the VMA.
    2102                 :            :  *      @node: Which node to prefer for allocation (modulo policy).
    2103                 :            :  *      @hugepage: for hugepages try only the preferred node if possible
    2104                 :            :  *
    2105                 :            :  *      This function allocates a page from the kernel page pool and applies
    2106                 :            :  *      a NUMA policy associated with the VMA or the current process.
    2107                 :            :  *      When VMA is not NULL caller must hold down_read on the mmap_sem of the
    2108                 :            :  *      mm_struct of the VMA to prevent it from going away. Should be used for
    2109                 :            :  *      all allocations for pages that will be mapped into user space. Returns
    2110                 :            :  *      NULL when no page can be allocated.
    2111                 :            :  */
    2112                 :            : struct page *
    2113                 :    1213125 : alloc_pages_vma(gfp_t gfp, int order, struct vm_area_struct *vma,
    2114                 :            :                 unsigned long addr, int node, bool hugepage)
    2115                 :            : {
    2116                 :    1213125 :         struct mempolicy *pol;
    2117                 :    1213125 :         struct page *page;
    2118                 :    1213125 :         int preferred_nid;
    2119                 :    1213125 :         nodemask_t *nmask;
    2120                 :            : 
    2121                 :    1213125 :         pol = get_vma_policy(vma, addr);
    2122                 :            : 
    2123         [ -  + ]:    1213125 :         if (pol->mode == MPOL_INTERLEAVE) {
    2124                 :          0 :                 unsigned nid;
    2125                 :            : 
    2126                 :          0 :                 nid = interleave_nid(pol, vma, addr, PAGE_SHIFT + order);
    2127         [ #  # ]:          0 :                 mpol_cond_put(pol);
    2128                 :          0 :                 page = alloc_page_interleave(gfp, order, nid);
    2129                 :          0 :                 goto out;
    2130                 :            :         }
    2131                 :            : 
    2132                 :    1213125 :         if (unlikely(IS_ENABLED(CONFIG_TRANSPARENT_HUGEPAGE) && hugepage)) {
    2133                 :            :                 int hpage_node = node;
    2134                 :            : 
    2135                 :            :                 /*
    2136                 :            :                  * For hugepage allocation and non-interleave policy which
    2137                 :            :                  * allows the current node (or other explicitly preferred
    2138                 :            :                  * node) we only try to allocate from the current/preferred
    2139                 :            :                  * node and don't fall back to other nodes, as the cost of
    2140                 :            :                  * remote accesses would likely offset THP benefits.
    2141                 :            :                  *
    2142                 :            :                  * If the policy is interleave, or does not allow the current
    2143                 :            :                  * node in its nodemask, we allocate the standard way.
    2144                 :            :                  */
    2145                 :            :                 if (pol->mode == MPOL_PREFERRED && !(pol->flags & MPOL_F_LOCAL))
    2146                 :            :                         hpage_node = pol->v.preferred_node;
    2147                 :            : 
    2148                 :            :                 nmask = policy_nodemask(gfp, pol);
    2149                 :            :                 if (!nmask || node_isset(hpage_node, *nmask)) {
    2150                 :            :                         mpol_cond_put(pol);
    2151                 :            :                         /*
    2152                 :            :                          * First, try to allocate THP only on local node, but
    2153                 :            :                          * don't reclaim unnecessarily, just compact.
    2154                 :            :                          */
    2155                 :            :                         page = __alloc_pages_node(hpage_node,
    2156                 :            :                                 gfp | __GFP_THISNODE | __GFP_NORETRY, order);
    2157                 :            : 
    2158                 :            :                         /*
    2159                 :            :                          * If hugepage allocations are configured to always
    2160                 :            :                          * synchronous compact or the vma has been madvised
    2161                 :            :                          * to prefer hugepage backing, retry allowing remote
    2162                 :            :                          * memory with both reclaim and compact as well.
    2163                 :            :                          */
    2164                 :            :                         if (!page && (gfp & __GFP_DIRECT_RECLAIM))
    2165                 :            :                                 page = __alloc_pages_node(hpage_node,
    2166                 :            :                                                                 gfp, order);
    2167                 :            : 
    2168                 :            :                         goto out;
    2169                 :            :                 }
    2170                 :            :         }
    2171                 :            : 
    2172                 :    1213125 :         nmask = policy_nodemask(gfp, pol);
    2173                 :    1213125 :         preferred_nid = policy_node(gfp, pol, node);
    2174                 :    1213125 :         page = __alloc_pages_nodemask(gfp, order, preferred_nid, nmask);
    2175         [ +  - ]:    1213125 :         mpol_cond_put(pol);
    2176                 :    1213125 : out:
    2177                 :    1213125 :         return page;
    2178                 :            : }
    2179                 :            : EXPORT_SYMBOL(alloc_pages_vma);
    2180                 :            : 
    2181                 :            : /**
    2182                 :            :  *      alloc_pages_current - Allocate pages.
    2183                 :            :  *
    2184                 :            :  *      @gfp:
    2185                 :            :  *              %GFP_USER   user allocation,
    2186                 :            :  *              %GFP_KERNEL kernel allocation,
    2187                 :            :  *              %GFP_HIGHMEM highmem allocation,
    2188                 :            :  *              %GFP_FS     don't call back into a file system.
    2189                 :            :  *              %GFP_ATOMIC don't sleep.
    2190                 :            :  *      @order: Power of two of allocation size in pages. 0 is a single page.
    2191                 :            :  *
    2192                 :            :  *      Allocate a page from the kernel page pool.  When not in
    2193                 :            :  *      interrupt context and apply the current process NUMA policy.
    2194                 :            :  *      Returns NULL when no page can be allocated.
    2195                 :            :  */
    2196                 :    2809404 : struct page *alloc_pages_current(gfp_t gfp, unsigned order)
    2197                 :            : {
    2198                 :    2809404 :         struct mempolicy *pol = &default_policy;
    2199                 :    2809404 :         struct page *page;
    2200                 :            : 
    2201   [ +  +  +  - ]:    2809404 :         if (!in_interrupt() && !(gfp & __GFP_THISNODE))
    2202         [ +  + ]:    2809282 :                 pol = get_task_policy(current);
    2203                 :            : 
    2204                 :            :         /*
    2205                 :            :          * No reference counting needed for current->mempolicy
    2206                 :            :          * nor system default_policy
    2207                 :            :          */
    2208         [ +  + ]:    2809404 :         if (pol->mode == MPOL_INTERLEAVE)
    2209                 :     374958 :                 page = alloc_page_interleave(gfp, order, interleave_nodes(pol));
    2210                 :            :         else
    2211                 :    2621925 :                 page = __alloc_pages_nodemask(gfp, order,
    2212                 :            :                                 policy_node(gfp, pol, numa_node_id()),
    2213                 :            :                                 policy_nodemask(gfp, pol));
    2214                 :            : 
    2215                 :    2809404 :         return page;
    2216                 :            : }
    2217                 :            : EXPORT_SYMBOL(alloc_pages_current);
    2218                 :            : 
    2219                 :    2076723 : int vma_dup_policy(struct vm_area_struct *src, struct vm_area_struct *dst)
    2220                 :            : {
    2221         [ -  + ]:    2076723 :         struct mempolicy *pol = mpol_dup(vma_policy(src));
    2222                 :            : 
    2223         [ -  + ]:    2076723 :         if (IS_ERR(pol))
    2224                 :          0 :                 return PTR_ERR(pol);
    2225                 :    2076723 :         dst->vm_policy = pol;
    2226                 :    2076723 :         return 0;
    2227                 :            : }
    2228                 :            : 
    2229                 :            : /*
    2230                 :            :  * If mpol_dup() sees current->cpuset == cpuset_being_rebound, then it
    2231                 :            :  * rebinds the mempolicy its copying by calling mpol_rebind_policy()
    2232                 :            :  * with the mems_allowed returned by cpuset_mems_allowed().  This
    2233                 :            :  * keeps mempolicies cpuset relative after its cpuset moves.  See
    2234                 :            :  * further kernel/cpuset.c update_nodemask().
    2235                 :            :  *
    2236                 :            :  * current's mempolicy may be rebinded by the other task(the task that changes
    2237                 :            :  * cpuset's mems), so we needn't do rebind work for current task.
    2238                 :            :  */
    2239                 :            : 
    2240                 :            : /* Slow path of a mempolicy duplicate */
    2241                 :         30 : struct mempolicy *__mpol_dup(struct mempolicy *old)
    2242                 :            : {
    2243                 :         30 :         struct mempolicy *new = kmem_cache_alloc(policy_cache, GFP_KERNEL);
    2244                 :            : 
    2245         [ +  - ]:         30 :         if (!new)
    2246                 :            :                 return ERR_PTR(-ENOMEM);
    2247                 :            : 
    2248                 :            :         /* task's mempolicy is protected by alloc_lock */
    2249         [ +  - ]:         30 :         if (old == current->mempolicy) {
    2250                 :         30 :                 task_lock(current);
    2251                 :         30 :                 *new = *old;
    2252                 :         30 :                 task_unlock(current);
    2253                 :            :         } else
    2254                 :          0 :                 *new = *old;
    2255                 :            : 
    2256         [ -  + ]:         30 :         if (current_cpuset_is_being_rebound()) {
    2257                 :          0 :                 nodemask_t mems = cpuset_mems_allowed(current);
    2258                 :          0 :                 mpol_rebind_policy(new, &mems);
    2259                 :            :         }
    2260                 :         30 :         atomic_set(&new->refcnt, 1);
    2261                 :         30 :         return new;
    2262                 :            : }
    2263                 :            : 
    2264                 :            : /* Slow path of a mempolicy comparison */
    2265                 :          0 : bool __mpol_equal(struct mempolicy *a, struct mempolicy *b)
    2266                 :            : {
    2267         [ #  # ]:          0 :         if (!a || !b)
    2268                 :            :                 return false;
    2269         [ #  # ]:          0 :         if (a->mode != b->mode)
    2270                 :            :                 return false;
    2271         [ #  # ]:          0 :         if (a->flags != b->flags)
    2272                 :            :                 return false;
    2273         [ #  # ]:          0 :         if (mpol_store_user_nodemask(a))
    2274         [ #  # ]:          0 :                 if (!nodes_equal(a->w.user_nodemask, b->w.user_nodemask))
    2275                 :            :                         return false;
    2276                 :            : 
    2277      [ #  #  # ]:          0 :         switch (a->mode) {
    2278                 :          0 :         case MPOL_BIND:
    2279                 :            :                 /* Fall through */
    2280                 :            :         case MPOL_INTERLEAVE:
    2281                 :          0 :                 return !!nodes_equal(a->v.nodes, b->v.nodes);
    2282                 :          0 :         case MPOL_PREFERRED:
    2283                 :            :                 /* a's ->flags is the same as b's */
    2284         [ #  # ]:          0 :                 if (a->flags & MPOL_F_LOCAL)
    2285                 :            :                         return true;
    2286                 :          0 :                 return a->v.preferred_node == b->v.preferred_node;
    2287                 :          0 :         default:
    2288                 :          0 :                 BUG();
    2289                 :            :                 return false;
    2290                 :            :         }
    2291                 :            : }
    2292                 :            : 
    2293                 :            : /*
    2294                 :            :  * Shared memory backing store policy support.
    2295                 :            :  *
    2296                 :            :  * Remember policies even when nobody has shared memory mapped.
    2297                 :            :  * The policies are kept in Red-Black tree linked from the inode.
    2298                 :            :  * They are protected by the sp->lock rwlock, which should be held
    2299                 :            :  * for any accesses to the tree.
    2300                 :            :  */
    2301                 :            : 
    2302                 :            : /*
    2303                 :            :  * lookup first element intersecting start-end.  Caller holds sp->lock for
    2304                 :            :  * reading or for writing
    2305                 :            :  */
    2306                 :            : static struct sp_node *
    2307                 :            : sp_lookup(struct shared_policy *sp, unsigned long start, unsigned long end)
    2308                 :            : {
    2309                 :            :         struct rb_node *n = sp->root.rb_node;
    2310                 :            : 
    2311                 :            :         while (n) {
    2312                 :            :                 struct sp_node *p = rb_entry(n, struct sp_node, nd);
    2313                 :            : 
    2314                 :            :                 if (start >= p->end)
    2315                 :            :                         n = n->rb_right;
    2316                 :            :                 else if (end <= p->start)
    2317                 :            :                         n = n->rb_left;
    2318                 :            :                 else
    2319                 :            :                         break;
    2320                 :            :         }
    2321                 :            :         if (!n)
    2322                 :            :                 return NULL;
    2323                 :            :         for (;;) {
    2324                 :            :                 struct sp_node *w = NULL;
    2325                 :            :                 struct rb_node *prev = rb_prev(n);
    2326                 :            :                 if (!prev)
    2327                 :            :                         break;
    2328                 :            :                 w = rb_entry(prev, struct sp_node, nd);
    2329                 :            :                 if (w->end <= start)
    2330                 :            :                         break;
    2331                 :            :                 n = prev;
    2332                 :            :         }
    2333                 :            :         return rb_entry(n, struct sp_node, nd);
    2334                 :            : }
    2335                 :            : 
    2336                 :            : /*
    2337                 :            :  * Insert a new shared policy into the list.  Caller holds sp->lock for
    2338                 :            :  * writing.
    2339                 :            :  */
    2340                 :          0 : static void sp_insert(struct shared_policy *sp, struct sp_node *new)
    2341                 :            : {
    2342                 :          0 :         struct rb_node **p = &sp->root.rb_node;
    2343                 :          0 :         struct rb_node *parent = NULL;
    2344                 :          0 :         struct sp_node *nd;
    2345                 :            : 
    2346                 :          0 :         while (*p) {
    2347                 :          0 :                 parent = *p;
    2348                 :          0 :                 nd = rb_entry(parent, struct sp_node, nd);
    2349         [ #  # ]:          0 :                 if (new->start < nd->start)
    2350                 :          0 :                         p = &(*p)->rb_left;
    2351         [ #  # ]:          0 :                 else if (new->end > nd->end)
    2352                 :          0 :                         p = &(*p)->rb_right;
    2353                 :            :                 else
    2354         [ #  # ]:          0 :                         BUG();
    2355                 :            :         }
    2356                 :          0 :         rb_link_node(&new->nd, parent, p);
    2357                 :          0 :         rb_insert_color(&new->nd, &sp->root);
    2358                 :          0 :         pr_debug("inserting %lx-%lx: %d\n", new->start, new->end,
    2359                 :            :                  new->policy ? new->policy->mode : 0);
    2360                 :          0 : }
    2361                 :            : 
    2362                 :            : /* Find shared policy intersecting idx */
    2363                 :            : struct mempolicy *
    2364                 :      39474 : mpol_shared_policy_lookup(struct shared_policy *sp, unsigned long idx)
    2365                 :            : {
    2366                 :      39474 :         struct mempolicy *pol = NULL;
    2367                 :      39474 :         struct sp_node *sn;
    2368                 :            : 
    2369         [ -  + ]:      39474 :         if (!sp->root.rb_node)
    2370                 :            :                 return NULL;
    2371                 :          0 :         read_lock(&sp->lock);
    2372                 :          0 :         sn = sp_lookup(sp, idx, idx+1);
    2373         [ #  # ]:          0 :         if (sn) {
    2374         [ #  # ]:          0 :                 mpol_get(sn->policy);
    2375                 :          0 :                 pol = sn->policy;
    2376                 :            :         }
    2377                 :          0 :         read_unlock(&sp->lock);
    2378                 :          0 :         return pol;
    2379                 :            : }
    2380                 :            : 
    2381                 :          0 : static void sp_free(struct sp_node *n)
    2382                 :            : {
    2383         [ #  # ]:          0 :         mpol_put(n->policy);
    2384                 :          0 :         kmem_cache_free(sn_cache, n);
    2385                 :          0 : }
    2386                 :            : 
    2387                 :            : /**
    2388                 :            :  * mpol_misplaced - check whether current page node is valid in policy
    2389                 :            :  *
    2390                 :            :  * @page: page to be checked
    2391                 :            :  * @vma: vm area where page mapped
    2392                 :            :  * @addr: virtual address where page mapped
    2393                 :            :  *
    2394                 :            :  * Lookup current policy node id for vma,addr and "compare to" page's
    2395                 :            :  * node id.
    2396                 :            :  *
    2397                 :            :  * Returns:
    2398                 :            :  *      -1      - not misplaced, page is in the right node
    2399                 :            :  *      node    - node id where the page should be
    2400                 :            :  *
    2401                 :            :  * Policy determination "mimics" alloc_page_vma().
    2402                 :            :  * Called from fault path where we know the vma and faulting address.
    2403                 :            :  */
    2404                 :          0 : int mpol_misplaced(struct page *page, struct vm_area_struct *vma, unsigned long addr)
    2405                 :            : {
    2406                 :          0 :         struct mempolicy *pol;
    2407                 :          0 :         struct zoneref *z;
    2408                 :          0 :         int curnid = page_to_nid(page);
    2409                 :          0 :         unsigned long pgoff;
    2410                 :          0 :         int thiscpu = raw_smp_processor_id();
    2411                 :          0 :         int thisnid = cpu_to_node(thiscpu);
    2412                 :          0 :         int polnid = NUMA_NO_NODE;
    2413                 :          0 :         int ret = -1;
    2414                 :            : 
    2415                 :          0 :         pol = get_vma_policy(vma, addr);
    2416         [ #  # ]:          0 :         if (!(pol->flags & MPOL_F_MOF))
    2417                 :          0 :                 goto out;
    2418                 :            : 
    2419   [ #  #  #  # ]:          0 :         switch (pol->mode) {
    2420                 :          0 :         case MPOL_INTERLEAVE:
    2421                 :          0 :                 pgoff = vma->vm_pgoff;
    2422                 :          0 :                 pgoff += (addr - vma->vm_start) >> PAGE_SHIFT;
    2423                 :          0 :                 polnid = offset_il_node(pol, pgoff);
    2424                 :          0 :                 break;
    2425                 :            : 
    2426                 :          0 :         case MPOL_PREFERRED:
    2427         [ #  # ]:          0 :                 if (pol->flags & MPOL_F_LOCAL)
    2428                 :          0 :                         polnid = numa_node_id();
    2429                 :            :                 else
    2430                 :          0 :                         polnid = pol->v.preferred_node;
    2431                 :            :                 break;
    2432                 :            : 
    2433                 :          0 :         case MPOL_BIND:
    2434                 :            : 
    2435                 :            :                 /*
    2436                 :            :                  * allows binding to multiple nodes.
    2437                 :            :                  * use current page if in policy nodemask,
    2438                 :            :                  * else select nearest allowed node, if any.
    2439                 :            :                  * If no allowed nodes, use current [!misplaced].
    2440                 :            :                  */
    2441         [ #  # ]:          0 :                 if (node_isset(curnid, pol->v.nodes))
    2442                 :          0 :                         goto out;
    2443         [ #  # ]:          0 :                 z = first_zones_zonelist(
    2444                 :            :                                 node_zonelist(numa_node_id(), GFP_HIGHUSER),
    2445                 :            :                                 gfp_zone(GFP_HIGHUSER),
    2446                 :            :                                 &pol->v.nodes);
    2447                 :          0 :                 polnid = zone_to_nid(z->zone);
    2448                 :          0 :                 break;
    2449                 :            : 
    2450                 :          0 :         default:
    2451                 :          0 :                 BUG();
    2452                 :            :         }
    2453                 :            : 
    2454                 :            :         /* Migrate the page towards the node whose CPU is referencing it */
    2455         [ #  # ]:          0 :         if (pol->flags & MPOL_F_MORON) {
    2456                 :          0 :                 polnid = thisnid;
    2457                 :            : 
    2458                 :          0 :                 if (!should_numa_migrate_memory(current, page, curnid, thiscpu))
    2459                 :            :                         goto out;
    2460                 :            :         }
    2461                 :            : 
    2462         [ #  # ]:          0 :         if (curnid != polnid)
    2463                 :          0 :                 ret = polnid;
    2464                 :          0 : out:
    2465         [ #  # ]:          0 :         mpol_cond_put(pol);
    2466                 :            : 
    2467                 :          0 :         return ret;
    2468                 :            : }
    2469                 :            : 
    2470                 :            : /*
    2471                 :            :  * Drop the (possibly final) reference to task->mempolicy.  It needs to be
    2472                 :            :  * dropped after task->mempolicy is set to NULL so that any allocation done as
    2473                 :            :  * part of its kmem_cache_free(), such as by KASAN, doesn't reference a freed
    2474                 :            :  * policy.
    2475                 :            :  */
    2476                 :      27150 : void mpol_put_task_policy(struct task_struct *task)
    2477                 :            : {
    2478                 :      27150 :         struct mempolicy *pol;
    2479                 :            : 
    2480                 :      27150 :         task_lock(task);
    2481                 :      27150 :         pol = task->mempolicy;
    2482                 :      27150 :         task->mempolicy = NULL;
    2483                 :      27150 :         task_unlock(task);
    2484         [ -  + ]:      27150 :         mpol_put(pol);
    2485                 :      27150 : }
    2486                 :            : 
    2487                 :          0 : static void sp_delete(struct shared_policy *sp, struct sp_node *n)
    2488                 :            : {
    2489                 :          0 :         pr_debug("deleting %lx-l%lx\n", n->start, n->end);
    2490                 :          0 :         rb_erase(&n->nd, &sp->root);
    2491                 :          0 :         sp_free(n);
    2492                 :          0 : }
    2493                 :            : 
    2494                 :          0 : static void sp_node_init(struct sp_node *node, unsigned long start,
    2495                 :            :                         unsigned long end, struct mempolicy *pol)
    2496                 :            : {
    2497                 :          0 :         node->start = start;
    2498                 :          0 :         node->end = end;
    2499                 :          0 :         node->policy = pol;
    2500                 :            : }
    2501                 :            : 
    2502                 :          0 : static struct sp_node *sp_alloc(unsigned long start, unsigned long end,
    2503                 :            :                                 struct mempolicy *pol)
    2504                 :            : {
    2505                 :          0 :         struct sp_node *n;
    2506                 :          0 :         struct mempolicy *newpol;
    2507                 :            : 
    2508                 :          0 :         n = kmem_cache_alloc(sn_cache, GFP_KERNEL);
    2509         [ #  # ]:          0 :         if (!n)
    2510                 :            :                 return NULL;
    2511                 :            : 
    2512         [ #  # ]:          0 :         newpol = mpol_dup(pol);
    2513         [ #  # ]:          0 :         if (IS_ERR(newpol)) {
    2514                 :          0 :                 kmem_cache_free(sn_cache, n);
    2515                 :          0 :                 return NULL;
    2516                 :            :         }
    2517                 :          0 :         newpol->flags |= MPOL_F_SHARED;
    2518                 :          0 :         sp_node_init(n, start, end, newpol);
    2519                 :            : 
    2520                 :          0 :         return n;
    2521                 :            : }
    2522                 :            : 
    2523                 :            : /* Replace a policy range. */
    2524                 :          0 : static int shared_policy_replace(struct shared_policy *sp, unsigned long start,
    2525                 :            :                                  unsigned long end, struct sp_node *new)
    2526                 :            : {
    2527                 :          0 :         struct sp_node *n;
    2528                 :          0 :         struct sp_node *n_new = NULL;
    2529                 :          0 :         struct mempolicy *mpol_new = NULL;
    2530                 :          0 :         int ret = 0;
    2531                 :            : 
    2532                 :          0 : restart:
    2533                 :          0 :         write_lock(&sp->lock);
    2534                 :          0 :         n = sp_lookup(sp, start, end);
    2535                 :            :         /* Take care of old policies in the same range. */
    2536   [ #  #  #  # ]:          0 :         while (n && n->start < end) {
    2537                 :          0 :                 struct rb_node *next = rb_next(&n->nd);
    2538         [ #  # ]:          0 :                 if (n->start >= start) {
    2539         [ #  # ]:          0 :                         if (n->end <= end)
    2540                 :          0 :                                 sp_delete(sp, n);
    2541                 :            :                         else
    2542                 :          0 :                                 n->start = end;
    2543                 :            :                 } else {
    2544                 :            :                         /* Old policy spanning whole new range. */
    2545         [ #  # ]:          0 :                         if (n->end > end) {
    2546         [ #  # ]:          0 :                                 if (!n_new)
    2547                 :          0 :                                         goto alloc_new;
    2548                 :            : 
    2549                 :          0 :                                 *mpol_new = *n->policy;
    2550                 :          0 :                                 atomic_set(&mpol_new->refcnt, 1);
    2551                 :          0 :                                 sp_node_init(n_new, end, n->end, mpol_new);
    2552                 :          0 :                                 n->end = start;
    2553                 :          0 :                                 sp_insert(sp, n_new);
    2554                 :          0 :                                 n_new = NULL;
    2555                 :          0 :                                 mpol_new = NULL;
    2556                 :          0 :                                 break;
    2557                 :            :                         } else
    2558                 :          0 :                                 n->end = start;
    2559                 :            :                 }
    2560         [ #  # ]:          0 :                 if (!next)
    2561                 :            :                         break;
    2562                 :            :                 n = rb_entry(next, struct sp_node, nd);
    2563                 :            :         }
    2564         [ #  # ]:          0 :         if (new)
    2565                 :          0 :                 sp_insert(sp, new);
    2566                 :          0 :         write_unlock(&sp->lock);
    2567                 :          0 :         ret = 0;
    2568                 :            : 
    2569                 :          0 : err_out:
    2570         [ #  # ]:          0 :         if (mpol_new)
    2571                 :          0 :                 mpol_put(mpol_new);
    2572         [ #  # ]:          0 :         if (n_new)
    2573                 :          0 :                 kmem_cache_free(sn_cache, n_new);
    2574                 :            : 
    2575                 :          0 :         return ret;
    2576                 :            : 
    2577                 :            : alloc_new:
    2578                 :          0 :         write_unlock(&sp->lock);
    2579                 :          0 :         ret = -ENOMEM;
    2580                 :          0 :         n_new = kmem_cache_alloc(sn_cache, GFP_KERNEL);
    2581         [ #  # ]:          0 :         if (!n_new)
    2582                 :          0 :                 goto err_out;
    2583                 :          0 :         mpol_new = kmem_cache_alloc(policy_cache, GFP_KERNEL);
    2584         [ #  # ]:          0 :         if (!mpol_new)
    2585                 :          0 :                 goto err_out;
    2586                 :          0 :         goto restart;
    2587                 :            : }
    2588                 :            : 
    2589                 :            : /**
    2590                 :            :  * mpol_shared_policy_init - initialize shared policy for inode
    2591                 :            :  * @sp: pointer to inode shared policy
    2592                 :            :  * @mpol:  struct mempolicy to install
    2593                 :            :  *
    2594                 :            :  * Install non-NULL @mpol in inode's shared policy rb-tree.
    2595                 :            :  * On entry, the current task has a reference on a non-NULL @mpol.
    2596                 :            :  * This must be released on exit.
    2597                 :            :  * This is called at get_inode() calls and we can use GFP_KERNEL.
    2598                 :            :  */
    2599                 :      15960 : void mpol_shared_policy_init(struct shared_policy *sp, struct mempolicy *mpol)
    2600                 :            : {
    2601                 :      15960 :         int ret;
    2602                 :            : 
    2603                 :      15960 :         sp->root = RB_ROOT;          /* empty tree == default mempolicy */
    2604                 :      15960 :         rwlock_init(&sp->lock);
    2605                 :            : 
    2606         [ -  + ]:      15960 :         if (mpol) {
    2607                 :          0 :                 struct vm_area_struct pvma;
    2608                 :          0 :                 struct mempolicy *new;
    2609                 :          0 :                 NODEMASK_SCRATCH(scratch);
    2610                 :            : 
    2611                 :          0 :                 if (!scratch)
    2612                 :            :                         goto put_mpol;
    2613                 :            :                 /* contextualize the tmpfs mount point mempolicy */
    2614                 :          0 :                 new = mpol_new(mpol->mode, mpol->flags, &mpol->w.user_nodemask);
    2615         [ #  # ]:          0 :                 if (IS_ERR(new))
    2616                 :          0 :                         goto free_scratch; /* no valid nodemask intersection */
    2617                 :            : 
    2618                 :          0 :                 task_lock(current);
    2619                 :          0 :                 ret = mpol_set_nodemask(new, &mpol->w.user_nodemask, scratch);
    2620                 :          0 :                 task_unlock(current);
    2621         [ #  # ]:          0 :                 if (ret)
    2622                 :          0 :                         goto put_new;
    2623                 :            : 
    2624                 :            :                 /* Create pseudo-vma that contains just the policy */
    2625                 :          0 :                 vma_init(&pvma, NULL);
    2626   [ #  #  #  # ]:          0 :                 pvma.vm_end = TASK_SIZE;        /* policy covers entire file */
    2627                 :          0 :                 mpol_set_shared_policy(sp, &pvma, new); /* adds ref */
    2628                 :            : 
    2629                 :          0 : put_new:
    2630         [ #  # ]:          0 :                 mpol_put(new);                  /* drop initial ref */
    2631                 :          0 : free_scratch:
    2632                 :          0 :                 NODEMASK_SCRATCH_FREE(scratch);
    2633                 :          0 : put_mpol:
    2634                 :          0 :                 mpol_put(mpol); /* drop our incoming ref on sb mpol */
    2635                 :            :         }
    2636                 :      15960 : }
    2637                 :            : 
    2638                 :          0 : int mpol_set_shared_policy(struct shared_policy *info,
    2639                 :            :                         struct vm_area_struct *vma, struct mempolicy *npol)
    2640                 :            : {
    2641                 :          0 :         int err;
    2642                 :          0 :         struct sp_node *new = NULL;
    2643         [ #  # ]:          0 :         unsigned long sz = vma_pages(vma);
    2644                 :            : 
    2645                 :          0 :         pr_debug("set_shared_policy %lx sz %lu %d %d %lx\n",
    2646                 :            :                  vma->vm_pgoff,
    2647                 :            :                  sz, npol ? npol->mode : -1,
    2648                 :            :                  npol ? npol->flags : -1,
    2649                 :            :                  npol ? nodes_addr(npol->v.nodes)[0] : NUMA_NO_NODE);
    2650                 :            : 
    2651         [ #  # ]:          0 :         if (npol) {
    2652                 :          0 :                 new = sp_alloc(vma->vm_pgoff, vma->vm_pgoff + sz, npol);
    2653         [ #  # ]:          0 :                 if (!new)
    2654                 :            :                         return -ENOMEM;
    2655                 :            :         }
    2656                 :          0 :         err = shared_policy_replace(info, vma->vm_pgoff, vma->vm_pgoff+sz, new);
    2657         [ #  # ]:          0 :         if (err && new)
    2658                 :          0 :                 sp_free(new);
    2659                 :            :         return err;
    2660                 :            : }
    2661                 :            : 
    2662                 :            : /* Free a backing policy store on inode delete. */
    2663                 :       3000 : void mpol_free_shared_policy(struct shared_policy *p)
    2664                 :            : {
    2665                 :       3000 :         struct sp_node *n;
    2666                 :       3000 :         struct rb_node *next;
    2667                 :            : 
    2668         [ -  + ]:       3000 :         if (!p->root.rb_node)
    2669                 :            :                 return;
    2670                 :          0 :         write_lock(&p->lock);
    2671                 :          0 :         next = rb_first(&p->root);
    2672         [ #  # ]:          0 :         while (next) {
    2673                 :          0 :                 n = rb_entry(next, struct sp_node, nd);
    2674                 :          0 :                 next = rb_next(&n->nd);
    2675                 :          0 :                 sp_delete(p, n);
    2676                 :            :         }
    2677                 :          0 :         write_unlock(&p->lock);
    2678                 :            : }
    2679                 :            : 
    2680                 :            : #ifdef CONFIG_NUMA_BALANCING
    2681                 :            : static int __initdata numabalancing_override;
    2682                 :            : 
    2683                 :            : static void __init check_numabalancing_enable(void)
    2684                 :            : {
    2685                 :            :         bool numabalancing_default = false;
    2686                 :            : 
    2687                 :            :         if (IS_ENABLED(CONFIG_NUMA_BALANCING_DEFAULT_ENABLED))
    2688                 :            :                 numabalancing_default = true;
    2689                 :            : 
    2690                 :            :         /* Parsed by setup_numabalancing. override == 1 enables, -1 disables */
    2691                 :            :         if (numabalancing_override)
    2692                 :            :                 set_numabalancing_state(numabalancing_override == 1);
    2693                 :            : 
    2694                 :            :         if (num_online_nodes() > 1 && !numabalancing_override) {
    2695                 :            :                 pr_info("%s automatic NUMA balancing. Configure with numa_balancing= or the kernel.numa_balancing sysctl\n",
    2696                 :            :                         numabalancing_default ? "Enabling" : "Disabling");
    2697                 :            :                 set_numabalancing_state(numabalancing_default);
    2698                 :            :         }
    2699                 :            : }
    2700                 :            : 
    2701                 :            : static int __init setup_numabalancing(char *str)
    2702                 :            : {
    2703                 :            :         int ret = 0;
    2704                 :            :         if (!str)
    2705                 :            :                 goto out;
    2706                 :            : 
    2707                 :            :         if (!strcmp(str, "enable")) {
    2708                 :            :                 numabalancing_override = 1;
    2709                 :            :                 ret = 1;
    2710                 :            :         } else if (!strcmp(str, "disable")) {
    2711                 :            :                 numabalancing_override = -1;
    2712                 :            :                 ret = 1;
    2713                 :            :         }
    2714                 :            : out:
    2715                 :            :         if (!ret)
    2716                 :            :                 pr_warn("Unable to parse numa_balancing=\n");
    2717                 :            : 
    2718                 :            :         return ret;
    2719                 :            : }
    2720                 :            : __setup("numa_balancing=", setup_numabalancing);
    2721                 :            : #else
    2722                 :         30 : static inline void __init check_numabalancing_enable(void)
    2723                 :            : {
    2724                 :         30 : }
    2725                 :            : #endif /* CONFIG_NUMA_BALANCING */
    2726                 :            : 
    2727                 :            : /* assumes fs == KERNEL_DS */
    2728                 :         30 : void __init numa_policy_init(void)
    2729                 :            : {
    2730                 :         30 :         nodemask_t interleave_nodes;
    2731                 :         30 :         unsigned long largest = 0;
    2732                 :         30 :         int nid, prefer = 0;
    2733                 :            : 
    2734                 :         30 :         policy_cache = kmem_cache_create("numa_policy",
    2735                 :            :                                          sizeof(struct mempolicy),
    2736                 :            :                                          0, SLAB_PANIC, NULL);
    2737                 :            : 
    2738                 :         30 :         sn_cache = kmem_cache_create("shared_policy_node",
    2739                 :            :                                      sizeof(struct sp_node),
    2740                 :            :                                      0, SLAB_PANIC, NULL);
    2741                 :            : 
    2742         [ +  + ]:         90 :         for_each_node(nid) {
    2743                 :         30 :                 preferred_node_policy[nid] = (struct mempolicy) {
    2744                 :            :                         .refcnt = ATOMIC_INIT(1),
    2745                 :            :                         .mode = MPOL_PREFERRED,
    2746                 :            :                         .flags = MPOL_F_MOF | MPOL_F_MORON,
    2747                 :            :                         .v = { .preferred_node = nid, },
    2748                 :            :                 };
    2749                 :            :         }
    2750                 :            : 
    2751                 :            :         /*
    2752                 :            :          * Set interleaving policy for system init. Interleaving is only
    2753                 :            :          * enabled across suitably sized nodes (default is >= 16MB), or
    2754                 :            :          * fall back to the largest node if they're all smaller.
    2755                 :            :          */
    2756                 :         30 :         nodes_clear(interleave_nodes);
    2757         [ +  + ]:        120 :         for_each_node_state(nid, N_MEMORY) {
    2758                 :         30 :                 unsigned long total_pages = node_present_pages(nid);
    2759                 :            : 
    2760                 :            :                 /* Preserve the largest node */
    2761         [ +  - ]:         30 :                 if (largest < total_pages) {
    2762                 :         30 :                         largest = total_pages;
    2763                 :         30 :                         prefer = nid;
    2764                 :            :                 }
    2765                 :            : 
    2766                 :            :                 /* Interleave this node? */
    2767         [ +  - ]:         30 :                 if ((total_pages << PAGE_SHIFT) >= (16 << 20))
    2768                 :         30 :                         node_set(nid, interleave_nodes);
    2769                 :            :         }
    2770                 :            : 
    2771                 :            :         /* All too small, use the largest */
    2772         [ -  + ]:         30 :         if (unlikely(nodes_empty(interleave_nodes)))
    2773                 :          0 :                 node_set(prefer, interleave_nodes);
    2774                 :            : 
    2775         [ -  + ]:         30 :         if (do_set_mempolicy(MPOL_INTERLEAVE, 0, &interleave_nodes))
    2776                 :          0 :                 pr_err("%s: interleaving failed\n", __func__);
    2777                 :            : 
    2778                 :         30 :         check_numabalancing_enable();
    2779                 :         30 : }
    2780                 :            : 
    2781                 :            : /* Reset policy of current process to default */
    2782                 :         60 : void numa_default_policy(void)
    2783                 :            : {
    2784                 :         60 :         do_set_mempolicy(MPOL_DEFAULT, 0, NULL);
    2785                 :         60 : }
    2786                 :            : 
    2787                 :            : /*
    2788                 :            :  * Parse and format mempolicy from/to strings
    2789                 :            :  */
    2790                 :            : 
    2791                 :            : /*
    2792                 :            :  * "local" is implemented internally by MPOL_PREFERRED with MPOL_F_LOCAL flag.
    2793                 :            :  */
    2794                 :            : static const char * const policy_modes[] =
    2795                 :            : {
    2796                 :            :         [MPOL_DEFAULT]    = "default",
    2797                 :            :         [MPOL_PREFERRED]  = "prefer",
    2798                 :            :         [MPOL_BIND]       = "bind",
    2799                 :            :         [MPOL_INTERLEAVE] = "interleave",
    2800                 :            :         [MPOL_LOCAL]      = "local",
    2801                 :            : };
    2802                 :            : 
    2803                 :            : 
    2804                 :            : #ifdef CONFIG_TMPFS
    2805                 :            : /**
    2806                 :            :  * mpol_parse_str - parse string to mempolicy, for tmpfs mpol mount option.
    2807                 :            :  * @str:  string containing mempolicy to parse
    2808                 :            :  * @mpol:  pointer to struct mempolicy pointer, returned on success.
    2809                 :            :  *
    2810                 :            :  * Format of input:
    2811                 :            :  *      <mode>[=<flags>][:<nodelist>]
    2812                 :            :  *
    2813                 :            :  * On success, returns 0, else 1
    2814                 :            :  */
    2815                 :          0 : int mpol_parse_str(char *str, struct mempolicy **mpol)
    2816                 :            : {
    2817                 :          0 :         struct mempolicy *new = NULL;
    2818                 :          0 :         unsigned short mode_flags;
    2819                 :          0 :         nodemask_t nodes;
    2820                 :          0 :         char *nodelist = strchr(str, ':');
    2821                 :          0 :         char *flags = strchr(str, '=');
    2822                 :          0 :         int err = 1, mode;
    2823                 :            : 
    2824         [ #  # ]:          0 :         if (flags)
    2825                 :          0 :                 *flags++ = '\0';        /* terminate mode string */
    2826                 :            : 
    2827         [ #  # ]:          0 :         if (nodelist) {
    2828                 :            :                 /* NUL-terminate mode or flags string */
    2829                 :          0 :                 *nodelist++ = '\0';
    2830         [ #  # ]:          0 :                 if (nodelist_parse(nodelist, nodes))
    2831                 :          0 :                         goto out;
    2832         [ #  # ]:          0 :                 if (!nodes_subset(nodes, node_states[N_MEMORY]))
    2833                 :          0 :                         goto out;
    2834                 :            :         } else
    2835                 :          0 :                 nodes_clear(nodes);
    2836                 :            : 
    2837                 :          0 :         mode = match_string(policy_modes, MPOL_MAX, str);
    2838         [ #  # ]:          0 :         if (mode < 0)
    2839                 :          0 :                 goto out;
    2840                 :            : 
    2841   [ #  #  #  #  :          0 :         switch (mode) {
                   #  # ]
    2842                 :          0 :         case MPOL_PREFERRED:
    2843                 :            :                 /*
    2844                 :            :                  * Insist on a nodelist of one node only
    2845                 :            :                  */
    2846         [ #  # ]:          0 :                 if (nodelist) {
    2847                 :            :                         char *rest = nodelist;
    2848         [ #  # ]:          0 :                         while (isdigit(*rest))
    2849                 :          0 :                                 rest++;
    2850         [ #  # ]:          0 :                         if (*rest)
    2851                 :          0 :                                 goto out;
    2852                 :            :                 }
    2853                 :            :                 break;
    2854                 :          0 :         case MPOL_INTERLEAVE:
    2855                 :            :                 /*
    2856                 :            :                  * Default to online nodes with memory if no nodelist
    2857                 :            :                  */
    2858         [ #  # ]:          0 :                 if (!nodelist)
    2859                 :          0 :                         nodes = node_states[N_MEMORY];
    2860                 :            :                 break;
    2861                 :          0 :         case MPOL_LOCAL:
    2862                 :            :                 /*
    2863                 :            :                  * Don't allow a nodelist;  mpol_new() checks flags
    2864                 :            :                  */
    2865         [ #  # ]:          0 :                 if (nodelist)
    2866                 :          0 :                         goto out;
    2867                 :            :                 mode = MPOL_PREFERRED;
    2868                 :            :                 break;
    2869                 :          0 :         case MPOL_DEFAULT:
    2870                 :            :                 /*
    2871                 :            :                  * Insist on a empty nodelist
    2872                 :            :                  */
    2873         [ #  # ]:          0 :                 if (!nodelist)
    2874                 :          0 :                         err = 0;
    2875                 :          0 :                 goto out;
    2876                 :          0 :         case MPOL_BIND:
    2877                 :            :                 /*
    2878                 :            :                  * Insist on a nodelist
    2879                 :            :                  */
    2880         [ #  # ]:          0 :                 if (!nodelist)
    2881                 :          0 :                         goto out;
    2882                 :            :         }
    2883                 :            : 
    2884                 :          0 :         mode_flags = 0;
    2885         [ #  # ]:          0 :         if (flags) {
    2886                 :            :                 /*
    2887                 :            :                  * Currently, we only support two mutually exclusive
    2888                 :            :                  * mode flags.
    2889                 :            :                  */
    2890         [ #  # ]:          0 :                 if (!strcmp(flags, "static"))
    2891                 :            :                         mode_flags |= MPOL_F_STATIC_NODES;
    2892         [ #  # ]:          0 :                 else if (!strcmp(flags, "relative"))
    2893                 :            :                         mode_flags |= MPOL_F_RELATIVE_NODES;
    2894                 :            :                 else
    2895                 :          0 :                         goto out;
    2896                 :            :         }
    2897                 :            : 
    2898                 :          0 :         new = mpol_new(mode, mode_flags, &nodes);
    2899         [ #  # ]:          0 :         if (IS_ERR(new))
    2900                 :          0 :                 goto out;
    2901                 :            : 
    2902                 :            :         /*
    2903                 :            :          * Save nodes for mpol_to_str() to show the tmpfs mount options
    2904                 :            :          * for /proc/mounts, /proc/pid/mounts and /proc/pid/mountinfo.
    2905                 :            :          */
    2906         [ #  # ]:          0 :         if (mode != MPOL_PREFERRED)
    2907                 :          0 :                 new->v.nodes = nodes;
    2908         [ #  # ]:          0 :         else if (nodelist)
    2909                 :          0 :                 new->v.preferred_node = first_node(nodes);
    2910                 :            :         else
    2911                 :          0 :                 new->flags |= MPOL_F_LOCAL;
    2912                 :            : 
    2913                 :            :         /*
    2914                 :            :          * Save nodes for contextualization: this will be used to "clone"
    2915                 :            :          * the mempolicy in a specific context [cpuset] at a later time.
    2916                 :            :          */
    2917                 :          0 :         new->w.user_nodemask = nodes;
    2918                 :            : 
    2919                 :          0 :         err = 0;
    2920                 :            : 
    2921                 :          0 : out:
    2922                 :            :         /* Restore string for error message */
    2923         [ #  # ]:          0 :         if (nodelist)
    2924                 :          0 :                 *--nodelist = ':';
    2925         [ #  # ]:          0 :         if (flags)
    2926                 :          0 :                 *--flags = '=';
    2927         [ #  # ]:          0 :         if (!err)
    2928                 :          0 :                 *mpol = new;
    2929                 :          0 :         return err;
    2930                 :            : }
    2931                 :            : #endif /* CONFIG_TMPFS */
    2932                 :            : 
    2933                 :            : /**
    2934                 :            :  * mpol_to_str - format a mempolicy structure for printing
    2935                 :            :  * @buffer:  to contain formatted mempolicy string
    2936                 :            :  * @maxlen:  length of @buffer
    2937                 :            :  * @pol:  pointer to mempolicy to be formatted
    2938                 :            :  *
    2939                 :            :  * Convert @pol into a string.  If @buffer is too short, truncate the string.
    2940                 :            :  * Recommend a @maxlen of at least 32 for the longest mode, "interleave", the
    2941                 :            :  * longest flag, "relative", and to display at least a few node ids.
    2942                 :            :  */
    2943                 :          0 : void mpol_to_str(char *buffer, int maxlen, struct mempolicy *pol)
    2944                 :            : {
    2945                 :          0 :         char *p = buffer;
    2946                 :          0 :         nodemask_t nodes = NODE_MASK_NONE;
    2947                 :          0 :         unsigned short mode = MPOL_DEFAULT;
    2948                 :          0 :         unsigned short flags = 0;
    2949                 :            : 
    2950   [ #  #  #  #  :          0 :         if (pol && pol != &default_policy && !(pol->flags & MPOL_F_MORON)) {
                   #  # ]
    2951                 :          0 :                 mode = pol->mode;
    2952                 :          0 :                 flags = pol->flags;
    2953                 :            :         }
    2954                 :            : 
    2955   [ #  #  #  # ]:          0 :         switch (mode) {
    2956                 :            :         case MPOL_DEFAULT:
    2957                 :            :                 break;
    2958                 :          0 :         case MPOL_PREFERRED:
    2959         [ #  # ]:          0 :                 if (flags & MPOL_F_LOCAL)
    2960                 :            :                         mode = MPOL_LOCAL;
    2961                 :            :                 else
    2962                 :          0 :                         node_set(pol->v.preferred_node, nodes);
    2963                 :            :                 break;
    2964                 :          0 :         case MPOL_BIND:
    2965                 :            :         case MPOL_INTERLEAVE:
    2966                 :          0 :                 nodes = pol->v.nodes;
    2967                 :          0 :                 break;
    2968                 :            :         default:
    2969                 :          0 :                 WARN_ON_ONCE(1);
    2970                 :          0 :                 snprintf(p, maxlen, "unknown");
    2971                 :          0 :                 return;
    2972                 :            :         }
    2973                 :            : 
    2974                 :          0 :         p += snprintf(p, maxlen, "%s", policy_modes[mode]);
    2975                 :            : 
    2976         [ #  # ]:          0 :         if (flags & MPOL_MODE_FLAGS) {
    2977                 :          0 :                 p += snprintf(p, buffer + maxlen - p, "=");
    2978                 :            : 
    2979                 :            :                 /*
    2980                 :            :                  * Currently, the only defined flags are mutually exclusive
    2981                 :            :                  */
    2982         [ #  # ]:          0 :                 if (flags & MPOL_F_STATIC_NODES)
    2983                 :          0 :                         p += snprintf(p, buffer + maxlen - p, "static");
    2984                 :          0 :                 else if (flags & MPOL_F_RELATIVE_NODES)
    2985                 :          0 :                         p += snprintf(p, buffer + maxlen - p, "relative");
    2986                 :            :         }
    2987                 :            : 
    2988         [ #  # ]:          0 :         if (!nodes_empty(nodes))
    2989                 :          0 :                 p += scnprintf(p, buffer + maxlen - p, ":%*pbl",
    2990                 :            :                                nodemask_pr_args(&nodes));
    2991                 :            : }

Generated by: LCOV version 1.14