简介

首先需要明白什么是阻塞，然后明白open函数的的打开标志，进一步明白这些标志是在哪里判断的，是由谁来管理的。
除了读写权限以外，还存在一个O_NONBLOCK 标志，这个标志表征阻塞和非阻塞。

代码

非阻塞

  1. /*-------------------应用层--------------------------*/
  2. # 应用层以O_NONBLOCK 标志打开，
  3. fd = open(filename, O_RDWR | O_NONBLOCK);
  4. /*-------------------驱动层--------------------------*/
  5. # 判断是否含有 O_NONBLOCK 标志
  6. demodrv_read(struct file *file, char __user *buf, size_t count, loff_t *ppos)
  7. # 非阻塞模式
  8.     if (file->f_flags & O_NONBLOCK)    
  9.         # 比如说需要读取的数据还没有准备好，是直接返回，还是睡眠等会再读
  10.         do something
  11.         return -EAGAIN; /*非阻塞模式*/

阻塞模式

非阻塞模式用的比较少，很多时候使用的是组赛模式，如果读取不到数据，那么就睡眠，等待条件满足。
进程睡眠一般含有以下五种，

  1. # include/linux/sched.h
  2. #define TASK_RUNNING        0 (就绪态)
  3. #define TASK_INTERRUPTIBLE    1 (可中断睡眠态)
  4. #define TASK_UNINTERRUPTIBLE    2 (不可中断睡眠态)
  5. #define __TASK_STOPPED        4    (中止态)
  6. #define __TASK_TRACED        8    (僵尸态)

等待队列

当把一个进程转入睡眠态，就是由TASK_RUNNING转换为TASK_INTERRUPTIBLE态或者TASK_UNINTERRUPTIBLE态。然后这个进程会被调理运行队列(进程调度器操作)。当请求的资源或者事件到来，进程将会被重新唤醒。

  1. include/linux/wait.h:
  2. /*---------------------------数据结构体-----------------------------*/
  3. struct __wait_queue_head {
  4.     spinlock_t        lock;
  5.     struct list_head    task_list;
  6. };
  7. typedef struct __wait_queue_head wait_queue_head_t;
  9. # 使用 wait_queue_t 来表示等待的队列元素
  10. struct __wait_queue {
  11.     unsigned int        flags;
  12.     void            *private;
  13.     wait_queue_func_t    func;
  14.     struct list_head    task_list;
  15. };
  16. typedef struct __wait_queue wait_queue_t;
  17. /*----------------------------API-----------------------------*/
  18. DECLARE_WAIT_QUEUE_HEAD(name)
  19.     /*声明一个等待队列 - 静态*/
  21. wait_queue_head_t read_wait;
  22. init_waitqueue_head(name)
  23.     /*声明一个等待队列 - 动态*/

内核睡眠有关函数

  1. include/linux/wait.h
  2. #define wait_event(wq, condition)   
  3. #define wait_event_interruptible(wq, condition)
  4. #define wait_event_interruptible_timeout(wq, condition, timeout)
  5. #define wait_event_timeout(wq, condition, timeout)
  7. # wq 等待队列
  8. # condition 布尔表达式
  9. # timeout     
  10.     # 1*HZ n*HZ
  12. /*------------唤醒---------------*/
  13. #define wake_up(x)            
  14.     # 唤醒所有等待队列之中的进程
  15.     # 配合 wait_event 以及 wait_event_timeout 使用
  16. #define wake_up_interruptible(x)
  17.     # 配合wait_event_interruptible 以及 wait_event_interruptible_timeout 使用

阻塞模式的代码实现

  1. /*首先定义好设备的结构体*/
  2. struct mydemo_device {
  3.     const char *name;
  4.     struct device *dev;
  5.     struct miscdevice *miscdev; 
  6.         wait_queue_head_t read_queue; /*读队列*/
  7.     wait_queue_head_t write_queue;    /*写队列*/
  8. };
  10. /*加一层嵌套*/
  11. struct mydemo_private_data {
  12.     struct mydemo_device *device;
  13. };
  14. /*-----------静态全局数据-----------------*/
  16. static struct mydemo_device *mydemo_device; 
  18. /*------------init函数--------------------*/
  19. simple_char_init
  20.     struct mydemo_device *device = kmalloc(sizeof(struct mydemo_device), GFP_KERNEL);
  21.     /*注册杂项设备*/
  22.     misc_register(&mydemodrv_misc_device);
  23.     device->dev = mydemodrv_misc_device.this_device;
  24.     device->miscdev = &mydemodrv_misc_device;
  25.     /*比较重要的是这两步，初始化这两个队列*/
  26.     init_waitqueue_head(&device->read_queue);
  27.     init_waitqueue_head(&device->write_queue);
  28.     /*赋值给全局静态函数*/
  29.     mydemo_device = device; 
  31. /*------------open函数--------------------*/
  32. demodrv_open
  33.     struct mydemo_private_data *data;
  34.     struct mydemo_device *device = mydemo_device;
  35.     /*私有数据的指针*/
  36.     data = kmalloc(sizeof(struct mydemo_private_data), GFP_KERNEL);
  37.     data->device = device; 
  38.     /*将私有数据放入文件结构的私有指针里面*/
  39.     file->private_data = data;
  41. /*------------read函数--------------------*/
  42. demodrv_read
  43.     /*获取文件的私有数据*/
  44.     struct mydemo_private_data *data = file->private_data;
  45.     /*得到设备指针*/
  46.     struct mydemo_device *device = data->device;
  47.     /*假如现在没有数据，等待有数据，在此阻塞*/
  48.     wait_event_interruptible(device->read_queue,
  49.                     !kfifo_is_empty(&mydemo_fifo)
  50.     /*现在可以读取数据了*/
  51.     kfifo_to_user(&mydemo_fifo, buf, count, &actual_readed);

参考资料

进程资源和进程状态 TASK_RUNNING TASK_INTERRUPTIBLE TASK_UNINTERRUPTIBLE