【Linux网络编程】Nginx -- 事件模块(三)

【1】epoll 的原理简介

详见 【Linux网络编程】Epoll 的实现原理分析

【2】ngx_epoll_module epoll 驱动模块

【2.1】ngx_epoll_module epoll 驱动模块 -- 相关接口定义

ngx_epoll_conf_t 结构体

// epoll 模块的配置结构体
typedef struct {
    // epoll 系统调用，获取事件的数组大小
    // 对应指令 epoll_events
    // 表示 epoll_wait 函数返回的最大事件数
    ngx_uint_t  events;

    // AIO 相关参数
    // 并发处理异步 IO 事件个数
    ngx_uint_t  aio_requests;
} ngx_epoll_conf_t;

ngx_epoll_module 的定义

// epoll 模块定义
ngx_module_t  ngx_epoll_module = {
    NGX_MODULE_V1,
    &ngx_epoll_module_ctx,               /* module context */
    ngx_epoll_commands,                  /* module directives */
    NGX_EVENT_MODULE,                    /* module type */
    NULL,                                /* init master */
    NULL,                                /* init module */
    NULL,                                /* init process */
    NULL,                                /* init thread */
    NULL,                                /* exit thread */
    NULL,                                /* exit process */
    NULL,                                /* exit master */
    NGX_MODULE_V1_PADDING
};

ngx_epoll_module_ctx 的定义

// epoll 模块的函数表
static ngx_event_module_t  ngx_epoll_module_ctx = {
    // epoll 模块的名字 "epoll"
    &epoll_name,

    // 创建配置结构体
    ngx_epoll_create_conf,               /* create configuration */

    // 初始化配置结构体
    ngx_epoll_init_conf,                 /* init configuration */

    // epoll 的事件模块访问接口，是一个函数表
    {
        // epoll 添加事件
        // 检查事件关联的连接对象，决定是新添加还是修改
        // 对应于 ngx_event_actions_t 的 add 方法
        ngx_epoll_add_event,             /* add an event */

        // epoll 删除事件
        // 检查事件关联的连接对象，决定是完全删除还是修改
        // 对应于 ngx_event_actions_t 的 del 方法
        ngx_epoll_del_event,             /* delete an event */
        // 对应于 ngx_event_actions_t 的 enable 方法
        ngx_epoll_add_event,             /* enable an event */
        // 对应于 ngx_event_actions_t 的 disable 方法
        ngx_epoll_del_event,             /* disable an event */

        // epoll关注连接的读写事件
        // 添加事件成功，读写事件都是活跃的，即已经使用
        // 对应于 ngx_event_actions_t 的 add_conn 方法
        ngx_epoll_add_connection,        /* add an connection */

        // epoll删除连接的读写事件
        // 删除事件成功，读写事件都不活跃
        // 对应于 ngx_event_actions_t 的 del_conn 方法
        ngx_epoll_del_connection,        /* delete an connection */

#if (NGX_HAVE_EVENTFD)
        // 使用 epoll 模拟了事件通知机制
        // 向文件里写一个数字，令文件可读，从而触发 epoll 事件
        // 参数 handler 是真正的业务回调函数
        ngx_epoll_notify,                /* trigger a notify */
#else
        // 对应于 ngx_event_actions_t 的 notify 方法
        // 未实现
        NULL,                            /* trigger a notify */
#endif
        // epoll 模块核心功能，调用 epoll_wait 处理发生的事件
        // 使用 event_list 和 nevents 获取内核返回的事件
        // timer 是无事件发生时最多等待的时间，即超时时间
        // 函数可以分为两部分，一是用 epoll 获得事件，二是处理事件，加入延后队列
        // 函数里不处理定时器，因为定时器不属于 epoll 事件
        // 对应于 ngx_event_actions_t 的 process_events 方法
        ngx_epoll_process_events,        /* process the events */

        // 调用 epoll_create 初始化 epoll 机制, timer 无意义
        // 参数 size=cycle->connection_n / 2，但并无实际意义
        // 设置全局变量，操作系统提供的底层数据收发接口
        // 初始化全局的事件模块访问接口，指向 epoll 的函数
        // 默认使用 et 模式，边缘触发，高速
        // 对应于 ngx_event_actions_t 的 init 方法
        ngx_epoll_init,                  /* init the events */

        // epoll 模块结束工作，关闭 epoll 句柄和通知句柄，释放内存
        // 对应于 ngx_event_actions_t 的 done 方法
        ngx_epoll_done,                  /* done the events */
    }
};

