NGX --- ACCEPT事件处理

最新推荐文章于 2025-05-18 13:06:57 发布

Dalek

最新推荐文章于 2025-05-18 13:06:57 发布

阅读量1.2k

点赞数

CC 4.0 BY-SA版权

分类专栏： server

本文链接：https://blog.youkuaiyun.com/hellozdd/article/details/9850447

server 专栏收录该内容

14 篇文章

订阅专栏

本文深入探讨了NGINX中ACCEPT事件的处理流程，从ngx_process_events_and_timers函数开始，讲解了如何处理ACCEPT事件，包括ngx_event_process_posted函数的使用以及ngx_event_accept处理函数的注册。文中提到了事件结构ngx_event_s，特别是accept字段和handler钩子函数，指出ngx_event_process_init函数在初始化阶段为ACCEPT事件分配资源并设置处理函数。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

ngx_event_accept



void
ngx_process_events_and_timers(ngx_cycle_t *cycle)
{
    ngx_uint_t  flags;
    ngx_msec_t  timer, delta;
	......


    delta = ngx_current_msec;
    
    // 处理事件ngx_epoll_process_events
    (void) ngx_process_events(cycle, timer, flags);

    delta = ngx_current_msec - delta;

    ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                   "timer delta: %M", delta);
    
    // 这个是ACCEPT 事件队列指针
    if (ngx_posted_accept_events) {
        ngx_event_process_posted(cycle, &ngx_posted_accept_events); //--------->此处处理ACCEPT事件
    }

	......
}
// 事件处理函数
void
ngx_event_process_posted(ngx_cycle_t *cycle,
    ngx_thread_volatile ngx_event_t **posted)
{
    ngx_event_t  *ev;

    for ( ;; ) {

        ev = (ngx_event_t *) *posted;

        ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
                      "posted event %p", ev);

        if (ev == NULL) {
            // 处理完事件后退出循环
            return;
        }
		// 从ngx_posted_accept_events 事件队列上取下事件
        ngx_delete_posted_event(ev);
		
		// 调用事件处理函数处理事件，这里是调用ngx_event_accept处理ACCEPT事件
        ev->handler(ev);
    }
}

// 暂时不看ngx_event_accept的处理流程，先看看事件的结构


struct ngx_event_s {
    void            *data;

    unsigned         write:1;       // 写事件

    unsigned         accept:1;      // accept 事件

    /* used to detect the stale events in kqueue, rtsig, and epoll */
    unsigned         instance:1;    //  用于检测过时事件

    /*
     * the event was passed or would be passed to a kernel;
     * in aio mode - operation was posted.
     */
    unsigned         active:1;      // 

    unsigned         disabled:1;

    /* the ready event; in aio mode 0 means that no operation can be posted */
    unsigned         ready:1;

    unsigned         oneshot:1;

    /* aio operation is complete */
    unsigned         complete:1;
	
	......
	// 事件处理函数钩子函数,这个钩子函数应该是在事件发生的时候注册上去的，是这样吗？
	// 
    ngx_event_handler_pt  handler;      


	......

    /* the links of the posted queue */
    ngx_event_t     *next;
    ngx_event_t    **prev;

	......
};
// 搜索下，看看这个事件处理钩子函数是在什么时候注册上去的，选取其中一部分的内容如下
Ngx_event.c (src\event):            rev->handler = ngx_event_acceptex;
Ngx_event.c (src\event):            ls[i].log.handler = ngx_acceptex_log_error;
Ngx_event.c (src\event):            rev->handler = ngx_event_accept;
Ngx_event.c (src\event):        rev->handler = ngx_event_accept;
Ngx_event.h (src\event):    ngx_event_handler_pt  handler;      // 事件处理函数钩子函数
Ngx_event.h (src\event):    ngx_event_handler_pt       handler;
Ngx_eventport_module.c (src\event\modules):                 * active handler
Ngx_eventport_module.c (src\event\modules):                    rev->handler(rev);
Ngx_eventport_module.c (src\event\modules):                    wev->handler(wev);
Ngx_event_accept.c (src\event):        log->handler = NULL;
Ngx_event_accept.c (src\event):        ls->handler(c);
Ngx_event_busy_lock.c (src\event):        ctx->event->handler = ngx_event_busy_lock_handler;
Ngx_event_busy_lock.c (src\event):            ctx->event->handler = ngx_event_busy_lock_handler;
Ngx_event_busy_lock.c (src\event):            wakeup->handler = ngx_event_busy_lock_posted_handler;
Ngx_event_busy_lock.c (src\event):        wakeup->handler = ngx_event_busy_lock_posted_handler;
Ngx_event_busy_lock.c (src\event):    ev->handler = ngx_event_busy_lock_posted_handler;

