libverto-commits June 2011

libverto-commits@lists.fedorahosted.org

1 participants
66 discussions

[libverto] [core] make sure all fields in the ev struct are initialized
by Nathaniel McCallum 29 Jun '11

29 Jun '11

commit 75cc6b80012eb4a95d1629a86f181c601ee8b00a Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Wed Jun 29 14:31:13 2011 -0400 [core] make sure all fields in the ev struct are initialized src/verto.c | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) --- diff --git a/src/verto.c b/src/verto.c index 01e3310..dcf7e27 100644 --- a/src/verto.c +++ b/src/verto.c @@ -239,7 +239,7 @@ make_ev(struct vertoEvCtx *ctx, enum vertoEvPriority priority, ev = malloc(sizeof(struct vertoEv)); if (ev) { - ev->next = NULL; + memset(ev, 0, sizeof(struct vertoEv)); ev->ctx = ctx; ev->type = type; ev->priority = priority;

1 0

[libverto] [core] add delayed verto_del() from within callbacks to void reading freed memory
by Nathaniel McCallum 29 Jun '11

29 Jun '11

commit 39bb47bcef1b89c5b8b8be2d0956788c4e9cdf45 Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Wed Jun 29 14:24:17 2011 -0400 [core] add delayed verto_del() from within callbacks to void reading freed memory src/verto.c | 31 ++++++++++++++++++++++++------- 1 files changed, 24 insertions(+), 7 deletions(-) --- diff --git a/src/verto.c b/src/verto.c index 9221487..01e3310 100644 --- a/src/verto.c +++ b/src/verto.c @@ -69,6 +69,8 @@ struct vertoEv { void *modpriv; enum vertoEvFlag flags; bool persists; + size_t depth; + bool deleted; union { int signal; time_t interval; @@ -532,6 +534,16 @@ verto_del(struct vertoEv *ev) { if (!ev) return; + + /* If the event is freed in the callback, we just set a flag so that + * verto_fire() can actually do the delete when the callback completes. + * + * If we don't do this, than verto_fire() will access freed memory. */ + if (ev->depth > 0) { + ev->deleted = true; + return; + } + ev->ctx->funcs.ctx_del(ev->ctx->modpriv, ev, ev->modpriv); remove_ev(&(ev->ctx->events), ev); free(ev); @@ -567,14 +579,19 @@ verto_fire(struct vertoEv *ev) { void *priv; + ev->depth++; ev->callback(ev->ctx, ev); - if (!(ev->flags & VERTO_EV_FLAG_PERSIST)) - verto_del(ev); - else if (!ev->persists) { - priv = ev->ctx->funcs.ctx_add(ev->ctx->modpriv, ev, &ev->persists); - assert(priv); /* TODO: create an error callback */ - ev->ctx->funcs.ctx_del(ev->ctx->modpriv, ev, ev->modpriv); - ev->modpriv = priv; + ev->depth--; + + if (ev->depth == 0) { + if (!(ev->flags & VERTO_EV_FLAG_PERSIST) || ev->deleted) + verto_del(ev); + else if (!ev->persists) { + priv = ev->ctx->funcs.ctx_add(ev->ctx->modpriv, ev, &ev->persists); + assert(priv); /* TODO: create an error callback */ + ev->ctx->funcs.ctx_del(ev->ctx->modpriv, ev, ev->modpriv); + ev->modpriv = priv; + } } }

1 0

[libverto] [all] add a persistence flag; remove verto_repeat()
by Nathaniel McCallum 29 Jun '11

29 Jun '11

commit d75df28b497fb540b2a6ed8f9a4854e7814dc95f Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Wed Jun 29 11:47:08 2011 -0400 [all] add a persistence flag; remove verto_repeat() src/verto-glib.c | 12 +++++--- src/verto-libev.c | 4 ++- src/verto-libevent.c | 13 ++++++--- src/verto-module.h | 4 ++- src/verto-tevent.c | 4 ++- src/verto.c | 72 ++++++++++++++++++++++++++----------------------- src/verto.h | 46 ++++++++++++++----------------- tests/child.c | 7 +++- tests/idle.c | 43 +++++++++++++++++++---------- tests/read.c | 4 +- tests/signal.c | 8 +++--- tests/test.h | 13 +++++++++ tests/timeout.c | 57 +++++++++++++++++++++++---------------- tests/write.c | 10 +++--- 14 files changed, 174 insertions(+), 123 deletions(-) --- diff --git a/src/verto-glib.c b/src/verto-glib.c index a8d652b..5104c4c 100644 --- a/src/verto-glib.c +++ b/src/verto-glib.c @@ -99,16 +99,15 @@ glib_ctx_break(void *lp) static gboolean glib_callback(gpointer data) { - gboolean retval = verto_get_type(data) == VERTO_EV_TYPE_SIGNAL; + gboolean persists = verto_get_flags(data) & VERTO_EV_FLAG_PERSIST; verto_fire(data); - return retval; + return persists; } gboolean glib_callback_io(GIOChannel *source, GIOCondition condition, gpointer data) { - verto_fire(data); - return TRUE; + return glib_callback(data); } static void @@ -119,11 +118,13 @@ glib_callback_child(GPid pid, gint status, gpointer data) } static void * -glib_ctx_add(void *ctx, const struct vertoEv *ev) +glib_ctx_add(void *ctx, const struct vertoEv *ev, bool *persists) { struct glibEv *gev = NULL; enum vertoEvType type = verto_get_type(ev); + *persists = verto_get_flags(ev) & VERTO_EV_FLAG_PERSIST; + gev = g_new0(struct glibEv, 1); if (!gev) return NULL; @@ -150,6 +151,7 @@ glib_ctx_add(void *ctx, const struct vertoEv *ev) break; case VERTO_EV_TYPE_CHILD: gev->src = g_child_watch_source_new(verto_get_pid(ev)); + *persists = false; break; case VERTO_EV_TYPE_SIGNAL: #if GLIB_MAJOR_VERSION >= 2 diff --git a/src/verto-libev.c b/src/verto-libev.c index a59fe8b..1409033 100644 --- a/src/verto-libev.c +++ b/src/verto-libev.c @@ -73,7 +73,7 @@ libev_callback(EV_P_ ev_watcher *w, int revents) return type ## w static void * -libev_ctx_add(void *ctx, const struct vertoEv *ev) +libev_ctx_add(void *ctx, const struct vertoEv *ev, bool *persists) { ev_io *iow = NULL; ev_timer *timerw = NULL; @@ -83,6 +83,7 @@ libev_ctx_add(void *ctx, const struct vertoEv *ev) ev_tstamp interval; int events = EV_NONE; + *persists = true; switch (verto_get_type(ev)) { case VERTO_EV_TYPE_IO: if (verto_get_io_flags(ev) & VERTO_EV_IO_FLAG_READ) @@ -98,6 +99,7 @@ libev_ctx_add(void *ctx, const struct vertoEv *ev) case VERTO_EV_TYPE_SIGNAL: setuptype(signal, ev, libev_callback, verto_get_signal(ev)); case VERTO_EV_TYPE_CHILD: + *persists = false; setuptype(child, ev, libev_callback, verto_get_pid(ev), 0); default: return NULL; /* Not supported */ diff --git a/src/verto-libevent.c b/src/verto-libevent.c index 30f41d2..983c95b 100644 --- a/src/verto-libevent.c +++ b/src/verto-libevent.c @@ -71,12 +71,16 @@ libevent_callback(evutil_socket_t socket, short type, void *data) } static void * -libevent_ctx_add(void *ctx, const struct vertoEv *ev) +libevent_ctx_add(void *ctx, const struct vertoEv *ev, bool *persists) { struct event *priv = NULL; struct timeval *timeout = NULL; struct timeval tv; - int flags = EV_PERSIST; + int flags = 0; + + *persists = verto_get_flags(ev) & VERTO_EV_FLAG_PERSIST; + if (*persists) + flags |= EV_PERSIST; switch (verto_get_type(ev)) { case VERTO_EV_TYPE_IO: @@ -91,10 +95,11 @@ libevent_ctx_add(void *ctx, const struct vertoEv *ev) timeout = &tv; tv.tv_sec = verto_get_interval(ev) / 1000; tv.tv_usec = verto_get_interval(ev) % 1000 * 1000; - priv = event_new(ctx, -1, EV_TIMEOUT, libevent_callback, (void *) ev); + priv = event_new(ctx, -1, EV_TIMEOUT | flags, libevent_callback, + (void *) ev); break; case VERTO_EV_TYPE_SIGNAL: - priv = event_new(ctx, verto_get_signal(ev), EV_SIGNAL | EV_PERSIST, + priv = event_new(ctx, verto_get_signal(ev), EV_SIGNAL | flags, libevent_callback, (void *) ev); break; case VERTO_EV_TYPE_IDLE: diff --git a/src/verto-module.h b/src/verto-module.h index 9bc0d6c..bbfeaa3 100644 --- a/src/verto-module.h +++ b/src/verto-module.h @@ -27,6 +27,8 @@ #ifndef VERTO_MODULE_H_ #define VERTO_MODULE_H_ +#include <stdbool.h> + #include <verto.h> #define VERTO_MODULE_VERSION 1 @@ -63,7 +65,7 @@ struct vertoEvCtxFuncs { void (*ctx_run)(void *ctx); void (*ctx_run_once)(void *ctx); void (*ctx_break)(void *ctx); - void *(*ctx_add)(void *ctx, const struct vertoEv *ev); + void *(*ctx_add)(void *ctx, const struct vertoEv *ev, bool *persists); void (*ctx_del)(void *ctx, const struct vertoEv *ev, void *evpriv); }; diff --git a/src/verto-tevent.c b/src/verto-tevent.c index 307ed6f..c605955 100644 --- a/src/verto-tevent.c +++ b/src/verto-tevent.c @@ -78,12 +78,13 @@ definecb(timer, struct timeval ct) definecb(signal, int signum, int count, void *siginfo) static void * -tevent_ctx_add(void *ctx, const struct vertoEv *ev) +tevent_ctx_add(void *ctx, const struct vertoEv *ev, bool *persists) { time_t interval; struct timeval tv; uint16_t flags = 0; + *persists = true; switch (verto_get_type(ev)) { case VERTO_EV_TYPE_IO: if (verto_get_io_flags(ev) & VERTO_EV_IO_FLAG_READ) @@ -93,6 +94,7 @@ tevent_ctx_add(void *ctx, const struct vertoEv *ev) return tevent_add_fd(tctx(ctx), tctx(ctx), verto_get_io_fd(ev), flags, tevent_fd_cb, (void *) ev); case VERTO_EV_TYPE_TIMEOUT: + *persists = false; interval = verto_get_interval(ev); tv = tevent_timeval_current_ofs(interval / 1000, interval % 1000 * 1000); return tevent_add_timer(tctx(ctx), tctx(ctx), tv, diff --git a/src/verto.c b/src/verto.c index 3ec30af..9221487 100644 --- a/src/verto.c +++ b/src/verto.c @@ -24,11 +24,11 @@ #define _GNU_SOURCE /* For dladdr(), asprintf() */ -#include <stdbool.h> #include <stdio.h> #include <stdlib.h> #include <string.h> #include <signal.h> +#include <assert.h> #include <libgen.h> #include <sys/types.h> @@ -56,7 +56,7 @@ struct vertoChild { struct vertoIO { int fd; - enum vertoEvIOFlags flags; + enum vertoEvIOFlag flags; }; struct vertoEv { @@ -67,6 +67,8 @@ struct vertoEv { vertoCallback callback; void *priv; void *modpriv; + enum vertoEvFlag flags; + bool persists; union { int signal; time_t interval; @@ -221,7 +223,8 @@ load_module(const char *impl, void **dll, const struct vertoModule **module) static inline struct vertoEv * make_ev(struct vertoEvCtx *ctx, enum vertoEvPriority priority, - vertoCallback callback, void *priv, enum vertoEvType type) + vertoCallback callback, void *priv, enum vertoEvType type, + enum vertoEvFlag flags) { struct vertoEv *ev = NULL; @@ -240,6 +243,7 @@ make_ev(struct vertoEvCtx *ctx, enum vertoEvPriority priority, ev->priority = priority; ev->callback = callback; ev->priv = priv; + ev->flags = flags; } return ev; @@ -393,10 +397,10 @@ verto_break(struct vertoEvCtx *ctx) } #define doadd(set, type) \ - struct vertoEv *ev = make_ev(ctx, priority, callback, priv, type); \ + struct vertoEv *ev = make_ev(ctx, priority, callback, priv, type, flags); \ if (ev) { \ set; \ - ev->modpriv = ctx->funcs.ctx_add(ctx->modpriv, ev); \ + ev->modpriv = ctx->funcs.ctx_add(ctx->modpriv, ev, &ev->persists); \ if (!ev->modpriv) { \ free(ev); \ return NULL; \ @@ -407,31 +411,35 @@ verto_break(struct vertoEvCtx *ctx) struct vertoEv * verto_add_io(struct vertoEvCtx *ctx, enum vertoEvPriority priority, - vertoCallback callback, void *priv, int fd, - enum vertoEvIOFlags flags) + enum vertoEvFlag flags, vertoCallback callback, void *priv, int fd, + enum vertoEvIOFlag ioflags) { if (fd < 0) return NULL; - doadd(ev->option.io.fd = fd; ev->option.io.flags = flags, VERTO_EV_TYPE_IO); + doadd(ev->option.io.fd = fd; + ev->option.io.flags = ioflags, + VERTO_EV_TYPE_IO); } struct vertoEv * verto_add_timeout(struct vertoEvCtx *ctx, enum vertoEvPriority priority, - vertoCallback callback, void *priv, time_t interval) + enum vertoEvFlag flags, vertoCallback callback, void *priv, + time_t interval) { doadd(ev->option.interval = interval, VERTO_EV_TYPE_TIMEOUT); } struct vertoEv * verto_add_idle(struct vertoEvCtx *ctx, enum vertoEvPriority priority, - vertoCallback callback, void *priv) + enum vertoEvFlag flags, vertoCallback callback, void *priv) { doadd(, VERTO_EV_TYPE_IDLE); } struct vertoEv * verto_add_signal(struct vertoEvCtx *ctx, enum vertoEvPriority priority, - vertoCallback callback, void *priv, int signal) + enum vertoEvFlag flags, vertoCallback callback, void *priv, + int signal) { if (signal < 0 || signal == SIGCHLD) return NULL; @@ -442,32 +450,14 @@ verto_add_signal(struct vertoEvCtx *ctx, enum vertoEvPriority priority, struct vertoEv * verto_add_child(struct vertoEvCtx *ctx, enum vertoEvPriority priority, - vertoCallback callback, void *priv, pid_t pid) + enum vertoEvFlag flags, vertoCallback callback, void *priv, + pid_t pid) { - if (pid < 1) + if (pid < 1 || (flags & VERTO_EV_FLAG_PERSIST)) /* persist makes no sense */ return NULL; doadd(ev->option.child.pid = pid, VERTO_EV_TYPE_CHILD); } -struct vertoEv * -verto_repeat(const struct vertoEv *ev) -{ - switch (ev->type) { - case VERTO_EV_TYPE_TIMEOUT: - return verto_add_timeout(ev->ctx, ev->priority, ev->callback, ev->priv, - ev->option.interval); - case VERTO_EV_TYPE_IDLE: - return verto_add_idle(ev->ctx, ev->priority, ev->callback, ev->priv); - case VERTO_EV_TYPE_CHILD: - case VERTO_EV_TYPE_IO: - case VERTO_EV_TYPE_SIGNAL: - default: - break; /* Not supported */ - } - - return NULL; -} - void * verto_get_private(const struct vertoEv *ev) { @@ -486,6 +476,12 @@ verto_get_priority(const struct vertoEv *ev) return ev->priority; } +enum vertoEvFlag +verto_get_flags(const struct vertoEv *ev) +{ + return ev->flags; +} + int verto_get_io_fd(const struct vertoEv *ev) { @@ -494,7 +490,7 @@ verto_get_io_fd(const struct vertoEv *ev) return -1; } -enum vertoEvIOFlags +enum vertoEvIOFlag verto_get_io_flags(const struct vertoEv *ev) { if (ev && (ev->type & VERTO_EV_TYPE_IO)) @@ -569,9 +565,17 @@ verto_convert_funcs(const struct vertoEvCtxFuncs *funcs, void verto_fire(struct vertoEv *ev) { + void *priv; + ev->callback(ev->ctx, ev); - if (!(ev->type & (VERTO_EV_TYPE_SIGNAL | VERTO_EV_TYPE_IO))) + if (!(ev->flags & VERTO_EV_FLAG_PERSIST)) verto_del(ev); + else if (!ev->persists) { + priv = ev->ctx->funcs.ctx_add(ev->ctx->modpriv, ev, &ev->persists); + assert(priv); /* TODO: create an error callback */ + ev->ctx->funcs.ctx_del(ev->ctx->modpriv, ev, ev->modpriv); + ev->modpriv = priv; + } } void diff --git a/src/verto.h b/src/verto.h index 4f93ad4..a77bcee 100644 --- a/src/verto.h +++ b/src/verto.h @@ -50,10 +50,17 @@ enum vertoEvPriority { _VERTO_EV_PRIORITY_MAX = VERTO_EV_PRIORITY_HIGH }; -enum vertoEvIOFlags { +enum vertoEvFlag { + VERTO_EV_FLAG_NONE = 0, + VERTO_EV_FLAG_PERSIST = 1, + _VERTO_EV_FLAG_MAX = VERTO_EV_FLAG_PERSIST +}; + +enum vertoEvIOFlag { VERTO_EV_IO_FLAG_NONE = 0, VERTO_EV_IO_FLAG_READ = 1, VERTO_EV_IO_FLAG_WRITE = 1 << 1, + _VERTO_EV_IO_FLAG_MAX = VERTO_EV_IO_FLAG_WRITE }; typedef void (*vertoCallback)(struct vertoEvCtx *ctx, struct vertoEv *ev); @@ -207,8 +214,8 @@ verto_break(struct vertoEvCtx *ctx); */ struct vertoEv * verto_add_io(struct vertoEvCtx *ctx, enum vertoEvPriority priority, - vertoCallback callback, void *priv, int fd, - enum vertoEvIOFlags flags); + enum vertoEvFlag flags, vertoCallback callback, void *priv, int fd, + enum vertoEvIOFlag ioflags); /** * Adds a callback executed after a period of time. @@ -234,7 +241,8 @@ verto_add_io(struct vertoEvCtx *ctx, enum vertoEvPriority priority, */ struct vertoEv * verto_add_timeout(struct vertoEvCtx *ctx, enum vertoEvPriority priority, - vertoCallback callback, void *priv, time_t interval); + enum vertoEvFlag flags, vertoCallback callback, void *priv, + time_t interval); /** * Adds a callback executed when there is nothing else to do. @@ -259,7 +267,7 @@ verto_add_timeout(struct vertoEvCtx *ctx, enum vertoEvPriority priority, */ struct vertoEv * verto_add_idle(struct vertoEvCtx *ctx, enum vertoEvPriority priority, - vertoCallback callback, void *priv); + enum vertoEvFlag flags, vertoCallback callback, void *priv); /** * Adds a callback executed when a signal is received. @@ -296,7 +304,8 @@ verto_add_idle(struct vertoEvCtx *ctx, enum vertoEvPriority priority, */ struct vertoEv * verto_add_signal(struct vertoEvCtx *ctx, enum vertoEvPriority priority, - vertoCallback callback, void *priv, int signal); + enum vertoEvFlag flags, vertoCallback callback, void *priv, + int signal); /** * Adds a callback executed when a child process exits. @@ -322,24 +331,8 @@ verto_add_signal(struct vertoEvCtx *ctx, enum vertoEvPriority priority, */ struct vertoEv * verto_add_child(struct vertoEvCtx *ctx, enum vertoEvPriority priority, - vertoCallback callback, void *priv, pid_t pid); - -/** - * Duplicates the current event so that it will be fired again. - * - * Always returns NULL for signal events since they are persistent. - * - * @see verto_add_read() - * @see verto_add_write() - * @see verto_add_timeout() - * @see verto_add_idle() - * @see verto_add_child() - * @see verto_del() - * @param ev The vertoEv to add. - * @return The new vertoEv registered with the event context. - */ -struct vertoEv * -verto_repeat(const struct vertoEv *ev); + enum vertoEvFlag flags, vertoCallback callback, void *priv, + pid_t pid); /** * Gets the private pointer of the vertoEv. @@ -386,6 +379,9 @@ verto_get_type(const struct vertoEv *ev); enum vertoEvPriority verto_get_priority(const struct vertoEv *ev); +enum vertoEvFlag +verto_get_flags(const struct vertoEv *ev); + /** * Gets the file descriptor associated with a read/write vertoEv. * @@ -397,7 +393,7 @@ verto_get_priority(const struct vertoEv *ev); int verto_get_io_fd(const struct vertoEv *ev); -enum vertoEvIOFlags +enum vertoEvIOFlag verto_get_io_flags(const struct vertoEv *ev); /** diff --git a/tests/child.c b/tests/child.c index 0ed89d9..e527375 100644 --- a/tests/child.c +++ b/tests/child.c @@ -64,9 +64,12 @@ do_test(struct vertoEvCtx *ctx) exit(EXITCODE); } - verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, exit_cb, NULL, 100); + verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_NONE, exit_cb, NULL, 100); - if (!verto_add_child(ctx, VERTO_EV_PRIORITY_DEFAULT, cb, NULL, pid)) { + /* Persist makes no sense for children events */ + assert(!verto_add_child(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_PERSIST, cb, NULL, pid)); + + if (!verto_add_child(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_NONE, cb, NULL, pid)) { printf("WARNING: Child not supported!\n"); usleep(100000); waitpid(pid, &exitstatus, 0); diff --git a/tests/idle.c b/tests/idle.c index 94728a3..1a508e4 100644 --- a/tests/idle.c +++ b/tests/idle.c @@ -24,16 +24,30 @@ #include "test.h" -static int occurrences; +static int callcount; +struct vertoEv *idle = NULL; void exit_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) { - if (occurrences == 0) - printf("WARNING: Idle not supported!\n"); - else if (occurrences > 1) { - printf("ERROR: Idle must not recur!\n"); - retval = 1; + retval = 1; + switch (callcount) { + case 1: + printf("ERROR: Idle (persist) did not recur!\n"); + break; + case 2: + printf("ERROR: Idle (non-persist) did not fire!\n"); + break; + case 0: + if (idle) { + printf("ERROR: Idle (persist) did not fire!\n"); + break; + } + printf("WARNING: Idle not supported!\n"); + case 3: + retval = 0; + default: + break; } verto_break(ctx); @@ -42,19 +56,18 @@ exit_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) void cb(struct vertoEvCtx *ctx, struct vertoEv *ev) { - if (++occurrences > 1) - exit_cb(ctx, ev); - - verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, exit_cb, NULL, 100); + if (++callcount == 2) { + verto_add_idle(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_NONE, cb, NULL); + verto_del(ev); + } } int do_test(struct vertoEvCtx *ctx) { - occurrences = 0; - - if (!verto_add_idle(ctx, VERTO_EV_PRIORITY_DEFAULT, cb, NULL)) - verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, exit_cb, NULL, 1); - + callcount = 0; + idle = verto_add_idle(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_PERSIST, cb, NULL); + assert(verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_NONE, + exit_cb, NULL, idle ? 100 : 1)); return 0; } diff --git a/tests/read.c b/tests/read.c index 056e236..d769d65 100644 --- a/tests/read.c +++ b/tests/read.c @@ -83,8 +83,8 @@ do_test(struct vertoEvCtx *ctx) fds[1] = -1; assert(pipe(fds) == 0); - assert(verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, timeout_cb, NULL, 1000)); - assert(verto_add_io(ctx, VERTO_EV_PRIORITY_DEFAULT, cb, NULL, fds[0], VERTO_EV_IO_FLAG_READ)); + assert(verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_NONE, timeout_cb, NULL, 1000)); + assert(verto_add_io(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_PERSIST, cb, NULL, fds[0], VERTO_EV_IO_FLAG_READ)); assert(write(fds[1], DATA, DATALEN) == DATALEN); return 0; } diff --git a/tests/signal.c b/tests/signal.c index c58077a..32bf8d5 100644 --- a/tests/signal.c +++ b/tests/signal.c @@ -64,11 +64,11 @@ do_test(struct vertoEvCtx *ctx) pid_t pid = 0; count = 0; - if (!verto_add_signal(ctx, VERTO_EV_PRIORITY_DEFAULT, cb, NULL, SIGUSR1)) { + if (!verto_add_signal(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_PERSIST, cb, NULL, SIGUSR1)) { printf("WARNING: Signal not supported!\n"); count = 2; } else { - verto_add_signal(ctx, VERTO_EV_PRIORITY_DEFAULT, + verto_add_signal(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_NONE, VERTO_SIG_IGN, NULL, SIGUSR2); pid = fork(); @@ -85,8 +85,8 @@ do_test(struct vertoEvCtx *ctx) } } - verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, exit_cb, - (void *) (uintptr_t) pid, 100); + verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_NONE, + exit_cb, (void *) (uintptr_t) pid, 100); return 0; } diff --git a/tests/test.h b/tests/test.h index 312d2cd..612b581 100644 --- a/tests/test.h +++ b/tests/test.h @@ -22,10 +22,12 @@ * SOFTWARE. */ +#include <stdbool.h> #include <stdlib.h> #include <stdio.h> #include <assert.h> #include <signal.h> +#include <string.h> #include <verto.h> @@ -82,3 +84,14 @@ main(int argc, char **argv) return retval; } + +void *passert(void *p) { + assert(p); + return p; +} + +#define new0(type) _new0(sizeof(type)) +void * _new0(ssize_t size) { + void *p = malloc(size); + return passert(p ? memset(p, 0, size) : p); +} diff --git a/tests/timeout.c b/tests/timeout.c index af10524..086ee5e 100644 --- a/tests/timeout.c +++ b/tests/timeout.c @@ -26,46 +26,55 @@ #include "test.h" +#define SLEEP 10 #define M2U(m) ((m) * 1000) -static struct timeval starttime; -static struct timeval endtime; +static int callcount; +struct timeval starttime; -void +static bool +elapsed(time_t min, time_t max) +{ + struct timeval tv; + long long diff; + + assert(gettimeofday(&tv, NULL) == 0); + diff = (tv.tv_sec - starttime.tv_sec) * M2U(1000) + + tv.tv_usec - starttime.tv_usec; + + assert(gettimeofday(&starttime, NULL) == 0); + if (diff < M2U(min) || diff > M2U(max)) { + printf("ERROR: Timeout is out-of-bounds!\n"); + return false; + } + return true; +} + +static void exit_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) { + assert(callcount == 3); verto_break(ctx); } -void +static void cb(struct vertoEvCtx *ctx, struct vertoEv *ev) { - long long diff; - - if (starttime.tv_sec == endtime.tv_sec && starttime.tv_usec == endtime.tv_usec) { - gettimeofday(&endtime, NULL); - - diff = (endtime.tv_sec - starttime.tv_sec) * M2U(1000) - + endtime.tv_usec - starttime.tv_usec; - - retval = diff < M2U(50) || diff > M2U(100); - if (retval != 0) - printf("ERROR: Timeout is out-of-bounds!\n"); - verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, exit_cb, NULL, 100); - return; + assert(elapsed(SLEEP, SLEEP*2)); + if (++callcount == 3) + assert(verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_NONE, exit_cb, NULL, SLEEP*2)); + else if (callcount == 2) { + assert(verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_NONE, cb, NULL, SLEEP)); + verto_del(ev); } - - printf("ERROR: Timeout must not repeat!\n"); - retval = 1; - exit_cb(ctx, ev); } int do_test(struct vertoEvCtx *ctx) { - gettimeofday(&starttime, NULL); - endtime = starttime; + callcount = 0; - assert(verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, cb, NULL, 50)); + assert(gettimeofday(&starttime, NULL) == 0); + assert(verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_PERSIST, cb, NULL, SLEEP)); return 0; } diff --git a/tests/write.c b/tests/write.c index daf17a6..350564b 100644 --- a/tests/write.c +++ b/tests/write.c @@ -76,7 +76,7 @@ read_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) fds[0] = -1; verto_del(ev); /* We don't want this callback called because of close() */ - assert(verto_add_io(ctx, VERTO_EV_PRIORITY_DEFAULT, error_cb, NULL, fds[1], VERTO_EV_IO_FLAG_WRITE)); + assert(verto_add_io(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_PERSIST, error_cb, NULL, fds[1], VERTO_EV_IO_FLAG_WRITE)); } static void @@ -88,7 +88,7 @@ write_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) assert(write(fd, DATA, DATALEN) == DATALEN); verto_del(ev); - assert(verto_add_io(ctx, VERTO_EV_PRIORITY_DEFAULT, read_cb, NULL, fds[0], VERTO_EV_IO_FLAG_READ)); + assert(verto_add_io(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_PERSIST, read_cb, NULL, fds[0], VERTO_EV_IO_FLAG_READ)); } int @@ -98,11 +98,11 @@ do_test(struct vertoEvCtx *ctx) fds[0] = -1; fds[1] = -1; - if (!verto_add_signal(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_SIG_IGN, NULL, SIGPIPE)) + if (!verto_add_signal(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_NONE, VERTO_SIG_IGN, NULL, SIGPIPE)) signal(SIGPIPE, SIG_IGN); assert(pipe(fds) == 0); - assert(verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, timeout_cb, NULL, 1000)); - assert(verto_add_io(ctx, VERTO_EV_PRIORITY_DEFAULT, write_cb, NULL, fds[1], VERTO_EV_IO_FLAG_WRITE)); + assert(verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_NONE, timeout_cb, NULL, 1000)); + assert(verto_add_io(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_EV_FLAG_PERSIST, write_cb, NULL, fds[1], VERTO_EV_IO_FLAG_WRITE)); return 0; }

1 0

[libverto] [all] make read/write a flag rather than a function
by Nathaniel McCallum 29 Jun '11

29 Jun '11

commit a7737dc7dd8a26994818ec5dfa3f59de7620431f Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Tue Jun 28 14:41:20 2011 -0400 [all] make read/write a flag rather than a function src/verto-glib.c | 37 +++++++++++++++-------------- src/verto-libev.c | 18 +++++++------- src/verto-libevent.c | 18 ++++++++++---- src/verto-tevent.c | 33 +++++++++---------------- src/verto.c | 49 ++++++++++++++++++-------------------- src/verto.h | 64 +++++++++++++++----------------------------------- tests/read.c | 39 +++++++++++++++--------------- tests/write.c | 26 ++++++++++++-------- 8 files changed, 130 insertions(+), 154 deletions(-) --- diff --git a/src/verto-glib.c b/src/verto-glib.c index 6320cc4..a8d652b 100644 --- a/src/verto-glib.c +++ b/src/verto-glib.c @@ -41,7 +41,6 @@ struct glibEvCtx { struct glibEv { GSource *src; - guint tag; GIOChannel *chan; }; @@ -109,7 +108,7 @@ gboolean glib_callback_io(GIOChannel *source, GIOCondition condition, gpointer data) { verto_fire(data); - return FALSE; + return TRUE; } static void @@ -130,17 +129,18 @@ glib_ctx_add(void *ctx, const struct vertoEv *ev) return NULL; switch (type) { - case VERTO_EV_TYPE_READ: - case VERTO_EV_TYPE_WRITE: - gev->chan = g_io_channel_unix_new(verto_get_fd(ev)); + case VERTO_EV_TYPE_IO: + gev->chan = g_io_channel_unix_new(verto_get_io_fd(ev)); if (!gev->chan) goto error; g_io_channel_set_close_on_unref(gev->chan, FALSE); - gev->src = g_io_create_watch(gev->chan, - verto_get_type(ev) == VERTO_EV_TYPE_READ - ? G_IO_IN - : G_IO_OUT); + GIOCondition cond = 0; + if (verto_get_io_flags(ev) & VERTO_EV_IO_FLAG_READ) + cond |= G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP | G_IO_NVAL; + if (verto_get_io_flags(ev) & VERTO_EV_IO_FLAG_WRITE) + cond |= G_IO_OUT | G_IO_ERR | G_IO_HUP | G_IO_NVAL; + gev->src = g_io_create_watch(gev->chan, cond); break; case VERTO_EV_TYPE_TIMEOUT: gev->src = g_timeout_source_new(verto_get_interval(ev)); @@ -165,7 +165,7 @@ glib_ctx_add(void *ctx, const struct vertoEv *ev) if (!gev->src) goto error; - if (type & (VERTO_EV_TYPE_READ | VERTO_EV_TYPE_WRITE)) + if (type & VERTO_EV_TYPE_IO) g_source_set_callback(gev->src, (GSourceFunc) glib_callback_io, (void *) ev, NULL); else if (type & VERTO_EV_TYPE_CHILD) g_source_set_callback(gev->src, (GSourceFunc) glib_callback_child, (void *) ev, NULL); @@ -174,8 +174,7 @@ glib_ctx_add(void *ctx, const struct vertoEv *ev) g_source_set_can_recurse(gev->src, FALSE); g_source_set_priority(gev->src, priority_map[verto_get_priority(ev)]); - gev->tag = g_source_attach(gev->src, ((struct glibEvCtx*) ctx)->context); - if (gev->tag == 0) + if (g_source_attach(gev->src, ((struct glibEvCtx*) ctx)->context) == 0) goto error; return gev; @@ -184,6 +183,10 @@ glib_ctx_add(void *ctx, const struct vertoEv *ev) if (gev) { if (gev->chan) g_io_channel_unref(gev->chan); + if (gev->src) { + g_source_destroy(gev->src); + g_source_unref(gev->src); + } g_free(gev); } return NULL; @@ -195,12 +198,12 @@ glib_ctx_del(void *lp, const struct vertoEv *ev, void *evpriv) if (!ev) return; - if (((struct glibEv *) evpriv)->tag > 0) - g_source_remove(((struct glibEv *) evpriv)->tag); - if (((struct glibEv *) evpriv)->src) - g_source_unref(((struct glibEv *) evpriv)->src); if (((struct glibEv *) evpriv)->chan) g_io_channel_unref(((struct glibEv *) evpriv)->chan); + if (((struct glibEv *) evpriv)->src) { + g_source_destroy(((struct glibEv *) evpriv)->src); + g_source_unref(((struct glibEv *) evpriv)->src); + } g_free(evpriv); } @@ -222,5 +225,3 @@ verto_convert_glib(GMainContext *mc, GMainLoop *ml) { return verto_convert(glib, glib_convert_(mc, ml)); } - - diff --git a/src/verto-libev.c b/src/verto-libev.c index 3d6dad9..a59fe8b 100644 --- a/src/verto-libev.c +++ b/src/verto-libev.c @@ -81,12 +81,15 @@ libev_ctx_add(void *ctx, const struct vertoEv *ev) ev_signal *signalw = NULL; ev_child *childw = NULL; ev_tstamp interval; + int events = EV_NONE; switch (verto_get_type(ev)) { - case VERTO_EV_TYPE_READ: - setuptype(io, ev, libev_callback, verto_get_fd(ev), EV_READ); - case VERTO_EV_TYPE_WRITE: - setuptype(io, ev, libev_callback, verto_get_fd(ev), EV_WRITE); + case VERTO_EV_TYPE_IO: + if (verto_get_io_flags(ev) & VERTO_EV_IO_FLAG_READ) + events |= EV_READ; + if (verto_get_io_flags(ev) & VERTO_EV_IO_FLAG_WRITE) + events |= EV_WRITE; + setuptype(io, ev, libev_callback, verto_get_io_fd(ev), events); case VERTO_EV_TYPE_TIMEOUT: interval = ((ev_tstamp) verto_get_interval(ev)) / 1000.0; setuptype(timer, ev, libev_callback, interval, interval); @@ -97,18 +100,15 @@ libev_ctx_add(void *ctx, const struct vertoEv *ev) case VERTO_EV_TYPE_CHILD: setuptype(child, ev, libev_callback, verto_get_pid(ev), 0); default: - break; /* Not supported */ + return NULL; /* Not supported */ } - - return NULL; } static void libev_ctx_del(void *ctx, const struct vertoEv *ev, void *evpriv) { switch (verto_get_type(ev)) { - case VERTO_EV_TYPE_READ: - case VERTO_EV_TYPE_WRITE: + case VERTO_EV_TYPE_IO: ev_io_stop(ctx, evpriv); case VERTO_EV_TYPE_TIMEOUT: ev_timer_stop(ctx, evpriv); diff --git a/src/verto-libevent.c b/src/verto-libevent.c index bd07cbe..30f41d2 100644 --- a/src/verto-libevent.c +++ b/src/verto-libevent.c @@ -36,6 +36,9 @@ * sense of "global." */ extern struct event_base *event_global_current_base_; +/* DEFAULT, LOW, MEDIUM, HIGH */ +static const int priority_map[4] = { 1, 2, 1, 0 }; + static void libevent_ctx_free(void *priv) { @@ -73,13 +76,16 @@ libevent_ctx_add(void *ctx, const struct vertoEv *ev) struct event *priv = NULL; struct timeval *timeout = NULL; struct timeval tv; + int flags = EV_PERSIST; switch (verto_get_type(ev)) { - case VERTO_EV_TYPE_READ: - priv = event_new(ctx, verto_get_fd(ev), EV_READ, libevent_callback, (void *) ev); - break; - case VERTO_EV_TYPE_WRITE: - priv = event_new(ctx, verto_get_fd(ev), EV_WRITE, libevent_callback, (void *) ev); + case VERTO_EV_TYPE_IO: + if (verto_get_io_flags(ev) & VERTO_EV_IO_FLAG_READ) + flags |= EV_READ; + if (verto_get_io_flags(ev) & VERTO_EV_IO_FLAG_WRITE) + flags |= EV_WRITE; + priv = event_new(ctx, verto_get_io_fd(ev), flags, + libevent_callback, (void *) ev); break; case VERTO_EV_TYPE_TIMEOUT: timeout = &tv; @@ -100,6 +106,7 @@ libevent_ctx_add(void *ctx, const struct vertoEv *ev) if (!priv) return NULL; + event_priority_set(priv, priority_map[verto_get_priority(ev)]); event_add(priv, timeout); return priv; } @@ -130,5 +137,6 @@ verto_default_libevent() struct vertoEvCtx * verto_convert_libevent(struct event_base* base) { + event_base_priority_init(base, 3); return verto_convert(libevent, base); } diff --git a/src/verto-tevent.c b/src/verto-tevent.c index f840e1a..307ed6f 100644 --- a/src/verto-tevent.c +++ b/src/verto-tevent.c @@ -80,40 +80,31 @@ definecb(signal, int signum, int count, void *siginfo) static void * tevent_ctx_add(void *ctx, const struct vertoEv *ev) { - void *priv = NULL; time_t interval; struct timeval tv; - - interval = verto_get_interval(ev); - tv = tevent_timeval_current_ofs(interval / 1000, interval % 1000 * 1000); + uint16_t flags = 0; switch (verto_get_type(ev)) { - case VERTO_EV_TYPE_READ: - priv = tevent_add_fd(tctx(ctx), tctx(ctx), verto_get_fd(ev), - TEVENT_FD_READ, tevent_fd_cb, (void *) ev); - break; - case VERTO_EV_TYPE_WRITE: - priv = tevent_add_fd(tctx(ctx), tctx(ctx), verto_get_fd(ev), - TEVENT_FD_WRITE, tevent_fd_cb, (void *) ev); - break; + case VERTO_EV_TYPE_IO: + if (verto_get_io_flags(ev) & VERTO_EV_IO_FLAG_READ) + flags |= TEVENT_FD_READ; + if (verto_get_io_flags(ev) & VERTO_EV_IO_FLAG_WRITE) + flags |= TEVENT_FD_WRITE; + return tevent_add_fd(tctx(ctx), tctx(ctx), verto_get_io_fd(ev), + flags, tevent_fd_cb, (void *) ev); case VERTO_EV_TYPE_TIMEOUT: - priv = tevent_add_timer(tctx(ctx), tctx(ctx), tv, + interval = verto_get_interval(ev); + tv = tevent_timeval_current_ofs(interval / 1000, interval % 1000 * 1000); + return tevent_add_timer(tctx(ctx), tctx(ctx), tv, tevent_timer_cb, (void *) ev); - break; case VERTO_EV_TYPE_SIGNAL: - priv = tevent_add_signal(tctx(ctx), tctx(ctx), verto_get_signal(ev), + return tevent_add_signal(tctx(ctx), tctx(ctx), verto_get_signal(ev), 0, tevent_signal_cb, (void *) ev); - break; case VERTO_EV_TYPE_IDLE: case VERTO_EV_TYPE_CHILD: default: return NULL; /* Not supported */ } - - if (!priv) - return NULL; - - return priv; } static void diff --git a/src/verto.c b/src/verto.c index 33689d7..3ec30af 100644 --- a/src/verto.c +++ b/src/verto.c @@ -54,6 +54,11 @@ struct vertoChild { int status; }; +struct vertoIO { + int fd; + enum vertoEvIOFlags flags; +}; + struct vertoEv { struct vertoEv *next; struct vertoEvCtx *ctx; @@ -63,10 +68,10 @@ struct vertoEv { void *priv; void *modpriv; union { - int fd; int signal; time_t interval; struct vertoChild child; + struct vertoIO io; } option; }; @@ -401,22 +406,13 @@ verto_break(struct vertoEvCtx *ctx) return ev; struct vertoEv * -verto_add_read(struct vertoEvCtx *ctx, enum vertoEvPriority priority, - vertoCallback callback, void *priv, int fd) -{ - if (fd < 0) - return NULL; - doadd(ev->option.fd = fd, VERTO_EV_TYPE_READ); -} - - -struct vertoEv * -verto_add_write(struct vertoEvCtx *ctx, enum vertoEvPriority priority, - vertoCallback callback, void *priv, int fd) +verto_add_io(struct vertoEvCtx *ctx, enum vertoEvPriority priority, + vertoCallback callback, void *priv, int fd, + enum vertoEvIOFlags flags) { if (fd < 0) return NULL; - doadd(ev->option.fd = fd, VERTO_EV_TYPE_WRITE); + doadd(ev->option.io.fd = fd; ev->option.io.flags = flags, VERTO_EV_TYPE_IO); } struct vertoEv * @@ -457,20 +453,13 @@ struct vertoEv * verto_repeat(const struct vertoEv *ev) { switch (ev->type) { - case VERTO_EV_TYPE_READ: - return verto_add_read(ev->ctx, ev->priority, ev->callback, ev->priv, - ev->option.fd); - case VERTO_EV_TYPE_WRITE: - return verto_add_write(ev->ctx, ev->priority, ev->callback, ev->priv, - ev->option.fd); case VERTO_EV_TYPE_TIMEOUT: return verto_add_timeout(ev->ctx, ev->priority, ev->callback, ev->priv, ev->option.interval); case VERTO_EV_TYPE_IDLE: return verto_add_idle(ev->ctx, ev->priority, ev->callback, ev->priv); case VERTO_EV_TYPE_CHILD: - return verto_add_child(ev->ctx, ev->priority, ev->callback, ev->priv, - ev->option.child.pid); + case VERTO_EV_TYPE_IO: case VERTO_EV_TYPE_SIGNAL: default: break; /* Not supported */ @@ -498,13 +487,21 @@ verto_get_priority(const struct vertoEv *ev) } int -verto_get_fd(const struct vertoEv *ev) +verto_get_io_fd(const struct vertoEv *ev) { - if (ev && (ev->type & (VERTO_EV_TYPE_READ | VERTO_EV_TYPE_WRITE))) - return ev->option.fd; + if (ev && (ev->type & VERTO_EV_TYPE_IO)) + return ev->option.io.fd; return -1; } +enum vertoEvIOFlags +verto_get_io_flags(const struct vertoEv *ev) +{ + if (ev && (ev->type & VERTO_EV_TYPE_IO)) + return ev->option.io.flags; + return VERTO_EV_IO_FLAG_NONE; +} + time_t verto_get_interval(const struct vertoEv *ev) { @@ -573,7 +570,7 @@ void verto_fire(struct vertoEv *ev) { ev->callback(ev->ctx, ev); - if (ev->type != VERTO_EV_TYPE_SIGNAL) + if (!(ev->type & (VERTO_EV_TYPE_SIGNAL | VERTO_EV_TYPE_IO))) verto_del(ev); } diff --git a/src/verto.h b/src/verto.h index 1927612..4f93ad4 100644 --- a/src/verto.h +++ b/src/verto.h @@ -34,12 +34,11 @@ struct vertoEvCtx; struct vertoEv; enum vertoEvType { - VERTO_EV_TYPE_READ = 1, - VERTO_EV_TYPE_WRITE = 1 << 1, - VERTO_EV_TYPE_TIMEOUT = 1 << 2, - VERTO_EV_TYPE_IDLE = 1 << 3, - VERTO_EV_TYPE_SIGNAL = 1 << 4, - VERTO_EV_TYPE_CHILD = 1 << 5, + VERTO_EV_TYPE_IO = 1, + VERTO_EV_TYPE_TIMEOUT = 1 << 1, + VERTO_EV_TYPE_IDLE = 1 << 2, + VERTO_EV_TYPE_SIGNAL = 1 << 3, + VERTO_EV_TYPE_CHILD = 1 << 4, _VERTO_EV_TYPE_MAX = VERTO_EV_TYPE_CHILD }; @@ -51,6 +50,12 @@ enum vertoEvPriority { _VERTO_EV_PRIORITY_MAX = VERTO_EV_PRIORITY_HIGH }; +enum vertoEvIOFlags { + VERTO_EV_IO_FLAG_NONE = 0, + VERTO_EV_IO_FLAG_READ = 1, + VERTO_EV_IO_FLAG_WRITE = 1 << 1, +}; + typedef void (*vertoCallback)(struct vertoEvCtx *ctx, struct vertoEv *ev); /** @@ -188,16 +193,7 @@ void verto_break(struct vertoEvCtx *ctx); /** - * Adds a callback executed when a file descriptor is ready to be read. - * - * Unlike some other event loop implementations, a vertoEv is a single-fire - * event, that is it does not persist. To cancel a future callback, use - * verto_del(). To repeat this event, use verto_repeat() inside the callback. - * - * The vertoEv returned is automatically freed: - * 1. After the callback is called. - * 2. When verto_del() is called. - * 3. When verto_free() is called on the EvCtx associated with this event. + * Adds a callback executed when a file descriptor is ready to be read/written. * * @see verto_repeat() * @see verto_del() @@ -210,34 +206,9 @@ verto_break(struct vertoEvCtx *ctx); * @return The vertoEv registered with the event context. */ struct vertoEv * -verto_add_read(struct vertoEvCtx *ctx, enum vertoEvPriority priority, - vertoCallback callback, void *priv, int fd); - -/** - * Adds a callback executed when a file descriptor is ready to be written. - * - * Unlike some other event loop implementations, a vertoEv is a single-fire - * event, that is it does not persist. To cancel a future callback, use - * verto_del(). To repeat this event, use verto_repeat() inside the callback. - * - * The vertoEv returned is automatically freed: - * 1. After the callback is called. - * 2. When verto_del() is called. - * 3. When verto_free() is called on the EvCtx associated with this event. - * - * @see verto_repeat() - * @see verto_del() - * @param ctx The vertoEvCtx which will fire the callback. - * @param priority The priority of the event (priority is not supported on - * all implementations). - * @param callback The callback to fire. - * @param priv Data which will be passed to the callback. - * @param fd The file descriptor to watch for writes. - * @return The vertoEv registered with the event context. - */ -struct vertoEv * -verto_add_write(struct vertoEvCtx *ctx, enum vertoEvPriority priority, - vertoCallback callback, void *priv, int fd); +verto_add_io(struct vertoEvCtx *ctx, enum vertoEvPriority priority, + vertoCallback callback, void *priv, int fd, + enum vertoEvIOFlags flags); /** * Adds a callback executed after a period of time. @@ -424,7 +395,10 @@ verto_get_priority(const struct vertoEv *ev); * @return The file descriptor, or -1 if not a read/write event. */ int -verto_get_fd(const struct vertoEv *ev); +verto_get_io_fd(const struct vertoEv *ev); + +enum vertoEvIOFlags +verto_get_io_flags(const struct vertoEv *ev); /** * Gets the interval associated with a timeout vertoEv. diff --git a/tests/read.c b/tests/read.c index a32faed..056e236 100644 --- a/tests/read.c +++ b/tests/read.c @@ -36,6 +36,7 @@ #define DATALEN 5 static int fds[2]; +static int callcount = 0; static void timeout_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) @@ -51,41 +52,39 @@ timeout_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) } static void -error_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) +cb(struct vertoEvCtx *ctx, struct vertoEv *ev) { unsigned char buff[DATALEN]; - int fd = verto_get_fd(ev); - assert(fd == fds[0]); - - /* When we get here, the fd should be closed, so an error should occur */ - assert(read(fd, buff, DATALEN) != DATALEN); - close(fd); - fds[0] = -1; - verto_break(ctx); -} + int fd = 0; + ssize_t bytes = 0; -static void -data_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) -{ - unsigned char buff[DATALEN]; - int fd = verto_get_fd(ev); + fd = verto_get_io_fd(ev); assert(fd == fds[0]); - assert(read(fd, buff, DATALEN) == DATALEN); - close(fds[1]); - fds[1] = -1; - assert(verto_add_read(ctx, VERTO_EV_PRIORITY_DEFAULT, error_cb, NULL, fd)); + bytes = read(fd, buff, DATALEN); + if (callcount++ == 0) { + assert(bytes == DATALEN); + close(fds[1]); + fds[1] = -1; + } + else { + assert(bytes != DATALEN); + close(fd); + fds[0] = -1; + verto_break(ctx); + } } int do_test(struct vertoEvCtx *ctx) { + callcount = 0; fds[0] = -1; fds[1] = -1; assert(pipe(fds) == 0); assert(verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, timeout_cb, NULL, 1000)); - assert(verto_add_read(ctx, VERTO_EV_PRIORITY_DEFAULT, data_cb, NULL, fds[0])); + assert(verto_add_io(ctx, VERTO_EV_PRIORITY_DEFAULT, cb, NULL, fds[0], VERTO_EV_IO_FLAG_READ)); assert(write(fds[1], DATA, DATALEN) == DATALEN); return 0; } diff --git a/tests/write.c b/tests/write.c index aee7a7e..daf17a6 100644 --- a/tests/write.c +++ b/tests/write.c @@ -36,6 +36,7 @@ #define DATALEN 5 static int fds[2]; +static int callcount = 0; static void timeout_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) @@ -53,11 +54,12 @@ timeout_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) static void error_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) { - int fd = verto_get_fd(ev); - assert(fd == fds[1]); + int fd = 0; /* When we get here, the fd should be closed, so an error should occur */ + fd = verto_get_io_fd(ev); assert(write(fd, DATA, DATALEN) != DATALEN); + verto_del(ev); verto_break(ctx); close(fd); fds[1] = -1; @@ -67,27 +69,32 @@ static void read_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) { unsigned char buff[DATALEN]; - int fd = verto_get_fd(ev); - assert(fd == fds[0]); + int fd = verto_get_io_fd(ev); assert(read(fd, buff, DATALEN) == DATALEN); - assert(verto_add_write(ctx, VERTO_EV_PRIORITY_HIGH, error_cb, NULL, fds[1])); close(fd); fds[0] = -1; + + verto_del(ev); /* We don't want this callback called because of close() */ + assert(verto_add_io(ctx, VERTO_EV_PRIORITY_DEFAULT, error_cb, NULL, fds[1], VERTO_EV_IO_FLAG_WRITE)); } static void write_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) { - int fd = verto_get_fd(ev); - assert(fd == fds[1]); + int fd = 0; + fd = verto_get_io_fd(ev); assert(write(fd, DATA, DATALEN) == DATALEN); + + verto_del(ev); + assert(verto_add_io(ctx, VERTO_EV_PRIORITY_DEFAULT, read_cb, NULL, fds[0], VERTO_EV_IO_FLAG_READ)); } int do_test(struct vertoEvCtx *ctx) { + callcount = 0; fds[0] = -1; fds[1] = -1; @@ -95,8 +102,7 @@ do_test(struct vertoEvCtx *ctx) signal(SIGPIPE, SIG_IGN); assert(pipe(fds) == 0); - assert(verto_add_timeout(ctx, VERTO_EV_PRIORITY_LOW, timeout_cb, NULL, 1000)); - assert(verto_add_write(ctx, VERTO_EV_PRIORITY_HIGH, write_cb, NULL, fds[1])); - assert(verto_add_read(ctx, VERTO_EV_PRIORITY_LOW, read_cb, NULL, fds[0])); + assert(verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, timeout_cb, NULL, 1000)); + assert(verto_add_io(ctx, VERTO_EV_PRIORITY_DEFAULT, write_cb, NULL, fds[1], VERTO_EV_IO_FLAG_WRITE)); return 0; }

1 0

[libverto] [build] add autogen.sh
by Nathaniel McCallum 27 Jun '11

27 Jun '11

commit 59d13c629784c6c4eb1f25c663d0cf61bf3e3dbb Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Mon Jun 27 13:42:42 2011 -0400 [build] add autogen.sh .gitignore | 1 - autogen.sh | 19 +++++++++++++++++++ 2 files changed, 19 insertions(+), 1 deletions(-) --- diff --git a/.gitignore b/.gitignore index 78f8d77..831c3fe 100644 --- a/.gitignore +++ b/.gitignore @@ -1,7 +1,6 @@ .deps .libs aclocal.m4 -autogen.sh autom4te.cache config.guess config.log diff --git a/autogen.sh b/autogen.sh new file mode 100755 index 0000000..381a8b7 --- /dev/null +++ b/autogen.sh @@ -0,0 +1,19 @@ +#!/bin/bash + +srcdir=`dirname $0` +test -z "$srcdir" && srcdir=. +topdir=`pwd` +cd $srcdir + +LIBTOOLIZE=`which glibtoolize 2>/dev/null` +[ $LIBTOOLIZE ] || LIBTOOLIZE=`which libtoolize` +$LIBTOOLIZE -c -f --automake +aclocal +#autoheader +automake --foreign -a -c -f +autoconf -f + +cd $topdir +if test "x$NOCONFIGURE" = "x"; then + $srcdir/configure $@ +fi

1 0

[libverto] [tests/write] refactor to avoid race conditions
by Nathaniel McCallum 27 Jun '11

27 Jun '11

commit 9669b86042044c0ae109a4f59bcabbc6b1d50970 Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Thu Jun 23 19:38:31 2011 -0400 [tests/write] refactor to avoid race conditions tests/write.c | 100 +++++++++++++++++++++----------------------------------- 1 files changed, 38 insertions(+), 62 deletions(-) --- diff --git a/tests/write.c b/tests/write.c index b1d4436..aee7a7e 100644 --- a/tests/write.c +++ b/tests/write.c @@ -35,92 +35,68 @@ #define DATA "hello" #define DATALEN 5 -static pid_t pid; -static int count; +static int fds[2]; static void -error_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) +timeout_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) { printf("ERROR: Timeout!\n"); + if (fds[0] >= 0) + close(fds[0]); + if (fds[1] >= 0) + close(fds[1]); + retval = 1; verto_break(ctx); } static void -cb(struct vertoEvCtx *ctx, struct vertoEv *ev) +error_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) { int fd = verto_get_fd(ev); + assert(fd == fds[1]); - count++; - if (write(fd, DATA, DATALEN) != DATALEN) { - if (count != 2) { - printf("ERROR: %d: %s\n", errno, strerror(errno)); - retval = 1; - } + /* When we get here, the fd should be closed, so an error should occur */ + assert(write(fd, DATA, DATALEN) != DATALEN); + verto_break(ctx); + close(fd); + fds[1] = -1; +} - goto out; - } +static void +read_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) +{ + unsigned char buff[DATALEN]; + int fd = verto_get_fd(ev); + assert(fd == fds[0]); - if (count > 1) { - printf("ERROR: Second call successful!?\n"); - retval = 1; - goto out; - } + assert(read(fd, buff, DATALEN) == DATALEN); + assert(verto_add_write(ctx, VERTO_EV_PRIORITY_HIGH, error_cb, NULL, fds[1])); + close(fd); + fds[0] = -1; +} - usleep(200000); /* 0.2 seconds; make time for child to close() */ - verto_repeat(ev); - return; +static void +write_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) +{ + int fd = verto_get_fd(ev); + assert(fd == fds[1]); - out: - waitpid(pid, NULL, 0); - close(fd); - verto_break(ctx); - return; + assert(write(fd, DATA, DATALEN) == DATALEN); } int do_test(struct vertoEvCtx *ctx) { - unsigned char buff[DATALEN]; - int fds[2] = {-1, -1}; - pid = 0; - count = 0; + fds[0] = -1; + fds[1] = -1; - /* Ignore when the pipe breaks */ if (!verto_add_signal(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_SIG_IGN, NULL, SIGPIPE)) signal(SIGPIPE, SIG_IGN); - if (pipe(fds) != 0) - return 1; - - if (!verto_add_write(ctx, VERTO_EV_PRIORITY_DEFAULT, cb, NULL, fds[1])) { - printf("ERROR: Unable to add write call!\n"); - close(fds[0]); - close(fds[1]); - return 1; - } - - if (!verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, error_cb, NULL, 1000)) { - printf("ERROR: Unable to add timeout!\n"); - close(fds[0]); - close(fds[1]); - return 1; - } - - pid = fork(); - if (pid < 0) - return 1; - else if (pid == 0) { - close(fds[1]); - usleep(100000); /* 0.1 seconds */ - if (read(fds[0], buff, DATALEN) != DATALEN) { - close(fds[0]); - exit(1); - } - close(fds[0]); - exit(0); - } - close(fds[0]); - + assert(pipe(fds) == 0); + assert(verto_add_timeout(ctx, VERTO_EV_PRIORITY_LOW, timeout_cb, NULL, 1000)); + assert(verto_add_write(ctx, VERTO_EV_PRIORITY_HIGH, write_cb, NULL, fds[1])); + assert(verto_add_read(ctx, VERTO_EV_PRIORITY_LOW, read_cb, NULL, fds[0])); return 0; }

1 0

[libverto] [tests/read] refactor to avoid race conditions
by Nathaniel McCallum 27 Jun '11

27 Jun '11

commit 1657f7248c8b23c1e96d49a0703b591bdcc5609e Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Thu Jun 23 19:38:23 2011 -0400 [tests/read] refactor to avoid race conditions tests/read.c | 91 ++++++++++++++++++++-------------------------------------- 1 files changed, 31 insertions(+), 60 deletions(-) --- diff --git a/tests/read.c b/tests/read.c index 26a9623..a32faed 100644 --- a/tests/read.c +++ b/tests/read.c @@ -35,86 +35,57 @@ #define DATA "hello" #define DATALEN 5 -static pid_t pid; -static int count; +static int fds[2]; static void -error_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) +timeout_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) { printf("ERROR: Timeout!\n"); + if (fds[0] >= 0) + close(fds[0]); + if (fds[1] >= 0) + close(fds[1]); + retval = 1; verto_break(ctx); } static void -cb(struct vertoEvCtx *ctx, struct vertoEv *ev) +error_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) { unsigned char buff[DATALEN]; int fd = verto_get_fd(ev); + assert(fd == fds[0]); - count++; - if (read(fd, buff, DATALEN) != DATALEN) { - if (count != 2) { - printf("ERROR: %d: %s\n", errno, strerror(errno)); - retval = 1; - } - - goto out; - } - - if (count > 1) { - printf("ERROR: Second call successful!?\n"); - retval = 1; - goto out; - } + /* When we get here, the fd should be closed, so an error should occur */ + assert(read(fd, buff, DATALEN) != DATALEN); + close(fd); + fds[0] = -1; + verto_break(ctx); +} - usleep(200000); /* 0.2 seconds; make time for child to close() */ - verto_repeat(ev); - return; +static void +data_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) +{ + unsigned char buff[DATALEN]; + int fd = verto_get_fd(ev); + assert(fd == fds[0]); - out: - waitpid(pid, NULL, 0); - close(fd); - verto_break(ctx); - return; + assert(read(fd, buff, DATALEN) == DATALEN); + close(fds[1]); + fds[1] = -1; + assert(verto_add_read(ctx, VERTO_EV_PRIORITY_DEFAULT, error_cb, NULL, fd)); } int do_test(struct vertoEvCtx *ctx) { - int fds[2] = {-1, -1}; - pid = 0; - count = 0; - - if (pipe(fds) != 0) - return 1; - - if (!verto_add_read(ctx, VERTO_EV_PRIORITY_DEFAULT, cb, NULL, fds[0])) { - printf("ERROR: Unable to add read call!\n"); - close(fds[0]); - close(fds[1]); - return 1; - } - - if (!verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, error_cb, NULL, 1000)) { - printf("ERROR: Unable to add timeout!\n"); - close(fds[0]); - close(fds[1]); - return 1; - } - - pid = fork(); - if (pid < 0) - return 1; - else if (pid == 0) { - close(fds[0]); - usleep(100000); /* 0.1 seconds */ - if (write(fds[1], DATA, DATALEN) != DATALEN) - exit(1); - close(fds[1]); - exit(0); - } - close(fds[1]); + fds[0] = -1; + fds[1] = -1; + assert(pipe(fds) == 0); + assert(verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, timeout_cb, NULL, 1000)); + assert(verto_add_read(ctx, VERTO_EV_PRIORITY_DEFAULT, data_cb, NULL, fds[0])); + assert(write(fds[1], DATA, DATALEN) == DATALEN); return 0; }

1 0

[libverto] [core] change version to 0.1
by Nathaniel McCallum 23 Jun '11

23 Jun '11

commit 724f4b6ebdf45cdc7811c7d900c9422258502484 Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Thu Jun 23 17:34:33 2011 -0400 [core] change version to 0.1 configure.ac | 2 +- 1 files changed, 1 insertions(+), 1 deletions(-) --- diff --git a/configure.ac b/configure.ac index 72530f6..a3a691f 100644 --- a/configure.ac +++ b/configure.ac @@ -1,7 +1,7 @@ dnl Process this file with autoconf to produce a configure script. AC_PREREQ(2.59) -AC_INIT(libverto, 1.0) +AC_INIT(libverto, 0.1) AC_CANONICAL_SYSTEM

1 0

[libverto] [pkgconfig] added .pc files
by Nathaniel McCallum 23 Jun '11

23 Jun '11

commit 8be2c6e3035e42a789867887811f28e5c76f1cc8 Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Thu Jun 23 17:33:40 2011 -0400 [pkgconfig] added .pc files .gitignore | 1 + Makefile.am | 7 +++++++ configure.ac | 9 ++++++++- libverto-glib.pc.in | 9 +++++++++ libverto-libev.pc.in | 9 +++++++++ libverto-libevent.pc.in | 9 +++++++++ libverto-tevent.pc.in | 9 +++++++++ libverto.pc.in | 9 +++++++++ 8 files changed, 61 insertions(+), 1 deletions(-) --- diff --git a/.gitignore b/.gitignore index a93a9da..78f8d77 100644 --- a/.gitignore +++ b/.gitignore @@ -21,6 +21,7 @@ missing *.lo *.o *.log +*.pc tests/idle tests/timeout diff --git a/Makefile.am b/Makefile.am index 0ddc5c9..ecd4347 100644 --- a/Makefile.am +++ b/Makefile.am @@ -1,2 +1,9 @@ +pkgconfigdir = $(libdir)/pkgconfig +pkgconfig_DATA = libverto.pc \ + libverto-glib.pc \ + libverto-libev.pc \ + libverto-libevent.pc \ + libverto-tevent.pc + ACLOCAL_AMFLAGS=-I m4 SUBDIRS=src tests diff --git a/configure.ac b/configure.ac index ea87a49..72530f6 100644 --- a/configure.ac +++ b/configure.ac @@ -92,6 +92,13 @@ echo -e "\tlibverto-libevent\t$with_libevent" echo -e "\tlibverto-tevent\t\t$with_tevent" echo -e "" -AC_CONFIG_FILES(Makefile src/Makefile tests/Makefile) +AC_CONFIG_FILES(Makefile + src/Makefile + tests/Makefile + libverto-glib.pc + libverto-libev.pc + libverto-libevent.pc + libverto-tevent.pc + libverto.pc) AC_OUTPUT diff --git a/libverto-glib.pc.in b/libverto-glib.pc.in new file mode 100644 index 0000000..2a75ce3 --- /dev/null +++ b/libverto-glib.pc.in @@ -0,0 +1,9 @@ +prefix=@prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: libverto-glib +Description: Event loop abstraction interface (glib module) +Version: @VERSION@ +Libs: -L${libdir} -lverto-glib +Cflags: -I${includedir} diff --git a/libverto-libev.pc.in b/libverto-libev.pc.in new file mode 100644 index 0000000..f793bd7 --- /dev/null +++ b/libverto-libev.pc.in @@ -0,0 +1,9 @@ +prefix=@prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: libverto-libev +Description: Event loop abstraction interface (libev module) +Version: @VERSION@ +Libs: -L${libdir} -lverto-libev +Cflags: -I${includedir} diff --git a/libverto-libevent.pc.in b/libverto-libevent.pc.in new file mode 100644 index 0000000..20f69c0 --- /dev/null +++ b/libverto-libevent.pc.in @@ -0,0 +1,9 @@ +prefix=@prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: libverto-libevent +Description: Event loop abstraction interface (libevent module) +Version: @VERSION@ +Libs: -L${libdir} -lverto-libevent +Cflags: -I${includedir} diff --git a/libverto-tevent.pc.in b/libverto-tevent.pc.in new file mode 100644 index 0000000..8714bfb --- /dev/null +++ b/libverto-tevent.pc.in @@ -0,0 +1,9 @@ +prefix=@prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: libverto-tevent +Description: Event loop abstraction interface (tevent module) +Version: @VERSION@ +Libs: -L${libdir} -lverto-tevent +Cflags: -I${includedir} diff --git a/libverto.pc.in b/libverto.pc.in new file mode 100644 index 0000000..1006092 --- /dev/null +++ b/libverto.pc.in @@ -0,0 +1,9 @@ +prefix=@prefix@ +libdir=@libdir@ +includedir=@includedir@ + +Name: libverto +Description: Event loop abstraction interface +Version: @VERSION@ +Libs: -L${libdir} -lverto +Cflags: -I${includedir}

1 0

[libverto] [tests/write] fall back to signal() if signals aren't supported
by Nathaniel McCallum 23 Jun '11

23 Jun '11

commit 3ddc80b1a287268810e2cdae27e31fce744d97a7 Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Thu Jun 23 17:14:20 2011 -0400 [tests/write] fall back to signal() if signals aren't supported tests/write.c | 3 ++- 1 files changed, 2 insertions(+), 1 deletions(-) --- diff --git a/tests/write.c b/tests/write.c index e83851b..b1d4436 100644 --- a/tests/write.c +++ b/tests/write.c @@ -87,7 +87,8 @@ do_test(struct vertoEvCtx *ctx) count = 0; /* Ignore when the pipe breaks */ - verto_add_signal(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_SIG_IGN, NULL, SIGPIPE); + if (!verto_add_signal(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_SIG_IGN, NULL, SIGPIPE)) + signal(SIGPIPE, SIG_IGN); if (pipe(fds) != 0) return 1;

1 0

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

libverto-commits June 2011