内核中completion的实现

内核编程中常见的一种模式是，在当前线程之外初始化某个活动，然后等待该活动的结束。这个活动可能是，创建一个新的内核线程或者新的用户空间进程、对一个已有进程的某个请求，或者某种类型的硬件动作，等等。在这种情况下，我们可以使用信号量来同步这两个任务。然而，内核中提供了另外一种机制——completion接口。Completion是一种轻量级的机制，他允许一个线程告诉另一个线程某个工作已经完成。

结构与初始化

       Completion在内核中的实现基于等待队列（关于等待队列理论知识在前面的文章中有介绍），completion结构很简单：

[cpp] view plain copy print ?

1. struct completion {  
2.     unsigned int done;/*用于同步的原子量*/  
3.     wait_queue_head_t wait;/*等待事件队列*/  
4. };  

struct completion {
	unsigned int done;/*用于同步的原子量*/
	wait_queue_head_t wait;/*等待事件队列*/
};

和信号量一样，初始化分为静态初始化和动态初始化两种情况：

静态初始化：

[cpp] view plain copy print ?

1. #define COMPLETION_INITIALIZER(work) \   
2.     { 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) }  
3.   
4. #define DECLARE_COMPLETION(work) \   
5.     struct completion work = COMPLETION_INITIALIZER(work)  

#define COMPLETION_INITIALIZER(work) \
	{ 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) }

#define DECLARE_COMPLETION(work) \
	struct completion work = COMPLETION_INITIALIZER(work)

动态初始化：

[cpp] view plain copy print ?

1. static inline void init_completion(struct completion *x)  
2. {  
3.     x->done = 0;  
4.     init_waitqueue_head(&x->wait);  
5. }  

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

     可见，两种初始化都将用于同步的done原子量置位了0，后面我们会看到，该变量在wait相关函数中减一，在complete系列函数中加一。

 

实现

       同步函数一般都成对出现，completion也不例外，我们看看最基本的两个complete和wait_for_completion函数的实现。

wait_for_completion最终由下面函数实现：

[cpp] view plain copy print ?

1. static inline long __sched  
2. do_wait_for_common(struct completion *x, long timeout, int state)  
3. {  
4.     if (!x->done) {  
5.         DECLARE_WAITQUEUE(wait, current);  
6.   
7.         wait.flags |= WQ_FLAG_EXCLUSIVE;  
8.         __add_wait_queue_tail(&x->wait, &wait);  
9.         do {  
10.             if (signal_pending_state(state, current)) {  
11.                 timeout = -ERESTARTSYS;  
12.                 break;  
13.             }  
14.             __set_current_state(state);  
15.             spin_unlock_irq(&x->wait.lock);  
16.             timeout = schedule_timeout(timeout);  
17.             spin_lock_irq(&x->wait.lock);  
18.         } while (!x->done && timeout);  
19.         __remove_wait_queue(&x->wait, &wait);  
20.         if (!x->done)  
21.             return timeout;  
22.     }  
23.     x->done--;  
24.     return timeout ?: 1;  
25. }  

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

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

而complete实现如下：

[cpp] view plain copy print ?

1. void complete(struct completion *x)  
2. {  
3.     unsigned long flags;  
4.   
5.     spin_lock_irqsave(&x->wait.lock, flags);  
6.     x->done++;  
7.     __wake_up_common(&x->wait, TASK_NORMAL, 1, 0, NULL);  
8.     spin_unlock_irqrestore(&x->wait.lock, flags);  
9. }  

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

	spin_lock_irqsave(&x->wait.lock, flags);
	x->done++;
	__wake_up_common(&x->wait, TASK_NORMAL, 1, 0, NULL);
	spin_unlock_irqrestore(&x->wait.lock, flags);
}

       不看内核实现的源代码我们也能想到他的实现，不外乎在wait函数中循环等待done变为可用（正），而另一边的complete函数为唤醒函数，当然是将done加一，唤醒待处理的函数。是的，从上面的代码看到，和我们想的一样。内核也是这样做的。

运用

运用LDD3中的例子：

[cpp] view plain copy print ?

1. #include <linux/module.h>   
2. #include <linux/init.h>   
3.   
4. #include <linux/sched.h>   
5. #include <linux/kernel.h>   
6. #include <linux/fs.h>   
7. #include <linux/types.h>   
8. #include <linux/completion.h>   
9.   
10. MODULE_LICENSE("GPL");  
11.   
12. static int complete_major=250;  
13. DECLARE_COMPLETION(comp);  
14.   
15. ssize_t complete_read(struct file *filp,char __user *buf,size_t count,loff_t *pos)  
16. {  
17.     printk(KERN_ERR "process %i (%s) going to sleep\n",current->pid,current->comm);  
18.     wait_for_completion(&comp);  
19.     printk(KERN_ERR "awoken %i (%s)\n",current->pid,current->comm);  
20.     return 0;  
21. }  
22.   
23. ssize_t complete_write(struct file *filp,const char __user *buf,size_t count,loff_t *pos)  
24. {  
25.     printk(KERN_ERR "process %i (%s) awakening the readers...\n",current->pid,current->comm);  
26.     complete(&comp);  
27.     return count;  
28. }  
29.   
30. struct file_operations complete_fops={  
31.     .owner=THIS_MODULE,  
32.     .read=complete_read,  
33.     .write=complete_write,  
34. };  
35.   
36. int complete_init(void)  
37. {  
38.     int result;  
39.     result=register_chrdev(complete_major,"complete",&complete_fops);  
40.     if(result<0)  
41.         return result;  
42.     if(complete_major==0)  
43.         complete_major=result;  
44.     return 0;  
45. }  
46. void complete_cleanup(void)  
47. {  
48.     unregister_chrdev(complete_major,"complete");  
49. }  
50. module_init(complete_init);  
51. module_exit(complete_cleanup);  

#include <linux/module.h>
#include <linux/init.h>

#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/completion.h>

MODULE_LICENSE("GPL");

static int complete_major=250;
DECLARE_COMPLETION(comp);

ssize_t complete_read(struct file *filp,char __user *buf,size_t count,loff_t *pos)
{
	printk(KERN_ERR "process %i (%s) going to sleep\n",current->pid,current->comm);
	wait_for_completion(&comp);
	printk(KERN_ERR "awoken %i (%s)\n",current->pid,current->comm);
	return 0;
}

ssize_t complete_write(struct file *filp,const char __user *buf,size_t count,loff_t *pos)
{
	printk(KERN_ERR "process %i (%s) awakening the readers...\n",current->pid,current->comm);
	complete(&comp);
	return count;
}

struct file_operations complete_fops={
	.owner=THIS_MODULE,
	.read=complete_read,
	.write=complete_write,
};

int complete_init(void)
{
	int result;
	result=register_chrdev(complete_major,"complete",&complete_fops);
	if(result<0)
		return result;
	if(complete_major==0)
		complete_major=result;
	return 0;
}
void complete_cleanup(void)
{
	unregister_chrdev(complete_major,"complete");
}
module_init(complete_init);
module_exit(complete_cleanup);

测试步骤：

1， mknod /dev/complete创建complete节点，在linux上驱动程序需要手动创建文件节点。

2， insmod complete.ko 插入驱动模块，这里要注意的是，因为我们的代码中是手动分配的设备号，很可能被系统已经使用了，所以如果出现这种情况，查看/proc/devices文件。找一个没有被使用的设备号。

3， cat /dev/complete 用于读该设备，调用设备的读函数

4， 打开另一个终端输入 echo “hello” > /dev/complete 该命令用于写入该设备。