208 lines
5.7 KiB
C
208 lines
5.7 KiB
C
#ifndef _LINUX_WAIT_SIMPLE_H
|
|
#define _LINUX_WAIT_SIMPLE_H
|
|
|
|
#include <linux/spinlock.h>
|
|
#include <linux/list.h>
|
|
|
|
#include <asm/current.h>
|
|
|
|
struct swaiter {
|
|
struct task_struct *task;
|
|
struct list_head node;
|
|
};
|
|
|
|
#define DEFINE_SWAITER(name) \
|
|
struct swaiter name = { \
|
|
.task = current, \
|
|
.node = LIST_HEAD_INIT((name).node), \
|
|
}
|
|
|
|
struct swait_head {
|
|
raw_spinlock_t lock;
|
|
struct list_head list;
|
|
};
|
|
|
|
#define SWAIT_HEAD_INITIALIZER(name) { \
|
|
.lock = __RAW_SPIN_LOCK_UNLOCKED(name.lock), \
|
|
.list = LIST_HEAD_INIT((name).list), \
|
|
}
|
|
|
|
#define DEFINE_SWAIT_HEAD(name) \
|
|
struct swait_head name = SWAIT_HEAD_INITIALIZER(name)
|
|
|
|
extern void __init_swait_head(struct swait_head *h, struct lock_class_key *key);
|
|
|
|
#define init_swait_head(swh) \
|
|
do { \
|
|
static struct lock_class_key __key; \
|
|
\
|
|
__init_swait_head((swh), &__key); \
|
|
} while (0)
|
|
|
|
/*
|
|
* Waiter functions
|
|
*/
|
|
extern void swait_prepare_locked(struct swait_head *head, struct swaiter *w);
|
|
extern void swait_prepare(struct swait_head *head, struct swaiter *w, int state);
|
|
extern void swait_finish_locked(struct swait_head *head, struct swaiter *w);
|
|
extern void swait_finish(struct swait_head *head, struct swaiter *w);
|
|
|
|
/* Check whether a head has waiters enqueued */
|
|
static inline bool swaitqueue_active(struct swait_head *h)
|
|
{
|
|
/* Make sure the condition is visible before checking list_empty() */
|
|
smp_mb();
|
|
return !list_empty(&h->list);
|
|
}
|
|
|
|
/*
|
|
* Wakeup functions
|
|
*/
|
|
extern unsigned int __swait_wake(struct swait_head *head, unsigned int state, unsigned int num);
|
|
extern unsigned int __swait_wake_locked(struct swait_head *head, unsigned int state, unsigned int num);
|
|
|
|
#define swait_wake(head) __swait_wake(head, TASK_NORMAL, 1)
|
|
#define swait_wake_interruptible(head) __swait_wake(head, TASK_INTERRUPTIBLE, 1)
|
|
#define swait_wake_all(head) __swait_wake(head, TASK_NORMAL, 0)
|
|
#define swait_wake_all_interruptible(head) __swait_wake(head, TASK_INTERRUPTIBLE, 0)
|
|
|
|
/*
|
|
* Event API
|
|
*/
|
|
#define __swait_event(wq, condition) \
|
|
do { \
|
|
DEFINE_SWAITER(__wait); \
|
|
\
|
|
for (;;) { \
|
|
swait_prepare(&wq, &__wait, TASK_UNINTERRUPTIBLE); \
|
|
if (condition) \
|
|
break; \
|
|
schedule(); \
|
|
} \
|
|
swait_finish(&wq, &__wait); \
|
|
} while (0)
|
|
|
|
/**
|
|
* swait_event - sleep until a condition gets true
|
|
* @wq: the waitqueue to wait on
|
|
* @condition: a C expression for the event to wait for
|
|
*
|
|
* The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
|
|
* @condition evaluates to true. The @condition is checked each time
|
|
* the waitqueue @wq is woken up.
|
|
*
|
|
* wake_up() has to be called after changing any variable that could
|
|
* change the result of the wait condition.
|
|
*/
|
|
#define swait_event(wq, condition) \
|
|
do { \
|
|
if (condition) \
|
|
break; \
|
|
__swait_event(wq, condition); \
|
|
} while (0)
|
|
|
|
#define __swait_event_interruptible(wq, condition, ret) \
|
|
do { \
|
|
DEFINE_SWAITER(__wait); \
|
|
\
|
|
for (;;) { \
|
|
swait_prepare(&wq, &__wait, TASK_INTERRUPTIBLE); \
|
|
if (condition) \
|
|
break; \
|
|
if (signal_pending(current)) { \
|
|
ret = -ERESTARTSYS; \
|
|
break; \
|
|
} \
|
|
schedule(); \
|
|
} \
|
|
swait_finish(&wq, &__wait); \
|
|
} while (0)
|
|
|
|
#define __swait_event_interruptible_timeout(wq, condition, ret) \
|
|
do { \
|
|
DEFINE_SWAITER(__wait); \
|
|
\
|
|
for (;;) { \
|
|
swait_prepare(&wq, &__wait, TASK_INTERRUPTIBLE); \
|
|
if (condition) \
|
|
break; \
|
|
if (signal_pending(current)) { \
|
|
ret = -ERESTARTSYS; \
|
|
break; \
|
|
} \
|
|
ret = schedule_timeout(ret); \
|
|
if (!ret) \
|
|
break; \
|
|
} \
|
|
swait_finish(&wq, &__wait); \
|
|
} while (0)
|
|
|
|
/**
|
|
* swait_event_interruptible - sleep until a condition gets true
|
|
* @wq: the waitqueue to wait on
|
|
* @condition: a C expression for the event to wait for
|
|
*
|
|
* The process is put to sleep (TASK_INTERRUPTIBLE) until the
|
|
* @condition evaluates to true. The @condition is checked each time
|
|
* the waitqueue @wq is woken up.
|
|
*
|
|
* wake_up() has to be called after changing any variable that could
|
|
* change the result of the wait condition.
|
|
*/
|
|
#define swait_event_interruptible(wq, condition) \
|
|
({ \
|
|
int __ret = 0; \
|
|
if (!(condition)) \
|
|
__swait_event_interruptible(wq, condition, __ret); \
|
|
__ret; \
|
|
})
|
|
|
|
#define swait_event_interruptible_timeout(wq, condition, timeout) \
|
|
({ \
|
|
int __ret = timeout; \
|
|
if (!(condition)) \
|
|
__swait_event_interruptible_timeout(wq, condition, __ret); \
|
|
__ret; \
|
|
})
|
|
|
|
#define __swait_event_timeout(wq, condition, ret) \
|
|
do { \
|
|
DEFINE_SWAITER(__wait); \
|
|
\
|
|
for (;;) { \
|
|
swait_prepare(&wq, &__wait, TASK_UNINTERRUPTIBLE); \
|
|
if (condition) \
|
|
break; \
|
|
ret = schedule_timeout(ret); \
|
|
if (!ret) \
|
|
break; \
|
|
} \
|
|
swait_finish(&wq, &__wait); \
|
|
} while (0)
|
|
|
|
/**
|
|
* swait_event_timeout - sleep until a condition gets true or a timeout elapses
|
|
* @wq: the waitqueue to wait on
|
|
* @condition: a C expression for the event to wait for
|
|
* @timeout: timeout, in jiffies
|
|
*
|
|
* The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
|
|
* @condition evaluates to true. The @condition is checked each time
|
|
* the waitqueue @wq is woken up.
|
|
*
|
|
* wake_up() has to be called after changing any variable that could
|
|
* change the result of the wait condition.
|
|
*
|
|
* The function returns 0 if the @timeout elapsed, and the remaining
|
|
* jiffies if the condition evaluated to true before the timeout elapsed.
|
|
*/
|
|
#define swait_event_timeout(wq, condition, timeout) \
|
|
({ \
|
|
long __ret = timeout; \
|
|
if (!(condition)) \
|
|
__swait_event_timeout(wq, condition, __ret); \
|
|
__ret; \
|
|
})
|
|
|
|
#endif
|