/* 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 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); } }
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); }
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); }
int dgp_reader_read(struct dgp_reader *dr, int fd) { int ret; int off; do { ret = read(fd, dr->buf + dr->bytes, sizeof(dr->buf) - dr->bytes); } while (ret < 0 && errno == EINTR); if (ret <= 0) { if (ret < 0) { if (errno == EAGAIN) return 0; perror("dgp_reader_read"); } return -1; } dr->bytes += ret; iv_timer_unregister(&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); iv_timer_register(&dr->keepalive_timeout); off = 0; while (off < dr->bytes) { int len; struct lsa *lsa; len = lsa_deserialise(&lsa, dr->buf + off, dr->bytes - off); if (len < 0) return -1; if (len == 0) { if (off == 0 && dr->bytes == sizeof(dr->buf)) return -1; break; } if (lsa != NULL) { if (dr->remoteid != NULL) adj_rib_in_add_lsa(&dr->adj_rib_in, lsa); lsa_put(lsa); } off += len; } dr->bytes -= off; memmove(dr->buf, dr->buf + off, dr->bytes); return 0; }
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_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; } }
static void done(struct req *req, int timeout) { iv_popen_request_close(&req->popen_req); iv_fd_unregister(&req->popen_fd); close(req->popen_fd.fd); if (!timeout) iv_timer_unregister(&req->closeit); }
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); }
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; }
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 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); }
void iv_run_timers(struct iv_state *st) { while (st->num_timers) { struct iv_timer_ *t = *get_node(st, 1); if (!st->time_valid) { st->time_valid = 1; iv_time_get(&st->time); } if (timespec_gt(&t->expires, &st->time)) break; iv_timer_unregister((struct iv_timer *)t); t->handler(t->cookie); } }
static void iv_popen_running_child_wait(void *_ch, int status, struct rusage *rusage) { struct iv_popen_running_child *ch = _ch; if (!WIFEXITED(status) && !WIFSIGNALED(status)) return; iv_wait_interest_unregister(&ch->wait); if (ch->parent != NULL) ch->parent->child = NULL; else iv_timer_unregister(&ch->signal_timer); free(ch); }
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_stop_idle_timer(LogReader *self) { if (iv_timer_registered(&self->idle_timer)) iv_timer_unregister(&self->idle_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. */ } } }