Whamcloud - gitweb
f0f7f69681f33c82bb234721c07bf5503b661317
[fs/lustre-release.git] / libcfs / include / libcfs / linux / linux-wait.h
1 /* SPDX-License-Identifier: GPL-2.0 */
2 #ifndef __LIBCFS_LINUX_WAIT_BIT_H
3 #define __LIBCFS_LINUX_WAIT_BIT_H
4
5 /* Make sure we can see if we have TASK_NOLOAD */
6 #include <linux/sched.h>
7 /*
8  * Linux wait-bit related types and methods:
9  */
10 #ifdef HAVE_WAIT_BIT_HEADER_H
11 #include <linux/wait_bit.h>
12 #endif
13 #include <linux/wait.h>
14
15 #ifndef HAVE_WAIT_QUEUE_ENTRY
16 #define wait_queue_entry_t wait_queue_t
17 #endif
18
19 #ifndef HAVE_WAIT_BIT_HEADER_H
20 struct wait_bit_queue_entry {
21         struct wait_bit_key     key;
22         wait_queue_entry_t      wq_entry;
23 };
24
25 #define ___wait_is_interruptible(state)                                         \
26         (!__builtin_constant_p(state) ||                                        \
27                 state == TASK_INTERRUPTIBLE || state == TASK_KILLABLE)          \
28
29 #endif /* ! HAVE_WAIT_BIT_HEADER_H */
30
31 #ifndef HAVE_PREPARE_TO_WAIT_EVENT
32 extern long prepare_to_wait_event(wait_queue_head_t *wq_head,
33                                   wait_queue_entry_t *wq_entry, int state);
34 #endif
35
36 /* ___wait_cond_timeout changed number of args in v3.12-rc1-78-g35a2af94c7ce
37  * so let's define our own ___wait_cond_timeout1
38  */
39
40 #define ___wait_cond_timeout1(condition)                                \
41 ({                                                                      \
42         bool __cond = (condition);                                      \
43         if (__cond && !__ret)                                           \
44                 __ret = 1;                                              \
45         __cond || !__ret;                                               \
46 })
47
48 #ifndef HAVE_CLEAR_AND_WAKE_UP_BIT
49 /**
50  * clear_and_wake_up_bit - clear a bit and wake up anyone waiting on that bit
51  *
52  * @bit: the bit of the word being waited on
53  * @word: the word being waited on, a kernel virtual address
54  *
55  * You can use this helper if bitflags are manipulated atomically rather than
56  * non-atomically under a lock.
57  */
58 static inline void clear_and_wake_up_bit(int bit, void *word)
59 {
60         clear_bit_unlock(bit, word);
61         /* See wake_up_bit() for which memory barrier you need to use. */
62         smp_mb__after_atomic();
63         wake_up_bit(word, bit);
64 }
65 #endif /* ! HAVE_CLEAR_AND_WAKE_UP_BIT */
66
67 #ifndef HAVE_WAIT_VAR_EVENT
68 extern void __init wait_bit_init(void);
69 extern void init_wait_var_entry(struct wait_bit_queue_entry *wbq_entry,
70                                 void *var, int flags);
71 extern void wake_up_var(void *var);
72 extern wait_queue_head_t *__var_waitqueue(void *p);
73
74 #define ___wait_var_event(var, condition, state, exclusive, ret, cmd)   \
75 ({                                                                      \
76         __label__ __out;                                                \
77         wait_queue_head_t *__wq_head = __var_waitqueue(var);            \
78         struct wait_bit_queue_entry __wbq_entry;                        \
79         long __ret = ret; /* explicit shadow */                         \
80                                                                         \
81         init_wait_var_entry(&__wbq_entry, var,                          \
82                             exclusive ? WQ_FLAG_EXCLUSIVE : 0);         \
83         for (;;) {                                                      \
84                 long __int = prepare_to_wait_event(__wq_head,           \
85                                                    &__wbq_entry.wq_entry, \
86                                                    state);              \
87                 if (condition)                                          \
88                         break;                                          \
89                                                                         \
90                 if (___wait_is_interruptible(state) && __int) {         \
91                         __ret = __int;                                  \
92                         goto __out;                                     \
93                 }                                                       \
94                                                                         \
95                 cmd;                                                    \
96         }                                                               \
97         finish_wait(__wq_head, &__wbq_entry.wq_entry);                  \
98 __out:  __ret;                                                          \
99 })
100
101 #define __wait_var_event(var, condition)                                \
102         ___wait_var_event(var, condition, TASK_UNINTERRUPTIBLE, 0, 0,   \
103                           schedule())
104
105 #define wait_var_event(var, condition)                                  \
106 do {                                                                    \
107         might_sleep();                                                  \
108         if (condition)                                                  \
109                 break;                                                  \
110         __wait_var_event(var, condition);                               \
111 } while (0)
112
113 #define __wait_var_event_killable(var, condition)                       \
114         ___wait_var_event(var, condition, TASK_KILLABLE, 0, 0,          \
115                           schedule())
116
117 #define wait_var_event_killable(var, condition)                         \
118 ({                                                                      \
119         int __ret = 0;                                                  \
120         might_sleep();                                                  \
121         if (!(condition))                                               \
122                 __ret = __wait_var_event_killable(var, condition);      \
123         __ret;                                                          \
124 })
125
126 #define __wait_var_event_timeout(var, condition, timeout)               \
127         ___wait_var_event(var, ___wait_cond_timeout1(condition),        \
128                           TASK_UNINTERRUPTIBLE, 0, timeout,             \
129                           __ret = schedule_timeout(__ret))
130
131 #define wait_var_event_timeout(var, condition, timeout)                 \
132 ({                                                                      \
133         long __ret = timeout;                                           \
134         might_sleep();                                                  \
135         if (!___wait_cond_timeout1(condition))                          \
136                 __ret = __wait_var_event_timeout(var, condition, timeout); \
137         __ret;                                                          \
138 })
139 #else /* !HAVE_WAIT_VAR_EVENT */
140 /* linux-3.10.0-1062.el7 defines wait_var_event_timeout() using
141  * __wait_cond_timeout(), but doesn't define __wait_cond_timeout !!!
142  */
143 # ifndef __wait_cond_timeout
144 # define ___wait_cond_timeout(condition)                                \
145 ({                                                                      \
146         bool __cond = (condition);                                      \
147         if (__cond && !__ret)                                           \
148                 __ret = 1;                                              \
149         __cond || !__ret;                                               \
150 })
151 # endif /* __wait_cond_timeout */
152
153 #endif /* ! HAVE_WAIT_VAR_EVENT */
154
155 /*
156  * prepare_to_wait_event() does not support an exclusive
157  * lifo wait.
158  * However it will not relink the wait_queue_entry if
159  * it is already linked.  So we link to the head of the
160  * queue here, and it will stay there.
161  */
162 static inline void prepare_to_wait_exclusive_head(
163         wait_queue_head_t *waitq, wait_queue_entry_t *link)
164 {
165         unsigned long flags;
166
167         spin_lock_irqsave(&(waitq->lock), flags);
168 #ifdef HAVE_WAIT_QUEUE_ENTRY_LIST
169         if (list_empty(&link->entry))
170 #else
171         if (list_empty(&link->task_list))
172 #endif
173                 __add_wait_queue_exclusive(waitq, link);
174         spin_unlock_irqrestore(&((waitq)->lock), flags);
175 }
176
177 #ifndef ___wait_event
178 /*
179  * The below macro ___wait_event() has an explicit shadow of the __ret
180  * variable when used from the wait_event_*() macros.
181  *
182  * This is so that both can use the ___wait_cond_timeout1() construct
183  * to wrap the condition.
184  *
185  * The type inconsistency of the wait_event_*() __ret variable is also
186  * on purpose; we use long where we can return timeout values and int
187  * otherwise.
188  */
189
190 #define ___wait_event(wq_head, condition, state, exclusive, ret, cmd)   \
191 ({                                                                      \
192         __label__ __out;                                                \
193         wait_queue_entry_ __wq_entry;                                   \
194         long __ret = ret;       /* explicit shadow */                   \
195                                                                         \
196         init_wait(&__wq_entry);                                         \
197         if (exclusive)                                                  \
198                 __wq_entry.flags = WQ_FLAG_EXCLUSIVE                    \
199         for (;;) {                                                      \
200                 long __int = prepare_to_wait_event(&wq_head,            \
201                                                   &__wq_entry, state);  \
202                                                                         \
203                 if (condition)                                          \
204                         break;                                          \
205                                                                         \
206                 if (___wait_is_interruptible(state) && __int) {         \
207                         __ret = __int;                                  \
208                         goto __out;                                     \
209                 }                                                       \
210                                                                         \
211                 cmd;                                                    \
212         }                                                               \
213         finish_wait(&wq_head, &__wq_entry);                             \
214 __out:  __ret;                                                          \
215 })
216 #endif
217
218 #ifndef TASK_NOLOAD
219
220 #define TASK_IDLE TASK_INTERRUPTIBLE
221
222 #define ___wait_event_idle(wq_head, condition, exclusive, ret, cmd)     \
223 ({                                                                      \
224         wait_queue_entry_t __wq_entry;                                  \
225         unsigned long flags;                                            \
226         long __ret = ret;       /* explicit shadow */                   \
227         sigset_t __old_blocked, __new_blocked;                          \
228                                                                         \
229         siginitset(&__new_blocked, LUSTRE_FATAL_SIGS);                  \
230         sigprocmask(0, &__new_blocked, &__old_blocked);                 \
231         init_wait(&__wq_entry);                                         \
232         if (exclusive)                                                  \
233                 __wq_entry.flags = WQ_FLAG_EXCLUSIVE;                   \
234         for (;;) {                                                      \
235                 prepare_to_wait_event(&wq_head,                         \
236                                    &__wq_entry,                         \
237                                    TASK_INTERRUPTIBLE);                 \
238                                                                         \
239                 if (condition)                                          \
240                         break;                                          \
241                 /* We have to do this here because some signals */      \
242                 /* are not blockable - ie from strace(1).       */      \
243                 /* In these cases we want to schedule_timeout() */      \
244                 /* again, because we don't want that to return  */      \
245                 /* -EINTR when the RPC actually succeeded.      */      \
246                 /* the recalc_sigpending() below will deliver the */    \
247                 /* signal properly.                             */      \
248                 if (signal_pending(current)) {                          \
249                         spin_lock_irqsave(&current->sighand->siglock,   \
250                                           flags);                       \
251                         clear_tsk_thread_flag(current, TIF_SIGPENDING); \
252                         spin_unlock_irqrestore(&current->sighand->siglock,\
253                                                flags);                  \
254                 }                                                       \
255                 cmd;                                                    \
256         }                                                               \
257         finish_wait(&wq_head, &__wq_entry);                             \
258         sigprocmask(SIG_SETMASK, &__old_blocked, NULL);                 \
259         __ret;                                                          \
260 })
261
262 #define wait_event_idle(wq_head, condition)                             \
263 do {                                                                    \
264         might_sleep();                                                  \
265         if (!(condition))                                               \
266                 ___wait_event_idle(wq_head, condition, 0, 0, schedule());\
267 } while (0)
268
269 #define wait_event_idle_exclusive(wq_head, condition)                   \
270 do {                                                                    \
271         might_sleep();                                                  \
272         if (!(condition))                                               \
273                 ___wait_event_idle(wq_head, condition, 1, 0, schedule());\
274 } while (0)
275
276 #define __wait_event_idle_exclusive_timeout(wq_head, condition, timeout)\
277         ___wait_event_idle(wq_head, ___wait_cond_timeout1(condition),   \
278                            1, timeout,                                  \
279                            __ret = schedule_timeout(__ret))
280
281 #define wait_event_idle_exclusive_timeout(wq_head, condition, timeout)  \
282 ({                                                                      \
283         long __ret = timeout;                                           \
284         might_sleep();                                                  \
285         if (!___wait_cond_timeout1(condition))                          \
286                 __ret = __wait_event_idle_exclusive_timeout(            \
287                         wq_head, condition, timeout);                   \
288         __ret;                                                          \
289 })
290
291 #define __wait_event_idle_exclusive_timeout_cmd(wq_head, condition,     \
292                                                 timeout, cmd1, cmd2)    \
293         ___wait_event_idle(wq_head, ___wait_cond_timeout1(condition),   \
294                            1, timeout,                                  \
295                            cmd1; __ret = schedule_timeout(__ret); cmd2)
296
297 #define wait_event_idle_exclusive_timeout_cmd(wq_head, condition, timeout,\
298                                               cmd1, cmd2)               \
299 ({                                                                      \
300         long __ret = timeout;                                           \
301         if (!___wait_cond_timeout1(condition))                          \
302                 __ret = __wait_event_idle_exclusive_timeout_cmd(        \
303                         wq_head, condition, timeout, cmd1, cmd2);       \
304         __ret;                                                          \
305 })
306
307 #define __wait_event_idle_timeout(wq_head, condition, timeout)          \
308         ___wait_event_idle(wq_head, ___wait_cond_timeout1(condition),   \
309                            0, timeout,                                  \
310                            __ret = schedule_timeout(__ret))
311
312 #define wait_event_idle_timeout(wq_head, condition, timeout)            \
313 ({                                                                      \
314         long __ret = timeout;                                           \
315         might_sleep();                                                  \
316         if (!___wait_cond_timeout1(condition))                          \
317                 __ret = __wait_event_idle_timeout(wq_head, condition,   \
318                                                   timeout);             \
319         __ret;                                                          \
320 })
321
322 #else /* TASK_IDLE */
323 #ifndef wait_event_idle
324 /**
325  * wait_event_idle - wait for a condition without contributing to system load
326  * @wq_head: the waitqueue to wait on
327  * @condition: a C expression for the event to wait for
328  *
329  * The process is put to sleep (TASK_IDLE) until the
330  * @condition evaluates to true.
331  * The @condition is checked each time the waitqueue @wq_head is woken up.
332  *
333  * wake_up() has to be called after changing any variable that could
334  * change the result of the wait condition.
335  *
336  */
337 #define wait_event_idle(wq_head, condition)                             \
338 do {                                                                    \
339         might_sleep();                                                  \
340         if (!(condition))                                               \
341                 ___wait_event(wq_head, condition, TASK_IDLE, 0, 0,      \
342                               schedule());                              \
343 } while (0)
344 #endif
345 #ifndef wait_event_idle_exclusive
346 /**
347  * wait_event_idle_exclusive - wait for a condition without contributing to
348  *               system load
349  * @wq_head: the waitqueue to wait on
350  * @condition: a C expression for the event to wait for
351  *
352  * The process is put to sleep (TASK_IDLE) until the
353  * @condition evaluates to true.
354  * The @condition is checked each time the waitqueue @wq_head is woken up.
355  *
356  * The process is put on the wait queue with an WQ_FLAG_EXCLUSIVE flag
357  * set thus if other processes wait on the same list, when this
358  * process is woken further processes are not considered.
359  *
360  * wake_up() has to be called after changing any variable that could
361  * change the result of the wait condition.
362  *
363  */
364 #define wait_event_idle_exclusive(wq_head, condition)                   \
365 do {                                                                    \
366         might_sleep();                                                  \
367         if (!(condition))                                               \
368                 ___wait_event(wq_head, condition, TASK_IDLE, 1, 0,      \
369                               schedule());                              \
370 } while (0)
371 #endif
372 #ifndef wait_event_idle_exclusive_timeout
373 /**
374  * wait_event_idle_exclusive_timeout - sleep without load until a condition
375  *                       becomes true or a timeout elapses
376  * @wq_head: the waitqueue to wait on
377  * @condition: a C expression for the event to wait for
378  * @timeout: timeout, in jiffies
379  *
380  * The process is put to sleep (TASK_IDLE) until the
381  * @condition evaluates to true. The @condition is checked each time
382  * the waitqueue @wq_head is woken up.
383  *
384  * The process is put on the wait queue with an WQ_FLAG_EXCLUSIVE flag
385  * set thus if other processes wait on the same list, when this
386  * process is woken further processes are not considered.
387  *
388  * wake_up() has to be called after changing any variable that could
389  * change the result of the wait condition.
390  *
391  * Returns:
392  * 0 if the @condition evaluated to %false after the @timeout elapsed,
393  * 1 if the @condition evaluated to %true after the @timeout elapsed,
394  * or the remaining jiffies (at least 1) if the @condition evaluated
395  * to %true before the @timeout elapsed.
396  */
397 #define wait_event_idle_exclusive_timeout(wq_head, condition, timeout)  \
398 ({                                                                      \
399         long __ret = timeout;                                           \
400         might_sleep();                                                  \
401         if (!___wait_cond_timeout1(condition))                          \
402                 __ret = __wait_event_idle_exclusive_timeout(wq_head,    \
403                                                             condition,  \
404                                                             timeout);   \
405         __ret;                                                          \
406 })
407 #endif
408 #ifndef wait_event_idle_exclusive_timeout_cmd
409 #define __wait_event_idle_exclusive_timeout_cmd(wq_head, condition,     \
410                                                 timeout, cmd1, cmd2)    \
411         ___wait_event(wq_head, ___wait_cond_timeout1(condition),        \
412                       TASK_IDLE, 1, timeout,                            \
413                       cmd1; __ret = schedule_timeout(__ret); cmd2)
414
415 #define wait_event_idle_exclusive_timeout_cmd(wq_head, condition, timeout,\
416                                               cmd1, cmd2)               \
417 ({                                                                      \
418         long __ret = timeout;                                           \
419         if (!___wait_cond_timeout1(condition))                          \
420                 __ret = __wait_event_idle_exclusive_timeout_cmd(        \
421                         wq_head, condition, timeout, cmd1, cmd2);       \
422         __ret;                                                          \
423 })
424 #endif
425
426 #ifndef wait_event_idle_timeout
427
428 #define __wait_event_idle_timeout(wq_head, condition, timeout)          \
429         ___wait_event(wq_head, ___wait_cond_timeout1(condition),        \
430                       TASK_IDLE, 0, timeout,                            \
431                       __ret = schedule_timeout(__ret))
432
433 /**
434  * wait_event_idle_timeout - sleep without load until a condition becomes
435  *                           true or a timeout elapses
436  * @wq_head: the waitqueue to wait on
437  * @condition: a C expression for the event to wait for
438  * @timeout: timeout, in jiffies
439  *
440  * The process is put to sleep (TASK_IDLE) until the
441  * @condition evaluates to true. The @condition is checked each time
442  * the waitqueue @wq_head is woken up.
443  *
444  * wake_up() has to be called after changing any variable that could
445  * change the result of the wait condition.
446  *
447  * Returns:
448  * 0 if the @condition evaluated to %false after the @timeout elapsed,
449  * 1 if the @condition evaluated to %true after the @timeout elapsed,
450  * or the remaining jiffies (at least 1) if the @condition evaluated
451  * to %true before the @timeout elapsed.
452  */
453 #define wait_event_idle_timeout(wq_head, condition, timeout)            \
454 ({                                                                      \
455         long __ret = timeout;                                           \
456         might_sleep();                                                  \
457         if (!___wait_cond_timeout1(condition))                          \
458                 __ret = __wait_event_idle_timeout(wq_head, condition,   \
459                                                   timeout);             \
460         __ret;                                                          \
461 })
462 #endif
463 #endif /* TASK_IDLE */
464
465 /* ___wait_event_lifo is used for lifo exclusive 'idle' waits */
466 #ifdef TASK_NOLOAD
467
468 #define ___wait_event_lifo(wq_head, condition, ret, cmd)                \
469 ({                                                                      \
470         wait_queue_entry_t       __wq_entry;                            \
471         long __ret = ret;       /* explicit shadow */                   \
472                                                                         \
473         init_wait(&__wq_entry);                                         \
474         __wq_entry.flags =  WQ_FLAG_EXCLUSIVE;                          \
475         for (;;) {                                                      \
476                 prepare_to_wait_exclusive_head(&wq_head, &__wq_entry);  \
477                 prepare_to_wait_event(&wq_head, &__wq_entry, TASK_IDLE);\
478                                                                         \
479                 if (condition)                                          \
480                         break;                                          \
481                                                                         \
482                 cmd;                                                    \
483         }                                                               \
484         finish_wait(&wq_head, &__wq_entry);                             \
485         __ret;                                                          \
486 })
487 #else
488 #define ___wait_event_lifo(wq_head, condition, ret, cmd)                \
489 ({                                                                      \
490         wait_queue_entry_t __wq_entry;                                  \
491         unsigned long flags;                                            \
492         long __ret = ret;       /* explicit shadow */                   \
493         sigset_t __old_blocked, __new_blocked;                          \
494                                                                         \
495         siginitset(&__new_blocked, LUSTRE_FATAL_SIGS);                  \
496         sigprocmask(0, &__new_blocked, &__old_blocked);                 \
497         init_wait(&__wq_entry);                                         \
498         __wq_entry.flags = WQ_FLAG_EXCLUSIVE;                           \
499         for (;;) {                                                      \
500                 prepare_to_wait_exclusive_head(&wq_head, &__wq_entry);  \
501                 prepare_to_wait_event(&wq_head, &__wq_entry,            \
502                                       TASK_INTERRUPTIBLE);              \
503                                                                         \
504                 if (condition)                                          \
505                         break;                                          \
506                 /* See justification in ___wait_event_idle */           \
507                 if (signal_pending(current)) {                          \
508                         spin_lock_irqsave(&current->sighand->siglock,   \
509                                           flags);                       \
510                         clear_tsk_thread_flag(current, TIF_SIGPENDING); \
511                         spin_unlock_irqrestore(&current->sighand->siglock,\
512                                                flags);                  \
513                 }                                                       \
514                 cmd;                                                    \
515         }                                                               \
516         sigprocmask(SIG_SETMASK, &__old_blocked, NULL);                 \
517         finish_wait(&wq_head, &__wq_entry);                             \
518         __ret;                                                          \
519 })
520 #endif
521
522 #define wait_event_idle_exclusive_lifo(wq_head, condition)              \
523 do {                                                                    \
524         might_sleep();                                                  \
525         if (!(condition))                                               \
526                 ___wait_event_lifo(wq_head, condition, 0, schedule());  \
527 } while (0)
528
529 #define __wait_event_idle_lifo_timeout(wq_head, condition, timeout)     \
530         ___wait_event_lifo(wq_head, ___wait_cond_timeout1(condition),   \
531                            timeout,                                     \
532                            __ret = schedule_timeout(__ret))
533
534 #define wait_event_idle_exclusive_lifo_timeout(wq_head, condition, timeout)\
535 ({                                                                      \
536         long __ret = timeout;                                           \
537         might_sleep();                                                  \
538         if (!___wait_cond_timeout1(condition))                          \
539                 __ret = __wait_event_idle_lifo_timeout(wq_head,         \
540                                                        condition,       \
541                                                        timeout);        \
542         __ret;                                                          \
543 })
544
545 /* l_wait_event_abortable() is a bit like wait_event_killable()
546  * except there is a fixed set of signals which will abort:
547  * LUSTRE_FATAL_SIGS
548  */
549 #define LUSTRE_FATAL_SIGS                                        \
550         (sigmask(SIGKILL) | sigmask(SIGINT) | sigmask(SIGTERM) | \
551          sigmask(SIGQUIT) | sigmask(SIGALRM))
552
553 #define l_wait_event_abortable(wq, condition)                           \
554 ({                                                                      \
555         sigset_t __new_blocked, __old_blocked;                          \
556         int __ret = 0;                                                  \
557         siginitsetinv(&__new_blocked, LUSTRE_FATAL_SIGS);               \
558         sigprocmask(SIG_BLOCK, &__new_blocked, &__old_blocked);         \
559         __ret = wait_event_interruptible(wq, condition);                \
560         sigprocmask(SIG_SETMASK, &__old_blocked, NULL);                 \
561         __ret;                                                          \
562 })
563
564 #define l_wait_event_abortable_timeout(wq, condition, timeout)          \
565 ({                                                                      \
566         sigset_t __new_blocked, __old_blocked;                          \
567         int __ret = 0;                                                  \
568         siginitsetinv(&__new_blocked, LUSTRE_FATAL_SIGS);               \
569         sigprocmask(SIG_BLOCK, &__new_blocked, &__old_blocked);         \
570         __ret = wait_event_interruptible_timeout(wq, condition, timeout);\
571         sigprocmask(SIG_SETMASK, &__old_blocked, NULL);                 \
572         __ret;                                                          \
573 })
574
575 #define l_wait_event_abortable_exclusive(wq, condition)                 \
576 ({                                                                      \
577         sigset_t __new_blocked, __old_blocked;                          \
578         int __ret = 0;                                                  \
579         siginitsetinv(&__new_blocked, LUSTRE_FATAL_SIGS);               \
580         sigprocmask(SIG_BLOCK, &__new_blocked, &__old_blocked);         \
581         __ret = wait_event_interruptible_exclusive(wq, condition);      \
582         sigprocmask(SIG_SETMASK, &__old_blocked, NULL);                 \
583         __ret;                                                          \
584 })
585
586 #endif /* __LICBFS_LINUX_WAIT_BIT_H */