Bump version for v1.2.3 release.

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

.gitignore

@@ -1,6 +1,6 @@
 bench
 test
-.*.d
+*.d
 *.o
 *~
 libuev.a

.travis.yml

@@ -0,0 +1,27 @@
+# Travis CI integration -- https://travis-ci.org/troglobit/libuev
+# Defaults to GNU GCC and autotools: ./configure && make && make test
+language: c
+
+# We don't need to install packages, use dockerized build, quicker
+sudo: false
+
+env:
+  global:
+   # The next declaration is the encrypted COVERITY_SCAN_TOKEN, created
+   #   via the "travis encrypt" command using the project repo's public key
+   - secure: "ikQcWMCLFoxq0+wMiqrNT5HRn0d4e3AxuF8VzNUNFrk6jUvHIufC/OKvr8VWPTjCaAQXZjWfdQAAARUXzJV10WZ7xpiv5qt4bt26Qih2AwMPMJeUOYrqXgQqhTPBp05iLYpo4ybICteXRI3zKKUA1wkdDC0jyu3rl+Fbveekbe0="
+
+addons:
+  coverity_scan:
+    project:
+      name: "troglobit/libuev"
+      description: "libuEv | Simple event loop for Linux"
+    notification_email: troglobit@gmail.com
+    build_command: "make"
+    branch_pattern: dev
+
+# We don't use configure, so we must define our own build script.
+script:
+  - make distclean
+  - make -j5
+  - make test

ChangeLog

@@ -0,0 +1 @@
+ChangeLog.md

ChangeLog.md

