Linux设备驱动程序学习（6）-高级字符驱动程序操作［（4）异步通知fasync]

异步通知fasync

异步通知fasync是应用于系统调用signal和sigaction函数，下面我会使用signal函数。简单的说，signal函数就是让一个信号与与一个函数对应，没当接收到这个信号就会调用相应的函数。

一、什么是异步通知

个人认为，异步通知类似于中断的机制，如下面的将要举例的程序，当设备可写时，设备驱动函数发送一个信号给内核，告知内核有数据可读,在条件不满足之前，并不会造成阻塞。而不像之前学的阻塞型IO和poll，它们是调用函数进去检查，条件不满足时还会造成阻塞。

二、应用层中启用异步通知机制

其实就三个步骤：

1）signal(SIGIO, sig_handler);

调用signal函数，让指定的信号SIGIO与处理函数sig_handler对应。

2）fcntl(fd, F_SET_OWNER, getpid());

指定一个进程作为文件的“属主(filp->owner)”，这样内核才知道信号要发给哪个进程。

3）f_flags = fcntl(fd, F_GETFL);

fcntl(fd, F_SETFL, f_flags | FASYNC);

在设备文件中添加FASYNC标志，驱动中就会调用将要实现的test_fasync函数。

三个步骤执行后，一旦有信号产生，相应的进程就会收到。

以下是fasync应用實例：

点击(此处)折叠或打开

1. #include <stdio.h>
   
2. #include <sys/types.h>
   
3. #include <sys/stat.h>
   
4. #include <fcntl.h>
   
5. #include <sys/select.h>
   
6. #include <unistd.h>
   
7. #include <signal.h>
   
8. 
   
9. unsigned int flag;
   
10. 
    
11. void sig_handler(int sig)
    
12. {
    
13.     printf("<app>%s\n", __FUNCTION__);
    
14.     flag = 1;
    
15. }
    
16. 
    
17. int main(void)
    
18. {
    
19.     char buf[20];
    
20.     int fd;
    
21.     int f_flags;
    
22.     flag = 0;
    
23. 
    
24.     fd = open("/dev/test", O_RDWR);
    
25.     if(fd < 0)
    
26.     {
    
27.         perror("open");
    
28.         return -1;
    
29.     }
    
30.     /*三个步骤*/
    
31.     signal(SIGIO, sig_handler);
    
32.     fcntl(fd, F_SETOWN, getpid());
    
33.     f_flags = fcntl(fd, F_GETFL);
    
34.     fcntl(fd, F_SETFL, FASYNC | f_flags);
    
35. 
    
36.     while(1)
    
37.     {
    
38.         printf("waiting \n"); //在还没收到信号前，程序还在不停的打印
    
39.         sleep(4);
    
40.         if(flag)
    
41.             break;
    
42.     }
    
43.     read(fd, buf, 10);
    
44.     printf("finish: read[%s]\n", buf);
    
45.     close(fd);
    
46.     return 0;
    
47. }

三、驱动中需要实现的异步通知

上面说的三个步骤，内核已经帮忙实现了前两个步骤，只需要我们稍稍实现第三个步骤的一个简单的传参。

实现异步通知，内核需要知道几个东西：哪个文件(filp)，什么信号(SIGIIO)，发给哪个进程(pid)，收到信号后做什么(sig_handler)。这些都由前两个步骤完成了。

回想一下，在实现等待队列中，我们需要将一个等待队列wait_queue_t添加到指定的等待队列头wait_queue_head_t中。

在这里，同样需要把一个结构体struct fasync_struct添加到内核的异步队列头(名字是我自己取的)中。这个结构体用来存放对应设备文件的信息(如fd, filp)并交给内核来管理。一但收到信号，内核就会在这个所谓的异步队列头找到相应的文件(fd)，并在filp->owner中找到对应的进程PID，并且调用对应的sig_handler了。

点击(此处)折叠或打开

1. struct fasync_struct {
   
2.     spinlock_t fa_lock;
   
3.     int magic;
   
4.     int fa_fd;
   
5.     struct fasync_struct *fa_next; /* singly linked list */
   
6.     struct file *fa_file;
   
7.     struct rcu_head fa_rcu;
   
8. };

以下附上ldd3中的scullp驅動源碼，做一下分析：

点击(此处)折叠或打开

1. #include <linux/module.h>
   
2. #include <linux/moduleparam.h>
   
3. #include <linux/sched.h>
   
4. #include <linux/kernel.h>    /* printk(), min() */
   
