select、poll、epoll解析

1
2
3
4
5
6
7
8
9
10
#include <sys/select.h>
#include <sys/time.h>

int select(int nfds, fd_set *readfds, fd_set *writefds, d_set *exceptfds, struct timeval *timeout);

void FD_CLR(int fd, fd_set *set);
int  FD_ISSET(int fd, fd_set *set);
void FD_SET(int fd, fd_set *set);
void FD_ZERO(fd_set *set);
// nfds设置成这三个参数中[readfds, writefds, exceptfds] socket描述符句柄中最大值加1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
static int do_select(int n, fd_set_bits *fds, struct timespec64 *end_time)
{
  // ... ...
  poll_initwait(&table);  // init_poll_funcptr(&pwq->pt, __pollwait); 注册回调函数
  for (;;) {
    // ... ...
    for (i = 0; i < n; ++rinp, ++routp, ++rexp) {  // 遍历所有fd
      // ... ...
      f = fdget(i);
      if (f.file) {
        if (f_op->poll) {  // 调用对应的poll方法
          // 对每个fd进行I/O事件检测
          mask = (*f_op->poll)(f.file, wait);  // 返回一个描述读写操作是否就绪的mask掩码
        }
        fdput(f);
        // 根据mask掩码判断是否有就绪的fd
        if ((mask & POLLIN_SET) && (in & bit)) {
            retval++;
        }
        if ((mask & POLLOUT_SET) && (out & bit)) {
          retval++;
        }
        if ((mask & POLLEX_SET) && (ex & bit)) {
          retval++;
        }
      }
      cond_resched();  // 让出CPU给其他进程运行，下次执行时从这里开始
    }
    // 如果有准备好的fd，或者超时，或者有信号打断，退出循环
    if (retval || timed_out || signal_pending(current))
      break;
    // 当do_select()没有达到上述三种情况时，会让当前进程去休眠一段时间，
    // 等待fd设备或定时器来唤醒自己，然后再继续循环看看哪些fd可用，提高效率
    if (!poll_schedule_timeout(&table, TASK_INTERRUPTIBLE, to, slack))
      timed_out = 1;
  }
}

1
2
3
include/uapi/linux/posix_types.h

#define __FD_SETSIZE    1024

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <poll.h>

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

struct pollfd {

  int   fd;       /* file descriptor */

  short events;   /* requested events */

  short revents;  /* returned events */

};

// events and revents可能的取值

POLLIN:There is data to read.

POLLPRI:There is urgent data to read (e.g., out-of-band data on TCP socket).

POLLOUT:Writing now will not block.

POLLRDHUP:Stream socket peer closed connection, or shut down writing half of connection.

POLLERR:Error condition (output only).

POLLHUP:Hang up (output only).

POLLNVAL:Invalid request: fd not open (output only).

1
2
3
4
5
6
7
#include <sys/epoll.h>

int epoll_create(int size);

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

1
2
3
4
5
6
7
int epoll_create(int size);

// 创建一个epoll的句柄，size用来告诉内核这个监听的数目一共有多大。

// 当创建好epoll句柄后，它就会占用一个fd值。在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。

// 返回值：非负的文件描述符(fd)

1
2
3
4
5
6
7
8
struct eventpoll {
    # ... ...
    /* List of ready file descriptors */
    struct list_head rdllist;  // 双链表中存放着将要通过epoll_wait返回给用户的满足条件的事件
    /* RB tree root used to store monitored fd structs */
    struct rb_root rbr; // 红黑树根节点，树存储着所有添加到epoll中的需要监控的事件
    # ... ...
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
struct epitem {
    union {
        /* RB tree node links this structure to the eventpoll RB tree */
        struct rb_node rbn;  // 红黑树节点
        // ... ...
    };
    /* List header used to link this structure to the eventpoll ready list */
    struct list_head rdllink;  // 双向链表节点
    /* The file descriptor information this item refers to */
    struct epoll_filefd ffd;  // 事件句柄信息
    struct eventpoll *ep; // 指向其所属的eventpoll对象
    /* The structure that describe the interested events and the source fd */
    struct epoll_event event;  // 期待发生的事件类型
};

1
2
3
4
5
6
7
8
9
10
11
12
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
// 事件注册函数
// epfd:epoll_create()的返回值

// op:表示动作
EPOLL_CTL_ADD:注册新的fd到epfd;
EPOLL_CTL_MOD:修改已经注册的fd的监听事件;
EPOLL_CTL_DEL:从epfd中删除一个fd;

// fd:需要监听的fd
// event:告诉内核需要监听什么事件
// 返回值：成功返回0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
typedef union epoll_data {
  void        *ptr;
  int          fd;
  __uint32_t   u32;
  __uint64_t   u64;
} epoll_data_t;

struct epoll_event {
  __uint32_t   events;  /* Epoll events */
  epoll_data_t data;    /* User data variable */
};

// events表示对应的文件描述符可以进行的操作
EPOLLIN:可读；
EPOLLOUT:可写；
EPOLLRDHUP:[TODO]；
EPOLLPRI:有紧急的数据可读；
EPOLLERR:发生错误；
EPOLLHUP:被挂断；
EPOLLET:将EPOLL设置为边缘触发模式(Edge Triggered)；
EPOLLONESHOT:只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个socket，需要再次把这个socket加入到EPOLL队列里。

1
2
3
4
5
6
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
// 等待事件的产生
// events:从内核得到事件的集合
// maxevents:告诉内核这个events有多大，该值不能大于epoll_create()时的size
// timeout:超时时间，毫秒，0表示立即返回，-1表示不确定也就是永久阻塞
// 返回值：需要处理的fd数目，0表示timeout