nginx源码阅读(十).ngx_event_core_module模块

最新推荐文章于 2020-01-18 22:30:40 发布
置顶 最新推荐文章于 2020-01-18 22:30:40 发布
阅读量930 收藏
点赞数
分类专栏： Nginx Nginx源码阅读 文章标签： nginx 源码 事件模块 event-core 流程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Move_now/article/details/78462223
版权

前言

本小节将进入到ngx_event_core_module模块,它是所有事件模块中排第一位的模块,因为要负责创建连接池,还要选择I/O多路复用机制等工作。接下来我们就来看看它是如何做到的,以及在nginx中扮演了一个什么角色。

模块的通用接口

我们先来看看ngx_event_core_module模块实现的所有模块都需要实现的ngx_module_t接口。

ngx_module_t  ngx_event_core_module = {
    /* NGX_MODULE_V1定义为:
     * #define NGX_MODULE_V1      0, 0, 0, 0, 0, 0, 1
     * 直接初始化前7个成员
     */
    NGX_MODULE_V1,
    /* ctx成员,事件模块的具体化接口 */
    &ngx_event_core_module_ctx,            /* module context */
    //ngx_command_t成员
    ngx_event_core_commands,               /* module directives */
    //模块类型
    NGX_EVENT_MODULE,                      /* module type */
    NULL,                                  /* init master */
    //初始化ngx_event_core_module模块
    ngx_event_module_init,                 /* init module */
    //在进入到工作循环前进行初始化
    ngx_event_process_init,                /* init process */
    NULL,                                  /* init thread */
    NULL,                                  /* exit thread */
    NULL,                                  /* exit process */
    NULL,                                  /* exit master */
    /* 将预留空间填充为0 */
    NGX_MODULE_V1_PADDING
};

关于ngx_event_module_init方法,在进入到master进程工作循环前由ngx_init_cycle调用:

//调用所有模块的init_module方法
for (i = 0; ngx_modules[i]; i++) {
    if (ngx_modules[i]->init_module) {
        if (ngx_modules[i]->init_module(cycle) != NGX_OK) {
            /* fatal */
            exit(1);
        }
    }
}

ngx_event_module_init所做的工作主要是初始化了一些变量,这里不具体分析(因为跟一些用于统计的变量有关,与该模块的联系不是特别大)

关于ngx_event_process_init,其实上一小节我们已经分析了它是如何创建连接池、读事件、写事件,不过除此之外,它还做了其他事情,比如调用指定的I/O多路复用机制模块的init方法。
关于它的调用,它是在ngx_worker_process_init中被调用。从main函数开始的调用栈如图:
这里写图片描述
而其的源码如下:

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;
    ngx_core_conf_t     *ccf;
    ngx_event_conf_t    *ecf;
    ngx_event_module_t  *module;

    //获取ngx_core_module的配置项结构体指针
    ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
    //获取ngx_event_core_module的配置项结构体指针
    ecf = ngx_event_get_conf(cycle->conf_ctx, ngx_event_core_module);

    /* 当配置文件中的负载均衡锁的选项启用
     * 并且使用的是多进程模型(worker进程数大于1并且使用了master进程)
     * 于是开启accept_mutex负载均衡锁(代表需要进行负载均衡)
     */
    if (ccf->master && ccf->worker_processes > 1 && ecf->accept_mutex) {
        //将全局负载均衡锁开关置为1
        ngx_use_accept_mutex = 1;
        //ngx_accept_mutex_held为0代表表示当前进程未获取到负载均衡锁
        //为1代表获取到了
        ngx_accept_mutex_held = 0;
        //ngx_accept_mutex_delay的值为在配置文件中指定的最大延迟时间
        //具体所代表的含义,我们在后面分析进程间负载均衡的时候再去了解
        ngx_accept_mutex_delay = ecf->accept_mutex_delay;

    } else {
        //否则将该全局变量置为0
        //表示不启用负载均衡(毕竟只有一个进程)
        ngx_use_accept_mutex = 0;
    }

#if (NGX_THREADS)
    ngx_posted_events_mutex = ngx_mutex_init(cycle->log, 0);
    if (ngx_posted_events_mutex == NULL) {
        return NGX_ERROR;
    }
