菜鸟nginx源码剖析 框架篇(一) 从main函数看nginx启动流程(转)

    • 俗话说的好,牵牛要牵牛鼻子 驾车顶牛,处理复杂的东西,只要抓住重点,才能理清脉络,不至于深陷其中,不能自拔。对复杂的nginx而言,main函数就是“牛之鼻”,只要能理清main函数,就一定能理解其中的奥秘,下面我们就一起来研究一下nginx的main函数。

      1.nginx的main函数解读

      nginx启动显然是由main函数驱动的,main函数在在core/nginx.c文件中,其源代码解析如下,涉及到的数据结构在本节仅指出其作用,将在第二节中详细解释。

    • nginx main函数的流程图如下:

      菜鸟nginx源码剖析 框架篇(一) 从main函数看nginx启动流程(转)

      需要说明的:

    • 1) 初始化错误提示列表,以errno为下标,元素就是对应的错误提示信息。

    •    1: if (ngx_strerror_init() != NGX_OK) {
         2:     return 1;
         3: }

      2)获取命令行参数,保存在全局变量中,可以设置的命令行参数如下表所示:

    •    1: if (ngx_get_options(argc, argv) != NGX_OK) {
         2:       return 1;
         3:   }
      命令行参数 作用
      -h或-? 显示版本信息和help信息
      -v 显示版本信息
      -V 显示nginx版本信息、编译器版本和配置选项信息
      -t 测试配置文件信息是否OK,即检测配置文件语法的正确性,并尝试打开配置文件中所引用到的文件
      -q 在测试配置文件的时候,屏蔽无错误信息,即quiet模式
      -s signal 发送信号到master进程(如stop、quit、reopen、reload)
      -p prefix 设置前缀路径(默认为当前目录)
      -c filename 设置配置文件(默认为conf/nginx.conf)
      -g directives 在配置文件外设置全局的指令

      3)时间、正则表达式和log的初始化。

         1: ngx_time_init();
         2:  
         3: (NGX_PCRE)
         4: ngx_regex_init();
         5: if
         6:  
         7: ngx_pid = ngx_getpid();
         8:  
         9: log = ngx_log_init(ngx_prefix);
        10: if (log == NULL) {
        11:     return 1;
        12: }

      4) 初始化cycle结构,并创建内存块大小为1024的内存池,内存池创建已经在《菜鸟nginx源码剖析数据结构篇(九) 内存池ngx_pool_t》讨论过了,nginx框架就是围绕着ngx_cycle_t结构体来控制运行的,其定义详情请参考下一节。

         1: ngx_memzero(&init_cycle, sizeof(ngx_cycle_t));
         2: init_cycle.log = log;
         3: ngx_cycle = &init_cycle;
         4:  
         5: init_cycle.pool = ngx_create_pool(1024, log);
         6: if (init_cycle.pool == NULL) {
         7:     return 1;
         8: }
       
      5)  将命令行参数保存到ngx_os_argv、ngx_argc以及ngx_argv这几个全局的变量中。这算是一个备份存储,方便以后master进程做热代码替换之用。
         1: if (ngx_save_argv(&init_cycle, argc, argv) != NGX_OK) {
         2:         return 1;
         3: }

      6)用命令行参数得来的全局变量初始化cycle的conf_prefix(配置文件所在路径的前缀)、prefix(nginx可执行文件所在路径)、conf_file(配置文件名)和conf_param(通过命令行-g选项指定的全局配置信息)。

         1: if (ngx_process_options(&init_cycle) != NGX_OK) {
         2:     return 1;
         3: }
      7)  根据操作系统确定一些参数,信息会被保存到一些全局变量中,如页大小ngx_pagesize, CPU cacheline
         1: if (ngx_os_init(log) != NGX_OK) {
         2:     return 1;
         3: }
      8) 初始化一个做循环冗余校验的表,由此可以看出后续的循环冗余校验将采用高效的查表法
         1: if (ngx_crc32_table_init() != NGX_OK) {  
         2:        return 1;  
         3:    } 
      9)通过环境变量NGINX完成socket的继承,继承来的socket将会放到init_cycle的listening数组中。同时可以读取master进程传递的平滑升级信息等等
         1: if (ngx_add_inherited_sockets(&init_cycle) != NGX_OK) {  
         2:         return 1;  
         3:     }  

      10)初始化所有模块的index信息,即对所有模块进行编号,ngx_modules数却是在自动编译的时候生成的,位于objs/ngx_modules.c文件中

         1: ngx_max_module = 0;
         2: for (i = 0; ngx_modules[i]; i++) {
         3:     ngx_modules[i]->index = ngx_max_module++;
         4: }

      11)  用上面收集的init_cycle信息初始化ngx_cycle,这行代码是nginx启动过程中最重要的一个步骤,在第3节将详细展开。

         1: cycle = ngx_init_cycle(&init_cycle);
         2: if (cycle == NULL) {
         3:     if (ngx_test_config) {
         4:         ngx_log_stderr(0, "configuration file %s test failed",
         5:                        init_cycle.conf_file.data);
         6:     }
         7:  
         8:     return 1;
         9: }

      12)ccf 为ngx_core_conf_t 将在第2节给出详细定义,这个地方需要解释下,ccf->master是从配置文件中解析master_process配置项所得的值,初始化为NGX_CONF_UNSET(-1),在配置项中,如果flag类型的配置项master_process被设置为on,则其值为1,如果为off,则其值为0,ngx_process为全局变量,用于记录要采用的工作模式,未被初始化,因此初始值是0(uint型全局变量会被系统默认初始化为0),相关宏定义如下:

      1. #define NGX_PROCESS_SINGLE     0
      2. #define NGX_PROCESS_MASTER     1
      3. #define NGX_PROCESS_SIGNALLER  2
      4. #define NGX_PROCESS_WORKER     3
      5. #define NGX_PROCESS_HELPER     4

      因此,下面的if判断语句的含义就是:用来处理一种特殊情况,即如果在配置项中未设置master_process配置项或者是设置为打开,ngx_process未被设置,采用默认值0,这个时候要采用master工作模式。因为master_process优先级高,且nginx默认采用master模式如果在配置项中设置master_process为off,那么if依据不会执行。最终nginx工作模式取决于ngx_proces的初值0,即采用单进程模式。

         1: ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
         2:  
         3: if (ccf->master && ngx_process == NGX_PROCESS_SINGLE) {
         4:     ngx_process = NGX_PROCESS_MASTER;
         5: }

      13)初始化信号;主要完成信号处理程序的注册

         1: if (ngx_init_signals(cycle->log) != NGX_OK) {
         2:     return 1;
         3: }

      14)若无继承sockets,且设置了守护进程表示,则创建守护进程

         1: if (!ngx_inherited && ccf->daemon) {  
         2:         if (ngx_daemon(cycle->log) != NGX_OK) {  
         3:             return 1;  
         4:         }  
         5:   
         6:         ngx_daemonized = 1;  
         7:     }  
         8:   
         9:     if (ngx_inherited) {  
        10:         ngx_daemonized = 1;  
        11: }  

      15) 创建进程记录文件;(非NGX_PROCESS_MASTER=1进程,不创建该文件)

         1: if (ngx_create_pidfile(&ccf->pid, cycle->log) != NGX_OK) {
         2:     return 1;
         3: }

      16)  进入进程主循环,根据ngx_process确定启动单进程模式还是多进程模式。

         1: if (ngx_process == NGX_PROCESS_SINGLE) {
         2:      ngx_single_process_cycle(cycle);
         3:  
         4:  } else {
         5:      ngx_master_process_cycle(cycle);
         6:  }
    • 2.相关结构体

      2.1. ngx_module_t

      nginx中所有模块的类型都是ngx_module_t类型的,定义了模块的一些属性。nginx是完全模块化的,所有的组件都是模块,从而实现了nginx的高度松耦合。同时,我们在进行nginx模块开发时,也离不开这个数据结构。在上面初始化过程中的第10步就是初始化这个结构。

         1: struct ngx_module_s {
         2:     /**
         3:      * 在具体类型模块(http、event等)的全局配置结构数组的下标。以http module模块为例,
         4:      * nginx把所有的http module的config信息存放在ngx_http_conf_ctx_t类型的变量中,
         5:      * 这个变量只有3个属性,分别是所有http module的main、srv、loc的config信息的数组。
         6:      * 如果该模块是http module,则ctx_index是该模块的config信息(main、srv、loc)
         7:      * 在ngx_http_conf_ctx_t中的下标。
         8:      */
         9:     ngx_uint_t            ctx_index;
        10:  
        11:     /**
        12:      * nginx把所有模块(ngx_module_t)存放到ngx_modules数组中,这个数组在nginx源码路
        13:      * 径的objs/ngx_modules.c中,是在运行configure脚本后生成的。index属性就是该模块
        14:      * 在ngx_modules数组中的下标。同时nginx把所有的core module的配置结构存放到ngx_cycle的
        15:      * conf_ctx数组中,index也是该模块的配置结构在ngx_cycle->conf_ctx数组中的下标。
        16:      */
        17:     ngx_uint_t            index;
        18:  
        19:     ……
        20:  
        21:     /**
        22:      * 模块的上下文属性,同一类型的模块的属性是相同的,比如core module的ctx是ngx_core_module_t类型。
        23:      * 而http module的ctx是ngx_http_moduel_t类型,event module的ctx是ngx_event_module_t类型等等。
        24:      * 相应类型的模块由分开处理的,比如所有的http module由ngx_http_module解析处理,而所有的event module
        25:      * 由ngx_events_module解析处理。
        26:      */
        27:     void                 *ctx;
        28:  
        29:     /**
        30:      * 该模块支持的指令的数组,最后以一个空指令结尾。ngx_commond_t的分析见下文。
        31:      */
        32:     ngx_command_t        *commands;
        33:  
        34:     /**
        35:      * 模块的类型,nginx所有的模块类型:
        36:      *         NGX_CORE_MODULE
        37:      *         NGX_CONF_MODULE
        38:      *         NGX_HTTP_MODULE
        39:      *         NGX_EVENT_MODULE
        40:      *         NGX_MAIL_MODULE
        41:      * 这些不同的类型也指定了不同的ctx。
        42:      */
        43:     ngx_uint_t            type;
        44:  
        45:     /* 接下来都是一些回调函数,在nginx初始化过程的特定时间点调用 */
        46:     ngx_int_t           (*init_master)(ngx_log_t *log);
        47:  
        48:     /* 初始化完所有模块后调用,在ngx_int_cycle函数(ngx_cycle.c)中 */
        49:     ngx_int_t           (*init_module)(ngx_cycle_t *cycle);
        50:  
        51:     /* 初始化完worker进程后调用,在ngx_worker_process_init函数(ngx_process_cycle.c)中 */
        52:     ngx_int_t           (*init_process)(ngx_cycle_t *cycle);
        53:     ngx_int_t           (*init_thread)(ngx_cycle_t *cycle);
        54:     void                (*exit_thread)(ngx_cycle_t *cycle);
        55:     void                (*exit_process)(ngx_cycle_t *cycle);
        56:  
        57:     void                (*exit_master)(ngx_cycle_t *cycle);
        58:     ……
        59: };
       
    • 模块类型和上下文属性的关系如下:
    • 模块类型(type) 上下文属性类型(ctx)
      NGX_CORE_MODULE ngx_core_module_t(ngx_conf_file.h)
      NGX_CONF_MODULE NULL
      NGX_HTTP_MODULE ngx_http_module_t(http/ngx_http_config.h)
      NGX_EVENT_MODULE ngx_event_module_t(event/ngx_event.h)
      NGX_MAIL_MODULE ngx_mail_module_t(mail/ngx_mail.h)
      • 常用的模块图如下图所示:

      • 菜鸟nginx源码剖析 框架篇(一) 从main函数看nginx启动流程(转)

      2.2 ngx_commond_t

      ngx_commond_t描述的是模块的配置指令,也就是出现在配置文件的指令。nginx模块支持多个配置指令,所以是以ngx_commond_t数组形式存储的。这个结构在配置文件解析和模块的配置结构信息初始化时会用到。

         1: struct ngx_command_s {
         2:     /**
         3:      * 指令名,与配置文件中一致
         4:      */
         5:     ngx_str_t             name;
         6:  
         7:     /**
         8:      * 指令的类型,以及参数的个数。这个属性有两个作用:
         9:      *     1. 实现只解析某个类型的指令,比如当前这个指令是event module类型的,而正在解析的是
        10:      *        http module,所以会跳过所有不是http module类型的指令。
        11:      *     2. 实现指令参数个数的校验。
        12:      */
        13:     ngx_uint_t            type;
        14:  
        15:     /*
        16:      * 回调函数,在解析配置文件时,遇到这个指令时调用。
        17:      * cf: 包括配置参数信息cf->args(ngx_array_t类型),以及指令对应的模块上下文cf->ctx
        18:      *         在解析不同模块的指令时,这个上下文信息不同。比如在解析core module时,cf->ctx
        19:      *         是ngx_cycle->conf_ctx也就是所有core module的配置结构数组,而在解析http module
        20:      *         时cf->ctx是ngx_http_conf_ctx_t类型的,其中包含所有http module的main、srv、loc
        21:      *         的配置结构数组。
        22:      * cmd: 指令对应的ngx_command_t结构。
        23:      * conf:指令对应的模块的配置信息。
        24:      */
        25:     char               *(*set)(ngx_conf_t *cf, ngx_command_t *cmd, void *conf);
        26:  
        27:     /**
        28:      * 对http module有效,http module的配置结构信息(main、srv、loc)都存放在ngx_http_conf_ctx_t
        29:      * 中对应的数组,conf属性指示这个指令的配置结构是main、srv还是loc。
        30:      */
        31:     ngx_uint_t            conf;
        32:  
        33:     /**
        34:      * 指令对应属性在模块配置结构中的偏移量。
        35:      */
        36:     ngx_uint_t            offset;
        37:     
        38:     /**
        39:      * 一般是函数指针,在set回调函数中调用。
        40:      */
        41:     void                 *post;
        42: };

      2.3 ngx_cycle_t

      ngx_cycle_t是nginx中最重要的数据结构,包含了全局的配置信息、所有监听的套接字、连接池、读写事件等。ngx_cycle_t相当于nginx的一个生命周期,从nginx启动后直到向nginx发送stop或者reload信号。nginx中有一个全局变量ngx_cycle指向当前的cycle。

       
         1: struct ngx_cycle_s {
         2:     /*保存着所有模块存储配置项的结构体的指针,它首先是一个数组,每个数组成员又是一个指针,这个指针指向另一个存储着指针的数组*/
         3:     void                  ****conf_ctx;
         4:     //内存池
         5:     ngx_pool_t               *pool;
         6:     
         7:     /*日志模块中提供了生成基本ngx_log_t日志对象的功能,这里的log实际上在还没有执行ngx_init_cycle方法前,也就是还没有解析配置前,如果有信息输出日志
         8:     就会暂时使用log对象,它会输出到屏幕。在调用ngx_int_cycle后,将会根据nginx.comfg配置文件中的配置项构造出正确的日志,此时会对log进行重新赋值*/
         9:     ngx_log_t                *log;
        10:     /*由nginx.conf配置文件读取到日志文件路径后,将开始初始化error_log日志文件,由于log对象还在用于输出日志屏幕,这时会用new_log暂时性地替代log日志
        11:     待初始化成功后,会用new_log的地址覆盖上面的log指针*/
        12:     ngx_log_t                 new_log;
        13:     
        14:     ngx_uint_t                log_use_stderr;  /* unsigned  log_use_stderr:1; */
        15:     //files文件数组的个数
        16:     ngx_uint_t                files_n;
        17:    /*对于poll、rtsig这样的事件模块,会以有效文件句柄来预先建立这些ngx_connection_t结构体,以加速时间的收集分发,这时files就会保存所有ngx_connection_t
        18:     的指针成员数组,files_n就是指针的总数,而文件句柄的值用于访问files数组成员*/
        19:     ngx_connection_t        **files;
        20:    //可用连接池
        21:     ngx_connection_t         *free_connections;
        22:     //可用连接池中连接总数
        23:     ngx_uint_t                free_connection_n;
        24:     
        25:     /*双向链表容器,元素是ngx_connection_t结构体,表示可重复使用的连接队列*/
        26:     ngx_queue_t               reusable_connections_queue;
        27:     //动态数组,每个数组元素存储着ngx_listening_t成员,表示监听端口及相关参数
        28:     ngx_array_t               listening;
        29:     //动态数组,存储着nginx所有要操作的目录,如果目录不存在,则试图创建,创建失败会导致nginx启动失败
        30:     ngx_array_t               paths;
        31:     /*单链表容器,元素类型是nginx_open_file_t,表示已打开的所有文件。*/
        32:     ngx_list_t                open_files;
        33:     /*单链表容器,元素是ngx_shm_zone_t,每个元素表示一块共享内存*/
        34:     ngx_list_t                shared_memory;
        35:     //当前连接对象的总数
        36:     ngx_uint_t                connection_n;
        37:  
        38:     //指向当前进程中所有连接对象
        39:     ngx_connection_t         *connections;
        40:     //指向当前进程中的所有读事件对象,connection_n同时表示所有读事件总数
        41:     ngx_event_t              *read_events;
        42:     //指向当前进程中的所有写事件对象,connection_n同时表示所有写事件总数
        43:     ngx_event_t              *write_events;
        44:     //旧的ngx_cycle_t对象用于引用上一个ngx_cycle_t对象中的成员
        45:     ngx_cycle_t              *old_cycle;
        46:     
        47:     ngx_str_t              conf_file;               // 配置文件名  
        48:      ngx_str_t                 conf_param;                   // 由命令行-g提供配置参数  
        49:      ngx_str_t                 conf_prefix;                  // 配置前缀  
        50:      ngx_str_t                 prefix;                       // nginx所在路径  
        51:      ngx_str_t                 lock_file;  
        52:      ngx_str_t                 hostname;                     // 主机名  
        53: };

      3.ngx_init_cycle函数

      ngx_init_cycle 初始化步骤 有以下操作,这里涉及到ngx_list_t和ngx_array_t,如果有不懂的同学请参考我之前对于这两个结构分析的文章,同时这个函数比较复杂,希望大家耐心点。

      1) 更新时区和时间。

         1: ngx_timezone_update();
         2:  
         3: /* force localtime update with a new timezone */
         4:  
         5: tp = ngx_timeofday();
         6: tp->sec = 0;
         7:  
         8: ngx_time_update();

      2) 创建内存池,并从内存池中创建ngx_cycle_t结构,然后给cycle日志和old_cycle赋值

         1: log = old_cycle->log;
         2:  
         3: pool = ngx_create_pool(NGX_CYCLE_POOL_SIZE, log);
         4: if (pool == NULL) {
         5:     return NULL;
         6: }
         7: pool->log = log;
         8:  
         9: cycle = ngx_pcalloc(pool, sizeof(ngx_cycle_t));
        10: if (cycle == NULL) {
        11:     ngx_destroy_pool(pool);
        12:     return NULL;
        13: }
        14:  
        15: cycle->pool = pool;
        16: cycle->log = log;
        17: cycle->old_cycle = old_cycle;

      3)根据old_cycle初始化cycle中的conf_file、conf_prefix、prefix和conf_param。

         1: cycle->conf_prefix.len = old_cycle->conf_prefix.len;
         2: cycle->conf_prefix.data = ngx_pstrdup(pool, &old_cycle->conf_prefix);
         3: if (cycle->conf_prefix.data == NULL) {
         4:     ngx_destroy_pool(pool);
         5:     return NULL;
         6: }
         7:  
         8: cycle->prefix.len = old_cycle->prefix.len;
         9: cycle->prefix.data = ngx_pstrdup(pool, &old_cycle->prefix);
        10: if (cycle->prefix.data == NULL) {
        11:     ngx_destroy_pool(pool);
        12:     return NULL;
        13: }
        14:  
        15: cycle->conf_file.len = old_cycle->conf_file.len;
        16: cycle->conf_file.data = ngx_pnalloc(pool, old_cycle->conf_file.len + 1);
        17: if (cycle->conf_file.data == NULL) {
        18:     ngx_destroy_pool(pool);
        19:     return NULL;
        20: }
        21: ngx_cpystrn(cycle->conf_file.data, old_cycle->conf_file.data,
        22:             old_cycle->conf_file.len + 1);
        23:  
        24: cycle->conf_param.len = old_cycle->conf_param.len;
        25: cycle->conf_param.data = ngx_pstrdup(pool, &old_cycle->conf_param);
        26: if (cycle->conf_param.data == NULL) {
        27:     ngx_destroy_pool(pool);
        28:     return NULL;
        29: }

      4)初始化pathes,pathes是一个ngx_array_t结构

         1: n = old_cycle->paths.nelts ? old_cycle->paths.nelts : 10;
         2:  
         3: cycle->paths.elts = ngx_pcalloc(pool, n * sizeof(ngx_path_t *));
         4: if (cycle->paths.elts == NULL) {
         5:     ngx_destroy_pool(pool);
         6:     return NULL;
         7: }
         8:  
         9: cycle->paths.nelts = 0;
        10: cycle->paths.size = sizeof(ngx_path_t *);
        11: cycle->paths.nalloc = n;
        12: cycle->paths.pool = pool;

      5) 根据old_cycle的open_files的大小,初始化openfiles , openfiles为ngx_list_t

         1: if (old_cycle->open_files.part.nelts) {
         2:     n = old_cycle->open_files.part.nelts;
         3:     for (part = old_cycle->open_files.part.next; part; part = part->next) {
         4:         n += part->nelts;
         5:     }
         6:  
         7: } else {
         8:     n = 20;
         9: }
        10:  
        11: if (ngx_list_init(&cycle->open_files, pool, n, sizeof(ngx_open_file_t))
        12:     != NGX_OK)
        13: {
        14:     ngx_destroy_pool(pool);
        15:     return NULL;
        16: }

      6) 根据old_cycle的shared_memory的大小初始化shared_memory(ngx_list_t)。

         1: if (old_cycle->shared_memory.part.nelts) {
         2:     n = old_cycle->shared_memory.part.nelts;
         3:     for (part = old_cycle->shared_memory.part.next; part; part = part->next)
         4:     {
         5:         n += part->nelts;
         6:     }
         7:  
         8: } else {
         9:     n = 1;
        10: }
        11:  
        12: if (ngx_list_init(&cycle->shared_memory, pool, n, sizeof(ngx_shm_zone_t))
        13:     != NGX_OK)
        14: {
        15:     ngx_destroy_pool(pool);
        16:     return NULL;
        17: }

      7) 根据old_cycle的listenning大小初始化listening(ngx_array_t)。

         1: n = old_cycle->listening.nelts ? old_cycle->listening.nelts : 10;
         2:  
         3: cycle->listening.elts = ngx_pcalloc(pool, n * sizeof(ngx_listening_t));
         4: if (cycle->listening.elts == NULL) {
         5:     ngx_destroy_pool(pool);
         6:     return NULL;
         7: }
         8:  
         9: cycle->listening.nelts = 0;
        10: cycle->listening.size = sizeof(ngx_listening_t);
        11: cycle->listening.nalloc = n;
        12: cycle->listening.pool = pool;

      8) 初始化conf_ctx(void ****)数组,大小是ngx_max_module,用于存储所有core module的配置结构信息。

         1: cycle->conf_ctx = ngx_pcalloc(pool, ngx_max_module * sizeof(void *));
         2:    if (cycle->conf_ctx == NULL) {
         3:        ngx_destroy_pool(pool);
         4:        return NULL;
         5:    }

      9) 调用系统调用gethostname获取主机名,初始化hostname。

         1: if (gethostname(hostname, NGX_MAXHOSTNAMELEN) == -1) {
         2:      ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "gethostname() failed");
         3:      ngx_destroy_pool(pool);
         4:      return NULL;
         5:  }
         6:  
         7:  /* on Linux gethostname() silently truncates name that does not fit */
         8:  
         9:  hostname[NGX_MAXHOSTNAMELEN - 1] = '\0';
        10:  cycle->hostname.len = ngx_strlen(hostname);
        11:  
        12:  cycle->hostname.data = ngx_pnalloc(pool, cycle->hostname.len);
        13:  if (cycle->hostname.data == NULL) {
        14:      ngx_destroy_pool(pool);
        15:      return NULL;
        16:  }
        17:  
        18:  ngx_strlow(cycle->hostname.data, (u_char *) hostname, cycle->hostname.len);

      10)调用所有core module的create_conf回调函数创建该core module的配置信息结构,并且更新cycle->conf_ctx数组,

      nginx的core module主要有:

      ngx_core_module(core/nginx.c)

      ngx_http_module(http/ngx_http.c)

      ngx_events_module(event/ngx_event.c)

      ngx_errlog_module(core/ngx_log.c)

      ngx_mail_module(mail/ngx_mail.c)

      ngx_openssl_module(event/ngx_event_openssl.c)

      ngx_google_perftools_module(misc/ngx_google_perftools_module.c)

      只有ngx_core_module和ngx_google_perftools_module两个模块有定义create_conf,而ngx_google_perftools_module仅用于性能测试,所以真正使用时只有ngx_core_module有create_conf回调函数。这个会调用函数会创建ngx_core_conf_t结构,用于存储整个配置文件main scope范围内的信息,比如worker_processes,worker_cpu_affinity等。

         1: for (i = 0; ngx_modules[i]; i++) {
         2:     if (ngx_modules[i]->type != NGX_CORE_MODULE) {
         3:         continue;
         4:     }
         5:  
         6:     module = ngx_modules[i]->ctx;
         7:  
         8:     if (module->create_conf) {
         9:         rv = module->create_conf(cycle);
        10:         if (rv == NULL) {
        11:             ngx_destroy_pool(pool);
        12:             return NULL;
        13:         }
        14:         cycle->conf_ctx[ngx_modules[i]->index] = rv;
        15:     }
        16: }

      11)初始化ngx_conf_t,用于解析配置文件并保存解析出来的信息。args是配置文件中指令的信息的数组,args[0]是指令名,args[1] - args[n]是指令的参数,参数个数需要根据ngx_commond_t的type属性做校验。ngx_conf_t中的module_type和cmd_type用于控制解析什么类型的指令,module_type表示只解析该类型模块包含的指令,cmd_type表示将要解析的指令的类型,也就是说只有符合module_type和cmd_type的指令才会被解析。比如module_type取NGX_HTTP_MODULE,而cmd_type取NGX_HTTP_SRV_CONF,那么在一次配置文件解析中,只会对http module的server块的指令进行解析。

         1: ngx_memzero(&conf, sizeof(ngx_conf_t));
         2: /* STUB: init array ? */
         3: conf.args = ngx_array_create(pool, 10, sizeof(ngx_str_t));
         4: if (conf.args == NULL) {
         5:     ngx_destroy_pool(pool);
         6:     return NULL;
         7: }
         8:  
         9: conf.temp_pool = ngx_create_pool(NGX_CYCLE_POOL_SIZE, log);
        10: if (conf.temp_pool == NULL) {
        11:     ngx_destroy_pool(pool);
        12:     return NULL;
        13: }
        14:  
        15:  
        16: conf.ctx = cycle->conf_ctx;
        17: conf.cycle = cycle;
        18: conf.pool = pool;
        19: conf.log = log;
        20: conf.module_type = NGX_CORE_MODULE;
        21: conf.cmd_type = NGX_MAIN_CONF;

      12)  对通过nginx -g xxx 设置的全局配置指令初始化、解析。

         1: if (ngx_conf_param(&conf) != NGX_CONF_OK) {
         2:     environ = senv;
         3:     ngx_destroy_cycle_pools(&conf);
         4:     return NULL;
         5: }

      13)解析配置文件。配置文件的解析类似一棵树的遍历,nginx中的指令分为块指令和普通指令,每个块指令对应一棵子树,比如http块和event块。由这些块指令负责调用ngx_conf_parse函数解析块内部的指令。配置文件的具体分析会另开一片文章,这里忽略这些细节。在ngx_conf_parse函数返回后,整个配置文件解析完毕,所有模块的指令已经初始化,也就意味着所有模块基本上都初始化完,实际上ngx_conf_parse函数后面隐藏了大量的信息,包括http模块的初始化和事件模块的初始化。关于http的初始化我们后面再详细描述,这里接着讲述ngx_init_cycle。

         1: if (ngx_conf_parse(&conf, &cycle->conf_file) != NGX_CONF_OK) {
         2:     environ = senv;
         3:     ngx_destroy_cycle_pools(&conf);
         4:     return NULL;
         5: }

      14)初始化所有core module模块的config结构调用ngx_core_module_t的init_conf 。在所有core module中,只有ngx_core_module有init_conf回调,用于对ngx_core_conf_t中没有配置的字段设置默认值。

         1: for (i = 0; ngx_modules[i]; i++) {
         2:     if (ngx_modules[i]->type != NGX_CORE_MODULE) {
         3:         continue;
         4:     }
         5:  
         6:     module = ngx_modules[i]->ctx;
         7:  
         8:     if (module->init_conf) {
         9:         if (module->init_conf(cycle, cycle->conf_ctx[ngx_modules[i]->index])
        10:             == NGX_CONF_ERROR)
        11:         {
        12:             environ = senv;
        13:             ngx_destroy_cycle_pools(&conf);
        14:             return NULL;
        15:         }
        16:     }
        17: }

      15) 创建nginx的pid文件。创建所有的文件路径、打开文件描述符以及创建共享内存。

         1: if (ngx_test_config) {
         2:  
         3:      if (ngx_create_pidfile(&ccf->pid, log) != NGX_OK) {
         4:          goto failed;
         5:      }
         6:  
         7:  } else if (!ngx_is_init_cycle(old_cycle)) {
         8:  
         9:      /*
        10:       * we do not create the pid file in the first ngx_init_cycle() call
        11:       * because we need to write the demonized process pid
        12:       */
        13:  
        14:      old_ccf = (ngx_core_conf_t *) ngx_get_conf(old_cycle->conf_ctx,
        15:                                                 ngx_core_module);
        16:      if (ccf->pid.len != old_ccf->pid.len
        17:          || ngx_strcmp(ccf->pid.data, old_ccf->pid.data) != 0)
        18:      {
        19:          /* new pid file name */
        20:  
        21:          if (ngx_create_pidfile(&ccf->pid, log) != NGX_OK) {
        22:              goto failed;
        23:          }
        24:  
        25:          ngx_delete_pidfile(old_cycle);
        26:      }
        27:  }
        28:  
        29:  
        30:  if (ngx_test_lockfile(cycle->lock_file.data, log) != NGX_OK) {
        31:      goto failed;
        32:  }
        33:  
        34:  
        35:  if (ngx_create_paths(cycle, ccf->user) != NGX_OK) {
        36:      goto failed;
        37:  }
        38:  
        39:  
        40:  if (ngx_log_open_default(cycle) != NGX_OK) {
        41:      goto failed;
        42:  }
        43:  
        44:  /* open the new files */
        45:  
        46:  part = &cycle->open_files.part;
        47:  file = part->elts;
        48:  
        49:  for (i = 0; /* void */ ; i++) {
        50:  
        51:      if (i >= part->nelts) {
        52:          if (part->next == NULL) {
        53:              break;
        54:          }
        55:          part = part->next;
        56:          file = part->elts;
        57:          i = 0;
        58:      }
        59:  
        60:      if (file[i].name.len == 0) {
        61:          continue;
        62:      }
        63:  
        64:      file[i].fd = ngx_open_file(file[i].name.data,
        65:                                 NGX_FILE_APPEND,
        66:                                 NGX_FILE_CREATE_OR_OPEN,
        67:                                 NGX_FILE_DEFAULT_ACCESS);
        68:  
        69:      ngx_log_debug3(NGX_LOG_DEBUG_CORE, log, 0,
        70:                     "log: %p %d \"%s\"",
        71:                     &file[i], file[i].fd, file[i].name.data);
        72:  
        73:      if (file[i].fd == NGX_INVALID_FILE) {
        74:          ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
        75:                        ngx_open_file_n " \"%s\" failed",
        76:                        file[i].name.data);
        77:          goto failed;
        78:      }
        79:  
        80:  !(NGX_WIN32)
        81:      if (fcntl(file[i].fd, F_SETFD, FD_CLOEXEC) == -1) {
        82:          ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
        83:                        "fcntl(FD_CLOEXEC) \"%s\" failed",
        84:                        file[i].name.data);
        85:          goto failed;
        86:      }
        87: dif
        88:  }
        89:  
        90:  cycle->log = &cycle->new_log;
        91:  pool->log = &cycle->new_log;
        92:  
        93:  
        94:  /* create shared memory */
        95:  
        96:  part = &cycle->shared_memory.part;
        97:  shm_zone = part->elts;
        98:  
        99:  for (i = 0; /* void */ ; i++) {
       100:  
       101:      if (i >= part->nelts) {
       102:          if (part->next == NULL) {
       103:              break;
       104:          }
       105:          part = part->next;
       106:          shm_zone = part->elts;
       107:          i = 0;
       108:      }
       109:  
       110:      if (shm_zone[i].shm.size == 0) {
       111:          ngx_log_error(NGX_LOG_EMERG, log, 0,
       112:                        "zero size shared memory zone \"%V\"",
       113:                        &shm_zone[i].shm.name);
       114:          goto failed;
       115:      }
       116:  
       117:      shm_zone[i].shm.log = cycle->log;
       118:  
       119:      opart = &old_cycle->shared_memory.part;
       120:      oshm_zone = opart->elts;
       121:  
       122:      for (n = 0; /* void */ ; n++) {
       123:  
       124:          if (n >= opart->nelts) {
       125:              if (opart->next == NULL) {
       126:                  break;
       127:              }
       128:              opart = opart->next;
       129:              oshm_zone = opart->elts;
       130:              n = 0;
       131:          }
       132:  
       133:          if (shm_zone[i].shm.name.len != oshm_zone[n].shm.name.len) {
       134:              continue;
       135:          }
       136:  
       137:          if (ngx_strncmp(shm_zone[i].shm.name.data,
       138:                          oshm_zone[n].shm.name.data,
       139:                          shm_zone[i].shm.name.len)
       140:              != 0)
       141:          {
       142:              continue;
       143:          }
       144:  
       145:          if (shm_zone[i].tag == oshm_zone[n].tag
       146:              && shm_zone[i].shm.size == oshm_zone[n].shm.size)
       147:          {
       148:              shm_zone[i].shm.addr = oshm_zone[n].shm.addr;
       149:  
       150:              if (shm_zone[i].init(&shm_zone[i], oshm_zone[n].data)
       151:                  != NGX_OK)
       152:              {
       153:                  goto failed;
       154:              }
       155:  
       156:              goto shm_zone_found;
       157:          }
       158:  
       159:          ngx_shm_free(&oshm_zone[n].shm);
       160:  
       161:          break;
       162:      }
       163:  
       164:      if (ngx_shm_alloc(&shm_zone[i].shm) != NGX_OK) {
       165:          goto failed;
       166:      }
       167:  
       168:      if (ngx_init_zone_pool(cycle, &shm_zone[i]) != NGX_OK) {
       169:          goto failed;
       170:      }
       171:  
       172:      if (shm_zone[i].init(&shm_zone[i], NULL) != NGX_OK) {
       173:          goto failed;
       174:      }
       175:  
       176:  shm_zone_found:
       177:  
       178:      continue;
       179:  }

      16)处理监听socket的,如果监听地址相同的话,则把新、旧cycle的监听socket合并

         1: if (old_cycle->listening.nelts) {
         2:         ls = old_cycle->listening.elts;
         3:         for (i = 0; i < old_cycle->listening.nelts; i++) {
         4:             ls[i].remain = 0;
         5:         }
         6:  
         7:         nls = cycle->listening.elts;
         8:         for (n = 0; n < cycle->listening.nelts; n++) {
         9:  
        10:             for (i = 0; i < old_cycle->listening.nelts; i++) {
        11:                 if (ls[i].ignore) {
        12:                     continue;
        13:                 }
        14:  
        15:                 if (ngx_cmp_sockaddr(nls[n].sockaddr, nls[n].socklen,
        16:                                      ls[i].sockaddr, ls[i].socklen, 1)
        17:                     == NGX_OK)
        18:                 {
        19:                     nls[n].fd = ls[i].fd;
        20:                     nls[n].previous = &ls[i];
        21:                     ls[i].remain = 1;
        22:  
        23:                     if (ls[i].backlog != nls[n].backlog) {
        24:                         nls[n].listen = 1;
        25:                     }
        26:                     break;
        27:                 }
        28:             }
        29:  
        30:             if (nls[n].fd == (ngx_socket_t) -1) {
        31:                 nls[n].open = 1;
        32:  
        33:             }
        34:         }
        35:  
        36:     } else {
        37:         ls = cycle->listening.elts;
        38:         for (i = 0; i < cycle->listening.nelts; i++) {
        39:             ls[i].open = 1;
        40:  
        41:         }
        42:     }

      17)打开所有的监听socket,具体过程和用socket编程时是一样的,调用socket创建套接字 -> 调用setsockopt设置成可重用socket -> 设置成非阻塞socket -> 调用bind绑定要监听的socket地址 -> 调用listen转化成监听socket。

         1: if (ngx_open_listening_sockets(cycle) != NGX_OK) {
         2:       goto failed;
         3:   }

      18)  根据cycle配置所有的监听socket,包括设置监听socket的接收缓冲区大小、发送缓冲区大小以及accept filter等

         1: if (!ngx_test_config) {
         2:     ngx_configure_listening_sockets(cycle);
         3: }

      19)  调用所有模块的init_module回调函数,进行模块的初始化动作。

         1: for (i = 0; ngx_modules[i]; i++) {
         2:     if (ngx_modules[i]->init_module) {
         3:         if (ngx_modules[i]->init_module(cycle) != NGX_OK) {
         4:             /* fatal */
         5:             exit(1);
         6:         }
         7:     }
         8: }

      20) ngx_init_cycle最后部分代码主要就是释放多余的资源,包括关闭共享内存、监听socket已经打开的文件等,然后ngx_init_cycle正常返回

         1: /* close and delete stuff that lefts from an old cycle */
         2:  
         3:    /* free the unnecessary shared memory */
         4:  
         5:    opart = &old_cycle->shared_memory.part;
         6:    oshm_zone = opart->elts;
         7:  
         8:    for (i = 0; /* void */ ; i++) {
         9:  
        10:        if (i >= opart->nelts) {
        11:            if (opart->next == NULL) {
        12:                goto old_shm_zone_done;
        13:            }
        14:            opart = opart->next;
        15:            oshm_zone = opart->elts;
        16:            i = 0;
        17:        }
        18:  
        19:        part = &cycle->shared_memory.part;
        20:        shm_zone = part->elts;
        21:  
        22:        for (n = 0; /* void */ ; n++) {
        23:  
        24:            if (n >= part->nelts) {
        25:                if (part->next == NULL) {
        26:                    break;
        27:                }
        28:                part = part->next;
        29:                shm_zone = part->elts;
        30:                n = 0;
        31:            }
        32:  
        33:            if (oshm_zone[i].shm.name.len == shm_zone[n].shm.name.len
        34:                && ngx_strncmp(oshm_zone[i].shm.name.data,
        35:                               shm_zone[n].shm.name.data,
        36:                               oshm_zone[i].shm.name.len)
        37:                == 0)
        38:            {
        39:                goto live_shm_zone;
        40:            }
        41:        }
        42:  
        43:        ngx_shm_free(&oshm_zone[i].shm);
        44:  
        45:    live_shm_zone:
        46:  
        47:        continue;
        48:    }
        49:  
        50: ld_shm_zone_done:
        51:  
        52:  
        53:    /* close the unnecessary listening sockets */
        54:  
        55:    ls = old_cycle->listening.elts;
        56:    for (i = 0; i < old_cycle->listening.nelts; i++) {
        57:  
        58:        if (ls[i].remain || ls[i].fd == (ngx_socket_t) -1) {
        59:            continue;
        60:        }
        61:  
        62:        if (ngx_close_socket(ls[i].fd) == -1) {
        63:            ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
        64:                          ngx_close_socket_n " listening socket on %V failed",
        65:                          &ls[i].addr_text);
        66:        }
        67:    }
        68:  
        69:  
        70:    /* close the unnecessary open files */
        71:  
        72:    part = &old_cycle->open_files.part;
        73:    file = part->elts;
        74:  
        75:    for (i = 0; /* void */ ; i++) {
        76:  
        77:        if (i >= part->nelts) {
        78:            if (part->next == NULL) {
        79:                break;
        80:            }
        81:            part = part->next;
        82:            file = part->elts;
        83:            i = 0;
        84:        }
        85:  
        86:        if (file[i].fd == NGX_INVALID_FILE || file[i].fd == ngx_stderr) {
        87:            continue;
        88:        }
        89:  
        90:        if (ngx_close_file(file[i].fd) == NGX_FILE_ERROR) {
        91:            ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
        92:                          ngx_close_file_n " \"%s\" failed",
        93:                          file[i].name.data);
        94:        }
        95:    }
        96:  
        97:    ngx_destroy_pool(conf.temp_pool);
        98:  
        99:    if (ngx_process == NGX_PROCESS_MASTER || ngx_is_init_cycle(old_cycle)) {
       100:  
       101:        /*
       102:         * perl_destruct() frees environ, if it is not the same as it was at
       103:         * perl_construct() time, therefore we save the previous cycle
       104:         * environment before ngx_conf_parse() where it will be changed.
       105:         */
       106:  
       107:        env = environ;
       108:        environ = senv;
       109:  
       110:        ngx_destroy_pool(old_cycle->pool);
       111:        cycle->old_cycle = NULL;
       112:  
       113:        environ = env;
       114:  
       115:        return cycle;
       116:    }
       117:  
       118:  
       119:    if (ngx_temp_pool == NULL) {
       120:        ngx_temp_pool = ngx_create_pool(128, cycle->log);
       121:        if (ngx_temp_pool == NULL) {
       122:            ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,
       123:                          "could not create ngx_temp_pool");
       124:            exit(1);
       125:        }
       126:  
       127:        n = 10;
       128:        ngx_old_cycles.elts = ngx_pcalloc(ngx_temp_pool,
       129:                                          n * sizeof(ngx_cycle_t *));
       130:        if (ngx_old_cycles.elts == NULL) {
       131:            exit(1);
       132:        }
       133:        ngx_old_cycles.nelts = 0;
       134:        ngx_old_cycles.size = sizeof(ngx_cycle_t *);
       135:        ngx_old_cycles.nalloc = n;
       136:        ngx_old_cycles.pool = ngx_temp_pool;
       137:  
       138:        ngx_cleaner_event.handler = ngx_clean_old_cycles;
       139:        ngx_cleaner_event.log = cycle->log;
       140:        ngx_cleaner_event.data = &dumb;
       141:        dumb.fd = (ngx_socket_t) -1;
       142:    }
       143:  
       144:    ngx_temp_pool->log = cycle->log;
       145:  
       146:    old = ngx_array_push(&ngx_old_cycles);
       147:    if (old == NULL) {
       148:        exit(1);
       149:    }
       150:    *old = old_cycle;
       151:  
       152:    if (!ngx_cleaner_event.timer_set) {
       153:        ngx_add_timer(&ngx_cleaner_event, 30000);
       154:        ngx_cleaner_event.timer_set = 1;
       155:    }
       156:  
       157:    return cycle;
       158:  
       159:  
       160: ailed:
       161:  
       162:    if (!ngx_is_init_cycle(old_cycle)) {
       163:        old_ccf = (ngx_core_conf_t *) ngx_get_conf(old_cycle->conf_ctx,
       164:                                                   ngx_core_module);
       165:        if (old_ccf->environment) {
       166:            environ = old_ccf->environment;
       167:        }
       168:    }
       169:  
       170:    /* rollback the new cycle configuration */
       171:  
       172:    part = &cycle->open_files.part;
       173:    file = part->elts;
       174:  
       175:    for (i = 0; /* void */ ; i++) {
       176:  
       177:        if (i >= part->nelts) {
       178:            if (part->next == NULL) {
       179:                break;
       180:            }
       181:            part = part->next;
       182:            file = part->elts;
       183:            i = 0;
       184:        }
       185:  
       186:        if (file[i].fd == NGX_INVALID_FILE || file[i].fd == ngx_stderr) {
       187:            continue;
       188:        }
       189:  
       190:        if (ngx_close_file(file[i].fd) == NGX_FILE_ERROR) {
       191:            ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,
       192:                          ngx_close_file_n " \"%s\" failed",
       193:                          file[i].name.data);
       194:        }
       195:    }
       196:  
       197:    if (ngx_test_config) {
       198:        ngx_destroy_cycle_pools(&conf);
       199:        return NULL;
       200:    }
       201:  
       202:    ls = cycle->listening.elts;
       203:    for (i = 0; i < cycle->listening.nelts; i++) {
       204:        if (ls[i].fd == (ngx_socket_t) -1 || !ls[i].open) {
       205:            continue;
       206:        }
       207:  
       208:        if (ngx_close_socket(ls[i].fd) == -1) {
       209:            ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,
       210:                          ngx_close_socket_n " %V failed",
       211:                          &ls[i].addr_text);
       212:        }
       213:    }
       214:  
       215:    ngx_destroy_cycle_pools(&conf);

      -

      Echo Chen:Blog.csdn.net/chen19870707

上一篇:hadoop2.x 异常


下一篇:java基础类型的byte为长度