您的位置: 首页  >  文章  >  Nginx源码分析 - Event事件篇 - Event模块和配置的初始化

Nginx源码分析 - Event事件篇 - Event模块和配置的初始化

分类: 文章 • 2024-03-24 22:40:58

Event的模块和配置的初始化，必须得结合我们讲过的两篇文章：《Nginx源码分析 - 主流程篇 - 模块的初始化》     和  《Nginx源码分析 - 主流程篇 - 解析配置文件》   

前面我们讲解了模块的初始化以及核心模块的配置文件的解析。而Event的配置解析会比核心模块解析会复杂一些，但是原理是一样的。

Event模块的数据结构

event事件模块的配置：

[cpp] view plain copy
 print?
  1. events {    
  2.         use epoll;    
  3.         worker_connections  1024;    
  4. }    

event事件模块，配置分为两层：ngx_events_module 事件模块 和 ngx_event_core_module 事件核心模块。

ngx_events_module：模块类型NGX_CORE_MODULE，所以此模块在最外层核心模块解析“events”命令的时候会回调ngx_events_block函数。

ngx_event_core_module：模块类型NGX_EVENT_MODULE，所以此模块在ngx_events_block函数被回调后，才能解析配置信息

最外层的events模块，类型NGX_CORE_MODULE，属于核心模块，核心模块在最开始配置文件初始化的时候，就会调用指令的命令集。所以在核心模块启动的时候就会调用events的模块配置解析指令函数：ngx_events_block

ngx_events_module 事件模块

[cpp] view plain copy
 print?
  1. /** 
  2.  * event模块命令集 
  3.  * 回调函数：ngx_events_block 
  4.  * 用于解析 event{} 块中的配置参数 
  5.  */  
  6. static ngx_command_t ngx_events_commands[] = {  
  7.   
  8. { ngx_string("events"), NGX_MAIN_CONF | NGX_CONF_BLOCK | NGX_CONF_NOARGS,  
  9.         ngx_events_block, 0, 0, NULL },  
  10.   
  11. ngx_null_command };  
  12.   
  13. /** 
  14.  * event模块上下文 
  15.  */  
  16. static ngx_core_module_t ngx_events_module_ctx = { ngx_string("events"), NULL,  
  17.         ngx_event_init_conf };  
  18.   
  19. /** 
  20.  * event模块 
  21.  * 模块类型：NGX_CORE_MODULE 
  22.  * 模块类型为核心模块，所以在ngx_init_cycle就会初始化conf 
  23.  */  
  24. ngx_module_t ngx_events_module = { NGX_MODULE_V1, &ngx_events_module_ctx, /* module context */  
  25. ngx_events_commands, /* module directives */  
  26. NGX_CORE_MODULE, /* module type */  
  27. NULL, /* init master */  
  28. NULL, /* init module */  
  29. NULL, /* init process */  
  30. NULL, /* init thread */  
  31. NULL, /* exit thread */  
  32. NULL, /* exit process */  
  33. NULL, /* exit master */  
  34. NGX_MODULE_V1_PADDING };  

ngx_event_core_module 事件核心模块

