Linux C系统调用poll与fasync区别

fasync的总结
我们知道，驱动程序运行在内核空间中，应用程序运行在用户空间中，两者是不能直接通信的。但在实际应用中，在设备已经准备好的时 候，我们希望通知用户程序设备已经ok，用户程序可以读取了，这样应用程序就不需要一直查询该设备 的状态，从而节约了资源，这就是异步通知。

相关函数原型：

int fasync_helper(struct inode *inode, struct file *filp, int mode, struct fasync_struct **fa);
作用：一个"帮忙者", 来实现 fasync 设备方法. 
fasync_helper 被调用来从相关的进程列表中添加或去除入口项, 当 FASYNC 标志因一个打开文件而改变。 它的所有参数除了最后一个, 都被提供给 fasync 方法并且被直接传递. 当数据到达时 kill_fasync被用来通知相关的进程. 它的参数是被传递的信号(常常是 SIGIO)和 band 。

参数：
mode  ：参数是传递给方法的相同的值, 
fa    ： 指针指向一个设备特定的 fasync_struct *


void kill_fasync(struct fasync_struct *fa, int sig, int band);
如果这个驱动支持异步通知, 这个函数可用来发送一个信号到登记在 fa 中的进程.





--------------------------------------------------------------
fasync这个东西就是为了使驱动的读写和application的读写分开，使得application可以在驱动读写时去做别的事，通过kill_fasync(kill_fasync(&async, SIGIO, POLL_IN);)发SIGIO信号给应用，应用通过fcntl把自己这个SIGIO的信号换成自己的响应函数，当驱动发(kill_fasync(&async, SIGIO, POLL_IN);)给应用时,应用就调用了自己的handler去处理。
fasync_helper作用就是初始化fasync这个东西，包括分配内存和设置属性。
最后记得在驱动的release里把fasync_helper初始化的东西free掉。





具体实现：
一 驱动方面：
1. 在设备抽象的数据结构中增加一个struct fasync_struct的指针
2. 实现设备操作中的fasync函数，这个函数很简单，其主体就是调用内核的fasync_helper函数。
3. 在需要向用户空间通知的地方(例如中断中)调用内核的kill_fasync函数。
4. 在驱动的release方法中调用kpp_fasync(-1, filp, 0);函数


二 应用层方面
其实就三个步骤：

1）signal(SIGIO, sig_handler);
调用signal函数，让指定的信号SIGIO与处理函数sig_handler对应。

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

3）设置文件标志，添加FASYNC标志
f_flags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, f_flags | FASYNC);

在设备文件中添加 FASYNC 标志，驱动中就会调用将要实现的 test_fasync 函数。
三个步骤执行后，一旦有信号产生，相应的进程就会收到。
完成了以上的工作的话，当内核执行到kill_fasync函数，用户空间SIGIO函数的处理函数就会被调用了。




POLL_IN POLL_OUT
=================================================================================
驱动程序向用户程序发信号
--------------------------------------------- 
当设备有IO事件发生，就有机制保证向应用进程发送信号，显然设备驱动程序扮演重要角色，实际终端tty、网络socket等的标准实现已经包括了实时信号驱动的支持，所以，在Linux中它们可以如上直接使用。但有些设备的驱动程序还并没有支持，所以需要定制设备驱动程序。以下两个API应该是可以屏蔽所有相关琐碎操作(类似send_sig())的标准接口:
int fasync_helper (int fd, struct file *filp, int mode, struct fasync_struct **fa);      
void kill_fasync (struct fasync_struct **fa, int sig, int band);

如果需要支持异步通知机制，如下设备结构中需要有异步事件通知队列(它应该与睡眠队列类似)，并且增加fasync()接口的实现(该函数将本进程登记到 async_queue 上去)。 
当一个打开的文件 FASYNC 标志变化时(调用fcntl()函数，设置FASYNC文件标志时)，fasync()接口将被调用。 

struct kpp_dev {
    struct cdev cdev;
    struct fasync_struct *async_queue;
};

