source: src/linux/universal/linux-3.18/mm/mempolicy.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 3 months ago

update

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