@@ -0,0 +1,203 @@
+Change Log
+==========
+
+All notable changes to the project are documented in this file.
+
+[v1.2.3] - 2015-09-17
+---------------------
+
+Very minor release.
+
+### Changes
+- [README.md][] updates, mostly cleanup and readability improvements
+- `make test` now runs the test case, on behalf of Travis-CI
+- Renamed CHANGELOG.md to [ChangeLog.md][]
+- Dropped [TODO.md][] from distribution archives, only for devs
+
+### Fixes
+- Lots of Markdown syntax fixes in both README and ChangeLog
+- Silence annoying warning from newer GNU ar in Ubuntu 15.10
+
+
+[v1.2.2] - 2015-08-30
+---------------------
+
+Minor bugfix release.
+
+### Changes
+- The `ifdef STATIC` in the Makefile has been removed.  Now both the
+  .a and .so libraries are built.  The user may then select what to
+  install.  This is a change for convenience when using libuEv from
+  a GNU Configure & Build based project.
+
+### Fixes
+- Fix odd data ordering issue on Debian Jessie in new `uev_private_t`
+- Fix issue #6: Segfault when stopping timer before calling `uev_exit()`
+
+
+[v1.2.1] - 2015-07-02
+---------------------
+
+### Changes
+- Private data members in `uev.h` have now been moved to a new file
+  called `private.h`.  This will hopefully make it easier to understand
+  what a user of libuEv is allowed to play around with.  Thanks to @vonj
+  for the discussions around this!
+- All builds of libuEv now default to use -fPIC, this bloats the code
+  slightly, but ensures that linking works for all use cases, withouth
+  introducing unnecessary complexity.
+
+### Fixes
+- Fix install/uninstall Makefile recipes so they work for both static
+  and dynamic builds.  Also, make sure to install all required headers.
+- Jakob Eriksson noticed that `O_CLOEXEC` does not exist in the Debian 6
+  EGLIBC, but `EPOLL_CLOEXEC` does, and is also what `epoll_create1()`
+  should use.  Thank you @vonj!
+
+
+[v1.2.0] - 2015-06-09
+---------------------
+
+API change in event callbacks and fix timers that never start.
+
+### Changes
+- Remove first `uev_ctx_t *` argument in callbacks, incompatible API
+  change!  Please update all your callbacks if you upgrade.
+
+### Fixes
+- Fix timers that accidentally broke in [v1.1.0].
+- Fixes to `bench.c`, it now actually listens to the pipe/socket.
+
+
+[v1.1.0] - 2015-03-04
+---------------------
+
+Massively improved error handling.
+
+### Changes
+- Handle case when user closes a descriptor *before* stopping a watcher.
+- Handle `EPOLLHUP` and `EPOLLERR`.  Restart `epoll(7)` descriptor and
+  all watchers when an error count reaches a MAX value -- handles stale
+  descriptors or cases when kernel does not notice updated descriptors.
+- Return error when stopping a watcher fails.
+- Update [README.md][] with new `uev_*_start()` functions.
+- Bump dev version to 1.1 due to the number of significant changes.
+
+### Fixes
+- Remove `test.c` from `DISTFILES` in `Makefile`.  You need the
+  comeplete sources to build the examples now.  Thanks to @karasz for
+  the heads up on this and the musl libc issue with missing `queue.h`!
+- Fix broken link to [v1.0.5] in this file.
+
+
+[v1.0.5] - 2015-02-15
+---------------------
+
+### Changes
+- Add `uev_*_start()` functions.
+- Add slightly odd `examples/signal.c` example that utilises `fork()`
+  and causes segfault in child.
+- Renamed `main.c` to `uev.c`
+- Move examples to `examples/` subdirectory
+- Simplify automatic dependency calculation
+- Add [TODO.md][] for wishlist items
+- Add [CHANGELOG.md][ChangeLog.md], to align with http://keepachangelog.com
+- Further updates to [README.md][]
+
+
+[v1.0.4] - 2015-01-24
+---------------------
+
+Minor documentation and build fixes.
+
+Release mainly targeted for [Finit development](https://github.com/troglobit/finit/).
+
+### Changes
+* `test.c` has been simplified/clarified
+* Further updates to [README.md][]
+* Minor update to Makefile, change how build progress is echoed
+
+
+[v1.0.3] - 2015-01-24
+---------------------
+
+This is a very minor release, with a strong focus on documentation. 
+
+### Changes
+- [README.md][], massively updated
+- API documentation, updated
+- Travis CI integration added, https://travis-ci.org/troglobit/libuev
+- Coverity Scan integration, https://scan.coverity.com/projects/3846
+- Clang scan-build support added
+
+
+[v1.0.2] - 2015-01-07
+---------------------
+
+### Fixes
+- Fix broken `make dist` target in [v1.0.1].
+
+
+[v1.0.1] - 2015-01-07
+---------------------
+
+### Changes
+- Cleanup and rewrite of [README.md][] after first audit by @vonj
+- Added API and example section to [README.md][]
+- New [joystick.c] example added
+- `main.c:uev_run()`: Document mysterious flags parameter
+
+
+[v1.0.0] - 2013-08-06
+---------------------
+
+First release in the new guise and API.
+
+### Changes
+- Add support for timers, using `timerfd_*()` and `epoll()` API's
+- Add support for signals using `signalfd()` API
+- Convert to use BSD `sys/queue.h` API in GLIBC instead of homebrew
+  linked list implementation
+- Massive changes to code structure, API naming
+- Reindent to use Linux KNF
+- Change library name to libuev
+- Lua support removed
+- Make sure to state the [MIT license][] correctly in all files
+- Import [Niels Provos][]' `bench.c`, the [libev version][]
+
+
+v0.0.1 - 2012-03-17
+-------------------
+
+[Initial announcement][] of [libuevent][] by [Flemming Madsen][] to the
+Lua users mailing list.
+
+
+[UNRELEASED]: https://github.com/troglobit/libuev/compare/v1.2.3...HEAD
+[v1.2.3]: https://github.com/troglobit/libuev/compare/v1.2.2...v1.2.3
+[v1.2.2]: https://github.com/troglobit/libuev/compare/v1.2.1...v1.2.2
+[v1.2.1]: https://github.com/troglobit/libuev/compare/v1.2.0...v1.2.1
+[v1.2.0]: https://github.com/troglobit/libuev/compare/v1.1.0...v1.2.0
+[v1.1.0]: https://github.com/troglobit/libuev/compare/v1.0.5...v1.1.0
+[v1.0.5]: https://github.com/troglobit/libuev/compare/v1.0.4...v1.0.5
+[v1.0.4]: https://github.com/troglobit/libuev/compare/v1.0.3...v1.0.4
+[v1.0.3]: https://github.com/troglobit/libuev/compare/v1.0.2...v1.0.3
+[v1.0.2]: https://github.com/troglobit/libuev/compare/v1.0.1...v1.0.2
+[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
+[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
+[Niels Provos]: http://en.wikipedia.org/wiki/Niels_Provos
+[MIT license]: http://en.wikipedia.org/wiki/MIT_License
+[libev version]: http://libev.schmorp.de/bench.c
+[libuevent]: https://code.google.com/p/libuevent/
+[Flemming Madsen]: http://www.madsensoft.dk
+[Initial announcement]: http://lua-users.org/lists/lua-l/2012-03/msg00510.html
+
+<!--
+  -- Local Variables:
+  --  mode: markdown
+  -- End:
+  -->

LICENSE

@@ -1,24 +1,20 @@
-Copyright (c) 2012  Flemming Madsen <flemming!madsen()madsensoft!dk>
+Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
-Copyright (c) 2013  Joachim Nilsson <troglobit()gmail!com>
+Copyright (c) 2013-2015  Joachim Nilsson <troglobit()gmail!com>
 
-Permission is hereby granted, free of charge, to any person obtaining
+Permission is hereby granted, free of charge, to any person obtaining a copy
-a copy of this software and associated documentation files (the
+of this software and associated documentation files (the "Software"), to deal
-"Software"), to deal in the Software without restriction, including
+in the Software without restriction, including without limitation the rights
-without limitation the rights to use, copy, modify, merge, publish,
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-distribute, sublicense, and/or sell copies of the Software, and to
+copies of the Software, and to permit persons to whom the Software is
-permit persons to whom the Software is furnished to do so, subject to
+furnished to do so, subject to the following conditions:
-the following conditions:
 
-The above copyright notice and this permission notice shall be
+The above copyright notice and this permission notice shall be included in
-included in all copies or substantial portions of the Software.
+all copies or substantial portions of the Software.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+THE SOFTWARE.
-
-For an explanation and background of the MIT license, see the Wikipedia
-article https://en.wikipedia.org/wiki/MIT_License

Makefile

@@ -1,31 +1,33 @@
-# -*-Makefile-*- for libuEv
+# libuEv -- Simple event loop for Linux
 #
-# Copyright (c) 2012  Flemming Madsen <flemming!madsen()madsensoft!dk>
+# Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
-# Copyright (c) 2013  Joachim Nilsson <troglobit()gmail!com>
+# Copyright (c) 2013-2015  Joachim Nilsson <troglobit()gmail!com>
 #
-# Permission is hereby granted, free of charge, to any person obtaining
+# Permission is hereby granted, free of charge, to any person obtaining a copy
-# a copy of this software and associated documentation files (the
+# of this software and associated documentation files (the "Software"), to deal
-# "Software"), to deal in the Software without restriction, including
+# in the Software without restriction, including without limitation the rights
-# without limitation the rights to use, copy, modify, merge, publish,
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# distribute, sublicense, and/or sell copies of the Software, and to
+# copies of the Software, and to permit persons to whom the Software is
-# permit persons to whom the Software is furnished to do so, subject to
+# furnished to do so, subject to the following conditions:
-# the following conditions:
 #
-# The above copyright notice and this permission notice shall be
+# The above copyright notice and this permission notice shall be included in
-# included in all copies or substantial portions of the Software.
+# all copies or substantial portions of the Software.
 #
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+# THE SOFTWARE.
 #
-.PHONY: all test clean
+.PHONY: all test clean joystick test examples bench
+
+# Figure out root of library, unless used as submodule
+ROOTDIR    ?= $(shell pwd)
 
 #VERSION    = $(shell git tag -l | tail -1)
-VERSION    ?= 1.0.1
+VERSION    ?= 1.2.3
 NAME        = libuev
 PKG         = $(NAME)-$(VERSION)
 ARCHIVE     = $(PKG).tar.xz
@@ -33,106 +35,117 @@ ARCHIVE     = $(PKG).tar.xz
 CC         ?= $(CROSS)gcc
 AR         ?= $(CROSS)ar
 STRIP      ?= $(CROSS)strip
-CHECK      ?= sparse
+MAKE       := @$(MAKE)
-CFLAGS     += -fPIC -Os
+INSTALL    := install --backup=off
+STRIPINST  := $(INSTALL) -s --strip-program=$(CROSS)strip -m 0755
+
+CFLAGS     += -fPIC
+CFLAGS     += -Os
 CPPFLAGS   += -W -Wall -Werror
 ARFLAGS     = crus
-CHECK_FLAGS = -Wcast-to-as -Wdefault-bitfield-sign -Wdo-while -Wparen-string        \
+MAKEFLAGS   = --no-print-directory --silent
-	      -Wptr-subtraction-blows -Wreturn-void -Wshadow -Wtypesign -Wbitwise   \
-	      -std=gnu99  -D__x86_64__ -D__LP64__ -I/usr/include/x86_64-linux-gnu
-JUNK        = *~ *.bak *.map .*.d DEADJOE *.gdb *.elf core core.*
 
-LIBNAME     = $(NAME)
+DISTFILES   = README ChangeLog LICENSE
-prefix     ?= /usr/local
+HEADERS     = uev.h private.h queue.h
-libdir     ?= $(prefix)/lib
+OBJS       := uev.o io.o timer.o signal.o
-datadir    ?= $(prefix)/share/doc/$(LIBNAME)
-incdir     ?= $(prefix)/include
-DISTFILES   = README LICENSE test.c
-HEADER      = uev.h
-
-OBJS       := main.o io.o timer.o signal.o
 SRCS       := $(OBJS:.o=.c)
-DEPS       := $(addprefix .,$(SRCS:.c=.d))
+DEPS       := $(SRCS:.c=.d)
+JUNK        = *~ *.bak *.map .*.d *.so* *.a DEADJOE *.gdb *.elf core core.* *.html
+
 VER         = 1
+LIBNAME     = $(NAME)
 SOLIB       = $(LIBNAME).so.$(VER)
 SYMLIB      = $(LIBNAME).so
 STATICLIB   = $(LIBNAME).a
 TARGET      = $(STATICLIB) $(SOLIB)
 
-# Pattern rules
+# Default install paths
-.c.o:
+prefix     ?= /usr/local
-	@printf "  CC      $@\n"
+libdir     ?= $(prefix)/lib
-	@$(CC) $(CFLAGS) $(CPPFLAGS) -c -o $@ $<
+datadir    ?= $(prefix)/share/doc/$(LIBNAME)
+incdir     ?= $(prefix)/include
 
-# Smart autodependecy generation via GCC -M.
+export STATICLIB JUNK ROOTDIR CFLAGS CPPFLAGS
-.%.d: %.c
+
-	@$(SHELL) -ec "$(CC) -MM $(CFLAGS) $(CPPFLAGS) $< 2>/dev/null \
+# This magic trick looks like a comment, but works on BSD PMake
-		| sed 's,.*: ,$*.o $@ : ,g' > $@; \
+#include <rules.mk>
-                [ -s $@ ] || rm -f $@"
+include rules.mk
 
 # Build rules
 all: $(TARGET)
 
+$(OBJS): Makefile
+
 $(SOLIB): Makefile $(OBJS)
 	@printf "  LINK    $@\n"
 	@$(CC) $(LDFLAGS) -shared -Wl,-soname=$@ -o $@ $(OBJS)
 
 $(STATICLIB): Makefile $(OBJS)
 	@printf "  ARCHIVE $@\n"
-	@$(AR) $(ARFLAGS) $@ $(OBJS)
+	@$(AR) $(ARFLAGS) $@ $(OBJS) 2>/dev/null
 
-install: strip
+install-exec: all
+	@printf "  INSTALL $(DESTDIR)$(libdir)/$(SOLIB)\n"
 	@install -d $(DESTDIR)$(libdir)
-	@install $(SOLIB) $(DESTDIR)$(prefix)/lib/$(SOLIB)
+	@install $(SOLIB) $(DESTDIR)$(libdir)/$(SOLIB)
-	@install $(STATICLIB) $(DESTDIR)$(prefix)/lib/$(STATICLIB)
+	@ln -sf $(SOLIB) $(DESTDIR)$(libdir)/$(SYMLIB)
-	@ln -sf $(SOLIB) $(DESTDIR)$(prefix)/lib/$(SYMLIB)
+
-	@install -d $(DESTDIR)$(incdir)
+install-dev:
-	@install -m 0644 $(HEADER) $(DESTDIR)$(incdir)/$(HEADER)
+	@install -d $(DESTDIR)$(incdir)/$(LIBNAME)
-	@install -d $(DESTDIR)$(datadir)
+	@for file in $(HEADERS); do						\
-	@for file in $(DISTFILES); do \
+		printf "  INSTALL $(DESTDIR)$(incdir)/$(LIBNAME)/$$file\n";	\
-		install -m 0644 $$file $(DESTDIR)$(datadir)/$$file; \
+		install -m 0644 $$file $(DESTDIR)$(incdir)/$(LIBNAME)/$$file;	\
 	done
+	@printf "  INSTALL $(DESTDIR)$(libdir)/$(STATICLIB)\n"
+	@install -d $(DESTDIR)$(libdir)
+	@install $(STATICLIB) $(DESTDIR)$(libdir)/$(STATICLIB)
+	@install -d $(DESTDIR)$(datadir)
+	@for file in $(DISTFILES); do					\
+		printf "  INSTALL $(DESTDIR)$(datadir)/$$file\n";	\
+		install -m 0644 $$file $(DESTDIR)$(datadir)/$$file;	\
+	done
+
+install: install-exec install-dev
 
 uninstall:
 	-@$(RM) -r $(DESTDIR)$(datadir)
-	-@$(RM) -r $(DESTDIR)$(incdir)
+	-@$(RM) -r $(DESTDIR)$(incdir)/$(LIBNAME)
-	-@$(RM) $(DESTDIR)$(prefix)/lib/$(LIBNAME)*
+	-@$(RM) $(DESTDIR)$(libdir)/$(SOLIB)
+	-@$(RM) $(DESTDIR)$(libdir)/$(SYMLIB)
+	-@$(RM) $(DESTDIR)$(libdir)/$(STATICLIB)
 
 strip: $(TARGET)
 	@printf "  STRIP   %s\n" $(TARGET)
 	@$(STRIP) --strip-unneeded $(TARGET)
 	@size $(TARGET)
 
-test: Makefile test.o $(STATICLIB)
+bench: Makefile $(STATICLIB)
-	@printf "  TEST    %s\n" $(STATICLIB)
+	@printf "  RUN     %s\n" $@
-	@$(CC) $(CPPFLAGS) -g -o test test.c $(STATICLIB) && ./test
+	@$(CC) $(CPPFLAGS) -D_GNU_SOURCE -g -o bench bench.c $(STATICLIB) && ./bench
 
-bench: Makefile bench.o $(STATICLIB)
+examples: all
-	@printf "  BENCH   %s\n" $(STATICLIB)
+	@$(MAKE) -C examples
-	@$(CC) $(CPPFLAGS) -g -o bench bench.c $(STATICLIB) && ./bench
 
-joystick: Makefile joystick.o $(STATICLIB)
+test joystick: all
-	@printf "  JOTST   %s\n" $(STATICLIB)
+	@$(MAKE) -C examples $@
-	@$(CC) $(CPPFLAGS) -g -o joystick joystick.c $(STATICLIB) && ./joystick
+	@./examples/$@
 
-check:
+# Runs Clang scan-build on the whole tree
-	@$(CHECK) $(CHECK_FLAGS) $(CPPFLAGS) $(SRCS) bench.c
+check: clean
+	@scan-build $(MAKE) all
 
 clean:
-	-@$(RM) $(TARGET) *.o test
+	-@$(MAKE) -C examples $@
+	-@$(RM) $(TARGET) *.o test joystick bench
 
 distclean: clean
+	-@$(MAKE) -C examples $@
 	-@$(RM) $(DEPS) $(JUNK)
 
 dist:
 	@echo "Building .xz tarball of $(PKG) in parent dir..."
-	git archive --format=tar --prefix=$(PKG)/ $(VERSION) | xz >../$(ARCHIVE)
+	git archive --format=tar --prefix=$(PKG)/ v$(VERSION) | xz >../$(ARCHIVE)
 	@(cd ..; md5sum $(ARCHIVE) | tee $(ARCHIVE).md5)
 
 # Include automatically generated rules
-ifneq ($(MAKECMDGOALS),clean)
-ifneq ($(MAKECMDGOALS),distclean)
 -include $(DEPS)
-endif
-endif
-

README.md

@@ -1,5 +1,24 @@
 libuEv | Simple event loop for Linux
 ====================================
+[![Travis Status][]][Travis] [![Coverity Status][]][Coverity Scan]
+
+
+Table of Contents
+-----------------
+
+* [Introduction](#introduction)
+* [API](#api)
+  * [Create an Event Context](#create-an-event-context)
+  * [Register an Event Watcher](#register-an-event-watcher)
+  * [Start Event Loop](#start-event-loop)
+  * [Summary](#summary)
+* [Joystick Example](#joystick-example)
+* [Build & Install](#build--install)
+* [Origin & References](#origin--references)
+
+
+Introduction
+------------
 
 > “Why an event loop, why not use threads?”
 
@@ -9,14 +28,14 @@ often swing without consideration.  Event loops and non-blocking I/O is
 often a far easier approach, as well as less error prone.
 
 The purpose of many applications is, with a little logic sprinkled on
-top, to act upon: network packets entering an interface, timeouts
+top, to act on network packets entering an interface, timeouts expiring,
-expiring, mouse clicks, or other types of events.  Such applications are
+mouse clicks, or other types of events.  Such applications are often
-often very well suited to use an event loop.
+very well suited to use an event loop.
 
 Applications that need to churn massively parallel algorithms are more
 suitable for running multiple (independent) threads on several CPU
 cores.  However, threaded applications must deal with the side effects
-of concurrency, like: race conditions, deadlocks, live locks, etc.
+of concurrency, like race conditions, deadlocks, live locks, etc.
 Writing error free threaded applications is hard, debugging them can be
 even harder.
 
@@ -29,151 +48,225 @@ core, even though they run Linux, with multiple threads a program may
 actually run slower!  Always profile your program, and if possible, test
 it on different architectures.
 
-LibuEv is a simple event loop in the style of the more established
+[libuEv][] is a simple event loop in the style of the more established
-[libevent](http://libevent.org/),
+[libevent][1], [libev][2] and the venerable [Xt(3)][3] event loop.  The
-[libev](http://software.schmorp.de/pkg/libev.html) and the venerable
+*u* (micro) in the name refers to both the small feature set and the
-[Xt(3)](http://unix.com/man-page/All/3x/XtDispatchEvent) event loop.
+small size overhead impact of the library.  The primary target of
-The *u* (micro) in the name refers to both the small feature set and the
+[libuEv][] is a modern Linux system.
-small size overhead impact of the library.  The primary target of libuEv
-is a modern Linux system.
 
-Experienced developers may appreciate that libuEv is built on top of
+Experienced developers may appreciate that [libuEv][] is built on top of
-modern Linux APIs: epoll, timerfd and signalfd.
+modern Linux APIs: epoll, timerfd and signalfd.  Note, a certain amount
+of care is needed when dealing with APIs that employ signalfd.  For
+details, see [this article][4] at [lwn.net](http://lwn.net).
+
+> “Event driven software improves concurrency” -- [Dave Zarzycki, Apple]
 
 
 API
 ---
 
-Here is the interface to libuEv.  It handles three different types of
+The C interface to [libuEv][] is very simple.  It handles three different
-events: I/O (files, sockets, message queues, etc.), timers, and
+types of events: I/O (files, sockets, message queues, etc.), timers, and
-signals.
+signals.  With a slight caveat on signals
 
 ```C
-/* Callback example, arg is passed from watcher's *_init()
- * w->fd holds the file descriptor, events is set by libuEv
- * to indicate if any of UEV_READ and/or UEV_WRITE is ready.
- */
-void callback(uev_ctx_t *ctx, uev_t *w, void *arg, int events);
 
-/* Event loop functions, notice use of flags! */
+    /* Callback example, arg is passed from watcher's *_init()
-int uev_init       (uev_ctx_t *ctx);
+     * w->fd holds the file descriptor, events is set by libuEv
-int uev_exit       (uev_ctx_t *ctx);
+     * to indicate if any of UEV_READ and/or UEV_WRITE is ready.
-int uev_run        (uev_ctx_t *ctx, int flags);         /* UEV_NONE, UEV_ONCE, and/or UEV_NONBLOCK */
+     */
+    void callback       (uev_t *w, void *arg, int events);
 
-/* I/O watcher:     fd is non-blocking, events is UEV_READ and/or UEV_WRITE */
+    /* Event loop:      Notice the use of flags! */
-int uev_io_init    (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int fd, int events);
+    int uev_init        (uev_ctx_t *ctx);
-int uev_io_set     (uev_t *w, int fd, int events);
+    int uev_exit        (uev_ctx_t *ctx);
-int uev_io_stop    (uev_t *w);
+    int uev_run         (uev_ctx_t *ctx, int flags);         /* UEV_NONE, UEV_ONCE, and/or UEV_NONBLOCK */
+    
+    /* I/O watcher:     fd is non-blocking, events is UEV_READ and/or UEV_WRITE */
+    int uev_io_init     (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int fd, int events);
+    int uev_io_set      (uev_t *w, int fd, int events);
+    int uev_io_start    (uev_t *w);
+    int uev_io_stop     (uev_t *w);
+    
+    /* Timer watcher:   timeout and period in milliseconds */
+    int uev_timer_init  (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int timeout, int period);
+    int uev_timer_set   (uev_t *w, int timeout, int period); /* Change timeout or period */
+    int uev_timer_start (uev_t *w);                          /* Restart a stopped timer */
+    int uev_timer_stop  (uev_t *w);                          /* Stop a timer */
+    
+    /* Signal watcher:  signo is the signal to wait for, e.g., SIGTERM */
+    int uev_signal_init (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int signo);
+    int uev_signal_set  (uev_t *w, int signo);               /* Change signal to wait for */
+    int uev_signal_start(uev_t *w);                          /* Restart a stopped signal watcher */
+    int uev_signal_stop (uev_t *w);                          /* Stop signal watcher */
 
-/* Timer watcher:   timeout and period in milliseconds */
-int uev_timer_init (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int timeout, int period);
-int uev_timer_set  (uev_t *w, int timeout, int period); /* Change timeout or period */
-int uev_timer_stop (uev_t *w);                          /* Stop a timer */
-
-/* Signal watcher:  signo is the signal to wait for, e.g., SIGTERM */
-int uev_signal_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int signo);
-int uev_signal_set (uev_t *w, int signo);               /* Change signal to wait for */
-int uev_signal_stop(uev_t *w);                          /* Stop signal watcher */
 ```
 
-To be able to set up callbacks to events the developer first need to
+### Create an Event Context
-create an *event context*, achieved by calling `uev_init()` with a
-pointer to a local `uev_ctx_t` variable.
 
-Events are monitored by watchers in libuEV.  A watcher is nothing more
+To monitor events the developer first creates an *event context*, this
-than a mechnism that polls a file descriptor.  Register a watcher with a
+is achieved by calling `uev_init()` with a pointer to a (thread) local
-callback to the event context by passing the `uev_ctx_t` variable, along
+`uev_ctx_t` variable.
-with an `uev_t` variable to each event's `_init()` function.
 
-When all watchers are registered call the event loop with `uev_run()`
+```C
-and the argument to the event context.  The `flags` parameter is slightly
+
-mysterious, but can be used to integrate libuEv into another event loop.
+    uev_ctx_t ctx;
-With `flags` set to `UEV_ONCE` the event loop returns after having
+    
+    uev_init(&ctx);
+
+```
+
+### Register an Event Watcher
+
+For each event to be monitored, be it a signal, timer or a file
+descriptor, a *watcher* must be registered with the event context.  The
+watcher, an `uev_t`, is registered by calling the event type's `_init()`
+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)
+    {
+        /* Graceful exit, with optional cleanup ... */
+        uev_exit(w->ctx);
+    }
+    
+    int main(void)
+	{
+	    uev_t sigterm_watcher;
+        .
+		.
+		.
+        uev_signal_init(&ctx, &sigterm_watcher, cleanup_exit, NULL, SIGTERM);
+		.
+		.
+		.
+	}
+
+```
+
+### Start Event Loop
+
+When all watchers are registered, call the *event loop* with `uev_run()`
+and the argument to the event context.  The `flags` parameter can be
+used to integrate [libuEv][] into another event loop.
+
+In this example we set `flags` to none:
+
+```C
+
+    uev_run(&ctx, UEV_NONE);
+
+```
+
+With `flags` set to `UEV_ONCE` the event loop returns as soon as it has
 served the first event.  If `flags` is set to `UEV_ONCE | UEV_NONBLOCK`
 the event loop returns immediately if no event is available.
 
-Summary:
+**Note:** libuEv handles many types of errors, stream close, or peer
+shutdowns internally, but also lets the callback run.  This is useful
+for stateful connections to be able to detect EOF.
 
-1. Prepare an event context with `uev_init()`
+### Summary
-2. Register event callbacks with `uev_io_init()`, `uev_signal_init()`
-   or `uev_timer_init()`
-3. Enter the event loop with `uev_run()`
-4. Leave the event loop with `uev_exit()`, possibly from a callback
 
-**Note:** Make sure to use non-blocking stream I/O!  Most hard to find
+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()`
+4. 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
 opened in blocking mode.  Be careful out there!
 
+**Note 2:** When closing a descriptor or socket, make sure to first stop
+  your watcher, if possible.  This will help prevent any nasty side
+  effects on your program.
 
-Example
+**Note 3:** As mentioned above, a certain amount of care is needed when
--------
+dealing with signalfd.  This means that if your application, for
+instance, uses `system()` you must redesign that to use `fork()`, and
+then in the child, unblock all signals blocked by your parent process,
+before you run `exec()`.  This because Linux does not unblock signals
+for your children, and neither does most (all?) C-libraries.  An example
+of this, from [finit][6], implementing `run()` as a better replacement
+to `system()`, which sucks anyawy :)
 
-Here follows a very brief example to illustrate how one can use libuEv
+
-to act upon joystick input.
+Joystick Example
+----------------
+
+Here follows a very brief example to illustrate how one can use
+[libuEv][] to act upon joystick input.
 
 ```C
-#include <err.h>
-#include <errno.h>
-#include <stdio.h>
-#include <stdint.h>
-#include <fcntl.h>
-#include <unistd.h>
 
-#include "uev.h"
+    #include <err.h>
+    #include <errno.h>
+    #include <stdio.h>
+    #include <stdint.h>
+    #include <fcntl.h>
+    #include <unistd.h>
+    
+    #include "uev.h"
+    
+    struct js_event {
+    	uint32_t time;		/* event timestamp in milliseconds */
+    	int16_t  value;		/* value */
+    	uint8_t  type;		/* event type */
+    	uint8_t  number;	/* axis/button number */
+    } e;
+    
+    static void joystick_cb(uev_t *w, void *arg, int events)
+    {
+    	read (w->fd, &e, sizeof(e));
+    
+    	switch (e.type) {
+    	case 1:
+    		if (e.value) printf("Button %d pressed\n", e.number);
+    		else 	     printf("Button %d released\n", e.number);
+    		break;
+    
+    	case 2:
+    		printf("Joystick axis %d moved, value %d!\n", e.number, e.value);
+    		break;
+    	}
+    }
+    
+    int main(void)
+    {
+    	int       fd = open("/dev/input/js1", O_RDONLY, O_NONBLOCK);
+    	uev_t     js1_watcher;
+    	uev_ctx_t ctx;
+    
+    	if (fd < 0)
+    		errx(errno, "Cannot find a joystick attached.");
+    
+    	uev_init(&ctx);
+    	uev_io_init(&ctx, &js1_watcher, joystick_cb, NULL, fd, UEV_READ);
+    
+    	puts("Starting, press Ctrl-C to exit.");
+    
+    	return uev_run(&ctx, 0);
+    }
 
-struct js_event {
-	uint32_t time;		/* event timestamp in milliseconds */
-	int16_t  value;		/* value */
-	uint8_t  type;		/* event type */
-	uint8_t  number;	/* axis/button number */
-} e;
-
-static void joystick_cb(uev_ctx_t *ctx, uev_t *w, void *arg, int events)
-{
-	read (w->fd, &e, sizeof(e));
-
-	switch (e.type) {
-	case 1:
-		if (e.value) printf("Button %d pressed\n", e.number);
-		else 	     printf("Button %d released\n", e.number);
-		break;
-
-	case 2:
-		printf("Joystick axis %d moved, value %d!\n", e.number, e.value);
-		break;
-	}
-}
-
-int main(void)
-{
-	int       fd = open("/dev/input/js1", O_RDONLY, O_NONBLOCK);
-	uev_t     js1_watcher;
-	uev_ctx_t ctx;
-
-	if (fd < 0)
-		errx(errno, "Cannot find a joystick attached.");
-
-	uev_init(&ctx);
-	uev_io_init(&ctx, &js1_watcher, joystick_cb, NULL, fd, UEV_READ);
-
-	puts("Starting, press Ctrl-C to exit.");
-
-	return uev_run(&ctx, 0);
-}
 ```
 
 To compile the program, save the code as `joystick.c` and call GCC with
 `gcc -o joystick joystick.c io.c timer.c signal.c main.c` from this
 directory, skips using a Makefile altogether.  Alternatively, call the
-`Makefile` with `make joystick` from this directory.
+`Makefile` with <kbd>make joystick</kbd> from this directory.
 
-For a more complete, and perhaps more relevant example, see the code for
+More complete and relevant example uses of [libuEv][] is the TFTP/FTP
-the TFTP/FTP server [uftpd](https://github.com/troglobit/uftpd).  It
+server [uftpd][5], and the Linux `/sbin/init` replacement [finit][6].
-uses libuEv as a GIT submodule.
+Both use [libuEv][] as a GIT submodule.
 
-Also, see the `bench.c` program (`make bench` from within the library)
+Also see the `bench.c` program (<kbd>make bench</kbd> from within the
-for [reference benchmarks](http://libev.schmorp.de/bench.html) against
+library) for [reference benchmarks][7] against [libevent][1] and
-libevent and libev.
+[libev][2].
 
 
 Build & Install
@@ -184,11 +277,11 @@ use GCC and GNU Make specific extensions here and there.  This is not on
 purpose and patches to correct this are most welcome.  Particularly
 patches to support *BSD and its kqueue interface.
 
-* `make all`: The library
+* <kbd>make all</kbd>: The library
-* `make test`: Test and showcase
+* <kbd>make test</kbd>: Test and showcase
-* `make install`: Honors `$prefix` and `$DESTDIR` environment variables
+* <kbd>make install</kbd>: Honors `$prefix` and `$DESTDIR` environment variables
 
-Size of libuEv:
+Size of [libuEv][]:
 
     $ make strip
     CC      main.o
@@ -210,22 +303,36 @@ Size of libuEv:
 Origin & References
 --------------------
 
-LibuEv (this library) was originally based on
+[libuEv][] was originally based on [LibUEvent][8] by [Flemming Madsen]
-[LibUEvent](http://code.google.com/p/libuevent/) by
+but has been completely rewritten with a much clearer API.  Now more
-[Flemming Madsen](http://www.madsensoft.dk/) but has been completely
+similar to the famous [libev][2] by [Mark Lehmann][].  Another small
-rewritten with a much clearer API.  Now more similar to the famous
+event library used for inspiration is the very small [Picoev][9] by
-[libev](http://software.schmorp.de/pkg/libev.html) by Mark Lehmann.
+[Oku Kazuho][].
-Another small event library used for inspiration is the very small
-[Picoev](https://github.com/kazuho/picoev) by
-[Oku Kazuho](https://github.com/kazuho).
 
-* http://code.google.com/p/libuevent/
+[libuEv][] is developed and maintained by [Joachim Nilsson][].
-* http://software.schmorp.de/pkg/libev.html
-* http://libev.schmorp.de/bench.html
-* http://libevent.org/
-* http://developer.cybozu.co.jp/archives/kazuho/2009/08/picoev-a-tiny-e.html
-* http://coderepos.org/share/browser/lang/c/picoev/
 
-LibuEv is maintained by [Joachim Nilsson](mailto:troglobit@gmail.com) at
+[1]: http://libevent.org
-[GitHub](https://github.com/troglobit/libuev)
+[2]: http://software.schmorp.de/pkg/libev.html
+[3]: http://unix.com/man-page/All/3x/XtDispatchEvent
+[4]: http://lwn.net/Articles/415684/
+[5]: https://github.com/troglobit/uftpd
+[6]: https://github.com/troglobit/finit
+[7]: http://libev.schmorp.de/bench.html
+[8]: http://code.google.com/p/libuevent/
+[9]: https://github.com/kazuho/picoev
+[Travis]:          https://travis-ci.org/troglobit/libuev
+[Travis Status]:   https://travis-ci.org/troglobit/libuev.png?branch=master
+[Coverity Scan]:   https://scan.coverity.com/projects/3846
+[Coverity Status]: https://scan.coverity.com/projects/3846/badge.svg
+[LibuEv]:          https://github.com/troglobit/libuev
+[Oku Kazuho]:      https://github.com/kazuho
+[Mark Lehmann]:    http://software.schmorp.de
+[Joachim Nilsson]: http://troglobit.com
+[Flemming Madsen]: http://www.madsensoft.dk
+[Dave Zarzycki, Apple]: http://www.youtube.com/watch?v=cD_s6Fjdri8
 
+<!--
+  -- Local Variables:
+  --  mode: markdown
+  -- End:
+  -->

TODO

@@ -0,0 +1 @@
+TODO.md

TODO.md

@@ -0,0 +1,5 @@
+LibuEv TODO
+===========
+
+* Make port to *BSD kqueue API, http://en.wikipedia.org/wiki/Kqueue
+

bench.c

@@ -70,7 +70,7 @@ static int *pipes;
 static uev_t *evio;
 static uev_t *evto;
 
-static void read_cb(uev_ctx_t *UNUSED(ctx), uev_t *w, void *arg, int UNUSED(events))
+static void read_cb(uev_t *w, void *arg, int UNUSED(events))
 {
 	int idx, widx;
 	u_char ch;
@@ -96,7 +96,7 @@ static void read_cb(uev_ctx_t *UNUSED(ctx), uev_t *w, void *arg, int UNUSED(even
 	}
 }
 
-static void timer_cb(uev_ctx_t UNUSED(*ctx), uev_t UNUSED(*w), void UNUSED(*arg), int UNUSED(events))
+static void timer_cb(uev_t UNUSED(*w), void UNUSED(*arg), int UNUSED(events))
 {
 	/* nop */
 }
@@ -208,16 +208,17 @@ int main(int argc, char **argv)
 		if (timers)
 			uev_timer_init(&ctx, &evto[i], timer_cb, NULL, 0, 0);
 		args[i].index = i;
-		uev_io_init(&ctx, &evio[i], read_cb, &args[i], -1, UEV_READ);
 
 #ifdef USE_PIPES
-		if (pipe(cp) == -1) {
+		if (pipe2(cp, O_NONBLOCK) == -1) {
 #else
-		if (socketpair(AF_UNIX, SOCK_STREAM, 0, cp) == -1) {
+		if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0, cp) == -1) {
 #endif
 			perror("pipe");
 			exit(1);
 		}
+
+		uev_io_init(&ctx, &evio[i], read_cb, &args[i], cp[0], UEV_READ);
 	}
 
 	for (i = 0; i < 2; i++)

examples/Makefile

@@ -0,0 +1,54 @@
+# libuEv examples
+#
+# Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
+# Copyright (c) 2013-2015  Joachim Nilsson <troglobit()gmail!com>
+#
+# 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.
+#
+.PHONY: all clean
+
+TARGET      = signal test joystick
+OBJS       := $(addsuffix .o, $(TARGET))
+SRCS       := $(OBJS:.o=.c)
+DEPS       := $(SRCS:.c=.d)
+CPPFLAGS   += -I../
+LDFLAGS    := -L../
+LDLIBS     := ../$(STATICLIB)
+
+# This magic trick looks like a comment, but works on BSD PMake
+#include <../rules.mk>
+include ../rules.mk
+
+all: $(TARGET)
+
+signal: signal.o
+
+test: test.o
+
+joystick: joystick.o
+
+clean:
+	-@$(RM) $(TARGET) *.o
+
+distclean: clean
+	-@$(RM) $(DEPS) $(JUNK)
+
+# Include automatically generated rules
+-include $(DEPS)

examples/joystick.c

@@ -1,25 +1,24 @@
 /* Simple example of how to use libuEv with Linux joystick API
  *
- * Copyright (c) 2014  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2014-2015  Joachim Nilsson <troglobit()gmail!com>
  *
- * Permission is hereby granted, free of charge, to any person obtaining
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
- * a copy of this software and associated documentation files (the
+ * of this software and associated documentation files (the "Software"), to deal
- * "Software"), to deal in the Software without restriction, including
+ * in the Software without restriction, including without limitation the rights
- * without limitation the rights to use, copy, modify, merge, publish,
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * distribute, sublicense, and/or sell copies of the Software, and to
+ * copies of the Software, and to permit persons to whom the Software is
- * permit persons to whom the Software is furnished to do so, subject to
+ * furnished to do so, subject to the following conditions:
- * the following conditions:
  *
- * The above copyright notice and this permission notice shall be
+ * The above copyright notice and this permission notice shall be included in
- * included in all copies or substantial portions of the Software.
+ * all copies or substantial portions of the Software.
  *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * THE SOFTWARE.
  */
 
 #include <err.h>
@@ -40,7 +39,7 @@ struct js_event {
 	uint8_t  number;	/* axis/button number */
 } e;
 
-static void joystick_cb(uev_ctx_t *UNUSED(ctx), uev_t *w, void *UNUSED(arg), int UNUSED(events))
+static void joystick_cb(uev_t *w, void *UNUSED(arg), int UNUSED(events))
 {
 	if (read (w->fd, &e, sizeof(e)) < 0)
 		errx(errno, "Failed reading joystick event");

examples/signal.c

@@ -0,0 +1,141 @@
+/* Multiple signals, segfault and fork() to test sub-processes.
+ *
+ * Copyright (c) 2015  Joachim Nilsson <troglobit@gmail.com>
+ *
+ * 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.
+ */
+
+#define _GNU_SOURCE
+#include <err.h>
+#include <sched.h>
+#include <signal.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/user.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "uev.h"
+
+#define UNUSED(arg) arg __attribute__ ((unused))
+#define DO_SEGFAULT 1
+
+typedef struct {
+	int magic;
+	void *ptr;
+} arg_t;
+
+/* Stack is not shared between parent and child, only the heap. */
+static arg_t arg = {
+	.magic = 1337,
+	.ptr = NULL
+};
+
+static int callback(arg_t *arg, int event, void *foo)
+{
+	arg_t *event_arg  = (arg_t *)foo;
+
+	printf("child: got magic %d and ptr %p, with event %d and event arg %p\n",
+	       arg->magic, arg->ptr, event, event_arg);
+
+	arg->magic = 7331;
+	arg->ptr   = &event_arg;
+
+	/* Cause segfault! */
+#if DO_SEGFAULT == 1
+	event_arg->ptr = arg->ptr;
+	printf("child: segfaulting failed!\n");
+#endif
+
+        return 42;
+}
+
+static void sigsegv_cb(uev_t *UNUSED(w), void *UNUSED(arg), int UNUSED(events))
+{
+	warnx("PID %d caused segfault.", getpid());
+	exit(-1);
+}
+
+static void sigchld_cb(uev_t *UNUSED(w), void *UNUSED(arg), int UNUSED(events))
+{
+        pid_t pid = waitpid(-1, NULL, WNOHANG);
+
+        if (-1 != pid)
+                warnx("PID %d exited, bye.", pid);
+}
+
+static void work_cb(uev_t *UNUSED(w), void *arg, int UNUSED(events))
+{
+	int    status = 0;
+        pid_t  pid;
+
+        pid = fork();
+        if (-1 == pid)
+                err(1, "fork");
+	if (!pid) {
+		status = callback(arg, 6137, NULL);
+                exit(status);
+        }
+
+        if (waitpid(pid, &status, 0) == -1)
+                err(1, "waitpid");
+
+	if (WIFEXITED(status))
+		printf("Child exited normally => %d\n", WEXITSTATUS(status));
+	else if (WCOREDUMP(status))
+		printf("Child crashed! %s\n", DO_SEGFAULT
+		       ? "As expected, everything is OK."
+		       : "This should not happen!");
+	else
+		printf("Child did not exit normally!\n");
+}
+
+static void exit_cb(uev_t *w, void *UNUSED(arg), int UNUSED(events))
+{
+        printf("Process deadline reached, exiting!\n");
+	uev_exit(w->ctx);
+}
+
+int main(void)
+{
+	uev_t sigsegv_watcher, sigchld_watcher, timeout_watcher, deadline_watcher;
+	uev_ctx_t ctx;
+
+	/* Initialize libuEv */
+	uev_init(&ctx);
+
+	/* Setup callbacks */
+	uev_signal_init(&ctx, &sigsegv_watcher, sigsegv_cb, NULL, SIGSEGV);
+	uev_signal_init(&ctx, &sigchld_watcher, sigchld_cb, NULL, SIGCHLD);
+	uev_timer_init(&ctx, &timeout_watcher, work_cb, &arg, 400, 0);
+	uev_timer_init(&ctx, &deadline_watcher, exit_cb, NULL, 1000, 0);
+
+	/* Start event loop */
+	return uev_run(&ctx, 0);
+}
+
+/**
+ * Local Variables:
+ *  version-control: t
+ *  indent-tabs-mode: t
+ *  c-file-style: "linux"
+ * End:
+ */

examples/test.c

@@ -1,26 +1,25 @@
 /* Test libuEv event library
  *
- * Copyright (c) 2012  Flemming Madsen <flemming!madsen()madsensoft!dk>
+ * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2015  Joachim Nilsson <troglobit()gmail!com>
  *
- * Permission is hereby granted, free of charge, to any person obtaining
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
- * a copy of this software and associated documentation files (the
+ * of this software and associated documentation files (the "Software"), to deal
- * "Software"), to deal in the Software without restriction, including
+ * in the Software without restriction, including without limitation the rights
- * without limitation the rights to use, copy, modify, merge, publish,
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * distribute, sublicense, and/or sell copies of the Software, and to
+ * copies of the Software, and to permit persons to whom the Software is
- * permit persons to whom the Software is furnished to do so, subject to
+ * furnished to do so, subject to the following conditions:
- * the following conditions:
  *
- * The above copyright notice and this permission notice shall be
+ * The above copyright notice and this permission notice shall be included in
- * included in all copies or substantial portions of the Software.
+ * all copies or substantial portions of the Software.
  *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * THE SOFTWARE.
  */
 
 #include <signal.h>
@@ -40,33 +39,33 @@ static int in, out;
 static int period = 0;
 static uev_t *watchdog;
 
-static void lifetime_cb(uev_ctx_t *ctx, uev_t UNUSED(*w), void *arg, int UNUSED(events))
+static void lifetime_cb(uev_t *w, void *arg, int UNUSED(events))
 {
-	fprintf(stderr, "\nLifetime exceeded %p\n", arg);
+	fprintf(stderr, "\nLifetime exceeded, program completed successfully! (arg:%p)\n", arg);
-	uev_exit(ctx);
+	uev_exit(w->ctx);
 }
 
 /* The pipe watchdog, if it triggers we haven't received data in time. */
-static void timeout_cb(uev_ctx_t *ctx, uev_t *w, void *arg, int UNUSED(events))
+static void timeout_cb(uev_t *w, void *arg, int UNUSED(events))
 {
 	watchdog = NULL;
 	fprintf(stderr, "\nTimeout exceeded %p\n", arg);
 
-	uev_timer_stop(w);
+	// uev_timer_stop(w); <-- No need to stop timers with period=0 :)
-	uev_exit(ctx);
+	uev_exit(w->ctx);
 }
 
-static void periodic_task(uev_ctx_t UNUSED(*ctx), uev_t UNUSED(*w), void UNUSED(*arg), int UNUSED(events))
+static void periodic_task(uev_t UNUSED(*w), void UNUSED(*arg), int UNUSED(events))
 {
 	fprintf(stderr, "|");
 }
 
-static void signal_cb(uev_ctx_t *UNUSED(ctx), uev_t *w, void *UNUSED(arg), int UNUSED(events))
+static void signal_cb(uev_t *w, void *UNUSED(arg), int UNUSED(events))
 {
 	fprintf(stderr, w->signo == SIGINT ? "^Cv" : "^\v");
 }
 
-static void pipe_read_cb(uev_ctx_t *UNUSED(ctx), uev_t UNUSED(*w), void UNUSED(*arg), int UNUSED(events))
+static void pipe_read_cb(uev_t UNUSED(*w), void UNUSED(*arg), int UNUSED(events))
 {
 	int cnt;
 	char msg[50];
@@ -80,7 +79,7 @@ static void pipe_read_cb(uev_ctx_t *UNUSED(ctx), uev_t UNUSED(*w), void UNUSED(*
 	fprintf(stderr, "%.*s.%d ", cnt, msg, cnt);
 }
 
-static void pipe_write_cb(uev_ctx_t UNUSED(*ctx), uev_t *w, void *arg, int UNUSED(events))
+static void pipe_write_cb(uev_t *w, void *arg, int UNUSED(events))
 {
 	my_t *my  = arg;
 	char *msg = "TESTING";
@@ -111,7 +110,7 @@ int main(void)
 	if (pipe(fd) < 0)
 		return 1;
 
-	/*  */
+	/* Initialize libuEv */
 	uev_init(&ctx);
 
 	/* Signal watchers, Ctrl-C => SIGINT, Ctrl-\ => SIGQUIT */
@@ -141,7 +140,7 @@ int main(void)
 	fprintf(stderr, "Period is %d must be 10: %s\n", period, 10 == period ? "OK" : "ERROR!");
 	if (10 != period)
 		return 1;
-                
+
 	return 0;
 }
 

io.c

@@ -1,28 +1,29 @@
 /* libuEv - Micro event loop library
  *
- * Copyright (c) 2012  Flemming Madsen <flemming!madsen()madsensoft!dk>
+ * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2015  Joachim Nilsson <troglobit()gmail!com>
  *
- * Permission is hereby granted, free of charge, to any person obtaining
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
- * a copy of this software and associated documentation files (the
+ * of this software and associated documentation files (the "Software"), to deal
- * "Software"), to deal in the Software without restriction, including
+ * in the Software without restriction, including without limitation the rights
- * without limitation the rights to use, copy, modify, merge, publish,
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * distribute, sublicense, and/or sell copies of the Software, and to
+ * copies of the Software, and to permit persons to whom the Software is
- * permit persons to whom the Software is furnished to do so, subject to
+ * furnished to do so, subject to the following conditions:
- * the following conditions:
  *
- * The above copyright notice and this permission notice shall be
+ * The above copyright notice and this permission notice shall be included in
- * included in all copies or substantial portions of the Software.
+ * all copies or substantial portions of the Software.
  *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * THE SOFTWARE.
  */
 
+#include <errno.h>
+
 #include "uev.h"
 
 
@@ -39,12 +40,14 @@
  */
 int uev_io_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int fd, int events)
 {
+	if (fd < 0) {
+		errno = EINVAL;
+		return -1;
+	}
+
 	if (uev_watcher_init(ctx, w, UEV_IO_TYPE, cb, arg, fd, events))
 		return -1;
 
-	if (fd < 0)
-		return 0;
-
 	return uev_watcher_start(w);
 }
 
@@ -58,18 +61,26 @@ int uev_io_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int fd, int e
  */
 int uev_io_set(uev_t *w, int fd, int events)
 {
-	if (uev_io_stop(w))
+	/* Ignore any errors, only to clean up anything lingering ... */
-		return -1;
+	uev_io_stop(w);
-
-	/* Remove from internal list */
-	LIST_REMOVE(w, link);
 
 	return uev_io_init(w->ctx, w, (uev_cb_t *)w->cb, w->arg, fd, events);
 }
 
+/**
+ * Start an I/O watcher
+ * @param w  Watcher to start (again)
+ *
+ * @return POSIX OK(0) or non-zero with @param errno set on error.
+ */
+int uev_io_start(uev_t *w)
+{
+	return uev_io_set(w, w->fd, w->events);
+}
+
 /**
  * Stop an I/O watcher
- * @param w  Pointer to an uev_t watcher
+ * @param w  Watcher to stop
  *
  * @return POSIX OK(0) or non-zero with @param errno set on error.
  */

private.h

@@ -0,0 +1,89 @@
+/* libuEv - Private methods and data types, do not use directly!
+ *
+ * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
+ * Copyright (c) 2013-2015  Joachim Nilsson <troglobit()gmail!com>
+ *
+ * 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.
+ */
+
+#ifndef LIBUEV_PRIVATE_H_
+#define LIBUEV_PRIVATE_H_
+
+#include <stdio.h>
+#include <sys/epoll.h>
+#include "queue.h"	       /* OpenBSD queue.h > old GLIBC version */
+
+/* I/O, timer, or signal watcher */
+typedef enum {
+	UEV_IO_TYPE = 1,
+	UEV_TIMER_TYPE,
+	UEV_SIGNAL_TYPE,
+} uev_type_t;
+
+/* Event mask, used internally only. */
+#define UEV_EVENT_MASK  (UEV_READ | UEV_WRITE)
+
+/* Main libuEv context type */
+typedef struct {
+	int             running;
+	int             fd;     /* For epoll() */
+	uint32_t        errors;
+	LIST_HEAD(,uev) watchers;
+} uev_ctx_t;
+
+/* Forward declare due to dependencys, don't try this at home kids. */
+struct uev;
+
+/* This is used to hide all private data members in uev_t */
+#define uev_private_t                                           \
+	LIST_ENTRY(uev) link;   /* For queue.h linked list */   \
+								\
+	int             active;                                 \
+	int             events;                                 \
+								\
+	/* Watcher callback with optional argument */           \
+	void          (*cb)(struct uev *, void *, int);         \
+	void           *arg;                                    \
+								\
+	/* Timer watchers, time in milliseconds */		\
+	int             timeout;                                \
+	int             period;                                 \
+								\
+	/* Signal watchers */                                   \
+	int             signo;                                  \
+								\
+	/* Watcher type */					\
+	uev_type_t
+
+/* Internal API for dealing with generic watchers */
+int uev_watcher_init (uev_ctx_t *ctx, struct uev *w, uev_type_t type,
+		      void (*cb)(struct uev *, void *, int), void *arg,
+		      int fd, int events);
+int uev_watcher_start(struct uev *w);
+int uev_watcher_stop (struct uev *w);
+
+#endif /* LIBUEV_PRIVATE_H_ */
+
+/**
+ * Local Variables:
+ *  version-control: t
+ *  indent-tabs-mode: t
+ *  c-file-style: "linux"
+ * End:
+ */

queue.h

@@ -0,0 +1,648 @@
+/*	$OpenBSD: queue.h,v 1.38 2013/07/03 15:05:21 fgsch Exp $	*/
+/*	$NetBSD: queue.h,v 1.11 1996/05/16 05:17:14 mycroft Exp $	*/
+
+/*
+ * Copyright (c) 1991, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)queue.h	8.5 (Berkeley) 8/20/94
+ */
+
+#ifndef	_SYS_QUEUE_H_
+#define	_SYS_QUEUE_H_
+
+/*
+ * This file defines five types of data structures: singly-linked lists, 
+ * lists, simple queues, tail queues, and circular queues.
+ *
+ *
+ * A singly-linked list is headed by a single forward pointer. The elements
+ * are singly linked for minimum space and pointer manipulation overhead at
+ * the expense of O(n) removal for arbitrary elements. New elements can be
+ * added to the list after an existing element or at the head of the list.
+ * Elements being removed from the head of the list should use the explicit
+ * macro for this purpose for optimum efficiency. A singly-linked list may
+ * only be traversed in the forward direction.  Singly-linked lists are ideal
+ * for applications with large datasets and few or no removals or for
+ * implementing a LIFO queue.
+ *
+ * A list is headed by a single forward pointer (or an array of forward
+ * pointers for a hash table header). The elements are doubly linked
+ * so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before
+ * or after an existing element or at the head of the list. A list
+ * may only be traversed in the forward direction.
+ *
+ * A simple queue is headed by a pair of pointers, one the head of the
+ * list and the other to the tail of the list. The elements are singly
+ * linked to save space, so elements can only be removed from the
+ * head of the list. New elements can be added to the list before or after
+ * an existing element, at the head of the list, or at the end of the
+ * list. A simple queue may only be traversed in the forward direction.
+ *
+ * A tail queue is headed by a pair of pointers, one to the head of the
+ * list and the other to the tail of the list. The elements are doubly
+ * linked so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before or
+ * after an existing element, at the head of the list, or at the end of
+ * the list. A tail queue may be traversed in either direction.
+ *
+ * A circle queue is headed by a pair of pointers, one to the head of the
+ * list and the other to the tail of the list. The elements are doubly
+ * linked so that an arbitrary element can be removed without a need to
+ * traverse the list. New elements can be added to the list before or after
+ * an existing element, at the head of the list, or at the end of the list.
+ * A circle queue may be traversed in either direction, but has a more
+ * complex end of list detection.
+ *
+ * For details on the use of these macros, see the queue(3) manual page.
+ */
+
+#if defined(QUEUE_MACRO_DEBUG) || (defined(_KERNEL) && defined(DIAGNOSTIC))
+#define _Q_INVALIDATE(a) (a) = ((void *)-1)
+#else
+#define _Q_INVALIDATE(a)
+#endif
+
+/*
+ * Singly-linked List definitions.
+ */
+#define SLIST_HEAD(name, type)						\
+struct name {								\
+	struct type *slh_first;	/* first element */			\
+}
+ 
+#define	SLIST_HEAD_INITIALIZER(head)					\
+	{ NULL }
+ 
+#define SLIST_ENTRY(type)						\
+struct {								\
+	struct type *sle_next;	/* next element */			\
+}
+ 
+/*
+ * Singly-linked List access methods.
+ */
+#define	SLIST_FIRST(head)	((head)->slh_first)
+#define	SLIST_END(head)		NULL
+#define	SLIST_EMPTY(head)	(SLIST_FIRST(head) == SLIST_END(head))
+#define	SLIST_NEXT(elm, field)	((elm)->field.sle_next)
+
+#define	SLIST_FOREACH(var, head, field)					\
+	for((var) = SLIST_FIRST(head);					\
+	    (var) != SLIST_END(head);					\
+	    (var) = SLIST_NEXT(var, field))
+
+#define	SLIST_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = SLIST_FIRST(head);				\
+	    (var) && ((tvar) = SLIST_NEXT(var, field), 1);		\
+	    (var) = (tvar))
+
+/*
+ * Singly-linked List functions.
+ */
+#define	SLIST_INIT(head) {						\
+	SLIST_FIRST(head) = SLIST_END(head);				\
+}
+
+#define	SLIST_INSERT_AFTER(slistelm, elm, field) do {			\
+	(elm)->field.sle_next = (slistelm)->field.sle_next;		\
+	(slistelm)->field.sle_next = (elm);				\
+} while (0)
+
+#define	SLIST_INSERT_HEAD(head, elm, field) do {			\
+	(elm)->field.sle_next = (head)->slh_first;			\
+	(head)->slh_first = (elm);					\
+} while (0)
+
+#define	SLIST_REMOVE_AFTER(elm, field) do {				\
+	(elm)->field.sle_next = (elm)->field.sle_next->field.sle_next;	\
+} while (0)
+
+#define	SLIST_REMOVE_HEAD(head, field) do {				\
+	(head)->slh_first = (head)->slh_first->field.sle_next;		\
+} while (0)
+
+#define SLIST_REMOVE(head, elm, type, field) do {			\
+	if ((head)->slh_first == (elm)) {				\
+		SLIST_REMOVE_HEAD((head), field);			\
+	} else {							\
+		struct type *curelm = (head)->slh_first;		\
+									\
+		while (curelm->field.sle_next != (elm))			\
+			curelm = curelm->field.sle_next;		\
+		curelm->field.sle_next =				\
+		    curelm->field.sle_next->field.sle_next;		\
+		_Q_INVALIDATE((elm)->field.sle_next);			\
+	}								\
+} while (0)
+
+/*
+ * List definitions.
+ */
+#define LIST_HEAD(name, type)						\
+struct name {								\
+	struct type *lh_first;	/* first element */			\
+}
+
+#define LIST_HEAD_INITIALIZER(head)					\
+	{ NULL }
+
+#define LIST_ENTRY(type)						\
+struct {								\
+	struct type *le_next;	/* next element */			\
+	struct type **le_prev;	/* address of previous next element */	\
+}
+
+/*
+ * List access methods
+ */
+#define	LIST_FIRST(head)		((head)->lh_first)
+#define	LIST_END(head)			NULL
+#define	LIST_EMPTY(head)		(LIST_FIRST(head) == LIST_END(head))
+#define	LIST_NEXT(elm, field)		((elm)->field.le_next)
+
+#define LIST_FOREACH(var, head, field)					\
+	for((var) = LIST_FIRST(head);					\
+	    (var)!= LIST_END(head);					\
+	    (var) = LIST_NEXT(var, field))
+
+#define	LIST_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = LIST_FIRST(head);				\
+	    (var) && ((tvar) = LIST_NEXT(var, field), 1);		\
+	    (var) = (tvar))
+
+/*
+ * List functions.
+ */
+#define	LIST_INIT(head) do {						\
+	LIST_FIRST(head) = LIST_END(head);				\
+} while (0)
+
+#define LIST_INSERT_AFTER(listelm, elm, field) do {			\
+	if (((elm)->field.le_next = (listelm)->field.le_next) != NULL)	\
+		(listelm)->field.le_next->field.le_prev =		\
+		    &(elm)->field.le_next;				\
+	(listelm)->field.le_next = (elm);				\
+	(elm)->field.le_prev = &(listelm)->field.le_next;		\
+} while (0)
+
+#define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\
+	(elm)->field.le_prev = (listelm)->field.le_prev;		\
+	(elm)->field.le_next = (listelm);				\
+	*(listelm)->field.le_prev = (elm);				\
+	(listelm)->field.le_prev = &(elm)->field.le_next;		\
+} while (0)
+
+#define LIST_INSERT_HEAD(head, elm, field) do {				\
+	if (((elm)->field.le_next = (head)->lh_first) != NULL)		\
+		(head)->lh_first->field.le_prev = &(elm)->field.le_next;\
+	(head)->lh_first = (elm);					\
+	(elm)->field.le_prev = &(head)->lh_first;			\
+} while (0)
+
+#define LIST_REMOVE(elm, field) do {					\
+	if ((elm)->field.le_next != NULL)				\
+		(elm)->field.le_next->field.le_prev =			\
+		    (elm)->field.le_prev;				\
+	*(elm)->field.le_prev = (elm)->field.le_next;			\
+	_Q_INVALIDATE((elm)->field.le_prev);				\
+	_Q_INVALIDATE((elm)->field.le_next);				\
+} while (0)
+
+#define LIST_REPLACE(elm, elm2, field) do {				\
+	if (((elm2)->field.le_next = (elm)->field.le_next) != NULL)	\
+		(elm2)->field.le_next->field.le_prev =			\
+		    &(elm2)->field.le_next;				\
+	(elm2)->field.le_prev = (elm)->field.le_prev;			\
+	*(elm2)->field.le_prev = (elm2);				\
+	_Q_INVALIDATE((elm)->field.le_prev);				\
+	_Q_INVALIDATE((elm)->field.le_next);				\
+} while (0)
+
+/*
+ * Simple queue definitions.
+ */
+#define SIMPLEQ_HEAD(name, type)					\
+struct name {								\
+	struct type *sqh_first;	/* first element */			\
+	struct type **sqh_last;	/* addr of last next element */		\
+}
+
+#define SIMPLEQ_HEAD_INITIALIZER(head)					\
+	{ NULL, &(head).sqh_first }
+
+#define SIMPLEQ_ENTRY(type)						\
+struct {								\
+	struct type *sqe_next;	/* next element */			\
+}
+
+/*
+ * Simple queue access methods.
+ */
+#define	SIMPLEQ_FIRST(head)	    ((head)->sqh_first)
+#define	SIMPLEQ_END(head)	    NULL
+#define	SIMPLEQ_EMPTY(head)	    (SIMPLEQ_FIRST(head) == SIMPLEQ_END(head))
+#define	SIMPLEQ_NEXT(elm, field)    ((elm)->field.sqe_next)
+
+#define SIMPLEQ_FOREACH(var, head, field)				\
+	for((var) = SIMPLEQ_FIRST(head);				\
+	    (var) != SIMPLEQ_END(head);					\
+	    (var) = SIMPLEQ_NEXT(var, field))
+
+#define	SIMPLEQ_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = SIMPLEQ_FIRST(head);				\
+	    (var) && ((tvar) = SIMPLEQ_NEXT(var, field), 1);		\
+	    (var) = (tvar))
+
+/*
+ * Simple queue functions.
+ */
+#define	SIMPLEQ_INIT(head) do {						\
+	(head)->sqh_first = NULL;					\
+	(head)->sqh_last = &(head)->sqh_first;				\
+} while (0)
+
+#define SIMPLEQ_INSERT_HEAD(head, elm, field) do {			\
+	if (((elm)->field.sqe_next = (head)->sqh_first) == NULL)	\
+		(head)->sqh_last = &(elm)->field.sqe_next;		\
+	(head)->sqh_first = (elm);					\
+} while (0)
+
+#define SIMPLEQ_INSERT_TAIL(head, elm, field) do {			\
+	(elm)->field.sqe_next = NULL;					\
+	*(head)->sqh_last = (elm);					\
+	(head)->sqh_last = &(elm)->field.sqe_next;			\
+} while (0)
+
+#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
+	if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\
+		(head)->sqh_last = &(elm)->field.sqe_next;		\
+	(listelm)->field.sqe_next = (elm);				\
+} while (0)
+
+#define SIMPLEQ_REMOVE_HEAD(head, field) do {			\
+	if (((head)->sqh_first = (head)->sqh_first->field.sqe_next) == NULL) \
+		(head)->sqh_last = &(head)->sqh_first;			\
+} while (0)
+
+#define SIMPLEQ_REMOVE_AFTER(head, elm, field) do {			\
+	if (((elm)->field.sqe_next = (elm)->field.sqe_next->field.sqe_next) \
+	    == NULL)							\
+		(head)->sqh_last = &(elm)->field.sqe_next;		\
+} while (0)
+
+/*
+ * XOR Simple queue definitions.
+ */
+#define XSIMPLEQ_HEAD(name, type)					\
+struct name {								\
+	struct type *sqx_first;	/* first element */			\
+	struct type **sqx_last;	/* addr of last next element */		\
+	unsigned long sqx_cookie;					\
+}
+
+#define XSIMPLEQ_ENTRY(type)						\
+struct {								\
+	struct type *sqx_next;	/* next element */			\
+}
+
+/*
+ * XOR Simple queue access methods.
+ */
+#define XSIMPLEQ_XOR(head, ptr)	    ((__typeof(ptr))((head)->sqx_cookie ^ \
+					(unsigned long)(ptr)))
+#define	XSIMPLEQ_FIRST(head)	    XSIMPLEQ_XOR(head, ((head)->sqx_first))
+#define	XSIMPLEQ_END(head)	    NULL
+#define	XSIMPLEQ_EMPTY(head)	    (XSIMPLEQ_FIRST(head) == XSIMPLEQ_END(head))
+#define	XSIMPLEQ_NEXT(head, elm, field)    XSIMPLEQ_XOR(head, ((elm)->field.sqx_next))
+
+
+#define XSIMPLEQ_FOREACH(var, head, field)				\
+	for ((var) = XSIMPLEQ_FIRST(head);				\
+	    (var) != XSIMPLEQ_END(head);				\
+	    (var) = XSIMPLEQ_NEXT(head, var, field))
+
+#define	XSIMPLEQ_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = XSIMPLEQ_FIRST(head);				\
+	    (var) && ((tvar) = XSIMPLEQ_NEXT(head, var, field), 1);	\
+	    (var) = (tvar))
+
+/*
+ * XOR Simple queue functions.
+ */
+#define	XSIMPLEQ_INIT(head) do {					\
+	arc4random_buf(&(head)->sqx_cookie, sizeof((head)->sqx_cookie)); \
+	(head)->sqx_first = XSIMPLEQ_XOR(head, NULL);			\
+	(head)->sqx_last = XSIMPLEQ_XOR(head, &(head)->sqx_first);	\
+} while (0)
+
+#define XSIMPLEQ_INSERT_HEAD(head, elm, field) do {			\
+	if (((elm)->field.sqx_next = (head)->sqx_first) ==		\
+	    XSIMPLEQ_XOR(head, NULL))					\
+		(head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \
+	(head)->sqx_first = XSIMPLEQ_XOR(head, (elm));			\
+} while (0)
+
+#define XSIMPLEQ_INSERT_TAIL(head, elm, field) do {			\
+	(elm)->field.sqx_next = XSIMPLEQ_XOR(head, NULL);		\
+	*(XSIMPLEQ_XOR(head, (head)->sqx_last)) = XSIMPLEQ_XOR(head, (elm)); \
+	(head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next);	\
+} while (0)
+
+#define XSIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
+	if (((elm)->field.sqx_next = (listelm)->field.sqx_next) ==	\
+	    XSIMPLEQ_XOR(head, NULL))					\
+		(head)->sqx_last = XSIMPLEQ_XOR(head, &(elm)->field.sqx_next); \
+	(listelm)->field.sqx_next = XSIMPLEQ_XOR(head, (elm));		\
+} while (0)
+
+#define XSIMPLEQ_REMOVE_HEAD(head, field) do {				\
+	if (((head)->sqx_first = XSIMPLEQ_XOR(head,			\
+	    (head)->sqx_first)->field.sqx_next) == XSIMPLEQ_XOR(head, NULL)) \
+		(head)->sqx_last = XSIMPLEQ_XOR(head, &(head)->sqx_first); \
+} while (0)
+
+#define XSIMPLEQ_REMOVE_AFTER(head, elm, field) do {			\
+	if (((elm)->field.sqx_next = XSIMPLEQ_XOR(head,			\
+	    (elm)->field.sqx_next)->field.sqx_next)			\
+	    == XSIMPLEQ_XOR(head, NULL))				\
+		(head)->sqx_last = 					\
+		    XSIMPLEQ_XOR(head, &(elm)->field.sqx_next);		\
+} while (0)
+
+		    
+/*
+ * Tail queue definitions.
+ */
+#define TAILQ_HEAD(name, type)						\
+struct name {								\
+	struct type *tqh_first;	/* first element */			\
+	struct type **tqh_last;	/* addr of last next element */		\
+}
+
+#define TAILQ_HEAD_INITIALIZER(head)					\
+	{ NULL, &(head).tqh_first }
+
+#define TAILQ_ENTRY(type)						\
+struct {								\
+	struct type *tqe_next;	/* next element */			\
+	struct type **tqe_prev;	/* address of previous next element */	\
+}
+
+/* 
+ * tail queue access methods 
+ */
+#define	TAILQ_FIRST(head)		((head)->tqh_first)
+#define	TAILQ_END(head)			NULL
+#define	TAILQ_NEXT(elm, field)		((elm)->field.tqe_next)
+#define TAILQ_LAST(head, headname)					\
+	(*(((struct headname *)((head)->tqh_last))->tqh_last))
+/* XXX */
+#define TAILQ_PREV(elm, headname, field)				\
+	(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))
+#define	TAILQ_EMPTY(head)						\
+	(TAILQ_FIRST(head) == TAILQ_END(head))
+
+#define TAILQ_FOREACH(var, head, field)					\
+	for((var) = TAILQ_FIRST(head);					\
+	    (var) != TAILQ_END(head);					\
+	    (var) = TAILQ_NEXT(var, field))
+
+#define	TAILQ_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = TAILQ_FIRST(head);					\
+	    (var) != TAILQ_END(head) &&					\
+	    ((tvar) = TAILQ_NEXT(var, field), 1);			\
+	    (var) = (tvar))
+
+
+#define TAILQ_FOREACH_REVERSE(var, head, headname, field)		\
+	for((var) = TAILQ_LAST(head, headname);				\
+	    (var) != TAILQ_END(head);					\
+	    (var) = TAILQ_PREV(var, headname, field))
+
+#define	TAILQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)	\
+	for ((var) = TAILQ_LAST(head, headname);			\
+	    (var) != TAILQ_END(head) &&					\
+	    ((tvar) = TAILQ_PREV(var, headname, field), 1);		\
+	    (var) = (tvar))
+
+/*
+ * Tail queue functions.
+ */
+#define	TAILQ_INIT(head) do {						\
+	(head)->tqh_first = NULL;					\
+	(head)->tqh_last = &(head)->tqh_first;				\
+} while (0)
+
+#define TAILQ_INSERT_HEAD(head, elm, field) do {			\
+	if (((elm)->field.tqe_next = (head)->tqh_first) != NULL)	\
+		(head)->tqh_first->field.tqe_prev =			\
+		    &(elm)->field.tqe_next;				\
+	else								\
+		(head)->tqh_last = &(elm)->field.tqe_next;		\
+	(head)->tqh_first = (elm);					\
+	(elm)->field.tqe_prev = &(head)->tqh_first;			\
+} while (0)
+
+#define TAILQ_INSERT_TAIL(head, elm, field) do {			\
+	(elm)->field.tqe_next = NULL;					\
+	(elm)->field.tqe_prev = (head)->tqh_last;			\
+	*(head)->tqh_last = (elm);					\
+	(head)->tqh_last = &(elm)->field.tqe_next;			\
+} while (0)
+
+#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\
+	if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\
+		(elm)->field.tqe_next->field.tqe_prev =			\
+		    &(elm)->field.tqe_next;				\
+	else								\
+		(head)->tqh_last = &(elm)->field.tqe_next;		\
+	(listelm)->field.tqe_next = (elm);				\
+	(elm)->field.tqe_prev = &(listelm)->field.tqe_next;		\
+} while (0)
+
+#define	TAILQ_INSERT_BEFORE(listelm, elm, field) do {			\
+	(elm)->field.tqe_prev = (listelm)->field.tqe_prev;		\
+	(elm)->field.tqe_next = (listelm);				\
+	*(listelm)->field.tqe_prev = (elm);				\
+	(listelm)->field.tqe_prev = &(elm)->field.tqe_next;		\
+} while (0)
+
+#define TAILQ_REMOVE(head, elm, field) do {				\
+	if (((elm)->field.tqe_next) != NULL)				\
+		(elm)->field.tqe_next->field.tqe_prev =			\
+		    (elm)->field.tqe_prev;				\
+	else								\
+		(head)->tqh_last = (elm)->field.tqe_prev;		\
+	*(elm)->field.tqe_prev = (elm)->field.tqe_next;			\
+	_Q_INVALIDATE((elm)->field.tqe_prev);				\
+	_Q_INVALIDATE((elm)->field.tqe_next);				\
+} while (0)
+
+#define TAILQ_REPLACE(head, elm, elm2, field) do {			\
+	if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL)	\
+		(elm2)->field.tqe_next->field.tqe_prev =		\
+		    &(elm2)->field.tqe_next;				\
+	else								\
+		(head)->tqh_last = &(elm2)->field.tqe_next;		\
+	(elm2)->field.tqe_prev = (elm)->field.tqe_prev;			\
+	*(elm2)->field.tqe_prev = (elm2);				\
+	_Q_INVALIDATE((elm)->field.tqe_prev);				\
+	_Q_INVALIDATE((elm)->field.tqe_next);				\
+} while (0)
+
+/*
+ * Circular queue definitions.
+ */
+#define CIRCLEQ_HEAD(name, type)					\
+struct name {								\
+	struct type *cqh_first;		/* first element */		\
+	struct type *cqh_last;		/* last element */		\
+}
+
+#define CIRCLEQ_HEAD_INITIALIZER(head)					\
+	{ CIRCLEQ_END(&head), CIRCLEQ_END(&head) }
+
+#define CIRCLEQ_ENTRY(type)						\
+struct {								\
+	struct type *cqe_next;		/* next element */		\
+	struct type *cqe_prev;		/* previous element */		\
+}
+
+/*
+ * Circular queue access methods 
+ */
+#define	CIRCLEQ_FIRST(head)		((head)->cqh_first)
+#define	CIRCLEQ_LAST(head)		((head)->cqh_last)
+#define	CIRCLEQ_END(head)		((void *)(head))
+#define	CIRCLEQ_NEXT(elm, field)	((elm)->field.cqe_next)
+#define	CIRCLEQ_PREV(elm, field)	((elm)->field.cqe_prev)
+#define	CIRCLEQ_EMPTY(head)						\
+	(CIRCLEQ_FIRST(head) == CIRCLEQ_END(head))
+
+#define CIRCLEQ_FOREACH(var, head, field)				\
+	for((var) = CIRCLEQ_FIRST(head);				\
+	    (var) != CIRCLEQ_END(head);					\
+	    (var) = CIRCLEQ_NEXT(var, field))
+
+#define	CIRCLEQ_FOREACH_SAFE(var, head, field, tvar)			\
+	for ((var) = CIRCLEQ_FIRST(head);				\
+	    (var) != CIRCLEQ_END(head) &&				\
+	    ((tvar) = CIRCLEQ_NEXT(var, field), 1);			\
+	    (var) = (tvar))
+
+#define CIRCLEQ_FOREACH_REVERSE(var, head, field)			\
+	for((var) = CIRCLEQ_LAST(head);					\
+	    (var) != CIRCLEQ_END(head);					\
+	    (var) = CIRCLEQ_PREV(var, field))
+
+#define	CIRCLEQ_FOREACH_REVERSE_SAFE(var, head, headname, field, tvar)	\
+	for ((var) = CIRCLEQ_LAST(head, headname);			\
+	    (var) != CIRCLEQ_END(head) && 				\
+	    ((tvar) = CIRCLEQ_PREV(var, headname, field), 1);		\
+	    (var) = (tvar))
+
+/*
+ * Circular queue functions.
+ */
+#define	CIRCLEQ_INIT(head) do {						\
+	(head)->cqh_first = CIRCLEQ_END(head);				\
+	(head)->cqh_last = CIRCLEQ_END(head);				\
+} while (0)
+
+#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\
+	(elm)->field.cqe_next = (listelm)->field.cqe_next;		\
+	(elm)->field.cqe_prev = (listelm);				\
+	if ((listelm)->field.cqe_next == CIRCLEQ_END(head))		\
+		(head)->cqh_last = (elm);				\
+	else								\
+		(listelm)->field.cqe_next->field.cqe_prev = (elm);	\
+	(listelm)->field.cqe_next = (elm);				\
+} while (0)
+
+#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do {		\
+	(elm)->field.cqe_next = (listelm);				\
+	(elm)->field.cqe_prev = (listelm)->field.cqe_prev;		\
+	if ((listelm)->field.cqe_prev == CIRCLEQ_END(head))		\
+		(head)->cqh_first = (elm);				\
+	else								\
+		(listelm)->field.cqe_prev->field.cqe_next = (elm);	\
+	(listelm)->field.cqe_prev = (elm);				\
+} while (0)
+
+#define CIRCLEQ_INSERT_HEAD(head, elm, field) do {			\
+	(elm)->field.cqe_next = (head)->cqh_first;			\
+	(elm)->field.cqe_prev = CIRCLEQ_END(head);			\
+	if ((head)->cqh_last == CIRCLEQ_END(head))			\
+		(head)->cqh_last = (elm);				\
+	else								\
+		(head)->cqh_first->field.cqe_prev = (elm);		\
+	(head)->cqh_first = (elm);					\
+} while (0)
+
+#define CIRCLEQ_INSERT_TAIL(head, elm, field) do {			\
+	(elm)->field.cqe_next = CIRCLEQ_END(head);			\
+	(elm)->field.cqe_prev = (head)->cqh_last;			\
+	if ((head)->cqh_first == CIRCLEQ_END(head))			\
+		(head)->cqh_first = (elm);				\
+	else								\
+		(head)->cqh_last->field.cqe_next = (elm);		\
+	(head)->cqh_last = (elm);					\
+} while (0)
+
+#define	CIRCLEQ_REMOVE(head, elm, field) do {				\
+	if ((elm)->field.cqe_next == CIRCLEQ_END(head))			\
+		(head)->cqh_last = (elm)->field.cqe_prev;		\
+	else								\
+		(elm)->field.cqe_next->field.cqe_prev =			\
+		    (elm)->field.cqe_prev;				\
+	if ((elm)->field.cqe_prev == CIRCLEQ_END(head))			\
+		(head)->cqh_first = (elm)->field.cqe_next;		\
+	else								\
+		(elm)->field.cqe_prev->field.cqe_next =			\
+		    (elm)->field.cqe_next;				\
+	_Q_INVALIDATE((elm)->field.cqe_prev);				\
+	_Q_INVALIDATE((elm)->field.cqe_next);				\
+} while (0)
+
+#define CIRCLEQ_REPLACE(head, elm, elm2, field) do {			\
+	if (((elm2)->field.cqe_next = (elm)->field.cqe_next) ==		\
+	    CIRCLEQ_END(head))						\
+		(head)->cqh_last = (elm2);				\
+	else								\
+		(elm2)->field.cqe_next->field.cqe_prev = (elm2);	\
+	if (((elm2)->field.cqe_prev = (elm)->field.cqe_prev) ==		\
+	    CIRCLEQ_END(head))						\
+		(head)->cqh_first = (elm2);				\
+	else								\
+		(elm2)->field.cqe_prev->field.cqe_next = (elm2);	\
+	_Q_INVALIDATE((elm)->field.cqe_prev);				\
+	_Q_INVALIDATE((elm)->field.cqe_next);				\
+} while (0)
+
+#endif	/* !_SYS_QUEUE_H_ */

