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

结构与初始化

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

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

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

静态初始化：

[cpp] view plain copy
  1. #define COMPLETION_INITIALIZER(work) \
  2. { 0, __WAIT_QUEUE_HEAD_INITIALIZER((work).wait) }
  3. #define DECLARE_COMPLETION(work) \
  4. struct completion work = COMPLETION_INITIALIZER(work)

动态初始化：

[cpp] view plain copy
  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最终由下面函数实现：

[cpp] view plain copy
  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. wait.flags |= WQ_FLAG_EXCLUSIVE;
  7. __add_wait_queue_tail(&x->wait, &wait);
  8. do {
  9. if (signal_pending_state(state, current)) {
  10. timeout = -ERESTARTSYS;
  11. break;
  12. }
  13. __set_current_state(state);
  14. spin_unlock_irq(&x->wait.lock);
  15. timeout = schedule_timeout(timeout);
  16. spin_lock_irq(&x->wait.lock);
  17. } while (!x->done && timeout);
  18. __remove_wait_queue(&x->wait, &wait);
  19. if (!x->done)
  20. return timeout;
  21. }
  22. x->done--;
  23. return timeout ?: 1;
  24. }

而complete实现如下：

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

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

运用

运用LDD3中的例子：

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

Linux内核同步机制之completion相关推荐

  1. Linux内核同步机制之（四）：spin lock【转】

    转自:http://www.wowotech.net/kernel_synchronization/spinlock.html 一.前言 在linux kernel的实现中,经常会遇到这样的场景:共享 ...

  2. Linux内核同步机制之信号量与锁

    Linux内核同步控制方法有很多,信号量.锁.原子量.RCU等等,不同的实现方法应用于不同的环境来提高操作系统效率.首先,看看我们最熟悉的两种机制--信号量.锁. 一.信号量 首先还是看看内核中是怎么 ...

  3. linux 内核 同步机制

    原子操作   原子操作是由编译器来保证的,保证一个线程对数据的操作不会被其他线程打断.    自旋锁 原子操作只能用于临界区只有一个变量的情况,实际应用中,临界区的情况要复杂的多.对于复杂的临界区,L ...

  4. Linux内核同步机制--自旋锁【转】

    本文转载自:http://www.cppblog.com/aaxron/archive/2013/04/12/199386.html 自旋锁与互斥锁有点类似,只是自旋锁不会引起调用者睡眠,如果自旋锁已 ...

  5. Linux内核同步机制之（一）：原子操作

    作者: 郭健 来源: wowotech 一.源由 我们的程序逻辑经常遇到这样的操作序列: 1.读一个位于memory中的变量的值到寄存器中 2.修改该变量的值(也就是修改寄存器中的值) 3.将寄存器中 ...

  6. linux内核同步机制-RCU（3）

    在正式开始之前,我们来回顾两个比较重要的概念,grace period和quiescent state. grace period的确定在rcu里很重要,它代表了读操作是否完成,也就是是否退出了临界区 ...

  7. linux内核同步机制相关收集

    memory barrier http://www.wowotech.net/kernel_synchronization/memory-barrier.html 转载于:https://www.cn ...

  8. Linux内核同步 - Read/Write spin lock

    一.为何会有rw spin lock? 在有了强大的spin lock之后,为何还会有rw spin lock呢?无他,仅仅是为了增加内核的并发,从而增加性能而已.spin lock严格的限制只有一个 ...

  9. Linux内核同步：RCU

    linux内核 RCU机制详解 简介 RCU(Read-Copy Update)是数据同步的一种方式,在当前的Linux内核中发挥着重要的作用.RCU主要针对的数据对象是链表,目的是提高遍历读取数据的 ...

最新文章

  1. webpack 处理CSS
  2. textarea怎样隐藏滚动条
  3. [Java基础]IO流小结
  4. OpenCV显示中文汉字，未使用CvxText和FreeType库
  5. 解决SecureCRT无法用非root账号登录ssh
  6. 网页与 alert() 一样用于弹框却比之多了一个取消选项的方法 confirm()
  7. 简述计算机控制系统调试和运行的过程,简述计算机控制系统的一般控制过程
  8. 超经典两万字，MySQL数据库快速入门。
  9. Linux文件类型和权限
  10. Centos6.5 邮件服务
  11. ActiveMQ系列（四）ActiveMQ核心功能持久化、事务、签收
  12. 国风就是帅，会三板吗，看看新天吧
  13. 多版本谷歌chrome浏览器并存（谷歌浏览器从C盘移植）
  14. python将两个csv文件按列合并
  15. 模型量化论文阅读#4----EWGS:Network Quantization with Element-wise Gradient Scaling
  16. mac下如何将adobe acrobat reader dc设为.pdf的默认打开方式？
  17. 微信小程序使用iconfont字体图标
  18. 目标检测-ROI Pooling介绍
  19. 如何将多个图片转成文字版的Word
  20. .bat输出目录下所有文件的绝对路径

热门文章

  1. 大龄程序员怎样渡过中年危机？（转）
  2. 在一个字符串中找到第一个只出现一次的字符
  3. 圆形坠落模拟算法设计
  4. java二嗨租车项目_Java入门第二季6-1租车项目代码
  5. openssl不是内部或外部命令_OpenSSL新架构蓝图
  6. 泉州经贸职业技术学院计算机系,部门简介-泉州经贸职业技术学院网络电教中心...
  7. android手机最低内存,原神手机端需要哪些配置 手机端最低配置要求介绍
  8. linux usleep 线程控制权_linux多线程同步—信号量
  9. python使用多线程写生成器_Python学习——多线程，异步IO，生成器，协程
  10. NewCode----彩色宝石项链