[cpp] view plain copy
 print?
  1. /** 
  2.  * event核心模块名称 
  3.  */  
  4. static ngx_str_t event_core_name = ngx_string("event_core");  
  5.   
  6. /** 
  7.  * 定义Event核心模块的命令参数 
  8.  * 主要： 
  9.  * worker_connections 工作线程最大连接数 
  10.  * use 使用什么模型，例如epoll 
  11.  * multi_accept 
  12.  * accept_mutex_delay 
  13.  * debug_connection 
  14.  */  
  15. static ngx_command_t ngx_event_core_commands[] = {  
  16.   
  17. { ngx_string("worker_connections"), NGX_EVENT_CONF | NGX_CONF_TAKE1,  
  18.         ngx_event_connections, 0, 0, NULL },  
  19.   
  20.         { ngx_string("use"), NGX_EVENT_CONF | NGX_CONF_TAKE1, ngx_event_use, 0,  
  21.                 0, NULL },  
  22.   
  23.         { ngx_string("multi_accept"), NGX_EVENT_CONF | NGX_CONF_FLAG,  
  24.                 ngx_conf_set_flag_slot, 0, offsetof(ngx_event_conf_t,  
  25.                         multi_accept), NULL },  
  26.   
  27.         { ngx_string("accept_mutex"), NGX_EVENT_CONF | NGX_CONF_FLAG,  
  28.                 ngx_conf_set_flag_slot, 0, offsetof(ngx_event_conf_t,  
  29.                         accept_mutex), NULL },  
  30.   
  31.         { ngx_string("accept_mutex_delay"), NGX_EVENT_CONF | NGX_CONF_TAKE1,  
  32.                 ngx_conf_set_msec_slot, 0, offsetof(ngx_event_conf_t,  
  33.                         accept_mutex_delay), NULL },  
  34.   
  35.         { ngx_string("debug_connection"), NGX_EVENT_CONF | NGX_CONF_TAKE1,  
  36.                 ngx_event_debug_connection, 0, 0, NULL },  
  37.   
  38.         ngx_null_command };  
  39.   
  40. /** 
  41.  * Event核心模块上下文 
  42.  * ngx_event_core_create_conf：创建配置文件 
  43.  * ngx_event_core_init_conf：初始化配置文件 
  44.  */  
  45. ngx_event_module_t ngx_event_core_module_ctx = { &event_core_name,  
  46.         ngx_event_core_create_conf, /* create configuration */  
  47.         ngx_event_core_init_conf, /* init configuration */  
  48.   
  49.         { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL } };  
  50.   
  51. /** 
  52.  * Event核心模块 
  53.  * ngx_event_module_init：模块初始化 
  54.  * ngx_event_process_init：进程初始化 
  55.  * 类型：NGX_EVENT_MODULE 
  56.  */  
  57. ngx_module_t ngx_event_core_module = { NGX_MODULE_V1,  
  58.         &ngx_event_core_module_ctx, /* module context */  
  59.         ngx_event_core_commands, /* module directives */  
  60.         NGX_EVENT_MODULE, /* module type */  
  61.         NULL, /* init master */  
  62.         ngx_event_module_init, /* init module */  
  63.         ngx_event_process_init, /* init process */  
  64.         NULL, /* init thread */  
  65.         NULL, /* exit thread */  
  66.         NULL, /* exit process */  
  67.         NULL, /* exit master */  
  68.         NGX_MODULE_V1_PADDING };  

ngx_event_conf_t 事件conf结构

[cpp] view plain copy
 print?
  1. /** 
  2.  * event事件模块配置的结构对象 
  3.  */  
  4. typedef struct {  
  5.     ngx_uint_t    connections;  
  6.     ngx_uint_t    use;  
  7.   
  8.     ngx_flag_t    multi_accept;  
  9.     ngx_flag_t    accept_mutex;  
  10.   
  11.     ngx_msec_t    accept_mutex_delay;  
  12.   
  13.     u_char       *name;  
  14.   
  15. #if (NGX_DEBUG)  
  16.     ngx_array_t   debug_connection;  
  17. #endif  
  18. } ngx_event_conf_t;  

Event模块结构图

Nginx源码分析 - Event事件篇 - Event模块和配置的初始化

Event模块的初始化

1. ngx_event_module_init 模块初始化函数

ngx_event_module_init方法为事件核心模块的初始化函数。

