Bump version for v2.1.0 release

Signed-off-by: Joachim Nilsson <troglobit@gmail.com>

.travis.yml

@@ -5,6 +5,11 @@ language: c
 # Use docker for quicker builds, it now allows https://docs.travis-ci.com/user/apt/
 sudo: false
 
+# Test build with both GCC and Clang (LLVM)
+compiler:
+  - gcc
+  - clang
+
 env:
   global:
    # The next declaration is the encrypted COVERITY_SCAN_TOKEN, created
@@ -17,13 +22,13 @@ addons:
       name: "troglobit/libuev"
       description: "libuEv | Simple event loop for Linux"
     notification_email: troglobit@gmail.com
-    build_command_prepend: "./autogen && ./configure"
+    build_command_prepend: "./autogen.sh && ./configure --enable-examples"
     build_command: "make clean all"
     branch_pattern: dev
 
 script:
   - ./autogen.sh
-  - ./configure --disable-silent-rules
+  - ./configure --disable-silent-rules --enable-examples
   - make clean
   - make -j5
   - make check

API.md

@@ -47,6 +47,11 @@ Overview
  * w->fd holds the file descriptor or socket, and events is set by
  * libuEv to indicate status: UEV_READ and/or UEV_WRITE with any of
  * the optional UEV_HUP, UEV_RDHUP, or UEV_PRI for urgent read data.
+ *
+ * Note: UEV_ERROR may be returned for any watcher and must be checked
+ *       by all callbacks.  I/O watchers may also need to check UEV_HUP.
+ *       Appropriate action, e.g. restart the watcher, is up to the
+ *       application and is thus delegated to the callback.
  */
 void callback       (uev_t *w, void *arg, int events);
 
@@ -99,16 +104,20 @@ uev_init(&ctx);
 
 ### Register an Event Watcher
 
-For each event to monitor, be it a signal, timer or file descriptor, a
+For each event to monitor, be it a signal, cron/timer or a file/network
-*watcher* must be registered with the event context.  The watcher, an
+descriptor, a *watcher* must be registered with the event context.  The
-`uev_t`, is registered by calling the event type's `_init()` function
+watcher, an `uev_t`, is registered by calling the event type's `_init()`
-with the `uev_ctx_t` context, the callback, and an optional argument.
+function with the `uev_ctx_t` context, the callback, and an optional
+argument.
 
 Here is a signal example:
 
 ```C
 void cleanup_exit(uev_t *w, void *arg, int events)
 {
+    if (UEV_ERROR == events)
+	    puts("Ignoring signal watcher error ...");
+
     /* Graceful exit, with optional cleanup ... */
     uev_exit(w->ctx);
 }
@@ -125,6 +134,17 @@ int main(void)
 }
 ```
 
+Notice that the callback must be prepared to handle `UEV_ERROR`.  I/O
+watchers in particular, but also timer watchers, must be restarted if
+required by the application.  libuEv automatically tries to restart a
+signal watcher, but should that fail the callback will return error as
+well.
+
+I/O watchers should also check for `UEV_HUP`, preferably when handling
+any short `read()` or `write()` system calls.  A short read on a socket
+may be due to the remote end having performed a `shutdown()`.  This is
+signaled to the callback using `UEV_HUP` in the `events` mask.
+
 
 ### Start Event Loop
 
@@ -162,8 +182,16 @@ for stateful connections to be able to detect EOF.
 1. Set up an event context with `uev_init()`
 2. Register event callbacks with the event context using
    `uev_io_init()`, `uev_signal_init()` or `uev_timer_init()`
-3. Start the event loop with `uev_run()`
+3. Make sure callbacks checks their `events` mask and handles:
-4. Exit the event loop with `uev_exit()`, possibly from a callback
+
+   - `UEV_ERROR`, e.g. I/O watchers must be restarted
+   - `UEV_HUP`, reading any remaining data on the descriptor
+
+   In both of these cases the watcher is stopped by libuEv.  On HUP the
+   descriptor/connection must be reopened and the watcher reinitialized
+   with `uev_io_set()`, if required by the application.
+4. Start the event loop with `uev_run()`
+5. Exit the event loop with `uev_exit()`, possibly from a callback
 
 **Note 1:** Make sure to use non-blocking stream I/O!  Most hard to find
   bugs in event driven applications are due to sockets and files being