5. #include <linux/slab.h>        /* kmalloc() */
   
6. #include <linux/fs.h>        /* everything... */
   
7. #include <linux/proc_fs.h>
   
8. #include <linux/errno.h>    /* error codes */
   
9. #include <linux/types.h>    /* size_t */
   
10. #include <linux/fcntl.h>
    
11. #include <linux/poll.h>
    
12. #include <linux/cdev.h>
    
13. #include <asm/uaccess.h>
    
14. 
    
15. #include "scull.h"        /* local definitions */
    
16. 
    
17. struct scull_pipe {
    
18.         wait_queue_head_t inq, outq; /* read and write queues */
    
19.         char *buffer, *end; /* begin of buf, end of buf */
    
20.         int buffersize; /* used in pointer arithmetic */
    
21.         char *rp, *wp; /* where to read, where to write */
    
22.         int nreaders, nwriters; /* number of openings for r/w */
    
23.         struct fasync_struct *async_queue; /* asynchronous readers */
    
24.         struct semaphore sem; /* mutual exclusion semaphore */
    
25.         struct cdev cdev; /* Char device structure */
    
26. };
    
27. 
    
28. /* parameters */
    
29. static int scull_p_nr_devs = SCULL_P_NR_DEVS;    /* number of pipe devices */
    
30. int scull_p_buffer = SCULL_P_BUFFER;    /* buffer size */
    
31. dev_t scull_p_devno;            /* Our first device number */
    
32. 
    
33. module_param(scull_p_nr_devs, int, 0);    /* FIXME check perms */
    
34. module_param(scull_p_buffer, int, 0);
    
35. 
    
36. static struct scull_pipe *scull_p_devices;
    
37. 
    
38. static int scull_p_fasync(int fd, struct file *filp, int mode);
    
39. static int spacefree(struct scull_pipe *dev);
    
40. /*
    
41.  * Open and close
    
42.  */
    
43. 
    
44. static int scull_p_open(struct inode *inode, struct file *filp)
    
45. {
    
46.     struct scull_pipe *dev;
    
47. 
    
48.     dev = container_of(inode->i_cdev, struct scull_pipe, cdev);
    
49.     filp->private_data = dev;
    
50. 
    
51.     if (down_interruptible(&dev->sem))
    
52.         return -ERESTARTSYS;
    
53.     if (!dev->buffer) {
    
54.         /* allocate the buffer */
    
55.         dev->buffer = kmalloc(scull_p_buffer, GFP_KERNEL);
    
56.         if (!dev->buffer) {
    
57.             up(&dev->sem);
    
58.             return -ENOMEM;
    
59.         }
    
60.     }
    
61.     dev->buffersize = scull_p_buffer;
    
62.     dev->end = dev->buffer + dev->buffersize;
    
63.     dev->rp = dev->wp = dev->buffer; /* rd and wr from the beginning */
    
64. 
    
65.     /* use f_mode,not f_flags: it's cleaner (fs/open.c tells why) */
    
66.     if (filp->f_mode & FMODE_READ)
    
67.         dev->nreaders++;
    
68.     if (filp->f_mode & FMODE_WRITE)
    
69.         dev->nwriters++;
    
70.     up(&dev->sem);
    
71. 
    
72.     return nonseekable_open(inode, filp);
    
73. }
    
74. 
    
75. 
    
76. 
    
77. static int scull_p_release(struct inode *inode, struct file *filp)
    
78. {
    
79.     struct scull_pipe *dev = filp->private_data;
    
80. 
    
81.     /* remove this filp from the asynchronously notified filp's */
    
82.     scull_p_fasync(-1, filp, 0);
    
83.     down(&dev->sem);
    
84.     if (filp->f_mode & FMODE_READ)
    
85.         dev->nreaders--;
    
86.     if (filp->f_mode & FMODE_WRITE)
    
87.         dev->nwriters--;
    
88.     if (dev->nreaders + dev->nwriters == 0) {
    
89.         kfree(dev->buffer);
    
90.         dev->buffer = NULL; /* the other fields are not checked on open */
    
91.     }
    
92.     up(&dev->sem);
    
93.     return 0;
    
94. }
95. 
    
96. /*
    
97.  * Data management: read and write
    
98.  */
99. static ssize_t scull_p_read (struct file *filp, char __user *buf, size_t count,
    
100.                 loff_t *f_pos)
     
