diff options
Diffstat (limited to 'src/util/verto/verto-libev.c')
| -rw-r--r-- | src/util/verto/verto-libev.c | 199 |
1 files changed, 199 insertions, 0 deletions
diff --git a/src/util/verto/verto-libev.c b/src/util/verto/verto-libev.c new file mode 100644 index 000000000000..9c7c32449c72 --- /dev/null +++ b/src/util/verto/verto-libev.c @@ -0,0 +1,199 @@ +/* + * Copyright 2011 Red Hat, Inc. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation files + * (the "Software"), to deal in the Software without restriction, + * including without limitation the rights to use, copy, modify, merge, + * publish, distribute, sublicense, and/or sell copies of the Software, + * and to permit persons to whom the Software is furnished to do so, + * subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS + * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include <stdlib.h> +#include <string.h> +#include <errno.h> + +#include <verto-libev.h> +#define VERTO_MODULE_TYPES +typedef struct ev_loop verto_mod_ctx; +typedef ev_watcher verto_mod_ev; +#include <verto-module.h> + +static verto_mod_ctx * +libev_ctx_new(void) +{ + return ev_loop_new(EVFLAG_AUTO); +} + +static verto_mod_ctx * +libev_ctx_default(void) +{ + return ev_default_loop(EVFLAG_AUTO); +} + +static void +libev_ctx_free(verto_mod_ctx *ctx) +{ + if (ctx != EV_DEFAULT) + ev_loop_destroy(ctx); +} + +static void +libev_ctx_run(verto_mod_ctx *ctx) +{ + ev_run(ctx, 0); +} + +static void +libev_ctx_run_once(verto_mod_ctx *ctx) +{ + ev_run(ctx, EVRUN_ONCE); +} + +static void +libev_ctx_break(verto_mod_ctx *ctx) +{ + ev_break(ctx, EVBREAK_ONE); +} + +static void +libev_ctx_reinitialize(verto_mod_ctx *ctx) +{ + ev_loop_fork(ctx); +} + +static void +libev_callback(EV_P_ ev_watcher *w, int revents) +{ + verto_ev_flag state = VERTO_EV_FLAG_NONE; + + if (verto_get_type(w->data)== VERTO_EV_TYPE_CHILD) + verto_set_proc_status(w->data, ((ev_child*) w)->rstatus); + + if (revents & EV_READ) + state |= VERTO_EV_FLAG_IO_READ; + if (revents & EV_WRITE) + state |= VERTO_EV_FLAG_IO_WRITE; + if (revents & EV_ERROR) + state |= VERTO_EV_FLAG_IO_ERROR; + + verto_set_fd_state(w->data, state); + verto_fire(w->data); +} + +static void +libev_ctx_set_flags(verto_mod_ctx *ctx, const verto_ev *ev, + verto_mod_ev *evpriv) +{ + if (verto_get_type(ev) == VERTO_EV_TYPE_IO) { + int events = EV_NONE; + + if (verto_get_flags(ev) & VERTO_EV_FLAG_IO_READ) + events |= EV_READ; + if (verto_get_flags(ev) & VERTO_EV_FLAG_IO_WRITE) + events |= EV_WRITE; + + ev_io_stop(ctx, (ev_io*) evpriv); + ev_io_set(((ev_io*) evpriv), verto_get_fd(ev), events); + ev_io_start(ctx, (ev_io*) evpriv); + } +} + +#define setuptype(type, ...) \ + w.type = malloc(sizeof(ev_ ## type)); \ + if (w.type) { \ + ev_ ## type ## _init(w.type, (EV_CB(type, (*))) __VA_ARGS__); \ + ev_ ## type ## _start(ctx, w.type); \ + } \ + break + +static verto_mod_ev * +libev_ctx_add(verto_mod_ctx *ctx, const verto_ev *ev, verto_ev_flag *flags) +{ + union { + ev_watcher *watcher; + ev_io *io; + ev_timer *timer; + ev_idle *idle; + ev_signal *signal; + ev_child *child; + } w; + ev_tstamp interval; + + w.watcher = NULL; + *flags |= VERTO_EV_FLAG_PERSIST; + switch (verto_get_type(ev)) { + case VERTO_EV_TYPE_IO: + setuptype(io, libev_callback, verto_get_fd(ev), EV_NONE); + case VERTO_EV_TYPE_TIMEOUT: + interval = ((ev_tstamp) verto_get_interval(ev)) / 1000.0; + setuptype(timer, libev_callback, interval, interval); + case VERTO_EV_TYPE_IDLE: + setuptype(idle, libev_callback); + case VERTO_EV_TYPE_SIGNAL: + setuptype(signal, libev_callback, verto_get_signal(ev)); + case VERTO_EV_TYPE_CHILD: + *flags &= ~VERTO_EV_FLAG_PERSIST; /* Child events don't persist */ + setuptype(child, libev_callback, verto_get_proc(ev), 0); + default: + break; /* Not supported */ + } + + if (w.watcher) { + w.watcher->data = (void*) ev; + libev_ctx_set_flags(ctx, ev, w.watcher); + } + return w.watcher; +} + +static void +libev_ctx_del(verto_mod_ctx *ctx, const verto_ev *ev, verto_mod_ev *evpriv) +{ + switch (verto_get_type(ev)) { + case VERTO_EV_TYPE_IO: + ev_io_stop(ctx, (ev_io*) evpriv); + break; + case VERTO_EV_TYPE_TIMEOUT: + ev_timer_stop(ctx, (ev_timer*) evpriv); + break; + case VERTO_EV_TYPE_IDLE: + ev_idle_stop(ctx, (ev_idle*) evpriv); + break; + case VERTO_EV_TYPE_SIGNAL: + ev_signal_stop(ctx, (ev_signal*) evpriv); + break; + case VERTO_EV_TYPE_CHILD: + ev_child_stop(ctx, (ev_child*) evpriv); + break; + default: + break; + } + + free(evpriv); +} + +VERTO_MODULE(libev, ev_loop_new, + VERTO_EV_TYPE_IO | + VERTO_EV_TYPE_TIMEOUT | + VERTO_EV_TYPE_IDLE | + VERTO_EV_TYPE_SIGNAL | + VERTO_EV_TYPE_CHILD); + +verto_ctx * +verto_convert_libev(struct ev_loop* loop) +{ + return verto_convert(libev, 0, loop); +} |