Ubuntu 下 nginx-1.24.0 源码分析 - ngx_init_cycle 函数

nei声明在 src/core/ngx_cycle.h

ngx_cycle_t *ngx_init_cycle(ngx_cycle_t *old_cycle);

实现在 src/core/ngx_cycle.c

ngx_cycle_t *
ngx_init_cycle(ngx_cycle_t *old_cycle)
{void                *rv;char               **senv;ngx_uint_t           i, n;ngx_log_t           *log;ngx_time_t          *tp;ngx_conf_t           conf;ngx_pool_t          *pool;ngx_cycle_t         *cycle, **old;ngx_shm_zone_t      *shm_zone, *oshm_zone;ngx_list_part_t     *part, *opart;ngx_open_file_t     *file;ngx_listening_t     *ls, *nls;ngx_core_conf_t     *ccf, *old_ccf;ngx_core_module_t   *module;char                 hostname[NGX_MAXHOSTNAMELEN];ngx_timezone_update();/* force localtime update with a new timezone */tp = ngx_timeofday();tp->sec = 0;ngx_time_update();log = old_cycle->log;pool = ngx_create_pool(NGX_CYCLE_POOL_SIZE, log);if (pool == NULL) {return NULL;}pool->log = log;cycle = ngx_pcalloc(pool, sizeof(ngx_cycle_t));if (cycle == NULL) {ngx_destroy_pool(pool);return NULL;}cycle->pool = pool;cycle->log = log;cycle->old_cycle = old_cycle;cycle->conf_prefix.len = old_cycle->conf_prefix.len;cycle->conf_prefix.data = ngx_pstrdup(pool, &old_cycle->conf_prefix);if (cycle->conf_prefix.data == NULL) {ngx_destroy_pool(pool);return NULL;}cycle->prefix.len = old_cycle->prefix.len;cycle->prefix.data = ngx_pstrdup(pool, &old_cycle->prefix);if (cycle->prefix.data == NULL) {ngx_destroy_pool(pool);return NULL;}cycle->error_log.len = old_cycle->error_log.len;cycle->error_log.data = ngx_pnalloc(pool, old_cycle->error_log.len + 1);if (cycle->error_log.data == NULL) {ngx_destroy_pool(pool);return NULL;}ngx_cpystrn(cycle->error_log.data, old_cycle->error_log.data,old_cycle->error_log.len + 1);cycle->conf_file.len = old_cycle->conf_file.len;cycle->conf_file.data = ngx_pnalloc(pool, old_cycle->conf_file.len + 1);if (cycle->conf_file.data == NULL) {ngx_destroy_pool(pool);return NULL;}ngx_cpystrn(cycle->conf_file.data, old_cycle->conf_file.data,old_cycle->conf_file.len + 1);cycle->conf_param.len = old_cycle->conf_param.len;cycle->conf_param.data = ngx_pstrdup(pool, &old_cycle->conf_param);if (cycle->conf_param.data == NULL) {ngx_destroy_pool(pool);return NULL;}n = old_cycle->paths.nelts ? old_cycle->paths.nelts : 10;if (ngx_array_init(&cycle->paths, pool, n, sizeof(ngx_path_t *))!= NGX_OK){ngx_destroy_pool(pool);return NULL;}ngx_memzero(cycle->paths.elts, n * sizeof(ngx_path_t *));if (ngx_array_init(&cycle->config_dump, pool, 1, sizeof(ngx_conf_dump_t))!= NGX_OK){ngx_destroy_pool(pool);return NULL;}ngx_rbtree_init(&cycle->config_dump_rbtree, &cycle->config_dump_sentinel,ngx_str_rbtree_insert_value);if (old_cycle->open_files.part.nelts) {n = old_cycle->open_files.part.nelts;for (part = old_cycle->open_files.part.next; part; part = part->next) {n += part->nelts;}} else {n = 20;}if (ngx_list_init(&cycle->open_files, pool, n, sizeof(ngx_open_file_t))!= NGX_OK){ngx_destroy_pool(pool);return NULL;}if (old_cycle->shared_memory.part.nelts) {n = old_cycle->shared_memory.part.nelts;for (part = old_cycle->shared_memory.part.next; part; part = part->next){n += part->nelts;}} else {n = 1;}if (ngx_list_init(&cycle->shared_memory, pool, n, sizeof(ngx_shm_zone_t))!= NGX_OK){ngx_destroy_pool(pool);return NULL;}n = old_cycle->listening.nelts ? old_cycle->listening.nelts : 10;if (ngx_array_init(&cycle->listening, pool, n, sizeof(ngx_listening_t))!= NGX_OK){ngx_destroy_pool(pool);return NULL;}ngx_memzero(cycle->listening.elts, n * sizeof(ngx_listening_t));ngx_queue_init(&cycle->reusable_connections_queue);cycle->conf_ctx = ngx_pcalloc(pool, ngx_max_module * sizeof(void *));if (cycle->conf_ctx == NULL) {ngx_destroy_pool(pool);return NULL;}if (gethostname(hostname, NGX_MAXHOSTNAMELEN) == -1) {ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "gethostname() failed");ngx_destroy_pool(pool);return NULL;}/* on Linux gethostname() silently truncates name that does not fit */hostname[NGX_MAXHOSTNAMELEN - 1] = '\0';cycle->hostname.len = ngx_strlen(hostname);cycle->hostname.data = ngx_pnalloc(pool, cycle->hostname.len);if (cycle->hostname.data == NULL) {ngx_destroy_pool(pool);return NULL;}ngx_strlow(cycle->hostname.data, (u_char *) hostname, cycle->hostname.len);if (ngx_cycle_modules(cycle) != NGX_OK) {ngx_destroy_pool(pool);return NULL;}for (i = 0; cycle->modules[i]; i++) {if (cycle->modules[i]->type != NGX_CORE_MODULE) {continue;}module = cycle->modules[i]->ctx;if (module->create_conf) {rv = module->create_conf(cycle);if (rv == NULL) {ngx_destroy_pool(pool);return NULL;}cycle->conf_ctx[cycle->modules[i]->index] = rv;}}senv = environ;ngx_memzero(&conf, sizeof(ngx_conf_t));/* STUB: init array ? */conf.args = ngx_array_create(pool, 10, sizeof(ngx_str_t));if (conf.args == NULL) {ngx_destroy_pool(pool);return NULL;}conf.temp_pool = ngx_create_pool(NGX_CYCLE_POOL_SIZE, log);if (conf.temp_pool == NULL) {ngx_destroy_pool(pool);return NULL;}conf.ctx = cycle->conf_ctx;conf.cycle = cycle;conf.pool = pool;conf.log = log;conf.module_type = NGX_CORE_MODULE;conf.cmd_type = NGX_MAIN_CONF;#if 0log->log_level = NGX_LOG_DEBUG_ALL;
#endifif (ngx_conf_param(&conf) != NGX_CONF_OK) {environ = senv;ngx_destroy_cycle_pools(&conf);return NULL;}if (ngx_conf_parse(&conf, &cycle->conf_file) != NGX_CONF_OK) {environ = senv;ngx_destroy_cycle_pools(&conf);return NULL;}if (ngx_test_config && !ngx_quiet_mode) {ngx_log_stderr(0, "the configuration file %s syntax is ok",cycle->conf_file.data);}for (i = 0; cycle->modules[i]; i++) {if (cycle->modules[i]->type != NGX_CORE_MODULE) {continue;}module = cycle->modules[i]->ctx;if (module->init_conf) {if (module->init_conf(cycle,cycle->conf_ctx[cycle->modules[i]->index])== NGX_CONF_ERROR){environ = senv;ngx_destroy_cycle_pools(&conf);return NULL;}}}if (ngx_process == NGX_PROCESS_SIGNALLER) {return cycle;}ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);if (ngx_test_config) {if (ngx_create_pidfile(&ccf->pid, log) != NGX_OK) {goto failed;}} else if (!ngx_is_init_cycle(old_cycle)) {/** we do not create the pid file in the first ngx_init_cycle() call* because we need to write the demonized process pid*/old_ccf = (ngx_core_conf_t *) ngx_get_conf(old_cycle->conf_ctx,ngx_core_module);if (ccf->pid.len != old_ccf->pid.len|| ngx_strcmp(ccf->pid.data, old_ccf->pid.data) != 0){/* new pid file name */if (ngx_create_pidfile(&ccf->pid, log) != NGX_OK) {goto failed;}ngx_delete_pidfile(old_cycle);}}if (ngx_test_lockfile(cycle->lock_file.data, log) != NGX_OK) {goto failed;}if (ngx_create_paths(cycle, ccf->user) != NGX_OK) {goto failed;}if (ngx_log_open_default(cycle) != NGX_OK) {goto failed;}/* open the new files */part = &cycle->open_files.part;file = part->elts;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].name.len == 0) {continue;}file[i].fd = ngx_open_file(file[i].name.data,NGX_FILE_APPEND,NGX_FILE_CREATE_OR_OPEN,NGX_FILE_DEFAULT_ACCESS);ngx_log_debug3(NGX_LOG_DEBUG_CORE, log, 0,"log: %p %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);goto failed;}#if !(NGX_WIN32)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);goto failed;}
#endif}cycle->log = &cycle->new_log;pool->log = &cycle->new_log;/* create shared memory */part = &cycle->shared_memory.part;shm_zone = part->elts;for (i = 0; /* void */ ; i++) {if (i >= part->nelts) {if (part->next == NULL) {break;}part = part->next;shm_zone = part->elts;i = 0;}if (shm_zone[i].shm.size == 0) {ngx_log_error(NGX_LOG_EMERG, log, 0,"zero size shared memory zone \"%V\"",&shm_zone[i].shm.name);goto failed;}shm_zone[i].shm.log = cycle->log;opart = &old_cycle->shared_memory.part;oshm_zone = opart->elts;for (n = 0; /* void */ ; n++) {if (n >= opart->nelts) {if (opart->next == NULL) {break;}opart = opart->next;oshm_zone = opart->elts;n = 0;}if (shm_zone[i].shm.name.len != oshm_zone[n].shm.name.len) {continue;}if (ngx_strncmp(shm_zone[i].shm.name.data,oshm_zone[n].shm.name.data,shm_zone[i].shm.name.len)!= 0){continue;}if (shm_zone[i].tag == oshm_zone[n].tag&& shm_zone[i].shm.size == oshm_zone[n].shm.size&& !shm_zone[i].noreuse){shm_zone[i].shm.addr = oshm_zone[n].shm.addr;
#if (NGX_WIN32)shm_zone[i].shm.handle = oshm_zone[n].shm.handle;
#endifif (shm_zone[i].init(&shm_zone[i], oshm_zone[n].data)!= NGX_OK){goto failed;}goto shm_zone_found;}break;}if (ngx_shm_alloc(&shm_zone[i].shm) != NGX_OK) {goto failed;}if (ngx_init_zone_pool(cycle, &shm_zone[i]) != NGX_OK) {goto failed;}if (shm_zone[i].init(&shm_zone[i], NULL) != NGX_OK) {goto failed;}shm_zone_found:continue;}/* handle the listening sockets */if (old_cycle->listening.nelts) {ls = old_cycle->listening.elts;for (i = 0; i < old_cycle->listening.nelts; i++) {ls[i].remain = 0;}nls = cycle->listening.elts;for (n = 0; n < cycle->listening.nelts; n++) {for (i = 0; i < old_cycle->listening.nelts; i++) {if (ls[i].ignore) {continue;}if (ls[i].remain) {continue;}if (ls[i].type != nls[n].type) {continue;}if (ngx_cmp_sockaddr(nls[n].sockaddr, nls[n].socklen,ls[i].sockaddr, ls[i].socklen, 1)== NGX_OK){nls[n].fd = ls[i].fd;nls[n].inherited = ls[i].inherited;nls[n].previous = &ls[i];ls[i].remain = 1;if (ls[i].backlog != nls[n].backlog) {nls[n].listen = 1;}#if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)/** FreeBSD, except the most recent versions,* could not remove accept filter*/nls[n].deferred_accept = ls[i].deferred_accept;if (ls[i].accept_filter && nls[n].accept_filter) {if (ngx_strcmp(ls[i].accept_filter,nls[n].accept_filter)!= 0){nls[n].delete_deferred = 1;nls[n].add_deferred = 1;}} else if (ls[i].accept_filter) {nls[n].delete_deferred = 1;} else if (nls[n].accept_filter) {nls[n].add_deferred = 1;}
#endif#if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)if (ls[i].deferred_accept && !nls[n].deferred_accept) {nls[n].delete_deferred = 1;} else if (ls[i].deferred_accept != nls[n].deferred_accept){nls[n].add_deferred = 1;}
#endif#if (NGX_HAVE_REUSEPORT)if (nls[n].reuseport && !ls[i].reuseport) {nls[n].add_reuseport = 1;}
#endifbreak;}}if (nls[n].fd == (ngx_socket_t) -1) {nls[n].open = 1;
#if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)if (nls[n].accept_filter) {nls[n].add_deferred = 1;}
#endif
#if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)if (nls[n].deferred_accept) {nls[n].add_deferred = 1;}
#endif}}} else {ls = cycle->listening.elts;for (i = 0; i < cycle->listening.nelts; i++) {ls[i].open = 1;
#if (NGX_HAVE_DEFERRED_ACCEPT && defined SO_ACCEPTFILTER)if (ls[i].accept_filter) {ls[i].add_deferred = 1;}
#endif
#if (NGX_HAVE_DEFERRED_ACCEPT && defined TCP_DEFER_ACCEPT)if (ls[i].deferred_accept) {ls[i].add_deferred = 1;}
#endif}}if (ngx_open_listening_sockets(cycle) != NGX_OK) {goto failed;}if (!ngx_test_config) {ngx_configure_listening_sockets(cycle);}/* commit the new cycle configuration */if (!ngx_use_stderr) {(void) ngx_log_redirect_stderr(cycle);}pool->log = cycle->log;if (ngx_init_modules(cycle) != NGX_OK) {/* fatal */exit(1);}/* close and delete stuff that lefts from an old cycle *//* free the unnecessary shared memory */opart = &old_cycle->shared_memory.part;oshm_zone = opart->elts;for (i = 0; /* void */ ; i++) {if (i >= opart->nelts) {if (opart->next == NULL) {goto old_shm_zone_done;}opart = opart->next;oshm_zone = opart->elts;i = 0;}part = &cycle->shared_memory.part;shm_zone = part->elts;for (n = 0; /* void */ ; n++) {if (n >= part->nelts) {if (part->next == NULL) {break;}part = part->next;shm_zone = part->elts;n = 0;}if (oshm_zone[i].shm.name.len != shm_zone[n].shm.name.len) {continue;}if (ngx_strncmp(oshm_zone[i].shm.name.data,shm_zone[n].shm.name.data,oshm_zone[i].shm.name.len)!= 0){continue;}if (oshm_zone[i].tag == shm_zone[n].tag&& oshm_zone[i].shm.size == shm_zone[n].shm.size&& !oshm_zone[i].noreuse){goto live_shm_zone;}break;}ngx_shm_free(&oshm_zone[i].shm);live_shm_zone:continue;}old_shm_zone_done:/* close the unnecessary listening sockets */ls = old_cycle->listening.elts;for (i = 0; i < old_cycle->listening.nelts; i++) {if (ls[i].remain || ls[i].fd == (ngx_socket_t) -1) {continue;}if (ngx_close_socket(ls[i].fd) == -1) {ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,ngx_close_socket_n " listening socket on %V failed",&ls[i].addr_text);}#if (NGX_HAVE_UNIX_DOMAIN)if (ls[i].sockaddr->sa_family == AF_UNIX) {u_char  *name;name = ls[i].addr_text.data + sizeof("unix:") - 1;ngx_log_error(NGX_LOG_WARN, cycle->log, 0,"deleting socket %s", name);if (ngx_delete_file(name) == NGX_FILE_ERROR) {ngx_log_error(NGX_LOG_EMERG, cycle->log, ngx_socket_errno,ngx_delete_file_n " %s failed", name);}}#endif}/* close the unnecessary open files */part = &old_cycle->open_files.part;file = part->elts;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) {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);}}ngx_destroy_pool(conf.temp_pool);if (ngx_process == NGX_PROCESS_MASTER || ngx_is_init_cycle(old_cycle)) {ngx_destroy_pool(old_cycle->pool);cycle->old_cycle = NULL;return cycle;}if (ngx_temp_pool == NULL) {ngx_temp_pool = ngx_create_pool(128, cycle->log);if (ngx_temp_pool == NULL) {ngx_log_error(NGX_LOG_EMERG, cycle->log, 0,"could not create ngx_temp_pool");exit(1);}n = 10;if (ngx_array_init(&ngx_old_cycles, ngx_temp_pool, n,sizeof(ngx_cycle_t *))!= NGX_OK){exit(1);}ngx_memzero(ngx_old_cycles.elts, n * sizeof(ngx_cycle_t *));ngx_cleaner_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;old = ngx_array_push(&ngx_old_cycles);if (old == NULL) {exit(1);}*old = old_cycle;if (!ngx_cleaner_event.timer_set) {ngx_add_timer(&ngx_cleaner_event, 30000);ngx_cleaner_event.timer_set = 1;}return cycle;failed:if (!ngx_is_init_cycle(old_cycle)) {old_ccf = (ngx_core_conf_t *) ngx_get_conf(old_cycle->conf_ctx,ngx_core_module);if (old_ccf->environment) {environ = old_ccf->environment;}}/* rollback the new cycle configuration */part = &cycle->open_files.part;file = part->elts;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) {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);}}/* free the newly created shared memory */part = &cycle->shared_memory.part;shm_zone = part->elts;for (i = 0; /* void */ ; i++) {if (i >= part->nelts) {if (part->next == NULL) {break;}part = part->next;shm_zone = part->elts;i = 0;}if (shm_zone[i].shm.addr == NULL) {continue;}opart = &old_cycle->shared_memory.part;oshm_zone = opart->elts;for (n = 0; /* void */ ; n++) {if (n >= opart->nelts) {if (opart->next == NULL) {break;}opart = opart->next;oshm_zone = opart->elts;n = 0;}if (shm_zone[i].shm.name.len != oshm_zone[n].shm.name.len) {continue;}if (ngx_strncmp(shm_zone[i].shm.name.data,oshm_zone[n].shm.name.data,shm_zone[i].shm.name.len)!= 0){continue;}if (shm_zone[i].tag == oshm_zone[n].tag&& shm_zone[i].shm.size == oshm_zone[n].shm.size&& !shm_zone[i].noreuse){goto old_shm_zone_found;}break;}ngx_shm_free(&shm_zone[i].shm);old_shm_zone_found:continue;}if (ngx_test_config) {ngx_destroy_cycle_pools(&conf);return NULL;}ls = cycle->listening.elts;for (i = 0; i < cycle->listening.nelts; i++) {if (ls[i].fd == (ngx_socket_t) -1 || !ls[i].open) {continue;}if (ngx_close_socket(ls[i].fd) == -1) {ngx_log_error(NGX_LOG_EMERG, log, ngx_socket_errno,ngx_close_socket_n " %V failed",&ls[i].addr_text);}}ngx_destroy_cycle_pools(&conf);return NULL;
}

