static void
log_threaded_dest_driver_stop_watches(LogThrDestDriver* self)
{
if (iv_task_registered(&self->do_work))
{
iv_task_unregister(&self->do_work);
}
if (iv_timer_registered(&self->timer_reopen))
{
iv_timer_unregister(&self->timer_reopen);
}
if (iv_timer_registered(&self->timer_throttle))
{
iv_timer_unregister(&self->timer_throttle);
}
}
/* unregister the underlying ivykis timer, can only be called from the main thread. */
void
ml_batched_timer_unregister(MlBatchedTimer *self)
{
if (iv_timer_registered(&self->timer))
iv_timer_unregister(&self->timer);
self->updated = TRUE;
}
static void
poll_file_changes_stop_watches(PollEvents *s)
{
PollFileChanges *self = (PollFileChanges *) s;
if (iv_timer_registered(&self->follow_timer))
iv_timer_unregister(&self->follow_timer);
}
static void
log_writer_stop_watches(LogWriter *self)
{
if (self->watches_running)
{
if (iv_timer_registered(&self->reopen_timer))
iv_timer_unregister(&self->reopen_timer);
if (iv_timer_registered(&self->suspend_timer))
iv_timer_unregister(&self->suspend_timer);
if (iv_fd_registered(&self->fd_watch))
iv_fd_unregister(&self->fd_watch);
if (iv_task_registered(&self->immed_io_task))
iv_task_unregister(&self->immed_io_task);
log_queue_reset_parallel_push(self->queue);
self->watches_running = FALSE;
}
}
void dgp_reader_unregister(struct dgp_reader *dr)
{
if (dr->remoteid != NULL) {
adj_rib_in_truncate(&dr->adj_rib_in);
rib_listener_to_loc_deinit(&dr->to_loc);
}
if (iv_timer_registered(&dr->keepalive_timeout))
iv_timer_unregister(&dr->keepalive_timeout);
}
static void
log_reader_stop_watches(LogReader *self)
{
if (iv_fd_registered(&self->fd_watch))
iv_fd_unregister(&self->fd_watch);
if (iv_timer_registered(&self->follow_timer))
iv_timer_unregister(&self->follow_timer);
if (iv_task_registered(&self->restart_task))
iv_task_unregister(&self->restart_task);
}
void
log_writer_arm_suspend_timer(LogWriter *self, void (*handler)(void *), gint timeout_msec)
{
if (iv_timer_registered(&self->suspend_timer))
iv_timer_unregister(&self->suspend_timer);
iv_validate_now();
self->suspend_timer.handler = handler;
self->suspend_timer.expires = iv_now;
timespec_add_msec(&self->suspend_timer.expires, timeout_msec);
iv_timer_register(&self->suspend_timer);
}
static void
trigger_source_stop_watches (TriggerSource *self)
{
if (!self->watches_running)
return;
if (iv_timer_registered (&self->trigger_timer))
iv_timer_unregister (&self->trigger_timer);
self->watches_running = FALSE;
}
static void
afinter_source_stop_watches(AFInterSource *self)
{
if (self->watches_running)
{
if (iv_task_registered(&self->restart_task))
iv_task_unregister(&self->restart_task);
if (iv_timer_registered(&self->mark_timer))
iv_timer_unregister(&self->mark_timer);
self->watches_running = FALSE;
}
}
static void
afsocket_dd_start_reconnect_timer(AFSocketDestDriver *self)
{
main_loop_assert_main_thread();
if (iv_timer_registered(&self->reconnect_timer))
iv_timer_unregister(&self->reconnect_timer);
iv_validate_now();
self->reconnect_timer.expires = iv_now;
timespec_add_msec(&self->reconnect_timer.expires, self->time_reopen * 1000);
iv_timer_register(&self->reconnect_timer);
}
/* function called using main_loop_call() in case the suppress timer needs
* to be updated. It is running in the main thread, thus is able to
* reregister our ivykis timer */
static void
ml_batched_timer_perform_update(MlBatchedTimer *self)
{
main_loop_assert_main_thread();
if (iv_timer_registered(&self->timer))
iv_timer_unregister(&self->timer);
self->timer.expires = self->expires;
if (self->timer.expires.tv_sec > 0)
iv_timer_register(&self->timer);
self->unref_cookie(self->cookie);
}
static gboolean
log_db_parser_deinit(LogPipe *s)
{
LogDBParser *self = (LogDBParser *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
if (iv_timer_registered(&self->tick))
{
iv_timer_unregister(&self->tick);
}
cfg_persist_config_add(cfg, log_db_parser_format_persist_name(self), self->db, (GDestroyNotify) pattern_db_free, FALSE);
self->db = NULL;
return TRUE;
}
/* function called using main_loop_call() in case the suppress timer needs
* to be updated */
static void
log_writer_perform_suppress_timer_update(LogWriter *self)
{
main_loop_assert_main_thread();
if (iv_timer_registered(&self->suppress_timer))
iv_timer_unregister(&self->suppress_timer);
g_static_mutex_lock(&self->suppress_lock);
self->suppress_timer.expires = self->suppress_timer_expires;
self->suppress_timer_updated = TRUE;
g_static_mutex_unlock(&self->suppress_lock);
if (self->suppress_timer.expires.tv_sec > 0)
iv_timer_register(&self->suppress_timer);
log_pipe_unref(&self->super);
}
static void
afsocket_dd_stop_watches(AFSocketDestDriver *self)
{
main_loop_assert_main_thread();
if (iv_fd_registered(&self->connect_fd))
{
iv_fd_unregister(&self->connect_fd);
/* need to close the fd in this case as it wasn't established yet */
msg_verbose("Closing connecting fd",
evt_tag_int("fd", self->fd));
close(self->fd);
}
if (iv_timer_registered(&self->reconnect_timer))
iv_timer_unregister(&self->reconnect_timer);
}
static void
log_reader_update_watches(LogReader *self)
{
gint fd;
GIOCondition cond;
gboolean free_to_send;
main_loop_assert_main_thread();
self->suspended = FALSE;
free_to_send = log_source_free_to_send(&self->super);
if (!free_to_send ||
self->immediate_check ||
log_proto_prepare(self->proto, &fd, &cond))
{
/* we disable all I/O related callbacks here because we either know
* that we can continue (e.g. immediate_check == TRUE) or we know
* that we can't continue even if data would be available (e.g.
* free_to_send == FALSE)
*/
self->immediate_check = FALSE;
if (iv_fd_registered(&self->fd_watch))
{
iv_fd_set_handler_in(&self->fd_watch, NULL);
iv_fd_set_handler_out(&self->fd_watch, NULL);
/* we disable the error handler too, as it might be
* triggered even when we don't want to read data
* (e.g. log_source_free_to_send() is FALSE).
*
* And at least on Linux, it may happen that EPOLLERR is
* set, while there's still data in the socket buffer. Thus
* in reaction to an EPOLLERR, we could possibly send
* further messages without validating the
* log_source_free_to_send() would allow us to, potentially
* overflowing our window (and causing a failed assertion in
* log_source_queue().
*/
iv_fd_set_handler_err(&self->fd_watch, NULL);
}
if (iv_timer_registered(&self->follow_timer))
iv_timer_unregister(&self->follow_timer);
if (free_to_send)
{
/* we have data in our input buffer, we need to start working
* on it immediately, without waiting for I/O events */
if (!iv_task_registered(&self->restart_task))
{
iv_task_register(&self->restart_task);
}
}
else
{
self->suspended = TRUE;
}
return;
}
if (iv_fd_registered(&self->fd_watch))
{
/* this branch is executed when our fd is connected to a non-file
* source (e.g. TCP, UDP socket). We set up I/O callbacks here.
* files cannot be polled using epoll, as it causes an I/O error
* (thus abort in ivykis).
*/
if (cond & G_IO_IN)
iv_fd_set_handler_in(&self->fd_watch, log_reader_io_process_input);
else
iv_fd_set_handler_in(&self->fd_watch, NULL);
if (cond & G_IO_OUT)
iv_fd_set_handler_out(&self->fd_watch, log_reader_io_process_input);
else
iv_fd_set_handler_out(&self->fd_watch, NULL);
if (cond & (G_IO_IN + G_IO_OUT))
iv_fd_set_handler_err(&self->fd_watch, log_reader_io_process_input);
else
iv_fd_set_handler_err(&self->fd_watch, NULL);
}
else
{
if (self->options->follow_freq > 0)
{
if (iv_timer_registered(&self->follow_timer))
iv_timer_unregister(&self->follow_timer);
iv_validate_now();
self->follow_timer.expires = iv_now;
timespec_add_msec(&self->follow_timer.expires, self->options->follow_freq);
iv_timer_register(&self->follow_timer);
}
else
{
/* NOTE: we don't need to unregister the timer here as follow_freq
* never changes during runtime, thus if ever it was registered that
* also means that we go into the if branch above. */
}
}
}
static void
log_reader_stop_idle_timer(LogReader *self)
{
if (iv_timer_registered(&self->idle_timer))
iv_timer_unregister(&self->idle_timer);
}