#endif

    //初始化定时器(nginx中的定时器是由红黑树实现的)
    if (ngx_event_timer_init(cycle->log) == NGX_ERROR) {
        return NGX_ERROR;
    }

    //遍历所有事件模块
    for (m = 0; ngx_modules[m]; m++) {
        if (ngx_modules[m]->type != NGX_EVENT_MODULE) {
            continue;
        }

        //配置项中的use选项选择了使用的I/O多路复用机制
        //找到事件模块中的该事件驱动模块
        if (ngx_modules[m]->ctx_index != ecf->use) {
            continue;
        }

        module = ngx_modules[m]->ctx;

        //调用该模块对应的init方法进行初始化
        if (module->actions.init(cycle, ngx_timer_resolution) != NGX_OK) {
            /* fatal */
            exit(2);
        }

        break;
    }

#if !(NGX_WIN32)

    /* nginx中采用了时间缓存,并不是需要获取时间时就调用gettimeofday来获取
     * 因此精度方面可能需要进行控制
     * 而ngx_timer_resolution(通过核心模块的配置项获取,默认是0)表示时间的精度
     * 而NGX_USE_TIMER_EVENT在epoll中并没有使用
     * 因此只要设置了控制时间的精度
     * 就会定期进行更新
     */
    if (ngx_timer_resolution && !(ngx_event_flags & NGX_USE_TIMER_EVENT)) {
        /* 设置SIGALRM捕捉之后的处理函数
         * ngx_timer_signal_handler
         */
        struct sigaction  sa;
        struct itimerval  itv;

        ngx_memzero(&sa, sizeof(struct sigaction));
        sa.sa_handler = ngx_timer_signal_handler;
        sigemptyset(&sa.sa_mask);

        if (sigaction(SIGALRM, &sa, NULL) == -1) {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                          "sigaction(SIGALRM) failed");
            return NGX_ERROR;
        }

        /* 设置定时时间
         * it_interval成员指定间隔的时间
         * it_value成员指定初始定时时间
         */
        itv.it_interval.tv_sec = ngx_timer_resolution / 1000;
        itv.it_interval.tv_usec = (ngx_timer_resolution % 1000) * 1000;
        itv.it_value.tv_sec = ngx_timer_resolution / 1000;
        itv.it_value.tv_usec = (ngx_timer_resolution % 1000 ) * 1000;

        /* 调用setitimer函数
         * 每过ngx_timer_resolution时间调用ngx_timer_signal_handler方法
         */
        if (setitimer(ITIMER_REAL, &itv, NULL) == -1) {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                          "setitimer() failed");
        }
    }

    /* 使用poll事件驱动 */
    if (ngx_event_flags & NGX_USE_FD_EVENT) {
        struct rlimit  rlmt;

        if (getrlimit(RLIMIT_NOFILE, &rlmt) == -1) {
            ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
                          "getrlimit(RLIMIT_NOFILE) failed");
            return NGX_ERROR;
        }

        cycle->files_n = (ngx_uint_t) rlmt.rlim_cur;

        /* 预分配运行时使用的句柄 */
        cycle->files = ngx_calloc(sizeof(ngx_connection_t *) * cycle->files_n,
                                  cycle->log);
        if (cycle->files == NULL) {
            return NGX_ERROR;
        }
    }