@@ -186,7 +214,7 @@ for stateful connections to be able to detect EOF.
 Using -luev
 -----------
 
-LibuEv is by default installed as a library with a few header files, you
+libuEv is by default installed as a library with a few header files, you
 should only ever need to include one:
 
 ```C
@@ -248,13 +276,24 @@ struct js_event {
  */
 static void joystick_cb(uev_t *w, void *arg, int events)
 {
+    ssize_t cnt;
+
     if (UEV_ERROR == events) {
         /* Possibly joystick was unplugged */
-        warn("Unrecoverable error, exiting");
+        warnx("Spurious problem with the joystick watcher, restarting.");
-        uev_exit(w->ctx);
+        uev_io_start(w);
     }
 
-    read(w->fd, &e, sizeof(e));
+    cnt = read(w->fd, &e, sizeof(e));
+    if (cnt < 0) {
+        warn("Failed reading joystick event");
+        return;
+    }
+
+    if (cnt == 0 || UEV_HUP == events) {
+        warn("Joystick disconnected");
+        return;
+    }
 
     switch (e.type) {
     case 1:
@@ -310,6 +349,6 @@ library) for [reference benchmarks][7] against [libevent][1] and
 [5]:      https://github.com/troglobit/uftpd
 [6]:      https://github.com/troglobit/finit
 [7]:      http://libev.schmorp.de/bench.html
-[LibuEv]: https://github.com/troglobit/libuev
+[libuEv]: https://github.com/troglobit/libuev
 [GLIBC workaround]: https://sourceware.org/glibc/wiki/Y2038ProofnessDesign
 [Dave Zarzycki, Apple]: http://www.youtube.com/watch?v=cD_s6Fjdri8

ChangeLog.md

@@ -4,6 +4,36 @@ Change Log
 All notable changes to the project are documented in this file.
 
 
+[v2.1.0][] - 2017-11-14
+-----------------------
+
+### Changes
+- Remove event loop error tracking used to trigger a `epoll_create1()`
+  at a certain error threshold.  This tracking was first introduced in
+  [v1.1.0][], triggered by spurious `EPOLLERR` on I/O watchers
+- Unconditionally stop I/O watchers that return `EPOLLERR` or `EPOLLHUP`
+  it is up to the watcher callback to clear the error and/or `read()`
+  the last few bytes from the descriptor.  HUP usally means EOF, or that
+  the remote end of a stream or pipe closed, this may also be signaled
+  by `read()` returning zero
+- Add missing `--enable-examples` to `configure` script
+- Update documentation, both [README.md][] and [API.md][]
+
+### Fixes
+- Properly stop and de-register signal and cron/timer watchers from the
+  epoll socket in case of errors, problem introduced in [v2.0.0][]
+- Mark watcher file descriptor as unintialized on internal error
+- Fix double-close of cron/timer watchers.  Problem triggered when the
+  timer expires and calls `uev_exit()`, which stops all watchers.  When
+  the timer callback returns another call to stop the watcher triggered
+  the double `close()`
+- Fix unit test's error handling in watcher callbacks, for reference
+- Fix use-before-set in cronrun unit test
+- Make sure to restart unit test's I/O watchers on `UEV_ERROR`
+- Make sure to restart example I/O watchers on `UEV_ERROR`
+- Properly check for `UEV_HUP` in unit tests and examples
+
+
 [v2.0.0][] - 2017-11-11
 -----------------------
 
@@ -14,10 +44,10 @@ likely not notice any difference, but please read on.
 ### Changes
 - `uev_run()` no longer exits the main event loop if an unrecoverable
   error with a watcher occurs.  Instead, the watcher is disabled and the
-  callback is run one last time with `events` set to `UEV_ERROR`.
+  callback is run one last time with `events` set to `UEV_ERROR`
 - Watcher callbacks must handle `UEV_ERROR` conditions.  This pertains
-  in particular to signal and timer watchers.
+  in particular to signal and timer watchers
-- Examples and API docs updated with the new failure modes.
+- Examples and API docs updated with the new failure modes
 
 
 [v1.6.0][] - 2017-09-18
@@ -52,7 +82,7 @@ likely not notice any difference, but please read on.
 
 ### Changes
 - Add support for absolute timers with the `uev_cron_*()` API.
-- Update build & install instructions in README
+- Update build & install instructions in [README.md][]
 
 ### Fixes
 - Fix `uev_timer_set()` so that it returns error in case the underlying
@@ -94,7 +124,7 @@ introduced in [v1.2.1][].  Apologies for any problems this may cause!
   `pkg-config` your C program must now `#include <uev/uev.h>`
 - Support for `EPOLLPRI` events for I/O watchers, thanks to Markus Svilans
 - Simplified joystick example
