/******************************************************************************
* *
* 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;
}
