epoll源码分析----2

来自：http://blog.chinaunix.net/uid-20687780-id-2105157.html

上面的原型是epoll的fd所维护的主结构，下面是每一个具体的fd结构.

以后每一个fd加入到epoll中，就会创建一个struct epitem结构，并插入至红黑树中。

接着是epoll_ctl函数原型:

 asmlinkage long sys_epoll_ctl(int epfd,int op,int fd,struct epoll_event __user *event)
 {
     int error;
     struct file *file,*tfile;
     struct eventpoll *ep;
     struct epoll_event epds;

     error = -FAULT;
     //判断行参的合法性
     if(ep_op_has_event(op) && copy_from_user(&epds,event,sizeof(struct         epoll_event)))
             goto error_return;

     error = -EBADF;
     file = fget (epfd);
     if(!file)    goto error_return;

     tfile = fget(fd);
     if(!tfile)    goto error_fput;

     error = -EPERM;
     //不能没有poll驱动
     if(!tfile->f_op || !tfile->f_op->poll)
         goto error_tgt_fput;

     error =-EINVAL;
     //防止自己监听自己
     if(file == tfile || !is_file_poll(file))
         goto error_tgt_fput;
     //在create时存入进去的，现在将其拿出来
     ep = file->private->data;

     mutex_lock(&ep->mtx);
     //防止重复添加
     epi = epi_find(ep,tfile,fd);
     error = -EINVAL;

     switch(op)
     {
         ….....
         case EPOLL_CTL_ADD:
             if(!epi)
             {
                 epds.events |=EPOLLERR | POLLHUP;
                 error = ep_insert(ep,&epds,tfile,fd);
             } else
                 error = -EEXIST;
             break;
         …....
     }
     return error;
 }

下面就是插入代码:

 static int ep_insert(struct eventpoll *ep,struct epoll_event *event,
                 struct file *tfile,int fd)
 {
     int error ,revents,pwake = 0;
     unsigned long flags ;
     struct epitem *epi;
     /*
     struct ep_queue{
         poll_table pt;
         struct epitem *epi;
     }
     */
     struct ep_pqueue epq;

     //分配一个epitem结构体来保存每个加入的fd
     error = -ENOMEM;
     if(!(epi = kmem_cache_alloc(epi_cache,GFP_KERNEL)))
         goto error_return;
     //初始化该结构体
     ep_rb_initnode(&epi->rbn);
     INIT_LIST_HEAD(&epi->rdllink);
     INIT_LIST_HEAD(&epi->fllink);
     INIT_LIST_HEAD(&epi->pwqlist);
     epi->ep = ep;
     ep_set_ffd(&epi->ffd,tfile,fd);
     epi->event = *event;
     epi->nwait = 0;
     epi->next = EP_UNACTIVE_PTR;

     epq.epi = epi;
     //安装poll回调函数
     init_poll_funcptr(&epq.pt,ep_ptable_queue_proc);
     //调用poll函数来获取当前事件位，其实是利用它来调用注册函数ep_ptable_queue_proc
     revents = tfile->f_op->poll(tfile,&epq.pt);

     if(epi->nwait < 0)
         goto error_unregister;

     spin_lock(&tfile->f_ep_lock);
     list_add_tail(&epi->fllink,&tfile->f_ep_lilnks);
     spin_unlock(&tfile->f_ep_lock);

     ep_rbtree_insert(ep,epi);
     spin_lock_irqsave(&ep->lock,flags);

     if((revents & event->events) && !ep_is_linked(&epi->rdllink))
     {
         list_add_tail(&epi->rdllink,&ep->rdllist);
     if(waitqueue_active(&ep->wq))
         __wake_up_locked(&ep->wq,TAKS_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE);

     if(waitqueue_active(&ep->poll_wait))
         pwake++;
     }

     spin_unlock_irqrestore(&ep->lock,flags);
     if(pwake)
         ep_poll_safewake(&psw,&ep->poll_wait);
         …....

     return 0;

     …...

 }

 //当poll醒来时就回调用该函数
 static void ep_ptable_queue_proc(struct file *file,wait_queue_head_t *whead,
                 poll_table *pt)
 {
     //从注册时的结构中struct ep_pqueue中获取项epi
     struct epitem *epi = ep_item_from_epqueue(pt);
     /*//epitem的私有项,通过pwqlist来进行链接
      *struct eppoll_entry
      {
         struct list_head llink;
         void *base;
         wait_queue_t wait;
         wait_queue_head_t *whead;
      }
     */
     struct eppoll_entry *pwq;//struct epitem的私有项，为每一个fd保存内核poll

     //为每一个等待的结构分配一项
     if(epi->nwait >= 0 && (pwq = kmem_cache_alloc(pwq_cache,
             GFP_KERNEL)))
     {
         //醒来就调用ep_poll_callback,这里才是真正意义上的poll醒来时的回调函数
         init_waitqueue_func_entry(&pwq->wait,ep_poll_callback);
         pwq->whead = whead;
         pwq->base = epi;
         //加入到该驱动的等待队列
         add_wait_queue(whead,&pwq->wait);
         //将等待链接也放入到epitem链表中去
         list_add_tail(&pwq->llink,&epi->pwqlist);
         epi->nwait ++;
     } else {
         epi->nwait = -1;
     }
 }
 //当poll监听的事件到达时，就会调用下面的函数
 static int ep_poll_callback(wait_queue_t *wait,unsigned mode,int sync,void *key)
 {
     int pwake = 0;
     unsigned long flags;
     struct epitem *epi = ep_item_from_wait(wait);
     struct eventpoll *ep = epi->ep;

     spin_lock_irqsave(&ep->lock,flags);
     //判断注册的感兴趣事件
     //#define EP_PRIVATE_BITS      (EPOLLONESHOT | EPOLLET)
     //有非EPOLLONESHONT或EPOLLET事件
     if(!(epi->event.events & ~EP_PRIVATE_BITS))
             goto out_unlock;

     if(unlikely(ep->ovflist != EP_UNACTIVE_PTR))
     {
         if(epi->next == EP_UNACTIVE_PTR) {
             epi->next = ep->ovflist;
             ep->ovflist = epi;
         }
         goto out_unlock;
     }

     if(ep_is_linked(&epi->rdllink))
         goto is_linked;
     //关键是这一句，将该fd加入到epoll监听的就绪链表中
     list_add_tail(&epi->rdllink,&ep->rdllist);
 is_linked:
     if(waitqueue_active(&ep->wq))
         __wake_up_locked(&ep->wq,TASK_UNINTERRUPTIBLE
             | TASK_INTERRUPTIBLE);
     if(waitqueue_active(&ep->poll_wait))
         pwake++;
 out_unlock:
     spin_unlock_irqrestore(&ep->lock,flags);

     if(pwake)
         ep_poll_safewake(&psw,&ep->poll_wait);
     return 1;
 }

这里采用了两级回调方式，流程如下:

目前为止，整个数据结构就可以描述如下: