Chinaunix首页 | 论坛 | 博客

chituhuan的ChinaUnix博客

首页　| 　博文目录　| 　关于我

chituhuan

  • 博客访问： 466764
  • 博文数量： 89
  • 博客积分： 1126
  • 博客等级： 少尉
  • 技术积分： 1432
  • 用 户 组： 普通用户
  • 注册时间： 2011-04-11 23:37
文章分类

全部博文（89）

文章存档

2016年（6）

2015年（2）

2014年（1）

2013年（3）

2012年（23）

2011年（54）

我的朋友
最近访客
推荐博文
相关博文
字符驱动学习四（异步通知 signal）

分类： LINUX

2011-07-02 17:47:35

    异步通知意思是：一旦设备就绪，则主动通知应用程序，这样应用程序不需要查询设备状态，类似硬件上的“中断”概念。准确的称谓是“信号驱动的异步I/O”.信号是在软件层次上对中断机制的一种模拟。
    在驱动框架中需要实现xxx_fasync函数，主要涉及一个结构体 struct fasync_struct 和fasync_helper kill_fasync 两个函数。这个结构体和两个函数的声明在include/linux/fs.h中。

  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. };
  1. /* SMP safe fasync helpers: */
  2. extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
  3. /* can be called from interrupts */
  4. extern void kill_fasync(struct fasync_struct **, int, int);
函数的实现是在：fs/fcntl.c: fasync_helper函数经常在字符设备中用来申请和删除异步队列。如果删除则 on= -1;在release函数中使用删除模式。
  1. /*
  2.  * fasync_helper() is used by almost all character device drivers
  3.  * to set up the fasync queue, and for regular files by the file
  4.  * lease code. It returns negative on error, 0 if it did no changes
  5.  * and positive if it added/deleted the entry.
  6.  */
  7. int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)
  8. {
  9.     if (!on)
  10.         return fasync_remove_entry(filp, fapp);
  11.     return fasync_add_entry(fd, filp, fapp);
  12. }

  14. EXPORT_SYMBOL(fasync_helper);
xxx_fasync的驱动基本构架是：
1. 在设备抽象的数据结构中增加一个struct fasync_struct的指针
  1. struct cfifo_t{
  2.     struct cdev cdev;
  3.     unsigned char mem[GLOBALMEM_SIZE];
  4.     struct semaphore sem;

  6.     unsigned int current_len;
  7.     wait_queue_head_t r_wait;
  8.     wait_queue_head_t w_wait;

  10.     struct fasync_struct *r_async_queue; /* 异步指针结构体指针 读*/
  11. };
2. 实现设备操作中的fasync函数，这个函数很简单，其主体就是调用内核的fasync_helper函数。

设备的fasync函数：
  1. static int cfifo_fasync(int fd, struct file *filp, int mode)
  2. {
  3.     struct cfifo_t *dev = filp->private_data;
  4.     return fasync_helper(fd, filp, mode, &dev->r_async_queue);
  5. }
3. 在需要向用户空间通知的地方(例如wrie方法中)调用内核的kill_fasync函数。
  1. static ssize_t cfifo_write(struct file *filp, const char __user *buf, size_t count, loff_t *fpos)
  2. {
  3.     int ret = 0;
  4.     struct cfifo_t *dev = filp->private_data;
  5.     DECLARE_WAITQUEUE(wait, current);

  7.     down(&dev->sem);
  8.     add_wait_queue(&dev->w_wait, &wait);

  10.     while(dev->current_len >= GLOBALMEM_SIZE){
  11.         if(filp->f_flags & O_NONBLOCK){
  12.             ret = -EAGAIN;
  13.             goto out;
  14.         }

  16.         __set_current_state(TASK_INTERRUPTIBLE); /* 进程状态，定义在 linux/sched.h */
  17.         up(&dev->sem); /* 释放信号量，避免死锁 */

  19.         schedule(); /* 调度其他进程运行*/
  20.         if(signal_pending(current)){
  21.             ret = -ERESTARTSYS;
  22.             goto out2;
  23.         }

  25.         down(&dev->sem);
  26.     }

  28.     if(count > GLOBALMEM_SIZE - dev->current_len)
  29.         count = GLOBALMEM_SIZE - dev->current_len;


  32.     if(copy_from_user(dev->mem+dev->current_len, buf, count)){
  33.         ret = - EFAULT;
  34.         goto out;
  35.     }
  36.     else{
  37.         dev->current_len += count;
  38.         *fpos = dev->current_len;
  39.         ret = count;

  41.         wake_up_interruptible(&dev->r_wait);
  42.         printk(KERN_INFO "write %s %d bites \n", buf, count);

  44.         /* 产生异步信号 */
  45.         if(NULL != dev->r_async_queue)
  46.             kill_fasync(&dev->r_async_queue, SIGIO, POLL_IN);
  47.     }

  49. out:
  50.     up(&dev->sem);
  51. out2:
  52.     remove_wait_queue(&dev->w_wait, &wait);
  53.     set_current_state(TASK_RUNNING);

  55.     return ret;
  56. }
