原文网址:http://www.cnblogs.com/geneil/archive/2011/12/04/2275272.html

阻塞与非阻塞是设备访问的两种方式。在写阻塞与非阻塞的驱动程序时,经常用到等待队列。

一、阻塞与非阻塞
  阻塞调用是指调用结果返回之前,当前线程会被挂起,函数只有在得到结果之后才会返回。
  非阻塞指不能立刻得到结果之前,该函数不会阻塞当前进程,而会立刻返回。
  对象是否处于阻塞模式和函数是不是阻塞调用有很强的相关性,但并不是一一对应的。阻塞对象上可以有非阻塞的调用方式,我们可以通过一定的API去轮询状态,在适当的时候调用阻塞函数,就可以避免阻塞。而对于非阻塞对象,调用的函数也可以进入阻塞调用。函数select()就是这样一个例子。

二、等待队列
  在linux设备驱动程序中,阻塞进程可以使用等待队列来实现。
  在内核中,等待队列是有很多用处的,尤其是在中断处理进程同步定时等场合,可以使用等待队列实现阻塞进程的唤醒。它以队列为基础数据结构,与进程调度机制紧密结合,能够用于实现内核中的异步事件通知机制,同步对系统资源的访问。

1、等待队列的实现:

  在linux中,等待队列的结构如下:

  1. struct __wait_queue_head {
    spinlock_t lock; //自旋锁,用来对task_list链表起保护作用,实现了对等待队列的互斥访问
    struct list_head task_list; //用来存放等待的进程
    };
    typedef struct __wait_queue_head wait_queue_head_t;

2、等待队列的使用
(1)定义和初始化等待队列:

  1. wait_queue_head_t wait//定义等待队列
    init_waitqueue_head(&wait);//初始化等待队列
    定义并初始化等待队列:
    #define DECLARE_WAIT_QUEUE_HEAD(name) wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)

(2)添加或移除等待队列:

  1. void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);//将等待队列元素wait添加到等待队列头q所指向的等待队列链表中。
    void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);

(3)等待事件:

  1. wait_event(wq, condition);//在等待队列中睡眠直到condition为真。
    wait_event_timeout(wq, condition, timeout);
    wait_event_interruptible(wq, condition)
    wait_event_interruptible_timeout(wq, condition, timeout)
    /*
    *  queue:作为等待队列头的等待队列被唤醒
    * conditon:必须满足,否则阻塞
    * timeout和conditon相比,有更高优先级
    */

(4)睡眠:

  1. sleep_on(wait_queue_head_t *q);
    interruptible_sleep_on(wait_queue_head_t *q);
    /*
    sleep_on作用是把目前进程的状态置成TASK_UNINTERRUPTIBLE,直到资源可用,q引导的等待队列被唤醒。
    interruptible_sleep_on作用是一样的, 只不过它把进程状态置为TASK_INTERRUPTIBLE
    */

(5)唤醒等待队列:

  1. //可唤醒处于TASK_INTERRUPTIBLE和TASK_UNINTERRUPTIBLE状态的进程;
    #define wake_up(x) __wake_up(x, TASK_NORMAL, 1, NULL)
  2.  
  3. //只能唤醒处于TASK_INTERRUPTIBLE状态的进程
    #define wake_up_interruptible(x) __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)

三、操作系统中睡眠、阻塞、挂起的区别形象解释

  首先这些术语都是对于线程来说的。对线程的控制就好比你控制了一个雇工为你干活。你对雇工的控制是通过编程来实现的。
  挂起线程的意思就是你对主动对雇工说:“你睡觉去吧,用着你的时候我主动去叫你,然后接着干活”。
  使线程睡眠的意思就是你主动对雇工说:“你睡觉去吧,某时某刻过来报到,然后接着干活”。
  线程阻塞的意思就是,你突然发现,你的雇工不知道在什么时候没经过你允许,自己睡觉呢,但是你不能怪雇工,肯定你这个雇主没注意,本来你让雇工扫地,结果扫帚被偷了或被邻居家借去了,你又没让雇工继续干别的活,他就只好睡觉了。至于扫帚回来后,雇工会不会知道,会不会继续干活,你不用担心,雇工一旦发现扫帚回来了,他就会自己去干活的。因为雇工受过良好的培训。这个培训机构就是操作系统。

