Input: dell-wmi - switch to using sparse keymap library

[pandora-kernel.git] / mm / mempolicy.c

diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index 5bc0a96..f969da5 100644 (file)
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -1275,33 +1275,42 @@ SYSCALL_DEFINE4(migrate_pages, pid_t, pid, unsigned long, maxnode,
                const unsigned long __user *, new_nodes)
 {
        const struct cred *cred = current_cred(), *tcred;
-       struct mm_struct *mm;
+       struct mm_struct *mm = NULL;
        struct task_struct *task;
-       nodemask_t old;
-       nodemask_t new;
        nodemask_t task_nodes;
        int err;
+       nodemask_t *old;
+       nodemask_t *new;
+       NODEMASK_SCRATCH(scratch);
+
+       if (!scratch)
+               return -ENOMEM;
+
+       old = &scratch->mask1;
+       new = &scratch->mask2;
 
-       err = get_nodes(&old, old_nodes, maxnode);
+       err = get_nodes(old, old_nodes, maxnode);
        if (err)
-               return err;
+               goto out;
 
-       err = get_nodes(&new, new_nodes, maxnode);
+       err = get_nodes(new, new_nodes, maxnode);
        if (err)
-               return err;
+               goto out;
 
        /* Find the mm_struct */
        read_lock(&tasklist_lock);
        task = pid ? find_task_by_vpid(pid) : current;
        if (!task) {
                read_unlock(&tasklist_lock);
-               return -ESRCH;
+               err = -ESRCH;
+               goto out;
        }
        mm = get_task_mm(task);
        read_unlock(&tasklist_lock);
 
+       err = -EINVAL;
        if (!mm)
-               return -EINVAL;
+               goto out;
 
        /*
         * Check if this process has the right to modify the specified
@@ -1322,12 +1331,12 @@ SYSCALL_DEFINE4(migrate_pages, pid_t, pid, unsigned long, maxnode,
 
        task_nodes = cpuset_mems_allowed(task);
        /* Is the user allowed to access the target nodes? */
-       if (!nodes_subset(new, task_nodes) && !capable(CAP_SYS_NICE)) {
+       if (!nodes_subset(*new, task_nodes) && !capable(CAP_SYS_NICE)) {
                err = -EPERM;
                goto out;
        }
 
-       if (!nodes_subset(new, node_states[N_HIGH_MEMORY])) {
+       if (!nodes_subset(*new, node_states[N_HIGH_MEMORY])) {
                err = -EINVAL;
                goto out;
        }
@@ -1336,10 +1345,13 @@ SYSCALL_DEFINE4(migrate_pages, pid_t, pid, unsigned long, maxnode,
        if (err)
                goto out;
 
-       err = do_migrate_pages(mm, &old, &new,
+       err = do_migrate_pages(mm, old, new,
                capable(CAP_SYS_NICE) ? MPOL_MF_MOVE_ALL : MPOL_MF_MOVE);
 out:
-       mmput(mm);
+       if (mm)
+               mmput(mm);
+       NODEMASK_SCRATCH_FREE(scratch);
+
        return err;
 }
 
@@ -1712,6 +1724,50 @@ bool init_nodemask_of_mempolicy(nodemask_t *mask)
 }
 #endif
 
+/*
+ * mempolicy_nodemask_intersects
+ *
+ * If tsk's mempolicy is "default" [NULL], return 'true' to indicate default
+ * policy.  Otherwise, check for intersection between mask and the policy
+ * nodemask for 'bind' or 'interleave' policy.  For 'perferred' or 'local'
+ * policy, always return true since it may allocate elsewhere on fallback.
+ *
+ * Takes task_lock(tsk) to prevent freeing of its mempolicy.
+ */
+bool mempolicy_nodemask_intersects(struct task_struct *tsk,
+                                       const nodemask_t *mask)
+{
+       struct mempolicy *mempolicy;
+       bool ret = true;
+
+       if (!mask)
+               return ret;
+       task_lock(tsk);
+       mempolicy = tsk->mempolicy;
+       if (!mempolicy)
+               goto out;
+
+       switch (mempolicy->mode) {
+       case MPOL_PREFERRED:
+               /*
+                * MPOL_PREFERRED and MPOL_F_LOCAL are only preferred nodes to
+                * allocate from, they may fallback to other nodes when oom.
+                * Thus, it's possible for tsk to have allocated memory from
+                * nodes in mask.
+                */
+               break;
+       case MPOL_BIND:
+       case MPOL_INTERLEAVE:
+               ret = nodes_intersects(mempolicy->v.nodes, *mask);
+               break;
+       default:
+               BUG();
+       }
+out:
+       task_unlock(tsk);
+       return ret;
+}
+
 /* Allocate a page in interleaved policy.
    Own path because it needs to do special accounting. */
 static struct page *alloc_page_interleave(gfp_t gfp, unsigned order,