ngx_epoll_commands 的定义

// epoll 模块支持的指令
// 定义 epoll 模块感兴趣的配置项结构数组
static ngx_command_t  ngx_epoll_commands[] = {

    // event_list 数组大小，存储内核返回的事件
    //
    // epoll_events 配置项表示 epoll_wait 函数每次返回的最多事件数(即第3个参数)
    // 在 ngx_epoll_init 函数中会预分配 epoll_events 配置项指定的 epoll_event 结构体
    { ngx_string("epoll_events"),
      NGX_EVENT_CONF|NGX_CONF_TAKE1,
      ngx_conf_set_num_slot,
      0,
      offsetof(ngx_epoll_conf_t, events),
      NULL },

    // 该配置项表示创建的异步 IO 上下文能并发处理异步 IO 事件的个数
    // 即 io_setup 函数的第一个参数
    { ngx_string("worker_aio_requests"),
      NGX_EVENT_CONF|NGX_CONF_TAKE1,
      ngx_conf_set_num_slot,
      0,
      offsetof(ngx_epoll_conf_t, aio_requests),
      NULL },

      ngx_null_command
};

【2.2】ngx_epoll_module epoll 驱动模块 -- 相关方法

初始化方法 -- ngx_epoll_init

• 调用 epoll_create 方法创建 epoll 对象
• 创建 event_list 数组，用于进行 epoll_wait 调用时传递内核态的事件

// 创建 epoll 对象和创建 event_list 数组
// 
// 调用 epoll_create 初始化 epoll 机制, timer 无意义
// 参数 size=cycle->connection_n / 2，但并无实际意义
// 设置全局变量，操作系统提供的底层数据收发接口
// 初始化全局的事件模块访问接口，指向 epoll 的函数
// 默认使用 et 模式，边缘触发，高速
static ngx_int_t
ngx_epoll_init(ngx_cycle_t *cycle, ngx_msec_t timer)
{
    ngx_epoll_conf_t  *epcf;

    // 获取 epoll 模块的配置
    epcf = ngx_event_get_conf(cycle->conf_ctx, ngx_epoll_module);

    // ep == -1 表示还没有创建 epoll 句柄，需要初始化
    if (ep == -1) {
        // 创建 epoll 句柄
        // 参数 size=cycle->connection_n / 2，但并无实际意义
        // 调用 epoll_create 函数创建 epoll 对象描述符
        ep = epoll_create(cycle->connection_n / 2);

        // epoll 初始化失败
        if (ep == -1) {
            ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,
                          "epoll_create() failed");
            return NGX_ERROR;
        }

#if (NGX_HAVE_EVENTFD)
        // 初始化多线程通知用的描述符和事件/连接
        if (ngx_epoll_notify_init(cycle->log) != NGX_OK) {

            // 如果初始化失败，那么 notify 指针置空
            ngx_epoll_module_ctx.actions.notify = NULL;
        }
#endif

// 若系统支持异步 IO，则初始化异步 IO
#if (NGX_HAVE_FILE_AIO)
        ngx_epoll_aio_init(cycle, epcf);
#endif

#if (NGX_HAVE_EPOLLRDHUP)
        ngx_epoll_test_rdhup(cycle);
#endif
    }

    // 预分配 events 个 epoll_event 结构 event_list，event_list 是存储产生事件的数组
    // events 由 epoll_events 配置项指定
    // 检查当前事件数组的大小，最开始 nevents 是 0
    if (nevents < epcf->events) {

        // 若现有 event_list 个数小于配置项所指定的值 epcf->events
        // 则先释放，再从新分配
        if (event_list) {
            ngx_free(event_list);
        }

        // 相当于 vector.resize(cf.events)
        // 预分配 epcf->events 个 epoll_event 结构，并使 event_list 指向该地址
        event_list = ngx_alloc(sizeof(struct epoll_event) * epcf->events,
                               cycle->log);
        if (event_list == NULL) {
            return NGX_ERROR;
        }
    }

    // 设置正确的数组长度
    // 设置正确的 epoll_event 结构个数
    nevents = epcf->events;

    // 指定 IO 的读写方法
    // 设置全局变量，操作系统提供的底层数据收发接口
    // ngx_posix_init.c 里初始化为 linux 的底层接口
    //
    // // unix 基本的数据收发接口
    // // 屏蔽 linux/bsd/darwin 等的差异
    // ngx_os_io_t ngx_os_io = {
    //     ngx_unix_recv,
    //     ngx_readv_chain,
    //     ngx_udp_unix_recv,
    //     ngx_unix_send,
    //     ngx_udp_unix_send,
    //     ngx_udp_unix_sendmsg_chain,
    //     ngx_writev_chain,
    //     0
    // };
    ngx_io = ngx_os_io;

    // 初始化全局的事件模块访问接口，指向 epoll 的函数
    ngx_event_actions = ngx_epoll_module_ctx.actions;