#endif

    /* 预分配connections数组 */
    cycle->connections =
        ngx_alloc(sizeof(ngx_connection_t) * cycle->connection_n, cycle->log);
    if (cycle->connections == NULL) {
        return NGX_ERROR;
    }

    c = cycle->connections;

    /* 预分配读事件 */
    cycle->read_events = ngx_alloc(sizeof(ngx_event_t) * cycle->connection_n,
                                   cycle->log);
    if (cycle->read_events == NULL) {
        return NGX_ERROR;
    }

    /* 初始化读事件 */
    rev = cycle->read_events;
    for (i = 0; i < cycle->connection_n; i++) {
        rev[i].closed = 1;
        rev[i].instance = 1;
#if (NGX_THREADS)
        rev[i].lock = &c[i].lock;
        rev[i].own_lock = &c[i].lock;
#endif
    }

    /* 预分配写事件 */
    cycle->write_events = ngx_alloc(sizeof(ngx_event_t) * cycle->connection_n,
                                    cycle->log);
    if (cycle->write_events == NULL) {
        return NGX_ERROR;
    }

    /* 初始化写事件 */
    wev = cycle->write_events;
    for (i = 0; i < cycle->connection_n; i++) {
        wev[i].closed = 1;
#if (NGX_THREADS)
        wev[i].lock = &c[i].lock;
        wev[i].own_lock = &c[i].lock;
#endif
    }

    /* 初始化状态时,connections数组中的都是空闲连接
     * 使用data变量将connections数组中所有元素都连接起来
     * 然后将读事件和写事件绑定到连接上
     * 并将fd置为-1
     */
    i = cycle->connection_n;
    next = NULL;

    do {
        i--;

        c[i].data = next;
        c[i].read = &cycle->read_events[i];
        c[i].write = &cycle->write_events[i];
        c[i].fd = (ngx_socket_t) -1;

        next = &c[i];

#if (NGX_THREADS)
        c[i].lock = 0;
#endif
    } while (i);

    //将free_connections指向第一个空闲连接
    cycle->free_connections = next;
    //设置空闲连接数
    cycle->free_connection_n = cycle->connection_n;

    /* for each listening socket */

    /* 为每个监听端口分配一个连接 */
    ls = cycle->listening.elts;
    for (i = 0; i < cycle->listening.nelts; i++) {

        /* 获取一个空闲连接 */
        c = ngx_get_connection(ls[i].fd, cycle->log);

        if (c == NULL) {
            return NGX_ERROR;
        }

        c->log = &ls[i].log;

        //将listening对象绑定到连接对象上
        c->listening = &ls[i];
        //将连接对象绑定到listening对象上
        ls[i].connection = c;

        //监听端口只关心读事件
        rev = c->read;

        rev->log = c->log;
        //设置为可以接受连接
        rev->accept = 1;

#if (NGX_HAVE_DEFERRED_ACCEPT)
        rev->deferred_accept = ls[i].deferred_accept;
#endif

        if (!(ngx_event_flags & NGX_USE_IOCP_EVENT)) {
            if (ls[i].previous) {

                /*
                 * delete the old accept events that were bound to
                 * the old cycle read events array
                 */

                old = ls[i].previous->connection;

                if (ngx_del_event(old->read, NGX_READ_EVENT, NGX_CLOSE_EVENT)
                    == NGX_ERROR)
                {
                    return NGX_ERROR;
                }

                old->fd = (ngx_socket_t) -1;
            }
        }

#if (NGX_WIN32)

        if (ngx_event_flags & NGX_USE_IOCP_EVENT) {
            ngx_iocp_conf_t  *iocpcf;

            rev->handler = ngx_event_acceptex;

            if (ngx_use_accept_mutex) {
                continue;
            }

            if (ngx_add_event(rev, 0, NGX_IOCP_ACCEPT) == NGX_ERROR) {
                return NGX_ERROR;
            }

            ls[i].log.handler = ngx_acceptex_log_error;

            iocpcf = ngx_event_get_conf(cycle->conf_ctx, ngx_iocp_module);
            if (ngx_event_post_acceptex(&ls[i], iocpcf->post_acceptex)
                == NGX_ERROR)
            {
                return NGX_ERROR;
            }

        } else {
            rev->handler = ngx_event_accept;

            if (ngx_use_accept_mutex) {
                continue;
            }

            if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
                return NGX_ERROR;
            }
        }

#else
        /* 设置接受连接的回调函数为ngx_event_accept
         * 即监听端口上收到连接请求时的回调函数
         * 在ngx_event_accept函数中从连接池里获取到连接
         * 关键操作:ls->handler(c); //调用其他事件消费模块的handler(比如http模块)
         */
        rev->handler = ngx_event_accept;

        /* 如果使用了负载均衡(ngx_use_accept_mutex为1)
         * 只有当拥有负载均衡锁的时候才添加事件到epoll中
         */
        if (ngx_use_accept_mutex) {
            continue;
        }



        if (ngx_event_flags & NGX_USE_RTSIG_EVENT) {
            if (ngx_add_conn(c) == NGX_ERROR) {
                return NGX_ERROR;
            }

        } else {
            //将读事件添加到epoll监听事件中
            if (ngx_add_event(rev, NGX_READ_EVENT, 0) == NGX_ERROR) {
                return NGX_ERROR;
            }
        }

