Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1071297
  • 博文数量: 277
  • 博客积分: 8313
  • 博客等级: 中将
  • 技术积分: 2976
  • 用 户 组: 普通用户
  • 注册时间: 2010-04-22 11:25
文章分类

全部博文(277)

文章存档

2013年(17)

2012年(66)

2011年(104)

2010年(90)

我的朋友

分类: LINUX

2012-05-03 16:50:10

作者:bullbat


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


结构与初始化

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

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

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

静态初始化:

  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)  

动态初始化:

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

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

 

实现

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

wait_for_completion最终由下面函数实现:

  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. }  

而complete实现如下:

  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. }  

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


运用

运用LDD3中的例子:

  1. #include   
  2. #include   
  3.   
  4. #include   
  5. #include   
  6. #include   
  7. #include   
  8. #include   
  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);  

测试步骤:

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

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

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

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

阅读(791) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~