[cpp] view plain copy
 print?
  1. /** 
  2.  * event事件核心模块初始化函数 
  3.  */  
  4. static ngx_int_t ngx_event_module_init(ngx_cycle_t *cycle) {  
  5.     void ***cf;  
  6.     u_char *shared;  
  7.     size_t size, cl;  
  8.     ngx_shm_t shm;  
  9.     ngx_time_t *tp;  
  10.     ngx_core_conf_t *ccf;  
  11.     ngx_event_conf_t *ecf;  
  12.   
  13.     /* 获取配置信息 */  
  14.     cf = ngx_get_conf(cycle->conf_ctx, ngx_events_module);  
  15.     ecf = (*cf)[ngx_event_core_module.ctx_index];  
  16.   
  17.     if (!ngx_test_config && ngx_process <= NGX_PROCESS_MASTER) {  
  18.         ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0,  
  19.                 "using the \"%s\" event method", ecf->name);  
  20.     }  
  21.   
  22.     ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);  
  23.   
  24.     ngx_timer_resolution = ccf->timer_resolution;  
  25.   
  26. #if !(NGX_WIN32)  
  27.     {  
  28.         ngx_int_t limit;  
  29.         struct rlimit rlmt;  
  30.   
  31.         if (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {  
  32.             ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,  
  33.                     "getrlimit(RLIMIT_NOFILE) failed, ignored");  
  34.   
  35.         } else {  
  36.             if (ecf->connections > (ngx_uint_t) rlmt.rlim_cur  
  37.                     && (ccf->rlimit_nofile == NGX_CONF_UNSET  
  38.                             || ecf->connections  
  39.                                     > (ngx_uint_t) ccf->rlimit_nofile)) {  
  40.                 limit = (ccf->rlimit_nofile == NGX_CONF_UNSET) ?  
  41.                         (ngx_int_t) rlmt.rlim_cur : ccf->rlimit_nofile;  
  42.   
  43.                 ngx_log_error(NGX_LOG_WARN, cycle->log, 0,  
  44.                         "%ui worker_connections exceed "  
  45.                                 "open file resource limit: %i",  
  46.                         ecf->connections, limit);  
  47.             }  
  48.         }  
  49.     }  
  50. #endif /* !(NGX_WIN32) */  
  51.   
  52.     if (ccf->master == 0) {  
  53.         return NGX_OK;  
  54.     }  
  55.   
  56.     if (ngx_accept_mutex_ptr) {  
  57.         return NGX_OK;  
  58.     }  
  59.   
  60.     /* cl should be equal to or greater than cache line size */  
  61.   
  62.     cl = 128;  
  63.   
  64.     size = cl /* ngx_accept_mutex */  
  65.     + cl /* ngx_connection_counter */  
  66.     + cl; /* ngx_temp_number */  
  67.   
  68. #if (NGX_STAT_STUB)  
  69.   
  70.     size += cl /* ngx_stat_accepted */  
  71.     + cl /* ngx_stat_handled */  
  72.     + cl /* ngx_stat_requests */  
  73.     + cl /* ngx_stat_active */  
  74.     + cl /* ngx_stat_reading */  
  75.     + cl /* ngx_stat_writing */  
  76.     + cl; /* ngx_stat_waiting */  
  77.   
  78. #endif  
  79.   
  80.     shm.size = size;  
  81.     shm.name.len = sizeof("nginx_shared_zone") - 1;  
  82.     shm.name.data = (u_char *) "nginx_shared_zone";  
  83.     shm.log = cycle->log;  
  84.   
  85.     if (ngx_shm_alloc(&shm) != NGX_OK) {  
  86.         return NGX_ERROR;  
  87.     }  
  88.   
  89.     shared = shm.addr;  
  90.   
  91.     ngx_accept_mutex_ptr = (ngx_atomic_t *) shared;  
  92.     ngx_accept_mutex.spin = (ngx_uint_t) -1;  
  93.   
  94.     if (ngx_shmtx_create(&ngx_accept_mutex, (ngx_shmtx_sh_t *) shared,  
  95.             cycle->lock_file.data) != NGX_OK) {  
  96.         return NGX_ERROR;  
  97.     }  
  98.   
  99.     ngx_connection_counter = (ngx_atomic_t *) (shared + 1 * cl);  
  100.   
  101.     (void) ngx_atomic_cmp_set(ngx_connection_counter, 0, 1);  
  102.   
  103.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle->log, 0,  
  104.             "counter: %p, %uA",  
  105.             ngx_connection_counter, *ngx_connection_counter);  
  106.   
  107.     ngx_temp_number = (ngx_atomic_t *) (shared + 2 * cl);  
  108.   
  109.     tp = ngx_timeofday();  
  110.   
  111.     ngx_random_number = (tp->msec << 16) + ngx_pid;  
  112.   
  113. #if (NGX_STAT_STUB)  
  114.   
  115.     ngx_stat_accepted = (ngx_atomic_t *) (shared + 3 * cl);  
  116.     ngx_stat_handled = (ngx_atomic_t *) (shared + 4 * cl);  
  117.     ngx_stat_requests = (ngx_atomic_t *) (shared + 5 * cl);  
  118.     ngx_stat_active = (ngx_atomic_t *) (shared + 6 * cl);  
  119.     ngx_stat_reading = (ngx_atomic_t *) (shared + 7 * cl);  
  120.     ngx_stat_writing = (ngx_atomic_t *) (shared + 8 * cl);  
  121.     ngx_stat_waiting = (ngx_atomic_t *) (shared + 9 * cl);  
  122.   
  123. #endif  
  124.   
  125.     return NGX_OK;  
  126. }  

