ngx_init_cycle

文链接地址: 

nginx启动最重要的部分是在ngx_init_cycle中，我们接下来就会详细的分析这个函数，以及相关的函数.

下面就是ngx_init_cycle的流程图

首先先来看几个相关的数据结构。 在nginx中，模块的结构是这样子的，首先所有的模块都是用ngx_module_t来表示，而模块又分为三类，分别是 ngx_core_module_t和ngx_http_module_t，而在ngx_module_t中会包含这两个结构，只不过不同类的模块包含不 同的结构。一般来说这部分就叫做ctx，我们写模块都会先定义一个ctx，然后包含到ngx_module_t中。这里有个type域用来标识模块的类 型。

 

struct ngx_module_s {
void  ****conf_ctx;
//ctx索引
    ngx_uint_t            ctx_index;
    ngx_uint_t            index;
........................................................
    ngx_uint_t            version;
//ctx
    void                 *ctx;
    ngx_command_t        *commands;
    ngx_uint_t            type;
 
    ngx_int_t           (*init_master)(ngx_log_t *log);
 
    ngx_int_t           (*init_module)(ngx_cycle_t *cycle);
 
    ngx_int_t           (*init_process)(ngx_cycle_t *cycle);
    ngx_int_t           (*init_thread)(ngx_cycle_t *cycle);
    void                (*exit_thread)(ngx_cycle_t *cycle);
    void                (*exit_process)(ngx_cycle_t *cycle);
 
    void                (*exit_master)(ngx_cycle_t *cycle);
.............................................................
};

这里看到有两个index，分别是ctx_index和index，他们的区别是这样子的，ctx_index保存了每一个http module的config的索引，而所有的http module config是分别保存在nginx_conf_t的ctx数组中的.而index保存了每一个core module的config，而每个core module的config都是保存在cycle的conf_ctx中的，下面的代码能够很明显看出他们的不同。

#define ngx_http_conf_get_module_main_conf(cf, module)                        \
    ((ngx_http_conf_ctx_t *) cf->ctx)->main_conf[module.ctx_index]
 
#define ngx_get_conf(conf_ctx, module)  conf_ctx[module.index]

ngx_core_module_t都包括(log, event, event_openssl, http, mail,google perftools)，可以看到http module本身也是一个core module。这里要注意还有一个conf module，只不过它也是用core module这个数据结构。

typedef struct {
    ngx_str_t             name;
    void               *(*create_conf)(ngx_cycle_t *cycle);
    char               *(*init_conf)(ngx_cycle_t *cycle, void *conf);
} ngx_core_module_t;

ngx_http_module_t包括所有src/http/下面的模块，它就包含了所有的http module，它们都从属于http core模块。

typedef struct {
    ngx_int_t   (*preconfiguration)(ngx_conf_t *cf);
    ngx_int_t   (*postconfiguration)(ngx_conf_t *cf);
 
    void       *(*create_main_conf)(ngx_conf_t *cf);
    char       *(*init_main_conf)(ngx_conf_t *cf, void *conf);
 
    void       *(*create_srv_conf)(ngx_conf_t *cf);
    char       *(*merge_srv_conf)(ngx_conf_t *cf, void *prev, void *conf);
 
    void       *(*create_loc_conf)(ngx_conf_t *cf);
    char       *(*merge_loc_conf)(ngx_conf_t *cf, void *prev, void *conf);
} ngx_http_module_t;

然后我们看到在ngx_module_t中还有一个很重要的域，那就是ngx_command_t,这个域对应了当前的模块所包含的所有指令，这个域主要是供nginx解析配置文件时使用，设置相关的数据结构。

struct ngx_command_s {
    ngx_str_t             name;
    ngx_uint_t            type;
//指令对应的回调函数。
    char               *(*set)(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
    ngx_uint_t            conf;
    ngx_uint_t            offset;
    void                 *post;
};

上面只是简单的介绍几个数据结构，接下来配合代码，我们会看到这些结构中的回调函数，域都是如何被调用，以及调用顺序是如何的。

来看ngx_init_cycle，这个函数比较长，我们只分析我们关心的部分。这里要注意，下面的代码是完全按照顺序进行分析的，因为这里我们非常关注这些回调函数什么的顺序。

下面这段代码片段主要是创建所有core module的configure.它通过调用每个core module的create_conf方法，来创建对应的conf，然后将这个conf对象保存在全局的conf_ctx中，这样后面如果想取得这个 config对象，则之需要通过简单的索引就能得到。

