/*
* Can only run from the output thread.
*/
static void
log_queue_fifo_ack_backlog(LogQueue *s, gint n)
{
LogQueueFifo *self = (LogQueueFifo *) s;
LogMessage *msg;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
gint i;
log_queue_assert_output_thread(s);
for (i = 0; i < n && self->qbacklog_len > 0; i++)
{
LogMessageQueueNode *node;
node = iv_list_entry(self->qbacklog.next, LogMessageQueueNode, list);
msg = node->msg;
path_options.ack_needed = node->ack_needed;
iv_list_del(&node->list);
log_msg_free_queue_node(node);
self->qbacklog_len--;
log_msg_ack(msg, &path_options);
log_msg_unref(msg);
}
}
/*
* Can only run from the output thread.
*
* NOTE: this returns a reference which the caller must take care to free.
*/
static LogMessage *
log_queue_fifo_pop_head(LogQueue *s, LogPathOptions *path_options)
{
LogQueueFifo *self = (LogQueueFifo *) s;
LogMessageQueueNode *node;
LogMessage *msg = NULL;
if (self->qoverflow_output_len == 0)
{
/* slow path, output queue is empty, get some elements from the wait queue */
g_static_mutex_lock(&self->super.lock);
iv_list_splice_tail_init(&self->qoverflow_wait, &self->qoverflow_output);
self->qoverflow_output_len = self->qoverflow_wait_len;
self->qoverflow_wait_len = 0;
g_static_mutex_unlock(&self->super.lock);
}
if (self->qoverflow_output_len > 0)
{
node = iv_list_entry(self->qoverflow_output.next, LogMessageQueueNode, list);
msg = node->msg;
path_options->ack_needed = node->ack_needed;
self->qoverflow_output_len--;
if (!self->super.use_backlog)
{
iv_list_del(&node->list);
log_msg_free_queue_node(node);
}
else
{
iv_list_del_init(&node->list);
}
}
else
{
/* no items either on the wait queue nor the output queue.
*
* NOTE: the input queues may contain items even in this case,
* however we don't touch them here, they'll be migrated to the
* wait_queue once the input threads finish their processing (or
* the high watermark is reached). Also, they are unlocked, so
* no way to touch them safely.
*/
return NULL;
}
stats_counter_dec(self->super.stored_messages);
if (self->super.use_backlog)
{
log_msg_ref(msg);
iv_list_add_tail(&node->list, &self->qbacklog);
self->qbacklog_len++;
}
return msg;
}
/* move items from the per-thread input queue to the lock-protected "wait" queue */
static void
log_queue_fifo_move_input_unlocked(LogQueueFifo *self, gint thread_id)
{
gint queue_len;
/* since we're in the input thread, queue_len will be racy. It can
* increase due to log_queue_fifo_push_head() and can also decrease as
* items are removed from the output queue using log_queue_pop_head().
*
* The only reason we're using it here is to check for qoverflow
* overflows, however the only side-effect of the race (if lost) is that
* we would lose a couple of message too many or add some more messages to
* qoverflow than permitted by the user. Since if flow-control is used,
* the fifo size should be sized larger than the potential window sizes,
* otherwise we can lose messages anyway, this is not deemed a cost to
* justify proper locking in this case.
*/
queue_len = log_queue_fifo_get_length(&self->super);
if (queue_len + self->qoverflow_input[thread_id].len > self->qoverflow_size)
{
/* slow path, the input thread's queue would overflow the queue, let's drop some messages */
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
gint i;
gint n;
/* NOTE: MAX is needed here to ensure that the lost race on queue_len
* doesn't result in n < 0 */
n = self->qoverflow_input[thread_id].len - MAX(0, (self->qoverflow_size - queue_len));
for (i = 0; i < n; i++)
{
LogMessageQueueNode *node = iv_list_entry(self->qoverflow_input[thread_id].items.next, LogMessageQueueNode, list);
LogMessage *msg = node->msg;
iv_list_del(&node->list);
self->qoverflow_input[thread_id].len--;
path_options.ack_needed = node->ack_needed;
stats_counter_inc(self->super.dropped_messages);
log_msg_free_queue_node(node);
log_msg_drop(msg, &path_options);
}
msg_debug("Destination queue full, dropping messages",
evt_tag_int("queue_len", queue_len),
evt_tag_int("log_fifo_size", self->qoverflow_size),
evt_tag_int("count", n),
evt_tag_str("persist_name", self->super.persist_name),
NULL);
}
stats_counter_add(self->super.stored_messages, self->qoverflow_input[thread_id].len);
iv_list_splice_tail_init(&self->qoverflow_input[thread_id].items, &self->qoverflow_wait);
self->qoverflow_wait_len += self->qoverflow_input[thread_id].len;
self->qoverflow_input[thread_id].len = 0;
}
static void
log_queue_fifo_free_queue(struct iv_list_head *q)
{
while (!iv_list_empty(q))
{
LogMessageQueueNode *node;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
LogMessage *msg;
node = iv_list_entry(q->next, LogMessageQueueNode, list);
iv_list_del(&node->list);
path_options.ack_needed = node->ack_needed;
msg = node->msg;
log_msg_free_queue_node(node);
log_msg_ack(msg, &path_options);
log_msg_unref(msg);
}
}
/*
* Can only run from the output thread.
*/
static void
log_queue_fifo_ack_backlog(LogQueue *s, gint rewind_count)
{
LogQueueFifo *self = (LogQueueFifo *) s;
LogMessage *msg;
LogPathOptions path_options = LOG_PATH_OPTIONS_INIT;
gint pos;
for (pos = 0; pos < rewind_count && self->qbacklog_len > 0; pos++)
{
LogMessageQueueNode *node;
node = iv_list_entry(self->qbacklog.next, LogMessageQueueNode, list);
msg = node->msg;
iv_list_del(&node->list);
self->qbacklog_len--;
path_options.ack_needed = node->ack_needed;
log_msg_ack(msg, &path_options, AT_PROCESSED);
log_msg_free_queue_node(node);
log_msg_unref(msg);
}
}
