int main(int argc, char **argv)
{
ZBX_TASK_EX t;
#ifdef _WINDOWS
int ret;
/* Provide, so our process handles errors instead of the system itself. */
/* Attention!!! */
/* The system does not display the critical-error-handler message box. */
/* Instead, the system sends the error to the calling process.*/
SetErrorMode(SEM_FAILCRITICALERRORS);
#endif
#if defined(PS_OVERWRITE_ARGV) || defined(PS_PSTAT_ARGV)
argv = setproctitle_save_env(argc, argv);
#endif
memset(&t, 0, sizeof(t));
t.task = ZBX_TASK_START;
progname = get_program_name(argv[0]);
parse_commandline(argc, argv, &t);
import_symbols();
/* this is needed to set default hostname in zbx_load_config() */
init_metrics();
switch (t.task)
{
case ZBX_TASK_SHOW_USAGE:
usage();
exit(EXIT_FAILURE);
break;
#ifdef _WINDOWS
case ZBX_TASK_INSTALL_SERVICE:
case ZBX_TASK_UNINSTALL_SERVICE:
case ZBX_TASK_START_SERVICE:
case ZBX_TASK_STOP_SERVICE:
zbx_load_config(ZBX_CFG_FILE_REQUIRED);
zbx_free_config();
if (t.flags & ZBX_TASK_FLAG_MULTIPLE_AGENTS)
{
zbx_snprintf(ZABBIX_SERVICE_NAME, sizeof(ZABBIX_SERVICE_NAME), "%s [%s]",
APPLICATION_NAME, CONFIG_HOSTNAME);
zbx_snprintf(ZABBIX_EVENT_SOURCE, sizeof(ZABBIX_EVENT_SOURCE), "%s [%s]",
APPLICATION_NAME, CONFIG_HOSTNAME);
}
ret = zbx_exec_service_task(argv[0], &t);
free_metrics();
exit(ret);
break;
#endif
case ZBX_TASK_TEST_METRIC:
case ZBX_TASK_PRINT_SUPPORTED:
zbx_load_config(ZBX_CFG_FILE_OPTIONAL);
#ifdef _WINDOWS
init_perf_collector(0);
load_perf_counters(CONFIG_PERF_COUNTERS);
#else
zbx_set_common_signal_handlers();
#endif
#ifndef _WINDOWS
if (FAIL == load_modules(CONFIG_LOAD_MODULE_PATH, CONFIG_LOAD_MODULE, CONFIG_TIMEOUT, 0))
{
zabbix_log(LOG_LEVEL_CRIT, "loading modules failed, exiting...");
exit(EXIT_FAILURE);
}
#endif
load_user_parameters(CONFIG_USER_PARAMETERS);
load_aliases(CONFIG_ALIASES);
zbx_free_config();
if (ZBX_TASK_TEST_METRIC == t.task)
test_parameter(TEST_METRIC);
else
test_parameters();
#ifdef _WINDOWS
free_perf_collector(); /* cpu_collector must be freed before perf_collector is freed */
#endif
#ifndef _WINDOWS
unload_modules();
#endif
free_metrics();
alias_list_free();
exit(SUCCEED);
break;
default:
zbx_load_config(ZBX_CFG_FILE_REQUIRED);
break;
}
START_MAIN_ZABBIX_ENTRY(CONFIG_ALLOW_ROOT);
exit(SUCCEED);
}
/******************************************************************************
* *
* 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;
init_perf_collector(&collector->perfs);
#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);
}
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;
}
