Linux驱动的同步阻塞和同步非阻塞

在字符设备驱动中，若要求应用与驱动同步，则在驱动程序中可以根据情况实现为阻塞或非阻塞

一、同步阻塞

这种操作会阻塞应用程序直到设备完成read/write操作或者返回一个错误码。在应用程序阻塞这段时间，程序所代表的进程并不消耗CPU的时间，因而从这个角度看，这种操作模式效率是非常高效的。为了支持这种I/O操作模式，设备驱动程序需要实现file_operations的read和wirte函数。

直接使用内核提供的API

驱动程序在实现阻塞型I/O时，可以直接使用内核提供的wait_event系统和wake_up系列函数，这些函数的核心设计建立在等待队列的基础上。

1）wait_event系统函数(等待在某一队列中直到某一条件满足)

wait_event_interrupt()

Linux内核中，该宏用来将当前调用它的进程睡眠等待在一个event上，直到进程被唤醒并且需要的condition条件为真。睡眠的进程状态时TASK_INTERRUPTIBLE的，这就意味着它可以被用户程序所中断而结束。但通常情况是等到的event事件发生了，它被唤醒重新加入到调度器的运行队列中等待下一次调度执行。

void init_wait_entry(struct wait_queue_entry *wq_entry, int flags)
{wq_entry->flags = flags;wq_entry->private = current;wq_entry->func = autoremove_wake_function;INIT_LIST_HEAD(&wq_entry->entry);
}
/*
1)init_wait_entry用来定义了一个名为“__wq_entry”的等待队列节点对象。__wq_entry中的
autoremove_wake_function函数在节点上的进程被唤醒时调用，private指向当前调用
wait_event_interruptible的进程。
2)prepare_to_wait_event用来完成睡眠前的准备工作，并且将__wq_entry节点加入到等待
队列wq中：__add_wait_queue(wq_head, wq_entry)，该函数把__wq_entry节点接入到等到队列
中成为头节点后的第一个等待节点，所以后面进来的进程最先被唤醒；并把前进程状态设置为
TASK_INTERRUPTIBLE
3)prepare_to_wait_event之后进程仍然在调度器的运行队列中,当最后调用schedule()时，在
schedule这里调度器将把当前进程从它的运行队列中移除，schedule函数调用deactivate_task
函数来将当前任务从运行队列中移除，在多处理器系统中每个CPU都拥有自己的运行队列。
4)当condition为真时，通过break进入finish_wait，基本是prepare_to_wait_event的反向动作。
*/
#define ___wait_event(wq_head, condition, state, exclusive, ret, cmd)        \
({                                        \__label__ __out;                            \struct wait_queue_entry __wq_entry;                    \long __ret = ret;    /* explicit shadow */                \\init_wait_entry(&__wq_entry, exclusive ? WQ_FLAG_EXCLUSIVE : 0);    \for (;;) {                                \long __int = prepare_to_wait_event(&wq_head, &__wq_entry, state);\\if (condition)                            \break;                            \\if (___wait_is_interruptible(state) && __int) {            \__ret = __int;                        \goto __out;                        \}                                \\cmd;                                \}                                    \finish_wait(&wq_head, &__wq_entry);                    \
__out:    __ret;                                    \
})/*schedule()作为cmd*/
#define __wait_event_interruptible(wq_head, condition)                \___wait_event(wq_head, condition, TASK_INTERRUPTIBLE, 0, 0,        \schedule())/*在condition不为真时，将睡眠在一个等待队列wq_head上，所以函数首先判断condition是否为真
如果为真，函数将直接返回，否则调用它的进程将通过__wait_event_interruptible最终进入睡眠
状态*/
#define wait_event_interruptible(wq_head, condition)                \
({                                        \int __ret = 0;                                \might_sleep();                                \if (!(condition))                            \__ret = __wait_event_interruptible(wq_head, condition);        \__ret;                                    \
})

由以上源码可以见wait_event_interruptable的表现形式时阻塞在了schedule()函数(kernel/sched/core.c)上直到进程下次被唤醒并被调度执行。当进程被唤醒时，继续从schedule下面执行(此时进程状态为TASK_RUNNING，所在的等待节点__wq_entry已经从wq中删除)，通过contine继续for循环直到contion为真时通过break进入finish_wait。

wait_event()

该函数使调用的进程进入等待队列，赋予睡眠进程的状态是TASK_UNINTERRUPTIBLE。该函数与wait_event_interruptible的区别是，它使睡眠的进程不可被中断，而且当进程被唤醒时也不会检查是否有等待的信号需要处理。

wait_event_timeout()

该函数与wait_event的区别时，会指定一个时间期限，在指定的时间到达时将返回0。

wait_event_interruptible_timeout()

该函数与wait_event_interruptible的区别时，会指定一个时间期限，在指定的时间到达时将返回0。

2）wake_up系列和wake_up_interruptible系列函数

wake_up_interruptible()

用来唤醒一个等待队列上的睡眠进程

int try_to_wake_up(struct task_struct *p, unsigned int state, int wake_flags)
{
/*函数用p->state & state将wake_up系列函数中的进程状态与要唤醒的进程的状态进行检查，如果
p->state & state = 0的话那么唤醒操作返回0，是一次不成功的操作。因此可以看出
wake_up_interruptible只能唤醒通过wait_event_interruptible睡眠的进程。*/
}/*传入TASK_INTERRUPTIBLE的参数会在调用等待节点上的func，也就是autoremove_wake_function
会用到，实际的代码发生在try_to_wake_up函数里*/
#define wake_up_interruptible(x)    __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)

