1 files changed, 39 insertions, 3 deletions

diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index 623488fdc1f5..a0ed78ab54d7 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -303,6 +303,33 @@ enum {
         WQ_CPU_INTENSIVE        = 1 << 5, /* cpu instensive workqueue */
         WQ_SYSFS                = 1 << 6, /* visible in sysfs, see wq_sysfs_register() */
 
+        /*
+         * Per-cpu workqueues are generally preferred because they tend to
+         * show better performance thanks to cache locality.  Per-cpu
+         * workqueues exclude the scheduler from choosing the CPU to
+         * execute the worker threads, which has an unfortunate side effect
+         * of increasing power consumption.
+         *
+         * The scheduler considers a CPU idle if it doesn't have any task
+         * to execute and tries to keep idle cores idle to conserve power;
+         * however, for example, a per-cpu work item scheduled from an
+         * interrupt handler on an idle CPU will force the scheduler to
+         * excute the work item on that CPU breaking the idleness, which in
+         * turn may lead to more scheduling choices which are sub-optimal
+         * in terms of power consumption.
+         *
+         * Workqueues marked with WQ_POWER_EFFICIENT are per-cpu by default
+         * but become unbound if workqueue.power_efficient kernel param is
+         * specified.  Per-cpu workqueues which are identified to
+         * contribute significantly to power-consumption are identified and
+         * marked with this flag and enabling the power_efficient mode
+         * leads to noticeable power saving at the cost of small
+         * performance disadvantage.
+         *
+         * http://thread.gmane.org/gmane.linux.kernel/1480396
+         */
+        WQ_POWER_EFFICIENT      = 1 << 7,
+
         __WQ_DRAINING           = 1 << 16, /* internal: workqueue is draining */
         __WQ_ORDERED            = 1 << 17, /* internal: workqueue is ordered */
 
@@ -333,11 +360,19 @@ enum {
  *
  * system_freezable_wq is equivalent to system_wq except that it's
  * freezable.
+ *
+ * *_power_efficient_wq are inclined towards saving power and converted
+ * into WQ_UNBOUND variants if 'wq_power_efficient' is enabled; otherwise,
+ * they are same as their non-power-efficient counterparts - e.g.
+ * system_power_efficient_wq is identical to system_wq if
+ * 'wq_power_efficient' is disabled.  See WQ_POWER_EFFICIENT for more info.
  */
 extern struct workqueue_struct *system_wq;
 extern struct workqueue_struct *system_long_wq;
 extern struct workqueue_struct *system_unbound_wq;
 extern struct workqueue_struct *system_freezable_wq;
+extern struct workqueue_struct *system_power_efficient_wq;
+extern struct workqueue_struct *system_freezable_power_efficient_wq;
 
 static inline struct workqueue_struct * __deprecated __system_nrt_wq(void)
 {
@@ -410,11 +445,12 @@ __alloc_workqueue_key(const char *fmt, unsigned int flags, int max_active,
         alloc_workqueue(fmt, WQ_UNBOUND | __WQ_ORDERED | (flags), 1, ##args)
 
 #define create_workqueue(name)                                          \
-        alloc_workqueue((name), WQ_MEM_RECLAIM, 1)
+        alloc_workqueue("%s", WQ_MEM_RECLAIM, 1, (name))
 #define create_freezable_workqueue(name)                                \
-        alloc_workqueue((name), WQ_FREEZABLE | WQ_UNBOUND | WQ_MEM_RECLAIM, 1)
+        alloc_workqueue("%s", WQ_FREEZABLE | WQ_UNBOUND | WQ_MEM_RECLAIM, \
+                        1, (name))
 #define create_singlethread_workqueue(name)                             \
-        alloc_workqueue((name), WQ_UNBOUND | WQ_MEM_RECLAIM, 1)
+        alloc_workqueue("%s", WQ_UNBOUND | WQ_MEM_RECLAIM, 1, (name))
 
 extern void destroy_workqueue(struct workqueue_struct *wq);