设备驱动的轮询编程select()和poll()

看到轮询设备操作的时候DT了，不是很懂，今天又看了看，感觉理解了，但是肯定还是不扎实。

使用非阻塞IO的应用程序通常会使用select()和poll()系统调用查询是否可以对设备进行无阻塞访问。

在用户空间使用的是select()，在内核空间使用的是poll()。

一、select

1.定义：Select系统调用用于多路监控，当没有一个文件满足要求时，select将阻塞调用进程。、

2.函数：int select(int maxfd, fd_set *readfds, fd_set *writefds, fe_set *exceptfds, const struct  timeval *timeout)

3.参数：

Maxfd:文件描述符的范围，比待检测的最大文件描述符大1
v Readfds:被读监控的文件描述符集
v Writefds:被写监控的文件描述符集
v Exceptfds:被异常监控的文件描述符集；
v Timeout:定时器

关于参数Timeout:

Timeout值为0，不管是否有文件满足要求，都立刻返回，无文件满足要求返回0，有文件满足要求返回一个正值。
v Timeout为NULL，select将阻塞进程，直到某个文件满足要求
v Timeout 值为正整数 ，就是等待的最长时间，即select在timeout时间内阻塞进程。

4.select的返回值：

①正常情况下返回满足要求的文件描述符个数；
②经过了timeout等待后仍无文件满足要求，返回值为0；
③如果select被某个信号中断，它将返回-1并设置errno为EINTR。
④如果出错，返回-1并设置相应的errno。

5.使用方法

①将要监控的文件添加到文件描述符集
②调用Select开始监控
③ 判断文件是否发生变化

6.select的系统调用

系统提供了4个宏对描述符集进行操作：
#include <sys/select.h>
void FD_SET(int fd, fd_set *fdset)
void FD_CLR(int fd, fd_set *fdset)
void FD_ZERO(fd_set *fdset)
void FD_ISSET(int fd, fd_set *fdset)
宏FD_SET将文件描述符fd添加到文件描述符集fdset中；
宏FD_CLR从文件描述符集fdset中清除文件描述符fd；
宏FD_ZERO清空文件描述符集fdset；
在调用select后使用FD_ISSET来检测文件描述符集fdset中的文件fd发生了变化。

6.select的历程。

FD_ZERO(&fds);//清空集合
FD_SET(fd1,&fds);//设置描述符
FD_SET(fd2,&fds);//设置描述符
maxfdp=fd1+1； //描述符最大值加1,假设fd1>fd2
switch(select(maxfdp,&fds,NULL,NULL,&timeout)) 
case -1: exit(-1);break;//select错误，退出程序
case 0:break; 
default: 
if(FD_ISSET(fd1,&fds))//测试fd1是否可读

 

二、poll()函数的使用方法

1.含义：应用程序常常使用select系统调用,它可能会阻塞进程。

2.函数原型：unsignedint (*poll)(struct file *filp,poll_table *wait)

3.poll的实现：

①对可能引起设备文件状态变化的等待队列调用poll_wait()函数，将对应的等待队列头加到poll_table。

②返回值表示是否可能对设备进行无阻塞读、写访问的掩码。

关于poll_wait()函数的用法以及注意事项附截图一个：

poll()函数应返回设备资源可获取状态：

POLLIN 设备可读
v POLLRDNORM 数据可读
v POLLOUT 设备可写
v POLLWRNORM 数据可写

设备可读通常返回(POLLIN|POLLRDNORM)
设备可写通常返回(POLLOUT|POLLWRNORM)

4.poll()的历程

static unsigned int mem_poll(struct file *filp,poll_table *wait)
{
struct scull_pipe *dev=filp->private_data;
unsigned int mask=0;
/* 把等待队列添加到poll_table */
poll_wait(filp,&dev->inq,wait);
/*返回掩码*/
if(有数据可读) 
mask = POLLIN |POLLRDNORM;/*设备可读*/
return mask;
}

老谢的最后一句话：Poll方法只是做一个登记，真正的阻塞发生在select.c 中的 do_select函数。

注意：poll()并没有使进程发生阻塞，但是select()确实导致了进程的阻塞，这个原因是因为内核这一层发生了故事，老谢领着看内核了，我犯迷糊了没看懂。

下面附上GQ的历程代码：

1.驱动设备注册部分---这一部分包含init_waitqueue_head()----设备初始化函数。

