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;
  
  ///這里為了獲得集合中的最大描述符，這樣可減少循環(huán)中遍歷的次數(shù)。
  ///也就是為什么linux中select第一個參數(shù)為何如此重要了
  rcu_read_lock();
  retval = max_select_fd(n, fds);
  rcu_read_unlock();
  if (retval < 0)
    return retval;
  n = retval;

  ////初始化 poll_table結(jié)構(gòu)，其中一個重要任務(wù)是把 __pollwait函數(shù)地址賦值給它，
  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;
  ///主循環(huán)，將會在這里完成描述符的狀態(tài)輪訓(xùn)
  for (;;) {
    unsigned long *rinp, *routp, *rexp, *inp, *outp, *exp;

    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;
      ///select中 fd_set 以及 do_select 中的 fd_set_bits 參數(shù)，都是按照位來保存描述符，意思是比如申請一個1024位的內(nèi)存，
      ///如果第 28位置1，說明此集合有 描述符 28， 
      in = *inp++; out = *outp++; ex = *exp++;
      all_bits = in | out | ex; // 檢測讀寫異常3個集合中有無描述符
      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); ///通過 描述符 index 獲得 struct file結(jié)構(gòu)指針，
        if (file) {
          f_op = file->f_op; //通過 struct file 獲得 file_operations，這是操作文件的回調(diào)函數(shù)集合。
          mask = DEFAULT_POLLMASK;
          if (f_op && f_op->poll) {
            wait_key_set(wait, in, out, bit);
            mask = (*f_op->poll)(file, wait); //調(diào)用我們的設(shè)備中實現(xiàn)的 poll函數(shù)，
                                     //因此，為了能讓select正常工作，在我們設(shè)備驅(qū)動中，必須要提供poll的實現(xiàn)，
          }
          fput_light(file, fput_needed);
          if ((mask & POLLIN_SET) && (in & bit)) {
            res_in |= bit;
            retval++;
            wait = NULL; /// 此處包括以下的，把wait設(shè)置為NULL，是因為檢測到mask = (*f_op->poll)(file, wait); 描述符已經(jīng)就緒
                       /// 無需再把當(dāng)前進程添加到等待隊列里，do_select 遍歷完所有描述符之后就會退出。
          } 
          if ((mask & POLLOUT_SET) && (out & bit)) {
            res_out |= bit;
            retval++;
            wait = NULL;
          }
          if ((mask & POLLEX_SET) && (ex & bit)) {
            res_ex |= bit;
            retval++;
            wait = NULL;
          }
        }
      }
      if (res_in)
        *rinp = res_in;
      if (res_out)
        *routp = res_out;
      if (res_ex)
        *rexp = res_ex;
      cond_resched();
    }
    wait = NULL; //已經(jīng)遍歷完一遍，該加到等待隊列的，都已經(jīng)加了，無需再加，因此設(shè)置為NULL
    if (retval || timed_out || signal_pending(current)) //描述符就緒，超時，或者信號中斷就退出循環(huán)
      break;
    if (table.error) {//出錯退出循環(huán)
      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 (!poll_schedule_timeout(&table, TASK_INTERRUPTIBLE,
            to, slack))
      timed_out = 1;
  }

  poll_freewait(&table);

  return retval;
}
void poll_initwait(struct poll_wqueues *pwq)
{
  init_poll_funcptr(&pwq->pt, __pollwait); //設(shè)置poll_table的回調(diào)函數(shù)為 __pollwait,這樣當(dāng)我們在驅(qū)動中調(diào)用poll_wait 就會調(diào)用到 __pollwait
  ........
}
static void __pollwait(struct file *filp, wait_queue_head_t *wait_address,
        poll_table *p)
{
  ...................
  init_waitqueue_func_entry(&entry->wait, pollwake); // 設(shè)置喚醒進程調(diào)用的回調(diào)函數(shù)，當(dāng)在驅(qū)動中調(diào)用 wake_up喚醒隊列時候，
                                          // pollwake會被調(diào)用，這里其實就是調(diào)用隊列的默認函數(shù) default_wake_function
                                          // 用來喚醒睡眠的進程。
  add_wait_queue(wait_address, &entry->wait);     //加入到等待隊列
}

