设备驱动中的阻塞和同步机制

1. 阻塞和非阻塞

1.1 阻塞调用

        是指调用结果返回之前，当前线程会被挂起。函数只有在得到结果之后才会返回。应用程序阻塞读取数据，如下所示：

int fd;
int ret = 0;
int data = 0;

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

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

1.2 非阻塞调用

        是指在不能立刻得到返回结果之前，该函数不会阻塞当前线程，而会立刻返回。应用程序非阻塞读取数据，如下所示：

int fd;
int ret = 0;
int data = 0;

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

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

2. 等待队列

        在Linux中等待队列一般应用在中断处理、进程同步、定时等场合。它能够实现内核中的异步事件通知机制，同步对系统资源的访问等。

        等待队列的基本数据结构是一个双向链表，这个链表存储睡眠的进程。可以使用等待队列来实现阻塞进程的唤醒。

2.1 等待队列的使用

2.1.1 定义和初始化等待队列头

        Linux 内核提供了等待队列(wait queue)来实现阻塞进程的唤醒工作，如果我们要在驱动中使用等待队列，必须创建并初始化一个等待队列头，等待队列头使用结构体wait_queue_head_t 表示，wait_queue_head_t 结构体定义在文件 include/linux/wait.h 中：

        struct __wait_queue_head{

                spinlock_t lock;

                struct list_head task_list；

        }

        typedef struct __wait_queue_head wait_queue_head_t;

        成员变量定义：

        lock自旋锁

        lock自旋锁用来对task_list链表起保护作用。当要向task_list链表中加入或删除元素时，内核内部就会锁定lock锁，当修改完成后，会释放lock锁。lock自旋锁在task_list操作过程中，实现了对等待队列的互斥访问。

        task_list变量

        task_list是一个双向循环链表，用来存放等待的进程。

        struct list_head {

                    struct list_head *next, *prev;

        };

        定义好等待队列头以后需要初始化，使用 init_waitqueue_head 函数初始化等待队列头，函数原型如下：

        void init_waitqueue_head(wait_queue_head_t *q)

        参数 q 就是要初始化的等待队列头。

        也可以使用宏 DECLARE_WAIT_QUEUE_HEAD 来一次性完成等待队列头的定义的初始化。

2.1.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 ，在Linux内核中current相当于一个全局变量，表示当前进程。因此宏DECLARE_WAITQUEUE 就是给当前正在运行的进程创建并初始化了一个等待队列项。

2.1.3 将队列项添加/移除等待队列头

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

        等待队列项添加 API 函数如下：

        void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)

        函数参数和返回值含义如下：

        q：等待队列项要加入的等待队列头。

        wait：要加入的等待队列项。

        返回值：无。

        等待队列项移除 API 函数如下：

        void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait)

        函数参数和返回值含义如下：

        q：要删除的等待队列项所处的等待队列头。

        wait：要删除的等待队列项。

        返回值：无。

2.1.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 状态的进程。

2.1.5 等待事件

        除了主动唤醒以外，也可以设置等待队列等待某个事件，当这个事件满足以后就自动唤醒等待队列中的进程，和等待事件有关的 API 函数如下所示：

        wait_event(wq, condition)

        等待以 wq 为等待队列头的等待队列被唤醒，前提是condition条件必须满足(为真)，否则一直阻塞。在等待期间此函数会将进程设置为TASK_UNINTERRUPTIBLE状态（进入睡眠）直到condition变量变为真，每次进程被唤醒的时候都会检查condition的值。

        wait_event_interruptible(wq, condition)

        与 wait_event 函数类似，但是此函数将进程设置为 TASK_INTERRUPTIBLE，就是可以被信号打断。

        wait_event_timeout(wq, condition, timeout)

        功能和 wait_event 类似，但是此函数可以添加超时时间，以jiffies为单位。此函数有返回值，如果返回0的话表示超时时间到，而且 condition为假。为1的话表示 condition 为真，也就是条件满足了。

        wait_event_interruptible_timeout(wq, condition, timeout)

        与 wait_event_timeout 函数类似，此函数也将进程设置为 TASK_INTERRUPTIBLE，可以被信号打断。