static int kpp_fasync(int fd, struct file *filp, int mode)
{
    struct kpp_dev *dev = filp->private_data; 
    return fasync_helper(fd, filp, mode, &dev->async_queue);
}

事件发生的时机，就是中断服务程序或相应的软中断中调用kill_fasync():
if (dev->async_queue)
    kill_fasync(&dev->async_queue, SIGIO, POLL_IN);
如果是写操作，就是POLL_OUT。注意，无论用户进程设定了什么期望的信号，在这个环节，发送的一般就是SIGIO。注意在设备文件关闭(release方法)时，注意执行fasync()，使得本文件的操作从上述的设备异步事件等待链表中剥离。

static int kpp_release(struct inode *inode, struct file *filp)
{
    kpp_fasync(-1, filp, 0);
    return 0;
}



----------------------------------------

异步通知 fasync 方法
应用程序必须：
 1.指定一个进程作为文件的属主，使用fcntl执行F_SETOWN，属主的进程ID号就保存在filp->f_owner中
 2. 设置FASYNC / O_ASYNC 标志，通过fcntl的F_SETFL完成。
然后输入文件就可以在数据到达时发送SIGIO信号，信号发送给filp->f_owner中的进程。

驱动程序中：
1. 设备结构体中加入 struct fasync_struct *async_queue;
2. 驱动方法fasync中调用fasync_helper()
   static int XXX_fasync(int fd, struct file *filp, int mode)
   {
         struct mem_dev *dev_p = filp->private_data;
         return fasync_helper(fd, filp, mode, &dev_p->async_queue);
   }
3. 当数据到达时调用kill_fasync()发送信号 （如在write中）
   if (dev_p->async_queue)
   {
        kill_fasync(&dev_p->async_queue, SIGIO, POLL_IN);
   }
4. 文件关闭时，release方法中调用fasync方法，从活动的异步读取进程列中删除该文件。
    XXX_fasync(-1, filp, 0);

例子：
驱动：
#include <linux/init.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/errno.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/sched.h>
#include <linux/cdev.h>
#include <asm/system.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/slab.h>
#include <linux/device.h>
#define MEM_SIZE 256
#define MEM_NAME "mem"
struct mem_dev
{
    struct cdev dev;
    char mem[MEM_SIZE];
    struct fasync_struct *async_queue;
};
static struct mem_dev *mem_dev_p;
static dev_t mem_devno;
static struct class *mem_class;


static ssize_t mem_read(struct file *filp, char __user *buf, size_t count, loff_t *pos)
{
    struct mem_dev *dev_p = filp->private_data;
    if (count > MEM_SIZE)
        count = MEM_SIZE;
    if (copy_to_user(buf, dev_p->mem, count))
    {
        return -EFAULT;
    }

    return count;
}


static ssize_t mem_write(struct file *filp, const char __user *buf, size_t count, loff_t *pos)
{
    struct mem_dev *dev_p = filp->private_data;

    if (count > MEM_SIZE)
        count = MEM_SIZE;
    if (copy_from_user(dev_p->mem, buf, count))
    {
        return -EFAULT;
    }

    if (dev_p->async_queue)
    {
        kill_fasync(&dev_p->async_queue, SIGIO, POLL_IN);
    }

    return count;
}



