【Linux网络编程】Nginx -- 事件模块(三)
【1】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;
}本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
