Clean up duplicate includes in mm/
[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 & ~(unsigned long)(MPOL_F_NODE|MPOL_F_ADDR))
530                 return -EINVAL;
531         if (flags & MPOL_F_ADDR) {
532                 down_read(&mm->mmap_sem);
533                 vma = find_vma_intersection(mm, addr, addr+1);
534                 if (!vma) {
535                         up_read(&mm->mmap_sem);
536                         return -EFAULT;
537                 }
538                 if (vma->vm_ops && vma->vm_ops->get_policy)
539                         pol = vma->vm_ops->get_policy(vma, addr);
540                 else
541                         pol = vma->vm_policy;
542         } else if (addr)
543                 return -EINVAL;
544
545         if (!pol)
546                 pol = &default_policy;
547
548         if (flags & MPOL_F_NODE) {
549                 if (flags & MPOL_F_ADDR) {
550                         err = lookup_node(mm, addr);
551                         if (err < 0)
552                                 goto out;
553                         *policy = err;
554                 } else if (pol == current->mempolicy &&
555                                 pol->policy == MPOL_INTERLEAVE) {
556                         *policy = current->il_next;
557                 } else {
558                         err = -EINVAL;
559                         goto out;
560                 }
561         } else
562                 *policy = pol->policy;
563
564         if (vma) {
565                 up_read(&current->mm->mmap_sem);
566                 vma = NULL;
567         }
568
569         err = 0;
570         if (nmask)
571                 get_zonemask(pol, nmask);
572
573  out:
574         if (vma)
575                 up_read(&current->mm->mmap_sem);
576         return err;
577 }
578
579 #ifdef CONFIG_MIGRATION
580 /*
581  * page migration
582  */
583 static void migrate_page_add(struct page *page, struct list_head *pagelist,
584                                 unsigned long flags)
585 {
586         /*
587          * Avoid migrating a page that is shared with others.
588          */
589         if ((flags & MPOL_MF_MOVE_ALL) || page_mapcount(page) == 1)
590                 isolate_lru_page(page, pagelist);
591 }
592
593 static struct page *new_node_page(struct page *page, unsigned long node, int **x)
594 {
595         return alloc_pages_node(node, GFP_HIGHUSER_MOVABLE, 0);
596 }
597
598 /*
599  * Migrate pages from one node to a target node.
600  * Returns error or the number of pages not migrated.
601  */
602 int migrate_to_node(struct mm_struct *mm, int source, int dest, int flags)
603 {
604         nodemask_t nmask;
605         LIST_HEAD(pagelist);
606         int err = 0;
607
608         nodes_clear(nmask);
609         node_set(source, nmask);
610
611         check_range(mm, mm->mmap->vm_start, TASK_SIZE, &nmask,
612                         flags | MPOL_MF_DISCONTIG_OK, &pagelist);
613
614         if (!list_empty(&pagelist))
615                 err = migrate_pages(&pagelist, new_node_page, dest);
616
617         return err;
618 }
619
620 /*
621  * Move pages between the two nodesets so as to preserve the physical
622  * layout as much as possible.
623  *
624  * Returns the number of page that could not be moved.
625  */
626 int do_migrate_pages(struct mm_struct *mm,
627         const nodemask_t *from_nodes, const nodemask_t *to_nodes, int flags)
628 {
629         LIST_HEAD(pagelist);
630         int busy = 0;
631         int err = 0;
632         nodemask_t tmp;
633
634         down_read(&mm->mmap_sem);
635
636         err = migrate_vmas(mm, from_nodes, to_nodes, flags);
637         if (err)
638                 goto out;
639
640 /*
641  * Find a 'source' bit set in 'tmp' whose corresponding 'dest'
642  * bit in 'to' is not also set in 'tmp'.  Clear the found 'source'
643  * bit in 'tmp', and return that <source, dest> pair for migration.
644  * The pair of nodemasks 'to' and 'from' define the map.
645  *
646  * If no pair of bits is found that way, fallback to picking some
647  * pair of 'source' and 'dest' bits that are not the same.  If the
648  * 'source' and 'dest' bits are the same, this represents a node
649  * that will be migrating to itself, so no pages need move.
650  *
651  * If no bits are left in 'tmp', or if all remaining bits left
652  * in 'tmp' correspond to the same bit in 'to', return false
653  * (nothing left to migrate).
654  *
655  * This lets us pick a pair of nodes to migrate between, such that
656  * if possible the dest node is not already occupied by some other
657  * source node, minimizing the risk of overloading the memory on a
658  * node that would happen if we migrated incoming memory to a node
659  * before migrating outgoing memory source that same node.
660  *
661  * A single scan of tmp is sufficient.  As we go, we remember the
662  * most recent <s, d> pair that moved (s != d).  If we find a pair
663  * that not only moved, but what's better, moved to an empty slot
664  * (d is not set in tmp), then we break out then, with that pair.
665  * Otherwise when we finish scannng from_tmp, we at least have the
666  * most recent <s, d> pair that moved.  If we get all the way through
667  * the scan of tmp without finding any node that moved, much less
668  * moved to an empty node, then there is nothing left worth migrating.
669  */
670
671         tmp = *from_nodes;
672         while (!nodes_empty(tmp)) {
673                 int s,d;
674                 int source = -1;
675                 int dest = 0;
676
677                 for_each_node_mask(s, tmp) {
678                         d = node_remap(s, *from_nodes, *to_nodes);
679                         if (s == d)
680                                 continue;
681
682                         source = s;     /* Node moved. Memorize */
683                         dest = d;
684
685                         /* dest not in remaining from nodes? */
686                         if (!node_isset(dest, tmp))
687                                 break;
688                 }
689                 if (source == -1)
690                         break;
691
692                 node_clear(source, tmp);
693                 err = migrate_to_node(mm, source, dest, flags);
694                 if (err > 0)
695                         busy += err;
696                 if (err < 0)
697                         break;
698         }
699 out:
700         up_read(&mm->mmap_sem);
701         if (err < 0)
702                 return err;
703         return busy;
704
705 }
706
707 static struct page *new_vma_page(struct page *page, unsigned long private, int **x)
708 {
709         struct vm_area_struct *vma = (struct vm_area_struct *)private;
710
711         return alloc_page_vma(GFP_HIGHUSER_MOVABLE, vma,
712                                         page_address_in_vma(page, vma));
713 }
714 #else
715
716 static void migrate_page_add(struct page *page, struct list_head *pagelist,
717                                 unsigned long flags)
718 {
719 }
720
721 int do_migrate_pages(struct mm_struct *mm,
722         const nodemask_t *from_nodes, const nodemask_t *to_nodes, int flags)
723 {
724         return -ENOSYS;
725 }
726
727 static struct page *new_vma_page(struct page *page, unsigned long private, int **x)
728 {
729         return NULL;
730 }
731 #endif
732
733 long do_mbind(unsigned long start, unsigned long len,
734                 unsigned long mode, nodemask_t *nmask, unsigned long flags)
735 {
736         struct vm_area_struct *vma;
737         struct mm_struct *mm = current->mm;
738         struct mempolicy *new;
739         unsigned long end;
740         int err;
741         LIST_HEAD(pagelist);
742
743         if ((flags & ~(unsigned long)(MPOL_MF_STRICT |
744                                       MPOL_MF_MOVE | MPOL_MF_MOVE_ALL))
745             || mode > MPOL_MAX)
746                 return -EINVAL;
747         if ((flags & MPOL_MF_MOVE_ALL) && !capable(CAP_SYS_NICE))
748                 return -EPERM;
749
750         if (start & ~PAGE_MASK)
751                 return -EINVAL;
752
753         if (mode == MPOL_DEFAULT)
754                 flags &= ~MPOL_MF_STRICT;
755
756         len = (len + PAGE_SIZE - 1) & PAGE_MASK;
757         end = start + len;
758
759         if (end < start)
760                 return -EINVAL;
761         if (end == start)
762                 return 0;
763
764         if (mpol_check_policy(mode, nmask))
765                 return -EINVAL;
766
767         new = mpol_new(mode, nmask);
768         if (IS_ERR(new))
769                 return PTR_ERR(new);
770
771         /*
772          * If we are using the default policy then operation
773          * on discontinuous address spaces is okay after all
774          */
775         if (!new)
776                 flags |= MPOL_MF_DISCONTIG_OK;
777
778         pr_debug("mbind %lx-%lx mode:%ld nodes:%lx\n",start,start+len,
779                  mode, nmask ? nodes_addr(*nmask)[0] : -1);
780
781         down_write(&mm->mmap_sem);
782         vma = check_range(mm, start, end, nmask,
783                           flags | MPOL_MF_INVERT, &pagelist);
784
785         err = PTR_ERR(vma);
786         if (!IS_ERR(vma)) {
787                 int nr_failed = 0;
788
789                 err = mbind_range(vma, start, end, new);
790
791                 if (!list_empty(&pagelist))
792                         nr_failed = migrate_pages(&pagelist, new_vma_page,
793                                                 (unsigned long)vma);
794
795                 if (!err && nr_failed && (flags & MPOL_MF_STRICT))
796                         err = -EIO;
797         }
798
799         up_write(&mm->mmap_sem);
800         mpol_free(new);
801         return err;
802 }
803
804 /*
805  * User space interface with variable sized bitmaps for nodelists.
806  */
807
808 /* Copy a node mask from user space. */
809 static int get_nodes(nodemask_t *nodes, const unsigned long __user *nmask,
810                      unsigned long maxnode)
811 {
812         unsigned long k;
813         unsigned long nlongs;
814         unsigned long endmask;
815
816         --maxnode;
817         nodes_clear(*nodes);
818         if (maxnode == 0 || !nmask)
819                 return 0;
820         if (maxnode > PAGE_SIZE*BITS_PER_BYTE)
821                 return -EINVAL;
822
823         nlongs = BITS_TO_LONGS(maxnode);
824         if ((maxnode % BITS_PER_LONG) == 0)
825                 endmask = ~0UL;
826         else
827                 endmask = (1UL << (maxnode % BITS_PER_LONG)) - 1;
828
829         /* When the user specified more nodes than supported just check
830            if the non supported part is all zero. */
831         if (nlongs > BITS_TO_LONGS(MAX_NUMNODES)) {
832                 if (nlongs > PAGE_SIZE/sizeof(long))
833                         return -EINVAL;
834                 for (k = BITS_TO_LONGS(MAX_NUMNODES); k < nlongs; k++) {
835                         unsigned long t;
836                         if (get_user(t, nmask + k))
837                                 return -EFAULT;
838                         if (k == nlongs - 1) {
839                                 if (t & endmask)
840                                         return -EINVAL;
841                         } else if (t)
842                                 return -EINVAL;
843                 }
844                 nlongs = BITS_TO_LONGS(MAX_NUMNODES);
845                 endmask = ~0UL;
846         }
847
848         if (copy_from_user(nodes_addr(*nodes), nmask, nlongs*sizeof(unsigned long)))
849                 return -EFAULT;
850         nodes_addr(*nodes)[nlongs-1] &= endmask;
851         return 0;
852 }
853
854 /* Copy a kernel node mask to user space */
855 static int copy_nodes_to_user(unsigned long __user *mask, unsigned long maxnode,
856                               nodemask_t *nodes)
857 {
858         unsigned long copy = ALIGN(maxnode-1, 64) / 8;
859         const int nbytes = BITS_TO_LONGS(MAX_NUMNODES) * sizeof(long);
860
861         if (copy > nbytes) {
862                 if (copy > PAGE_SIZE)
863                         return -EINVAL;
864                 if (clear_user((char __user *)mask + nbytes, copy - nbytes))
865                         return -EFAULT;
866                 copy = nbytes;
867         }
868         return copy_to_user(mask, nodes_addr(*nodes), copy) ? -EFAULT : 0;
869 }
870
871 asmlinkage long sys_mbind(unsigned long start, unsigned long len,
872                         unsigned long mode,
873                         unsigned long __user *nmask, unsigned long maxnode,
874                         unsigned flags)
875 {
876         nodemask_t nodes;
877         int err;
878
879         err = get_nodes(&nodes, nmask, maxnode);
880         if (err)
881                 return err;
882 #ifdef CONFIG_CPUSETS
883         /* Restrict the nodes to the allowed nodes in the cpuset */
884         nodes_and(nodes, nodes, current->mems_allowed);
885 #endif
886         return do_mbind(start, len, mode, &nodes, flags);
887 }
888
889 /* Set the process memory policy */
890 asmlinkage long sys_set_mempolicy(int mode, unsigned long __user *nmask,
891                 unsigned long maxnode)
892 {
893         int err;
894         nodemask_t nodes;
895
896         if (mode < 0 || mode > MPOL_MAX)
897                 return -EINVAL;
898         err = get_nodes(&nodes, nmask, maxnode);
899         if (err)
900                 return err;
901         return do_set_mempolicy(mode, &nodes);
902 }
903
904 asmlinkage long sys_migrate_pages(pid_t pid, unsigned long maxnode,
905                 const unsigned long __user *old_nodes,
906                 const unsigned long __user *new_nodes)
907 {
908         struct mm_struct *mm;
909         struct task_struct *task;
910         nodemask_t old;
911         nodemask_t new;
912         nodemask_t task_nodes;
913         int err;
914
915         err = get_nodes(&old, old_nodes, maxnode);
916         if (err)
917                 return err;
918
919         err = get_nodes(&new, new_nodes, maxnode);
920         if (err)
921                 return err;
922
923         /* Find the mm_struct */
924         read_lock(&tasklist_lock);
925         task = pid ? find_task_by_pid(pid) : current;
926         if (!task) {
927                 read_unlock(&tasklist_lock);
928                 return -ESRCH;
929         }
930         mm = get_task_mm(task);
931         read_unlock(&tasklist_lock);
932
933         if (!mm)
934                 return -EINVAL;
935
936         /*
937          * Check if this process has the right to modify the specified
938          * process. The right exists if the process has administrative
939          * capabilities, superuser privileges or the same
940          * userid as the target process.
941          */
942         if ((current->euid != task->suid) && (current->euid != task->uid) &&
943             (current->uid != task->suid) && (current->uid != task->uid) &&
944             !capable(CAP_SYS_NICE)) {
945                 err = -EPERM;
946                 goto out;
947         }
948
949         task_nodes = cpuset_mems_allowed(task);
950         /* Is the user allowed to access the target nodes? */
951         if (!nodes_subset(new, task_nodes) && !capable(CAP_SYS_NICE)) {
952                 err = -EPERM;
953                 goto out;
954         }
955
956         if (!nodes_subset(new, node_online_map)) {
957                 err = -EINVAL;
958                 goto out;
959         }
960
961         err = security_task_movememory(task);
962         if (err)
963                 goto out;
964
965         err = do_migrate_pages(mm, &old, &new,
966                 capable(CAP_SYS_NICE) ? MPOL_MF_MOVE_ALL : MPOL_MF_MOVE);
967 out:
968         mmput(mm);
969         return err;
970 }
971
972
973 /* Retrieve NUMA policy */
974 asmlinkage long sys_get_mempolicy(int __user *policy,
975                                 unsigned long __user *nmask,
976                                 unsigned long maxnode,
977                                 unsigned long addr, unsigned long flags)
978 {
979         int err, pval;
980         nodemask_t nodes;
981
982         if (nmask != NULL && maxnode < MAX_NUMNODES)
983                 return -EINVAL;
984
985         err = do_get_mempolicy(&pval, &nodes, addr, flags);
986
987         if (err)
988                 return err;
989
990         if (policy && put_user(pval, policy))
991                 return -EFAULT;
992
993         if (nmask)
994                 err = copy_nodes_to_user(nmask, maxnode, &nodes);
995
996         return err;
997 }
998
999 #ifdef CONFIG_COMPAT
1000
1001 asmlinkage long compat_sys_get_mempolicy(int __user *policy,
1002                                      compat_ulong_t __user *nmask,
1003                                      compat_ulong_t maxnode,
1004                                      compat_ulong_t addr, compat_ulong_t flags)
1005 {
1006         long err;
1007         unsigned long __user *nm = NULL;
1008         unsigned long nr_bits, alloc_size;
1009         DECLARE_BITMAP(bm, MAX_NUMNODES);
1010
1011         nr_bits = min_t(unsigned long, maxnode-1, MAX_NUMNODES);
1012         alloc_size = ALIGN(nr_bits, BITS_PER_LONG) / 8;
1013
1014         if (nmask)
1015                 nm = compat_alloc_user_space(alloc_size);
1016
1017         err = sys_get_mempolicy(policy, nm, nr_bits+1, addr, flags);
1018
1019         if (!err && nmask) {
1020                 err = copy_from_user(bm, nm, alloc_size);
1021                 /* ensure entire bitmap is zeroed */
1022                 err |= clear_user(nmask, ALIGN(maxnode-1, 8) / 8);
1023                 err |= compat_put_bitmap(nmask, bm, nr_bits);
1024         }
1025
1026         return err;
1027 }
1028
1029 asmlinkage long compat_sys_set_mempolicy(int mode, compat_ulong_t __user *nmask,
1030                                      compat_ulong_t maxnode)
1031 {
1032         long err = 0;
1033         unsigned long __user *nm = NULL;
1034         unsigned long nr_bits, alloc_size;
1035         DECLARE_BITMAP(bm, MAX_NUMNODES);
1036
1037         nr_bits = min_t(unsigned long, maxnode-1, MAX_NUMNODES);
1038         alloc_size = ALIGN(nr_bits, BITS_PER_LONG) / 8;
1039
1040         if (nmask) {
1041                 err = compat_get_bitmap(bm, nmask, nr_bits);
1042                 nm = compat_alloc_user_space(alloc_size);
1043                 err |= copy_to_user(nm, bm, alloc_size);
1044         }
1045
1046         if (err)
1047                 return -EFAULT;
1048
1049         return sys_set_mempolicy(mode, nm, nr_bits+1);
1050 }
1051
1052 asmlinkage long compat_sys_mbind(compat_ulong_t start, compat_ulong_t len,
1053                              compat_ulong_t mode, compat_ulong_t __user *nmask,
1054                              compat_ulong_t maxnode, compat_ulong_t flags)
1055 {
1056         long err = 0;
1057         unsigned long __user *nm = NULL;
1058         unsigned long nr_bits, alloc_size;
1059         nodemask_t bm;
1060
1061         nr_bits = min_t(unsigned long, maxnode-1, MAX_NUMNODES);
1062         alloc_size = ALIGN(nr_bits, BITS_PER_LONG) / 8;
1063
1064         if (nmask) {
1065                 err = compat_get_bitmap(nodes_addr(bm), nmask, nr_bits);
1066                 nm = compat_alloc_user_space(alloc_size);
1067                 err |= copy_to_user(nm, nodes_addr(bm), alloc_size);
1068         }
1069
1070         if (err)
1071                 return -EFAULT;
1072
1073         return sys_mbind(start, len, mode, nm, nr_bits+1, flags);
1074 }
1075
1076 #endif
1077
1078 /*
1079  * get_vma_policy(@task, @vma, @addr)
1080  * @task - task for fallback if vma policy == default
1081  * @vma   - virtual memory area whose policy is sought
1082  * @addr  - address in @vma for shared policy lookup
1083  *
1084  * Returns effective policy for a VMA at specified address.
1085  * Falls back to @task or system default policy, as necessary.
1086  * Returned policy has extra reference count if shared, vma,
1087  * or some other task's policy [show_numa_maps() can pass
1088  * @task != current].  It is the caller's responsibility to
1089  * free the reference in these cases.
1090  */
1091 static struct mempolicy * get_vma_policy(struct task_struct *task,
1092                 struct vm_area_struct *vma, unsigned long addr)
1093 {
1094         struct mempolicy *pol = task->mempolicy;
1095         int shared_pol = 0;
1096
1097         if (vma) {
1098                 if (vma->vm_ops && vma->vm_ops->get_policy) {
1099                         pol = vma->vm_ops->get_policy(vma, addr);
1100                         shared_pol = 1; /* if pol non-NULL, add ref below */
1101                 } else if (vma->vm_policy &&
1102                                 vma->vm_policy->policy != MPOL_DEFAULT)
1103                         pol = vma->vm_policy;
1104         }
1105         if (!pol)
1106                 pol = &default_policy;
1107         else if (!shared_pol && pol != current->mempolicy)
1108                 mpol_get(pol);  /* vma or other task's policy */
1109         return pol;
1110 }
1111
1112 /* Return a zonelist representing a mempolicy */
1113 static struct zonelist *zonelist_policy(gfp_t gfp, struct mempolicy *policy)
1114 {
1115         int nd;
1116
1117         switch (policy->policy) {
1118         case MPOL_PREFERRED:
1119                 nd = policy->v.preferred_node;
1120                 if (nd < 0)
1121                         nd = numa_node_id();
1122                 break;
1123         case MPOL_BIND:
1124                 /* Lower zones don't get a policy applied */
1125                 /* Careful: current->mems_allowed might have moved */
1126                 if (gfp_zone(gfp) >= policy_zone)
1127                         if (cpuset_zonelist_valid_mems_allowed(policy->v.zonelist))
1128                                 return policy->v.zonelist;
1129                 /*FALL THROUGH*/
1130         case MPOL_INTERLEAVE: /* should not happen */
1131         case MPOL_DEFAULT:
1132                 nd = numa_node_id();
1133                 break;
1134         default:
1135                 nd = 0;
1136                 BUG();
1137         }
1138         return NODE_DATA(nd)->node_zonelists + gfp_zone(gfp);
1139 }
1140
1141 /* Do dynamic interleaving for a process */
1142 static unsigned interleave_nodes(struct mempolicy *policy)
1143 {
1144         unsigned nid, next;
1145         struct task_struct *me = current;
1146
1147         nid = me->il_next;
1148         next = next_node(nid, policy->v.nodes);
1149         if (next >= MAX_NUMNODES)
1150                 next = first_node(policy->v.nodes);
1151         me->il_next = next;
1152         return nid;
1153 }
1154
1155 /*
1156  * Depending on the memory policy provide a node from which to allocate the
1157  * next slab entry.
1158  */
1159 unsigned slab_node(struct mempolicy *policy)
1160 {
1161         int pol = policy ? policy->policy : MPOL_DEFAULT;
1162
1163         switch (pol) {
1164         case MPOL_INTERLEAVE:
1165                 return interleave_nodes(policy);
1166
1167         case MPOL_BIND:
1168                 /*
1169                  * Follow bind policy behavior and start allocation at the
1170                  * first node.
1171                  */
1172                 return zone_to_nid(policy->v.zonelist->zones[0]);
1173
1174         case MPOL_PREFERRED:
1175                 if (policy->v.preferred_node >= 0)
1176                         return policy->v.preferred_node;
1177                 /* Fall through */
1178
1179         default:
1180                 return numa_node_id();
1181         }
1182 }
1183
1184 /* Do static interleaving for a VMA with known offset. */
1185 static unsigned offset_il_node(struct mempolicy *pol,
1186                 struct vm_area_struct *vma, unsigned long off)
1187 {
1188         unsigned nnodes = nodes_weight(pol->v.nodes);
1189         unsigned target = (unsigned)off % nnodes;
1190         int c;
1191         int nid = -1;
1192
1193         c = 0;
1194         do {
1195                 nid = next_node(nid, pol->v.nodes);
1196                 c++;
1197         } while (c <= target);
1198         return nid;
1199 }
1200
1201 /* Determine a node number for interleave */
1202 static inline unsigned interleave_nid(struct mempolicy *pol,
1203                  struct vm_area_struct *vma, unsigned long addr, int shift)
1204 {
1205         if (vma) {
1206                 unsigned long off;
1207
1208                 /*
1209                  * for small pages, there is no difference between
1210                  * shift and PAGE_SHIFT, so the bit-shift is safe.
1211                  * for huge pages, since vm_pgoff is in units of small
1212                  * pages, we need to shift off the always 0 bits to get
1213                  * a useful offset.
1214                  */
1215                 BUG_ON(shift < PAGE_SHIFT);
1216                 off = vma->vm_pgoff >> (shift - PAGE_SHIFT);
1217                 off += (addr - vma->vm_start) >> shift;
1218                 return offset_il_node(pol, vma, off);
1219         } else
1220                 return interleave_nodes(pol);
1221 }
1222
1223 #ifdef CONFIG_HUGETLBFS
1224 /*
1225  * huge_zonelist(@vma, @addr, @gfp_flags, @mpol)
1226  * @vma = virtual memory area whose policy is sought
1227  * @addr = address in @vma for shared policy lookup and interleave policy
1228  * @gfp_flags = for requested zone
1229  * @mpol = pointer to mempolicy pointer for reference counted 'BIND policy
1230  *
1231  * Returns a zonelist suitable for a huge page allocation.
1232  * If the effective policy is 'BIND, returns pointer to policy's zonelist.
1233  * If it is also a policy for which get_vma_policy() returns an extra
1234  * reference, we must hold that reference until after allocation.
1235  * In that case, return policy via @mpol so hugetlb allocation can drop
1236  * the reference.  For non-'BIND referenced policies, we can/do drop the
1237  * reference here, so the caller doesn't need to know about the special case
1238  * for default and current task policy.
1239  */
1240 struct zonelist *huge_zonelist(struct vm_area_struct *vma, unsigned long addr,
1241                                 gfp_t gfp_flags, struct mempolicy **mpol)
1242 {
1243         struct mempolicy *pol = get_vma_policy(current, vma, addr);
1244         struct zonelist *zl;
1245
1246         *mpol = NULL;           /* probably no unref needed */
1247         if (pol->policy == MPOL_INTERLEAVE) {
1248                 unsigned nid;
1249
1250                 nid = interleave_nid(pol, vma, addr, HPAGE_SHIFT);
1251                 __mpol_free(pol);               /* finished with pol */
1252                 return NODE_DATA(nid)->node_zonelists + gfp_zone(gfp_flags);
1253         }
1254
1255         zl = zonelist_policy(GFP_HIGHUSER, pol);
1256         if (unlikely(pol != &default_policy && pol != current->mempolicy)) {
1257                 if (pol->policy != MPOL_BIND)
1258                         __mpol_free(pol);       /* finished with pol */
1259                 else
1260                         *mpol = pol;    /* unref needed after allocation */
1261         }
1262         return zl;
1263 }
1264 #endif
1265
1266 /* Allocate a page in interleaved policy.
1267    Own path because it needs to do special accounting. */
1268 static struct page *alloc_page_interleave(gfp_t gfp, unsigned order,
1269                                         unsigned nid)
1270 {
1271         struct zonelist *zl;
1272         struct page *page;
1273
1274         zl = NODE_DATA(nid)->node_zonelists + gfp_zone(gfp);
1275         page = __alloc_pages(gfp, order, zl);
1276         if (page && page_zone(page) == zl->zones[0])
1277                 inc_zone_page_state(page, NUMA_INTERLEAVE_HIT);
1278         return page;
1279 }
1280
1281 /**
1282  *      alloc_page_vma  - Allocate a page for a VMA.
1283  *
1284  *      @gfp:
1285  *      %GFP_USER    user allocation.
1286  *      %GFP_KERNEL  kernel allocations,
1287  *      %GFP_HIGHMEM highmem/user allocations,
1288  *      %GFP_FS      allocation should not call back into a file system.
1289  *      %GFP_ATOMIC  don't sleep.
1290  *
1291  *      @vma:  Pointer to VMA or NULL if not available.
1292  *      @addr: Virtual Address of the allocation. Must be inside the VMA.
1293  *
1294  *      This function allocates a page from the kernel page pool and applies
1295  *      a NUMA policy associated with the VMA or the current process.
1296  *      When VMA is not NULL caller must hold down_read on the mmap_sem of the
1297  *      mm_struct of the VMA to prevent it from going away. Should be used for
1298  *      all allocations for pages that will be mapped into
1299  *      user space. Returns NULL when no page can be allocated.
1300  *
1301  *      Should be called with the mm_sem of the vma hold.
1302  */
1303 struct page *
1304 alloc_page_vma(gfp_t gfp, struct vm_area_struct *vma, unsigned long addr)
1305 {
1306         struct mempolicy *pol = get_vma_policy(current, vma, addr);
1307         struct zonelist *zl;
1308
1309         cpuset_update_task_memory_state();
1310
1311         if (unlikely(pol->policy == MPOL_INTERLEAVE)) {
1312                 unsigned nid;
1313
1314                 nid = interleave_nid(pol, vma, addr, PAGE_SHIFT);
1315                 return alloc_page_interleave(gfp, 0, nid);
1316         }
1317         zl = zonelist_policy(gfp, pol);
1318         if (pol != &default_policy && pol != current->mempolicy) {
1319                 /*
1320                  * slow path: ref counted policy -- shared or vma
1321                  */
1322                 struct page *page =  __alloc_pages(gfp, 0, zl);
1323                 __mpol_free(pol);
1324                 return page;
1325         }
1326         /*
1327          * fast path:  default or task policy
1328          */
1329         return __alloc_pages(gfp, 0, zl);
1330 }
1331
1332 /**
1333  *      alloc_pages_current - Allocate pages.
1334  *
1335  *      @gfp:
1336  *              %GFP_USER   user allocation,
1337  *              %GFP_KERNEL kernel allocation,
1338  *              %GFP_HIGHMEM highmem allocation,
1339  *              %GFP_FS     don't call back into a file system.
1340  *              %GFP_ATOMIC don't sleep.
1341  *      @order: Power of two of allocation size in pages. 0 is a single page.
1342  *
1343  *      Allocate a page from the kernel page pool.  When not in
1344  *      interrupt context and apply the current process NUMA policy.
1345  *      Returns NULL when no page can be allocated.
1346  *
1347  *      Don't call cpuset_update_task_memory_state() unless
1348  *      1) it's ok to take cpuset_sem (can WAIT), and
1349  *      2) allocating for current task (not interrupt).
1350  */
1351 struct page *alloc_pages_current(gfp_t gfp, unsigned order)
1352 {
1353         struct mempolicy *pol = current->mempolicy;
1354
1355         if ((gfp & __GFP_WAIT) && !in_interrupt())
1356                 cpuset_update_task_memory_state();
1357         if (!pol || in_interrupt() || (gfp & __GFP_THISNODE))
1358                 pol = &default_policy;
1359         if (pol->policy == MPOL_INTERLEAVE)
1360                 return alloc_page_interleave(gfp, order, interleave_nodes(pol));
1361         return __alloc_pages(gfp, order, zonelist_policy(gfp, pol));
1362 }
1363 EXPORT_SYMBOL(alloc_pages_current);
1364
1365 /*
1366  * If mpol_copy() sees current->cpuset == cpuset_being_rebound, then it
1367  * rebinds the mempolicy its copying by calling mpol_rebind_policy()
1368  * with the mems_allowed returned by cpuset_mems_allowed().  This
1369  * keeps mempolicies cpuset relative after its cpuset moves.  See
1370  * further kernel/cpuset.c update_nodemask().
1371  */
1372 void *cpuset_being_rebound;
1373
1374 /* Slow path of a mempolicy copy */
1375 struct mempolicy *__mpol_copy(struct mempolicy *old)
1376 {
1377         struct mempolicy *new = kmem_cache_alloc(policy_cache, GFP_KERNEL);
1378
1379         if (!new)
1380                 return ERR_PTR(-ENOMEM);
1381         if (current_cpuset_is_being_rebound()) {
1382                 nodemask_t mems = cpuset_mems_allowed(current);
1383                 mpol_rebind_policy(old, &mems);
1384         }
1385         *new = *old;
1386         atomic_set(&new->refcnt, 1);
1387         if (new->policy == MPOL_BIND) {
1388                 int sz = ksize(old->v.zonelist);
1389                 new->v.zonelist = kmemdup(old->v.zonelist, sz, GFP_KERNEL);
1390                 if (!new->v.zonelist) {
1391                         kmem_cache_free(policy_cache, new);
1392                         return ERR_PTR(-ENOMEM);
1393                 }
1394         }
1395         return new;
1396 }
1397
1398 /* Slow path of a mempolicy comparison */
1399 int __mpol_equal(struct mempolicy *a, struct mempolicy *b)
1400 {
1401         if (!a || !b)
1402                 return 0;
1403         if (a->policy != b->policy)
1404                 return 0;
1405         switch (a->policy) {
1406         case MPOL_DEFAULT:
1407                 return 1;
1408         case MPOL_INTERLEAVE:
1409                 return nodes_equal(a->v.nodes, b->v.nodes);
1410         case MPOL_PREFERRED:
1411                 return a->v.preferred_node == b->v.preferred_node;
1412         case MPOL_BIND: {
1413                 int i;
1414                 for (i = 0; a->v.zonelist->zones[i]; i++)
1415                         if (a->v.zonelist->zones[i] != b->v.zonelist->zones[i])
1416                                 return 0;
1417                 return b->v.zonelist->zones[i] == NULL;
1418         }
1419         default:
1420                 BUG();
1421                 return 0;
1422         }
1423 }
1424
1425 /* Slow path of a mpol destructor. */
1426 void __mpol_free(struct mempolicy *p)
1427 {
1428         if (!atomic_dec_and_test(&p->refcnt))
1429                 return;
1430         if (p->policy == MPOL_BIND)
1431                 kfree(p->v.zonelist);
1432         p->policy = MPOL_DEFAULT;
1433         kmem_cache_free(policy_cache, p);
1434 }
1435
1436 /*
1437  * Shared memory backing store policy support.
1438  *
1439  * Remember policies even when nobody has shared memory mapped.
1440  * The policies are kept in Red-Black tree linked from the inode.
1441  * They are protected by the sp->lock spinlock, which should be held
1442  * for any accesses to the tree.
1443  */
1444
1445 /* lookup first element intersecting start-end */
1446 /* Caller holds sp->lock */
1447 static struct sp_node *
1448 sp_lookup(struct shared_policy *sp, unsigned long start, unsigned long end)
1449 {
1450         struct rb_node *n = sp->root.rb_node;
1451
1452         while (n) {
1453                 struct sp_node *p = rb_entry(n, struct sp_node, nd);
1454
1455                 if (start >= p->end)
1456                         n = n->rb_right;
1457                 else if (end <= p->start)
1458                         n = n->rb_left;
1459                 else
1460                         break;
1461         }
1462         if (!n)
1463                 return NULL;
1464         for (;;) {
1465                 struct sp_node *w = NULL;
1466                 struct rb_node *prev = rb_prev(n);
1467                 if (!prev)
1468                         break;
1469                 w = rb_entry(prev, struct sp_node, nd);
1470                 if (w->end <= start)
1471                         break;
1472                 n = prev;
1473         }
1474         return rb_entry(n, struct sp_node, nd);
1475 }
1476
1477 /* Insert a new shared policy into the list. */
1478 /* Caller holds sp->lock */
1479 static void sp_insert(struct shared_policy *sp, struct sp_node *new)
1480 {
1481         struct rb_node **p = &sp->root.rb_node;
1482         struct rb_node *parent = NULL;
1483         struct sp_node *nd;
1484
1485         while (*p) {
1486                 parent = *p;
1487                 nd = rb_entry(parent, struct sp_node, nd);
1488                 if (new->start < nd->start)
1489                         p = &(*p)->rb_left;
1490                 else if (new->end > nd->end)
1491                         p = &(*p)->rb_right;
1492                 else
1493                         BUG();
1494         }
1495         rb_link_node(&new->nd, parent, p);
1496         rb_insert_color(&new->nd, &sp->root);
1497         pr_debug("inserting %lx-%lx: %d\n", new->start, new->end,
1498                  new->policy ? new->policy->policy : 0);
1499 }
1500
1501 /* Find shared policy intersecting idx */
1502 struct mempolicy *
1503 mpol_shared_policy_lookup(struct shared_policy *sp, unsigned long idx)
1504 {
1505         struct mempolicy *pol = NULL;
1506         struct sp_node *sn;
1507
1508         if (!sp->root.rb_node)
1509                 return NULL;
1510         spin_lock(&sp->lock);
1511         sn = sp_lookup(sp, idx, idx+1);
1512         if (sn) {
1513                 mpol_get(sn->policy);
1514                 pol = sn->policy;
1515         }
1516         spin_unlock(&sp->lock);
1517         return pol;
1518 }
1519
1520 static void sp_delete(struct shared_policy *sp, struct sp_node *n)
1521 {
1522         pr_debug("deleting %lx-l%lx\n", n->start, n->end);
1523         rb_erase(&n->nd, &sp->root);
1524         mpol_free(n->policy);
1525         kmem_cache_free(sn_cache, n);
1526 }
1527
1528 struct sp_node *
1529 sp_alloc(unsigned long start, unsigned long end, struct mempolicy *pol)
1530 {
1531         struct sp_node *n = kmem_cache_alloc(sn_cache, GFP_KERNEL);
1532
1533         if (!n)
1534                 return NULL;
1535         n->start = start;
1536         n->end = end;
1537         mpol_get(pol);
1538         n->policy = pol;
1539         return n;
1540 }
1541
1542 /* Replace a policy range. */
1543 static int shared_policy_replace(struct shared_policy *sp, unsigned long start,
1544                                  unsigned long end, struct sp_node *new)
1545 {
1546         struct sp_node *n, *new2 = NULL;
1547
1548 restart:
1549         spin_lock(&sp->lock);
1550         n = sp_lookup(sp, start, end);
1551         /* Take care of old policies in the same range. */
1552         while (n && n->start < end) {
1553                 struct rb_node *next = rb_next(&n->nd);
1554                 if (n->start >= start) {
1555                         if (n->end <= end)
1556                                 sp_delete(sp, n);
1557                         else
1558                                 n->start = end;
1559                 } else {
1560                         /* Old policy spanning whole new range. */
1561                         if (n->end > end) {
1562                                 if (!new2) {
1563                                         spin_unlock(&sp->lock);
1564                                         new2 = sp_alloc(end, n->end, n->policy);
1565                                         if (!new2)
1566                                                 return -ENOMEM;
1567                                         goto restart;
1568                                 }
1569                                 n->end = start;
1570                                 sp_insert(sp, new2);
1571                                 new2 = NULL;
1572                                 break;
1573                         } else
1574                                 n->end = start;
1575                 }
1576                 if (!next)
1577                         break;
1578                 n = rb_entry(next, struct sp_node, nd);
1579         }
1580         if (new)
1581                 sp_insert(sp, new);
1582         spin_unlock(&sp->lock);
1583         if (new2) {
1584                 mpol_free(new2->policy);
1585                 kmem_cache_free(sn_cache, new2);
1586         }
1587         return 0;
1588 }
1589
1590 void mpol_shared_policy_init(struct shared_policy *info, int policy,
1591                                 nodemask_t *policy_nodes)
1592 {
1593         info->root = RB_ROOT;
1594         spin_lock_init(&info->lock);
1595
1596         if (policy != MPOL_DEFAULT) {
1597                 struct mempolicy *newpol;
1598
1599                 /* Falls back to MPOL_DEFAULT on any error */
1600                 newpol = mpol_new(policy, policy_nodes);
1601                 if (!IS_ERR(newpol)) {
1602                         /* Create pseudo-vma that contains just the policy */
1603                         struct vm_area_struct pvma;
1604
1605                         memset(&pvma, 0, sizeof(struct vm_area_struct));
1606                         /* Policy covers entire file */
1607                         pvma.vm_end = TASK_SIZE;
1608                         mpol_set_shared_policy(info, &pvma, newpol);
1609                         mpol_free(newpol);
1610                 }
1611         }
1612 }
1613
1614 int mpol_set_shared_policy(struct shared_policy *info,
1615                         struct vm_area_struct *vma, struct mempolicy *npol)
1616 {
1617         int err;
1618         struct sp_node *new = NULL;
1619         unsigned long sz = vma_pages(vma);
1620
1621         pr_debug("set_shared_policy %lx sz %lu %d %lx\n",
1622                  vma->vm_pgoff,
1623                  sz, npol? npol->policy : -1,
1624                  npol ? nodes_addr(npol->v.nodes)[0] : -1);
1625
1626         if (npol) {
1627                 new = sp_alloc(vma->vm_pgoff, vma->vm_pgoff + sz, npol);
1628                 if (!new)
1629                         return -ENOMEM;
1630         }
1631         err = shared_policy_replace(info, vma->vm_pgoff, vma->vm_pgoff+sz, new);
1632         if (err && new)
1633                 kmem_cache_free(sn_cache, new);
1634         return err;
1635 }
1636
1637 /* Free a backing policy store on inode delete. */
1638 void mpol_free_shared_policy(struct shared_policy *p)
1639 {
1640         struct sp_node *n;
1641         struct rb_node *next;
1642
1643         if (!p->root.rb_node)
1644                 return;
1645         spin_lock(&p->lock);
1646         next = rb_first(&p->root);
1647         while (next) {
1648                 n = rb_entry(next, struct sp_node, nd);
1649                 next = rb_next(&n->nd);
1650                 rb_erase(&n->nd, &p->root);
1651                 mpol_free(n->policy);
1652                 kmem_cache_free(sn_cache, n);
1653         }
1654         spin_unlock(&p->lock);
1655 }
1656
1657 /* assumes fs == KERNEL_DS */
1658 void __init numa_policy_init(void)
1659 {
1660         nodemask_t interleave_nodes;
1661         unsigned long largest = 0;
1662         int nid, prefer = 0;
1663
1664         policy_cache = kmem_cache_create("numa_policy",
1665                                          sizeof(struct mempolicy),
1666                                          0, SLAB_PANIC, NULL);
1667
1668         sn_cache = kmem_cache_create("shared_policy_node",
1669                                      sizeof(struct sp_node),
1670                                      0, SLAB_PANIC, NULL);
1671
1672         /*
1673          * Set interleaving policy for system init. Interleaving is only
1674          * enabled across suitably sized nodes (default is >= 16MB), or
1675          * fall back to the largest node if they're all smaller.
1676          */
1677         nodes_clear(interleave_nodes);
1678         for_each_online_node(nid) {
1679                 unsigned long total_pages = node_present_pages(nid);
1680
1681                 /* Preserve the largest node */
1682                 if (largest < total_pages) {
1683                         largest = total_pages;
1684                         prefer = nid;
1685                 }
1686
1687                 /* Interleave this node? */
1688                 if ((total_pages << PAGE_SHIFT) >= (16 << 20))
1689                         node_set(nid, interleave_nodes);
1690         }
1691
1692         /* All too small, use the largest */
1693         if (unlikely(nodes_empty(interleave_nodes)))
1694                 node_set(prefer, interleave_nodes);
1695
1696         if (do_set_mempolicy(MPOL_INTERLEAVE, &interleave_nodes))
1697                 printk("numa_policy_init: interleaving failed\n");
1698 }
1699
1700 /* Reset policy of current process to default */
1701 void numa_default_policy(void)
1702 {
1703         do_set_mempolicy(MPOL_DEFAULT, NULL);
1704 }
1705
1706 /* Migrate a policy to a different set of nodes */
1707 void mpol_rebind_policy(struct mempolicy *pol, const nodemask_t *newmask)
1708 {
1709         nodemask_t *mpolmask;
1710         nodemask_t tmp;
1711
1712         if (!pol)
1713                 return;
1714         mpolmask = &pol->cpuset_mems_allowed;
1715         if (nodes_equal(*mpolmask, *newmask))
1716                 return;
1717
1718         switch (pol->policy) {
1719         case MPOL_DEFAULT:
1720                 break;
1721         case MPOL_INTERLEAVE:
1722                 nodes_remap(tmp, pol->v.nodes, *mpolmask, *newmask);
1723                 pol->v.nodes = tmp;
1724                 *mpolmask = *newmask;
1725                 current->il_next = node_remap(current->il_next,
1726                                                 *mpolmask, *newmask);
1727                 break;
1728         case MPOL_PREFERRED:
1729                 pol->v.preferred_node = node_remap(pol->v.preferred_node,
1730                                                 *mpolmask, *newmask);
1731                 *mpolmask = *newmask;
1732                 break;
1733         case MPOL_BIND: {
1734                 nodemask_t nodes;
1735                 struct zone **z;
1736                 struct zonelist *zonelist;
1737
1738                 nodes_clear(nodes);
1739                 for (z = pol->v.zonelist->zones; *z; z++)
1740                         node_set(zone_to_nid(*z), nodes);
1741                 nodes_remap(tmp, nodes, *mpolmask, *newmask);
1742                 nodes = tmp;
1743
1744                 zonelist = bind_zonelist(&nodes);
1745
1746                 /* If no mem, then zonelist is NULL and we keep old zonelist.
1747                  * If that old zonelist has no remaining mems_allowed nodes,
1748                  * then zonelist_policy() will "FALL THROUGH" to MPOL_DEFAULT.
1749                  */
1750
1751                 if (!IS_ERR(zonelist)) {
1752                         /* Good - got mem - substitute new zonelist */
1753                         kfree(pol->v.zonelist);
1754                         pol->v.zonelist = zonelist;
1755                 }
1756                 *mpolmask = *newmask;
1757                 break;
1758         }
1759         default:
1760                 BUG();
1761                 break;
1762         }
1763 }
1764
1765 /*
1766  * Wrapper for mpol_rebind_policy() that just requires task
1767  * pointer, and updates task mempolicy.
1768  */
1769
1770 void mpol_rebind_task(struct task_struct *tsk, const nodemask_t *new)
1771 {
1772         mpol_rebind_policy(tsk->mempolicy, new);
1773 }
1774
1775 /*
1776  * Rebind each vma in mm to new nodemask.
1777  *
1778  * Call holding a reference to mm.  Takes mm->mmap_sem during call.
1779  */
1780
1781 void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new)
1782 {
1783         struct vm_area_struct *vma;
1784
1785         down_write(&mm->mmap_sem);
1786         for (vma = mm->mmap; vma; vma = vma->vm_next)
1787                 mpol_rebind_policy(vma->vm_policy, new);
1788         up_write(&mm->mmap_sem);
1789 }
1790
1791 /*
1792  * Display pages allocated per node and memory policy via /proc.
1793  */
1794
1795 static const char * const policy_types[] =
1796         { "default", "prefer", "bind", "interleave" };
1797
1798 /*
1799  * Convert a mempolicy into a string.
1800  * Returns the number of characters in buffer (if positive)
1801  * or an error (negative)
1802  */
1803 static inline int mpol_to_str(char *buffer, int maxlen, struct mempolicy *pol)
1804 {
1805         char *p = buffer;
1806         int l;
1807         nodemask_t nodes;
1808         int mode = pol ? pol->policy : MPOL_DEFAULT;
1809
1810         switch (mode) {
1811         case MPOL_DEFAULT:
1812                 nodes_clear(nodes);
1813                 break;
1814
1815         case MPOL_PREFERRED:
1816                 nodes_clear(nodes);
1817                 node_set(pol->v.preferred_node, nodes);
1818                 break;
1819
1820         case MPOL_BIND:
1821                 get_zonemask(pol, &nodes);
1822                 break;
1823
1824         case MPOL_INTERLEAVE:
1825                 nodes = pol->v.nodes;
1826                 break;
1827
1828         default:
1829                 BUG();
1830                 return -EFAULT;
1831         }
1832
1833         l = strlen(policy_types[mode]);
1834         if (buffer + maxlen < p + l + 1)
1835                 return -ENOSPC;
1836
1837         strcpy(p, policy_types[mode]);
1838         p += l;
1839
1840         if (!nodes_empty(nodes)) {
1841                 if (buffer + maxlen < p + 2)
1842                         return -ENOSPC;
1843                 *p++ = '=';
1844                 p += nodelist_scnprintf(p, buffer + maxlen - p, nodes);
1845         }
1846         return p - buffer;
1847 }
1848
1849 struct numa_maps {
1850         unsigned long pages;
1851         unsigned long anon;
1852         unsigned long active;
1853         unsigned long writeback;
1854         unsigned long mapcount_max;
1855         unsigned long dirty;
1856         unsigned long swapcache;
1857         unsigned long node[MAX_NUMNODES];
1858 };
1859
1860 static void gather_stats(struct page *page, void *private, int pte_dirty)
1861 {
1862         struct numa_maps *md = private;
1863         int count = page_mapcount(page);
1864
1865         md->pages++;
1866         if (pte_dirty || PageDirty(page))
1867                 md->dirty++;
1868
1869         if (PageSwapCache(page))
1870                 md->swapcache++;
1871
1872         if (PageActive(page))
1873                 md->active++;
1874
1875         if (PageWriteback(page))
1876                 md->writeback++;
1877
1878         if (PageAnon(page))
1879                 md->anon++;
1880
1881         if (count > md->mapcount_max)
1882                 md->mapcount_max = count;
1883
1884         md->node[page_to_nid(page)]++;
1885 }
1886
1887 #ifdef CONFIG_HUGETLB_PAGE
1888 static void check_huge_range(struct vm_area_struct *vma,
1889                 unsigned long start, unsigned long end,
1890                 struct numa_maps *md)
1891 {
1892         unsigned long addr;
1893         struct page *page;
1894
1895         for (addr = start; addr < end; addr += HPAGE_SIZE) {
1896                 pte_t *ptep = huge_pte_offset(vma->vm_mm, addr & HPAGE_MASK);
1897                 pte_t pte;
1898
1899                 if (!ptep)
1900                         continue;
1901
1902                 pte = *ptep;
1903                 if (pte_none(pte))
1904                         continue;
1905
1906                 page = pte_page(pte);
1907                 if (!page)
1908                         continue;
1909
1910                 gather_stats(page, md, pte_dirty(*ptep));
1911         }
1912 }
1913 #else
1914 static inline void check_huge_range(struct vm_area_struct *vma,
1915                 unsigned long start, unsigned long end,
1916                 struct numa_maps *md)
1917 {
1918 }
1919 #endif
1920
1921 int show_numa_map(struct seq_file *m, void *v)
1922 {
1923         struct proc_maps_private *priv = m->private;
1924         struct vm_area_struct *vma = v;
1925         struct numa_maps *md;
1926         struct file *file = vma->vm_file;
1927         struct mm_struct *mm = vma->vm_mm;
1928         struct mempolicy *pol;
1929         int n;
1930         char buffer[50];
1931
1932         if (!mm)
1933                 return 0;
1934
1935         md = kzalloc(sizeof(struct numa_maps), GFP_KERNEL);
1936         if (!md)
1937                 return 0;
1938
1939         pol = get_vma_policy(priv->task, vma, vma->vm_start);
1940         mpol_to_str(buffer, sizeof(buffer), pol);
1941         /*
1942          * unref shared or other task's mempolicy
1943          */
1944         if (pol != &default_policy && pol != current->mempolicy)
1945                 __mpol_free(pol);
1946
1947         seq_printf(m, "%08lx %s", vma->vm_start, buffer);
1948
1949         if (file) {
1950                 seq_printf(m, " file=");
1951                 seq_path(m, file->f_path.mnt, file->f_path.dentry, "\n\t= ");
1952         } else if (vma->vm_start <= mm->brk && vma->vm_end >= mm->start_brk) {
1953                 seq_printf(m, " heap");
1954         } else if (vma->vm_start <= mm->start_stack &&
1955                         vma->vm_end >= mm->start_stack) {
1956                 seq_printf(m, " stack");
1957         }
1958
1959         if (is_vm_hugetlb_page(vma)) {
1960                 check_huge_range(vma, vma->vm_start, vma->vm_end, md);
1961                 seq_printf(m, " huge");
1962         } else {
1963                 check_pgd_range(vma, vma->vm_start, vma->vm_end,
1964                                 &node_online_map, MPOL_MF_STATS, md);
1965         }
1966
1967         if (!md->pages)
1968                 goto out;
1969
1970         if (md->anon)
1971                 seq_printf(m," anon=%lu",md->anon);
1972
1973         if (md->dirty)
1974                 seq_printf(m," dirty=%lu",md->dirty);
1975
1976         if (md->pages != md->anon && md->pages != md->dirty)
1977                 seq_printf(m, " mapped=%lu", md->pages);
1978
1979         if (md->mapcount_max > 1)
1980                 seq_printf(m, " mapmax=%lu", md->mapcount_max);
1981
1982         if (md->swapcache)
1983                 seq_printf(m," swapcache=%lu", md->swapcache);
1984
1985         if (md->active < md->pages && !is_vm_hugetlb_page(vma))
1986                 seq_printf(m," active=%lu", md->active);
1987
1988         if (md->writeback)
1989                 seq_printf(m," writeback=%lu", md->writeback);
1990
1991         for_each_online_node(n)
1992                 if (md->node[n])
1993                         seq_printf(m, " N%d=%lu", n, md->node[n]);
1994 out:
1995         seq_putc(m, '\n');
1996         kfree(md);
1997
1998         if (m->count < m->size)
1999                 m->version = (vma != priv->tail_vma) ? vma->vm_start : 0;
2000         return 0;
2001 }
2002