ngx_init_cycle 是 Nginx 核心模块中的一个关键函数，
负责初始化 Nginx 的运行环境。
它基于传入的旧周期（old_cycle）创建一个新的周期（cycle），
并完成一系列复杂的初始化工作，
包括配置文件解析、共享内存分配、监听套接字设置等。

函数签名

ngx_cycle_t *ngx_init_cycle(ngx_cycle_t *old_cycle)

作用

  • 接收一个指向旧周期（old_cycle）的指针。

  • 返回一个新创建的周期（cycle）指针，表示初始化后的运行时环境。

  • 如果初始化失败，返回 NULL。

  • 新周期会继承旧周期的部分信息（如路径、配置文件路径等），同时根据新的配置进行更新。

   ngx_timezone_update();/* force localtime update with a new timezone */tp = ngx_timeofday();tp->sec = 0;ngx_time_update();

ngx_timezone_update()更新进程的时区缓存
ngx_timeofday() 获取当前时间缓存对象 tp。
tp->sec = 0 强制标记时间缓存为“已失效”。
ngx_time_update() 重新计算当前时间并更新缓存。

tp->sec = 0; 的作用是强制标记当前时间缓存为无效，从而确保在调用 ngx_time_update() 时会重新调用系统函数来获取最新的时间戳。
如果没有强制刷新时间缓存（即 tp->sec != 0），ngx_time_update() 可能不会真正调用系统函数，而是直接使用缓存值

   log = old_cycle->log;

 从旧的 Nginx 运行周期（old_cycle）中继承日志对象（log），并将其赋值给当前的局部变量 log