3. 轮询

        如果应用程序以非阻塞的方式访问设备，设备驱动程序就要提供非阻塞的处理方式，也就是轮询。poll、epoll 和 select 可以用于处理轮询。应用程序通过poll、epoll 和 select 函数来查询设备是否可以操作，如果可以操作的话就从设备读取或者向设备写入数据。当应用程序调用poll、epoll 和 select 函数的时候设备驱动程序中的 poll 函数就会执行，因此需要在设备驱动程序中编写 poll 函数。

3.1 select 函数

select 函数原型如下：

        int select(int nfds, fd_set *readfds, fd_set *writefds,fd_set *exceptfds, struct timeval *timeout)

        函数参数和返回值含义如下：

        nfds：所要监视的这三类文件描述集合中，最大文件描述符加1。

        readfds、writefds 和 exceptfds：这三个指针指向描述符集合，这三个参数指明了关心哪些描述符、需要满足哪些条件等，这三个参数都是 fd_set 类型的，fd_set 类型变量的每一个位都代表了一个文件描述符。readfds 用于监视指定描述符集的读变化，也就是监视这些文件是否可以读取，只要这些集合里面有一个文件可以读取那么 seclect 就会返回一个大于 0 的值表示文件可以读取。如果没有文件可以读取，那么就会根据 timeout 参数来判断是否超时。可以将 readfs设置为 NULL，表示不关心任何文件的读变化。writefds 和 readfs 类似，只是 writefs 用于监视这些文件是否可以进行写操作。exceptfds 用于监视这些文件的异常。比如我们现在要从一个设备文件中读取数据，那么就可以定义一个 fd_set 变量，这个变量要传递给参数 readfds。当我们定义好一个 fd_set 变量以后可以使用如下所示几个宏进行操作：

        void FD_ZERO(fd_set *set)

        void FD_SET(int fd, fd_set *set)

        void FD_CLR(int fd, fd_set *set)

        int FD_ISSET(int fd, fd_set *set)

        FD_ZERO 用于将 fd_set 变量的所有位都清零，FD_SET 用于将 fd_set 变量的某个位置 1，也就是向 fd_set 添加一个文件描述符，参数 fd 就是要加入的文件描述符。FD_CLR 用户将 fd_set变量的某个位清零，也就是将一个文件描述符从 fd_set 中删除，参数 fd 就是要删除的文件描述符。FD_ISSET 用于测试一个文件是否属于某个集合，参数 fd 就是要判断的文件描述符。

        timeout:超时时间，当我们调用 select 函数等待某些文件描述符可以设置超时时间，超时时间使用结构体 timeval 表示，结构体定义如下所示：

        struct timeval {

                long tv_sec; /* 秒 */

                long tv_usec; /* 微妙 */

        };

        当 timeout 为 NULL 的时候就表示无限期的等待。

        返回值：0，表示的话就表示超时发生，但是没有任何文件描述符可以进行操作；-1，发生

错误；其他值，可以进行操作的文件描述符个数。

        select 函数非阻塞读访问示例:

void main(void)
{
	int ret, fd; /* 要监视的文件描述符 */
	fd_set readfds; /* 读操作文件描述符集 */
	struct timeval timeout; /* 超时结构体 */

	fd = open("dev_xxx", O_RDWR | O_NONBLOCK); /* 非阻塞式访问 */

	FD_ZERO(&readfds); /* 清除 readfds */
	FD_SET(fd, &readfds); /* 将 fd 添加到 readfds 里面 */

	/* 构造超时时间 */
	timeout.tv_sec = 0;
	timeout.tv_usec = 500000; /* 500ms */

	ret = select(fd + 1, &readfds, NULL, NULL, &timeout);
	switch (ret) {
		case 0: /* 超时 */
			printf("timeout!\r\n");
			break;
		case -1: /* 错误 */
			printf("error!\r\n");
			break;
		default: /* 可以读取数据 */
			if(FD_ISSET(fd, &readfds)) { /* 判断是否为 fd 文件描述符 */
			/* 使用 read 函数读取数据 */
			}
			break;
	} 
}

