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