新周期初始化时，尚未解析新的配置文件，无法确定新的日志路径或级别。
若直接使用新配置的日志可能失败（如路径无效），导致错误信息无法记录。
复用旧日志配置，新周期完全初始化前,确保初始化阶段的日志记录可靠。

   pool = ngx_create_pool(NGX_CYCLE_POOL_SIZE, log);if (pool == NULL) {return NULL;}pool->log = log;

创建一个内存池（memory pool），用于管理 Nginx 运行周期（cycle）中的内存分配

NGX_CYCLE_POOL_SIZE
这是一个宏定义，表示内存池的初始大小。

log 是一个指向日志对象的指针，用于记录内存池操作中的错误或调试信息。

   cycle = ngx_pcalloc(pool, sizeof(ngx_cycle_t));if (cycle == NULL) {ngx_destroy_pool(pool);return NULL;}

从内存池分配一个新的 ngx_cycle_t 结构（核心运行时上下文）

   cycle->pool = pool;cycle->log = log;cycle->old_cycle = old_cycle;

 cycle->pool = pool;
关联新内存池到新周期。
所有后续内存分配均通过此池进行，确保统一管理。

 cycle->log = log;
设置新周期的日志对象。
确保新周期的所有操作使用继承的日志配置，直到新配置生效。

 cycle->old_cycle = old_cycle;
