/* run in the main thread in reaction to a log_reader_reopen to change
* the source LogProto instance. It needs to be ran in the main
* thread as it reregisters the watches associated with the main
* thread. */
void
log_reader_reopen_deferred(gpointer s)
{
gpointer *args = (gpointer *) s;
LogReader *self = args[0];
LogProto *proto = args[1];
log_reader_stop_watches(self);
if (self->io_job.working)
{
/* NOTE: proto can be NULL */
self->pending_proto = proto;
self->pending_proto_present = TRUE;
return;
}
if (self->proto)
log_proto_free(self->proto);
self->proto = proto;
if(proto)
{
log_reader_start_watches(self);
}
}
static void
log_reader_fd_finalize(GSource *source)
{
LogReaderWatch *self = (LogReaderWatch *) source;
log_proto_free(self->proto);
log_pipe_unref(&self->reader->super.super);
}
static void
log_writer_work_finished(gpointer s)
{
LogWriter *self = (LogWriter *) s;
main_loop_assert_main_thread();
self->flush_waiting_for_timeout = FALSE;
if (self->pending_proto_present)
{
/* pending proto is only set in the main thread, so no need to
* lock it before coming here. After we're syncing with the
* log_writer_reopen() call, quite possibly coming from a
* non-main thread. */
g_static_mutex_lock(&self->pending_proto_lock);
if (self->proto)
log_proto_free(self->proto);
self->proto = self->pending_proto;
self->pending_proto = NULL;
self->pending_proto_present = FALSE;
g_cond_signal(self->pending_proto_cond);
g_static_mutex_unlock(&self->pending_proto_lock);
}
if (!self->work_result)
{
log_writer_broken(self, NC_WRITE_ERROR);
if (self->proto)
{
log_writer_suspend(self);
msg_notice("Suspending write operation because of an I/O error",
evt_tag_int("fd", log_proto_get_fd(self->proto)),
evt_tag_int("time_reopen", self->options->time_reopen),
NULL);
}
goto exit;
}
if ((self->super.flags & PIF_INITIALIZED) && self->proto)
{
/* reenable polling the source, but only if we're still initialized */
log_writer_start_watches(self);
}
exit:
log_pipe_unref(&self->super);
}
static void
log_reader_free(LogPipe *s)
{
LogReader *self = (LogReader *) s;
if (self->proto)
{
log_proto_free(self->proto);
self->proto = NULL;
}
log_pipe_unref(self->control);
g_sockaddr_unref(self->peer_addr);
g_free(self->follow_filename);
g_static_mutex_free(&self->pending_proto_lock);
g_cond_free(self->pending_proto_cond);
log_source_free(s);
}
static void
log_reader_work_finished(void *s)
{
LogReader *self = (LogReader *) s;
if (self->pending_proto_present)
{
/* pending proto is only set in the main thread, so no need to
* lock it before coming here. After we're syncing with the
* log_writer_reopen() call, quite possibly coming from a
* non-main thread. */
g_static_mutex_lock(&self->pending_proto_lock);
if (self->proto)
log_proto_free(self->proto);
self->proto = self->pending_proto;
self->pending_proto = NULL;
self->pending_proto_present = FALSE;
g_cond_signal(self->pending_proto_cond);
g_static_mutex_unlock(&self->pending_proto_lock);
}
if (self->notify_code)
{
gint notify_code = self->notify_code;
self->notify_code = 0;
log_pipe_notify(self->control, &self->super.super, notify_code, self);
}
if (self->super.super.flags & PIF_INITIALIZED)
{
/* reenable polling the source assuming that we're still in
* business (e.g. the reader hasn't been uninitialized) */
log_proto_reset_error(self->proto);
log_reader_start_watches(self);
}
log_pipe_unref(&self->super.super);
}
