Mem Policy: add MPOL_F_MEMS_ALLOWED get_mempolicy() flag
[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    could replace all the switch()es with a mempolicy_ops structure.
67 */
68
69 #include <linux/mempolicy.h>
70 #include <linux/mm.h>
71 #include <linux/highmem.h>
72 #include <linux/hugetlb.h>
73 #include <linux/kernel.h>
74 #include <linux/sched.h>
75 #include <linux/nodemask.h>
76 #include <linux/cpuset.h>
77 #include <linux/gfp.h>
78 #include <linux/slab.h>
79 #include <linux/string.h>
80 #include <linux/module.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/rmap.h>
89 #include <linux/security.h>
90
91 #include <asm/tlbflush.h>
92 #include <asm/uaccess.h>
93
94 /* Internal flags */
95 #define MPOL_MF_DISCONTIG_OK (MPOL_MF_INTERNAL << 0)    /* Skip checks for continuous vmas */
96 #define MPOL_MF_INVERT (MPOL_MF_INTERNAL << 1)          /* Invert check for nodemask */
97 #define MPOL_MF_STATS (MPOL_MF_INTERNAL << 2)           /* Gather statistics */
98
99 static struct kmem_cache *policy_cache;
100 static struct kmem_cache *sn_cache;
101
102 /* Highest zone. An specific allocation for a zone below that is not
103    policied. */
104 enum zone_type policy_zone = 0;
105
106 struct mempolicy default_policy = {
107         .refcnt = ATOMIC_INIT(1), /* never free it */
108         .policy = MPOL_DEFAULT,
109 };
110
111 /* Do sanity checking on a policy */
112 static int mpol_check_policy(int mode, nodemask_t *nodes)
113 {
114         int empty = nodes_empty(*nodes);
115
116         switch (mode) {
117         case MPOL_DEFAULT:
118                 if (!empty)
119                         return -EINVAL;
120                 break;
121         case MPOL_BIND:
122         case MPOL_INTERLEAVE:
123                 /* Preferred will only use the first bit, but allow
124                    more for now. */
125                 if (empty)
126                         return -EINVAL;
127                 break;
128         }
129         return nodes_subset(*nodes, node_online_map) ? 0 : -EINVAL;
130 }
131
132 /* Generate a custom zonelist for the BIND policy. */
133 static struct zonelist *bind_zonelist(nodemask_t *nodes)
134 {
135         struct zonelist *zl;
136         int num, max, nd;
137         enum zone_type k;
138
139         max = 1 + MAX_NR_ZONES * nodes_weight(*nodes);
140         max++;                  /* space for zlcache_ptr (see mmzone.h) */
141         zl = kmalloc(sizeof(struct zone *) * max, GFP_KERNEL);
142         if (!zl)
143                 return ERR_PTR(-ENOMEM);
144         zl->zlcache_ptr = NULL;
145         num = 0;
146         /* First put in the highest zones from all nodes, then all the next 
147            lower zones etc. Avoid empty zones because the memory allocator
148            doesn't like them. If you implement node hot removal you
149            have to fix that. */
150         k = MAX_NR_ZONES - 1;
151         while (1) {
152                 for_each_node_mask(nd, *nodes) { 
153                         struct zone *z = &NODE_DATA(nd)->node_zones[k];
154                         if (z->present_pages > 0) 
155                                 zl->zones[num++] = z;
156                 }
157                 if (k == 0)
158                         break;
159                 k--;
160         }
161         if (num == 0) {
162                 kfree(zl);
163                 return ERR_PTR(-EINVAL);
164         }
165         zl->zones[num] = NULL;
166         return zl;
167 }
168
169 /* Create a new policy */
170 static struct mempolicy *mpol_new(int mode, nodemask_t *nodes)
171 {
172         struct mempolicy *policy;
173
174         pr_debug("setting mode %d nodes[0] %lx\n",
175                  mode, nodes ? nodes_addr(*nodes)[0] : -1);
176
177         if (mode == MPOL_DEFAULT)
178                 return NULL;
179         policy = kmem_cache_alloc(policy_cache, GFP_KERNEL);
180         if (!policy)
181                 return ERR_PTR(-ENOMEM);
182         atomic_set(&policy->refcnt, 1);
183         switch (mode) {
184         case MPOL_INTERLEAVE:
185                 policy->v.nodes = *nodes;
186                 if (nodes_weight(*nodes) == 0) {
187                         kmem_cache_free(policy_cache, policy);
188                         return ERR_PTR(-EINVAL);
189                 }
190                 break;
191         case MPOL_PREFERRED:
192                 policy->v.preferred_node = first_node(*nodes);
193                 if (policy->v.preferred_node >= MAX_NUMNODES)
194                         policy->v.preferred_node = -1;
195                 break;
196         case MPOL_BIND:
197                 policy->v.zonelist = bind_zonelist(nodes);
198                 if (IS_ERR(policy->v.zonelist)) {
199                         void *error_code = policy->v.zonelist;
200                         kmem_cache_free(policy_cache, policy);
201                         return error_code;
202                 }
203                 break;
204         }
205         policy->policy = mode;
206         policy->cpuset_mems_allowed = cpuset_mems_allowed(current);
207         return policy;
208 }
209
210 static void gather_stats(struct page *, void *, int pte_dirty);
211 static void migrate_page_add(struct page *page, struct list_head *pagelist,
212                                 unsigned long flags);
213
214 /* Scan through pages checking if pages follow certain conditions. */
215 static int check_pte_range(struct vm_area_struct *vma, pmd_t *pmd,
216                 unsigned long addr, unsigned long end,
217                 const nodemask_t *nodes, unsigned long flags,
218                 void *private)
219 {
220         pte_t *orig_pte;
221         pte_t *pte;
222         spinlock_t *ptl;
223
224         orig_pte = pte = pte_offset_map_lock(vma->vm_mm, pmd, addr, &ptl);
225         do {
226                 struct page *page;
227                 int nid;
228
229                 if (!pte_present(*pte))
230                         continue;
231                 page = vm_normal_page(vma, addr, *pte);
232                 if (!page)
233                         continue;
234                 /*
235                  * The check for PageReserved here is important to avoid
236                  * handling zero pages and other pages that may have been
237                  * marked special by the system.
238                  *
239                  * If the PageReserved would not be checked here then f.e.
240                  * the location of the zero page could have an influence
241                  * on MPOL_MF_STRICT, zero pages would be counted for
242                  * the per node stats, and there would be useless attempts
243                  * to put zero pages on the migration list.
244                  */
245                 if (PageReserved(page))
246                         continue;
247                 nid = page_to_nid(page);
248                 if (node_isset(nid, *nodes) == !!(flags & MPOL_MF_INVERT))
249                         continue;
250
251                 if (flags & MPOL_MF_STATS)
252                         gather_stats(page, private, pte_dirty(*pte));
253                 else if (flags & (MPOL_MF_MOVE | MPOL_MF_MOVE_ALL))
254                         migrate_page_add(page, private, flags);
255                 else
256                         break;
257         } while (pte++, addr += PAGE_SIZE, addr != end);
258         pte_unmap_unlock(orig_pte, ptl);
259         return addr != end;
260 }
261
262 static inline int check_pmd_range(struct vm_area_struct *vma, pud_t *pud,
263                 unsigned long addr, unsigned long end,
264                 const nodemask_t *nodes, unsigned long flags,
265                 void *private)
266 {
267         pmd_t *pmd;
268         unsigned long next;
269
270         pmd = pmd_offset(pud, addr);
271         do {
272                 next = pmd_addr_end(addr, end);
273                 if (pmd_none_or_clear_bad(pmd))
274                         continue;
275                 if (check_pte_range(vma, pmd, addr, next, nodes,
276                                     flags, private))
277                         return -EIO;
278         } while (pmd++, addr = next, addr != end);
279         return 0;
280 }
281
282 static inline int check_pud_range(struct vm_area_struct *vma, pgd_t *pgd,
283                 unsigned long addr, unsigned long end,
284                 const nodemask_t *nodes, unsigned long flags,
285                 void *private)
286 {
287         pud_t *pud;
288         unsigned long next;
289
290         pud = pud_offset(pgd, addr);
291         do {
292                 next = pud_addr_end(addr, end);
293                 if (pud_none_or_clear_bad(pud))
294                         continue;
295                 if (check_pmd_range(vma, pud, addr, next, nodes,
296                                     flags, private))
297                         return -EIO;
298         } while (pud++, addr = next, addr != end);
299         return 0;
300 }
301
302 static inline int check_pgd_range(struct vm_area_struct *vma,
303                 unsigned long addr, unsigned long end,
304                 const nodemask_t *nodes, unsigned long flags,
305                 void *private)
306 {
307         pgd_t *pgd;
308         unsigned long next;
309
310         pgd = pgd_offset(vma->vm_mm, addr);
311         do {
312                 next = pgd_addr_end(addr, end);
313                 if (pgd_none_or_clear_bad(pgd))
314                         continue;
315                 if (check_pud_range(vma, pgd, addr, next, nodes,
316                                     flags, private))
317                         return -EIO;
318         } while (pgd++, addr = next, addr != end);
319         return 0;
320 }
321
322 /*
323  * Check if all pages in a range are on a set of nodes.
324  * If pagelist != NULL then isolate pages from the LRU and
325  * put them on the pagelist.
326  */
327 static struct vm_area_struct *
328 check_range(struct mm_struct *mm, unsigned long start, unsigned long end,
329                 const nodemask_t *nodes, unsigned long flags, void *private)
330 {
331         int err;
332         struct vm_area_struct *first, *vma, *prev;
333
334         if (flags & (MPOL_MF_MOVE | MPOL_MF_MOVE_ALL)) {
335
336                 err = migrate_prep();
337                 if (err)
338                         return ERR_PTR(err);
339         }
340
341         first = find_vma(mm, start);
342         if (!first)
343                 return ERR_PTR(-EFAULT);
344         prev = NULL;
345         for (vma = first; vma && vma->vm_start < end; vma = vma->vm_next) {
346                 if (!(flags & MPOL_MF_DISCONTIG_OK)) {
347                         if (!vma->vm_next && vma->vm_end < end)
348                                 return ERR_PTR(-EFAULT);
349                         if (prev && prev->vm_end < vma->vm_start)
350                                 return ERR_PTR(-EFAULT);
351                 }
352                 if (!is_vm_hugetlb_page(vma) &&
353                     ((flags & MPOL_MF_STRICT) ||
354                      ((flags & (MPOL_MF_MOVE | MPOL_MF_MOVE_ALL)) &&
355                                 vma_migratable(vma)))) {
356                         unsigned long endvma = vma->vm_end;
357
358                         if (endvma > end)
359                                 endvma = end;
360                         if (vma->vm_start > start)
361                                 start = vma->vm_start;
362                         err = check_pgd_range(vma, start, endvma, nodes,
363                                                 flags, private);
364                         if (err) {
365                                 first = ERR_PTR(err);
366                                 break;
367                         }
368                 }
369                 prev = vma;
370         }
371         return first;
372 }
373
374 /* Apply policy to a single VMA */
375 static int policy_vma(struct vm_area_struct *vma, struct mempolicy *new)
376 {
377         int err = 0;
378         struct mempolicy *old = vma->vm_policy;
379
380         pr_debug("vma %lx-%lx/%lx vm_ops %p vm_file %p set_policy %p\n",
381                  vma->vm_start, vma->vm_end, vma->vm_pgoff,
382                  vma->vm_ops, vma->vm_file,
383                  vma->vm_ops ? vma->vm_ops->set_policy : NULL);
384
385         if (vma->vm_ops && vma->vm_ops->set_policy)
386                 err = vma->vm_ops->set_policy(vma, new);
387         if (!err) {
388                 mpol_get(new);
389                 vma->vm_policy = new;
390                 mpol_free(old);
391         }
392         return err;
393 }
394
395 /* Step 2: apply policy to a range and do splits. */
396 static int mbind_range(struct vm_area_struct *vma, unsigned long start,
397                        unsigned long end, struct mempolicy *new)
398 {
399         struct vm_area_struct *next;
400         int err;
401
402         err = 0;
403         for (; vma && vma->vm_start < end; vma = next) {
404                 next = vma->vm_next;
405                 if (vma->vm_start < start)
406                         err = split_vma(vma->vm_mm, vma, start, 1);
407                 if (!err && vma->vm_end > end)
408                         err = split_vma(vma->vm_mm, vma, end, 0);
409                 if (!err)
410                         err = policy_vma(vma, new);
411                 if (err)
412                         break;
413         }
414         return err;
415 }
416
417 static int contextualize_policy(int mode, nodemask_t *nodes)
418 {
419         if (!nodes)
420                 return 0;
421
422         cpuset_update_task_memory_state();
423         if (!cpuset_nodes_subset_current_mems_allowed(*nodes))
424                 return -EINVAL;
425         return mpol_check_policy(mode, nodes);
426 }
427
428
429 /*
430  * Update task->flags PF_MEMPOLICY bit: set iff non-default
431  * mempolicy.  Allows more rapid checking of this (combined perhaps
432  * with other PF_* flag bits) on memory allocation hot code paths.
433  *
434  * If called from outside this file, the task 'p' should -only- be
435  * a newly forked child not yet visible on the task list, because
436  * manipulating the task flags of a visible task is not safe.
437  *
438  * The above limitation is why this routine has the funny name
439  * mpol_fix_fork_child_flag().
440  *
441  * It is also safe to call this with a task pointer of current,
442  * which the static wrapper mpol_set_task_struct_flag() does,
443  * for use within this file.
444  */
445
446 void mpol_fix_fork_child_flag(struct task_struct *p)
447 {
448         if (p->mempolicy)
449                 p->flags |= PF_MEMPOLICY;
450         else
451                 p->flags &= ~PF_MEMPOLICY;
452 }
453
454 static void mpol_set_task_struct_flag(void)
455 {
456         mpol_fix_fork_child_flag(current);
457 }
458
459 /* Set the process memory policy */
460 long do_set_mempolicy(int mode, nodemask_t *nodes)
461 {
462         struct mempolicy *new;
463
464         if (contextualize_policy(mode, nodes))
465                 return -EINVAL;
466         new = mpol_new(mode, nodes);
467         if (IS_ERR(new))
468                 return PTR_ERR(new);
469         mpol_free(current->mempolicy);
470         current->mempolicy = new;
471         mpol_set_task_struct_flag();
472         if (new && new->policy == MPOL_INTERLEAVE)
473                 current->il_next = first_node(new->v.nodes);
474         return 0;
475 }
476
477 /* Fill a zone bitmap for a policy */
478 static void get_zonemask(struct mempolicy *p, nodemask_t *nodes)
479 {
480         int i;
481
482         nodes_clear(*nodes);
483         switch (p->policy) {
484         case MPOL_BIND:
485                 for (i = 0; p->v.zonelist->zones[i]; i++)
486                         node_set(zone_to_nid(p->v.zonelist->zones[i]),
487                                 *nodes);
488                 break;
489         case MPOL_DEFAULT:
490                 break;
491         case MPOL_INTERLEAVE:
492                 *nodes = p->v.nodes;
493                 break;
494         case MPOL_PREFERRED:
495                 /* or use current node instead of online map? */
496                 if (p->v.preferred_node < 0)
497                         *nodes = node_online_map;
498                 else
499                         node_set(p->v.preferred_node, *nodes);
500                 break;
501         default:
502                 BUG();
503         }
504 }
505
506 static int lookup_node(struct mm_struct *mm, unsigned long addr)
507 {
508         struct page *p;
509         int err;
510
511         err = get_user_pages(current, mm, addr & PAGE_MASK, 1, 0, 0, &p, NULL);
512         if (err >= 0) {
513                 err = page_to_nid(p);
514                 put_page(p);
515         }
516         return err;
517 }
518
519 /* Retrieve NUMA policy */
520 long do_get_mempolicy(int *policy, nodemask_t *nmask,
521                         unsigned long addr, unsigned long flags)
522 {
523         int err;
524         struct mm_struct *mm = current->mm;
525         struct vm_area_struct *vma = NULL;
526         struct mempolicy *pol = current->mempolicy;
527
528         cpuset_update_task_memory_state();
529         if (flags &
530                 ~(unsigned long)(MPOL_F_NODE|MPOL_F_ADDR|MPOL_F_MEMS_ALLOWED))
531                 return -EINVAL;
532
533         if (flags & MPOL_F_MEMS_ALLOWED) {
534                 if (flags & (MPOL_F_NODE|MPOL_F_ADDR))
535                         return -EINVAL;
536                 *policy = 0;    /* just so it's initialized */
537                 *nmask  = cpuset_current_mems_allowed;
538                 return 0;
539         }
540
541         if (flags & MPOL_F_ADDR) {
542                 down_read(&mm->mmap_sem);
543                 vma = find_vma_intersection(mm, addr, addr+1);
544                 if (!vma) {
545                         up_read(&mm->mmap_sem);
546                         return -EFAULT;
547                 }
548                 if (vma->vm_ops && vma->vm_ops->get_policy)
549                         pol = vma->vm_ops->get_policy(vma, addr);
550                 else
551                         pol = vma->vm_policy;
552         } else if (addr)
553                 return -EINVAL;
554
555         if (!pol)
556                 pol = &default_policy;
557
558         if (flags & MPOL_F_NODE) {
559                 if (flags & MPOL_F_ADDR) {
560                         err = lookup_node(mm, addr);
561                         if (err < 0)
562                                 goto out;
563                         *policy = err;
564                 } else if (pol == current->mempolicy &&
565                                 pol->policy == MPOL_INTERLEAVE) {
566                         *policy = current->il_next;
567                 } else {
568                         err = -EINVAL;
569                         goto out;
570                 }
571         } else
572                 *policy = pol->policy;
573
574         if (vma) {
575                 up_read(&current->mm->mmap_sem);
576                 vma = NULL;
577         }
578
579         err = 0;
580         if (nmask)
581                 get_zonemask(pol, nmask);
582
583  out:
584         if (vma)
585                 up_read(&current->mm->mmap_sem);
586         return err;
587 }
588
589 #ifdef CONFIG_MIGRATION
590 /*
591  * page migration
592  */
593 static void migrate_page_add(struct page *page, struct list_head *pagelist,
594                                 unsigned long flags)
595 {
596         /*
597          * Avoid migrating a page that is shared with others.
598          */
599         if ((flags & MPOL_MF_MOVE_ALL) || page_mapcount(page) == 1)
600                 isolate_lru_page(page, pagelist);
601 }
602
603 static struct page *new_node_page(struct page *page, unsigned long node, int **x)
604 {
605         return alloc_pages_node(node, GFP_HIGHUSER_MOVABLE, 0);
606 }
607
608 /*
609  * Migrate pages from one node to a target node.
610  * Returns error or the number of pages not migrated.
611  */
612 int migrate_to_node(struct mm_struct *mm, int source, int dest, int flags)
613 {
614         nodemask_t nmask;
615         LIST_HEAD(pagelist);
616         int err = 0;
617
618         nodes_clear(nmask);
619         node_set(source, nmask);
620
621         check_range(mm, mm->mmap->vm_start, TASK_SIZE, &nmask,
622                         flags | MPOL_MF_DISCONTIG_OK, &pagelist);
623
624         if (!list_empty(&pagelist))
625                 err = migrate_pages(&pagelist, new_node_page, dest);
626
627         return err;
628 }
629
630 /*
631  * Move pages between the two nodesets so as to preserve the physical
632  * layout as much as possible.
633  *
634  * Returns the number of page that could not be moved.
635  */
636 int do_migrate_pages(struct mm_struct *mm,
637         const nodemask_t *from_nodes, const nodemask_t *to_nodes, int flags)
638 {
639         LIST_HEAD(pagelist);
640         int busy = 0;
641         int err = 0;
642         nodemask_t tmp;
643
644         down_read(&mm->mmap_sem);
645
646         err = migrate_vmas(mm, from_nodes, to_nodes, flags);
647         if (err)
648                 goto out;
649
650 /*
651  * Find a 'source' bit set in 'tmp' whose corresponding 'dest'
652  * bit in 'to' is not also set in 'tmp'.  Clear the found 'source'
653  * bit in 'tmp', and return that <source, dest> pair for migration.
654  * The pair of nodemasks 'to' and 'from' define the map.
655  *
656  * If no pair of bits is found that way, fallback to picking some
657  * pair of 'source' and 'dest' bits that are not the same.  If the
658  * 'source' and 'dest' bits are the same, this represents a node
659  * that will be migrating to itself, so no pages need move.
660  *
661  * If no bits are left in 'tmp', or if all remaining bits left
662  * in 'tmp' correspond to the same bit in 'to', return false
663  * (nothing left to migrate).
664  *
665  * This lets us pick a pair of nodes to migrate between, such that
666  * if possible the dest node is not already occupied by some other
667  * source node, minimizing the risk of overloading the memory on a
668  * node that would happen if we migrated incoming memory to a node
669  * before migrating outgoing memory source that same node.
670  *
671  * A single scan of tmp is sufficient.  As we go, we remember the
672  * most recent <s, d> pair that moved (s != d).  If we find a pair
673  * that not only moved, but what's better, moved to an empty slot
674  * (d is not set in tmp), then we break out then, with that pair.
675  * Otherwise when we finish scannng from_tmp, we at least have the
676  * most recent <s, d> pair that moved.  If we get all the way through
677  * the scan of tmp without finding any node that moved, much less
678  * moved to an empty node, then there is nothing left worth migrating.
679  */
680
681         tmp = *from_nodes;
682         while (!nodes_empty(tmp)) {
683                 int s,d;
684                 int source = -1;
685                 int dest = 0;
686
687                 for_each_node_mask(s, tmp) {
688                         d = node_remap(s, *from_nodes, *to_nodes);
689                         if (s == d)
690                                 continue;
691
692                         source = s;     /* Node moved. Memorize */
693                         dest = d;
694
695                         /* dest not in remaining from nodes? */
696                         if (!node_isset(dest, tmp))
697                                 break;
698                 }
699                 if (source == -1)
700                         break;
701
702                 node_clear(source, tmp);
703                 err = migrate_to_node(mm, source, dest, flags);
704                 if (err > 0)
705                         busy += err;
706                 if (err < 0)
707                         break;
708         }
709 out:
710         up_read(&mm->mmap_sem);
711         if (err < 0)
712                 return err;
713         return busy;
714
715 }
716
717 static struct page *new_vma_page(struct page *page, unsigned long private, int **x)
718 {
719         struct vm_area_struct *vma = (struct vm_area_struct *)private;
720
721         return alloc_page_vma(GFP_HIGHUSER_MOVABLE, vma,
722                                         page_address_in_vma(page, vma));
723 }
724 #else
725
726 static void migrate_page_add(struct page *page, struct list_head *pagelist,
727                                 unsigned long flags)
728 {
729 }
730
731 int do_migrate_pages(struct mm_struct *mm,
732         const nodemask_t *from_nodes, const nodemask_t *to_nodes, int flags)
733 {
734         return -ENOSYS;
735 }
736
737 static struct page *new_vma_page(struct page *page, unsigned long private, int **x)
738 {
739         return NULL;
740 }
741 #endif
742
743 long do_mbind(unsigned long start, unsigned long len,
744                 unsigned long mode, nodemask_t *nmask, unsigned long flags)
745 {
746         struct vm_area_struct *vma;
747         struct mm_struct *mm = current->mm;
748         struct mempolicy *new;
749         unsigned long end;
750         int err;
751         LIST_HEAD(pagelist);
752
753         if ((flags & ~(unsigned long)(MPOL_MF_STRICT |
754                                       MPOL_MF_MOVE | MPOL_MF_MOVE_ALL))
755             || mode > MPOL_MAX)
756                 return -EINVAL;
757         if ((flags & MPOL_MF_MOVE_ALL) && !capable(CAP_SYS_NICE))
758                 return -EPERM;
759
760         if (start & ~PAGE_MASK)
761                 return -EINVAL;
762
763         if (mode == MPOL_DEFAULT)
764                 flags &= ~MPOL_MF_STRICT;
765
766         len = (len + PAGE_SIZE - 1) & PAGE_MASK;
767         end = start + len;
768
769         if (end < start)
770                 return -EINVAL;
771         if (end == start)
772                 return 0;
773
774         if (mpol_check_policy(mode, nmask))
775                 return -EINVAL;
776
777         new = mpol_new(mode, nmask);
778         if (IS_ERR(new))
779                 return PTR_ERR(new);
780
781         /*
782          * If we are using the default policy then operation
783          * on discontinuous address spaces is okay after all
784          */
785         if (!new)
786                 flags |= MPOL_MF_DISCONTIG_OK;
787
788         pr_debug("mbind %lx-%lx mode:%ld nodes:%lx\n",start,start+len,
789                  mode, nmask ? nodes_addr(*nmask)[0] : -1);
790
791         down_write(&mm->mmap_sem);
792         vma = check_range(mm, start, end, nmask,
793                           flags | MPOL_MF_INVERT, &pagelist);
794
795         err = PTR_ERR(vma);
796         if (!IS_ERR(vma)) {
797                 int nr_failed = 0;
798
799                 err = mbind_range(vma, start, end, new);
800
801                 if (!list_empty(&pagelist))
802                         nr_failed = migrate_pages(&pagelist, new_vma_page,
803                                                 (unsigned long)vma);
804
805                 if (!err && nr_failed && (flags & MPOL_MF_STRICT))
806                         err = -EIO;
807         }
808
809         up_write(&mm->mmap_sem);
810         mpol_free(new);
811         return err;
812 }
813
814 /*
815  * User space interface with variable sized bitmaps for nodelists.
816  */
817
818 /* Copy a node mask from user space. */
819 static int get_nodes(nodemask_t *nodes, const unsigned long __user *nmask,
820                      unsigned long maxnode)
821 {
822         unsigned long k;
823         unsigned long nlongs;
824         unsigned long endmask;
825
826         --maxnode;
827         nodes_clear(*nodes);
828         if (maxnode == 0 || !nmask)
829                 return 0;
830         if (maxnode > PAGE_SIZE*BITS_PER_BYTE)
831                 return -EINVAL;
832
833         nlongs = BITS_TO_LONGS(maxnode);
834         if ((maxnode % BITS_PER_LONG) == 0)
835                 endmask = ~0UL;
836         else
837                 endmask = (1UL << (maxnode % BITS_PER_LONG)) - 1;
838
839         /* When the user specified more nodes than supported just check
840            if the non supported part is all zero. */
841         if (nlongs > BITS_TO_LONGS(MAX_NUMNODES)) {
842                 if (nlongs > PAGE_SIZE/sizeof(long))
843                         return -EINVAL;
844                 for (k = BITS_TO_LONGS(MAX_NUMNODES); k < nlongs; k++) {
845                         unsigned long t;
846                         if (get_user(t, nmask + k))
847                                 return -EFAULT;
848                         if (k == nlongs - 1) {
849                                 if (t & endmask)
850                                         return -EINVAL;
851                         } else if (t)
852                                 return -EINVAL;
853                 }
854                 nlongs = BITS_TO_LONGS(MAX_NUMNODES);
855                 endmask = ~0UL;
856         }
857
858         if (copy_from_user(nodes_addr(*nodes), nmask, nlongs*sizeof(unsigned long)))
859                 return -EFAULT;
860         nodes_addr(*nodes)[nlongs-1] &= endmask;
861         return 0;
862 }
863
864 /* Copy a kernel node mask to user space */
865 static int copy_nodes_to_user(unsigned long __user *mask, unsigned long maxnode,
866                               nodemask_t *nodes)
867 {
868         unsigned long copy = ALIGN(maxnode-1, 64) / 8;
869         const int nbytes = BITS_TO_LONGS(MAX_NUMNODES) * sizeof(long);
870
871         if (copy > nbytes) {
872                 if (copy > PAGE_SIZE)
873                         return -EINVAL;
874                 if (clear_user((char __user *)mask + nbytes, copy - nbytes))
875                         return -EFAULT;
876                 copy = nbytes;
877         }
878         return copy_to_user(mask, nodes_addr(*nodes), copy) ? -EFAULT : 0;
879 }
880
881 asmlinkage long sys_mbind(unsigned long start, unsigned long len,
882                         unsigned long mode,
883                         unsigned long __user *nmask, unsigned long maxnode,
884                         unsigned flags)
885 {
886         nodemask_t nodes;
887         int err;
888
889         err = get_nodes(&nodes, nmask, maxnode);
890         if (err)
891                 return err;
892 #ifdef CONFIG_CPUSETS
893         /* Restrict the nodes to the allowed nodes in the cpuset */
894         nodes_and(nodes, nodes, current->mems_allowed);
895 #endif
896         return do_mbind(start, len, mode, &nodes, flags);
897 }
898
899 /* Set the process memory policy */
900 asmlinkage long sys_set_mempolicy(int mode, unsigned long __user *nmask,
901                 unsigned long maxnode)
902 {
903         int err;
904         nodemask_t nodes;
905
906         if (mode < 0 || mode > MPOL_MAX)
907                 return -EINVAL;
908         err = get_nodes(&nodes, nmask, maxnode);
909         if (err)
910                 return err;
911         return do_set_mempolicy(mode, &nodes);
912 }
913
914 asmlinkage long sys_migrate_pages(pid_t pid, unsigned long maxnode,
915                 const unsigned long __user *old_nodes,
916                 const unsigned long __user *new_nodes)
917 {
918         struct mm_struct *mm;
919         struct task_struct *task;
920         nodemask_t old;
921         nodemask_t new;
922         nodemask_t task_nodes;
923         int err;
924
925         err = get_nodes(&old, old_nodes, maxnode);
926         if (err)
927                 return err;
928
929         err = get_nodes(&new, new_nodes, maxnode);
930         if (err)
931                 return err;
932
933         /* Find the mm_struct */
934         read_lock(&tasklist_lock);
935         task = pid ? find_task_by_pid(pid) : current;
936         if (!task) {
937                 read_unlock(&tasklist_lock);
938                 return -ESRCH;
939         }
940         mm = get_task_mm(task);
941         read_unlock(&tasklist_lock);
942
943         if (!mm)
944                 return -EINVAL;
945
946         /*
947          * Check if this process has the right to modify the specified
948          * process. The right exists if the process has administrative
949          * capabilities, superuser privileges or the same
950          * userid as the target process.
951          */
952         if ((current->euid != task->suid) && (current->euid != task->uid) &&
953             (current->uid != task->suid) && (current->uid != task->uid) &&
954             !capable(CAP_SYS_NICE)) {
955                 err = -EPERM;
956                 goto out;
957         }
958
959         task_nodes = cpuset_mems_allowed(task);
960         /* Is the user allowed to access the target nodes? */
961         if (!nodes_subset(new, task_nodes) && !capable(CAP_SYS_NICE)) {
962                 err = -EPERM;
963                 goto out;
964         }
965
966         if (!nodes_subset(new, node_online_map)) {
967                 err = -EINVAL;
968                 goto out;
969         }
970
971         err = security_task_movememory(task);
972         if (err)
973                 goto out;
974
975         err = do_migrate_pages(mm, &old, &new,
976                 capable(CAP_SYS_NICE) ? MPOL_MF_MOVE_ALL : MPOL_MF_MOVE);
977 out:
978         mmput(mm);
979         return err;
980 }
981
982
983 /* Retrieve NUMA policy */
984 asmlinkage long sys_get_mempolicy(int __user *policy,
985                                 unsigned long __user *nmask,
986                                 unsigned long maxnode,
987                                 unsigned long addr, unsigned long flags)
988 {
989         int err, pval;
990         nodemask_t nodes;
991
992         if (nmask != NULL && maxnode < MAX_NUMNODES)
993                 return -EINVAL;
994
995         err = do_get_mempolicy(&pval, &nodes, addr, flags);
996
997         if (err)
998                 return err;
999
1000         if (policy && put_user(pval, policy))
1001                 return -EFAULT;
1002
1003         if (nmask)
1004                 err = copy_nodes_to_user(nmask, maxnode, &nodes);
1005
1006         return err;
1007 }
1008
1009 #ifdef CONFIG_COMPAT
1010
1011 asmlinkage long compat_sys_get_mempolicy(int __user *policy,
1012                                      compat_ulong_t __user *nmask,
1013                                      compat_ulong_t maxnode,
1014                                      compat_ulong_t addr, compat_ulong_t flags)
1015 {
1016         long err;
1017         unsigned long __user *nm = NULL;
1018         unsigned long nr_bits, alloc_size;
1019         DECLARE_BITMAP(bm, MAX_NUMNODES);
1020
1021         nr_bits = min_t(unsigned long, maxnode-1, MAX_NUMNODES);
1022         alloc_size = ALIGN(nr_bits, BITS_PER_LONG) / 8;
1023
1024         if (nmask)
1025                 nm = compat_alloc_user_space(alloc_size);
1026
1027         err = sys_get_mempolicy(policy, nm, nr_bits+1, addr, flags);
1028
1029         if (!err && nmask) {
1030                 err = copy_from_user(bm, nm, alloc_size);
1031                 /* ensure entire bitmap is zeroed */
1032                 err |= clear_user(nmask, ALIGN(maxnode-1, 8) / 8);
1033                 err |= compat_put_bitmap(nmask, bm, nr_bits);
1034         }
1035
1036         return err;
1037 }
1038
1039 asmlinkage long compat_sys_set_mempolicy(int mode, compat_ulong_t __user *nmask,
1040                                      compat_ulong_t maxnode)
1041 {
1042         long err = 0;
1043         unsigned long __user *nm = NULL;
1044         unsigned long nr_bits, alloc_size;
1045         DECLARE_BITMAP(bm, MAX_NUMNODES);
1046
1047         nr_bits = min_t(unsigned long, maxnode-1, MAX_NUMNODES);
1048         alloc_size = ALIGN(nr_bits, BITS_PER_LONG) / 8;
1049
1050         if (nmask) {
1051                 err = compat_get_bitmap(bm, nmask, nr_bits);
1052                 nm = compat_alloc_user_space(alloc_size);
1053                 err |= copy_to_user(nm, bm, alloc_size);
1054         }
1055
1056         if (err)
1057                 return -EFAULT;
1058
1059         return sys_set_mempolicy(mode, nm, nr_bits+1);
1060 }
1061
1062 asmlinkage long compat_sys_mbind(compat_ulong_t start, compat_ulong_t len,
1063                              compat_ulong_t mode, compat_ulong_t __user *nmask,
1064                              compat_ulong_t maxnode, compat_ulong_t flags)
1065 {
1066         long err = 0;
1067         unsigned long __user *nm = NULL;
1068         unsigned long nr_bits, alloc_size;
1069         nodemask_t bm;
1070
1071         nr_bits = min_t(unsigned long, maxnode-1, MAX_NUMNODES);
1072         alloc_size = ALIGN(nr_bits, BITS_PER_LONG) / 8;
1073
1074         if (nmask) {
1075                 err = compat_get_bitmap(nodes_addr(bm), nmask, nr_bits);
1076                 nm = compat_alloc_user_space(alloc_size);
1077                 err |= copy_to_user(nm, nodes_addr(bm), alloc_size);
1078         }
1079
1080         if (err)
1081                 return -EFAULT;
1082
1083         return sys_mbind(start, len, mode, nm, nr_bits+1, flags);
1084 }
1085
1086 #endif
1087
1088 /*
1089  * get_vma_policy(@task, @vma, @addr)
1090  * @task - task for fallback if vma policy == default
1091  * @vma   - virtual memory area whose policy is sought
1092  * @addr  - address in @vma for shared policy lookup
1093  *
1094  * Returns effective policy for a VMA at specified address.
1095  * Falls back to @task or system default policy, as necessary.
1096  * Returned policy has extra reference count if shared, vma,
1097  * or some other task's policy [show_numa_maps() can pass
1098  * @task != current].  It is the caller's responsibility to
1099  * free the reference in these cases.
1100  */
1101 static struct mempolicy * get_vma_policy(struct task_struct *task,
1102                 struct vm_area_struct *vma, unsigned long addr)
1103 {
1104         struct mempolicy *pol = task->mempolicy;
1105         int shared_pol = 0;
1106
1107         if (vma) {
1108                 if (vma->vm_ops && vma->vm_ops->get_policy) {
1109                         pol = vma->vm_ops->get_policy(vma, addr);
1110                         shared_pol = 1; /* if pol non-NULL, add ref below */
1111                 } else if (vma->vm_policy &&
1112                                 vma->vm_policy->policy != MPOL_DEFAULT)
1113                         pol = vma->vm_policy;
1114         }
1115         if (!pol)
1116                 pol = &default_policy;
1117         else if (!shared_pol && pol != current->mempolicy)
1118                 mpol_get(pol);  /* vma or other task's policy */
1119         return pol;
1120 }
1121
1122 /* Return a zonelist representing a mempolicy */
1123 static struct zonelist *zonelist_policy(gfp_t gfp, struct mempolicy *policy)
1124 {
1125         int nd;
1126
1127         switch (policy->policy) {
1128         case MPOL_PREFERRED:
1129                 nd = policy->v.preferred_node;
1130                 if (nd < 0)
1131                         nd = numa_node_id();
1132                 break;
1133         case MPOL_BIND:
1134                 /* Lower zones don't get a policy applied */
1135                 /* Careful: current->mems_allowed might have moved */
1136                 if (gfp_zone(gfp) >= policy_zone)
1137                         if (cpuset_zonelist_valid_mems_allowed(policy->v.zonelist))
1138                                 return policy->v.zonelist;
1139                 /*FALL THROUGH*/
1140         case MPOL_INTERLEAVE: /* should not happen */
1141         case MPOL_DEFAULT:
1142                 nd = numa_node_id();
1143                 break;
1144         default:
1145                 nd = 0;
1146                 BUG();
1147         }
1148         return NODE_DATA(nd)->node_zonelists + gfp_zone(gfp);
1149 }
1150
1151 /* Do dynamic interleaving for a process */
1152 static unsigned interleave_nodes(struct mempolicy *policy)
1153 {
1154         unsigned nid, next;
1155         struct task_struct *me = current;
1156
1157         nid = me->il_next;
1158         next = next_node(nid, policy->v.nodes);
1159         if (next >= MAX_NUMNODES)
1160                 next = first_node(policy->v.nodes);
1161         me->il_next = next;
1162         return nid;
1163 }
1164
1165 /*
1166  * Depending on the memory policy provide a node from which to allocate the
1167  * next slab entry.
1168  */
1169 unsigned slab_node(struct mempolicy *policy)
1170 {
1171         int pol = policy ? policy->policy : MPOL_DEFAULT;
1172
1173         switch (pol) {
1174         case MPOL_INTERLEAVE:
1175                 return interleave_nodes(policy);
1176
1177         case MPOL_BIND:
1178                 /*
1179                  * Follow bind policy behavior and start allocation at the
1180                  * first node.
1181                  */
1182                 return zone_to_nid(policy->v.zonelist->zones[0]);
1183
1184         case MPOL_PREFERRED:
1185                 if (policy->v.preferred_node >= 0)
1186                         return policy->v.preferred_node;
1187                 /* Fall through */
1188
1189         default:
1190                 return numa_node_id();
1191         }
1192 }
1193
1194 /* Do static interleaving for a VMA with known offset. */
1195 static unsigned offset_il_node(struct mempolicy *pol,
1196                 struct vm_area_struct *vma, unsigned long off)
1197 {
1198         unsigned nnodes = nodes_weight(pol->v.nodes);
1199         unsigned target = (unsigned)off % nnodes;
1200         int c;
1201         int nid = -1;
1202
1203         c = 0;
1204         do {
1205                 nid = next_node(nid, pol->v.nodes);
1206                 c++;
1207         } while (c <= target);
1208         return nid;
1209 }
1210
1211 /* Determine a node number for interleave */
1212 static inline unsigned interleave_nid(struct mempolicy *pol,
1213                  struct vm_area_struct *vma, unsigned long addr, int shift)
1214 {
1215         if (vma) {
1216                 unsigned long off;
1217
1218                 /*
1219                  * for small pages, there is no difference between
1220                  * shift and PAGE_SHIFT, so the bit-shift is safe.
1221                  * for huge pages, since vm_pgoff is in units of small
1222                  * pages, we need to shift off the always 0 bits to get
1223                  * a useful offset.
1224                  */
1225                 BUG_ON(shift < PAGE_SHIFT);
1226                 off = vma->vm_pgoff >> (shift - PAGE_SHIFT);
1227                 off += (addr - vma->vm_start) >> shift;
1228                 return offset_il_node(pol, vma, off);
1229         } else
1230                 return interleave_nodes(pol);
1231 }
1232
1233 #ifdef CONFIG_HUGETLBFS
1234 /*
1235  * huge_zonelist(@vma, @addr, @gfp_flags, @mpol)
1236  * @vma = virtual memory area whose policy is sought
1237  * @addr = address in @vma for shared policy lookup and interleave policy
1238  * @gfp_flags = for requested zone
1239  * @mpol = pointer to mempolicy pointer for reference counted 'BIND policy
1240  *
1241  * Returns a zonelist suitable for a huge page allocation.
1242  * If the effective policy is 'BIND, returns pointer to policy's zonelist.
1243  * If it is also a policy for which get_vma_policy() returns an extra
1244  * reference, we must hold that reference until after allocation.
1245  * In that case, return policy via @mpol so hugetlb allocation can drop
1246  * the reference.  For non-'BIND referenced policies, we can/do drop the
1247  * reference here, so the caller doesn't need to know about the special case
1248  * for default and current task policy.
1249  */
1250 struct zonelist *huge_zonelist(struct vm_area_struct *vma, unsigned long addr,
1251                                 gfp_t gfp_flags, struct mempolicy **mpol)
1252 {
1253         struct mempolicy *pol = get_vma_policy(current, vma, addr);
1254         struct zonelist *zl;
1255
1256         *mpol = NULL;           /* probably no unref needed */
1257         if (pol->policy == MPOL_INTERLEAVE) {
1258                 unsigned nid;
1259
1260                 nid = interleave_nid(pol, vma, addr, HPAGE_SHIFT);
1261                 __mpol_free(pol);               /* finished with pol */
1262                 return NODE_DATA(nid)->node_zonelists + gfp_zone(gfp_flags);
1263         }
1264
1265         zl = zonelist_policy(GFP_HIGHUSER, pol);
1266         if (unlikely(pol != &default_policy && pol != current->mempolicy)) {
1267                 if (pol->policy != MPOL_BIND)
1268                         __mpol_free(pol);       /* finished with pol */
1269                 else
1270                         *mpol = pol;    /* unref needed after allocation */
1271         }
1272         return zl;
1273 }
1274 #endif
1275
1276 /* Allocate a page in interleaved policy.
1277    Own path because it needs to do special accounting. */
1278 static struct page *alloc_page_interleave(gfp_t gfp, unsigned order,
1279                                         unsigned nid)
1280 {
1281         struct zonelist *zl;
1282         struct page *page;
1283
1284         zl = NODE_DATA(nid)->node_zonelists + gfp_zone(gfp);
1285         page = __alloc_pages(gfp, order, zl);
1286         if (page && page_zone(page) == zl->zones[0])
1287                 inc_zone_page_state(page, NUMA_INTERLEAVE_HIT);
1288         return page;
1289 }
1290
1291 /**
1292  *      alloc_page_vma  - Allocate a page for a VMA.
1293  *
1294  *      @gfp:
1295  *      %GFP_USER    user allocation.
1296  *      %GFP_KERNEL  kernel allocations,
1297  *      %GFP_HIGHMEM highmem/user allocations,
1298  *      %GFP_FS      allocation should not call back into a file system.
1299  *      %GFP_ATOMIC  don't sleep.
1300  *
1301  *      @vma:  Pointer to VMA or NULL if not available.
1302  *      @addr: Virtual Address of the allocation. Must be inside the VMA.
1303  *
1304  *      This function allocates a page from the kernel page pool and applies
1305  *      a NUMA policy associated with the VMA or the current process.
1306  *      When VMA is not NULL caller must hold down_read on the mmap_sem of the
1307  *      mm_struct of the VMA to prevent it from going away. Should be used for
1308  *      all allocations for pages that will be mapped into
1309  *      user space. Returns NULL when no page can be allocated.
1310  *
1311  *      Should be called with the mm_sem of the vma hold.
1312  */
1313 struct page *
1314 alloc_page_vma(gfp_t gfp, struct vm_area_struct *vma, unsigned long addr)
1315 {
1316         struct mempolicy *pol = get_vma_policy(current, vma, addr);
1317         struct zonelist *zl;
1318
1319         cpuset_update_task_memory_state();
1320
1321         if (unlikely(pol->policy == MPOL_INTERLEAVE)) {
1322                 unsigned nid;
1323
1324                 nid = interleave_nid(pol, vma, addr, PAGE_SHIFT);
1325                 return alloc_page_interleave(gfp, 0, nid);
1326         }
1327         zl = zonelist_policy(gfp, pol);
1328         if (pol != &default_policy && pol != current->mempolicy) {
1329                 /*
1330                  * slow path: ref counted policy -- shared or vma
1331                  */
1332                 struct page *page =  __alloc_pages(gfp, 0, zl);
1333                 __mpol_free(pol);
1334                 return page;
1335         }
1336         /*
1337          * fast path:  default or task policy
1338          */
1339         return __alloc_pages(gfp, 0, zl);
1340 }
1341
1342 /**
1343  *      alloc_pages_current - Allocate pages.
1344  *
1345  *      @gfp:
1346  *              %GFP_USER   user allocation,
1347  *              %GFP_KERNEL kernel allocation,
1348  *              %GFP_HIGHMEM highmem allocation,
1349  *              %GFP_FS     don't call back into a file system.
1350  *              %GFP_ATOMIC don't sleep.
1351  *      @order: Power of two of allocation size in pages. 0 is a single page.
1352  *
1353  *      Allocate a page from the kernel page pool.  When not in
1354  *      interrupt context and apply the current process NUMA policy.
1355  *      Returns NULL when no page can be allocated.
1356  *
1357  *      Don't call cpuset_update_task_memory_state() unless
1358  *      1) it's ok to take cpuset_sem (can WAIT), and
1359  *      2) allocating for current task (not interrupt).
1360  */
1361 struct page *alloc_pages_current(gfp_t gfp, unsigned order)
1362 {
1363         struct mempolicy *pol = current->mempolicy;
1364
1365         if ((gfp & __GFP_WAIT) && !in_interrupt())
1366                 cpuset_update_task_memory_state();
1367         if (!pol || in_interrupt() || (gfp & __GFP_THISNODE))
1368                 pol = &default_policy;
1369         if (pol->policy == MPOL_INTERLEAVE)
1370                 return alloc_page_interleave(gfp, order, interleave_nodes(pol));
1371         return __alloc_pages(gfp, order, zonelist_policy(gfp, pol));
1372 }
1373 EXPORT_SYMBOL(alloc_pages_current);
1374
1375 /*
1376  * If mpol_copy() sees current->cpuset == cpuset_being_rebound, then it
1377  * rebinds the mempolicy its copying by calling mpol_rebind_policy()
1378  * with the mems_allowed returned by cpuset_mems_allowed().  This
1379  * keeps mempolicies cpuset relative after its cpuset moves.  See
1380  * further kernel/cpuset.c update_nodemask().
1381  */
1382 void *cpuset_being_rebound;
1383
1384 /* Slow path of a mempolicy copy */
1385 struct mempolicy *__mpol_copy(struct mempolicy *old)
1386 {
1387         struct mempolicy *new = kmem_cache_alloc(policy_cache, GFP_KERNEL);
1388
1389         if (!new)
1390                 return ERR_PTR(-ENOMEM);
1391         if (current_cpuset_is_being_rebound()) {
1392                 nodemask_t mems = cpuset_mems_allowed(current);
1393                 mpol_rebind_policy(old, &mems);
1394         }
1395         *new = *old;
1396         atomic_set(&new->refcnt, 1);
1397         if (new->policy == MPOL_BIND) {
1398                 int sz = ksize(old->v.zonelist);
1399                 new->v.zonelist = kmemdup(old->v.zonelist, sz, GFP_KERNEL);
1400                 if (!new->v.zonelist) {
1401                         kmem_cache_free(policy_cache, new);
1402                         return ERR_PTR(-ENOMEM);
1403                 }
1404         }
1405         return new;
1406 }
1407
1408 /* Slow path of a mempolicy comparison */
1409 int __mpol_equal(struct mempolicy *a, struct mempolicy *b)
1410 {
1411         if (!a || !b)
1412                 return 0;
1413         if (a->policy != b->policy)
1414                 return 0;
1415         switch (a->policy) {
1416         case MPOL_DEFAULT:
1417                 return 1;
1418         case MPOL_INTERLEAVE:
1419                 return nodes_equal(a->v.nodes, b->v.nodes);
1420         case MPOL_PREFERRED:
1421                 return a->v.preferred_node == b->v.preferred_node;
1422         case MPOL_BIND: {
1423                 int i;
1424                 for (i = 0; a->v.zonelist->zones[i]; i++)
1425                         if (a->v.zonelist->zones[i] != b->v.zonelist->zones[i])
1426                                 return 0;
1427                 return b->v.zonelist->zones[i] == NULL;
1428         }
1429         default:
1430                 BUG();
1431                 return 0;
1432         }
1433 }
1434
1435 /* Slow path of a mpol destructor. */
1436 void __mpol_free(struct mempolicy *p)
1437 {
1438         if (!atomic_dec_and_test(&p->refcnt))
1439                 return;
1440         if (p->policy == MPOL_BIND)
1441                 kfree(p->v.zonelist);
1442         p->policy = MPOL_DEFAULT;
1443         kmem_cache_free(policy_cache, p);
1444 }
1445
1446 /*
1447  * Shared memory backing store policy support.
1448  *
1449  * Remember policies even when nobody has shared memory mapped.
1450  * The policies are kept in Red-Black tree linked from the inode.
1451  * They are protected by the sp->lock spinlock, which should be held
1452  * for any accesses to the tree.
1453  */
1454
1455 /* lookup first element intersecting start-end */
1456 /* Caller holds sp->lock */
1457 static struct sp_node *
1458 sp_lookup(struct shared_policy *sp, unsigned long start, unsigned long end)
1459 {
1460         struct rb_node *n = sp->root.rb_node;
1461
1462         while (n) {
1463                 struct sp_node *p = rb_entry(n, struct sp_node, nd);
1464
1465                 if (start >= p->end)
1466                         n = n->rb_right;
1467                 else if (end <= p->start)
1468                         n = n->rb_left;
1469                 else
1470                         break;
1471         }
1472         if (!n)
1473                 return NULL;
1474         for (;;) {
1475                 struct sp_node *w = NULL;
1476                 struct rb_node *prev = rb_prev(n);
1477                 if (!prev)
1478                         break;
1479                 w = rb_entry(prev, struct sp_node, nd);
1480                 if (w->end <= start)
1481                         break;
1482                 n = prev;
1483         }
1484         return rb_entry(n, struct sp_node, nd);
1485 }
1486
1487 /* Insert a new shared policy into the list. */
1488 /* Caller holds sp->lock */
1489 static void sp_insert(struct shared_policy *sp, struct sp_node *new)
1490 {
1491         struct rb_node **p = &sp->root.rb_node;
1492         struct rb_node *parent = NULL;
1493         struct sp_node *nd;
1494
1495         while (*p) {
1496                 parent = *p;
1497                 nd = rb_entry(parent, struct sp_node, nd);
1498                 if (new->start < nd->start)
1499                         p = &(*p)->rb_left;
1500                 else if (new->end > nd->end)
1501                         p = &(*p)->rb_right;
1502                 else
1503                         BUG();
1504         }
1505         rb_link_node(&new->nd, parent, p);
1506         rb_insert_color(&new->nd, &sp->root);
1507         pr_debug("inserting %lx-%lx: %d\n", new->start, new->end,
1508                  new->policy ? new->policy->policy : 0);
1509 }
1510
1511 /* Find shared policy intersecting idx */
1512 struct mempolicy *
1513 mpol_shared_policy_lookup(struct shared_policy *sp, unsigned long idx)
1514 {
1515         struct mempolicy *pol = NULL;
1516         struct sp_node *sn;
1517
1518         if (!sp->root.rb_node)
1519                 return NULL;
1520         spin_lock(&sp->lock);
1521         sn = sp_lookup(sp, idx, idx+1);
1522         if (sn) {
1523                 mpol_get(sn->policy);
1524                 pol = sn->policy;
1525         }
1526         spin_unlock(&sp->lock);
1527         return pol;
1528 }
1529
1530 static void sp_delete(struct shared_policy *sp, struct sp_node *n)
1531 {
1532         pr_debug("deleting %lx-l%lx\n", n->start, n->end);
1533         rb_erase(&n->nd, &sp->root);
1534         mpol_free(n->policy);
1535         kmem_cache_free(sn_cache, n);
1536 }
1537
1538 struct sp_node *
1539 sp_alloc(unsigned long start, unsigned long end, struct mempolicy *pol)
1540 {
1541         struct sp_node *n = kmem_cache_alloc(sn_cache, GFP_KERNEL);
1542
1543         if (!n)
1544                 return NULL;
1545         n->start = start;
1546         n->end = end;
1547         mpol_get(pol);
1548         n->policy = pol;
1549         return n;
1550 }
1551
1552 /* Replace a policy range. */
1553 static int shared_policy_replace(struct shared_policy *sp, unsigned long start,
1554                                  unsigned long end, struct sp_node *new)
1555 {
1556         struct sp_node *n, *new2 = NULL;
1557
1558 restart:
1559         spin_lock(&sp->lock);
1560         n = sp_lookup(sp, start, end);
1561         /* Take care of old policies in the same range. */
1562         while (n && n->start < end) {
1563                 struct rb_node *next = rb_next(&n->nd);
1564                 if (n->start >= start) {
1565                         if (n->end <= end)
1566                                 sp_delete(sp, n);
1567                         else
1568                                 n->start = end;
1569                 } else {
1570                         /* Old policy spanning whole new range. */
1571                         if (n->end > end) {
1572                                 if (!new2) {
1573                                         spin_unlock(&sp->lock);
1574                                         new2 = sp_alloc(end, n->end, n->policy);
1575                                         if (!new2)
1576                                                 return -ENOMEM;
1577                                         goto restart;
1578                                 }
1579                                 n->end = start;
1580                                 sp_insert(sp, new2);
1581                                 new2 = NULL;
1582                                 break;
1583                         } else
1584                                 n->end = start;
1585                 }
1586                 if (!next)
1587                         break;
1588                 n = rb_entry(next, struct sp_node, nd);
1589         }
1590         if (new)
1591                 sp_insert(sp, new);
1592         spin_unlock(&sp->lock);
1593         if (new2) {
1594                 mpol_free(new2->policy);
1595                 kmem_cache_free(sn_cache, new2);
1596         }
1597         return 0;
1598 }
1599
1600 void mpol_shared_policy_init(struct shared_policy *info, int policy,
1601                                 nodemask_t *policy_nodes)
1602 {
1603         info->root = RB_ROOT;
1604         spin_lock_init(&info->lock);
1605
1606         if (policy != MPOL_DEFAULT) {
1607                 struct mempolicy *newpol;
1608
1609                 /* Falls back to MPOL_DEFAULT on any error */
1610                 newpol = mpol_new(policy, policy_nodes);
1611                 if (!IS_ERR(newpol)) {
1612                         /* Create pseudo-vma that contains just the policy */
1613                         struct vm_area_struct pvma;
1614
1615                         memset(&pvma, 0, sizeof(struct vm_area_struct));
1616                         /* Policy covers entire file */
1617                         pvma.vm_end = TASK_SIZE;
1618                         mpol_set_shared_policy(info, &pvma, newpol);
1619                         mpol_free(newpol);
1620                 }
1621         }
1622 }
1623
1624 int mpol_set_shared_policy(struct shared_policy *info,
1625                         struct vm_area_struct *vma, struct mempolicy *npol)
1626 {
1627         int err;
1628         struct sp_node *new = NULL;
1629         unsigned long sz = vma_pages(vma);
1630
1631         pr_debug("set_shared_policy %lx sz %lu %d %lx\n",
1632                  vma->vm_pgoff,
1633                  sz, npol? npol->policy : -1,
1634                  npol ? nodes_addr(npol->v.nodes)[0] : -1);
1635
1636         if (npol) {
1637                 new = sp_alloc(vma->vm_pgoff, vma->vm_pgoff + sz, npol);
1638                 if (!new)
1639                         return -ENOMEM;
1640         }
1641         err = shared_policy_replace(info, vma->vm_pgoff, vma->vm_pgoff+sz, new);
1642         if (err && new)
1643                 kmem_cache_free(sn_cache, new);
1644         return err;
1645 }
1646
1647 /* Free a backing policy store on inode delete. */
1648 void mpol_free_shared_policy(struct shared_policy *p)
1649 {
1650         struct sp_node *n;
1651         struct rb_node *next;
1652
1653         if (!p->root.rb_node)
1654                 return;
1655         spin_lock(&p->lock);
1656         next = rb_first(&p->root);
1657         while (next) {
1658                 n = rb_entry(next, struct sp_node, nd);
1659                 next = rb_next(&n->nd);
1660                 rb_erase(&n->nd, &p->root);
1661                 mpol_free(n->policy);
1662                 kmem_cache_free(sn_cache, n);
1663         }
1664         spin_unlock(&p->lock);
1665 }
1666
1667 /* assumes fs == KERNEL_DS */
1668 void __init numa_policy_init(void)
1669 {
1670         nodemask_t interleave_nodes;
1671         unsigned long largest = 0;
1672         int nid, prefer = 0;
1673
1674         policy_cache = kmem_cache_create("numa_policy",
1675                                          sizeof(struct mempolicy),
1676                                          0, SLAB_PANIC, NULL);
1677
1678         sn_cache = kmem_cache_create("shared_policy_node",
1679                                      sizeof(struct sp_node),
1680                                      0, SLAB_PANIC, NULL);
1681
1682         /*
1683          * Set interleaving policy for system init. Interleaving is only
1684          * enabled across suitably sized nodes (default is >= 16MB), or
1685          * fall back to the largest node if they're all smaller.
1686          */
1687         nodes_clear(interleave_nodes);
1688         for_each_online_node(nid) {
1689                 unsigned long total_pages = node_present_pages(nid);
1690
1691                 /* Preserve the largest node */
1692                 if (largest < total_pages) {
1693                         largest = total_pages;
1694                         prefer = nid;
1695                 }
1696
1697                 /* Interleave this node? */
1698                 if ((total_pages << PAGE_SHIFT) >= (16 << 20))
1699                         node_set(nid, interleave_nodes);
1700         }
1701
1702         /* All too small, use the largest */
1703         if (unlikely(nodes_empty(interleave_nodes)))
1704                 node_set(prefer, interleave_nodes);
1705
1706         if (do_set_mempolicy(MPOL_INTERLEAVE, &interleave_nodes))
1707                 printk("numa_policy_init: interleaving failed\n");
1708 }
1709
1710 /* Reset policy of current process to default */
1711 void numa_default_policy(void)
1712 {
1713         do_set_mempolicy(MPOL_DEFAULT, NULL);
1714 }
1715
1716 /* Migrate a policy to a different set of nodes */
1717 void mpol_rebind_policy(struct mempolicy *pol, const nodemask_t *newmask)
1718 {
1719         nodemask_t *mpolmask;
1720         nodemask_t tmp;
1721
1722         if (!pol)
1723                 return;
1724         mpolmask = &pol->cpuset_mems_allowed;
1725         if (nodes_equal(*mpolmask, *newmask))
1726                 return;
1727
1728         switch (pol->policy) {
1729         case MPOL_DEFAULT:
1730                 break;
1731         case MPOL_INTERLEAVE:
1732                 nodes_remap(tmp, pol->v.nodes, *mpolmask, *newmask);
1733                 pol->v.nodes = tmp;
1734                 *mpolmask = *newmask;
1735                 current->il_next = node_remap(current->il_next,
1736                                                 *mpolmask, *newmask);
1737                 break;
1738         case MPOL_PREFERRED:
1739                 pol->v.preferred_node = node_remap(pol->v.preferred_node,
1740                                                 *mpolmask, *newmask);
1741                 *mpolmask = *newmask;
1742                 break;
1743         case MPOL_BIND: {
1744                 nodemask_t nodes;
1745                 struct zone **z;
1746                 struct zonelist *zonelist;
1747
1748                 nodes_clear(nodes);
1749                 for (z = pol->v.zonelist->zones; *z; z++)
1750                         node_set(zone_to_nid(*z), nodes);
1751                 nodes_remap(tmp, nodes, *mpolmask, *newmask);
1752                 nodes = tmp;
1753
1754                 zonelist = bind_zonelist(&nodes);
1755
1756                 /* If no mem, then zonelist is NULL and we keep old zonelist.
1757                  * If that old zonelist has no remaining mems_allowed nodes,
1758                  * then zonelist_policy() will "FALL THROUGH" to MPOL_DEFAULT.
1759                  */
1760
1761                 if (!IS_ERR(zonelist)) {
1762                         /* Good - got mem - substitute new zonelist */
1763                         kfree(pol->v.zonelist);
1764                         pol->v.zonelist = zonelist;
1765                 }
1766                 *mpolmask = *newmask;
1767                 break;
1768         }
1769         default:
1770                 BUG();
1771                 break;
1772         }
1773 }
1774
1775 /*
1776  * Wrapper for mpol_rebind_policy() that just requires task
1777  * pointer, and updates task mempolicy.
1778  */
1779
1780 void mpol_rebind_task(struct task_struct *tsk, const nodemask_t *new)
1781 {
1782         mpol_rebind_policy(tsk->mempolicy, new);
1783 }
1784
1785 /*
1786  * Rebind each vma in mm to new nodemask.
1787  *
1788  * Call holding a reference to mm.  Takes mm->mmap_sem during call.
1789  */
1790
1791 void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new)
1792 {
1793         struct vm_area_struct *vma;
1794
1795         down_write(&mm->mmap_sem);
1796         for (vma = mm->mmap; vma; vma = vma->vm_next)
1797                 mpol_rebind_policy(vma->vm_policy, new);
1798         up_write(&mm->mmap_sem);
1799 }
1800
1801 /*
1802  * Display pages allocated per node and memory policy via /proc.
1803  */
1804
1805 static const char * const policy_types[] =
1806         { "default", "prefer", "bind", "interleave" };
1807
1808 /*
1809  * Convert a mempolicy into a string.
1810  * Returns the number of characters in buffer (if positive)
1811  * or an error (negative)
1812  */
1813 static inline int mpol_to_str(char *buffer, int maxlen, struct mempolicy *pol)
1814 {
1815         char *p = buffer;
1816         int l;
1817         nodemask_t nodes;
1818         int mode = pol ? pol->policy : MPOL_DEFAULT;
1819
1820         switch (mode) {
1821         case MPOL_DEFAULT:
1822                 nodes_clear(nodes);
1823                 break;
1824
1825         case MPOL_PREFERRED:
1826                 nodes_clear(nodes);
1827                 node_set(pol->v.preferred_node, nodes);
1828                 break;
1829
1830         case MPOL_BIND:
1831                 get_zonemask(pol, &nodes);
1832                 break;
1833
1834         case MPOL_INTERLEAVE:
1835                 nodes = pol->v.nodes;
1836                 break;
1837
1838         default:
1839                 BUG();
1840                 return -EFAULT;
1841         }
1842
1843         l = strlen(policy_types[mode]);
1844         if (buffer + maxlen < p + l + 1)
1845                 return -ENOSPC;
1846
1847         strcpy(p, policy_types[mode]);
1848         p += l;
1849
1850         if (!nodes_empty(nodes)) {
1851                 if (buffer + maxlen < p + 2)
1852                         return -ENOSPC;
1853                 *p++ = '=';
1854                 p += nodelist_scnprintf(p, buffer + maxlen - p, nodes);
1855         }
1856         return p - buffer;
1857 }
1858
1859 struct numa_maps {
1860         unsigned long pages;
1861         unsigned long anon;
1862         unsigned long active;
1863         unsigned long writeback;
1864         unsigned long mapcount_max;
1865         unsigned long dirty;
1866         unsigned long swapcache;
1867         unsigned long node[MAX_NUMNODES];
1868 };
1869
1870 static void gather_stats(struct page *page, void *private, int pte_dirty)
1871 {
1872         struct numa_maps *md = private;
1873         int count = page_mapcount(page);
1874
1875         md->pages++;
1876         if (pte_dirty || PageDirty(page))
1877                 md->dirty++;
1878
1879         if (PageSwapCache(page))
1880                 md->swapcache++;
1881
1882         if (PageActive(page))
1883                 md->active++;
1884
1885         if (PageWriteback(page))
1886                 md->writeback++;
1887
1888         if (PageAnon(page))
1889                 md->anon++;
1890
1891         if (count > md->mapcount_max)
1892                 md->mapcount_max = count;
1893
1894         md->node[page_to_nid(page)]++;
1895 }
1896
1897 #ifdef CONFIG_HUGETLB_PAGE
1898 static void check_huge_range(struct vm_area_struct *vma,
1899                 unsigned long start, unsigned long end,
1900                 struct numa_maps *md)
1901 {
1902         unsigned long addr;
1903         struct page *page;
1904
1905         for (addr = start; addr < end; addr += HPAGE_SIZE) {
1906                 pte_t *ptep = huge_pte_offset(vma->vm_mm, addr & HPAGE_MASK);
1907                 pte_t pte;
1908
1909                 if (!ptep)
1910                         continue;
1911
1912                 pte = *ptep;
1913                 if (pte_none(pte))
1914                         continue;
1915
1916                 page = pte_page(pte);
1917                 if (!page)
1918                         continue;
1919
1920                 gather_stats(page, md, pte_dirty(*ptep));
1921         }
1922 }
1923 #else
1924 static inline void check_huge_range(struct vm_area_struct *vma,
1925                 unsigned long start, unsigned long end,
1926                 struct numa_maps *md)
1927 {
1928 }
1929 #endif
1930
1931 int show_numa_map(struct seq_file *m, void *v)
1932 {
1933         struct proc_maps_private *priv = m->private;
1934         struct vm_area_struct *vma = v;
1935         struct numa_maps *md;
1936         struct file *file = vma->vm_file;
1937         struct mm_struct *mm = vma->vm_mm;
1938         struct mempolicy *pol;
1939         int n;
1940         char buffer[50];
1941
1942         if (!mm)
1943                 return 0;
1944
1945         md = kzalloc(sizeof(struct numa_maps), GFP_KERNEL);
1946         if (!md)
1947                 return 0;
1948
1949         pol = get_vma_policy(priv->task, vma, vma->vm_start);
1950         mpol_to_str(buffer, sizeof(buffer), pol);
1951         /*
1952          * unref shared or other task's mempolicy
1953          */
1954         if (pol != &default_policy && pol != current->mempolicy)
1955                 __mpol_free(pol);
1956
1957         seq_printf(m, "%08lx %s", vma->vm_start, buffer);
1958
1959         if (file) {
1960                 seq_printf(m, " file=");
1961                 seq_path(m, file->f_path.mnt, file->f_path.dentry, "\n\t= ");
1962         } else if (vma->vm_start <= mm->brk && vma->vm_end >= mm->start_brk) {
1963                 seq_printf(m, " heap");
1964         } else if (vma->vm_start <= mm->start_stack &&
1965                         vma->vm_end >= mm->start_stack) {
1966                 seq_printf(m, " stack");
1967         }
1968
1969         if (is_vm_hugetlb_page(vma)) {
1970                 check_huge_range(vma, vma->vm_start, vma->vm_end, md);
1971                 seq_printf(m, " huge");
1972         } else {
1973                 check_pgd_range(vma, vma->vm_start, vma->vm_end,
1974                                 &node_online_map, MPOL_MF_STATS, md);
1975         }
1976
1977         if (!md->pages)
1978                 goto out;
1979
1980         if (md->anon)
1981                 seq_printf(m," anon=%lu",md->anon);
1982
1983         if (md->dirty)
1984                 seq_printf(m," dirty=%lu",md->dirty);
1985
1986         if (md->pages != md->anon && md->pages != md->dirty)
1987                 seq_printf(m, " mapped=%lu", md->pages);
1988
1989         if (md->mapcount_max > 1)
1990                 seq_printf(m, " mapmax=%lu", md->mapcount_max);
1991
1992         if (md->swapcache)
1993                 seq_printf(m," swapcache=%lu", md->swapcache);
1994
1995         if (md->active < md->pages && !is_vm_hugetlb_page(vma))
1996                 seq_printf(m," active=%lu", md->active);
1997
1998         if (md->writeback)
1999                 seq_printf(m," writeback=%lu", md->writeback);
2000
2001         for_each_online_node(n)
2002                 if (md->node[n])
2003                         seq_printf(m, " N%d=%lu", n, md->node[n]);
2004 out:
2005         seq_putc(m, '\n');
2006         kfree(md);
2007
2008         if (m->count < m->size)
2009                 m->version = (vma != priv->tail_vma) ? vma->vm_start : 0;
2010         return 0;
2011 }
2012