Event模块配置的初始化

1. ngx_events_module 模块配置初始化

ngx_init_cycle方法中的模块初始化。ngx_events_module类型为NGX_CORE_MODULE，所以在ngx_init_cycle中就会进行核心模块的初始化。

但是ngx_events_module中的create_conf方法为NULL，所以不会调用创建配置的方法。

[cpp] view plain copy
 print?
  1. /* 
  2.  * 核心模块的配置文件创建 
  3.  * 配置创建调用nginx.c 中的 ngx_core_module_create_conf 
  4.  * */  
  5. for (i = 0; cycle->modules[i]; i++) {  
  6.     if (cycle->modules[i]->type != NGX_CORE_MODULE) {  
  7.         continue;  
  8.     }  
  9.   
  10.     module = cycle->modules[i]->ctx;  
  11.   
  12.     if (module->create_conf) {  
  13.         rv = module->create_conf(cycle); //模块回调函数，创建模块的配置信息  
  14.         if (rv == NULL) {  
  15.             ngx_destroy_pool(pool);  
  16.             return NULL;  
  17.         }  
  18.         cycle->conf_ctx[cycle->modules[i]->index] = rv; //配置文件复制  
  19.     }  
  20. }  

2. ngx_conf_parse 解析顶层“event”的配置

ngx_init_cycle方法中会调用ngx_conf_parse方法，并且解析的/usr/local/nginx/conf/nginx.conf配置文件。此次调用只解析最顶层的配置信息“events”，而不会解析{}块中的内容

[cpp] view plain copy
 print?
  1. /* 解析命令行中的配置参数；例如：nginx -t -c /usr/local/nginx/conf/nginx.conf */  
  2. if (ngx_conf_param(&conf) != NGX_CONF_OK) {  
  3.     environ = senv;  
  4.     ngx_destroy_cycle_pools(&conf);  
  5.     return NULL;  
  6. }  
  7.   
  8. /* 解析配置文件/usr/local/nginx/conf/nginx.conf 信息 */  
  9. if (ngx_conf_parse(&conf, &cycle->conf_file) != NGX_CONF_OK) {  
  10.     environ = senv;  
  11.     ngx_destroy_cycle_pools(&conf);  
  12.     return NULL;  
  13. }  

3. ngx_events_block 解析events块block中的内容

ngx_events_block方法为ngx_events_commands命令集的回调函数。在最顶层解析nginx.conf文件的时候，会进行核心模块的命令集遍历。（参考： Nginx源码分析 - 主流程篇 - 解析配置文件    中的ngx_conf_handler）   会遍历模块命令集的cmd->set方法。

ngx_events_block中主要创建ngx_event_core_module事件的核心模块以及配置信息。

