libverto-commits June 2011

libverto-commits@lists.fedorahosted.org

1 participants
66 discussions

[libverto] [tests/read] make tests/read more like tests/write
by Nathaniel McCallum 23 Jun '11

23 Jun '11

commit a05cee9c19272d356929a0c5c02d5844acb7091d Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Thu Jun 23 17:08:18 2011 -0400 [tests/read] make tests/read more like tests/write tests/read.c | 8 +++----- 1 files changed, 3 insertions(+), 5 deletions(-) --- diff --git a/tests/read.c b/tests/read.c index 39f8d6a..26a9623 100644 --- a/tests/read.c +++ b/tests/read.c @@ -41,7 +41,7 @@ static int count; static void error_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) { - printf("ERROR: Read event never fired!\n"); + printf("ERROR: Timeout!\n"); retval = 1; verto_break(ctx); } @@ -54,10 +54,8 @@ cb(struct vertoEvCtx *ctx, struct vertoEv *ev) count++; if (read(fd, buff, DATALEN) != DATALEN) { - /* If we got called because the fd was closed, OK. - * Otherwise, an error occurred. */ if (count != 2) { - printf("ERROR: %s\n", strerror(errno)); + printf("ERROR: %d: %s\n", errno, strerror(errno)); retval = 1; } @@ -70,6 +68,7 @@ cb(struct vertoEvCtx *ctx, struct vertoEv *ev) goto out; } + usleep(200000); /* 0.2 seconds; make time for child to close() */ verto_repeat(ev); return; @@ -112,7 +111,6 @@ do_test(struct vertoEvCtx *ctx) usleep(100000); /* 0.1 seconds */ if (write(fds[1], DATA, DATALEN) != DATALEN) exit(1); - usleep(100000); /* 0.1 seconds */ close(fds[1]); exit(0); }

1 0

[libverto] [tests/write] add write test
by Nathaniel McCallum 23 Jun '11

23 Jun '11

commit 3e328cde74a784627d42eb25bca207354f048661 Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Thu Jun 23 17:07:59 2011 -0400 [tests/write] add write test tests/Makefile.am | 2 +- tests/write.c | 125 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 126 insertions(+), 1 deletions(-) --- diff --git a/tests/Makefile.am b/tests/Makefile.am index b70a389..fac612f 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -16,6 +16,6 @@ if WITH_TEVENT AM_CFLAGS += -DHAVE_TEVENT=1 endif -TESTS = timeout idle child signal read +TESTS = timeout idle child signal read write noinst_PROGRAMS = $(TESTS) EXTRA_DIST = test.h \ No newline at end of file diff --git a/tests/write.c b/tests/write.c new file mode 100644 index 0000000..e83851b --- /dev/null +++ b/tests/write.c @@ -0,0 +1,125 @@ +/* + * 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 <stdint.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <signal.h> +#include <string.h> +#include <errno.h> + +#include <verto-module.h> +#include "test.h" + +#define DATA "hello" +#define DATALEN 5 + +static pid_t pid; +static int count; + +static void +error_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) +{ + printf("ERROR: Timeout!\n"); + retval = 1; + verto_break(ctx); +} + +static void +cb(struct vertoEvCtx *ctx, struct vertoEv *ev) +{ + int fd = verto_get_fd(ev); + + count++; + if (write(fd, DATA, 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; + } + + usleep(200000); /* 0.2 seconds; make time for child to close() */ + verto_repeat(ev); + return; + + out: + waitpid(pid, NULL, 0); + close(fd); + verto_break(ctx); + return; +} + +int +do_test(struct vertoEvCtx *ctx) +{ + unsigned char buff[DATALEN]; + int fds[2] = {-1, -1}; + pid = 0; + count = 0; + + /* Ignore when the pipe breaks */ + verto_add_signal(ctx, VERTO_EV_PRIORITY_DEFAULT, VERTO_SIG_IGN, NULL, SIGPIPE); + + 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]); + + return 0; +}

1 0

[libverto] [glib] fix the io callback
by Nathaniel McCallum 23 Jun '11

23 Jun '11

