你好，我是拉依达。

这是我的Linux驱动开发八股文详细解析系列。

本系列最开始是我在csdn上更新的文章，目前已经是csdn搜索“linux驱动”综合推荐第一名，累计阅读次数4w次。

全文总字数近8w字，是目前全网最全面，最清晰的入门linux驱动学习资料。

现重新对内容进行整理，希望可以帮助到更多学习嵌入式的同学。

【下面是拉依达推荐学习相关专栏：】
一、Linux驱动学习专栏：拉依达的Linux驱动八股文 - 牛客网
二、Linux应用学习专栏：拉依达的Linux应用八股文 - 牛客网
【我的嵌入式学习和校招经验】 拉依达的嵌入式学习和秋招经验-CSDN博客
嵌入式学习规划/就业经验指导，可私信咨询

———————————————————————————————————————————————————

十三、阻塞与非阻塞IO

13.1 阻塞与非阻塞IO原理

这里的 IO 指的是 Input/Output（输入/输出）：是应用程序对驱动设备的输入/输出操作。

阻塞IO

阻塞IO操作是指在执行设备操作时， 若不能获得资源， 则挂起进程直到满足可操作的条件后再进行操作。

被挂起的进程进入睡眠状态， 被从调度器的运行队列移走， 直到等待的条件被满足该进程会唤醒。

在阻塞访问时， 不能获取资源的进程将进入休眠， 它将 CPU 资源让给其他进程。 因为阻塞的进程会进入休眠状态， 所以必须确保有一个地方能够唤醒休眠的进程。唤醒进程最大可能发生在中断函数里面， 因为在硬件资源获得的同时往往伴随着一个中断。Linux 内核提供了等待队列(wait queue)来实现阻塞进程的唤醒工作。

如图，应用程序调用 read 函数从设备中读取数据，当设备不可用或数据未准备好的时候就会进入到休眠态。等设备可用的时候就会从休眠态唤醒，然后从设备中读取数据返回给应用程序。

int fd;
int data = 0;
fd = open("/dev/xxx_dev", O_RDWR); /* 阻塞方式打开，默认是阻塞 */
ret = read(fd, &data, sizeof(data)); /* 读取数据 */

非阻塞IO

非阻塞IO操作是在不能进行设备操作时， 并不挂起， 要么放弃， 要么不停地查询， 直至可以进行操作为止。非阻塞的进程则不断尝试， 直到可以进行 I/O。

应用程序使用非阻塞访问方式从设备读取数据，当设备不可用或数据未准备好的时候会立即向内核返回一个错误码，表示数据读取失败。应用程序会再次重新读取数据，一直往复循环，直到数据读取成功。

若用户以非阻塞的方式访问设备文件， 则当设备资源不可获取时， 设备驱动的 xxx_read（） 、 xxx_write（ ） 等操作应立即返回， read（ ） 、 write（ ） 等系统调用也随即被返回， 应用程序收到-EAGAIN 返回值。

int fd;
int data = 0;
fd = open("/dev/xxx_dev", O_RDWR | O_NONBLOCK); /* 非阻塞方式打开 */
ret = read(fd, &data, sizeof(data)); /* 读取数据 */

13.2 阻塞IO使用

应用层（默认打开）

fd = open(filename, O_RDWR);
if (fd < 0) 
{
	printf("Can't open file %s\r\n", filename);
    return -1;
}

ret = read(fd, &data, sizeof(data));
if (ret < 0) 
{ 
	  printf("don't know how to read\n");
	  /* 数据读取错误或者无效 */
} else 
{ 
	  /* 数据读取正确 */
	  if (data) /* 读取到数据 */
	  printf("key value = %#X\r\n", data);
}

驱动层（等待队列）

在 Linux 驱动程序中，使用等待队列（ Wait Queue） 来实现阻塞进程的唤醒。

Linux 内核的等待队列是以双循环链表为基础数据结构， 与进程调度机制紧密结合， 能够用于实现核心的异步事件通知机制。

它有两种数据结构： 等待队列头（wait_queue_head_t） 和等待队列项（wait_queue_t）。等待队列头和等待队列项中都包含一个 list_head 类型的域作为连接件。 它通过一个双链表 把等待 task的头和等待的进程列表链接起来。