#if (NGX_HAVE_CLEAR_EVENT)
    // 默认使用 et 模式，边缘触发，高速
    ngx_event_flags = NGX_USE_CLEAR_EVENT
#else
    ngx_event_flags = NGX_USE_LEVEL_EVENT
#endif
                      |NGX_USE_GREEDY_EVENT
                      |NGX_USE_EPOLL_EVENT;

    return NGX_OK;
}

事件添加与删除方法 -- ngx_epoll_add_event / ngx_epoll_del_event

// epoll 添加事件
// 检查事件关联的连接对象，决定是新添加还是修改
// 将某个描述符的某个事件添加到 epoll 对象的监控机制中
static ngx_int_t
ngx_epoll_add_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
{
    int                  op;
    uint32_t             events, prev;
    ngx_event_t         *e;
    ngx_connection_t    *c;
    struct epoll_event   ee;

    // 获取事件关联的连接对象
    // 每个事件的 data 成员都存放着其对应的 ngx_connection_t 连接
    c = ev->data;

    // 计算 epoll 的标志位
    // events 参数是方便下面确定当前事件是可读还是可写
    events = (uint32_t) event;

    // prev 是对应事件的标志
    // 添加读事件则查看写事件
    //
    // 这里在判断事件类型是可读还是可写，必须根据事件的 active 标志位来判断事件是否活跃
    // 因为 epoll_ctl 函数有添加 add 和修改 mod 模式
    // 若一个事件所关联的连接已经在 epoll 对象的监控中，则只需修改事件的类型即可
    // 若一个事件所关联的连接没有在 epoll 对象的监控中，则需要将其相应的事件类型注册到 epoll 对象中
    // 这样做的情况是避免与事件相关联的连接两次注册到 epoll 对象中
    if (event == NGX_READ_EVENT) {
        // 若待添加的事件类型 event 可读
        // 则首先判断该事件所关联的连接是否需要将写事件添加到 epoll 对象中
        // 即先判断关联的连接的写事件是否为活跃事件
        e = c->write;
        prev = EPOLLOUT;

        // 读事件的 epoll 标志
#if (NGX_READ_EVENT != EPOLLIN|EPOLLRDHUP)
        events = EPOLLIN|EPOLLRDHUP;
#endif

    // 添加写事件则查看读事件
    } else {
        e = c->read;
        prev = EPOLLIN|EPOLLRDHUP;

        // 写事件的epoll标志
#if (NGX_WRITE_EVENT != EPOLLOUT)
        events = EPOLLOUT;
#endif
    }

    // 根据 active 标志位确定事件是否为活跃事件，以决定到达是修改还是添加事件
    //
    // 如果另外的读写事件是活跃的那么就意味着已经加过了
    // active 的设置就在下面的代码里
    // epoll 的操作就是修改 EPOLL_CTL_MOD
    // 需要加上对应事件的读写标志，即 prev
    if (e->active) {
        op = EPOLL_CTL_MOD;
        events |= prev;

    } else {
        // 若当前事件不是活跃事件，则将该事件添加到 epoll 对象中
        op = EPOLL_CTL_ADD;
    }

#if (NGX_HAVE_EPOLLEXCLUSIVE && NGX_HAVE_EPOLLRDHUP)
    if (flags & NGX_EXCLUSIVE_EVENT) {
        events &= ~EPOLLRDHUP;
    }
#endif

    // 将 flags 参数加入到 events 标志位中
    // 加上 flags 标志，里面有 ET
    ee.events = events | (uint32_t) flags;

    // union 的指针成员，关联到连接对象
    // 因为目前的 32位/64位的计算机指针地址低位都是 0（字节对齐）
    // 所以用最低位来存储 instance 标志，即一个 bool 值
    // 在真正取出连接对象时需要把低位的信息去掉
    //
    // prt 存储事件关联的连接对象 ngx_connection_t 以及过期事件 instance 标志位
    ee.data.ptr = (void *) ((uintptr_t) c | ev->instance);

    ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
                   "epoll add event: fd:%d op:%d ev:%08XD",
                   c->fd, op, ee.events);

    // 调用 epoll_ctl 方法向 epoll 对象添加事件或在 epoll 对象中修改事件
    if (epoll_ctl(ep, op, c->fd, &ee) == -1) {
        ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
                      "epoll_ctl(%d, %d) failed", op, c->fd);
        return NGX_ERROR;
    }

    // 添加事件成功，此事件就是活跃的，即已经使用
    ev->active = 1;
