mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-11-28 22:54:05 +08:00
6f63904c8f
Add complete_on_current_cpu, wake_up_poll_on_current_cpu helpers to wake up tasks on the current CPU. These two helpers are useful when the task needs to make a synchronous context switch to another task. In this context, synchronous means it wakes up the target task and falls asleep right after that. One example of such workloads is seccomp user notifies. This mechanism allows the supervisor process handles system calls on behalf of a target process. While the supervisor is handling an intercepted system call, the target process will be blocked in the kernel, waiting for a response to come back. On-CPU context switches are much faster than regular ones. Signed-off-by: Andrei Vagin <avagin@google.com> Acked-by: "Peter Zijlstra (Intel)" <peterz@infradead.org> Link: https://lore.kernel.org/r/20230308073201.3102738-4-avagin@google.com Signed-off-by: Kees Cook <keescook@chromium.org>
487 lines
15 KiB
C
487 lines
15 KiB
C
// SPDX-License-Identifier: GPL-2.0-only
|
|
/*
|
|
* Generic waiting primitives.
|
|
*
|
|
* (C) 2004 Nadia Yvette Chambers, Oracle
|
|
*/
|
|
|
|
void __init_waitqueue_head(struct wait_queue_head *wq_head, const char *name, struct lock_class_key *key)
|
|
{
|
|
spin_lock_init(&wq_head->lock);
|
|
lockdep_set_class_and_name(&wq_head->lock, key, name);
|
|
INIT_LIST_HEAD(&wq_head->head);
|
|
}
|
|
|
|
EXPORT_SYMBOL(__init_waitqueue_head);
|
|
|
|
void add_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
|
|
{
|
|
unsigned long flags;
|
|
|
|
wq_entry->flags &= ~WQ_FLAG_EXCLUSIVE;
|
|
spin_lock_irqsave(&wq_head->lock, flags);
|
|
__add_wait_queue(wq_head, wq_entry);
|
|
spin_unlock_irqrestore(&wq_head->lock, flags);
|
|
}
|
|
EXPORT_SYMBOL(add_wait_queue);
|
|
|
|
void add_wait_queue_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
|
|
{
|
|
unsigned long flags;
|
|
|
|
wq_entry->flags |= WQ_FLAG_EXCLUSIVE;
|
|
spin_lock_irqsave(&wq_head->lock, flags);
|
|
__add_wait_queue_entry_tail(wq_head, wq_entry);
|
|
spin_unlock_irqrestore(&wq_head->lock, flags);
|
|
}
|
|
EXPORT_SYMBOL(add_wait_queue_exclusive);
|
|
|
|
void add_wait_queue_priority(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
|
|
{
|
|
unsigned long flags;
|
|
|
|
wq_entry->flags |= WQ_FLAG_EXCLUSIVE | WQ_FLAG_PRIORITY;
|
|
spin_lock_irqsave(&wq_head->lock, flags);
|
|
__add_wait_queue(wq_head, wq_entry);
|
|
spin_unlock_irqrestore(&wq_head->lock, flags);
|
|
}
|
|
EXPORT_SYMBOL_GPL(add_wait_queue_priority);
|
|
|
|
void remove_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
|
|
{
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&wq_head->lock, flags);
|
|
__remove_wait_queue(wq_head, wq_entry);
|
|
spin_unlock_irqrestore(&wq_head->lock, flags);
|
|
}
|
|
EXPORT_SYMBOL(remove_wait_queue);
|
|
|
|
/*
|
|
* Scan threshold to break wait queue walk.
|
|
* This allows a waker to take a break from holding the
|
|
* wait queue lock during the wait queue walk.
|
|
*/
|
|
#define WAITQUEUE_WALK_BREAK_CNT 64
|
|
|
|
/*
|
|
* The core wakeup function. Non-exclusive wakeups (nr_exclusive == 0) just
|
|
* wake everything up. If it's an exclusive wakeup (nr_exclusive == small +ve
|
|
* number) then we wake that number of exclusive tasks, and potentially all
|
|
* the non-exclusive tasks. Normally, exclusive tasks will be at the end of
|
|
* the list and any non-exclusive tasks will be woken first. A priority task
|
|
* may be at the head of the list, and can consume the event without any other
|
|
* tasks being woken.
|
|
*
|
|
* There are circumstances in which we can try to wake a task which has already
|
|
* started to run but is not in state TASK_RUNNING. try_to_wake_up() returns
|
|
* zero in this (rare) case, and we handle it by continuing to scan the queue.
|
|
*/
|
|
static int __wake_up_common(struct wait_queue_head *wq_head, unsigned int mode,
|
|
int nr_exclusive, int wake_flags, void *key,
|
|
wait_queue_entry_t *bookmark)
|
|
{
|
|
wait_queue_entry_t *curr, *next;
|
|
int cnt = 0;
|
|
|
|
lockdep_assert_held(&wq_head->lock);
|
|
|
|
if (bookmark && (bookmark->flags & WQ_FLAG_BOOKMARK)) {
|
|
curr = list_next_entry(bookmark, entry);
|
|
|
|
list_del(&bookmark->entry);
|
|
bookmark->flags = 0;
|
|
} else
|
|
curr = list_first_entry(&wq_head->head, wait_queue_entry_t, entry);
|
|
|
|
if (&curr->entry == &wq_head->head)
|
|
return nr_exclusive;
|
|
|
|
list_for_each_entry_safe_from(curr, next, &wq_head->head, entry) {
|
|
unsigned flags = curr->flags;
|
|
int ret;
|
|
|
|
if (flags & WQ_FLAG_BOOKMARK)
|
|
continue;
|
|
|
|
ret = curr->func(curr, mode, wake_flags, key);
|
|
if (ret < 0)
|
|
break;
|
|
if (ret && (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
|
|
break;
|
|
|
|
if (bookmark && (++cnt > WAITQUEUE_WALK_BREAK_CNT) &&
|
|
(&next->entry != &wq_head->head)) {
|
|
bookmark->flags = WQ_FLAG_BOOKMARK;
|
|
list_add_tail(&bookmark->entry, &next->entry);
|
|
break;
|
|
}
|
|
}
|
|
|
|
return nr_exclusive;
|
|
}
|
|
|
|
static int __wake_up_common_lock(struct wait_queue_head *wq_head, unsigned int mode,
|
|
int nr_exclusive, int wake_flags, void *key)
|
|
{
|
|
unsigned long flags;
|
|
wait_queue_entry_t bookmark;
|
|
int remaining = nr_exclusive;
|
|
|
|
bookmark.flags = 0;
|
|
bookmark.private = NULL;
|
|
bookmark.func = NULL;
|
|
INIT_LIST_HEAD(&bookmark.entry);
|
|
|
|
do {
|
|
spin_lock_irqsave(&wq_head->lock, flags);
|
|
remaining = __wake_up_common(wq_head, mode, remaining,
|
|
wake_flags, key, &bookmark);
|
|
spin_unlock_irqrestore(&wq_head->lock, flags);
|
|
} while (bookmark.flags & WQ_FLAG_BOOKMARK);
|
|
|
|
return nr_exclusive - remaining;
|
|
}
|
|
|
|
/**
|
|
* __wake_up - wake up threads blocked on a waitqueue.
|
|
* @wq_head: the waitqueue
|
|
* @mode: which threads
|
|
* @nr_exclusive: how many wake-one or wake-many threads to wake up
|
|
* @key: is directly passed to the wakeup function
|
|
*
|
|
* If this function wakes up a task, it executes a full memory barrier
|
|
* before accessing the task state. Returns the number of exclusive
|
|
* tasks that were awaken.
|
|
*/
|
|
int __wake_up(struct wait_queue_head *wq_head, unsigned int mode,
|
|
int nr_exclusive, void *key)
|
|
{
|
|
return __wake_up_common_lock(wq_head, mode, nr_exclusive, 0, key);
|
|
}
|
|
EXPORT_SYMBOL(__wake_up);
|
|
|
|
void __wake_up_on_current_cpu(struct wait_queue_head *wq_head, unsigned int mode, void *key)
|
|
{
|
|
__wake_up_common_lock(wq_head, mode, 1, WF_CURRENT_CPU, key);
|
|
}
|
|
|
|
/*
|
|
* Same as __wake_up but called with the spinlock in wait_queue_head_t held.
|
|
*/
|
|
void __wake_up_locked(struct wait_queue_head *wq_head, unsigned int mode, int nr)
|
|
{
|
|
__wake_up_common(wq_head, mode, nr, 0, NULL, NULL);
|
|
}
|
|
EXPORT_SYMBOL_GPL(__wake_up_locked);
|
|
|
|
void __wake_up_locked_key(struct wait_queue_head *wq_head, unsigned int mode, void *key)
|
|
{
|
|
__wake_up_common(wq_head, mode, 1, 0, key, NULL);
|
|
}
|
|
EXPORT_SYMBOL_GPL(__wake_up_locked_key);
|
|
|
|
void __wake_up_locked_key_bookmark(struct wait_queue_head *wq_head,
|
|
unsigned int mode, void *key, wait_queue_entry_t *bookmark)
|
|
{
|
|
__wake_up_common(wq_head, mode, 1, 0, key, bookmark);
|
|
}
|
|
EXPORT_SYMBOL_GPL(__wake_up_locked_key_bookmark);
|
|
|
|
/**
|
|
* __wake_up_sync_key - wake up threads blocked on a waitqueue.
|
|
* @wq_head: the waitqueue
|
|
* @mode: which threads
|
|
* @key: opaque value to be passed to wakeup targets
|
|
*
|
|
* The sync wakeup differs that the waker knows that it will schedule
|
|
* away soon, so while the target thread will be woken up, it will not
|
|
* be migrated to another CPU - ie. the two threads are 'synchronized'
|
|
* with each other. This can prevent needless bouncing between CPUs.
|
|
*
|
|
* On UP it can prevent extra preemption.
|
|
*
|
|
* If this function wakes up a task, it executes a full memory barrier before
|
|
* accessing the task state.
|
|
*/
|
|
void __wake_up_sync_key(struct wait_queue_head *wq_head, unsigned int mode,
|
|
void *key)
|
|
{
|
|
if (unlikely(!wq_head))
|
|
return;
|
|
|
|
__wake_up_common_lock(wq_head, mode, 1, WF_SYNC, key);
|
|
}
|
|
EXPORT_SYMBOL_GPL(__wake_up_sync_key);
|
|
|
|
/**
|
|
* __wake_up_locked_sync_key - wake up a thread blocked on a locked waitqueue.
|
|
* @wq_head: the waitqueue
|
|
* @mode: which threads
|
|
* @key: opaque value to be passed to wakeup targets
|
|
*
|
|
* The sync wakeup differs in that the waker knows that it will schedule
|
|
* away soon, so while the target thread will be woken up, it will not
|
|
* be migrated to another CPU - ie. the two threads are 'synchronized'
|
|
* with each other. This can prevent needless bouncing between CPUs.
|
|
*
|
|
* On UP it can prevent extra preemption.
|
|
*
|
|
* If this function wakes up a task, it executes a full memory barrier before
|
|
* accessing the task state.
|
|
*/
|
|
void __wake_up_locked_sync_key(struct wait_queue_head *wq_head,
|
|
unsigned int mode, void *key)
|
|
{
|
|
__wake_up_common(wq_head, mode, 1, WF_SYNC, key, NULL);
|
|
}
|
|
EXPORT_SYMBOL_GPL(__wake_up_locked_sync_key);
|
|
|
|
/*
|
|
* __wake_up_sync - see __wake_up_sync_key()
|
|
*/
|
|
void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode)
|
|
{
|
|
__wake_up_sync_key(wq_head, mode, NULL);
|
|
}
|
|
EXPORT_SYMBOL_GPL(__wake_up_sync); /* For internal use only */
|
|
|
|
void __wake_up_pollfree(struct wait_queue_head *wq_head)
|
|
{
|
|
__wake_up(wq_head, TASK_NORMAL, 0, poll_to_key(EPOLLHUP | POLLFREE));
|
|
/* POLLFREE must have cleared the queue. */
|
|
WARN_ON_ONCE(waitqueue_active(wq_head));
|
|
}
|
|
|
|
/*
|
|
* Note: we use "set_current_state()" _after_ the wait-queue add,
|
|
* because we need a memory barrier there on SMP, so that any
|
|
* wake-function that tests for the wait-queue being active
|
|
* will be guaranteed to see waitqueue addition _or_ subsequent
|
|
* tests in this thread will see the wakeup having taken place.
|
|
*
|
|
* The spin_unlock() itself is semi-permeable and only protects
|
|
* one way (it only protects stuff inside the critical region and
|
|
* stops them from bleeding out - it would still allow subsequent
|
|
* loads to move into the critical region).
|
|
*/
|
|
void
|
|
prepare_to_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state)
|
|
{
|
|
unsigned long flags;
|
|
|
|
wq_entry->flags &= ~WQ_FLAG_EXCLUSIVE;
|
|
spin_lock_irqsave(&wq_head->lock, flags);
|
|
if (list_empty(&wq_entry->entry))
|
|
__add_wait_queue(wq_head, wq_entry);
|
|
set_current_state(state);
|
|
spin_unlock_irqrestore(&wq_head->lock, flags);
|
|
}
|
|
EXPORT_SYMBOL(prepare_to_wait);
|
|
|
|
/* Returns true if we are the first waiter in the queue, false otherwise. */
|
|
bool
|
|
prepare_to_wait_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state)
|
|
{
|
|
unsigned long flags;
|
|
bool was_empty = false;
|
|
|
|
wq_entry->flags |= WQ_FLAG_EXCLUSIVE;
|
|
spin_lock_irqsave(&wq_head->lock, flags);
|
|
if (list_empty(&wq_entry->entry)) {
|
|
was_empty = list_empty(&wq_head->head);
|
|
__add_wait_queue_entry_tail(wq_head, wq_entry);
|
|
}
|
|
set_current_state(state);
|
|
spin_unlock_irqrestore(&wq_head->lock, flags);
|
|
return was_empty;
|
|
}
|
|
EXPORT_SYMBOL(prepare_to_wait_exclusive);
|
|
|
|
void init_wait_entry(struct wait_queue_entry *wq_entry, int flags)
|
|
{
|
|
wq_entry->flags = flags;
|
|
wq_entry->private = current;
|
|
wq_entry->func = autoremove_wake_function;
|
|
INIT_LIST_HEAD(&wq_entry->entry);
|
|
}
|
|
EXPORT_SYMBOL(init_wait_entry);
|
|
|
|
long prepare_to_wait_event(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state)
|
|
{
|
|
unsigned long flags;
|
|
long ret = 0;
|
|
|
|
spin_lock_irqsave(&wq_head->lock, flags);
|
|
if (signal_pending_state(state, current)) {
|
|
/*
|
|
* Exclusive waiter must not fail if it was selected by wakeup,
|
|
* it should "consume" the condition we were waiting for.
|
|
*
|
|
* The caller will recheck the condition and return success if
|
|
* we were already woken up, we can not miss the event because
|
|
* wakeup locks/unlocks the same wq_head->lock.
|
|
*
|
|
* But we need to ensure that set-condition + wakeup after that
|
|
* can't see us, it should wake up another exclusive waiter if
|
|
* we fail.
|
|
*/
|
|
list_del_init(&wq_entry->entry);
|
|
ret = -ERESTARTSYS;
|
|
} else {
|
|
if (list_empty(&wq_entry->entry)) {
|
|
if (wq_entry->flags & WQ_FLAG_EXCLUSIVE)
|
|
__add_wait_queue_entry_tail(wq_head, wq_entry);
|
|
else
|
|
__add_wait_queue(wq_head, wq_entry);
|
|
}
|
|
set_current_state(state);
|
|
}
|
|
spin_unlock_irqrestore(&wq_head->lock, flags);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(prepare_to_wait_event);
|
|
|
|
/*
|
|
* Note! These two wait functions are entered with the
|
|
* wait-queue lock held (and interrupts off in the _irq
|
|
* case), so there is no race with testing the wakeup
|
|
* condition in the caller before they add the wait
|
|
* entry to the wake queue.
|
|
*/
|
|
int do_wait_intr(wait_queue_head_t *wq, wait_queue_entry_t *wait)
|
|
{
|
|
if (likely(list_empty(&wait->entry)))
|
|
__add_wait_queue_entry_tail(wq, wait);
|
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
if (signal_pending(current))
|
|
return -ERESTARTSYS;
|
|
|
|
spin_unlock(&wq->lock);
|
|
schedule();
|
|
spin_lock(&wq->lock);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(do_wait_intr);
|
|
|
|
int do_wait_intr_irq(wait_queue_head_t *wq, wait_queue_entry_t *wait)
|
|
{
|
|
if (likely(list_empty(&wait->entry)))
|
|
__add_wait_queue_entry_tail(wq, wait);
|
|
|
|
set_current_state(TASK_INTERRUPTIBLE);
|
|
if (signal_pending(current))
|
|
return -ERESTARTSYS;
|
|
|
|
spin_unlock_irq(&wq->lock);
|
|
schedule();
|
|
spin_lock_irq(&wq->lock);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(do_wait_intr_irq);
|
|
|
|
/**
|
|
* finish_wait - clean up after waiting in a queue
|
|
* @wq_head: waitqueue waited on
|
|
* @wq_entry: wait descriptor
|
|
*
|
|
* Sets current thread back to running state and removes
|
|
* the wait descriptor from the given waitqueue if still
|
|
* queued.
|
|
*/
|
|
void finish_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
|
|
{
|
|
unsigned long flags;
|
|
|
|
__set_current_state(TASK_RUNNING);
|
|
/*
|
|
* We can check for list emptiness outside the lock
|
|
* IFF:
|
|
* - we use the "careful" check that verifies both
|
|
* the next and prev pointers, so that there cannot
|
|
* be any half-pending updates in progress on other
|
|
* CPU's that we haven't seen yet (and that might
|
|
* still change the stack area.
|
|
* and
|
|
* - all other users take the lock (ie we can only
|
|
* have _one_ other CPU that looks at or modifies
|
|
* the list).
|
|
*/
|
|
if (!list_empty_careful(&wq_entry->entry)) {
|
|
spin_lock_irqsave(&wq_head->lock, flags);
|
|
list_del_init(&wq_entry->entry);
|
|
spin_unlock_irqrestore(&wq_head->lock, flags);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(finish_wait);
|
|
|
|
int autoremove_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync, void *key)
|
|
{
|
|
int ret = default_wake_function(wq_entry, mode, sync, key);
|
|
|
|
if (ret)
|
|
list_del_init_careful(&wq_entry->entry);
|
|
|
|
return ret;
|
|
}
|
|
EXPORT_SYMBOL(autoremove_wake_function);
|
|
|
|
/*
|
|
* DEFINE_WAIT_FUNC(wait, woken_wake_func);
|
|
*
|
|
* add_wait_queue(&wq_head, &wait);
|
|
* for (;;) {
|
|
* if (condition)
|
|
* break;
|
|
*
|
|
* // in wait_woken() // in woken_wake_function()
|
|
*
|
|
* p->state = mode; wq_entry->flags |= WQ_FLAG_WOKEN;
|
|
* smp_mb(); // A try_to_wake_up():
|
|
* if (!(wq_entry->flags & WQ_FLAG_WOKEN)) <full barrier>
|
|
* schedule() if (p->state & mode)
|
|
* p->state = TASK_RUNNING; p->state = TASK_RUNNING;
|
|
* wq_entry->flags &= ~WQ_FLAG_WOKEN; ~~~~~~~~~~~~~~~~~~
|
|
* smp_mb(); // B condition = true;
|
|
* } smp_mb(); // C
|
|
* remove_wait_queue(&wq_head, &wait); wq_entry->flags |= WQ_FLAG_WOKEN;
|
|
*/
|
|
long wait_woken(struct wait_queue_entry *wq_entry, unsigned mode, long timeout)
|
|
{
|
|
/*
|
|
* The below executes an smp_mb(), which matches with the full barrier
|
|
* executed by the try_to_wake_up() in woken_wake_function() such that
|
|
* either we see the store to wq_entry->flags in woken_wake_function()
|
|
* or woken_wake_function() sees our store to current->state.
|
|
*/
|
|
set_current_state(mode); /* A */
|
|
if (!(wq_entry->flags & WQ_FLAG_WOKEN) && !kthread_should_stop_or_park())
|
|
timeout = schedule_timeout(timeout);
|
|
__set_current_state(TASK_RUNNING);
|
|
|
|
/*
|
|
* The below executes an smp_mb(), which matches with the smp_mb() (C)
|
|
* in woken_wake_function() such that either we see the wait condition
|
|
* being true or the store to wq_entry->flags in woken_wake_function()
|
|
* follows ours in the coherence order.
|
|
*/
|
|
smp_store_mb(wq_entry->flags, wq_entry->flags & ~WQ_FLAG_WOKEN); /* B */
|
|
|
|
return timeout;
|
|
}
|
|
EXPORT_SYMBOL(wait_woken);
|
|
|
|
int woken_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync, void *key)
|
|
{
|
|
/* Pairs with the smp_store_mb() in wait_woken(). */
|
|
smp_mb(); /* C */
|
|
wq_entry->flags |= WQ_FLAG_WOKEN;
|
|
|
|
return default_wake_function(wq_entry, mode, sync, key);
|
|
}
|
|
EXPORT_SYMBOL(woken_wake_function);
|