1. 等待队列头 如果要在驱动中使用等待队列，必须创建并初始化一个等待队列头。等待队列头使用结构体 wait_queue_head_t 来表示

   struct __wait_queue_head {
       spinlock_t lock; //自旋锁
       struct list_head task_list; //链表头
   };
   typedef struct __wait_queue_head wait_queue_head_t;
   

   定义好等待队列头以后需要初始化， 使用 init_waitqueue_head 函数初始化等待队列头。

   void init_waitqueue_head(wait_queue_head_t *q)
   //q：要初始化的等待队列头
   

2. 等待队列项 每个访问设备的进程都是一个队列项， 当设备不可用时就要将这些进程对应的等待队列项添加到等待队列里面。结构体 wait_queue_t 表示等待队列项

   struct __wait_queue {
       unsigned int flags;
       void *private;
       wait_queue_func_t func;
       struct list_head task_list;
   };
   typedef struct __wait_queue wait_queue_t;
   

   使用宏 DECLARE_WAITQUEUE 定义并初始化一个等待队列项

   DECLARE_WAITQUEUE(name, tsk)
   //name：等待队列项的名字
   //tsk：等待队列项属于哪个任务(进程)， 一般设置为 current
   

   在内核中 current 相当于全局变量 ， 表 示 当 前 进 程 。所以DECLARE_WAITQUEUE是给当前正在运行的进程创建并初始化了一个等待队列项。

3. 添加/删除队列 当设备不可访问的时就需要将进程对应的等待队列项 添加到前面创建的等待队列头中， 只有添加到等待队列头中以后进程才能进入休眠态。

   void add_wait_queue(wait_queue_head_t *q,wait_queue_t *wait)
   //q： 等待队列项要加入的等待队列头
   //wait：要加入的等待队列项 
   

   当设备可以访问后再将进程对应的等待队列项从等待队列头中移除即可。

   void remove_wait_queue(wait_queue_head_t *q,wait_queue_t *wait)
   //q： 要删除的等待队列项所处的等待队列头
   //wait：要删除的等待队列项
   

4. 唤醒等待睡眠进程 当设备可以使用的时就要唤醒进入休眠态的进程， 唤醒可以使用如下两个函数

   void wake_up(wait_queue_head_t *q) //功能： 唤醒所有休眠进程
   void wake_up_interruptible(wait_queue_head_t *q)//功能： 唤醒可中断的休眠进程
   //q ：要唤醒的等待队列头
   

   这两个函数会将这个等待队列头中的所有进程都唤醒。 wake_up 函 数 可 以 唤 醒 处 于TASK_INTERRUPTIBLE 和 TASK_UNINTERRUPTIBLE 状 态 的 进 程 ， wake_up_interruptible 函数只能唤醒处于 TASK_INTERRUPTIBLE 状态的进程

5. 等待事件 除了主动唤醒以外， 也可以设置等待队列等待某个事件， 当这个事件满足以后就自动唤醒等待队列中的进程。 调用的时要确认 condition 值是真还是假， 如果调用 condition 为真， 则不会休眠。

   wait_event(wq, condition)
   //不可中断的阻塞等待， 让调用进程进入不可中断的睡眠状态， 
   //在等待队列里面睡眠直到 condition变成真， 被内核唤醒。
   wait_event_interruptible(queue,condition) 
   //可中断的阻塞等待， 让调用进程进入可中断的睡眠状态， 
   //直到 condition 变成真被内核唤醒或被信号打断唤醒。
   wait_event_timeout(queue,condition,timeout)
   //功能和 wait_event 类似，但是此函数可以添加超时时间，以 jiffies 为单位。 
   //如果所给的睡眠时间为负数则立即返回 。
   //如果在睡眠期间被唤醒,且condition 为真则返回剩余的睡眠时间, 
   //否则继续睡眠直到到达或超过给定的睡眠时间,然后返回 0 。
   wait_event_interruptible_timeout(queue,condition,timeout)
   //与 wait_event_timeout 函数类似， 如果在睡眠期间被信号打断则返回 ERESTARTSYS 错误码。
   

   使用等待队列实现阻塞访问重点注意两点：

   • ①、将任务或者进程加入到等待队列头，

   • ②、在合适的点唤醒等待队列，一般都是中断处理函数里面。

