Chinaunix首页 | 论坛 | 博客
  • 博客访问: 1349050
  • 博文数量: 201
  • 博客积分: 1450
  • 博客等级: 上尉
  • 技术积分: 2235
  • 用 户 组: 普通用户
  • 注册时间: 2008-09-11 11:38
个人简介

学习永无止境!!

文章分类

全部博文(201)

文章存档

2019年(3)

2018年(8)

2017年(32)

2016年(7)

2015年(13)

2014年(44)

2013年(24)

2011年(6)

2010年(17)

2009年(46)

2008年(1)

分类: 嵌入式

2015-01-07 15:48:08

异步通知:

使用异步通知机制可以提高查询设备的效率。通过使用异步通知,应用程序可以在数据可用时收到一个信号,而无需不停地轮询。

设置异步通知的步骤(针对应用层来说的):

1.首先制定一个进程作为文件的属主。通过使用fcntl系统调用执行F_SETOWN命令时,属主进程的ID号就会保存在filp->f_owner中,目的是为了让内核知道应该通知哪个进程。

2.在设备中设置FASYNC标志。通过fcntl调用的F_SETFL来完成。

设置晚以上两步后,输入文件就可以在新数据到达时请求发送一个SIGIO信号,该信号被发送到存放在filp->f_owner中的进程。

实例:启用stdin输入文件到当前进程的异步通知机制

 signal(SIGIO,&input_handler);

 fcntl(STDIN_FILENO,F_SETOWN,getpid());//设置STDIN_FILENO的属主为当前进程

 oflags=fcntl(STDIN_FILENO,F_GETFL);//获得STDIN_FILENO的描述符

fcntl(STDIN_FILENO,F_SETFL,oflags|FASYNC);//从新设置描述符

注意的问题:

1.应用程序通常只假设套接字和终端具备异步通知功能。

2.当进程受到SIGIO信号时,它并不知道哪个输入文件有了新的输入。如果有多于一个文件可以异步通知输入的进程,则应用程序必须借助于poll或select来确定输入的来源。

 

驱动程序的实现:

1、F_SETOWN被调用时对filp->f_owner赋值。

2.在执行F_SETFL启用FASYNC时,调用驱动程序的fasync方法。只要filp->f_owner中的FASYNC标志发生了变化,就会调用该方法,以便把这个变化通知驱动程序,使其正确响应。文件打开时,默认fasync标志是被清除的。

3.当数据到达时,所有注册为异步通知的进程都会收到一个SIGIO信号。

 

linux 这种调用方法基于一个数据结构和两个函数,对于驱动开发而言主要关注两个函数,内核会自己维护该数据结构,为驱动程序服务(书上对该数据结构也并未给出多少解释)。包含在头文件中。

 

struct fasync_struct {
    int    magic;
    int    fa_fd;
    struct    fasync_struct    *fa_next; /* singly linked list */
    struct    file         *fa_file;
};

两个函数如下:

int fasnyc_helper(int fd,struct file *filp,int mode,struct fasync_struct **fa);

void kill_fasync(struct fasync_struct **fa,int sig,int band);

当一个打开的文件的FASYNC标志被修改时,调用fasync_helper以便从相关的进程列表中增加或删除文件。当数据到达时,可使用kill_fasync通知所有的相关进程。它的参数是要发送的信号(sig)和带宽(band)。

注意的地方:1.对于struct fasync_struct这个数据结构在编写驱动时并不需要特别关注,它会由内核来维护,驱动程序中调用它即可。如同poll的底层实现上poll_table这个内存页链表也是由内核来维护,驱动程序使用它即可。

2.对于用来通知可读的异步通知:band几乎总是为poll_in

对于用来通知可写的异步通知:band几乎总是为poll_out

3.wait_enevt_interruptible(dev->inq,(dev->rp != dev->wp));

wake_up_interruptible(&dev->inq);

在使进程休眠的时候使用的是值传递,但在唤醒进程的时候使用的指针传递。

实现:

static int scull_p_fasync(int fd,struct file *filp,int mode)

{

   struct scull_pipe *dev = filp->private;

   fasync_helper(fd,filp,mod,&dev->async_queue);

}

 

 

接着当数据到达时,必须执行下面的语句来通知异步读取进程。由于提供scullpipe的读取进程的新数据是在某个进程调用wirte产生的,所以这条语句在scullpipe的write方法中实现:

if(dev->async_queue)

      kill_fasync(&dev->async_queue,SIGIO,POLL_IN);

 

最后注意在文件关闭之前,必须调用fasync方法,以便从活动的异步读取进程列表中删除文件。

scull_p_fasync(-1,filp,0);

下面是自己敲了一下scull_pipe的程序,顺便对前边学的复习一下:

#include

#include

#include

 

#include

#include

#include

#include

#include

#include

#include

#include

#include

#include

 

#include  //包含一些局部变量

 

int scull_major = SCULL_MAJOR;

int scull_minor = 0;

int scull_p_nr_devs = SCULL_P_NR_DEVS;

