File: /Users/paulross/dev/linux/linux-3.13/include/linux/wait.h

Green shading in the line number column means the source is part of the translation unit, red means it is conditionally excluded. Highlighted line numbers link to the translation unit page. Highlighted macros link to the macro page.

       1: #ifndef _LINUX_WAIT_H
       2: #define _LINUX_WAIT_H
       3: /*
       4:  * Linux wait queue related types and methods
       5:  */
       6: #include <linux/list.h>
       7: #include <linux/stddef.h>
       8: #include <linux/spinlock.h>
       9: #include <asm/current.h>
      10: #include <uapi/linux/wait.h>
      11: 
      12: typedef struct __wait_queue wait_queue_t;
      13: typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int flags, void *key);
      14: int default_wake_function(wait_queue_t *wait, unsigned mode, int flags, void *key);
      15: 
      16: struct __wait_queue {
      17:     unsigned int        flags;
      18: #define WQ_FLAG_EXCLUSIVE    0x01
      19:     void            *private;
      20:     wait_queue_func_t    func;
      21:     struct list_head    task_list;
      22: };
      23: 
      24: struct wait_bit_key {
      25:     void            *flags;
      26:     int            bit_nr;
      27: #define WAIT_ATOMIC_T_BIT_NR    -1
      28: };
      29: 
      30: struct wait_bit_queue {
      31:     struct wait_bit_key    key;
      32:     wait_queue_t        wait;
      33: };
      34: 
      35: struct __wait_queue_head {
      36:     spinlock_t        lock;
      37:     struct list_head    task_list;
      38: };
      39: typedef struct __wait_queue_head wait_queue_head_t;
      40: 
      41: struct task_struct;
      42: 
      43: /*
      44:  * Macros for declaration and initialisaton of the datatypes
      45:  */
      46: 
      47: #define __WAITQUEUE_INITIALIZER(name, tsk) {                \
      48:     .private    = tsk,                        \
      49:     .func        = default_wake_function,            \
      50:     .task_list    = { NULL, NULL } }
      51: 
      52: #define DECLARE_WAITQUEUE(name, tsk)                    \
      53:     wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk)
      54: 
      55: #define __WAIT_QUEUE_HEAD_INITIALIZER(name) {                \
      56:     .lock        = __SPIN_LOCK_UNLOCKED(name.lock),        \
      57:     .task_list    = { &(name).task_list, &(name).task_list } }
      58: 
      59: #define DECLARE_WAIT_QUEUE_HEAD(name) \
      60:     wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)
      61: 
      62: #define __WAIT_BIT_KEY_INITIALIZER(word, bit)                \
      63:     { .flags = word, .bit_nr = bit, }
      64: 
      65: #define __WAIT_ATOMIC_T_KEY_INITIALIZER(p)                \
      66:     { .flags = p, .bit_nr = WAIT_ATOMIC_T_BIT_NR, }
      67: 
      68: extern void __init_waitqueue_head(wait_queue_head_t *q, const char *name, struct lock_class_key *);
      69: 
      70: #define init_waitqueue_head(q)                \
      71:     do {                        \
      72:         static struct lock_class_key __key;    \
      73:                             \
      74:         __init_waitqueue_head((q), #q, &__key);    \
      75:     } while (0)
      76: 
      77: #ifdef CONFIG_LOCKDEP
      78: # define __WAIT_QUEUE_HEAD_INIT_ONSTACK(name) \
      79:     ({ init_waitqueue_head(&name); name; })
      80: # define DECLARE_WAIT_QUEUE_HEAD_ONSTACK(name) \
      81:     wait_queue_head_t name = __WAIT_QUEUE_HEAD_INIT_ONSTACK(name)
      82: #else
      83: # define DECLARE_WAIT_QUEUE_HEAD_ONSTACK(name) DECLARE_WAIT_QUEUE_HEAD(name)
      84: #endif
      85: 
      86: static inline void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p)
      87: {
      88:     q->flags    = 0;
      89:     q->private    = p;
      90:     q->func        = default_wake_function;
      91: }
      92: 
      93: static inline void
      94: init_waitqueue_func_entry(wait_queue_t *q, wait_queue_func_t func)
      95: {
      96:     q->flags    = 0;
      97:     q->private    = NULL;
      98:     q->func        = func;
      99: }
     100: 
     101: static inline int waitqueue_active(wait_queue_head_t *q)
     102: {
     103:     return !list_empty(&q->task_list);
     104: }
     105: 
     106: extern void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);
     107: extern void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait);
     108: extern void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);
     109: 
     110: static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)
     111: {
     112:     list_add(&new->task_list, &head->task_list);
     113: }
     114: 
     115: /*
     116:  * Used for wake-one threads:
     117:  */
     118: static inline void
     119: __add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait)
     120: {
     121:     wait->flags |= WQ_FLAG_EXCLUSIVE;
     122:     __add_wait_queue(q, wait);
     123: }
     124: 
     125: static inline void __add_wait_queue_tail(wait_queue_head_t *head,
     126:                      wait_queue_t *new)
     127: {
     128:     list_add_tail(&new->task_list, &head->task_list);
     129: }
     130: 
     131: static inline void
     132: __add_wait_queue_tail_exclusive(wait_queue_head_t *q, wait_queue_t *wait)
     133: {
     134:     wait->flags |= WQ_FLAG_EXCLUSIVE;
     135:     __add_wait_queue_tail(q, wait);
     136: }
     137: 
     138: static inline void
     139: __remove_wait_queue(wait_queue_head_t *head, wait_queue_t *old)
     140: {
     141:     list_del(&old->task_list);
     142: }
     143: 
     144: void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr, void *key);
     145: void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key);
     146: void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode, int nr, void *key);
     147: void __wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr);
     148: void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr);
     149: void __wake_up_bit(wait_queue_head_t *, void *, int);
     150: int __wait_on_bit(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned);
     151: int __wait_on_bit_lock(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned);
     152: void wake_up_bit(void *, int);
     153: void wake_up_atomic_t(atomic_t *);
     154: int out_of_line_wait_on_bit(void *, int, int (*)(void *), unsigned);
     155: int out_of_line_wait_on_bit_lock(void *, int, int (*)(void *), unsigned);
     156: int out_of_line_wait_on_atomic_t(atomic_t *, int (*)(atomic_t *), unsigned);
     157: wait_queue_head_t *bit_waitqueue(void *, int);
     158: 
     159: #define wake_up(x)            __wake_up(x, TASK_NORMAL, 1, NULL)
     160: #define wake_up_nr(x, nr)        __wake_up(x, TASK_NORMAL, nr, NULL)
     161: #define wake_up_all(x)            __wake_up(x, TASK_NORMAL, 0, NULL)
     162: #define wake_up_locked(x)        __wake_up_locked((x), TASK_NORMAL, 1)
     163: #define wake_up_all_locked(x)        __wake_up_locked((x), TASK_NORMAL, 0)
     164: 
     165: #define wake_up_interruptible(x)    __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
     166: #define wake_up_interruptible_nr(x, nr)    __wake_up(x, TASK_INTERRUPTIBLE, nr, NULL)
     167: #define wake_up_interruptible_all(x)    __wake_up(x, TASK_INTERRUPTIBLE, 0, NULL)
     168: #define wake_up_interruptible_sync(x)    __wake_up_sync((x), TASK_INTERRUPTIBLE, 1)
     169: 
     170: /*
     171:  * Wakeup macros to be used to report events to the targets.
     172:  */
     173: #define wake_up_poll(x, m)                        \
     174:     __wake_up(x, TASK_NORMAL, 1, (void *) (m))
     175: #define wake_up_locked_poll(x, m)                    \
     176:     __wake_up_locked_key((x), TASK_NORMAL, (void *) (m))
     177: #define wake_up_interruptible_poll(x, m)                \
     178:     __wake_up(x, TASK_INTERRUPTIBLE, 1, (void *) (m))
     179: #define wake_up_interruptible_sync_poll(x, m)                \
     180:     __wake_up_sync_key((x), TASK_INTERRUPTIBLE, 1, (void *) (m))
     181: 
     182: #define ___wait_cond_timeout(condition)                    \
     183: ({                                    \
     184:     bool __cond = (condition);                    \
     185:     if (__cond && !__ret)                        \
     186:         __ret = 1;                        \
     187:     __cond || !__ret;                        \
     188: })
     189: 
     190: #define ___wait_is_interruptible(state)                    \
     191:     (!__builtin_constant_p(state) ||                \
     192:         state == TASK_INTERRUPTIBLE || state == TASK_KILLABLE)    \
     193: 
     194: #define ___wait_event(wq, condition, state, exclusive, ret, cmd)    \
     195: ({                                    \
     196:     __label__ __out;                        \
     197:     wait_queue_t __wait;                        \
     198:     long __ret = ret;                        \
     199:                                     \
     200:     INIT_LIST_HEAD(&__wait.task_list);                \
     201:     if (exclusive)                            \
     202:         __wait.flags = WQ_FLAG_EXCLUSIVE;            \
     203:     else                                \
     204:         __wait.flags = 0;                    \
     205:                                     \
     206:     for (;;) {                            \
     207:         long __int = prepare_to_wait_event(&wq, &__wait, state);\
                                    \
     209:         if (condition)                        \
     210:             break;                        \
     211:                                     \
     212:         if (___wait_is_interruptible(state) && __int) {        \
     213:             __ret = __int;                    \
     214:             if (exclusive) {                \
     215:                 abort_exclusive_wait(&wq, &__wait,    \
     216:                              state, NULL);    \
     217:                 goto __out;                \
     218:             }                        \
     219:             break;                        \
     220:         }                            \
     221:                                     \
     222:         cmd;                            \
     223:     }                                \
     224:     finish_wait(&wq, &__wait);                    \
     225: __out:    __ret;                                \
     226: })
     227: 
     228: #define __wait_event(wq, condition)                    \
     229:     (void)___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 0, 0,    \
     230:                 schedule())
     231: 
     232: /**
     233:  * wait_event - sleep until a condition gets true
     234:  * @wq: the waitqueue to wait on
     235:  * @condition: a C expression for the event to wait for
     236:  *
     237:  * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
     238:  * @condition evaluates to true. The @condition is checked each time
     239:  * the waitqueue @wq is woken up.
     240:  *
     241:  * wake_up() has to be called after changing any variable that could
     242:  * change the result of the wait condition.
     243:  */
     244: #define wait_event(wq, condition)                    \
     245: do {                                    \
     246:     if (condition)                            \
     247:         break;                            \
     248:     __wait_event(wq, condition);                    \
     249: } while (0)
     250: 
     251: #define __wait_event_timeout(wq, condition, timeout)            \
     252:     ___wait_event(wq, ___wait_cond_timeout(condition),        \
     253:               TASK_UNINTERRUPTIBLE, 0, timeout,            \
     254:               __ret = schedule_timeout(__ret))
     255: 
     256: /**
     257:  * wait_event_timeout - sleep until a condition gets true or a timeout elapses
     258:  * @wq: the waitqueue to wait on
     259:  * @condition: a C expression for the event to wait for
     260:  * @timeout: timeout, in jiffies
     261:  *
     262:  * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
     263:  * @condition evaluates to true. The @condition is checked each time
     264:  * the waitqueue @wq is woken up.
     265:  *
     266:  * wake_up() has to be called after changing any variable that could
     267:  * change the result of the wait condition.
     268:  *
     269:  * The function returns 0 if the @timeout elapsed, or the remaining
     270:  * jiffies (at least 1) if the @condition evaluated to %true before
     271:  * the @timeout elapsed.
     272:  */
     273: #define wait_event_timeout(wq, condition, timeout)            \
     274: ({                                    \
     275:     long __ret = timeout;                        \
     276:     if (!___wait_cond_timeout(condition))                \
     277:         __ret = __wait_event_timeout(wq, condition, timeout);    \
     278:     __ret;                                \
     279: })
     280: 
     281: #define __wait_event_cmd(wq, condition, cmd1, cmd2)            \
     282:     (void)___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 0, 0,    \
     283:                 cmd1; schedule(); cmd2)
     284: 
     285: /**
     286:  * wait_event_cmd - sleep until a condition gets true
     287:  * @wq: the waitqueue to wait on
     288:  * @condition: a C expression for the event to wait for
     289:  * cmd1: the command will be executed before sleep
     290:  * cmd2: the command will be executed after sleep
     291:  *
     292:  * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
     293:  * @condition evaluates to true. The @condition is checked each time
     294:  * the waitqueue @wq is woken up.
     295:  *
     296:  * wake_up() has to be called after changing any variable that could
     297:  * change the result of the wait condition.
     298:  */
     299: #define wait_event_cmd(wq, condition, cmd1, cmd2)            \
     300: do {                                    \
     301:     if (condition)                            \
     302:         break;                            \
     303:     __wait_event_cmd(wq, condition, cmd1, cmd2);            \
     304: } while (0)
     305: 
     306: #define __wait_event_interruptible(wq, condition)            \
     307:     ___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0,        \
     308:               schedule())
     309: 
     310: /**
     311:  * wait_event_interruptible - sleep until a condition gets true
     312:  * @wq: the waitqueue to wait on
     313:  * @condition: a C expression for the event to wait for
     314:  *
     315:  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
     316:  * @condition evaluates to true or a signal is received.
     317:  * The @condition is checked each time the waitqueue @wq is woken up.
     318:  *
     319:  * wake_up() has to be called after changing any variable that could
     320:  * change the result of the wait condition.
     321:  *
     322:  * The function will return -ERESTARTSYS if it was interrupted by a
     323:  * signal and 0 if @condition evaluated to true.
     324:  */
     325: #define wait_event_interruptible(wq, condition)                \
     326: ({                                    \
     327:     int __ret = 0;                            \
     328:     if (!(condition))                        \
     329:         __ret = __wait_event_interruptible(wq, condition);    \
     330:     __ret;                                \
     331: })
     332: 
     333: #define __wait_event_interruptible_timeout(wq, condition, timeout)    \
     334:     ___wait_event(wq, ___wait_cond_timeout(condition),        \
     335:               TASK_INTERRUPTIBLE, 0, timeout,            \
     336:               __ret = schedule_timeout(__ret))
     337: 
     338: /**
     339:  * wait_event_interruptible_timeout - sleep until a condition gets true or a timeout elapses
     340:  * @wq: the waitqueue to wait on
     341:  * @condition: a C expression for the event to wait for
     342:  * @timeout: timeout, in jiffies
     343:  *
     344:  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
     345:  * @condition evaluates to true or a signal is received.
     346:  * The @condition is checked each time the waitqueue @wq is woken up.
     347:  *
     348:  * wake_up() has to be called after changing any variable that could
     349:  * change the result of the wait condition.
     350:  *
     351:  * Returns:
     352:  * 0 if the @timeout elapsed, -%ERESTARTSYS if it was interrupted by
     353:  * a signal, or the remaining jiffies (at least 1) if the @condition
     354:  * evaluated to %true before the @timeout elapsed.
     355:  */
     356: #define wait_event_interruptible_timeout(wq, condition, timeout)    \
     357: ({                                    \
     358:     long __ret = timeout;                        \
     359:     if (!___wait_cond_timeout(condition))                \
     360:         __ret = __wait_event_interruptible_timeout(wq,        \
     361:                         condition, timeout);    \
     362:     __ret;                                \
     363: })
     364: 
     365: #define __wait_event_hrtimeout(wq, condition, timeout, state)        \
     366: ({                                    \
     367:     int __ret = 0;                            \
     368:     struct hrtimer_sleeper __t;                    \
     369:                                     \
     370:     hrtimer_init_on_stack(&__t.timer, CLOCK_MONOTONIC,        \
     371:                   HRTIMER_MODE_REL);            \
     372:     hrtimer_init_sleeper(&__t, current);                \
     373:     if ((timeout).tv64 != KTIME_MAX)                \
     374:         hrtimer_start_range_ns(&__t.timer, timeout,        \
     375:                        current->timer_slack_ns,        \
     376:                        HRTIMER_MODE_REL);        \
     377:                                     \
     378:     __ret = ___wait_event(wq, condition, state, 0, 0,        \
     379:         if (!__t.task) {                    \
     380:             __ret = -ETIME;                    \
     381:             break;                        \
     382:         }                            \
     383:         schedule());                        \
     384:                                     \
     385:     hrtimer_cancel(&__t.timer);                    \
     386:     destroy_hrtimer_on_stack(&__t.timer);                \
     387:     __ret;                                \
     388: })
     389: 
     390: /**
     391:  * wait_event_hrtimeout - sleep until a condition gets true or a timeout elapses
     392:  * @wq: the waitqueue to wait on
     393:  * @condition: a C expression for the event to wait for
     394:  * @timeout: timeout, as a ktime_t
     395:  *
     396:  * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
     397:  * @condition evaluates to true or a signal is received.
     398:  * The @condition is checked each time the waitqueue @wq is woken up.
     399:  *
     400:  * wake_up() has to be called after changing any variable that could
     401:  * change the result of the wait condition.
     402:  *
     403:  * The function returns 0 if @condition became true, or -ETIME if the timeout
     404:  * elapsed.
     405:  */
     406: #define wait_event_hrtimeout(wq, condition, timeout)            \
     407: ({                                    \
     408:     int __ret = 0;                            \
     409:     if (!(condition))                        \
     410:         __ret = __wait_event_hrtimeout(wq, condition, timeout,    \
     411:                            TASK_UNINTERRUPTIBLE);    \
     412:     __ret;                                \
     413: })
     414: 
     415: /**
     416:  * wait_event_interruptible_hrtimeout - sleep until a condition gets true or a timeout elapses
     417:  * @wq: the waitqueue to wait on
     418:  * @condition: a C expression for the event to wait for
     419:  * @timeout: timeout, as a ktime_t
     420:  *
     421:  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
     422:  * @condition evaluates to true or a signal is received.
     423:  * The @condition is checked each time the waitqueue @wq is woken up.
     424:  *
     425:  * wake_up() has to be called after changing any variable that could
     426:  * change the result of the wait condition.
     427:  *
     428:  * The function returns 0 if @condition became true, -ERESTARTSYS if it was
     429:  * interrupted by a signal, or -ETIME if the timeout elapsed.
     430:  */
     431: #define wait_event_interruptible_hrtimeout(wq, condition, timeout)    \
     432: ({                                    \
     433:     long __ret = 0;                            \
     434:     if (!(condition))                        \
     435:         __ret = __wait_event_hrtimeout(wq, condition, timeout,    \
     436:                            TASK_INTERRUPTIBLE);    \
     437:     __ret;                                \
     438: })
     439: 
     440: #define __wait_event_interruptible_exclusive(wq, condition)        \
     441:     ___wait_event(wq, condition, TASK_INTERRUPTIBLE, 1, 0,        \
     442:               schedule())
     443: 
     444: #define wait_event_interruptible_exclusive(wq, condition)        \
     445: ({                                    \
     446:     int __ret = 0;                            \
     447:     if (!(condition))                        \
     448:         __ret = __wait_event_interruptible_exclusive(wq, condition);\
    __ret;                                \
     450: })
     451: 
     452: 
     453: #define __wait_event_interruptible_locked(wq, condition, exclusive, irq) \
     454: ({                                    \
     455:     int __ret = 0;                            \
     456:     DEFINE_WAIT(__wait);                        \
     457:     if (exclusive)                            \
     458:         __wait.flags |= WQ_FLAG_EXCLUSIVE;            \
     459:     do {                                \
     460:         if (likely(list_empty(&__wait.task_list)))        \
     461:             __add_wait_queue_tail(&(wq), &__wait);        \
     462:         set_current_state(TASK_INTERRUPTIBLE);            \
     463:         if (signal_pending(current)) {                \
     464:             __ret = -ERESTARTSYS;                \
     465:             break;                        \
     466:         }                            \
     467:         if (irq)                        \
     468:             spin_unlock_irq(&(wq).lock);            \
     469:         else                            \
     470:             spin_unlock(&(wq).lock);            \
     471:         schedule();                        \
     472:         if (irq)                        \
     473:             spin_lock_irq(&(wq).lock);            \
     474:         else                            \
     475:             spin_lock(&(wq).lock);                \
     476:     } while (!(condition));                        \
     477:     __remove_wait_queue(&(wq), &__wait);                \
     478:     __set_current_state(TASK_RUNNING);                \
     479:     __ret;                                \
     480: })
     481: 
     482: 
     483: /**
     484:  * wait_event_interruptible_locked - sleep until a condition gets true
     485:  * @wq: the waitqueue to wait on
     486:  * @condition: a C expression for the event to wait for
     487:  *
     488:  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
     489:  * @condition evaluates to true or a signal is received.
     490:  * The @condition is checked each time the waitqueue @wq is woken up.
     491:  *
     492:  * It must be called with wq.lock being held.  This spinlock is
     493:  * unlocked while sleeping but @condition testing is done while lock
     494:  * is held and when this macro exits the lock is held.
     495:  *
     496:  * The lock is locked/unlocked using spin_lock()/spin_unlock()
     497:  * functions which must match the way they are locked/unlocked outside
     498:  * of this macro.
     499:  *
     500:  * wake_up_locked() has to be called after changing any variable that could
     501:  * change the result of the wait condition.
     502:  *
     503:  * The function will return -ERESTARTSYS if it was interrupted by a
     504:  * signal and 0 if @condition evaluated to true.
     505:  */
     506: #define wait_event_interruptible_locked(wq, condition)            \
     507:     ((condition)                            \
     508:      ? 0 : __wait_event_interruptible_locked(wq, condition, 0, 0))
     509: 
     510: /**
     511:  * wait_event_interruptible_locked_irq - sleep until a condition gets true
     512:  * @wq: the waitqueue to wait on
     513:  * @condition: a C expression for the event to wait for
     514:  *
     515:  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
     516:  * @condition evaluates to true or a signal is received.
     517:  * The @condition is checked each time the waitqueue @wq is woken up.
     518:  *
     519:  * It must be called with wq.lock being held.  This spinlock is
     520:  * unlocked while sleeping but @condition testing is done while lock
     521:  * is held and when this macro exits the lock is held.
     522:  *
     523:  * The lock is locked/unlocked using spin_lock_irq()/spin_unlock_irq()
     524:  * functions which must match the way they are locked/unlocked outside
     525:  * of this macro.
     526:  *
     527:  * wake_up_locked() has to be called after changing any variable that could
     528:  * change the result of the wait condition.
     529:  *
     530:  * The function will return -ERESTARTSYS if it was interrupted by a
     531:  * signal and 0 if @condition evaluated to true.
     532:  */
     533: #define wait_event_interruptible_locked_irq(wq, condition)        \
     534:     ((condition)                            \
     535:      ? 0 : __wait_event_interruptible_locked(wq, condition, 0, 1))
     536: 
     537: /**
     538:  * wait_event_interruptible_exclusive_locked - sleep exclusively until a condition gets true
     539:  * @wq: the waitqueue to wait on
     540:  * @condition: a C expression for the event to wait for
     541:  *
     542:  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
     543:  * @condition evaluates to true or a signal is received.
     544:  * The @condition is checked each time the waitqueue @wq is woken up.
     545:  *
     546:  * It must be called with wq.lock being held.  This spinlock is
     547:  * unlocked while sleeping but @condition testing is done while lock
     548:  * is held and when this macro exits the lock is held.
     549:  *
     550:  * The lock is locked/unlocked using spin_lock()/spin_unlock()
     551:  * functions which must match the way they are locked/unlocked outside
     552:  * of this macro.
     553:  *
     554:  * The process is put on the wait queue with an WQ_FLAG_EXCLUSIVE flag
     555:  * set thus when other process waits process on the list if this
     556:  * process is awaken further processes are not considered.
     557:  *
     558:  * wake_up_locked() has to be called after changing any variable that could
     559:  * change the result of the wait condition.
     560:  *
     561:  * The function will return -ERESTARTSYS if it was interrupted by a
     562:  * signal and 0 if @condition evaluated to true.
     563:  */
     564: #define wait_event_interruptible_exclusive_locked(wq, condition)    \
     565:     ((condition)                            \
     566:      ? 0 : __wait_event_interruptible_locked(wq, condition, 1, 0))
     567: 
     568: /**
     569:  * wait_event_interruptible_exclusive_locked_irq - sleep until a condition gets true
     570:  * @wq: the waitqueue to wait on
     571:  * @condition: a C expression for the event to wait for
     572:  *
     573:  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
     574:  * @condition evaluates to true or a signal is received.
     575:  * The @condition is checked each time the waitqueue @wq is woken up.
     576:  *
     577:  * It must be called with wq.lock being held.  This spinlock is
     578:  * unlocked while sleeping but @condition testing is done while lock
     579:  * is held and when this macro exits the lock is held.
     580:  *
     581:  * The lock is locked/unlocked using spin_lock_irq()/spin_unlock_irq()
     582:  * functions which must match the way they are locked/unlocked outside
     583:  * of this macro.
     584:  *
     585:  * The process is put on the wait queue with an WQ_FLAG_EXCLUSIVE flag
     586:  * set thus when other process waits process on the list if this
     587:  * process is awaken further processes are not considered.
     588:  *
     589:  * wake_up_locked() has to be called after changing any variable that could
     590:  * change the result of the wait condition.
     591:  *
     592:  * The function will return -ERESTARTSYS if it was interrupted by a
     593:  * signal and 0 if @condition evaluated to true.
     594:  */
     595: #define wait_event_interruptible_exclusive_locked_irq(wq, condition)    \
     596:     ((condition)                            \
     597:      ? 0 : __wait_event_interruptible_locked(wq, condition, 1, 1))
     598: 
     599: 
     600: #define __wait_event_killable(wq, condition)                \
     601:     ___wait_event(wq, condition, TASK_KILLABLE, 0, 0, schedule())
     602: 
     603: /**
     604:  * wait_event_killable - sleep until a condition gets true
     605:  * @wq: the waitqueue to wait on
     606:  * @condition: a C expression for the event to wait for
     607:  *
     608:  * The process is put to sleep (TASK_KILLABLE) until the
     609:  * @condition evaluates to true or a signal is received.
     610:  * The @condition is checked each time the waitqueue @wq is woken up.
     611:  *
     612:  * wake_up() has to be called after changing any variable that could
     613:  * change the result of the wait condition.
     614:  *
     615:  * The function will return -ERESTARTSYS if it was interrupted by a
     616:  * signal and 0 if @condition evaluated to true.
     617:  */
     618: #define wait_event_killable(wq, condition)                \
     619: ({                                    \
     620:     int __ret = 0;                            \
     621:     if (!(condition))                        \
     622:         __ret = __wait_event_killable(wq, condition);        \
     623:     __ret;                                \
     624: })
     625: 
     626: 
     627: #define __wait_event_lock_irq(wq, condition, lock, cmd)            \
     628:     (void)___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 0, 0,    \
     629:                 spin_unlock_irq(&lock);            \
     630:                 cmd;                    \
     631:                 schedule();                    \
     632:                 spin_lock_irq(&lock))
     633: 
     634: /**
     635:  * wait_event_lock_irq_cmd - sleep until a condition gets true. The
     636:  *                 condition is checked under the lock. This
     637:  *                 is expected to be called with the lock
     638:  *                 taken.
     639:  * @wq: the waitqueue to wait on
     640:  * @condition: a C expression for the event to wait for
     641:  * @lock: a locked spinlock_t, which will be released before cmd
     642:  *      and schedule() and reacquired afterwards.
     643:  * @cmd: a command which is invoked outside the critical section before
     644:  *     sleep
     645:  *
     646:  * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
     647:  * @condition evaluates to true. The @condition is checked each time
     648:  * the waitqueue @wq is woken up.
     649:  *
     650:  * wake_up() has to be called after changing any variable that could
     651:  * change the result of the wait condition.
     652:  *
     653:  * This is supposed to be called while holding the lock. The lock is
     654:  * dropped before invoking the cmd and going to sleep and is reacquired
     655:  * afterwards.
     656:  */
     657: #define wait_event_lock_irq_cmd(wq, condition, lock, cmd)        \
     658: do {                                    \
     659:     if (condition)                            \
     660:         break;                            \
     661:     __wait_event_lock_irq(wq, condition, lock, cmd);        \
     662: } while (0)
     663: 
     664: /**
     665:  * wait_event_lock_irq - sleep until a condition gets true. The
     666:  *             condition is checked under the lock. This
     667:  *             is expected to be called with the lock
     668:  *             taken.
     669:  * @wq: the waitqueue to wait on
     670:  * @condition: a C expression for the event to wait for
     671:  * @lock: a locked spinlock_t, which will be released before schedule()
     672:  *      and reacquired afterwards.
     673:  *
     674:  * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
     675:  * @condition evaluates to true. The @condition is checked each time
     676:  * the waitqueue @wq is woken up.
     677:  *
     678:  * wake_up() has to be called after changing any variable that could
     679:  * change the result of the wait condition.
     680:  *
     681:  * This is supposed to be called while holding the lock. The lock is
     682:  * dropped before going to sleep and is reacquired afterwards.
     683:  */
     684: #define wait_event_lock_irq(wq, condition, lock)            \
     685: do {                                    \
     686:     if (condition)                            \
     687:         break;                            \
     688:     __wait_event_lock_irq(wq, condition, lock, );            \
     689: } while (0)
     690: 
     691: 
     692: #define __wait_event_interruptible_lock_irq(wq, condition, lock, cmd)    \
     693:     ___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0,        \
     694:               spin_unlock_irq(&lock);                \
     695:               cmd;                        \
     696:               schedule();                    \
     697:               spin_lock_irq(&lock))
     698: 
     699: /**
     700:  * wait_event_interruptible_lock_irq_cmd - sleep until a condition gets true.
     701:  *        The condition is checked under the lock. This is expected to
     702:  *        be called with the lock taken.
     703:  * @wq: the waitqueue to wait on
     704:  * @condition: a C expression for the event to wait for
     705:  * @lock: a locked spinlock_t, which will be released before cmd and
     706:  *      schedule() and reacquired afterwards.
     707:  * @cmd: a command which is invoked outside the critical section before
     708:  *     sleep
     709:  *
     710:  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
     711:  * @condition evaluates to true or a signal is received. The @condition is
     712:  * checked each time the waitqueue @wq is woken up.
     713:  *
     714:  * wake_up() has to be called after changing any variable that could
     715:  * change the result of the wait condition.
     716:  *
     717:  * This is supposed to be called while holding the lock. The lock is
     718:  * dropped before invoking the cmd and going to sleep and is reacquired
     719:  * afterwards.
     720:  *
     721:  * The macro will return -ERESTARTSYS if it was interrupted by a signal
     722:  * and 0 if @condition evaluated to true.
     723:  */
     724: #define wait_event_interruptible_lock_irq_cmd(wq, condition, lock, cmd)    \
     725: ({                                    \
     726:     int __ret = 0;                            \
     727:     if (!(condition))                        \
     728:         __ret = __wait_event_interruptible_lock_irq(wq,        \
     729:                         condition, lock, cmd);    \
     730:     __ret;                                \
     731: })
     732: 
     733: /**
     734:  * wait_event_interruptible_lock_irq - sleep until a condition gets true.
     735:  *        The condition is checked under the lock. This is expected
     736:  *        to be called with the lock taken.
     737:  * @wq: the waitqueue to wait on
     738:  * @condition: a C expression for the event to wait for
     739:  * @lock: a locked spinlock_t, which will be released before schedule()
     740:  *      and reacquired afterwards.
     741:  *
     742:  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
     743:  * @condition evaluates to true or signal is received. The @condition is
     744:  * checked each time the waitqueue @wq is woken up.
     745:  *
     746:  * wake_up() has to be called after changing any variable that could
     747:  * change the result of the wait condition.
     748:  *
     749:  * This is supposed to be called while holding the lock. The lock is
     750:  * dropped before going to sleep and is reacquired afterwards.
     751:  *
     752:  * The macro will return -ERESTARTSYS if it was interrupted by a signal
     753:  * and 0 if @condition evaluated to true.
     754:  */
     755: #define wait_event_interruptible_lock_irq(wq, condition, lock)        \
     756: ({                                    \
     757:     int __ret = 0;                            \
     758:     if (!(condition))                        \
     759:         __ret = __wait_event_interruptible_lock_irq(wq,        \
     760:                         condition, lock,);    \
     761:     __ret;                                \
     762: })
     763: 
     764: #define __wait_event_interruptible_lock_irq_timeout(wq, condition,    \
     765:                             lock, timeout)    \
     766:     ___wait_event(wq, ___wait_cond_timeout(condition),        \
     767:               TASK_INTERRUPTIBLE, 0, timeout,            \
     768:               spin_unlock_irq(&lock);                \
     769:               __ret = schedule_timeout(__ret);            \
     770:               spin_lock_irq(&lock));
     771: 
     772: /**
     773:  * wait_event_interruptible_lock_irq_timeout - sleep until a condition gets
     774:  *        true or a timeout elapses. The condition is checked under
     775:  *        the lock. This is expected to be called with the lock taken.
     776:  * @wq: the waitqueue to wait on
     777:  * @condition: a C expression for the event to wait for
     778:  * @lock: a locked spinlock_t, which will be released before schedule()
     779:  *      and reacquired afterwards.
     780:  * @timeout: timeout, in jiffies
     781:  *
     782:  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
     783:  * @condition evaluates to true or signal is received. The @condition is
     784:  * checked each time the waitqueue @wq is woken up.
     785:  *
     786:  * wake_up() has to be called after changing any variable that could
     787:  * change the result of the wait condition.
     788:  *
     789:  * This is supposed to be called while holding the lock. The lock is
     790:  * dropped before going to sleep and is reacquired afterwards.
     791:  *
     792:  * The function returns 0 if the @timeout elapsed, -ERESTARTSYS if it
     793:  * was interrupted by a signal, and the remaining jiffies otherwise
     794:  * if the condition evaluated to true before the timeout elapsed.
     795:  */
     796: #define wait_event_interruptible_lock_irq_timeout(wq, condition, lock,    \
     797:                           timeout)        \
     798: ({                                    \
     799:     long __ret = timeout;                        \
     800:     if (!___wait_cond_timeout(condition))                \
     801:         __ret = __wait_event_interruptible_lock_irq_timeout(    \
     802:                     wq, condition, lock, timeout);    \
     803:     __ret;                                \
     804: })
     805: 
     806: 
     807: /*
     808:  * These are the old interfaces to sleep waiting for an event.
     809:  * They are racy.  DO NOT use them, use the wait_event* interfaces above.
     810:  * We plan to remove these interfaces.
     811:  */
     812: extern void sleep_on(wait_queue_head_t *q);
     813: extern long sleep_on_timeout(wait_queue_head_t *q, signed long timeout);
     814: extern void interruptible_sleep_on(wait_queue_head_t *q);
     815: extern long interruptible_sleep_on_timeout(wait_queue_head_t *q, signed long timeout);
     816: 
     817: /*
     818:  * Waitqueues which are removed from the waitqueue_head at wakeup time
     819:  */
     820: void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state);
     821: void prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state);
     822: long prepare_to_wait_event(wait_queue_head_t *q, wait_queue_t *wait, int state);
     823: void finish_wait(wait_queue_head_t *q, wait_queue_t *wait);
     824: void abort_exclusive_wait(wait_queue_head_t *q, wait_queue_t *wait, unsigned int mode, void *key);
     825: int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
     826: int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
     827: 
     828: #define DEFINE_WAIT_FUNC(name, function)                \
     829:     wait_queue_t name = {                        \
     830:         .private    = current,                \
     831:         .func        = function,                \
     832:         .task_list    = LIST_HEAD_INIT((name).task_list),    \
     833:     }
     834: 
     835: #define DEFINE_WAIT(name) DEFINE_WAIT_FUNC(name, autoremove_wake_function)
     836: 
     837: #define DEFINE_WAIT_BIT(name, word, bit)                \
     838:     struct wait_bit_queue name = {                    \
     839:         .key = __WAIT_BIT_KEY_INITIALIZER(word, bit),        \
     840:         .wait    = {                        \
     841:             .private    = current,            \
     842:             .func        = wake_bit_function,        \
     843:             .task_list    =                \
     844:                 LIST_HEAD_INIT((name).wait.task_list),    \
     845:         },                            \
     846:     }
     847: 
     848: #define init_wait(wait)                            \
     849:     do {                                \
     850:         (wait)->private = current;                \
     851:         (wait)->func = autoremove_wake_function;        \
     852:         INIT_LIST_HEAD(&(wait)->task_list);            \
     853:         (wait)->flags = 0;                    \
     854:     } while (0)
     855: 
     856: /**
     857:  * wait_on_bit - wait for a bit to be cleared
     858:  * @word: the word being waited on, a kernel virtual address
     859:  * @bit: the bit of the word being waited on
     860:  * @action: the function used to sleep, which may take special actions
     861:  * @mode: the task state to sleep in
     862:  *
     863:  * There is a standard hashed waitqueue table for generic use. This
     864:  * is the part of the hashtable's accessor API that waits on a bit.
     865:  * For instance, if one were to have waiters on a bitflag, one would
     866:  * call wait_on_bit() in threads waiting for the bit to clear.
     867:  * One uses wait_on_bit() where one is waiting for the bit to clear,
     868:  * but has no intention of setting it.
     869:  */
     870: static inline int
     871: wait_on_bit(void *word, int bit, int (*action)(void *), unsigned mode)
     872: {
     873:     if (!test_bit(bit, word))
     874:         return 0;
     875:     return out_of_line_wait_on_bit(word, bit, action, mode);
     876: }
     877: 
     878: /**
     879:  * wait_on_bit_lock - wait for a bit to be cleared, when wanting to set it
     880:  * @word: the word being waited on, a kernel virtual address
     881:  * @bit: the bit of the word being waited on
     882:  * @action: the function used to sleep, which may take special actions
     883:  * @mode: the task state to sleep in
     884:  *
     885:  * There is a standard hashed waitqueue table for generic use. This
     886:  * is the part of the hashtable's accessor API that waits on a bit
     887:  * when one intends to set it, for instance, trying to lock bitflags.
     888:  * For instance, if one were to have waiters trying to set bitflag
     889:  * and waiting for it to clear before setting it, one would call
     890:  * wait_on_bit() in threads waiting to be able to set the bit.
     891:  * One uses wait_on_bit_lock() where one is waiting for the bit to
     892:  * clear with the intention of setting it, and when done, clearing it.
     893:  */
     894: static inline int
     895: wait_on_bit_lock(void *word, int bit, int (*action)(void *), unsigned mode)
     896: {
     897:     if (!test_and_set_bit(bit, word))
     898:         return 0;
     899:     return out_of_line_wait_on_bit_lock(word, bit, action, mode);
     900: }
     901: 
     902: /**
     903:  * wait_on_atomic_t - Wait for an atomic_t to become 0
     904:  * @val: The atomic value being waited on, a kernel virtual address
     905:  * @action: the function used to sleep, which may take special actions
     906:  * @mode: the task state to sleep in
     907:  *
     908:  * Wait for an atomic_t to become 0.  We abuse the bit-wait waitqueue table for
     909:  * the purpose of getting a waitqueue, but we set the key to a bit number
     910:  * outside of the target 'word'.
     911:  */
     912: static inline
     913: int wait_on_atomic_t(atomic_t *val, int (*action)(atomic_t *), unsigned mode)
     914: {
     915:     if (atomic_read(val) == 0)
     916:         return 0;
     917:     return out_of_line_wait_on_atomic_t(val, action, mode);
     918: }
     919: 
     920: #endif /* _LINUX_WAIT_H */
     921: