Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
1#ifndef _LINUX_WAIT_BIT_H
2#define _LINUX_WAIT_BIT_H
3
4/*
5 * Linux wait-bit related types and methods:
6 */
7#include <linux/wait.h>
8
9struct wait_bit_key {
10 void *flags;
11 int bit_nr;
12#define WAIT_ATOMIC_T_BIT_NR -1
13 unsigned long timeout;
14};
15
16struct wait_bit_queue_entry {
17 struct wait_bit_key key;
18 struct wait_queue_entry wq_entry;
19};
20
21#define __WAIT_BIT_KEY_INITIALIZER(word, bit) \
22 { .flags = word, .bit_nr = bit, }
23
24#define __WAIT_ATOMIC_T_KEY_INITIALIZER(p) \
25 { .flags = p, .bit_nr = WAIT_ATOMIC_T_BIT_NR, }
26
27typedef int wait_bit_action_f(struct wait_bit_key *key, int mode);
28void __wake_up_bit(struct wait_queue_head *wq_head, void *word, int bit);
29int __wait_on_bit(struct wait_queue_head *wq_head, struct wait_bit_queue_entry *wbq_entry, wait_bit_action_f *action, unsigned int mode);
30int __wait_on_bit_lock(struct wait_queue_head *wq_head, struct wait_bit_queue_entry *wbq_entry, wait_bit_action_f *action, unsigned int mode);
31void wake_up_bit(void *word, int bit);
32void wake_up_atomic_t(atomic_t *p);
33int out_of_line_wait_on_bit(void *word, int, wait_bit_action_f *action, unsigned int mode);
34int out_of_line_wait_on_bit_timeout(void *word, int, wait_bit_action_f *action, unsigned int mode, unsigned long timeout);
35int out_of_line_wait_on_bit_lock(void *word, int, wait_bit_action_f *action, unsigned int mode);
36int out_of_line_wait_on_atomic_t(atomic_t *p, int (*)(atomic_t *), unsigned int mode);
37struct wait_queue_head *bit_waitqueue(void *word, int bit);
38extern void __init wait_bit_init(void);
39
40int wake_bit_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync, void *key);
41
42#define DEFINE_WAIT_BIT(name, word, bit) \
43 struct wait_bit_queue_entry name = { \
44 .key = __WAIT_BIT_KEY_INITIALIZER(word, bit), \
45 .wq_entry = { \
46 .private = current, \
47 .func = wake_bit_function, \
48 .entry = \
49 LIST_HEAD_INIT((name).wq_entry.entry), \
50 }, \
51 }
52
53extern int bit_wait(struct wait_bit_key *key, int bit);
54extern int bit_wait_io(struct wait_bit_key *key, int bit);
55extern int bit_wait_timeout(struct wait_bit_key *key, int bit);
56extern int bit_wait_io_timeout(struct wait_bit_key *key, int bit);
57
58/**
59 * wait_on_bit - wait for a bit to be cleared
60 * @word: the word being waited on, a kernel virtual address
61 * @bit: the bit of the word being waited on
62 * @mode: the task state to sleep in
63 *
64 * There is a standard hashed waitqueue table for generic use. This
65 * is the part of the hashtable's accessor API that waits on a bit.
66 * For instance, if one were to have waiters on a bitflag, one would
67 * call wait_on_bit() in threads waiting for the bit to clear.
68 * One uses wait_on_bit() where one is waiting for the bit to clear,
69 * but has no intention of setting it.
70 * Returned value will be zero if the bit was cleared, or non-zero
71 * if the process received a signal and the mode permitted wakeup
72 * on that signal.
73 */
74static inline int
75wait_on_bit(unsigned long *word, int bit, unsigned mode)
76{
77 might_sleep();
78 if (!test_bit(bit, word))
79 return 0;
80 return out_of_line_wait_on_bit(word, bit,
81 bit_wait,
82 mode);
83}
84
85/**
86 * wait_on_bit_io - wait for a bit to be cleared
87 * @word: the word being waited on, a kernel virtual address
88 * @bit: the bit of the word being waited on
89 * @mode: the task state to sleep in
90 *
91 * Use the standard hashed waitqueue table to wait for a bit
92 * to be cleared. This is similar to wait_on_bit(), but calls
93 * io_schedule() instead of schedule() for the actual waiting.
94 *
95 * Returned value will be zero if the bit was cleared, or non-zero
96 * if the process received a signal and the mode permitted wakeup
97 * on that signal.
98 */
99static inline int
100wait_on_bit_io(unsigned long *word, int bit, unsigned mode)
101{
102 might_sleep();
103 if (!test_bit(bit, word))
104 return 0;
105 return out_of_line_wait_on_bit(word, bit,
106 bit_wait_io,
107 mode);
108}
109
110/**
111 * wait_on_bit_timeout - wait for a bit to be cleared or a timeout elapses
112 * @word: the word being waited on, a kernel virtual address
113 * @bit: the bit of the word being waited on
114 * @mode: the task state to sleep in
115 * @timeout: timeout, in jiffies
116 *
117 * Use the standard hashed waitqueue table to wait for a bit
118 * to be cleared. This is similar to wait_on_bit(), except also takes a
119 * timeout parameter.
120 *
121 * Returned value will be zero if the bit was cleared before the
122 * @timeout elapsed, or non-zero if the @timeout elapsed or process
123 * received a signal and the mode permitted wakeup on that signal.
124 */
125static inline int
126wait_on_bit_timeout(unsigned long *word, int bit, unsigned mode,
127 unsigned long timeout)
128{
129 might_sleep();
130 if (!test_bit(bit, word))
131 return 0;
132 return out_of_line_wait_on_bit_timeout(word, bit,
133 bit_wait_timeout,
134 mode, timeout);
135}
136
137/**
138 * wait_on_bit_action - wait for a bit to be cleared
139 * @word: the word being waited on, a kernel virtual address
140 * @bit: the bit of the word being waited on
141 * @action: the function used to sleep, which may take special actions
142 * @mode: the task state to sleep in
143 *
144 * Use the standard hashed waitqueue table to wait for a bit
145 * to be cleared, and allow the waiting action to be specified.
146 * This is like wait_on_bit() but allows fine control of how the waiting
147 * is done.
148 *
149 * Returned value will be zero if the bit was cleared, or non-zero
150 * if the process received a signal and the mode permitted wakeup
151 * on that signal.
152 */
153static inline int
154wait_on_bit_action(unsigned long *word, int bit, wait_bit_action_f *action,
155 unsigned mode)
156{
157 might_sleep();
158 if (!test_bit(bit, word))
159 return 0;
160 return out_of_line_wait_on_bit(word, bit, action, mode);
161}
162
163/**
164 * wait_on_bit_lock - wait for a bit to be cleared, when wanting to set it
165 * @word: the word being waited on, a kernel virtual address
166 * @bit: the bit of the word being waited on
167 * @mode: the task state to sleep in
168 *
169 * There is a standard hashed waitqueue table for generic use. This
170 * is the part of the hashtable's accessor API that waits on a bit
171 * when one intends to set it, for instance, trying to lock bitflags.
172 * For instance, if one were to have waiters trying to set bitflag
173 * and waiting for it to clear before setting it, one would call
174 * wait_on_bit() in threads waiting to be able to set the bit.
175 * One uses wait_on_bit_lock() where one is waiting for the bit to
176 * clear with the intention of setting it, and when done, clearing it.
177 *
178 * Returns zero if the bit was (eventually) found to be clear and was
179 * set. Returns non-zero if a signal was delivered to the process and
180 * the @mode allows that signal to wake the process.
181 */
182static inline int
183wait_on_bit_lock(unsigned long *word, int bit, unsigned mode)
184{
185 might_sleep();
186 if (!test_and_set_bit(bit, word))
187 return 0;
188 return out_of_line_wait_on_bit_lock(word, bit, bit_wait, mode);
189}
190
191/**
192 * wait_on_bit_lock_io - wait for a bit to be cleared, when wanting to set it
193 * @word: the word being waited on, a kernel virtual address
194 * @bit: the bit of the word being waited on
195 * @mode: the task state to sleep in
196 *
197 * Use the standard hashed waitqueue table to wait for a bit
198 * to be cleared and then to atomically set it. This is similar
199 * to wait_on_bit(), but calls io_schedule() instead of schedule()
200 * for the actual waiting.
201 *
202 * Returns zero if the bit was (eventually) found to be clear and was
203 * set. Returns non-zero if a signal was delivered to the process and
204 * the @mode allows that signal to wake the process.
205 */
206static inline int
207wait_on_bit_lock_io(unsigned long *word, int bit, unsigned mode)
208{
209 might_sleep();
210 if (!test_and_set_bit(bit, word))
211 return 0;
212 return out_of_line_wait_on_bit_lock(word, bit, bit_wait_io, mode);
213}
214
215/**
216 * wait_on_bit_lock_action - wait for a bit to be cleared, when wanting to set it
217 * @word: the word being waited on, a kernel virtual address
218 * @bit: the bit of the word being waited on
219 * @action: the function used to sleep, which may take special actions
220 * @mode: the task state to sleep in
221 *
222 * Use the standard hashed waitqueue table to wait for a bit
223 * to be cleared and then to set it, and allow the waiting action
224 * to be specified.
225 * This is like wait_on_bit() but allows fine control of how the waiting
226 * is done.
227 *
228 * Returns zero if the bit was (eventually) found to be clear and was
229 * set. Returns non-zero if a signal was delivered to the process and
230 * the @mode allows that signal to wake the process.
231 */
232static inline int
233wait_on_bit_lock_action(unsigned long *word, int bit, wait_bit_action_f *action,
234 unsigned mode)
235{
236 might_sleep();
237 if (!test_and_set_bit(bit, word))
238 return 0;
239 return out_of_line_wait_on_bit_lock(word, bit, action, mode);
240}
241
242/**
243 * wait_on_atomic_t - Wait for an atomic_t to become 0
244 * @val: The atomic value being waited on, a kernel virtual address
245 * @action: the function used to sleep, which may take special actions
246 * @mode: the task state to sleep in
247 *
248 * Wait for an atomic_t to become 0. We abuse the bit-wait waitqueue table for
249 * the purpose of getting a waitqueue, but we set the key to a bit number
250 * outside of the target 'word'.
251 */
252static inline
253int wait_on_atomic_t(atomic_t *val, int (*action)(atomic_t *), unsigned mode)
254{
255 might_sleep();
256 if (atomic_read(val) == 0)
257 return 0;
258 return out_of_line_wait_on_atomic_t(val, action, mode);
259}
260
261#endif /* _LINUX_WAIT_BIT_H */