int scull_p_buffer = SCULL_P_BUFFER;

 

module_param(scull_major,int,S_IRUGO);

module_param(scull_minor,int,S_IRUGO);

module_param(scull_p_nr_devs,int,0);

module_param(scull_p_buffer,int,0);

 

struct scull_pipe {

     wait_queue_head_t  inq,outq;  //定义读写等待队列

     char *buffer,*end;  //缓冲区开始和结束指针

     int buffersize;

     char *rp,*wp;  //当前的读写位置

     int nreaders,nwriters; //读写者计数

     sttuct fasync_struct *asynv_queue;

     struct semphore sem;

     struct cdev cdev;

};

 

dev_t scull_devno;

static struct scull_pipe *scull_p_devices;

 

static int scull_p_fasync(int fd,struct file *filp,int mode);

static int spacefree(struct scull_pipe *dev);

 

static int scull_p_open(struct inode *inode,struct file *filp)

{

   struct scull_pipe *dev;

   dev = container_of(inode->i_cdev,struct scull_pipe,cdev);

   filp->private_data = dev;

 

   if(down_interuptible(&dev->sem))

        return -ERESTARTSYS;

   if(!dev->buffer){

        dev->buffer = kmalloc(scull_p_buffer,GFP_KERNEL);

        if(!dev->buffer){

              up(&dev->sem);

              return -ENOMEM;

         }

   }

   dev->buffersize = scull_p_buffersize;

   dev->end = scull_p_buffer + scull_p_buffersize;

   dev->rp = dev->wp = dev->buffer;

 

   if(filp->f_mode & FMODE_READ)

         dev->nreaders++;

   if(filp->f_mode & FMODE_WRITE)

         dev->nwriters++;

 

   up(&dev->sem);

   return nonseekable_open(inode,filp);

}

 

static int scull_p_release(struct inode *inode,struct file *filp)

{

   struct scull_pipe *dev = filp->private_data;

   scull_p_fasync(-1,filp,0);

   down_interruptible(&dev->sem);

   if(filp->f_mode & FMODE_READ)

         dev->nreaders--;

   if(filp->f_mode & FMODE_WRITE)

         dev->nwriters--;

   if(dev->nreaders + dev->nwriters == 0){

          kfree(dev->buffer);

          dev->buffer =NULL;

   }

    up(&dev->sem);

    return 0;

}

 

static scull_p_read(struct file *filp,char __user *buf,size_t count,loof_t *f_pos)

{

   struct scull_pipe *dev = filp->private_data;

 

   if(down_interruptible(&dev->sem))

        renturn -ERESTARTSYS;

 

    while(dev->rp == dev->wp){

        up(&dev->sem);

        if(filp->f_flags & O_NONBLOCK)

               return -EAGAIN;

        PDEBUG(....);

        if(wait_event_intertuptible(dev->inq,(dev->rp != dev->wp)))

               return -ERESTARTSYS;

        if(down_interruptible(&dev->sem))

               return -ERESTARTSYS;

     }

 

     ....

   if(copy_to_user(buf,dev->rp,count){

            up(&dev->sem);

            return -EFAULT;

   }

   dev->rp += count;

   if(dev->rp == dev->end)

             dev->rp = dev->end;

 

   up(&dev->sem);

 

   wake_up_interrputible(&dev->outq); //在读走数据以后,唤醒写等待队列

   return count;

}

 

static int scull_p_ioctl(struct inode *inode,struct file *filp,unsigned int cmd,unsigned long arg)

{

     int err = 0;

 

     if(_IOC_TYPE(cmd) != SCULL_IOC_MAGIC)  return -ENOTTY;

     if(_IOC_NR(cmd)     > SCULL_IOC_MAXNR)  return -ENOTTY;

 

     if(_IOC_DIR(cmd) & _IOC_READ)

            err = !access_ok(VERIFY_WRITE,(void __user *)arg,_IOC_SIZE(cmd));

     else if(_IOC_DIR(cmd) & _IOC_WRITE)

             err = !access_ok(VERIFY_READ,(void __user *)arg,_IOC_SIZE(cmd)):

     if(err)  return -EFAULT;

 这里的access_ok函数,成功返回1,失败返回零。上述代码完成了对cmd的检查确保其唯一性,access_ok是面向内核的 ,所以传输方向与其刚好相反。

      switch(cmd){

           case SCULL_P_IOCTSIZE:               //分别是在头文件中定义的宏命令

                     scull_p_buffer = arg;

                     break;

 

           case SCULL_P_IOCQSIZE:

                     return scull_p_buffer;

 

          default:  /* redundant, as cmd was checked against MAXNR */       

                     return -ENOTTY;

      }

      return 0;

}

 

 

static int scull_getwritespace(struct scull_pipe *dev, struct file *filp)

       while (spacefree(dev) == 0) { /* full */

                DEFINE_WAIT(wait);   设置等待队列入口

                up(&dev->sem);

                if (filp->f_flags & O_NONBLOCK)

                       return -EAGAIN;

                PDEBUG("/"%s/" writing: going to sleep/n",current->comm);

                prepare_to_wait(&dev->outq, &wait, TASK_INTERRUPTIBLE); //将dev->outq加入到等待队列,并设置其为可中断状态。

                if (spacefree(dev) == 0)  //这个检查狠重要,确保仍需要休眠

                      schedule();

                finish_wait(&dev->outq, &wait);//schedule()晚以后,马上调用finish_wait

                if (signal_pending(current))

                       return -ERESTARTSYS; /* signal: tell the fs layer to handle it */

                if (down_interruptible(&dev->sem))

                      return -ERESTARTSYS;

       }

       return 0;

}