#endif

    }

    return NGX_OK;
}

这里写图片描述

感兴趣的配置项

在分析事件模块的具体化通用接口ngx_event_core_module_ctx之前,我们先对ngx_event_core_module模块对哪些模块感兴趣做个了解,这有利于我们看懂后面的代码。

static ngx_command_t  ngx_event_core_commands[] = {

    //连接池的大小,即每个worker进程中支持的tcp最大连接数
    //与下面的connections配置项意义相同
    { ngx_string("worker_connections"),
      NGX_EVENT_CONF|NGX_CONF_TAKE1,
      ngx_event_connections,
      0,
      0,
      NULL },

    //连接池的大小
    { ngx_string("connections"),
      NGX_EVENT_CONF|NGX_CONF_TAKE1,
      ngx_event_connections,
      0,
      0,
      NULL },

    //确定选择的哪一个事件模块作为I/O多路复用机制
    { ngx_string("use"),
      NGX_EVENT_CONF|NGX_CONF_TAKE1,
      ngx_event_use,
      0,
      0,
      NULL },

    //对于epoll来说,该配置项意味着在接收到一个新连接事件时,调用accpet尽可能多的接受连接
    { ngx_string("multi_accept"),
      NGX_EVENT_CONF|NGX_CONF_FLAG,
      ngx_conf_set_flag_slot,
      0,
      offsetof(ngx_event_conf_t, multi_accept),
      NULL },

    //确定是否使用负载均衡锁,默认为开启
    //但是在nginx1.11.3版本之后,默认关闭
    { ngx_string("accept_mutex"),
      NGX_EVENT_CONF|NGX_CONF_FLAG,
      ngx_conf_set_flag_slot,
      0,
      offsetof(ngx_event_conf_t, accept_mutex),
      NULL },

    //启用负载均衡锁后,延迟accept_mutex_delay毫秒后再试图处理新连接事件
    { ngx_string("accept_mutex_delay"),
      NGX_EVENT_CONF|NGX_CONF_TAKE1,
      ngx_conf_set_msec_slot,
      0,
      offsetof(ngx_event_conf_t, accept_mutex_delay),
      NULL },

    //需要对来自指定ip的tcp连接打印debug级的调试日志
    { ngx_string("debug_connection"),
      NGX_EVENT_CONF|NGX_CONF_TAKE1,
      ngx_event_debug_connection,
      0,
      0,
      NULL },

      ngx_null_command
};

之前也提到过,在ngx_init_cycle函数中会调用ngx_conf_parse对nginx.conf文件进行解析,其中会调用ngx_conf_handler,用依次读取到的配置项遍历ngx_modules数组,如果有模块对该配置项感兴趣,则会调用其commands成员中的set指向的函数对该配置项进行处理。
这里我们稍微总结一下事件模块中配置项的解析还有存储方面。

  1. 首先是ngx_init_cycle函数中调用ngx_conf_parse函数,其中会调用ngx_conf_handler函数,对读取到的配置项遍历ngx_modules数组,当读取到”events{}”时,ngx_events_module就会调用commands成员中set成员指向的函数ngx_events_block,该函数内部申请了存储配置项的结构体空间,并与核心结构体ngx_cycle_t的conf_ctx产生了联系

  2. 存储配置项的结构体已经有了,ngx_events_block调用ngx_conf_parse,当有事件模块感兴趣的配置项时,就会调用当前事件模块设置的配置项解析方法(对应上面列出的感兴趣的那7个配置项)

  3. 最后调用每个模块都会实现的init_conf对对应的配置项结构体里的没设置的值设为默认值。

ngx_event_core_module模块中对应的init_conf方法为ngx_event_init_conf函数,下面我们会对该函数进行分析。解析了配置文件之后,配置项结构体中还没有被赋值的成员,将被设置为默认值,这就是ngx_event_init_conf的工作。

存储配置项

那么现在我们就可以来看看,事件模块中存储配置项的结构体长什么样子(event/ngx_event.h中定义):