保存旧周期指针到新周期。
在平滑重启或重新配置时，新周期需要访问旧周期的资源（如监听套接字、共享内存）。
资源复用：通过 old_cycle 复用旧资源（如 SO_REUSEPORT 套接字），实现零停机更新。
渐进式释放：旧周期资源在新周期稳定后逐步清理，避免服务中断。

   cycle->conf_prefix.len = old_cycle->conf_prefix.len;cycle->conf_prefix.data = ngx_pstrdup(pool, &old_cycle->conf_prefix);if (cycle->conf_prefix.data == NULL) {ngx_destroy_pool(pool);return NULL;}

复制配置文件前缀（conf_prefix）

从旧周期复制 conf_prefix，用于定位配置文件
平滑重启：保持配置路径一致，避免重新解析路径导致的延迟。

ngx_pstrdup

    cycle->prefix.len = old_cycle->prefix.len;cycle->prefix.data = ngx_pstrdup(pool, &old_cycle->prefix);if (cycle->prefix.data == NULL) {ngx_destroy_pool(pool);return NULL;}

从旧周期复制 prefix（如 /usr/local/nginx/），用于解析相对路径

    cycle->error_log.len = old_cycle->error_log.len;cycle->error_log.data = ngx_pnalloc(pool, old_cycle->error_log.len + 1);if (cycle->error_log.data == NULL) {ngx_destroy_pool(pool);return NULL;}ngx_cpystrn(cycle->error_log.data, old_cycle->error_log.data,old_cycle->error_log.len + 1);

