nginx事件初始化

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指令的时候，将调用此回调函数。此函数的大概分析如下： 

 

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

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的代码分析如下：

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

 

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

 

本文摘自：http://blog.csdn.net/marcky/article/details/6025647感谢作者