mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
338 lines
11 KiB
338 lines
11 KiB
/* SPDX-License-Identifier: GPL-2.0 */ |
|
#ifndef _LINUX_WAIT_BIT_H |
|
#define _LINUX_WAIT_BIT_H |
|
|
|
/* |
|
* Linux wait-bit related types and methods: |
|
*/ |
|
#include <linux/wait.h> |
|
|
|
struct wait_bit_key { |
|
void *flags; |
|
int bit_nr; |
|
unsigned long timeout; |
|
}; |
|
|
|
struct wait_bit_queue_entry { |
|
struct wait_bit_key key; |
|
struct wait_queue_entry wq_entry; |
|
}; |
|
|
|
#define __WAIT_BIT_KEY_INITIALIZER(word, bit) \ |
|
{ .flags = word, .bit_nr = bit, } |
|
|
|
typedef int wait_bit_action_f(struct wait_bit_key *key, int mode); |
|
|
|
void __wake_up_bit(struct wait_queue_head *wq_head, void *word, int bit); |
|
int __wait_on_bit(struct wait_queue_head *wq_head, struct wait_bit_queue_entry *wbq_entry, wait_bit_action_f *action, unsigned int mode); |
|
int __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); |
|
void wake_up_bit(void *word, int bit); |
|
int out_of_line_wait_on_bit(void *word, int, wait_bit_action_f *action, unsigned int mode); |
|
int out_of_line_wait_on_bit_timeout(void *word, int, wait_bit_action_f *action, unsigned int mode, unsigned long timeout); |
|
int out_of_line_wait_on_bit_lock(void *word, int, wait_bit_action_f *action, unsigned int mode); |
|
struct wait_queue_head *bit_waitqueue(void *word, int bit); |
|
extern void __init wait_bit_init(void); |
|
|
|
int wake_bit_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync, void *key); |
|
|
|
#define DEFINE_WAIT_BIT(name, word, bit) \ |
|
struct wait_bit_queue_entry name = { \ |
|
.key = __WAIT_BIT_KEY_INITIALIZER(word, bit), \ |
|
.wq_entry = { \ |
|
.private = current, \ |
|
.func = wake_bit_function, \ |
|
.entry = \ |
|
LIST_HEAD_INIT((name).wq_entry.entry), \ |
|
}, \ |
|
} |
|
|
|
extern int bit_wait(struct wait_bit_key *key, int mode); |
|
extern int bit_wait_io(struct wait_bit_key *key, int mode); |
|
extern int bit_wait_timeout(struct wait_bit_key *key, int mode); |
|
extern int bit_wait_io_timeout(struct wait_bit_key *key, int mode); |
|
|
|
/** |
|
* wait_on_bit - wait for a bit to be cleared |
|
* @word: the word being waited on, a kernel virtual address |
|
* @bit: the bit of the word being waited on |
|
* @mode: the task state to sleep in |
|
* |
|
* There is a standard hashed waitqueue table for generic use. This |
|
* is the part of the hashtable's accessor API that waits on a bit. |
|
* For instance, if one were to have waiters on a bitflag, one would |
|
* call wait_on_bit() in threads waiting for the bit to clear. |
|
* One uses wait_on_bit() where one is waiting for the bit to clear, |
|
* but has no intention of setting it. |
|
* Returned value will be zero if the bit was cleared, or non-zero |
|
* if the process received a signal and the mode permitted wakeup |
|
* on that signal. |
|
*/ |
|
static inline int |
|
wait_on_bit(unsigned long *word, int bit, unsigned mode) |
|
{ |
|
might_sleep(); |
|
if (!test_bit(bit, word)) |
|
return 0; |
|
return out_of_line_wait_on_bit(word, bit, |
|
bit_wait, |
|
mode); |
|
} |
|
|
|
/** |
|
* wait_on_bit_io - wait for a bit to be cleared |
|
* @word: the word being waited on, a kernel virtual address |
|
* @bit: the bit of the word being waited on |
|
* @mode: the task state to sleep in |
|
* |
|
* Use the standard hashed waitqueue table to wait for a bit |
|
* to be cleared. This is similar to wait_on_bit(), but calls |
|
* io_schedule() instead of schedule() for the actual waiting. |
|
* |
|
* Returned value will be zero if the bit was cleared, or non-zero |
|
* if the process received a signal and the mode permitted wakeup |
|
* on that signal. |
|
*/ |
|
static inline int |
|
wait_on_bit_io(unsigned long *word, int bit, unsigned mode) |
|
{ |
|
might_sleep(); |
|
if (!test_bit(bit, word)) |
|
return 0; |
|
return out_of_line_wait_on_bit(word, bit, |
|
bit_wait_io, |
|
mode); |
|
} |
|
|
|
/** |
|
* wait_on_bit_timeout - wait for a bit to be cleared or a timeout elapses |
|
* @word: the word being waited on, a kernel virtual address |
|
* @bit: the bit of the word being waited on |
|
* @mode: the task state to sleep in |
|
* @timeout: timeout, in jiffies |
|
* |
|
* Use the standard hashed waitqueue table to wait for a bit |
|
* to be cleared. This is similar to wait_on_bit(), except also takes a |
|
* timeout parameter. |
|
* |
|
* Returned value will be zero if the bit was cleared before the |
|
* @timeout elapsed, or non-zero if the @timeout elapsed or process |
|
* received a signal and the mode permitted wakeup on that signal. |
|
*/ |
|
static inline int |
|
wait_on_bit_timeout(unsigned long *word, int bit, unsigned mode, |
|
unsigned long timeout) |
|
{ |
|
might_sleep(); |
|
if (!test_bit(bit, word)) |
|
return 0; |
|
return out_of_line_wait_on_bit_timeout(word, bit, |
|
bit_wait_timeout, |
|
mode, timeout); |
|
} |
|
|
|
/** |
|
* wait_on_bit_action - wait for a bit to be cleared |
|
* @word: the word being waited on, a kernel virtual address |
|
* @bit: the bit of the word being waited on |
|
* @action: the function used to sleep, which may take special actions |
|
* @mode: the task state to sleep in |
|
* |
|
* Use the standard hashed waitqueue table to wait for a bit |
|
* to be cleared, and allow the waiting action to be specified. |
|
* This is like wait_on_bit() but allows fine control of how the waiting |
|
* is done. |
|
* |
|
* Returned value will be zero if the bit was cleared, or non-zero |
|
* if the process received a signal and the mode permitted wakeup |
|
* on that signal. |
|
*/ |
|
static inline int |
|
wait_on_bit_action(unsigned long *word, int bit, wait_bit_action_f *action, |
|
unsigned mode) |
|
{ |
|
might_sleep(); |
|
if (!test_bit(bit, word)) |
|
return 0; |
|
return out_of_line_wait_on_bit(word, bit, action, mode); |
|
} |
|
|
|
/** |
|
* wait_on_bit_lock - wait for a bit to be cleared, when wanting to set it |
|
* @word: the word being waited on, a kernel virtual address |
|
* @bit: the bit of the word being waited on |
|
* @mode: the task state to sleep in |
|
* |
|
* There is a standard hashed waitqueue table for generic use. This |
|
* is the part of the hashtable's accessor API that waits on a bit |
|
* when one intends to set it, for instance, trying to lock bitflags. |
|
* For instance, if one were to have waiters trying to set bitflag |
|
* and waiting for it to clear before setting it, one would call |
|
* wait_on_bit() in threads waiting to be able to set the bit. |
|
* One uses wait_on_bit_lock() where one is waiting for the bit to |
|
* clear with the intention of setting it, and when done, clearing it. |
|
* |
|
* Returns zero if the bit was (eventually) found to be clear and was |
|
* set. Returns non-zero if a signal was delivered to the process and |
|
* the @mode allows that signal to wake the process. |
|
*/ |
|
static inline int |
|
wait_on_bit_lock(unsigned long *word, int bit, unsigned mode) |
|
{ |
|
might_sleep(); |
|
if (!test_and_set_bit(bit, word)) |
|
return 0; |
|
return out_of_line_wait_on_bit_lock(word, bit, bit_wait, mode); |
|
} |
|
|
|
/** |
|
* wait_on_bit_lock_io - wait for a bit to be cleared, when wanting to set it |
|
* @word: the word being waited on, a kernel virtual address |
|
* @bit: the bit of the word being waited on |
|
* @mode: the task state to sleep in |
|
* |
|
* Use the standard hashed waitqueue table to wait for a bit |
|
* to be cleared and then to atomically set it. This is similar |
|
* to wait_on_bit(), but calls io_schedule() instead of schedule() |
|
* for the actual waiting. |
|
* |
|
* Returns zero if the bit was (eventually) found to be clear and was |
|
* set. Returns non-zero if a signal was delivered to the process and |
|
* the @mode allows that signal to wake the process. |
|
*/ |
|
static inline int |
|
wait_on_bit_lock_io(unsigned long *word, int bit, unsigned mode) |
|
{ |
|
might_sleep(); |
|
if (!test_and_set_bit(bit, word)) |
|
return 0; |
|
return out_of_line_wait_on_bit_lock(word, bit, bit_wait_io, mode); |
|
} |
|
|
|
/** |
|
* wait_on_bit_lock_action - wait for a bit to be cleared, when wanting to set it |
|
* @word: the word being waited on, a kernel virtual address |
|
* @bit: the bit of the word being waited on |
|
* @action: the function used to sleep, which may take special actions |
|
* @mode: the task state to sleep in |
|
* |
|
* Use the standard hashed waitqueue table to wait for a bit |
|
* to be cleared and then to set it, and allow the waiting action |
|
* to be specified. |
|
* This is like wait_on_bit() but allows fine control of how the waiting |
|
* is done. |
|
* |
|
* Returns zero if the bit was (eventually) found to be clear and was |
|
* set. Returns non-zero if a signal was delivered to the process and |
|
* the @mode allows that signal to wake the process. |
|
*/ |
|
static inline int |
|
wait_on_bit_lock_action(unsigned long *word, int bit, wait_bit_action_f *action, |
|
unsigned mode) |
|
{ |
|
might_sleep(); |
|
if (!test_and_set_bit(bit, word)) |
|
return 0; |
|
return out_of_line_wait_on_bit_lock(word, bit, action, mode); |
|
} |
|
|
|
extern void init_wait_var_entry(struct wait_bit_queue_entry *wbq_entry, void *var, int flags); |
|
extern void wake_up_var(void *var); |
|
extern wait_queue_head_t *__var_waitqueue(void *p); |
|
|
|
#define ___wait_var_event(var, condition, state, exclusive, ret, cmd) \ |
|
({ \ |
|
__label__ __out; \ |
|
struct wait_queue_head *__wq_head = __var_waitqueue(var); \ |
|
struct wait_bit_queue_entry __wbq_entry; \ |
|
long __ret = ret; /* explicit shadow */ \ |
|
\ |
|
init_wait_var_entry(&__wbq_entry, var, \ |
|
exclusive ? WQ_FLAG_EXCLUSIVE : 0); \ |
|
for (;;) { \ |
|
long __int = prepare_to_wait_event(__wq_head, \ |
|
&__wbq_entry.wq_entry, \ |
|
state); \ |
|
if (condition) \ |
|
break; \ |
|
\ |
|
if (___wait_is_interruptible(state) && __int) { \ |
|
__ret = __int; \ |
|
goto __out; \ |
|
} \ |
|
\ |
|
cmd; \ |
|
} \ |
|
finish_wait(__wq_head, &__wbq_entry.wq_entry); \ |
|
__out: __ret; \ |
|
}) |
|
|
|
#define __wait_var_event(var, condition) \ |
|
___wait_var_event(var, condition, TASK_UNINTERRUPTIBLE, 0, 0, \ |
|
schedule()) |
|
|
|
#define wait_var_event(var, condition) \ |
|
do { \ |
|
might_sleep(); \ |
|
if (condition) \ |
|
break; \ |
|
__wait_var_event(var, condition); \ |
|
} while (0) |
|
|
|
#define __wait_var_event_killable(var, condition) \ |
|
___wait_var_event(var, condition, TASK_KILLABLE, 0, 0, \ |
|
schedule()) |
|
|
|
#define wait_var_event_killable(var, condition) \ |
|
({ \ |
|
int __ret = 0; \ |
|
might_sleep(); \ |
|
if (!(condition)) \ |
|
__ret = __wait_var_event_killable(var, condition); \ |
|
__ret; \ |
|
}) |
|
|
|
#define __wait_var_event_timeout(var, condition, timeout) \ |
|
___wait_var_event(var, ___wait_cond_timeout(condition), \ |
|
TASK_UNINTERRUPTIBLE, 0, timeout, \ |
|
__ret = schedule_timeout(__ret)) |
|
|
|
#define wait_var_event_timeout(var, condition, timeout) \ |
|
({ \ |
|
long __ret = timeout; \ |
|
might_sleep(); \ |
|
if (!___wait_cond_timeout(condition)) \ |
|
__ret = __wait_var_event_timeout(var, condition, timeout); \ |
|
__ret; \ |
|
}) |
|
|
|
#define __wait_var_event_interruptible(var, condition) \ |
|
___wait_var_event(var, condition, TASK_INTERRUPTIBLE, 0, 0, \ |
|
schedule()) |
|
|
|
#define wait_var_event_interruptible(var, condition) \ |
|
({ \ |
|
int __ret = 0; \ |
|
might_sleep(); \ |
|
if (!(condition)) \ |
|
__ret = __wait_var_event_interruptible(var, condition); \ |
|
__ret; \ |
|
}) |
|
|
|
/** |
|
* clear_and_wake_up_bit - clear a bit and wake up anyone waiting on that bit |
|
* |
|
* @bit: the bit of the word being waited on |
|
* @word: the word being waited on, a kernel virtual address |
|
* |
|
* You can use this helper if bitflags are manipulated atomically rather than |
|
* non-atomically under a lock. |
|
*/ |
|
static inline void clear_and_wake_up_bit(int bit, void *word) |
|
{ |
|
clear_bit_unlock(bit, word); |
|
/* See wake_up_bit() for which memory barrier you need to use. */ |
|
smp_mb__after_atomic(); |
|
wake_up_bit(word, bit); |
|
} |
|
|
|
#endif /* _LINUX_WAIT_BIT_H */
|
|
|