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