x4412&ibox项目实战39－轮询操作

armeasy

在用户程序中，使用非阻塞I/O的应用程序通常会使用select()和poll()系统调用查询是否可对设备进行无阻塞的访问。select()和poll()系统调用最终会引发设备驱动中的poll()函数被执行。select()和poll()系统调用的本质一样，前者在 BSD UNIX 中引入的，后者在 System V中引入的。应用程序中最广泛用到的是BSD UNIX中引入的select()系统调用，其原型如下：

1. int select(int numfds, fd _ set *readfds, fd _ set *writefds, fd _ set *exceptfds,struct timeval *timeout);

复制代码

其中readfds、writefds、exceptfds分别是被select()监视的读、写和异常处理的文件描述符集合，numfds的值是文件描述符加1。timeout参数是一个指向struct timeval类型的指针，它可以使select()在等待timeout时间后若没有文件描述符准备好则返回。

下列操作用来设置、清除、判断文件描述符集合。

1. FD_ZERO(fd_set *set)

复制代码

清除一个文件描述符集。

1. FD_SET(int fd,fd_set *set)

复制代码

将一个文件描述符加入文件描述符集中。

1. FD_CLR(int fd,fd_set *set)

复制代码

将一个文件描述符从文件描述符集中清除。

1. FD_ISSET(int fd,fd_set *set)

复制代码

判断文件描述符是否被置位。

设备驱动中 poll()函数的原型如下：

1. unsigned int(*poll)(struct file * filp, struct poll_table* wait);

复制代码

第一个参数为file结构体指针，第二个参数为轮询表指针。这个函数应该进行以下两项工作。

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

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

驱动程序poll()函数应该返回设备资源的可获取状态，即POLLIN、POLLOUT、POLLPRI、POLLERR、POLLNVAL等宏的位“或”结果。每个宏的含义都表明设备的一种状态，如POLLIN（定义为 0x0001）意味着设备可以无阻塞地读，POLLOUT（定义为0x0004）意味着设备可以无阻塞地写。

将上一小节的FIFO驱动修改为使用轮询操作，在kernel/drivers/char/x4412目录下新建x4412-globalfifo-poll.c，编辑内容如下：

1. #include <linux/module.h>
   
2. #include <linux/types.h>
   
3. #include <linux/fs.h>
   
4. #include <linux/errno.h>
   
5. #include <linux/sched.h>
   
6. #include <linux/init.h>
   
7. #include <linux/cdev.h>
   
8. #include <asm/uaccess.h>
   
9. #include <linux/poll.h>
   
10. #include <linux/slab.h>
    
11. #include <linux/device.h>
    
12. 
    
13. #define GLOBALFIFO_SIZE 0x1000 /*全局fifo最大4K字节*/
    
14. #define FIFO_CLEAR 0x1  /*清0全局内存的长度*/
    
15. DEFINE_SEMAPHORE(sem);//初始化并声明一个信号量
    
16. DECLARE_WAIT_QUEUE_HEAD(r_wait);//初始化并声明一个等待队列r_wait
    
17. DECLARE_WAIT_QUEUE_HEAD(w_wait);//初始化并声明一个等待队列w_wait
    
18. static int globalfifo_major;
    
19. static struct class *cdev_class;
    
20. struct globalfifo_dev                                    
    
21. {
    
22.          struct cdev cdev; /*cdev结构体*/                     
    
23.          unsigned int current_len;    /*fifo有效数据长度*/
    
24.          unsigned char mem[GLOBALFIFO_SIZE]; /*全局内存*/
    
25. };
    
26. struct globalfifo_dev *globalfifo_devp; /*设备结构体指针*/
    
27. int globalfifo_open(struct inode *inode, struct file *filp)
    
28. {
    
29.          /*将设备结构体指针赋值给文件私有数据指针*/
    
30.          filp->private_data = globalfifo_devp;
    
31.          return 0;
    
32. }
    
33. int globalfifo_release(struct inode *inode, struct file *filp)
    
34. {
    
35.          return 0;
    
36. }
    
37. static long globalfifo_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
    
38. {
    
39.          struct globalfifo_dev *dev = filp->private_data;/*获得设备结构体指针*/
    
40.          switch (cmd)
    
41.          {
    
42.                    case FIFO_CLEAR:
    
43.                             down(&sem); //获得信号量   
    
44.                             dev->current_len = 0;
    
45.                             memset(dev->mem,0,GLOBALFIFO_SIZE);
    
46.                             up(&sem); //释放信号量
    
47.                             printk(KERN_INFO "globalfifo is set to zero\n");     
    
48.                    break;
    
49.                    default:
    
50.                             return  - EINVAL;
    
51.          }
    
52.          return 0;
    
53. }
    