    for (i = 0; ngx_modules[i]; i++) {
        if (ngx_modules[i]->type != NGX_CORE_MODULE) {
            continue;
        }
//得到core module
        module = ngx_modules[i]->ctx;
//如果create_conf存在，则直接创建config.
        if (module->create_conf) {
            rv = module->create_conf(cycle);
            if (rv == NULL) {
                ngx_destroy_pool(pool);
                return NULL;
            }
//保存config.
            cycle->conf_ctx[ngx_modules[i]->index] = rv;
        }
    }

当所有的core module的config都创建完毕后，就要开始解析配置文件了，解析配置文件它会一行行读取，然后如果遇到指令，则会查找到对应的 ngx_command_t对象，然后执行对应的回调set方法。这里所有动作都在ngx_conf_parse这个函数中进行.
这里要注意一个 东西，那就是commands是分两种类型的，一种是一般的命令，这里之需要直接调用set进行设置，而另外一种就是命令本身包括大括号的，比如 types, geo,http 这些，这些命令的话，nginx这里是通过在命令本身的set函数里面设置conf的hand来做的，我们来看下types的set回调 ngx_http_core_types。

他的代码很简单，就是设置对应的handler，保存当前的cf，然后调用ngx_conf_parse继续解析下面的，最后解析完毕(也就是当前的命令结束),恢复conf。

static char *
ngx_http_core_types(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
{
    ngx_http_core_loc_conf_t *clcf = conf;
 
    char        *rv;
    ngx_conf_t   save;
...............................
//保存conf
    save = *cf;
//设置handler
    cf->handler = ngx_http_core_type;
    cf->handler_conf = conf;
//继续解析
    rv = ngx_conf_parse(cf, NULL);
//恢复conf
    *cf = save;
    return rv;
}

然后在ngx_conf_parse会判断cf是否有handler回调，如果有的话，优先调用handler回调，如果没有，则会进入ngx_conf_handler进行一般处理。

//如果handler存在，则调用handler
        if (cf->handler) {
 
            /*
             * the custom handler, i.e., that is used in the http's
             * "types { ... }" directive
             */
 
            rv = (*cf->handler)(cf, NULL, cf->handler_conf);
            if (rv == NGX_CONF_OK) {
                continue;
            }
            goto failed;
        }
//否则进入一般的处理，
        rc = ngx_conf_handler(cf, rc);

下面就是ngx_conf_handler的片段，代码很简单，就是遍历模块的command，比较名字，然后调用回调函数set。

    for (i = 0; ngx_modules[i]; i++) {
 
        /* look up the directive in the appropriate modules */
 
        if (ngx_modules[i]->type != NGX_CONF_MODULE
            && ngx_modules[i]->type != cf->module_type)
        {
            continue;
        }
 
        cmd = ngx_modules[i]->commands;
        if (cmd == NULL) {
            continue;
        }
 
        for ( /* void */ ; cmd->name.len; cmd++) {
................................................
//调用set。
            rv = cmd->set(cf, cmd, conf);
 
            if (rv == NGX_CONF_OK) {
                return NGX_OK;
            }

ok，接下来或许有个疑问，那就是前面只是创建了core module的config，然后解析配置文件的时候会保存http module的config的一些东西，那么http module相关的config在那里创建呢？

http module相关的config是在ngx_http_block中创建的，在ngx_http_block中会创建，初始化，合并config，以及整个http handler phase的初始化等等。

首先是初始化所有的http module的ctx_index.

    ngx_http_max_module = 0;
    for (m = 0; ngx_modules[m]; m++) {
        if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
            continue;
        }
//每个模块都有自己对应的索引值.
        ngx_modules[m]->ctx_index = ngx_http_max_module++;
    }

然后就是创建http module的对应的main,srv,loc config,这里很简单就是调用对应的create_xxx_conf回调函数。这里可以看到所有的http module相关的config都是保存在ngx_http_conf_ctx_t中。ngx_http_conf_ctx_t这个结构很简单，就是保存 了三个数组，分别是main,srv,loc 的conf，其中每个都保存了所有的http module的对应的conf。

typedef struct {
    void        **main_conf;
    void        **srv_conf;
    void        **loc_conf;
} ngx_http_conf_ctx_t;

接下来来看ngx_http_block剩下的代码。

    ngx_http_conf_ctx_t         *ctx;
//开始初始化，可以看到默认会分配max个config
    ctx->main_conf = ngx_pcalloc(cf->pool,
                                 sizeof(void *) * ngx_http_max_module);
    if (ctx->main_conf == NULL) {
        return NGX_CONF_ERROR;
    }
//下面省略了srv和loc的创建
.......................................
 
//开始遍历
    for (m = 0; ngx_modules[m]; m++) {
        if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
            continue;
        }
//得到对应的module上下文
        module = ngx_modules[m]->ctx;
//得到对应的索引
        mi = ngx_modules[m]->ctx_index;
//如果有对应的回调，则调用回调函数，然后将返回的模块config设置到ctx的对应的conf列表中。
        if (module->create_main_conf) {
            ctx->main_conf[mi] = module->create_main_conf(cf);
            if (ctx->main_conf[mi] == NULL) {
                return NGX_CONF_ERROR;
            }
        }
        if (module->create_srv_conf) {
            ctx->srv_conf[mi] = module->create_srv_conf(cf);
            if (ctx->srv_conf[mi] == NULL) {
                return NGX_CONF_ERROR;
            }
        }
//下面省略了loc的调用。
    }

而当创建完毕之后，真正初始化模块之前需要调用preconfiguration来进行一些操作。

    cf->ctx = ctx;
 
    for (m = 0; ngx_modules[m]; m++) {
        if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
            continue;
        }
 
        module = ngx_modules[m]->ctx;
//调用preconfiguration。
        if (module->preconfiguration) {
            if (module->preconfiguration(cf) != NGX_OK) {
                return NGX_CONF_ERROR;
            }
        }
    }

然后就是继续parse config.

cf->module_type = NGX_HTTP_MODULE;
cf->cmd_type = NGX_HTTP_MAIN_CONF;
rv = ngx_conf_parse(cf, NULL);

当http block完全parse完毕之后，就需要merge(main和srv或者srv和loc)相关的config了。不过在每次merge之前都会首先初始化main conf。