继承错误日志路径：复制旧周期的错误日志文件路径
日志连续性：初始化阶段使用旧日志配置，避免日志记录中断
字符串安全性：通过 ngx_cpystrn 确保字符串以 \0 结尾

   cycle->conf_file.len = old_cycle->conf_file.len;cycle->conf_file.data = ngx_pnalloc(pool, old_cycle->conf_file.len + 1);if (cycle->conf_file.data == NULL) {ngx_destroy_pool(pool);return NULL;}ngx_cpystrn(cycle->conf_file.data, old_cycle->conf_file.data,old_cycle->conf_file.len + 1);

继承配置文件路径：复制旧周期的配置文件路径

    cycle->conf_param.len = old_cycle->conf_param.len;cycle->conf_param.data = ngx_pstrdup(pool, &old_cycle->conf_param);if (cycle->conf_param.data == NULL) {ngx_destroy_pool(pool);return NULL;}

继承命令行配置参数：复制通过 -g 参数传递的配置

    n = old_cycle->paths.nelts ? old_cycle->paths.nelts : 10;

确定 paths 数组的初始容量 n。

若旧周期（old_cycle）存在路径配置，则继承其大小；否则预分配 10 个元素。

paths 用于存储 Nginx 运行时路径（如临时文件目录）。旧周期可能已包含路径信息（如 client_body_temp_path），新周期需复用或初始化。

资源复用：继承旧周期的容量，避免重复计算路径数量。
预分配优化：默认值 10 是经验值，平衡内存占用与扩容开销。

    ngx_memzero(cycle->paths.elts, n * sizeof(ngx_path_t *));

将 paths 数组的前 n 个元素清零（初始化为 NULL）

ngx_array_init 分配的内存未初始化，可能包含脏数据。路径指针需显式置空，避免后续误判

确保数组初始状态明确（所有元素为 NULL）

    if (ngx_array_init(&cycle->config_dump, pool, 1, sizeof(ngx_conf_dump_t))!= NGX_OK){ngx_destroy_pool(pool);return NULL;}

初始化数组 config_dump，用于存储配置转储条目

使用内存池 pool 分配内存，初始容量为 1，每个元素大小为 ngx_conf_dump_t

若初始化失败（返回 NGX_ERROR），销毁内存池并终止初始化。

Ubuntu 下 nginx-1.24.0 源码分析 - ngx_conf_dump_t-CSDN博客

    ngx_rbtree_init(&cycle->config_dump_rbtree, &cycle->config_dump_sentinel,ngx_str_rbtree_insert_value);

初始化红黑树 config_dump_rbtree，用于快速查找和去重

根节点为 config_dump_rbtree，哨兵节点为 config_dump_sentinel。
使用 ngx_str_rbtree_insert_value 作为插入回调，按字符串键排序。
 


Ubuntu 下 nginx-1.24.0 源码分析 - ngx_rbtree_init-CSDN博客

Ubuntu 下 nginx-1.24.0 源码分析 - ngx_str_rbtree_insert_value-CSDN博客

ngx_array_t config_dump

存储配置条目

动态数组，存储 ngx_conf_dump_t 结构体

ngx_rbtree_t config_dump_rbtree

索引配置条目，加速查找与去重

红黑树键值为配置名称（ngx_str_t），节点数据指向 config_dump 数组素


                
        

以 ngx_conf_dump_t.name（配置块名称）作为红黑树的键，通过 ngx_str_rbtree_insert_value 回调按字符串排序。


功能分离：
数组存储数据，红黑树管理索引，职责清晰。

   if (old_cycle->open_files.part.nelts) {n = old_cycle->open_files.part.nelts;for (part = old_cycle->open_files.part.next; part; part = part->next) {n += part->nelts;}} else {n = 20;}

open_files 存储 nginx 运行时需持久打开的文件（如日志文件、共享内存文件）。

在平滑重启或重新配置时，新周期需继承这些文件以避免频繁打开/关闭。

判断旧cycle（old_cycle）的open_files链表的第一个节点（part）是否有元素

open_files是ngx_list_t类型，内部由多个ngx_list_part_t节点组成，每个节点包含多个元素。

Ubuntu 下 nginx-1.24.0 源码分析 - ngx_list_t-CSDN博客

如果旧cycle的open_files存在元素，进入计算总元素数的逻辑

初始化容量 n 为旧周期文件数量

获取旧周期 open_files 列表第一个分片（part）的元素数量。

ngx_list_t 是分片链表结构，每个分片（part）包含 nelts 个元素。
此处初始化 n 为第一个分片的元素数。

遍历旧周期 open_files 的所有分片，累加总元素数到 n。

ngx_list_t 可能包含多个分片（如元素数量超过单个分片容量），需遍历所有分片统计总数。

若旧周期无文件，设置初始容量 n = 20。

if (ngx_list_init(&cycle->open_files, pool, n, sizeof(ngx_open_file_t))!= NGX_OK){ngx_destroy_pool(pool);return NULL;}

