ngx_event_accept

最新推荐文章于 2022-09-26 17:33:28 发布
最新推荐文章于 2022-09-26 17:33:28 发布
阅读量1.4k 收藏
点赞数
分类专栏： nginx 文章标签： c nginx源码分析 nginx event accept
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zgwhugr0216/article/details/30502933
版权 
void
ngx_event_accept(ngx_event_t *ev)
{
    socklen_t          socklen;
    ngx_err_t          err;
    ngx_log_t         *log;
    ngx_uint_t         level;
    ngx_socket_t       s;
    ngx_event_t       *rev, *wev;
    ngx_listening_t   *ls;
    ngx_connection_t  *c, *lc;
    ngx_event_conf_t  *ecf;
    u_char             sa[NGX_SOCKADDRLEN];
#if (NGX_HAVE_ACCEPT4)
    static ngx_uint_t  use_accept4 = 1;
#endif

    if (ev->timedout) {
        if (ngx_enable_accept_events((ngx_cycle_t *) ngx_cycle) != NGX_OK) {
            return;
        }

        ev->timedout = 0;
    }

    ecf = ngx_event_get_conf(ngx_cycle->conf_ctx, ngx_event_core_module);

    if (ngx_event_flags & NGX_USE_RTSIG_EVENT) {
        ev->available = 1;

    } else if (!(ngx_event_flags & NGX_USE_KQUEUE_EVENT)) {
        ev->available = ecf->multi_accept;  // epoll
    }

    lc = ev->data;  // 获得listening socket的connection
    ls = lc->listening;  // 获得对应的listening配置项
    ev->ready = 0;

    ngx_log_debug2(NGX_LOG_DEBUG_EVENT, ev->log, 0,
                   "accept on %V, ready: %d", &ls->addr_text, ev->available);

    do {
        socklen = NGX_SOCKADDRLEN;

#if (NGX_HAVE_ACCEPT4)
        if (use_accept4) {
            s = accept4(lc->fd, (struct sockaddr *) sa, &socklen,
                        SOCK_NONBLOCK);
        } else {
            s = accept(lc->fd, (struct sockaddr *) sa, &socklen);
        }
#else
        s = accept(lc->fd, (struct sockaddr *) sa, &socklen);  // accept client connection
#endif

        if (s == (ngx_socket_t) -1) {
            err = ngx_socket_errno;

            if (err == NGX_EAGAIN) {  // 无client连接，返回
                ngx_log_debug0(NGX_LOG_DEBUG_EVENT, ev->log, err,
                               "accept() not ready");
                return;
            }

            level = NGX_LOG_ALERT;

            if (err == NGX_ECONNABORTED) {
                level = NGX_LOG_ERR;

            } else if (err == NGX_EMFILE || err == NGX_ENFILE) {
                level = NGX_LOG_CRIT;
            }

#if (NGX_HAVE_ACCEPT4)
            ngx_log_error(level, ev->log, err,
                          use_accept4 ? "accept4() failed" : "accept() failed");

            if (use_accept4 && err == NGX_ENOSYS) {
                use_accept4 = 0;
                ngx_inherited_nonblocking = 0;
                continue;
            }
#else
            ngx_log_error(level, ev->log, err, "accept() failed");
#endif

            if (err == NGX_ECONNABORTED) {
                if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
                    ev->available--;
                }

                if (ev->available) {
                    continue;  // just try accept again
                }
            }

            if (err == NGX_EMFILE || err == NGX_ENFILE) {  // too many fds，进程资源耗尽
                if (ngx_disable_accept_events((ngx_cycle_t *) ngx_cycle)  // 将监听socket从epoll中剔除，让其他进程处理client连接
                    != NGX_OK)
                {
                    return;
                }

                if (ngx_use_accept_mutex) {
                    if (ngx_accept_mutex_held) {
                        ngx_shmtx_unlock(&ngx_accept_mutex);  // 释放accept锁
                        ngx_accept_mutex_held = 0;  // 清楚标记
                    }

                    ngx_accept_disabled = 1;  // disable accept一次

                } else {
                    ngx_add_timer(ev, ecf->accept_mutex_delay);
                }
            }

            return;
        }

#if (NGX_STAT_STUB)
        (void) ngx_atomic_fetch_add(ngx_stat_accepted, 1);
#endif
        // 简单的负载均衡（当进程的可用连接数少于总连接数的八分之一时，进程放弃accept新连接，让其他进程来处理新连接
        ngx_accept_disabled = ngx_cycle->connection_n / 8
                              - ngx_cycle->free_connection_n;

        c = ngx_get_connection(s, ev->log);  // 获取new connection

        if (c == NULL) {
            if (ngx_close_socket(s) == -1) {
                ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_socket_errno,
                              ngx_close_socket_n " failed");
            }

            return;
        }

