Nginx源码分析-事件驱动的初始化

http://blog.csdn.net/marcky/article/details/6025647

转载申明：本文可以任意转载，但需注明原文地址，谢谢！



Nginx的高性能应该算是事件驱动的功劳。Nginx事件处理的相关代码位于src/event目录中，事件驱动是Nginx的核心，所以代码量相对也比较大。事件驱动初始化的过程主要由下图中的三步组成。







第一步：解析配置文件的初始化

在Nginx的启动初始化过程中，将调用ngx_conf_parse()解析配置文件，此过程将遇到类似如下的配置项：

events {

worker_connections 20480;

}

此处的events是一个block指令，在它下面还可以配置很多其他的指令，比如这里的worker_connections等。events下面可以配置的指令定义在数组ngx_event_core_commands（位于src/event/ngx_event.c文件中）中。每个指令都有自己对应的回调函数，events指令的回调函数是ngx_events_block()(位于src/events/ngx_event.c文件中)，即在解析配置文件到events指令的时候，将调用此回调函数。此函数的大概分析如下：



[cpp:nogutter] view
plaincopyprint?

static char *

ngx_events_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)

{

char *rv;

void ***ctx;

ngx_uint_t i;

ngx_conf_t pcf;

ngx_event_module_t *m;

/* 这个源码中的英文注释已经很清楚了。*/

/* count the number of the event modules and set up their indices */

ngx_event_max_module = 0;

for (i = 0; ngx_modules[i]; i++) {

if (ngx_modules[i]->type != NGX_EVENT_MODULE) {

continue;

}

ngx_modules[i]->ctx_index = ngx_event_max_module++;

}

ctx = ngx_pcalloc(cf->pool, sizeof(void *));

if (ctx == NULL) {

return NGX_CONF_ERROR;

}

/*为每个事件模块分配一个指针，用以保存相应配置结构的地址。*/

*ctx = ngx_pcalloc(cf->pool, ngx_event_max_module * sizeof(void *));

if (*ctx == NULL) {

return NGX_CONF_ERROR;

}

*(void **) conf = ctx;

/* 循环调用每个事件模块的create_conf函数，创建配置结构*/

for (i = 0; ngx_modules[i]; i++) {

if (ngx_modules[i]->type != NGX_EVENT_MODULE) {

continue;

}

m = ngx_modules[i]->ctx;

if (m->create_conf) {

(*ctx)[ngx_modules[i]->ctx_index] = m->create_conf(cf->cycle);

if ((*ctx)[ngx_modules[i]->ctx_index] == NULL) {

return NGX_CONF_ERROR;

}

}

}

pcf = *cf;

cf->ctx = ctx;

cf->module_type = NGX_EVENT_MODULE;

cf->cmd_type = NGX_EVENT_CONF;

/* 由于events是一个block指令，events域下还可以配置很多其他指令，

比如use等，现在开始解析events block中的指令，完成初始化工作。*/

rv = ngx_conf_parse(cf, NULL);

*cf = pcf;

if (rv != NGX_CONF_OK)

return rv;

/*循环执行每个事件模块的init_conf函数，初始化配置结构*/

for (i = 0; ngx_modules[i]; i++) {

if (ngx_modules[i]->type != NGX_EVENT_MODULE) {

continue;

}

m = ngx_modules[i]->ctx;

if (m->init_conf) {

rv = m->init_conf(cf->cycle, (*ctx)[ngx_modules[i]->ctx_index]);

if (rv != NGX_CONF_OK) {

return rv;

}

}

}

return NGX_CONF_OK;

}



ngx_events_block()函数中最重要的一个过程就是调用ngx_conf_parse(cf, NULL)，此处调用ngx_conf_parse()的作用就是完成配置文件中events{}这个block的解析，从而调用其下所有的配置指令的回调函数，完成解析配置文件的初始化工作。



第二步：ngx_event_module_init

