Merge branch 'linus' into cpus4096

6 files changed, 135 insertions, 60 deletions

diff --git a/kernel/Makefile b/kernel/Makefile
index 2921d90ce32f..2aebc4cd7878 100644
--- a/kernel/Makefile
+++ b/kernel/Makefile
@@ -40,7 +40,11 @@ obj-$(CONFIG_RT_MUTEXES) += rtmutex.o
 obj-$(CONFIG_DEBUG_RT_MUTEXES) += rtmutex-debug.o
 obj-$(CONFIG_RT_MUTEX_TESTER) += rtmutex-tester.o
 obj-$(CONFIG_GENERIC_ISA_DMA) += dma.o
-obj-$(CONFIG_USE_GENERIC_SMP_HELPERS) += smp.o
+ifeq ($(CONFIG_USE_GENERIC_SMP_HELPERS),y)
+obj-y += smp.o
+else
+obj-y += up.o
+endif
 obj-$(CONFIG_SMP) += spinlock.o
 obj-$(CONFIG_DEBUG_SPINLOCK) += spinlock.o
 obj-$(CONFIG_PROVE_LOCKING) += spinlock.o
diff --git a/kernel/async.c b/kernel/async.c
index f286e9f2b736..608b32b42812 100644
--- a/kernel/async.c
+++ b/kernel/async.c
@@ -90,12 +90,12 @@ extern int initcall_debug;
 static async_cookie_t  __lowest_in_progress(struct list_head *running)
 {
         struct async_entry *entry;
-        if (!list_empty(&async_pending)) {
-                entry = list_first_entry(&async_pending,
+        if (!list_empty(running)) {
+                entry = list_first_entry(running,
                         struct async_entry, list);
                 return entry->cookie;
-        } else if (!list_empty(running)) {
-                entry = list_first_entry(running,
+        } else if (!list_empty(&async_pending)) {
+                entry = list_first_entry(&async_pending,
                         struct async_entry, list);
                 return entry->cookie;
         } else {
@@ -104,6 +104,17 @@ static async_cookie_t  __lowest_in_progress(struct list_head *running)
         }
 
 }
+
+static async_cookie_t  lowest_in_progress(struct list_head *running)
+{
+        unsigned long flags;
+        async_cookie_t ret;
+
+        spin_lock_irqsave(&async_lock, flags);
+        ret = __lowest_in_progress(running);
+        spin_unlock_irqrestore(&async_lock, flags);
+        return ret;
+}
 /*
  * pick the first pending entry and run it
  */
@@ -229,7 +240,7 @@ void async_synchronize_cookie_special(async_cookie_t cookie, struct list_head *r
                 starttime = ktime_get();
         }
 
-        wait_event(async_done, __lowest_in_progress(running) >= cookie);
+        wait_event(async_done, lowest_in_progress(running) >= cookie);
 
         if (initcall_debug && system_state == SYSTEM_BOOTING) {
                 endtime = ktime_get();
diff --git a/kernel/rcutorture.c b/kernel/rcutorture.c
index 1cff28db56b6..7c4142a79f0a 100644
--- a/kernel/rcutorture.c
+++ b/kernel/rcutorture.c
@@ -136,29 +136,47 @@ static int stutter_pause_test = 0;
 #endif
 int rcutorture_runnable = RCUTORTURE_RUNNABLE_INIT;
 
-#define FULLSTOP_SHUTDOWN 1     /* Bail due to system shutdown/panic. */
-#define FULLSTOP_CLEANUP  2     /* Orderly shutdown. */
-static int fullstop;            /* stop generating callbacks at test end. */
-DEFINE_MUTEX(fullstop_mutex);   /* protect fullstop transitions and */
-                                /*  spawning of kthreads. */
+/* Mediate rmmod and system shutdown.  Concurrent rmmod & shutdown illegal! */
+
+#define FULLSTOP_DONTSTOP 0     /* Normal operation. */
+#define FULLSTOP_SHUTDOWN 1     /* System shutdown with rcutorture running. */
+#define FULLSTOP_RMMOD    2     /* Normal rmmod of rcutorture. */
+static int fullstop = FULLSTOP_RMMOD;
+DEFINE_MUTEX(fullstop_mutex);   /* Protect fullstop transitions and spawning */
+                                /*  of kthreads. */
 
 /*
- * Detect and respond to a signal-based shutdown.
+ * Detect and respond to a system shutdown.
  */
 static int
 rcutorture_shutdown_notify(struct notifier_block *unused1,
                            unsigned long unused2, void *unused3)
 {
-        if (fullstop)
-                return NOTIFY_DONE;
         mutex_lock(&fullstop_mutex);
-        if (!fullstop)
+        if (fullstop == FULLSTOP_DONTSTOP)
                 fullstop = FULLSTOP_SHUTDOWN;
+        else
+                printk(KERN_WARNING /* but going down anyway, so... */
+                       "Concurrent 'rmmod rcutorture' and shutdown illegal!\n");
         mutex_unlock(&fullstop_mutex);
         return NOTIFY_DONE;
 }
 
 /*
+ * Absorb kthreads into a kernel function that won't return, so that
+ * they won't ever access module text or data again.
+ */
+static void rcutorture_shutdown_absorb(char *title)
+{
+        if (ACCESS_ONCE(fullstop) == FULLSTOP_SHUTDOWN) {
+                printk(KERN_NOTICE
+                       "rcutorture thread %s parking due to system shutdown\n",
+                       title);
+                schedule_timeout_uninterruptible(MAX_SCHEDULE_TIMEOUT);
+        }
+}
+
+/*
  * Allocate an element from the rcu_tortures pool.
  */
 static struct rcu_torture *
@@ -219,13 +237,14 @@ rcu_random(struct rcu_random_state *rrsp)
 }
 
 static void
-rcu_stutter_wait(void)
+rcu_stutter_wait(char *title)
 {
-        while ((stutter_pause_test || !rcutorture_runnable) && !fullstop) {
+        while (stutter_pause_test || !rcutorture_runnable) {
                 if (rcutorture_runnable)
                         schedule_timeout_interruptible(1);
                 else
                         schedule_timeout_interruptible(round_jiffies_relative(HZ));
+                rcutorture_shutdown_absorb(title);
         }
 }
 
@@ -287,7 +306,7 @@ rcu_torture_cb(struct rcu_head *p)
         int i;
         struct rcu_torture *rp = container_of(p, struct rcu_torture, rtort_rcu);
 
-        if (fullstop) {
+        if (fullstop != FULLSTOP_DONTSTOP) {
                 /* Test is ending, just drop callbacks on the floor. */
                 /* The next initialization will pick up the pieces. */
                 return;
@@ -619,10 +638,11 @@ rcu_torture_writer(void *arg)
                 }
                 rcu_torture_current_version++;
                 oldbatch = cur_ops->completed();
-                rcu_stutter_wait();
-        } while (!kthread_should_stop() && !fullstop);
+                rcu_stutter_wait("rcu_torture_writer");
+        } while (!kthread_should_stop() && fullstop == FULLSTOP_DONTSTOP);
         VERBOSE_PRINTK_STRING("rcu_torture_writer task stopping");
-        while (!kthread_should_stop() && fullstop != FULLSTOP_SHUTDOWN)
+        rcutorture_shutdown_absorb("rcu_torture_writer");
+        while (!kthread_should_stop())
                 schedule_timeout_uninterruptible(1);
         return 0;
 }
@@ -643,11 +663,12 @@ rcu_torture_fakewriter(void *arg)
                 schedule_timeout_uninterruptible(1 + rcu_random(&rand)%10);
                 udelay(rcu_random(&rand) & 0x3ff);
                 cur_ops->sync();
-                rcu_stutter_wait();
-        } while (!kthread_should_stop() && !fullstop);
+                rcu_stutter_wait("rcu_torture_fakewriter");
+        } while (!kthread_should_stop() && fullstop == FULLSTOP_DONTSTOP);
 
         VERBOSE_PRINTK_STRING("rcu_torture_fakewriter task stopping");
-        while (!kthread_should_stop() && fullstop != FULLSTOP_SHUTDOWN)
+        rcutorture_shutdown_absorb("rcu_torture_fakewriter");
+        while (!kthread_should_stop())
                 schedule_timeout_uninterruptible(1);
         return 0;
 }
@@ -752,12 +773,13 @@ rcu_torture_reader(void *arg)
                 preempt_enable();
                 cur_ops->readunlock(idx);
                 schedule();
-                rcu_stutter_wait();
-        } while (!kthread_should_stop() && !fullstop);
+                rcu_stutter_wait("rcu_torture_reader");
+        } while (!kthread_should_stop() && fullstop == FULLSTOP_DONTSTOP);
         VERBOSE_PRINTK_STRING("rcu_torture_reader task stopping");
+        rcutorture_shutdown_absorb("rcu_torture_reader");
         if (irqreader && cur_ops->irqcapable)
                 del_timer_sync(&t);
-        while (!kthread_should_stop() && fullstop != FULLSTOP_SHUTDOWN)
+        while (!kthread_should_stop())
                 schedule_timeout_uninterruptible(1);
         return 0;
 }
@@ -854,7 +876,8 @@ rcu_torture_stats(void *arg)
         do {
                 schedule_timeout_interruptible(stat_interval * HZ);
                 rcu_torture_stats_print();
-        } while (!kthread_should_stop() && !fullstop);
+                rcutorture_shutdown_absorb("rcu_torture_stats");
+        } while (!kthread_should_stop());
         VERBOSE_PRINTK_STRING("rcu_torture_stats task stopping");
         return 0;
 }
