static gboolean
afinter_source_init(LogPipe *s)
{
AFInterSource *self = (AFInterSource *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (!log_source_init(s))
return FALSE;
self->mark_freq = cfg->mark_freq;
afinter_postpone_mark(self->mark_freq);
self->mark_timer.expires = next_mark_target;
/* post event is used by other threads and can only be unregistered if
* current_afinter_source is set to NULL in a thread safe manner */
iv_event_register(&self->post);
iv_event_register(&self->schedule_wakeup);
afinter_source_start_watches(self);
g_static_mutex_lock(&internal_msg_lock);
current_internal_source = self;
g_static_mutex_unlock(&internal_msg_lock);
return TRUE;
}
static void
log_threaded_dest_driver_init_watches(LogThrDestDriver* self)
{
IV_EVENT_INIT(&self->wake_up_event);
self->wake_up_event.cookie = self;
self->wake_up_event.handler = log_threaded_dest_driver_wake_up;
iv_event_register(&self->wake_up_event);
IV_EVENT_INIT(&self->shutdown_event);
self->shutdown_event.cookie = self;
self->shutdown_event.handler = log_threaded_dest_driver_shutdown;
iv_event_register(&self->shutdown_event);
IV_TIMER_INIT(&self->timer_reopen);
self->timer_reopen.cookie = self;
self->timer_reopen.handler = log_threaded_dest_driver_do_work;
IV_TIMER_INIT(&self->timer_throttle);
self->timer_throttle.cookie = self;
self->timer_throttle.handler = log_threaded_dest_driver_do_work;
IV_TASK_INIT(&self->do_work);
self->do_work.cookie = self;
self->do_work.handler = log_threaded_dest_driver_do_work;
}
static gboolean
log_reader_init(LogPipe *s)
{
LogReader *self = (LogReader *) s;
if (!log_source_init(s))
return FALSE;
if (!log_proto_server_validate_options(self->proto))
return FALSE;
if (!self->options->parse_options.format_handler)
{
msg_error("Unknown format plugin specified",
evt_tag_str("format", self->options->parse_options.format));
return FALSE;
}
poll_events_set_callback(self->poll_events, log_reader_io_process_input, self);
log_reader_update_watches(self);
iv_event_register(&self->schedule_wakeup);
iv_event_register(&self->last_msg_sent_event);
return TRUE;
}
static void iv_work_thread(void *_thr)
{
struct work_pool_thread *thr = _thr;
struct work_pool_priv *pool = thr->pool;
iv_init();
INIT_IV_LIST_HEAD(&thr->list);
thr->kicked = 0;
IV_EVENT_INIT(&thr->kick);
thr->kick.cookie = thr;
thr->kick.handler = iv_work_thread_got_event;
iv_event_register(&thr->kick);
IV_TIMER_INIT(&thr->idle_timer);
thr->idle_timer.cookie = thr;
thr->idle_timer.handler = iv_work_thread_idle_timeout;
if (pool->thread_start != NULL)
pool->thread_start(pool->cookie);
iv_event_post(&thr->kick);
iv_main();
iv_deinit();
}
static void
_register_event(struct iv_event *event, void (*handler)(void *))
{
IV_EVENT_INIT(event);
event->handler = handler;
event->cookie = NULL;
iv_event_register(event);
}
static void
_init_watches(JournalReader *self)
{
IV_EVENT_INIT(&self->schedule_wakeup);
self->schedule_wakeup.cookie = self;
self->schedule_wakeup.handler = _wakeup_triggered;
iv_event_register(&self->schedule_wakeup);
IV_TASK_INIT(&self->restart_task);
self->restart_task.cookie = self;
self->restart_task.handler = _io_process_input;
main_loop_io_worker_job_init(&self->io_job);
self->io_job.user_data = self;
self->io_job.work = (void (*)(void *)) _work_perform;
self->io_job.completion = (void (*)(void *)) _work_finished;
}
static void thr_child(void *_dummy)
{
iv_init();
IV_EVENT_INIT(&ev_child);
ev_child.handler = got_ev_child;
iv_event_register(&ev_child);
iv_validate_now();
tim_start = iv_now;
iv_event_post(&ev_parent);
iv_main();
iv_deinit();
}
static gboolean
log_reader_init(LogPipe *s)
{
LogReader *self = (LogReader *) s;
if (!log_source_init(s))
return FALSE;
/* check for new data */
if (self->options->padding)
{
if (self->options->msg_size < self->options->padding)
{
msg_error("Buffer is too small to hold padding number of bytes",
evt_tag_int("padding", self->options->padding),
evt_tag_int("msg_size", self->options->msg_size),
NULL);
return FALSE;
}
}
if (self->options->text_encoding)
{
if (!log_proto_set_encoding(self->proto, self->options->text_encoding))
{
msg_error("Unknown character set name specified",
evt_tag_str("encoding", self->options->text_encoding),
NULL);
return FALSE;
}
}
if (!self->options->parse_options.format_handler)
{
msg_error("Unknown format plugin specified",
evt_tag_str("format", self->options->parse_options.format),
NULL);
return FALSE;
}
if (!log_reader_start_watches(self))
return FALSE;
iv_event_register(&self->schedule_wakeup);
return TRUE;
}
static gboolean
_init(LogPipe *s)
{
JournalReader *self = (JournalReader *)s;
if (journal_reader_initialized)
{
msg_error("The configuration must not contain more than one systemd-journal() source",
NULL);
return FALSE;
}
if (!log_source_init(s))
return FALSE;
gint res = journald_open(self->journal, SD_JOURNAL_LOCAL_ONLY);
if (res < 0)
{
msg_error("Error opening the journal",
evt_tag_errno("error", errno),
NULL);
return FALSE;
}
if (!_set_starting_position(self))
{
journald_close(self->journal);
return FALSE;
}
if (!_add_poll_events(self))
{
return FALSE;
}
self->immediate_check = TRUE;
journal_reader_initialized = TRUE;
_update_watches(self);
iv_event_register(&self->schedule_wakeup);
return TRUE;
}
int main()
{
long long nsec;
iv_init();
#ifdef USE_SIGNAL
signal(SIGALRM, got_signal_timeout);
alarm(5);
#else
IV_TIMER_INIT(&timeout);
iv_validate_now();
timeout.expires = iv_now;
timeout.expires.tv_sec += 5;
timeout.handler = got_timer_timeout;
iv_timer_register(&timeout);
#endif
IV_EVENT_INIT(&ev_parent);
ev_parent.handler = got_ev_parent;
iv_event_register(&ev_parent);
iv_thread_create("child", thr_child, NULL);
iv_main();
iv_deinit();
nsec = 1000000000ULL * (tim_end.tv_sec - tim_start.tv_sec) +
(tim_end.tv_nsec - tim_start.tv_nsec);
printf("%s: %d in %lld nsec => %d/sec\n",
iv_poll_method_name(), ev_received, (long long)nsec,
(int)(1000000000ULL * ev_received / nsec));
return 0;
}
static gboolean
log_reader_init(LogPipe *s)
{
LogReader *self = (LogReader *) s;
if (!log_source_init(s))
return FALSE;
if (!log_proto_server_validate_options(self->proto))
return FALSE;
if (!self->options->parse_options.format_handler)
{
msg_error("Unknown format plugin specified",
evt_tag_str("format", self->options->parse_options.format),
NULL);
return FALSE;
}
if (!log_reader_start_watches(self))
return FALSE;
iv_event_register(&self->schedule_wakeup);
return TRUE;
}
