nginx source code study notes (20) - event module 1 - initialization

After reading the previous study notes, I believe that I have a certain understanding of the startup process of nginx. From this section on, we want to go deep into each module and learn the main operations within each module.

This article comes from: http://blog.csdn.net/lengzijian/article/details/7598996

Today we will learn about the event module. In the previous startup, we mentioned calling each module many times. The hook function of

This method mainly creates an ngx_event_conf_t structure and allocates memory space.

2. Read the configuration file:

For example, the read file has the following lines:

[cpp] view plaincopyprint?

events

{

use epoll;

1. worker_connections 10240; }
3. The events in this place are a block instruction. Many instructions can be configured within the brackets. These instructions are defined in src/event/ngx_event.c
4. [cpp] view plaincopyprint?

static
ngx_command_t ngx_event_core_commands[] = {

{ ngx_string(

"worker_ connections"
1. ), NGX_EVENT_CONF|NGX_CONF_TAKE1,
2. ngx_event_connections,
3. 0, 0,
4. NULL },
5. ...(omitted here)
7.                                                                                     
NGX_EVENT_CONF|NGX_CONF_TAKE1,
ngx_event_connections,
0,
11. 0,
NULL },
{ngx_string(
14. "use" ),
NGX_EVENT_CONF|NGX_CONF_TAKE1,
ngx_event_use,
0,
18. 0,
NULL },
ngx_null_command
};
22. When events are parsed, the following function will be called back:
[cpp] view plaincopyprint?
24. 1. src/event/ngx_event.c  
    2. static char *  
    3. ngx_events_block(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)  
    4. {  
    5.     char                 *rv;  
    6.     void               ***ctx;  
    7.     ngx_uint_t            i;  
    8.     ngx_conf_t            pcf;  
    9.     ngx_event_module_t   *m;  
    10.   
    11.     /* count the number of the event modules and set up their indices */  
    12.     //计算event模块数量，并且记录  
    13.     ngx_event_max_module = 0;  
    14.     for (i = 0; ngx_modules[i]; i++) {  
    15.         if (ngx_modules[i]->type != NGX_EVENT_MODULE) {  
    16.             continue;  
    17.         }  
    18.   
    19.         ngx_modules[i]->ctx_index = ngx_event_max_module++;  
    20.     }  
    21.   
    22.     ctx = ngx_pcalloc(cf->pool, sizeof(void *));  
    23.     if (ctx == NULL) {  
    24.         return NGX_CONF_ERROR;  
    25.     }  
    26.     //为每一个event模块分配空间，用来保存响应配置结构的地址  
    27.     //共分配了ngx_event_max_module个空间  
    28.     *ctx = ngx_pcalloc(cf->pool, ngx_event_max_module * sizeof(void *));  
    29.     if (*ctx == NULL) {  
    30.         return NGX_CONF_ERROR;  
    31.     }  
    32.   
    33.     *(void **) conf = ctx;  
    34.   
    35.     for (i = 0; ngx_modules[i]; i++) {  
    36.         if (ngx_modules[i]->type != NGX_EVENT_MODULE) {  
    37.             continue;  
    38.         }
    40. m = ngx_modules[i]->ctx;
    41. ​​​​​
    if
    42. (m->create_conf) { (*ctx)[ngx_modules[i]->ctx_index] = m->create_conf(cf->cycle);
    43.                                                                     
    ((*ctx)[ngx_modules[i]->ctx_index] == NULL) {
    44.                                                                                                                                                  
    45. pcf = *cf; cf->ctx = ctx;
    46. cf->module_type = NGX_EVENT_MODULE;
    47. cf->cmd_type = NGX_EVENT_CONF;
    //Since events is a block instruction, many other instructions can be configured in the events domain,
    //For example, the use mentioned before, etc., now start to parse the instructions in the events block and complete the initialization Work.
    52. rv = ngx_conf_parse(cf, NULL);
    54. *cf = pcf;
    55. if (rv != NGX_CONF_OK)
    56.                                                                             
    ​​​​​​​​​​​
    58. if​(ngx_modules[i]-> ;type != NGX_EVENT_MODULE) {
                                                           m = ngx_modules[i]->ctx;
    60. //Loop to execute each event The init_conf function of the module, the initialization configuration structure
    62. (m-& gt; init_conf) {
    63. RV = m-& gt; init_conf (CF-& GT; cycle, (*ctx) [ngx_modules[i]->ctx_index]); return
    64. rv;                          
    65. }
    66. return
    NGX_CONF_OK;
    68. }
        

        The most important process in the ngx_events_block() function is to call ngx_conf_parse(cf, NULL). The function of calling ngx_conf_parse() here is to complete the parsing of the events{} block in the configuration file, thereby calling all configurations under it. The callback function of the instruction completes the initialization of parsing the configuration file. But here I have a personal question. After asking the seniors, I will specify the question and answer******.

        2. Initialize conf (init_conf)

        ngx_event_init_conf()
        

        This method mainly initializes the ngx_event_conf_t structure.
        

        3.ngx_event_module_init

        As the name suggests, it is the initialization operation of the module, but looking at the source code of each module, it is found that many modules do not have init callback functions. I am also struggling with why here, hoping to find the answer after learning all the code.

        [cpp] view plaincopyprint?

        1. src/event/ngx_event.c  
        2. static ngx_int_t  
        3. ngx_event_module_init(ngx_cycle_t *cycle)  
        4. {  
        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.     //判断ngx_events_module是否调用过初始化conf操作  
        14.     cf = ngx_get_conf(cycle->conf_ctx, ngx_events_module);  
        15.   
        16.     if (cf == NULL) {  
        17.         ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,  
        18.                       "no "events" section in configuration");  
        19.         return NGX_ERROR;  
        20.     }  
        21.       
        22.     //获取ngx_event_core_module模块的配置结构  
        23.     ecf = (*cf)[ngx_event_core_module.ctx_index];  
        24.       
        25.     //查看是否是event中的模块，例如use 。。。。
        26. if (!ngx_test_config && ngx_process
        27. ngx_log_error(NGX _LOG_NOTICE, cycle->log, 0,
        28.                                                                              "event method", ecf->name);
        29. }
        30. //Get the configuration structure of the ngx_core_module module
        31. ccf = (ngx_core_conf_t *) ngx_get_conf(cycle- >conf_ctx, ngx_core_module);
        33. //Get the timer_resolution parameter from the configuration structure of the ngx_core_module module ngx_timer_resolution = ccf->timer_resolution;
        34. #if !(NGX_WIN32)
        36. { ngx_int_t limit;
        rlimit rlmt;
        39. //Get the ability of the current process The maximum number of open files man getrlimit
        41. (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) { x_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
        42.                                                                                                                                                                                                                        else{
        43. _The maximum number of connections to a module is unlimited​​
        44. ​​​​​/ /Or ngx_event_core_module connection is greater than ngx_core_module maximum number of connections
        45. (ECF-& GT; Connections & GT; (ngx_uint_t) rlmt.rlim_cur
        46. (ccf-& gt; _NOFILE == ngx_conf_unset
                                                                       limit = (ccf->rlimit_nofile == NGX_CONF_UNSET) ?
        ( ngx_int_t) rlmt.rlim_cur: ccf- & gt; rlimit_nofile;
                                                                                        " open file resource limit: %i" ); endif /* !(NGX_WIN32) */
        //If the master process is closed, return
        54. //Because closing the master process means single-process work Method,
        55. //The subsequent operations create shared memory to implement locks and other work, which is not required for a single process.
    69. if (ccf->master == 0) {
    70. NGX_OK; }
    // If the accept mutex already exists, there is no need to create it again.
    73. NGX_OK;
    74. }
    76. /* cl should be equal or bigger than cache line size */
    cl = 128;
    79. //Create size here Shared memory, this shared memory will be divided into three equal segments
    size = cl                                      + cl                                                       
    81.                                                                                                       ,
    82. shm.size = size;
    83.  shm.name.len = sizeof("nginx_shared_zone"
    );
    84.  shm.name.data = (u_char *) "nginx_share d_zone"
    ;
    85. shm.log = cycle->log;
    87. (ngx_shm_alloc(&shm) ! = NGX_OK) { NGX_ERROR;
    NGX_ERROR;
    90. shared = shm.addr;
    91. //Accept mutex gets the first cl size memory of shared memory
    93. ngx_accept_mutex_ptr = (ngx_atomic_t *) shared; ngx_accept_mutex.spin = (ngx_uint_t) -1;
    94. /*Create accept mutex
    95. The implementation of accept mutex depends on whether it supports atomic operations, if there are corresponding atomic operations;
    That’s it Use the obtained shared memory to implement the accept mutex; otherwise, the file lock will be used to implement the accept mutex.
    The function of the accept mutex is to avoid panic groups and achieve load balancing of worker processes.
26. ngx_accept_mutex, shared, cycle->lock_file.data)
!= NGX_OK)
27.                                                                                     
//Get the cl-sized address of the second segment of memory
29. ngx_connection_counter = (ngx_atomic_t *) (shared + 1 * cl);
30. (
void
31. ) ngx_atomic_cmp_set(ngx_connection_counter, 0, 1);
32. ngx_log_debug2(NGX_LOG_DEBUG_EVENT, cycle- >log, 0,
33.                                                                                                         x_connection_counter);
//Get the size of the third segment of memory cl Address
35. ngx_temp_number = (ngx_atomic_t *) (shared + 2 * cl);
36. tp = ngx_timeofday() ;
38. ngx_random_number = (tp-> ;msec
return
40. NGX_OK;
41. 4.ngx_event_process_init in the previous worker process As mentioned in the analysis, when a worker process is created, the worker process will first initialize the process, and at this time the ngx_event_process_init function will be called.
42. [cpp] view plaincopyprint?
1. src/event/ngx_event.c
2. staticngx_int_t
3. ngx_event_process_init(ngx_cycle_t *cycle)
4. {
5. ngx_uint_t m, i;
6. ngx_event_t *rev, *wev;
7. ngx_listening_t *ls;
8. ngx_connection_t *c, *next, *old;
9. ngx_core_conf_t *ccf;
10. ngx_event_conf_t *ecf;
11. ngx_event_module_t *module;
13. //As before, get the configuration structure of the response module
14. ccf = (ngx_core_conf_t *) ngx_get_conf( cycle->conf_ctx, ngx_core_module);
15.  ecf = ngx_event_get_conf(cycle->conf_ctx, ngx_event_core_module);
16.  
17. //Master process is open, worker process is greater than 1, accept_mutex has been created
18. //cai Open the accept mutex
19. if (ccf->master &&ccf->worker_processes > 1 &&ecf->accept_mutex) {
20. ngx_use_accept_mutex = 1; / /Use mutex
21. ngx_accept_mutex_held = 0; //Whether to get accept mutex
22. ngx_accept_mutex_delay = ecf->accept_mutex_delay;//After failure to compete for the mutex , waiting for the next scramble time interval
24. } else {
25. ngx_use_accept_mutex = 0 ;
26. }
28. #if (NGX_THREADS)
29. //Threads aside
30. #endif
31. //Initialize counter, a red will be created here Black Tree, to maintain the timer, will explain in detail later
32. if (ngx_event_timer_init(cycle->log) == NGX_ERROR) {
33. return NGX_ERROR;
}
36. for (m = 0; ngx_modules[m]; m++) {
37. //As mentioned here before, skip non-NGX_EVENT_MODULE modules
                                                                                                                                                              
38. }
39.                                      // Modules specified by non-use configuration instructions are skipped, Linux default epoll                                              ->use) { module = ngx_modules[m]->ctx;
40. /*Call the init function of the specific time module ( These modules are located in the src/event/modules directory), so nginx A layer of abstraction has been made to the time module, which makes it easier for different systems to use different event models and expands new time models. Our focus should be on epoll.
41.                                                                                                                                                                                                                 The init callback here actually calls the ngx_epoll_init function. The module->actions structure encapsulates all interface functions of epoll. nginx registers epoll into the event abstraction layer through the actions structure.
The type of actions is ngx_event_action_t, located in src/event/ngx_event.h
43. These specific contents will be explained in the next section.
44.                                        module->actions.init(cycle, ngx_timer_resolution) != NGX_OK) {
45. *fatal */
46. exit(2); ​ break
;
47. }
48. //Omitted here Part of the content
50. //Create a global ngx_connection_t array to save all connections
51. //Since this process is executed in each worker process, each worker has Own connection array
53. cycle->connections = ngx_alloc(sizeof
(ngx_connection_t) *cycle->connection_n, cycle->log);
54. if
(cycle->connections == NULL) {
56. c = cycle->connections;
57. //Create an array of read events
58. cycle->read_events = ngx_alloc(sizeof
59. (ngx_event_t) * cycle->connection_n,                                                                                                                                                                                                                                                                        ​;log);
60. if
61. (cycle->read_events == NULL) {
62. NGX_ERROR;
63. }
64. rev = cycle->read_events;
65. for (i = 0; i connection_n; i++) {
66. rev[i].closed = 1 ;
67.                                  [i].instance = 1;
#if (NGX_THREADS)
68. rev[i].lock = &c[i].lock;
69. rev[i].own_lock = &c[i].lock;
#endif
72. }  
73.     //创建一个写事件数组  
74.     cycle->write_events = ngx_alloc(sizeof(ngx_event_t) * cycle->connection_n,  
75.                                     cycle->log);  
76.     if (cycle->write_events == NULL) {  
77.         return NGX_ERROR;  
78.     }  
79.   
80.     wev = cycle->write_events;  
81.     for (i = 0; i connection_n; i++) {  
82.         wev[i].closed = 1;  
83. #if (NGX_THREADS)  
84.         wev[i].lock = &c[i].lock;  
85.         wev[i].own_lock = &c[i].lock;  
86. #endif  
87.     }  
88.   
89.     i = cycle->connection_n;  
90.     next = NULL;  
91.     //初始化整个connection数组  
92.     do {  
93.         i--;  
94.   
95.         c[i].data = next;  
96.         c[i].read = &cycle->read_events[i];  
97.         c[i].write = &cycle->write_events[i];  
98.         c[i].fd = (ngx_socket_t) -1;  
99.   
100.         next = &c[i];  
101.   
102. #if (NGX_THREADS)  
103.         c[i].lock = 0;  
104. #endif  
105.     }while (i);
107. cycle->free_connections = next;
108. cycle->free_connection_n = cycle-> connection_n;
110. /* for each listening socket */
111. //Assign a connection from the connection array for each listening socket, that is, a slot
112. ls = cycle->listening .els; Connect to solt
113. _ C = ngx_get_connection (ls [i] .fd, cycle-& gt; log); NGX_ERROR; }  
114.   
115.         c->log = &ls[i].log;  
116.   
117.         c->listening = &ls[i];  
118.         ls[i].connection = c;  
119.   
120.         rev = c->read;  
121.   
122.         rev->log = c->log;  
123.         rev->accept = 1; //读时间发生，调用accept  
124.   
125. #if (NGX_HAVE_DEFERRED_ACCEPT)  
126.         //省略  
127. #endif  
128.   
129.         if (!(ngx_event_flags & NGX_USE_IOCP_EVENT)) {  
130.             if (ls[i].previous) {  
131.   
132.                 /* 
133.                  * delete the old accept events that were bound to 
134.                  * the old cycle read events array 
135.                  */  
136.   
137.                 old = ls[i].previous->connection;  
138.   
139.                 if (ngx_del_event(old->read, NGX_READ_EVENT, NGX_CLOSE_EVENT)  
140.                     == NGX_ERROR)  
141.                 {  
142.                     return NGX_ERROR;  
143.                 }  
144.   
145.                 old->fd = (ngx_socket_t) -1;  
146.             }  
147.         }
149. //Register the callback function ngx_event_accept
150. rev->handler = ngx_even t_accept;
151.                                    , do not put the listening socket into epoll for the time being, but
152.                                                                                                                          {
153.                                                                                                                                                                                                                                     
154. }
155. } else{
156.      //If the accept mutex is not used, then put this listening socket into epoll.
158.                                                                                                                                                                             
159. #endif
160. }
161. return
162. NGX_OK;
163. }
164. Until now , event-driven initialization has been completed.
The above introduces the nginx source code study notes (20) - event module 1 - initialization, including IOC and counter content. I hope it will be helpful to friends who are interested in PHP tutorials.