101. {
     
102.     struct scull_pipe *dev = filp->private_data;
     
103. 
     
104.     if (down_interruptible(&dev->sem))
     
105.         return -ERESTARTSYS;
     
106. 
     
107.     while (dev->rp == dev->wp) { /* nothing to read */
     
108.         up(&dev->sem); /* release the lock */
     
109.         if (filp->f_flags & O_NONBLOCK)
     
110.             return -EAGAIN;
     
111.         PDEBUG("\"%s\" reading: going to sleep\n", current->comm);
     
112.         if (wait_event_interruptible(dev->inq, (dev->rp != dev->wp)))
     
113.             return -ERESTARTSYS; /* signal: tell the fs layer to handle it */
     
114.         /* otherwise loop, but first reacquire the lock */
     
115.         if (down_interruptible(&dev->sem))
     
116.             return -ERESTARTSYS;
     
117.     }
     
118.     /* ok, data is there, return something */
     
119.     if (dev->wp > dev->rp)
     
120.         count = min(count, (size_t)(dev->wp - dev->rp));
     
121.     else /* the write pointer has wrapped, return data up to dev->end */
     
122.         count = min(count, (size_t)(dev->end - dev->rp));
     
123.     if (copy_to_user(buf, dev->rp, count)) {
     
124.         up (&dev->sem);
     
125.         return -EFAULT;
     
126.     }
     
127.     dev->rp += count;
     
128.     if (dev->rp == dev->end)
     
129.         dev->rp = dev->buffer; /* wrapped */
     
130.     up (&dev->sem);
     
131. 
     
132.     /* finally, awake any writers and return */
     
133.     wake_up_interruptible(&dev->outq);
     
134.     PDEBUG("\"%s\" did read %li bytes\n",current->comm, (long)count);
     
135.     return count;
     
136. }
     
137. 
     
138. /* Wait for space for writing; caller must hold device semaphore. On
     
139.  * error the semaphore will be released before returning. */
     
140. static int scull_getwritespace(struct scull_pipe *dev, struct file *filp)
     
141. {
     
142.     while (spacefree(dev) == 0) { /* full */
     
143.         DEFINE_WAIT(wait);
     
144.         
     
145.         up(&dev->sem);
     
146.         if (filp->f_flags & O_NONBLOCK)
     
147.             return -EAGAIN;
     
148.         PDEBUG("\"%s\" writing: going to sleep\n",current->comm);
     
149.         prepare_to_wait(&dev->outq, &wait, TASK_INTERRUPTIBLE);
     
150.         if (spacefree(dev) == 0)
     
151.             schedule();
     
152.         finish_wait(&dev->outq, &wait);
     
153.         if (signal_pending(current))
     
154.             return -ERESTARTSYS; /* signal: tell the fs layer to handle it */
     
155.         if (down_interruptible(&dev->sem))
     
156.             return -ERESTARTSYS;
     
157.     }
     
158.     return 0;
     
159. }    
     
160. 
     
161. /* How much space is free? */
     
162. static int spacefree(struct scull_pipe *dev)
     
163. {
     
164.     if (dev->rp == dev->wp)
     
165.         return dev->buffersize - 1;
     
166.     return ((dev->rp + dev->buffersize - dev->wp) % dev->buffersize) - 1;
     
167. }
     
168. 
     
169. static ssize_t scull_p_write(struct file *filp, const char __user *buf, size_t count,
     
170.                 loff_t *f_pos)
     
171. {
     
172.     struct scull_pipe *dev = filp->private_data;
     
173.     int result;
     
174. 
     
175.     if (down_interruptible(&dev->sem))
     
176.         return -ERESTARTSYS;
     
177. 
     
178.     /* Make sure there's space to write */
     
179.     result = scull_getwritespace(dev, filp);
     
180.     if (result)
     
181.         return result; /* scull_getwritespace called up(&dev->sem) */
     
182. 
     
183.     /* ok, space is there, accept something */
     
184.     count = min(count, (size_t)spacefree(dev));
     
185.     if (dev->wp >= dev->rp)
     
186.         count = min(count, (size_t)(dev->end - dev->wp)); /* to end-of-buf */
     
187.     else /* the write pointer has wrapped, fill up to rp-1 */
     
188.         count = min(count, (size_t)(dev->rp - dev->wp - 1));
     
189.     PDEBUG("Going to accept %li bytes to %p from %p\n", (long)count, dev->wp, buf);
     
190.     if (copy_from_user(dev->wp, buf, count)) {
     
191.         up (&dev->sem);
     
192.         return -EFAULT;
     
193.     }
     
194.     dev->wp += count;
     
195.     if (dev->wp == dev->end)
     
196.         dev->wp = dev->buffer; /* wrapped */
     
197.     up(&dev->sem);
     
198. 
     
199.     /* finally, awake any reader */
     
200.     wake_up_interruptible(&dev->inq); /* blocked in read() and select() */
     
201. 
     
202.     /* and signal asynchronous readers, explained late in chapter 5 */
     
203.     if (dev->async_queue)
     
204.         kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
     
205.     PDEBUG("\"%s\" did write %li bytes\n",current->comm, (long)count);
     
206.     return count;
     
207. }
     
