static void open_child_request(struct req *req)
{
int f;
IV_POPEN_REQUEST_INIT(&req->popen_req);
req->popen_req.file = "/usr/bin/vmstat";
req->argv[0] = "/usr/bin/vmstat";
req->argv[1] = "1";
req->argv[2] = NULL;
req->popen_req.argv = req->argv;
req->popen_req.type = "r";
f = iv_popen_request_submit(&req->popen_req);
printf("submitted the popen request, fd is %d\n", f);
IV_FD_INIT(&req->popen_fd);
req->popen_fd.fd = f;
req->popen_fd.cookie = req;
req->popen_fd.handler_in = got_data;
iv_fd_register(&req->popen_fd);
IV_TIMER_INIT(&req->closeit);
iv_validate_now();
req->closeit.expires = iv_now;
req->closeit.expires.tv_sec += 5;
req->closeit.cookie = req;
req->closeit.handler = do_close;
iv_timer_register(&req->closeit);
}
static void
log_threaded_dest_driver_do_work(gpointer data)
{
LogThrDestDriver *self = (LogThrDestDriver *)data;
gint timeout_msec = 0;
self->suspended = FALSE;
log_threaded_dest_driver_stop_watches(self);
if (!self->worker.connected)
{
__connect(self);
}
else if (log_queue_check_items(self->queue, &timeout_msec,
log_threaded_dest_driver_message_became_available_in_the_queue,
self, NULL))
{
log_threaded_dest_driver_do_insert(self);
if (!self->suspended)
log_threaded_dest_driver_start_watches(self);
}
else if (timeout_msec != 0)
{
log_queue_reset_parallel_push(self->queue);
iv_validate_now();
self->timer_throttle.expires = iv_now;
timespec_add_msec(&self->timer_throttle.expires, timeout_msec);
iv_timer_register(&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);
}
void
log_threaded_dest_driver_suspend(LogThrDestDriver *self)
{
iv_validate_now();
self->timer_reopen.expires = iv_now;
self->timer_reopen.expires.tv_sec += self->time_reopen;
iv_timer_register(&self->timer_reopen);
}
static void
poll_file_changes_rearm_timer(PollFileChanges *self)
{
iv_validate_now();
self->follow_timer.expires = iv_now;
timespec_add_msec(&self->follow_timer.expires, self->follow_freq);
iv_timer_register(&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;
}
static void
affile_dw_arm_reaper(AFFileDestWriter *self)
{
/* not yet reaped, set up the next callback */
iv_validate_now();
self->reap_timer.expires = iv_now;
timespec_add_msec(&self->reap_timer.expires, self->owner->time_reap * 1000 / 2);
iv_timer_register(&self->reap_timer);
}
static void
log_db_parser_timer_tick(gpointer s)
{
LogDBParser *self = (LogDBParser *) s;
pattern_db_timer_tick(self->db);
self->tick.expires.tv_sec++;
iv_timer_register(&self->tick);
}
static void
log_reader_update_watches(LogReader *self)
{
GIOCondition cond;
gint idle_timeout = -1;
main_loop_assert_main_thread();
log_reader_stop_idle_timer(self);
if (!log_reader_is_opened(self))
return;
log_reader_start_watches_if_stopped(self);
gboolean free_to_send = log_source_free_to_send(&self->super);
if (!free_to_send)
{
log_reader_suspend_until_awoken(self);
return;
}
LogProtoPrepareAction prepare_action = log_proto_server_prepare(self->proto, &cond, &idle_timeout);
if (idle_timeout > 0)
{
iv_validate_now();
self->idle_timer.expires = iv_now;
self->idle_timer.expires.tv_sec += idle_timeout;
iv_timer_register(&self->idle_timer);
}
if (self->immediate_check)
{
log_reader_force_check_in_next_poll(self);
return;
}
switch (prepare_action)
{
case LPPA_POLL_IO:
poll_events_update_watches(self->poll_events, cond);
break;
case LPPA_FORCE_SCHEDULE_FETCH:
log_reader_force_check_in_next_poll(self);
break;
case LPPA_SUSPEND:
log_reader_suspend_until_awoken(self);
break;
default:
g_assert_not_reached();
break;
}
}
static void
trigger_source_start_watches (TriggerSource *self)
{
if (self->watches_running)
return;
if (self->trigger_timer.expires.tv_sec >= 0)
iv_timer_register (&self->trigger_timer);
self->watches_running = TRUE;
}
static void
afinter_source_start_watches(AFInterSource *self)
{
if (!self->watches_running)
{
if (self->mark_timer.expires.tv_sec >= 0)
iv_timer_register(&self->mark_timer);
self->watches_running = TRUE;
}
}
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 gotev0(void *_x)
{
printf("got ev0\n");
iv_event_raw_unregister(&ev0);
IV_TIMER_INIT(&ev1);
iv_validate_now();
ev1.expires = iv_now;
ev1.expires.tv_sec++;
ev1.handler = gotev1;
iv_timer_register(&ev1);
}
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);
}
/* 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);
}
/* NOTE: the return value is only used during initialization, and it is not
* expected that it'd change once it returns success */
static gboolean
log_reader_start_watches(LogReader *self)
{
gint fd;
GIOCondition cond;
log_proto_prepare(self->proto, &fd, &cond);
if (self->options->follow_freq > 0)
{
/* follow freq specified (only the file source does that, go into timed polling */
/* NOTE: the fd may not be set here, as it may not have been opened yet */
iv_timer_register(&self->follow_timer);
}
else if (fd < 0)
{
msg_error("In order to poll non-yet-existing files, follow_freq() must be set",
NULL);
return FALSE;
}
else
{
/* we have an FD, it is possible to poll it, register it */
self->fd_watch.fd = fd;
if (self->pollable_state < 0)
{
if (iv_fd_register_try(&self->fd_watch) == 0)
self->pollable_state = 1;
else
self->pollable_state = 0;
}
else if (self->pollable_state > 0)
{
iv_fd_register(&self->fd_watch);
}
else
{
msg_error("Unable to determine how to monitor this fd, follow_freq() not set and it is not possible to poll it with the current ivykis polling method, try changing IV_EXCLUDE_POLL_METHOD environment variable",
evt_tag_int("fd", fd),
NULL);
return FALSE;
}
}
log_reader_update_watches(self);
return TRUE;
}
static void
main_loop_exit_initiate(void)
{
if (main_loop_is_terminating())
return;
msg_notice("syslog-ng shutting down",
evt_tag_str("version", SYSLOG_NG_VERSION));
IV_TIMER_INIT(&main_loop_exit_timer);
iv_validate_now();
main_loop_exit_timer.expires = iv_now;
main_loop_exit_timer.handler = main_loop_exit_timer_elapsed;
timespec_add_msec(&main_loop_exit_timer.expires, 100);
iv_timer_register(&main_loop_exit_timer);
__main_loop_is_terminating = TRUE;
}
static void iv_work_thread_idle_timeout(void *_thr)
{
struct work_pool_thread *thr = _thr;
struct work_pool_priv *pool = thr->pool;
mutex_lock(&pool->lock);
if (thr->kicked) {
thr->idle_timer.expires = iv_now;
thr->idle_timer.expires.tv_sec += 10;
iv_timer_register(&thr->idle_timer);
} else {
iv_list_del_init(&thr->list);
__iv_work_thread_die(thr);
}
mutex_unlock(&pool->lock);
}
static gboolean
log_db_parser_init(LogPipe *s)
{
LogDBParser *self = (LogDBParser *) s;
GlobalConfig *cfg = log_pipe_get_config(s);
self->db = cfg_persist_config_fetch(cfg, log_db_parser_format_persist_name(self));
if (self->db)
{
struct stat st;
if (stat(self->db_file, &st) < 0)
{
msg_error("Error stating pattern database file, no automatic reload will be performed",
evt_tag_str("error", g_strerror(errno)),
NULL);
}
else if (self->db_file_inode != st.st_ino || self->db_file_mtime != st.st_mtime)
{
self->db = pattern_db_new();
log_db_parser_reload_database(self);
self->db_file_inode = st.st_ino;
self->db_file_mtime = st.st_mtime;
}
}
else
{
self->db = pattern_db_new();
log_db_parser_reload_database(self);
}
if (self->db)
pattern_db_set_emit_func(self->db, log_db_parser_emit, self);
iv_validate_now();
IV_TIMER_INIT(&self->tick);
self->tick.cookie = self;
self->tick.handler = log_db_parser_timer_tick;
self->tick.expires = iv_now;
self->tick.expires.tv_sec++;
self->tick.expires.tv_nsec = 0;
iv_timer_register(&self->tick);
return self->db != NULL;
}
int main()
{
long long nsec;
iv_init();
#ifdef USE_SIGNAL
signal(SIGALRM, got_signal_timeout);
alarm(5);
#else
IV_TIMER_INIT(&timeout);
iv_validate_now();
timeout.expires = iv_now;
timeout.expires.tv_sec += 5;
timeout.handler = got_timer_timeout;
iv_timer_register(&timeout);
#endif
IV_SIGNAL_INIT(&is);
is.signum = SIGUSR1;
is.handler = got_sig;
iv_signal_register(&is);
iv_validate_now();
tim_start = iv_now;
raise(SIGUSR1);
iv_main();
iv_deinit();
nsec = 1000000000ULL * (tim_end.tv_sec - tim_start.tv_sec) +
(tim_end.tv_nsec - tim_start.tv_nsec);
printf("%s: %d in %ld nsec => %d/sec\n",
iv_poll_method_name(), sig_received, (long)nsec,
(int)(1000000000ULL * sig_received / nsec));
return 0;
}
int main()
{
long long nsec;
iv_init();
#ifdef USE_SIGNAL
signal(SIGALRM, got_signal_timeout);
alarm(5);
#else
IV_TIMER_INIT(&timeout);
iv_validate_now();
timeout.expires = iv_now;
timeout.expires.tv_sec += 5;
timeout.handler = got_timer_timeout;
iv_timer_register(&timeout);
#endif
IV_EVENT_RAW_INIT(&ev);
ev.handler = got_ev;
iv_event_raw_register(&ev);
iv_validate_now();
tim_start = iv_now;
iv_event_raw_post(&ev);
iv_main();
iv_deinit();
nsec = 1000000000ULL * (tim_end.tv_sec - tim_start.tv_sec) +
(tim_end.tv_nsec - tim_start.tv_nsec);
printf("%s: %d in %ld nsec => %d/sec\n",
iv_poll_method_name(), ev_received, (long)nsec,
(int)(1000000000ULL * ev_received / nsec));
return 0;
}
void write_stats_to_log_handler(void *arg)
{
int idx;
struct iface_util_by_time info;
char timestamp[TIMESTAMP_SIZE];
get_timestamp(timestamp, sizeof(timestamp));
log_write("=========================================================================\n");
log_write("TIMESTAMP: %s\n", timestamp);
for( idx = 0; idx < ifaces_cnt; idx++ ) {
log_write("Interface %s:\n", iface_info_instances[idx].iface_name);
get_util_for_util_last_10_sec(&info, &iface_info_instances[idx]);
log_write("\tUtilization for last 10 sec: ");
log_write(" RX: %.5f Mbps,", info.rx_mbytes_per_sec);
log_write(" TX: %.5f Mbps\n", info.tx_mbytes_per_sec);
get_util_for_util_last_30_sec(&info, &iface_info_instances[idx]);
log_write("\tUtilization for last 30 sec: ");
log_write(" RX: %.5f Mbps,", info.rx_mbytes_per_sec);
log_write(" TX: %.5f Mbps\n", info.tx_mbytes_per_sec);
get_util_for_util_last_60_sec(&info, &iface_info_instances[idx]);
log_write("\tUtilization for last 60 sec: ");
log_write(" RX: %.5f Mbps,", info.rx_mbytes_per_sec);
log_write(" TX: %.5f Mbps\n", info.tx_mbytes_per_sec);
log_write("\n");
}
log_write("=========================================================================\n");
iv_validate_now();
log_timer.expires = iv_now;
log_timer.expires.tv_sec += WRITE_STATS_PERIOD;
iv_timer_register(&log_timer);
}
void
__test_fd_handling(Journald *journald)
{
gint fd = journald_get_fd(journald);
journald_process(journald);
task_called = FALSE;
poll_triggered = FALSE;
struct iv_task add_entry_task;
struct iv_fd fd_to_poll;
struct iv_timer stop_timer;
IV_TASK_INIT(&add_entry_task);
add_entry_task.cookie = journald;
add_entry_task.handler = add_mock_entries;
IV_FD_INIT(&fd_to_poll);
fd_to_poll.fd = fd;
fd_to_poll.cookie = journald;
fd_to_poll.handler_in = handle_new_entry;
iv_validate_now();
IV_TIMER_INIT(&stop_timer);
stop_timer.cookie = NULL;
stop_timer.expires = iv_now;
stop_timer.expires.tv_sec++;
stop_timer.handler = stop_timer_expired;
iv_task_register(&add_entry_task);
iv_fd_register(&fd_to_poll);
iv_timer_register(&stop_timer);
iv_main();
assert_true(poll_triggered, ASSERTION_ERROR("Poll event isn't triggered"));
}
void dgp_reader_register(struct dgp_reader *dr)
{
dr->bytes = 0;
if (dr->remoteid != NULL) {
dr->adj_rib_in.myid = dr->myid;
dr->adj_rib_in.remoteid = dr->remoteid;
adj_rib_in_init(&dr->adj_rib_in);
dr->to_loc.dest = dr->rib;
rib_listener_to_loc_init(&dr->to_loc);
adj_rib_in_listener_register(&dr->adj_rib_in, &dr->to_loc.rl);
}
IV_TIMER_INIT(&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);
dr->keepalive_timeout.cookie = dr;
dr->keepalive_timeout.handler = dgp_reader_keepalive_timeout;
iv_timer_register(&dr->keepalive_timeout);
}
static void handler_task(void *_t)
{
iv_timer_register(&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. */
}
}
}
