【Nginx】ngx_event_core_module模块

ngx_event_core_module模块属于事件模块，它是其它事件类模块的基础。它主要完成以下任务：

• 创建连接池
• 决定使用哪些事件驱动机制
• 初始化将要使用的事件模块

下面分析该模块的代码。

ngx_event_core_module的ngx_command_t数组定义如下：

/* ngx_event_core_module对7个配置项感兴趣 */
static ngx_command_t  ngx_event_core_commands[] = {
    /* 一个worker进程的最大TCP连接数 */
    {
        ngx_string("worker_connections"),
        NGX_EVENT_CONF|NGX_CONF_TAKE1,
        ngx_event_connections,
        0,
        0,
        NULL
    },
    /* 同上 */
    {
        ngx_string("connections"),
        NGX_EVENT_CONF|NGX_CONF_TAKE1,
        ngx_event_connections,
        0,
        0,
        NULL
    },
    /* 确定选择哪一个事件模块作为事件驱动机制 */
    {
        ngx_string("use"),
        NGX_EVENT_CONF|NGX_CONF_TAKE1,
        ngx_event_use,
        0,
        0,
        NULL
    },
    /* 当有连接事件时，尽可能多地建立连接 */
    {
        ngx_string("multi_accept"),
        NGX_EVENT_CONF|NGX_CONF_FLAG,
        ngx_conf_set_flag_slot,
        0,
        offsetof(ngx_event_conf_t, multi_accept),
        NULL
    },
    /* 确定是否使用负载均衡锁 */
    {
        ngx_string("accept_mutex"),
        NGX_EVENT_CONF|NGX_CONF_FLAG,
        ngx_conf_set_flag_slot,
        0,
        offsetof(ngx_event_conf_t, accept_mutex),
        NULL
    },
    /* 启用负载均衡锁后，延迟accept_mutex_delay毫秒再处理新连接事件 */
    {
        ngx_string("accept_mutex_delay"),
        NGX_EVENT_CONF|NGX_CONF_TAKE1,
        ngx_conf_set_msec_slot,
        0,
        offsetof(ngx_event_conf_t, accept_mutex_delay),
        NULL
    },
    /* 对指定IP的TCP连接打印debug级别的调试日志 */
    {
        ngx_string("debug_connection"),
        NGX_EVENT_CONF|NGX_CONF_TAKE1,
        ngx_event_debug_connection,
        0,
        0,
        NULL
    },
    ngx_null_command
}; 

有几个配置项的解析使用的是Nginx预设的方法，解析出来的参数存放在ngx_event_conf_t结构体中，该结构体定义如下：

/* 对应ngx_event_core_commands数组中解析配置项的7个方法 */
typedef struct {
    ngx_uint_t    connections;  /* 连接池大小 */
    ngx_uint_t    use;          /* 该模块在事件模块中的编号，也就是ngx_module_s.ctx_index */
    ngx_flag_t    multi_accept; /* 1表示一次建立尽可能多的连接 */
    ngx_flag_t    accept_mutex; /* 1表示启用负载均衡锁 */
    ngx_msec_t    accept_mutex_delay;   /* 拿不到负载均衡锁时延迟建立连接的时间 */
    u_char       *name;         /* 所选用事件模块的名字 */
#if (NGX_DEBUG)
    ngx_array_t   debug_connection; /* 调试用 */
#endif
} ngx_event_conf_t; // 存储事件类配置项的结构体 

下面再看看事件模块的通用接口ngx_event_module_t结构体的定义：