初始化新周期的 open_files 列表。

pool：内存池，用于管理列表内存。

n：初始容量（继承旧文件数或默认 20）。

sizeof(ngx_open_file_t)：每个元素的大小（文件描述符结构）。

Ubuntu 下 nginx-1.24.0 源码分析 - ngx_list_init-CSDN博客

    if (old_cycle->shared_memory.part.nelts) {n = old_cycle->shared_memory.part.nelts;for (part = old_cycle->shared_memory.part.next; part; part = part->next){n += part->nelts;}} else {n = 1;}

判断旧周期（old_cycle）的共享内存列表是否非空。
shared_memory 存储 nginx 的共享内存区域
在平滑重启或重新配置时，新周期需继承这些区域以避免重复创建。

获取旧周期共享内存列表第一个分片（part）的元素数量

ngx_list_t 是分片链表结构，每个分片（part）包含 nelts 个元素。此处初始化 n 为第一个分片的元素数。

遍历旧周期 shared_memory 的所有分片，累加总元素数到 n。

ngx_list_t 可能包含多个分片（如元素数量超过单个分片容量），需遍历所有分片统计总数。

若旧周期无共享内存，设置初始容量 n = 1。

  if (ngx_list_init(&cycle->shared_memory, pool, n, sizeof(ngx_shm_zone_t))!= NGX_OK){ngx_destroy_pool(pool);return NULL;}

初始化新周期的 shared_memory 列表。

   n = old_cycle->listening.nelts ? old_cycle->listening.nelts : 10;

根据旧周期（old_cycle）的监听套接字数量设置新周期的初始容量 n。
若旧周期无监听套接字，则默认预分配 10 个元素。

old_cycle->listening.nelts 是旧周期监听数组的元素数量。
若存在旧监听套接字，继承其数量；否则使用默认值 10。
监听数组（listening）存储 Nginx 监听的端口和套接字信息（如 listen 80;）。

在 Nginx 启动时，所有监听套接字会被初始化并集中存储到 cycle->listening 数组中，方便后续统一操作（如绑定、监听、关闭）。

初始化阶段：在 ngx_init_cycle() 函数中，Nginx 会遍历 cycle->listening 数组，为每个监听创建套接字并设置为监听状态。

平滑重启：当配置文件更改时，Nginx 可以平滑地切换到新配置，而不中断当前连接。

这需要能够比较新旧配置中的监听端口，cycle->listening 提供了这种能力

  if (ngx_array_init(&cycle->listening, pool, n, sizeof(ngx_listening_t))!= NGX_OK){ngx_destroy_pool(pool);return NULL;}

初始化 cycle->listening 数组

    ngx_memzero(cycle->listening.elts, n * sizeof(ngx_listening_t));

将监听数组的前 n 个元素清零。

ngx_memzero 是 memset 的封装，确保内存初始化为 0

动态数组分配的内存可能包含脏数据，直接使用可能导致未定义行为（如误判套接字状态）

   ngx_queue_init(&cycle->reusable_connections_queue);

初始化可重用连接队列：
将 cycle->reusable_connections_queue 初始化为一个空的双向链表（队列），用于管理可重用的空闲连接（ngx_connection_t）。

ngx_queue_t 是 Nginx 的双向链表节点结构

ngx_queue_init(q) 宏会将队列的 prev 和 next 指针均指向自身，表示队列为空。

队列用途：
reusable_connections_queue 存储当前未被使用的连接对象（如已关闭的 TCP 连接），这些连接可被重新分配以避免频繁创建/销毁的开销。

频繁调用 accept() 创建新连接会导致性能下降，而重用空闲连接可显著降低延迟。

资源复用：
当连接关闭时，Nginx 不会立即释放其资源（如套接字、内存），而是将其放入 reusable_connections_queue，等待后续请求复用。

在内存紧张时，可通过调整队列大小（worker_connections）动态平衡资源。

Ubuntu 下 nginx-1.24.0 源码分析 - ngx_queue_init-CSDN博客

    cycle->conf_ctx = ngx_pcalloc(pool, ngx_max_module * sizeof(void *));if (cycle->conf_ctx == NULL) {ngx_destroy_pool(pool);return NULL;}

从内存池 pool 中分配一个指针数组 conf_ctx，每个元素对应一个模块的配置结构指针。

ngx_max_module：编译时确定的模块总数

sizeof(void *)：每个指针的大小

数组长度为 ngx_max_module，索引为模块的唯一标识符（module->index）。

若内存分配失败，销毁内存池并终止初始化。

Ubuntu 下 nginx-1.24.0 源码分析 - conf_ctx-CSDN博客

    if (gethostname(hostname, NGX_MAXHOSTNAMELEN) == -1) {ngx_log_error(NGX_LOG_EMERG, log, ngx_errno, "gethostname() failed");ngx_destroy_pool(pool);return NULL;}

调用 gethostname() 系统调用获取本地主机名，存储到 hostname 缓冲区。

缓冲区大小为 NGX_MAXHOSTNAMELEN

若调用失败（返回 -1），记录致命错误（NGX_LOG_EMERG），销毁内存池并终止初始化。

gethostname-CSDN博客

    hostname[NGX_MAXHOSTNAMELEN - 1] = '\0';cycle->hostname.len = ngx_strlen(hostname);

确保 hostname 以 \0 结尾，避免未终止字符串导致的安全风险。

Linux 的 gethostname() 在缓冲区不足时静默截断，但不会添加 \0。
手动设置最后一个字节为 \0，确保字符串合法性。

计算主机名的实际长度（不含终止符），存储到 cycle->hostname.len

    cycle->hostname.data = ngx_pnalloc(pool, cycle->hostname.len);if (cycle->hostname.data == NULL) {ngx_destroy_pool(pool);return NULL;}

从内存池 pool 分配内存，存储主机名的副本

