home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / linux / wait.h < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-09  |  15.5 KB  |  518 lines

  1. #ifndef _LINUX_WAIT_H
  2. #define _LINUX_WAIT_H
  3.  
  4. #define WNOHANG        0x00000001
  5. #define WUNTRACED    0x00000002
  6. #define WSTOPPED    WUNTRACED
  7. #define WEXITED        0x00000004
  8. #define WCONTINUED    0x00000008
  9. #define WNOWAIT        0x01000000    /* Don't reap, just poll status.  */
  10.  
  11. #define __WNOTHREAD    0x20000000    /* Don't wait on children of other threads in this group */
  12. #define __WALL        0x40000000    /* Wait on all children, regardless of type */
  13. #define __WCLONE    0x80000000    /* Wait only on non-SIGCHLD children */
  14.  
  15. /* First argument to waitid: */
  16. #define P_ALL        0
  17. #define P_PID        1
  18. #define P_PGID        2
  19.  
  20. #ifdef __KERNEL__
  21.  
  22. #include <linux/list.h>
  23. #include <linux/stddef.h>
  24. #include <linux/spinlock.h>
  25. #include <asm/system.h>
  26. #include <asm/current.h>
  27.  
  28. typedef struct __wait_queue wait_queue_t;
  29. typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int sync, void *key);
  30. int default_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
  31.  
  32. struct __wait_queue {
  33.     unsigned int flags;
  34. #define WQ_FLAG_EXCLUSIVE    0x01
  35.     void *private;
  36.     wait_queue_func_t func;
  37.     struct list_head task_list;
  38. };
  39.  
  40. struct wait_bit_key {
  41.     void *flags;
  42.     int bit_nr;
  43. };
  44.  
  45. struct wait_bit_queue {
  46.     struct wait_bit_key key;
  47.     wait_queue_t wait;
  48. };
  49.  
  50. struct __wait_queue_head {
  51.     spinlock_t lock;
  52.     struct list_head task_list;
  53. };
  54. typedef struct __wait_queue_head wait_queue_head_t;
  55.  
  56. struct task_struct;
  57.  
  58. /*
  59.  * Macros for declaration and initialisaton of the datatypes
  60.  */
  61.  
  62. #define __WAITQUEUE_INITIALIZER(name, tsk) {                \
  63.     .private    = tsk,                        \
  64.     .func        = default_wake_function,            \
  65.     .task_list    = { NULL, NULL } }
  66.  
  67. #define DECLARE_WAITQUEUE(name, tsk)                    \
  68.     wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk)
  69.  
  70. #define __WAIT_QUEUE_HEAD_INITIALIZER(name) {                \
  71.     .lock        = __SPIN_LOCK_UNLOCKED(name.lock),        \
  72.     .task_list    = { &(name).task_list, &(name).task_list } }
  73.  
  74. #define DECLARE_WAIT_QUEUE_HEAD(name) \
  75.     wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)
  76.  
  77. #define __WAIT_BIT_KEY_INITIALIZER(word, bit)                \
  78.     { .flags = word, .bit_nr = bit, }
  79.  
  80. extern void init_waitqueue_head(wait_queue_head_t *q);
  81.  
  82. #ifdef CONFIG_LOCKDEP
  83. # define __WAIT_QUEUE_HEAD_INIT_ONSTACK(name) \
  84.     ({ init_waitqueue_head(&name); name; })
  85. # define DECLARE_WAIT_QUEUE_HEAD_ONSTACK(name) \
  86.     wait_queue_head_t name = __WAIT_QUEUE_HEAD_INIT_ONSTACK(name)
  87. #else
  88. # define DECLARE_WAIT_QUEUE_HEAD_ONSTACK(name) DECLARE_WAIT_QUEUE_HEAD(name)
  89. #endif
  90.  
  91. static inline void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p)
  92. {
  93.     q->flags = 0;
  94.     q->private = p;
  95.     q->func = default_wake_function;
  96. }
  97.  
  98. static inline void init_waitqueue_func_entry(wait_queue_t *q,
  99.                     wait_queue_func_t func)
  100. {
  101.     q->flags = 0;
  102.     q->private = NULL;
  103.     q->func = func;
  104. }
  105.  
  106. static inline int waitqueue_active(wait_queue_head_t *q)
  107. {
  108.     return !list_empty(&q->task_list);
  109. }
  110.  
  111. extern void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);
  112. extern void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait);
  113. extern void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);
  114.  
  115. static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)
  116. {
  117.     list_add(&new->task_list, &head->task_list);
  118. }
  119.  
  120. /*
  121.  * Used for wake-one threads:
  122.  */
  123. static inline void __add_wait_queue_tail(wait_queue_head_t *head,
  124.                         wait_queue_t *new)
  125. {
  126.     list_add_tail(&new->task_list, &head->task_list);
  127. }
  128.  
  129. static inline void __remove_wait_queue(wait_queue_head_t *head,
  130.                             wait_queue_t *old)
  131. {
  132.     list_del(&old->task_list);
  133. }
  134.  
  135. void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
  136.             int nr_exclusive, int sync, void *key);
  137. void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr, void *key);
  138. extern void __wake_up_locked(wait_queue_head_t *q, unsigned int mode);
  139. extern void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr);
  140. void __wake_up_bit(wait_queue_head_t *, void *, int);
  141. int __wait_on_bit(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned);
  142. int __wait_on_bit_lock(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned);
  143. void wake_up_bit(void *, int);
  144. int out_of_line_wait_on_bit(void *, int, int (*)(void *), unsigned);
  145. int out_of_line_wait_on_bit_lock(void *, int, int (*)(void *), unsigned);
  146. wait_queue_head_t *bit_waitqueue(void *, int);
  147.  
  148. #define wake_up(x)            __wake_up(x, TASK_NORMAL, 1, NULL)
  149. #define wake_up_nr(x, nr)        __wake_up(x, TASK_NORMAL, nr, NULL)
  150. #define wake_up_all(x)            __wake_up(x, TASK_NORMAL, 0, NULL)
  151. #define wake_up_locked(x)        __wake_up_locked((x), TASK_NORMAL)
  152.  
  153. #define wake_up_interruptible(x)    __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
  154. #define wake_up_interruptible_nr(x, nr)    __wake_up(x, TASK_INTERRUPTIBLE, nr, NULL)
  155. #define wake_up_interruptible_all(x)    __wake_up(x, TASK_INTERRUPTIBLE, 0, NULL)
  156. #define wake_up_interruptible_sync(x)    __wake_up_sync((x), TASK_INTERRUPTIBLE, 1)
  157.  
  158. #ifdef CONFIG_DEBUG_LOCK_ALLOC
  159. /*
  160.  * macro to avoid include hell
  161.  */
  162. #define wake_up_nested(x, s)                        \
  163. do {                                    \
  164.     unsigned long flags;                        \
  165.                                     \
  166.     spin_lock_irqsave_nested(&(x)->lock, flags, (s));        \
  167.     wake_up_locked(x);                         \
  168.     spin_unlock_irqrestore(&(x)->lock, flags);            \
  169. } while (0)
  170. #else
  171. #define wake_up_nested(x, s)        wake_up(x)
  172. #endif
  173.  
  174. #define __wait_event(wq, condition)                     \
  175. do {                                    \
  176.     DEFINE_WAIT(__wait);                        \
  177.                                     \
  178.     for (;;) {                            \
  179.         prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);    \
  180.         if (condition)                        \
  181.             break;                        \
  182.         schedule();                        \
  183.     }                                \
  184.     finish_wait(&wq, &__wait);                    \
  185. } while (0)
  186.  
  187. /**
  188.  * wait_event - sleep until a condition gets true
  189.  * @wq: the waitqueue to wait on
  190.  * @condition: a C expression for the event to wait for
  191.  *
  192.  * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
  193.  * @condition evaluates to true. The @condition is checked each time
  194.  * the waitqueue @wq is woken up.
  195.  *
  196.  * wake_up() has to be called after changing any variable that could
  197.  * change the result of the wait condition.
  198.  */
  199. #define wait_event(wq, condition)                     \
  200. do {                                    \
  201.     if (condition)                             \
  202.         break;                            \
  203.     __wait_event(wq, condition);                    \
  204. } while (0)
  205.  
  206. #define __wait_event_timeout(wq, condition, ret)            \
  207. do {                                    \
  208.     DEFINE_WAIT(__wait);                        \
  209.                                     \
  210.     for (;;) {                            \
  211.         prepare_to_wait(&wq, &__wait, TASK_UNINTERRUPTIBLE);    \
  212.         if (condition)                        \
  213.             break;                        \
  214.         ret = schedule_timeout(ret);                \
  215.         if (!ret)                        \
  216.             break;                        \
  217.     }                                \
  218.     finish_wait(&wq, &__wait);                    \
  219. } while (0)
  220.  
  221. /**
  222.  * wait_event_timeout - sleep until a condition gets true or a timeout elapses
  223.  * @wq: the waitqueue to wait on
  224.  * @condition: a C expression for the event to wait for
  225.  * @timeout: timeout, in jiffies
  226.  *
  227.  * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
  228.  * @condition evaluates to true. The @condition is checked each time
  229.  * the waitqueue @wq is woken up.
  230.  *
  231.  * wake_up() has to be called after changing any variable that could
  232.  * change the result of the wait condition.
  233.  *
  234.  * The function returns 0 if the @timeout elapsed, and the remaining
  235.  * jiffies if the condition evaluated to true before the timeout elapsed.
  236.  */
  237. #define wait_event_timeout(wq, condition, timeout)            \
  238. ({                                    \
  239.     long __ret = timeout;                        \
  240.     if (!(condition))                         \
  241.         __wait_event_timeout(wq, condition, __ret);        \
  242.     __ret;                                \
  243. })
  244.  
  245. #define __wait_event_interruptible(wq, condition, ret)            \
  246. do {                                    \
  247.     DEFINE_WAIT(__wait);                        \
  248.                                     \
  249.     for (;;) {                            \
  250.         prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE);    \
  251.         if (condition)                        \
  252.             break;                        \
  253.         if (!signal_pending(current)) {                \
  254.             schedule();                    \
  255.             continue;                    \
  256.         }                            \
  257.         ret = -ERESTARTSYS;                    \
  258.         break;                            \
  259.     }                                \
  260.     finish_wait(&wq, &__wait);                    \
  261. } while (0)
  262.  
  263. /**
  264.  * wait_event_interruptible - sleep until a condition gets true
  265.  * @wq: the waitqueue to wait on
  266.  * @condition: a C expression for the event to wait for
  267.  *
  268.  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
  269.  * @condition evaluates to true or a signal is received.
  270.  * The @condition is checked each time the waitqueue @wq is woken up.
  271.  *
  272.  * wake_up() has to be called after changing any variable that could
  273.  * change the result of the wait condition.
  274.  *
  275.  * The function will return -ERESTARTSYS if it was interrupted by a
  276.  * signal and 0 if @condition evaluated to true.
  277.  */
  278. #define wait_event_interruptible(wq, condition)                \
  279. ({                                    \
  280.     int __ret = 0;                            \
  281.     if (!(condition))                        \
  282.         __wait_event_interruptible(wq, condition, __ret);    \
  283.     __ret;                                \
  284. })
  285.  
  286. #define __wait_event_interruptible_timeout(wq, condition, ret)        \
  287. do {                                    \
  288.     DEFINE_WAIT(__wait);                        \
  289.                                     \
  290.     for (;;) {                            \
  291.         prepare_to_wait(&wq, &__wait, TASK_INTERRUPTIBLE);    \
  292.         if (condition)                        \
  293.             break;                        \
  294.         if (!signal_pending(current)) {                \
  295.             ret = schedule_timeout(ret);            \
  296.             if (!ret)                    \
  297.                 break;                    \
  298.             continue;                    \
  299.         }                            \
  300.         ret = -ERESTARTSYS;                    \
  301.         break;                            \
  302.     }                                \
  303.     finish_wait(&wq, &__wait);                    \
  304. } while (0)
  305.  
  306. /**
  307.  * wait_event_interruptible_timeout - sleep until a condition gets true or a timeout elapses
  308.  * @wq: the waitqueue to wait on
  309.  * @condition: a C expression for the event to wait for
  310.  * @timeout: timeout, in jiffies
  311.  *
  312.  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
  313.  * @condition evaluates to true or a signal is received.
  314.  * The @condition is checked each time the waitqueue @wq is woken up.
  315.  *
  316.  * wake_up() has to be called after changing any variable that could
  317.  * change the result of the wait condition.
  318.  *
  319.  * The function returns 0 if the @timeout elapsed, -ERESTARTSYS if it
  320.  * was interrupted by a signal, and the remaining jiffies otherwise
  321.  * if the condition evaluated to true before the timeout elapsed.
  322.  */
  323. #define wait_event_interruptible_timeout(wq, condition, timeout)    \
  324. ({                                    \
  325.     long __ret = timeout;                        \
  326.     if (!(condition))                        \
  327.         __wait_event_interruptible_timeout(wq, condition, __ret); \
  328.     __ret;                                \
  329. })
  330.  
  331. #define __wait_event_interruptible_exclusive(wq, condition, ret)    \
  332. do {                                    \
  333.     DEFINE_WAIT(__wait);                        \
  334.                                     \
  335.     for (;;) {                            \
  336.         prepare_to_wait_exclusive(&wq, &__wait,            \
  337.                     TASK_INTERRUPTIBLE);        \
  338.         if (condition) {                    \
  339.             finish_wait(&wq, &__wait);            \
  340.             break;                        \
  341.         }                            \
  342.         if (!signal_pending(current)) {                \
  343.             schedule();                    \
  344.             continue;                    \
  345.         }                            \
  346.         ret = -ERESTARTSYS;                    \
  347.         abort_exclusive_wait(&wq, &__wait,             \
  348.                 TASK_INTERRUPTIBLE, NULL);        \
  349.         break;                            \
  350.     }                                \
  351. } while (0)
  352.  
  353. #define wait_event_interruptible_exclusive(wq, condition)        \
  354. ({                                    \
  355.     int __ret = 0;                            \
  356.     if (!(condition))                        \
  357.         __wait_event_interruptible_exclusive(wq, condition, __ret);\
  358.     __ret;                                \
  359. })
  360.  
  361. #define __wait_event_killable(wq, condition, ret)            \
  362. do {                                    \
  363.     DEFINE_WAIT(__wait);                        \
  364.                                     \
  365.     for (;;) {                            \
  366.         prepare_to_wait(&wq, &__wait, TASK_KILLABLE);        \
  367.         if (condition)                        \
  368.             break;                        \
  369.         if (!fatal_signal_pending(current)) {            \
  370.             schedule();                    \
  371.             continue;                    \
  372.         }                            \
  373.         ret = -ERESTARTSYS;                    \
  374.         break;                            \
  375.     }                                \
  376.     finish_wait(&wq, &__wait);                    \
  377. } while (0)
  378.  
  379. /**
  380.  * wait_event_killable - sleep until a condition gets true
  381.  * @wq: the waitqueue to wait on
  382.  * @condition: a C expression for the event to wait for
  383.  *
  384.  * The process is put to sleep (TASK_KILLABLE) until the
  385.  * @condition evaluates to true or a signal is received.
  386.  * The @condition is checked each time the waitqueue @wq is woken up.
  387.  *
  388.  * wake_up() has to be called after changing any variable that could
  389.  * change the result of the wait condition.
  390.  *
  391.  * The function will return -ERESTARTSYS if it was interrupted by a
  392.  * signal and 0 if @condition evaluated to true.
  393.  */
  394. #define wait_event_killable(wq, condition)                \
  395. ({                                    \
  396.     int __ret = 0;                            \
  397.     if (!(condition))                        \
  398.         __wait_event_killable(wq, condition, __ret);        \
  399.     __ret;                                \
  400. })
  401.  
  402. /*
  403.  * Must be called with the spinlock in the wait_queue_head_t held.
  404.  */
  405. static inline void add_wait_queue_exclusive_locked(wait_queue_head_t *q,
  406.                            wait_queue_t * wait)
  407. {
  408.     wait->flags |= WQ_FLAG_EXCLUSIVE;
  409.     __add_wait_queue_tail(q,  wait);
  410. }
  411.  
  412. /*
  413.  * Must be called with the spinlock in the wait_queue_head_t held.
  414.  */
  415. static inline void remove_wait_queue_locked(wait_queue_head_t *q,
  416.                         wait_queue_t * wait)
  417. {
  418.     __remove_wait_queue(q,  wait);
  419. }
  420.  
  421. /*
  422.  * These are the old interfaces to sleep waiting for an event.
  423.  * They are racy.  DO NOT use them, use the wait_event* interfaces above.
  424.  * We plan to remove these interfaces.
  425.  */
  426. extern void sleep_on(wait_queue_head_t *q);
  427. extern long sleep_on_timeout(wait_queue_head_t *q,
  428.                       signed long timeout);
  429. extern void interruptible_sleep_on(wait_queue_head_t *q);
  430. extern long interruptible_sleep_on_timeout(wait_queue_head_t *q,
  431.                        signed long timeout);
  432.  
  433. /*
  434.  * Waitqueues which are removed from the waitqueue_head at wakeup time
  435.  */
  436. void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state);
  437. void prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state);
  438. void finish_wait(wait_queue_head_t *q, wait_queue_t *wait);
  439. void abort_exclusive_wait(wait_queue_head_t *q, wait_queue_t *wait,
  440.             unsigned int mode, void *key);
  441. int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
  442. int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
  443.  
  444. #define DEFINE_WAIT(name)                        \
  445.     wait_queue_t name = {                        \
  446.         .private    = current,                \
  447.         .func        = autoremove_wake_function,        \
  448.         .task_list    = LIST_HEAD_INIT((name).task_list),    \
  449.     }
  450.  
  451. #define DEFINE_WAIT_BIT(name, word, bit)                \
  452.     struct wait_bit_queue name = {                    \
  453.         .key = __WAIT_BIT_KEY_INITIALIZER(word, bit),        \
  454.         .wait    = {                        \
  455.             .private    = current,            \
  456.             .func        = wake_bit_function,        \
  457.             .task_list    =                \
  458.                 LIST_HEAD_INIT((name).wait.task_list),    \
  459.         },                            \
  460.     }
  461.  
  462. #define init_wait(wait)                            \
  463.     do {                                \
  464.         (wait)->private = current;                \
  465.         (wait)->func = autoremove_wake_function;        \
  466.         INIT_LIST_HEAD(&(wait)->task_list);            \
  467.     } while (0)
  468.  
  469. /**
  470.  * wait_on_bit - wait for a bit to be cleared
  471.  * @word: the word being waited on, a kernel virtual address
  472.  * @bit: the bit of the word being waited on
  473.  * @action: the function used to sleep, which may take special actions
  474.  * @mode: the task state to sleep in
  475.  *
  476.  * There is a standard hashed waitqueue table for generic use. This
  477.  * is the part of the hashtable's accessor API that waits on a bit.
  478.  * For instance, if one were to have waiters on a bitflag, one would
  479.  * call wait_on_bit() in threads waiting for the bit to clear.
  480.  * One uses wait_on_bit() where one is waiting for the bit to clear,
  481.  * but has no intention of setting it.
  482.  */
  483. static inline int wait_on_bit(void *word, int bit,
  484.                 int (*action)(void *), unsigned mode)
  485. {
  486.     if (!test_bit(bit, word))
  487.         return 0;
  488.     return out_of_line_wait_on_bit(word, bit, action, mode);
  489. }
  490.  
  491. /**
  492.  * wait_on_bit_lock - wait for a bit to be cleared, when wanting to set it
  493.  * @word: the word being waited on, a kernel virtual address
  494.  * @bit: the bit of the word being waited on
  495.  * @action: the function used to sleep, which may take special actions
  496.  * @mode: the task state to sleep in
  497.  *
  498.  * There is a standard hashed waitqueue table for generic use. This
  499.  * is the part of the hashtable's accessor API that waits on a bit
  500.  * when one intends to set it, for instance, trying to lock bitflags.
  501.  * For instance, if one were to have waiters trying to set bitflag
  502.  * and waiting for it to clear before setting it, one would call
  503.  * wait_on_bit() in threads waiting to be able to set the bit.
  504.  * One uses wait_on_bit_lock() where one is waiting for the bit to
  505.  * clear with the intention of setting it, and when done, clearing it.
  506.  */
  507. static inline int wait_on_bit_lock(void *word, int bit,
  508.                 int (*action)(void *), unsigned mode)
  509. {
  510.     if (!test_and_set_bit(bit, word))
  511.         return 0;
  512.     return out_of_line_wait_on_bit_lock(word, bit, action, mode);
  513. }
  514.     
  515. #endif /* __KERNEL__ */
  516.  
  517. #endif
  518.