typedef struct {
    //连接池的大小
    ngx_uint_t    connections;
    /* 选用的事件驱动模块
     * 这里存储的是事件模块中模块内部的编号
     */
    ngx_uint_t    use;

    /* 标识位,为1时表示在接收到一个新连接事件时,一次性建立尽可能多的连接 */
    ngx_flag_t    multi_accept;
    /* 标识位,为1时表示启用负载均衡锁 */
    ngx_flag_t    accept_mutex;

    /* 负载均衡锁会使得一些worker进程在拿不到锁时延迟建立新连接
     * 而延迟的时间就由accept_mutex_delay执行(以ms为单位)
     */
    ngx_msec_t    accept_mutex_delay;

    //选用的事件驱动模块的名字,它与use成员相对应
    u_char       *name;

#if (NGX_DEBUG)
    ngx_array_t   debug_connection;
#endif
} ngx_event_conf_t;
事件模块的通用接口
......
static ngx_str_t  event_core_name = ngx_string("event_core");

......
ngx_event_module_t  ngx_event_core_module_ctx = {
    //name
    &event_core_name,
    //create_conf
    ngx_event_create_conf,                 /* create configuration */
    //init_conf
    ngx_event_init_conf,                   /* init configuration */

    /* 关于ngx_event_actions中的方法ngx_event_core_module并不需要去实现
     * 因为该模块并不需要对事件进行注册、添加、删除等操作
     */
    { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL }
};

下面我们来看看ngx_event_create_conf是如何实现的:

static void *
ngx_event_create_conf(ngx_cycle_t *cycle)
{
    ngx_event_conf_t  *ecf;

    //申请存储配置项的结构体(ngx_event_conf_t)空间
    ecf = ngx_palloc(cycle->pool, sizeof(ngx_event_conf_t));
    if (ecf == NULL) {
        return NULL;
    }

    //将配置项结构体(ngx_event_conf_t)的成员设置为unset
    ecf->connections = NGX_CONF_UNSET_UINT;
    ecf->use = NGX_CONF_UNSET_UINT;
    ecf->multi_accept = NGX_CONF_UNSET;
    ecf->accept_mutex = NGX_CONF_UNSET;
    ecf->accept_mutex_delay = NGX_CONF_UNSET_MSEC;
    ecf->name = (void *) NGX_CONF_UNSET;

#if (NGX_DEBUG)

    if (ngx_array_init(&ecf->debug_connection, cycle->pool, 4,
                       sizeof(ngx_event_debug_t)) == NGX_ERROR)
    {
        return NULL;
    }

#endif

    return ecf;
}

只看了函数的源码是远远不够的,主要是要把握该函数出于什么功能被调用,何时被调用,这样才能把事件模块的逻辑理清楚,否则看懂了代码也不明白为什么这样做。

  1. ngx_event_create_conf函数是在ngx_events_block中被调用的,它会先调用所有事件模块的create_conf函数(即ngx_event_create_conf函数),作用是在解析配置文件前,先申请存储配置项结构体(ngx_event_conf_t)的空间,接着将结构体的成员设置为NGX_CONF_UNSET(这不是代表默认值,而是未设置)。

  2. 接着ngx_events_block会调用ngx_conf_parse解析配置项并存储在结构体(ngx_event_conf_t)中

  3. 当解析完配置文件后,调用ngx_event_init_conf方法将配置项结构体中没有被设置值的成员设置为默认值。