// 我们看到，不同的事件被注册了不同的处理函数，这里我们关心ACCEPT事件
// 只有在ngx_event_process_init函数中才有注册ngx_event_accept处理函数

static ngx_int_t
ngx_event_process_init(ngx_cycle_t *cycle)
{
    ngx_uint_t           m, i;
    ngx_event_t         *rev, *wev;
    ngx_listening_t     *ls;
    ngx_connection_t    *c, *next, *old;
    ngx_core_conf_t     *ccf;
    ngx_event_conf_t    *ecf;
    ngx_event_module_t  *module;

	......

#if (NGX_WIN32)
	......

#else
        // 注册ACCEPT事件处理函数
        rev->handler = ngx_event_accept;

        if (ngx_use_accept_mutex) {
            continue;
        }

        if (ngx_event_flags & NGX_USE_RTSIG_EVENT) {
            if (ngx_add_conn(c) == NGX_ERROR) {
                return NGX_ERROR;
            }

        } else {
            if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
                return NGX_ERROR;
            }
        }

#endif

    }

    return NGX_OK;
}
// 按照我们正常的理解，应当时当ACCEPT事件发生的时候，我们生产一个事件
// 结构的事件数据，并且设置为ACCEPT事件，并且设置处理钩子函数。
// 我们再来看下ngx_event_process_init函数的另外一部分代码实现
static ngx_int_t
ngx_event_process_init(ngx_cycle_t *cycle)
{
    ngx_uint_t           m, i;
    ngx_event_t         *rev, *wev;
    ngx_listening_t     *ls;
    ngx_connection_t    *c, *next, *old;
    ngx_core_conf_t     *ccf;
    ngx_event_conf_t    *ecf;
    ngx_event_module_t  *module;

	......

#endif
    // 分配连接池
    cycle->connections =
        ngx_alloc(sizeof(ngx_connection_t) * cycle->connection_n, cycle->log);
    if (cycle->connections == NULL) {
        return NGX_ERROR;
    }
    // 获取连接池地址
    c = cycle->connections;

    // 分配读事件池，有多少连接就有多少事件结构数据
    cycle->read_events = ngx_alloc(sizeof(ngx_event_t) * cycle->connection_n,
                                   cycle->log);
    if (cycle->read_events == NULL) {
        return NGX_ERROR;
    }
    
    // 获取读事件池地址
    rev = cycle->read_events;

    // 设置全部读事件部分属性
    for (i = 0; i < cycle->connection_n; i++) {
        rev[i].closed = 1;
        rev[i].instance = 1;
#if (NGX_THREADS)
        rev[i].lock = &c[i].lock;
        rev[i].own_lock = &c[i].lock;
#endif
    }
    
    // 分配写事件池，有多少连接就有多少事件结构数据
    cycle->write_events = ngx_alloc(sizeof(ngx_event_t) * cycle->connection_n,
                                    cycle->log);
    if (cycle->write_events == NULL) {
        return NGX_ERROR;
    }

    // 获取写事件地址
    wev = cycle->write_events;

    // 设置全部写事件部分属性
    for (i = 0; i < cycle->connection_n; i++) {
        wev[i].closed = 1;
#if (NGX_THREADS)
        wev[i].lock = &c[i].lock;
        wev[i].own_lock = &c[i].lock;
#endif
    }
    // 连接总数
    i = cycle->connection_n;
    next = NULL;

    // 将读写事件挂接到连接数据结构上
    do {
        i--;

        c[i].data = next;
        c[i].read = &cycle->read_events[i];
        c[i].write = &cycle->write_events[i];
        c[i].fd = (ngx_socket_t) -1;

        next = &c[i];

#if (NGX_THREADS)
        c[i].lock = 0;
#endif
    } while (i);

    // 挂接到空闲连接数组上
    cycle->free_connections = next;
    cycle->free_connection_n = cycle->connection_n;
	
#if (NGX_WIN32)
	......

#else
        // 注册ACCEPT事件处理函数
        rev->handler = ngx_event_accept;

        if (ngx_use_accept_mutex) {
            continue;
        }

        if (ngx_event_flags & NGX_USE_RTSIG_EVENT) {
            if (ngx_add_conn(c) == NGX_ERROR) {
                return NGX_ERROR;
            }

        } else {
            if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
                return NGX_ERROR;
            }
        }

#endif
		......
}