Merge branch 'linus' into irq/threaded

Conflicts:
	include/linux/irq.h
	kernel/irq/handle.c

1 files changed, 119 insertions, 135 deletions

diff --git a/kernel/cpuset.c b/kernel/cpuset.c
index f76db9dcaa0..026faccca86 100644
--- a/kernel/cpuset.c
+++ b/kernel/cpuset.c
@@ -128,10 +128,6 @@ static inline struct cpuset *task_cs(struct task_struct *task)
         return container_of(task_subsys_state(task, cpuset_subsys_id),
                             struct cpuset, css);
 }
-struct cpuset_hotplug_scanner {
-        struct cgroup_scanner scan;
-        struct cgroup *to;
-};
 
 /* bits in struct cpuset flags field */
 typedef enum {
@@ -521,6 +517,7 @@ static int validate_change(const struct cpuset *cur, const struct cpuset *trial)
         return 0;
 }
 
+#ifdef CONFIG_SMP
 /*
  * Helper routine for generate_sched_domains().
  * Do cpusets a, b have overlapping cpus_allowed masks?
@@ -815,6 +812,18 @@ static void do_rebuild_sched_domains(struct work_struct *unused)
 
         put_online_cpus();
 }
+#else /* !CONFIG_SMP */
+static void do_rebuild_sched_domains(struct work_struct *unused)
+{
+}
+
+static int generate_sched_domains(struct cpumask **domains,
+                        struct sched_domain_attr **attributes)
+{
+        *domains = NULL;
+        return 1;
+}
+#endif /* CONFIG_SMP */
 
 static DECLARE_WORK(rebuild_sched_domains_work, do_rebuild_sched_domains);
 
@@ -1026,101 +1035,70 @@ static void cpuset_migrate_mm(struct mm_struct *mm, const nodemask_t *from,
         mutex_unlock(&callback_mutex);
 }
 
+/*
+ * Rebind task's vmas to cpuset's new mems_allowed, and migrate pages to new
+ * nodes if memory_migrate flag is set. Called with cgroup_mutex held.
+ */
+static void cpuset_change_nodemask(struct task_struct *p,
+                                   struct cgroup_scanner *scan)
+{
+        struct mm_struct *mm;
+        struct cpuset *cs;
+        int migrate;
+        const nodemask_t *oldmem = scan->data;
+
+        mm = get_task_mm(p);
+        if (!mm)
+                return;
+
+        cs = cgroup_cs(scan->cg);
+        migrate = is_memory_migrate(cs);
+
+        mpol_rebind_mm(mm, &cs->mems_allowed);
+        if (migrate)
+                cpuset_migrate_mm(mm, oldmem, &cs->mems_allowed);
+        mmput(mm);
+}
+
 static void *cpuset_being_rebound;
 
 /**
  * update_tasks_nodemask - Update the nodemasks of tasks in the cpuset.
  * @cs: the cpuset in which each task's mems_allowed mask needs to be changed
  * @oldmem: old mems_allowed of cpuset cs
+ * @heap: if NULL, defer allocating heap memory to cgroup_scan_tasks()
  *
  * Called with cgroup_mutex held
- * Return 0 if successful, -errno if not.
+ * No return value. It's guaranteed that cgroup_scan_tasks() always returns 0
+ * if @heap != NULL.
  */
