最全Linux驱动开发八股文（十三）

你好，我是拉依达。

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

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

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

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

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

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

13.3 非阻塞IO使用（轮询）

应用层

如果用户应用程序以非阻塞的方式访问设备，设备驱动程序就要提供非阻塞的处理方式，即轮询。 poll、 epoll 和 select 可以用于处理轮询。

应用程序通过 select、 epoll 或 poll 函数来查询设备是否可以操作，如果可以操作的话就从设备读取或者向设备写入数据。当应用程序调用 select、 epoll 或 poll 函数的时，设备驱动程序中的 poll 函数就会执行，因此需要在设备驱动程序中编写 poll 函数。

1.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，表示不关心任何文件的读变化。
  • writefs 用于监视文件是否可以进行写操作。
  • exceptfds 用于监视文件的异常。
• timeout:超时时间，当调用 select 函数等待某些文件描述符可以设置超时时间
• 返回值： 0: 超时发生，没有文件描述符可以进行操作； -1: 发生错误； 其他值: 可以进行操作的文件描述符个数

从一个设备文件中读取数据，要定义一个 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文件描述符从 fd_set 中删除
• FD_ISSET: 测试文件描述符 fd是否属于某个集合

超时时间使用结构体 timeval 表示， 当 timeout 为 NULL 的时候就表示无限期的等待。

struct timeval {
    long tv_sec; /* 秒 */
    long tv_usec; /* 微妙 */
};

应用层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 文件描述符是否在readfds里面 */
            { 
                /* 使用 read 函数读取数据 */
            }
            break;
    }
}

2.poll

在单个线程中， select 函数能够监视的文件描述符数量有最大的限制，一般为 1024。可以修改内核将监视的文件描述符数量改大。这时可以使用 poll 函数，poll 函数本质上和 select 没有太大的差别，但是 poll 函数没有最大文件描述符限制。

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

• fds： 要监视的文件描述符集合以及要监视的事件, 为一个数组，数组元素都是结构体 pollfd类型的。
• nfds： poll 函数要监视的文件描述符数量
• timeout： 超时时间，单位为 ms
• 返回值：返回 revents 域中不为 0 的 pollfd 结构体个数，发生事件或错误的文件描述符数量； 0：超时； -1：发生错误，并且设置 errno 为错误类型

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 内核设置具体的返回事件。

应用层 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.epoll

selcet 和 poll 函数都会随着所监听的 fd 数量的增加，出现效率低下的问题，而且poll 函数每次必须遍历所有的描述符来检查就绪的描述符，这个过程很浪费时间。

epoll 就是为处理大并发而准备的，一般常常在网络编程中使用 epoll 函数。

应用程序需要先使用 epoll_create 函数创建一个 epoll 句柄

int epoll_create(int size)

• size：从 Linux2.6.8 开始此参数已经没有意义了，填写一个大于 0 的值就可以
• 返回值： epoll 句柄，如果为-1 的话表示创建失败

epoll 句柄创建成功以后使用 epoll_ctl 函数向其中添加要监视的文件描述符以及监视的事件

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

• epfd： 要操作的 epoll 句柄，使用 epoll_create 函数创建的 epoll 句柄
• op： 要对epoll 句柄进行的操作，可以设置为：
  • EPOLL_CTL_ADD 向 epfd 添加文件参数 fd 表示的描述符
  • EPOLL_CTL_MOD 修改参数 fd 的 event 事件。
  • EPOLL_CTL_DEL 从 epfd 中删除 fd 描述符
• fd：要监视的文件描述符
• event： 要监视的事件类型，为 epoll_event 结构体类型指针
• 返回值： 0：成功； -1：失败，并且设置 errno 的值为相应的错误码。

监视的事件类型为 epoll_event 结构体类型指针

struct epoll_event {
        uint32_t events; /* epoll 事件 */
        epoll_data_t data; /* 用户数据 */
};

• events 表示要监视的事件，可选的事件如下
  • EPOLLIN 有数据可以读取
  • EPOLLOUT 可以写数据
  • EPOLLPRI 有紧急的数据需要读取
  • EPOLLERR 指定的文件描述符发生错误
  • EPOLLHUP 指定的文件描述符挂起
  • EPOLLET 设置 epoll 为边沿触发，默认触发模式为水平触发
  • EPOLLONESHOT 一次性的监视，当监视完成以后还需要再次监视某个 fd，就需要将fd 重新添加到 epoll 里面

最后通过 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 并不适合。当设计到的文件描述符比较少的时候就适合用 selcet 和 poll。

驱动层

当应用程序调用 select 或 poll 函数来对驱动程序进行非阻塞访问，驱动程序file_operations 操作集中的 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 中

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

• filp： 要打开的设备文件(文件描述符)
• wait_address：要添加到 poll_table 中的等待队列头
• p：file_operations 中 poll 函数的 wait 参数

驱动层poll函数模板（和应用层select、poll对应）

/* 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)
{
    int ret = 0;
    unsigned char keyvalue = 0;
    unsigned char releasekey = 0;
    struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;


   if (filp->f_flags & O_NONBLOCK)	/* 非阻塞访问 */
   { 
		if(atomic_read(&dev->releasekey) == 0)	/* 没有按键按下，返回-EAGAIN */
			return -EAGAIN;
	} 
	else /* 阻塞访问 */
    {							
		/* 加入等待队列，等待被唤醒,也就是有按键按下 */
 		ret = wait_event_interruptible(dev->r_wait, atomic_read(&dev->releasekey)); 
		if (ret) 
        {
			goto wait_error;
		}
    }
	......
wait_error:
	return ret;
	......
}

unsigned int imx6uirq_poll(struct file *filp, struct poll_table_struct *wait)
{
	unsigned int mask = 0;
	struct imx6uirq_dev *dev = (struct imx6uirq_dev *)filp->private_data;

	poll_wait(filp, &dev->r_wait, wait);	/* 将等待队列头添加到poll_table中 */
	
	if(atomic_read(&dev->releasekey)) {		/* 按键按下 */
		mask = POLLIN | POLLRDNORM;			/* 返回PLLIN */
	}
	return mask;
}

static struct file_operations imx6uirq_fops = 
{
    .owner = THIS_MODULE,
    .open = imx6uirq_open,
    .read = imx6uirq_read,
    .poll = imx6uirq_poll,
};