1 files changed, 34 insertions, 6 deletions

diff --git a/kernel/workqueue.c b/kernel/workqueue.c
index 2bd5aee1c736..82c4fa70595c 100644
--- a/kernel/workqueue.c
+++ b/kernel/workqueue.c
@@ -29,7 +29,8 @@
 #include <linux/kthread.h>
 
 /*
- * The per-CPU workqueue (if single thread, we always use cpu 0's).
+ * The per-CPU workqueue (if single thread, we always use the first
+ * possible cpu).
  *
  * The sequence counters are for flush_scheduled_work().  It wants to wait
  * until until all currently-scheduled works are completed, but it doesn't
@@ -69,6 +70,8 @@ struct workqueue_struct {
 static DEFINE_SPINLOCK(workqueue_lock);
 static LIST_HEAD(workqueues);
 
+static int singlethread_cpu;
+
 /* If it's single threaded, it isn't in the list of workqueues. */
 static inline int is_single_threaded(struct workqueue_struct *wq)
 {
@@ -102,7 +105,7 @@ int fastcall queue_work(struct workqueue_struct *wq, struct work_struct *work)
 
         if (!test_and_set_bit(0, &work->pending)) {
                 if (unlikely(is_single_threaded(wq)))
-                        cpu = any_online_cpu(cpu_online_map);
+                        cpu = singlethread_cpu;
                 BUG_ON(!list_empty(&work->entry));
                 __queue_work(per_cpu_ptr(wq->cpu_wq, cpu), work);
                 ret = 1;
@@ -118,7 +121,7 @@ static void delayed_work_timer_fn(unsigned long __data)
         int cpu = smp_processor_id();
 
         if (unlikely(is_single_threaded(wq)))
-                cpu = any_online_cpu(cpu_online_map);
+                cpu = singlethread_cpu;
 
         __queue_work(per_cpu_ptr(wq->cpu_wq, cpu), work);
 }
@@ -267,7 +270,7 @@ void fastcall flush_workqueue(struct workqueue_struct *wq)
 
         if (is_single_threaded(wq)) {
                 /* Always use first cpu's area. */
-                flush_cpu_workqueue(per_cpu_ptr(wq->cpu_wq, any_online_cpu(cpu_online_map)));
+                flush_cpu_workqueue(per_cpu_ptr(wq->cpu_wq, singlethread_cpu));
         } else {
                 int cpu;
 
@@ -315,12 +318,17 @@ struct workqueue_struct *__create_workqueue(const char *name,
                 return NULL;
 
         wq->cpu_wq = alloc_percpu(struct cpu_workqueue_struct);
+        if (!wq->cpu_wq) {
+                kfree(wq);
+                return NULL;
+        }
+
         wq->name = name;
         /* We don't need the distraction of CPUs appearing and vanishing. */
         lock_cpu_hotplug();
         if (singlethread) {
                 INIT_LIST_HEAD(&wq->list);
-                p = create_workqueue_thread(wq, any_online_cpu(cpu_online_map));
+                p = create_workqueue_thread(wq, singlethread_cpu);
                 if (!p)
                         destroy = 1;
                 else
@@ -374,7 +382,7 @@ void destroy_workqueue(struct workqueue_struct *wq)
         /* We don't need the distraction of CPUs appearing and vanishing. */
         lock_cpu_hotplug();
         if (is_single_threaded(wq))
-                cleanup_workqueue_thread(wq, any_online_cpu(cpu_online_map));
+                cleanup_workqueue_thread(wq, singlethread_cpu);
         else {
                 for_each_online_cpu(cpu)
                         cleanup_workqueue_thread(wq, cpu);
@@ -419,6 +427,25 @@ int schedule_delayed_work_on(int cpu,
         return ret;
 }
 
+int schedule_on_each_cpu(void (*func) (void *info), void *info)
+{
+        int cpu;
+        struct work_struct *work;
+
+        work = kmalloc(NR_CPUS * sizeof(struct work_struct), GFP_KERNEL);
+
+        if (!work)
+                return -ENOMEM;
+        for_each_online_cpu(cpu) {
+                INIT_WORK(work + cpu, func, info);
+                __queue_work(per_cpu_ptr(keventd_wq->cpu_wq, cpu),
+                                work + cpu);
+        }
+        flush_workqueue(keventd_wq);
+        kfree(work);
+        return 0;
+}
+
 void flush_scheduled_work(void)
 {
         flush_workqueue(keventd_wq);
@@ -543,6 +570,7 @@ static int __devinit workqueue_cpu_callback(struct notifier_block *nfb,
 
 void init_workqueues(void)
 {
+        singlethread_cpu = first_cpu(cpu_possible_map);
         hotcpu_notifier(workqueue_cpu_callback, 0);
         keventd_wq = create_workqueue("events");
         BUG_ON(!keventd_wq);