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