12.Nginx启动流程之ngx_init_cycle

Nginx的启动流程在ngx_add_inherited_sockets之后，会调用ngx_init_cycle来创建cycle，从下面的代码分析，我们可以看出，在ngx_init_cycle中，Nginx主要进行了以下工作：

1.根据旧cycle来创建新cycle，根据旧cycle的经验，可以推测出创建新cycle所需要的内存空间

2.对新cycle进行初始化工作，包括打开文件、打开监听套接字等

3.解析配置文件

4.模块初始化

5.创建pidfile文件

6.出错回滚及关闭不需要的文件描述符和监听套接字

/* core/ngx_core.h */typedef struct ngx_cycle_s       ngx_cycle_t;/* core/ngx_cycle.h */struct ngx_cycle_s {                 // ngx_cycle_t结构体定义    void           ****conf_ctx;     // 模块配置上下文数组    ngx_pool_t        *pool;         // 使用的内存池指针    ngx_log_t         *log;          // 使用的日志指针    ngx_log_t         *new_log;      // 新的日志指针    ngx_array_t        listening;    // 监听套接字数组    ngx_array_t        pathes;       // 路径数组    ngx_list_t         open_files;   // 打开文件链表    ngx_uint_t         connection_n; // 最大连接数    ngx_connection_t  *connections;    ngx_event_t       *read_events;    ngx_event_t       *write_events;    ngx_cycle_t       *old_cycle;    // 旧cycle    ngx_str_t          conf_file;    // 配置文件    ngx_str_t          root;         // 工作目录};/* core/ngx_connection.c *//* 为cycle打开监听套接字   param cycle: ngx_cycle_t结构体指针*/ngx_int_t ngx_open_listening_sockets(ngx_cycle_t *cycle){    ngx_uint_t        tries, failed, reuseaddr, i;    ngx_err_t         err;    ngx_log_t        *log;    ngx_socket_t      s;    ngx_listening_t  *ls;    reuseaddr = 1;#if (NGX_SUPPRESS_WARN)    failed = 0;#endif    log = cycle->log;    // tries用于指定重试次数, 这里为5次    for (tries = /* STUB */ 5; tries; tries--) {        failed = 0;        ls = cycle->listening.elts;        // 遍历cycle的监听套接字数组        for (i = 0; i < cycle->listening.nelts; i++) {            if (ls[i].ignore) {                // 如果监听套接字的ignore成员不为0, 那么就直接忽略                continue;            }            if (ls[i].fd != -1) {                // 如果监听套接字的fd不为-1, 那么说明已经打开                continue;            }            if (ls[i].inherited) {                // 如果监听套接字的inherited不为0, 那么说明是继承而来的, 直接跳过                continue;            }            // ngx_socket宏就是调用socket库函数来创建套接字            s = ngx_socket(ls[i].family, ls[i].type, ls[i].protocol,                           ls[i].flags);            if (s == -1) {                ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,                              ngx_socket_n " %s failed", ls[i].addr_text.data);                return NGX_ERROR;            }#if (WIN32)            /*             * Winsock assignes a socket number divisible by 4             * so to find a connection we divide a socket number by 4.             */            if (s % 4) {                ngx_log_error(NGX_LOG_EMERG, ls->log, 0,                              ngx_socket_n " created socket %d", s);                return NGX_ERROR;            }#endif            // 设置套接字选项SO_REUSEADDR, 即允许端口重用            if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR,                           (const void *) &reuseaddr, sizeof(int)) == -1) {                ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,                              "setsockopt(SO_REUSEADDR) %s failed",                              ls[i].addr_text.data);                return NGX_ERROR;            }            if (!(ngx_event_flags & NGX_USE_AIO_EVENT)) {                // 如果不使用异步IO                                // 使用fcntl或者ioctl设置套接字为非阻塞                if (ngx_nonblocking(s) == -1) {                    ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,                                  ngx_nonblocking_n " %s failed",                                  ls[i].addr_text.data);                    return NGX_ERROR;                }            }#if 0            if (ls[i].nonblocking) {                if (ngx_nonblocking(s) == -1) {                    ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,                                  ngx_nonblocking_n " %s failed",                                  ls[i].addr_text.data);                    return NGX_ERROR;                }            }#endif            // 绑定套接字到监听套接字的sockaddr成员所指地址结构            if (bind(s, ls[i].sockaddr, ls[i].socklen) == -1) {                err = ngx_socket_errno;                ngx_log_error(NGX_LOG_EMERG, log, err,                              "bind() to %s failed", ls[i].addr_text.data);                // 绑定失败的错误不是NGX_EADDRINUSE即EADDRINUSE时, 返回NGX_ERROR                if (err != NGX_EADDRINUSE)                    return NGX_ERROR;                // 绑定失败的错误是NGX_EADDRINUSE即EADDRINUSE时, 关闭套接字                if (ngx_close_socket(s) == -1)                    ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,                                  ngx_close_socket_n " %s failed",                                  ls[i].addr_text.data);                failed = 1;                continue;            }            // 调用listen使套接字转变为一个被动套接字, backlog由ls[i]的backlog成员指定            if (listen(s, ls[i].backlog) == -1) {                ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,                              "listen() to %s failed", ls[i].addr_text.data);                return NGX_ERROR;            }            // 置ls[i]的fd成员为刚创建的套接字描述符            ls[i].fd = s;        }        if (!failed)            // 如果上述步骤都没有出错, 那么退出重试循环            break;        ngx_log_error(NGX_LOG_NOTICE, log, 0,                      "try again to bind() after 500ms");        // 等待500ms后进行下一次重试        ngx_msleep(500);    }    if (failed) {        // 如果重试次数耗尽, 但是依旧出错, 那么返回NGX_ERROR        ngx_log_error(NGX_LOG_EMERG, log, 0, "still can not bind()");        return NGX_ERROR;    }        return NGX_OK;}/* core/ngx_cycle.c */volatile ngx_cycle_t  *ngx_cycle;ngx_array_t            ngx_old_cycles;static ngx_pool_t     *ngx_temp_pool;static ngx_event_t     ngx_cleaner_event;#ifdef NGX_ERROR_LOG_PATHstatic ngx_str_t  error_log = ngx_string(NGX_ERROR_LOG_PATH);#elsestatic ngx_str_t  error_log = ngx_null_string;#endif/* 创建pidfile文件   param cycle    : 新cycle指针         old_cycle: 旧cycle指针   return         : NGX_OK/NGX_ERROR*/ngx_int_t ngx_create_pidfile(ngx_cycle_t *cycle, ngx_cycle_t *old_cycle){    ngx_uint_t        trunc;    size_t            len;    // NGX_INT64_LEN宏表示64位有符号整数的十进制字符串形式的最大长度, 值为20    u_char           *name, pid[NGX_INT64_LEN + 1];    ngx_file_t        file;    ngx_core_conf_t  *ccf, *old_ccf;    if (!ngx_test_config && old_cycle && old_cycle->conf_ctx == NULL) {        return NGX_OK;    }    ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);    if (!ngx_test_config && old_cycle) {        old_ccf = (ngx_core_conf_t *) ngx_get_conf(old_cycle->conf_ctx,                                                   ngx_core_module);        // 判断旧cycle和新cycle的pidfile文件名是否一样, 如果一样, 则说明可以沿用旧cycle下的pidfile文件        if (ccf->pid.len == old_ccf->pid.len            && ngx_strcmp(ccf->pid.data, old_ccf->pid.data) == 0)        {            return NGX_OK;        }    }    // 使用pid无符号字符数组来存放当前进程PID的十进制字符串形式    len = ngx_snprintf((char *) pid, NGX_INT64_LEN + 1, PID_T_FMT, ngx_pid);    // 初始化ngx_file_t结构体类型的file变量为0    ngx_memzero(&file, sizeof(ngx_file_t));    // 如果当前进程是子进程且ngx_inherited为1, 那么pidfile文件名为newpid, 反之则为pid    file.name = (ngx_inherited && getppid() > 1) ? ccf->newpid : ccf->pid;    file.log = cycle->log;    // 如果只是测试配置文件, 那么不截断文件, 反之则截断    trunc = ngx_test_config ? 0: NGX_FILE_TRUNCATE;    // ngx_open_file宏实质就是调用open来打开和创建文件    // 这里就是打开pidfile文件    file.fd = ngx_open_file(file.name.data, NGX_FILE_RDWR,                            NGX_FILE_CREATE_OR_OPEN|trunc);    if (file.fd == NGX_INVALID_FILE) {        ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_errno,                      ngx_open_file_n " \"%s\" failed", file.name.data);        return NGX_ERROR;    }    if (!ngx_test_config) {        // 将pid无符号字符数组存放的数据写入pidfile文件        if (ngx_write_file(&file, pid, len, 0) == NGX_ERROR) {            return NGX_ERROR;        }    }    // 关闭打开的pidfile文件    if (ngx_close_file(file.fd) == NGX_FILE_ERROR) {        ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,                      ngx_close_file_n " \"%s\" failed", file.name.data);    }    // 删除旧cycle的pidfile文件    ngx_delete_pidfile(old_cycle);    return NGX_OK;}/* 根据旧cycle创建新cycle*/ngx_cycle_t *ngx_init_cycle(ngx_cycle_t *old_cycle){    void               *rv;    ngx_uint_t          i, n, failed;    ngx_log_t          *log;    ngx_conf_t          conf;    ngx_pool_t         *pool;    ngx_cycle_t        *cycle, **old;    ngx_socket_t        fd;    ngx_list_part_t    *part;    ngx_open_file_t    *file;    ngx_listening_t    *ls, *nls;    ngx_core_module_t  *module;    log = old_cycle->log;    // 创建一个大小为16KB的内存池pool    if (!(pool = ngx_create_pool(16 * 1024, log))) {        return NULL;    }    pool->log = log;    // 从内存池pool中申请一块ngx_cycle_t结构体大小的内存空间    // 用于存放新的cycle    if (!(cycle = ngx_pcalloc(pool, sizeof(ngx_cycle_t)))) {        ngx_destroy_pool(pool);        return NULL;    }    cycle->pool = pool;                          // 设置使用的内存池    cycle->log = log;                            // 设置使用的日志句柄    cycle->old_cycle = old_cycle;                // 设置旧cycle    cycle->conf_file = old_cycle->conf_file;     // 设置配置文件    cycle->root.len = sizeof(NGX_PREFIX) - 1;    // 设置工作目录字符串长度    cycle->root.data = (u_char *) NGX_PREFIX;    // 设置工作目录字符串数据    // 获取旧cycle的路径数组的元素个数n    n = old_cycle->pathes.nelts ? old_cycle->pathes.nelts : 10;    // 从内存池pool申请n个ngx_path_t结构体大小的内存空间    if (!(cycle->pathes.elts = ngx_pcalloc(pool, n * sizeof(ngx_path_t *)))) {        ngx_destroy_pool(pool);        return NULL;    }    // 设置路径数组的当前元素个数为0    cycle->pathes.nelts = 0;    // 设置路径数组的元素大小为ngx_path_t结构体大小    cycle->pathes.size = sizeof(ngx_path_t *);    // 设置路径数组的初始容量为n    cycle->pathes.nalloc = n;    // 设置路径数组使用的内存池为pool    cycle->pathes.pool = pool;    if (old_cycle->open_files.part.nelts) {        // 如果旧cycle的打开文件链表的头节点的数据区的已有元素个数不为0, 说明链表不为空                // 使用n统计旧cycle的打开文件链表各节点数据区的已有元素个数之和        n = old_cycle->open_files.part.nelts;        for (part = old_cycle->open_files.part.next; part; part = part->next) {            n += part->nelts;        }    } else {        // 如果旧cycle的打开文件链表为空, 那么置n为20        n = 20;    }    // 初始化新cycle的打开文件链表: 使用的内存池为pool, 头节点的数据区可以存放n个ngx_open_file_t结构体    if (ngx_list_init(&cycle->open_files, pool, n, sizeof(ngx_open_file_t))                                                                  == NGX_ERROR)    {        ngx_destroy_pool(pool);        return NULL;    }    // 使用旧cycle创建一个日志    if (!(cycle->new_log = ngx_log_create_errlog(cycle, NULL))) {        ngx_destroy_pool(pool);        return NULL;    }    // 设置新cycle的新日志的文件名    cycle->new_log->file->name = error_log;    // 获取旧cycle的监听套接字数组的已有元素个数n, 默认为10    n = old_cycle->listening.nelts ? old_cycle->listening.nelts : 10;    // 从内存池pool申请n个ngx_listening_t结构体大小的内存空间    cycle->listening.elts = ngx_pcalloc(pool, n * sizeof(ngx_listening_t));    if (cycle->listening.elts == NULL) {        ngx_destroy_pool(pool);        return NULL;    }    // 设置监听套接字数组的已有元素个数为0    cycle->listening.nelts = 0;    // 设置监听套接字数组的元素大小为ngx_listening_t结构体大小    cycle->listening.size = sizeof(ngx_listening_t);    // 设置监听套接字数组的初始容量为n    cycle->listening.nalloc = n;    // 设置监听套接字数组使用的内存池为pool    cycle->listening.pool = pool;    // 全局变量ngx_max_module用于统计Nginx的模块数量    // 从内存池pool申请ngx_max_module个指针大小的内存空间    cycle->conf_ctx = ngx_pcalloc(pool, ngx_max_module * sizeof(void *));    if (cycle->conf_ctx == NULL) {        ngx_destroy_pool(pool);        return NULL;    }    // 全局变量ngx_modules数组用于存放Nginx的所有模块结构体    // 这里对ngx_modules数组进行遍历    for (i = 0; ngx_modules[i]; i++) {        // 只对NGX_CORE_MODULE类型的模块进行处理        if (ngx_modules[i]->type != NGX_CORE_MODULE) {            continue;        }        module = ngx_modules[i]->ctx;        if (module->create_conf) {            // 如果模块的create_conf函数指针不为空, 那么调用create_conf来创建模块的配置信息            rv = module->create_conf(cycle);            if (rv == NGX_CONF_ERROR) {                // 一旦某个模块的create_conf出错, 立刻返回                ngx_destroy_pool(pool);                return NULL;            }            // 在新cycle的模块配置上下文数组的相应位置记录create_conf的返回值            cycle->conf_ctx[ngx_modules[i]->index] = rv;        }    }    // 初始化ngx_conf_t结构体类型的conf变量为0    ngx_memzero(&conf, sizeof(ngx_conf_t));    // 从内存池pool申请一块10个ngx_str_t结构体大小的内存空间    conf.args = ngx_create_array(pool, 10, sizeof(ngx_str_t));    if (conf.args == NULL) {        ngx_destroy_pool(pool);        return NULL;    }    // 设置conf的ctx成员为新cycle的模块配置上下文数组首地址    conf.ctx = cycle->conf_ctx;    // 设置conf的cycle成员为新cycle    conf.cycle = cycle;    // 设置conf使用的内存池为pool    conf.pool = pool;    // 设置conf使用的日志为log    conf.log = log;    // 设置conf的module_type成员为NGX_CORE_MODULE    conf.module_type = NGX_CORE_MODULE;    // 设置conf的cmd_type成员为NGX_MAIN_CONF    conf.cmd_type = NGX_MAIN_CONF;    // 进行配置文件解析    if (ngx_conf_parse(&conf, &cycle->conf_file) != NGX_CONF_OK) {        ngx_destroy_pool(pool);        return NULL;    }    if (ngx_test_config) {        ngx_log_error(NGX_LOG_INFO, log, 0,                      "the configuration file %s syntax is ok",                      cycle->conf_file.data);    }    for (i = 0; ngx_modules[i]; i++) {        // 只对NGX_CORE_MODULE类型的模块进行处理        if (ngx_modules[i]->type != NGX_CORE_MODULE) {            continue;        }        module = ngx_modules[i]->ctx;        if (module->init_conf) {            // 如果模块的init_conf函数指针不为空, 那么调用init_conf来初始化模块的配置信息            if (module->init_conf(cycle, cycle->conf_ctx[ngx_modules[i]->index])                                                              == NGX_CONF_ERROR)            {                ngx_destroy_pool(pool);                return NULL;            }        }    }    failed = 0;#if !(WIN32)    // 创建pidfile文件    if (ngx_create_pidfile(cycle, old_cycle) == NGX_ERROR) {        failed = 1;    }#endif    if (!failed) {        // 如果创建pidfile文件没有失败        // 以下是遍历新cycle的打开文件链表        part = &cycle->open_files.part;        file = part->elts;        for (i = 0; /* void */ ; i++) {            if (i >= part->nelts) {                // 如果遍历到当前节点的数据区的结尾                if (part->next == NULL) {                    // 如果当前节点是链表的尾节点, 那么遍历结束                    break;                }                // part指向下一个节点, file指向下一个节点的数据区首地址, i重置为0,                // 也就是遍历下一个节点的数据区                part = part->next;                file = part->elts;                i = 0;            }            if (file[i].name.data == NULL) {                // 如果file[i]的name成员的数据为空, 也就是没有指明文件名, 那么跳过                continue;            }            // 打开file[i]的name成员的数据所指向的文件名            file[i].fd = ngx_open_file(file[i].name.data,                                       NGX_FILE_RDWR,                                       NGX_FILE_CREATE_OR_OPEN|NGX_FILE_APPEND);#if 0            log->log_level = NGX_LOG_DEBUG_ALL;#endif            ngx_log_debug3(NGX_LOG_DEBUG_CORE, log, 0,                           "log: %0X %d \"%s\"",                           &file[i], file[i].fd, file[i].name.data);            if (file[i].fd == NGX_INVALID_FILE) {                // 如果打开失败, 退出遍历                ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,                              ngx_open_file_n " \"%s\" failed",                              file[i].name.data);                failed = 1;                break;            }#if (WIN32)            if (ngx_file_append_mode(file[i].fd) == NGX_ERROR) {                ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,                              ngx_file_append_mode_n " \"%s\" failed",                              file[i].name.data);                failed = 1;                break;            }#else            // 调用fcntl对打开的文件描述符设置FD_CLOEXEC,            // 也就是在使用exec系列函数后, 此描述符将被关闭            if (fcntl(file[i].fd, F_SETFD, FD_CLOEXEC) == -1) {                ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,                              "fcntl(FD_CLOEXEC) \"%s\" failed",                              file[i].name.data);                failed = 1;                break;            }#endif        }    }    // 设置新cycle的log成员为其new_log成员    cycle->log = cycle->new_log;    // 修改内存池pool使用的log为新cycle的new_log    pool->log = cycle->new_log;    if (cycle->log->log_level == 0) {        // 如果新cycle的log的日志级别为0即NGX_LOG_STDERR, 那么修改日志级别为NGX_LOG_ERR        cycle->log->log_level = NGX_LOG_ERR;    }    if (!failed) {        // 如果前面的步骤没有失败                if (old_cycle->listening.nelts) {            // 如果旧cycle的监听套接字数组不为空                        ls = old_cycle->listening.elts;            for (i = 0; i < old_cycle->listening.nelts; i++) {                // 遍历旧cycle的监听套接字数组, 设置每个监听套接字的remain成员为0                ls[i].remain = 0;            }            nls = cycle->listening.elts;            // 对新cycle的监听套接字数组进行遍历, 上面设置该数组为空的, 按道理这里应该不会执行循环体            for (n = 0; n < cycle->listening.nelts; n++) {                for (i = 0; i < old_cycle->listening.nelts; i++) {                    // 遍历旧cycle的监听套接字数组                    if (ls[i].ignore) {                        continue;                    }                    // 找到与nls[n]的sockaddr成员所指套接字地址相同的ls[i]                    if (ngx_memcmp(nls[n].sockaddr,                                   ls[i].sockaddr, ls[i].socklen) == 0)                    {                        fd = ls[i].fd;#if (WIN32)                        /*                         * Winsock assignes a socket number divisible by 4 so                         * to find a connection we divide a socket number by 4.                         */                        fd /= 4;#endif                        if (fd >= (ngx_socket_t) cycle->connection_n) {                            // 如果fd达到新cycle的最大连接数, 那么退出当前循环                            ngx_log_error(NGX_LOG_EMERG, log, 0,                                        "%d connections is not enough to hold "                                        "an open listening socket on %s, "                                        "required at least %d connections",                                        cycle->connection_n,                                        ls[i].addr_text.data, fd);                            failed = 1;                            break;                        }                        // ls[i]的fd成员赋值给nls[n]的fd成员                        nls[n].fd = ls[i].fd;                        nls[i].remain = 1;                        ls[i].remain = 1;                        break;                    }                }                if (nls[n].fd == -1) {                    nls[n].new = 1;                }            }        } else {            // 如果旧cycle的监听套接字数组为空                        ls = cycle->listening.elts;            // 置新cycle的监听套接字数组的每个元素的new成员为1            for (i = 0; i < cycle->listening.nelts; i++) {                ls[i].new = 1;            }        }        if (!ngx_test_config && !failed) {            // 如果不是在测试配置文件并且上述步骤没有失败                        // 为cycle打开监听套接字            if (ngx_open_listening_sockets(cycle) == NGX_ERROR) {                failed = 1;            }        }    }    if (failed) {        // 如果上述步骤出错, 进行回滚操作        part = &cycle->open_files.part;        file = part->elts;        // 遍历新cycle的打开文件链表        for (i = 0; /* void */ ; i++) {            if (i >= part->nelts) {                if (part->next == NULL) {                    break;                }                part = part->next;                file = part->elts;                i = 0;            }            if (file[i].fd == NGX_INVALID_FILE                || file[i].fd == ngx_stderr_fileno)            {                continue;            }            // 关闭打开的文件描述符            if (ngx_close_file(file[i].fd) == NGX_FILE_ERROR) {                ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,                              ngx_close_file_n " \"%s\" failed",                              file[i].name.data);            }        }        if (ngx_test_config) {            // 如果是在测试配置文件, 那么销毁内存池pool后就可以返回了            // 因为在测试配置文件时, 是不需要执行打开监听套接字的操作的            ngx_destroy_pool(pool);            return NULL;        }        ls = cycle->listening.elts;        // 遍历cycle的监听套接字数组        for (i = 0; i < cycle->listening.nelts; i++) {            if (ls[i].fd == -1 || !ls[i].new) {                continue;            }            // 关闭监听套接字            if (ngx_close_socket(ls[i].fd) == -1) {                ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,                              ngx_close_socket_n " %s failed",                              ls[i].addr_text.data);            }        }        // 销毁内存池pool并返回        ngx_destroy_pool(pool);        return NULL;    }#if !(WIN32)    if (!ngx_test_config && cycle->log->file->fd != STDERR_FILENO) {        // 不是在测试配置文件且新cycle的日志文件描述符不为标准错误文件描述符        ngx_log_debug3(NGX_LOG_DEBUG_CORE, log, 0,                       "dup2: %0X %d \"%s\"",                       cycle->log->file,                       cycle->log->file->fd, cycle->log->file->name.data);        // 重定向标准错误到新cycle的日志文件        if (dup2(cycle->log->file->fd, STDERR_FILENO) == NGX_ERROR) {            ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,                          "dup2(STDERR) failed");            exit(1);        }    }#endif    pool->log = cycle->log;    for (i = 0; ngx_modules[i]; i++) {        if (ngx_modules[i]->init_module) {            // 如果模块的init_module函数指针不为空, 那么调用init_module来进行模块初始化工作            if (ngx_modules[i]->init_module(cycle) == NGX_ERROR) {                exit(1);            }        }    }    ls = old_cycle->listening.elts;    // 遍历旧cycle的监听套接字数组    for (i = 0; i < old_cycle->listening.nelts; i++) {        if (ls[i].remain) {            // 如果remain成员不为0, 即表示保留, 那么跳过            continue;        }        // 关闭监听套接字        if (ngx_close_socket(ls[i].fd) == -1) {            ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,                          ngx_close_socket_n " %s failed",                          ls[i].addr_text.data);        }    }    part = &old_cycle->open_files.part;    file = part->elts;    // 遍历新cycle的打开文件链表    for (i = 0; /* void */ ; i++) {        if (i >= part->nelts) {            if (part->next == NULL) {                break;            }            part = part->next;            file = part->elts;            i = 0;        }        if (file[i].fd == NGX_INVALID_FILE || file[i].fd == ngx_stderr_fileno) {            continue;        }        // 关闭打开的文件描述符        if (ngx_close_file(file[i].fd) == NGX_FILE_ERROR) {            ngx_log_error(NGX_LOG_EMERG, log, ngx_errno,                          ngx_close_file_n " \"%s\" failed",                          file[i].name.data);        }    }    if (old_cycle->connections == NULL) {        ngx_destroy_pool(old_cycle->pool);        return cycle;    }    if (ngx_process == NGX_PROCESS_MASTER) {        ngx_destroy_pool(old_cycle->pool);        return cycle;    }    if (ngx_temp_pool == NULL) {        // 如果ngx_temp_pool指针为空                // 创建大小为128字节的内存池作为ngx_temp_pool        ngx_temp_pool = ngx_create_pool(128, cycle->log);        if (ngx_temp_pool == NULL) {            ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,                          "can not create ngx_temp_pool");            exit(1);        }        n = 10;        // 从内存池ngx_temp_pool申请10个指针大小的内存空间给ngx_old_cycles数组        ngx_old_cycles.elts = ngx_pcalloc(ngx_temp_pool,                                          n * sizeof(ngx_cycle_t *));        if (ngx_old_cycles.elts == NULL) {            exit(1);        }        // ngx_old_cycles数组的初始元素为0个        ngx_old_cycles.nelts = 0;        // ngx_old_cycles数组的元素大小即为指针大小        ngx_old_cycles.size = sizeof(ngx_cycle_t *);        // ngx_old_cycles数组的初始容量为10        ngx_old_cycles.nalloc = n;        // ngx_old_cycles数组使用的内存池为ngx_temp_pool        ngx_old_cycles.pool = ngx_temp_pool;        ngx_cleaner_event.event_handler = ngx_clean_old_cycles;        ngx_cleaner_event.log = cycle->log;        ngx_cleaner_event.data = &dumb;        dumb.fd = (ngx_socket_t) -1;    }    ngx_temp_pool->log = cycle->log;    // 从ngx_old_cycles数组分配一个元素的内存    old = ngx_push_array(&ngx_old_cycles);    if (old == NULL) {        exit(1);    }    // 将旧cycle存放进ngx_old_cycles数组    *old = old_cycle;    if (!ngx_cleaner_event.timer_set) {        ngx_add_timer(&ngx_cleaner_event, 30000);        ngx_cleaner_event.timer_set = 1;    }    // 返回新cycle    return cycle;}