快速链接:
.
个人博客笔记导读目录(全部)

• 在wait_for_completion时，先将x->wait加入到等待队列，在检查done的值，如果为0 ，则死循环卡住。推出循环后，则done–；
• 在complete时，先done++，在wake_up(x->wait)等待队列
  注意done–的最小值和done++的最大值都是(~0U)

结构体

struct completion {
    
	unsigned int done;
	wait_queue_head_t wait;
};

#define UINT_MAX	(~0U)

init_completion

#define init_completion(x) __init_completion(x)

static inline void __init_completion(struct completion *x)
{
    
	x->done = 0;
	init_waitqueue_head(&x->wait);
}

complete

void complete(struct completion *x)
{
    
	unsigned long flags;

	spin_lock_irqsave(&x->wait.lock, flags);

	if (x->done != UINT_MAX)
		x->done++;
	__wake_up_locked(&x->wait, TASK_NORMAL, 1);
	spin_unlock_irqrestore(&x->wait.lock, flags);
}
EXPORT_SYMBOL(complete);

wait_for_completion

wait_for_completion --> wait_for_common --> do_wait_for_common

void __sched wait_for_completion(struct completion *x)
{
    
	wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);
}
EXPORT_SYMBOL(wait_for_completion);


static long __sched wait_for_common(struct completion *x, long timeout, int state)
{
    
	return __wait_for_common(x, schedule_timeout, timeout, state);
}

static inline long __sched __wait_for_common(struct completion *x,
		  long (*action)(long), long timeout, int state)
{
    
	might_sleep();

	complete_acquire(x);

	spin_lock_irq(&x->wait.lock);
	timeout = do_wait_for_common(x, action, timeout, state);
	spin_unlock_irq(&x->wait.lock);

	complete_release(x);

	return timeout;
}

static inline long __sched do_wait_for_common(struct completion *x,
		   long (*action)(long), long timeout, int state)
{
    
	if (!x->done) {
    
		DECLARE_WAITQUEUE(wait, current);

		__add_wait_queue_entry_tail_exclusive(&x->wait, &wait);
		do {
    
			if (signal_pending_state(state, current)) {
    
				timeout = -ERESTARTSYS;
				break;
			}
			__set_current_state(state);
			spin_unlock_irq(&x->wait.lock);
			timeout = action(timeout);
			spin_lock_irq(&x->wait.lock);
		} while (!x->done && timeout);
		__remove_wait_queue(&x->wait, &wait);
		if (!x->done)
			return timeout;
	}
	if (x->done != UINT_MAX)
		x->done--;
	return timeout ?: 1;
}

wait_for_completion的相关API

wait_for_completion
wait_for_completion_timeout
wait_for_completion_interruptible
wait_for_completion_killable
wait_for_completion_killable_timeout
wait_for_completion_io
wait_for_common_io

TASK_UNINTERRUPTIBLE
TASK_INTERRUPTIBLE
TASK_KILLABLE

默认等待时间为MAX_SCHEDULE_TIMEOUT=LONG_MAX，也就是等于一个最大的数字((long)(~0UL >> 1)) = 9223372036854775807
void __sched wait_for_completion(struct completion *x)
{
    
	wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);
}


unsigned long __sched wait_for_completion_timeout(struct completion *x, unsigned long timeout)
{
    
	return wait_for_common(x, timeout, TASK_UNINTERRUPTIBLE);
}

int __sched wait_for_completion_interruptible(struct completion *x)
{
    
	long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_INTERRUPTIBLE);
	if (t == -ERESTARTSYS)
		return t;
	return 0;
}

long __sched wait_for_completion_interruptible_timeout(struct completion *x,
					  unsigned long timeout)
{
    
	return wait_for_common(x, timeout, TASK_INTERRUPTIBLE);
}

int __sched wait_for_completion_killable(struct completion *x)
{
    
	long t = wait_for_common(x, MAX_SCHEDULE_TIMEOUT, TASK_KILLABLE);
	if (t == -ERESTARTSYS)
		return t;
	return 0;
}

long __sched wait_for_completion_killable_timeout(struct completion *x,
				     unsigned long timeout)
{
    
	return wait_for_common(x, timeout, TASK_KILLABLE);
}

void __sched wait_for_completion_io(struct completion *x)
{
    
	wait_for_common_io(x, MAX_SCHEDULE_TIMEOUT, TASK_UNINTERRUPTIBLE);
}

unsigned long __sched wait_for_completion_io_timeout(struct completion *x, unsigned long timeout)
{
    
	return wait_for_common_io(x, timeout, TASK_UNINTERRUPTIBLE);
}

wait_for_common和wait_for_common_io的区别，区别在于schedule_timeout和io_schedule_timeout变量，这两个变量是指向函数的指针

static long __sched wait_for_common(struct completion *x, long timeout, int state)
{
    
	return __wait_for_common(x, schedule_timeout, timeout, state);
}

static long __sched wait_for_common_io(struct completion *x, long timeout, int state)
{
    
	return __wait_for_common(x, io_schedule_timeout, timeout, state);
}

下方的action(timeout)，其实就是在调用schedule_timeout(xxx)或io_schedule_timeout(xxx)

static inline long __sched do_wait_for_common(struct completion *x,
		   long (*action)(long), long timeout, int state)
{
    
	if (!x->done) {
    
		DECLARE_WAITQUEUE(wait, current);

		__add_wait_queue_entry_tail_exclusive(&x->wait, &wait);
		do {
    
			if (signal_pending_state(state, current)) {
    
				timeout = -ERESTARTSYS;
				break;
			}
			__set_current_state(state);
			spin_unlock_irq(&x->wait.lock);
			timeout = action(timeout);
			spin_lock_irq(&x->wait.lock);
		} while (!x->done && timeout);
		__remove_wait_queue(&x->wait, &wait);
		if (!x->done)
			return timeout;
	}
	if (x->done != UINT_MAX)
		x->done--;
	return timeout ?: 1;
}