/*设备驱动模块加载函数*/
static int memdev_init(void)
{
  int result;
  int i;

  dev_t devno = MKDEV(mem_major, 0);

  /* 静态申请设备号*/
  if (mem_major)
    result = register_chrdev_region(devno, 2, "memdev");
  else  /* 动态分配设备号 */
  {
    result = alloc_chrdev_region(&devno, 0, 2, "memdev");
    mem_major = MAJOR(devno);
  }  
  
  if (result < 0)
    return result;

  /*初始化cdev结构*/
  cdev_init(&cdev, &mem_fops);
  cdev.owner = THIS_MODULE;
  cdev.ops = &mem_fops;
  
  /* 注册字符设备 */
  cdev_add(&cdev, MKDEV(mem_major, 0), MEMDEV_NR_DEVS);
   
  /* 为设备描述结构分配内存*/
  mem_devp = kmalloc(MEMDEV_NR_DEVS * sizeof(struct mem_dev), GFP_KERNEL);
  if (!mem_devp)    /*申请失败*/
  {
    result =  - ENOMEM;
    goto fail_malloc;
  }
  memset(mem_devp, 0, sizeof(struct mem_dev));
  
  /*为设备分配内存*/
  for (i=0; i < MEMDEV_NR_DEVS; i++) 
  {
        mem_devp[i].size = MEMDEV_SIZE;
        mem_devp[i].data = kmalloc(MEMDEV_SIZE, GFP_KERNEL);
        memset(mem_devp[i].data, 0, MEMDEV_SIZE);
  
  	/*初始化等待队列*/
 	init_waitqueue_head(&(mem_devp[i].inq)); 
 	//init_waitqueue_head(&(mem_devp[i].outq));
  }
   
  return 0;

  fail_malloc: 
  unregister_chrdev_region(devno, 1);
  
  return result;
}

2.文件结构体指针部分-----新定义了poll()

/*文件操作结构体*/
static const struct file_operations mem_fops =
{
  .owner = THIS_MODULE,
  .llseek = mem_llseek,
  .read = mem_read,
  .write = mem_write,
  .open = mem_open,
  .release = mem_release,
  .poll = mem_poll,
};

3下面是读函数其中包括.wait_event_interruptible()

/*读函数*/
static ssize_t mem_read(struct file *filp, char __user *buf, size_t size, loff_t *ppos)
{
  unsigned long p =  *ppos;
  unsigned int count = size;
  int ret = 0;
  struct mem_dev *dev = filp->private_data; /*获得设备结构体指针*/

  /*判断读位置是否有效*/
  if (p >= MEMDEV_SIZE)
    return 0;
  if (count > MEMDEV_SIZE - p)
    count = MEMDEV_SIZE - p;
    
  while (!have_data) /* 没有数据可读，考虑为什么不用if，而用while */
  {
        if (filp->f_flags & O_NONBLOCK)
            return -EAGAIN;
	
	wait_event_interruptible(dev->inq,have_data);
  }

  /*读数据到用户空间*/
  if (copy_to_user(buf, (void*)(dev->data + p), count))
  {
    ret =  - EFAULT;
  }
  else
  {
    *ppos += count;
    ret = count;
   
    printk(KERN_INFO "read %d bytes(s) from %d\n", count, p);
  }
  
  have_data = false; /* 表明不再有数据可读 */
  /* 唤醒写进程 */
  return ret;
}

4.写函数----包括唤醒

/*写函数*/
static ssize_t mem_write(struct file *filp, const char __user *buf, size_t size, loff_t *ppos)
{
  unsigned long p =  *ppos;
  unsigned int count = size;
  int ret = 0;
  struct mem_dev *dev = filp->private_data; /*获得设备结构体指针*/
  
  /*分析和获取有效的写长度*/
  if (p >= MEMDEV_SIZE)
    return 0;
  if (count > MEMDEV_SIZE - p)
    count = MEMDEV_SIZE - p;

  /*从用户空间写入数据*/
  if (copy_from_user(dev->data + p, buf, count))
    ret =  - EFAULT;
  else
  {
    *ppos += count;
    ret = count;
    
    printk(KERN_INFO "written %d bytes(s) from %d\n", count, p);
  }
  
  have_data = true; /* 有新的数据可读 */
    
    /* 唤醒读进程 */
    wake_up(&(dev->inq));

  return ret;
}

5.将等待队列添加到poll_table()

unsigned int mem_poll(struct file *filp, poll_table *wait)
{
    struct mem_dev  *dev = filp->private_data; 
    unsigned int mask = 0;
    
   /*将等待队列添加到poll_table */
    poll_wait(filp, &dev->inq,  wait);
 
    
    if (have_data)         

    mask |= POLLIN | POLLRDNORM;  /* readable */

    return mask;
}