mempolicy: restructure rebinding-mempolicy functions

Nick Piggin reported that the allocator may see an empty nodemask when
changing cpuset's mems[1].  It happens only on the kernel that do not do
atomic nodemask_t stores.  (MAX_NUMNODES > BITS_PER_LONG)

But I found that there is also a problem on the kernel that can do atomic
nodemask_t stores.  The problem is that the allocator can't find a node to
alloc page when changing cpuset's mems though there is a lot of free
memory.  The reason is like this:

(mpol: mempolicy)
	task1			task1's mpol	task2
	alloc page		1
	  alloc on node0? NO	1
				1		change mems from 1 to 0
				1		rebind task1's mpol
				0-1		  set new bits
				0	  	  clear disallowed bits
	  alloc on node1? NO	0
	  ...
	can't alloc page
	  goto oom

I can use the attached program reproduce it by the following step:

# mkdir /dev/cpuset
# mount -t cpuset cpuset /dev/cpuset
# mkdir /dev/cpuset/1
# echo `cat /dev/cpuset/cpus` > /dev/cpuset/1/cpus
# echo `cat /dev/cpuset/mems` > /dev/cpuset/1/mems
# echo $$ > /dev/cpuset/1/tasks
# numactl --membind=`cat /dev/cpuset/mems` ./cpuset_mem_hog <nr_tasks> &
   <nr_tasks> = max(nr_cpus - 1, 1)
# killall -s SIGUSR1 cpuset_mem_hog
# ./change_mems.sh

several hours later, oom will happen though there is a lot of free memory.

This patchset fixes this problem by expanding the nodes range first(set
newly allowed bits) and shrink it lazily(clear newly disallowed bits).  So
we use a variable to tell the write-side task that read-side task is
reading nodemask, and the write-side task clears newly disallowed nodes
after read-side task ends the current memory allocation.

This patch:

In order to fix no node to alloc memory, when we want to update mempolicy
and mems_allowed, we expand the set of nodes first (set all the newly
nodes) and shrink the set of nodes lazily(clean disallowed nodes), But the
mempolicy's rebind functions may breaks the expanding.

So we restructure the mempolicy's rebind functions and split the rebind
work to two steps, just like the update of cpuset's mems: The 1st step:
expand the set of the mempolicy's nodes.  The 2nd step: shrink the set of
the mempolicy's nodes.  It is used when there is no real lock to protect
the mempolicy in the read-side.  Otherwise we can do rebind work at once.

In order to implement it, we define

	enum mpol_rebind_step {
		MPOL_REBIND_ONCE,
		MPOL_REBIND_STEP1,
		MPOL_REBIND_STEP2,
		MPOL_REBIND_NSTEP,
	};

If the mempolicy needn't be updated by two steps, we can pass
MPOL_REBIND_ONCE to the rebind functions.  Or we can pass
MPOL_REBIND_STEP1 to do the first step of the rebind work and pass
MPOL_REBIND_STEP2 to do the second step work.

Besides that, it maybe long time between these two step and we have to
release the lock that protects mempolicy and mems_allowed.  If we hold the
lock once again, we must check whether the current mempolicy is under the
rebinding (the first step has been done) or not, because the task may
alloc a new mempolicy when we don't hold the lock.  So we defined the
following flag to identify it:

#define MPOL_F_REBINDING (1 << 2)

The new functions will be used in the next patch.

Signed-off-by: Miao Xie <miaox@cn.fujitsu.com>
Cc: David Rientjes <rientjes@google.com>
Cc: Nick Piggin <npiggin@suse.de>
Cc: Paul Menage <menage@google.com>
Cc: Lee Schermerhorn <lee.schermerhorn@hp.com>
Cc: Hugh Dickins <hugh.dickins@tiscali.co.uk>
Cc: Ravikiran Thirumalai <kiran@scalex86.org>
Cc: KOSAKI Motohiro <kosaki.motohiro@jp.fujitsu.com>
Cc: Christoph Lameter <cl@linux-foundation.org>
Cc: Andi Kleen <andi@firstfloor.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 105 insertions, 19 deletions

diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index 0c73c8b814c..8a993db8802 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -119,7 +119,22 @@ struct mempolicy default_policy = {
 
 static const struct mempolicy_operations {
         int (*create)(struct mempolicy *pol, const nodemask_t *nodes);
-        void (*rebind)(struct mempolicy *pol, const nodemask_t *nodes);
+        /*
+         * If read-side task has no lock to protect task->mempolicy, write-side
+         * task will rebind the task->mempolicy by two step. The first step is
+         * setting all the newly nodes, and the second step is cleaning all the
+         * disallowed nodes. In this way, we can avoid finding no node to alloc
+         * page.
+         * If we have a lock to protect task->mempolicy in read-side, we do
+         * rebind directly.
+         *
+         * step:
+         *      MPOL_REBIND_ONCE - do rebind work at once
+         *      MPOL_REBIND_STEP1 - set all the newly nodes
+         *      MPOL_REBIND_STEP2 - clean all the disallowed nodes
+         */
+        void (*rebind)(struct mempolicy *pol, const nodemask_t *nodes,
+                        enum mpol_rebind_step step);
 } mpol_ops[MPOL_MAX];
 
 /* Check that the nodemask contains at least one populated zone */
@@ -274,12 +289,19 @@ void __mpol_put(struct mempolicy *p)
         kmem_cache_free(policy_cache, p);
 }
 
-static void mpol_rebind_default(struct mempolicy *pol, const nodemask_t *nodes)
+static void mpol_rebind_default(struct mempolicy *pol, const nodemask_t *nodes,
+                                enum mpol_rebind_step step)
 {
 }
 