#if 0
    ev->oneshot = (flags & NGX_ONESHOT_EVENT) ? 1 : 0;
#endif

    return NGX_OK;
}

// epoll 删除事件
// 检查事件关联的连接对象，决定是完全删除还是修改
// 将某个连接的某个事件从 epoll 对象监控中删除
static ngx_int_t
ngx_epoll_del_event(ngx_event_t *ev, ngx_int_t event, ngx_uint_t flags)
{
    int                  op;
    uint32_t             prev;
    ngx_event_t         *e;
    ngx_connection_t    *c;
    struct epoll_event   ee;

    /*
     * when the file descriptor is closed, the epoll automatically deletes
     * it from its queue, so we do not need to delete explicitly the event
     * before the closing the file descriptor
     */

    // 是否是要求事件关闭
    // 当事件关联的文件描述符关闭后，epoll 对象自动将其事件删除
    if (flags & NGX_CLOSE_EVENT) {
        // 设置 active 成员
        ev->active = 0;
        return NGX_OK;
    }

    // 获取事件关联的连接对象
    c = ev->data;

    // 根据 event 参数判断当前删除的是读事件还是写事件
    // prev 是对应事件的标志
    // 添加读事件则查看写事件
    if (event == NGX_READ_EVENT) {
        // 若要删除读事件，则首先判断写事件的 active 标志位
        e = c->write;
        prev = EPOLLOUT;

    // 添加写事件则查看读事件
    } else {
        // 若要删除写事件，则判断读事件的 active 标志位
        e = c->read;
        prev = EPOLLIN|EPOLLRDHUP;
    }


    // 如果另外的读写事件是活跃的那么就意味着已经加过了
    // active 的设置就在下面的代码里
    // epoll 的操作就是修改 EPOLL_CTL_MOD
    // 需要加上对应事件的读写标志，即 prev
    //
    // 若要删除读事件，且写事件是活跃事件，则修改事件类型即可
    // 若要删除写事件，且读事件是活跃事件，则修改事件类型即可
    if (e->active) {
        op = EPOLL_CTL_MOD;
        ee.events = prev | (uint32_t) flags;

        // union 的指针成员，关联到连接对象
        // 因为目前的 32位/64位的计算机指针地址低位都是 0（字节对齐）
        // 所以用最低位来存储 instance 标志，即一个 bool 值
        // 在真正取出连接对象时需要把低位的信息去掉
        ee.data.ptr = (void *) ((uintptr_t) c | ev->instance);

    } else {
        // 若读写事件都不是活跃事件，此时表示事件未准备就绪，则将其删除 
        op = EPOLL_CTL_DEL;
        ee.events = 0;
        ee.data.ptr = NULL;
    }

    ngx_log_debug3(NGX_LOG_DEBUG_EVENT, ev->log, 0,
                   "epoll del event: fd:%d op:%d ev:%08XD",
                   c->fd, op, ee.events);

    // 到这里，已经确定了是删除还是修改 epoll 事件
    // 执行系统调用，删除 epoll 关注事件
    if (epoll_ctl(ep, op, c->fd, &ee) == -1) {
        ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_errno,
                      "epoll_ctl(%d, %d) failed", op, c->fd);
        return NGX_ERROR;
    }

    // 删除事件成功，此事件不活跃，即已停止关注
    ev->active = 0;

    return NGX_OK;
}