-- Updated `README` slightly
+- Updated [README.md][] slightly
 
 
 [v1.3.1][] - 2016-02-02
@@ -102,7 +132,7 @@ introduced in [v1.2.1][].  Apologies for any problems this may cause!
 
 ### Fixes
 - Remove symlinks to Markdown files from GIT
-- Distribute and install Markdown files: README.md, etc.
+- Distribute and install Markdown files: [README.md][], etc.
 
 
 [v1.3.0][] - 2016-01-22
@@ -138,7 +168,7 @@ Very minor release.
 - Dropped [TODO.md][] from distribution archives, only for devs
 
 ### Fixes
-- Lots of Markdown syntax fixes in both README and ChangeLog
+- Lots of Markdown syntax fixes in both [README.md][] and ChangeLog
 - Silence annoying warning from newer GNU ar in Ubuntu 15.10
 
 
@@ -296,7 +326,8 @@ v0.0.1 - 2012-03-17
 Lua users mailing list.
 
 
-[UNRELEASED]: https://github.com/troglobit/libuev/compare/v2.0.0...HEAD
+[UNRELEASED]: https://github.com/troglobit/libuev/compare/v2.1.0...HEAD
+[v2.1.0]: https://github.com/troglobit/libuev/compare/v2.0.0...v2.1.0
 [v2.0.0]: https://github.com/troglobit/libuev/compare/v1.6.0...v2.0.0
 [v1.6.0]: https://github.com/troglobit/libuev/compare/v1.5.2...v1.6.0
 [v1.5.2]: https://github.com/troglobit/libuev/compare/v1.5.1...v1.5.2
@@ -319,6 +350,7 @@ Lua users mailing list.
 [v1.0.1]: https://github.com/troglobit/libuev/compare/v1.0.0...v1.0.1
 [v1.0.0]: https://github.com/troglobit/libuev/compare/v0.0.1...v1.0.0
 [TODO.md]: https://github.com/troglobit/libuev/blob/master/TODO.md
+[API.md]: https://github.com/troglobit/libuev/blob/master/API.md
 [README.md]: https://github.com/troglobit/libuev/blob/master/README.md
 [ChangeLog.md]: https://github.com/troglobit/libuev/blob/master/ChangeLog.md
 [joystick.c]: https://github.com/troglobit/libuev/blob/master/joystick.c

Makefile.am

@@ -4,6 +4,10 @@ DIST_SUBDIRS        = src examples tests
 doc_DATA            = API.md README.md LICENSE
 EXTRA_DIST          = API.md README.md LICENSE AUTHORS ChangeLog.md
 
+if ENABLE_EXAMPLES
+SUBDIRS            += examples
+endif
+
 ## Generate .deb package
 package:
 	@dpkg-buildpackage -uc -us -B

README.md

@@ -28,11 +28,16 @@ small size overhead impact of the library.
 Failure mode changes introduced in v2.0 may affect users of v1.x, See
 the [ChangeLog][] for the full details.
 
+The [API documentation](API.md) is available as a separate document.
+
 
 Example
 -------
 