int core_sys_select(int n, fd_set __user *inp, fd_set __user *outp,
        fd_set __user *exp, struct timespec *end_time)
{
  ........
  //把描述符集合從用戶空間復(fù)制到內(nèi)核空間
  if ((ret = get_fd_set(n, inp, fds.in)) ||
    (ret = get_fd_set(n, outp, fds.out)) ||
    (ret = get_fd_set(n, exp, fds.ex)))
  .........
  ret = do_select(n, &fds, end_time);
  .............
  ////把do_select返回集合，從內(nèi)核空間復(fù)制到用戶空間
  if (set_fd_set(n, inp, fds.res_in) ||
    set_fd_set(n, outp, fds.res_out) ||
    set_fd_set(n, exp, fds.res_ex))
    ret = -EFAULT;
   ............
}

struct epitem {
  /* RB tree node used to link this structure to the eventpoll RB tree */
  struct rb_node rbn; //   紅黑樹節(jié)點，
  
  struct epoll_filefd ffd;  // 存儲此變量對應(yīng)的描述符

  struct epoll_event event; //用戶定義的結(jié)構(gòu)
  /*其他成員*/

};

struct eventpoll {
  /*其他成員*/
  .......

  /* Wait queue used by file->poll() */
  wait_queue_head_t poll_wait;

  /* List of ready file descriptors */
  struct list_head rdllist;      ///描述符就緒隊列，掛載的是 epitem結(jié)構(gòu) 

  /* RB tree root used to store monitored fd structs */
  struct rb_root rbr; /// 存儲 新添加的 描述符的紅黑樹根， 此成員用來存儲添加進來的所有描述符。掛載的是epitem結(jié)構(gòu)
  
   .........
};

//epoll_create
SYSCALL_DEFINE1(epoll_create1, int, flags)
{
  int error;
  struct eventpoll *ep = NULL;

  /*其他代碼*/
  ......
  //分配 eventpoll結(jié)構(gòu)，這個結(jié)構(gòu)是epoll的靈魂，他包含了所有需要處理得數(shù)據(jù)。 
  error = ep_alloc(&ep);
  if (error < 0)
    return error;
  
  error = anon_inode_getfd("[eventpoll]", &eventpoll_fops, ep,
         flags & O_CLOEXEC); ///打開 eventpoll 的描述符，并把 ep存儲到 file->private_data變量里。
  if (error < 0)
    ep_free(ep);

  return error;
}

SYSCALL_DEFINE4(epoll_ctl, int, epfd, int, op, int, fd,
    struct epoll_event __user *, event)
{
  /*其他代碼*/
  .....
  ep = file->private_data;
  ......
  epi = ep_find(ep, tfile, fd);  ///從 eventpoll的 rbr里查找描述符是 fd 的 epitem，

  error = -EINVAL;
  switch (op) {
  case EPOLL_CTL_ADD:
    if (!epi) {
      epds.events |= POLLERR | POLLHUP;
      error = ep_insert(ep, &epds, tfile, fd);   // 在這個函數(shù)里添加新描述符，同時修改重要的回調(diào)函數(shù)。
                                      //同時還調(diào)用描述符的poll，查看就緒狀態(tài)
    } else
      error = -EEXIST;
    break;
   /*其他代碼*/
   ........
}
static int ep_insert(struct eventpoll *ep, struct epoll_event *event,
       struct file *tfile, int fd)
{
  ..... /*其他代碼*/
 