对于一个等待队列x, wake_up_interruptible(x)最后调用了__wake_up_common，后者通过list_for_each_entry_safe_from对等待队列x进行遍历，对于遍历过程的每个等待节点，都会调用该节点上的函数func，也就是前面的autoremove_wake_function函数，其主要功能是唤醒当前节点上的进程(把进程加入调度器的的运行队列，进程状态变为TASK_RUNNING),并将等待节点从等待队列删除，通常情况下函数都会成功返回1。

    list_for_each_entry_safe_from(curr, next, &wq_head->head, entry) {unsigned flags = curr->flags;int ret;if (flags & WQ_FLAG_BOOKMARK)continue;ret = curr->func(curr, mode, wake_flags, key);if (ret < 0)break;if (ret && (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)break;if (bookmark && (++cnt > WAITQUEUE_WALK_BREAK_CNT) &&(&next->entry != &wq_head->head)) {bookmark->flags = WQ_FLAG_BOOKMARK;list_add_tail(&bookmark->entry, &next->entry);break;}}

从上面代码可以看到，如果想让函数遍历结束，必须满足以下三个条件：

1. 负责唤醒进程的函数func成功返回；

2. 等待节点的flags成员设置了WQ_FLAG_EXCLUSIVE标志，这个是排他性的，如果设置有该标志，那么唤醒当前节点上的进程后将不会再继续唤醒操作；

3. nr_exclusive等于1，nr_exclusive表示运行唤醒的排他性进程的数量。

在此可以将函数结束继续唤醒队列中的进程的条件简单归纳为：遇到一个排他性唤醒的节点并且当前允许排他性唤醒的进程数量为1。

其他一些wake_up系列/wake_up_interruptible系列函数

wake_up_interruptible函数在内核中同样有自己的一些变体，它们之间的主要区别除了TASK_INTERRUPTIBLE和TASK_UNINTERRUPTIBLE之外，在于每次调用时视图唤醒的进程数量，因为唤醒一个进程不存在timeout问题，所以没有类似类似wake_up_timeout这样的函数。

#define wake_up(x)            __wake_up(x, TASK_NORMAL, 1, NULL)
#define wake_up_nr(x, nr)        __wake_up(x, TASK_NORMAL, nr, NULL)
#define wake_up_all(x)            __wake_up(x, TASK_NORMAL, 0, NULL)
#define wake_up_locked(x)        __wake_up_locked((x), TASK_NORMAL, 1)
#define wake_up_all_locked(x)        __wake_up_locked((x), TASK_NORMAL, 0)#define wake_up_interruptible(x)    __wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
#define wake_up_interruptible_nr(x, nr)    __wake_up(x, TASK_INTERRUPTIBLE, nr, NULL)
#define wake_up_interruptible_all(x)    __wake_up(x, TASK_INTERRUPTIBLE, 0, NULL)
#define wake_up_interruptible_sync(x)    __wake_up_sync((x), TASK_INTERRUPTIBLE)

4. 因为TASK_NORMAL在内核中的定义如下，所以wake_up可以取代wake_up_interruptible，也可以用来唤醒wait_event而睡眠的进程。

#define TASK_NORMAL            (TASK_INTERRUPTIBLE | TASK_UNINTERRUPTIBLE)

5. wake_up_nr和wake_up_all表示可以唤醒的排他性进程的数量，前者可以唤醒nr个这样的进程，后者可以唤醒队列中的所有排他性进程。wake_up则只能唤醒一个，当然对于非排他性节点上的进程，这些函数都会视图去唤醒它们。

6. 对于wake_up_interruptible系列函数除了只能唤醒TASK_INTERRUPTIBLE状态的进程外，其他的功能和wake_up系列一样.

7. wake_up_locked和wake_up的唯一区别是，后者内部会使用等待队列自旋锁，而前者不会。所以如果使用wake_up_locked时需要自己考虑加锁问题。

8. wake_up_interruptible_sync用来保证调用它的进程不会被唤醒的进程所抢占而调度出处理器。

不直接使用内核提供的API

内核为以上讨论的wait_event/wake_up/wake_up_interrupt等系列函数中为等待队列提供了默认的操作模式。当然若不满足开发需求时驱动开发时可以按照wait_event和wake_up等函数的实现原理来构建自己的睡眠唤醒函数，比如一个典型的睡眠序列：

DECLARE_WAITQUEUE(wait, current);  //定义一个等待节点wait
set_current_state(TASK_UNINTERRUPTIBLE); //设置进程状态
add_wait_queue(&xxx_wq, &wait);  //将节点加入等待队列
schedule(); //让进程进入睡眠状态
remove_wait_queue(&xxx_wq, &wait); //唤醒以后将等待节点从队列移除

DECLARE_WAITQUEUE、 add_wait_queue这两个动作加起来完成的效果如下图所示。 在wait_queue_head_t指向的链表上， 新定义的wait_queue元素被插入， 而这个新插入的元素绑定了一个task_struct（当前做xxx_write的current， 这也是DECLARE_WAITQUEUE使用“current”作为参数的原因） 。

二、同步非阻塞

这种操作模式下，用于要求以O_NONBLOCK标志的形式传达到驱动程序中，如果用户希望这是一个不能阻塞的操作，就需要在open这个文件时指定O_NONBLOCK或者在read/write前在指定的文件描述符上通过fcntl函数设置O_NONBLOCK标志。

比如这种情况下驱动程序可以通过传递到read/write函数的参数struct file *filp来获取这一信息：若用户指定了O_NONBLOCK的情形下，filp->f_flags & O_NONBLOCK的结果为真。在这种情况下如果设备不能立即完成用户程序所需的I/O操作，应该返回一个错误码(EAGAIN或EWOULDBLOCK，二者是同一个值)来宣告结束；否则应默认按照阻塞方式来进行。

#define    EAGAIN        35    /* Try again */
#define    EWOULDBLOCK    EAGAIN    /* Operation would block */