-The library documentation is available as a [separate document](API.md).
+Notice below how watcher `UEV_ERROR` conditions must be handled by each
+callback.  I/O watchers must also check for `UEV_HUP`.  Both errors are
+usually fatal, libuEv makes sure to stop each watcher before a callback
+runs, leaving it up to the callback to take appropriate action.
 
 ```C
 #include <stdio.h>
@@ -40,6 +45,10 @@ The library documentation is available as a [separate document](API.md).
 
 static void cb(uev_t *w, void *arg, int events)
 {
+    if (UEV_ERROR == events) {
+        puts("Problem with timer, attempting to restart.");
+        uev_timer_start(w);
+    }
 	puts("Every other second");
 }
 

configure.ac

@@ -1,4 +1,4 @@
-AC_INIT(libuev, 2.0.0, https://github.com/troglobit/libuev/issues)
+AC_INIT(libuev, 2.1.0, https://github.com/troglobit/libuev/issues)
 AM_INIT_AUTOMAKE([1.11 foreign no-dist-gzip dist-xz])
 AM_SILENT_RULES([yes])
 
@@ -11,4 +11,10 @@ AC_PROG_CC
 AM_PROG_AR
 LT_INIT
 
+# Optional features
+AC_ARG_ENABLE([examples],
+	[AC_HELP_STRING([--enable-examples], [Build libuEv examples/ directory])],
+	[], [enable_examples=no])
+AM_CONDITIONAL([ENABLE_EXAMPLES], [test "$enable_examples" = yes])
+
 AC_OUTPUT

examples/.gitignore

@@ -3,3 +3,4 @@ signal
 cronrun
 test
 redirect
+hej.txt

examples/joystick.c

@@ -43,11 +43,23 @@ struct js_event {
  */
 static void joystick_cb(uev_t *w, void *arg, int events)
 {
-	if (UEV_ERROR == events)
+	ssize_t len;
-		errx(EBADF, "Unrecoverable error, exiting");
 
-	if (read(w->fd, &e, sizeof(e)) < 0)
+	if (UEV_ERROR == events) {
-		errx(errno, "Failed reading joystick event");
+		warnx("Spurious problem with the joystick watcher, restarting.");
+		uev_io_start(w);
+	}
+
+	len = read(w->fd, &e, sizeof(e));
+	if (len < 0) {
+		warn("Failed reading joystick event");
+		return;
+	}
+
+	if (len == 0 || UEV_HUP == events) {
+		warn("Joystick disconnected");
+		return;
+	}
 
 	switch (e.type) {
 	case 1:

examples/redirect.c

@@ -24,8 +24,10 @@ void process_stdin(uev_t *w, void *arg, int events)
 	char buf[256];
 	int len;
 
-	if (UEV_ERROR == events)
+	if (UEV_ERROR == events) {
-		errx(EBADF, "Unrecoverable error, exiting");
+		warnx("Spurious problem with the stdin watcher, restarting.");
+		uev_io_start(w);
+	}
 
 	len = read(w->fd, buf, sizeof(buf));
 	if (len == -1) {
@@ -33,7 +35,7 @@ void process_stdin(uev_t *w, void *arg, int events)
 		return;
 	}
 
-	if (len == 0) {
+	if (len == 0 || UEV_HUP == events) {
 		warnx("Connection closed.");
 		return;
 	}

src/private.h

@@ -31,10 +31,10 @@
 
 /* I/O, timer, or signal watcher */
 typedef enum {
-	UEV_CRON_TYPE = 1,
+	UEV_IO_TYPE = 1,
-	UEV_IO_TYPE,
 	UEV_SIGNAL_TYPE,
 	UEV_TIMER_TYPE,
+	UEV_CRON_TYPE,
 } uev_type_t;
 
 /* Event mask, used internally only. */
@@ -44,7 +44,6 @@ typedef enum {
 typedef struct {
 	int             running;
 	int             fd;     /* For epoll() */
-	uint32_t        errors;
 	LIST_HEAD(,uev) watchers;
 	uint32_t        workaround; /* For workarounds, e.g. redirected stdin */
 } uev_ctx_t;

src/timer.c

@@ -83,6 +83,7 @@ int uev_timer_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int timeou
 		_uev_watcher_stop(w);
 	exit:
 		close(fd);
+		w->fd = -1;
 		return -1;
 	}
 
@@ -165,6 +166,10 @@ int uev_timer_start(uev_t *w)
  */
 int uev_timer_stop(uev_t *w)
 {
+	/* Check if already stopped in uev_run() after cb() or _init() */
+	if (!_uev_watcher_active(w))
+		return 0;
+
 	/* Stop kernel timer */
 	uev_timer_set(w, 0, 0);
 

src/uev.c

@@ -52,12 +52,6 @@ static int _init(uev_ctx_t *ctx, int close_old)
 	return 0;
 }
 
-/* Simple check if a descriptor is still valid in the kernel */
-static int is_valid_fd(int fd)
-{
-    return fcntl(fd, F_GETFL) != -1 || errno != EBADF;
-}
-
 /* Used by file i/o workaround when epoll => EPERM */
 static int has_data(int fd)
 {
@@ -74,14 +68,6 @@ static int has_data(int fd)
 	return 0;
 }
 
-/* Set error condition and remove watcher from set */
-static void invalidate_watcher(uev_t *w, struct epoll_event *event)
-{
-	event->events = UEV_ERROR;
-	w->active = 0;
-	LIST_REMOVE(w, link);
-}
-
 /* Private to libuEv, do not use directly! */
 int _uev_watcher_init(uev_ctx_t *ctx, uev_t *w, uev_type_t type, uev_cb_t *cb, void *arg, int fd, int events)
 {
@@ -294,7 +280,7 @@ int uev_run(uev_ctx_t *ctx, int flags)
 
 	while (ctx->running && !LIST_EMPTY(&ctx->watchers)) {
 		int i, nfds, rerun = 0;
-		struct epoll_event events[UEV_MAX_EVENTS];
+		struct epoll_event ee[UEV_MAX_EVENTS];
 
 		/* Handle special case: `application < file.txt` */
 		if (ctx->workaround) {
@@ -316,7 +302,7 @@ int uev_run(uev_ctx_t *ctx, int flags)
 			continue;
 		ctx->workaround = 0;
 
-		while ((nfds = epoll_wait(ctx->fd, events, UEV_MAX_EVENTS, timeout)) < 0) {
+		while ((nfds = epoll_wait(ctx->fd, ee, UEV_MAX_EVENTS, timeout)) < 0) {
 			if (!ctx->running)
 				break;
 
@@ -325,82 +311,62 @@ int uev_run(uev_ctx_t *ctx, int flags)
 
 			/* Unrecoverable error, cleanup and exit with error. */
 			uev_exit(ctx);
+
 			return -2;
 		}
 
 		for (i = 0; ctx->running && i < nfds; i++) {
-			w = (uev_t *)events[i].data.ptr;
+			uint64_t exp;
+			uint32_t events;
+			struct signalfd_siginfo fdsi;
+			ssize_t sz = sizeof(fdsi);
 
-			if (events[i].events & (EPOLLHUP | EPOLLERR)) {
+			w = (uev_t *)ee[i].data.ptr;
-				ctx->errors++;
+			events = ee[i].events;
 
-				if (ctx->errors >= 42) {
+			switch (w->type) {
-					uev_t *tmp, *retry = w;;
+			case UEV_IO_TYPE:
+				if (events & (EPOLLHUP | EPOLLERR))
+					uev_io_stop(w);
+				break;
 
-					/* If not valid anymore, try to remove, ignore any errors. */
+			case UEV_SIGNAL_TYPE:
-					if (!is_valid_fd(w->fd))
+				if (read(w->fd, &fdsi, sz) != sz) {
-						_uev_watcher_stop(w);
+					if (uev_signal_start(w)) {
-
+						uev_signal_stop(w);
-					/* Must recreate epoll fd now ... */
+						events = UEV_ERROR;
-					if (_init(ctx, 1)) {
-						/* Catastrophic error, no way to recover. */
-						uev_exit(ctx);
-						return -3;
 					}
-
-					/* Restart watchers in new efd */
-					LIST_FOREACH_SAFE(w, &ctx->watchers, link, tmp) {
-						if (_uev_watcher_active(w)) {
-							w->active = 0;
-							LIST_REMOVE(w, link);
-							_uev_watcher_start(w);
-						}
-					}
-					_uev_watcher_start(retry);
-
-					/* New efd, restart everything! */
-					ctx->errors = 0;
-					continue;
 				}
-			}
+				break;
-
-			if (UEV_CRON_TYPE == w->type) {
-				uint64_t exp;
 
+			case UEV_TIMER_TYPE:
 				if (read(w->fd, &exp, sizeof(exp)) != sizeof(exp)) {
-					if (errno != ECANCELED)
+					uev_timer_stop(w);
-						invalidate_watcher(w, &events[i]);
+					events = UEV_ERROR;
-					else
+				}
-						events[i].events = UEV_HUP;
+
+				if (!w->u.t.period)
+					w->u.t.timeout = 0;
+				break;
+
+			case UEV_CRON_TYPE:
+				if (read(w->fd, &exp, sizeof(exp)) != sizeof(exp)) {
+					events = UEV_HUP;
+					if (errno != ECANCELED) {
+						uev_cron_stop(w);
+						events = UEV_ERROR;
+					}
 				}
 
 				if (!w->u.c.interval)
 					w->u.c.when = 0;
 				else
 					w->u.c.when += w->u.c.interval;
-			}
+				break;
-
-			if (UEV_TIMER_TYPE == w->type) {
-				uint64_t exp;
-
-				if (read(w->fd, &exp, sizeof(exp)) != sizeof(exp)) {
-					invalidate_watcher(w, &events[i]);
-				}
-
-				if (!w->u.t.period)
-					w->u.t.timeout = 0;
-			}
-
-			if (UEV_SIGNAL_TYPE == w->type) {
-				struct signalfd_siginfo fdsi;
-				ssize_t sz = sizeof(fdsi);
-
-				if (read(w->fd, &fdsi, sz) != sz)
-					invalidate_watcher(w, &events[i]);
 			}
 
 			if (w->cb)
-				w->cb(w, w->arg, events[i].events & UEV_EVENT_MASK);
+				w->cb(w, w->arg, events & UEV_EVENT_MASK);
 
 			if (UEV_CRON_TYPE == w->type) {
 				if (!w->u.c.when)

src/uev.h

@@ -66,6 +66,11 @@ typedef struct uev {
  * Generic callback for watchers, @events holds %UEV_READ and/or %UEV_WRITE
  * with optional %UEV_PRI (priority data available to read) and any of the
  * %UEV_HUP and/or %UEV_RDHUP, which may be used to signal hang-up events.
+ *
+ * Note: UEV_ERROR conditions must be handled by all callbacks!
+ *       I/O watchers may also need to check UEV_HUP.  Appropriate action,
+ *       e.g. restart the watcher, is up to the application and is thus
+ *       delegated to the callback.
  */
 typedef void (uev_cb_t)(uev_t *w, void *arg, int events);
 

tests/active.c

@@ -12,8 +12,11 @@ uev_t timer3;
 uev_t cron1;
 uev_t cron2;
 
-static void cb(uev_t *w, void *UNUSED(arg), int UNUSED(events))
+static void cb(uev_t *w, void *UNUSED(arg), int events)
 {
+	if (UEV_ERROR == events)
+		fprintf(stderr, "timer watcher failed, ignoring ...\n");
+
 	fail_unless(w == &timer1);
 
 	fail_unless(uev_timer_active(&timer2));

tests/complete.c

@@ -33,15 +33,21 @@ static int in, out;
 static int period = 0;
 static uev_t *watchdog;
 
-static void lifetime_cb(uev_t *w, void *arg, int UNUSED(events))
+static void lifetime_cb(uev_t *w, void *arg, int events)
 {
+	if (UEV_ERROR == events)
+		fprintf(stderr, "timer watcher failed, ignoring ...\n");
+
 	fprintf(stderr, "\nLifetime exceeded, program completed successfully! (arg:%p)\n", arg);
 	uev_exit(w->ctx);
 }
 
 /* The pipe watchdog, if it triggers we haven't received data in time. */
-static void timeout_cb(uev_t *w, void *arg, int UNUSED(events))
+static void timeout_cb(uev_t *w, void *arg, int events)
 {
+	if (UEV_ERROR == events)
+		fprintf(stderr, "timer watcher failed, ignoring ...\n");
+
 	watchdog = NULL;
 	fprintf(stderr, "\nTimeout exceeded %p\n", arg);
 
@@ -54,23 +60,46 @@ static void periodic_task(uev_t UNUSED(*w), void UNUSED(*arg), int UNUSED(events
 	fprintf(stderr, "|");
 }
 
-static void signal_cb(uev_t *w, void *UNUSED(arg), int UNUSED(events))
+static void signal_cb(uev_t *w, void *UNUSED(arg), int events)
 {
+	if (UEV_ERROR == events) {
+		fprintf(stderr, "Signal watcher failed, unrecoverable error.\n");
+		return;
+	}
+
 	fprintf(stderr, w->signo == SIGINT ? "^Cv" : "^\v");
 }
 
-static void pipe_read_cb(uev_t UNUSED(*w), void UNUSED(*arg), int UNUSED(events))
+static void pipe_read_cb(uev_t *w, void UNUSED(*arg), int events)
 {
-	int cnt;
+	int len;
 	char msg[50];
 
+	if (UEV_ERROR == events) {
+	error:
+		fprintf(stderr, "pipe watcher failed, restarting ...\n");
+		uev_io_start(w);
+		return;
+	}
+
         /* Kick watchdog */
 	if (watchdog)
 		uev_timer_set(watchdog, 1000, 0);
 
-	cnt = read(in, msg, sizeof(msg));
+	/* Here we can read() from in or w->fd, either works. */
-//	fprintf(stderr, "READ %.*s %d\n", cnt, msg, cnt);
+	len = read(w->fd, msg, sizeof(msg));
-	fprintf(stderr, "%.*s.%d ", cnt, msg, cnt);
+	if (len < 0) {
+		perror(__func__);
+		goto error;
+	}
+
+	if (len == 0 || UEV_HUP == events) {
+		fprintf(stderr, "Other end of pipe closed, no more data\n");
+		return;
+	}
+
+//	fprintf(stderr, "READ %.*s %d\n", len, msg, len);
+	fprintf(stderr, "%.*s.%d ", len, msg, len);
 }
 
 static void pipe_write_cb(uev_t *w, void *arg, int UNUSED(events))
@@ -78,6 +107,10 @@ static void pipe_write_cb(uev_t *w, void *arg, int UNUSED(events))
 	my_t *my  = arg;
 	char *msg = "TESTING";
 
+	if (UEV_ERROR == events)
+		fprintf(stderr, "timer watcher failed, ignoring ...\n");
+
+	/* Here we *must* use out, not w->fd, since we're a timer callback */
 	if (write(out, msg, my->counter) < 0) {
                 perror("\nFailed writing to pipe");
                 return;

tests/cronrun.c

@@ -30,11 +30,14 @@
 
 struct timeval tv;
 
-static void cron_job(uev_t *w, void *UNUSED(arg), int UNUSED(events))
+static void cron_job(uev_t *w, void *UNUSED(arg), int events)
 {
 	static int laps = 3;
 	struct timeval now;
 
+	if (UEV_ERROR == events)
+		fprintf(stderr, "cron watcher failed, ignoring ...\n");
+
 	/* Update timer every lap */
 	tv.tv_sec += TIMEOUT;
 
@@ -55,10 +58,11 @@ int main(void)
 	uev_init(&ctx);
 
 	gettimeofday(&tv, NULL);
+	when = tv.tv_sec + TIMEOUT;
+
 	printf("Start of test %s", ctime(&tv.tv_sec));
 	printf("Expected cron %s", ctime(&when));
 	
-	when     = tv.tv_sec + TIMEOUT;
 	interval = INTERVAL;
 	uev_cron_init(&ctx, &cron_watcher, cron_job, NULL, when, interval);
 

tests/timer.c

@@ -5,10 +5,13 @@
 #define TIMEOUT 2		/* 2 sec */
 struct timeval start;
 
-static void cb(uev_t *w, void *UNUSED(arg), int UNUSED(events))
+static void cb(uev_t *w, void *UNUSED(arg), int events)
 {
 	struct timeval now;
 
+	if (UEV_ERROR == events)
+		fprintf(stderr, "timer watcher failed, ignoring ...\n");
+
 	gettimeofday(&now, NULL);
 	fail_unless(now.tv_sec == start.tv_sec + TIMEOUT);