static void
trigger_source_init_watches (TriggerSource *self)
{
IV_TIMER_INIT (&self->trigger_timer);
self->trigger_timer.cookie = self;
self->trigger_timer.handler = trigger_source_triggered;
}
/* one-time initialization of the MlBatchedTimer structure */
void
ml_batched_timer_init(MlBatchedTimer *self)
{
g_static_mutex_init(&self->lock);
IV_TIMER_INIT(&self->timer);
self->timer.cookie = self;
self->timer.handler = (void (*)(void *)) ml_batched_timer_handle;
}
static void
afsocket_dd_init_watches(AFSocketDestDriver *self)
{
IV_FD_INIT(&self->connect_fd);
self->connect_fd.cookie = self;
self->connect_fd.handler_out = (void (*)(void *)) afsocket_dd_connected;
IV_TIMER_INIT(&self->reconnect_timer);
self->reconnect_timer.cookie = self;
self->reconnect_timer.handler = (void (*)(void *)) afsocket_dd_reconnect;
}
static void gotev0(void *_x)
{
printf("got ev0\n");
iv_event_raw_unregister(&ev0);
IV_TIMER_INIT(&ev1);
iv_validate_now();
ev1.expires = iv_now;
ev1.expires.tv_sec++;
ev1.handler = gotev1;
iv_timer_register(&ev1);
}
static void
afsocket_dd_init_watches(AFSocketDestDriver *self)
{
IV_FD_INIT(&self->connect_fd);
self->connect_fd.cookie = self;
self->connect_fd.handler_out = (void (*)(void *)) afsocket_dd_connected;
IV_TIMER_INIT(&self->reconnect_timer);
self->reconnect_timer.cookie = self;
/* Using reinit as a handler before establishing the first successful connection.
* We'll change this to afsocket_dd_reconnect when the initialization of the
* connection succeeds.*/
self->reconnect_timer.handler = (void (*)(void *)) afsocket_dd_try_connect;
}
static void
afinter_source_init_watches(AFInterSource *self)
{
IV_EVENT_INIT(&self->post);
self->post.cookie = self;
self->post.handler = afinter_source_post;
IV_TIMER_INIT(&self->mark_timer);
self->mark_timer.cookie = self;
self->mark_timer.handler = afinter_source_mark;
IV_EVENT_INIT(&self->schedule_wakeup);
self->schedule_wakeup.cookie = self;
self->schedule_wakeup.handler = (void (*)(void *)) afinter_source_update_watches;
IV_TASK_INIT(&self->restart_task);
self->restart_task.cookie = self;
self->restart_task.handler = afinter_source_post;
}
static void
main_loop_exit_initiate(void)
{
if (main_loop_is_terminating())
return;
msg_notice("syslog-ng shutting down",
evt_tag_str("version", SYSLOG_NG_VERSION));
IV_TIMER_INIT(&main_loop_exit_timer);
iv_validate_now();
main_loop_exit_timer.expires = iv_now;
main_loop_exit_timer.handler = main_loop_exit_timer_elapsed;
timespec_add_msec(&main_loop_exit_timer.expires, 100);
iv_timer_register(&main_loop_exit_timer);
__main_loop_is_terminating = TRUE;
}
static gboolean
log_db_parser_init(LogPipe *s)
{
LogDBParser *self = (LogDBParser *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
self->db = cfg_persist_config_fetch(cfg, log_db_parser_format_persist_name(self));
if (self->db)
{
struct stat st;
if (stat(self->db_file, &st) < 0)
{
msg_error("Error stating pattern database file, no automatic reload will be performed",
evt_tag_str("error", g_strerror(errno)),
NULL);
}
else if (self->db_file_inode != st.st_ino || self->db_file_mtime != st.st_mtime)
{
self->db = pattern_db_new();
log_db_parser_reload_database(self);
self->db_file_inode = st.st_ino;
self->db_file_mtime = st.st_mtime;
}
}
else
{
self->db = pattern_db_new();
log_db_parser_reload_database(self);
}
if (self->db)
pattern_db_set_emit_func(self->db, log_db_parser_emit, self);
iv_validate_now();
IV_TIMER_INIT(&self->tick);
self->tick.cookie = self;
self->tick.handler = log_db_parser_timer_tick;
self->tick.expires = iv_now;
self->tick.expires.tv_sec++;
self->tick.expires.tv_nsec = 0;
iv_timer_register(&self->tick);
return self->db != NULL;
}
PollEvents *
poll_file_changes_new(gint fd, const gchar *follow_filename, gint follow_freq, LogPipe *control)
{
PollFileChanges *self = g_new0(PollFileChanges, 1);
self->super.stop_watches = poll_file_changes_stop_watches;
self->super.update_watches = poll_file_changes_update_watches;
self->super.free_fn = poll_file_changes_free;
self->fd = fd;
self->follow_filename = g_strdup(follow_filename);
self->follow_freq = follow_freq;
self->control = log_pipe_ref(control);
IV_TIMER_INIT(&self->follow_timer);
self->follow_timer.cookie = self;
self->follow_timer.handler = poll_file_changes_check_file;
return &self->super;
}
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_SIGNAL_INIT(&is);
is.signum = SIGUSR1;
is.handler = got_sig;
iv_signal_register(&is);
iv_validate_now();
tim_start = iv_now;
raise(SIGUSR1);
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 %ld nsec => %d/sec\n",
iv_poll_method_name(), sig_received, (long)nsec,
(int)(1000000000ULL * sig_received / nsec));
return 0;
}
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_RAW_INIT(&ev);
ev.handler = got_ev;
iv_event_raw_register(&ev);
iv_validate_now();
tim_start = iv_now;
iv_event_raw_post(&ev);
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 %ld nsec => %d/sec\n",
iv_poll_method_name(), ev_received, (long)nsec,
(int)(1000000000ULL * ev_received / nsec));
return 0;
}
int main()
{
alarm(5);
iv_init();
IV_TASK_INIT(&task);
task.handler = handler_task;
iv_task_register(&task);
IV_TIMER_INIT(&timer);
iv_validate_now();
timer.expires = iv_now;
timer.expires.tv_sec--;
timer.handler = handler_timer;
iv_main();
iv_deinit();
return !success;
}
void dgp_reader_register(struct dgp_reader *dr)
{
dr->bytes = 0;
if (dr->remoteid != NULL) {
dr->adj_rib_in.myid = dr->myid;
dr->adj_rib_in.remoteid = dr->remoteid;
adj_rib_in_init(&dr->adj_rib_in);
dr->to_loc.dest = dr->rib;
rib_listener_to_loc_init(&dr->to_loc);
adj_rib_in_listener_register(&dr->adj_rib_in, &dr->to_loc.rl);
}
IV_TIMER_INIT(&dr->keepalive_timeout);
iv_validate_now();
dr->keepalive_timeout.expires = iv_now;
timespec_add_ms(&dr->keepalive_timeout.expires,
1000 * KEEPALIVE_TIMEOUT, 1000 * KEEPALIVE_TIMEOUT);
dr->keepalive_timeout.cookie = dr;
dr->keepalive_timeout.handler = dgp_reader_keepalive_timeout;
iv_timer_register(&dr->keepalive_timeout);
}
void
__test_fd_handling(Journald *journald)
{
gint fd = journald_get_fd(journald);
journald_process(journald);
task_called = FALSE;
poll_triggered = FALSE;
struct iv_task add_entry_task;
struct iv_fd fd_to_poll;
struct iv_timer stop_timer;
IV_TASK_INIT(&add_entry_task);
add_entry_task.cookie = journald;
add_entry_task.handler = add_mock_entries;
IV_FD_INIT(&fd_to_poll);
fd_to_poll.fd = fd;
fd_to_poll.cookie = journald;
fd_to_poll.handler_in = handle_new_entry;
iv_validate_now();
IV_TIMER_INIT(&stop_timer);
stop_timer.cookie = NULL;
stop_timer.expires = iv_now;
stop_timer.expires.tv_sec++;
stop_timer.handler = stop_timer_expired;
iv_task_register(&add_entry_task);
iv_fd_register(&fd_to_poll);
iv_timer_register(&stop_timer);
iv_main();
assert_true(poll_triggered, ASSERTION_ERROR("Poll event isn't triggered"));
}
static void
log_reader_init_watches(LogReader *self)
{
IV_TASK_INIT(&self->restart_task);
self->restart_task.cookie = self;
self->restart_task.handler = log_reader_io_process_input;
IV_EVENT_INIT(&self->schedule_wakeup);
self->schedule_wakeup.cookie = self;
self->schedule_wakeup.handler = log_reader_wakeup_triggered;
IV_EVENT_INIT(&self->last_msg_sent_event);
self->last_msg_sent_event.cookie = self;
self->last_msg_sent_event.handler = _last_msg_sent;
IV_TIMER_INIT(&self->idle_timer);
self->idle_timer.cookie = self;
self->idle_timer.handler = log_reader_idle_timeout;
main_loop_io_worker_job_init(&self->io_job);
self->io_job.user_data = self;
self->io_job.work = (void (*)(void *)) log_reader_work_perform;
self->io_job.completion = (void (*)(void *)) log_reader_work_finished;
}