54. static unsigned int globalfifo_poll(struct file *filp, poll_table *wait)
    
55. {
    
56.          unsigned int mask = 0;
    
57.          struct globalfifo_dev *dev = filp->private_data; /*获得设备结构体指针*/
    
58.          down(&sem);
    
59.          poll_wait(filp, &r_wait, wait);//添加读等待队列头
    
60.          poll_wait(filp, &w_wait, wait);//添加写等待队列头
    
61.          if(dev->current_len != 0)/*fifo非空*/
    
62.          {
    
63.                    mask |= POLLIN | POLLRDNORM; /*标示数据可获得*/
    
64.          }
    
65.          if (dev->current_len != GLOBALFIFO_SIZE)/*fifo非满*/
    
66.          {
    
67.                    mask |= POLLOUT | POLLWRNORM; /*标示数据可写入*/
    
68.          }
    
69.          up(&sem);
    
70.          return mask;
    
71. }
    
72. static ssize_t globalfifo_read(struct file *filp, char __user *buf, size_t count,loff_t *ppos)
    
73. {
    
74.          int ret;
    
75.          struct globalfifo_dev *dev = filp->private_data; //获得设备结构体指针
    
76.          DECLARE_WAITQUEUE(wait, current); //定义等待队列
    
77.          down(&sem); //获得信号量
    
78.          add_wait_queue(&r_wait, &wait); //进入读等待队列头
    
79.          if (dev->current_len == 0)/* 如果FIFO为空，则进程进入睡眠等待 */
    
80.          {
    
81.                    if (filp->f_flags &O_NONBLOCK)//非阻塞
    
82.                    {
    
83.                             ret =  - EAGAIN;
    
84.                             goto out;
    
85.                    }
    
86.                    __set_current_state(TASK_INTERRUPTIBLE); //改变进程状态为睡眠
    
87.                    up(&sem);
    
88.                    schedule(); //调度其他进程执行
    
89.                    if (signal_pending(current))//如果是因为信号唤醒
    
90.                    {
    
91.                             ret =  - ERESTARTSYS;
    
92.                             goto out2;
    
93.                    }
    
94.                    down(&sem);
    
95.          }
    
96.          if (count > dev->current_len)/* 拷贝到用户空间 */
    
97.                    count = dev->current_len;
    
98.          if (copy_to_user(buf, dev->mem, count)) //从内核空间拷贝到用户空间
    
99.          {
    
100.                    ret =  - EFAULT;
     
101.                    goto out;
     
102.          }
     
103.          else
     
104.          {
     
105.                    memcpy(dev->mem, dev->mem + count, dev->current_len - count);  //fifo(管道)数据前移
     
106.                    dev->current_len -= count;     //有效数据长度减少
     
107.                    printk(KERN_INFO "read %d bytes(s),current_len:%d\n", count, dev->current_len);
     
108.                    wake_up_interruptible(&w_wait); //唤醒写等待队列
     
109.                    ret = count;
     
110.          }
     
111. out:
     
112.          up(&sem); //释放信号量
     
113. out2:
     
114.          remove_wait_queue(&w_wait, &wait); //从附属的等待队列头移除
     
115.          set_current_state(TASK_RUNNING);
     
116.          return ret;
     
117. }
     
118. /*globalfifo写操作*/
     
119. static ssize_t globalfifo_write(struct file *filp, const char __user *buf, size_t count, loff_t *ppos)
     