在《Nginx启动初始化过程(二)》结尾的时候有这样的一段文字——“执行所有模块的init_module操作，看名字为对模块进行初始化。 浏览源码，发现包括几个NGX_CORE_MODULE类型的模块在内的绝大多数模块都没有这个init回调函数。究竟哪些模块才使用这个回调接口呢？动用搜索功能，终于找到了一个模块使用了这个回调接口，它就是ngx_event_core_module。在此，就不纠结这个独特的初始化函数了，到分析事件驱动的时候，再回头看看。”；此处的小标题ngx_event_module_init就是模块ngx_event_core_module的那个回调函数。ngx_event_module_init的代码分析如下：

[cpp:nogutter]
view plaincopyprint?

static ngx_int_t

ngx_event_module_init(ngx_cycle_t *cycle)

{

void ***cf;

u_char *shared;

size_t size, cl;

ngx_shm_t shm;

ngx_time_t *tp;

ngx_core_conf_t *ccf;

ngx_event_conf_t *ecf;



cf = ngx_get_conf(cycle->conf_ctx, ngx_events_module);

if (cf == NULL) {

return NGX_ERROR;

}

/*取得ngx_event_core_module模块的配置结构*/

ecf = (*cf)[ngx_event_core_module.ctx_index];

/*取得ngx_core_module模块的配置结构*/

ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);

/*从ngx_core_module模块的配置结构中获取timer_resolution指令的配置参数*/

ngx_timer_resolution = ccf->timer_resolution;

。。。。。。。。。。。。。。。。。。。。

/*如果关闭了master进程，就不需要下面的步骤了。因为，关闭了master进程就是

单进程方式工作，下面的步骤是创建共享内存实现锁等工作，单进程不需要。

*/

if (ccf->master == 0) {

return NGX_OK;

}

/*已经存在accept互斥体了，不需要再重复创建*/

if (ngx_accept_mutex_ptr) {

return NGX_OK;

}

/* cl should be equal or bigger than cache line size */

cl = 128;

/*后面将会创建size大小的共享内存，这块共享内存将被均分成三段，

分别供ngx_accept_mutex、ngx_connection_counter、ngx_temp_number

使用。

*/

size = cl /* ngx_accept_mutex */

+ cl /* ngx_connection_counter */

+ cl; /* ngx_temp_number */

。。。。。。。。。。。。。。。。。。。。。

/*开始着手创建共享内存，大小为size，命名为nginx_shared_zone*/

shm.size = size;

shm.name.len = sizeof("nginx_shared_zone");

shm.name.data = (u_char *) "nginx_shared_zone";

shm.log = cycle->log;

/*创建起共享内存，共享内存的起始地址保存在shm.addr*/

if (ngx_shm_alloc(&shm) != NGX_OK) {

return NGX_ERROR;

}

/*取得共享内存的起始地址*/

shared = shm.addr;



/*accept互斥体取得共享内存的第一段cl大小内存*/

ngx_accept_mutex_ptr = (ngx_atomic_t *) shared;



/*创建accept互斥体。



accept互斥体的实现依赖是否支持原子操作，如果有相应的原子操作；

就是用取得的这段共享内存来实现accept互斥体；否则，将使用文件

锁来实现accept互斥体。



accept互斥体的作用是：避免惊群和实现worker进程的负载均衡。

*/

if (ngx_shmtx_create(&ngx_accept_mutex, shared, cycle->lock_file.data)

!= NGX_OK)

{

return NGX_ERROR;

}

/*ngx_connection_counter取得共享内存的第二段cl大小内存*/

ngx_connection_counter = (ngx_atomic_t *) (shared + 1 * cl);

(void) ngx_atomic_cmp_set(ngx_connection_counter, 0, 1);



/*ngx_temp_number取得共享内存的第三段cl大小内存*/

ngx_temp_number = (ngx_atomic_t *) (shared + 2 * cl);