#if (NGX_STAT_STUB)
        (void) ngx_atomic_fetch_add(ngx_stat_active, 1);
#endif

        c->pool = ngx_create_pool(ls->pool_size, ev->log);  // 为connection创建mem pool
        if (c->pool == NULL) {
            ngx_close_accepted_connection(c);
            return;
        }

        c->sockaddr = ngx_palloc(c->pool, socklen);
        if (c->sockaddr == NULL) {
            ngx_close_accepted_connection(c);
            return;
        }

        ngx_memcpy(c->sockaddr, sa, socklen);

        log = ngx_palloc(c->pool, sizeof(ngx_log_t));
        if (log == NULL) {
            ngx_close_accepted_connection(c);
            return;
        }

        /* set a blocking mode for aio and non-blocking mode for others */

        if (ngx_inherited_nonblocking) {
            if (ngx_event_flags & NGX_USE_AIO_EVENT) {
                if (ngx_blocking(s) == -1) {
                    ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_socket_errno,
                                  ngx_blocking_n " failed");
                    ngx_close_accepted_connection(c);
                    return;
                }
            }

        } else {
            if (!(ngx_event_flags & (NGX_USE_AIO_EVENT|NGX_USE_RTSIG_EVENT))) {
                if (ngx_nonblocking(s) == -1) {  // 设置socket为nonblock，epoll
                    ngx_log_error(NGX_LOG_ALERT, ev->log, ngx_socket_errno,
                                  ngx_nonblocking_n " failed");
                    ngx_close_accepted_connection(c);
                    return;
                }
            }
        }

        *log = ls->log;
        // 设置socket io读写回调函数
        c->recv = ngx_recv;
        c->send = ngx_send;
        c->recv_chain = ngx_recv_chain;
        c->send_chain = ngx_send_chain;

        c->log = log;
        c->pool->log = log;

        c->socklen = socklen;
        c->listening = ls;  // 设置listening指针
        c->local_sockaddr = ls->sockaddr;
        c->local_socklen = ls->socklen;
        c->unexpected_eof = 1;

#if (NGX_HAVE_UNIX_DOMAIN)
        if (c->sockaddr->sa_family == AF_UNIX) {
            c->tcp_nopush = NGX_TCP_NOPUSH_DISABLED;
            c->tcp_nodelay = NGX_TCP_NODELAY_DISABLED;
#if (NGX_SOLARIS)
            /* Solaris's sendfilev() supports AF_NCA, AF_INET, and AF_INET6 */
            c->sendfile = 0;
#endif
        }
#endif

        rev = c->read;
        wev = c->write;

        wev->ready = 1;  // 连接建立后，默认是ready for write的

        if (ngx_event_flags & (NGX_USE_AIO_EVENT|NGX_USE_RTSIG_EVENT)) {
            /* rtsig, aio, iocp */
            rev->ready = 1;
        }

        if (ev->deferred_accept) {
            rev->ready = 1;
#if (NGX_HAVE_KQUEUE)
            rev->available = 1;
#endif
        }

        rev->log = log;
        wev->log = log;

        /*
         * TODO: MT: - ngx_atomic_fetch_add()
         *             or protection by critical section or light mutex
         *
         * TODO: MP: - allocated in a shared memory
         *             or protection by critical section or light mutex
         */

        c->number = ngx_atomic_fetch_add(ngx_connection_counter, 1);

#if (NGX_STAT_STUB)
        (void) ngx_atomic_fetch_add(ngx_stat_handled, 1);
#endif

#if (NGX_THREADS)
        rev->lock = &c->lock;
        wev->lock = &c->lock;
        rev->own_lock = &c->lock;
        wev->own_lock = &c->lock;
#endif

        if (ls->addr_ntop) {
            c->addr_text.data = ngx_pnalloc(c->pool, ls->addr_text_max_len);
            if (c->addr_text.data == NULL) {
                ngx_close_accepted_connection(c);
                return;
            }

            c->addr_text.len = ngx_sock_ntop(c->sockaddr, c->socklen,
                                             c->addr_text.data,
                                             ls->addr_text_max_len, 0);
            if (c->addr_text.len == 0) {
                ngx_close_accepted_connection(c);
                return;
            }
        }

