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 <asm/atomic.h>
14
15struct workqueue_struct;
16
17struct work_struct;
18typedef void (*work_func_t)(struct work_struct *work);
19
20
21
22
23
24#define work_data_bits(work) ((unsigned long *)(&(work)->data))
25
26enum {
27 WORK_STRUCT_PENDING_BIT = 0,
28 WORK_STRUCT_DELAYED_BIT = 1,
29 WORK_STRUCT_CWQ_BIT = 2,
30 WORK_STRUCT_LINKED_BIT = 3,
31#ifdef CONFIG_DEBUG_OBJECTS_WORK
32 WORK_STRUCT_STATIC_BIT = 4,
33 WORK_STRUCT_COLOR_SHIFT = 5,
34#else
35 WORK_STRUCT_COLOR_SHIFT = 4,
36#endif
37
38 WORK_STRUCT_COLOR_BITS = 4,
39
40 WORK_STRUCT_PENDING = 1 << WORK_STRUCT_PENDING_BIT,
41 WORK_STRUCT_DELAYED = 1 << WORK_STRUCT_DELAYED_BIT,
42 WORK_STRUCT_CWQ = 1 << WORK_STRUCT_CWQ_BIT,
43 WORK_STRUCT_LINKED = 1 << WORK_STRUCT_LINKED_BIT,
44#ifdef CONFIG_DEBUG_OBJECTS_WORK
45 WORK_STRUCT_STATIC = 1 << WORK_STRUCT_STATIC_BIT,
46#else
47 WORK_STRUCT_STATIC = 0,
48#endif
49
50
51
52
53
54 WORK_NR_COLORS = (1 << WORK_STRUCT_COLOR_BITS) - 1,
55 WORK_NO_COLOR = WORK_NR_COLORS,
56
57
58 WORK_CPU_UNBOUND = NR_CPUS,
59 WORK_CPU_NONE = NR_CPUS + 1,
60 WORK_CPU_LAST = WORK_CPU_NONE,
61
62
63
64
65
66
67 WORK_STRUCT_FLAG_BITS = WORK_STRUCT_COLOR_SHIFT +
68 WORK_STRUCT_COLOR_BITS,
69
70 WORK_STRUCT_FLAG_MASK = (1UL << WORK_STRUCT_FLAG_BITS) - 1,
71 WORK_STRUCT_WQ_DATA_MASK = ~WORK_STRUCT_FLAG_MASK,
72 WORK_STRUCT_NO_CPU = WORK_CPU_NONE << WORK_STRUCT_FLAG_BITS,
73
74
75 WORK_BUSY_PENDING = 1 << 0,
76 WORK_BUSY_RUNNING = 1 << 1,
77};
78
79struct work_struct {
80 atomic_long_t data;
81 struct list_head entry;
82 work_func_t func;
83#ifdef CONFIG_LOCKDEP
84 struct lockdep_map lockdep_map;
85#endif
86};
87
88#define WORK_DATA_INIT() ATOMIC_LONG_INIT(WORK_STRUCT_NO_CPU)
89#define WORK_DATA_STATIC_INIT() \
90 ATOMIC_LONG_INIT(WORK_STRUCT_NO_CPU | WORK_STRUCT_STATIC)
91
92struct delayed_work {
93 struct work_struct work;
94 struct timer_list timer;
95};
96
97static inline struct delayed_work *to_delayed_work(struct work_struct *work)
98{
99 return container_of(work, struct delayed_work, work);
100}
101
102struct execute_work {
103 struct work_struct work;
104};
105
106#ifdef CONFIG_LOCKDEP
107
108
109
110
111
112#define __WORK_INIT_LOCKDEP_MAP(n, k) \
113 .lockdep_map = STATIC_LOCKDEP_MAP_INIT(n, k),
114#else
115#define __WORK_INIT_LOCKDEP_MAP(n, k)
116#endif
117
118#define __WORK_INITIALIZER(n, f) { \
119 .data = WORK_DATA_STATIC_INIT(), \
120 .entry = { &(n).entry, &(n).entry }, \
121 .func = (f), \
122 __WORK_INIT_LOCKDEP_MAP(#n, &(n)) \
123 }
124
125#define __DELAYED_WORK_INITIALIZER(n, f) { \
126 .work = __WORK_INITIALIZER((n).work, (f)), \
127 .timer = TIMER_INITIALIZER(NULL, 0, 0), \
128 }
129
130#define __DEFERRED_WORK_INITIALIZER(n, f) { \
131 .work = __WORK_INITIALIZER((n).work, (f)), \
132 .timer = TIMER_DEFERRED_INITIALIZER(NULL, 0, 0), \
133 }
134
135#define DECLARE_WORK(n, f) \
136 struct work_struct n = __WORK_INITIALIZER(n, f)
137
138#define DECLARE_DELAYED_WORK(n, f) \
139 struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f)
140
141#define DECLARE_DEFERRED_WORK(n, f) \
142 struct delayed_work n = __DEFERRED_WORK_INITIALIZER(n, f)
143
144
145
146
147#define PREPARE_WORK(_work, _func) \
148 do { \
149 (_work)->func = (_func); \
150 } while (0)
151
152#define PREPARE_DELAYED_WORK(_work, _func) \
153 PREPARE_WORK(&(_work)->work, (_func))
154
155#ifdef CONFIG_DEBUG_OBJECTS_WORK
156extern void __init_work(struct work_struct *work, int onstack);
157extern void destroy_work_on_stack(struct work_struct *work);
158static inline unsigned int work_static(struct work_struct *work)
159{
160 return *work_data_bits(work) & WORK_STRUCT_STATIC;
161}
162#else
163static inline void __init_work(struct work_struct *work, int onstack) { }
164static inline void destroy_work_on_stack(struct work_struct *work) { }
165static inline unsigned int work_static(struct work_struct *work) { return 0; }
166#endif
167
168
169
170
171
172
173
174
175#ifdef CONFIG_LOCKDEP
176#define __INIT_WORK(_work, _func, _onstack) \
177 do { \
178 static struct lock_class_key __key; \
179 \
180 __init_work((_work), _onstack); \
181 (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \
182 lockdep_init_map(&(_work)->lockdep_map, #_work, &__key, 0);\
183 INIT_LIST_HEAD(&(_work)->entry); \
184 PREPARE_WORK((_work), (_func)); \
185 } while (0)
186#else
187#define __INIT_WORK(_work, _func, _onstack) \
188 do { \
189 __init_work((_work), _onstack); \
190 (_work)->data = (atomic_long_t) WORK_DATA_INIT(); \
191 INIT_LIST_HEAD(&(_work)->entry); \
192 PREPARE_WORK((_work), (_func)); \
193 } while (0)
194#endif
195
196#define INIT_WORK(_work, _func) \
197 do { \
198 __INIT_WORK((_work), (_func), 0); \
199 } while (0)
200
201#define INIT_WORK_ONSTACK(_work, _func) \
202 do { \
203 __INIT_WORK((_work), (_func), 1); \
204 } while (0)
205
206#define INIT_DELAYED_WORK(_work, _func) \
207 do { \
208 INIT_WORK(&(_work)->work, (_func)); \
209 init_timer(&(_work)->timer); \
210 } while (0)
211
212#define INIT_DELAYED_WORK_ONSTACK(_work, _func) \
213 do { \
214 INIT_WORK_ONSTACK(&(_work)->work, (_func)); \
215 init_timer_on_stack(&(_work)->timer); \
216 } while (0)
217
218#define INIT_DELAYED_WORK_DEFERRABLE(_work, _func) \
219 do { \
220 INIT_WORK(&(_work)->work, (_func)); \
221 init_timer_deferrable(&(_work)->timer); \
222 } while (0)
223
224
225
226
227
228#define work_pending(work) \
229 test_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))
230
231
232
233
234
235
236#define delayed_work_pending(w) \
237 work_pending(&(w)->work)
238
239
240
241
242
243#define work_clear_pending(work) \
244 clear_bit(WORK_STRUCT_PENDING_BIT, work_data_bits(work))
245
246
247
248
249
250enum {
251 WQ_NON_REENTRANT = 1 << 0,
252 WQ_UNBOUND = 1 << 1,
253 WQ_FREEZABLE = 1 << 2,
254 WQ_MEM_RECLAIM = 1 << 3,
255 WQ_HIGHPRI = 1 << 4,
256 WQ_CPU_INTENSIVE = 1 << 5,
257
258 WQ_DYING = 1 << 6,
259 WQ_RESCUER = 1 << 7,
260
261 WQ_MAX_ACTIVE = 512,
262 WQ_MAX_UNBOUND_PER_CPU = 4,
263 WQ_DFL_ACTIVE = WQ_MAX_ACTIVE / 2,
264};
265
266
267#define WQ_UNBOUND_MAX_ACTIVE \
268 max_t(int, WQ_MAX_ACTIVE, num_possible_cpus() * WQ_MAX_UNBOUND_PER_CPU)
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290extern struct workqueue_struct *system_wq;
291extern struct workqueue_struct *system_long_wq;
292extern struct workqueue_struct *system_nrt_wq;
293extern struct workqueue_struct *system_unbound_wq;
294
295extern struct workqueue_struct *
296__alloc_workqueue_key(const char *name, unsigned int flags, int max_active,
297 struct lock_class_key *key, const char *lock_name);
298
299#ifdef CONFIG_LOCKDEP
300#define alloc_workqueue(name, flags, max_active) \
301({ \
302 static struct lock_class_key __key; \
303 const char *__lock_name; \
304 \
305 if (__builtin_constant_p(name)) \
306 __lock_name = (name); \
307 else \
308 __lock_name = #name; \
309 \
310 __alloc_workqueue_key((name), (flags), (max_active), \
311 &__key, __lock_name); \
312})
313#else
314#define alloc_workqueue(name, flags, max_active) \
315 __alloc_workqueue_key((name), (flags), (max_active), NULL, NULL)
316#endif
317
318
319
320
321
322
323
324
325
326
327
328
329
330static inline struct workqueue_struct *
331alloc_ordered_workqueue(const char *name, unsigned int flags)
332{
333 return alloc_workqueue(name, WQ_UNBOUND | flags, 1);
334}
335
336#define create_workqueue(name) \
337 alloc_workqueue((name), WQ_MEM_RECLAIM, 1)
338#define create_freezable_workqueue(name) \
339 alloc_workqueue((name), WQ_FREEZABLE | WQ_UNBOUND | WQ_MEM_RECLAIM, 1)
340#define create_singlethread_workqueue(name) \
341 alloc_workqueue((name), WQ_UNBOUND | WQ_MEM_RECLAIM, 1)
342
343extern void destroy_workqueue(struct workqueue_struct *wq);
344
345extern int queue_work(struct workqueue_struct *wq, struct work_struct *work);
346extern int queue_work_on(int cpu, struct workqueue_struct *wq,
347 struct work_struct *work);
348extern int queue_delayed_work(struct workqueue_struct *wq,
349 struct delayed_work *work, unsigned long delay);
350extern int queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
351 struct delayed_work *work, unsigned long delay);
352
353extern void flush_workqueue(struct workqueue_struct *wq);
354extern void flush_scheduled_work(void);
355
356extern int schedule_work(struct work_struct *work);
357extern int schedule_work_on(int cpu, struct work_struct *work);
358extern int schedule_delayed_work(struct delayed_work *work, unsigned long delay);
359extern int schedule_delayed_work_on(int cpu, struct delayed_work *work,
360 unsigned long delay);
361extern int schedule_on_each_cpu(work_func_t func);
362extern int keventd_up(void);
363
364int execute_in_process_context(work_func_t fn, struct execute_work *);
365
366extern bool flush_work(struct work_struct *work);
367extern bool flush_work_sync(struct work_struct *work);
368extern bool cancel_work_sync(struct work_struct *work);
369
370extern bool flush_delayed_work(struct delayed_work *dwork);
371extern bool flush_delayed_work_sync(struct delayed_work *work);
372extern bool cancel_delayed_work_sync(struct delayed_work *dwork);
373
374extern void workqueue_set_max_active(struct workqueue_struct *wq,
375 int max_active);
376extern bool workqueue_congested(unsigned int cpu, struct workqueue_struct *wq);
377extern unsigned int work_cpu(struct work_struct *work);
378extern unsigned int work_busy(struct work_struct *work);
379
380
381
382
383
384
385
386static inline bool cancel_delayed_work(struct delayed_work *work)
387{
388 bool ret;
389
390 ret = del_timer_sync(&work->timer);
391 if (ret)
392 work_clear_pending(&work->work);
393 return ret;
394}
395
396
397
398
399
400
401static inline bool __cancel_delayed_work(struct delayed_work *work)
402{
403 bool ret;
404
405 ret = del_timer(&work->timer);
406 if (ret)
407 work_clear_pending(&work->work);
408 return ret;
409}
410
411
412static inline __deprecated
413void cancel_rearming_delayed_workqueue(struct workqueue_struct *wq,
414 struct delayed_work *work)
415{
416 cancel_delayed_work_sync(work);
417}
418
419
420static inline __deprecated
421void cancel_rearming_delayed_work(struct delayed_work *work)
422{
423 cancel_delayed_work_sync(work);
424}
425
426#ifndef CONFIG_SMP
427static inline long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg)
428{
429 return fn(arg);
430}
431#else
432long work_on_cpu(unsigned int cpu, long (*fn)(void *), void *arg);
433#endif
434
435#ifdef CONFIG_FREEZER
436extern void freeze_workqueues_begin(void);
437extern bool freeze_workqueues_busy(void);
438extern void thaw_workqueues(void);
439#endif
440
441#endif
442