四、阻塞与非阻塞操作

  阻塞操作是指在执行设备操作时若不能获得资源则挂起进程,直到满足可操作的条件后在进行操作。
  非阻塞操作的进程在不能进行设备操作时并不挂起,它或者被放弃,或者不停的查询,直到可以进行操作为止。

  回顾简单字符设备驱动, 我们看到如何实现 read 和 write 方法. 在此, 但是, 我们跳过了一个重要的问题:一个驱动当它无法立刻满足请求应当如何响应? 一个对 read 的调用可能当没有数据时到来, 而以后会期待更多的数据. 或者一个进程可能试图写, 但是你的设备没有准备好接受数据, 因为你的输出缓冲满了. 调用进程往往不关心这种问题; 程序员只希望调用 read 或 write 并且使调用返回, 在必要的工作已完成后. 这样, 在这样的情形中, 你的驱动应当(缺省地)阻塞进程, 使它进入睡眠直到请求可继续。
  

  在我们看全功能的 read 和 write 方法的实现之前, 我们触及的最后一点是决定何时使进程睡眠. 
  (1)阻塞型驱动中,read实现方式:如果一个进程调用 read 但是没有数据可用, 这个进程必须阻塞. 这个进程在有数据达到时被立刻唤醒, 并且那个数据被返回给调用者, 即便小于在给方法的 count 参数中请求的数量.
  (2)阻塞型驱动中,write实现方式:如果一个进程调用 write 并且在缓冲中没有空间, 这个进程必须阻塞, 并且它必须在一个与用作 read 的不同的等待队列中. 当一些数据被写入硬件设备, 并且在输出缓冲中的空间变空闲, 这个进程被唤醒并且写调用成功, 尽管数据可能只被部分写入如果在缓冲只没有空间给被请求的 count 字节.
  (3)有时要求一个操作不阻塞, 即便它不能完全地进行下去.应用程序元可以调用 filp->f_flags 中的 O_NONBLOCK 标志来人为的设置读写操作为非阻塞方式. 这个标志定义于 <linux/fcntl.h>, 被 <linux/fs.h>自动包含.

五、阻塞型驱动测试程序:

1.memdev.h

  1. /*mem设备描述结构体*/
    struct mem_dev
    {
    char *data;
    unsigned long size;
    wait_queue_head_t inq;
    };
  2.  
  3. #endif /* _MEMDEV_H_ */

 

