mm: remove useless vma parameter to offset_il_node
[sfrench/cifs-2.6.git] / 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                 inc_zone_page_state(page, NUMA_INTERLEAVE_HIT);
1925         return page;
1926 }
1927
1928 /**
1929  *      alloc_pages_vma - Allocate a page for a VMA.
1930  *
1931  *      @gfp:
1932  *      %GFP_USER    user allocation.
1933  *      %GFP_KERNEL  kernel allocations,
1934  *      %GFP_HIGHMEM highmem/user allocations,
1935  *      %GFP_FS      allocation should not call back into a file system.
1936  *      %GFP_ATOMIC  don't sleep.
1937  *
1938  *      @order:Order of the GFP allocation.
1939  *      @vma:  Pointer to VMA or NULL if not available.
1940  *      @addr: Virtual Address of the allocation. Must be inside the VMA.
1941  *      @node: Which node to prefer for allocation (modulo policy).
1942  *      @hugepage: for hugepages try only the preferred node if possible
1943  *
1944  *      This function allocates a page from the kernel page pool and applies
1945  *      a NUMA policy associated with the VMA or the current process.
1946  *      When VMA is not NULL caller must hold down_read on the mmap_sem of the
1947  *      mm_struct of the VMA to prevent it from going away. Should be used for
1948  *      all allocations for pages that will be mapped into user space. Returns
1949  *      NULL when no page can be allocated.
1950  */
1951 struct page *
1952 alloc_pages_vma(gfp_t gfp, int order, struct vm_area_struct *vma,
1953                 unsigned long addr, int node, bool hugepage)
1954 {
1955         struct mempolicy *pol;
1956         struct page *page;
1957         int preferred_nid;
1958         nodemask_t *nmask;
1959
1960         pol = get_vma_policy(vma, addr);
1961
1962         if (pol->mode == MPOL_INTERLEAVE) {
1963                 unsigned nid;
1964
1965                 nid = interleave_nid(pol, vma, addr, PAGE_SHIFT + order);
1966                 mpol_cond_put(pol);
1967                 page = alloc_page_interleave(gfp, order, nid);
1968                 goto out;
1969         }
1970
1971         if (unlikely(IS_ENABLED(CONFIG_TRANSPARENT_HUGEPAGE) && hugepage)) {
1972                 int hpage_node = node;
1973
1974                 /*
1975                  * For hugepage allocation and non-interleave policy which
1976                  * allows the current node (or other explicitly preferred
1977                  * node) we only try to allocate from the current/preferred
1978                  * node and don't fall back to other nodes, as the cost of
1979                  * remote accesses would likely offset THP benefits.
1980                  *
1981                  * If the policy is interleave, or does not allow the current
1982                  * node in its nodemask, we allocate the standard way.
1983                  */
1984                 if (pol->mode == MPOL_PREFERRED &&
1985                                                 !(pol->flags & MPOL_F_LOCAL))
1986                         hpage_node = pol->v.preferred_node;
1987
1988                 nmask = policy_nodemask(gfp, pol);
1989                 if (!nmask || node_isset(hpage_node, *nmask)) {
1990                         mpol_cond_put(pol);
1991                         page = __alloc_pages_node(hpage_node,
1992                                                 gfp | __GFP_THISNODE, order);
1993                         goto out;
1994                 }
1995         }
1996
1997         nmask = policy_nodemask(gfp, pol);
1998         preferred_nid = policy_node(gfp, pol, node);
1999         page = __alloc_pages_nodemask(gfp, order, preferred_nid, nmask);
2000         mpol_cond_put(pol);
2001 out:
2002         return page;
2003 }
2004
2005 /**
2006  *      alloc_pages_current - Allocate pages.
2007  *
2008  *      @gfp:
2009  *              %GFP_USER   user allocation,
2010  *              %GFP_KERNEL kernel allocation,
2011  *              %GFP_HIGHMEM highmem allocation,
2012  *              %GFP_FS     don't call back into a file system.
2013  *              %GFP_ATOMIC don't sleep.
2014  *      @order: Power of two of allocation size in pages. 0 is a single page.
2015  *
2016  *      Allocate a page from the kernel page pool.  When not in
2017  *      interrupt context and apply the current process NUMA policy.
2018  *      Returns NULL when no page can be allocated.
2019  */
2020 struct page *alloc_pages_current(gfp_t gfp, unsigned order)
2021 {
2022         struct mempolicy *pol = &default_policy;
2023         struct page *page;
2024
2025         if (!in_interrupt() && !(gfp & __GFP_THISNODE))
2026                 pol = get_task_policy(current);
2027
2028         /*
2029          * No reference counting needed for current->mempolicy
2030          * nor system default_policy
2031          */
2032         if (pol->mode == MPOL_INTERLEAVE)
2033                 page = alloc_page_interleave(gfp, order, interleave_nodes(pol));
2034         else
2035                 page = __alloc_pages_nodemask(gfp, order,
2036                                 policy_node(gfp, pol, numa_node_id()),
2037                                 policy_nodemask(gfp, pol));
2038
2039         return page;
2040 }
2041 EXPORT_SYMBOL(alloc_pages_current);
2042
2043 int vma_dup_policy(struct vm_area_struct *src, struct vm_area_struct *dst)
2044 {
2045         struct mempolicy *pol = mpol_dup(vma_policy(src));
2046
2047         if (IS_ERR(pol))
2048                 return PTR_ERR(pol);
2049         dst->vm_policy = pol;
2050         return 0;
2051 }
2052
2053 /*
2054  * If mpol_dup() sees current->cpuset == cpuset_being_rebound, then it
2055  * rebinds the mempolicy its copying by calling mpol_rebind_policy()
2056  * with the mems_allowed returned by cpuset_mems_allowed().  This
2057  * keeps mempolicies cpuset relative after its cpuset moves.  See
2058  * further kernel/cpuset.c update_nodemask().
2059  *
2060  * current's mempolicy may be rebinded by the other task(the task that changes
2061  * cpuset's mems), so we needn't do rebind work for current task.
2062  */
2063
2064 /* Slow path of a mempolicy duplicate */
2065 struct mempolicy *__mpol_dup(struct mempolicy *old)
2066 {
2067         struct mempolicy *new = kmem_cache_alloc(policy_cache, GFP_KERNEL);
2068
2069         if (!new)
2070                 return ERR_PTR(-ENOMEM);
2071
2072         /* task's mempolicy is protected by alloc_lock */
2073         if (old == current->mempolicy) {
2074                 task_lock(current);
2075                 *new = *old;
2076                 task_unlock(current);
2077         } else
2078                 *new = *old;
2079
2080         if (current_cpuset_is_being_rebound()) {
2081                 nodemask_t mems = cpuset_mems_allowed(current);
2082                 mpol_rebind_policy(new, &mems);
2083         }
2084         atomic_set(&new->refcnt, 1);
2085         return new;
2086 }
2087
2088 /* Slow path of a mempolicy comparison */
2089 bool __mpol_equal(struct mempolicy *a, struct mempolicy *b)
2090 {
2091         if (!a || !b)
2092                 return false;
2093         if (a->mode != b->mode)
2094                 return false;
2095         if (a->flags != b->flags)
2096                 return false;
2097         if (mpol_store_user_nodemask(a))
2098                 if (!nodes_equal(a->w.user_nodemask, b->w.user_nodemask))
2099                         return false;
2100
2101         switch (a->mode) {
2102         case MPOL_BIND:
2103                 /* Fall through */
2104         case MPOL_INTERLEAVE:
2105                 return !!nodes_equal(a->v.nodes, b->v.nodes);
2106         case MPOL_PREFERRED:
2107                 return a->v.preferred_node == b->v.preferred_node;
2108         default:
2109                 BUG();
2110                 return false;
2111         }
2112 }
2113
2114 /*
2115  * Shared memory backing store policy support.
2116  *
2117  * Remember policies even when nobody has shared memory mapped.
2118  * The policies are kept in Red-Black tree linked from the inode.
2119  * They are protected by the sp->lock rwlock, which should be held
2120  * for any accesses to the tree.
2121  */
2122
2123 /*
2124  * lookup first element intersecting start-end.  Caller holds sp->lock for
2125  * reading or for writing
2126  */
2127 static struct sp_node *
2128 sp_lookup(struct shared_policy *sp, unsigned long start, unsigned long end)
2129 {
2130         struct rb_node *n = sp->root.rb_node;
2131
2132         while (n) {
2133                 struct sp_node *p = rb_entry(n, struct sp_node, nd);
2134
2135                 if (start >= p->end)
2136                         n = n->rb_right;
2137                 else if (end <= p->start)
2138                         n = n->rb_left;
2139                 else
2140                         break;
2141         }
2142         if (!n)
2143                 return NULL;
2144         for (;;) {
2145                 struct sp_node *w = NULL;
2146                 struct rb_node *prev = rb_prev(n);
2147                 if (!prev)
2148                         break;
2149                 w = rb_entry(prev, struct sp_node, nd);
2150                 if (w->end <= start)
2151                         break;
2152                 n = prev;
2153         }
2154         return rb_entry(n, struct sp_node, nd);
2155 }
2156
2157 /*
2158  * Insert a new shared policy into the list.  Caller holds sp->lock for
2159  * writing.
2160  */
2161 static void sp_insert(struct shared_policy *sp, struct sp_node *new)
2162 {
2163         struct rb_node **p = &sp->root.rb_node;
2164         struct rb_node *parent = NULL;
2165         struct sp_node *nd;
2166
2167         while (*p) {
2168                 parent = *p;
2169                 nd = rb_entry(parent, struct sp_node, nd);
2170                 if (new->start < nd->start)
2171                         p = &(*p)->rb_left;
2172                 else if (new->end > nd->end)
2173                         p = &(*p)->rb_right;
2174                 else
2175                         BUG();
2176         }
2177         rb_link_node(&new->nd, parent, p);
2178         rb_insert_color(&new->nd, &sp->root);
2179         pr_debug("inserting %lx-%lx: %d\n", new->start, new->end,
2180                  new->policy ? new->policy->mode : 0);
2181 }
2182
2183 /* Find shared policy intersecting idx */
2184 struct mempolicy *
2185 mpol_shared_policy_lookup(struct shared_policy *sp, unsigned long idx)
2186 {
2187         struct mempolicy *pol = NULL;
2188         struct sp_node *sn;
2189
2190         if (!sp->root.rb_node)
2191                 return NULL;
2192         read_lock(&sp->lock);
2193         sn = sp_lookup(sp, idx, idx+1);
2194         if (sn) {
2195                 mpol_get(sn->policy);
2196                 pol = sn->policy;
2197         }
2198         read_unlock(&sp->lock);
2199         return pol;
2200 }
2201
2202 static void sp_free(struct sp_node *n)
2203 {
2204         mpol_put(n->policy);
2205         kmem_cache_free(sn_cache, n);
2206 }
2207
2208 /**
2209  * mpol_misplaced - check whether current page node is valid in policy
2210  *
2211  * @page: page to be checked
2212  * @vma: vm area where page mapped
2213  * @addr: virtual address where page mapped
2214  *
2215  * Lookup current policy node id for vma,addr and "compare to" page's
2216  * node id.
2217  *
2218  * Returns:
2219  *      -1      - not misplaced, page is in the right node
2220  *      node    - node id where the page should be
2221  *
2222  * Policy determination "mimics" alloc_page_vma().
2223  * Called from fault path where we know the vma and faulting address.
2224  */
2225 int mpol_misplaced(struct page *page, struct vm_area_struct *vma, unsigned long addr)
2226 {
2227         struct mempolicy *pol;
2228         struct zoneref *z;
2229         int curnid = page_to_nid(page);
2230         unsigned long pgoff;
2231         int thiscpu = raw_smp_processor_id();
2232         int thisnid = cpu_to_node(thiscpu);
2233         int polnid = -1;
2234         int ret = -1;
2235
2236         BUG_ON(!vma);
2237
2238         pol = get_vma_policy(vma, addr);
2239         if (!(pol->flags & MPOL_F_MOF))
2240                 goto out;
2241
2242         switch (pol->mode) {
2243         case MPOL_INTERLEAVE:
2244                 BUG_ON(addr >= vma->vm_end);
2245                 BUG_ON(addr < vma->vm_start);
2246
2247                 pgoff = vma->vm_pgoff;
2248                 pgoff += (addr - vma->vm_start) >> PAGE_SHIFT;
2249                 polnid = offset_il_node(pol, pgoff);
2250                 break;
2251
2252         case MPOL_PREFERRED:
2253                 if (pol->flags & MPOL_F_LOCAL)
2254                         polnid = numa_node_id();
2255                 else
2256                         polnid = pol->v.preferred_node;
2257                 break;
2258
2259         case MPOL_BIND:
2260
2261                 /*
2262                  * allows binding to multiple nodes.
2263                  * use current page if in policy nodemask,
2264                  * else select nearest allowed node, if any.
2265                  * If no allowed nodes, use current [!misplaced].
2266                  */
2267                 if (node_isset(curnid, pol->v.nodes))
2268                         goto out;
2269                 z = first_zones_zonelist(
2270                                 node_zonelist(numa_node_id(), GFP_HIGHUSER),
2271                                 gfp_zone(GFP_HIGHUSER),
2272                                 &pol->v.nodes);
2273                 polnid = z->zone->node;
2274                 break;
2275
2276         default:
2277                 BUG();
2278         }
2279
2280         /* Migrate the page towards the node whose CPU is referencing it */
2281         if (pol->flags & MPOL_F_MORON) {
2282                 polnid = thisnid;
2283
2284                 if (!should_numa_migrate_memory(current, page, curnid, thiscpu))
2285                         goto out;
2286         }
2287
2288         if (curnid != polnid)
2289                 ret = polnid;
2290 out:
2291         mpol_cond_put(pol);
2292
2293         return ret;
2294 }
2295
2296 /*
2297  * Drop the (possibly final) reference to task->mempolicy.  It needs to be
2298  * dropped after task->mempolicy is set to NULL so that any allocation done as
2299  * part of its kmem_cache_free(), such as by KASAN, doesn't reference a freed
2300  * policy.
2301  */
2302 void mpol_put_task_policy(struct task_struct *task)
2303 {
2304         struct mempolicy *pol;
2305
2306         task_lock(task);
2307         pol = task->mempolicy;
2308         task->mempolicy = NULL;
2309         task_unlock(task);
2310         mpol_put(pol);
2311 }
2312
2313 static void sp_delete(struct shared_policy *sp, struct sp_node *n)
2314 {
2315         pr_debug("deleting %lx-l%lx\n", n->start, n->end);
2316         rb_erase(&n->nd, &sp->root);
2317         sp_free(n);
2318 }
2319
2320 static void sp_node_init(struct sp_node *node, unsigned long start,
2321                         unsigned long end, struct mempolicy *pol)
2322 {
2323         node->start = start;
2324         node->end = end;
2325         node->policy = pol;
2326 }
2327
2328 static struct sp_node *sp_alloc(unsigned long start, unsigned long end,
2329                                 struct mempolicy *pol)
2330 {
2331         struct sp_node *n;
2332         struct mempolicy *newpol;
2333
2334         n = kmem_cache_alloc(sn_cache, GFP_KERNEL);
2335         if (!n)
2336                 return NULL;
2337
2338         newpol = mpol_dup(pol);
2339         if (IS_ERR(newpol)) {
2340                 kmem_cache_free(sn_cache, n);
2341                 return NULL;
2342         }
2343         newpol->flags |= MPOL_F_SHARED;
2344         sp_node_init(n, start, end, newpol);
2345
2346         return n;
2347 }
2348
2349 /* Replace a policy range. */
2350 static int shared_policy_replace(struct shared_policy *sp, unsigned long start,
2351                                  unsigned long end, struct sp_node *new)
2352 {
2353         struct sp_node *n;
2354         struct sp_node *n_new = NULL;
2355         struct mempolicy *mpol_new = NULL;
2356         int ret = 0;
2357
2358 restart:
2359         write_lock(&sp->lock);
2360         n = sp_lookup(sp, start, end);
2361         /* Take care of old policies in the same range. */
2362         while (n && n->start < end) {
2363                 struct rb_node *next = rb_next(&n->nd);
2364                 if (n->start >= start) {
2365                         if (n->end <= end)
2366                                 sp_delete(sp, n);
2367                         else
2368                                 n->start = end;
2369                 } else {
2370                         /* Old policy spanning whole new range. */
2371                         if (n->end > end) {
2372                                 if (!n_new)
2373                                         goto alloc_new;
2374
2375                                 *mpol_new = *n->policy;
2376                                 atomic_set(&mpol_new->refcnt, 1);
2377                                 sp_node_init(n_new, end, n->end, mpol_new);
2378                                 n->end = start;
2379                                 sp_insert(sp, n_new);
2380                                 n_new = NULL;
2381                                 mpol_new = NULL;
2382                                 break;
2383                         } else
2384                                 n->end = start;
2385                 }
2386                 if (!next)
2387                         break;
2388                 n = rb_entry(next, struct sp_node, nd);
2389         }
2390         if (new)
2391                 sp_insert(sp, new);
2392         write_unlock(&sp->lock);
2393         ret = 0;
2394
2395 err_out:
2396         if (mpol_new)
2397                 mpol_put(mpol_new);
2398         if (n_new)
2399                 kmem_cache_free(sn_cache, n_new);
2400
2401         return ret;
2402
2403 alloc_new:
2404         write_unlock(&sp->lock);
2405         ret = -ENOMEM;
2406         n_new = kmem_cache_alloc(sn_cache, GFP_KERNEL);
2407         if (!n_new)
2408                 goto err_out;
2409         mpol_new = kmem_cache_alloc(policy_cache, GFP_KERNEL);
2410         if (!mpol_new)
2411                 goto err_out;
2412         goto restart;
2413 }
2414
2415 /**
2416  * mpol_shared_policy_init - initialize shared policy for inode
2417  * @sp: pointer to inode shared policy
2418  * @mpol:  struct mempolicy to install
2419  *
2420  * Install non-NULL @mpol in inode's shared policy rb-tree.
2421  * On entry, the current task has a reference on a non-NULL @mpol.
2422  * This must be released on exit.
2423  * This is called at get_inode() calls and we can use GFP_KERNEL.
2424  */
2425 void mpol_shared_policy_init(struct shared_policy *sp, struct mempolicy *mpol)
2426 {
2427         int ret;
2428
2429         sp->root = RB_ROOT;             /* empty tree == default mempolicy */
2430         rwlock_init(&sp->lock);
2431
2432         if (mpol) {
2433                 struct vm_area_struct pvma;
2434                 struct mempolicy *new;
2435                 NODEMASK_SCRATCH(scratch);
2436
2437                 if (!scratch)
2438                         goto put_mpol;
2439                 /* contextualize the tmpfs mount point mempolicy */
2440                 new = mpol_new(mpol->mode, mpol->flags, &mpol->w.user_nodemask);
2441                 if (IS_ERR(new))
2442                         goto free_scratch; /* no valid nodemask intersection */
2443
2444                 task_lock(current);
2445                 ret = mpol_set_nodemask(new, &mpol->w.user_nodemask, scratch);
2446                 task_unlock(current);
2447                 if (ret)
2448                         goto put_new;
2449
2450                 /* Create pseudo-vma that contains just the policy */
2451                 memset(&pvma, 0, sizeof(struct vm_area_struct));
2452                 pvma.vm_end = TASK_SIZE;        /* policy covers entire file */
2453                 mpol_set_shared_policy(sp, &pvma, new); /* adds ref */
2454
2455 put_new:
2456                 mpol_put(new);                  /* drop initial ref */
2457 free_scratch:
2458                 NODEMASK_SCRATCH_FREE(scratch);
2459 put_mpol:
2460                 mpol_put(mpol); /* drop our incoming ref on sb mpol */
2461         }
2462 }
2463
2464 int mpol_set_shared_policy(struct shared_policy *info,
2465                         struct vm_area_struct *vma, struct mempolicy *npol)
2466 {
2467         int err;
2468         struct sp_node *new = NULL;
2469         unsigned long sz = vma_pages(vma);
2470
2471         pr_debug("set_shared_policy %lx sz %lu %d %d %lx\n",
2472                  vma->vm_pgoff,
2473                  sz, npol ? npol->mode : -1,
2474                  npol ? npol->flags : -1,
2475                  npol ? nodes_addr(npol->v.nodes)[0] : NUMA_NO_NODE);
2476
2477         if (npol) {
2478                 new = sp_alloc(vma->vm_pgoff, vma->vm_pgoff + sz, npol);
2479                 if (!new)
2480                         return -ENOMEM;
2481         }
2482         err = shared_policy_replace(info, vma->vm_pgoff, vma->vm_pgoff+sz, new);
2483         if (err && new)
2484                 sp_free(new);
2485         return err;
2486 }
2487
2488 /* Free a backing policy store on inode delete. */
2489 void mpol_free_shared_policy(struct shared_policy *p)
2490 {
2491         struct sp_node *n;
2492         struct rb_node *next;
2493
2494         if (!p->root.rb_node)
2495                 return;
2496         write_lock(&p->lock);
2497         next = rb_first(&p->root);
2498         while (next) {
2499                 n = rb_entry(next, struct sp_node, nd);
2500                 next = rb_next(&n->nd);
2501                 sp_delete(p, n);
2502         }
2503         write_unlock(&p->lock);
2504 }
2505
2506 #ifdef CONFIG_NUMA_BALANCING
2507 static int __initdata numabalancing_override;
2508
2509 static void __init check_numabalancing_enable(void)
2510 {
2511         bool numabalancing_default = false;
2512
2513         if (IS_ENABLED(CONFIG_NUMA_BALANCING_DEFAULT_ENABLED))
2514                 numabalancing_default = true;
2515
2516         /* Parsed by setup_numabalancing. override == 1 enables, -1 disables */
2517         if (numabalancing_override)
2518                 set_numabalancing_state(numabalancing_override == 1);
2519
2520         if (num_online_nodes() > 1 && !numabalancing_override) {
2521                 pr_info("%s automatic NUMA balancing. Configure with numa_balancing= or the kernel.numa_balancing sysctl\n",
2522                         numabalancing_default ? "Enabling" : "Disabling");
2523                 set_numabalancing_state(numabalancing_default);
2524         }
2525 }
2526
2527 static int __init setup_numabalancing(char *str)
2528 {
2529         int ret = 0;
2530         if (!str)
2531                 goto out;
2532
2533         if (!strcmp(str, "enable")) {
2534                 numabalancing_override = 1;
2535                 ret = 1;
2536         } else if (!strcmp(str, "disable")) {
2537                 numabalancing_override = -1;
2538                 ret = 1;
2539         }
2540 out:
2541         if (!ret)
2542                 pr_warn("Unable to parse numa_balancing=\n");
2543
2544         return ret;
2545 }
2546 __setup("numa_balancing=", setup_numabalancing);
2547 #else
2548 static inline void __init check_numabalancing_enable(void)
2549 {
2550 }
2551 #endif /* CONFIG_NUMA_BALANCING */
2552
2553 /* assumes fs == KERNEL_DS */
2554 void __init numa_policy_init(void)
2555 {
2556         nodemask_t interleave_nodes;
2557         unsigned long largest = 0;
2558         int nid, prefer = 0;
2559
2560         policy_cache = kmem_cache_create("numa_policy",
2561                                          sizeof(struct mempolicy),
2562                                          0, SLAB_PANIC, NULL);
2563
2564         sn_cache = kmem_cache_create("shared_policy_node",
2565                                      sizeof(struct sp_node),
2566                                      0, SLAB_PANIC, NULL);
2567
2568         for_each_node(nid) {
2569                 preferred_node_policy[nid] = (struct mempolicy) {
2570                         .refcnt = ATOMIC_INIT(1),
2571                         .mode = MPOL_PREFERRED,
2572                         .flags = MPOL_F_MOF | MPOL_F_MORON,
2573                         .v = { .preferred_node = nid, },
2574                 };
2575         }
2576
2577         /*
2578          * Set interleaving policy for system init. Interleaving is only
2579          * enabled across suitably sized nodes (default is >= 16MB), or
2580          * fall back to the largest node if they're all smaller.
2581          */
2582         nodes_clear(interleave_nodes);
2583         for_each_node_state(nid, N_MEMORY) {
2584                 unsigned long total_pages = node_present_pages(nid);
2585
2586                 /* Preserve the largest node */
2587                 if (largest < total_pages) {
2588                         largest = total_pages;
2589                         prefer = nid;
2590                 }
2591
2592                 /* Interleave this node? */
2593                 if ((total_pages << PAGE_SHIFT) >= (16 << 20))
2594                         node_set(nid, interleave_nodes);
2595         }
2596
2597         /* All too small, use the largest */
2598         if (unlikely(nodes_empty(interleave_nodes)))
2599                 node_set(prefer, interleave_nodes);
2600
2601         if (do_set_mempolicy(MPOL_INTERLEAVE, 0, &interleave_nodes))
2602                 pr_err("%s: interleaving failed\n", __func__);
2603
2604         check_numabalancing_enable();
2605 }
2606
2607 /* Reset policy of current process to default */
2608 void numa_default_policy(void)
2609 {
2610         do_set_mempolicy(MPOL_DEFAULT, 0, NULL);
2611 }
2612
2613 /*
2614  * Parse and format mempolicy from/to strings
2615  */
2616
2617 /*
2618  * "local" is implemented internally by MPOL_PREFERRED with MPOL_F_LOCAL flag.
2619  */
2620 static const char * const policy_modes[] =
2621 {
2622         [MPOL_DEFAULT]    = "default",
2623         [MPOL_PREFERRED]  = "prefer",
2624         [MPOL_BIND]       = "bind",
2625         [MPOL_INTERLEAVE] = "interleave",
2626         [MPOL_LOCAL]      = "local",
2627 };
2628
2629
2630 #ifdef CONFIG_TMPFS
2631 /**
2632  * mpol_parse_str - parse string to mempolicy, for tmpfs mpol mount option.
2633  * @str:  string containing mempolicy to parse
2634  * @mpol:  pointer to struct mempolicy pointer, returned on success.
2635  *
2636  * Format of input:
2637  *      <mode>[=<flags>][:<nodelist>]
2638  *
2639  * On success, returns 0, else 1
2640  */
2641 int mpol_parse_str(char *str, struct mempolicy **mpol)
2642 {
2643         struct mempolicy *new = NULL;
2644         unsigned short mode;
2645         unsigned short mode_flags;
2646         nodemask_t nodes;
2647         char *nodelist = strchr(str, ':');
2648         char *flags = strchr(str, '=');
2649         int err = 1;
2650
2651         if (nodelist) {
2652                 /* NUL-terminate mode or flags string */
2653                 *nodelist++ = '\0';
2654                 if (nodelist_parse(nodelist, nodes))
2655                         goto out;
2656                 if (!nodes_subset(nodes, node_states[N_MEMORY]))
2657                         goto out;
2658         } else
2659                 nodes_clear(nodes);
2660
2661         if (flags)
2662                 *flags++ = '\0';        /* terminate mode string */
2663
2664         for (mode = 0; mode < MPOL_MAX; mode++) {
2665                 if (!strcmp(str, policy_modes[mode])) {
2666                         break;
2667                 }
2668         }
2669         if (mode >= MPOL_MAX)
2670                 goto out;
2671
2672         switch (mode) {
2673         case MPOL_PREFERRED:
2674                 /*
2675                  * Insist on a nodelist of one node only
2676                  */
2677                 if (nodelist) {
2678                         char *rest = nodelist;
2679                         while (isdigit(*rest))
2680                                 rest++;
2681                         if (*rest)
2682                                 goto out;
2683                 }
2684                 break;
2685         case MPOL_INTERLEAVE:
2686                 /*
2687                  * Default to online nodes with memory if no nodelist
2688                  */
2689                 if (!nodelist)
2690                         nodes = node_states[N_MEMORY];
2691                 break;
2692         case MPOL_LOCAL:
2693                 /*
2694                  * Don't allow a nodelist;  mpol_new() checks flags
2695                  */
2696                 if (nodelist)
2697                         goto out;
2698                 mode = MPOL_PREFERRED;
2699                 break;
2700         case MPOL_DEFAULT:
2701                 /*
2702                  * Insist on a empty nodelist
2703                  */
2704                 if (!nodelist)
2705                         err = 0;
2706                 goto out;
2707         case MPOL_BIND:
2708                 /*
2709                  * Insist on a nodelist
2710                  */
2711                 if (!nodelist)
2712                         goto out;
2713         }
2714
2715         mode_flags = 0;
2716         if (flags) {
2717                 /*
2718                  * Currently, we only support two mutually exclusive
2719                  * mode flags.
2720                  */
2721                 if (!strcmp(flags, "static"))
2722                         mode_flags |= MPOL_F_STATIC_NODES;
2723                 else if (!strcmp(flags, "relative"))
2724                         mode_flags |= MPOL_F_RELATIVE_NODES;
2725                 else
2726                         goto out;
2727         }
2728
2729         new = mpol_new(mode, mode_flags, &nodes);
2730         if (IS_ERR(new))
2731                 goto out;
2732
2733         /*
2734          * Save nodes for mpol_to_str() to show the tmpfs mount options
2735          * for /proc/mounts, /proc/pid/mounts and /proc/pid/mountinfo.
2736          */
2737         if (mode != MPOL_PREFERRED)
2738                 new->v.nodes = nodes;
2739         else if (nodelist)
2740                 new->v.preferred_node = first_node(nodes);
2741         else
2742                 new->flags |= MPOL_F_LOCAL;
2743
2744         /*
2745          * Save nodes for contextualization: this will be used to "clone"
2746          * the mempolicy in a specific context [cpuset] at a later time.
2747          */
2748         new->w.user_nodemask = nodes;
2749
2750         err = 0;
2751
2752 out:
2753         /* Restore string for error message */
2754         if (nodelist)
2755                 *--nodelist = ':';
2756         if (flags)
2757                 *--flags = '=';
2758         if (!err)
2759                 *mpol = new;
2760         return err;
2761 }
2762 #endif /* CONFIG_TMPFS */
2763
2764 /**
2765  * mpol_to_str - format a mempolicy structure for printing
2766  * @buffer:  to contain formatted mempolicy string
2767  * @maxlen:  length of @buffer
2768  * @pol:  pointer to mempolicy to be formatted
2769  *
2770  * Convert @pol into a string.  If @buffer is too short, truncate the string.
2771  * Recommend a @maxlen of at least 32 for the longest mode, "interleave", the
2772  * longest flag, "relative", and to display at least a few node ids.
2773  */
2774 void mpol_to_str(char *buffer, int maxlen, struct mempolicy *pol)
2775 {
2776         char *p = buffer;
2777         nodemask_t nodes = NODE_MASK_NONE;
2778         unsigned short mode = MPOL_DEFAULT;
2779         unsigned short flags = 0;
2780
2781         if (pol && pol != &default_policy && !(pol->flags & MPOL_F_MORON)) {
2782                 mode = pol->mode;
2783                 flags = pol->flags;
2784         }
2785
2786         switch (mode) {
2787         case MPOL_DEFAULT:
2788                 break;
2789         case MPOL_PREFERRED:
2790                 if (flags & MPOL_F_LOCAL)
2791                         mode = MPOL_LOCAL;
2792                 else
2793                         node_set(pol->v.preferred_node, nodes);
2794                 break;
2795         case MPOL_BIND:
2796         case MPOL_INTERLEAVE:
2797                 nodes = pol->v.nodes;
2798                 break;
2799         default:
2800                 WARN_ON_ONCE(1);
2801                 snprintf(p, maxlen, "unknown");
2802                 return;
2803         }
2804
2805         p += snprintf(p, maxlen, "%s", policy_modes[mode]);
2806
2807         if (flags & MPOL_MODE_FLAGS) {
2808                 p += snprintf(p, buffer + maxlen - p, "=");
2809
2810                 /*
2811                  * Currently, the only defined flags are mutually exclusive
2812                  */
2813                 if (flags & MPOL_F_STATIC_NODES)
2814                         p += snprintf(p, buffer + maxlen - p, "static");
2815                 else if (flags & MPOL_F_RELATIVE_NODES)
2816                         p += snprintf(p, buffer + maxlen - p, "relative");
2817         }
2818
2819         if (!nodes_empty(nodes))
2820                 p += scnprintf(p, buffer + maxlen - p, ":%*pbl",
2821                                nodemask_pr_args(&nodes));
2822 }