int iv_inited(void)
{
if (iv_state_index == -1)
return 0;
return iv_get_state() != NULL;
}
int iv_fd_register_try(struct iv_fd *_fd)
{
struct iv_state *st = iv_get_state();
struct iv_fd_ *fd = (struct iv_fd_ *)_fd;
int orig_wanted_bands;
int ret;
iv_fd_register_prologue(st, fd);
recompute_wanted_flags(fd);
orig_wanted_bands = fd->wanted_bands;
if (!fd->wanted_bands)
fd->wanted_bands = MASKIN | MASKOUT;
ret = method->notify_fd_sync(st, fd);
if (ret) {
fd->registered = 0;
if (method->unregister_fd != NULL)
method->unregister_fd(st, fd);
return ret;
}
if (!orig_wanted_bands) {
fd->wanted_bands = 0;
method->notify_fd(st, fd);
}
iv_fd_register_epilogue(st, fd);
return 0;
}
void iv_main(void)
{
struct iv_state *st = iv_get_state();
int run_timers;
st->quit = 0;
run_timers = 1;
while (1) {
struct timespec _abs;
const struct timespec *abs;
if (run_timers)
iv_run_timers(st);
iv_run_tasks(st);
if (st->quit || !st->numobjs)
break;
if (iv_pending_tasks(st)) {
_abs.tv_sec = 0;
_abs.tv_nsec = 0;
abs = &_abs;
} else {
abs = iv_get_soonest_timeout(st);
}
run_timers = iv_fd_poll_and_run(st, abs);
}
}
int iv_inited(void)
{
#ifndef HAVE_THREAD
if (!iv_state_key_allocated)
return 0;
#endif
return iv_get_state() != NULL;
}
void iv_validate_now(void)
{
struct iv_state *st = iv_get_state();
if (!st->time_valid) {
st->time_valid = 1;
iv_time_get(&st->time);
}
}
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);
}
void iv_fd_register(struct iv_fd *_fd)
{
struct iv_state *st = iv_get_state();
struct iv_fd_ *fd = (struct iv_fd_ *)_fd;
iv_fd_register_prologue(st, fd);
notify_fd(st, fd);
iv_fd_register_epilogue(st, fd);
}
void iv_task_unregister(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_unregister: called with task not on a list");
st->numobjs--;
iv_list_del_init(&t->list);
}
void iv_fd_set_handler_err(struct iv_fd *_fd, void (*handler_err)(void *))
{
struct iv_state *st = iv_get_state();
struct iv_fd_ *fd = (struct iv_fd_ *)_fd;
if (!fd->registered) {
iv_fatal("iv_fd_set_handler_err: called with fd which "
"is not registered");
}
fd->handler_err = handler_err;
notify_fd(st, fd);
}
BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved)
{
if (iv_state_index == -1)
return TRUE;
if (fdwReason == DLL_PROCESS_DETACH || fdwReason == DLL_THREAD_DETACH) {
struct iv_state *st;
st = iv_get_state();
if (st != NULL)
__iv_deinit(st);
}
if (fdwReason == DLL_PROCESS_DETACH) {
TlsFree(iv_state_index);
iv_state_index = -1;
}
return TRUE;
}
void iv_main(void)
{
struct iv_state *st = iv_get_state();
st->quit = 0;
while (1) {
struct timespec to;
iv_run_tasks(st);
iv_run_timers(st);
if (st->quit || !st->numobjs)
break;
if (iv_pending_tasks(st) || iv_get_soonest_timeout(st, &to)) {
to.tv_sec = 0;
to.tv_nsec = 0;
}
iv_fd_poll_and_run(st, &to);
}
}
void iv_timer_unregister(struct iv_timer *_t)
{
struct iv_state *st = iv_get_state();
struct iv_timer_ *t = (struct iv_timer_ *)_t;
struct iv_timer_ **m;
struct iv_timer_ **p;
if (t->index == -1) {
iv_fatal("iv_timer_unregister: called with timer not "
"on the heap");
}
if (t->index > st->num_timers) {
iv_fatal("iv_timer_unregister: timer index %d > %d",
t->index, st->num_timers);
}
p = get_node(st, t->index);
if (*p != t) {
iv_fatal("iv_timer_unregister: unregistered timer "
"index belonging to other timer");
}
st->numobjs--;
m = get_node(st, st->num_timers);
st->num_timers--;
*p = *m;
(*p)->index = t->index;
*m = NULL;
if (p != m) {
pull_up(st, (*p)->index, p);
push_down(st, (*p)->index, p);
}
t->index = -1;
}
void iv_fd_unregister(struct iv_fd *_fd)
{
struct iv_state *st = iv_get_state();
struct iv_fd_ *fd = (struct iv_fd_ *)_fd;
if (!fd->registered) {
iv_fatal("iv_fd_unregister: called with fd which is "
"not registered");
}
fd->registered = 0;
iv_list_del(&fd->list_active);
notify_fd(st, fd);
if (method->unregister_fd != NULL)
method->unregister_fd(st, fd);
st->numobjs--;
st->numfds--;
if (st->handled_fd == fd)
st->handled_fd = NULL;
}
void iv_timer_register(struct iv_timer *_t)
{
struct iv_state *st = iv_get_state();
struct iv_timer_ *t = (struct iv_timer_ *)_t;
struct iv_timer_ **p;
int index;
if (t->index != -1) {
iv_fatal("iv_timer_register: called with timer still "
"on the heap");
}
st->numobjs++;
index = ++st->num_timers;
p = get_node(st, index);
if (p == NULL)
iv_fatal("iv_timer_register: timer list overflow");
*p = t;
t->index = index;
pull_up(st, index, p);
}
void iv_quit(void)
{
struct iv_state *st = iv_get_state();
st->quit = 1;
}
int iv_inited(void)
{
return iv_state_key_allocated && (iv_get_state() != NULL);
}
void iv_deinit(void)
{
struct iv_state *st = iv_get_state();
__iv_deinit(st);
}
struct timespec *__iv_now_location(void)
{
struct iv_state *st = iv_get_state();
return &st->time;
}
void iv_invalidate_now(void)
{
struct iv_state *st = iv_get_state();
__iv_invalidate_now(st);
}