120. {
     
121.          struct globalfifo_dev *dev = filp->private_data; //获得设备结构体指针
     
122.          int ret;
     
123.          DECLARE_WAITQUEUE(wait, current); //定义等待队列
     
124.          down(&sem); //获取信号量
     
125.          add_wait_queue(&w_wait, &wait); //进入写等待队列头
     
126.          if (dev->current_len == GLOBALFIFO_SIZE)/* 如果FIFO已满则进入睡眠等待 */
     
127.          {
     
128.                    if (filp->f_flags &O_NONBLOCK)//如果是非阻塞访问
     
129.                    {
     
130.                             ret =  - EAGAIN;
     
131.                             goto out;
     
132.                    }
     
133.                    __set_current_state(TASK_INTERRUPTIBLE); //改变进程状态为睡眠
     
134.                    up(&sem);
     
135.                    schedule(); //调度其他进程执行
     
136.                    if (signal_pending(current))//如果是因为信号唤醒
     
137.                    {
     
138.                             ret =  - ERESTARTSYS;
     
139.                             goto out2;
     
140.                    }
     
141.                    down(&sem); //获得信号量
     
142.          }
     
143.          /*从用户空间拷贝到内核空间*/
     
144.          if (count > GLOBALFIFO_SIZE - dev->current_len)
     
145.                    count = GLOBALFIFO_SIZE - dev->current_len;
     
146.          if (copy_from_user(dev->mem + dev->current_len, buf, count))
     
147.          {
     
148.                    ret =  - EFAULT;
     
149.                    goto out;
     
150.          }
     
151.          else
     
152.          {
     
153.                    dev->current_len += count;
     
154.                    printk(KERN_INFO "written %d bytes(s),current_len:%d\n", count, dev->current_len);
     
155.                    wake_up_interruptible(&r_wait); //唤醒读等待队列
     
156.                    ret = count;
     
157.          }
     
158. out:
     
159.          up(&sem); //释放信号量
     
160. out2:
     
161.          remove_wait_queue(&w_wait, &wait); //从附属的等待队列头移除
     
162.          set_current_state(TASK_RUNNING);
     
163.          return ret;
     
164. }
     
165. /*文件操作结构体*/
     
166. static const struct file_operations globalfifo_fops =
     
167. {
     
168.          .owner = THIS_MODULE,
     
169.          .read = globalfifo_read,
     
170.          .write = globalfifo_write,
     
171.          .unlocked_ioctl = globalfifo_ioctl,
     
172.          .poll = globalfifo_poll,
     
173.          .open = globalfifo_open,
     
174.          .release = globalfifo_release,
     
175. };
     
176. /*初始化并注册cdev*/
     
177. static void globalfifo_setup_cdev(struct globalfifo_dev *dev, int index)
     
178. {
     
179.          int err, devno = MKDEV(globalfifo_major, index);
     
180.          cdev_init(&dev->cdev, &globalfifo_fops);
     
181.          dev->cdev.owner = THIS_MODULE;
     
182.          dev->cdev.ops = &globalfifo_fops;
     
183.          err = cdev_add(&dev->cdev, devno, 1);
     
184.          if (err)
     
185.                    printk(KERN_NOTICE "Error %d adding LED%d", err, index);
     
186. }
     
187. /*设备驱动模块加载函数*/
     
188. int globalfifo_init(void)
     
189. {
     
190.          int ret;
     
191.          dev_t devno;
     
192.          ret = alloc_chrdev_region(&devno, 0, 1, "x4412-globalfifo-poll");
     
193.          globalfifo_major = MAJOR(devno);
     
194.          if (ret < 0)
     
195.                    return ret;
     
196.          /* 动态申请设备结构体的内存*/
     
197.          globalfifo_devp = kmalloc(sizeof(struct globalfifo_dev), GFP_KERNEL);
     
198.          if (!globalfifo_devp)    /*申请失败*/
     
199.          {
     
200.                    ret =  - ENOMEM;
     
201.                    goto fail_malloc;
     
202.          }
     
203.          memset(globalfifo_devp, 0, sizeof(struct globalfifo_dev));
     
204.          globalfifo_setup_cdev(globalfifo_devp, 0);
     
205.          cdev_class = class_create(THIS_MODULE,"x4412-globalfifo-poll");
     
206.          if(IS_ERR(cdev_class))
     
207.                    goto fail_class;
     
208.          device_create(cdev_class,NULL,devno,NULL,"x4412-globalfifo-poll");
     
209.          return 0;
     
210. fail_class:
     
211.          class_destroy(cdev_class);
     
212. fail_malloc:
     
213.          unregister_chrdev_region(devno, 1);
     
214.          return ret;
     
215. }
     
216. /*模块卸载函数*/
     
217. void globalfifo_exit(void)
     
218. {
     
219.          device_destroy(cdev_class,MKDEV(globalfifo_major,0));
     
220.          class_destroy(cdev_class);
     
221.          cdev_del(&globalfifo_devp->cdev);   /*注销cdev*/
     
222.          kfree(globalfifo_devp);     /*释放设备结构体内存*/
     
223.          unregister_chrdev_region(MKDEV(globalfifo_major, 0), 1); /*释放设备号*/
     
224. }
     
225. MODULE_LICENSE("Dual BSD/GPL");
     
226. MODULE_AUTHOR("www.9tripod.com");
     
227. module_init(globalfifo_init);
     
228. module_exit(globalfifo_exit);