static int mem_fasync(int fd, struct file *filp, int mode)
{
    struct mem_dev *dev_p = filp->private_data;

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


static int mem_open(struct inode * inode , struct file * filp)
{
    filp->private_data = mem_dev_p;
    return 0;
}


static int mem_release(struct inode * inode, struct file *filp)
{
    mem_fasync(-1, filp, 0);
    return 0;
}


static const struct file_operations mem_fops = 
{
    .owner = THIS_MODULE,
    .open = mem_open,
    .release = mem_release,
    .read = mem_read,
    .write = mem_write,
    .fasync = mem_fasync,
};


static int __init my_mem_init(void)
{
    int ret;
    ret = alloc_chrdev_region(&mem_devno, 0, 1, MEM_NAME);
    if (ret)
    {
        goto out_1;
    }

    mem_dev_p = kmalloc(sizeof(struct mem_dev), GFP_KERNEL);
    if (NULL == mem_dev_p)
    {
        ret = -ENOMEM;
        goto out_2;
    }

    memset(mem_dev_p, 0, sizeof(struct mem_dev));

    cdev_init(&mem_dev_p->dev, &mem_fops);
    mem_dev_p->dev.owner = THIS_MODULE;
    mem_dev_p->dev.ops = &mem_fops;
    ret = cdev_add(&mem_dev_p->dev, mem_devno, 1);
    if (ret)
    {
        goto out_3;
    }

    mem_class = class_create(THIS_MODULE, "mem_driver");
    device_create(mem_class, NULL, mem_devno, NULL, "mem_fasync");

    printk("mem_init
");
    return 0;

out_3: kfree(mem_dev_p);
out_2: unregister_chrdev_region(mem_devno, 1);
out_1: return ret;
}


static void __exit my_mem_exit(void)
{
    device_destroy(mem_class, mem_devno);
    class_destroy(mem_class);

    cdev_del(&mem_dev_p->dev);
    kfree(mem_dev_p);
    unregister_chrdev_region(mem_devno, 1);

    printk("mem_exit
");
}

MODULE_LICENSE("Dual BSD/GPL");
module_init(my_mem_init);
module_exit(my_mem_exit);

应用程序：
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <signal.h>
#include <string.h>


void catch_sigio(int signu)
{
    printf("catch signo
");
}


int main(void)
{
  int flags;
    if (SIG_ERR == signal(SIGIO, catch_sigio))
    {
        printf("signal failed
");
        return -1;
    }

    int fd;
    fd = open("/dev/mem_fasync", O_RDWR);
    if (-1 == fd)
    {
        perror("open");
        return -2;
    }
    printf("open success
");


    fcntl(fd, F_SETOWN, getpid());
    flags = fcntl(fd, F_GETFL);
    fcntl(fd, F_SETFL, flags | O_ASYNC);


    while (1)
    {
        NULL;
    }
    return 0;
}



比较：
1. 上一节我们已经学习了用 poll 轮询数据，来避免不必要的休眠，但是事实上，轮询的直接负面作用就是效率低下，这样一节我们学习如何使用异步通知IO来提 高效率

2. fcntl系统调用
int fcntl(int fd, int cmd, long arg);
fcntl的作用是改变一个已打开文件的属性，fd是要改变的文件的描述符，cmd是命令罗列如下：
F_DUPFD, F_GETFD, F_SETFD, F_GETFL, F_SETFL, F_SETLK, F_SETLKW, F_GETLK, F_GETOWN, F_SETOWN
本节只关心F_SETOWN（设置异步IO所有权），F_GETFL（获取文件flags），F_SETFL（设置文件flags）
arg是要改变的属性内容

3. 用户进程启用异步通知机制
首先，设置一个进程作为一个文件的属主(owner)，这样内核就知道该把文件的信号发送给哪个进程
fcntl(fd, F_SETOWN, getpid()); // getpid()就是当前进程咯
然后，给文件设置FASYNC标志，以启用异步通知机制
fcntl(fd, F_SETFL, fcntl(fd, F_GETFL) | FASYNC);

4. 缺陷
当有多个文件发送异步通知信号给一个进程时，进程无法知道是哪个文件发送的信号，这时候还是要借助poll的帮助完成IO


5. 从驱动程序的角度考虑
当文件的状态标志设置了FASYNC操作时，驱动程序会调用fasync的函数。
fasync的实现相当简单
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);
}

当有新的数据到达时，驱动程序应该发送一个SIGIO给用户，这个操作用kill_fasync方法完成
if(dev->async_queue)
         kill_fasync(&dev->async_queue, SIGIO, POLL_IN);

最后，从异步通知列表中移除注册进去了的文件指针就直接调用scull_p_fasync(-1, filp, 0);

linux C系统调用polling轮询的用法

本篇文章是对select、poll、epoll之间的区别进行了详细的分析介绍。需要的朋友参考下


linux提供了select、poll、epoll接口来实现IO复用，三者的原型如下所示，本文从参数、实现、性能等方面对三者进行对比。

复制代码 代码如下:


int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
 int poll(struct pollfd *fds, nfds_t nfds, int timeout);
 int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
  

 select、poll、epoll_wait参数及实现对比
1．select的第一个参数nfds为fdset集合中最大描述符值加1，fdset是一个位数组，其大小限制为__FD_SETSIZE（1024），位数组的每一位代表其对应的描述符是否需要被检查。

select的第二三四个参数表示需要关注读、写、错误事件的文件描述符位数组，这些参数既是输入参数也是输出参数，可能会被内核修改用于标示哪些描述符上发生了关注的事件。所以每次调用select前都需要重新初始化fdset。

timeout参数为超时时间，该结构会被内核修改，其值为超时剩余的时间。
 
select对应于内核中的sys_select调用，sys_select首先将第二三四个参数指向的fd_set拷贝到内核，然后对每个被SET的描述符调用进行poll，并记录在临时结果中（fdset），如果有事件发生，select会将临时结果写到用户空间并返回；当轮询一遍后没有任何事件发生时，如果指定了超时时间，则select会睡眠到超时，睡眠结束后再进行一次轮询，并将临时结果写到用户空间，然后返回。

select返回后，需要逐一检查关注的描述符是否被SET（事件是否发生）。

2．poll与select不同，通过一个pollfd数组向内核传递需要关注的事件，故没有描述符个数的限制，pollfd中的events字段和revents分别用于标示关注的事件和发生的事件，故pollfd数组只需要被初始化一次。

poll的实现机制与select类似，其对应内核中的sys_poll，只不过poll向内核传递pollfd数组，然后对pollfd中的每个描述符进行poll，相比处理fdset来说，poll效率更高。

poll返回后，需要对pollfd中的每个元素检查其revents值，来得指事件是否发生。

3．epoll通过epoll_create创建一个用于epoll轮询的描述符，通过epoll_ctl添加/修改/删除事件，通过epoll_wait检查事件，epoll_wait的第二个参数用于存放结果。

epoll与select、poll不同，首先，其不用每次调用都向内核拷贝事件描述信息，在第一次调用后，事件信息就会与对应的epoll描述符关联起来。另外epoll不是通过轮询，而是通过在等待的描述符上注册回调函数，当事件发生时，回调函数负责把发生的事件存储在就绪事件链表中，最后写到用户空间。

epoll返回后，该参数指向的缓冲区中即为发生的事件，对缓冲区中每个元素进行处理即可，而不需要像poll、select那样进行轮询检查。

select、poll、epoll_wait性能对比
select、poll的内部实现机制相似，性能差别主要在于向内核传递参数以及对fdset的位操作上，另外，select存在描述符数的硬限制，不能处理很大的描述符集合。这里主要考察poll与epoll在不同大小描述符集合的情况下性能的差异。

 测试程序会统计在不同的文件描述符集合的情况下，1s内poll与epoll调用的次数。统计结果如下，从结果可以看出，对poll而言，每秒钟内的系统调用数目虽集合增大而很快降低，而epoll基本保持不变，具有很好的扩展性。

 

一、连接数
 我本人也曾经在项目中用过select和epoll,对于select，感触最深的是linux下select最大数目限制(windows 下似乎没有限制)，每个进程的select最多能处理FD_SETSIZE个FD(文件句柄)，
 如果要处理超过1024个句柄，只能采用多进程了。
 常见的使用slect的多进程模型是这样的： 一个进程专门accept，成功后将fd通过unix socket传递给子进程处理，父进程可以根据子进程负载分派。曾经用过1个父进程+4个子进程 承载了超过4000个的负载。
 这种模型在我们当时的业务运行的非常好。epoll在连接数方面没有限制，当然可能需要用户调用API重现设置进程的资源限制。

二、IO差别
1、select的实现
 这段可以结合linux内核代码描述了，我使用的是2.6.28，其他2.6的代码应该差不多吧。
先看看select:
 select系统调用的代码在fs/Select.c下，

复制代码 代码如下:


asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp,
             fd_set __user *exp, struct timeval __user *tvp)
 {
     struct timespec end_time, *to = NULL;
     struct timeval tv;
     int ret;
     if (tvp) {
         if (copy_from_user(&tv, tvp, sizeof(tv)))
             return -EFAULT;
         to = &end_time;
         if (poll_select_set_timeout(to,
                 tv.tv_sec + (tv.tv_usec / USEC_PER_SEC),
                 (tv.tv_usec % USEC_PER_SEC) * NSEC_PER_USEC))
             return -EINVAL;
     }
     ret = core_sys_select(n, inp, outp, exp, to);
     ret = poll_select_copy_remaining(&end_time, tvp, 1, ret);
     return ret;
 } 


前面是从用户控件拷贝各个fd_set到内核空间，接下来的具体工作在core_sys_select中，
core_sys_select->do_select,真正的核心内容在do_select里：

复制代码 代码如下:


int do_select(int n, fd_set_bits *fds, struct timespec *end_time)
 {
     ktime_t expire, *to = NULL;
     struct poll_wqueues table;
     poll_table *wait;
     int retval, i, timed_out = 0;
     unsigned long slack = 0;
     rcu_read_lock();
     retval = max_select_fd(n, fds);
     rcu_read_unlock();
     if (retval < 0)
         return retval;
     n = retval;
     poll_initwait(&table);
     wait = &table.pt;
     if (end_time && !end_time->tv_sec && !end_time->tv_nsec) {
         wait = NULL;
         timed_out = 1;
     }
     if (end_time && !timed_out)
         slack = estimate_accuracy(end_time);
     retval = 0;
     for (;;) {
         unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;
         set_current_state(TASK_INTERRUPTIBLE);
         inp = fds->in; outp = fds->out; exp = fds->ex;
         rinp = fds->res_in; routp = fds->res_out; rexp = fds->res_ex;
         for (i = 0; i < n; ++rinp, ++routp, ++rexp) {
             unsigned long in, out, ex, all_bits, bit = 1, mask, j;
             unsigned long res_in = 0, res_out = 0, res_ex = 0;
             const struct file_operations *f_op = NULL;
             struct file *file = NULL;
             in = *inp++; out = *outp++; ex = *exp++;
             all_bits = in | out | ex;
             if (all_bits == 0) {
                 i += __NFDBITS;
                 continue;
             }
             for (j = 0; j < __NFDBITS; ++j, ++i, bit <<= 1) {
                 int fput_needed;
                 if (i >= n)
                     break;
                 if (!(bit & all_bits))
                     continue;
                 file = fget_light(i, &fput_needed);
                 if (file) {
                     f_op = file->f_op;
                     mask = DEFAULT_POLLMASK;
                     if (f_op && f_op->poll)
                         mask = (*f_op->poll)(file, retval ? NULL : wait);
                     fput_light(file, fput_needed);
                     if ((mask & POLLIN_SET) && (in & bit)) {
                         res_in |= bit;
                         retval++;
                     }
                     if ((mask & POLLOUT_SET) && (out & bit)) {
                         res_out |= bit;
                         retval++;
                     }
                     if ((mask & POLLEX_SET) && (ex & bit)) {
                         res_ex |= bit;
                         retval++;
                     }
                 }
             }
             if (res_in)
                 *rinp = res_in;
             if (res_out)
                 *routp = res_out;
             if (res_ex)
                 *rexp = res_ex;
             cond_resched();
         }
         wait = NULL;
         if (retval || timed_out || signal_pending(current))
             break;
         if (table.error) {
             retval = table.error;
             break;
         }
         /*
          * If this is the first loop and we have a timeout
          * given, then we convert to ktime_t and set the to
          * pointer to the expiry value.
          */
         if (end_time && !to) {
             expire = timespec_to_ktime(*end_time);
             to = &expire;
         }
         if (!schedule_hrtimeout_range(to, slack, HRTIMER_MODE_ABS))
             timed_out = 1;
     }
     __set_current_state(TASK_RUNNING);
     poll_freewait(&table);
     return retval;
 } 


上面的代码很多，其实真正关键的代码是这一句:

复制代码 代码如下:


mask = (*f_op->poll)(file, retval ? NULL : wait); 
这个是调用文件系统的 poll函数，不同的文件系统poll函数自然不同，由于我们这里关注的是tcp连接，而socketfs的注册在 net/Socket.c里。
register_filesystem(&sock_fs_type); 
 socket文件系统的函数也是在net/Socket.c里：
static const struct file_operations socket_file_ops = {
     .owner =    THIS_MODULE,
     .llseek =    no_llseek,
     .aio_read =    sock_aio_read,
     .aio_write =    sock_aio_write,
     .poll =        sock_poll,
     .unlocked_ioctl = sock_ioctl,
 #ifdef CONFIG_COMPAT
     .compat_ioctl = compat_sock_ioctl,
 #endif
     .mmap =        sock_mmap,
     .open =        sock_no_open,    /* special open code to disallow open via /proc */
     .release =    sock_close,
     .fasync =    sock_fasync,
     .sendpage =    sock_sendpage,
     .splice_write = generic_splice_sendpage,
     .splice_read =    sock_splice_read,
 };


从sock_poll跟随下去，
 最后可以到 net/ipv4/tcp.c的
unsigned int tcp_poll(struct file *file, struct socket *sock, poll_table *wait) 
这个是最终的查询函数，
 也就是说select 的核心功能是调用tcp文件系统的poll函数，不停的查询，如果没有想要的数据，主动执行一次调度（防止一直占用cpu），直到有一个连接有想要的消息为止。
 从这里可以看出select的执行方式基本就是不同的调用poll,直到有需要的消息为止，如果select 处理的socket很多，这其实对整个机器的性能也是一个消耗。
2、epoll的实现
epoll的实现代码在 fs/EventPoll.c下，
 由于epoll涉及到几个系统调用，这里不逐个分析了，仅仅分析几个关键点，
 第一个关键点在
static int ep_insert(struct eventpoll *ep, struct epoll_event *event,
              struct file *tfile, int fd) 
这是在我们调用sys_epoll_ctl 添加一个被管理socket的时候调用的函数，关键的几行如下：

复制代码 代码如下:


epq.epi = epi;
     init_poll_funcptr(&epq.pt, ep_ptable_queue_proc);
     /*
      * Attach the item to the poll hooks and get current event bits.
      * We can safely use the file* here because its usage count has
      * been increased by the caller of this function. Note that after
      * this operation completes, the poll callback can start hitting
      * the new item.
      */
     revents = tfile->f_op->poll(tfile, &epq.pt); 


这里也是调用文件系统的poll函数，不过这次初始化了一个结构，这个结构会带有一个poll函数的callback函数：ep_ptable_queue_proc，
 在调用poll函数的时候，会执行这个callback，这个callback的功能就是将当前进程添加到 socket的等待进程上。

复制代码 代码如下:


static void ep_ptable_queue_proc(struct file *file, wait_queue_head_t *whead,
                  poll_table *pt)
 {
     struct epitem *epi = ep_item_from_epqueue(pt);
     struct eppoll_entry *pwq;
     if (epi->nwait >= 0 && (pwq = kmem_cache_alloc(pwq_cache, GFP_KERNEL))) {
         init_waitqueue_func_entry(&pwq->wait, ep_poll_callback);
         pwq->whead = whead;
         pwq->base = epi;
         add_wait_queue(whead, &pwq->wait);
         list_add_tail(&pwq->llink, &epi->pwqlist);
         epi->nwait++;
     } else {
         /* We have to signal that an error occurred */
         epi->nwait = -1;
     }
 }  


注意到参数 whead 实际上是 sk->sleep，其实就是将当前进程添加到sk的等待队列里，当该socket收到数据或者其他事件触发时，会调用
sock_def_readable 或者sock_def_write_space 通知函数来唤醒等待进程，这2个函数都是在socket创建的时候填充在sk结构里的。
 从前面的分析来看，epoll确实是比select聪明的多、轻松的多，不用再苦哈哈的去轮询了。