/****************************************************************************** * * * Comments: Get the value of a counter. If it is a rate counter, * * sleep 1 second to get the second raw value. * * * ******************************************************************************/ PDH_STATUS calculate_counter_value(const char *function, const char *counterpath, double *value) { PDH_HQUERY query; PDH_HCOUNTER handle = NULL; PDH_STATUS pdh_status; PDH_RAW_COUNTER rawData, rawData2; PDH_FMT_COUNTERVALUE counterValue; if (ERROR_SUCCESS != (pdh_status = zbx_PdhOpenQuery(function, &query))) return pdh_status; if (ERROR_SUCCESS != (pdh_status = zbx_PdhAddCounter(function, NULL, query, counterpath, &handle))) goto close_query; if (ERROR_SUCCESS != (pdh_status = zbx_PdhCollectQueryData(function, counterpath, query))) goto remove_counter; if (ERROR_SUCCESS != (pdh_status = zbx_PdhGetRawCounterValue(function, counterpath, handle, &rawData))) goto remove_counter; if (PDH_CSTATUS_INVALID_DATA == (pdh_status = PdhCalculateCounterFromRawValue(handle, PDH_FMT_DOUBLE | PDH_FMT_NOCAP100, &rawData, NULL, &counterValue))) { /* some (e.g., rate) counters require two raw values, MSDN lacks documentation */ /* about what happens but tests show that PDH_CSTATUS_INVALID_DATA is returned */ zbx_sleep(1); if (ERROR_SUCCESS == (pdh_status = zbx_PdhCollectQueryData(function, counterpath, query)) && ERROR_SUCCESS == (pdh_status = zbx_PdhGetRawCounterValue(function, counterpath, handle, &rawData2))) { pdh_status = PdhCalculateCounterFromRawValue(handle, PDH_FMT_DOUBLE | PDH_FMT_NOCAP100, &rawData2, &rawData, &counterValue); } } if (ERROR_SUCCESS != pdh_status || (PDH_CSTATUS_VALID_DATA != counterValue.CStatus && PDH_CSTATUS_NEW_DATA != counterValue.CStatus)) { if (ERROR_SUCCESS == pdh_status) pdh_status = counterValue.CStatus; zabbix_log(LOG_LEVEL_DEBUG, "%s(): cannot calculate counter value '%s': %s", function, counterpath, strerror_from_module(pdh_status, L"PDH.DLL")); } else { *value = counterValue.doubleValue; } remove_counter: PdhRemoveCounter(handle); close_query: PdhCloseQuery(query); return pdh_status; }
ZBX_THREAD_ENTRY(listener_thread, args) { int ret, local_request_failed = 0; zbx_sock_t s; assert(args); assert(((zbx_thread_args_t *)args)->args); process_type = ((zbx_thread_args_t *)args)->process_type; server_num = ((zbx_thread_args_t *)args)->server_num; process_num = ((zbx_thread_args_t *)args)->process_num; zabbix_log(LOG_LEVEL_INFORMATION, "%s #%d started [%s #%d]", get_daemon_type_string(daemon_type), server_num, get_process_type_string(process_type), process_num); memcpy(&s, (zbx_sock_t *)((zbx_thread_args_t *)args)->args, sizeof(zbx_sock_t)); zbx_free(args); while (ZBX_IS_RUNNING()) { zbx_setproctitle("listener #%d [waiting for connection]", process_num); if (SUCCEED == (ret = zbx_tcp_accept(&s))) { local_request_failed = 0; /* reset consecutive errors counter */ zbx_setproctitle("listener #%d [processing request]", process_num); if (SUCCEED == (ret = zbx_tcp_check_security(&s, CONFIG_HOSTS_ALLOWED, 0))) process_listener(&s); zbx_tcp_unaccept(&s); } if (SUCCEED == ret || EINTR == zbx_sock_last_error()) continue; zabbix_log(LOG_LEVEL_DEBUG, "failed to accept an incoming connection: %s", zbx_tcp_strerror()); if (local_request_failed++ > 1000) { zabbix_log(LOG_LEVEL_WARNING, "too many failures to accept an incoming connection"); local_request_failed = 0; } if (ZBX_IS_RUNNING()) zbx_sleep(1); } #ifdef _WINDOWS ZBX_DO_EXIT(); zbx_thread_exit(EXIT_SUCCESS); #endif }
void zbx_on_exit() { zabbix_log(LOG_LEVEL_INFORMATION, "zbx_on_exit()"); #if !defined(_WINDOWS) int i = 0; if (threads != NULL) { for ( i = 1; i <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS + CONFIG_DBSYNCER_FORKS + CONFIG_IPMIPOLLER_FORKS; i ++) { if (threads[i]) { kill(threads[i], SIGTERM); threads[i] = (ZBX_THREAD_HANDLE)NULL; } } zbx_free(threads); } #endif /* not _WINDOWS */ #ifdef USE_PID_FILE daemon_stop(); #endif /* USE_PID_FILE */ free_metrics(); zbx_sleep(2); /* wait for all threads closing */ DBconnect(ZBX_DB_CONNECT_EXIT); free_database_cache(); DBclose(); /* zbx_mutex_destroy(&node_sync_access);*/ #ifdef HAVE_OPENIPMI free_ipmi_handler(); #endif zabbix_close_log(); #ifdef HAVE_SQLITE3 php_sem_remove(&sqlite_access); #endif /* HAVE_SQLITE3 */ zabbix_log(LOG_LEVEL_INFORMATION, "ZABBIX Proxy stopped. ZABBIX %s (revision %s).", ZABBIX_VERSION, ZABBIX_REVISION); exit(SUCCEED); }
ZBX_THREAD_ENTRY(listener_thread, args) { int ret, local_request_failed = 0; zbx_sock_t s; assert(args); assert(((zbx_thread_args_t *)args)->args); zabbix_log(LOG_LEVEL_WARNING, "agent #%d started [listener]", ((zbx_thread_args_t *)args)->thread_num); memcpy(&s, (zbx_sock_t *)((zbx_thread_args_t *)args)->args, sizeof(zbx_sock_t)); zbx_free(args); while (ZBX_IS_RUNNING()) { zbx_setproctitle("listener [waiting for connection]"); if (SUCCEED == (ret = zbx_tcp_accept(&s))) { local_request_failed = 0; /* reset consecutive errors counter */ zbx_setproctitle("listener [processing request]"); zabbix_log(LOG_LEVEL_DEBUG, "Processing request."); if (SUCCEED == (ret = zbx_tcp_check_security(&s, CONFIG_HOSTS_ALLOWED, 0))) process_listener(&s); zbx_tcp_unaccept(&s); } if (SUCCEED == ret) continue; zabbix_log(LOG_LEVEL_DEBUG, "Listener error: %s", zbx_tcp_strerror()); if (local_request_failed++ > 1000) { zabbix_log(LOG_LEVEL_WARNING, "Too many consecutive errors on accept() call."); local_request_failed = 0; } if (ZBX_IS_RUNNING()) zbx_sleep(1); } #ifdef _WINDOWS zabbix_log(LOG_LEVEL_INFORMATION, "zabbix_agentd listener stopped"); ZBX_DO_EXIT(); zbx_thread_exit(0); #endif }
ZBX_THREAD_ENTRY(listener_thread, pSock) { int ret, local_request_failed = 0; zbx_sock_t s; assert(pSock); zbx_setproctitle("listener waiting for connection"); zabbix_log( LOG_LEVEL_INFORMATION, "zabbix_agentd listener started"); memcpy(&s, ((zbx_sock_t *)pSock), sizeof(zbx_sock_t)); while(ZBX_IS_RUNNING) { if( SUCCEED == (ret = zbx_tcp_accept(&s)) ) { local_request_failed = 0; /* Reset consecutive errors counter */ zbx_setproctitle("processing request"); zabbix_log(LOG_LEVEL_DEBUG, "Processing request."); if( SUCCEED == (ret = zbx_tcp_check_security(&s, CONFIG_HOSTS_ALLOWED, 0)) ) { process_listener(&s); } zbx_tcp_unaccept(&s); } zbx_setproctitle("listener waiting for connection"); if( SUCCEED == ret ) continue; zabbix_log(LOG_LEVEL_DEBUG, "Listener error: %s", zbx_tcp_strerror()); if (local_request_failed++ > 1000) { zabbix_log( LOG_LEVEL_WARNING, "Too many consecutive errors on accept() call."); local_request_failed = 0; } if(ZBX_IS_RUNNING) zbx_sleep(1); } zabbix_log( LOG_LEVEL_INFORMATION, "zabbix_agentd listener stopped"); ZBX_DO_EXIT(); zbx_tread_exit(0); }
void zbx_on_exit() { zabbix_log(LOG_LEVEL_DEBUG, "zbx_on_exit() called"); if (NULL != threads) { int i; sigset_t set; /* ignore SIGCHLD signals in order for zbx_sleep() to work */ sigemptyset(&set); sigaddset(&set, SIGCHLD); sigprocmask(SIG_BLOCK, &set, NULL); for (i = 0; i < threads_num; i++) { if (threads[i]) { kill(threads[i], SIGTERM); threads[i] = ZBX_THREAD_HANDLE_NULL; } } zbx_free(threads); } free_metrics(); zbx_sleep(2); /* wait for all child processes to exit */ DBconnect(ZBX_DB_CONNECT_EXIT); free_database_cache(); free_configuration_cache(); DBclose(); #ifdef HAVE_OPENIPMI free_ipmi_handler(); #endif #ifdef HAVE_SQLITE3 zbx_remove_sqlite3_mutex(); #endif free_selfmon_collector(); zabbix_log(LOG_LEVEL_INFORMATION, "Zabbix Proxy stopped. Zabbix %s (revision %s).", ZABBIX_VERSION, ZABBIX_REVISION); zabbix_close_log(); exit(SUCCEED); }
void zbx_on_exit() { zabbix_log(LOG_LEVEL_DEBUG, "zbx_on_exit() called"); if (NULL != threads) { int i; #if !defined(_WINDOWS) sigset_t set; /* ignore SIGCHLD signals in order for zbx_sleep() to work */ sigemptyset(&set); sigaddset(&set, SIGCHLD); sigprocmask(SIG_BLOCK, &set, NULL); #endif for (i = 0; i < threads_num; i++) { if (threads[i]) { zbx_thread_kill(threads[i]); threads[i] = ZBX_THREAD_HANDLE_NULL; } } zbx_free(threads); } #ifndef _WINDOWS zbx_sleep(2); /* wait for all processes to exit */ #endif zabbix_log(LOG_LEVEL_INFORMATION, "Zabbix Agent stopped. Zabbix %s (revision %s).", ZABBIX_VERSION, ZABBIX_REVISION); zabbix_close_log(); free_metrics(); alias_list_free(); free_collector_data(); #ifdef _WINDOWS free_perf_collector(); #endif exit(SUCCEED); }
/****************************************************************************** * * * Function: * * * * Purpose: * * * * Parameters: * * * * Return value: * * * * Comments: * * * ******************************************************************************/ ZBX_THREAD_ENTRY(monitor_thread, args) { assert(args); zabbix_log(LOG_LEVEL_INFORMATION, "jobarg_monitor #%d started [monitor]", ((zbx_thread_args_t *) args)->thread_num); zbx_free(args); DBconnect(ZBX_DB_CONNECT_NORMAL); CONFIG_SPAN_TIME = ja_schedule_load_span(); while (ZBX_IS_RUNNING()) { zbx_setproctitle("process monitor"); process_monitor(); zbx_sleep(CONFIG_JAMONITOR_INTERVAL); } zabbix_log(LOG_LEVEL_INFORMATION, "jobarg_monitor stopped"); zbx_thread_exit(0); }
/****************************************************************************** * * * Function: collector_thread * * * * Purpose: Collect system information * * * * Author: Eugene Grigorjev * * * ******************************************************************************/ ZBX_THREAD_ENTRY(collector_thread, args) { assert(args); zabbix_log(LOG_LEVEL_WARNING, "agent #%d started [collector]", ((zbx_thread_args_t *)args)->thread_num); zbx_free(args); if (SUCCEED != init_cpu_collector(&(collector->cpus))) free_cpu_collector(&(collector->cpus)); while (ZBX_IS_RUNNING()) { zbx_setproctitle("collector [processing data]"); #ifdef _WINDOWS collect_perfstat(); #else if (0 != CPU_COLLECTOR_STARTED(collector)) collect_cpustat(&(collector->cpus)); if (0 != DISKDEVICE_COLLECTOR_STARTED(collector)) collect_stats_diskdevices(); #endif #ifdef _AIX if (1 == collector->vmstat.enabled) collect_vmstat_data(&collector->vmstat); #endif zbx_setproctitle("collector [sleeping for 1 seconds]"); zbx_sleep(1); } if (CPU_COLLECTOR_STARTED(collector)) free_cpu_collector(&(collector->cpus)); #ifdef _WINDOWS free_perf_collector(); /* cpu_collector must be freed before perf_collector is freed */ #endif zabbix_log(LOG_LEVEL_INFORMATION, "zabbix_agentd collector stopped"); ZBX_DO_EXIT(); zbx_thread_exit(0); }
/****************************************************************************** * * * Function: * * * * Purpose: * * * * Parameters: * * * * Return value: * * * * Comments: * * * ******************************************************************************/ void zbx_on_exit() { int rc; zabbix_log(LOG_LEVEL_DEBUG, "zbx_on_exit() called"); if (SUCCEED == DBtxn_ongoing()) DBrollback(); if (NULL != threads) { int i; sigset_t set; /* ignore SIGCHLD signals in order for zbx_sleep() to work */ sigemptyset(&set); sigaddset(&set, SIGCHLD); sigprocmask(SIG_BLOCK, &set, NULL); for (i = 0; i < threads_num; i++) { if (threads[i]) { kill(threads[i], SIGTERM); threads[i] = ZBX_THREAD_HANDLE_NULL; } } zbx_free(threads); } zbx_sleep(2); /* wait for all child processes to exit */ ja_free_selfmon_collector(); /* kill the external command */ rc = system("pkill -SIGTERM jobarg_session"); rc = system("pkill -SIGTERM jobarg_command"); ja_log("JASERVER000002", 0, NULL, 0, JOBARG_VERSION, JOBARG_REVISION); zabbix_close_log(); exit(SUCCEED); }
static VOID WINAPI ServiceCtrlHandler(DWORD ctrlCode) { serviceStatus.dwServiceType = SERVICE_WIN32_OWN_PROCESS; serviceStatus.dwCurrentState = SERVICE_RUNNING; serviceStatus.dwControlsAccepted = SERVICE_ACCEPT_STOP | SERVICE_ACCEPT_SHUTDOWN; serviceStatus.dwWin32ExitCode = 0; serviceStatus.dwServiceSpecificExitCode = 0; serviceStatus.dwCheckPoint = 0; serviceStatus.dwWaitHint = 0; switch(ctrlCode) { case SERVICE_CONTROL_STOP: case SERVICE_CONTROL_SHUTDOWN: zabbix_log(LOG_LEVEL_INFORMATION, "Zabbix Agent shutdown requested"); serviceStatus.dwCurrentState = SERVICE_STOP_PENDING; serviceStatus.dwWaitHint = 4000; SetServiceStatus(serviceHandle, &serviceStatus); /* notify other threads and allow them to terminate */ ZBX_DO_EXIT(); zbx_sleep(1); serviceStatus.dwCurrentState = SERVICE_STOPPED; serviceStatus.dwWaitHint = 0; serviceStatus.dwCheckPoint = 0; serviceStatus.dwWin32ExitCode = 0; zabbix_log(LOG_LEVEL_INFORMATION, "Zabbix Agent stopped. Zabbix %s (revision %s).", ZABBIX_VERSION, ZABBIX_REVISION); break; default: break; } SetServiceStatus(serviceHandle, &serviceStatus); }
void zbx_on_exit() { zabbix_log(LOG_LEVEL_DEBUG, "zbx_on_exit() called"); if (SUCCEED == DBtxn_ongoing()) DBrollback(); if (NULL != threads) { int i; sigset_t set; /* ignore SIGCHLD signals in order for zbx_sleep() to work */ sigemptyset(&set); sigaddset(&set, SIGCHLD); sigprocmask(SIG_BLOCK, &set, NULL); for (i = 0; i < threads_num; i++) { if (threads[i]) { kill(threads[i], SIGTERM); threads[i] = ZBX_THREAD_HANDLE_NULL; } } zbx_free(threads); } free_metrics(); zbx_sleep(2); /* wait for all child processes to exit */ DBconnect(ZBX_DB_CONNECT_EXIT); free_database_cache(); DBclose(); free_configuration_cache(); /* free history value cache */ zbx_vc_destroy(); zbx_destroy_itservices_lock(); zbx_mutex_destroy(&node_sync_access); #ifdef HAVE_OPENIPMI free_ipmi_handler(); #endif #ifdef HAVE_SQLITE3 zbx_remove_sqlite3_mutex(); #endif /* free vmware support */ if (0 != CONFIG_VMWARE_FORKS) zbx_vmware_destroy(); free_selfmon_collector(); unload_modules(); zabbix_log(LOG_LEVEL_INFORMATION, "Zabbix Server stopped. Zabbix %s (revision %s).", ZABBIX_VERSION, ZABBIX_REVISION); zabbix_close_log(); #if defined(PS_OVERWRITE_ARGV) setproctitle_free_env(); #endif exit(SUCCEED); }
int MAIN_ZABBIX_ENTRY(void) { int i; pid_t pid; zbx_sock_t listen_sock; int server_num = 0; if(CONFIG_LOG_FILE == NULL) { zabbix_open_log(LOG_TYPE_SYSLOG,CONFIG_LOG_LEVEL,NULL); } else { zabbix_open_log(LOG_TYPE_FILE,CONFIG_LOG_LEVEL,CONFIG_LOG_FILE); } #ifdef HAVE_SNMP # define SNMP_FEATURE_STATUS "YES" #else # define SNMP_FEATURE_STATUS " NO" #endif #ifdef HAVE_LIBCURL # define LIBCURL_FEATURE_STATUS "YES" #else # define LIBCURL_FEATURE_STATUS " NO" #endif #ifdef HAVE_ODBC # define ODBC_FEATURE_STATUS "YES" #else # define ODBC_FEATURE_STATUS " NO" #endif #ifdef HAVE_IPV6 # define IPV6_FEATURE_STATUS "YES" #else # define IPV6_FEATURE_STATUS " NO" #endif zabbix_log( LOG_LEVEL_WARNING, "Starting zabbix_proxy. ZABBIX %s (revision %s).", ZABBIX_VERSION, ZABBIX_REVISION); zabbix_log( LOG_LEVEL_WARNING, "**** Enabled features ****"); zabbix_log( LOG_LEVEL_WARNING, "SNMP monitoring: " SNMP_FEATURE_STATUS ); zabbix_log( LOG_LEVEL_WARNING, "WEB monitoring: " LIBCURL_FEATURE_STATUS ); zabbix_log( LOG_LEVEL_WARNING, "ODBC: " ODBC_FEATURE_STATUS ); zabbix_log( LOG_LEVEL_WARNING, "IPv6 support: " IPV6_FEATURE_STATUS ); zabbix_log( LOG_LEVEL_WARNING, "**************************"); #ifdef HAVE_SQLITE3 if(ZBX_MUTEX_ERROR == php_sem_get(&sqlite_access, CONFIG_DBNAME)) { zbx_error("Unable to create mutex for sqlite"); exit(FAIL); } #endif /* HAVE_SQLITE3 */ DBinit(); init_database_cache(ZBX_PROCESS_PROXY); threads = calloc(1 + CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS + CONFIG_DBSYNCER_FORKS + CONFIG_IPMIPOLLER_FORKS, sizeof(pid_t)); if (CONFIG_TRAPPERD_FORKS > 0) { if (FAIL == zbx_tcp_listen(&listen_sock, CONFIG_LISTEN_IP, (unsigned short)CONFIG_LISTEN_PORT)) { zabbix_log(LOG_LEVEL_CRIT, "Listener failed with error: %s.", zbx_tcp_strerror()); exit(1); } } for ( i = 1; i <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS + CONFIG_DBSYNCER_FORKS + CONFIG_IPMIPOLLER_FORKS; i++) { if ((pid = zbx_fork()) == 0) { server_num = i; break; } else threads[i] = pid; } /* Main process */ if (server_num == 0) { init_main_process(); zabbix_log(LOG_LEVEL_WARNING, "server #%d started [Heartbeat sender]", server_num); main_heart_loop(); for (;;) zbx_sleep(3600); } if (server_num <= CONFIG_CONFSYNCER_FORKS) { zabbix_log(LOG_LEVEL_WARNING, "server #%d started [Configuration syncer]", server_num); main_proxyconfig_loop(server_num); } else if (server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS) { zabbix_log(LOG_LEVEL_WARNING, "server #%d started [Datasender]", server_num); main_datasender_loop(); } else if (server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS) { #ifdef HAVE_SNMP init_snmp("zabbix_server"); #endif /* HAVE_SNMP */ zabbix_log(LOG_LEVEL_WARNING, "server #%d started [Poller. SNMP:"SNMP_FEATURE_STATUS"]", server_num); main_poller_loop(ZBX_PROCESS_PROXY, ZBX_POLLER_TYPE_NORMAL, server_num - (CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS)); } else if (server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS) { zabbix_log(LOG_LEVEL_WARNING, "server #%d started [Trapper]", server_num); child_trapper_main(ZBX_PROCESS_PROXY, &listen_sock); } else if(server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS) { zabbix_log(LOG_LEVEL_WARNING, "server #%d started [ICMP pinger]", server_num); main_pinger_loop(ZBX_PROCESS_PROXY, server_num - (CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS)); } else if(server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS) { zabbix_log(LOG_LEVEL_WARNING, "server #%d started [Housekeeper]", server_num); main_housekeeper_loop(); } else if(server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS) { #ifdef HAVE_SNMP init_snmp("zabbix_server"); #endif /* HAVE_SNMP */ zabbix_log(LOG_LEVEL_WARNING, "server #%d started [Poller for unreachable hosts. SNMP:"SNMP_FEATURE_STATUS"]", server_num); main_poller_loop(ZBX_PROCESS_PROXY, ZBX_POLLER_TYPE_UNREACHABLE, server_num - (CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS)); } else if (server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_HTTPPOLLER_FORKS) { zabbix_log(LOG_LEVEL_WARNING, "server #%d started [HTTP Poller]", server_num); main_httppoller_loop(ZBX_PROCESS_PROXY, server_num - (CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS)); } else if (server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS) { #ifdef HAVE_SNMP init_snmp("zabbix_server"); #endif /* HAVE_SNMP */ zabbix_log(LOG_LEVEL_WARNING, "server #%d started [Discoverer. SNMP:"SNMP_FEATURE_STATUS"]", server_num); main_discoverer_loop(ZBX_PROCESS_PROXY, server_num - (CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_HTTPPOLLER_FORKS)); } else if (server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS + CONFIG_DBSYNCER_FORKS) { zabbix_log(LOG_LEVEL_WARNING, "server #%d started [DB Syncer]", server_num); main_dbsyncer_loop(); } else if (server_num <= CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS + CONFIG_DBSYNCER_FORKS + CONFIG_IPMIPOLLER_FORKS) { zabbix_log(LOG_LEVEL_WARNING, "server #%d started [IPMI Poller]", server_num); main_poller_loop(ZBX_PROCESS_PROXY, ZBX_POLLER_TYPE_IPMI, server_num - (CONFIG_CONFSYNCER_FORKS + CONFIG_DATASENDER_FORKS + CONFIG_POLLER_FORKS + CONFIG_TRAPPERD_FORKS + CONFIG_PINGER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS + CONFIG_DBSYNCER_FORKS)); } return SUCCEED; }
ZBX_THREAD_ENTRY(active_checks_thread, args) { ZBX_THREAD_ACTIVECHK_ARGS activechk_args; #if defined(ZABBIX_DAEMON) struct sigaction phan; #endif /* ZABBIX_DAEMON */ int nextcheck = 0, nextrefresh = 0, nextsend = 0; char *p = NULL; #if defined(ZABBIX_DAEMON) phan.sa_handler = child_signal_handler; sigemptyset(&phan.sa_mask); phan.sa_flags = 0; sigaction(SIGALRM, &phan, NULL); #endif /* ZABBIX_DAEMON */ activechk_args.host = strdup(((ZBX_THREAD_ACTIVECHK_ARGS *)args)->host); activechk_args.port = ((ZBX_THREAD_ACTIVECHK_ARGS *)args)->port; assert(activechk_args.host); p = strchr(activechk_args.host,','); if(p) *p = '\0'; zabbix_log( LOG_LEVEL_INFORMATION, "zabbix_agentd active check started [%s:%u]", activechk_args.host, activechk_args.port); init_active_metrics(); while(ZBX_IS_RUNNING) { if(time(NULL) >= nextsend) { send_buffer(activechk_args.host, activechk_args.port); nextsend = (int)time(NULL) + 1; } if(time(NULL) >= nextrefresh) { zbx_setproctitle("poller [getting list of active checks]"); if(FAIL == refresh_active_checks(activechk_args.host, activechk_args.port)) { nextrefresh = (int)time(NULL) + 60; } else { nextrefresh = (int)time(NULL) + CONFIG_REFRESH_ACTIVE_CHECKS; } } if(time(NULL) >= nextcheck) { zbx_setproctitle("poller [processing active checks]"); process_active_checks(activechk_args.host, activechk_args.port); nextcheck = get_min_nextcheck(); if(FAIL == nextcheck) nextcheck = (int)time(NULL) + 60; } else { zabbix_log(LOG_LEVEL_DEBUG, "Sleeping for %d seconds", 1 ); zbx_setproctitle("poller [sleeping for %d seconds]", 1); zbx_sleep(1); } } zbx_free(activechk_args.host); free_active_metrics(); zabbix_log( LOG_LEVEL_INFORMATION, "zabbix_agentd active check stopped"); ZBX_DO_EXIT(); zbx_tread_exit(0); }
/****************************************************************************** * * * Function: zbx_mutex_create_ext * * * * Purpose: Create the mutex * * * * Parameters: mutex - handle of mutex * * name - name of mutex (index for nix system) * * forced - remove mutex if exists (only for nix) * * * * Return value: If the function succeeds, then return SUCCEED, * * FAIL on an error * * * * Author: Eugene Grigorjev * * * * Comments: use alias 'zbx_mutex_create' and 'zbx_mutex_create_force' * * * ******************************************************************************/ int zbx_mutex_create_ext(ZBX_MUTEX *mutex, ZBX_MUTEX_NAME name, unsigned char forced) { #ifdef _WINDOWS if (NULL == (*mutex = CreateMutex(NULL, FALSE, name))) { zbx_error("error on mutex creating: %s", strerror_from_system(GetLastError())); return FAIL; } #else #define ZBX_MAX_ATTEMPTS 10 int attempts = 0, i; key_t sem_key; union semun semopts; struct semid_ds seminfo; if (-1 == (sem_key = ftok(CONFIG_FILE, (int)'z'))) { zbx_error("cannot create IPC key for path '%s', try to create for path '.': %s", CONFIG_FILE, zbx_strerror(errno)); if (-1 == (sem_key = ftok(".", (int)'z'))) { zbx_error("cannot create IPC key for path '.': %s", zbx_strerror(errno)); return FAIL; } } lbl_create: if (-1 != ZBX_SEM_LIST_ID || -1 != (ZBX_SEM_LIST_ID = semget(sem_key, ZBX_MUTEX_COUNT, IPC_CREAT | IPC_EXCL | 0600 /* 0022 */)) ) { /* set default semaphore value */ semopts.val = 1; for (i = 0; ZBX_MUTEX_COUNT > i; i++) { if (-1 == semctl(ZBX_SEM_LIST_ID, i, SETVAL, semopts)) { zbx_error("semaphore [%i] error in semctl(SETVAL): %s", name, zbx_strerror(errno)); return FAIL; } zbx_mutex_lock(&i); /* call semop to update sem_otime */ zbx_mutex_unlock(&i); /* release semaphore */ } } else if (EEXIST == errno) { ZBX_SEM_LIST_ID = semget(sem_key, 0 /* get reference */, 0600 /* 0022 */); if (1 == forced) { if (0 != semctl(ZBX_SEM_LIST_ID, 0, IPC_RMID, 0)) { zbx_error("cannot recreate Zabbix semaphores for IPC key 0x%lx Semaphore ID %ld: %s", sem_key, ZBX_SEM_LIST_ID, zbx_strerror(errno)); exit(EXIT_FAILURE); } /* semaphore is successfully removed */ ZBX_SEM_LIST_ID = -1; if (ZBX_MAX_ATTEMPTS < ++attempts) { zbx_error("cannot recreate Zabbix semaphores for IPC key 0x%lx: too many attempts", sem_key); exit(EXIT_FAILURE); } if ((ZBX_MAX_ATTEMPTS / 2) < attempts) zbx_sleep(1); goto lbl_create; } semopts.buf = &seminfo; /* wait for initialization */ for (i = 0; ZBX_MUTEX_MAX_TRIES > i; i++) { if (-1 == semctl(ZBX_SEM_LIST_ID, 0, IPC_STAT, semopts)) { zbx_error("semaphore [%i] error in semctl(IPC_STAT): %s", name, zbx_strerror(errno)); break; } if (0 != semopts.buf->sem_otime) goto lbl_return; zbx_sleep(1); } zbx_error("semaphore [%i] not initialized", name); return FAIL; } else { zbx_error("cannot create Semaphore: %s", zbx_strerror(errno)); return FAIL; } lbl_return: *mutex = name; mutexes++; #endif /* _WINDOWS */ return SUCCEED; }
ZBX_THREAD_ENTRY(listener_thread, args) { #if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL) char *msg = NULL; #endif int ret; zbx_socket_t s; assert(args); assert(((zbx_thread_args_t *)args)->args); process_type = ((zbx_thread_args_t *)args)->process_type; server_num = ((zbx_thread_args_t *)args)->server_num; process_num = ((zbx_thread_args_t *)args)->process_num; zabbix_log(LOG_LEVEL_INFORMATION, "%s #%d started [%s #%d]", get_program_type_string(program_type), server_num, get_process_type_string(process_type), process_num); memcpy(&s, (zbx_socket_t *)((zbx_thread_args_t *)args)->args, sizeof(zbx_socket_t)); zbx_free(args); #if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL) zbx_tls_init_child(); #endif while (ZBX_IS_RUNNING()) { zbx_setproctitle("listener #%d [waiting for connection]", process_num); ret = zbx_tcp_accept(&s, configured_tls_accept_modes); zbx_update_env(zbx_time()); if (SUCCEED == ret) { zbx_setproctitle("listener #%d [processing request]", process_num); if ('\0' != *CONFIG_HOSTS_ALLOWED && SUCCEED == (ret = zbx_tcp_check_allowed_peers(&s, CONFIG_HOSTS_ALLOWED))) { #if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL) if (ZBX_TCP_SEC_TLS_CERT != s.connection_type || SUCCEED == (ret = zbx_check_server_issuer_subject(&s, &msg))) #endif { process_listener(&s); } } zbx_tcp_unaccept(&s); } if (SUCCEED == ret || EINTR == zbx_socket_last_error()) continue; #if defined(HAVE_POLARSSL) || defined(HAVE_GNUTLS) || defined(HAVE_OPENSSL) if (NULL != msg) { zabbix_log(LOG_LEVEL_WARNING, "failed to accept an incoming connection: %s", msg); zbx_free(msg); } else #endif { zabbix_log(LOG_LEVEL_WARNING, "failed to accept an incoming connection: %s", zbx_socket_strerror()); } if (ZBX_IS_RUNNING()) zbx_sleep(1); } #ifdef _WINDOWS ZBX_DO_EXIT(); zbx_thread_exit(EXIT_SUCCESS); #endif }
int MAIN_ZABBIX_ENTRY() { zbx_thread_args_t *thread_args; zbx_sock_t listen_sock; int i, thread_num = 0; #ifdef _WINDOWS DWORD res; #endif if (NULL == CONFIG_LOG_FILE || '\0' == *CONFIG_LOG_FILE) zabbix_open_log(LOG_TYPE_SYSLOG, CONFIG_LOG_LEVEL, NULL); else zabbix_open_log(LOG_TYPE_FILE, CONFIG_LOG_LEVEL, CONFIG_LOG_FILE); zabbix_log(LOG_LEVEL_INFORMATION, "Starting Zabbix Agent [%s]. Zabbix %s (revision %s).", CONFIG_HOSTNAME, ZABBIX_VERSION, ZABBIX_REVISION); zabbix_log(LOG_LEVEL_INFORMATION, "using configuration file: %s", CONFIG_FILE); #ifndef _WINDOWS if (FAIL == load_modules(CONFIG_LOAD_MODULE_PATH, CONFIG_LOAD_MODULE, CONFIG_TIMEOUT, 1)) { zabbix_log(LOG_LEVEL_CRIT, "loading modules failed, exiting..."); exit(EXIT_FAILURE); } #endif if (0 != CONFIG_PASSIVE_FORKS) { if (FAIL == zbx_tcp_listen(&listen_sock, CONFIG_LISTEN_IP, (unsigned short)CONFIG_LISTEN_PORT)) { zabbix_log(LOG_LEVEL_CRIT, "listener failed: %s", zbx_tcp_strerror()); exit(1); } } init_collector_data(); #ifdef _WINDOWS init_perf_collector(1); load_perf_counters(CONFIG_PERF_COUNTERS); #endif load_user_parameters(CONFIG_USER_PARAMETERS); load_aliases(CONFIG_ALIASES); zbx_free_config(); /* --- START THREADS ---*/ /* allocate memory for a collector, all listeners and an active check */ threads_num = 1 + CONFIG_PASSIVE_FORKS + CONFIG_ACTIVE_FORKS; threads = zbx_calloc(threads, threads_num, sizeof(ZBX_THREAD_HANDLE)); /* start the collector thread */ thread_args = (zbx_thread_args_t *)zbx_malloc(NULL, sizeof(zbx_thread_args_t)); thread_args->thread_num = thread_num; thread_args->thread_num2 = 1; thread_args->args = NULL; threads[thread_num++] = zbx_thread_start(collector_thread, thread_args); /* start listeners */ for (i = 0; i < CONFIG_PASSIVE_FORKS; i++) { thread_args = (zbx_thread_args_t *)zbx_malloc(NULL, sizeof(zbx_thread_args_t)); thread_args->thread_num = thread_num; thread_args->thread_num2 = i + 1; thread_args->args = &listen_sock; threads[thread_num++] = zbx_thread_start(listener_thread, thread_args); } /* start active check */ for (i = 0; i < CONFIG_ACTIVE_FORKS; i++) { thread_args = (zbx_thread_args_t *)zbx_malloc(NULL, sizeof(zbx_thread_args_t)); thread_args->thread_num = thread_num; thread_args->thread_num2 = i + 1; thread_args->args = &CONFIG_ACTIVE_ARGS[i]; threads[thread_num++] = zbx_thread_start(active_checks_thread, thread_args); } #ifdef _WINDOWS set_parent_signal_handler(); /* must be called after all threads are created */ /* wait for an exiting thread */ res = WaitForMultipleObjectsEx(threads_num, threads, FALSE, INFINITE, FALSE); if (ZBX_IS_RUNNING()) { /* Zabbix agent service should either be stopped by the user in ServiceCtrlHandler() or */ /* crash. If some thread has terminated normally, it means something is terribly wrong. */ zabbix_log(LOG_LEVEL_CRIT, "One thread has terminated unexpectedly (code:%lu). Exiting ...", res); THIS_SHOULD_NEVER_HAPPEN; /* notify other threads and allow them to terminate */ ZBX_DO_EXIT(); zbx_sleep(1); } else { /* wait for the service worker thread to terminate us */ zbx_sleep(3); THIS_SHOULD_NEVER_HAPPEN; } #else while (-1 == wait(&i)) /* wait for any child to exit */ { if (EINTR != errno) { zabbix_log(LOG_LEVEL_ERR, "failed to wait on child processes: %s", zbx_strerror(errno)); break; } } /* all exiting child processes should be caught by signal handlers */ THIS_SHOULD_NEVER_HAPPEN; #endif zbx_on_exit(); return SUCCEED; }
/****************************************************************************** * * * Function: zbx_mutex_create_ext * * * * Purpose: Create the mutex * * * * Parameters: mutex - handle of mutex * * name - name of mutex (index for nix system) * * forced - remove mutex if exists (only for nix) * * * * Return value: If the function succeeds, then return ZBX_MUTEX_OK, * * ZBX_MUTEX_ERROR on an error * * * * Author: Eugene Grigorjev * * * * Comments: you can use alias 'zbx_mutex_create' and 'zbx_mutex_create_force'* * * ******************************************************************************/ int zbx_mutex_create_ext(ZBX_MUTEX *mutex, ZBX_MUTEX_NAME name, unsigned char forced) { #if defined(_WINDOWS) if(NULL == ((*mutex) = CreateMutex(NULL, FALSE, name))) { zbx_error("Error on mutex creating. [%s]", strerror_from_system(GetLastError())); return ZBX_MUTEX_ERROR; } #else /* not _WINDOWS */ #define ZBX_MAX_ATTEMPTS 10 int attempts = 0, i; key_t sem_key; union semun semopts; struct semid_ds seminfo; if (-1 == (sem_key = ftok(CONFIG_FILE, (int)'z'))) { zbx_error("Can not create IPC key for path '%s', try to create for path '.' [%s]", CONFIG_FILE, strerror(errno)); if (-1 == (sem_key = ftok(".", (int)'z'))) { zbx_error("Can not create IPC key for path '.' [%s]", strerror(errno)); return ZBX_MUTEX_ERROR; } } lbl_create: if (-1 != ZBX_SEM_LIST_ID || -1 != (ZBX_SEM_LIST_ID = semget(sem_key, ZBX_MUTEX_COUNT, IPC_CREAT | IPC_EXCL | 0600 /* 0022 */)) ) { /* set default semaphore value */ semopts.val = 1; for (i = 0; i < ZBX_MUTEX_COUNT; i++) { if (-1 == semctl(ZBX_SEM_LIST_ID, i, SETVAL, semopts)) { zbx_error("Semaphore [%i] error in semctl(SETVAL) [%s]", name, strerror(errno)); return ZBX_MUTEX_ERROR; } zbx_mutex_lock(&i); /* call semop to update sem_otime */ zbx_mutex_unlock(&i); /* release semaphore */ } } else if (errno == EEXIST) { ZBX_SEM_LIST_ID = semget(sem_key, 0 /* get reference */, 0600 /* 0022 */); if (forced) { if (0 != semctl(ZBX_SEM_LIST_ID, 0, IPC_RMID, 0)) { zbx_error("Can't recreate Zabbix semaphores for IPC key 0x%lx Semaphore ID %ld. %s.", sem_key, ZBX_SEM_LIST_ID, strerror(errno)); exit(FAIL); } /* Semaphore is successfully removed */ ZBX_SEM_LIST_ID = -1; if (++attempts > ZBX_MAX_ATTEMPTS) { zbx_error("Can't recreate Zabbix semaphores for IPC key 0x%lx. [too many attempts]", sem_key); exit(FAIL); } if (attempts > (ZBX_MAX_ATTEMPTS / 2)) { zbx_sleep(1); } goto lbl_create; } semopts.buf = &seminfo; /* wait for initialization */ for (i = 0; i < ZBX_MUTEX_MAX_TRIES; i++) { if (-1 == semctl(ZBX_SEM_LIST_ID, 0, IPC_STAT, semopts)) { zbx_error("Semaphore [%i] error in semctl(IPC_STAT). %s.", name, strerror(errno)); break; } if(semopts.buf->sem_otime !=0 ) goto lbl_return; zbx_sleep(1); } zbx_error("Semaphore [%i] not initialized", name); return ZBX_MUTEX_ERROR; } else { zbx_error("Can not create Semaphore [%s]", strerror(errno)); return ZBX_MUTEX_ERROR; } lbl_return: *mutex = name; mutexes++; #endif /* _WINDOWS */ return ZBX_MUTEX_OK; }
int PERF_MONITOR(const char *cmd, const char *param, unsigned flags, AGENT_RESULT *result) { HQUERY query; HCOUNTER counter; PDH_STATUS status; PDH_RAW_COUNTER rawData, rawData2; PDH_FMT_COUNTERVALUE counterValue; char counter_name[MAX_STRING_LEN]; int ret = SYSINFO_RET_FAIL; if(num_param(param) > 1) { return SYSINFO_RET_FAIL; } if(get_param(param, 1, counter_name, sizeof(counter_name)) != 0) { counter_name[0] = '\0'; } if(counter_name[0] == '\0') { return SYSINFO_RET_FAIL; } if (ERROR_SUCCESS == PdhOpenQuery(NULL,0,&query)) { if (ERROR_SUCCESS == (status = PdhAddCounter(query,counter_name,0,&counter))) { if (ERROR_SUCCESS == (status = PdhCollectQueryData(query))) { if(ERROR_SUCCESS == (status = PdhGetRawCounterValue(counter, NULL, &rawData)) && (rawData.CStatus == PDH_CSTATUS_VALID_DATA || rawData.CStatus == PDH_CSTATUS_NEW_DATA)) { if( PDH_CSTATUS_INVALID_DATA == (status = PdhCalculateCounterFromRawValue( counter, PDH_FMT_DOUBLE, &rawData, NULL, &counterValue )) ) { zbx_sleep(1); PdhCollectQueryData(query); PdhGetRawCounterValue(counter, NULL, &rawData2); status = PdhCalculateCounterFromRawValue( counter, PDH_FMT_DOUBLE, &rawData2, &rawData, &counterValue); } if(ERROR_SUCCESS == status) { SET_DBL_RESULT(result, counterValue.doubleValue); ret = SYSINFO_RET_OK; } else { zabbix_log(LOG_LEVEL_DEBUG, "Can't format counter value [%s] [%s]", counter_name, strerror_from_module(status,"PDH.DLL")); } } else { if(ERROR_SUCCESS == status) status = rawData.CStatus; zabbix_log(LOG_LEVEL_DEBUG, "Can't get counter value [%s] [%s]", counter_name, strerror_from_module(status,"PDH.DLL")); } } else { zabbix_log(LOG_LEVEL_DEBUG, "Can't collect data [%s] [%s]", counter_name, strerror_from_module(status,"PDH.DLL")); } PdhRemoveCounter(&counter); } else { zabbix_log(LOG_LEVEL_DEBUG, "Can't add counter [%s] [%s]", counter_name, strerror_from_module(status,"PDH.DLL")); } PdhCloseQuery(query); } return ret; }