4 files changed, 43 insertions, 28 deletions

diff --git a/mm/filemap.c b/mm/filemap.c
index b7b1be6dbd83..5c74b68935ac 100644
--- a/mm/filemap.c
+++ b/mm/filemap.c
@@ -604,7 +604,7 @@ void __lock_page(struct page *page)
 }
 EXPORT_SYMBOL(__lock_page);
 
-int fastcall __lock_page_killable(struct page *page)
+int __lock_page_killable(struct page *page)
 {
         DEFINE_WAIT_BIT(wait, &page->flags, PG_locked);
 
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index d9a380312467..cb1b3a7ecdfc 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -24,14 +24,15 @@
 const unsigned long hugetlb_zero = 0, hugetlb_infinity = ~0UL;
 static unsigned long nr_huge_pages, free_huge_pages, resv_huge_pages;
 static unsigned long surplus_huge_pages;
+static unsigned long nr_overcommit_huge_pages;
 unsigned long max_huge_pages;
+unsigned long sysctl_overcommit_huge_pages;
 static struct list_head hugepage_freelists[MAX_NUMNODES];
 static unsigned int nr_huge_pages_node[MAX_NUMNODES];
 static unsigned int free_huge_pages_node[MAX_NUMNODES];
 static unsigned int surplus_huge_pages_node[MAX_NUMNODES];
 static gfp_t htlb_alloc_mask = GFP_HIGHUSER;
 unsigned long hugepages_treat_as_movable;
-unsigned long nr_overcommit_huge_pages;
 static int hugetlb_next_nid;
 
 /*
@@ -609,8 +610,9 @@ int hugetlb_overcommit_handler(struct ctl_table *table, int write,
                         struct file *file, void __user *buffer,
                         size_t *length, loff_t *ppos)
 {
-        spin_lock(&hugetlb_lock);
         proc_doulongvec_minmax(table, write, file, buffer, length, ppos);
+        spin_lock(&hugetlb_lock);
+        nr_overcommit_huge_pages = sysctl_overcommit_huge_pages;
         spin_unlock(&hugetlb_lock);
         return 0;
 }
diff --git a/mm/memory.c b/mm/memory.c
index e5628a5fd678..717aa0e3be2d 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -989,6 +989,8 @@ int get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
         int i;
         unsigned int vm_flags;
 
+        if (len <= 0)
+                return 0;
         /* 
          * Require read or write permissions.
          * If 'force' is set, we only require the "MAY" flags.
diff --git a/mm/mempolicy.c b/mm/mempolicy.c
index 83c69f8a64c2..8d246c3b340f 100644
--- a/mm/mempolicy.c
+++ b/mm/mempolicy.c
@@ -116,22 +116,51 @@ static void mpol_rebind_policy(struct mempolicy *pol,
 /* Do sanity checking on a policy */
 static int mpol_check_policy(int mode, nodemask_t *nodes)
 {
-        int empty = nodes_empty(*nodes);
+        int was_empty, is_empty;
+
+        if (!nodes)
+                return 0;
+
+        /*
+         * "Contextualize" the in-coming nodemast for cpusets:
+         * Remember whether in-coming nodemask was empty,  If not,
+         * restrict the nodes to the allowed nodes in the cpuset.
+         * This is guaranteed to be a subset of nodes with memory.
+         */
+        cpuset_update_task_memory_state();
+        is_empty = was_empty = nodes_empty(*nodes);
+        if (!was_empty) {
+                nodes_and(*nodes, *nodes, cpuset_current_mems_allowed);
+                is_empty = nodes_empty(*nodes); /* after "contextualization" */
+        }
 
         switch (mode) {
         case MPOL_DEFAULT:
-                if (!empty)
+                /*
+                 * require caller to specify an empty nodemask
+                 * before "contextualization"
+                 */
+                if (!was_empty)
                         return -EINVAL;
                 break;
         case MPOL_BIND:
         case MPOL_INTERLEAVE:
-                /* Preferred will only use the first bit, but allow
-                   more for now. */
-                if (empty)
+                /*
+                 * require at least 1 valid node after "contextualization"
+                 */
+                if (is_empty)
+                        return -EINVAL;
+                break;
+        case MPOL_PREFERRED:
+                /*
+                 * Did caller specify invalid nodes?
+                 * Don't silently accept this as "local allocation".
+                 */
+                if (!was_empty && is_empty)
                         return -EINVAL;
                 break;
         }
-        return nodes_subset(*nodes, node_states[N_HIGH_MEMORY]) ? 0 : -EINVAL;
+        return 0;
 }
 
 /* Generate a custom zonelist for the BIND policy. */
@@ -188,8 +217,6 @@ static struct mempolicy *mpol_new(int mode, nodemask_t *nodes)
         switch (mode) {
         case MPOL_INTERLEAVE:
                 policy->v.nodes = *nodes;
-                nodes_and(policy->v.nodes, policy->v.nodes,
-                                        node_states[N_HIGH_MEMORY]);
                 if (nodes_weight(policy->v.nodes) == 0) {
                         kmem_cache_free(policy_cache, policy);
                         return ERR_PTR(-EINVAL);
@@ -421,18 +448,6 @@ static int mbind_range(struct vm_area_struct *vma, unsigned long start,
         return err;
 }
 
-static int contextualize_policy(int mode, nodemask_t *nodes)
-{
-        if (!nodes)
-                return 0;
-
-        cpuset_update_task_memory_state();
-        if (!cpuset_nodes_subset_current_mems_allowed(*nodes))
-                return -EINVAL;
-        return mpol_check_policy(mode, nodes);
-}
-
-
 /*
  * Update task->flags PF_MEMPOLICY bit: set iff non-default
  * mempolicy.  Allows more rapid checking of this (combined perhaps
@@ -468,7 +483,7 @@ static long do_set_mempolicy(int mode, nodemask_t *nodes)
 {
         struct mempolicy *new;
 
-        if (contextualize_policy(mode, nodes))
+        if (mpol_check_policy(mode, nodes))
                 return -EINVAL;
         new = mpol_new(mode, nodes);
         if (IS_ERR(new))
@@ -915,10 +930,6 @@ asmlinkage long sys_mbind(unsigned long start, unsigned long len,
         err = get_nodes(&nodes, nmask, maxnode);
         if (err)
                 return err;
-#ifdef CONFIG_CPUSETS
-        /* Restrict the nodes to the allowed nodes in the cpuset */
-        nodes_and(nodes, nodes, current->mems_allowed);
-#endif
         return do_mbind(start, len, mode, &nodes, flags);
 }