static char *
ngx_event_init_conf(ngx_cycle_t *cycle, void *conf)
{
    //获取到模块的配置项指针
    ngx_event_conf_t  *ecf = conf;

#if (NGX_HAVE_EPOLL) && !(NGX_TEST_BUILD_EPOLL)
    int                  fd;
#endif
#if (NGX_HAVE_RTSIG)
    ngx_uint_t           rtsig;
    ngx_core_conf_t     *ccf;
#endif
    ngx_int_t            i;
    ngx_module_t        *module;
    ngx_event_module_t  *event_module;

    module = NULL;

#if (NGX_HAVE_EPOLL) && !(NGX_TEST_BUILD_EPOLL)
    /* 调用epoll_create测试epoll机制是否可用 */
    fd = epoll_create(100);


    if (fd != -1) {
        /* 创建成功,证明epoll可用
         * 关闭测试epoll返回的fd
         * 选择epoll为默认的事件驱动模块
         */
        close(fd);
        module = &ngx_epoll_module;

    } else if (ngx_errno != NGX_ENOSYS) {
        /* 虽然返回-1创建失败了
         * 但是如果errno不为ENOSYS(Function not implemented)
         * 证明epoll还是可用的(至少当前机器有这个机制存在)
         */
        module = &ngx_epoll_module;
    }

#endif


/* 若有rtsig机制并且module还未选择
 * 则默认使用rtsig机制
 */
#if (NGX_HAVE_RTSIG)

    if (module == NULL) {
        module = &ngx_rtsig_module;
        rtsig = 1;

    } else {
        rtsig = 0;
    }

#endif

/* 如果有devpoll机制,选择devpoll机制
 * 这里你可能会疑惑为什么不用判断module是否为NULL
 * 因为目前一个操作系统上不会同时出现epoll、devpoll、kqueue等机制
 */
#if (NGX_HAVE_DEVPOLL)

    module = &ngx_devpoll_module;

#endif

/* 若有kqueue机制,则默认选择kqueue机制 */
#if (NGX_HAVE_KQUEUE)

    module = &ngx_kqueue_module;

#endif

/* 如果module还未选择
 * 有select就默认选select了
 */
#if (NGX_HAVE_SELECT)

    if (module == NULL) {
        module = &ngx_select_module;
    }

#endif

    /* 走到这一步,要是module还是没有选择出来
     * 那就遍历事件模块,选择第一个非ngx_event_core_module模块作为默认的事件驱动模块
     */
    if (module == NULL) {
        for (i = 0; ngx_modules[i]; i++) {
            //过滤掉非事件模块
            if (ngx_modules[i]->type != NGX_EVENT_MODULE) {
                continue;
            }

            event_module = ngx_modules[i]->ctx;

            //过滤掉ngx_event_core_module模块
            if (ngx_strcmp(event_module->name->data, event_core_name.data) == 0)
            {
                continue;
            }

            //选择ngx_modules[i]作为默认的事件驱动模块
            module = ngx_modules[i];
            break;
        }
    }

    //此时还没有合适的默认module
    //那就出错了
    if (module == NULL) {
        ngx_log_error(NGX_LOG_EMERG, cycle->log, 0, "no events module found");
        return NGX_CONF_ERROR;
    }

    /* 若配置项中没有设置连接池的大小
     * 则设置连接池的默认大小
     * DEFAULT_CONNECTIONS宏定义为512
     * ngx_conf_init_uint_value是一个宏函数:
     * #define ngx_conf_init_uint_value(conf, default)    \
     * if(conf == NGX_CONF_UNSET_UINT) {  \
     *     conf = default;    \  
     * }
     */
    ngx_conf_init_uint_value(ecf->connections, DEFAULT_CONNECTIONS);

    //给cycle->connection_n赋值
    cycle->connection_n = ecf->connections;

    //若use配置项没有赋值,则设置默认使用的事件驱动模块
    ngx_conf_init_uint_value(ecf->use, module->ctx_index);

    //初始化使用的事件模块的名字
    event_module = module->ctx;
    ngx_conf_init_ptr_value(ecf->name, event_module->name->data);

    //若配置项中没有设置multi_accept,则默认不接受多个请求,即一次只accept一个连接
    ngx_conf_init_value(ecf->multi_accept, 0);
    //若配置项中没有设置accept_mutex,则默认使用负载均衡锁,但是1.11.3版本之后默认关闭
    ngx_conf_init_value(ecf->accept_mutex, 1);
    //若配置项中没有设置accept_mutex,则默认负载均衡锁的等待时间是500ms
    ngx_conf_init_msec_value(ecf->accept_mutex_delay, 500);


#if (NGX_HAVE_RTSIG)

    if (!rtsig) {
        return NGX_CONF_OK;
    }

    if (ecf->accept_mutex) {
        return NGX_CONF_OK;
    }

    ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);

    if (ccf->worker_processes == 0) {
        return NGX_CONF_OK;
    }

    ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
                  "the \"rtsig\" method requires \"accept_mutex\" to be on");

    return NGX_CONF_ERROR;

#else

    return NGX_CONF_OK;

