nginx source code study notes (21) - event module 2 - event-driven core ngx_process_events_and_timers

First of all, let’s continue to recall that there is an uninvolved content ngx_process_events_and_timers in the previous sub-thread execution operation. Today we will study this function.

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

First, let’s take a look at some screenshots of Section 19:

Today we mainly explain the event-driven function, the red part in the picture:

[cpp] view plaincopyprint?

1. src/event/ngx_event.c
3. void
4. ngx_process_events_and_timers(ngx _cycle_t *cycle)
5. {
6. ngx_uint_t flags;
7. ngx_msec_t timer, delta;
9. (ngx_timer_resolution) time r = NGX_TIMER_INFINITE; flags = 0;
11. } else
12. {
13. timer = ngx_event_find_timer(); flags = NGX_UPDATE_TIME;
14. }
16. /*
18. The ngx_use_accept_mutex variable represents whether to use accept The mutex
19. is used by default and can be turned off through the accept_mutex off; command; */
20.                                                                                                             
21.                                   ngx_accept_disabled variable is calculated in the ngx_event_accept function.
22. If ngx_accept_disabled is greater than 0, it means that the process accepts too many links, Therefore, it gives up an opportunity to compete for the accept mutex and reduces itself by one.
23. Then, continue to process events on existing connections.
24. nginx takes advantage of this to implement basic load balancing of inherited connections.
25.                                                                          
26.                 ngx_accept_disabled--; /*
27. Try to lock Accept Mutex. Only by successfully obtaining the lock can the Listen put word in EPOLL.
28. Therefore, this ensures that only one process has the listening socket, so when all processes are blocked in epoll_wait,
29. will not cause a group panic.​​​​
30.                                                                                                                                                                                                                                                             If the process acquires the lock, a NGX_POST_EVENTS flag will be added.
31. The function of this flag is to put all generated events into a queue, and then process the events slowly after they are released. Because the processing time may be time -consuming, if the lock is not applied first before processing, the process will occupy the lock for a long time. The efficiency is low.
32.                                                                                                            
}
33. else{
Not obtained The resulting process, of course, does not need the NGX_POST_EVENTS flag.
35. But you need to set the delay time before fighting for the lock.
36. */
37. (timer == ngx_timer_infinite
38. || timer & gt; ngx_accept_mutex_dlay) {
39. timer = ngx_acceth_mutex_delay;
40.                                                                                                 
delta = ngx_current_msec;
44. /*Next, epoll will start the wait event ,
45. The specific implementation of ngx_process_events corresponds to the ngx_epoll_process_events function in the epoll module
47. Will be explained in detail here later
48.  */
49.  ( void
50. ) ngx_process_events(cycle, timer, flags);
/ / Statistics of the time consumption of this wait event
51. delta = ngx_current_msec-delta;
52. ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle->log, 0,
53.                                           
/*
55. ngx_posted_accept_events is An event queue
, which temporarily stores the accept event epoll waits from the listening socket.
57. After the NGX_POST_EVENTS flag mentioned above is used, all accept events will be temporarily stored in this queue
58. */
if
60. (ngx_posted_accept_events ) { ngx_event_process_posted(cycle, &ngx_posted_accept_events);
61. }
//After all accept events are processed, If the lock is held, release it.
62. if (ngx_accept_mutex_held) {
63. ngx_shmtx_unlock(&ngx_accept_mutex);
64. }
66. /*
67. delta is before For statistical time-consuming, if there is millisecond-level time-consuming, check the timers of all times.
68. If it is timeout, delete the expired timer from the time rbtree, and call the handler function of the corresponding event to process
69. */
70. if (delta) {
71. ngx_event_expire_timers();
72. }
74. ngx_log_debug1(NGX_LOG_DEBUG_EVENT, cycle-> ;log, 0,
75.                                                                                              /*
76. Processing ordinary events (read and write data obtained on the connection event),
77. Because each event has its own handler method,
78. */
79. if
80. (ngx_posted_events) {
(ngx_threaded) {
81.              ngx_wakeup_worker_thread(cycle);                                              : }
82. }
83. I have talked about the accept event before. In fact, it is to monitor whether there are new events on the socket. Here is the handler method of the accept time:
84. ngx_event_accept:
85. [cpp] view plaincopyprint?
    1. src/event/ngx_event_accept.c  
    2.   
    3. void  
    4. ngx_event_accept(ngx_event_t *ev)  
    5. {  
    6.     socklen_t          socklen;  
    7.     ngx_err_t          err;  
    8.     ngx_log_t         *log;  
    9.     ngx_socket_t       s;  
    10.     ngx_event_t       *rev, *wev;  
    11.     ngx_listening_t   *ls;  
    12.     ngx_connection_t  *c, *lc;  
    13.     ngx_event_conf_t  *ecf;  
    14.     u_char             sa[NGX_SOCKADDRLEN];  
    15.       
    16.     //省略部分代码  
    17.   
    18.     lc = ev->data;  
    19.     ls = lc->listening;  
    20.     ev->ready = 0;  
    21.   
    22.     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,  
    23.                    "accept on %V, ready: %d", &ls->addr_text, ev->available);  
    24.   
    25.     do {  
    26.         socklen = NGX_SOCKADDRLEN;  
    27.         //accept一个新的连接  
    28.         s = accept(lc->fd, (struct sockaddr *) sa, &socklen);  
    29.         //省略部分代码  
    30.           
    31.         /* 
    32.         accept到一个新的连接后，就重新计算ngx_accept_disabled的值， 
    33.         它主要是用来做负载均衡，之前有提过。 
    34.          
    35.         这里，我们可以看到他的就只方式 
    36.         “总连接数的八分之一   -   剩余的连接数“ 
    37.         总连接指每个进程设定的最大连接数，这个数字可以再配置文件中指定。After the 7/8 of the total number of connections to the total number of connections, the NGX_ACCEPT_DISABLED is greater than zero, and the connection is overloaded
    39. */
    41. ngx_accept_disabled = ngx_cycle->connection_n / 8
    - ngx_cycle->free_connection_n;
    c = ngx_get_connection(s, ev->log);
    45. //Only released when the connection is closed pool
    47. if (c->pool == NULL ) {
    ngx_close_accepted_connection(c);
    49.                                                                                    );                                                                                                                                                                                
    50. ngx_memcpy(c->sockaddr, sa, socklen);
    51. log = ngx_palloc(c->pool, sizeof
    52. (ngx_log_t));
    53. if (log == null) { ngx_close_accepted_connection (c);
    54. Roturn
    55. ; }  
    56.   
    57.         /* set a blocking mode for aio and non-blocking mode for others */  
    58.   
    59.         if (ngx_inherited_nonblocking) {  
    60.             if (ngx_event_flags & NGX_USE_AIO_EVENT) {  
    61.                 if (ngx_blocking(s) == -1) {  
    62.                     ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_socket_errno,  
    63.                                   ngx_blocking_n " failed");  
    64.                     ngx_close_accepted_connection(c);  
    65.                     return;  
    66.                 }  
    67.             }  
    68.   
    69.         } else {  
    70.             //我们使用epoll模型，这里我们设置连接为nonblocking  
    71.             if (!(ngx_event_flags & (NGX_USE_AIO_EVENT|NGX_USE_RTSIG_EVENT))) {  
    72.                 if (ngx_nonblocking(s) == -1) {  
    73.                     ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_socket_errno,  
    74.                                   ngx_nonblocking_n " failed");  
    75.                     ngx_close_accepted_connection(c);  
    76.                     return;  
    77.                 }  
    78.             }  
    79.         }  
    80.   
    81.         *log = ls->log;  
    82.         //初始化新的连接  
    83.         c->recv = ngx_recv;  
    84.         c->send = ngx_send;  
    85.         c->recv_chain = ngx_recv_chain;  
    86.         c->send_chain = ngx_send_chain;  
    87.   
    88.         c->log = log;  
    89.         c->pool->log = log;  
    90.   
    91.         c->socklen = socklen;  
    92.         c->listening = ls;  
    93.         c->local_sockaddr = ls->sockaddr;  
    94.   
    95.         c->unexpected_eof = 1;  
    96.   
    97. #if (NGX_HAVE_UNIX_DOMAIN)  
    98.         if (c->sockaddr->sa_family == AF_UNIX) {  
    99.             c->tcp_nopush = NGX_TCP_NOPUSH_DISABLED;  
    100.             c->tcp_nodelay = NGX_TCP_NODELAY_DISABLED;  
    101. #if (NGX_SOLARIS)  
    102.             /* Solaris's sendfilev() supports AF_NCA, AF_INET, and AF_INET6 */  
    103.             c->sendfile = 0;  
    104. #endif  
    105.         }  
    106. #endif  
    107.   
    108.         rev = c->read;  
    109.         wev = c->write;  
    110.   
    111.         wev->ready = 1;  
    112.   
    113.         if (ngx_event_flags & (NGX_USE_AIO_EVENT|NGX_USE_RTSIG_EVENT)) {  
    114.             /* rtsig, aio, iocp */  
    115.             rev->ready = 1;  
    116.         }  
    117.   
    118.         if (ev->deferred_accept) {  
    119.             rev->ready = 1;  
    120. #if (NGX_HAVE_KQUEUE)  
    121.             rev->available = 1;  
    122. #endif  
    123.         }  
    124.   
    125.         rev->log = log;  
    126.         wev->log = log;  
    127.   
    128.         /* 
    129.          * TODO: MT: - ngx_atomic_fetch_add() 
    130.          *             or protection by critical section or light mutex 
    131.          * 
    132.          * TODO: MP: - allocated in a shared memory 
    133.          *           - ngx_atomic_fetch_add() 
    134.          *             or protection by critical section or light mutex 
    135.          */  
    136.   
    137.         c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);  
    138.           
    139.         if (ngx_add_conn && (ngx_event_flags & NGX_USE_EPOLL_EVENT) == 0) {  
    140.             if (ngx_add_conn(c) == NGX_ERROR) {  
    141.                 ngx_close_accepted_connection(c);  
    142.                 return;  
    143.             }  
    144.         }  
    145.   
    146.         log->data = NULL;  
    147.         log->handler = NULL;  
    148.           
    149.         /* 
    150.         这里listen handler很重要，它将完成新连接的最后初始化工作， 
    151.         同时将accept到的新的连接放入epoll中；挂在这个handler上的函数， 
    152.         就是ngx_http_init_connection 在之后http模块中在详细介绍 
    153.         */  
    154.         ls->handler(c);  
    155.   
    156.         if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {  
    157.             ev->available--;  
    158.         }  
    159.   
    160.     } while (ev->available);  
    161. }  
    
    

    accpt事件的handler方法也就是如此了。之后就是每个连接的读写事件handler方法，这一部分会直接将我们引入http模块，我们还不急，还要学习下nginx经典模块epoll。

    The above introduces the nginx source code study notes (21) - event module 2 - the event-driven core ngx_process_events_and_timers, including queue content. I hope it will be helpful to friends who are interested in PHP tutorials.