ngx_pnalloc 分配指定长度的内存
若分配失败，销毁内存池并终止初始化。

    ngx_strlow(cycle->hostname.data, (u_char *) hostname, cycle->hostname.len);

将主机名转换为全小写，存储到 cycle->hostname.data。

ngx_strlow 是 Nginx 的封装函数，逐字符转换为小写。

主机名在 DNS 和 HTTP 协议中通常不区分大小写，统一格式避免配置或路由问题。

统一小写格式，简化后续比较和匹配逻辑（如虚拟主机配置）。

    if (ngx_cycle_modules(cycle) != NGX_OK) {ngx_destroy_pool(pool);return NULL;}

调用 ngx_cycle_modules 初始化 cycle->modules 数组，该数组包含所有核心模块的指针。

Nginx 模块分为核心模块（NGX_CORE_MODULE）、事件模块、HTTP 模块等。

ngx_cycle_modules 会遍历全局模块列表（ngx_modules），筛选出核心模块并按优先级排序。
若模块初始化失败（如内存不足），立即回滚资源。

Ubuntu 下 nginx-1.24.0 源码分析 - ngx_cycle_modules-CSDN博客

    for (i = 0; cycle->modules[i]; i++) {if (cycle->modules[i]->type != NGX_CORE_MODULE) {continue;}

遍历所有核心模块

Ubuntu 下 nginx-1.24.0 源码分析 - cycle-＞modules[i]-＞type-CSDN博客

module = cycle->modules[i]->ctx;

获取核心模块的配置

module 的类型是：

ngx_core_module_t   *module;

Ubuntu 下 nginx-1.24.0 源码分析 - cycle-＞modules[i]-＞ctx-CSDN博客

Ubuntu 下 nginx-1.24.0 源码分析 - ngx_core_module_t-CSDN博客


 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/bicheng/72935.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

qt 操作多个sqlite文件

qt 操作多个sqlite文件

qt 操作多个sqlite文件 Chapter1 qt 操作多个sqlite文件1. 引入必要的头文件2. 创建并连接多个SQLite数据库3. 代码说明4. 注意事项 Chapter2 qt 多线程操作sqlite多文件1. 引入必要的头文件2. 创建数据库操作的工作线程类3. 在主线程中创建并启动多个工作线程4. 代码说明5. 运…
阅读更多...
最新版本WebContext构造函数-避坑

最新版本WebContext构造函数-避坑

import org.thymeleaf.context.IWebContext; import org.thymeleaf.context.WebContext; 当你想把页面信息全部获取出来存到redis缓存中使用时&#xff0c;SpringWebContext在Spring5中报错 SpringWebContext ctx new SpringWebContext(request, response,request.getServlet…
阅读更多...
用Python分割并高效处理PDF大文件

用Python分割并高效处理PDF大文件

在处理大型PDF文件时&#xff0c;将它们分解成更小、更易于管理的块通常是有益的。这个过程称为分区&#xff0c;它可以提高处理效率&#xff0c;并使分析或操作文档变得更容易。在本文中&#xff0c;我们将讨论如何使用Python和为Unstructured.io库将PDF文件划分为更小的部分。…
阅读更多...
neo4j随笔-将csv文件导入知识图谱

neo4j随笔-将csv文件导入知识图谱

目录 导入前的准备 导入csv文件 导入nodes1.1.csv并动态为节点添加标签 ​编辑导入relations1.1.csv并动态为关系添加标签 结果 导入前的准备 我有两个csv文件 nodes1.1.csv存放节点信息,用记事本打开&#xff0c;能正常显示&#xff0c;且编码为UTF-8&#xff0c;就可以…
阅读更多...
cpu 多级缓存L1、L2、L3 与主存关系

cpu 多级缓存L1、L2、L3 与主存关系

现代 CPU 的多级缓存&#xff08;L1、L2、L3&#xff09;和主存&#xff08;DRAM&#xff09;构成了一个层次化的内存系统&#xff0c;旨在通过减少内存访问延迟和提高数据访问速度来优化计算性能。以下是对多级缓存和主存的详细解析&#xff1a; 1. 缓存层次结构 现代 CPU 通…
阅读更多...
C++：入门详解（关于C与C++基本差别）

C++：入门详解（关于C与C++基本差别）

目录 一.C的第一个程序 二.命名空间&#xff08;namespace&#xff09; 1.命名空间的定义与使用&#xff1a; &#xff08;1&#xff09;命名空间里可以定义变量&#xff0c;函数&#xff0c;结构体等多种类型 &#xff08;2&#xff09;命名空间调用&#xff08;&#xf…
阅读更多...
Python的学习篇（七）--网页结构

Python的学习篇（七）--网页结构

七、网页&#xff08;HTML&#xff09;结构 7.1 HTML介绍 HTML(Hyper Text Markup Language)&#xff0c;超文本标记语言。 超文本&#xff1a;比文本的功能要强大&#xff0c;通过链接和交互式的方式来组织与呈现信息的文本形式。不仅仅有文本&#xff0c;还可以包含图片、…
阅读更多...
*VulnHub-FristiLeaks:1.3暴力解法、细节解法，主打软硬都吃，隧道搭建、寻找exp、提权、只要你想没有做不到的姿势

*VulnHub-FristiLeaks:1.3暴力解法、细节解法，主打软硬都吃，隧道搭建、寻找exp、提权、只要你想没有做不到的姿势

*VulnHub-FristiLeaks:1.3暴力解法、细节解法&#xff0c;主打软硬都吃&#xff0c;隧道搭建、寻找exp、提权、只要你想没有做不到的姿势 一、信息收集 1、扫靶机ip 经典第一步&#xff0c;扫一下靶机ip arp-scan -l 扫描同网段 nmap -sP 192.168.122.0/242、指纹扫描、端口…
阅读更多...
PHP:格式化JSON为PHP语法格式

PHP:格式化JSON为PHP语法格式

1. 原生函数 $arr [1,2,3,4]; $str var_export($a,true); var_dump($str); 2. 自定义方法 class Export{private static $space;private static function do($a, string $prev){$res ;$next $prev . self::$space;if (is_array($a)) {$res . [;foreach ($a as $k > $…
阅读更多...
【Python 数据结构 9.树】

【Python 数据结构 9.树】

我装作漠视一切&#xff0c;其实我在乎的太多&#xff0c;但我知道抓得越紧越容易失去 —— 25.3.6 一、树的基本概念 1.树的定义 树是n个结点的有限集合&#xff0c;n0时为空树。当n大于0的时候&#xff0c;满足如下两个条件&#xff1a; ① 有且仅有一个特定的结点&#xff…
阅读更多...
pyqt联合designer的运用和设置

pyqt联合designer的运用和设置

PyQt Designer 简介 PyQt Designer 是一个用于创建和设计 PyQt 应用程序用户界面的可视化工具。它允许用户通过拖放方式添加和排列各种控件，如按钮、文本框、滑块等，并设置它们的属性和样式，从而快速构建出美观且功能完整的 UI 界面。 Windows版本：【免费】安装包别管啊啊…
阅读更多...
纯html文件实现目录和文档关联

纯html文件实现目录和文档关联

目录结构 效果图 代码 <!DOCTYPE html> <html lang"en"><head><meta charset"UTF-8"><title>项目结题报告</title><style lang"scss">::-webkit-scrollbar {width: 6px;height: 6px;}::-webkit-scro…
阅读更多...
python用户图形界面wxpython库安装与使用

python用户图形界面wxpython库安装与使用

要开始使用 wxPython 库来创建 Python 用户图形界面&#xff0c;首先需要安装这个库。在大多数情况下&#xff0c;你可以通过 pip 来安装 wxPython。下面我会指导你完成安装过程&#xff0c;并给出一个简单的例子来展示如何使用 wxPython 创建一个基本的窗口应用程序。 安装 w…
阅读更多...
MongoDB winx64 msi包安装详细教程

MongoDB winx64 msi包安装详细教程

首先我们可以从官网上选择对应版本和对应的包类型进行安装&#xff1a; 下载地址&#xff1a;Download MongoDB Community Server | MongoDB 这里可以根据自己的需求&#xff0c; 这里我选择的是8.0.5 msi的版本&#xff0c;采用的传统装软件的方式安装。无需配置命令。 下载…
阅读更多...
如何借助 ArcGIS Pro 高效统计基站 10km 范围内的村庄数量？

如何借助 ArcGIS Pro 高效统计基站 10km 范围内的村庄数量？

在当今数字化时代&#xff0c;地理信息系统&#xff08;GIS&#xff09;技术在各个领域都发挥着重要作用。 特别是在通信行业&#xff0c;对于基站周边覆盖范围内的地理信息分析&#xff0c;能够帮助我们更好地进行网络规划、资源分配以及市场分析等工作。 今天&#xff0c;就…
阅读更多...
saltstack通过master下发脚本批量修改minion_id，修改为IP

saltstack通过master下发脚本批量修改minion_id，修改为IP

通过master下发脚本批量修改minion_id&#xff0c;以修改为IP为例 通过cmd.script远程执行shell脚本修改minion_id&#xff0c;步骤如下: # 下发脚本并执行 >> salt old_minion_id cmd.script salt://modify_minion_id.sh saltenvdev #输出结果 old_minion_id:Minion di…
阅读更多...
【大模型】WPS 接入 DeepSeek-R1详解，打造全能AI办公助手

【大模型】WPS 接入 DeepSeek-R1详解，打造全能AI办公助手

目录 一、前言 二、WPS接入AI工具优势​​​​​​​ 三、WPS接入AI工具两种方式 3.1 手动配置的方式 3.2 Office AI助手 四、WPS手动配置方式接入AI大模型 4.1 安装VBA插件 4.1.1 下载VBA插件并安装 4.2 配置WPS 4.3 WPS集成VB 4.4 AI助手效果测试 4.5 配置模板文…
阅读更多...
《苍穹外卖》SpringBoot后端开发项目重点知识整理（DAY1 to DAY3）

《苍穹外卖》SpringBoot后端开发项目重点知识整理（DAY1 to DAY3）

目录 一、在本地部署并启动Nginx服务1. 解压Nginx压缩包2. 启动Nginx服务3. 验证Nginx是否启动成功&#xff1a; 二、导入接口文档1. 黑马程序员提供的YApi平台2. YApi Pro平台3. 推荐工具&#xff1a;Apifox 三、Swagger1. 常用注解1.1 Api与ApiModel1.2 ApiModelProperty与Ap…
阅读更多...
Mysql5.7-yum安装和更改mysql数据存放路径-2020年记录

Mysql5.7-yum安装和更改mysql数据存放路径-2020年记录

记录下官网里用yum rpm源安装mysql, 1 官网下载rpm https://dev.mysql.com/downloads/repo/yum/ https://dev.mysql.com/doc/refman/5.7/en/linux-installation-yum-repo.html&#xff08;附官网操作手册&#xff09; wget https://repo.mysql.com//mysql80-community-release…
阅读更多...
HTML5(Web前端开发笔记第一期)

HTML5(Web前端开发笔记第一期)

p.s.这是萌新自己自学总结的笔记&#xff0c;如果想学习得更透彻的话还是请去看大佬的讲解 目录 三件套标签标题标签段落标签文本格式化标签图像标签超链接标签锚点链接默认链接地址 音频标签视频标签 HTML基本骨架综合案例->个人简介列表表格表单input标签单选框radio上传…
阅读更多...
最新文章

Copyright @ 2022~2023