#endif
}

最后附上一张大致流程图来总结本小节:
这里写图片描述

小结

本小节信息量略大,与第八节关系紧密,如果感觉难以理解,建议和第八节对照着一起看,希望能做到把主框架及ngx_events_module、ngx_event_core_module联系起来。

接下来我们将分析ngx_epoll_module模块。

UKey_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【Nginx】ngx_event_core_module模块
weixin_33923148的博客
04-11 66
ngx_event_core_module模块属于事件模块，它是其他事件类模块的基础。它主要完毕下面任务： 创建连接池决定使用哪些事件驱动机制初始化将要使用的事件模块 以下分析该模块的代码。 ngx_event_core_module的ngx_command_t数组定义例如以下： /* ngx_event_core_module对7个配置项感兴趣 */ stat...
Nginx事件管理之ngx_event_core_module模块
weixin_30734435的博客
04-25 122
1. 概述 ngx_event_core_module 模块是一个事件类型的模块，它在所有事件模块中的顺序是第一位。它主要完成以下两点任务： 创建连接池（包括读/写事件）； 决定究竟使用哪些事件驱动机制，并初始化将要使用的事件模块 2. 配置项 static ngx_command_t ngx_event_core_commands[] = { /* 连接池的大小，也就是每个 wo...
nginx事件模块结构体详解
爱宝贝丶的博客
01-08 321
        事件模块是nginx的核心模块之一，nginx中客户端请求的处理和命令行指令的执行都是基于事件模块进行驱动的。因此，掌握事件模块的实现原理对于我们理解nginx整体架构有非常重要的意义。本文首先会讲解事件模块相关的几个模块定义及其执行流程进行讲解，其源码的讲解将会在后面的文章中进行。  &nb...
nginx源码分析-各模块说明
@农夫(Ben.Liang)
09-07 2656
auth:农夫-Benemail:szjava#126.com(请把#换成@)blog:http://blog.csdn.net/zll_liang ngx_core_module 核心模块 ngx_errlog_module 日志模块 为什么叫errlog呢？ ngx_conf_module 配置模块， 主要是解决配置文件并存储到相应的conf_t中 ngx_events_mod
reading-code-of-nginx-1.9.2_y123456yz.tar.gz
10-20
3. **事件处理**：Nginx的事件处理主要由`ngx_event_module`模块完成，`ngx_event_actions`结构体定义了事件的基本操作，如添加、删除、激活事件等。 4. **请求处理**：当接收到客户端请求时，`ngx_...
Nginx-1.7.3:Nginx源码阅读注解
03-23
在本主题“Nginx-1.7.3：Nginx源码阅读注解”中，我们将深入探讨Nginx 1.7.3版本的源码结构、核心模块及其工作原理。 源码阅读是理解Nginx内部机制的关键步骤，这对于开发者进行性能优化、功能扩展或定制化开发具有...
nginx-1.17.9:nginx-1.17.9源码分析
03-23
在 Nginx 源码中，`src/core/nginx.h` 文件是整个项目的头文件，包含了基础的数据类型定义和全局宏。`src/event` 目录下则是事件模块的核心代码，包括了对不同操作系统事件机制的封装，如 epoll（Linux），kqueue...
nginx源码分析configure脚本详解
01-20
 在之前介绍event模块的时候，讲到init_cycle函数中对cycle进行了初始化，其中很重要一步操作就是讲包含所有module信息的数组拷贝到这个cycle对应的结构中（nginx/src/core/ngx_module.c），文件中函数用
nginx开源库源码分享
最新发布
04-20
4. `ngx_http_core_module`：Nginx的核心HTTP模块，负责解析HTTP请求，执行URL重写，调用其他处理模块。 5. `ngx_connection_t`：表示一个网络连接，包含连接相关的所有信息，如socket描述符、读写事件、客户端地址...
nginx的ngx_module_s 模块
weixin_33836223的博客
04-26 828
2019独角兽企业重金招聘Python工程师标准>>> ...
nginx源码分析之配置图解
robertzhouxh的专栏
04-13 651
nginx配置结构清晰，层次分明，这得益于整个架构的模块化设计，文本将揭示配置文件如何被处理和应用。   整个配置文件解析后的结果如图这样存储。 一、解析的核心机制 nginx源码里，ngx_conf_t是解析的关键结构体 ngx_conf_handler函数里： 01 /* set up the directive's
nginx模块开发之一
for_tech的博客
05-17 2109
本文以开发一个简单nginx模块为例，讲述nginx http模块开发的入门知识。
nginx 源码学习笔记（二十）—— event 模块(一) ——初始化
数据库天地
05-25 158
读完之前的学习笔记，相信已经对nginx的启动流程有了一定的认识，从这一节起我们想深入各个模块，学习各个模块的内的主要操作。 本文来自于：http://blog.csdn.net/lengzijian/article/details/7598996 今天我们就来学习下event模块，在之前的启动里多次提到了调用各个模块的钩子函数，我们先来回忆一下关于event模块钩子函数的执行，也是eve...
菜鸟学习nginx之核心模块ngx_events_module
程序员的世界
12-29 989
既然Nginx是HTTP服务端软件，那么必然离不开网络。今天就介绍Nginx高性能网络是如何实现的。 一、核心模块-ngx_events_module （校长） 上一篇中介绍了Nginx模块抽象，今天深入探讨一下ngx_event_module事件模块。 1.1、模块定义 /** * 模块定义--事件模块 */ ngx_module_t ngx_events_module = { ...
nginx源码分析之IO多路复用流程
逍遥子曰：
03-02 4294
一、             主流程几乎所有的服务器程序的工作模式都是：（1）      初始化一些参数；（2）      开启监听socket；（3）      在主线程的死循环（一般都是死循环）中对监听socket和业务socket进行IO状态监控（IO多路复用），并对IO进行处理；Nginx的主要工作模式是多进程模式，那么它的工作方式也是类似的。只不过是它的死循环被分散到了各个工作进程中。这
nginx ngx_http_index_module(默认初始页)
Claroja
01-18 217
设置默认页面 样例 location / { index index.$geo.html index.html; } API 语法 默认 作用域 描述 index file …; index.html; http, server, location 打开端口时的,默认页面 参考: http://nginx.org/en/docs/http/ngx_http_index...
Nginx源码阅读（模块）
Jiajun Zhu
01-21 658
每个nginx模块，都是一个ngx_module_t类型的变量。根据ngx_module_t的type，所有nginx模块可以分为5种类型： type ctx指向的数据结构 commands指向的数据结构 具体模块 NGX_CORE_MODULE ngx_core_module_t ngx_command_t ngx_core_module、ngx_e...
nginx源码阅读(一).综述
热门推荐
Move_now的博客
10-28 1万+
前言 nginx作为一款开源的轻量级高性能web服务器,是非常值得立志从事服务端开发方向的人学习的。现今nginx的最新版本是nginx-1.13.6,代码量也日渐庞大,但是由于其核心思想并没改变,为了降低阅读难度,我选择的是nginx-1.0.15版本,并且由于时间和水平有限,重点关注的是nginx的启动以及进程模型、事件模块中的epoll模块、负载均衡以及整体的框架等方面。 这里先推荐两本
Nginx 模块 - ngx_core_module
05-17
ngx_core_module 是 Nginx 的核心模块，它提供了 Nginx 的基本功能，如配置文件解析、事件处理、进程间通信等。在 Nginx 启动时，ngx_core_module 会被首先加载。 ngx_core_module 的主要功能包括： 1. 配置文件解析：ngx_core_module 负责解析 Nginx 的配置文件，并将配置文件中的指令转化为 Nginx 内部结构体表示。 2. 事件管理：ngx_core_module 提供了事件管理器，负责监听套接字、定时器等事件，并将事件交给相应的模块处理。 3. 进程间通信：ngx_core_module 提供了进程间通信机制，可以用于多进程协同工作，如 master 进程与 worker 进程之间的通信。 4. 日志管理：ngx_core_module 提供了日志管理器，用于记录 Nginx 的运行日志。 5. 内存管理：ngx_core_module 提供了内存管理器，用于管理 Nginx 的内存分配和释放。 除此之外，ngx_core_module 还提供了一些基本的指令，如 worker_processes、worker_cpu_affinity 等，用于控制 Nginx 的进程数和 CPU 亲和性等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值