rules.mk

@@ -0,0 +1,9 @@
+# Pretty printing and GCC -M for auto dep files
+%.o: %.c
+	@printf "  CC      $(subst $(ROOTDIR)/,,$(shell pwd)/)$@\n"
+	@$(CC) $(CFLAGS) $(CPPFLAGS) -c -MMD -MP -o $@ $<
+
+%: %.o
+	@printf "  LINK    $(subst $(ROOTDIR)/,,$(shell pwd)/)$@\n"
+	@$(CC) $(CFLAGS) $(LDFLAGS) -Wl,-Map,$@.map -o $@ $^ $(LDLIBS$(LDLIBS-$(@)))
+

signal.c

@@ -1,26 +1,25 @@
 /* libuEv - Micro event loop library
  *
- * Copyright (c) 2012  Flemming Madsen <flemming!madsen()madsensoft!dk>
+ * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2015  Joachim Nilsson <troglobit()gmail!com>
  *
- * Permission is hereby granted, free of charge, to any person obtaining
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
- * a copy of this software and associated documentation files (the
+ * of this software and associated documentation files (the "Software"), to deal
- * "Software"), to deal in the Software without restriction, including
+ * in the Software without restriction, including without limitation the rights
- * without limitation the rights to use, copy, modify, merge, publish,
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * distribute, sublicense, and/or sell copies of the Software, and to
+ * copies of the Software, and to permit persons to whom the Software is
- * permit persons to whom the Software is furnished to do so, subject to
+ * furnished to do so, subject to the following conditions:
- * the following conditions:
  *
- * The above copyright notice and this permission notice shall be
+ * The above copyright notice and this permission notice shall be included in
- * included in all copies or substantial portions of the Software.
+ * all copies or substantial portions of the Software.
  *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * THE SOFTWARE.
  */
 
 #include <errno.h>
