nginx源码分析--nginx上下文结构初始化
说在前面：
本文的讨论基于的nginx版本是1.2.1。
文章对于nginx的一些背景知识（如什么是模块，上下文等）没有过多提及，本文适合对nginx有一定了解的同学。
ngx_conf_t *cf; 做过nginx模块开发，或者是有学习过nginx源码的同学会对这个结构体非常眼熟了。
ngx_cycle.c:251 conf.ctx = cycle->conf_ctx;
ctx(context)在nginx里随处可见，字面理解是上下文；在nginx里，ctx保存的每个模块的配置结构.
cycle->conf_ctx是一个四重指针，为什么需要四重指针？希望读完本文，会对你理解有一定帮助。
nginx配置文件nginx.conf（文章会围绕这个配置文件，分析nginx解析并保存模块上下文的过程）
1 http {
2 resolver 8.8.8.8;
3
4 server
5 {
6 listen 80;
7 server_name dcshi.com
8 root /data/html
9
10 location /a
11 {
12 set $foo $bar;
13
14 return 200;
15 }
16
17 location /b.html
18 {
19 root /opt/html;
20 }
21
22 }
23
24 server
25 {
26 listen 80;
27 server_name s2.dcshi.com
28
29 location /a {}
30
31 location /b {}
32 }
33 }
与上述配置文件对应的模块上下文(ctx)架构图:
1）ngx_cycle.c
215 for (i = 0; ngx_modules[i]; i++) {
216 if (ngx_modules[i]->type != NGX_CORE_MODULE) {
217 continue;
218 }
219
220 module = ngx_modules[i]->ctx;
/* 如果是核心模块，而且有定义了create_conf，则调用模块的create_conf来创建上下文结构 */
222 if (module->create_conf) {
223 rv = module->create_conf(cycle);
224 if (rv == NULL) {
225 ngx_destroy_pool(pool);
226 return NULL;
227 }
228 cycle->conf_ctx[ngx_modules[i]->index] = rv;
229 }
230 }
2）ngx_cycle.c
/*
* 调取ngx_conf_parse开始解析配置文件(nginx.conf),ngx_conf_parse是一个很通用的函数。
* 参数二是一个文件名，如果传入NULL，则解析当前的block配置。{ }配置文件里两花括号定义一个block。
* /
268 if (ngx_conf_parse(&conf, &cycle->conf_file) != NGX_CONF_OK) {
269 environ = senv;
270 ngx_destroy_cycle_pools(&conf);
271 return NULL;
272 }
3）ngx_conf_file.c：
/*
* 如果指令指定了handler函数，则直接调用
* cf->handler 什么时候不为NULL？后续再讨论。
*/
222 if (cf->handler) {
223
224 /*
225 * the custom handler, i.e., that is used in the http's
226 * "types { ... }" directive
227 */
228
229 rv = (*cf->handler)(cf, NULL, cf->handler_conf);
230 if (rv == NGX_CONF_OK) {
231 continue;
232 }
233
234 if (rv == NGX_CONF_ERROR) {
235 goto failed;
236 }
237
238 ngx_conf_log_error(NGX_LOG_EMERG, cf, 0, rv);
239
240 goto failed;
241 }
242
243
// cf->hanlder为NULL，则调用ngx_conf_handler来遍历所有模块的指令，以触发该指令对应的回调函数。
244 rc = ngx_conf_handler(cf, rc);
4）ngx_conf_file.c
/*
* NGX_DIRECT_CONF为什么是direct(直接)，这类命令字只出现在core模块里
* direct字面理解是需要使用（赋值）时候可以直接拿来使用即可，即在调用前上下文结构已经分配好，如worker_processes指令
* 对应的非direct则需要先分配空间后才能使用，如http指令(http是一个指令，不是一类指令，不要搞混哦！)
* 上面提到的步骤一，nginx在解析配置文件之前，会依次调用NGX_CORE_MODULE 模块的create_conf，
* direct指令的上下文就是这个时候分配的.
*
*/
380 if (cmd->type & NGX_DIRECT_CONF) {
381 conf = ((void **) cf->ctx)[ngx_modules[i]->index];
382
/*
* http指令就是一个NGX_MAIN_CONF指令(怎么确定指令type，请看ngx_command_s定义)
* 细心的同学看到，381行与384行的唯一区别是，后者是返回指针的地址。
* c/c++开发的同学都知道 func(char *p) 与 func(char **p)的区别。后者的func可以对传入的p重新分配内存
* 如http指令为例，http所在模块是ngx_http_module，其没有定义create_conf(ngx_http.c:98)
* 即在步骤一里是不会给ngx_http_module分配上下文结构的，所以需要在ngx_http_block里进行动态分配
* 所以，这就是为什么需要传入的是指针的地址。
* 至于为什么ngx_http_module不也提供create_conf回调，理论上结构更统一？答案留给你们自己思考。
*/
383 } else if (cmd->type & NGX_MAIN_CONF) {
384 conf = &(((void **) cf->ctx)[ngx_modules[i]->index]);
385
386 } else if (cf->ctx) {
/*
* cmd->conf是什么？set指令的conf是 NGX_HTTP_LOC_CONF_OFFSET(ngx_http_rewrite_module.c:81)
* #define NGX_HTTP_LOC_CONF_OFFSET offsetof(ngx_http_conf_ctx_t, loc_conf)
* 通过上面的宏定义，清楚可以知道cmd->conf返回的是一个变量在struct里的偏移
* nginx为每个http模块提供的上下文结构(ngx_http_conf_ctx_t)包括main_conf, srv_conf, loc_conf 三个元素；
* 对于一个指令而言，只会用到上下文结构中的一个*_conf；但对于一个模块（包含多个指令）而言，可能会用到任意多个*_conf。
* set指令可以运行在location和server，set指令的上下文结构又保存在srv_conf or loc_conf？请独立思考来验证自己是否已经对模块有一定理解。
*/
387 confp = *(void **) ((char *) cf->ctx + cmd->conf);
388
389 if (confp) {
390 conf = confp[ngx_modules[i]->ctx_index];
391 }
392 }
393
/* 调用指令对应的回调函数进行初始化操作 */
394 rv = cmd->set(cf, cmd, conf);
通过上面的代码片段，我们可以理解到，nginx是在边解析配置文件，边查找对应的模块指令，并调用指令绑定的回调函数进行初始化。
下面是http指令的定义:
83 static ngx_command_t ngx_http_commands[] = {
84
85 { ngx_string("http"),
86 NGX_MAIN_CONF|NGX_CONF_BLOCK|NGX_CONF_NOARGS,
87 ngx_http_block,
88 0,
89 0,
90 NULL },
91
92 ngx_null_command
93 };
ngx_http_block是一个很重要函数，当nginx在解析配置文件阶段，读取到http指令，即调用ngx_http_block函数对 http {….} 花括号里的配置进行解析。
5）ngx_http.c
120 ngx_http_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
121 {
…...
130
131 /* the main http context */
132
133 ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
134 if (ctx == NULL) {
135 return NGX_CONF_ERROR;
136 }
137
/*
* 注意，传进来的conf被修改了。
* 因为http_module虽是core模块，但是并没有定义create_conf，所以步骤一并没有为http_module分配上下文空间
* http指令是NGX_MAIN_CONF，所以conf传入的实质是一个指针的指针
* 所以通过在这里重新赋值，来为conf分配空间
*/
138 *(ngx_http_conf_ctx_t **) conf = ctx;
139
140
141 /* 为所有的http module计算ctx_index */
142
143 ngx_http_max_module = 0;
144 for (m = 0; ngx_modules[m]; m++) {
145 if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
146 continue;
147 }
148
149 ngx_modules[m]->ctx_index = ngx_http_max_module++;
150 }
151
152
/*
* 为http ctx的的main_conf, srv_conf loc_conf 分配内存；
* 可以看到每个*_conf都是定长的,长度为ngx_http_max_module，
* 即每个模块都会被分配main_conf, srv_conf loc_conf，而不管改模块是否需要。
*/
155 ctx->main_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
…...
167 ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
…….
178 ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
/* 遍历所有的模块，分别调用其回调函数进行初始化 */
189 for (m = 0; ngx_modules[m]; m++) {
190 if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
191 continue;
192 }
193
194 module = ngx_modules[m]->ctx;
195 mi = ngx_modules[m]->ctx_index;
196
197 if (module->create_main_conf) {
198 ctx->main_conf[mi] = module->create_main_conf(cf);
202 }
203
204 if (module->create_srv_conf) {
205 ctx->srv_conf[mi] = module->create_srv_conf(cf);
209 }
210
211 if (module->create_loc_conf) {
212 ctx->loc_conf[mi] = module->create_loc_conf(cf);
216 }
217 }
218
/* 对cf进行一个临时拷贝，在329行重新恢复。 */
219 pcf = *cf;
/*
* 注意：改变cf->ctx的上下文；nginx在解析配置文件的过程中，cf->ctx总会临时修改（最后被恢复）。
* 在解析http {} 的时候cf->ctx表示http_module的上下文结构
* 在解析server{} 的时候cf->ctx表示的是server的上下文结构
* 在解析location{} 的时候，cf->ctx表示的是location的上下文结构
* 可结合文章开头的架构图理解
*/
220 cf->ctx = ctx;
…...
235
236 /* 解析http { }, 依次调用涉及的指令回调函数，server作为http里一个必须的指令，也是在这个时候被调用 */
238 cf->module_type = NGX_HTTP_MODULE;
239 cf->cmd_type = NGX_HTTP_MAIN_CONF;
240 rv = ngx_conf_parse(cf, NULL);
241
242 if (rv != NGX_CONF_OK) {
243 goto failed;
244 }
…..
328
329 *cf = pcf;
6）ngx_http_core_module.c
/*
* 注意：正如第三个参数的命名-dummy(假的)，本函数里没有使用.
* 没有使用传入的conf，那http与server的ctx是怎样串联的？(答案在文章开篇的架构图)
*/
2832 ngx_http_core_server(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
2833 {
……
/* 为server指令分配一个上下文，这个上文终究要跟http的上下文串联起来的 */
2845 ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
2846 if (ctx == NULL) {
2847 return NGX_CONF_ERROR;
2848 }
/*
* 注意：server的ctx->main_conf是直接指向http_ctx（http的ctx，比server ctx更高一级）的main_conf
* 与ngx_http_block不同，这里只对上下文结构里的srv_conf和loc_conf进行内存分配
* 原因很简单，在server里调用的指令不可能用到main_conf的配置结构.
* 相同的道理，location里的指令不可能用到main_conf和srv_conf，所以只需要对loc_conf内存即可(ngx_http_core_location)
* 建议结合文章开篇的架构图理解
*/
2850 http_ctx = cf->ctx;
2851 ctx->main_conf = http_ctx->main_conf;
2852
…….
2855 ctx->srv_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
…….
2862 ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
/* 遍历所有的http module，对分别调用create_srv_conf 和 create_loc_conf进行初始化上下文配置 */
2867 for (i = 0; ngx_modules[i]; i++) {
2868 if (ngx_modules[i]->type != NGX_HTTP_MODULE) {
2869 continue;
2870 }
2871
2872 module = ngx_modules[i]->ctx;
2873
2874 if (module->create_srv_conf) {
2875 mconf = module->create_srv_conf(cf);
2880 ctx->srv_conf[ngx_modules[i]->ctx_index] = mconf;
2881 }
2882
2883 if (module->create_loc_conf) {
2884 mconf = module->create_loc_conf(cf);
2889 ctx->loc_conf[ngx_modules[i]->ctx_index] = mconf;
2890 }
2891 }
/*
* 核心来了，这段代码解释了http_ctx与srv_ctx怎样串联
* 2896, 2897行目的是把整个srv_ctx 先保存在ngx_http_core_module模块的ctx变量里
* 结合架构图理解
*/
2896 cscf = ctx->srv_conf[ngx_http_core_module.ctx_index];
2897 cscf->ctx = ctx;
2898
/*
* 串联了，http_ctx->main_conf(与srv_ctx->main_conf是等价的，还记得2851行吧?)
* 2900 - 2907行展示了串联的逻辑：整个ctx并没有直接串联，实际上是通过ngx_http_core_module模块进行串联的
* cmcf->servers是一个array类型，所以nginx.conf里配置的多个server也被依次串联起来
* 结合架构图理解
* /
2900 cmcf = ctx->main_conf[ngx_http_core_module.ctx_index];
2902 cscfp = ngx_array_push(&cmcf->servers);
2903 if (cscfp == NULL) {
2904 return NGX_CONF_ERROR;
2905 }
2906
2907 *cscfp = cscf;
2908
/* 继续调用ngx_conf_parse对server{ } 进行解析，其中location作为server里的一个指令，也在这个时候被调用。见步骤7 */
2911
2912 pcf = *cf;
2913 cf->ctx = ctx;
2914 cf->cmd_type = NGX_HTTP_SRV_CONF;
2915
2916 rv = ngx_conf_parse(cf, NULL);
2917
/* cf被恢复 */
2918 *cf = pcf;
7) ngx_http_core_module.c
/*
* 注意：正如第三个参数的命名-dummy(假的)，本函数里没有使用.
*/
2956 ngx_http_core_location(ngx_conf_t *cf, ngx_command_t *cmd, void *dummy)
2957 {
…….
2968 ctx = ngx_pcalloc(cf->pool, sizeof(ngx_http_conf_ctx_t));
2969 if (ctx == NULL) {
2970 return NGX_CONF_ERROR;
2971 }
2972
/* 正如上文所说，location里的指令不可能使用main_conf和srv_conf，所以只需要为loc_conf分配空间 */
2973 pctx = cf->ctx;
2974 ctx->main_conf = pctx->main_conf;
2975 ctx->srv_conf = pctx->srv_conf;
2976
2977 ctx->loc_conf = ngx_pcalloc(cf->pool, sizeof(void *) * ngx_http_max_module);
/* 变量所有http module，依次调用create_loc_conf进行上下文初始化操作 */
2982 for (i = 0; ngx_modules[i]; i++) {
2983 if (ngx_modules[i]->type != NGX_HTTP_MODULE) {
2984 continue;
2985 }
2987 module = ngx_modules[i]->ctx;
2988
2989 if (module->create_loc_conf) {
2990 ctx->loc_conf[ngx_modules[i]->ctx_index] = module->create_loc_conf(cf);
2996 }
2997
/*
* 2998 - 3084 与步骤6类似，通过ngx_http_core_module 进行串联
* 结合架构图理解
*/
2998 clcf = ctx->loc_conf[ngx_http_core_module.ctx_index];
2999 clcf->loc_conf = ctx->loc_conf;
3000
…….
3083 pclcf = pctx->loc_conf[ngx_http_core_module.ctx_index];
3084
3085 if (pclcf->name.len) {
……. //location是允许嵌套的，如location /a { location /b { } } ,暂不讨论
3131 }
3132
3133 if (ngx_http_add_location(cf, &pclcf->locations, clcf) != NGX_OK) {
3134 return NGX_CONF_ERROR;
3135 }
/* 继续对location里的指令进行解析；值得注意的是，cf->ctx被修改，指向的是当前location的ctx */
3137 save = *cf;
3138 cf->ctx = ctx;
3139 cf->cmd_type = NGX_HTTP_LOC_CONF;
3140
3141 rv = ngx_conf_parse(cf, NULL);
3142
3143 *cf = save;
3144
3145 return rv;
3146 }
8）ngx_http.c
步骤5, http对应的回调函数是ngx_http_block.在240行完成对整个http { } block的解析以后，nginx还需要合并配置。
从上面的分析，提及到的ctx有http_ctx, srv_ctx, loc_ctx；以loc_conf为例，三个ctx都有包含，而且是互相独立的。
如 root 指令既可以定义在server { } ，也可以定义在location { };
如果location里没有对root进行定义，则location的loc_conf需要继承server { } 的root配置，这就是merge的作用。
下面的代码则展示了，nginx是如何进行merge：
- 分别 merge http_ctx 和 srv_ctx的 srv_conf 和 loc_conf
- merge srv_ctx 和 loc_ctx的loc_conf
251 cmcf = ctx->main_conf[ngx_http_core_module.ctx_index];
252 cscfp = cmcf->servers.elts;
253
254 for (m = 0; ngx_modules[m]; m++) {
255 if (ngx_modules[m]->type != NGX_HTTP_MODULE) {
256 continue;
257 }
258
259 module = ngx_modules[m]->ctx;
260 mi = ngx_modules[m]->ctx_index;
261
262 /* init http{} main_conf's */
263
264 if (module->init_main_conf) {
265 rv = module->init_main_conf(cf, ctx->main_conf[mi]);
266 if (rv != NGX_CONF_OK) {
267 goto failed;
268 }
269 }
270
271 rv = ngx_http_merge_servers(cf, cmcf, module, mi);
272 if (rv != NGX_CONF_OK) {
273 goto failed;
274 }
275 }