static void adjust_squeue_for_time_change(squeue_t **q, int delta)
{
timed_event *event;
squeue_t *sq_new;
/*
* this is pretty inefficient in terms of free() + malloc(),
* but it should be pretty rare that we have to adjust times
* so we go with the well-tested codepath.
*/
sq_new = squeue_create(squeue_size(*q));
while ((event = squeue_pop(*q))) {
if (event->compensate_for_time_change == TRUE) {
if (event->timing_func) {
time_t (*timingfunc)(void);
timingfunc = event->timing_func;
event->run_time = timingfunc();
} else {
event->run_time += delta;
}
}
if (event->priority) {
event->sq_event = squeue_add_usec(sq_new, event->run_time, event->priority - 1, event);
} else {
event->sq_event = squeue_add(sq_new, event->run_time, event);
}
}
squeue_destroy(*q, 0);
*q = sq_new;
}
/*
* Create the event queue
* We oversize it somewhat to avoid unnecessary growing
*/
int init_event_queue(void)
{
unsigned int size;
size = num_objects.hosts + num_objects.services;
if (size < 4096)
size = 4096;
nagios_squeue = squeue_create(size);
return 0;
}
static squeue_t *
ip_squeue_create(pri_t pri)
{
squeue_t *sqp;
sqp = squeue_create(ip_squeue_worker_wait, pri);
ASSERT(sqp != NULL);
if (ip_squeue_create_callback != NULL)
ip_squeue_create_callback(sqp);
return (sqp);
}
static void squeue_foreach(squeue_t *q, int (*walker)(squeue_event *, void *), void *arg)
{
squeue_t *dup;
void *e, *dup_d;
dup = squeue_create(q->size);
dup_d = dup->d;
memcpy(dup, q, sizeof(*q));
dup->d = dup_d;
memcpy(dup->d, q->d, (q->size * sizeof(void *)));
while ((e = pqueue_pop(dup))) {
walker(e, arg);
}
squeue_destroy(dup, 0);
}
static void enter_worker(int sd)
{
/* created with socketpair(), usually */
master_sd = sd;
parent_pid = getppid();
(void)chdir("/tmp");
(void)chdir("nagios-workers");
if (setpgid(0, 0)) {
/* XXX: handle error somehow, or maybe just ignore it */
}
/* we need to catch child signals the default way */
signal(SIGCHLD, SIG_DFL);
fcntl(fileno(stdout), F_SETFD, FD_CLOEXEC);
fcntl(fileno(stderr), F_SETFD, FD_CLOEXEC);
fcntl(master_sd, F_SETFD, FD_CLOEXEC);
iobs = iobroker_create();
if (!iobs) {
/* XXX: handle this a bit better */
worker_die("Worker failed to create io broker socket set");
}
/*
* Create a modest scheduling queue that will be
* more than enough for our needs
*/
sq = squeue_create(1024);
set_socket_options(master_sd, 256 * 1024);
iobroker_register(iobs, master_sd, NULL, receive_command);
while (iobroker_get_num_fds(iobs) > 0) {
int poll_time = -1;
/* check for timed out jobs */
for (;;) {
child_process *cp;
struct timeval now, tmo;
/* stop when scheduling queue is empty */
cp = (child_process *)squeue_peek(sq);
if (!cp)
break;
tmo.tv_usec = cp->start.tv_usec;
tmo.tv_sec = cp->start.tv_sec + cp->timeout;
gettimeofday(&now, NULL);
poll_time = tv_delta_msec(&now, &tmo);
/*
* A little extra takes care of rounding errors and
* ensures we never kill a job before it times out.
* 5 milliseconds is enough to take care of that.
*/
poll_time += 5;
if (poll_time > 0)
break;
/* this job timed out, so kill it */
wlog("job with pid %d timed out. Killing it", cp->pid);
kill_job(cp, ETIME);
}
iobroker_poll(iobs, poll_time);
/*
* if our parent goes away we can't really do anything
* sensible at all, so let's just break out and exit
*/
if (kill(parent_pid, 0) < 0 && errno == ESRCH) {
break;
}
}
/* we exit when the master shuts us down */
exit(EXIT_SUCCESS);
}
int main(int argc, char **argv)
{
squeue_t *sq;
struct timeval tv;
sq_test_event a, b, c, d, *x;
t_set_colors(0);
t_start("squeue tests");
a.id = 1;
b.id = 2;
c.id = 3;
d.id = 4;
gettimeofday(&tv, NULL);
/* Order in is a, b, c, d, but we should get b, c, d, a out. */
srand(tv.tv_usec ^ tv.tv_sec);
t((sq = squeue_create(1024)) != NULL);
t(squeue_size(sq) == 0);
/* we fill and empty the squeue completely once before testing */
sq_test_random(sq);
t(squeue_size(sq) == 0, "Size should be 0 after first sq_test_random");
t((a.evt = squeue_add(sq, time(NULL) + 9, &a)) != NULL);
t(squeue_size(sq) == 1);
t((b.evt = squeue_add(sq, time(NULL) + 3, &b)) != NULL);
t(squeue_size(sq) == 2);
t((c.evt = squeue_add_msec(sq, time(NULL) + 5, 0, &c)) != NULL);
t(squeue_size(sq) == 3);
t((d.evt = squeue_add_usec(sq, time(NULL) + 5, 1, &d)) != NULL);
t(squeue_size(sq) == 4);
/* add and remove lots. remainder should be what we have above */
sq_test_random(sq);
/* testing squeue_peek() */
t((x = (sq_test_event *)squeue_peek(sq)) != NULL);
t(x == &b, "x: %p; a: %p; b: %p; c: %p; d: %p\n", x, &a, &b, &c, &d);
t(x->id == b.id);
t(squeue_size(sq) == 4);
/* testing squeue_remove() and re-add */
t(squeue_remove(sq, b.evt) == 0);
t(squeue_size(sq) == 3);
t((x = squeue_peek(sq)) != NULL);
t(x == &c);
t((b.evt = squeue_add(sq, time(NULL) + 3, &b)) != NULL);
t(squeue_size(sq) == 4);
/* peek should now give us the &b event (again) */
t((x = squeue_peek(sq)) != NULL);
if (x != &b) {
printf("about to fail pretty f*****g hard...\n");
printf("ea: %p; &b: %p; &c: %p; ed: %p; x: %p\n",
&a, &b, &c, &d, x);
}
t(x == &b);
t(x->id == b.id);
t(squeue_size(sq) == 4);
/* testing squeue_pop(), lifo manner */
t((x = squeue_pop(sq)) != NULL);
t(squeue_size(sq) == 3,
"squeue_size(sq) = %d\n", squeue_size(sq));
t(x == &b, "x: %p; &b: %p\n", x, &b);
t(x->id == b.id, "x->id: %lu; d.id: %lu\n", x->id, d.id);
/* Test squeue_pop() */
t((x = squeue_pop(sq)) != NULL);
t(squeue_size(sq) == 2);
t(x == &c, "x->id: %lu; c.id: %lu\n", x->id, c.id);
t(x->id == c.id, "x->id: %lu; c.id: %lu\n", x->id, c.id);
/* this should fail gracefully (-1 return from squeue_remove()) */
t(squeue_remove(NULL, NULL) == -1);
t(squeue_remove(NULL, a.evt) == -1);
squeue_foreach(sq, sq_walker, NULL);
/* clean up to prevent false valgrind positives */
squeue_destroy(sq, 0);
return t_end();
}