@@ -46,6 +45,12 @@ int uev_signal_init(uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int signo
 	int fd;
 	sigset_t mask;
 
+	if (!w || !ctx) {
+		errno = EINVAL;
+		return -1;
+	}
+	w->fd = -1;
+
 	sigemptyset(&mask);
 	fd = signalfd(-1, &mask, SFD_NONBLOCK);
 	if (fd < 0)
@@ -81,6 +86,9 @@ int uev_signal_set(uev_t *w, int signo)
 		return -1;
 	}
 
+	/* Remember for callbacks and start/stop */
+	w->signo = signo;
+
 	/* Handle stopped signal watchers */
 	if (w->fd < 0) {
 		/* Remove from internal list */
@@ -104,6 +112,26 @@ int uev_signal_set(uev_t *w, int signo)
 	return uev_watcher_start(w);
 }
 
+
+/**
+ * Start a stopped signal watcher
+ * @param w  Watcher to start (again)
+ *
+ * @return POSIX OK(0) or non-zero with @param errno set on error.
+ */
+int uev_signal_start(uev_t *w)
+{
+	if (!w) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if (-1 != w->fd)
+		uev_signal_stop(w);
+
+	return uev_signal_set(w, w->signo);
+}
+
 /**
  * Stop a signal watcher
  * @param w  Watcher to stop

timer.c

@@ -1,26 +1,25 @@
 /* libuEv - Micro event loop library
  *
- * Copyright (c) 2012  Flemming Madsen <flemming!madsen()madsensoft!dk>
+ * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2015  Joachim Nilsson <troglobit()gmail!com>
  *
- * Permission is hereby granted, free of charge, to any person obtaining
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
- * a copy of this software and associated documentation files (the
+ * of this software and associated documentation files (the "Software"), to deal
- * "Software"), to deal in the Software without restriction, including
+ * in the Software without restriction, including without limitation the rights
- * without limitation the rights to use, copy, modify, merge, publish,
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * distribute, sublicense, and/or sell copies of the Software, and to
+ * copies of the Software, and to permit persons to whom the Software is
- * permit persons to whom the Software is furnished to do so, subject to
+ * furnished to do so, subject to the following conditions:
- * the following conditions:
  *
- * The above copyright notice and this permission notice shall be
+ * The above copyright notice and this permission notice shall be included in
- * included in all copies or substantial portions of the Software.
+ * all copies or substantial portions of the Software.
  *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * THE SOFTWARE.
  */
 
 #include <errno.h>