208. 
     
209. static unsigned int scull_p_poll(struct file *filp, poll_table *wait)
     
210. {
     
211.     struct scull_pipe *dev = filp->private_data;
     
212.     unsigned int mask = 0;
     
213. 
     
214.     /*
     
215.      * The buffer is circular; it is considered full
     
216.      * if "wp" is right behind "rp" and empty if the
     
217.      * two are equal.
     
218.      */
     
219.     down(&dev->sem);
     
220.     poll_wait(filp, &dev->inq, wait);
     
221.     poll_wait(filp, &dev->outq, wait);
     
222.     if (dev->rp != dev->wp)
     
223.         mask |= POLLIN | POLLRDNORM;    /* readable */
     
224.     if (spacefree(dev))
     
225.         mask |= POLLOUT | POLLWRNORM;    /* writable */
     
226.     up(&dev->sem);
     
227.     return mask;
     
228. }
     
229. 
     
230. static int scull_p_fasync(int fd, struct file *filp, int mode)
     
231. {
     
232.     struct scull_pipe *dev = filp->private_data;
233.     return fasync_helper(fd, filp, mode, &dev->async_queue);
     
234. }
     
235. 
     
236. /* FIXME this should use seq_file */
     
237. #ifdef SCULL_DEBUG
     
238. static void scullp_proc_offset(char *buf, char **start, off_t *offset, int *len)
     
239. {
     
240.     if (*offset == 0)
     
241.         return;
     
242.     if (*offset >= *len) {    /* Not there yet */
     
243.         *offset -= *len;
     
244.         *len = 0;
     
245.     }
     
246.     else {            /* We're into the interesting stuff now */
     
247.         *start = buf + *offset;
     
248.         *offset = 0;
     
249.     }
     
250. }
     
251. 
     
252. static int scull_read_p_mem(char *buf, char **start, off_t offset, int count,
     
253.         int *eof, void *data)
     
254. {
     
255.     int i, len;
     
256.     struct scull_pipe *p;
     
257. 
     
258. #define LIMIT (PAGE_SIZE-200)    /* don't print any more after this size */
     
259.     *start = buf;
     
260.     len = sprintf(buf, "Default buffersize is %i\n", scull_p_buffer);
     
261.     for(i = 0; i<scull_p_nr_devs && len <= LIMIT; i++) {
     
262.         p = &scull_p_devices[i];
     
263.         if (down_interruptible(&p->sem))
     
264.             return -ERESTARTSYS;
     
265.         len += sprintf(buf+len, "\nDevice %i: %p\n", i, p);
266.         len += sprintf(buf+len, " Buffer: %p to %p (%i bytes)\n", p->buffer, p->end, p->buffersize);
     
267.         len += sprintf(buf+len, " rp %p wp %p\n", p->rp, p->wp);
     
268.         len += sprintf(buf+len, " readers %i writers %i\n", p->nreaders, p->nwriters);
     
269.         up(&p->sem);
     
270.         scullp_proc_offset(buf, start, &offset, &len);
     
271.     }
     
272.     *eof = (len <= LIMIT);
     
273.     return len;
     
274. }
     
275. #endif
     
276. 
     
277. /*
     
278.  * The file operations for the pipe device
     
279.  * (some are overlayed with bare scull)
     
280.  */
     
281. struct file_operations scull_pipe_fops = {
     
282.     .owner =    THIS_MODULE,
     
283.     .llseek =    no_llseek,
     
284.     .read =        scull_p_read,
     
285.     .write =    scull_p_write,
     
286.     .poll =        scull_p_poll,
     
287.     .ioctl =    scull_ioctl,
     
288.     .open =        scull_p_open,
     
289.     .release =    scull_p_release,
     
290.     .fasync =    scull_p_fasync,
     
291. };
     
292. 
     
293. /*
     
294.  * Set up a cdev entry.
     
295.  */
     
