blob: 704f4f652d0af8b28406154678ee38b5f98298bf [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * workqueue.h --- work queue handling for Linux.
3 */
4
5#ifndef _LINUX_WORKQUEUE_H
6#define _LINUX_WORKQUEUE_H
7
8#include <linux/timer.h>
9#include <linux/linkage.h>
10#include <linux/bitops.h>
Johannes Berg4e6045f2007-10-18 23:39:55 -070011#include <linux/lockdep.h>
Tejun Heo7a22ad72010-06-29 10:07:13 +020012#include <linux/threads.h>
Arun Sharma600634972011-07-26 16:09:06 -070013#include <linux/atomic.h>
Tejun Heo7a4e3442013-03-12 11:30:00 -070014#include <linux/cpumask.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070015
16struct workqueue_struct;
17
David Howells65f27f32006-11-22 14:55:48 +000018struct work_struct;
19typedef void (*work_func_t)(struct work_struct *work);
Tejun Heod8e794d2012-08-03 10:30:45 -070020void delayed_work_timer_fn(unsigned long __data);
David Howells6bb49e52006-11-22 14:54:45 +000021
Linus Torvaldsa08727b2006-12-16 09:53:50 -080022/*
23 * The first word is the work queue pointer and the flags rolled into
24 * one
25 */
26#define work_data_bits(work) ((unsigned long *)(&(work)->data))
27
Tejun Heo22df02b2010-06-29 10:07:10 +020028enum {
29 WORK_STRUCT_PENDING_BIT = 0, /* work item is pending execution */
Tejun Heo8a2e8e5d2010-08-25 10:33:56 +020030 WORK_STRUCT_DELAYED_BIT = 1, /* work item is delayed */
Tejun Heo112202d2013-02-13 19:29:12 -080031 WORK_STRUCT_PWQ_BIT = 2, /* data points to pwq */
Tejun Heo8a2e8e5d2010-08-25 10:33:56 +020032 WORK_STRUCT_LINKED_BIT = 3, /* next work is linked to this one */
Tejun Heo22df02b2010-06-29 10:07:10 +020033#ifdef CONFIG_DEBUG_OBJECTS_WORK
Tejun Heo8a2e8e5d2010-08-25 10:33:56 +020034 WORK_STRUCT_STATIC_BIT = 4, /* static initializer (debugobjects) */
35 WORK_STRUCT_COLOR_SHIFT = 5, /* color for workqueue flushing */
Tejun Heo0f900042010-06-29 10:07:11 +020036#else
Tejun Heo8a2e8e5d2010-08-25 10:33:56 +020037 WORK_STRUCT_COLOR_SHIFT = 4, /* color for workqueue flushing */
Tejun Heo22df02b2010-06-29 10:07:10 +020038#endif
39
Tejun Heo73f53c42010-06-29 10:07:11 +020040 WORK_STRUCT_COLOR_BITS = 4,
41
Tejun Heo22df02b2010-06-29 10:07:10 +020042 WORK_STRUCT_PENDING = 1 << WORK_STRUCT_PENDING_BIT,
Tejun Heo8a2e8e5d2010-08-25 10:33:56 +020043 WORK_STRUCT_DELAYED = 1 << WORK_STRUCT_DELAYED_BIT,
Tejun Heo112202d2013-02-13 19:29:12 -080044 WORK_STRUCT_PWQ = 1 << WORK_STRUCT_PWQ_BIT,
Tejun Heoaffee4b2010-06-29 10:07:12 +020045 WORK_STRUCT_LINKED = 1 << WORK_STRUCT_LINKED_BIT,
Tejun Heo22df02b2010-06-29 10:07:10 +020046#ifdef CONFIG_DEBUG_OBJECTS_WORK
47 WORK_STRUCT_STATIC = 1 << WORK_STRUCT_STATIC_BIT,
48#else
49 WORK_STRUCT_STATIC = 0,
50#endif
51
Tejun Heo73f53c42010-06-29 10:07:11 +020052 /*
53 * The last color is no color used for works which don't
54 * participate in workqueue flushing.
55 */
56 WORK_NR_COLORS = (1 << WORK_STRUCT_COLOR_BITS) - 1,
57 WORK_NO_COLOR = WORK_NR_COLORS,
58
Tejun Heobdbc5dd2010-07-02 10:03:51 +020059 /* special cpu IDs */
Tejun Heof3421792010-07-02 10:03:51 +020060 WORK_CPU_UNBOUND = NR_CPUS,
Lai Jiangshan6be19582013-02-06 18:04:53 -080061 WORK_CPU_END = NR_CPUS + 1,
Tejun Heobdbc5dd2010-07-02 10:03:51 +020062
Tejun Heo73f53c42010-06-29 10:07:11 +020063 /*
Tejun Heo112202d2013-02-13 19:29:12 -080064 * Reserve 7 bits off of pwq pointer w/ debugobjects turned off.
65 * This makes pwqs aligned to 256 bytes and allows 15 workqueue
66 * flush colors.
Tejun Heo73f53c42010-06-29 10:07:11 +020067 */
68 WORK_STRUCT_FLAG_BITS = WORK_STRUCT_COLOR_SHIFT +
69 WORK_STRUCT_COLOR_BITS,
70
Tejun Heo112202d2013-02-13 19:29:12 -080071 /* data contains off-queue information when !WORK_STRUCT_PWQ */
Lai Jiangshan45d95502013-02-19 12:17:01 -080072 WORK_OFFQ_FLAG_BASE = WORK_STRUCT_COLOR_SHIFT,
Tejun Heobbb68df2012-08-03 10:30:46 -070073
74 WORK_OFFQ_CANCELING = (1 << WORK_OFFQ_FLAG_BASE),
75
Tejun Heo715b06b2013-01-24 11:01:33 -080076 /*
77 * When a work item is off queue, its high bits point to the last
Tejun Heo7c3eed52013-01-24 11:01:33 -080078 * pool it was on. Cap at 31 bits and use the highest number to
79 * indicate that no pool is associated.
Tejun Heo715b06b2013-01-24 11:01:33 -080080 */
Tejun Heobbb68df2012-08-03 10:30:46 -070081 WORK_OFFQ_FLAG_BITS = 1,
Tejun Heo7c3eed52013-01-24 11:01:33 -080082 WORK_OFFQ_POOL_SHIFT = WORK_OFFQ_FLAG_BASE + WORK_OFFQ_FLAG_BITS,
83 WORK_OFFQ_LEFT = BITS_PER_LONG - WORK_OFFQ_POOL_SHIFT,
84 WORK_OFFQ_POOL_BITS = WORK_OFFQ_LEFT <= 31 ? WORK_OFFQ_LEFT : 31,
85 WORK_OFFQ_POOL_NONE = (1LU << WORK_OFFQ_POOL_BITS) - 1,
Tejun Heob5490072012-08-03 10:30:46 -070086
87 /* convenience constants */
Tejun Heo0f900042010-06-29 10:07:11 +020088 WORK_STRUCT_FLAG_MASK = (1UL << WORK_STRUCT_FLAG_BITS) - 1,
Tejun Heo22df02b2010-06-29 10:07:10 +020089 WORK_STRUCT_WQ_DATA_MASK = ~WORK_STRUCT_FLAG_MASK,
Tejun Heo7c3eed52013-01-24 11:01:33 -080090 WORK_STRUCT_NO_POOL = (unsigned long)WORK_OFFQ_POOL_NONE << WORK_OFFQ_POOL_SHIFT,
Tejun Heodcd989c2010-06-29 10:07:14 +020091
92 /* bit mask for work_busy() return values */
93 WORK_BUSY_PENDING = 1 << 0,
94 WORK_BUSY_RUNNING = 1 << 1,
Tejun Heo3d1cb202013-04-30 15:27:22 -070095
96 /* maximum string length for set_worker_desc() */
97 WORKER_DESC_LEN = 24,
Tejun Heo22df02b2010-06-29 10:07:10 +020098};
99
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100struct work_struct {
Linus Torvaldsa08727b2006-12-16 09:53:50 -0800101 atomic_long_t data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102 struct list_head entry;
David Howells6bb49e52006-11-22 14:54:45 +0000103 work_func_t func;
Johannes Berg4e6045f2007-10-18 23:39:55 -0700104#ifdef CONFIG_LOCKDEP
105 struct lockdep_map lockdep_map;
106#endif
David Howells52bad642006-11-22 14:54:01 +0000107};
108
Tejun Heo7c3eed52013-01-24 11:01:33 -0800109#define WORK_DATA_INIT() ATOMIC_LONG_INIT(WORK_STRUCT_NO_POOL)
Tejun Heo7a22ad72010-06-29 10:07:13 +0200110#define WORK_DATA_STATIC_INIT() \
Tejun Heo7c3eed52013-01-24 11:01:33 -0800111 ATOMIC_LONG_INIT(WORK_STRUCT_NO_POOL | WORK_STRUCT_STATIC)
Linus Torvaldsa08727b2006-12-16 09:53:50 -0800112
David Howells52bad642006-11-22 14:54:01 +0000113struct delayed_work {
114 struct work_struct work;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 struct timer_list timer;
Lai Jiangshan60c057b2013-02-06 18:04:53 -0800116
117 /* target workqueue and CPU ->timer uses to queue ->work */
118 struct workqueue_struct *wq;
Tejun Heo12650572012-08-08 09:38:42 -0700119 int cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120};
121
Tejun Heo7a4e3442013-03-12 11:30:00 -0700122/*
123 * A struct for workqueue attributes. This can be used to change
124 * attributes of an unbound workqueue.
Tejun Heod55262c2013-04-01 11:23:38 -0700125 *
126 * Unlike other fields, ->no_numa isn't a property of a worker_pool. It
127 * only modifies how apply_workqueue_attrs() select pools and thus doesn't
128 * participate in pool hash calculations or equality comparisons.
Tejun Heo7a4e3442013-03-12 11:30:00 -0700129 */
130struct workqueue_attrs {
131 int nice; /* nice level */
132 cpumask_var_t cpumask; /* allowed CPUs */
Tejun Heod55262c2013-04-01 11:23:38 -0700133 bool no_numa; /* disable NUMA affinity */
Tejun Heo7a4e3442013-03-12 11:30:00 -0700134};
135
Jean Delvarebf6aede2009-04-02 16:56:54 -0700136static inline struct delayed_work *to_delayed_work(struct work_struct *work)
137{
138 return container_of(work, struct delayed_work, work);
139}
140
James Bottomley1fa44ec2006-02-23 12:43:43 -0600141struct execute_work {
142 struct work_struct work;
143};
144
Johannes Berg4e6045f2007-10-18 23:39:55 -0700145#ifdef CONFIG_LOCKDEP
146/*
147 * NB: because we have to copy the lockdep_map, setting _key
148 * here is required, otherwise it could get initialised to the
149 * copy of the lockdep_map!
150 */
151#define __WORK_INIT_LOCKDEP_MAP(n, k) \
152 .lockdep_map = STATIC_LOCKDEP_MAP_INIT(n, k),
153#else
154#define __WORK_INIT_LOCKDEP_MAP(n, k)
155#endif
156
Tejun Heoee64e7f2012-08-21 13:18:23 -0700157#define __WORK_INITIALIZER(n, f) { \
158 .data = WORK_DATA_STATIC_INIT(), \
159 .entry = { &(n).entry, &(n).entry }, \
160 .func = (f), \
161 __WORK_INIT_LOCKDEP_MAP(#n, &(n)) \
David Howells65f27f32006-11-22 14:55:48 +0000162 }
163
Tejun Heof991b312012-08-21 13:18:23 -0700164#define __DELAYED_WORK_INITIALIZER(n, f, tflags) { \
Tejun Heoee64e7f2012-08-21 13:18:23 -0700165 .work = __WORK_INITIALIZER((n).work, (f)), \
Tejun Heof991b312012-08-21 13:18:23 -0700166 .timer = __TIMER_INITIALIZER(delayed_work_timer_fn, \
Tejun Heoe0aecdd2012-08-21 13:18:24 -0700167 0, (unsigned long)&(n), \
168 (tflags) | TIMER_IRQSAFE), \
Phil Carmodydd6414b2010-10-20 15:57:33 -0700169 }
170
Tejun Heoee64e7f2012-08-21 13:18:23 -0700171#define DECLARE_WORK(n, f) \
David Howells65f27f32006-11-22 14:55:48 +0000172 struct work_struct n = __WORK_INITIALIZER(n, f)
173
Tejun Heoee64e7f2012-08-21 13:18:23 -0700174#define DECLARE_DELAYED_WORK(n, f) \
Tejun Heof991b312012-08-21 13:18:23 -0700175 struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, 0)
David Howells65f27f32006-11-22 14:55:48 +0000176
Tejun Heo203b42f2012-08-21 13:18:23 -0700177#define DECLARE_DEFERRABLE_WORK(n, f) \
Tejun Heof991b312012-08-21 13:18:23 -0700178 struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, TIMER_DEFERRABLE)
Phil Carmodydd6414b2010-10-20 15:57:33 -0700179
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180/*
David Howells65f27f32006-11-22 14:55:48 +0000181 * initialize a work item's function pointer
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 */
Tejun Heoee64e7f2012-08-21 13:18:23 -0700183#define PREPARE_WORK(_work, _func) \
184 do { \
185 (_work)->func = (_func); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186 } while (0)
187
Tejun Heoee64e7f2012-08-21 13:18:23 -0700188#define PREPARE_DELAYED_WORK(_work, _func) \
David Howells65f27f32006-11-22 14:55:48 +0000189 PREPARE_WORK(&(_work)->work, (_func))
David Howells52bad642006-11-22 14:54:01 +0000190
Thomas Gleixnerdc186ad2009-11-16 01:09:48 +0900191#ifdef CONFIG_DEBUG_OBJECTS_WORK
192extern void __init_work(struct work_struct *work, int onstack);
193extern void destroy_work_on_stack(struct work_struct *work);
Tejun Heo4690c4a2010-06-29 10:07:10 +0200194static inline unsigned int work_static(struct work_struct *work)
195{
Tejun Heo22df02b2010-06-29 10:07:10 +0200196 return *work_data_bits(work) & WORK_STRUCT_STATIC;
Tejun Heo4690c4a2010-06-29 10:07:10 +0200197}
Thomas Gleixnerdc186ad2009-11-16 01:09:48 +0900198#else
199static inline void __init_work(struct work_struct *work, int onstack) { }
200static inline void destroy_work_on_stack(struct work_struct *work) { }
Tejun Heo4690c4a2010-06-29 10:07:10 +0200201static inline unsigned int work_static(struct work_struct *work) { return 0; }
Thomas Gleixnerdc186ad2009-11-16 01:09:48 +0900202#endif
203
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204/*
David Howells52bad642006-11-22 14:54:01 +0000205 * initialize all of a work item in one go
Linus Torvaldsa08727b2006-12-16 09:53:50 -0800206 *
Dmitri Vorobievb9049df2009-06-23 12:09:29 +0200207 * NOTE! No point in using "atomic_long_set()": using a direct
Linus Torvaldsa08727b2006-12-16 09:53:50 -0800208 * assignment of the work data initializer allows the compiler
209 * to generate better code.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 */
Johannes Berg4e6045f2007-10-18 23:39:55 -0700211#ifdef CONFIG_LOCKDEP
Thomas Gleixnerdc186ad2009-11-16 01:09:48 +0900212#define __INIT_WORK(_work, _func, _onstack) \
Johannes Berg4e6045f2007-10-18 23:39:55 -0700213 do { \
214 static struct lock_class_key __key; \
215 \
Thomas Gleixnerdc186ad2009-11-16 01:09:48 +0900216 __init_work((_work), _onstack); \
Johannes Berg4e6045f2007-10-18 23:39:55 -0700217 (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \
Tejun Heoee64e7f2012-08-21 13:18:23 -0700218 lockdep_init_map(&(_work)->lockdep_map, #_work, &__key, 0); \
Johannes Berg4e6045f2007-10-18 23:39:55 -0700219 INIT_LIST_HEAD(&(_work)->entry); \
220 PREPARE_WORK((_work), (_func)); \
221 } while (0)
222#else
Thomas Gleixnerdc186ad2009-11-16 01:09:48 +0900223#define __INIT_WORK(_work, _func, _onstack) \
David Howells65f27f32006-11-22 14:55:48 +0000224 do { \
Thomas Gleixnerdc186ad2009-11-16 01:09:48 +0900225 __init_work((_work), _onstack); \
Oleg Nesterov23b2e592007-05-09 02:34:19 -0700226 (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \
David Howells65f27f32006-11-22 14:55:48 +0000227 INIT_LIST_HEAD(&(_work)->entry); \
228 PREPARE_WORK((_work), (_func)); \
229 } while (0)
Johannes Berg4e6045f2007-10-18 23:39:55 -0700230#endif
David Howells65f27f32006-11-22 14:55:48 +0000231
Tejun Heoee64e7f2012-08-21 13:18:23 -0700232#define INIT_WORK(_work, _func) \
233 do { \
234 __INIT_WORK((_work), (_func), 0); \
Thomas Gleixnerdc186ad2009-11-16 01:09:48 +0900235 } while (0)
236
Tejun Heoee64e7f2012-08-21 13:18:23 -0700237#define INIT_WORK_ONSTACK(_work, _func) \
238 do { \
239 __INIT_WORK((_work), (_func), 1); \
Thomas Gleixnerdc186ad2009-11-16 01:09:48 +0900240 } while (0)
241
Tejun Heof991b312012-08-21 13:18:23 -0700242#define __INIT_DELAYED_WORK(_work, _func, _tflags) \
Tejun Heoee64e7f2012-08-21 13:18:23 -0700243 do { \
244 INIT_WORK(&(_work)->work, (_func)); \
Tejun Heof991b312012-08-21 13:18:23 -0700245 __setup_timer(&(_work)->timer, delayed_work_timer_fn, \
Tejun Heoe0aecdd2012-08-21 13:18:24 -0700246 (unsigned long)(_work), \
247 (_tflags) | TIMER_IRQSAFE); \
David Howells65f27f32006-11-22 14:55:48 +0000248 } while (0)
249
Tejun Heof991b312012-08-21 13:18:23 -0700250#define __INIT_DELAYED_WORK_ONSTACK(_work, _func, _tflags) \
Tejun Heoee64e7f2012-08-21 13:18:23 -0700251 do { \
252 INIT_WORK_ONSTACK(&(_work)->work, (_func)); \
Tejun Heof991b312012-08-21 13:18:23 -0700253 __setup_timer_on_stack(&(_work)->timer, \
254 delayed_work_timer_fn, \
255 (unsigned long)(_work), \
Tejun Heoe0aecdd2012-08-21 13:18:24 -0700256 (_tflags) | TIMER_IRQSAFE); \
Peter Zijlstra6d612b02009-01-12 12:52:23 +0100257 } while (0)
258
Tejun Heof991b312012-08-21 13:18:23 -0700259#define INIT_DELAYED_WORK(_work, _func) \
260 __INIT_DELAYED_WORK(_work, _func, 0)
261
262#define INIT_DELAYED_WORK_ONSTACK(_work, _func) \
263 __INIT_DELAYED_WORK_ONSTACK(_work, _func, 0)
264
Tejun Heo203b42f2012-08-21 13:18:23 -0700265#define INIT_DEFERRABLE_WORK(_work, _func) \
Tejun Heof991b312012-08-21 13:18:23 -0700266 __INIT_DELAYED_WORK(_work, _func, TIMER_DEFERRABLE)
267
268#define INIT_DEFERRABLE_WORK_ONSTACK(_work, _func) \
269 __INIT_DELAYED_WORK_ONSTACK(_work, _func, TIMER_DEFERRABLE)
Venki Pallipadi28287032007-05-08 00:27:47 -0700270
David Howells365970a2006-11-22 14:54:49 +0000271/**
272 * work_pending - Find out whether a work item is currently pending
273 * @work: The work item in question
274 */
275#define work_pending(work) \
Tejun Heo22df02b2010-06-29 10:07:10 +0200276 test_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))
David Howells365970a2006-11-22 14:54:49 +0000277
278/**
279 * delayed_work_pending - Find out whether a delayable work item is currently
280 * pending
281 * @work: The work item in question
282 */
Linus Torvalds02218722006-12-15 14:13:51 -0800283#define delayed_work_pending(w) \
284 work_pending(&(w)->work)
David Howells365970a2006-11-22 14:54:49 +0000285
David Howells65f27f32006-11-22 14:55:48 +0000286/**
Oleg Nesterov23b2e592007-05-09 02:34:19 -0700287 * work_clear_pending - for internal use only, mark a work item as not pending
288 * @work: The work item in question
David Howells65f27f32006-11-22 14:55:48 +0000289 */
Oleg Nesterov23b2e592007-05-09 02:34:19 -0700290#define work_clear_pending(work) \
Tejun Heo22df02b2010-06-29 10:07:10 +0200291 clear_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))
David Howells65f27f32006-11-22 14:55:48 +0000292
Tejun Heoc54fce62010-09-10 16:51:36 +0200293/*
294 * Workqueue flags and constants. For details, please refer to
295 * Documentation/workqueue.txt.
296 */
Tejun Heo97e37d72010-06-29 10:07:10 +0200297enum {
Tejun Heo12076372013-07-30 08:30:16 -0400298 /*
299 * All wqs are now non-reentrant making the following flag
300 * meaningless. Will be removed.
301 */
302 WQ_NON_REENTRANT = 1 << 0, /* DEPRECATED */
303
Tejun Heoc7fc77f2010-07-02 10:03:51 +0200304 WQ_UNBOUND = 1 << 1, /* not bound to any cpu */
Tejun Heo58a69cb2011-02-16 09:25:31 +0100305 WQ_FREEZABLE = 1 << 2, /* freeze during suspend */
Tejun Heo6370a6a2010-10-11 15:12:27 +0200306 WQ_MEM_RECLAIM = 1 << 3, /* may be used for memory reclaim */
Tejun Heo649027d2010-06-29 10:07:14 +0200307 WQ_HIGHPRI = 1 << 4, /* high priority */
Tejun Heofb0e7be2010-06-29 10:07:15 +0200308 WQ_CPU_INTENSIVE = 1 << 5, /* cpu instensive workqueue */
Tejun Heo226223a2013-03-12 11:30:05 -0700309 WQ_SYSFS = 1 << 6, /* visible in sysfs, see wq_sysfs_register() */
Tejun Heob71ab8c2010-06-29 10:07:14 +0200310
Viresh Kumarcee22a12013-04-08 16:45:40 +0530311 /*
312 * Per-cpu workqueues are generally preferred because they tend to
313 * show better performance thanks to cache locality. Per-cpu
314 * workqueues exclude the scheduler from choosing the CPU to
315 * execute the worker threads, which has an unfortunate side effect
316 * of increasing power consumption.
317 *
318 * The scheduler considers a CPU idle if it doesn't have any task
319 * to execute and tries to keep idle cores idle to conserve power;
320 * however, for example, a per-cpu work item scheduled from an
321 * interrupt handler on an idle CPU will force the scheduler to
322 * excute the work item on that CPU breaking the idleness, which in
323 * turn may lead to more scheduling choices which are sub-optimal
324 * in terms of power consumption.
325 *
326 * Workqueues marked with WQ_POWER_EFFICIENT are per-cpu by default
327 * but become unbound if workqueue.power_efficient kernel param is
328 * specified. Per-cpu workqueues which are identified to
329 * contribute significantly to power-consumption are identified and
330 * marked with this flag and enabling the power_efficient mode
331 * leads to noticeable power saving at the cost of small
332 * performance disadvantage.
333 *
334 * http://thread.gmane.org/gmane.linux.kernel/1480396
335 */
336 WQ_POWER_EFFICIENT = 1 << 7,
337
Tejun Heo618b01e2013-03-12 11:30:04 -0700338 __WQ_DRAINING = 1 << 16, /* internal: workqueue is draining */
Tejun Heo8719dce2013-03-12 11:30:04 -0700339 __WQ_ORDERED = 1 << 17, /* internal: workqueue is ordered */
Tejun Heoe41e7042010-08-24 14:22:47 +0200340
Tejun Heob71ab8c2010-06-29 10:07:14 +0200341 WQ_MAX_ACTIVE = 512, /* I like 512, better ideas? */
Tejun Heof3421792010-07-02 10:03:51 +0200342 WQ_MAX_UNBOUND_PER_CPU = 4, /* 4 * #cpus for unbound wq */
Tejun Heob71ab8c2010-06-29 10:07:14 +0200343 WQ_DFL_ACTIVE = WQ_MAX_ACTIVE / 2,
Tejun Heo97e37d72010-06-29 10:07:10 +0200344};
David Howells52bad642006-11-22 14:54:01 +0000345
Tejun Heof3421792010-07-02 10:03:51 +0200346/* unbound wq's aren't per-cpu, scale max_active according to #cpus */
347#define WQ_UNBOUND_MAX_ACTIVE \
348 max_t(int, WQ_MAX_ACTIVE, num_possible_cpus() * WQ_MAX_UNBOUND_PER_CPU)
349
Tejun Heod320c032010-06-29 10:07:14 +0200350/*
351 * System-wide workqueues which are always present.
352 *
353 * system_wq is the one used by schedule[_delayed]_work[_on]().
354 * Multi-CPU multi-threaded. There are users which expect relatively
355 * short queue flush time. Don't queue works which can run for too
356 * long.
357 *
358 * system_long_wq is similar to system_wq but may host long running
359 * works. Queue flushing might take relatively long.
360 *
Tejun Heof3421792010-07-02 10:03:51 +0200361 * system_unbound_wq is unbound workqueue. Workers are not bound to
362 * any specific CPU, not concurrency managed, and all queued works are
363 * executed immediately as long as max_active limit is not reached and
364 * resources are available.
Tejun Heo4149efb2011-02-08 10:39:03 +0100365 *
Tejun Heo24d51ad2011-02-21 09:52:50 +0100366 * system_freezable_wq is equivalent to system_wq except that it's
367 * freezable.
Viresh Kumar06681062013-04-24 17:12:54 +0530368 *
369 * *_power_efficient_wq are inclined towards saving power and converted
370 * into WQ_UNBOUND variants if 'wq_power_efficient' is enabled; otherwise,
371 * they are same as their non-power-efficient counterparts - e.g.
372 * system_power_efficient_wq is identical to system_wq if
373 * 'wq_power_efficient' is disabled. See WQ_POWER_EFFICIENT for more info.
Tejun Heod320c032010-06-29 10:07:14 +0200374 */
375extern struct workqueue_struct *system_wq;
376extern struct workqueue_struct *system_long_wq;
Tejun Heof3421792010-07-02 10:03:51 +0200377extern struct workqueue_struct *system_unbound_wq;
Tejun Heo24d51ad2011-02-21 09:52:50 +0100378extern struct workqueue_struct *system_freezable_wq;
Viresh Kumar06681062013-04-24 17:12:54 +0530379extern struct workqueue_struct *system_power_efficient_wq;
380extern struct workqueue_struct *system_freezable_power_efficient_wq;
Tejun Heoae930e02012-08-20 14:51:23 -0700381
Tejun Heo3b07e9c2012-08-20 14:51:24 -0700382static inline struct workqueue_struct * __deprecated __system_nrt_wq(void)
Tejun Heoae930e02012-08-20 14:51:23 -0700383{
384 return system_wq;
385}
386
Tejun Heo3b07e9c2012-08-20 14:51:24 -0700387static inline struct workqueue_struct * __deprecated __system_nrt_freezable_wq(void)
Tejun Heoae930e02012-08-20 14:51:23 -0700388{
389 return system_freezable_wq;
390}
391
392/* equivlalent to system_wq and system_freezable_wq, deprecated */
393#define system_nrt_wq __system_nrt_wq()
394#define system_nrt_freezable_wq __system_nrt_freezable_wq()
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
Johannes Berg4e6045f2007-10-18 23:39:55 -0700396extern struct workqueue_struct *
Tejun Heob196be82012-01-10 15:11:35 -0800397__alloc_workqueue_key(const char *fmt, unsigned int flags, int max_active,
398 struct lock_class_key *key, const char *lock_name, ...) __printf(1, 6);
Johannes Berg4e6045f2007-10-18 23:39:55 -0700399
Tejun Heob196be82012-01-10 15:11:35 -0800400/**
401 * alloc_workqueue - allocate a workqueue
402 * @fmt: printf format for the name of the workqueue
403 * @flags: WQ_* flags
404 * @max_active: max in-flight work items, 0 for default
405 * @args: args for @fmt
406 *
407 * Allocate a workqueue with the specified parameters. For detailed
408 * information on WQ_* flags, please refer to Documentation/workqueue.txt.
409 *
410 * The __lock_name macro dance is to guarantee that single lock_class_key
411 * doesn't end up with different namesm, which isn't allowed by lockdep.
412 *
413 * RETURNS:
414 * Pointer to the allocated workqueue on success, %NULL on failure.
415 */
Johannes Berg4e6045f2007-10-18 23:39:55 -0700416#ifdef CONFIG_LOCKDEP
Tejun Heoee64e7f2012-08-21 13:18:23 -0700417#define alloc_workqueue(fmt, flags, max_active, args...) \
418({ \
419 static struct lock_class_key __key; \
420 const char *__lock_name; \
421 \
Li Zhongfada94e2014-02-14 10:52:57 +0800422 __lock_name = #fmt#args; \
Tejun Heoee64e7f2012-08-21 13:18:23 -0700423 \
424 __alloc_workqueue_key((fmt), (flags), (max_active), \
425 &__key, __lock_name, ##args); \
Johannes Berg4e6045f2007-10-18 23:39:55 -0700426})
427#else
Tejun Heoee64e7f2012-08-21 13:18:23 -0700428#define alloc_workqueue(fmt, flags, max_active, args...) \
429 __alloc_workqueue_key((fmt), (flags), (max_active), \
Tejun Heob196be82012-01-10 15:11:35 -0800430 NULL, NULL, ##args)
Johannes Berg4e6045f2007-10-18 23:39:55 -0700431#endif
432
Tejun Heo81dcaf62010-09-16 10:17:35 +0200433/**
434 * alloc_ordered_workqueue - allocate an ordered workqueue
Tejun Heob196be82012-01-10 15:11:35 -0800435 * @fmt: printf format for the name of the workqueue
Tejun Heo58a69cb2011-02-16 09:25:31 +0100436 * @flags: WQ_* flags (only WQ_FREEZABLE and WQ_MEM_RECLAIM are meaningful)
Tejun Heob196be82012-01-10 15:11:35 -0800437 * @args: args for @fmt
Tejun Heo81dcaf62010-09-16 10:17:35 +0200438 *
439 * Allocate an ordered workqueue. An ordered workqueue executes at
440 * most one work item at any given time in the queued order. They are
441 * implemented as unbound workqueues with @max_active of one.
442 *
443 * RETURNS:
444 * Pointer to the allocated workqueue on success, %NULL on failure.
445 */
Tejun Heoee64e7f2012-08-21 13:18:23 -0700446#define alloc_ordered_workqueue(fmt, flags, args...) \
Tejun Heo8719dce2013-03-12 11:30:04 -0700447 alloc_workqueue(fmt, WQ_UNBOUND | __WQ_ORDERED | (flags), 1, ##args)
Tejun Heo81dcaf62010-09-16 10:17:35 +0200448
Tejun Heoee64e7f2012-08-21 13:18:23 -0700449#define create_workqueue(name) \
Kees Cookd8537542013-07-03 15:04:57 -0700450 alloc_workqueue("%s", WQ_MEM_RECLAIM, 1, (name))
Tejun Heoee64e7f2012-08-21 13:18:23 -0700451#define create_freezable_workqueue(name) \
Kees Cookd8537542013-07-03 15:04:57 -0700452 alloc_workqueue("%s", WQ_FREEZABLE | WQ_UNBOUND | WQ_MEM_RECLAIM, \
453 1, (name))
Tejun Heoee64e7f2012-08-21 13:18:23 -0700454#define create_singlethread_workqueue(name) \
Kees Cookd8537542013-07-03 15:04:57 -0700455 alloc_workqueue("%s", WQ_UNBOUND | WQ_MEM_RECLAIM, 1, (name))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456
457extern void destroy_workqueue(struct workqueue_struct *wq);
458
Tejun Heo7a4e3442013-03-12 11:30:00 -0700459struct workqueue_attrs *alloc_workqueue_attrs(gfp_t gfp_mask);
460void free_workqueue_attrs(struct workqueue_attrs *attrs);
Tejun Heo9e8cd2f2013-03-12 11:30:04 -0700461int apply_workqueue_attrs(struct workqueue_struct *wq,
462 const struct workqueue_attrs *attrs);
Tejun Heo7a4e3442013-03-12 11:30:00 -0700463
Tejun Heod4283e92012-08-03 10:30:44 -0700464extern bool queue_work_on(int cpu, struct workqueue_struct *wq,
Zhang Ruic1a220e2008-07-23 21:28:39 -0700465 struct work_struct *work);
Tejun Heod4283e92012-08-03 10:30:44 -0700466extern bool queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
Oleg Nesterov28e53bd2007-05-09 02:34:22 -0700467 struct delayed_work *work, unsigned long delay);
Tejun Heo8376fe22012-08-03 10:30:47 -0700468extern bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq,
469 struct delayed_work *dwork, unsigned long delay);
Oleg Nesterov28e53bd2007-05-09 02:34:22 -0700470
Harvey Harrisonb3c97522008-02-13 15:03:15 -0800471extern void flush_workqueue(struct workqueue_struct *wq);
Tejun Heo9c5a2ba2011-04-05 18:01:44 +0200472extern void drain_workqueue(struct workqueue_struct *wq);
Oleg Nesterov28e53bd2007-05-09 02:34:22 -0700473extern void flush_scheduled_work(void);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474
David Howells65f27f32006-11-22 14:55:48 +0000475extern int schedule_on_each_cpu(work_func_t func);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476
David Howells65f27f32006-11-22 14:55:48 +0000477int execute_in_process_context(work_func_t fn, struct execute_work *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478
Tejun Heo401a8d02010-09-16 10:36:00 +0200479extern bool flush_work(struct work_struct *work);
480extern bool cancel_work_sync(struct work_struct *work);
481
482extern bool flush_delayed_work(struct delayed_work *dwork);
Tejun Heo57b30ae2012-08-21 13:18:24 -0700483extern bool cancel_delayed_work(struct delayed_work *dwork);
Tejun Heo401a8d02010-09-16 10:36:00 +0200484extern bool cancel_delayed_work_sync(struct delayed_work *dwork);
Oleg Nesterov28e53bd2007-05-09 02:34:22 -0700485
Tejun Heodcd989c2010-06-29 10:07:14 +0200486extern void workqueue_set_max_active(struct workqueue_struct *wq,
487 int max_active);
Tejun Heoe62676162013-03-12 17:41:37 -0700488extern bool current_is_workqueue_rescuer(void);
Tejun Heod84ff052013-03-12 11:29:59 -0700489extern bool workqueue_congested(int cpu, struct workqueue_struct *wq);
Tejun Heodcd989c2010-06-29 10:07:14 +0200490extern unsigned int work_busy(struct work_struct *work);
Tejun Heo3d1cb202013-04-30 15:27:22 -0700491extern __printf(1, 2) void set_worker_desc(const char *fmt, ...);
492extern void print_worker_info(const char *log_lvl, struct task_struct *task);
Tejun Heodcd989c2010-06-29 10:07:14 +0200493
Tejun Heo8425e3d52013-03-13 16:51:36 -0700494/**
495 * queue_work - queue work on a workqueue
496 * @wq: workqueue to use
497 * @work: work to queue
498 *
499 * Returns %false if @work was already on a queue, %true otherwise.
500 *
501 * We queue the work to the CPU on which it was submitted, but if the CPU dies
502 * it can be processed by another CPU.
503 */
504static inline bool queue_work(struct workqueue_struct *wq,
505 struct work_struct *work)
506{
507 return queue_work_on(WORK_CPU_UNBOUND, wq, work);
508}
509
510/**
511 * queue_delayed_work - queue work on a workqueue after delay
512 * @wq: workqueue to use
513 * @dwork: delayable work to queue
514 * @delay: number of jiffies to wait before queueing
515 *
516 * Equivalent to queue_delayed_work_on() but tries to use the local CPU.
517 */
518static inline bool queue_delayed_work(struct workqueue_struct *wq,
519 struct delayed_work *dwork,
520 unsigned long delay)
521{
522 return queue_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay);
523}
524
525/**
526 * mod_delayed_work - modify delay of or queue a delayed work
527 * @wq: workqueue to use
528 * @dwork: work to queue
529 * @delay: number of jiffies to wait before queueing
530 *
531 * mod_delayed_work_on() on local CPU.
532 */
533static inline bool mod_delayed_work(struct workqueue_struct *wq,
534 struct delayed_work *dwork,
535 unsigned long delay)
536{
537 return mod_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay);
538}
539
540/**
541 * schedule_work_on - put work task on a specific cpu
542 * @cpu: cpu to put the work task on
543 * @work: job to be done
544 *
545 * This puts a job on a specific cpu
546 */
547static inline bool schedule_work_on(int cpu, struct work_struct *work)
548{
549 return queue_work_on(cpu, system_wq, work);
550}
551
552/**
553 * schedule_work - put work task in global workqueue
554 * @work: job to be done
555 *
556 * Returns %false if @work was already on the kernel-global workqueue and
557 * %true otherwise.
558 *
559 * This puts a job in the kernel-global workqueue if it was not already
560 * queued and leaves it in the same position on the kernel-global
561 * workqueue otherwise.
562 */
563static inline bool schedule_work(struct work_struct *work)
564{
565 return queue_work(system_wq, work);
566}
567
568/**
569 * schedule_delayed_work_on - queue work in global workqueue on CPU after delay
570 * @cpu: cpu to use
571 * @dwork: job to be done
572 * @delay: number of jiffies to wait
573 *
574 * After waiting for a given time this puts a job in the kernel-global
575 * workqueue on the specified CPU.
576 */
577static inline bool schedule_delayed_work_on(int cpu, struct delayed_work *dwork,
578 unsigned long delay)
579{
580 return queue_delayed_work_on(cpu, system_wq, dwork, delay);
581}
582
583/**
584 * schedule_delayed_work - put work task in global workqueue after delay
585 * @dwork: job to be done
586 * @delay: number of jiffies to wait or 0 for immediate execution
587 *
588 * After waiting for a given time this puts a job in the kernel-global
589 * workqueue.
590 */
591static inline bool schedule_delayed_work(struct delayed_work *dwork,
592 unsigned long delay)
593{
594 return queue_delayed_work(system_wq, dwork, delay);
595}
596
597/**
598 * keventd_up - is workqueue initialized yet?
599 */
600static inline bool keventd_up(void)
601{
602 return system_wq != NULL;
603}
604
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605/*
Oleg Nesterov4e496272009-09-05 11:17:06 -0700606 * Like above, but uses del_timer() instead of del_timer_sync(). This means,
607 * if it returns 0 the timer function may be running and the queueing is in
608 * progress.
609 */
Tejun Heo136b5722012-08-21 13:18:24 -0700610static inline bool __deprecated __cancel_delayed_work(struct delayed_work *work)
Oleg Nesterov4e496272009-09-05 11:17:06 -0700611{
Tejun Heo401a8d02010-09-16 10:36:00 +0200612 bool ret;
Oleg Nesterov4e496272009-09-05 11:17:06 -0700613
614 ret = del_timer(&work->timer);
615 if (ret)
616 work_clear_pending(&work->work);
617 return ret;
618}
619
Tejun Heo606a5022012-08-20 14:51:23 -0700620/* used to be different but now identical to flush_work(), deprecated */
Tejun Heo43829732012-08-20 14:51:24 -0700621static inline bool __deprecated flush_work_sync(struct work_struct *work)
Tejun Heo606a5022012-08-20 14:51:23 -0700622{
623 return flush_work(work);
624}
625
626/* used to be different but now identical to flush_delayed_work(), deprecated */
Tejun Heo43829732012-08-20 14:51:24 -0700627static inline bool __deprecated flush_delayed_work_sync(struct delayed_work *dwork)
Tejun Heo606a5022012-08-20 14:51:23 -0700628{
629 return flush_delayed_work(dwork);
630}
631
Rusty Russell2d3854a2008-11-05 13:39:10 +1100632#ifndef CONFIG_SMP
Tejun Heod84ff052013-03-12 11:29:59 -0700633static inline long work_on_cpu(int cpu, long (*fn)(void *), void *arg)
Rusty Russell2d3854a2008-11-05 13:39:10 +1100634{
635 return fn(arg);
636}
637#else
Tejun Heod84ff052013-03-12 11:29:59 -0700638long work_on_cpu(int cpu, long (*fn)(void *), void *arg);
Rusty Russell2d3854a2008-11-05 13:39:10 +1100639#endif /* CONFIG_SMP */
Paul E. McKenneya25909a2010-05-13 12:32:28 -0700640
Tejun Heoa0a1a5f2010-06-29 10:07:12 +0200641#ifdef CONFIG_FREEZER
642extern void freeze_workqueues_begin(void);
643extern bool freeze_workqueues_busy(void);
644extern void thaw_workqueues(void);
645#endif /* CONFIG_FREEZER */
646
Tejun Heo226223a2013-03-12 11:30:05 -0700647#ifdef CONFIG_SYSFS
648int workqueue_sysfs_register(struct workqueue_struct *wq);
649#else /* CONFIG_SYSFS */
650static inline int workqueue_sysfs_register(struct workqueue_struct *wq)
651{ return 0; }
652#endif /* CONFIG_SYSFS */
653
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654#endif