[cpp] view plain copy
 print?
  1. /** 
  2.  * 模块解析 
  3.  * 事件模块配置如下： 
  4.  * events { 
  5.     worker_connections  1024; 
  6.     } 
  7.          光使用核心配置的方式，只能解析到 events 这一层。 
  8.          如果需要继续往{}中的内容解析，就得重新调用ngx_conf_parse进行解析 
  9.  */  
  10. static char *  
  11. ngx_events_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf) {  
  12.     char *rv;  
  13.     void ***ctx;  
  14.     ngx_uint_t i;  
  15.     ngx_conf_t pcf;  
  16.     ngx_event_module_t *m;  
  17.   
  18.     if (*(void **) conf) {  
  19.         return "is duplicate";  
  20.     }  
  21.   
  22.     /* count the number of the event modules and set up their indices */  
  23.   
  24.     ngx_event_max_module = ngx_count_modules(cf->cycle, NGX_EVENT_MODULE);  
  25.   
  26.     /* 分配内存空间 */  
  27.     ctx = ngx_pcalloc(cf->pool, sizeof(void *));  
  28.     if (ctx == NULL) {  
  29.         return NGX_CONF_ERROR ;  
  30.     }  
  31.   
  32.     *ctx = ngx_pcalloc(cf->pool, ngx_event_max_module * sizeof(void *));  
  33.     if (*ctx == NULL) {  
  34.         return NGX_CONF_ERROR ;  
  35.     }  
  36.   
  37.     *(void **) conf = ctx;  
  38.   
  39.     /* 模块初始化，如果是NGX_EVENT_MODULE，则调用模块的create_conf方法 */  
  40.     for (i = 0; cf->cycle->modules[i]; i++) {  
  41.         if (cf->cycle->modules[i]->type != NGX_EVENT_MODULE) {  
  42.             continue;  
  43.         }  
  44.   
  45.         m = cf->cycle->modules[i]->ctx;  
  46.   
  47.         if (m->create_conf) {  
  48.             (*ctx)[cf->cycle->modules[i]->ctx_index] = m->create_conf(  
  49.                     cf->cycle);  
  50.             if ((*ctx)[cf->cycle->modules[i]->ctx_index] == NULL) {  
  51.                 return NGX_CONF_ERROR ;  
  52.             }  
  53.         }  
  54.     }  
  55.   
  56.     /* event*/  
  57.     pcf = *cf;  
  58.     cf->ctx = ctx;  
  59.     cf->module_type = NGX_EVENT_MODULE;  
  60.     cf->cmd_type = NGX_EVENT_CONF;  
  61.   
  62.     /* 调用配置解析，这次解析的是 块中的内容，非文件内容 */  
  63.     rv = ngx_conf_parse(cf, NULL);  
  64.   
  65.     *cf = pcf;  
  66.   
  67.     if (rv != NGX_CONF_OK) {  
  68.         return rv;  
  69.     }  
  70.   
  71.     /* 初始化 模块的init_conf 方法*/  
  72.     for (i = 0; cf->cycle->modules[i]; i++) {  
  73.         if (cf->cycle->modules[i]->type != NGX_EVENT_MODULE) {  
  74.             continue;  
  75.         }  
  76.   
  77.         m = cf->cycle->modules[i]->ctx;  
  78.   
  79.         if (m->init_conf) {  
  80.             rv = m->init_conf(cf->cycle,  
  81.                     (*ctx)[cf->cycle->modules[i]->ctx_index]);  
  82.             if (rv != NGX_CONF_OK) {  
  83.                 return rv;  
  84.             }  
  85.         }  
  86.     }  
  87.   
  88.     return NGX_CONF_OK;  
  89. }  

4. ngx_event_core_create_conf和ngx_event_core_init_conf

ngx_event_core_create_conf：主要是创建event事件核心模块

ngx_event_core_init_conf：初始化event事件核心模块

