kernel/sched/wait.c - linux - Git at Google

 /*
  * Generic waiting primitives.
  *
  * (C) 2004 Nadia Yvette Chambers, Oracle
  */
 #include <linux/init.h>
 #include <linux/export.h>
 #include <linux/sched/signal.h>
 #include <linux/sched/debug.h>
 #include <linux/mm.h>
 #include <linux/wait.h>
 #include <linux/hash.h>
 #include <linux/kthread.h>

 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_entry_tail(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 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);


 /*
  * 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 all the non-exclusive tasks and one exclusive task.
  *
  * 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 void __wake_up_common(struct wait_queue_head *wq_head, unsigned int mode,
 			int nr_exclusive, int wake_flags, void *key)
 {
 	wait_queue_entry_t *curr, *next;

 	list_for_each_entry_safe(curr, next, &wq_head->head, entry) {
 		unsigned flags = curr->flags;
 		int ret = curr->func(curr, mode, wake_flags, key);
 		if (ret < 0)
 			break;
 		if (ret && (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
 			break;
 	}
 }

 /**
  * __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
  *
  * It may be assumed that this function implies a write memory barrier before
  * changing the task state if and only if any tasks are woken up.
  */
 void __wake_up(struct wait_queue_head *wq_head, unsigned int mode,
 			int nr_exclusive, void *key)
 {
 	unsigned long flags;

 	spin_lock_irqsave(&wq_head->lock, flags);
 	__wake_up_common(wq_head, mode, nr_exclusive, 0, key);
 	spin_unlock_irqrestore(&wq_head->lock, flags);
 }
 EXPORT_SYMBOL(__wake_up);

 /*
  * 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);
 }
 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);
 }
 EXPORT_SYMBOL_GPL(__wake_up_locked_key);

 /**
  * __wake_up_sync_key - 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: 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.
  *
  * It may be assumed that this function implies a write memory barrier before
  * changing the task state if and only if any tasks are woken up.
  */
 void __wake_up_sync_key(struct wait_queue_head *wq_head, unsigned int mode,
 			int nr_exclusive, void *key)
 {
 	unsigned long flags;
 	int wake_flags = 1; /* XXX WF_SYNC */

 	if (unlikely(!wq_head))
 		return;

 	if (unlikely(nr_exclusive != 1))
 		wake_flags = 0;

 	spin_lock_irqsave(&wq_head->lock, flags);
 	__wake_up_common(wq_head, mode, nr_exclusive, wake_flags, key);
 	spin_unlock_irqrestore(&wq_head->lock, flags);
 }
 EXPORT_SYMBOL_GPL(__wake_up_sync_key);

 /*
  * __wake_up_sync - see __wake_up_sync_key()
  */
 void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode, int nr_exclusive)
 {
 	__wake_up_sync_key(wq_head, mode, nr_exclusive, NULL);
 }
 EXPORT_SYMBOL_GPL(__wake_up_sync);	/* For internal use only */

 /*
  * 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);

 void
 prepare_to_wait_exclusive(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_entry_tail(wq_head, wq_entry);
 	set_current_state(state);
 	spin_unlock_irqrestore(&wq_head->lock, flags);
 }
 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 (unlikely(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(&wq_entry->entry);
 	return ret;
 }
 EXPORT_SYMBOL(autoremove_wake_function);

 static inline bool is_kthread_should_stop(void)
 {
 	return (current->flags & PF_KTHREAD) && kthread_should_stop();
 }

 /*
  * DEFINE_WAIT_FUNC(wait, woken_wake_func);
  *
  * add_wait_queue(&wq_head, &wait);
  * for (;;) {
  *     if (condition)
  *         break;
  *
  *     p->state = mode;				condition = true;
  *     smp_mb(); // A				smp_wmb(); // C
  *     if (!wq_entry->flags & WQ_FLAG_WOKEN)	wq_entry->flags |= WQ_FLAG_WOKEN;
  *         schedule()				try_to_wake_up();
  *     p->state = TASK_RUNNING;		    ~~~~~~~~~~~~~~~~~~
  *     wq_entry->flags &= ~WQ_FLAG_WOKEN;		condition = true;
  *     smp_mb() // B				smp_wmb(); // C
  *						wq_entry->flags |= WQ_FLAG_WOKEN;
  * }
  * remove_wait_queue(&wq_head, &wait);
  *
  */
 long wait_woken(struct wait_queue_entry *wq_entry, unsigned mode, long timeout)
 {
 	set_current_state(mode); /* A */
 	/*
 	 * The above implies an smp_mb(), which matches with the smp_wmb() from
 	 * woken_wake_function() such that if we observe WQ_FLAG_WOKEN we must
 	 * also observe all state before the wakeup.
 	 */
 	if (!(wq_entry->flags & WQ_FLAG_WOKEN) && !is_kthread_should_stop())
 		timeout = schedule_timeout(timeout);
 	__set_current_state(TASK_RUNNING);

 	/*
 	 * The below implies an smp_mb(), it too pairs with the smp_wmb() from
 	 * woken_wake_function() such that we must either observe the wait
 	 * condition being true _OR_ WQ_FLAG_WOKEN such that we will not miss
 	 * an event.
 	 */
 	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)
 {
 	/*
 	 * Although this function is called under waitqueue lock, LOCK
 	 * doesn't imply write barrier and the users expects write
 	 * barrier semantics on wakeup functions.  The following
 	 * smp_wmb() is equivalent to smp_wmb() in try_to_wake_up()
 	 * and is paired with smp_store_mb() in wait_woken().
 	 */
 	smp_wmb(); /* C */
 	wq_entry->flags |= WQ_FLAG_WOKEN;

 	return default_wake_function(wq_entry, mode, sync, key);
 }
 EXPORT_SYMBOL(woken_wake_function);
	/*
	* Generic waiting primitives.
	*
	* (C) 2004 Nadia Yvette Chambers, Oracle
	*/
	#include <linux/init.h>
	#include <linux/export.h>
	#include <linux/sched/signal.h>
	#include <linux/sched/debug.h>
	#include <linux/mm.h>
	#include <linux/wait.h>
	#include <linux/hash.h>
	#include <linux/kthread.h>

	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_entry_tail(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 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);


	/*
	* 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 all the non-exclusive tasks and one exclusive task.
	*
	* 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 void __wake_up_common(struct wait_queue_head *wq_head, unsigned int mode,
	int nr_exclusive, int wake_flags, void *key)
	{
	wait_queue_entry_t curr, next;

	list_for_each_entry_safe(curr, next, &wq_head->head, entry) {
	unsigned flags = curr->flags;
	int ret = curr->func(curr, mode, wake_flags, key);
	if (ret < 0)
	break;
	if (ret && (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
	break;
	}
	}

	/**
	* __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
	*
	* It may be assumed that this function implies a write memory barrier before
	* changing the task state if and only if any tasks are woken up.
	*/
	void __wake_up(struct wait_queue_head *wq_head, unsigned int mode,
	int nr_exclusive, void *key)
	{
	unsigned long flags;

	spin_lock_irqsave(&wq_head->lock, flags);
	__wake_up_common(wq_head, mode, nr_exclusive, 0, key);
	spin_unlock_irqrestore(&wq_head->lock, flags);
	}
	EXPORT_SYMBOL(__wake_up);

	/*
	* 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);
	}
	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);
	}
	EXPORT_SYMBOL_GPL(__wake_up_locked_key);

	/**
	* __wake_up_sync_key - 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: 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.
	*
	* It may be assumed that this function implies a write memory barrier before
	* changing the task state if and only if any tasks are woken up.
	*/
	void __wake_up_sync_key(struct wait_queue_head *wq_head, unsigned int mode,
	int nr_exclusive, void *key)
	{
	unsigned long flags;
	int wake_flags = 1; /* XXX WF_SYNC */

	if (unlikely(!wq_head))
	return;

	if (unlikely(nr_exclusive != 1))
	wake_flags = 0;

	spin_lock_irqsave(&wq_head->lock, flags);
	__wake_up_common(wq_head, mode, nr_exclusive, wake_flags, key);
	spin_unlock_irqrestore(&wq_head->lock, flags);
	}
	EXPORT_SYMBOL_GPL(__wake_up_sync_key);

	/*
	* __wake_up_sync - see __wake_up_sync_key()
	*/
	void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode, int nr_exclusive)
	{
	__wake_up_sync_key(wq_head, mode, nr_exclusive, NULL);
	}
	EXPORT_SYMBOL_GPL(__wake_up_sync); /* For internal use only */

	/*
	* 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);

	void
	prepare_to_wait_exclusive(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_entry_tail(wq_head, wq_entry);
	set_current_state(state);
	spin_unlock_irqrestore(&wq_head->lock, flags);
	}
	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 (unlikely(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(&wq_entry->entry);
	return ret;
	}
	EXPORT_SYMBOL(autoremove_wake_function);

	static inline bool is_kthread_should_stop(void)
	{
	return (current->flags & PF_KTHREAD) && kthread_should_stop();
	}

	/*
	* DEFINE_WAIT_FUNC(wait, woken_wake_func);
	*
	* add_wait_queue(&wq_head, &wait);
	* for (;;) {
	* if (condition)
	* break;
	*
	* p->state = mode; condition = true;
	* smp_mb(); // A smp_wmb(); // C
	* if (!wq_entry->flags & WQ_FLAG_WOKEN) wq_entry->flags \|= WQ_FLAG_WOKEN;
	* schedule() try_to_wake_up();
	* p->state = TASK_RUNNING; ~~~~~~~~~~~~~~~~~~
	* wq_entry->flags &= ~WQ_FLAG_WOKEN; condition = true;
	* smp_mb() // B smp_wmb(); // C
	* wq_entry->flags \|= WQ_FLAG_WOKEN;
	* }
	* remove_wait_queue(&wq_head, &wait);
	*
	*/
	long wait_woken(struct wait_queue_entry *wq_entry, unsigned mode, long timeout)
	{
	set_current_state(mode); /* A */
	/*
	* The above implies an smp_mb(), which matches with the smp_wmb() from
	* woken_wake_function() such that if we observe WQ_FLAG_WOKEN we must
	* also observe all state before the wakeup.
	*/
	if (!(wq_entry->flags & WQ_FLAG_WOKEN) && !is_kthread_should_stop())
	timeout = schedule_timeout(timeout);
	__set_current_state(TASK_RUNNING);

	/*
	* The below implies an smp_mb(), it too pairs with the smp_wmb() from
	* woken_wake_function() such that we must either observe the wait
	* condition being true _OR_ WQ_FLAG_WOKEN such that we will not miss
	* an event.
	*/
	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)
	{
	/*
	* Although this function is called under waitqueue lock, LOCK
	* doesn't imply write barrier and the users expects write
	* barrier semantics on wakeup functions. The following
	* smp_wmb() is equivalent to smp_wmb() in try_to_wake_up()
	* and is paired with smp_store_mb() in wait_woken().
	*/
	smp_wmb(); /* C */
	wq_entry->flags \|= WQ_FLAG_WOKEN;

	return default_wake_function(wq_entry, mode, sync, key);
	}
	EXPORT_SYMBOL(woken_wake_function);