6. 使用模板

   /* imx6uirq 设备结构体 */
   struct imx6uirq_dev
   {
   	......
       wait_queue_head_t r_wait; /*  读等待队列头 */
   };
   
   struct imx6uirq_dev imx6uirq; /* irq 设备 */
   
   static irqreturn_t key0_handler(int irq, void *dev_id)
   {   
       struct imx6uirq_dev *dev = (struct imx6uirq_dev *)dev_id;
       tasklet_schedule(&dev->irqkeydesc[0].testtasklet);
       printk("tasklet ok\n");
       return IRQ_RETVAL(IRQ_HANDLED);
   }
   static void testtasklet_func(unsigned long data)
   {
      	......
       if(atomic_read(&dev->releasekey))  /*  完成一次按键过程 */
       {                                      
           /* wake_up(&dev->r_wait); */
           wake_up_interruptible(&dev->r_wait);
       }
   }
   
   static int keyio_init(void)
   {
     	......
       /*  初始化等待队列头 */
       init_waitqueue_head(&imx6uirq.r_wait);
       return 0;
   }
   
   static ssize_t imx6uirq_read(struct file *filp, char __user *buf,size_t cnt, loff_t *offt)
   {
    	......
   #if 0
   	/*  加入等待队列，等待被唤醒, 也就是有按键按下 */
   	ret = wait_event_interruptible(dev->r_wait, atomic_read(&dev->releasekey));			
   	if (ret) {
   		goto wait_error;
   	}
   #else
       DECLARE_WAITQUEUE(wait, current);	/* 定义一个等待队列 */
   	if(atomic_read(&dev->releasekey) == 0) /* 没有按键按下 */
       {	
   		add_wait_queue(&dev->r_wait, &wait);	/* 将等待队列添加到等待队列头 */
   		__set_current_state(TASK_INTERRUPTIBLE);/* 设置任务状态 */
   		schedule();							/* 进行一次任务切换 */
   		if(signal_pending(current))	 /* 判断是否为信号引起的唤醒 */
           {			
   			ret = -ERESTARTSYS;
   			goto wait_error;
   		}
   		__set_current_state(TASK_RUNNING);      /* 将当前任务设置为运行状态 */
   	    remove_wait_queue(&dev->r_wait, &wait);    /* 将对应的队列项从等待队列头删除 */
   	}
   #endif
       ......
       
   wait_error:
   	set_current_state(TASK_RUNNING);		/* 设置任务为运行态 */
   	remove_wait_queue(&dev->r_wait, &wait);	/* 将等待队列移除 */
   	return ret;
   }
   
   static struct file_operations imx6uirq_fops = 
   {
       .owner = THIS_MODULE,
       .open = imx6uirq_open,
       .read = imx6uirq_read,
   };
   

   

• 在设备结构体中添加一个等待队列头 r_wait，因为在 Linux 驱动中处理阻塞 IO需要用到等待队列。
• 调用 init_waitqueue_head 函数初始化等待队列头 r_wait。
• read驱动函数手动休眠等待按键按下
• 法一：
  • 采用等待事件来处理 read 的阻塞访问，wait_event_interruptible 函数等待 releasekey 有效，也就是有按键按下。
  • 如果按键没有按下的话进程就会进入休眠状态，因为采用了 wait_event_interruptible 函数，因此进入休眠态的进程可以被信号打断。
• 法二：
  • 首先使用 DECLARE_WAITQUEUE 宏定义一个等待队列，
  • 如果没有按键按下的话就使用 add_wait_queue 函数将当前任务的等待队列添加到等待队列头 r_wait 中。
  • 随后调用__set_current_state 函数设置当前进程的状态为 TASK_INTERRUPTIBLE，也就是可以被信号打断。
  • 接下来调用 schedule 函数进行一次任务切换，当前进程就会进入到休眠态。
  • 如果有按键按下，那么进入休眠态的进程就会唤醒，然后接着从休眠点开始运行。首先通过 signal_pending 函数判断一下进程是不是由信号唤醒的，如果是由信号唤醒的话就直接返回-ERESTARTSYS 这个错误码。
  • 如果不是由信号唤醒的(也就是被按键唤醒的)那么就在 调用__set_current_state 函数将任务状态设置为TASK_RUNNING，然后在调用 remove_wait_queue 函数将进程从等待队列中删除。
• 定时器中断处理函数执行，表示有按键按下，先在判断一下是否是一次有效的按键，如果是的话就通过 wake_up 或者 wake_up_interruptible 函数来唤醒等待队列r_wait。
• 完成read函数后，设置任务为运行态，将等待队列移除