。。。。。。。。。。。。。。。。。。。。。。

return NGX_OK;

}





第三步：ngx_event_process_init

在worker进程的分析中，有提到调用每个模块自定义的进程初始化函数。ngx_event_process_init回调函数就是ngx_event_core_commands模块自定义的进程初始化函数。因此，在master进程创建好了一个worker进程后，worker进程首先就会做进程的初始化工作，此时就会调用ngx_event_process_init函数。ngx_event_process_init的代码分析如下：

[cpp:nogutter] view
plaincopyprint?

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);

/*master进程打开，worker进程数大于1，配置了accetp_mutex(默认使用)

时，才使用accept互斥体。

*/

if (ccf->master && ccf->worker_processes > 1 && ecf->accept_mutex) {

ngx_use_accept_mutex = 1; /* 1 使用accept互斥体， 0 不使用*/

ngx_accept_mutex_held = 0; /* ngx_accept_mutex_held代表是否获得accept互斥体*/

ngx_accept_mutex_delay = ecf->accept_mutex_delay; /*抢互斥体失败后，下次再抢的间隔时间*/

} else {

ngx_use_accept_mutex = 0;

}

/*初始化计时器，此处将会创建起一颗红黑色，来维护计时器。*/

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; /*非NGX_EVENT_MODULE跳过*/

}

if (ngx_modules[m]->ctx_index != ecf->use) {

continue;/*非use配置指令指定的模块跳过，Linux默认epoll*/

}

module = ngx_modules[m]->ctx;

/*调用具体事件模块的init函数。



由于Nginx实现了很多的事件模块，比如：epoll，poll，select, kqueue,aio

（这些模块位于src/event/modules目录中）等等，所以Nginx对事件模块进行

了一层抽象，方便在不同的系统上使用不同的事件模型，也便于扩展新的事件

模型。从此过后，将把注意力主要集中在epoll上。



此处的init回调，其实就是调用了ngx_epoll_init函数。module->actions结构

封装了epoll的所有接口函数。Nginx就是通过actions结构将epoll注册到事件

抽象层中。actions的类型是ngx_event_actions_t，位于src/event/ngx_event.h

*/

if (module->actions.init(cycle, ngx_timer_resolution) != NGX_OK) {

/* fatal */

exit(2);

}

break; /*跳出循环，只可能使用一个具体的事件模型*/

}

。。。。。。。。。。。。。。。。。。。。。。。。。

/*创建一个connection数组，维护所有的connection；

本过程已经是在worker进程中了，所以是每个worker都有自己的

connection数组。

*/

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;

}



/*创建一个写事件数组*/

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;

}

i = cycle->connection_n;

next = NULL;



/*初始化整个connection数组，connection数组使用得很是巧妙，

能够快速的获取释放一个连接结构。下一篇画个图来详细看看

这个connection。

*/

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];

} while (i);

cycle->free_connections = next;

cycle->free_connection_n = cycle->connection_n;

/* for each listening socket */



/*为每个监听套接字从connection数组中分配一个连接，即一个slot*/

ls = cycle->listening.elts;

for (i = 0; i < cycle->listening.nelts; i++) {

/*从connection中取得一个新的连接slot*/

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; /*读事件发生，调用accept*/

。。。。。。。。。。。。。。。。。。。。

#if (NGX_WIN32)

。。。。。。。。。。。。。。。。。。。

#else

/*注册监听套接口读事件的回调函数ngx_event_accept*/

rev->handler = ngx_event_accept;

/*使用了accept_mutex，暂时不将监听套接字放入epoll中

而是等到worker抢到accept互斥体后，再放入epoll，避免

惊群的发生。

*/

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 {

/*没有使用accept互斥体，那么就在此处将监听套接字放入

epoll中。

*/

if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {

return NGX_ERROR;

}

}

#endif

}

return NGX_OK;

}



至此，事件驱动的初始化三步曲就分析完了。