@@ -866,52 +889,49 @@ static int rcu_idle_cpu;	/* Force all torture tasks off this CPU */
  */
 static void rcu_torture_shuffle_tasks(void)
 {
-        cpumask_var_t tmp_mask;
+        cpumask_t tmp_mask;
         int i;
 
-        if (!alloc_cpumask_var(&tmp_mask, GFP_KERNEL))
-                BUG();
-
-        cpumask_setall(tmp_mask);
+        cpus_setall(tmp_mask);
         get_online_cpus();
 
         /* No point in shuffling if there is only one online CPU (ex: UP) */
-        if (num_online_cpus() == 1)
-                goto out;
+        if (num_online_cpus() == 1) {
+                put_online_cpus();
+                return;
+        }
 
         if (rcu_idle_cpu != -1)
-                cpumask_clear_cpu(rcu_idle_cpu, tmp_mask);
+                cpu_clear(rcu_idle_cpu, tmp_mask);
 
-        set_cpus_allowed_ptr(current, tmp_mask);
+        set_cpus_allowed_ptr(current, &tmp_mask);
 
         if (reader_tasks) {
                 for (i = 0; i < nrealreaders; i++)
                         if (reader_tasks[i])
                                 set_cpus_allowed_ptr(reader_tasks[i],
-                                                     tmp_mask);
+                                                     &tmp_mask);
         }
 
         if (fakewriter_tasks) {
                 for (i = 0; i < nfakewriters; i++)
                         if (fakewriter_tasks[i])
                                 set_cpus_allowed_ptr(fakewriter_tasks[i],
-                                                     tmp_mask);
+                                                     &tmp_mask);
         }
 
         if (writer_task)
-                set_cpus_allowed_ptr(writer_task, tmp_mask);
+                set_cpus_allowed_ptr(writer_task, &tmp_mask);
 
         if (stats_task)
-                set_cpus_allowed_ptr(stats_task, tmp_mask);
+                set_cpus_allowed_ptr(stats_task, &tmp_mask);
 
         if (rcu_idle_cpu == -1)
                 rcu_idle_cpu = num_online_cpus() - 1;
         else
                 rcu_idle_cpu--;
 
-out:
         put_online_cpus();