连接添加与删除方法 -- ngx_epoll_add_connection / ngx_epoll_del_connection

// 将指定连接所关联的描述符添加到 epoll 对象中
// epoll 关注连接的读写事件
// 添加事件成功，读写事件都是活跃的，即已经使用
static ngx_int_t
ngx_epoll_add_connection(ngx_connection_t *c)
{
    struct epoll_event  ee;

    // 不区分读写，添加全部标志位，使用 et 模式
    // 设置事件的类型：可读、可写、ET 模式
    ee.events = EPOLLIN|EPOLLOUT|EPOLLET|EPOLLRDHUP;

    // union 的指针成员，关联到连接对象
    // 因为目前的32位/64位的计算机指针地址低位都是 0（字节对齐）
    // 所以用最低位来存储 instance 标志，即一个 bool 值
    // 在真正取出连接对象时需要把低位的信息去掉
    ee.data.ptr = (void *) ((uintptr_t) c | c->read->instance);

    ngx_log_debug2(NGX_LOG_DEBUG_EVENT, c->log, 0,
                   "epoll add connection: fd:%d ev:%08XD", c->fd, ee.events);

    // 执行系统调用，直接添加 epoll 关注事件
    if (epoll_ctl(ep, EPOLL_CTL_ADD, c->fd, &ee) == -1) {
        ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
                      "epoll_ctl(EPOLL_CTL_ADD, %d) failed", c->fd);
        return NGX_ERROR;
    }

    // 添加事件成功，读写事件都是活跃的，即已经使用
    c->read->active = 1;
    c->write->active = 1;

    return NGX_OK;
}

// 将连接所关联的描述符从 epoll 对象中删除
// epoll 删除连接的读写事件
// 删除事件成功，读写事件都不活跃
static ngx_int_t
ngx_epoll_del_connection(ngx_connection_t *c, ngx_uint_t flags)
{
    int                 op;
    struct epoll_event  ee;

    /*
     * when the file descriptor is closed the epoll automatically deletes
     * it from its queue so we do not need to delete explicitly the event
     * before the closing the file descriptor
     */

    // 是否是要求事件关闭
    // 当事件关联的文件描述符关闭后，epoll 对象自动将其事件删除
    if (flags & NGX_CLOSE_EVENT) {
        // 删除事件成功，读写事件都不活跃
        c->read->active = 0;
        c->write->active = 0;
        return NGX_OK;
    }

    ngx_log_debug1(NGX_LOG_DEBUG_EVENT, c->log, 0,
                   "epoll del connection: fd:%d", c->fd);

    // 直接删除所有的事件
    op = EPOLL_CTL_DEL;
    ee.events = 0;
    ee.data.ptr = NULL;

    // 执行系统调用，直接删除 epoll 关注事件
    if (epoll_ctl(ep, op, c->fd, &ee) == -1) {
        ngx_log_error(NGX_LOG_ALERT, c->log, ngx_errno,
                      "epoll_ctl(%d, %d) failed", op, c->fd);
        return NGX_ERROR;
    }

    // 删除事件成功，读写事件都不活跃
    c->read->active = 0;
    c->write->active = 0;

    return NGX_OK;
}

事件处理方法 -- ngx_epoll_process_events

• ngx_epoll_process_events 方法会收集当前触发的所有事件，对于不需要加入到 post 队列延后处理的事件，该方法会立刻执行对应的回调方法，这其实是在做分发事件的工作，只是在 epoll 的进程中调用这些回调方法，因此，每一个回调方法都不能导致进程休眠或者消耗太多的时间，以免 epoll 不能即时地处理其他事件；