-static int update_tasks_nodemask(struct cpuset *cs, const nodemask_t *oldmem)
+static void update_tasks_nodemask(struct cpuset *cs, const nodemask_t *oldmem,
+                                 struct ptr_heap *heap)
 {
-        struct task_struct *p;
-        struct mm_struct **mmarray;
-        int i, n, ntasks;
-        int migrate;
-        int fudge;
-        struct cgroup_iter it;
-        int retval;
+        struct cgroup_scanner scan;
 
         cpuset_being_rebound = cs;              /* causes mpol_dup() rebind */
 
-        fudge = 10;                             /* spare mmarray[] slots */
-        fudge += cpumask_weight(cs->cpus_allowed);/* imagine 1 fork-bomb/cpu */
-        retval = -ENOMEM;
-
-        /*
-         * Allocate mmarray[] to hold mm reference for each task
-         * in cpuset cs.  Can't kmalloc GFP_KERNEL while holding
-         * tasklist_lock.  We could use GFP_ATOMIC, but with a
-         * few more lines of code, we can retry until we get a big
-         * enough mmarray[] w/o using GFP_ATOMIC.
-         */
-        while (1) {
-                ntasks = cgroup_task_count(cs->css.cgroup);  /* guess */
-                ntasks += fudge;
-                mmarray = kmalloc(ntasks * sizeof(*mmarray), GFP_KERNEL);
-                if (!mmarray)
-                        goto done;
-                read_lock(&tasklist_lock);              /* block fork */
-                if (cgroup_task_count(cs->css.cgroup) <= ntasks)
-                        break;                          /* got enough */
-                read_unlock(&tasklist_lock);            /* try again */
-                kfree(mmarray);
-        }
-
-        n = 0;
-
-        /* Load up mmarray[] with mm reference for each task in cpuset. */
-        cgroup_iter_start(cs->css.cgroup, &it);
-        while ((p = cgroup_iter_next(cs->css.cgroup, &it))) {
-                struct mm_struct *mm;
-
-                if (n >= ntasks) {
-                        printk(KERN_WARNING
-                                "Cpuset mempolicy rebind incomplete.\n");
-                        break;
-                }
-                mm = get_task_mm(p);
-                if (!mm)
-                        continue;
-                mmarray[n++] = mm;
-        }
-        cgroup_iter_end(cs->css.cgroup, &it);
-        read_unlock(&tasklist_lock);
+        scan.cg = cs->css.cgroup;
+        scan.test_task = NULL;
+        scan.process_task = cpuset_change_nodemask;
+        scan.heap = heap;
+        scan.data = (nodemask_t *)oldmem;
 
         /*
-         * Now that we've dropped the tasklist spinlock, we can
-         * rebind the vma mempolicies of each mm in mmarray[] to their
-         * new cpuset, and release that mm.  The mpol_rebind_mm()
-         * call takes mmap_sem, which we couldn't take while holding
-         * tasklist_lock.  Forks can happen again now - the mpol_dup()
-         * cpuset_being_rebound check will catch such forks, and rebind
-         * their vma mempolicies too.  Because we still hold the global
-         * cgroup_mutex, we know that no other rebind effort will
-         * be contending for the global variable cpuset_being_rebound.
+         * The mpol_rebind_mm() call takes mmap_sem, which we couldn't
+         * take while holding tasklist_lock.  Forks can happen - the
+         * mpol_dup() cpuset_being_rebound check will catch such forks,
+         * and rebind their vma mempolicies too.  Because we still hold
+         * the global cgroup_mutex, we know that no other rebind effort
+         * will be contending for the global variable cpuset_being_rebound.
          * It's ok if we rebind the same mm twice; mpol_rebind_mm()
          * is idempotent.  Also migrate pages in each mm to new nodes.
          */
-        migrate = is_memory_migrate(cs);
-        for (i = 0; i < n; i++) {
-                struct mm_struct *mm = mmarray[i];
-
-                mpol_rebind_mm(mm, &cs->mems_allowed);
-                if (migrate)
-                        cpuset_migrate_mm(mm, oldmem, &cs->mems_allowed);
-                mmput(mm);
-        }
+        cgroup_scan_tasks(&scan);
 
         /* We're done rebinding vmas to this cpuset's new mems_allowed. */
-        kfree(mmarray);
         cpuset_being_rebound = NULL;
-        retval = 0;
-done:
-        return retval;
 }
 
 /*
@@ -1141,6 +1119,7 @@ static int update_nodemask(struct cpuset *cs, struct cpuset *trialcs,
 {
         nodemask_t oldmem;
         int retval;
+        struct ptr_heap heap;
 
         /*
          * top_cpuset.mems_allowed tracks node_stats[N_HIGH_MEMORY];
@@ -1175,12 +1154,18 @@ static int update_nodemask(struct cpuset *cs, struct cpuset *trialcs,