  init_poll_funcptr(&epq.pt, ep_ptable_queue_proc);//設(shè)置 poll_tabe回調(diào)函數(shù)為 ep_ptable_queue_proc
         //ep_ptable_queue_proc會設(shè)置等待隊列的回調(diào)指針為 ep_epoll_callback，同時添加等待隊列。
  
  ........ /*其他代碼*/
  
  revents = tfile->f_op->poll(tfile, &epq.pt); //調(diào)用描述符的poll回調(diào)，在此函數(shù)里 ep_ptable_queue_proc會被調(diào)用

  ....... /*其他代碼*/

  ep_rbtree_insert(ep, epi); //把新生成關(guān)于epitem添加到紅黑樹里

  ...... /*其他代碼*/

  if ((revents & event->events) && !ep_is_linked(&epi->rdllink)) { 
    list_add_tail(&epi->rdllink, &ep->rdllist); //如果 上邊的poll調(diào)用，檢測到描述符就緒，添加本描述符到就緒隊列里。

    if (waitqueue_active(&ep->wq))
      wake_up_locked(&ep->wq);
    if (waitqueue_active(&ep->poll_wait))
      pwake++;
  }
  ...... /*其他代碼*/
  /* We have to call this outside the lock */
  if (pwake)
    ep_poll_safewake(&ep->poll_wait); // 如果描述符就緒隊列不為空，則喚醒 epoll_wait所在的進程。

  ......... /*其他代碼*/

}
//這個函數(shù)設(shè)置等待隊列回調(diào)函數(shù)為 ep_poll_callback，
//這樣到底層有數(shù)據(jù)喚醒等待隊列時候，ep_poll_callback就會被調(diào)用，從而把就緒的描述符加到就緒隊列。
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;
  }
}
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;
  ......... /*其他代碼*/
  if (!ep_is_linked(&epi->rdllink))
    list_add_tail(&epi->rdllink, &ep->rdllist); // 把當(dāng)前就緒的描述epitem結(jié)構(gòu)添加到就緒隊列里
  ......... /*其他代碼*/

  if (pwake)
    ep_poll_safewake(&ep->poll_wait); //如果隊列不為空，喚醒 epoll_wait所在進程
  ......... /*其他代碼*/
}

epoll_wait內(nèi)核代碼里主要是調(diào)用ep_poll，列出ep_poll部分代碼片段：
static int ep_poll(struct eventpoll *ep, struct epoll_event __user *events,
      int maxevents, long timeout)
{
  int res, eavail;
  unsigned long flags;
  long jtimeout;
  wait_queue_t wait;
  ......... /*其他代碼*/
  
  if (list_empty(&ep->rdllist)) {
    
    init_waitqueue_entry(&wait, current);
    wait.flags |= WQ_FLAG_EXCLUSIVE;
    __add_wait_queue(&ep->wq, &wait);  
    // 如果檢測到就緒隊列為空，添加當(dāng)前進程到等待隊列，并執(zhí)行否循環(huán)
    for (;;) {
      
      set_current_state(TASK_INTERRUPTIBLE);
      if (!list_empty(&ep->rdllist) || !jtimeout)  //如果就緒隊列不為空，或者超時則退出循環(huán)
        break;
      if (signal_pending(current)) { //如果信號中斷，退出循環(huán)
        res = -EINTR;
        break;
      }

      spin_unlock_irqrestore(&ep->lock, flags);
      jtimeout = schedule_timeout(jtimeout);//睡眠，知道被喚醒或者超時為止。
      spin_lock_irqsave(&ep->lock, flags);
    }
    __remove_wait_queue(&ep->wq, &wait);

    set_current_state(TASK_RUNNING);
  }
  
  ......... /*其他代碼*/
  
  if (!res && eavail &&
    !(res = ep_send_events(ep, events, maxevents)) && jtimeout)
    goto retry;
   // ep_send_events主要任務(wù)是把就緒隊列的就緒描述符copy到用戶空間的 epoll_event數(shù)組里，

  return res;
}