// 处理已准备就绪的事件
// epoll 模块核心功能，调用 epoll_wait 处理发生的事件
// 使用 event_list 和 nevents 获取内核返回的事件
// timer 是无事件发生时最多等待的时间，即超时时间
// 如果 ngx_event_find_timer 返回 timer==0，那么 epoll 不会等待，立即返回
// 函数可以分为两部分，一是用 epoll 获得事件，二是处理事件，加入延后队列
// 函数里不处理定时器，因为定时器不属于 epoll 事件
static ngx_int_t
ngx_epoll_process_events(ngx_cycle_t *cycle, ngx_msec_t timer, ngx_uint_t flags)
{
    int                events;
    uint32_t           revents;
    ngx_int_t          instance, i;
    ngx_uint_t         level;
    ngx_err_t          err;
    ngx_event_t       *rev, *wev;
    ngx_queue_t       *queue;
    ngx_connection_t  *c;

    /* NGX_TIMER_INFINITE == INFTIM */

    ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                   "epoll timer: %M", timer);

    // 如果使用负载均衡且抢到了 accept 锁，那么 flags 里有 NGX_POST_EVENTS 标志
    // 如果没有设置更新缓存时间的精度，那么 flags 里有 NGX_UPDATE_TIME

    // 调用 epoll_wait 在规定的 timer 时间内等待监控的事件准备就绪
    // 调用 epoll_wait 处理发生的事件
    // 使用 event_list 和 nevents 获取内核返回的事件
    // 返回值 events 是实际获得的事件数量
    // epoll_wait 等待最多 timer 时间后返回
    // 如果 epoll 有事件发生，那么等待时间 timer 无意义，epoll_wait 立即返回
    // 如果 ngx_event_find_timer 返回 timer==0，那么 epoll 不会等待，立即返回
    events = epoll_wait(ep, event_list, (int) nevents, timer);

    // 检查是否发生了错误
    // 如果调用 epoll_wait 获得了 0 个或多个事件，就没有错误
    err = (events == -1) ? ngx_errno : 0;

    // 如果要求更新时间，或者收到了更新时间的信号
    // 通常 event 模块调用时总会传递 NGX_UPDATE_TIME，这时就会更新缓存的时间
    // sigalarm 信号的处理函数设置 ngx_event_timer_alarm 变量
    //
    // 若没有设置 timer_resolution 配置项时，
    // NGX_UPDATE_TIME 标志表示每次调用 epoll_wait 函数返回后需要更新时间
    // 若设置 timer_resolution 配置项，
    // 则每隔 timer_resolution 配置项参数会设置 ngx_event_timer_alarm 为 1，表示需要更新时间
    if (flags & NGX_UPDATE_TIME || ngx_event_timer_alarm) {
        // in ngx_times.c，系统调用，更新缓存事件
        // 更新时间，将时间缓存到一组全局变量中，方便程序高效获取事件 
        ngx_time_update();
    }

    // 错误处理
    // 处理 epoll_wait 的错误
    if (err) {

        // 错误是由信号中断引起的
        if (err == NGX_EINTR) {

            // 如果是更新时间的信号，那么就不是错误
            if (ngx_event_timer_alarm) {
                ngx_event_timer_alarm = 0;
                return NGX_OK;
            }

            level = NGX_LOG_INFO;

        } else {
            level = NGX_LOG_ALERT;
        }

        ngx_log_error(level, cycle->log, err, "epoll_wait() failed");
        return NGX_ERROR;
    }

    // 若 epoll_wait 返回的事件数 events 为 0，则有两种可能
    // 1、超时返回，即时间超过 timer
    // 2、在限定的 timer 时间内返回，此时表示出错 error 返回
    //
    // 0 个事件，说明 nginx 没有收到任何请求或者数据收发
    if (events == 0) {
        // #define NGX_TIMER_INFINITE  (ngx_msec_t) -1
        // 不是无限等待，在很短的时间里无事件发生，是正常现象
        if (timer != NGX_TIMER_INFINITE) {
            return NGX_OK;
        }

        // 无限等待，却没有任何事件， 出错了
        ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
                      "epoll_wait() returned no events without timeout");
        return NGX_ERROR;
    }

    // 遍历由 epoll_wait 返回的所有已准备就绪的事件，并处理这些事件
    // 调用 epoll_wait 获得了多个事件，存储在 event_list 里，共 events 个
    // 遍历 event_list 数组，逐个处理事件
    for (i = 0; i < events; i++) {

        // 从 epoll 结构体的 union.ptr 获得连接对象指针
        // 获取与事件关联的连接对象
        // 连接对象地址的最低位保存的是添加事件时设置的事件过期标志位
        c = event_list[i].data.ptr;

        // 获取事件过期标志位，即连接对象地址的最低位
        // 因为目前的32位/64位的计算机指针地址低位都是0（字节对齐）
        // 所以用最低位来存储instance标志，即一个bool值
        // 在真正取出连接对象时需要把低位的信息去掉
        instance = (uintptr_t) c & 1;

        // 屏蔽连接对象的最低位，即获取连接对象的真正地址
        // 此时才是真正的连接对象指针
        c = (ngx_connection_t *) ((uintptr_t) c & (uintptr_t) ~1);

        // 获取读事件
        // 优先查看连接里的读事件
        rev = c->read;

        // fd == -1 描述符无效
        // instance 不对，连接有错误
        //
        // 同一连接的读写事件的 instance 标志位是相同的
        // 若 fd 描述符为 -1，或连接对象读事件的 instance 标志位不相同，则判为过期事件
        if (c->fd == -1 || rev->instance != instance) {

            /*
             * the stale event from a file descriptor
             * that was just closed in this iteration
             */

            ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                           "epoll: stale event %p", c);
            continue;
        }

        // 获取 epoll 的事件标志
        // 获取连接对象中已准备就绪的事件类型
        revents = event_list[i].events;

        ngx_log_debug3(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                       "epoll: fd:%d ev:%04XD d:%p",
                       c->fd, revents, event_list[i].data.ptr);

        // EPOLLERR|EPOLLHUP 是发生了错误
        // 记录 epoll_wait 的错误返回状态
        // EPOLLERR 表示连接出错；EPOLLHUP 表示收到 RST 报文；
        // 检测到上面这两种错误时，TCP 连接中可能存在未读取的数据；
        if (revents & (EPOLLERR|EPOLLHUP)) {
            ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                           "epoll_wait() error on fd:%d ev:%04XD",
                           c->fd, revents);

            /*
             * if the error events were returned, add EPOLLIN and EPOLLOUT
             * to handle the events at least in one active handler
             */

            revents |= EPOLLIN|EPOLLOUT;
        }

#if 0
        if (revents & ~(EPOLLIN|EPOLLOUT|EPOLLERR|EPOLLHUP)) {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
                          "strange epoll_wait() events fd:%d ev:%04XD",
                          c->fd, revents);
        }
#endif

        // 发生了错误，但没有 EPOLLIN|EPOLLOUT 的读写事件
        // 则将 EPOLLIN、EPOLLOUT 添加到 revents 中
        // 即在调用读写事件时能够处理连接的错误
        //if ((revents & (EPOLLERR|EPOLLHUP))
        //     && (revents & (EPOLLIN|EPOLLOUT)) == 0)
        //{
        //    /*
        //     * if the error events were returned without EPOLLIN or EPOLLOUT,
        //     * then add these flags to handle the events at least in one
        //     * active handler
        //     */

        //    // 加上一个读写事件，保证后续有 handler 可以处理
        //    // 实际上会由读事件来处理
        //    revents |= EPOLLIN|EPOLLOUT;
        //}

        // 有读事件，且读事件是可用的
        if ((revents & EPOLLIN) && rev->active) {

#if (NGX_HAVE_EPOLLRDHUP)
            // EPOLLRDHUP 表示连接对端关闭了读取端
            if (revents & EPOLLRDHUP) {
                rev->pending_eof = 1;
            }
#endif

            // 读事件可用
            // 这里要区分 active 与 ready
            // active 是指事件被添加到 epoll 对象的监控中
            // ready 表示被监控的事件已经准备就绪，即可以对其进程 IO 处理
            rev->ready = 1;

            // nginx 1.17.5 新增, 用在 ngx_recv 时检查
            rev->available = -1;

            // NGX_POST_EVENTS 表示已准备就绪的事件需要延迟处理
            // 根据 accept 标志位将事件加入到相应的队列中
            //
            // 检查此事件是否要延后处理
            // 如果使用负载均衡且抢到 accept 锁，那么 flags 里有 NGX_POST_EVENTS 标志
            // 1.9.x 使用 reuseport，那么就不延后处理
            if (flags & NGX_POST_EVENTS) {
                // 是否是接受请求的事件，两个延后处理队列
                queue = rev->accept ? &ngx_posted_accept_events
                                    : &ngx_posted_events;

                // 暂不处理，而是加入延后处理队列
                // 加快事件的处理速度，避免其他进程的等待
                // in ngx_event_posted.h,函数宏
                ngx_post_event(rev, queue);

            } else {
                // 不 accept 的进程不需要入队，直接处理
                // 不延后，立即调用读事件的 handler 回调函数处理事件
                // 1.9.x reuseport 直接处理，省去了入队列出队列的成本，更快
                //
                // 若不延迟处理，则直接调用事件的处理函数
                rev->handler(rev);
            }
        }

        // 读事件处理完后再查看连接里的写事件
        wev = c->write;

        // 有写事件，且写事件是可用的
        if ((revents & EPOLLOUT) && wev->active) {

            // fd == -1 描述符无效
            // instance 不对，连接有错误
            // 检查写事件是否过期
            if (c->fd == -1 || wev->instance != instance) {

                /*
                 * the stale event from a file descriptor
                 * that was just closed in this iteration
                 */

                ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                               "epoll: stale event %p", c);
                continue;
            }

            // 写事件可用
            wev->ready = 1;

            // 1.10 新增，使用 complete 标记多线程异步操作已经完成