    for (m = 0; ngx_modules[m]; m++) {
        if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
            continue;
        }
//和上面类似，首先取得模块以及对应索引。
        module = ngx_modules[m]->ctx;
        mi = ngx_modules[m]->ctx_index;
 
        /* init http{} main_conf's */
//如果有init_main_conf,则首先初始化main conf.
        if (module->init_main_conf) {
            rv = module->init_main_conf(cf, ctx->main_conf[mi]);
            if (rv != NGX_CONF_OK) {
                goto failed;
            }
        }
//然后开始merge config。
        rv = ngx_http_merge_servers(cf, cmcf, module, mi);
        if (rv != NGX_CONF_OK) {
            goto failed;
        }
    }

所有的merge动作都在ngx_http_merge_servers中，这个函数这里就不分析了，他主要就是遍历所有的server，然后判断模块是否有merge回调函数，如果有的话，就调用回调函数。

这里对location的处理部分就不进行分析了，这里是一个很复杂的地方，以后会专门写一篇blog来分析这部分。

当merge完毕之后，然后就是初始化location tree，创建handler phase，调用postconfiguration，以及变量的初始化。

//初始化handler phase
    if (ngx_http_init_phases(cf, cmcf) != NGX_OK) {
        return NGX_CONF_ERROR;
    }
//遍历模块，然后调用对应的postconfiguration.
    for (m = 0; ngx_modules[m]; m++) {
        if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
            continue;
        }
 
        module = ngx_modules[m]->ctx;
//调用回调
        if (module->postconfiguration) {
            if (module->postconfiguration(cf) != NGX_OK) {
                return NGX_CONF_ERROR;
            }
        }
    }
//开始初始化变量
    if (ngx_http_variables_init_vars(cf) != NGX_OK) {
        return NGX_CONF_ERROR;
    }

当这些都做完之后，就开始初始化socket相关的东西，比如设置读写回调函数等等，这个会在下一篇详细分析。

/* optimize the lists of ports, addresses and server names */
if (ngx_http_optimize_servers(cf, cmcf, cmcf->ports) != NGX_OK) {
    return NGX_CONF_ERROR;
}

再接着看ngx_cycle_init剩下的部分，当配置文件解析完毕后，就开始初始化core module的config

    for (i = 0; ngx_modules[i]; i++) {
        if (ngx_modules[i]->type != NGX_CORE_MODULE) {
            continue;
        }
 
        module = ngx_modules[i]->ctx;
//调用init_conf
        if (module->init_conf) {
            if (module->init_conf(cycle, cycle->conf_ctx[ngx_modules[i]->index])
                == NGX_CONF_ERROR)
            {
                environ = senv;
                ngx_destroy_cycle_pools(&conf);
                return NULL;
            }
        }
    }

再紧接着就是初始化所有创建的共享内存。

if (ngx_shm_alloc(&shm_zone[i].shm) != NGX_OK) {
    goto failed;
}
 
if (ngx_init_zone_pool(cycle, &shm_zone[i]) != NGX_OK) {
    goto failed;
}
 
if (shm_zone[i].init(&shm_zone[i], NULL) != NGX_OK) {
    goto failed;
}

然后是listen socket的初始化，这里还记得前面的http_block中也有socket的初始化，这里要注意，那边只是挂载对应的hook，这里才是创建并bind等操作。

if (ngx_open_listening_sockets(cycle) != NGX_OK) {
    goto failed;
}

等这些都做完则是调用init_module对所有的模块进行初始化。

for (i = 0; ngx_modules[i]; i++) {
    if (ngx_modules[i]->init_module) {
        if (ngx_modules[i]->init_module(cycle) != NGX_OK) {
            /* fatal */
            exit(1);
        }
    }
}

然后ngx_init_cycle剩下就是一些清理工作了。