2.memdev.c

  1. static mem_major = MEMDEV_MAJOR;
    bool have_data = false; /*表明设备有足够数据可供读*/
  2.  
  3. module_param(mem_major, int, S_IRUGO);
  4.  
  5. struct mem_dev *mem_devp; /*设备结构体指针*/
  6.  
  7. struct cdev cdev;
  8.  
  9. /*文件打开函数*/
    int mem_open(struct inode *inode, struct file *filp)
    {
    struct mem_dev *dev;
  10.  
  11. /*获取次设备号*/
    int num = MINOR(inode->i_rdev);
  12.  
  13. if (num >= MEMDEV_NR_DEVS)
    return -ENODEV;
    dev = &mem_devp[num];
  14.  
  15. /*将设备描述结构指针赋值给文件私有数据指针*/
    filp->private_data = dev;
  16.  
  17. return 0;
    }
  18.  
  19. /*文件释放函数*/
    int mem_release(struct inode *inode, struct file *filp)
    {
    return 0;
    }
  20.  
  21. /*读函数*/
    static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
    {
    unsigned long p = *ppos;
    unsigned int count = size;
    int ret = 0;
    struct mem_dev *dev = filp->private_data; /*获得设备结构体指针*/
  22.  
  23. /*判断读位置是否有效*/
    if (p >= MEMDEV_SIZE)
    return 0;
    if (count > MEMDEV_SIZE - p)
    count = MEMDEV_SIZE - p;
  24.  
  25. while (!have_data) /* 没有数据可读,考虑为什么不用if,而用while,中断信号唤醒 */
    {
    if (filp->f_flags & O_NONBLOCK)
    return -EAGAIN;
  26.  
  27. wait_event_interruptible(dev->inq,have_data);
    }
  28.  
  29. /*读数据到用户空间*/
    if (copy_to_user(buf, (void*)(dev->data + p), count))
    {
    ret = - EFAULT;
    }
    else
    {
    *ppos += count;
    ret = count;
  30.  
  31. printk(KERN_INFO "read %d bytes(s) from %d\n", count, p);
    }
  32.  
  33. have_data = false; /* 表明不再有数据可读 */
    return ret;
    }
  34.  
  35. /*写函数*/
    static ssize_t mem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
    {
    unsigned long p = *ppos;
    unsigned int count = size;
    int ret = 0;
    struct mem_dev *dev = filp->private_data; /*获得设备结构体指针*/
  36.  
  37. /*分析和获取有效的写长度*/
    if (p >= MEMDEV_SIZE)
    return 0;
    if (count > MEMDEV_SIZE - p)
    count = MEMDEV_SIZE - p;
  38.  
  39. /*从用户空间写入数据*/
    if (copy_from_user(dev->data + p, buf, count))
    ret = - EFAULT;
    else
    {
    *ppos += count;
    ret = count;
  40.  
  41. printk(KERN_INFO "written %d bytes(s) from %d\n", count, p);
    }
  42.  
  43. have_data = true; /* 有新的数据可读 */
  44.  
  45. /* 唤醒读进程 */
    wake_up(&(dev->inq));
  46.  
  47. return ret;
    }
  48.  
  49. /* seek文件定位函数 */
    static loff_t mem_llseek(struct file *filp, loff_t offset, int whence)
    {
    loff_t newpos;
  50.  
  51. switch(whence) {
    case 0: /* SEEK_SET */
    newpos = offset;
    break;
  52.  
  53. case 1: /* SEEK_CUR */
    newpos = filp->f_pos + offset;
    break;
  54.  
  55. case 2: /* SEEK_END */
    newpos = MEMDEV_SIZE -1 + offset;
    break;
  56.  
  57. default: /* can't happen */
    return -EINVAL;
    }
    if ((newpos<0) || (newpos>MEMDEV_SIZE))
    return -EINVAL;
  58.  
  59. filp->f_pos = newpos;
    return newpos;
  60.  
  61. }
  62.  
  63. /*文件操作结构体*/
    static const struct file_operations mem_fops =
    {
    .owner = THIS_MODULE,
    .llseek = mem_llseek,
    .read = mem_read,
    .write = mem_write,
    .open = mem_open,
    .release = mem_release,
    };
  64.  
  65. /*设备驱动模块加载函数*/
    static int memdev_init(void)
    {
    int result;
    int i;
  66.  
  67. dev_t devno = MKDEV(mem_major, 0);
  68.  
  69. /* 静态申请设备号*/
    if (mem_major)
    result = register_chrdev_region(devno, 2, "memdev");
    else /* 动态分配设备号 */
    {
    result = alloc_chrdev_region(&devno, 0, 2, "memdev");
    mem_major = MAJOR(devno);
    }
  70.  
  71. if (result < 0)
    return result;
  72.  
  73. /*初始化cdev结构*/
    cdev_init(&cdev, &mem_fops);
    cdev.owner = THIS_MODULE;
    cdev.ops = &mem_fops;
  74.  
  75. /* 注册字符设备 */
    cdev_add(&cdev, MKDEV(mem_major, 0), MEMDEV_NR_DEVS);
  76.  
  77. /* 为设备描述结构分配内存*/
    mem_devp = kmalloc(MEMDEV_NR_DEVS * sizeof(struct mem_dev), GFP_KERNEL);
    if (!mem_devp) /*申请失败*/
    {
    result = - ENOMEM;
    goto fail_malloc;
    }
    memset(mem_devp, 0, sizeof(struct mem_dev));
  78.  
  79. /*为设备分配内存*/
    for (i=0; i < MEMDEV_NR_DEVS; i++)
    {
    mem_devp[i].size = MEMDEV_SIZE;
    mem_devp[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL);
    memset(mem_devp[i].data, 0, MEMDEV_SIZE);
  80.  
  81. /*初始化等待队列*/
    init_waitqueue_head(&(mem_devp[i].inq));
    }
  82.  
  83. return 0;
  84.  
  85. fail_malloc:
    unregister_chrdev_region(devno, 1);
  86.  
  87. return result;
    }
  88.  
  89. /*模块卸载函数*/
    static void memdev_exit(void)
    {
    cdev_del(&cdev); /*注销设备*/
    kfree(mem_devp); /*释放设备结构体内存*/
    unregister_chrdev_region(MKDEV(mem_major, 0), 2); /*释放设备号*/
    }
  90.  
  91. MODULE_AUTHOR("David Xie");
    MODULE_LICENSE("GPL");
  92.  
  93. module_init(memdev_init);
    module_exit(memdev_exit);


3.app-write.c

  1. #include <stdio.h>
  2.  
  3. int main()
    {
    FILE *fp = NULL;
    char Buf[128];
  4.  
  5. /*打开设备文件*/
    fp = fopen("/dev/memdev0","r+");
    if (fp == NULL)
    {
    printf("Open Dev memdev0 Error!\n");
    return -1;
    }
  6.  
  7. /*写入设备*/
    strcpy(Buf,"memdev is char dev!");
    printf("Write BUF: %s\n",Buf);
    fwrite(Buf, sizeof(Buf), 1, fp);
  8.  
  9. sleep(5);
    fclose(fp);
  10.  
  11. return 0;
  12.  
  13. }

 

4.app-read.c

  1. #include <stdio.h>
  2.  
  3. int main()
    {
    FILE *fp = NULL;
    char Buf[128];
  4.  
  5. /*初始化Buf*/
    strcpy(Buf,"memdev is char dev!");
    printf("BUF: %s\n",Buf);
  6.  
  7. /*打开设备文件*/
    fp = fopen("/dev/memdev0","r+");
    if (fp == NULL)
    {
    printf("Open memdev0 Error!\n");
    return -1;
    }
  8.  
  9. /*清除Buf*/
    strcpy(Buf,"Buf is NULL!");
    printf("Read BUF1: %s\n",Buf);
  10.  
  11. /*读出数据*/
    fread(Buf, sizeof(Buf), 1, fp);
  12.  
  13. /*检测结果*/
    printf("Read BUF2: %s\n",Buf);
  14.  
  15. fclose(fp);
  16.  
  17. return 0;
  18.  
  19. }