@@ -123,11 +122,28 @@ int uev_timer_set(uev_t *w, int timeout, int period)
 		msec2tspec(timeout, &time.it_value);
 		msec2tspec(period, &time.it_interval);
 		timerfd_settime(w->fd, 0, &time, NULL);
-
-		return uev_watcher_start(w);
 	}
 
-	return 0;
+	return uev_watcher_start(w);
+}
+
+/**
+ * Start a stopped timer watcher
+ * @param w  Watcher to start (again)
+ *
+ * @return POSIX OK(0) or non-zero with @param errno set on error.
+ */
+int uev_timer_start(uev_t *w)
+{
+	if (!w) {
+		errno = EINVAL;
+		return -1;
+	}
+
+	if (-1 != w->fd)
+		uev_watcher_stop(w);
+
+	return uev_timer_set(w, w->timeout, w->period);
 }
 
 /**
@@ -138,12 +154,12 @@ int uev_timer_set(uev_t *w, int timeout, int period)
  */
 int uev_timer_stop(uev_t *w)
 {
-	if (uev_watcher_stop(w))
-		return -1;
-
 	/* Stop kernel timer */
 	uev_timer_set(w, 0, 0);
 
+	if (uev_watcher_stop(w))
+		return -1;
+
 	/* Close timerfd, will have to be reopened again on reset */
 	close(w->fd);
 	w->fd = -1;

uev.c

@@ -1,29 +1,29 @@
 /* libuEv - Micro event loop library
  *
- * Copyright (c) 2012  Flemming Madsen <flemming!madsen()madsensoft!dk>
+ * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2015  Joachim Nilsson <troglobit()gmail!com>
  *
- * Permission is hereby granted, free of charge, to any person obtaining
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
- * a copy of this software and associated documentation files (the
+ * of this software and associated documentation files (the "Software"), to deal
- * "Software"), to deal in the Software without restriction, including
+ * in the Software without restriction, including without limitation the rights
- * without limitation the rights to use, copy, modify, merge, publish,
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * distribute, sublicense, and/or sell copies of the Software, and to
+ * copies of the Software, and to permit persons to whom the Software is
- * permit persons to whom the Software is furnished to do so, subject to
+ * furnished to do so, subject to the following conditions:
- * the following conditions:
  *
- * The above copyright notice and this permission notice shall be
+ * The above copyright notice and this permission notice shall be included in
- * included in all copies or substantial portions of the Software.
+ * all copies or substantial portions of the Software.
  *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * THE SOFTWARE.
  */
 
 #include <errno.h>
+#include <fcntl.h>		/* O_CLOEXEC */
 #include <string.h>		/* memset() */
 #include <sys/epoll.h>
 #include <sys/signalfd.h>	/* struct signalfd_siginfo */
@@ -33,6 +33,28 @@
 
 #define UNUSED(arg) arg __attribute__ ((unused))
 
+
+static int _init(uev_ctx_t *ctx, int close_old)
+{
+	int fd = epoll_create1(EPOLL_CLOEXEC);
+
+	if (fd < 0)
+		return -1;
+
+	if (close_old)
+		close(ctx->fd);
+
+	ctx->fd = fd;
+
+	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;
+}
+
 /* 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)
 {
@@ -41,16 +63,14 @@ int uev_watcher_init(uev_ctx_t *ctx, uev_t *w, uev_type_t type, uev_cb_t *cb, vo
 		return -1;
 	}
 
-	memset(w, 0, sizeof(*w));
 	w->ctx    = ctx;
-	w->fd     = fd;
 	w->type   = type;
+	w->active = 0;
+	w->fd     = fd;
 	w->cb     = (void *)cb;
 	w->arg    = arg;
 	w->events = events;
 
-	LIST_INSERT_HEAD(&w->ctx->watchers, w, link);
-
 	return 0;
 }
 
@@ -67,13 +87,16 @@ int uev_watcher_start(uev_t *w)
 	if (w->active)
 		return 0;
 
-	ev.events   = w->events;
+	ev.events   = w->events | EPOLLRDHUP;
 	ev.data.ptr = w;
 	if (epoll_ctl(w->ctx->fd, EPOLL_CTL_ADD, w->fd, &ev) < 0)
 		return -1;
 
 	w->active = 1;
 
+	/* Add to internal list for bookkeeping */
+	LIST_INSERT_HEAD(&w->ctx->watchers, w, link);
+
 	return 0;
 }
 
