static void iv_work_thread_got_event(void *_thr)
{
struct work_pool_thread *thr = _thr;
struct work_pool_priv *pool = thr->pool;
uint32_t last_seq;
mutex_lock(&pool->lock);
thr->kicked = 0;
if (!iv_list_empty(&thr->list)) {
iv_list_del_init(&thr->list);
iv_timer_unregister(&thr->idle_timer);
}
last_seq = pool->seq_tail;
while ((int32_t)(last_seq - pool->seq_head) > 0) {
struct iv_work_item *work;
pool->seq_head++;
work = iv_container_of(pool->work_items.next,
struct iv_work_item, list);
iv_list_del(&work->list);
mutex_unlock(&pool->lock);
work->work(work->cookie);
iv_invalidate_now();
mutex_lock(&pool->lock);
if (iv_list_empty(&pool->work_done))
iv_event_post(&pool->ev);
iv_list_add_tail(&work->list, &pool->work_done);
}
if (pool->seq_head == pool->seq_tail) {
if (!pool->shutting_down) {
iv_list_add(&thr->list, &pool->idle_threads);
iv_validate_now();
thr->idle_timer.expires = iv_now;
thr->idle_timer.expires.tv_sec += 10;
iv_timer_register(&thr->idle_timer);
} else {
__iv_work_thread_die(thr);
}
} else {
/*
* If we're already at the maximum number of pool
* threads, and none of those threads were idle when
* more work arrived, then there may have been no
* kick sent for the new work item(s) (and no new
* pool thread started either), so if we're leaving
* with work items still pending, make sure we get
* called again, so that we don't deadlock.
*/
iv_event_post(&thr->kick);
}
mutex_unlock(&pool->lock);
}
void iv_fd_make_ready(struct iv_list_head *active, struct iv_fd_ *fd, int bands)
{
if (iv_list_empty(&fd->list_active)) {
fd->ready_bands = 0;
iv_list_add_tail(&fd->list_active, active);
}
fd->ready_bands |= bands;
}
/*
* 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;
}
void iv_task_register(struct iv_task *_t)
{
struct iv_state *st = iv_get_state();
struct iv_task_ *t = (struct iv_task_ *)_t;
if (!iv_list_empty(&t->list))
iv_fatal("iv_task_register: called with task still on a list");
st->numobjs++;
iv_list_add_tail(&t->list, &st->tasks);
}
static void iv_fd_kqueue_notify_fd(struct iv_state *st, struct iv_fd_ *fd)
{
iv_list_del_init(&fd->list_notify);
if (fd->registered_bands != fd->wanted_bands)
iv_list_add_tail(&fd->list_notify, &st->u.kqueue.notify);
}
static int iv_fd_port_poll(struct iv_state *st,
struct iv_list_head *active,
const struct timespec *abs)
{
struct timespec _rel;
struct timespec *rel;
int run_timers;
int run_events;
unsigned int nget;
port_event_t pe[PORTEV_NUM];
int ret;
int i;
iv_fd_port_upload(st);
rel = to_relative(st, &_rel, abs);
run_timers = 0;
if (rel != NULL && rel->tv_sec == 0 && rel->tv_nsec == 0)
run_timers = 1;
run_events = 0;
poll_more:
nget = 1;
/*
* If we get EINTR from port_getn(), no events are returned
* and nget will not have been updated, but if we get ETIME,
* events may be returned, and nget will be set to the number
* of events in the array, and we need to process those
* events as usual.
*/
ret = port_getn(st->u.port.port_fd, pe, PORTEV_NUM, &nget, rel);
__iv_invalidate_now(st);
if (ret < 0 && errno != ETIME) {
if (errno == EINTR)
return run_timers;
iv_fatal("iv_fd_port_poll: got error %d[%s]", errno,
strerror(errno));
}
if (ret < 0 && errno == ETIME)
run_timers = 1;
for (i = 0; i < nget; i++) {
int source;
source = pe[i].portev_source;
if (source == PORT_SOURCE_FD) {
int revents;
struct iv_fd_ *fd;
revents = pe[i].portev_events;
fd = pe[i].portev_user;
if (revents & (POLLIN | POLLERR | POLLHUP))
iv_fd_make_ready(active, fd, MASKIN);
if (revents & (POLLOUT | POLLERR | POLLHUP))
iv_fd_make_ready(active, fd, MASKOUT);
if (revents & (POLLERR | POLLHUP))
iv_fd_make_ready(active, fd, MASKERR);
fd->registered_bands = 0;
iv_list_del_init(&fd->list_notify);
if (fd->wanted_bands) {
iv_list_add_tail(&fd->list_notify,
&st->u.port.notify);
}
} else if (source == PORT_SOURCE_TIMER) {
run_timers = 1;
} else if (source == PORT_SOURCE_USER) {
run_events = 1;
} else {
iv_fatal("iv_fd_port_poll: received event "
"from unknown source %d", source);
}
}
if (nget == PORTEV_NUM) {
run_timers = 1;
rel = &_rel;
rel->tv_sec = 0;
rel->tv_nsec = 0;
goto poll_more;
}
if (run_events)
iv_event_run_pending_events();
return run_timers;
}
/**
* Assumed to be called from one of the input threads. If the thread_id
* cannot be determined, the item is put directly in the wait queue.
*
* Puts the message to the queue, and logs an error if it caused the
* queue to be full.
*
* It attempts to put the item to the per-thread input queue.
*
* NOTE: It consumes the reference passed by the caller.
**/
static void
log_queue_fifo_push_tail(LogQueue *s, LogMessage *msg, const LogPathOptions *path_options)
{
LogQueueFifo *self = (LogQueueFifo *) s;
gint thread_id;
LogMessageQueueNode *node;
thread_id = main_loop_io_worker_thread_id();
g_assert(thread_id < 0 || log_queue_max_threads > thread_id);
/* NOTE: we don't use high-water marks for now, as log_fetch_limit
* limits the number of items placed on the per-thread input queue
* anyway, and any sane number decreased the performance measurably.
*
* This means that per-thread input queues contain _all_ items that
* a single poll iteration produces. And once the reader is finished
* (either because the input is depleted or because of
* log_fetch_limit / window_size) the whole bunch is propagated to
* the "wait" queue.
*/
if (thread_id >= 0) {
/* fastpath, use per-thread input FIFOs */
if (!self->qoverflow_input[thread_id].finish_cb_registered)
{
/* this is the first item in the input FIFO, register a finish
* callback to make sure it gets moved to the wait_queue if the
* input thread finishes */
main_loop_io_worker_register_finish_callback(&self->qoverflow_input[thread_id].cb);
self->qoverflow_input[thread_id].finish_cb_registered = TRUE;
}
node = log_msg_alloc_queue_node(msg, path_options);
iv_list_add_tail(&node->list, &self->qoverflow_input[thread_id].items);
self->qoverflow_input[thread_id].len++;
log_msg_unref(msg);
return;
}
/* slow path, put the pending item and the whole input queue to the wait_queue */
g_static_mutex_lock(&self->super.lock);
if (thread_id >= 0)
log_queue_fifo_move_input_unlocked(self, thread_id);
if (log_queue_fifo_get_length(s) < self->qoverflow_size)
{
node = log_msg_alloc_queue_node(msg, path_options);
iv_list_add_tail(&node->list, &self->qoverflow_wait);
self->qoverflow_wait_len++;
log_queue_push_notify(&self->super);
stats_counter_inc(self->super.stored_messages);
g_static_mutex_unlock(&self->super.lock);
log_msg_unref(msg);
}
else
{
stats_counter_inc(self->super.dropped_messages);
g_static_mutex_unlock(&self->super.lock);
log_msg_drop(msg, path_options);
msg_debug("Destination queue full, dropping message",
evt_tag_int("queue_len", log_queue_fifo_get_length(&self->super)),
evt_tag_int("log_fifo_size", self->qoverflow_size),
NULL);
}
return;
}