4. 在驱动的release方法中调用前面定义的fasync函数
  1. static int cfifo_release(struct inode *inode, struct file *filp)
  2. {
  3.     cfifo_fasync(-1, filp, 0); /* 文件从异步通知队列中删除 */
  4.     filp->private_data = NULL;
  5.     return 0;
  6. }

测试程序：
  1. /**
  2.  * =====================================================================================
  3.  * Filename: cfifo_signal_test.c
  4.  * Description: 测试cfifo 驱动信号
  5.  *
  6.  * Created: 2011年07月02日 17时13分32秒
  7.  * Revision: none
  8.  * Compiler: gcc
  9.  *
  10.  * Author: wanghuan
  11.  * Company:
  12.  * =====================================================================================
  13.  */

  15. #include <stdio.h>
  16. #include <stdlib.h>
  17. #include <sys/types.h>
  18. #include <sys/stat.h>
  19. #include <fcntl.h>
  20. #include <unistd.h>
  21. #include <signal.h>

  23. void input_handler(int signum)
  24. {
  25.     printf("[%s %s %d] Sinnal Num = %d\n", __FUNCTION__, __FILE__, __LINE__, signum);
  26. }

  28. int main()
  29. {
  30.     int fd, oflags;
  31.     fd = open("/dev/cfifo0", O_RDWR, S_IRUSR| S_IRUSR);
  32.     if(fd != -1)
  33.     {
  34.         signal(SIGIO, input_handler);
  35.         fcntl(fd, F_SETOWN, getpid());
  36.         oflags = fcntl(fd, F_GETFL);
  37.         fcntl(fd, F_SETFL, oflags | FASYNC);
  38.         while(1)
  39.         {
  40.             sleep(100);
  41.         }
  42.     }
  43.     else
  44.         perror("open");

  46.     return 0;
  47. }
分析一下测试程序看signal工作的流程：
1.设置信号的处理函数。  signal(SIGIO, input_handler);
2.将当文件和进程号关联，确定信号发射对象。fcntl(fd, F_SETOWN, getpid());
3.设置当前的文件支持异步通知，这一步实际上就是调用驱动中的xxx_fasync 函数，使fasync_helper分配异步通知队列。
4.当向文件中写入数据时在wrtie方法中调到
  1.  if(NULL != dev->r_async_queue)
  2.             kill_fasync(&dev->r_async_queue, SIGIO, POLL_IN);
  3. 这样就会产生SIGIO信号。
