Chinaunix首页 | 论坛 | 博客
  • 博客访问: 6394
  • 博文数量: 8
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 26
  • 用 户 组: 普通用户
  • 注册时间: 2016-08-15 14:41
  • 认证徽章:
个人简介

不想征服Unix的菜鸟不是好菜鸟

文章分类

全部博文(8)

文章存档

2018年(1)

2017年(7)

我的朋友
最近访客

分类: LINUX

2017-09-08 14:27:33

前面已经说了阻塞非阻塞的访问方式,这里我们就继续说下异步通知的机制。

什么是异步通知呢?异步通知的意思就是,一旦设备就绪,则主动通知应用程序,应用程序 根本就不需要查询设备状态,类似于中断的概念,一个进程收到一个信号与处理器收到一个中断请求可以说是一样的。信号是异步的,一个进程不必通过任何操作来 等待信号的到达。下面我们就看一下在linux中机制的实现方式。

在linux中,异步通知是使用信号来实现的,而在linux,大概有30种信号,比如大家熟悉的ctrl+c的SIGINT信号,进程能够忽略或者捕获除过SIGSTOP和SIGKILL的全部信号,当信号背捕获以后,有相应的函数来处理它。

在linux中,使用signal()函数来捕获信号,它的函数运行如下:

  1. #include   
  2.   
  3. typedef void (*sighandler_t)(int);  
  4.   
  5. sighandler_t signal(int signum, sighandler_t handler);  
第 一个参数就是指定的信号的值,而第二个参数便是此信号的信号处理函数,当为SIG_IGN,表示信号被忽略,当为SIG_DFL时,表示采用系统的默认方 式来处理该信号。当然,信号处理函数也可以自己定义。当signal()调用成功后,返回处理函数handler值,调用失败后返回SIG_ERR。下面 的函数就是当ctrl+c发生以后,进程捕获别且指定处理函数:
  1. signal(SIGINT,sigterm_handler);  
这里面SIGINT便是接受的信号,而sigterm_handler就是针对此信号的处理函数,当然处理函数可以自己定义。

下面我们来看一个异步通知的实例:

  1. #include  
  2. #include  
  3. #include  
  4. #include  
  5. #include  
  6. #include  
  7. #define MAX_LEN 100  
  8.   
  9. void input_handler(int num)  
  10. {  
  11.     char data[MAX_LEN];  
  12.     int len;  
  13.   
  14.     len=read(STDIN_FILENO,&data,MAX_LEN);  
  15.     data[len]=0;  
  16.     printf("input available:%s\n",data);  
  17. }  
  18.   
  19. main()  
  20. {  
  21.     int oflags;  
  22.       
  23.     signal(SIGIO,input_handler);  
  24.     fcntl(STDIN_FILENO,F_SETOWN,getpid());  
  25.     oflags=fcntl(STDIN_FILENO,F_GETFL);  
  26.     fcntl(STDIN_FILENO,F_SETFL,oflags|FASYNC);  
  27.   
  28.     while(1);  
  29. }  
首 先这里面将要进行捕获的信号是SIGIO信号,这里面通过signal()对标准输入文本描述符STDIN_FILENO启动异步信号机制。当用户进行输 入以后,进程将捕获到SIGIO信号,然后调用处理函数input_handler()进行处理,当然这个函数是自己定义的。而 fcntl(STDIN_FILENO,F_SETOWN,getpid())设置进程为STDIN_FILENO文件的拥有者,这一步其实是将该信号与 进程进行绑定,下面oflags=fcntl(STDIN_FILENO,F_GETFL)和 fcntl(STDIN_FILENO,F_SETFL,oflags|FASYNC)是启动异步机制,对设备设置FASYNC标志,程序执行后效果如 下:
  1. wanchres@wanchres-desktop:~/Linux/test/c code$ ./signal_test   
  2. wanchres  
  3. input available:wanchres  
当输入一串字符以后,标准输入设备释放SIGIO信号,然后这个信号驱使对应的应用程序中的处理函数得以执行,将输入显示出来。上面的例子很好的说明了一个在用户空间中处理一个释放信号的具体的过程。

而在驱动程序和应用程序的异步通知的交互中,这种仅仅在应用程序端的,因为信号的源头在设备驱动端。因此,应该再合适的时候让设备驱动释放信号,其相关的步骤如下:

1、支持F_SETOWN命令,能在这个控制命令处理中设置filp->f_owner为对应进程ID,此工作已由内核完成。

2、支持F_SETFL命令的处理,每当FASYNC标志改变时,驱动中的fasync()函数将得以执行,所以驱动中应实现fasync()函数。

3、在设备资源可获得时,调用kill_fasync()函数激发相应的信号。

设备驱动中异步通知的编程实现中,主要用到一个结构体fasync_struct,其定义为:

  1. struct fasync_struct {  
  2.                int     magic;  
  3.                int     fa_fd;  
  4.                struct  fasync_struct   *fa_next; /* singly linked list */  
  5.                struct  file            *fa_file;             
  6. };  
fa_file即进程打开设备文件时创建的file结构file.owner即为进程的pid。

处理FASYNC标志变更的函数:

  1. int fasync_helper(int fd, struct file * filp, int on, struct fasync_struct **fapp)  
释放信号的函数:
  1. void kill_fasync(struct fasync_struct **fp, int sig, int band)  
下面我们来看下支持异步通知的模板。

设备结构体:

  1. struct xxx_dev{  
  2.         struct cdev cdev;  
  3.     ......  
  4.     struct fasync_struct *async_queue;  
  5. };  