[cpp] view plain copy
 print?
  1. /** 
  2.  * 创建Event的核心配置文件 
  3.  */  
  4. static void *  
  5. ngx_event_core_create_conf(ngx_cycle_t *cycle) {  
  6.     ngx_event_conf_t *ecf;  
  7.   
  8.     /* 分配配置文件内容 */  
  9.     ecf = ngx_palloc(cycle->pool, sizeof(ngx_event_conf_t));  
  10.     if (ecf == NULL) {  
  11.         return NULL;  
  12.     }  
  13.   
  14.     /* 设置默认值 */  
  15.     ecf->connections = NGX_CONF_UNSET_UINT;  
  16.     ecf->use = NGX_CONF_UNSET_UINT;  
  17.     ecf->multi_accept = NGX_CONF_UNSET;  
  18.     ecf->accept_mutex = NGX_CONF_UNSET;  
  19.     ecf->accept_mutex_delay = NGX_CONF_UNSET_MSEC;  
  20.     ecf->name = (void *) NGX_CONF_UNSET;  
  21.   
  22. #if (NGX_DEBUG)  
  23.   
  24.     if (ngx_array_init(&ecf->debug_connection, cycle->pool, 4,  
  25.                     sizeof(ngx_cidr_t)) == NGX_ERROR)  
  26.     {  
  27.         return NULL;  
  28.     }  
  29.   
  30. #endif  
  31.   
  32.     return ecf;  
  33. }  
  34.   
  35. /** 
  36.  * 初始化Event的核心配置文件 
  37.  */  
  38. static char *  
  39. ngx_event_core_init_conf(ngx_cycle_t *cycle, void *conf) {  
  40.     ngx_event_conf_t *ecf = conf;  
  41.   
  42. #if (NGX_HAVE_EPOLL) && !(NGX_TEST_BUILD_EPOLL)  
  43.     int fd;  
  44. #endif  
  45.     ngx_int_t i;  
  46.     ngx_module_t *module;  
  47.     ngx_event_module_t *event_module;  
  48.   
  49.     module = NULL;  
  50.   
  51. #if (NGX_HAVE_EPOLL) && !(NGX_TEST_BUILD_EPOLL)  
  52.   
  53.     fd = epoll_create(100);  
  54.   
  55.     if (fd != -1) {  
  56.         (void) close(fd);  
  57.         module = &ngx_epoll_module;  
  58.   
  59.     } else if (ngx_errno != NGX_ENOSYS) {  
  60.         module = &ngx_epoll_module;  
  61.     }  
  62.   
  63. #endif  
  64.   
  65. #if (NGX_HAVE_DEVPOLL) && !(NGX_TEST_BUILD_DEVPOLL)  
  66.   
  67.     module = &ngx_devpoll_module;  
  68.   
  69. #endif  
  70.   
  71. #if (NGX_HAVE_KQUEUE)  
  72.   
  73.     module = &ngx_kqueue_module;  
  74.   
  75. #endif  
  76.   
  77. #if (NGX_HAVE_SELECT)  
  78.   
  79.     if (module == NULL) {  
  80.         module = &ngx_select_module;  
  81.     }  
  82.   
  83. #endif  
  84.   
  85.     /** 
  86.      * 查询使用的事件模型:epoll、kqueue等 
  87.      * 因为在模块初始化的时候，epoll\kqueue等event的模型模块都会被初始化 
  88.      * 但是每个服务器只能选择一种相应的事件模型，所以选择一个适合自己的模块 
  89.      */  
  90.     if (module == NULL) {  
  91.         for (i = 0; cycle->modules[i]; i++) {  
  92.   
  93.             if (cycle->modules[i]->type != NGX_EVENT_MODULE) {  
  94.                 continue;  
  95.             }  
  96.   
  97.             event_module = cycle->modules[i]->ctx;  
  98.   
  99.             if (ngx_strcmp(event_module->name->data, event_core_name.data)  
  100.                     == 0) {  
  101.                 continue;  
  102.             }  
  103.   
  104.             module = cycle->modules[i];  
  105.             break;  
  106.         }  
  107.     }  
  108.   
  109.     if (module == NULL) {  
  110.         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0, "no events module found");  
  111.         return NGX_CONF_ERROR ;  
  112.     }  
  113.   
  114.     ngx_conf_init_uint_value(ecf->connections, DEFAULT_CONNECTIONS);  
  115.     cycle->connection_n = ecf->connections;  
  116.   
  117.     /** 
  118.      * 存储使用的事件模型模块索引 例如：epoll、kqueue 
  119.      * nginx.conf中存储的是：use epoll; 
  120.      * 这里会找到cycle->modules的具体模块的索引值，存储最终的索引值 
  121.      */  
  122.     ngx_conf_init_uint_value(ecf->use, module->ctx_index);  
  123.   
  124.     event_module = module->ctx;  
  125.     ngx_conf_init_ptr_value(ecf->name, event_module->name->data);  
  126.   
  127.     ngx_conf_init_value(ecf->multi_accept, 0);  
  128.     ngx_conf_init_value(ecf->accept_mutex, 1);  
  129.     ngx_conf_init_msec_value(ecf->accept_mutex_delay, 500);  
  130.   
  131.     return NGX_CONF_OK;  
  132. }  

5. 获取event配置

获取event的配置，先获取ngx_events_module配置，然后再到ngx_events_module模块上找到ngx_event_core_module 事件核心模块的配置。

[cpp] view plain copy
 print?
  1. #define ngx_event_get_conf(conf_ctx, module)                                  \  
  2.              (*(ngx_get_conf(conf_ctx, ngx_events_module))) [module.ctx_index];  


转自：http://blog.****.net/initphp/article/details/52434261

相关推荐