#if (NGX_THREADS)
            wev->complete = 1;
#endif

            // 检查此事件是否要延后处理
            // 1.9.x 使用 reuseport，那么就不延后处理
            if (flags & NGX_POST_EVENTS) {
                // 暂不处理，而是加入延后处理队列
                // 加快事件的处理速度，避免其他进程的等待
                // 写事件只有一个队列
                // in ngx_event_posted.h, 函数宏
                ngx_post_event(wev, &ngx_posted_events);

            } else {
                // 不 accept 的进程不需要入队，直接处理
                // 不延后，立即调用写事件的 handler 回调函数处理事件
                // 1.9.x reuseport 直接处理，省去了入队列出队列的成本，更快
                wev->handler(wev);
            }
        }
    }       //for循环结束，处理完epoll_wait获得的内核事件

    return NGX_OK;
}

释放销毁方法 -- ngx_epoll_done

// epoll 模块结束工作，关闭 epoll 句柄和通知句柄，释放内存
static void
ngx_epoll_done(ngx_cycle_t *cycle)
{
    // 关闭 epoll 句柄
    if (close(ep) == -1) {
        ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                      "epoll close() failed");
    }

    ep = -1;

#if (NGX_HAVE_EVENTFD)

    // 关闭通知句柄
    if (close(notify_fd) == -1) {
        ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                      "eventfd close() failed");
    }

    notify_fd = -1;

#endif

// aio 相关数据回收处理
#if (NGX_HAVE_FILE_AIO)

    if (ngx_eventfd != -1) {

        if (io_destroy(ngx_aio_ctx) == -1) {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                          "io_destroy() failed");
        }

        if (close(ngx_eventfd) == -1) {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                          "eventfd close() failed");
        }

        ngx_eventfd = -1;
    }

    ngx_aio_ctx = 0;

#endif

    // 释放内存，vector.clear()
    ngx_free(event_list);

    // 置为空指针和 0，安全
    event_list = NULL;
    nevents = 0;
}

参考致谢
本博客为博主的学习实践总结，并参考了众多博主的博文，在此表示感谢，博主若有不足之处，请批评指正。

【1】深入理解 Nginx 模块开发与架构解析

【2】理解 Nginx 源码

【3】Nginx学习之七-模块ngx_epoll_module详解（epoll机制在nginx中的实现）

【4】nginx epoll详解

【5】关于ngx_epoll_add_event的一些解释