#if (NGX_DEBUG)
        {

        struct sockaddr_in   *sin;
        ngx_cidr_t           *cidr;
        ngx_uint_t            i;
#if (NGX_HAVE_INET6)
        struct sockaddr_in6  *sin6;
        ngx_uint_t            n;
#endif

        cidr = ecf->debug_connection.elts;
        for (i = 0; i < ecf->debug_connection.nelts; i++) {
            if (cidr[i].family != (ngx_uint_t) c->sockaddr->sa_family) {
                goto next;
            }

            switch (cidr[i].family) {

#if (NGX_HAVE_INET6)
            case AF_INET6:
                sin6 = (struct sockaddr_in6 *) c->sockaddr;
                for (n = 0; n < 16; n++) {
                    if ((sin6->sin6_addr.s6_addr[n]
                        & cidr[i].u.in6.mask.s6_addr[n])
                        != cidr[i].u.in6.addr.s6_addr[n])
                    {
                        goto next;
                    }
                }
                break;
#endif

#if (NGX_HAVE_UNIX_DOMAIN)
            case AF_UNIX:
                break;
#endif

            default: /* AF_INET */
                sin = (struct sockaddr_in *) c->sockaddr;
                if ((sin->sin_addr.s_addr & cidr[i].u.in.mask)
                    != cidr[i].u.in.addr)
                {
                    goto next;
                }
                break;
            }

            log->log_level = NGX_LOG_DEBUG_CONNECTION|NGX_LOG_DEBUG_ALL;
            break;

        next:
            continue;
        }

        }
#endif

        ngx_log_debug3(NGX_LOG_DEBUG_EVENT, log, 0,
                       "*%uA accept: %V fd:%d", c->number, &c->addr_text, s);

        if (ngx_add_conn && (ngx_event_flags & NGX_USE_EPOLL_EVENT) == 0) {
            if (ngx_add_conn(c) == NGX_ERROR) {  // epoll, ngx_epoll_add_connection, 以边触发方式注册读写事件
                ngx_close_accepted_connection(c);
                return;
            }
        }

        log->data = NULL;
        log->handler = NULL;

        ls->handler(c);  // 如果是http模块，则调用ngx_http_init_connection；此处设置读写回调分别为ngx_http_wait_request_handler和ngx_http_empty_handler；

        if (ngx_event_flags & NGX_USE_KQUEUE_EVENT) {
            ev->available--;
        }

    } while (ev->available);
}

