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