commit 6e1689fab871f831e4187c7db64a5a3afb696d28 Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Thu Jun 23 17:07:13 2011 -0400 [glib] fix the io callback src/verto-glib.c | 21 ++++++++++++++++----- 1 files changed, 16 insertions(+), 5 deletions(-) --- diff --git a/src/verto-glib.c b/src/verto-glib.c index a77869c..6320cc4 100644 --- a/src/verto-glib.c +++ b/src/verto-glib.c @@ -105,6 +105,13 @@ glib_callback(gpointer data) return retval; } +gboolean +glib_callback_io(GIOChannel *source, GIOCondition condition, gpointer data) +{ + verto_fire(data); + return FALSE; +} + static void glib_callback_child(GPid pid, gint status, gpointer data) { @@ -116,12 +123,13 @@ static void * glib_ctx_add(void *ctx, const struct vertoEv *ev) { struct glibEv *gev = NULL; + enum vertoEvType type = verto_get_type(ev); gev = g_new0(struct glibEv, 1); if (!gev) return NULL; - switch (verto_get_type(ev)) { + switch (type) { case VERTO_EV_TYPE_READ: case VERTO_EV_TYPE_WRITE: gev->chan = g_io_channel_unix_new(verto_get_fd(ev)); @@ -154,15 +162,18 @@ glib_ctx_add(void *ctx, const struct vertoEv *ev) return NULL; /* Not supported */ } - if (!gev->src) goto error; + if (type & (VERTO_EV_TYPE_READ | VERTO_EV_TYPE_WRITE)) + 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); + else + g_source_set_callback(gev->src, glib_callback, (void *) ev, NULL); + g_source_set_can_recurse(gev->src, FALSE); g_source_set_priority(gev->src, priority_map[verto_get_priority(ev)]); - g_source_set_callback(gev->src, verto_get_type(ev) == VERTO_EV_TYPE_CHILD - ? (GSourceFunc) glib_callback_child - : glib_callback, (void *) ev, NULL); gev->tag = g_source_attach(gev->src, ((struct glibEvCtx*) ctx)->context); if (gev->tag == 0) goto error;

1 0

[libverto] [core] add support for ignoring signals
by Nathaniel McCallum 23 Jun '11

23 Jun '11

commit 73e9cf9b33d20540cbb0e3cf7c97300c46407fad Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Thu Jun 23 16:59:48 2011 -0400 [core] add support for ignoring signals src/verto.c | 7 +++++++ src/verto.h | 2 ++ tests/signal.c | 8 +++++++- 3 files changed, 16 insertions(+), 1 deletions(-) --- diff --git a/src/verto.c b/src/verto.c index b4eb436..33689d7 100644 --- a/src/verto.c +++ b/src/verto.c @@ -263,6 +263,11 @@ remove_ev(struct vertoEv **origin, struct vertoEv *item) remove_ev(&((*origin)->next), item); } +static void +signal_ignore(struct vertoEvCtx *ctx, struct vertoEv *ev) +{ +} + struct vertoEvCtx * verto_new(const char *impl) { @@ -434,6 +439,8 @@ verto_add_signal(struct vertoEvCtx *ctx, enum vertoEvPriority priority, { if (signal < 0 || signal == SIGCHLD) return NULL; + if (callback == VERTO_SIG_IGN) + callback = signal_ignore; doadd(ev->option.signal = signal, VERTO_EV_TYPE_SIGNAL); } diff --git a/src/verto.h b/src/verto.h index b2e8036..1927612 100644 --- a/src/verto.h +++ b/src/verto.h @@ -28,6 +28,8 @@ #include <time.h> /* For time_t */ #include <unistd.h> /* For pid_t */ +#define VERTO_SIG_IGN ((vertoCallback) 1) + struct vertoEvCtx; struct vertoEv; diff --git a/tests/signal.c b/tests/signal.c index 90530b3..c58077a 100644 --- a/tests/signal.c +++ b/tests/signal.c @@ -68,6 +68,9 @@ do_test(struct vertoEvCtx *ctx) printf("WARNING: Signal not supported!\n"); count = 2; } else { + verto_add_signal(ctx, VERTO_EV_PRIORITY_DEFAULT, + VERTO_SIG_IGN, NULL, SIGUSR2); + pid = fork(); if (pid < 0) return 1; @@ -76,11 +79,14 @@ do_test(struct vertoEvCtx *ctx) kill(getppid(), SIGUSR1); usleep(10000); /* 0.01 seconds */ kill(getppid(), SIGUSR1); + usleep(10000); /* 0.01 seconds */ + kill(getppid(), SIGUSR2); exit(0); } } - verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, exit_cb, (void *) (uintptr_t) pid, 100); + verto_add_timeout(ctx, VERTO_EV_PRIORITY_DEFAULT, exit_cb, + (void *) (uintptr_t) pid, 100); return 0; }

1 0

[libverto] [tests/read] Make sure the error_cb gets added
by Nathaniel McCallum 23 Jun '11

23 Jun '11

commit b734b60c537f2b79b81466fde1e7e43a9b42d9b4 Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Thu Jun 23 16:16:20 2011 -0400 [tests/read] Make sure the error_cb gets added tests/read.c | 11 +++++++++-- 1 files changed, 9 insertions(+), 2 deletions(-) --- diff --git a/tests/read.c b/tests/read.c index a34af7d..39f8d6a 100644 --- a/tests/read.c +++ b/tests/read.c @@ -38,7 +38,7 @@ static pid_t pid; static int count; -void +static void error_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) { printf("ERROR: Read event never fired!\n"); @@ -46,7 +46,7 @@ error_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) verto_break(ctx); } -void +static void cb(struct vertoEvCtx *ctx, struct vertoEv *ev) { unsigned char buff[DATALEN]; @@ -97,6 +97,13 @@ do_test(struct vertoEvCtx *ctx) 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;

1 0

[libverto] [tests] add read test
by Nathaniel McCallum 23 Jun '11

23 Jun '11

commit 0727fd8b2bc53993d3edba6819cff5ad45f69a08 Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Thu Jun 23 16:07:53 2011 -0400 [tests] add read test tests/Makefile.am | 2 +- tests/read.c | 115 +++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 116 insertions(+), 1 deletions(-) --- diff --git a/tests/Makefile.am b/tests/Makefile.am index b5264b4..b70a389 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -16,6 +16,6 @@ if WITH_TEVENT AM_CFLAGS += -DHAVE_TEVENT=1 endif -TESTS = timeout idle child signal +TESTS = timeout idle child signal read noinst_PROGRAMS = $(TESTS) EXTRA_DIST = test.h \ No newline at end of file diff --git a/tests/read.c b/tests/read.c new file mode 100644 index 0000000..a34af7d --- /dev/null +++ b/tests/read.c @@ -0,0 +1,115 @@ +/* + * 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 <stdint.h> +#include <sys/types.h> +#include <sys/wait.h> +#include <signal.h> +#include <string.h> +#include <errno.h> + +#include <verto-module.h> +#include "test.h" + +#define DATA "hello" +#define DATALEN 5 + +static pid_t pid; +static int count; + +void +error_cb(struct vertoEvCtx *ctx, struct vertoEv *ev) +{ + printf("ERROR: Read event never fired!\n"); + retval = 1; + verto_break(ctx); +} + +void +cb(struct vertoEvCtx *ctx, struct vertoEv *ev) +{ + unsigned char buff[DATALEN]; + int fd = verto_get_fd(ev); + + count++; + if (read(fd, buff, DATALEN) != DATALEN) { + /* If we got called because the fd was closed, OK. + * Otherwise, an error occurred. */ + if (count != 2) { + printf("ERROR: %s\n", strerror(errno)); + retval = 1; + } + + goto out; + } + + if (count > 1) { + printf("ERROR: Second call successful!?\n"); + retval = 1; + goto out; + } + + verto_repeat(ev); + return; + + out: + waitpid(pid, NULL, 0); + close(fd); + verto_break(ctx); + return; +} + +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; + } + + 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); + usleep(100000); /* 0.1 seconds */ + close(fds[1]); + exit(0); + } + close(fds[1]); + + return 0; +}