fasync()函数:
  1. static int xxx_fasync(int fd,struct file *filp,int mode)  
  2. {  
  3.     struct xxx_dev *dev = filp->private_data;  
  4.     return fasync_helper(fd,filp,mode,&dev->async_queue);  
  5. }  
在设备资源可以获得时,应该调用kill_fasync()释放SIGIO信号,可读时第三个参数是POLL_IN,可写时为POLL_OUT.
  1. static ssize_t xxx_write(struct file *filp,const char __user *buf,size_t count,loff_t *ppos)  
  2. {  
  3.     struct xxx_dev *dev = filp->private_data;  
  4.     ......  
  5.     if(dev->async_queue)  
  6.         kill_fasync(&dev->async_queue,SIGIO,POLL_IN);  
  7.         ......  
  8. }  
在release函数中,应调用fasync()函数将文件从异步通知的列表中删除。
  1. int xxx_release(struct inode *inode,struct file *filp)  
  2. {  
  3.     xxx_fasync(-1,filp,0);  
  4.     return 0;  
  5. }  
上面是异步通知在设备驱动中的模板,下面我们来看看在globalmem中添加异步通知后各模块的代码:
  1. struct globalmem_dev{  
  2.         struct cdev cdev;  
  3.     unsigned int current_len;  
  4.         unsigned char mem[GLOBALMEM_SIZE];  
  5.     struct semaphore sem;  
  6.     wait_queue_head_t r_wait;  
  7.     wait_queue_head_t w_wait;  
  8.     struct fasync_struct *async_queue;  
  9. };  

  1. static int globalmem_fasync(int fd,struct file *filp,int mode)  
  2. {  
  3.     struct globalmem_dev *dev = filp->private_data;  
  4.     return fasync_helper(fd,filp,mode,&dev->async_queue);  
  5. }  

  1. static ssize_t globalmem_write(struct file *filp,const char __user *buf,size_t count,loff_t *ppos)  
  2. {  
  3.     unsigned long p = *ppos;  
  4.     int ret = 0;  
  5.     struct globalmem_dev *dev = filp->private_data;  
  6.     DECLARE_WAITQUEUE(wait,current);      
  7.       
  8.     down(&dev->sem);  
  9.     add_wait_queue(&dev->w_wait,&wait);  
  10.   
  11.     while(dev->current_len==GLOBALMEM_SIZE){  
  12.         if(filp->f_flags & O_NONBLOCK){  
  13.             ret = -EAGAIN;  
  14.             goto out;         
  15.         }  
  16.         __set_current_state(TASK_INTERRUPTIBLE);  
  17.         up(&dev->sem);  
  18.   
  19.         schedule();  
  20.         if(signal_pending(current)){  
  21.             ret = -ERESTARTSYS;  
  22.             goto out2;    
  23.         }     
  24.           
  25.         down(&dev->sem);  
  26.     }  
  27.       
  28.     if(count > GLOBALMEM_SIZE-dev->current_len)  
  29.         count = GLOBALMEM_SIZE-dev->current_len;  
  30.     if(copy_from_user(dev->mem+dev->current_len,buf,count)){  
  31.         ret = -EFAULT;  
  32.         goto out;     
  33.     }else{  
  34.         dev->current_len += count;  
  35.         printk(KERN_INFO "written %d bytes(s),current_len:%d\n",count,dev->current_len);  
  36.   
  37.         wake_up_interruptible(&dev->r_wait);  
  38.           
  39.         if(dev->async_queue)  
  40.             kill_fasync(&dev->async_queue,SIGIO,POLL_IN);  
  41.   
  42.         ret = count;              
  43.     }  
  44.     out:up(&dev->sem);  
  45.     out2:remove_wait_queue(&dev->w_wait,&wait);  
  46.     set_current_state(TASK_RUNNING);  
  47.     return ret;  
  48. }  

  1. int globalmem_release(struct inode *inode,struct file *filp)  
  2. {  
  3.     globalmem_fasync(-1,filp,0);  
  4.     return 0;  
  5. }  

代码写好以后,我们还需编写一个在用户空间验证globalmem异步通知的程序,程序的功能是接收到globalmem发出的信号后输出信号值,代码如下:
  1. #include  
  2. #include  
  3. #include  
  4. #include  
  5. #include  
  6. #include  
  7.   
  8. void input_handler(int signum)  
  9. {  
  10.     printf("receive a signal from globalmem,signalnum:%d\n",signum);  
  11. }  
  12.   
  13. main()  
  14. {  
  15.     int fd,oflags;  
  16.     fd = open("/dev/globalmem_sync",O_RDWR,S_IRUSR|S_IWUSR);  
  17.     if(fd != -1){  
  18.         signal(SIGIO,input_handler);  
  19.         fcntl(fd,F_SETOWN,getpid());  
  20.         oflags = fcntl(fd,F_GETFL);  
  21.         fcntl(fd,F_SETFL,oflags|FASYNC);  
  22.         while(1){  
  23.             sleep(100);  
  24.         }  
  25.     }else{  
  26.         printf("device open failure\n");  
  27.     }  
  28. }  
将 驱动的内核模块make完成后,将其插入,然后编译用户程序,采用前面介绍过的加载新的设备驱动别且创建设备文件节点(mknod /dev/globalmem),最后再echo向/dev/globalmenm写入新的数据,例如:echo wanchres > /dev/globalmem。
阅读(147) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~
评论热议
请登录后评论。

登录 注册