296. static void scull_p_setup_cdev(struct scull_pipe *dev, int index)
     
297. {
     
298.     int err, devno = scull_p_devno + index;
     
299.     
     
300.     cdev_init(&dev->cdev, &scull_pipe_fops);
     
301.     dev->cdev.owner = THIS_MODULE;
     
302.     err = cdev_add (&dev->cdev, devno, 1);
     
303.     /* Fail gracefully if need be */
     
304.     if (err)
     
305.         printk(KERN_NOTICE "Error %d adding scullpipe%d", err, index);
     
306. }
     
307. 
     
308. /*
     
309.  * Initialize the pipe devs; return how many we did.
     
310.  */
     
311. int scull_p_init(dev_t firstdev)
     
312. {
     
313.     int i, result;
     
314. 
     
315.     result = register_chrdev_region(firstdev, scull_p_nr_devs, "scullp");
     
316.     if (result < 0) {
     
317.         printk(KERN_NOTICE "Unable to get scullp region, error %d\n", result);
     
318.         return 0;
     
319.     }
     
320.     scull_p_devno = firstdev;
     
321.     scull_p_devices = kmalloc(scull_p_nr_devs * sizeof(struct scull_pipe), GFP_KERNEL);
     
322.     if (scull_p_devices == NULL) {
     
323.         unregister_chrdev_region(firstdev, scull_p_nr_devs);
     
324.         return 0;
     
325.     }
     
326.     memset(scull_p_devices, 0, scull_p_nr_devs * sizeof(struct scull_pipe));
     
327.     for (i = 0; i < scull_p_nr_devs; i++) {
     
328.         init_waitqueue_head(&(scull_p_devices[i].inq));
     
329.         init_waitqueue_head(&(scull_p_devices[i].outq));
     
330.         init_MUTEX(&scull_p_devices[i].sem);
     
331.         scull_p_setup_cdev(scull_p_devices + i, i);
     
332.     }
     
333. #ifdef SCULL_DEBUG
     
334.     create_proc_read_entry("scullpipe", 0, NULL, scull_read_p_mem, NULL);
     
335. #endif
     
336.     return scull_p_nr_devs;
     
337. }
     
338. 
     
339. /*
     
340.  * This is called by cleanup_module or on failure.
     
341.  * It is required to never fail, even if nothing was initialized first
     
342.  */
     
343. void scull_p_cleanup(void)
     
344. {
     
345.     int i;
     
346. 
     
347. #ifdef SCULL_DEBUG
     
348.     remove_proc_entry("scullpipe", NULL);
     
349. #endif
     
350. 
     
351.     if (!scull_p_devices)
     
352.         return; /* nothing else to release */
     
353. 
     
354.     for (i = 0; i < scull_p_nr_devs; i++) {
     
355.         cdev_del(&scull_p_devices[i].cdev);
     
356.         kfree(scull_p_devices[i].buffer);
     
357.     }
     
358.     kfree(scull_p_devices);
     
359.     unregister_chrdev_region(scull_p_devno, scull_p_nr_devs);
     
360.     scull_p_devices = NULL; /* pedantic */
     
361. }

（1）讲一下函数fasync_helper:

int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)

一看就知道，前面的三个参数其实就是scull_p_fasync的三个参数，只要我们定义号的fasync_struct结构体也传进去就可以了。内核会完成我上面我們所说的事情。

（2）当设备可写时，调用函数kill_fasync发送信号SIGIO给内核。

讲解一下这个函数：

void kill_fasync(struct fasync_struct **fp, int sig, int band)

sig就是我们要发送的信号。

band(带宽)，一般都是使用POLL_IN，表示设备可读，如果设备可写，使用POLL_OUT

（3）当设备关闭时，需要将fasync_struct从异步队列中删除：
scull_p_fasync(-1, filp, 0);

删除也是调用scull_p_fasync，不过改了一下参数而已。

四、阻塞型IO、poll和异步通知的区别：

一个最重要的区别：

1）异步通知是不会造成阻塞的。

2）调用阻塞IO时如果条件不满足，会在驱动函数中的test_read或test_write中阻塞。

3）如果条件不满足，selcet会在系统调用中阻塞。

所谓的异步，就是进程可以在信号没到前干别的事情，等到信号到来了，进程就会被内核通知去做相应的信号操作。进程是不知道信号什么时候来的。

五，总结

今天只是讲了异步通知在内核中的实现，并且对应的应用函数和驱动函数需要做什么事情。最后总结了一下阻塞IO、poll和异步通知的区别。