588 lines
9.9 KiB
C
588 lines
9.9 KiB
C
|
|
#include "lib/buffer.h"
|
|
#include "lib/heap.h"
|
|
|
|
struct birdloop
|
|
{
|
|
pool *pool;
|
|
|
|
int wakeup_fds[2];
|
|
u8 poll_active;
|
|
|
|
xxx_time last_time;
|
|
xxx_time real_time;
|
|
u8 use_monotonic_clock;
|
|
|
|
BUFFER(timer2 *) timers;
|
|
list event_list;
|
|
list sock_list;
|
|
uint sock_num;
|
|
|
|
BUFFER(sock *) poll_sk;
|
|
BUFFER(struct pollfd) poll_fd;
|
|
u8 poll_changed;
|
|
u8 close_scheduled;
|
|
|
|
};
|
|
|
|
|
|
static void times_update_alt(struct birdloop *loop);
|
|
|
|
static int
|
|
times_init(struct birdloop *loop)
|
|
{
|
|
struct timespec ts;
|
|
int rv;
|
|
|
|
rv = clock_gettime(CLOCK_MONOTONIC, &ts);
|
|
if (rv < 0)
|
|
{
|
|
// log(L_WARN "Monotonic clock is missing");
|
|
|
|
loop->use_monotonic_clock = 0;
|
|
loop->last_time = 0;
|
|
loop->real_time = 0;
|
|
times_update_alt(loop);
|
|
return;
|
|
}
|
|
|
|
/*
|
|
if ((tv.tv_sec < 0) || (((s64) tv.tv_sec) > ((s64) 1 << 40)))
|
|
log(L_WARN "Monotonic clock is crazy");
|
|
*/
|
|
|
|
loop->use_monotonic_clock = 1;
|
|
loop->last_time = (tv.tv_sec S) + (tv.tv_nsec / 1000);
|
|
loop->real_time = 0;
|
|
}
|
|
|
|
static void
|
|
times_update_pri(struct birdloop *loop)
|
|
{
|
|
struct timespec ts;
|
|
int rv;
|
|
|
|
rv = clock_gettime(CLOCK_MONOTONIC, &ts);
|
|
if (rv < 0)
|
|
die("clock_gettime: %m");
|
|
|
|
xxx_time new_time = (tv.tv_sec S) + (tv.tv_nsec / 1000);
|
|
|
|
/*
|
|
if (new_time < loop->last_time)
|
|
log(L_ERR "Monotonic clock is broken");
|
|
*/
|
|
|
|
loop->last_time = new_time;
|
|
loop->real_time = 0;
|
|
}
|
|
|
|
static void
|
|
times_update_alt(struct birdloop *loop)
|
|
{
|
|
struct timeval tv;
|
|
int rv;
|
|
|
|
rv = gettimeofday(&tv, NULL);
|
|
if (rv < 0)
|
|
die("gettimeofday: %m");
|
|
|
|
xxx_time new_time = (tv.tv_sec S) + tv.tv_usec;
|
|
xxx_time delta = new_time - loop->real_time;
|
|
|
|
if ((delta < 0) || (delta > (60 S)))
|
|
{
|
|
/*
|
|
if (loop->real_time)
|
|
log(L_WARN "Time jump, delta %d us", (int) delta);
|
|
*/
|
|
|
|
delta = 100 MS;
|
|
}
|
|
|
|
loop->last_time += delta;
|
|
loop->real_time = new_time;
|
|
}
|
|
|
|
static void
|
|
times_update(struct birdloop *loop)
|
|
{
|
|
if (loop->use_monotonic_clock)
|
|
times_update_pri(loop);
|
|
else
|
|
times_update_alt(loop);
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
pipe_new(int *pfds)
|
|
{
|
|
int pfds[2], rv;
|
|
sock *sk;
|
|
|
|
rv = pipe(pfds);
|
|
if (rv < 0)
|
|
die("pipe: %m");
|
|
|
|
if (fcntl(pfds[0], F_SETFL, O_NONBLOCK) < 0)
|
|
die("fcntl(O_NONBLOCK): %m");
|
|
|
|
if (fcntl(pfds[1], F_SETFL, O_NONBLOCK) < 0)
|
|
die("fcntl(O_NONBLOCK): %m");
|
|
}
|
|
|
|
static void
|
|
wakeup_init(struct birdloop *loop)
|
|
{
|
|
pipe_new(loop->wakeup_fds);
|
|
}
|
|
|
|
static void
|
|
wakeup_drain(struct birdloop *loop)
|
|
{
|
|
char buf[64];
|
|
int rv;
|
|
|
|
try:
|
|
rv = read(loop->wakeup_fds[0], buf, 64);
|
|
if (rv < 0)
|
|
{
|
|
if (errno == EINTR)
|
|
goto try;
|
|
if (errno == EAGAIN)
|
|
return;
|
|
die("wakeup read: %m");
|
|
}
|
|
if (rv == 64)
|
|
goto try;
|
|
}
|
|
|
|
static void
|
|
wakeup_kick(struct birdloop *loop)
|
|
{
|
|
u64 v = 1;
|
|
int rv;
|
|
|
|
try:
|
|
rv = write(loop->wakeup_fds[1], &v, sizeof(u64));
|
|
if (rv < 0)
|
|
{
|
|
if (errno == EINTR)
|
|
goto try;
|
|
if (errno == EAGAIN)
|
|
return;
|
|
die("wakeup write: %m");
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
static inline uint events_waiting(struct birdloop *loop)
|
|
{ return !EMPTY_LIST(loop->event_list); }
|
|
|
|
static void
|
|
events_init(struct birdloop *loop)
|
|
{
|
|
list_init(&poll->event_list);
|
|
}
|
|
|
|
static void
|
|
events_fire(struct birdloop *loop)
|
|
{
|
|
times_update(loop);
|
|
ev_run_list(&loop->event_list);
|
|
}
|
|
|
|
void
|
|
ev2_schedule(event *e)
|
|
{
|
|
if (loop->poll_active && EMPTY_LIST(loop->event_list))
|
|
wakeup_kick(loop);
|
|
|
|
if (e->n.next)
|
|
rem_node(&e->n);
|
|
|
|
add_tail(&loop->event_list, &e->n);
|
|
}
|
|
|
|
|
|
#define TIMER_LESS(a,b) ((a)->expires < (b)->expires)
|
|
#define TIMER_SWAP(heap,a,b,t) (t = heap[a], heap[a] = heap[b], heap[b] = t, \
|
|
heap[a]->index = (a), heap[b]->index = (b))
|
|
|
|
|
|
static inline uint timers_count(struct birdloop *loop)
|
|
{ return loop->timers.used - 1; }
|
|
|
|
static inline timer2 *timers_first(struct birdloop *loop)
|
|
{ return (loop->timers.used > 1) ? loop->timers.data[1] : NULL; }
|
|
|
|
|
|
static void
|
|
tm2_free(resource *r)
|
|
{
|
|
timer2 *t = (timer2 *) r;
|
|
|
|
tm2_stop(t);
|
|
}
|
|
|
|
static void
|
|
tm2_dump(resource *r)
|
|
{
|
|
timer2 *t = (timer2 *) r;
|
|
|
|
debug("(code %p, data %p, ", t->hook, t->data);
|
|
if (t->randomize)
|
|
debug("rand %d, ", t->randomize);
|
|
if (t->recurrent)
|
|
debug("recur %d, ", t->recurrent);
|
|
if (t->expires)
|
|
debug("expires in %d sec)\n", t->expires - xxx_now);
|
|
else
|
|
debug("inactive)\n");
|
|
}
|
|
|
|
static struct resclass tm2_class = {
|
|
"Timer",
|
|
sizeof(timer),
|
|
tm2_free,
|
|
tm2_dump,
|
|
NULL,
|
|
NULL
|
|
};
|
|
|
|
timer2 *
|
|
tm2_new(pool *p)
|
|
{
|
|
timer2 *t = ralloc(p, &tm2_class);
|
|
t->index = -1;
|
|
return t;
|
|
}
|
|
|
|
void
|
|
tm2_start(timer2 *t, xxx_time after)
|
|
{
|
|
xxx_time when = loop->last_time + after;
|
|
uint tc = timers_count(loop);
|
|
|
|
if (!t->expires)
|
|
{
|
|
t->index = ++tc;
|
|
t->expires = when;
|
|
BUFFER_PUSH(loop->timers) = t;
|
|
HEAP_INSERT(loop->timers.data, tc, timer2 *, TIMER_LESS, TIMER_SWAP);
|
|
}
|
|
else if (t->expires < when)
|
|
{
|
|
t->expires = when;
|
|
HEAP_INCREASE(loop->timers.data, tc, timer2 *, TIMER_LESS, TIMER_SWAP, t->index);
|
|
}
|
|
else if (t->expires > when)
|
|
{
|
|
t->expires = when;
|
|
HEAP_DECREASE(loop->timers.data, tc, timer2 *, TIMER_LESS, TIMER_SWAP, t->index);
|
|
}
|
|
|
|
if (loop->poll_active && (t->index == 1))
|
|
wakeup_kick(loop);
|
|
}
|
|
|
|
void
|
|
tm2_stop(timer2 *t)
|
|
{
|
|
if (!t->expires)
|
|
return;
|
|
|
|
uint tc = timers_count(XXX);
|
|
HEAP_DELETE(loop->timers.data, tc, timer2 *, TIMER_LESS, TIMER_SWAP, t->index);
|
|
BUFFER_POP(loop->timers);
|
|
|
|
t->index = -1;
|
|
t->expires = 0;
|
|
}
|
|
|
|
static void
|
|
timers_init(struct birdloop *loop)
|
|
{
|
|
BUFFER_INIT(loop->timers, loop->pool, 4);
|
|
BUFFER_PUSH(loop->timers) = NULL;
|
|
}
|
|
|
|
static void
|
|
timers_fire(struct birdloop *loop)
|
|
{
|
|
xxx_time base_time;
|
|
timer2 *t;
|
|
|
|
times_update(loop);
|
|
base_time = loop->last_time;
|
|
|
|
while (t = timers_first(loop))
|
|
{
|
|
if (t->expires > base_time)
|
|
return;
|
|
|
|
if (t->recurrent)
|
|
{
|
|
xxx_time after = t->recurrent;
|
|
xxx_time delta = loop->last_time - t->expires;
|
|
|
|
if (t->randomize)
|
|
after += random() % (t->randomize + 1);
|
|
|
|
if (delta > after)
|
|
delta = 0;
|
|
|
|
tm2_start(t, after - delta);
|
|
}
|
|
else
|
|
tm2_stop(t);
|
|
|
|
t->hook(t);
|
|
}
|
|
}
|
|
|
|
|
|
static void
|
|
sockets_init(struct birdloop *loop)
|
|
{
|
|
list_init(&poll->sock_list);
|
|
poll->sock_num = 0;
|
|
|
|
BUFFER_INIT(loop->poll_sk, loop->pool, 4);
|
|
BUFFER_INIT(loop->poll_fd, loop->pool, 4);
|
|
poll_changed = 0;
|
|
}
|
|
|
|
static void
|
|
sockets_add(struct birdloop *loop, sock *s)
|
|
{
|
|
add_tail(&loop->sock_list, &s->n);
|
|
loop->sock_num++;
|
|
|
|
s->index = -1;
|
|
loop->poll_changed = 1;
|
|
|
|
if (loop->poll_active)
|
|
wakeup_kick(loop);
|
|
}
|
|
|
|
void
|
|
sk_start(sock *s)
|
|
{
|
|
sockets_add(xxx_loop, s);
|
|
}
|
|
|
|
static void
|
|
sockets_remove(struct birdloop *loop, sock *s)
|
|
{
|
|
rem_node(&s->n);
|
|
loop->sock_num--;
|
|
|
|
if (s->index >= 0)
|
|
s->poll_sk.data[sk->index] = NULL;
|
|
|
|
s->index = -1;
|
|
loop->poll_changed = 1;
|
|
|
|
/* Wakeup moved to sk_stop() */
|
|
}
|
|
|
|
void
|
|
sk_stop(sock *s)
|
|
{
|
|
sockets_remove(xxx_loop, s);
|
|
|
|
if (loop->poll_active)
|
|
{
|
|
loop->close_scheduled = 1;
|
|
wakeup_kick(loop);
|
|
}
|
|
else
|
|
close(s->fd);
|
|
|
|
s->fd = -1;
|
|
}
|
|
|
|
static inline uint sk_want_events(sock *s)
|
|
{ return (s->rx_hook ? POLLIN : 0) | ((s->ttx != s->tpos) ? POLLOUT : 0); }
|
|
|
|
static void
|
|
sockets_update(struct birdloop *loop, sock *s)
|
|
{
|
|
if (s->index >= 0)
|
|
s->poll_fd.data[s->index].events = sk_want_events(s);
|
|
}
|
|
|
|
static void
|
|
sockets_prepare(struct birdloop *loop)
|
|
{
|
|
BUFFER_SET(loop->poll_sk, loop->sock_num + 1);
|
|
BUFFER_SET(loop->poll_fd, loop->sock_num + 1);
|
|
|
|
struct pollfd *pfd = loop->poll_fd.data;
|
|
sock **psk = loop->poll_sk.data;
|
|
int i = 0;
|
|
node *n;
|
|
|
|
WALK_LIST(n, &loop->sock_list)
|
|
{
|
|
sock *s = SKIP_BACK(sock, n, n);
|
|
|
|
ASSERT(i < loop->sock_num);
|
|
|
|
s->index = i;
|
|
*psk = s;
|
|
pfd->fd = s->fd;
|
|
pfd->events = sk_want_events(s);
|
|
pfd->revents = 0;
|
|
|
|
pfd++;
|
|
psk++;
|
|
i++;
|
|
}
|
|
|
|
ASSERT(i == loop->sock_num);
|
|
|
|
/* Add internal wakeup fd */
|
|
*psk = NULL;
|
|
pfd->fd = loop->wakeup_fds[0];
|
|
pfd->events = POLLIN;
|
|
pfd->revents = 0;
|
|
|
|
loop->poll_changed = 0;
|
|
}
|
|
|
|
static void
|
|
sockets_close_fds(struct birdloop *loop)
|
|
{
|
|
struct pollfd *pfd = loop->poll_fd.data;
|
|
sock **psk = loop->poll_sk.data;
|
|
int poll_num = loop->poll_fd.used - 1;
|
|
|
|
int i;
|
|
for (i = 0; i < poll_num; i++)
|
|
if (psk[i] == NULL)
|
|
close(pfd[i].fd);
|
|
|
|
loop->close_scheduled = 0;
|
|
}
|
|
|
|
|
|
static void
|
|
sockets_fire(struct birdloop *loop)
|
|
{
|
|
struct pollfd *pfd = loop->poll_fd.data;
|
|
sock **psk = loop->poll_sk.data;
|
|
int poll_num = loop->poll_fd.used - 1;
|
|
|
|
times_update(loop);
|
|
|
|
/* Last fd is internal wakeup fd */
|
|
if (pfd[loop->sock_num].revents & POLLIN)
|
|
wakeup_drain(loop);
|
|
|
|
int i;
|
|
for (i = 0; i < poll_num; pfd++, psk++, i++)
|
|
{
|
|
int e = 1;
|
|
|
|
if (! pfd->revents)
|
|
continue;
|
|
|
|
if (pfd->revents & POLLNVAL)
|
|
die("poll: invalid fd %d", pfd->fd);
|
|
|
|
if (pfd->revents & POLLIN)
|
|
while (e && *psk && (*psk)->rx_hook)
|
|
e = sk_read(*psk);
|
|
|
|
e = 1;
|
|
if (pfd->revents & POLLOUT)
|
|
while (e && *psk)
|
|
e = sk_write(*psk);
|
|
}
|
|
}
|
|
|
|
|
|
struct birdloop *
|
|
birdloop_new(pool *p)
|
|
{
|
|
struct birdloop *loop = mb_allocz(p, sizeof(struct birdloop));
|
|
p->pool = p;
|
|
|
|
times_init(loop);
|
|
wakeup_init(loop);
|
|
|
|
events_init(loop);
|
|
timers_init(loop);
|
|
sockets_init(loop);
|
|
|
|
return loop;
|
|
}
|
|
|
|
void
|
|
birdloop_enter(struct birdloop *loop)
|
|
{
|
|
pthread_mutex_lock(loop->mutex);
|
|
}
|
|
|
|
void
|
|
birdloop_leave(struct birdloop *loop)
|
|
{
|
|
pthread_mutex_unlock(loop->mutex);
|
|
}
|
|
|
|
|
|
void
|
|
birdloop_main(struct birdloop *loop)
|
|
{
|
|
timer2 *t;
|
|
int timeout;
|
|
|
|
while (1)
|
|
{
|
|
events_fire(loop);
|
|
timers_fire(loop);
|
|
|
|
times_update(loop);
|
|
if (events_waiting(loop))
|
|
timeout = 0;
|
|
else if (t = timers_first(loop))
|
|
timeout = (tm2_remains(t) TO_MS) + 1;
|
|
else
|
|
timeout = -1;
|
|
|
|
if (loop->poll_changed)
|
|
sockets_prepare(loop);
|
|
|
|
loop->poll_active = 1;
|
|
pthread_mutex_unlock(loop->mutex);
|
|
|
|
try:
|
|
rv = poll(loop->poll_fd.data, loop->poll_fd.used, timeout);
|
|
if (rv < 0)
|
|
{
|
|
if (errno == EINTR || errno == EAGAIN)
|
|
goto try;
|
|
die("poll: %m");
|
|
}
|
|
|
|
pthread_mutex_lock(loop->mutex);
|
|
loop->poll_active = 0;
|
|
|
|
if (loop->close_scheduled)
|
|
sockets_close_fds(loop);
|
|
|
|
if (rv)
|
|
sockets_fire(loop);
|
|
|
|
timers_fire(loop);
|
|
}
|
|
}
|
|
|
|
|
|
|