mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 17:30:02 +00:00
![Ingo Molnar](/assets/img/avatar_default.png)
So I've noticed a number of instances where it was not obvious from the code whether ->task_list was for a wait-queue head or a wait-queue entry. Furthermore, there's a number of wait-queue users where the lists are not for 'tasks' but other entities (poll tables, etc.), in which case the 'task_list' name is actively confusing. To clear this all up, name the wait-queue head and entry list structure fields unambiguously: struct wait_queue_head::task_list => ::head struct wait_queue_entry::task_list => ::entry For example, this code: rqw->wait.task_list.next != &wait->task_list ... is was pretty unclear (to me) what it's doing, while now it's written this way: rqw->wait.head.next != &wait->entry ... which makes it pretty clear that we are iterating a list until we see the head. Other examples are: list_for_each_entry_safe(pos, next, &x->task_list, task_list) { list_for_each_entry(wq, &fence->wait.task_list, task_list) { ... where it's unclear (to me) what we are iterating, and during review it's hard to tell whether it's trying to walk a wait-queue entry (which would be a bug), while now it's written as: list_for_each_entry_safe(pos, next, &x->head, entry) { list_for_each_entry(wq, &fence->wait.head, entry) { Cc: Linus Torvalds <torvalds@linux-foundation.org> Cc: Peter Zijlstra <peterz@infradead.org> Cc: Thomas Gleixner <tglx@linutronix.de> Cc: linux-kernel@vger.kernel.org Signed-off-by: Ingo Molnar <mingo@kernel.org>
261 lines
9.1 KiB
C
261 lines
9.1 KiB
C
#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;
|
|
#define WAIT_ATOMIC_T_BIT_NR -1
|
|
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, }
|
|
|
|
#define __WAIT_ATOMIC_T_KEY_INITIALIZER(p) \
|
|
{ .flags = p, .bit_nr = WAIT_ATOMIC_T_BIT_NR, }
|
|
|
|
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);
|
|
void wake_up_atomic_t(atomic_t *p);
|
|
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);
|
|
int out_of_line_wait_on_atomic_t(atomic_t *p, int (*)(atomic_t *), 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 bit);
|
|
extern int bit_wait_io(struct wait_bit_key *key, int bit);
|
|
extern int bit_wait_timeout(struct wait_bit_key *key, int bit);
|
|
extern int bit_wait_io_timeout(struct wait_bit_key *key, int bit);
|
|
|
|
/**
|
|
* 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);
|
|
}
|
|
|
|
/**
|
|
* wait_on_atomic_t - Wait for an atomic_t to become 0
|
|
* @val: The atomic value being waited on, a kernel virtual address
|
|
* @action: the function used to sleep, which may take special actions
|
|
* @mode: the task state to sleep in
|
|
*
|
|
* Wait for an atomic_t to become 0. We abuse the bit-wait waitqueue table for
|
|
* the purpose of getting a waitqueue, but we set the key to a bit number
|
|
* outside of the target 'word'.
|
|
*/
|
|
static inline
|
|
int wait_on_atomic_t(atomic_t *val, int (*action)(atomic_t *), unsigned mode)
|
|
{
|
|
might_sleep();
|
|
if (atomic_read(val) == 0)
|
|
return 0;
|
|
return out_of_line_wait_on_atomic_t(val, action, mode);
|
|
}
|
|
|
|
#endif /* _LINUX_WAIT_BIT_H */
|