@@ -88,10 +111,15 @@ int uev_watcher_stop(uev_t *w)
 	if (!w->active)
 		return 0;
 
-	/* Remove from kernel */
-	epoll_ctl(w->ctx->fd, EPOLL_CTL_DEL, w->fd, NULL);
 	w->active = 0;
 
+	/* Remove from internal list */
+	LIST_REMOVE(w, link);
+
+	/* Remove from kernel */
+	if (epoll_ctl(w->ctx->fd, EPOLL_CTL_DEL, w->fd, NULL) < 0)
+		return -1;
+
 	return 0;
 }
 
@@ -103,17 +131,15 @@ int uev_watcher_stop(uev_t *w)
  */
 int uev_init(uev_ctx_t *ctx)
 {
-	int fd;
+	if (!ctx) {
-
+		errno = EINVAL;
-	fd = epoll_create(1);
-	if (fd < 0)
 		return -1;
+	}
 
 	memset(ctx, 0, sizeof(*ctx));
-	ctx->fd = fd;
 	LIST_INIT(&ctx->watchers);
 
-	return 0;
+	return _init(ctx, 0);
 }
 
 /**
@@ -206,20 +232,54 @@ int uev_run(uev_ctx_t *ctx, int flags)
 
 			if (EINTR == errno)
 				continue; /* Signalled, try again */
