int proto_init() {
proto_registry_class = registry_add_class(PROTO_REGISTRY);
if (!proto_registry_class)
return POM_ERR;
return POM_OK;
}
int event_init() {
event_registry_class = registry_add_class(EVENT_REGISTRY);
if (!event_registry_class)
return POM_ERR;
return POM_OK;
}
int output_init() {
output_registry_class = registry_add_class(OUTPUT_REGISTRY);
if (!output_registry_class)
return POM_ERR;
output_registry_class->instance_add = output_instance_add;
output_registry_class->instance_remove = output_instance_remove;
return POM_OK;
}
int input_init() {
input_registry_class = registry_add_class(INPUT_REGISTRY);
if (!input_registry_class)
return POM_ERR;
input_registry_class->instance_add = input_instance_add;
input_registry_class->instance_remove = input_instance_remove;
return POM_OK;
}
int core_init(unsigned int num_threads) {
core_registry_class = registry_add_class(CORE_REGISTRY);
if (!core_registry_class)
return POM_ERR;
perf_pkt_queue = registry_class_add_perf(core_registry_class, "pkt_queue", registry_perf_type_gauge, "Number of packets in the queue waiting to be processed", "pkts");
perf_thread_active = registry_class_add_perf(core_registry_class, "active_thread", registry_perf_type_gauge, "Number of active threads", "threads");
if (!perf_pkt_queue || !perf_thread_active)
return POM_OK;
core_param_dump_pkt = ptype_alloc("bool");
if (!core_param_dump_pkt)
return POM_ERR;
core_param_offline_dns = ptype_alloc("bool");
if (!core_param_offline_dns) {
ptype_cleanup(core_param_dump_pkt);
core_param_dump_pkt = NULL;
return POM_ERR;
}
core_param_reset_perf_on_restart = ptype_alloc("bool");
if (!core_param_reset_perf_on_restart) {
ptype_cleanup(core_param_dump_pkt);
core_param_dump_pkt = NULL;
ptype_cleanup(core_param_offline_dns);
core_param_offline_dns = NULL;
return POM_ERR;
}
struct registry_param *param = registry_new_param("dump_pkt", "no", core_param_dump_pkt, "Dump packets to logs", REGISTRY_PARAM_FLAG_CLEANUP_VAL);
if (registry_class_add_param(core_registry_class, param) != POM_OK)
goto err;
param = registry_new_param("offline_dns", "yes", core_param_offline_dns, "Enable offline DNS resolver", REGISTRY_PARAM_FLAG_CLEANUP_VAL);
if (registry_class_add_param(core_registry_class, param) != POM_OK)
goto err;
param = registry_new_param("reset_perf_on_restart", "no", core_param_reset_perf_on_restart, "Reset performances when core restarts", REGISTRY_PARAM_FLAG_CLEANUP_VAL);
if (registry_class_add_param(core_registry_class, param) != POM_OK)
goto err;
param = NULL;
// Start the processing threads
unsigned int num_cpu = sysconf(_SC_NPROCESSORS_ONLN) - 1;
if (num_cpu < 1) {
pomlog(POMLOG_WARN "Could not find the number of CPU, assuming %u", CORE_PROCESS_THREAD_DEFAULT);
num_cpu = CORE_PROCESS_THREAD_DEFAULT;
}
if (num_threads < 1)
num_threads = num_cpu;
if (num_threads > num_cpu)
pomlog(POMLOG_WARN "WARNING : Running more processing threads than available CPU is discouraged as it will cause issues by creating higher latencies and eventually dropping packets !!! You have been warned !");
if (num_threads > CORE_PROCESS_THREAD_MAX)
num_threads = CORE_PROCESS_THREAD_MAX;
core_num_threads = num_threads;
pomlog(POMLOG_INFO "Starting %u processing thread(s)", core_num_threads);
core_run = 1;
memset(core_processing_threads, 0, sizeof(struct core_processing_thread*) * CORE_PROCESS_THREAD_MAX);
unsigned int i;
for (i = 0; i < core_num_threads; i++) {
struct core_processing_thread *tmp = malloc(sizeof(struct core_processing_thread));
if (!tmp) {
pom_oom(sizeof(struct core_processing_thread));
goto err;
}
memset(tmp, 0, sizeof(struct core_processing_thread));
tmp->thread_id = i;
int res = pthread_mutex_init(&tmp->pkt_queue_lock, NULL);
if (res) {
pomlog(POMLOG_ERR "Error while initializing a thread pkt_queue lock : %s", pom_strerror(res));
free(tmp);
goto err;
}
res = pthread_cond_init(&tmp->pkt_queue_cond, NULL);
if (res) {
pomlog(POMLOG_ERR "Error while initializing a thread pkt_queue condition : %s", pom_strerror(res));
pthread_mutex_destroy(&tmp->pkt_queue_lock);
free(tmp);
goto err;
}
if (pthread_create(&tmp->thread, NULL, core_processing_thread_func, tmp)) {
pomlog(POMLOG_ERR "Error while creating a new processing thread : %s", pom_strerror(errno));
pthread_mutex_destroy(&tmp->pkt_queue_lock);
pthread_cond_destroy(&tmp->pkt_queue_cond);
free(tmp);
goto err;
}
core_processing_threads[i] = tmp;
}
return POM_OK;
err:
if (param)
registry_cleanup_param(param);
core_cleanup(0);
return POM_ERR;
}
