1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
#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
|