-static void mpol_rebind_nodemask(struct mempolicy *pol,
-                                 const nodemask_t *nodes)
+/*
+ * step:
+ *      MPOL_REBIND_ONCE  - do rebind work at once
+ *      MPOL_REBIND_STEP1 - set all the newly nodes
+ *      MPOL_REBIND_STEP2 - clean all the disallowed nodes
+ */
+static void mpol_rebind_nodemask(struct mempolicy *pol, const nodemask_t *nodes,
+                                 enum mpol_rebind_step step)
 {
         nodemask_t tmp;
 
@@ -288,12 +310,31 @@ static void mpol_rebind_nodemask(struct mempolicy *pol,
         else if (pol->flags & MPOL_F_RELATIVE_NODES)
                 mpol_relative_nodemask(&tmp, &pol->w.user_nodemask, nodes);
         else {
-                nodes_remap(tmp, pol->v.nodes, pol->w.cpuset_mems_allowed,
-                            *nodes);
-                pol->w.cpuset_mems_allowed = *nodes;
+                /*
+                 * if step == 1, we use ->w.cpuset_mems_allowed to cache the
+                 * result
+                 */
+                if (step == MPOL_REBIND_ONCE || step == MPOL_REBIND_STEP1) {
+                        nodes_remap(tmp, pol->v.nodes,
+                                        pol->w.cpuset_mems_allowed, *nodes);
+                        pol->w.cpuset_mems_allowed = step ? tmp : *nodes;
+                } else if (step == MPOL_REBIND_STEP2) {
+                        tmp = pol->w.cpuset_mems_allowed;
+                        pol->w.cpuset_mems_allowed = *nodes;
+                } else
+                        BUG();
         }
 
-        pol->v.nodes = tmp;
+        if (nodes_empty(tmp))
+                tmp = *nodes;
+
+        if (step == MPOL_REBIND_STEP1)
+                nodes_or(pol->v.nodes, pol->v.nodes, tmp);
+        else if (step == MPOL_REBIND_ONCE || step == MPOL_REBIND_STEP2)
+                pol->v.nodes = tmp;
+        else
+                BUG();
+
         if (!node_isset(current->il_next, tmp)) {
                 current->il_next = next_node(current->il_next, tmp);
                 if (current->il_next >= MAX_NUMNODES)
@@ -304,7 +345,8 @@ static void mpol_rebind_nodemask(struct mempolicy *pol,
 }
 
 static void mpol_rebind_preferred(struct mempolicy *pol,
-                                  const nodemask_t *nodes)
+                                  const nodemask_t *nodes,
+                                  enum mpol_rebind_step step)
 {
         nodemask_t tmp;
 
@@ -327,16 +369,45 @@ static void mpol_rebind_preferred(struct mempolicy *pol,
         }
 }
 
-/* Migrate a policy to a different set of nodes */
-static void mpol_rebind_policy(struct mempolicy *pol,
-                               const nodemask_t *newmask)
+/*
+ * mpol_rebind_policy - Migrate a policy to a different set of nodes
+ *
+ * If read-side task has no lock to protect task->mempolicy, write-side
+ * task will rebind the task->mempolicy by two step. The first step is
+ * setting all the newly nodes, and the second step is cleaning all the
+ * disallowed nodes. In this way, we can avoid finding no node to alloc
+ * page.
+ * If we have a lock to protect task->mempolicy in read-side, we do
+ * rebind directly.
+ *
+ * step:
+ *      MPOL_REBIND_ONCE  - do rebind work at once
+ *      MPOL_REBIND_STEP1 - set all the newly nodes
+ *      MPOL_REBIND_STEP2 - clean all the disallowed nodes
+ */
+static void mpol_rebind_policy(struct mempolicy *pol, const nodemask_t *newmask,
+                                enum mpol_rebind_step step)
 {
         if (!pol)
                 return;
-        if (!mpol_store_user_nodemask(pol) &&
+        if (!mpol_store_user_nodemask(pol) && step == 0 &&
             nodes_equal(pol->w.cpuset_mems_allowed, *newmask))
                 return;
-        mpol_ops[pol->mode].rebind(pol, newmask);
+
+        if (step == MPOL_REBIND_STEP1 && (pol->flags & MPOL_F_REBINDING))
+                return;
+
+        if (step == MPOL_REBIND_STEP2 && !(pol->flags & MPOL_F_REBINDING))
+                BUG();
+
+        if (step == MPOL_REBIND_STEP1)
+                pol->flags |= MPOL_F_REBINDING;
+        else if (step == MPOL_REBIND_STEP2)
+                pol->flags &= ~MPOL_F_REBINDING;
+        else if (step >= MPOL_REBIND_NSTEP)
+                BUG();
+
+        mpol_ops[pol->mode].rebind(pol, newmask, step);
 }
 
 /*
@@ -346,9 +417,10 @@ static void mpol_rebind_policy(struct mempolicy *pol,
  * Called with task's alloc_lock held.
  */
 
-void mpol_rebind_task(struct task_struct *tsk, const nodemask_t *new)
+void mpol_rebind_task(struct task_struct *tsk, const nodemask_t *new,
+                        enum mpol_rebind_step step)
 {
-        mpol_rebind_policy(tsk->mempolicy, new);
+        mpol_rebind_policy(tsk->mempolicy, new, step);
 }
 
 /*
@@ -363,7 +435,7 @@ void mpol_rebind_mm(struct mm_struct *mm, nodemask_t *new)
 
         down_write(&mm->mmap_sem);
         for (vma = mm->mmap; vma; vma = vma->vm_next)
-                mpol_rebind_policy(vma->vm_policy, new);
+                mpol_rebind_policy(vma->vm_policy, new, MPOL_REBIND_ONCE);
         up_write(&mm->mmap_sem);
 }
 
@@ -1745,6 +1817,9 @@ EXPORT_SYMBOL(alloc_pages_current);
  * with the mems_allowed returned by cpuset_mems_allowed().  This
  * keeps mempolicies cpuset relative after its cpuset moves.  See
  * further kernel/cpuset.c update_nodemask().
+ *
+ * current's mempolicy may be rebinded by the other task(the task that changes
+ * cpuset's mems), so we needn't do rebind work for current task.
  */
 
 /* Slow path of a mempolicy duplicate */
@@ -1754,13 +1829,24 @@ struct mempolicy *__mpol_dup(struct mempolicy *old)
 
         if (!new)
                 return ERR_PTR(-ENOMEM);
+
+        /* task's mempolicy is protected by alloc_lock */
+        if (old == current->mempolicy) {
+                task_lock(current);
+                *new = *old;
+                task_unlock(current);
+        } else
+                *new = *old;
+
         rcu_read_lock();
         if (current_cpuset_is_being_rebound()) {
                 nodemask_t mems = cpuset_mems_allowed(current);
-                mpol_rebind_policy(old, &mems);
+                if (new->flags & MPOL_F_REBINDING)
+                        mpol_rebind_policy(new, &mems, MPOL_REBIND_STEP2);
+                else
+                        mpol_rebind_policy(new, &mems, MPOL_REBIND_ONCE);
         }
         rcu_read_unlock();
-        *new = *old;
         atomic_set(&new->refcnt, 1);
         return new;
 }