zgwhugr0216
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
24.Nginx监听套接字读事件处理函数ngx_event_accept
疯哥哥带你飞
11-09 1730
前面讲过ngx_event_core_module模块的init_process函数ngx_event_process_init会为每个监听套接字的读事件注册处理函数ngx_event_accept，本篇就学习一下在ngx_event_accept函数中到底进行了哪些工作。 /* event/ngx_event_accept.c */ /* 监听套接字的读事件处理函数 * param
NGX --- ACCEPT事件处理
Dalek的专栏
08-09 1193
void ngx_process_events_and_timers(ngx_cycle_t *cycle) {     ngx_uint_t  flags;     ngx_msec_t  timer, delta; ......     delta = ngx_current_msec;          // 处理事件ngx_epoll_process_eve
Nginx源码阅读（ngx_event_accept）
Jiajun Zhu
04-02 960
static ngx_int_t ngx_event_process_init(ngx_cycle_t *cycle) { ngx_uint_t m, i; ngx_event_t *rev, *wev; ngx_listening_t *ls; ngx_connection_t *c, *next, *old; ...
nginx源代码分析 - 收到请求（一） accept处理事件
deusomax的专栏
12-01 475
收到客户端请求 epoll_wait返回events = 1, ngx_connection_t  *c = event_list[i].data.ptr; static struct epoll_event  *event_list; typedef union epoll_data {     void         *ptr;     int           fd;
nginx 处理accept
benbendy1984的专栏
11-16 2914
<br />      accept过程实现在 ngx_event_accept.c中的ngx_event_accept函数中,主要过程如下：<br /> <br />     一  accept()<br /> <br />     二  从连接池中取得一个连接                                                                                                  <br />           c = ngx_
ngx_devel_kit-0.3.0
07-18
ngx_devel_kit（通常缩写为 NDK）是一个针对Nginx的模块开发工具集，它为构建自定义Nginx模块提供了便利。在Nginx生态系统中，NDK是一个重要的扩展工具，允许开发者利用C语言直接操作Nginx的内部结构，以实现更高级...
ngx_cache_purge_2.4.2.tar.gz
02-21
这个版本2.4.2的压缩包包含了ngx_cache_purge模块的所有源代码及相关文件，以便开发者在自己的Nginx环境中集成和使用。 Nginx是一款高性能、轻量级的Web服务器和反向代理服务器，广泛应用于互联网服务。其内置的...
ngx_stream_module.so
12-22
nginx1.20.2
ngx_http_proxy_connect_module.zip
06-17
ngx_http_proxy_connect_module是一个针对Nginx服务器的第三方模块，主要功能是支持HTTP代理的"CONNECT"方法。在默认情况下，Nginx仅处理HTTP和HTTPS请求，但不支持通过HTTP代理进行TCP连接，比如SSL/TLS隧道。这个...
qevent 事件的accept（）和ignore（）
热门推荐
证券指标的专栏
06-03 1万+
本章内容也是关于Qt事件。或许这一章不能有一个完整的例子，因为对于事件总是感觉很抽象，还是从底层上理解一下比较好的吧！ 前面说到了事件的作用，下面来看看我们如何来接收事件。回忆一下前面的代码，我们在子类中重写了事件函数，以便让这些子类按照我们的需要完成某些功能，就像下面的代码： void MyLabel::mousePressEvent(QMouseEvent * event)
Nginx学习笔记之事件驱动框架处理流程
01-10
ngx_event_core_module模块的ngx_event_process_init方法对事件模块做了一些初始化。其中包括将“请求连接”这样一个读事件对应的处理方法（handler）设置为ngx_event_accept函数，并将此事件添加到epoll模块中。当有新连接事件发生时，ngx_event_accept就会被调用。大致流程是这样： worker进程在ngx_worker_process_cycle方法中不断循环调用ngx_process_events_and_timers函数处理事件，这个函数是事件处理的总入口。 ngx_process_events_and_timers会调
Nginx源码阅读 --- nginx evnet事件接受请求时，函数执行过程
alpha_love的博客
08-02 159
1. 首先了解几个地方： 监听套接字listen可读后（提前准备好处理函数ngx_http_init_connection），建立连接(ngx_event_accept), 并把后续可读处理函数设置为(ngx_http_wait_request_handler)，使用epoll_wait函数驱动整个过程进行 2. 具体代码跟踪： 当解析到配置文件http时，调用下面函数进行初始化监听处理函数， 3. 当建立http请求后的处理过程： ...
六、event_accept函数
04-28 1198
此函数对应于Listner在有新链接的时候调用的read函数。 [src/client.c]event_accept() int event_accept(int fd) { struct listener *l = fdtab[fd].owner;//这个值从前一部分可知 struct proxy *p = (struct proxy *)l->private; //这是在解析配置文
Qt中事件（event）的接受（accept）与忽略（ignore）
qq_32491021的博客
12-13 8216
之前一直对Qt的事件不甚理解，今天结合豆子哥的教程再在Vs2013+Qt 编译环境下进行编程后终于弄懂了，简单地记录一下我认为比较重要的点如下： 1.事件的传播是在组件层次上面的，而不是依靠类继承机制。 注：这句话很关键，当触发一个窗口组件时，如果ignore了，则事件会继续传播到上层组件。如下程序，点击了CustomButton按钮，则会触发CustomWidget和MainWindow这2个上...
nginx 源码学习笔记（二十）—— event 模块(一) ——初始化
数据库天地
05-25 158
读完之前的学习笔记，相信已经对nginx的启动流程有了一定的认识，从这一节起我们想深入各个模块，学习各个模块的内的主要操作。 本文来自于：http://blog.csdn.net/lengzijian/article/details/7598996 今天我们就来学习下event模块，在之前的启动里多次提到了调用各个模块的钩子函数，我们先来回忆一下关于event模块钩子函数的执行，也是eve...
Nginx源码分析 - Event事件篇 - Nginx的Event事件模块概览（17）
alpha_love的博客
05-12 671
目录 一、event模块的概览 二、重要数据结构 1. ngx_listening_s 侦听结构 2. ngx_connection_s socket连接对象结构 3. ngx_event_s 事件数据结构 前一章，我们讲解了《Nginx源码分析 - 主流程篇 - 多进程的惊群和进程负载均衡处理 》中实际上已经涉及到了一部分事件模块的概念。细心的可以发现，Nginx的事件都是由nginx_event.c文件中的ngx_process_events_and_timers进程事件分发器这个函数开..
Nginx的事件循环
fjs的专栏
11-03 2077
这篇文章讲Nginx是如何进行时间循环的，首先事件循环的起点就是监听端口获取连接，我们可以在ngx_event_core_module模块的ngx_event_process_init函数中看到如下的代码： /* for each listening socket */ /*为每个监听套接字从connection数组中分配一个连接，即一个slot*/ ls = cycle->li
NGINX源码之：filter机制
qq_22351805的博客
09-26 852
NGINX源码解读，ngx_http_send_header、ngx_http_output_filter、ngx_linux_sendfile_chain、
NGINX源码之：event与epoll
qq_22351805的博客
08-31 1193
nginx event与epoll处理机制，ngx_events_block、ngx_event_use、ngx_event_process_init、ngx_epoll_init、ngx_epoll_add_event、ngx_process_events_and_timers、ngx_epoll_process_events、ngx_event_accept、ngx_get_connection、ngx_drain_connections等方法解读.........
ngx_req_status
最新发布
11-20
ngx_req_status有不同的取值，包括NGX_OK、NGX_ERROR、NGX_AGAIN等。 NGX_OK表示请求处理成功，可以正常返回响应给客户端。 NGX_ERROR表示请求处理出现错误，需要终止请求并返回错误给客户端。 NGX_AGAIN表示请求...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值