-        free_cpumask_var(tmp_mask);
 }
 
 /* Shuffle tasks across CPUs, with the intent of allowing each CPU in the
@@ -925,7 +945,8 @@ rcu_torture_shuffle(void *arg)
         do {
                 schedule_timeout_interruptible(shuffle_interval * HZ);
                 rcu_torture_shuffle_tasks();
-        } while (!kthread_should_stop() && !fullstop);
+                rcutorture_shutdown_absorb("rcu_torture_shuffle");
+        } while (!kthread_should_stop());
         VERBOSE_PRINTK_STRING("rcu_torture_shuffle task stopping");
         return 0;
 }
@@ -940,10 +961,11 @@ rcu_torture_stutter(void *arg)
         do {
                 schedule_timeout_interruptible(stutter * HZ);
                 stutter_pause_test = 1;
-                if (!kthread_should_stop() && !fullstop)
+                if (!kthread_should_stop())
                         schedule_timeout_interruptible(stutter * HZ);
                 stutter_pause_test = 0;
-        } while (!kthread_should_stop() && !fullstop);
+                rcutorture_shutdown_absorb("rcu_torture_stutter");
+        } while (!kthread_should_stop());
         VERBOSE_PRINTK_STRING("rcu_torture_stutter task stopping");
         return 0;
 }
@@ -970,15 +992,16 @@ rcu_torture_cleanup(void)
         int i;
 
         mutex_lock(&fullstop_mutex);
-        if (!fullstop) {
-                /* If being signaled, let it happen, then exit. */
+        if (fullstop == FULLSTOP_SHUTDOWN) {
+                printk(KERN_WARNING /* but going down anyway, so... */
+                       "Concurrent 'rmmod rcutorture' and shutdown illegal!\n");
                 mutex_unlock(&fullstop_mutex);
-                schedule_timeout_interruptible(10 * HZ);
+                schedule_timeout_uninterruptible(10);
                 if (cur_ops->cb_barrier != NULL)
                         cur_ops->cb_barrier();
                 return;
         }