1 0

[libverto] [core] make verto_add_child() not support SIGCHLD
by Nathaniel McCallum 23 Jun '11

23 Jun '11

commit 037868a4dee8635d74648757b65095fc03e344d7 Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Thu Jun 23 12:53:59 2011 -0400 [core] make verto_add_child() not support SIGCHLD src/verto.c | 2 +- src/verto.h | 4 ++++ 2 files changed, 5 insertions(+), 1 deletions(-) --- diff --git a/src/verto.c b/src/verto.c index 30d7deb..b4eb436 100644 --- a/src/verto.c +++ b/src/verto.c @@ -432,7 +432,7 @@ struct vertoEv * verto_add_signal(struct vertoEvCtx *ctx, enum vertoEvPriority priority, vertoCallback callback, void *priv, int signal) { - if (signal < 0) + if (signal < 0 || signal == SIGCHLD) return NULL; doadd(ev->option.signal = signal, VERTO_EV_TYPE_SIGNAL); } diff --git a/src/verto.h b/src/verto.h index b413668..b2e8036 100644 --- a/src/verto.h +++ b/src/verto.h @@ -298,6 +298,9 @@ verto_add_idle(struct vertoEvCtx *ctx, enum vertoEvPriority priority, * other events, signal events WILL be freed automatically when verto_del() or * verto_free() is called. * + * NOTE: SIGCHLD is expressly not supported. If you want this notification, + * please use verto_add_child(). + * * WARNNIG: Signal events can only be reliably received in the default EvCtx * in some implementations. Attempting to receive signal events in non-default * loops may result in assert() failures. @@ -307,6 +310,7 @@ verto_add_idle(struct vertoEvCtx *ctx, enum vertoEvPriority priority, * a single process. Attempting to do so will result in undefined behavior, * and potentially even a crash. You have been warned. * + * @see verto_add_child() * @see verto_repeat() * @see verto_del() * @param ctx The vertoEvCtx which will fire the callback.

1 0

[libverto] [core] make documentation more explicit as to various behaviors
by Nathaniel McCallum 23 Jun '11

23 Jun '11

commit 92f2caf8a2ba6738f057f8aa71ee1ec7a2328c77 Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Thu Jun 23 12:51:56 2011 -0400 [core] make documentation more explicit as to various behaviors src/verto.h | 98 ++++++++++++++++++++++++++++++++++++++++++++-------------- 1 files changed, 74 insertions(+), 24 deletions(-) --- diff --git a/src/verto.h b/src/verto.h index ceed5fd..b413668 100644 --- a/src/verto.h +++ b/src/verto.h @@ -79,7 +79,8 @@ typedef void (*vertoCallback)(struct vertoEvCtx *ctx, struct vertoEv *ev); * best implementation to use. * * First, verto will attempt to use an existing, previously loaded - * implementation. This is handled automatically by internal caching. + * implementation. This is handled automatically by internal caching of either + * the first implementation loaded or the one specified by verto_set_default(). * * Second, verto will attempt to discern if you are already linked to any * of the supported implementations (to avoid wasting memory by loading @@ -88,11 +89,13 @@ typedef void (*vertoCallback)(struct vertoEvCtx *ctx, struct vertoEv *ev); * to more than one supported implementation one of the ones linked to * will be chosen, but the order of the particular choice is undefined. * - * Third, verto will attempt to load the compile-time default, if available. + * Third, verto will attempt to load the compile-time default, if defined at + * build time and available at runtime. * - * Last, verto will attempt to load any implementation installed. The - * specific order of this step is undefined. + * Last, verto will attempt to load any implementation installed. The specific + * order of this step is undefined. * + * @see verto_set_default() * @param impl The implementation to use, or NULL. * @return A new EvCtx, or NULL on error. Call verto_free() when done. */ @@ -104,12 +107,16 @@ verto_new(const char *impl); * * This function is essentially a singleton version of verto_new(). However, * since this function must return the same loop as the *_default() call of - * the underlying implementation (if such a function exists), it is *not* a - * global singleton, but a per-implementation singleton. + * the underlying implementation (if such a function exists), it is NOT a + * global singleton, but a per-implementation singleton. For this reason, you + * must call verto_free() when you are done with this loop. Even after calling + * verto_free() on the default vertoEvCtx, you can safely call verto_default() + * again and receive a new reference to the same (internally default) loop. * * In all other respects, verto_default() acts exactly like verto_new(). * * @see verto_new() + * @see verto_free() * @param impl The implementation to use, or NULL. * @return The default EvCtx, or NULL on error. Call verto_free() when done. */ @@ -141,6 +148,12 @@ verto_set_default(const char *impl); /** * Frees a vertoEvCtx. * + * When called on a default vertoEvCtx, the reference will be freed but the + * internal default loop will still be available via another call to + * verto_default(). + * + * @see verto_new() + * @see verto_default() * @param ctx The vertoEvCtx to free. */ void @@ -175,11 +188,16 @@ verto_break(struct vertoEvCtx *ctx); /** * Adds a callback executed when a file descriptor is ready to be read. * - * To stop this callback from being called for future events, see verto_del(). + * 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 either when verto_del() is - * called or when its vertoEvCtx is freed. + * 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 @@ -196,11 +214,16 @@ verto_add_read(struct vertoEvCtx *ctx, enum vertoEvPriority priority, /** * Adds a callback executed when a file descriptor is ready to be written. * - * To stop this callback from being called for future events, see verto_del(). + * 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 either when verto_del() is - * called or when its vertoEvCtx is freed. + * 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 @@ -217,11 +240,16 @@ verto_add_write(struct vertoEvCtx *ctx, enum vertoEvPriority priority, /** * Adds a callback executed after a period of time. * - * To stop this callback from being called for future events, see verto_del(). + * 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 either when verto_del() is - * called or when its vertoEvCtx is freed. + * 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 @@ -238,11 +266,16 @@ verto_add_timeout(struct vertoEvCtx *ctx, enum vertoEvPriority priority, /** * Adds a callback executed when there is nothing else to do. * - * To stop this callback from being called for future events, see verto_del(). + * 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 either when verto_del() is - * called or when its vertoEvCtx is freed. + * 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 @@ -258,11 +291,23 @@ verto_add_idle(struct vertoEvCtx *ctx, enum vertoEvPriority priority, /** * Adds a callback executed when a signal is received. * - * To stop this callback from being called for future events, see verto_del(). + * NOTE: This event is different than other vertoEv events. A signal vertoEv is + * NOT a single-fire event, but is called every time a signal is received. + * Relatedly, it is NOT freed after the callback is called. Further, + * verto_repeat() does nothing when called on a signal event. However, like + * other events, signal events WILL be freed automatically when verto_del() or + * verto_free() is called. + * + * WARNNIG: Signal events can only be reliably received in the default EvCtx + * in some implementations. Attempting to receive signal events in non-default + * loops may result in assert() failures. * - * The vertoEv returned is automatically freed either when verto_del() is - * called or when its vertoEvCtx is freed. + * WARNING: While verto does its best to protect you from crashes, there is + * essentially no way to do signal events if you mix multiple implementations in + * a single process. Attempting to do so will result in undefined behavior, + * and potentially even a crash. You have been warned. * + * @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 @@ -279,11 +324,16 @@ verto_add_signal(struct vertoEvCtx *ctx, enum vertoEvPriority priority, /** * Adds a callback executed when a child process exits. * - * To stop this callback from being called for future events, see verto_del(). + * 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 either when verto_del() is - * called or when its vertoEvCtx is freed. + * 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

1 0

[libverto] [core] add verto_set_default()
by Nathaniel McCallum 23 Jun '11

23 Jun '11

commit c3227d06f1047c725b3212b793a93fb62487ec2f Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Thu Jun 23 12:23:46 2011 -0400 [core] add verto_set_default() src/verto.c | 7 +++++++ src/verto.h | 22 ++++++++++++++++++++++ 2 files changed, 29 insertions(+), 0 deletions(-) --- diff --git a/src/verto.c b/src/verto.c index d7d0d79..30d7deb 100644 --- a/src/verto.c +++ b/src/verto.c @@ -301,6 +301,13 @@ verto_default(const char *impl) return ctx; } +int +verto_set_default(const char *impl) +{ + void *dll = NULL; /* we will leak the dll */ + return (!defmodule && impl && load_module(impl, &dll, &defmodule)); +} + void verto_free(struct vertoEvCtx *ctx) { diff --git a/src/verto.h b/src/verto.h index d17c859..ceed5fd 100644 --- a/src/verto.h +++ b/src/verto.h @@ -117,6 +117,28 @@ struct vertoEvCtx * verto_default(const char *impl); /** + * Sets the default implementation to use by its name. + * + * This function returns 1 on success and 0 on failure. It can fail for the + * following reasons: + * 1. The default implementation was already set via verto_set_default(). + * 2. The implementation specified could not be found. + * 3. The impl argument was NULL. + * 4. verto_new() was already called. + * 5. verto_default() was already called. + * 6. verto_new_NAME() was already called. + * 7. verto_default_NAME() was already called. + * 8. verto_convert_NAME() was already called. + * + * @see verto_new() + * @see verto_default() + * @param impl The implementation to use. + * @return The default EvCtx, or NULL on error. Call verto_free() when done. + */ +int +verto_set_default(const char *impl); + +/** * Frees a vertoEvCtx. * * @param ctx The vertoEvCtx to free.

1 0

[libverto] [core] fix verto_convert_funcs() so that it can be used by home-grown loops and clarify its docs
by Nathaniel McCallum 23 Jun '11

23 Jun '11

commit dae8ebdaa34267f2b538c95b0bf11b745a7edd56 Author: Nathaniel McCallum <npmccallum(a)redhat.com> Date: Thu Jun 23 12:23:21 2011 -0400 [core] fix verto_convert_funcs() so that it can be used by home-grown loops and clarify its docs src/verto-module.h | 38 +++++++++++++++++++++++++------------- src/verto.c | 8 ++++---- 2 files changed, 29 insertions(+), 17 deletions(-) --- diff --git a/src/verto-module.h b/src/verto-module.h index 26da547..9bc0d6c 100644 --- a/src/verto-module.h +++ b/src/verto-module.h @@ -29,8 +29,8 @@ #include <verto.h> -#define _VERTO_MODULE_VERSION 1 -#define _VERTO_MODULE_TABLE verto_module_table +#define VERTO_MODULE_VERSION 1 +#define VERTO_MODULE_TABLE verto_module_table #define VERTO_MODULE(name, symb) \ static struct vertoEvCtxFuncs name ## _funcs = { \ name ## _ctx_free, \ @@ -40,8 +40,8 @@ name ## _ctx_add, \ name ## _ctx_del \ }; \ - struct vertoModule _VERTO_MODULE_TABLE = { \ - _VERTO_MODULE_VERSION, \ + struct vertoModule VERTO_MODULE_TABLE = { \ + VERTO_MODULE_VERSION, \ # name, \ # symb, \ verto_new_ ## name, \ @@ -68,11 +68,7 @@ struct vertoEvCtxFuncs { }; /** - * Converts an existing implementation specific loop to a verto loop. - * - * You probably don't want this function. This function exists for creating - * implementation modules. See instead verto-NAME.h, where NAME is your - * specific implementation. + * Converts an existing implementation specific loop to a vertoEvCtx. * * This function also sets the internal default implementation so that future * calls to verto_new(NULL) or verto_default(NULL) will use this specific @@ -83,11 +79,27 @@ struct vertoEvCtxFuncs { * @return A new EvCtx, or NULL on error. Call verto_free() when done. */ #define verto_convert(name, priv) \ - _verto_convert(&name ## _funcs, &_VERTO_MODULE_TABLE, priv) + verto_convert_funcs(&name ## _funcs, &VERTO_MODULE_TABLE, priv) + +/** + * Converts an existing implementation specific loop to a vertoEvCtx. + * + * This function also sets the internal default implementation so that future + * calls to verto_new(NULL) or verto_default(NULL) will use this specific + * implementation. + * + * If you are a module implementation, you probably want the macro above. This + * function is generally used directly only when an application is attempting + * to expose a home-grown event loop to verto. + * + * @param name The name of the module (unquoted) + * @param priv The context private to store + * @return A new EvCtx, or NULL on error. Call verto_free() when done. + */ struct vertoEvCtx * -_verto_convert(const struct vertoEvCtxFuncs *funcs, - const struct vertoModule *module, - void *priv); +verto_convert_funcs(const struct vertoEvCtxFuncs *funcs, + const struct vertoModule *module, + void *priv); /** * Calls the callback of the vertoEv and then frees it via verto_del(). diff --git a/src/verto.c b/src/verto.c index 0a9bcd2..d7d0d79 100644 --- a/src/verto.c +++ b/src/verto.c @@ -82,8 +82,8 @@ do_load_file(const char *filename, bool reqsym, void **dll, return false; } - *module = (struct vertoModule*) dlsym(*dll, __str(_VERTO_MODULE_TABLE)); - if (!*module || (*module)->vers != _VERTO_MODULE_VERSION + *module = (struct vertoModule*) dlsym(*dll, __str(VERTO_MODULE_TABLE)); + if (!*module || (*module)->vers != VERTO_MODULE_VERSION || !(*module)->new_ctx || !(*module)->def_ctx) goto error; @@ -150,7 +150,7 @@ load_module(const char *impl, void **dll, const struct vertoModule **module) char *suffix = NULL; char *tmp = NULL; - if (!dladdr(_verto_convert, &dlinfo)) + if (!dladdr(verto_convert_funcs, &dlinfo)) return NULL; suffix = strstr(dlinfo.dli_fname, MODSUFFIX); @@ -533,7 +533,7 @@ verto_del(struct vertoEv *ev) /*** THE FOLLOWING ARE FOR IMPLEMENTATION MODULES ONLY ***/ struct vertoEvCtx * -_verto_convert(const struct vertoEvCtxFuncs *funcs, +verto_convert_funcs(const struct vertoEvCtxFuncs *funcs, const struct vertoModule *module, void *ctx_private) {

1 0

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

2014

2013

2012

2011

libverto-commits June 2011