Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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 <asm/atomic.h>
12
13struct workqueue_struct;
14
15struct work_struct;
16typedef void (*work_func_t)(struct work_struct *work);
17
18/*
19 * The first word is the work queue pointer and the flags rolled into
20 * one
21 */
22#define work_data_bits(work) ((unsigned long *)(&(work)->data))
23
24struct work_struct {
25 atomic_long_t data;
26#define WORK_STRUCT_PENDING 0 /* T if work item pending execution */
27#define WORK_STRUCT_NOAUTOREL 1 /* F if work item automatically released on exec */
28#define WORK_STRUCT_FLAG_MASK (3UL)
29#define WORK_STRUCT_WQ_DATA_MASK (~WORK_STRUCT_FLAG_MASK)
30 struct list_head entry;
31 work_func_t func;
32};
33
34#define WORK_DATA_INIT(autorelease) \
35 ATOMIC_LONG_INIT((autorelease) << WORK_STRUCT_NOAUTOREL)
36
37struct delayed_work {
38 struct work_struct work;
39 struct timer_list timer;
40};
41
42struct execute_work {
43 struct work_struct work;
44};
45
46#define __WORK_INITIALIZER(n, f) { \
47 .data = WORK_DATA_INIT(0), \
48 .entry = { &(n).entry, &(n).entry }, \
49 .func = (f), \
50 }
51
52#define __WORK_INITIALIZER_NAR(n, f) { \
53 .data = WORK_DATA_INIT(1), \
54 .entry = { &(n).entry, &(n).entry }, \
55 .func = (f), \
56 }
57
58#define __DELAYED_WORK_INITIALIZER(n, f) { \
59 .work = __WORK_INITIALIZER((n).work, (f)), \
60 .timer = TIMER_INITIALIZER(NULL, 0, 0), \
61 }
62
63#define __DELAYED_WORK_INITIALIZER_NAR(n, f) { \
64 .work = __WORK_INITIALIZER_NAR((n).work, (f)), \
65 .timer = TIMER_INITIALIZER(NULL, 0, 0), \
66 }
67
68#define DECLARE_WORK(n, f) \
69 struct work_struct n = __WORK_INITIALIZER(n, f)
70
71#define DECLARE_WORK_NAR(n, f) \
72 struct work_struct n = __WORK_INITIALIZER_NAR(n, f)
73
74#define DECLARE_DELAYED_WORK(n, f) \
75 struct delayed_work n = __DELAYED_WORK_INITIALIZER(n, f)
76
77#define DECLARE_DELAYED_WORK_NAR(n, f) \
78 struct dwork_struct n = __DELAYED_WORK_INITIALIZER_NAR(n, f)
79
80/*
81 * initialize a work item's function pointer
82 */
83#define PREPARE_WORK(_work, _func) \
84 do { \
85 (_work)->func = (_func); \
86 } while (0)
87
88#define PREPARE_DELAYED_WORK(_work, _func) \
89 PREPARE_WORK(&(_work)->work, (_func))
90
91/*
92 * initialize all of a work item in one go
93 *
94 * NOTE! No point in using "atomic_long_set()": useing a direct
95 * assignment of the work data initializer allows the compiler
96 * to generate better code.
97 */
98#define INIT_WORK(_work, _func) \
99 do { \
100 (_work)->data = (atomic_long_t) WORK_DATA_INIT(0); \
101 INIT_LIST_HEAD(&(_work)->entry); \
102 PREPARE_WORK((_work), (_func)); \
103 } while (0)
104
105#define INIT_WORK_NAR(_work, _func) \
106 do { \
107 (_work)->data = (atomic_long_t) WORK_DATA_INIT(1); \
108 INIT_LIST_HEAD(&(_work)->entry); \
109 PREPARE_WORK((_work), (_func)); \
110 } while (0)
111
112#define INIT_DELAYED_WORK(_work, _func) \
113 do { \
114 INIT_WORK(&(_work)->work, (_func)); \
115 init_timer(&(_work)->timer); \
116 } while (0)
117
118#define INIT_DELAYED_WORK_NAR(_work, _func) \
119 do { \
120 INIT_WORK_NAR(&(_work)->work, (_func)); \
121 init_timer(&(_work)->timer); \
122 } while (0)
123
124/**
125 * work_pending - Find out whether a work item is currently pending
126 * @work: The work item in question
127 */
128#define work_pending(work) \
129 test_bit(WORK_STRUCT_PENDING, work_data_bits(work))
130
131/**
132 * delayed_work_pending - Find out whether a delayable work item is currently
133 * pending
134 * @work: The work item in question
135 */
136#define delayed_work_pending(w) \
137 work_pending(&(w)->work)
138
139/**
140 * work_release - Release a work item under execution
141 * @work: The work item to release
142 *
143 * This is used to release a work item that has been initialised with automatic
144 * release mode disabled (WORK_STRUCT_NOAUTOREL is set). This gives the work
145 * function the opportunity to grab auxiliary data from the container of the
146 * work_struct before clearing the pending bit as the work_struct may be
147 * subject to deallocation the moment the pending bit is cleared.
148 *
149 * In such a case, this should be called in the work function after it has
150 * fetched any data it may require from the containter of the work_struct.
151 * After this function has been called, the work_struct may be scheduled for
152 * further execution or it may be deallocated unless other precautions are
153 * taken.
154 *
155 * This should also be used to release a delayed work item.
156 */
157#define work_release(work) \
158 clear_bit(WORK_STRUCT_PENDING, work_data_bits(work))
159
160
161extern struct workqueue_struct *__create_workqueue(const char *name,
162 int singlethread,
163 int freezeable);
164#define create_workqueue(name) __create_workqueue((name), 0, 0)
165#define create_freezeable_workqueue(name) __create_workqueue((name), 0, 1)
166#define create_singlethread_workqueue(name) __create_workqueue((name), 1, 0)
167
168extern void destroy_workqueue(struct workqueue_struct *wq);
169
170extern int FASTCALL(queue_work(struct workqueue_struct *wq, struct work_struct *work));
171extern int FASTCALL(queue_delayed_work(struct workqueue_struct *wq, struct delayed_work *work, unsigned long delay));
172extern int queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
173 struct delayed_work *work, unsigned long delay);
174extern void FASTCALL(flush_workqueue(struct workqueue_struct *wq));
175
176extern int FASTCALL(schedule_work(struct work_struct *work));
177extern int FASTCALL(run_scheduled_work(struct work_struct *work));
178extern int FASTCALL(schedule_delayed_work(struct delayed_work *work, unsigned long delay));
179
180extern int schedule_delayed_work_on(int cpu, struct delayed_work *work, unsigned long delay);
181extern int schedule_on_each_cpu(work_func_t func);
182extern void flush_scheduled_work(void);
183extern int current_is_keventd(void);
184extern int keventd_up(void);
185
186extern void init_workqueues(void);
187void cancel_rearming_delayed_work(struct delayed_work *work);
188void cancel_rearming_delayed_workqueue(struct workqueue_struct *,
189 struct delayed_work *);
190int execute_in_process_context(work_func_t fn, struct execute_work *);
191
192/*
193 * Kill off a pending schedule_delayed_work(). Note that the work callback
194 * function may still be running on return from cancel_delayed_work(). Run
195 * flush_scheduled_work() to wait on it.
196 */
197static inline int cancel_delayed_work(struct delayed_work *work)
198{
199 int ret;
200
201 ret = del_timer_sync(&work->timer);
202 if (ret)
203 work_release(&work->work);
204 return ret;
205}
206
207#endif