int init_perf_collector(int multithreaded)
{
const char *__function_name = "init_perf_collector";
int ret = FAIL;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
if (0 != multithreaded)
{
if (ZBX_MUTEX_ERROR == zbx_mutex_create_force(&perfstat_access, ZBX_MUTEX_PERFSTAT))
{
zbx_error("cannot create mutex for performance counters");
exit(EXIT_FAILURE);
}
}
if (ERROR_SUCCESS != zbx_PdhOpenQuery(__function_name, &ppsd.pdh_query))
goto out;
ppsd.nextcheck = time(NULL) + UNSUPPORTED_REFRESH_PERIOD;
ret = SUCCEED;
out:
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: init_collector_data *
* *
* Purpose: Allocate memory for collector *
* *
* Author: Eugene Grigorjev *
* *
* Comments: Unix version allocates memory as shared. *
* *
******************************************************************************/
void init_collector_data()
{
const char *__function_name = "init_collector_data";
int cpu_count;
size_t sz, sz_cpu;
#ifndef _WINDOWS
key_t shm_key;
#endif
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
cpu_count = zbx_get_cpu_num();
sz = sizeof(ZBX_COLLECTOR_DATA);
#ifdef _WINDOWS
sz_cpu = sizeof(PERF_COUNTER_DATA *) * (cpu_count + 1);
collector = zbx_malloc(collector, sz + sz_cpu);
memset(collector, 0, sz + sz_cpu);
collector->cpus.cpu_counter = (PERF_COUNTER_DATA **)(collector + 1);
collector->cpus.count = cpu_count;
#else
sz_cpu = sizeof(ZBX_SINGLE_CPU_STAT_DATA) * (cpu_count + 1);
if (-1 == (shm_key = zbx_ftok(CONFIG_FILE, ZBX_IPC_COLLECTOR_ID)))
{
zabbix_log(LOG_LEVEL_CRIT, "cannot create IPC key for collector");
exit(EXIT_FAILURE);
}
if (-1 == (shm_id = zbx_shmget(shm_key, sz + sz_cpu)))
{
zabbix_log(LOG_LEVEL_CRIT, "cannot allocate shared memory for collector");
exit(EXIT_FAILURE);
}
if ((void *)(-1) == (collector = shmat(shm_id, NULL, 0)))
{
zabbix_log(LOG_LEVEL_CRIT, "cannot attach shared memory for collector: %s", zbx_strerror(errno));
exit(EXIT_FAILURE);
}
collector->cpus.cpu = (ZBX_SINGLE_CPU_STAT_DATA *)(collector + 1);
collector->cpus.count = cpu_count;
collector->diskstat_shmid = NONEXISTENT_SHMID;
if (ZBX_MUTEX_ERROR == zbx_mutex_create_force(&diskstats_lock, ZBX_MUTEX_DISKSTATS))
{
zbx_error("cannot create mutex for disk statistics collector");
exit(EXIT_FAILURE);
}
#endif
#ifdef _AIX
memset(&collector->vmstat, 0, sizeof(collector->vmstat));
#endif
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
void zbx_mem_create(zbx_mem_info_t **info, key_t shm_key, int lock_name, zbx_uint64_t size,
const char *descr, const char *param, int allow_oom)
{
const char *__function_name = "zbx_mem_create";
int shm_id, index;
void *base;
descr = ZBX_NULL2STR(descr);
param = ZBX_NULL2STR(param);
zabbix_log(LOG_LEVEL_DEBUG, "In %s() descr:'%s' param:'%s' size:" ZBX_FS_SIZE_T,
__function_name, descr, param, (zbx_fs_size_t)size);
/* allocate shared memory */
if (4 != ZBX_PTR_SIZE && 8 != ZBX_PTR_SIZE)
{
zabbix_log(LOG_LEVEL_CRIT, "failed assumption about pointer size (" ZBX_FS_SIZE_T " not in {4, 8})",
(zbx_fs_size_t)ZBX_PTR_SIZE);
exit(FAIL);
}
if (!(MEM_MIN_SIZE <= size && size <= MEM_MAX_SIZE))
{
zabbix_log(LOG_LEVEL_CRIT, "requested size " ZBX_FS_SIZE_T " not within bounds [" ZBX_FS_UI64
" <= size <= " ZBX_FS_UI64 "]", (zbx_fs_size_t)size, MEM_MIN_SIZE, MEM_MAX_SIZE);
exit(FAIL);
}
if (-1 == (shm_id = zbx_shmget(shm_key, size)))
{
zabbix_log(LOG_LEVEL_CRIT, "cannot allocate shared memory for %s", descr);
exit(FAIL);
}
if ((void *)(-1) == (base = shmat(shm_id, NULL, 0)))
{
zabbix_log(LOG_LEVEL_CRIT, "cannot attach shared memory for %s: %s", descr, zbx_strerror(errno));
exit(FAIL);
}
/* allocate zbx_mem_info_t structure, its buckets, and description inside shared memory */
*info = ALIGN8(base);
(*info)->shm_id = shm_id;
(*info)->orig_size = size;
size -= (void *)(*info + 1) - base;
base = (void *)(*info + 1);
(*info)->buckets = ALIGNPTR(base);
memset((*info)->buckets, 0, MEM_BUCKET_COUNT * ZBX_PTR_SIZE);
size -= (void *)((*info)->buckets + MEM_BUCKET_COUNT) - base;
base = (void *)((*info)->buckets + MEM_BUCKET_COUNT);
zbx_strlcpy(base, descr, size);
(*info)->mem_descr = base;
size -= strlen(descr) + 1;
base += strlen(descr) + 1;
zbx_strlcpy(base, param, size);
(*info)->mem_param = base;
size -= strlen(param) + 1;
base += strlen(param) + 1;
(*info)->allow_oom = allow_oom;
/* allocate mutex */
if (ZBX_NO_MUTEX != lock_name)
{
(*info)->use_lock = 1;
if (ZBX_MUTEX_ERROR == zbx_mutex_create_force(&((*info)->mem_lock), lock_name))
{
zabbix_log(LOG_LEVEL_CRIT, "cannot create mutex for %s",
descr);
exit(FAIL);
}
}
else
(*info)->use_lock = 0;
/* prepare shared memory for further allocation by creating one big chunk */
(*info)->lo_bound = ALIGN8(base);
(*info)->hi_bound = ALIGN8(base + size - 8);
(*info)->total_size = (zbx_uint64_t)((*info)->hi_bound - (*info)->lo_bound - 2 * MEM_SIZE_FIELD);
index = mem_bucket_by_size((*info)->total_size);
(*info)->buckets[index] = (*info)->lo_bound;
mem_set_chunk_size((*info)->buckets[index], (*info)->total_size);
mem_set_prev_chunk((*info)->buckets[index], NULL);
mem_set_next_chunk((*info)->buckets[index], NULL);
(*info)->used_size = 0;
(*info)->free_size = (*info)->total_size;
zabbix_log(LOG_LEVEL_DEBUG, "valid user addresses: [%p, %p] total size: " ZBX_FS_SIZE_T,
(*info)->lo_bound + MEM_SIZE_FIELD,
(*info)->hi_bound - MEM_SIZE_FIELD,
(zbx_fs_size_t)(*info)->total_size);
zabbix_log(LOG_LEVEL_DEBUG, "End of %s()", __function_name);
}
int init_cpu_collector(ZBX_CPUS_STAT_DATA *pcpus)
{
const char *__function_name = "init_cpu_collector";
int cpu_num, ret = FAIL;
#ifdef _WINDOWS
TCHAR cpu[8];
char counterPath[PDH_MAX_COUNTER_PATH];
PDH_COUNTER_PATH_ELEMENTS cpe;
#else
#ifdef HAVE_KSTAT_H
kstat_ctl_t *kc;
kstat_t *k, *kd;
#endif
#endif
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
#ifdef _WINDOWS
cpe.szMachineName = NULL;
cpe.szObjectName = get_counter_name(PCI_PROCESSOR);
cpe.szInstanceName = cpu;
cpe.szParentInstance = NULL;
cpe.dwInstanceIndex = -1;
cpe.szCounterName = get_counter_name(PCI_PROCESSOR_TIME);
for (cpu_num = 0; cpu_num <= pcpus->count; cpu_num++)
{
if (0 == cpu_num)
zbx_wsnprintf(cpu, sizeof(cpu) / sizeof(TCHAR), TEXT("_Total"));
else
_itow_s(cpu_num - 1, cpu, sizeof(cpu) / sizeof(TCHAR), 10);
if (ERROR_SUCCESS != zbx_PdhMakeCounterPath(__function_name, &cpe, counterPath))
goto clean;
if (NULL == (pcpus->cpu_counter[cpu_num] = add_perf_counter(NULL, counterPath, MAX_CPU_HISTORY)))
goto clean;
}
cpe.szObjectName = get_counter_name(PCI_SYSTEM);
cpe.szInstanceName = NULL;
cpe.szCounterName = get_counter_name(PCI_PROCESSOR_QUEUE_LENGTH);
if (ERROR_SUCCESS != zbx_PdhMakeCounterPath(__function_name, &cpe, counterPath))
goto clean;
if (NULL == (pcpus->queue_counter = add_perf_counter(NULL, counterPath, MAX_CPU_HISTORY)))
goto clean;
ret = SUCCEED;
clean:
#else /* not _WINDOWS */
if (ZBX_MUTEX_ERROR == zbx_mutex_create_force(&cpustats_lock, ZBX_MUTEX_CPUSTATS))
{
zbx_error("unable to create mutex for cpu collector");
exit(FAIL);
}
for (cpu_num = 0; cpu_num <= pcpus->count; cpu_num++)
pcpus->cpu[cpu_num].cpu_num = cpu_num;
#ifdef HAVE_KSTAT_H
/* Solaris */
if (NULL != (kc = kstat_open()))
{
if (NULL != (k = kstat_lookup(kc, "unix", 0, "kstat_headers")) && -1 != kstat_read(kc, k, NULL))
{
int i;
for (i = 0, cpu_num = 1; i < k->ks_ndata; i++)
{
kd = (kstat_t *)k->ks_data;
if (0 == strcmp(kd[i].ks_module, "cpu_info"))
pcpus->cpu[cpu_num++].cpu_num = kd[i].ks_instance + 1;
}
}
kstat_close(kc);
}
#endif /* HAVE_KSTAT_H */
ret = SUCCEED;
#endif /* _WINDOWS */
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
/******************************************************************************
* *
* Function: init_selfmon_collector *
* *
* Purpose: Initialize structures and prepare state *
* for self-monitoring collector *
* *
* Parameters: *
* *
* Return value: *
* *
* Author: Alexander Vladishev *
* *
* Comments: *
* *
******************************************************************************/
void init_selfmon_collector()
{
const char *__function_name = "init_selfmon_collector";
size_t sz, sz_array, sz_process[ZBX_PROCESS_TYPE_COUNT], sz_total;
key_t shm_key;
char *p;
clock_t ticks;
struct tms buf;
unsigned char process_type;
int process_num, process_forks;
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
sz_total = sz = sizeof(zbx_selfmon_collector_t);
sz_total += sz_array = sizeof(zbx_stat_process_t *) * ZBX_PROCESS_TYPE_COUNT;
for (process_type = 0; process_type < ZBX_PROCESS_TYPE_COUNT; process_type++)
sz_total += sz_process[process_type] =
sizeof(zbx_stat_process_t) * get_process_type_forks(process_type);
zabbix_log(LOG_LEVEL_DEBUG, "%s() size:%d", __function_name, (int)sz_total);
if (-1 == (shm_key = zbx_ftok(CONFIG_FILE, ZBX_IPC_SELFMON_ID)))
{
zabbix_log(LOG_LEVEL_CRIT, "Cannot create IPC key for a self-monitoring collector");
exit(FAIL);
}
if (ZBX_MUTEX_ERROR == zbx_mutex_create_force(&sm_lock, ZBX_MUTEX_SELFMON))
{
zbx_error("Unable to create mutex for a self-monitoring collector");
exit(FAIL);
}
if (-1 == (shm_id = zbx_shmget(shm_key, sz_total)))
{
zabbix_log(LOG_LEVEL_CRIT, "Cannot allocate shared memory for a self-monitoring collector");
exit(FAIL);
}
if ((void *)(-1) == (p = shmat(shm_id, NULL, 0)))
{
zabbix_log(LOG_LEVEL_CRIT, "Cannot attach shared memory for a self-monitoring collector [%s]",
strerror(errno));
exit(FAIL);
}
collector = (zbx_selfmon_collector_t *)p; p += sz;
collector->process = (zbx_stat_process_t **)p; p += sz_array;
ticks = times(&buf);
for (process_type = 0; process_type < ZBX_PROCESS_TYPE_COUNT; process_type++)
{
collector->process[process_type] = (zbx_stat_process_t *)p; p += sz_process[process_type];
memset(collector->process[process_type], 0, sz_process[process_type]);
process_forks = get_process_type_forks(process_type);
for (process_num = 0; process_num < process_forks; process_num++)
{
collector->process[process_type][process_num].last_ticks = ticks;
collector->process[process_type][process_num].last_state = ZBX_PROCESS_STATE_BUSY;
}
}
zabbix_log(LOG_LEVEL_DEBUG, "End of %s() collector:%p", __function_name, collector);
}
int MAIN_ZABBIX_ENTRY()
{
DB_RESULT result;
DB_ROW row;
pid_t pid;
zbx_sock_t listen_sock;
int i, server_num = 0, server_count = 0;
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);
#ifdef HAVE_SNMP
# define SNMP_FEATURE_STATUS "YES"
#else
# define SNMP_FEATURE_STATUS " NO"
#endif
#ifdef HAVE_OPENIPMI
# define IPMI_FEATURE_STATUS "YES"
#else
# define IPMI_FEATURE_STATUS " NO"
#endif
#ifdef HAVE_LIBCURL
# define LIBCURL_FEATURE_STATUS "YES"
#else
# define LIBCURL_FEATURE_STATUS " NO"
#endif
#if defined(HAVE_LIBXML2) && defined(HAVE_LIBCURL)
# define VMWARE_FEATURE_STATUS "YES"
#else
# define VMWARE_FEATURE_STATUS " NO"
#endif
#ifdef HAVE_JABBER
# define JABBER_FEATURE_STATUS "YES"
#else
# define JABBER_FEATURE_STATUS " NO"
#endif
#ifdef HAVE_UNIXODBC
# define ODBC_FEATURE_STATUS "YES"
#else
# define ODBC_FEATURE_STATUS " NO"
#endif
#ifdef HAVE_SSH2
# define SSH2_FEATURE_STATUS "YES"
#else
# define SSH2_FEATURE_STATUS " NO"
#endif
#ifdef HAVE_IPV6
# define IPV6_FEATURE_STATUS "YES"
#else
# define IPV6_FEATURE_STATUS " NO"
#endif
zabbix_log(LOG_LEVEL_INFORMATION, "Starting Zabbix Server. Zabbix %s (revision %s).",
ZABBIX_VERSION, ZABBIX_REVISION);
zabbix_log(LOG_LEVEL_INFORMATION, "****** Enabled features ******");
zabbix_log(LOG_LEVEL_INFORMATION, "SNMP monitoring: " SNMP_FEATURE_STATUS);
zabbix_log(LOG_LEVEL_INFORMATION, "IPMI monitoring: " IPMI_FEATURE_STATUS);
zabbix_log(LOG_LEVEL_INFORMATION, "WEB monitoring: " LIBCURL_FEATURE_STATUS);
zabbix_log(LOG_LEVEL_INFORMATION, "VMware monitoring: " VMWARE_FEATURE_STATUS);
zabbix_log(LOG_LEVEL_INFORMATION, "Jabber notifications: " JABBER_FEATURE_STATUS);
zabbix_log(LOG_LEVEL_INFORMATION, "Ez Texting notifications: " LIBCURL_FEATURE_STATUS);
zabbix_log(LOG_LEVEL_INFORMATION, "ODBC: " ODBC_FEATURE_STATUS);
zabbix_log(LOG_LEVEL_INFORMATION, "SSH2 support: " SSH2_FEATURE_STATUS);
zabbix_log(LOG_LEVEL_INFORMATION, "IPv6 support: " IPV6_FEATURE_STATUS);
zabbix_log(LOG_LEVEL_INFORMATION, "******************************");
if (0 != CONFIG_NODEID)
{
zabbix_log(LOG_LEVEL_INFORMATION, "NodeID: %3d", CONFIG_NODEID);
zabbix_log(LOG_LEVEL_INFORMATION, "******************************");
}
zabbix_log(LOG_LEVEL_INFORMATION, "using configuration file: %s", CONFIG_FILE);
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);
}
zbx_free_config();
init_database_cache();
init_configuration_cache();
init_selfmon_collector();
/* initialize vmware support */
if (0 != CONFIG_VMWARE_FORKS)
zbx_vmware_init();
/* initialize history value cache */
zbx_vc_init();
zbx_create_itservices_lock();
#ifdef HAVE_SQLITE3
zbx_create_sqlite3_mutex();
#endif
if (SUCCEED != DBcheck_version())
exit(EXIT_FAILURE);
DBconnect(ZBX_DB_CONNECT_NORMAL);
if (0 != CONFIG_NODEID)
{
result = DBselect("select masterid from nodes where nodeid=%d", CONFIG_NODEID);
if (NULL != (row = DBfetch(result)) && SUCCEED != DBis_null(row[0]))
CONFIG_MASTER_NODEID = atoi(row[0]);
DBfree_result(result);
}
DCload_config();
/* make initial configuration sync before worker processes are forked */
DCsync_configuration();
DBclose();
if (ZBX_MUTEX_ERROR == zbx_mutex_create_force(&node_sync_access, ZBX_MUTEX_NODE_SYNC))
{
zbx_error("Unable to create mutex for node syncs");
exit(FAIL);
}
threads_num = CONFIG_CONFSYNCER_FORKS + CONFIG_WATCHDOG_FORKS + CONFIG_POLLER_FORKS
+ CONFIG_UNREACHABLE_POLLER_FORKS + CONFIG_TRAPPER_FORKS + CONFIG_PINGER_FORKS
+ CONFIG_ALERTER_FORKS + CONFIG_HOUSEKEEPER_FORKS + CONFIG_TIMER_FORKS
+ CONFIG_NODEWATCHER_FORKS + CONFIG_HTTPPOLLER_FORKS + CONFIG_DISCOVERER_FORKS
+ CONFIG_HISTSYNCER_FORKS + CONFIG_ESCALATOR_FORKS + CONFIG_IPMIPOLLER_FORKS
+ CONFIG_JAVAPOLLER_FORKS + CONFIG_SNMPTRAPPER_FORKS + CONFIG_PROXYPOLLER_FORKS
+ CONFIG_SELFMON_FORKS + CONFIG_VMWARE_FORKS;
threads = zbx_calloc(threads, threads_num, sizeof(pid_t));
if (0 < CONFIG_TRAPPER_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);
}
}
for (i = 0; i < threads_num; i++)
{
if (0 == (pid = zbx_child_fork()))
{
server_num = i + 1; /* child processes are numbered starting from 1 */
break;
}
else
threads[i] = pid;
}
if (0 == server_num)
{
zabbix_log(LOG_LEVEL_INFORMATION, "server #0 started [main process]");
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;
zbx_on_exit();
}
else if (server_num <= (server_count += CONFIG_CONFSYNCER_FORKS))
{
/* !!! configuration syncer must be server #1 - child_signal_handler() uses threads[0] !!! */
INIT_SERVER(ZBX_PROCESS_TYPE_CONFSYNCER, CONFIG_CONFSYNCER_FORKS);
main_dbconfig_loop();
}
else if (server_num <= (server_count += CONFIG_WATCHDOG_FORKS))
{
INIT_SERVER(ZBX_PROCESS_TYPE_WATCHDOG, CONFIG_WATCHDOG_FORKS);
main_watchdog_loop();
}
else if (server_num <= (server_count += CONFIG_POLLER_FORKS))
{
#ifdef HAVE_SNMP
init_snmp("zabbix_server");
#endif
INIT_SERVER(ZBX_PROCESS_TYPE_POLLER, CONFIG_POLLER_FORKS);
main_poller_loop(ZBX_POLLER_TYPE_NORMAL);
}
else if (server_num <= (server_count += CONFIG_UNREACHABLE_POLLER_FORKS))
{
#ifdef HAVE_SNMP
init_snmp("zabbix_server");
#endif
INIT_SERVER(ZBX_PROCESS_TYPE_UNREACHABLE, CONFIG_UNREACHABLE_POLLER_FORKS);
main_poller_loop(ZBX_POLLER_TYPE_UNREACHABLE);
}
else if (server_num <= (server_count += CONFIG_TRAPPER_FORKS))
{
INIT_SERVER(ZBX_PROCESS_TYPE_TRAPPER, CONFIG_TRAPPER_FORKS);
main_trapper_loop(&listen_sock);
}
else if (server_num <= (server_count += CONFIG_PINGER_FORKS))
{
INIT_SERVER(ZBX_PROCESS_TYPE_PINGER, CONFIG_PINGER_FORKS);
main_pinger_loop();
}
else if (server_num <= (server_count += CONFIG_ALERTER_FORKS))
{
INIT_SERVER(ZBX_PROCESS_TYPE_ALERTER, CONFIG_ALERTER_FORKS);
main_alerter_loop();
}
else if (server_num <= (server_count += CONFIG_HOUSEKEEPER_FORKS))
{
INIT_SERVER(ZBX_PROCESS_TYPE_HOUSEKEEPER, CONFIG_HOUSEKEEPER_FORKS);
main_housekeeper_loop();
}
else if (server_num <= (server_count += CONFIG_TIMER_FORKS))
{
INIT_SERVER(ZBX_PROCESS_TYPE_TIMER, CONFIG_TIMER_FORKS);
main_timer_loop();
}
else if (server_num <= (server_count += CONFIG_NODEWATCHER_FORKS))
{
INIT_SERVER(ZBX_PROCESS_TYPE_NODEWATCHER, CONFIG_NODEWATCHER_FORKS);
main_nodewatcher_loop();
}
else if (server_num <= (server_count += CONFIG_HTTPPOLLER_FORKS))
{
INIT_SERVER(ZBX_PROCESS_TYPE_HTTPPOLLER, CONFIG_HTTPPOLLER_FORKS);
main_httppoller_loop();
}
else if (server_num <= (server_count += CONFIG_DISCOVERER_FORKS))
{
#ifdef HAVE_SNMP
init_snmp("zabbix_server");
#endif
INIT_SERVER(ZBX_PROCESS_TYPE_DISCOVERER, CONFIG_DISCOVERER_FORKS);
main_discoverer_loop();
}
else if (server_num <= (server_count += CONFIG_HISTSYNCER_FORKS))
{
INIT_SERVER(ZBX_PROCESS_TYPE_HISTSYNCER, CONFIG_HISTSYNCER_FORKS);
main_dbsyncer_loop();
}
else if (server_num <= (server_count += CONFIG_ESCALATOR_FORKS))
{
INIT_SERVER(ZBX_PROCESS_TYPE_ESCALATOR, CONFIG_ESCALATOR_FORKS);
main_escalator_loop();
}
else if (server_num <= (server_count += CONFIG_IPMIPOLLER_FORKS))
{
INIT_SERVER(ZBX_PROCESS_TYPE_IPMIPOLLER, CONFIG_IPMIPOLLER_FORKS);
main_poller_loop(ZBX_POLLER_TYPE_IPMI);
}
else if (server_num <= (server_count += CONFIG_JAVAPOLLER_FORKS))
{
INIT_SERVER(ZBX_PROCESS_TYPE_JAVAPOLLER, CONFIG_JAVAPOLLER_FORKS);
main_poller_loop(ZBX_POLLER_TYPE_JAVA);
}
else if (server_num <= (server_count += CONFIG_SNMPTRAPPER_FORKS))
{
INIT_SERVER(ZBX_PROCESS_TYPE_SNMPTRAPPER, CONFIG_SNMPTRAPPER_FORKS);
main_snmptrapper_loop();
}
else if (server_num <= (server_count += CONFIG_PROXYPOLLER_FORKS))
{
INIT_SERVER(ZBX_PROCESS_TYPE_PROXYPOLLER, CONFIG_PROXYPOLLER_FORKS);
main_proxypoller_loop();
}
else if (server_num <= (server_count += CONFIG_SELFMON_FORKS))
{
INIT_SERVER(ZBX_PROCESS_TYPE_SELFMON, CONFIG_SELFMON_FORKS);
main_selfmon_loop();
}
else if (server_num <= (server_count += CONFIG_VMWARE_FORKS))
{
INIT_SERVER(ZBX_PROCESS_TYPE_VMWARE, CONFIG_VMWARE_FORKS);
main_vmware_loop();
}
return SUCCEED;
}
int init_cpu_collector(ZBX_CPUS_STAT_DATA *pcpus)
{
const char *__function_name = "init_cpu_collector";
int cpu_num, ret = FAIL;
#ifdef _WINDOWS
TCHAR cpu[8];
char counterPath[PDH_MAX_COUNTER_PATH];
PDH_COUNTER_PATH_ELEMENTS cpe;
#endif
zabbix_log(LOG_LEVEL_DEBUG, "In %s()", __function_name);
#ifdef _WINDOWS
cpe.szMachineName = NULL;
cpe.szObjectName = get_counter_name(PCI_PROCESSOR);
cpe.szInstanceName = cpu;
cpe.szParentInstance = NULL;
cpe.dwInstanceIndex = -1;
cpe.szCounterName = get_counter_name(PCI_PROCESSOR_TIME);
for (cpu_num = 0; cpu_num <= pcpus->count; cpu_num++)
{
if (0 == cpu_num)
zbx_wsnprintf(cpu, sizeof(cpu) / sizeof(TCHAR), TEXT("_Total"));
else
_itow_s(cpu_num - 1, cpu, sizeof(cpu) / sizeof(TCHAR), 10);
if (ERROR_SUCCESS != zbx_PdhMakeCounterPath(__function_name, &cpe, counterPath))
goto clean;
if (NULL == (pcpus->cpu_counter[cpu_num] = add_perf_counter(NULL, counterPath, MAX_CPU_HISTORY)))
goto clean;
}
cpe.szObjectName = get_counter_name(PCI_SYSTEM);
cpe.szInstanceName = NULL;
cpe.szCounterName = get_counter_name(PCI_PROCESSOR_QUEUE_LENGTH);
if (ERROR_SUCCESS != zbx_PdhMakeCounterPath(__function_name, &cpe, counterPath))
goto clean;
if (NULL == (pcpus->queue_counter = add_perf_counter(NULL, counterPath, MAX_CPU_HISTORY)))
goto clean;
ret = SUCCEED;
clean:
#else /* not _WINDOWS */
if (ZBX_MUTEX_ERROR == zbx_mutex_create_force(&cpustats_lock, ZBX_MUTEX_CPUSTATS))
{
zbx_error("unable to create mutex for cpu collector");
exit(EXIT_FAILURE);
}
#ifndef HAVE_KSTAT_H
for (cpu_num = 0; cpu_num <= pcpus->count; cpu_num++)
pcpus->cpu[cpu_num].cpu_num = cpu_num;
#else
/* Solaris */
/* CPU instance numbers on Solaris can be non-contiguous, we don't know them yet */
pcpus->cpu[0].cpu_num = 0;
for (cpu_num = 1; cpu_num <= pcpus->count; cpu_num++)
pcpus->cpu[cpu_num].cpu_num = -1;
if (NULL == (kc = kstat_open()))
{
zbx_error("kstat_open() failed");
exit(EXIT_FAILURE);
}
kc_id = kc->kc_chain_id;
if (NULL == ksp)
ksp = zbx_malloc(ksp, sizeof(kstat_t *) * pcpus->count);
if (SUCCEED != refresh_kstat(pcpus))
{
zbx_error("kstat_chain_update() failed");
exit(EXIT_FAILURE);
}
#endif /* HAVE_KSTAT_H */
ret = SUCCEED;
#endif /* _WINDOWS */
zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret));
return ret;
}
