1
2
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
16struct workqueue_struct;
17
18struct work_struct;
19typedef void (*work_func_t)(struct work_struct *work);
20void delayed_work_timer_fn(unsigned long __data);
21
22
23
24
25
26#define work_data_bits(work) ((unsigned long *)(&(work)->data))
27
28enum {
29 WORK_STRUCT_PENDING_BIT = 0,
30 WORK_STRUCT_DELAYED_BIT = 1,
31 WORK_STRUCT_PWQ_BIT = 2,
32 WORK_STRUCT_LINKED_BIT = 3,
33#ifdef CONFIG_DEBUG_OBJECTS_WORK
34 WORK_STRUCT_STATIC_BIT = 4,
35 WORK_STRUCT_COLOR_SHIFT = 5,
36#else
37 WORK_STRUCT_COLOR_SHIFT = 4,
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
54
55
56 WORK_NR_COLORS = (1 << WORK_STRUCT_COLOR_BITS) - 1,
57 WORK_NO_COLOR = WORK_NR_COLORS,
58
59
60 WORK_CPU_UNBOUND = NR_CPUS,
61 WORK_CPU_END = NR_CPUS + 1,
62
63
64
65
66
67
68 WORK_STRUCT_FLAG_BITS = WORK_STRUCT_COLOR_SHIFT +
69 WORK_STRUCT_COLOR_BITS,
70
71
72 WORK_OFFQ_FLAG_BASE = WORK_STRUCT_COLOR_SHIFT,
73
74 WORK_OFFQ_CANCELING = (1 << WORK_OFFQ_FLAG_BASE),
75
76
77
78
79
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
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
93 WORK_BUSY_PENDING = 1 << 0,
94 WORK_BUSY_RUNNING = 1 << 1,
95
96
97 WORKER_DESC_LEN = 24,
98};
99
100struct 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
113struct delayed_work {
114 struct work_struct work;
115 struct timer_list timer;
116
117
118 struct workqueue_struct *wq;
119 int cpu;
120};
121
122
123
124
125
126
127
128
129
130struct workqueue_attrs {
131 int nice;
132 cpumask_var_t cpumask;
133 bool no_numa;
134};
135
136static inline struct delayed_work *to_delayed_work(struct work_struct *work)
137{
138 return container_of(work, struct delayed_work, work);
139}
140
141struct execute_work {
142 struct work_struct work;
143};
144
145#ifdef CONFIG_LOCKDEP
146
147
148
149
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
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
192extern void __init_work(struct work_struct *work, int onstack);
193extern void destroy_work_on_stack(struct work_struct *work);
194static inline unsigned int work_static(struct work_struct *work)
195{
196 return *work_data_bits(work) & WORK_STRUCT_STATIC;
197}
198#else
199static inline void __init_work(struct work_struct *work, int onstack) { }
200static inline void destroy_work_on_stack(struct work_struct *work) { }
201static inline unsigned int work_static(struct work_struct *work) { return 0; }
202#endif
203
204
205
206
207
208
209
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
273
274
275#define work_pending(work) \
276 test_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))
277
278
279
280
281
282
283#define delayed_work_pending(w) \
284 work_pending(&(w)->work)
285
286
287
288
289
290#define work_clear_pending(work) \
291 clear_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))
292
293
294
295
296
297enum {
298 WQ_NON_REENTRANT = 1 << 0,
299 WQ_UNBOUND = 1 << 1,
300 WQ_FREEZABLE = 1 << 2,
301 WQ_MEM_RECLAIM = 1 << 3,
302 WQ_HIGHPRI = 1 << 4,
303 WQ_CPU_INTENSIVE = 1 << 5,
304 WQ_SYSFS = 1 << 6,
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331 WQ_POWER_EFFICIENT = 1 << 7,
332
333 __WQ_DRAINING = 1 << 16,
334 __WQ_ORDERED = 1 << 17,
335
336 WQ_MAX_ACTIVE = 512,
337 WQ_MAX_UNBOUND_PER_CPU = 4,
338 WQ_DFL_ACTIVE = WQ_MAX_ACTIVE / 2,
339};
340
341
342#define WQ_UNBOUND_MAX_ACTIVE \
343 max_t(int, WQ_MAX_ACTIVE, num_possible_cpus() * WQ_MAX_UNBOUND_PER_CPU)
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370extern struct workqueue_struct *system_wq;
371extern struct workqueue_struct *system_long_wq;
372extern struct workqueue_struct *system_unbound_wq;
373extern struct workqueue_struct *system_freezable_wq;
374extern struct workqueue_struct *system_power_efficient_wq;
375extern struct workqueue_struct *system_freezable_power_efficient_wq;
376
377static inline struct workqueue_struct * __deprecated __system_nrt_wq(void)
378{
379 return system_wq;
380}
381
382static inline struct workqueue_struct * __deprecated __system_nrt_freezable_wq(void)
383{
384 return system_freezable_wq;
385}
386
387
388#define system_nrt_wq __system_nrt_wq()
389#define system_nrt_freezable_wq __system_nrt_freezable_wq()
390
391extern struct workqueue_struct *
392__alloc_workqueue_key(const char *fmt, unsigned int flags, int max_active,
393 struct lock_class_key *key, const char *lock_name, ...) __printf(1, 6);
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411#ifdef CONFIG_LOCKDEP
412#define alloc_workqueue(fmt, flags, max_active, args...) \
413({ \
414 static struct lock_class_key __key; \
415 const char *__lock_name; \
416 \
417 if (__builtin_constant_p(fmt)) \
418 __lock_name = (fmt); \
419 else \
420 __lock_name = #fmt; \
421 \
422 __alloc_workqueue_key((fmt), (flags), (max_active), \
423 &__key, __lock_name, ##args); \
424})
425#else
426#define alloc_workqueue(fmt, flags, max_active, args...) \
427 __alloc_workqueue_key((fmt), (flags), (max_active), \
428 NULL, NULL, ##args)
429#endif
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444#define alloc_ordered_workqueue(fmt, flags, args...) \
445 alloc_workqueue(fmt, WQ_UNBOUND | __WQ_ORDERED | (flags), 1, ##args)
446
447#define create_workqueue(name) \
448 alloc_workqueue("%s", WQ_MEM_RECLAIM, 1, (name))
449#define create_freezable_workqueue(name) \
450 alloc_workqueue("%s", WQ_FREEZABLE | WQ_UNBOUND | WQ_MEM_RECLAIM, \
451 1, (name))
452#define create_singlethread_workqueue(name) \
453 alloc_workqueue("%s", WQ_UNBOUND | WQ_MEM_RECLAIM, 1, (name))
454
455extern void destroy_workqueue(struct workqueue_struct *wq);
456
457struct workqueue_attrs *alloc_workqueue_attrs(gfp_t gfp_mask);
458void free_workqueue_attrs(struct workqueue_attrs *attrs);
459int apply_workqueue_attrs(struct workqueue_struct *wq,
460 const struct workqueue_attrs *attrs);
461
462extern bool queue_work_on(int cpu, struct workqueue_struct *wq,
463 struct work_struct *work);
464extern bool queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
465 struct delayed_work *work, unsigned long delay);
466extern bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq,
467 struct delayed_work *dwork, unsigned long delay);
468
469extern void flush_workqueue(struct workqueue_struct *wq);
470extern void drain_workqueue(struct workqueue_struct *wq);
471extern void flush_scheduled_work(void);
472
473extern int schedule_on_each_cpu(work_func_t func);
474
475int execute_in_process_context(work_func_t fn, struct execute_work *);
476
477extern bool flush_work(struct work_struct *work);
478extern bool cancel_work_sync(struct work_struct *work);
479
480extern bool flush_delayed_work(struct delayed_work *dwork);
481extern bool cancel_delayed_work(struct delayed_work *dwork);
482extern bool cancel_delayed_work_sync(struct delayed_work *dwork);
483
484extern void workqueue_set_max_active(struct workqueue_struct *wq,
485 int max_active);
486extern bool current_is_workqueue_rescuer(void);
487extern bool workqueue_congested(int cpu, struct workqueue_struct *wq);
488extern unsigned int work_busy(struct work_struct *work);
489extern __printf(1, 2) void set_worker_desc(const char *fmt, ...);
490extern void print_worker_info(const char *log_lvl, struct task_struct *task);
491
492
493
494
495
496
497
498
499
500
501
502static inline bool queue_work(struct workqueue_struct *wq,
503 struct work_struct *work)
504{
505 return queue_work_on(WORK_CPU_UNBOUND, wq, work);
506}
507
508
509
510
511
512
513
514
515
516static inline bool queue_delayed_work(struct workqueue_struct *wq,
517 struct delayed_work *dwork,
518 unsigned long delay)
519{
520 return queue_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay);
521}
522
523
524
525
526
527
528
529
530
531static inline bool mod_delayed_work(struct workqueue_struct *wq,
532 struct delayed_work *dwork,
533 unsigned long delay)
534{
535 return mod_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay);
536}
537
538
539
540
541
542
543
544
545static inline bool schedule_work_on(int cpu, struct work_struct *work)
546{
547 return queue_work_on(cpu, system_wq, work);
548}
549
550
551
552
553
554
555
556
557
558
559
560
561static inline bool schedule_work(struct work_struct *work)
562{
563 return queue_work(system_wq, work);
564}
565
566
567
568
569
570
571
572
573
574
575static inline bool schedule_delayed_work_on(int cpu, struct delayed_work *dwork,
576 unsigned long delay)
577{
578 return queue_delayed_work_on(cpu, system_wq, dwork, delay);
579}
580
581
582
583
584
585
586
587
588
589static inline bool schedule_delayed_work(struct delayed_work *dwork,
590 unsigned long delay)
591{
592 return queue_delayed_work(system_wq, dwork, delay);
593}
594
595
596
597
598static inline bool keventd_up(void)
599{
600 return system_wq != NULL;
601}
602
603
604
605
606
607
608static inline bool __deprecated __cancel_delayed_work(struct delayed_work *work)
609{
610 bool ret;
611
612 ret = del_timer(&work->timer);
613 if (ret)
614 work_clear_pending(&work->work);
615 return ret;
616}
617
618
619static inline bool __deprecated flush_work_sync(struct work_struct *work)
620{
621 return flush_work(work);
622}
623
624
625static inline bool __deprecated flush_delayed_work_sync(struct delayed_work *dwork)
626{
627 return flush_delayed_work(dwork);
628}
629
630#ifndef CONFIG_SMP
631static inline long work_on_cpu(int cpu, long (*fn)(void *), void *arg)
632{
633 return fn(arg);
634}
635#else
636long work_on_cpu(int cpu, long (*fn)(void *), void *arg);
637#endif
638
639#ifdef CONFIG_FREEZER
640extern void freeze_workqueues_begin(void);
641extern bool freeze_workqueues_busy(void);
642extern void thaw_workqueues(void);
643#endif
644
645#ifdef CONFIG_SYSFS
646int workqueue_sysfs_register(struct workqueue_struct *wq);
647#else
648static inline int workqueue_sysfs_register(struct workqueue_struct *wq)
649{ return 0; }
650#endif
651
652#endif
653