ngx_event_accept

Author: chronolaw

nginx/src/core/ngx_connection.h

@@ -168,9 +168,13 @@ struct ngx_connection_s {
     ngx_socket_t        fd;
 
     // 接收数据的函数指针
+    // ngx_event_accept.c:ngx_event_accept()里设置为ngx_recv
+    // ngx_posix_init.c里初始化为linux的底层接口
     ngx_recv_pt         recv;
 
     // 发送数据的函数指针
+    // ngx_event_accept.c:ngx_event_accept()里设置为ngx_send
+    // ngx_posix_init.c里初始化为linux的底层接口
     ngx_send_pt         send;
 
     ngx_recv_chain_pt   recv_chain;
@@ -213,7 +217,9 @@ struct ngx_connection_s {
     // 复用连接对象
     ngx_queue_t         queue;
 
-    // 连接使用次数
+    // 连接创建的计数器
+    // ngx_event_accept.c:ngx_event_accept()
+    // c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);
     ngx_atomic_uint_t   number;
 
     // 处理的请求次数

nginx/src/event/ngx_event.c

@@ -70,6 +70,9 @@ ngx_uint_t            ngx_use_accept_mutex;
 ngx_uint_t            ngx_accept_events;
 ngx_uint_t            ngx_accept_mutex_held;
 ngx_msec_t            ngx_accept_mutex_delay;
+
+// ngx_accept_disabled是总连接数的1/8-空闲连接数
+// 也就是说空闲连接数小于总数的1/8,那么就暂时停止接受连接
 ngx_int_t             ngx_accept_disabled;
 
 

nginx/src/event/ngx_event.h

@@ -611,8 +611,16 @@ extern ngx_module_t           ngx_event_core_module;
 
 
 
+// 监听端口上收到连接请求时的回调函数，即事件handler
+// 从cycle的连接池里获取连接
+// 关键操作 ls->handler(c);调用其他模块的业务handler
 void ngx_event_accept(ngx_event_t *ev);
+
+// 尝试获取负载均衡锁，监听端口
+// 如未获取则不监听端口
+// 内部调用ngx_enable_accept_events/ngx_disable_accept_events
 ngx_int_t ngx_trylock_accept_mutex(ngx_cycle_t *cycle);
+
 u_char *ngx_accept_log_error(ngx_log_t *log, u_char *buf, size_t len);
 
 

nginx/src/event/ngx_event_accept.c

@@ -20,6 +20,9 @@ static ngx_int_t ngx_disable_accept_events(ngx_cycle_t *cycle);
 static void ngx_close_accepted_connection(ngx_connection_t *c);
 
 
+// 监听端口上收到连接请求时的回调函数，即事件handler
+// 从cycle的连接池里获取连接
+// 关键操作 ls->handler(c);调用其他模块的业务handler
 void
 ngx_event_accept(ngx_event_t *ev)
 {
@@ -37,6 +40,7 @@ ngx_event_accept(ngx_event_t *ev)
     static ngx_uint_t  use_accept4 = 1;
 #endif
 
+    // 事件已经超时
     if (ev->timedout) {
         // 遍历监听端口列表，加入epoll连接事件
         if (ngx_enable_accept_events((ngx_cycle_t *) ngx_cycle) != NGX_OK) {
@@ -48,15 +52,22 @@ ngx_event_accept(ngx_event_t *ev)
 
     ecf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_event_core_module);
 
+    // rtsig在nginx 1.9.x已经删除
     if (ngx_event_flags & NGX_USE_RTSIG_EVENT) {
         ev->available = 1;
 
     } else if (!(ngx_event_flags & NGX_USE_KQUEUE_EVENT)) {
+        // epoll是否允许尽可能接受多个请求
         ev->available = ecf->multi_accept;
     }
 
+    // 事件的连接对象
     lc = ev->data;
+
+    // 事件对应的监听端口对象
     ls = lc->listening;
+
+    // 此时还没有数据可读
     ev->ready = 0;
 
     ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
@@ -65,6 +76,7 @@ ngx_event_accept(ngx_event_t *ev)
     do {
         socklen = NGX_SOCKADDRLEN;
 
+        // 调用accept接受连接，返回socket对象
 #if (NGX_HAVE_ACCEPT4)
         if (use_accept4) {
             s = accept4(lc->fd, (struct sockaddr *) sa, &socklen,
@@ -76,6 +88,7 @@ ngx_event_accept(ngx_event_t *ev)
         s = accept(lc->fd, (struct sockaddr *) sa, &socklen);
 #endif
 
+        // 接受连接出错
         if (s == (ngx_socket_t) -1) {
             err = ngx_socket_errno;
 
@@ -117,6 +130,7 @@ ngx_event_accept(ngx_event_t *ev)
                 }
             }
 
+            // 系统的文件句柄数用完了
             if (err == NGX_EMFILE || err == NGX_ENFILE) {
                 // 遍历监听端口列表，删除epoll监听连接事件，不接受请求
                 if (ngx_disable_accept_events((ngx_cycle_t *) ngx_cycle)
@@ -125,29 +139,36 @@ ngx_event_accept(ngx_event_t *ev)
                     return;
                 }
 
+                // 解锁负载均衡，允许其他进程接受请求
                 if (ngx_use_accept_mutex) {
                     if (ngx_accept_mutex_held) {
                         ngx_shmtx_unlock(&ngx_accept_mutex);
                         ngx_accept_mutex_held = 0;
                     }
 
+                    //未持有锁，暂时不接受请求
                     ngx_accept_disabled = 1;
 
                 } else {
+                    // 不使用负载均衡
+                    // 等待一下，再次尝试接受请求
                     ngx_add_timer(ev, ecf->accept_mutex_delay);
                 }
             }
 
             return;
-        }
+        } // 接受连接出错
 
 #if (NGX_STAT_STUB)
         (void) ngx_atomic_fetch_add(ngx_stat_accepted, 1);
 #endif
 
+        // ngx_accept_disabled是总连接数的1/8-空闲连接数
+        // 也就是说空闲连接数小于总数的1/8,那么就暂时停止接受连接
         ngx_accept_disabled = ngx_cycle->connection_n / 8
                               - ngx_cycle->free_connection_n;
 
+        // 从全局变量ngx_cycle里获取空闲链接，即free_connections链表
         c = ngx_get_connection(s, ev->log);
 
         if (c == NULL) {
@@ -163,12 +184,14 @@ ngx_event_accept(ngx_event_t *ev)
         (void) ngx_atomic_fetch_add(ngx_stat_active, 1);
 #endif
 
+        // 创建连接使用的内存池
         c->pool = ngx_create_pool(ls->pool_size, ev->log);
         if (c->pool == NULL) {
             ngx_close_accepted_connection(c);
             return;
         }
 
+        // 拷贝客户端sockaddr
         c->sockaddr = ngx_palloc(c->pool, socklen);
         if (c->sockaddr == NULL) {
             ngx_close_accepted_connection(c);
@@ -185,6 +208,7 @@ ngx_event_accept(ngx_event_t *ev)
 
         /* set a blocking mode for aio and non-blocking mode for others */
 
+        // 设置socket为非阻塞
         if (ngx_inherited_nonblocking) {
             if (ngx_event_flags & NGX_USE_AIO_EVENT) {
                 if (ngx_blocking(s) == -1) {
@@ -208,6 +232,10 @@ ngx_event_accept(ngx_event_t *ev)
 
         *log = ls->log;
 
+        // 连接的收发数据函数
+        // #define ngx_recv             ngx_io.recv
+        // #define ngx_recv_chain       ngx_io.recv_chain
+        // ngx_posix_init.c里初始化为linux的底层接口
         c->recv = ngx_recv;
         c->send = ngx_send;
         c->recv_chain = ngx_recv_chain;
@@ -216,6 +244,7 @@ ngx_event_accept(ngx_event_t *ev)
         c->log = log;
         c->pool->log = log;
 
+        // 设置其他的成员
         c->socklen = socklen;
         c->listening = ls;
         c->local_sockaddr = ls->sockaddr;
@@ -234,11 +263,14 @@ ngx_event_accept(ngx_event_t *ev)
         }
 #endif
 
+        // 连接相关的读写事件
         rev = c->read;
         wev = c->write;
 
+        // 建立连接后是可写的
         wev->ready = 1;
 
+        // rtsig在nginx 1.9.x已经删除
         if (ngx_event_flags & (NGX_USE_AIO_EVENT|NGX_USE_RTSIG_EVENT)) {
             /* rtsig, aio, iocp */
             rev->ready = 1;
@@ -263,6 +295,7 @@ ngx_event_accept(ngx_event_t *ev)
          *             or protection by critical section or light mutex
          */
 
+        // 连接计数器增加
         c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);
 
 #if (NGX_STAT_STUB)
@@ -364,12 +397,18 @@ ngx_event_accept(ngx_event_t *ev)
         log->data = NULL;
         log->handler = NULL;
 
+        // 接受连接，收到请求的回调函数
+        // 在http模块里是http.c:ngx_http_init_connection
         ls->handler(c);
 
+        // epoll不处理
         if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
             ev->available--;
         }
 
+    // 如果ev->available = ecf->multi_accept;
+    // epoll尽可能接受多个请求
+    // 否则epoll只接受一个请求后即退出循环
     } while (ev->available);
 }