-        fullstop = FULLSTOP_CLEANUP;
+        fullstop = FULLSTOP_RMMOD;
         mutex_unlock(&fullstop_mutex);
         unregister_reboot_notifier(&rcutorture_nb);
         if (stutter_task) {
@@ -1078,7 +1101,7 @@ rcu_torture_init(void)
         else
                 nrealreaders = 2 * num_online_cpus();
         rcu_torture_print_module_parms("Start of test");
-        fullstop = 0;
+        fullstop = FULLSTOP_DONTSTOP;
 
         /* Set up the freelist. */
 
diff --git a/kernel/sched.c b/kernel/sched.c
index deb5ac8c12f3..8be2c13b50d0 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -125,6 +125,9 @@ DEFINE_TRACE(sched_switch);
 DEFINE_TRACE(sched_migrate_task);
 
 #ifdef CONFIG_SMP
+
+static void double_rq_lock(struct rq *rq1, struct rq *rq2);
+
 /*
  * Divide a load by a sched group cpu_power : (load / sg->__cpu_power)
  * Since cpu_power is a 'constant', we can use a reciprocal divide.
@@ -7282,10 +7285,10 @@ cpu_to_phys_group(int cpu, const struct cpumask *cpu_map,
  * groups, so roll our own. Now each node has its own list of groups which
  * gets dynamically allocated.
  */
-static DEFINE_PER_CPU(struct sched_domain, node_domains);
+static DEFINE_PER_CPU(struct static_sched_domain, node_domains);
 static struct sched_group ***sched_group_nodes_bycpu;
 
-static DEFINE_PER_CPU(struct sched_domain, allnodes_domains);
+static DEFINE_PER_CPU(struct static_sched_domain, allnodes_domains);
 static DEFINE_PER_CPU(struct static_sched_group, sched_group_allnodes);
 
 static int cpu_to_allnodes_group(int cpu, const struct cpumask *cpu_map,
@@ -7560,7 +7563,7 @@ static int __build_sched_domains(const struct cpumask *cpu_map,
 #ifdef CONFIG_NUMA
                 if (cpumask_weight(cpu_map) >
                                 SD_NODES_PER_DOMAIN*cpumask_weight(nodemask)) {
-                        sd = &per_cpu(allnodes_domains, i);
+                        sd = &per_cpu(allnodes_domains, i).sd;
                         SD_INIT(sd, ALLNODES);
                         set_domain_attribute(sd, attr);
                         cpumask_copy(sched_domain_span(sd), cpu_map);
@@ -7570,7 +7573,7 @@ static int __build_sched_domains(const struct cpumask *cpu_map,
                 } else
                         p = NULL;
 
-                sd = &per_cpu(node_domains, i);
+                sd = &per_cpu(node_domains, i).sd;
                 SD_INIT(sd, NODE);
                 set_domain_attribute(sd, attr);
                 sched_domain_node_span(cpu_to_node(i), sched_domain_span(sd));
@@ -7688,7 +7691,7 @@ static int __build_sched_domains(const struct cpumask *cpu_map,
                 for_each_cpu(j, nodemask) {
                         struct sched_domain *sd;
 
-                        sd = &per_cpu(node_domains, j);
+                        sd = &per_cpu(node_domains, j).sd;
                         sd->groups = sg;
                 }
                 sg->__cpu_power = 0;
diff --git a/kernel/sched_debug.c b/kernel/sched_debug.c
index 4293cfa9681d..16eeba4e4169 100644
--- a/kernel/sched_debug.c
+++ b/kernel/sched_debug.c
@@ -145,6 +145,19 @@ static void print_rq(struct seq_file *m, struct rq *rq, int rq_cpu)
         read_unlock_irqrestore(&tasklist_lock, flags);
 }
 
+#if defined(CONFIG_CGROUP_SCHED) && \
+        (defined(CONFIG_FAIR_GROUP_SCHED) || defined(CONFIG_RT_GROUP_SCHED))
+static void task_group_path(struct task_group *tg, char *buf, int buflen)
+{
+        /* may be NULL if the underlying cgroup isn't fully-created yet */
+        if (!tg->css.cgroup) {
+                buf[0] = '\0';
+                return;
+        }
+        cgroup_path(tg->css.cgroup, buf, buflen);
+}
+#endif
+
 void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
 {
         s64 MIN_vruntime = -1, min_vruntime, max_vruntime = -1,
@@ -154,10 +167,10 @@ void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
         unsigned long flags;
 
 #if defined(CONFIG_CGROUP_SCHED) && defined(CONFIG_FAIR_GROUP_SCHED)
-        char path[128] = "";
+        char path[128];
         struct task_group *tg = cfs_rq->tg;
 
-        cgroup_path(tg->css.cgroup, path, sizeof(path));
+        task_group_path(tg, path, sizeof(path));
 
         SEQ_printf(m, "\ncfs_rq[%d]:%s\n", cpu, path);
 #elif defined(CONFIG_USER_SCHED) && defined(CONFIG_FAIR_GROUP_SCHED)
@@ -208,10 +221,10 @@ void print_cfs_rq(struct seq_file *m, int cpu, struct cfs_rq *cfs_rq)
 void print_rt_rq(struct seq_file *m, int cpu, struct rt_rq *rt_rq)
 {
 #if defined(CONFIG_CGROUP_SCHED) && defined(CONFIG_RT_GROUP_SCHED)
-        char path[128] = "";
+        char path[128];
         struct task_group *tg = rt_rq->tg;
 
-        cgroup_path(tg->css.cgroup, path, sizeof(path));
+        task_group_path(tg, path, sizeof(path));
 
         SEQ_printf(m, "\nrt_rq[%d]:%s\n", cpu, path);
 #else
diff --git a/kernel/up.c b/kernel/up.c
new file mode 100644
index 000000000000..1ff27a28bb7d
--- /dev/null
+++ b/kernel/up.c
@@ -0,0 +1,21 @@
+/*
+ * Uniprocessor-only support functions.  The counterpart to kernel/smp.c
+ */
+
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/smp.h>
+
+int smp_call_function_single(int cpu, void (*func) (void *info), void *info,
+                                int wait)
+{
+        WARN_ON(cpu != 0);
+
+        local_irq_disable();
+        (func)(info);
+        local_irq_enable();
+
+        return 0;
+}
+EXPORT_SYMBOL(smp_call_function_single);