mm/mempolicy.c

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