【转】linux设备驱动程序中的阻塞机制的更多相关文章

  1. 蜕变成蝶~Linux设备驱动中的阻塞和非阻塞I/O

    今天意外收到一个消息,真是惊呆我了,博客轩给我发了信息,说是俺的博客文章有特色可以出本书,,这简直让我受宠若惊,俺只是个大三的技术宅,写的博客也是自己所学的一些见解和在网上看到我一些博文以及帖子里综合 ...

  2. Linux设备驱动中的阻塞和非阻塞I/O <转载>

    Green 博客园 首页 新随笔 联系 订阅 管理 Linux设备驱动中的阻塞和非阻塞I/O   [基本概念] 1.阻塞 阻塞操作是指在执行设备操作时,托不能获得资源,则挂起进程直到满足操作所需的条件 ...

  3. Linux设备驱动中的阻塞和非阻塞I/O

    [基本概念] 1.阻塞 阻塞操作是指在执行设备操作时,托不能获得资源,则挂起进程直到满足操作所需的条件后再进行操作.被挂起的进程进入休眠状态(不占用cpu资源),从调度器的运行队列转移到等待队列,直到 ...

  4. linux 设备驱动程序中的一些关联性思考

    首先,个人感觉设备驱动程序与应用程序中的文件操作隔得有点远,用户空间不论是直接使用系统调用还是库函数都是通过系统调用的接口进入内核空间代码的.但是看过一个博客的分析整个过程,感觉中间层太过麻烦,必须经 ...

  5. Linux设备驱动程序学习 高级字符驱动程序操作[阻塞型I/O和非阻塞I/O]【转】

    转自:http://blog.csdn.net/jacobywu/article/details/7475432 阻塞型I/O和非阻塞I/O 阻塞:休眠 非阻塞:异步通知 一 休眠 安全地进入休眠的两 ...

  6. 嵌入式Linux设备驱动程序:用户空间中的设备驱动程序

    嵌入式Linux设备驱动程序:用户空间中的设备驱动程序 Embedded Linux device drivers: Device drivers in user space Interfacing ...

  7. Linux设备驱动程序学习之分配内存

    内核为设备驱动提供了一个统一的内存管理接口,所以模块无需涉及分段和分页等问题. 我已经在第一个scull模块中使用了 kmalloc 和 kfree 来分配和释放内存空间. kmalloc 函数内幕 ...

  8. Linux设备驱动程序学习----1.设备驱动程序简介

    设备驱动程序简介 更多内容请参考Linux设备驱动程序学习----目录 1. 简介   Linux系统的优点是,系统内部实现细节对所有人都是公开的.Linux内核由大量复杂的代码组成,设备驱动程序可以 ...

  9. linux设备驱动程序-设备树(3)-设备树多级子节点的转换

    linux设备驱动程序--设备树多级子节点的转换 在上一章:设备树处理之--device_node转换成platform_device中,有提到在设备树的device_node到platform_de ...

随机推荐

  1. 消除ComponentOne(C1StudioNet_2013v2) 的注册提示

     以后大家如果遇到还有提示,在License文件里添加:C1.Win.C1Command.C1OutBar, C1.Win.C1Command.4, Version=4.0.20132.19568,  ...

  2. JS面向(基于)对象编程--构造方法(函数)

    构造函数(方法)介绍 什么是构造函数呢?在回答这个问题之前,我们来看一个需求:前面我们在创建人类的对象时,是先把一个对象创建好后,再给他的年龄和姓名属性赋值,如果现在我要求,在创建人类的对象时,就直接 ...

  3. 李洪强iOS开发之OC语言基础知识

    OC语言基础知识 一.面向对象 OC语言是面向对象的,c语言是面向过程的,面向对象和面向过程只是解决问题的两种思考方式,面向过程关注的是解决问题涉及的步骤,面向对象关注的是设计能够实现解决问题所需功能 ...

  4. Project Euler 102:Triangle containment 包含原点的三角形

    Triangle containment Three distinct points are plotted at random on a Cartesian plane, for which -10 ...

  5. JavaWeb项目开发案例精粹-第6章报价管理系统-06po层

    1. <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www ...

  6. 打印TMemo的内容到打印机

    Canvas.TextOut真是好用,Printer也实在好用: procedure PrintTStrings(Lst : TStrings) ; var I, Line : Integer; be ...

  7. IDL_GUI

    菜单栏设计 PRO IDLGui ;构建界面 ;显示 ;添加事件 tlb=WIDGET_BASE(xsize=400,ysize=400,/column,mbar=mbar);实现基类 file=WI ...

  8. SQL语句 递归

    --正向递归查询(根据ID查到自己和自己以下的所有数据)   connect by prior a.id = a. parentid   --反向递归查询(根据叶子ID查出自己和自己以上的根数据)   ...

  9. fastdfs-client-java工具类封装

    FastDFS是通过StorageClient来执行上传操作的 通过看源码我们知道,FastDFS有两个StorageClient工具类.

  10. CentOS启动和停止服务详解

    服务简介Linux 系统服务是在Linux启 动时自动加载,并在Linux退出时自动停止的系统任务.在Linux 启动过程中,我们可以看得很多“starting … ”提示信息,该信息表示正在启动系统 ...