-		exit:
+
-			result = -1;
+			/* Unrecoverable error, cleanup and exit with error. */
-			ctx->running = 0;
+			uev_exit(ctx);
-			break;
+			return -1;
 		}
 
 		for (i = 0; ctx->running && i < nfds; i++) {
 			w = (uev_t *)events[i].data.ptr;
 
+			if (events[i].events & (EPOLLHUP | EPOLLERR)) {
+				ctx->errors++;
+
+				if (ctx->errors >= 42) {
+					uev_t *tmp, *retry = w;;
+
+					/* If not valid anymore, try to remove, ignore any errors. */
+					if (!is_valid_fd(w->fd))
+						uev_watcher_stop(w);
+
+					/* Must recreate epoll fd now ... */
+					if (_init(ctx, 1)) {
+						uev_exit(ctx);
+						return -2;
+					}
+
+					/* Restart watchers in new efd */
+					LIST_FOREACH_SAFE(w, &ctx->watchers, link, tmp) {
+						if (w->active) {
+							w->active = 0;
+							LIST_REMOVE(w, link);
+							uev_watcher_start(w);
+						}
+					}
+					uev_watcher_start(retry);
+
+					/* New efd, restart everything! */
+					ctx->errors = 0;
+					continue;
+				}
+			}
+
 			if (UEV_TIMER_TYPE == w->type) {
 				uint64_t exp;
 
-				if (read(w->fd, &exp, sizeof(exp)) != sizeof(exp))
+				if (read(w->fd, &exp, sizeof(exp)) != sizeof(exp)) {
-					goto exit;
+					uev_exit(ctx);
+					return -3;
+				}
 
 				if (!w->period)
 					w->timeout = 0;
@@ -229,14 +289,14 @@ int uev_run(uev_ctx_t *ctx, int flags)
 				struct signalfd_siginfo fdsi;
 				ssize_t sz = sizeof(fdsi);
 
-				if (read(w->fd, &fdsi, sz) != sz)
+				if (read(w->fd, &fdsi, sz) != sz) {
-					goto exit;
+					uev_exit(ctx);
-
+					return -4;
-				w->signo = fdsi.ssi_signo;
+				}
 			}
 
 			if (w->cb)
-				w->cb((struct uev *)ctx, w, w->arg);
+				w->cb(w, w->arg, events[i].events & UEV_EVENT_MASK);
 
 			if (UEV_TIMER_TYPE == w->type) {
 				if (!w->timeout)

uev.h

@@ -1,34 +1,31 @@
 /* libuEv - Micro event loop library
  *
- * Copyright (c) 2012  Flemming Madsen <flemming!madsen()madsensoft!dk>
+ * Copyright (c) 2012       Flemming Madsen <flemming!madsen()madsensoft!dk>
- * Copyright (c) 2013  Joachim Nilsson <troglobit()gmail!com>
+ * Copyright (c) 2013-2015  Joachim Nilsson <troglobit()gmail!com>
  *
- * Permission is hereby granted, free of charge, to any person obtaining
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
- * a copy of this software and associated documentation files (the
+ * of this software and associated documentation files (the "Software"), to deal
- * "Software"), to deal in the Software without restriction, including
+ * in the Software without restriction, including without limitation the rights
- * without limitation the rights to use, copy, modify, merge, publish,
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * distribute, sublicense, and/or sell copies of the Software, and to
+ * copies of the Software, and to permit persons to whom the Software is
- * permit persons to whom the Software is furnished to do so, subject to
+ * furnished to do so, subject to the following conditions:
- * the following conditions:
  *
- * The above copyright notice and this permission notice shall be
+ * The above copyright notice and this permission notice shall be included in
- * included in all copies or substantial portions of the Software.
+ * all copies or substantial portions of the Software.
  *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
- * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ * THE SOFTWARE.
  */
 
 #ifndef LIBUEV_UEV_H_
 #define LIBUEV_UEV_H_
 
-#include <stdio.h>
+#include "private.h"
-#include <sys/epoll.h>
-#include <sys/queue.h>
 
 /* Max. number of simulateneous events */
 #define UEV_MAX_EVENTS  10
@@ -42,53 +39,18 @@
 #define UEV_ONCE        1
 #define UEV_NONBLOCK    2
 
-/* I/O, timer, or signal watcher */
+/* Event watcher */
-typedef enum {
-	UEV_IO_TYPE = 1,
-	UEV_TIMER_TYPE,
-	UEV_SIGNAL_TYPE,
-} uev_type_t;
-
-/* Forward declare due to dependencys, don't try this at home kids. */
-struct uev;
-
-/* Main libuEv context type */
-typedef struct {
-	int             running;
-	int             fd;	/* For epoll() */
-	LIST_HEAD(,uev) watchers;
-} uev_ctx_t;
-
-/* I/O event watcher */
 typedef struct uev {
-	LIST_ENTRY(uev) link;	/* For queue.h linked list */
+	/* Private data for libuEv internal engine */
+	uev_private_t   type;
 
-	/* Common to all watchers */
+	/* Public data for users to reference  */
-	uev_ctx_t      *ctx;
-	uev_type_t      type;
-	int             active;
 	int             fd;
-	int             events;
+	uev_ctx_t      *ctx;
-
-	/* Watcher callback with optional argument */
-	void          (*cb)(struct uev *, struct uev *, void *);
-	void           *arg;
-
-	/* Timer watchers, time in milliseconds */
-	int             timeout;
-	int             period;
-
-	/* Signal watchers */
-	int             signo;
 } uev_t;
 
 /* Generic callback for watchers */
-typedef void (uev_cb_t)(uev_ctx_t *ctx, uev_t *w, void *arg, int events);
+typedef void (uev_cb_t)(uev_t *w, void *arg, int events);
-
-/* Private methods, 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);
-int uev_watcher_start  (uev_t *w);
-int uev_watcher_stop   (uev_t *w);
 
 /* Public interface */
 int uev_init           (uev_ctx_t *ctx);
@@ -97,14 +59,17 @@ int uev_run            (uev_ctx_t *ctx, int flags);
 
 int uev_io_init        (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int fd, int events);
 int uev_io_set         (uev_t *w, int fd, int events);
+int uev_io_start       (uev_t *w);
 int uev_io_stop        (uev_t *w);
 
 int uev_timer_init     (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int timeout, int period);
 int uev_timer_set      (uev_t *w, int timeout, int period);
+int uev_timer_start    (uev_t *w);
 int uev_timer_stop     (uev_t *w);
 
 int uev_signal_init    (uev_ctx_t *ctx, uev_t *w, uev_cb_t *cb, void *arg, int signo);
 int uev_signal_set     (uev_t *w, int signo);
+int uev_signal_start   (uev_t *w);
 int uev_signal_stop    (uev_t *w);
 
 #endif /* LIBUEV_UEV_H_ */