Branch data Line data Source code
1 : : /*
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>
11 : : #include <linux/lockdep.h>
12 : : #include <linux/threads.h>
13 : : #include <linux/atomic.h>
14 : : #include <linux/cpumask.h>
15 : :
16 : : struct workqueue_struct;
17 : :
18 : : struct work_struct;
19 : : typedef void (*work_func_t)(struct work_struct *work);
20 : : void delayed_work_timer_fn(unsigned long __data);
21 : :
22 : : /*
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 : :
28 : : enum {
29 : : WORK_STRUCT_PENDING_BIT = 0, /* work item is pending execution */
30 : : WORK_STRUCT_DELAYED_BIT = 1, /* work item is delayed */
31 : : WORK_STRUCT_PWQ_BIT = 2, /* data points to pwq */
32 : : WORK_STRUCT_LINKED_BIT = 3, /* next work is linked to this one */
33 : : #ifdef CONFIG_DEBUG_OBJECTS_WORK
34 : : WORK_STRUCT_STATIC_BIT = 4, /* static initializer (debugobjects) */
35 : : WORK_STRUCT_COLOR_SHIFT = 5, /* color for workqueue flushing */
36 : : #else
37 : : WORK_STRUCT_COLOR_SHIFT = 4, /* color for workqueue flushing */
38 : : #endif
39 : :
40 : : WORK_STRUCT_COLOR_BITS = 4,
41 : :
42 : : WORK_STRUCT_PENDING = 1 << WORK_STRUCT_PENDING_BIT,
43 : : WORK_STRUCT_DELAYED = 1 << WORK_STRUCT_DELAYED_BIT,
44 : : WORK_STRUCT_PWQ = 1 << WORK_STRUCT_PWQ_BIT,
45 : : WORK_STRUCT_LINKED = 1 << WORK_STRUCT_LINKED_BIT,
46 : : #ifdef CONFIG_DEBUG_OBJECTS_WORK
47 : : WORK_STRUCT_STATIC = 1 << WORK_STRUCT_STATIC_BIT,
48 : : #else
49 : : WORK_STRUCT_STATIC = 0,
50 : : #endif
51 : :
52 : : /*
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 : :
59 : : /* special cpu IDs */
60 : : WORK_CPU_UNBOUND = NR_CPUS,
61 : : WORK_CPU_END = NR_CPUS + 1,
62 : :
63 : : /*
64 : : * 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.
67 : : */
68 : : WORK_STRUCT_FLAG_BITS = WORK_STRUCT_COLOR_SHIFT +
69 : : WORK_STRUCT_COLOR_BITS,
70 : :
71 : : /* data contains off-queue information when !WORK_STRUCT_PWQ */
72 : : WORK_OFFQ_FLAG_BASE = WORK_STRUCT_COLOR_SHIFT,
73 : :
74 : : WORK_OFFQ_CANCELING = (1 << WORK_OFFQ_FLAG_BASE),
75 : :
76 : : /*
77 : : * When a work item is off queue, its high bits point to the last
78 : : * pool it was on. Cap at 31 bits and use the highest number to
79 : : * indicate that no pool is associated.
80 : : */
81 : : WORK_OFFQ_FLAG_BITS = 1,
82 : : 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,
86 : :
87 : : /* convenience constants */
88 : : WORK_STRUCT_FLAG_MASK = (1UL << WORK_STRUCT_FLAG_BITS) - 1,
89 : : WORK_STRUCT_WQ_DATA_MASK = ~WORK_STRUCT_FLAG_MASK,
90 : : WORK_STRUCT_NO_POOL = (unsigned long)WORK_OFFQ_POOL_NONE << WORK_OFFQ_POOL_SHIFT,
91 : :
92 : : /* bit mask for work_busy() return values */
93 : : WORK_BUSY_PENDING = 1 << 0,
94 : : WORK_BUSY_RUNNING = 1 << 1,
95 : :
96 : : /* maximum string length for set_worker_desc() */
97 : : WORKER_DESC_LEN = 24,
98 : : };
99 : :
100 : : struct work_struct {
101 : : atomic_long_t data;
102 : : struct list_head entry;
103 : : work_func_t func;
104 : : #ifdef CONFIG_LOCKDEP
105 : : struct lockdep_map lockdep_map;
106 : : #endif
107 : : };
108 : :
109 : : #define WORK_DATA_INIT() ATOMIC_LONG_INIT(WORK_STRUCT_NO_POOL)
110 : : #define WORK_DATA_STATIC_INIT() \
111 : : ATOMIC_LONG_INIT(WORK_STRUCT_NO_POOL | WORK_STRUCT_STATIC)
112 : :
113 : : struct delayed_work {
114 : : struct work_struct work;
115 : : struct timer_list timer;
116 : :
117 : : /* target workqueue and CPU ->timer uses to queue ->work */
118 : : struct workqueue_struct *wq;
119 : : int cpu;
120 : : };
121 : :
122 : : /*
123 : : * A struct for workqueue attributes. This can be used to change
124 : : * attributes of an unbound workqueue.
125 : : *
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.
129 : : */
130 : : struct workqueue_attrs {
131 : : int nice; /* nice level */
132 : : cpumask_var_t cpumask; /* allowed CPUs */
133 : : bool no_numa; /* disable NUMA affinity */
134 : : };
135 : :
136 : : static inline struct delayed_work *to_delayed_work(struct work_struct *work)
137 : : {
138 : : return container_of(work, struct delayed_work, work);
139 : : }
140 : :
141 : : struct execute_work {
142 : : struct work_struct work;
143 : : };
144 : :
145 : : #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 : :
157 : : #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)) \
162 : : }
163 : :
164 : : #define __DELAYED_WORK_INITIALIZER(n, f, tflags) { \
165 : : .work = __WORK_INITIALIZER((n).work, (f)), \
166 : : .timer = __TIMER_INITIALIZER(delayed_work_timer_fn, \
167 : : 0, (unsigned long)&(n), \
168 : : (tflags) | TIMER_IRQSAFE), \
169 : : }
170 : :
171 : : #define DECLARE_WORK(n, f) \
172 : : struct work_struct n = __WORK_INITIALIZER(n, f)
173 : :
174 : : #define DECLARE_DELAYED_WORK(n, f) \
175 : : struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, 0)
176 : :
177 : : #define DECLARE_DEFERRABLE_WORK(n, f) \
178 : : struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f, TIMER_DEFERRABLE)
179 : :
180 : : /*
181 : : * initialize a work item's function pointer
182 : : */
183 : : #define PREPARE_WORK(_work, _func) \
184 : : do { \
185 : : (_work)->func = (_func); \
186 : : } while (0)
187 : :
188 : : #define PREPARE_DELAYED_WORK(_work, _func) \
189 : : PREPARE_WORK(&(_work)->work, (_func))
190 : :
191 : : #ifdef CONFIG_DEBUG_OBJECTS_WORK
192 : : extern void __init_work(struct work_struct *work, int onstack);
193 : : extern void destroy_work_on_stack(struct work_struct *work);
194 : : static inline unsigned int work_static(struct work_struct *work)
195 : : {
196 : : return *work_data_bits(work) & WORK_STRUCT_STATIC;
197 : : }
198 : : #else
199 : : static inline void __init_work(struct work_struct *work, int onstack) { }
200 : : static inline void destroy_work_on_stack(struct work_struct *work) { }
201 : : static inline unsigned int work_static(struct work_struct *work) { return 0; }
202 : : #endif
203 : :
204 : : /*
205 : : * initialize all of a work item in one go
206 : : *
207 : : * NOTE! No point in using "atomic_long_set()": using a direct
208 : : * assignment of the work data initializer allows the compiler
209 : : * to generate better code.
210 : : */
211 : : #ifdef CONFIG_LOCKDEP
212 : : #define __INIT_WORK(_work, _func, _onstack) \
213 : : do { \
214 : : static struct lock_class_key __key; \
215 : : \
216 : : __init_work((_work), _onstack); \
217 : : (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \
218 : : lockdep_init_map(&(_work)->lockdep_map, #_work, &__key, 0); \
219 : : INIT_LIST_HEAD(&(_work)->entry); \
220 : : PREPARE_WORK((_work), (_func)); \
221 : : } while (0)
222 : : #else
223 : : #define __INIT_WORK(_work, _func, _onstack) \
224 : : do { \
225 : : __init_work((_work), _onstack); \
226 : : (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \
227 : : INIT_LIST_HEAD(&(_work)->entry); \
228 : : PREPARE_WORK((_work), (_func)); \
229 : : } while (0)
230 : : #endif
231 : :
232 : : #define INIT_WORK(_work, _func) \
233 : : do { \
234 : : __INIT_WORK((_work), (_func), 0); \
235 : : } while (0)
236 : :
237 : : #define INIT_WORK_ONSTACK(_work, _func) \
238 : : do { \
239 : : __INIT_WORK((_work), (_func), 1); \
240 : : } while (0)
241 : :
242 : : #define __INIT_DELAYED_WORK(_work, _func, _tflags) \
243 : : do { \
244 : : INIT_WORK(&(_work)->work, (_func)); \
245 : : __setup_timer(&(_work)->timer, delayed_work_timer_fn, \
246 : : (unsigned long)(_work), \
247 : : (_tflags) | TIMER_IRQSAFE); \
248 : : } while (0)
249 : :
250 : : #define __INIT_DELAYED_WORK_ONSTACK(_work, _func, _tflags) \
251 : : do { \
252 : : INIT_WORK_ONSTACK(&(_work)->work, (_func)); \
253 : : __setup_timer_on_stack(&(_work)->timer, \
254 : : delayed_work_timer_fn, \
255 : : (unsigned long)(_work), \
256 : : (_tflags) | TIMER_IRQSAFE); \
257 : : } while (0)
258 : :
259 : : #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 : :
265 : : #define INIT_DEFERRABLE_WORK(_work, _func) \
266 : : __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)
270 : :
271 : : /**
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) \
276 : : test_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))
277 : :
278 : : /**
279 : : * delayed_work_pending - Find out whether a delayable work item is currently
280 : : * pending
281 : : * @work: The work item in question
282 : : */
283 : : #define delayed_work_pending(w) \
284 : : work_pending(&(w)->work)
285 : :
286 : : /**
287 : : * work_clear_pending - for internal use only, mark a work item as not pending
288 : : * @work: The work item in question
289 : : */
290 : : #define work_clear_pending(work) \
291 : : clear_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))
292 : :
293 : : /*
294 : : * Workqueue flags and constants. For details, please refer to
295 : : * Documentation/workqueue.txt.
296 : : */
297 : : enum {
298 : : /*
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 : :
304 : : WQ_UNBOUND = 1 << 1, /* not bound to any cpu */
305 : : WQ_FREEZABLE = 1 << 2, /* freeze during suspend */
306 : : WQ_MEM_RECLAIM = 1 << 3, /* may be used for memory reclaim */
307 : : WQ_HIGHPRI = 1 << 4, /* high priority */
308 : : WQ_CPU_INTENSIVE = 1 << 5, /* cpu instensive workqueue */
309 : : WQ_SYSFS = 1 << 6, /* visible in sysfs, see wq_sysfs_register() */
310 : :
311 : : /*
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 : :
338 : : __WQ_DRAINING = 1 << 16, /* internal: workqueue is draining */
339 : : __WQ_ORDERED = 1 << 17, /* internal: workqueue is ordered */
340 : :
341 : : WQ_MAX_ACTIVE = 512, /* I like 512, better ideas? */
342 : : WQ_MAX_UNBOUND_PER_CPU = 4, /* 4 * #cpus for unbound wq */
343 : : WQ_DFL_ACTIVE = WQ_MAX_ACTIVE / 2,
344 : : };
345 : :
346 : : /* 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 : :
350 : : /*
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 : : *
361 : : * 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.
365 : : *
366 : : * system_freezable_wq is equivalent to system_wq except that it's
367 : : * freezable.
368 : : *
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.
374 : : */
375 : : extern struct workqueue_struct *system_wq;
376 : : extern struct workqueue_struct *system_long_wq;
377 : : extern struct workqueue_struct *system_unbound_wq;
378 : : extern struct workqueue_struct *system_freezable_wq;
379 : : extern struct workqueue_struct *system_power_efficient_wq;
380 : : extern struct workqueue_struct *system_freezable_power_efficient_wq;
381 : :
382 : : static inline struct workqueue_struct * __deprecated __system_nrt_wq(void)
383 : : {
384 : : return system_wq;
385 : : }
386 : :
387 : : static inline struct workqueue_struct * __deprecated __system_nrt_freezable_wq(void)
388 : : {
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()
395 : :
396 : : extern struct workqueue_struct *
397 : : __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);
399 : :
400 : : /**
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 : : */
416 : : #ifdef CONFIG_LOCKDEP
417 : : #define alloc_workqueue(fmt, flags, max_active, args...) \
418 : : ({ \
419 : : static struct lock_class_key __key; \
420 : : const char *__lock_name; \
421 : : \
422 : : if (__builtin_constant_p(fmt)) \
423 : : __lock_name = (fmt); \
424 : : else \
425 : : __lock_name = #fmt; \
426 : : \
427 : : __alloc_workqueue_key((fmt), (flags), (max_active), \
428 : : &__key, __lock_name, ##args); \
429 : : })
430 : : #else
431 : : #define alloc_workqueue(fmt, flags, max_active, args...) \
432 : : __alloc_workqueue_key((fmt), (flags), (max_active), \
433 : : NULL, NULL, ##args)
434 : : #endif
435 : :
436 : : /**
437 : : * alloc_ordered_workqueue - allocate an ordered workqueue
438 : : * @fmt: printf format for the name of the workqueue
439 : : * @flags: WQ_* flags (only WQ_FREEZABLE and WQ_MEM_RECLAIM are meaningful)
440 : : * @args: args for @fmt
441 : : *
442 : : * Allocate an ordered workqueue. An ordered workqueue executes at
443 : : * most one work item at any given time in the queued order. They are
444 : : * implemented as unbound workqueues with @max_active of one.
445 : : *
446 : : * RETURNS:
447 : : * Pointer to the allocated workqueue on success, %NULL on failure.
448 : : */
449 : : #define alloc_ordered_workqueue(fmt, flags, args...) \
450 : : alloc_workqueue(fmt, WQ_UNBOUND | __WQ_ORDERED | (flags), 1, ##args)
451 : :
452 : : #define create_workqueue(name) \
453 : : alloc_workqueue("%s", WQ_MEM_RECLAIM, 1, (name))
454 : : #define create_freezable_workqueue(name) \
455 : : alloc_workqueue("%s", WQ_FREEZABLE | WQ_UNBOUND | WQ_MEM_RECLAIM, \
456 : : 1, (name))
457 : : #define create_singlethread_workqueue(name) \
458 : : alloc_workqueue("%s", WQ_UNBOUND | WQ_MEM_RECLAIM, 1, (name))
459 : :
460 : : extern void destroy_workqueue(struct workqueue_struct *wq);
461 : :
462 : : struct workqueue_attrs *alloc_workqueue_attrs(gfp_t gfp_mask);
463 : : void free_workqueue_attrs(struct workqueue_attrs *attrs);
464 : : int apply_workqueue_attrs(struct workqueue_struct *wq,
465 : : const struct workqueue_attrs *attrs);
466 : :
467 : : extern bool queue_work_on(int cpu, struct workqueue_struct *wq,
468 : : struct work_struct *work);
469 : : extern bool queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
470 : : struct delayed_work *work, unsigned long delay);
471 : : extern bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq,
472 : : struct delayed_work *dwork, unsigned long delay);
473 : :
474 : : extern void flush_workqueue(struct workqueue_struct *wq);
475 : : extern void drain_workqueue(struct workqueue_struct *wq);
476 : : extern void flush_scheduled_work(void);
477 : :
478 : : extern int schedule_on_each_cpu(work_func_t func);
479 : :
480 : : int execute_in_process_context(work_func_t fn, struct execute_work *);
481 : :
482 : : extern bool flush_work(struct work_struct *work);
483 : : extern bool cancel_work_sync(struct work_struct *work);
484 : :
485 : : extern bool flush_delayed_work(struct delayed_work *dwork);
486 : : extern bool cancel_delayed_work(struct delayed_work *dwork);
487 : : extern bool cancel_delayed_work_sync(struct delayed_work *dwork);
488 : :
489 : : extern void workqueue_set_max_active(struct workqueue_struct *wq,
490 : : int max_active);
491 : : extern bool current_is_workqueue_rescuer(void);
492 : : extern bool workqueue_congested(int cpu, struct workqueue_struct *wq);
493 : : extern unsigned int work_busy(struct work_struct *work);
494 : : extern __printf(1, 2) void set_worker_desc(const char *fmt, ...);
495 : : extern void print_worker_info(const char *log_lvl, struct task_struct *task);
496 : :
497 : : /**
498 : : * queue_work - queue work on a workqueue
499 : : * @wq: workqueue to use
500 : : * @work: work to queue
501 : : *
502 : : * Returns %false if @work was already on a queue, %true otherwise.
503 : : *
504 : : * We queue the work to the CPU on which it was submitted, but if the CPU dies
505 : : * it can be processed by another CPU.
506 : : */
507 : : static inline bool queue_work(struct workqueue_struct *wq,
508 : : struct work_struct *work)
509 : : {
510 : 447539 : return queue_work_on(WORK_CPU_UNBOUND, wq, work);
511 : : }
512 : :
513 : : /**
514 : : * queue_delayed_work - queue work on a workqueue after delay
515 : : * @wq: workqueue to use
516 : : * @dwork: delayable work to queue
517 : : * @delay: number of jiffies to wait before queueing
518 : : *
519 : : * Equivalent to queue_delayed_work_on() but tries to use the local CPU.
520 : : */
521 : : static inline bool queue_delayed_work(struct workqueue_struct *wq,
522 : : struct delayed_work *dwork,
523 : : unsigned long delay)
524 : : {
525 : 294424 : return queue_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay);
526 : : }
527 : :
528 : : /**
529 : : * mod_delayed_work - modify delay of or queue a delayed work
530 : : * @wq: workqueue to use
531 : : * @dwork: work to queue
532 : : * @delay: number of jiffies to wait before queueing
533 : : *
534 : : * mod_delayed_work_on() on local CPU.
535 : : */
536 : : static inline bool mod_delayed_work(struct workqueue_struct *wq,
537 : : struct delayed_work *dwork,
538 : : unsigned long delay)
539 : : {
540 : 8928 : return mod_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay);
541 : : }
542 : :
543 : : /**
544 : : * schedule_work_on - put work task on a specific cpu
545 : : * @cpu: cpu to put the work task on
546 : : * @work: job to be done
547 : : *
548 : : * This puts a job on a specific cpu
549 : : */
550 : : static inline bool schedule_work_on(int cpu, struct work_struct *work)
551 : : {
552 : 39 : return queue_work_on(cpu, system_wq, work);
553 : : }
554 : :
555 : : /**
556 : : * schedule_work - put work task in global workqueue
557 : : * @work: job to be done
558 : : *
559 : : * Returns %false if @work was already on the kernel-global workqueue and
560 : : * %true otherwise.
561 : : *
562 : : * This puts a job in the kernel-global workqueue if it was not already
563 : : * queued and leaves it in the same position on the kernel-global
564 : : * workqueue otherwise.
565 : : */
566 : : static inline bool schedule_work(struct work_struct *work)
567 : : {
568 : 214172 : return queue_work(system_wq, work);
569 : : }
570 : :
571 : : /**
572 : : * schedule_delayed_work_on - queue work in global workqueue on CPU after delay
573 : : * @cpu: cpu to use
574 : : * @dwork: job to be done
575 : : * @delay: number of jiffies to wait
576 : : *
577 : : * After waiting for a given time this puts a job in the kernel-global
578 : : * workqueue on the specified CPU.
579 : : */
580 : : static inline bool schedule_delayed_work_on(int cpu, struct delayed_work *dwork,
581 : : unsigned long delay)
582 : : {
583 : 0 : return queue_delayed_work_on(cpu, system_wq, dwork, delay);
584 : : }
585 : :
586 : : /**
587 : : * schedule_delayed_work - put work task in global workqueue after delay
588 : : * @dwork: job to be done
589 : : * @delay: number of jiffies to wait or 0 for immediate execution
590 : : *
591 : : * After waiting for a given time this puts a job in the kernel-global
592 : : * workqueue.
593 : : */
594 : : static inline bool schedule_delayed_work(struct delayed_work *dwork,
595 : : unsigned long delay)
596 : : {
597 : 78768 : return queue_delayed_work(system_wq, dwork, delay);
598 : : }
599 : :
600 : : /**
601 : : * keventd_up - is workqueue initialized yet?
602 : : */
603 : : static inline bool keventd_up(void)
604 : : {
605 : 0 : return system_wq != NULL;
606 : : }
607 : :
608 : : /*
609 : : * Like above, but uses del_timer() instead of del_timer_sync(). This means,
610 : : * if it returns 0 the timer function may be running and the queueing is in
611 : : * progress.
612 : : */
613 : : static inline bool __deprecated __cancel_delayed_work(struct delayed_work *work)
614 : : {
615 : : bool ret;
616 : :
617 : : ret = del_timer(&work->timer);
618 : : if (ret)
619 : : work_clear_pending(&work->work);
620 : : return ret;
621 : : }
622 : :
623 : : /* used to be different but now identical to flush_work(), deprecated */
624 : : static inline bool __deprecated flush_work_sync(struct work_struct *work)
625 : : {
626 : : return flush_work(work);
627 : : }
628 : :
629 : : /* used to be different but now identical to flush_delayed_work(), deprecated */
630 : : static inline bool __deprecated flush_delayed_work_sync(struct delayed_work *dwork)
631 : : {
632 : : return flush_delayed_work(dwork);
633 : : }
634 : :
635 : : #ifndef CONFIG_SMP
636 : : static inline long work_on_cpu(int cpu, long (*fn)(void *), void *arg)
637 : : {
638 : : return fn(arg);
639 : : }
640 : : #else
641 : : long work_on_cpu(int cpu, long (*fn)(void *), void *arg);
642 : : #endif /* CONFIG_SMP */
643 : :
644 : : #ifdef CONFIG_FREEZER
645 : : extern void freeze_workqueues_begin(void);
646 : : extern bool freeze_workqueues_busy(void);
647 : : extern void thaw_workqueues(void);
648 : : #endif /* CONFIG_FREEZER */
649 : :
650 : : #ifdef CONFIG_SYSFS
651 : : int workqueue_sysfs_register(struct workqueue_struct *wq);
652 : : #else /* CONFIG_SYSFS */
653 : : static inline int workqueue_sysfs_register(struct workqueue_struct *wq)
654 : : { return 0; }
655 : : #endif /* CONFIG_SYSFS */
656 : :
657 : : #endif
|