完整的程序：
  1. /**
  2.  * =====================================================================================
  3.  * Filename: cfifo.c
  4.  * Description: 字符设备驱动模型 阻塞I/O
  5.  *
  6.  * Created: 2011年06月12日 17时19分50秒
  7.  * Revision: none
  8.  * Compiler: gcc
  9.  *
  10.  * Author: wanghuan,
  11.  * Company:
  12.  * =====================================================================================
  13.  */

  15. #include <linux/module.h>
  16. #include <linux/types.h>
  17. #include <linux/fs.h>         /* file_operation */
  18. #include <linux/errno.h>     /* Error number */
  19. #include <linux/mm.h>    
  20. #include <linux/sched.h>    
  21. #include <linux/slab.h>    
  22. #include <linux/init.h>     /* __init __exit */
  23. #include <linux/device.h>
  24. #include <linux/cdev.h>    
  25. #include <linux/poll.h>    
  26. #include <asm/io.h>    
  27. #include <asm/system.h>    
  28. #include <asm/uaccess.h>     /* copy_to_user, copy_from_user */
  29. #include <linux/kernel.h>     /* printk() */

  31. #define GLOBALMEM_SIZE 0x1000
  32. #define MEM_CLEAR 0x1
  33. #define DEV_NAME "cfifo"
  34. //#define MEM_CLEAR _IO(GLOBALMEM_SIZE, 0)


  37. static int MAJOR_NR = 255;        /* Driver Major Number */
  38. //static int MINOR_NR = 0;        /* Driver Major Number */

  40. struct cfifo_t{
  41.     struct cdev cdev;
  42.     unsigned char mem[GLOBALMEM_SIZE];
  43.     struct semaphore sem;

  45.     unsigned int current_len;
  46.     wait_queue_head_t r_wait;
  47.     wait_queue_head_t w_wait;

  49.     struct fasync_struct *r_async_queue; /* 异步指针结构体指针 读*/
  50.     struct fasync_struct *w_async_queue; /* 异步指针结构体指针 写*/
  51. };
  52. static struct cfifo_t *cfifo_p;

  54. static ssize_t cfifo_read(struct file *filp, char __user *buf, size_t count, loff_t *fpos)
  55. {
  56.     int ret = 0;
  57.     struct cfifo_t *dev = filp->private_data;
  58.     DECLARE_WAITQUEUE(wait, current);
  59.     
  60.     down(&dev->sem);
  61.     add_wait_queue(&dev->r_wait, &wait);

  63.     while(dev->current_len == 0){
  64.         if(filp->f_flags & O_NONBLOCK){
  65.             ret = -EAGAIN;
  66.             goto out;
  67.         }

  69.         __set_current_state(TASK_INTERRUPTIBLE);
  70.         up(&dev->sem);

  72.         schedule(); /*调度其他进程运行*/
  73.         if(signal_pending(current)){
  74.             ret = -ERESTARTSYS;
  75.             goto out2;
  76.         }

  78.         down(&dev->sem);
  79.     }

  81.     if(count > dev->current_len)
  82.         count = dev->current_len;

  84.     if(copy_to_user(buf, (void*)(dev->mem), count)){
  85.         ret = -EFAULT;
  86.         goto out;
  87.     } else{
  88.         memcpy(dev->mem, dev->mem + count, dev->current_len - count);
  89.         dev->current_len -= count;
  90.         *fpos =dev->current_len;

  92.         wake_up_interruptible(&dev->w_wait);
  93.         ret =count;

  95.         printk(KERN_INFO "read %s %d bites \n", buf, count);
  96.     }

  98. out:
  99.     up(&dev->sem);
  100. out2:
  101.     remove_wait_queue(&dev->r_wait, &wait);
  102.     set_current_state(TASK_RUNNING);

  104.     return ret;
  105. }

  107. static ssize_t cfifo_write(struct file *filp, const char __user *buf, size_t count, loff_t *fpos)
  108. {
  109.     int ret = 0;
  110.     struct cfifo_t *dev = filp->private_data;
  111.     DECLARE_WAITQUEUE(wait, current);

  113.     down(&dev->sem);
  114.     add_wait_queue(&dev->w_wait, &wait);

  116.     while(dev->current_len >= GLOBALMEM_SIZE){
  117.         if(filp->f_flags & O_NONBLOCK){
  118.             ret = -EAGAIN;
  119.             goto out;
  120.         }

  122.         __set_current_state(TASK_INTERRUPTIBLE); /* 进程状态，定义在 linux/sched.h */
  123.         up(&dev->sem); /* 释放信号量，避免死锁 */

  125.         schedule(); /* 调度其他进程运行*/
  126.         if(signal_pending(current)){
  127.             ret = -ERESTARTSYS;
  128.             goto out2;
  129.         }

  131.         down(&dev->sem);
  132.     }

  134.     if(count > GLOBALMEM_SIZE - dev->current_len)
  135.         count = GLOBALMEM_SIZE - dev->current_len;


  138.     if(copy_from_user(dev->mem+dev->current_len, buf, count)){
  139.         ret = - EFAULT;
  140.         goto out;
  141.     }
  142.     else{
  143.         dev->current_len += count;
  144.         *fpos = dev->current_len;
  145.         ret = count;

  147.         wake_up_interruptible(&dev->r_wait);
  148.         printk(KERN_INFO "write %s %d bites \n", buf, count);

  150.         /* 产生异步信号 */
  151.         if(NULL != dev->r_async_queue)
  152.             kill_fasync(&dev->r_async_queue, SIGIO, POLL_IN);
  153.     }

  155. out:
  156.     up(&dev->sem);
  157. out2:
  158.     remove_wait_queue(&dev->w_wait, &wait);
  159.     set_current_state(TASK_RUNNING);

  161.     return ret;
  162. }

  164. static loff_t cfifo_llseek(struct file *filp, loff_t offset, int orig)
  165. {
  166.     loff_t ret;
  167.     switch(orig){
  168.         case 0:
  169.             if(offset < 0){
  170.                 ret = -EFAULT;
  171.                 break;
  172.             }
  173.             if((unsigned int)offset > GLOBALMEM_SIZE){
  174.                 ret = -EFAULT;
  175.                 break;
  176.             }

  178.             filp->f_pos = (unsigned int)offset;
  179.             ret = filp->f_pos;
  180.             break;
  181.         case 1:
  182.             if(filp->f_pos + offset > GLOBALMEM_SIZE){
  183.                 ret = -EFAULT;
  184.                 break;
  185.             }

  187.             if(filp->f_pos + offset < 0){
  188.                 ret = -EFAULT;
  189.                 break;
  190.             }

  192.             filp->f_pos += offset;
  193.             ret = filp->f_pos;
  194.             break;
  195.         default:
  196.             ret = -EFAULT;
  197.     }
  198.     return ret;
  199. }

  201. static int cfifo_ioctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
  202. {
  203.     struct cfifo_t *dev = filp->private_data;
  204.     switch(cmd){
  205.         case MEM_CLEAR:
  206.             if(down_interruptible(&dev->sem))
  207.                 return -ERESTARTSYS;

  209.             memset(dev->mem, 0, GLOBALMEM_SIZE);
  210.             dev->current_len = 0;
  211.             filp->f_pos = 0;

  213.             up(&dev->sem);
  214.             printk(KERN_INFO "globalmem is set to zero \n");
  215.             break;
  216.         default:
  217.             return -EINVAL;
  218.     }

  220.     return 0;
  221. }

  223. static unsigned int cfifo_poll(struct file *file, poll_table *wait)
  224. {
  225.     unsigned int mask = 0;
  226.     struct cfifo_t *dev = file->private_data;

  228.     down(&dev->sem);
  229.     poll_wait(file, &dev->r_wait, wait);
  230.     poll_wait(file, &dev->w_wait, wait);

  232.     if(dev->current_len != 0)
  233.         mask |= POLLIN | POLLRDNORM;

  235.     if(dev->current_len != GLOBALMEM_SIZE)
  236.         mask |= POLLOUT | POLLWRNORM;

  238.     up(&dev->sem);
  239.     return mask;
  240. }

  242. static int cfifo_fasync(int fd, struct file *filp, int mode)
  243. {
  244.     struct cfifo_t *dev = filp->private_data;
  245.     return fasync_helper(fd, filp, mode, &dev->r_async_queue);
  246. }

  248. static int cfifo_open(struct inode *inode, struct file *filp)
  249. {
  250.     struct cfifo_t *dev;
  251.     dev = container_of(inode->i_cdev, struct cfifo_t, cdev);
  252.     filp->private_data = dev;
  253.     return 0;
  254. }

  256. static int cfifo_release(struct inode *inode, struct file *filp)
  257. {
  258.     cfifo_fasync(-1, filp, 0); /* 文件从异步通知队列中删除 */
  259.     filp->private_data = NULL;
  260.     return 0;
  261. }

  263. static const struct file_operations cfifo_fops = {
  264.     .owner = THIS_MODULE,
  265.     .open = cfifo_open,
  266.     .release = cfifo_release,
  267.     .read = cfifo_read,
  268.     .write = cfifo_write,
  269.     .ioctl = cfifo_ioctl,
  270.     .llseek = cfifo_llseek,
  271.     .poll = cfifo_poll,
  272.     .fasync = cfifo_fasync,
  273. };

  275. static void cfifo_setup_cdev(struct cfifo_t *cfifo_cdev, int minor)
  276. {
  277.     int err;
  278.     dev_t devno = MKDEV(MAJOR_NR, minor);
  279.     
  280.     cdev_init(&cfifo_cdev->cdev, &cfifo_fops);
  281.     cfifo_p->cdev.owner = THIS_MODULE;
  282.     err = cdev_add(&cfifo_cdev->cdev, devno, 1);
  283.     if(err != 0)
  284.         printk(KERN_NOTICE "Error %d adding gmen", err);

  286.     cfifo_cdev->current_len = 0;
  287.     init_MUTEX(&cfifo_cdev->sem);
  288.     init_waitqueue_head(&cfifo_cdev->r_wait);
  289.     init_waitqueue_head(&cfifo_cdev->w_wait);
  290. }

  292. static struct class *cdev_class;
  293. static int __init cfifo_cdev_init(void)
  294. {
  295.     int result;
  296.     dev_t devno = MKDEV(MAJOR_NR, 0);

  298.     if(0 != MAJOR_NR){
  299.         result = register_chrdev_region(devno, 1, DEV_NAME); //注册设备 支持两个设备，此设备号从0开始
  300.     } else {
  301.         result = alloc_chrdev_region(&devno, 0, 1, DEV_NAME);
  302.         MAJOR_NR = MAJOR(devno);
  303.     }

  305.     printk(KERN_CRIT"hello cfifo\n");
  306.     if(result < 0)
  307.         return result;

  309.     cfifo_p = kmalloc(2*sizeof(struct cfifo_t), GFP_KERNEL);
  310.     if(NULL == cfifo_p){
  311.         unregister_chrdev_region(MKDEV(MAJOR_NR, 0), 1);
  312.         result = -ENOMEM;
  313.     }

  315.     memset(cfifo_p, 0, 1*sizeof(struct cfifo_t));
  316.     cfifo_setup_cdev(&cfifo_p[0], 0);
  317.     cfifo_setup_cdev(&cfifo_p[0], 1);

  319.     cdev_class = class_create(THIS_MODULE, DEV_NAME);
  320.     if(IS_ERR(cdev_class))
  321.         return PTR_ERR(cdev_class);

  323.     device_create(cdev_class, NULL, MKDEV(MAJOR_NR, 0),    NULL, DEV_NAME"%d", 0);
  324.     device_create(cdev_class, NULL, MKDEV(MAJOR_NR, 1),    NULL, DEV_NAME"%d", 1);
  325.     return 0;
  326. }

  328. void cfifo_cdev_exit(void)
  329. {
  330.     cdev_del(&cfifo_p[0].cdev);
  331.     cdev_del(&cfifo_p[0].cdev);

  333.     device_destroy(cdev_class, MKDEV(MAJOR_NR, 0)); //delete device node under /dev
  334.     device_destroy(cdev_class, MKDEV(MAJOR_NR, 1)); //delete device node under /dev
  335.     class_destroy(cdev_class); //delete class created by us

  337.     kfree(cfifo_p);
  338.     unregister_chrdev_region(MKDEV(MAJOR_NR, 0), 1); //由于注册了两个设备，最后一个参数为 2
  339. }

  341. module_init(cfifo_cdev_init);
  342. module_exit(cfifo_cdev_exit);
  343. MODULE_LICENSE("GPL");
  344. MODULE_AUTHOR("wanghuan");
阅读(1502) | 评论(0) | 转发(1) |
0

上一篇：使用Bash Shell快捷键

下一篇：Android源码编译整理总结

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6