Branch data Line data Source code
1 : : /*
2 : : * Generic wait-for-completion handler;
3 : : *
4 : : * It differs from semaphores in that their default case is the opposite,
5 : : * wait_for_completion default blocks whereas semaphore default non-block. The
6 : : * interface also makes it easy to 'complete' multiple waiting threads,
7 : : * something which isn't entirely natural for semaphores.
8 : : *
9 : : * But more importantly, the primitive documents the usage. Semaphores would
10 : : * typically be used for exclusion which gives rise to priority inversion.
11 : : * Waiting for completion is a typically sync point, but not an exclusion point.
12 : : */
13 : :
14 : : #include <linux/sched.h>
15 : : #include <linux/completion.h>
16 : :
17 : : /**
18 : : * complete: - signals a single thread waiting on this completion
19 : : * @x: holds the state of this particular completion
20 : : *
21 : : * This will wake up a single thread waiting on this completion. Threads will be
22 : : * awakened in the same order in which they were queued.
23 : : *
24 : : * See also complete_all(), wait_for_completion() and related routines.
25 : : *
26 : : * It may be assumed that this function implies a write memory barrier before
27 : : * changing the task state if and only if any tasks are woken up.
28 : : */
29 : 0 : void complete(struct completion *x)
30 : : {
31 : : unsigned long flags;
32 : :
33 : 1816524 : spin_lock_irqsave(&x->wait.lock, flags);
34 : 1816524 : x->done++;
35 : 1816524 : __wake_up_locked(&x->wait, TASK_NORMAL, 1);
36 : : spin_unlock_irqrestore(&x->wait.lock, flags);
37 : 1816526 : }
38 : : EXPORT_SYMBOL(complete);
39 : :
40 : : /**
41 : : * complete_all: - signals all threads waiting on this completion
42 : : * @x: holds the state of this particular completion
43 : : *
44 : : * This will wake up all threads waiting on this particular completion event.
45 : : *
46 : : * It may be assumed that this function implies a write memory barrier before
47 : : * changing the task state if and only if any tasks are woken up.
48 : : */
49 : 0 : void complete_all(struct completion *x)
50 : : {
51 : : unsigned long flags;
52 : :
53 : 112 : spin_lock_irqsave(&x->wait.lock, flags);
54 : 112 : x->done += UINT_MAX/2;
55 : 112 : __wake_up_locked(&x->wait, TASK_NORMAL, 0);
56 : : spin_unlock_irqrestore(&x->wait.lock, flags);
57 : 112 : }
58 : : EXPORT_SYMBOL(complete_all);
59 : :
60 : : static inline long __sched
61 : : do_wait_for_common(struct completion *x,
62 : : long (*action)(long), long timeout, int state)
63 : : {
64 [ + + ]: 1810591 : if (!x->done) {
65 : 7184234 : DECLARE_WAITQUEUE(wait, current);
66 : :
67 : : __add_wait_queue_tail_exclusive(&x->wait, &wait);
68 : : do {
69 [ + - ][ + ]: 1781531 : if (signal_pending_state(state, current)) {
70 : : timeout = -ERESTARTSYS;
71 : : break;
72 : : }
73 : 1781533 : __set_current_state(state);
74 : : spin_unlock_irq(&x->wait.lock);
75 : 1781531 : timeout = action(timeout);
76 : : spin_lock_irq(&x->wait.lock);
77 [ - + ]: 1781532 : } while (!x->done && timeout);
[ # # - + ]
[ # # ]
78 : : __remove_wait_queue(&x->wait, &wait);
79 [ - + ][ - + ]: 1781530 : if (!x->done)
80 : 1781530 : return timeout;
81 : : }
82 : 4 : x->done--;
83 [ # # ][ + ]: 4 : return timeout ?: 1;
84 : : }
85 : :
86 : : static inline long __sched
87 : : __wait_for_common(struct completion *x,
88 : : long (*action)(long), long timeout, int state)
89 : : {
90 : : might_sleep();
91 : :
92 : : spin_lock_irq(&x->wait.lock);
93 : : timeout = do_wait_for_common(x, action, timeout, state);
94 : : spin_unlock_irq(&x->wait.lock);
95 : : return timeout;
96 : : }
97 : :
98 : : static long __sched
99 : 0 : wait_for_common(struct completion *x, long timeout, int state)
100 : : {
101 : 1771774 : return __wait_for_common(x, schedule_timeout, timeout, state);
102 : : }
103 : :
104 : : static long __sched
105 : 0 : wait_for_common_io(struct completion *x, long timeout, int state)
106 : : {
107 : 38817 : return __wait_for_common(x, io_schedule_timeout, timeout, state);
108 : : }
109 : :
110 : : /**
111 : : * wait_for_completion: - waits for completion of a task
112 : : * @x: holds the state of this particular completion
113 : : *
114 : : * This waits to be signaled for completion of a specific task. It is NOT
115 : : * interruptible and there is no timeout.
116 : : *
117 : : * See also similar routines (i.e. wait_for_completion_timeout()) with timeout
118 : : * and interrupt capability. Also see complete().
119 : : */
120 : 0 : void __sched wait_for_completion(struct completion *x)
121 : : {
122 : 448704 : wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);
123 : 448705 : }
124 : : EXPORT_SYMBOL(wait_for_completion);
125 : :
126 : : /**
127 : : * wait_for_completion_timeout: - waits for completion of a task (w/timeout)
128 : : * @x: holds the state of this particular completion
129 : : * @timeout: timeout value in jiffies
130 : : *
131 : : * This waits for either a completion of a specific task to be signaled or for a
132 : : * specified timeout to expire. The timeout is in jiffies. It is not
133 : : * interruptible.
134 : : *
135 : : * Return: 0 if timed out, and positive (at least 1, or number of jiffies left
136 : : * till timeout) if completed.
137 : : */
138 : : unsigned long __sched
139 : 0 : wait_for_completion_timeout(struct completion *x, unsigned long timeout)
140 : : {
141 : 0 : return wait_for_common(x, timeout, TASK_UNINTERRUPTIBLE);
142 : : }
143 : : EXPORT_SYMBOL(wait_for_completion_timeout);
144 : :
145 : : /**
146 : : * wait_for_completion_io: - waits for completion of a task
147 : : * @x: holds the state of this particular completion
148 : : *
149 : : * This waits to be signaled for completion of a specific task. It is NOT
150 : : * interruptible and there is no timeout. The caller is accounted as waiting
151 : : * for IO.
152 : : */
153 : 0 : void __sched wait_for_completion_io(struct completion *x)
154 : : {
155 : 38817 : wait_for_common_io(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);
156 : 38817 : }
157 : : EXPORT_SYMBOL(wait_for_completion_io);
158 : :
159 : : /**
160 : : * wait_for_completion_io_timeout: - waits for completion of a task (w/timeout)
161 : : * @x: holds the state of this particular completion
162 : : * @timeout: timeout value in jiffies
163 : : *
164 : : * This waits for either a completion of a specific task to be signaled or for a
165 : : * specified timeout to expire. The timeout is in jiffies. It is not
166 : : * interruptible. The caller is accounted as waiting for IO.
167 : : *
168 : : * Return: 0 if timed out, and positive (at least 1, or number of jiffies left
169 : : * till timeout) if completed.
170 : : */
171 : : unsigned long __sched
172 : 0 : wait_for_completion_io_timeout(struct completion *x, unsigned long timeout)
173 : : {
174 : 0 : return wait_for_common_io(x, timeout, TASK_UNINTERRUPTIBLE);
175 : : }
176 : : EXPORT_SYMBOL(wait_for_completion_io_timeout);
177 : :
178 : : /**
179 : : * wait_for_completion_interruptible: - waits for completion of a task (w/intr)
180 : : * @x: holds the state of this particular completion
181 : : *
182 : : * This waits for completion of a specific task to be signaled. It is
183 : : * interruptible.
184 : : *
185 : : * Return: -ERESTARTSYS if interrupted, 0 if completed.
186 : : */
187 : 0 : int __sched wait_for_completion_interruptible(struct completion *x)
188 : : {
189 : 433704 : long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_INTERRUPTIBLE);
190 [ - + ]: 433704 : if (t == -ERESTARTSYS)
191 : 0 : return t;
192 : : return 0;
193 : : }
194 : : EXPORT_SYMBOL(wait_for_completion_interruptible);
195 : :
196 : : /**
197 : : * wait_for_completion_interruptible_timeout: - waits for completion (w/(to,intr))
198 : : * @x: holds the state of this particular completion
199 : : * @timeout: timeout value in jiffies
200 : : *
201 : : * This waits for either a completion of a specific task to be signaled or for a
202 : : * specified timeout to expire. It is interruptible. The timeout is in jiffies.
203 : : *
204 : : * Return: -ERESTARTSYS if interrupted, 0 if timed out, positive (at least 1,
205 : : * or number of jiffies left till timeout) if completed.
206 : : */
207 : : long __sched
208 : 0 : wait_for_completion_interruptible_timeout(struct completion *x,
209 : : unsigned long timeout)
210 : : {
211 : 877251 : return wait_for_common(x, timeout, TASK_INTERRUPTIBLE);
212 : : }
213 : : EXPORT_SYMBOL(wait_for_completion_interruptible_timeout);
214 : :
215 : : /**
216 : : * wait_for_completion_killable: - waits for completion of a task (killable)
217 : : * @x: holds the state of this particular completion
218 : : *
219 : : * This waits to be signaled for completion of a specific task. It can be
220 : : * interrupted by a kill signal.
221 : : *
222 : : * Return: -ERESTARTSYS if interrupted, 0 if completed.
223 : : */
224 : 0 : int __sched wait_for_completion_killable(struct completion *x)
225 : : {
226 : 12112 : long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_KILLABLE);
227 [ - + ]: 12112 : if (t == -ERESTARTSYS)
228 : 0 : return t;
229 : : return 0;
230 : : }
231 : : EXPORT_SYMBOL(wait_for_completion_killable);
232 : :
233 : : /**
234 : : * wait_for_completion_killable_timeout: - waits for completion of a task (w/(to,killable))
235 : : * @x: holds the state of this particular completion
236 : : * @timeout: timeout value in jiffies
237 : : *
238 : : * This waits for either a completion of a specific task to be
239 : : * signaled or for a specified timeout to expire. It can be
240 : : * interrupted by a kill signal. The timeout is in jiffies.
241 : : *
242 : : * Return: -ERESTARTSYS if interrupted, 0 if timed out, positive (at least 1,
243 : : * or number of jiffies left till timeout) if completed.
244 : : */
245 : : long __sched
246 : 0 : wait_for_completion_killable_timeout(struct completion *x,
247 : : unsigned long timeout)
248 : : {
249 : 0 : return wait_for_common(x, timeout, TASK_KILLABLE);
250 : : }
251 : : EXPORT_SYMBOL(wait_for_completion_killable_timeout);
252 : :
253 : : /**
254 : : * try_wait_for_completion - try to decrement a completion without blocking
255 : : * @x: completion structure
256 : : *
257 : : * Return: 0 if a decrement cannot be done without blocking
258 : : * 1 if a decrement succeeded.
259 : : *
260 : : * If a completion is being used as a counting completion,
261 : : * attempt to decrement the counter without blocking. This
262 : : * enables us to avoid waiting if the resource the completion
263 : : * is protecting is not available.
264 : : */
265 : 0 : bool try_wait_for_completion(struct completion *x)
266 : : {
267 : : unsigned long flags;
268 : : int ret = 1;
269 : :
270 : 0 : spin_lock_irqsave(&x->wait.lock, flags);
271 [ # # ]: 0 : if (!x->done)
272 : : ret = 0;
273 : : else
274 : 0 : x->done--;
275 : : spin_unlock_irqrestore(&x->wait.lock, flags);
276 : 0 : return ret;
277 : : }
278 : : EXPORT_SYMBOL(try_wait_for_completion);
279 : :
280 : : /**
281 : : * completion_done - Test to see if a completion has any waiters
282 : : * @x: completion structure
283 : : *
284 : : * Return: 0 if there are waiters (wait_for_completion() in progress)
285 : : * 1 if there are no waiters.
286 : : *
287 : : */
288 : 0 : bool completion_done(struct completion *x)
289 : : {
290 : : unsigned long flags;
291 : : int ret = 1;
292 : :
293 : 0 : spin_lock_irqsave(&x->wait.lock, flags);
294 [ # # ]: 0 : if (!x->done)
295 : : ret = 0;
296 : : spin_unlock_irqrestore(&x->wait.lock, flags);
297 : 0 : return ret;
298 : : }
299 : : EXPORT_SYMBOL(completion_done);
|
