/*
* Copyright (C) Igor Sysoev
* Copyright (C) Nginx, Inc.
*/
#include <ngx_config.h>
#include <ngx_core.h>
#include <ngx_event.h>
#include <nginx.h>
static void ngx_console_init(ngx_cycle_t *cycle);
static int __stdcall ngx_console_handler(u_long type);
static ngx_int_t ngx_create_signal_events(ngx_cycle_t *cycle);
static ngx_int_t ngx_start_worker_processes(ngx_cycle_t *cycle, ngx_int_t type);
static void ngx_reopen_worker_processes(ngx_cycle_t *cycle);
static void ngx_quit_worker_processes(ngx_cycle_t *cycle, ngx_uint_t old);
static void ngx_terminate_worker_processes(ngx_cycle_t *cycle);
static ngx_uint_t ngx_reap_worker(ngx_cycle_t *cycle, HANDLE h);
static void ngx_master_process_exit(ngx_cycle_t *cycle);
static void ngx_worker_process_cycle(ngx_cycle_t *cycle, char *mevn);
static void ngx_worker_process_exit(ngx_cycle_t *cycle);
static ngx_thread_value_t __stdcall ngx_worker_thread(void *data);
static ngx_thread_value_t __stdcall ngx_cache_manager_thread(void *data);
static void ngx_cache_manager_process_handler(void);
static ngx_thread_value_t __stdcall ngx_cache_loader_thread(void *data);
ngx_uint_t ngx_process;
ngx_uint_t ngx_worker;
ngx_pid_t ngx_pid;
ngx_pid_t ngx_parent;
ngx_uint_t ngx_inherited;
ngx_pid_t ngx_new_binary;
sig_atomic_t ngx_terminate;
sig_atomic_t ngx_quit;
sig_atomic_t ngx_reopen;
sig_atomic_t ngx_reconfigure;
ngx_uint_t ngx_exiting;
HANDLE ngx_master_process_event;
char ngx_master_process_event_name[NGX_PROCESS_SYNC_NAME];
static HANDLE ngx_stop_event;
static char ngx_stop_event_name[NGX_PROCESS_SYNC_NAME];
static HANDLE ngx_quit_event;
static char ngx_quit_event_name[NGX_PROCESS_SYNC_NAME];
static HANDLE ngx_reopen_event;
static char ngx_reopen_event_name[NGX_PROCESS_SYNC_NAME];
static HANDLE ngx_reload_event;
static char ngx_reload_event_name[NGX_PROCESS_SYNC_NAME];
HANDLE ngx_cache_manager_mutex;
char ngx_cache_manager_mutex_name[NGX_PROCESS_SYNC_NAME];
HANDLE ngx_cache_manager_event;
void
ngx_master_process_cycle(ngx_cycle_t *cycle)
{
u_long nev, ev, timeout;
ngx_err_t err;
ngx_int_t n;
ngx_msec_t timer;
ngx_uint_t live;
HANDLE events[MAXIMUM_WAIT_OBJECTS];
ngx_sprintf((u_char *) ngx_master_process_event_name,
"ngx_master_%s%Z", ngx_unique);
if (ngx_process == NGX_PROCESS_WORKER) {
ngx_worker_process_cycle(cycle, ngx_master_process_event_name);
return;
}
ngx_log_debug0(NGX_LOG_DEBUG_CORE, cycle->log, 0, "master started");
ngx_console_init(cycle);
SetEnvironmentVariable("ngx_unique", ngx_unique);
ngx_master_process_event = CreateEvent(NULL, 1, 0,
ngx_master_process_event_name);
if (ngx_master_process_event == NULL) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"CreateEvent(\"%s\") failed",
ngx_master_process_event_name);
exit(2);
}
if (ngx_create_signal_events(cycle) != NGX_OK) {
exit(2);
}
ngx_sprintf((u_char *) ngx_cache_manager_mutex_name,
"ngx_cache_manager_mutex_%s%Z", ngx_unique);
ngx_cache_manager_mutex = CreateMutex(NULL, 0,
ngx_cache_manager_mutex_name);
if (ngx_cache_manager_mutex == NULL) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"CreateMutex(\"%s\") failed", ngx_cache_manager_mutex_name);
exit(2);
}
events[0] = ngx_stop_event;
events[1] = ngx_quit_event;
events[2] = ngx_reopen_event;
events[3] = ngx_reload_event;
ngx_close_listening_sockets(cycle);
if (ngx_start_worker_processes(cycle, NGX_PROCESS_RESPAWN) == 0) {
exit(2);
}
timer = 0;
timeout = INFINITE;
for ( ;; ) {
nev = 4;
for (n = 0; n < ngx_last_process; n++) {
if (ngx_processes[n].handle) {
events[nev++] = ngx_processes[n].handle;
}
}
if (timer) {
timeout = timer > ngx_current_msec ? timer - ngx_current_msec : 0;
}
ev = WaitForMultipleObjects(nev, events, 0, timeout);
err = ngx_errno;
ngx_time_update();
ngx_log_debug1(NGX_LOG_DEBUG_CORE, cycle->log, 0,
"master WaitForMultipleObjects: %ul", ev);
if (ev == WAIT_OBJECT_0) {
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");
if (ResetEvent(ngx_stop_event) == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"ResetEvent(\"%s\") failed", ngx_stop_event_name);
}
if (timer == 0) {
timer = ngx_current_msec + 5000;
}
ngx_terminate = 1;
ngx_quit_worker_processes(cycle, 0);
continue;
}
if (ev == WAIT_OBJECT_0 + 1) {
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "shutting down");
if (ResetEvent(ngx_quit_event) == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"ResetEvent(\"%s\") failed", ngx_quit_event_name);
}
ngx_quit = 1;
ngx_quit_worker_processes(cycle, 0);
continue;
}
if (ev == WAIT_OBJECT_0 + 2) {
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reopening logs");
if (ResetEvent(ngx_reopen_event) == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"ResetEvent(\"%s\") failed",
ngx_reopen_event_name);
}
ngx_reopen_files(cycle, -1);
ngx_reopen_worker_processes(cycle);
continue;
}
if (ev == WAIT_OBJECT_0 + 3) {
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "reconfiguring");
if (ResetEvent(ngx_reload_event) == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"ResetEvent(\"%s\") failed",
ngx_reload_event_name);
}
cycle = ngx_init_cycle(cycle);
if (cycle == NULL) {
cycle = (ngx_cycle_t *) ngx_cycle;
continue;
}
ngx_cycle = cycle;
ngx_close_listening_sockets(cycle);
if (ngx_start_worker_processes(cycle, NGX_PROCESS_JUST_RESPAWN)) {
ngx_quit_worker_processes(cycle, 1);
}
continue;
}
if (ev > WAIT_OBJECT_0 + 3 && ev < WAIT_OBJECT_0 + nev) {
ngx_log_debug0(NGX_LOG_DEBUG_CORE, cycle->log, 0, "reap worker");
live = ngx_reap_worker(cycle, events[ev]);
if (!live && (ngx_terminate || ngx_quit)) {
ngx_master_process_exit(cycle);
}
continue;
}
if (ev == WAIT_TIMEOUT) {
ngx_terminate_worker_processes(cycle);
ngx_master_process_exit(cycle);
}
if (ev == WAIT_FAILED) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
"WaitForMultipleObjects() failed");
continue;
}
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"WaitForMultipleObjects() returned unexpected value %ul", ev);
}
}
static void
ngx_console_init(ngx_cycle_t *cycle)
{
ngx_core_conf_t *ccf;
ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
if (ccf->daemon) {
if (FreeConsole() == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"FreeConsole() failed");
}
return;
}
if (SetConsoleCtrlHandler(ngx_console_handler, 1) == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"SetConsoleCtrlHandler() failed");
}
}
static int __stdcall
ngx_console_handler(u_long type)
{
char *msg;
switch (type) {
case CTRL_C_EVENT:
msg = "Ctrl-C pressed, exiting";
break;
case CTRL_BREAK_EVENT:
msg = "Ctrl-Break pressed, exiting";
break;
case CTRL_CLOSE_EVENT:
msg = "console closing, exiting";
break;
case CTRL_LOGOFF_EVENT:
msg = "user logs off, exiting";
break;
default:
return 0;
}
ngx_log_error(NGX_LOG_NOTICE, ngx_cycle->log, 0, msg);
if (ngx_stop_event == NULL) {
return 1;
}
if (SetEvent(ngx_stop_event) == 0) {
ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, 0,
"SetEvent(\"%s\") failed", ngx_stop_event_name);
}
return 1;
}
static ngx_int_t
ngx_create_signal_events(ngx_cycle_t *cycle)
{
ngx_sprintf((u_char *) ngx_stop_event_name,
"Global\\ngx_stop_%s%Z", ngx_unique);
ngx_stop_event = CreateEvent(NULL, 1, 0, ngx_stop_event_name);
if (ngx_stop_event == NULL) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"CreateEvent(\"%s\") failed", ngx_stop_event_name);
return NGX_ERROR;
}
ngx_sprintf((u_char *) ngx_quit_event_name,
"Global\\ngx_quit_%s%Z", ngx_unique);
ngx_quit_event = CreateEvent(NULL, 1, 0, ngx_quit_event_name);
if (ngx_quit_event == NULL) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"CreateEvent(\"%s\") failed", ngx_quit_event_name);
return NGX_ERROR;
}
ngx_sprintf((u_char *) ngx_reopen_event_name,
"Global\\ngx_reopen_%s%Z", ngx_unique);
ngx_reopen_event = CreateEvent(NULL, 1, 0, ngx_reopen_event_name);
if (ngx_reopen_event == NULL) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"CreateEvent(\"%s\") failed", ngx_reopen_event_name);
return NGX_ERROR;
}
ngx_sprintf((u_char *) ngx_reload_event_name,
"Global\\ngx_reload_%s%Z", ngx_unique);
ngx_reload_event = CreateEvent(NULL, 1, 0, ngx_reload_event_name);
if (ngx_reload_event == NULL) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"CreateEvent(\"%s\") failed", ngx_reload_event_name);
return NGX_ERROR;
}
return NGX_OK;
}
static ngx_int_t
ngx_start_worker_processes(ngx_cycle_t *cycle, ngx_int_t type)
{
ngx_int_t n;
ngx_core_conf_t *ccf;
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "start worker processes");
ccf = (ngx_core_conf_t *) ngx_get_conf(cycle->conf_ctx, ngx_core_module);
for (n = 0; n < ccf->worker_processes; n++) {
if (ngx_spawn_process(cycle, "worker", type) == NGX_INVALID_PID) {
break;
}
}
return n;
}
static void
ngx_reopen_worker_processes(ngx_cycle_t *cycle)
{
ngx_int_t n;
for (n = 0; n < ngx_last_process; n++) {
if (ngx_processes[n].handle == NULL) {
continue;
}
if (SetEvent(ngx_processes[n].reopen) == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"SetEvent(\"%s\") failed",
ngx_processes[n].reopen_event);
}
}
}
static void
ngx_quit_worker_processes(ngx_cycle_t *cycle, ngx_uint_t old)
{
ngx_int_t n;
for (n = 0; n < ngx_last_process; n++) {
ngx_log_debug5(NGX_LOG_DEBUG_CORE, cycle->log, 0,
"process: %d %P %p e:%d j:%d",
n,
ngx_processes[n].pid,
ngx_processes[n].handle,
ngx_processes[n].exiting,
ngx_processes[n].just_spawn);
if (old && ngx_processes[n].just_spawn) {
ngx_processes[n].just_spawn = 0;
continue;
}
if (ngx_processes[n].handle == NULL) {
continue;
}
if (SetEvent(ngx_processes[n].quit) == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"SetEvent(\"%s\") failed",
ngx_processes[n].quit_event);
}
ngx_processes[n].exiting = 1;
}
}
static void
ngx_terminate_worker_processes(ngx_cycle_t *cycle)
{
ngx_int_t n;
for (n = 0; n < ngx_last_process; n++) {
if (ngx_processes[n].handle == NULL) {
continue;
}
if (TerminateProcess(ngx_processes[n].handle, 0) == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"TerminateProcess(\"%p\") failed",
ngx_processes[n].handle);
}
ngx_processes[n].exiting = 1;
ngx_close_handle(ngx_processes[n].reopen);
ngx_close_handle(ngx_processes[n].quit);
ngx_close_handle(ngx_processes[n].term);
ngx_close_handle(ngx_processes[n].handle);
}
}
static ngx_uint_t
ngx_reap_worker(ngx_cycle_t *cycle, HANDLE h)
{
u_long code;
ngx_int_t n;
for (n = 0; n < ngx_last_process; n++) {
if (ngx_processes[n].handle != h) {
continue;
}
if (GetExitCodeProcess(h, &code) == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"GetExitCodeProcess(%P) failed",
ngx_processes[n].pid);
}
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0,
"%s process %P exited with code %Xl",
ngx_processes[n].name, ngx_processes[n].pid, code);
ngx_close_handle(ngx_processes[n].reopen);
ngx_close_handle(ngx_processes[n].quit);
ngx_close_handle(ngx_processes[n].term);
ngx_close_handle(h);
ngx_processes[n].handle = NULL;
ngx_processes[n].term = NULL;
ngx_processes[n].quit = NULL;
ngx_processes[n].reopen = NULL;
if (!ngx_processes[n].exiting && !ngx_terminate && !ngx_quit) {
if (ngx_spawn_process(cycle, ngx_processes[n].name, n)
== NGX_INVALID_PID)
{
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"could not respawn %s", ngx_processes[n].name);
if (n == ngx_last_process - 1) {
ngx_last_process--;
}
}
}
goto found;
}
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0, "unknown process handle %p", h);
found:
for (n = 0; n < ngx_last_process; n++) {
ngx_log_debug5(NGX_LOG_DEBUG_CORE, cycle->log, 0,
"process: %d %P %p e:%d j:%d",
n,
ngx_processes[n].pid,
ngx_processes[n].handle,
ngx_processes[n].exiting,
ngx_processes[n].just_spawn);
if (ngx_processes[n].handle) {
return 1;
}
}
return 0;
}
static void
ngx_master_process_exit(ngx_cycle_t *cycle)
{
ngx_uint_t i;
ngx_delete_pidfile(cycle);
ngx_close_handle(ngx_cache_manager_mutex);
ngx_close_handle(ngx_stop_event);
ngx_close_handle(ngx_quit_event);
ngx_close_handle(ngx_reopen_event);
ngx_close_handle(ngx_reload_event);
ngx_close_handle(ngx_master_process_event);
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exit");
for (i = 0; cycle->modules[i]; i++) {
if (cycle->modules[i]->exit_master) {
cycle->modules[i]->exit_master(cycle);
}
}
ngx_destroy_pool(cycle->pool);
exit(0);
}
static void
ngx_worker_process_cycle(ngx_cycle_t *cycle, char *mevn)
{
char wtevn[NGX_PROCESS_SYNC_NAME];
char wqevn[NGX_PROCESS_SYNC_NAME];
char wroevn[NGX_PROCESS_SYNC_NAME];
HANDLE mev, events[3];
u_long nev, ev;
ngx_err_t err;
ngx_tid_t wtid, cmtid, cltid;
ngx_log_t *log;
log = cycle->log;
ngx_log_debug0(NGX_LOG_DEBUG_CORE, log, 0, "worker started");
ngx_sprintf((u_char *) wtevn, "ngx_worker_term_%P%Z", ngx_pid);
events[0] = CreateEvent(NULL, 1, 0, wtevn);
if (events[0] == NULL) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
"CreateEvent(\"%s\") failed", wtevn);
goto failed;
}
ngx_sprintf((u_char *) wqevn, "ngx_worker_quit_%P%Z", ngx_pid);
events[1] = CreateEvent(NULL, 1, 0, wqevn);
if (events[1] == NULL) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
"CreateEvent(\"%s\") failed", wqevn);
goto failed;
}
ngx_sprintf((u_char *) wroevn, "ngx_worker_reopen_%P%Z", ngx_pid);
events[2] = CreateEvent(NULL, 1, 0, wroevn);
if (events[2] == NULL) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
"CreateEvent(\"%s\") failed", wroevn);
goto failed;
}
mev = OpenEvent(EVENT_MODIFY_STATE, 0, mevn);
if (mev == NULL) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
"OpenEvent(\"%s\") failed", mevn);
goto failed;
}
if (SetEvent(mev) == 0) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
"SetEvent(\"%s\") failed", mevn);
goto failed;
}
ngx_sprintf((u_char *) ngx_cache_manager_mutex_name,
"ngx_cache_manager_mutex_%s%Z", ngx_unique);
ngx_cache_manager_mutex = OpenMutex(SYNCHRONIZE, 0,
ngx_cache_manager_mutex_name);
if (ngx_cache_manager_mutex == NULL) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
"OpenMutex(\"%s\") failed", ngx_cache_manager_mutex_name);
goto failed;
}
ngx_cache_manager_event = CreateEvent(NULL, 1, 0, NULL);
if (ngx_cache_manager_event == NULL) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"CreateEvent(\"ngx_cache_manager_event\") failed");
goto failed;
}
if (ngx_create_thread(&wtid, ngx_worker_thread, NULL, log) != 0) {
goto failed;
}
if (ngx_create_thread(&cmtid, ngx_cache_manager_thread, NULL, log) != 0) {
goto failed;
}
if (ngx_create_thread(&cltid, ngx_cache_loader_thread, NULL, log) != 0) {
goto failed;
}
for ( ;; ) {
ev = WaitForMultipleObjects(3, events, 0, INFINITE);
err = ngx_errno;
ngx_time_update();
ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0,
"worker WaitForMultipleObjects: %ul", ev);
if (ev == WAIT_OBJECT_0) {
ngx_terminate = 1;
ngx_log_error(NGX_LOG_NOTICE, log, 0, "exiting");
if (ResetEvent(events[0]) == 0) {
ngx_log_error(NGX_LOG_ALERT, log, 0,
"ResetEvent(\"%s\") failed", wtevn);
}
break;
}
if (ev == WAIT_OBJECT_0 + 1) {
ngx_quit = 1;
ngx_log_error(NGX_LOG_NOTICE, log, 0, "gracefully shutting down");
break;
}
if (ev == WAIT_OBJECT_0 + 2) {
ngx_reopen = 1;
ngx_log_error(NGX_LOG_NOTICE, log, 0, "reopening logs");
if (ResetEvent(events[2]) == 0) {
ngx_log_error(NGX_LOG_ALERT, log, 0,
"ResetEvent(\"%s\") failed", wroevn);
}
continue;
}
if (ev == WAIT_FAILED) {
ngx_log_error(NGX_LOG_ALERT, log, err,
"WaitForMultipleObjects() failed");
goto failed;
}
}
/* wait threads */
if (SetEvent(ngx_cache_manager_event) == 0) {
ngx_log_error(NGX_LOG_ALERT, log, ngx_errno,
"SetEvent(\"ngx_cache_manager_event\") failed");
}
events[1] = wtid;
events[2] = cmtid;
nev = 3;
for ( ;; ) {
ev = WaitForMultipleObjects(nev, events, 0, INFINITE);
err = ngx_errno;
ngx_time_update();
ngx_log_debug1(NGX_LOG_DEBUG_CORE, log, 0,
"worker exit WaitForMultipleObjects: %ul", ev);
if (ev == WAIT_OBJECT_0) {
break;
}
if (ev == WAIT_OBJECT_0 + 1) {
if (nev == 2) {
break;
}
events[1] = events[2];
nev = 2;
continue;
}
if (ev == WAIT_OBJECT_0 + 2) {
nev = 2;
continue;
}
if (ev == WAIT_FAILED) {
ngx_log_error(NGX_LOG_ALERT, log, err,
"WaitForMultipleObjects() failed");
break;
}
}
ngx_close_handle(ngx_cache_manager_event);
ngx_close_handle(events[0]);
ngx_close_handle(events[1]);
ngx_close_handle(events[2]);
ngx_close_handle(mev);
ngx_worker_process_exit(cycle);
failed:
exit(2);
}
static ngx_thread_value_t __stdcall
ngx_worker_thread(void *data)
{
ngx_int_t n;
ngx_time_t *tp;
ngx_cycle_t *cycle;
tp = ngx_timeofday();
srand((ngx_pid << 16) ^ (unsigned) tp->sec ^ tp->msec);
cycle = (ngx_cycle_t *) ngx_cycle;
for (n = 0; cycle->modules[n]; n++) {
if (cycle->modules[n]->init_process) {
if (cycle->modules[n]->init_process(cycle) == NGX_ERROR) {
/* fatal */
exit(2);
}
}
}
while (!ngx_quit) {
if (ngx_exiting) {
if (ngx_event_no_timers_left() == NGX_OK) {
break;
}
}
ngx_log_debug0(NGX_LOG_DEBUG_CORE, cycle->log, 0, "worker cycle");
ngx_process_events_and_timers(cycle);
if (ngx_terminate) {
return 0;
}
if (ngx_quit) {
ngx_quit = 0;
if (!ngx_exiting) {
ngx_exiting = 1;
ngx_set_shutdown_timer(cycle);
ngx_close_listening_sockets(cycle);
ngx_close_idle_connections(cycle);
ngx_event_process_posted(cycle, &ngx_posted_events);
}
}
if (ngx_reopen) {
ngx_reopen = 0;
ngx_reopen_files(cycle, -1);
}
}
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");
return 0;
}
static void
ngx_worker_process_exit(ngx_cycle_t *cycle)
{
ngx_uint_t i;
ngx_connection_t *c;
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exit");
for (i = 0; cycle->modules[i]; i++) {
if (cycle->modules[i]->exit_process) {
cycle->modules[i]->exit_process(cycle);
}
}
if (ngx_exiting && !ngx_terminate) {
c = cycle->connections;
for (i = 0; i < cycle->connection_n; i++) {
if (c[i].fd != (ngx_socket_t) -1
&& c[i].read
&& !c[i].read->accept
&& !c[i].read->channel
&& !c[i].read->resolver)
{
ngx_log_error(NGX_LOG_ALERT, cycle->log, 0,
"*%uA open socket #%d left in connection %ui",
c[i].number, c[i].fd, i);
}
}
}
ngx_destroy_pool(cycle->pool);
exit(0);
}
static ngx_thread_value_t __stdcall
ngx_cache_manager_thread(void *data)
{
u_long ev;
HANDLE events[2];
ngx_err_t err;
ngx_cycle_t *cycle;
cycle = (ngx_cycle_t *) ngx_cycle;
events[0] = ngx_cache_manager_event;
events[1] = ngx_cache_manager_mutex;
for ( ;; ) {
ev = WaitForMultipleObjects(2, events, 0, INFINITE);
err = ngx_errno;
ngx_time_update();
ngx_log_debug1(NGX_LOG_DEBUG_CORE, cycle->log, 0,
"cache manager WaitForMultipleObjects: %ul", ev);
if (ev == WAIT_FAILED) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, err,
"WaitForMultipleObjects() failed");
}
/*
* ev == WAIT_OBJECT_0
* ev == WAIT_OBJECT_0 + 1
* ev == WAIT_ABANDONED_0 + 1
*/
if (ngx_terminate || ngx_quit || ngx_exiting) {
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");
return 0;
}
break;
}
for ( ;; ) {
if (ngx_terminate || ngx_quit || ngx_exiting) {
ngx_log_error(NGX_LOG_NOTICE, cycle->log, 0, "exiting");
break;
}
ngx_cache_manager_process_handler();
}
if (ReleaseMutex(ngx_cache_manager_mutex) == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"ReleaseMutex() failed");
}
return 0;
}
static void
ngx_cache_manager_process_handler(void)
{
u_long ev;
ngx_uint_t i;
ngx_msec_t next, n;
ngx_path_t **path;
next = 60 * 60 * 1000;
path = ngx_cycle->paths.elts;
for (i = 0; i < ngx_cycle->paths.nelts; i++) {
if (path[i]->manager) {
n = path[i]->manager(path[i]->data);
next = (n <= next) ? n : next;
ngx_time_update();
}
}
if (next == 0) {
next = 1;
}
ev = WaitForSingleObject(ngx_cache_manager_event, (u_long) next);
if (ev != WAIT_TIMEOUT) {
ngx_time_update();
ngx_log_debug1(NGX_LOG_DEBUG_CORE, ngx_cycle->log, 0,
"cache manager WaitForSingleObject: %ul", ev);
}
}
static ngx_thread_value_t __stdcall
ngx_cache_loader_thread(void *data)
{
ngx_uint_t i;
ngx_path_t **path;
ngx_cycle_t *cycle;
ngx_msleep(60000);
cycle = (ngx_cycle_t *) ngx_cycle;
path = cycle->paths.elts;
for (i = 0; i < cycle->paths.nelts; i++) {
if (ngx_terminate || ngx_quit || ngx_exiting) {
break;
}
if (path[i]->loader) {
path[i]->loader(path[i]->data);
ngx_time_update();
}
}
return 0;
}
void
ngx_single_process_cycle(ngx_cycle_t *cycle)
{
ngx_tid_t tid;
ngx_console_init(cycle);
if (ngx_create_signal_events(cycle) != NGX_OK) {
exit(2);
}
if (ngx_create_thread(&tid, ngx_worker_thread, NULL, cycle->log) != 0) {
/* fatal */
exit(2);
}
/* STUB */
WaitForSingleObject(ngx_stop_event, INFINITE);
}
ngx_int_t
ngx_os_signal_process(ngx_cycle_t *cycle, char *sig, ngx_pid_t pid)
{
HANDLE ev;
ngx_int_t rc;
char evn[NGX_PROCESS_SYNC_NAME];
ngx_sprintf((u_char *) evn, "Global\\ngx_%s_%P%Z", sig, pid);
ev = OpenEvent(EVENT_MODIFY_STATE, 0, evn);
if (ev == NULL) {
ngx_log_error(NGX_LOG_ERR, cycle->log, ngx_errno,
"OpenEvent(\"%s\") failed", evn);
return 1;
}
if (SetEvent(ev) == 0) {
ngx_log_error(NGX_LOG_ALERT, cycle->log, ngx_errno,
"SetEvent(\"%s\") failed", evn);
rc = 1;
} else {
rc = 0;
}
ngx_close_handle(ev);
return rc;
}
void
ngx_close_handle(HANDLE h)
{
if (CloseHandle(h) == 0) {
ngx_log_error(NGX_LOG_ALERT, ngx_cycle->log, ngx_errno,
"CloseHandle(%p) failed", h);
}
}
Codebase Browser
nginx