这里结合scull代码分析下异步通知实现的过程:

异步机制在应用层设计FASYNC标志的置位,驱动层涉及到一个数据结构和两个函数的调用,首先来看驱动层,在scull的驱动代码中用scull_p_fasync函数实现了对fasync_helper的调用,如下:


static int scull_p_fasync(int fd, struct file *filp, int mode)

{

     struct scull_pipe *dev = filp->private_data;

 

     return fasync_helper(fd, filp, mode, &dev->async_queue);

}

在scull_p_write函数中实现了对kill_fasync的调用,如下:


static ssize_t scull_p_write(struct file *filp, const char __user *buf, size_t count,loff_t *f_pos)

{

     struct scull_pipe *dev = filp->private_data;

     int result;

 

     if (down_interruptible(&dev->sem))

           return -ERESTARTSYS;

 

    /* Make sure there's space to write */

    result = scull_getwritespace(dev, filp);

    if (result)

          return result; /* scull_getwritespace called up(&dev->sem) */

 

    /* ok, space is there, accept something */

    count = min(count, (size_t)spacefree(dev));

    if (dev->wp >= dev->rp)

         count = min(count, (size_t)(dev->end - dev->wp)); /* to end-of-buf */

    else                       /* the write pointer has wrapped, fill up to rp-1 */

         count = min(count, (size_t)(dev->rp - dev->wp - 1));

    PDEBUG("Going to accept %li bytes to %p from %p/n", (long)count, dev->wp, buf);

    if (copy_from_user(dev->wp, buf, count)) {

         up (&dev->sem);

         return -EFAULT;

    }

    dev->wp += count;

    if (dev->wp == dev->end)

           dev->wp = dev->buffer;       /* wrapped */

    up(&dev->sem);

 

     /* finally, awake any reader */

     wake_up_interruptible(&dev->inq);  /* blocked in read() and select() */

 

     /* and signal asynchronous readers, explained late in chapter 5 */

     if (dev->async_queue)

             kill_fasync(&dev->async_queue, SIGIO, POLL_IN);

     PDEBUG("/"%s/" did write %li bytes/n",current->comm, (long)count);

     return count;

}



 

在程序的最后调用了kill_fasync,在调用kill_fasync后会向文件的属主进程发送SIGIO信号,从而在驱动层完成了异步机制的设置。下面来看应用程序:


#include

#include

#include

#include

#include

#include

 

int gotdata=0;

void sighandler(int signo)

{

    if (signo==SIGIO)

        gotdata++;

    return;

}

 

char buffer[21];

 

int main(int argc, char **argv)

{

int pipetest0;

    int count;

    struct sigaction action;

 

if ((pipetest0 = open("/dev/scullpipe0",O_RDONLY)) < 0) {

printf("open scullpipe0 error! /n"); 

exit(1);

}

 

    memset(&action, 0, sizeof(action));

    action.sa_handler = sighandler;

    action.sa_flags = 0;

 

    sigaction(SIGIO, &action, NULL);

 

    fcntl(pipetest0, F_SETOWN, getpid());

    fcntl(pipetest0, F_SETFL, fcntl(pipetest0, F_GETFL) | FASYNC);

 

    while(1) {

        /* this only returns if a signal arrives */

        sleep(86400); /* one day */

        if (!gotdata)

            continue;

        count=read(pipetest0, buffer, 21);

        /* buggy: if avail data is more than 4kbytes... */

        write(1,buffer,count);

        gotdata=0;

break;

    }

 

close(pipetest0 );

printf("close pipetest0  ! /n"); 

 

printf("exit !/n"); 

  exit(0);

}

这个程序运行在后台,首先在主程序中通过

    fcntl(pipetest0, F_SETOWN, getpid());

    fcntl(pipetest0, F_SETFL, fcntl(pipetest0, F_GETFL) | FASYNC);

完成了应用层异步通知的设置,然后只有在驱动层调用到了kill_fasync从而发出SIGIO信号后,激活sigaction的处理函数,设置了gotdata的值,并得到了POLL_IN状态表明可读了,这是调用read函数读出数据,并通过write将读出的数据发往到终端。以上就是异步交换的整个过程。


 

阅读(1515) | 评论(0) | 转发(1) |
给主人留下些什么吧!~~