3.2  poll 函数

        在单个线程中，select 函数能够监视的文件描述符数量有最大的限制，一般为 1024，可以修改内核将监视的文件描述符数量改大，但是这样会降低效率。这个时候就可以使用 poll 函数，poll 函数本质上和 select 没有太大的差别，但是 poll 函数没有最大文件描述符限制，Linux 应用程序中 poll 函数原型如下所示：

        int poll(struct pollfd *fds, nfds_t nfds, int timeout)

        函数参数和返回值含义如下：

        fds：要监视的文件描述符集合以及要监视的事件，为一个数组，数组元素都是结构体 pollfd类型的，pollfd 结构体如下所示：

        struct pollfd {

                int fd; /* 文件描述符 */

                short events; /* 请求的事件 */

                short revents; /* 返回的事件 */

        };

        fd：是要监视的文件描述符，如果 fd 无效的话那么 events 监视事件也就无效，并且 revents返回 0。 events 是要监视的事件，可监视的事件类型如下所示：

        POLLIN 有数据可以读取。

        POLLPRI 有紧急的数据需要读取。

        POLLOUT 可以写数据。

        POLLERR 指定的文件描述符发生错误。

        POLLHUP 指定的文件描述符挂起。

        POLLNVAL 无效的请求。

        POLLRDNORM 等同于 POLLIN

        revents 是返回参数，也就是返回的事件，由 Linux 内核设置具体的返回事件。

        nfds：poll 函数要监视的文件描述符数量。

        timeout：超时时间，单位为 ms。

        返回值：返回 revents 域中不为 0 的 pollfd 结构体个数，也就是发生事件或错误的文件描述符数量；0，超时；-1，发生错误，并且设置 errno 为错误类型。

        使用 poll 函数对某个设备驱动文件进行读非阻塞访问的操作示例如下所示：

void main(void)
{
	int ret; 
	int fd; /* 要监视的文件描述符 */
	struct pollfd fds; 

	fd = open(filename, O_RDWR | O_NONBLOCK); /* 非阻塞式访问 */

	/* 构造结构体 */
	fds.fd = fd;
	fds.events = POLLIN; /* 监视数据是否可以读取 */

	ret = poll(&fds, 1, 500); /* 轮询文件是否可操作，超时 500ms */
	if (ret) { /* 数据有效 */
		......
		/* 读取数据 */
		......
	} else if (ret == 0) { /* 超时 */
		......
	} else if (ret < 0) { /* 错误 */
		......
	}
}

3.3  epoll 函数

        传统的 selcet 和 poll 函数都会随着所监听的 fd 数量的增加，出现效率低下的问题，而且poll 函数每次必须遍历所有的描述符来检查就绪的描述符，这个过程很浪费时间。为此epoll应运而生，epoll 就是为处理大并发而准备的，一般常常在网络编程中使用 epoll 函数。

3.3.1 应用程序需要先使用 epoll_create 函数创建一个 epoll 句柄，epoll_create 函数原型如下：

        int epoll_create(int size)

        函数参数和返回值含义如下：

        size：从 Linux2.6.8 开始此参数已经没有意义了，随便填写一个大于 0 的值就可以。

        返回值：epoll 句柄，如果为-1 的话表示创建失败。

3.3.2 epoll 句柄创建成功以后使用 epoll_ctl 函数向其中添加要监视的文件描述符以及监视的事件，epoll_ctl 函数原型如下所示：

        int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)

        函数参数和返回值含义如下：

        epfd：要操作的 epoll 句柄，也就是使用 epoll_create 函数创建的 epoll 句柄。

        op：表示要对 epfd(epoll 句柄)进行的操作，可以设置为：

        EPOLL_CTL_ADD 向 epfd 添加文件参数 fd 表示的描述符。

        EPOLL_CTL_MOD 修改参数 fd 的 event 事件。

        EPOLL_CTL_DEL 从 epfd 中删除 fd 描述符。

        fd：要监视的文件描述符。

        event：要监视的事件类型，为 epoll_event 结构体类型指针，epoll_event 结构体类型如下所示：

        struct epoll_event {

                uint32_t events; /* epoll 事件 */

                epoll_data_t data; /* 用户数据 */

        };

        结构体 epoll_event 的 events 成员变量表示要监视的事件，可选的事件如下所示：

        EPOLLIN 有数据可以读取。

        EPOLLOUT 可以写数据。

        EPOLLPRI 有紧急的数据需要读取。

        EPOLLERR 指定的文件描述符发生错误。

        EPOLLHUP 指定的文件描述符挂起。

        EPOLLET 设置 epoll 为边沿触发，默认触发模式为水平触发。

        EPOLLONESHOT 一次性的监视，当监视完成以后还需要再次监视某个 fd，那么就需要将fd 重新添加到 epoll 里面。

        上面这些事件可以进行“或”操作，也就是说可以设置监视多个事件。

        返回值：0，成功；-1，失败，并且设置 errno 的值为相应的错误码。