复制代码

       程序中声明了两个等待队列，在读和写函数中实现数据同步，避免读写数据错乱。同时，在file_operations结构体中增加了轮询成员poll，在对应的函数globalfifo_poll中对读写等待队列调用poll_wait函数，返回可对设备操作权限的掩码。

       编辑kernel/drivers/char/x4412/Kconfig文件，添加如下内容：

1. config X4412_GLOBALFIFO_POLL_DRIVER
   
2.          tristate "x4412 globalfifo by poll driver"
   
3.          default m
   
4.          help
   
5.          compile for x4412 globalfifo by poll driver,y for kernel,m for module.

复制代码

       编辑kernel/drivers/char/x4412/Makefile文件，添加如下内容：

1. obj-$(CONFIG_X4412_GLOBALFIFO_DRIVER) += x4412-globalfifo-poll.o

复制代码

       编译内核，在kernel/drivers/char/x4412目录将会生成目标映像x4412-globalfifo-poll.ko文件。

       在ubuntu用户目录或samba目录下新建应用程序x4412-globalfifo-poll-app.c文件，编辑内容如下：

1. #include <sys/types.h>
   
2. #include <sys/stat.h>
   
3. #include <stdio.h>
   
4. #include <fcntl.h>
   
5. #include <unistd.h>
   
6. #include <sys/time.h>
   
7. 
   
8. main()
   
9. {
   
10.          int fd;
    
11.          fd_set rfds,wfds;//读写文件描述符集
    
12.          /*以非阻塞方式打开设备文件*/
    
13.          fd = open("/dev/x4412-globalfifo-poll", O_RDONLY | O_NONBLOCK);
    
14.          if (fd !=  - 1)
    
15.          {
    
16.                    while (1)
    
17.                    {
    
18.                             FD_ZERO(&rfds);//清除读文件描述符
    
19.                             FD_ZERO(&wfds);//清除写文件描述符
    
20.                             FD_SET(fd, &rfds);//将rfds加入文件描述符集
    
21.                             FD_SET(fd, &wfds);//将wfds加入文件描述符集
    
22.                             //监控读写文件描述符
    
23.                             select(fd + 1, &rfds, &wfds, NULL, NULL);
    
24.                             /*数据可获得*/
    
25.                             if (FD_ISSET(fd, &rfds))
    
26.                             {
    
27.                                      printf("Poll monitor:can be read\n");
    
28.                             }
    
29.                             /*数据可写入*/
    
30.                             if (FD_ISSET(fd, &wfds))
    
31.                             {
    
32.                                      printf("Poll monitor:can be written\n");
    
33.                             }     
    
34.                    }
    
35.          }
    
36.          else
    
37.          {
    
38.                    printf("Device open failure\n");
    
39.          }
    
40. }

复制代码

       应用程序首先定义了两个文件描述符rfds和wfds，再以非阻塞的方式打开驱动模块，紧接着清除读写文件描述符后，将他们加入文件描述符集，再通过select函数监控这两个文件描述符。在整个while循环中不断使用FD_ISSET函数判断数据是否可读可写，并打印相应的提示信息。

       加载驱动模块后，在不写入任何内存的情况下运行应用程序，将不断打印“Pollmonitor:can be written”。

1. [root@x4412 mnt]# insmod x4412-globalfifo-poll.ko
   
2. [root@x4412 mnt]# ./x4412-globalfifo-poll
   
3. Poll monitor:can be written
   
4. Poll monitor:can be written

复制代码

       通过echo指令向/dev/x4412-globalfifo-poll写入一些指令后，将不断打印“Poll monitor:can be read”和“Poll monitor:can be written”。

1. [root@x4412 mnt]# echo 'www.9tripod.com' > /dev/x4412-globalfifo-poll
   
2. [ 1121.931135] written 16 bytes(s),current_len:16
   
3. [root@x4412 mnt]# ./x4412-globalfifo-poll
   
4. Poll monitor:can be read
   
5. Poll monitor:can be written
   
6. Poll monitor:can be read
   
7. Poll monitor:can be written

复制代码

       反复通过echo指令向/dev/x4412-globalfifo-poll写指令，直到FIFO被写满4096bytes，再使用应用程序测试，将不断打印“Poll monitor:can beread”。

1. [root@x4412 mnt]# echo 'www.9tripod.com' > /dev/x4412-globalfifo-poll
   
2. [ 1419.245771] written 16 bytes(s),current_len:4096
   
3. [root@x4412 mnt]#
   
4. [root@x4412 mnt]# ./x4412-globalfifo-poll
   
5. Poll monitor:can be read
   
6. Poll monitor:can be read

复制代码