1 files changed, 69 insertions, 43 deletions

diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index 3cec080faa23..643f66e10187 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -563,24 +563,50 @@ static int policy_vma(struct vm_area_struct *vma, struct mempolicy *new)
 }
 
 /* Step 2: apply policy to a range and do splits. */
-static int mbind_range(struct vm_area_struct *vma, unsigned long start,
-                       unsigned long end, struct mempolicy *new)
+static int mbind_range(struct mm_struct *mm, unsigned long start,
+                       unsigned long end, struct mempolicy *new_pol)
 {
         struct vm_area_struct *next;
-        int err;
+        struct vm_area_struct *prev;
+        struct vm_area_struct *vma;
+        int err = 0;
+        pgoff_t pgoff;
+        unsigned long vmstart;
+        unsigned long vmend;
 
-        err = 0;
-        for (; vma && vma->vm_start < end; vma = next) {
+        vma = find_vma_prev(mm, start, &prev);
+        if (!vma || vma->vm_start > start)
+                return -EFAULT;
+
+        for (; vma && vma->vm_start < end; prev = vma, vma = next) {
                 next = vma->vm_next;
-                if (vma->vm_start < start)
-                        err = split_vma(vma->vm_mm, vma, start, 1);
-                if (!err && vma->vm_end > end)
-                        err = split_vma(vma->vm_mm, vma, end, 0);
-                if (!err)
-                        err = policy_vma(vma, new);
+                vmstart = max(start, vma->vm_start);
+                vmend   = min(end, vma->vm_end);
+
+                pgoff = vma->vm_pgoff + ((start - vma->vm_start) >> PAGE_SHIFT);
+                prev = vma_merge(mm, prev, vmstart, vmend, vma->vm_flags,
+                                  vma->anon_vma, vma->vm_file, pgoff, new_pol);
+                if (prev) {
+                        vma = prev;
+                        next = vma->vm_next;
+                        continue;
+                }
+                if (vma->vm_start != vmstart) {
+                        err = split_vma(vma->vm_mm, vma, vmstart, 1);
+                        if (err)
+                                goto out;
+                }
+                if (vma->vm_end != vmend) {
+                        err = split_vma(vma->vm_mm, vma, vmend, 0);
+                        if (err)
+                                goto out;
+                }
+                err = policy_vma(vma, new_pol);
                 if (err)
-                        break;
+                        goto out;
         }
+
+ out:
         return err;
 }
 
@@ -862,36 +888,36 @@ int do_migrate_pages(struct mm_struct *mm,
         if (err)
                 goto out;
 
-/*
- * Find a 'source' bit set in 'tmp' whose corresponding 'dest'
- * bit in 'to' is not also set in 'tmp'.  Clear the found 'source'
- * bit in 'tmp', and return that <source, dest> pair for migration.
- * The pair of nodemasks 'to' and 'from' define the map.
- *
- * If no pair of bits is found that way, fallback to picking some
- * pair of 'source' and 'dest' bits that are not the same.  If the
- * 'source' and 'dest' bits are the same, this represents a node
- * that will be migrating to itself, so no pages need move.
- *
- * If no bits are left in 'tmp', or if all remaining bits left
- * in 'tmp' correspond to the same bit in 'to', return false
- * (nothing left to migrate).
- *
- * This lets us pick a pair of nodes to migrate between, such that
- * if possible the dest node is not already occupied by some other
- * source node, minimizing the risk of overloading the memory on a
- * node that would happen if we migrated incoming memory to a node
- * before migrating outgoing memory source that same node.
- *
- * A single scan of tmp is sufficient.  As we go, we remember the
- * most recent <s, d> pair that moved (s != d).  If we find a pair
- * that not only moved, but what's better, moved to an empty slot
- * (d is not set in tmp), then we break out then, with that pair.
- * Otherwise when we finish scannng from_tmp, we at least have the
- * most recent <s, d> pair that moved.  If we get all the way through
- * the scan of tmp without finding any node that moved, much less
- * moved to an empty node, then there is nothing left worth migrating.
- */
+        /*
+         * Find a 'source' bit set in 'tmp' whose corresponding 'dest'
+         * bit in 'to' is not also set in 'tmp'.  Clear the found 'source'
+         * bit in 'tmp', and return that <source, dest> pair for migration.
+         * The pair of nodemasks 'to' and 'from' define the map.
+         *
+         * If no pair of bits is found that way, fallback to picking some
+         * pair of 'source' and 'dest' bits that are not the same.  If the
+         * 'source' and 'dest' bits are the same, this represents a node
+         * that will be migrating to itself, so no pages need move.
+         *
+         * If no bits are left in 'tmp', or if all remaining bits left
+         * in 'tmp' correspond to the same bit in 'to', return false
+         * (nothing left to migrate).
+         *
+         * This lets us pick a pair of nodes to migrate between, such that
+         * if possible the dest node is not already occupied by some other
+         * source node, minimizing the risk of overloading the memory on a
+         * node that would happen if we migrated incoming memory to a node
+         * before migrating outgoing memory source that same node.
+         *
+         * A single scan of tmp is sufficient.  As we go, we remember the
+         * most recent <s, d> pair that moved (s != d).  If we find a pair
+         * that not only moved, but what's better, moved to an empty slot
+         * (d is not set in tmp), then we break out then, with that pair.
+         * Otherwise when we finish scannng from_tmp, we at least have the
+         * most recent <s, d> pair that moved.  If we get all the way through
+         * the scan of tmp without finding any node that moved, much less
+         * moved to an empty node, then there is nothing left worth migrating.
+         */
 
         tmp = *from_nodes;
         while (!nodes_empty(tmp)) {
@@ -1047,7 +1073,7 @@ static long do_mbind(unsigned long start, unsigned long len,
         if (!IS_ERR(vma)) {
                 int nr_failed = 0;
 
-                err = mbind_range(vma, start, end, new);
+                err = mbind_range(mm, start, end, new);
 
                 if (!list_empty(&pagelist))
                         nr_failed = migrate_pages(&pagelist, new_vma_page,