ngx_event_module_t  ngx_event_core_module_ctx = {
    &event_core_name,
    ngx_event_core_create_conf,            /* create configuration */
    ngx_event_core_init_conf,              /* init configuration */
    /* 定义事件驱动模块的核心方法
     * ngx_event_core_module不负责TCP网络事件的驱动，所以无须定义这些方法
     */
    { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
}; 

从上面的通用接口可以看到，ngx_event_core_module模块并没有定义10个抽象方法。因为事件驱动模块是诸如epoll、select这样具有事件驱动机制的模块来担当的，这些模块才需要提供函数接口，以便将事件添加或删除。而ngx_event_core_module模块的作用只是管理更下层的事件驱动模块，例如ngx_epoll_module、ngx_kqueue_module、ngx_poll_module等模块。

下面是整个ngx_module_t结构体的定义：

ngx_module_t  ngx_event_core_module = {
    NGX_MODULE_V1,
    &ngx_event_core_module_ctx,            /* module context */
    ngx_event_core_commands,               /* module directives */
    NGX_EVENT_MODULE,                      /* module type */
    NULL,                                  /* init master */
    ngx_event_module_init,                 /* init module */
    ngx_event_process_init,                /* init process */
    NULL,                                  /* init thread */
    NULL,                                  /* exit thread */
    NULL,                                  /* exit process */
    NULL,                                  /* exit master */
    NGX_MODULE_V1_PADDING
}; 

可以看到，该模块定义了两个函数：ngx_event_module_init和ngx_event_process_init。Nginx启动过程中，在fork出worker进程之前调用ngx_event_module_init，这个函数做一些变量的初始化；在fork出worker进程之后调用ngx_event_process_init，该函数做了较多工作，流程图如下：

此函数的代码在下方，注释中的标号和流程图中的标号相对应：

/* Nginx启动时在fork出worker子进程后调用 */
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;
    ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
    ecf = ngx_event_get_conf(cycle->conf_ctx, ngx_event_core_module);   // 获得存储配置项的结构体
    /* 1、确定使用负载均衡锁的条件
     * 1.1 工作在master模式
     * 1.2 配置文件中打开了负载均衡锁
     * 1.3 worker进程数量大于1
     */
    if (ccf->master && ccf->worker_processes > 1 && ecf->accept_mutex) {
        ngx_use_accept_mutex = 1;   /* 打开负载均衡锁 */
        ngx_accept_mutex_held = 0;
        ngx_accept_mutex_delay = ecf->accept_mutex_delay;   /* 拿不到锁时的延迟时间 */
    } else {
        /* 2、关闭负载均衡锁 */
        ngx_use_accept_mutex = 0;
    }
    /* 3、初始化红黑树实现的定时器 */
    if (ngx_event_timer_init(cycle->log) == NGX_ERROR) {
        return NGX_ERROR;
    }
    for (m = 0; ngx_modules[m]; m++) {
        if (ngx_modules[m]->type != NGX_EVENT_MODULE) {
            continue;
        }
        /* ecf->use中保存了所使用的事件驱动模块的索引号 */
        if (ngx_modules[m]->ctx_index != ecf->use) {
            continue;
        }
        module = ngx_modules[m]->ctx;   /* 获得选中模块的通用接口 */
        /* 4、初始化事件驱动模块模块 */
        if (module->actions.init(cycle, ngx_timer_resolution) != NGX_OK) {
            /* fatal */
            exit(2);
        }
        break;
    }
    /* 当配置文件中设置了timer_resolution配置项，进入这个块来控制时间精度 */
    if (ngx_timer_resolution && !(ngx_event_flags & NGX_USE_TIMER_EVENT)) {
        struct sigaction  sa;
        struct itimerval  itv;
        ngx_memzero(&sa, sizeof(struct sigaction));
        sa.sa_handler = ngx_timer_signal_handler;   /* 信号处理函数 */
        sigemptyset(&sa.sa_mask);
        if (sigaction(SIGALRM, &sa, NULL) == -1) {  /* 安装信号处理程序 */
            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                          "sigaction(SIGALRM) failed");
            return NGX_ERROR;
        }
        itv.it_interval.tv_sec = ngx_timer_resolution / 1000;
        itv.it_interval.tv_usec = (ngx_timer_resolution % 1000) * 1000;
        itv.it_value.tv_sec = ngx_timer_resolution / 1000;
        itv.it_value.tv_usec = (ngx_timer_resolution % 1000 ) * 1000;
        /* 5、设置时间间隔，根据配置项timer_resolution的值，
         * 每隔这么多毫秒回调ngx_timer_signal_handler方法，
         * 该方法置位ngx_event_timer_alarm标志，表示需要更新时间
         */
        if (setitimer(ITIMER_REAL, &itv, NULL) == -1) {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                          "setitimer() failed");
        }
    }
    if (ngx_event_flags & NGX_USE_FD_EVENT) {
        struct rlimit  rlmt;
        if (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                          "getrlimit(RLIMIT_NOFILE) failed");
            return NGX_ERROR;
        }
        cycle->files_n = (ngx_uint_t) rlmt.rlim_cur;
        /* 6、预先分配句柄 */
        cycle->files = ngx_calloc(sizeof(ngx_connection_t *) * cycle->files_n,
                                  cycle->log);
        if (cycle->files == NULL) {
            return NGX_ERROR;
        }
    }
    /* 7、预先分配连接池 */
    cycle->connections = ngx_alloc(sizeof(ngx_connection_t) * cycle->connection_n, cycle->log);
    if (cycle->connections == NULL) {
        return NGX_ERROR;
    }
    c = cycle->connections; // c指向连接池中的一个连接
    /* 8、预先分配读事件，事件个数等于分配的连接个数 */
    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
    }
    /* 9、预先分配写事件，事件个数等于分配的连接个数 */
    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--;
        /* 10、ngx_cycle_t所包含的连接池中，c指向连接池，
         * 一个连接对应一个读事件和一个写事件
         */
        c[i].data = next;   /* 以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);
    /* 11、让free_connections指向空闲链表首部 */
    cycle->free_connections = next;
    cycle->free_connection_n = cycle->connection_n;
    /* for each listening socket */
    ls = cycle->listening.elts;
    for (i = 0; i < cycle->listening.nelts; i++) {
        /* 从空闲连接链表获得ngx_connection_t连接 */
        c = ngx_get_connection(ls[i].fd, cycle->log);
        if (c == NULL) {
            return NGX_ERROR;
        }
        c->log = &ls[i].log;
        c->listening = &ls[i];
        ls[i].connection = c;
        rev = c->read;  /* 连接对应的读事件 */
        rev->log = c->log;
        rev->accept = 1;
        /* 12、定义读事件消费方法，有连接请求事件时调用此方法建立新连接 */
        rev->handler = ngx_event_accept;
        if (ngx_use_accept_mutex) {
            continue;
        }
        /* 13、将监听连接的读事件添加到epoll模块 */
        if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
            return NGX_ERROR;
        }
    }
    return NGX_OK;
} 

至此，ngx_event_core_module模块的启动工作完成，接下来的工作交由epoll事件驱动模块ngx_epoll_module负责，它负责收集、分发等事件。

参考：

《深入理解Nginx》 P305-P310.