3.3.3 一切都设置好以后应用程序就可以通过 epoll_wait 函数来等待事件的发生，类似 select 函数。epoll_wait 函数原型如下所示：

        int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)

        函数参数和返回值含义如下：

        epfd：要等待的 epoll。

        events：指向 epoll_event 结构体的数组，当有事件发生的时候 Linux 内核会填写 events，调用者可以根据 events 判断发生了哪些事件。

        maxevents：events 数组大小，必须大于 0。

        timeout：超时时间，单位为 ms。

        返回值：0，超时；-1，错误；其他值，准备就绪的文件描述符数量。

        epoll 更多的是用在大规模的并发服务器上，因为在这种场合下 select 和 poll 并不适合。当设计到的文件描述符(fd)比较少的时候就适合用 selcet 和 poll。

3.4 Linux 驱动下的 poll 操作函数

        当应用程序调用 select 或 poll 函数来对驱动程序进行非阻塞访问的时候，驱动程序file_operations 操作集中的 poll 函数就会执行。所以驱动程序的编写者需要提供对应的 poll 函数，poll 函数原型如下所示：

        unsigned int (*poll) (struct file *filp, struct poll_table_struct *wait)

        函数参数和返回值含义如下：

        filp：要打开的设备文件(文件描述符)。

        wait：结构体 poll_table_struct 类型指针，由应用程序传递进来的。一般将此参数传递给poll_wait 函数。

        返回值:向应用程序返回设备或者资源状态，可以返回的资源状态如下：

        POLLIN 有数据可以读取。

        POLLPRI 有紧急的数据需要读取。

        POLLOUT 可以写数据。

        POLLERR 指定的文件描述符发生错误。

        POLLHUP 指定的文件描述符挂起。

        POLLNVAL 无效的请求。

        POLLRDNORM 等同于 POLLIN，普通数据可读

        我们需要在驱动程序的 poll 函数中调用 poll_wait 函数，poll_wait 函数不会引起阻塞，只是

将应用程序添加到 poll_table 中，poll_wait 函数原型如下：

        void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)

        参数 wait_address 是要添加到 poll_table 中的等待队列头，参数 p 就是 poll_table，就是

file_operations 中 poll 函数的 wait 参数。

4. linux同步与异步操作：

4.1 同步：所谓同步，就是在发出一个功能调用时，在没有得到结果之前，该调用就不返回。也就是必须一件一件事做,等前一件做完了才能做下一件事。

例如普通B/S模式（同步）：提交请求->等待服务器处理->处理完毕返回 这个期间客户端浏览器不能干任何事

4.2 异步：异步的概念和同步相对。当一个异步过程调用发出后，调用者不能立刻得到结果。实际处理这个调用的部件在完成后，通过状态、通知和回调来通知调用者。

例如 ajax请求（异步）: 请求通过事件触发->服务器处理（这是浏览器仍然可以作其他事情）->处理完毕

4.3 阻塞：阻塞调用是指调用结果返回之前，当前线程会被挂起（线程进入非可执行状态，在这个状态下，cpu不会给线程分配时间片，即线程暂停运行）。函数只有在得到结果之后才会返回。

有人也许会把阻塞调用和同步调用等同起来，实际上他是不同的。对于同步调用来说，很多时候当前线程还是激活的，只是从逻辑上当前函数没有返回,它还会抢占cpu去执行其他逻辑，也会主动检测io是否准备好。

4.4 非阻塞

非阻塞和阻塞的概念相对应，指在不能立刻得到结果之前，该函数不会阻塞当前线程，而会立刻返回。

4.5 再简单点理解就是：

4.5.1 同步，就是我调用一个功能，该功能没有结束前，我死等结果。

4.5.2 异步，就是我调用一个功能，不需要知道该功能结果，该功能有结果后通知我（回调通知）

4.5.3 阻塞，就是调用我（函数），我（函数）没有接收完数据或者没有得到结果之前，我不会返回。

4.5.4 非阻塞，就是调用我（函数），我（函数）立即返回，通过select通知调用者

同步IO和异步IO的区别就在于：数据拷贝的时候进程是否阻塞。

阻塞IO和非阻塞IO的区别就在于：应用程序的调用是否立即返回。

阻塞操作它能够实现内核中的异步事件通知机制，同步对系统资源的访问等。