[ViewVC] Diff of: cvs/libev/ev.3

Comparing libev/ev.3 (file contents):
Revision 1.97 by root, Mon Feb 18 03:20:28 2013 UTC vs.
Revision 1.120 by root, Wed Jan 22 13:33:44 2020 UTC

-.\" Automatically generated by Pod::Man 2.25 (Pod::Simple 3.16)
+.\" Automatically generated by Pod::Man 4.11 (Pod::Simple 3.35)
 .\"
 .\" Standard preamble:
 .\" ========================================================================
 .de Sp \" Vertical space (when we can't use .PP)
 .if t .sp .5v
 .el\{\
 .    ds -- \|\(em\|
 .    ds PI \(*p
 .    ds L" ``
 .    ds R" ''
+.    ds C`
+.    ds C'
 'br\}
 .\"
 .\" Escape single quotes in literal strings from groff's Unicode transform.
 .ie \n(.g .ds Aq \(aq
 .el       .ds Aq '
 .\"
-.\" If the F register is turned on, we'll generate index entries on stderr for
+.\" If the F register is >0, we'll generate index entries on stderr for
 .\" titles (.TH), headers (.SH), subsections (.SS), items (.Ip), and index
 .\" entries marked with X<> in POD.  Of course, you'll have to process the
 .\" output yourself in some meaningful fashion.
-.ie \nF \{\
+.\"
+.\" Avoid warning from groff about undefined register 'F'.
-.    de IX
+.de IX
-.    tm Index:\\$1\t\\n%\t"\\$2"
 ..
-.    nr % 0
+.nr rF 0
-.    rr F
+.if \n(.g .if rF .nr rF 1
+.if (\n(rF:(\n(.g==0)) \{\
+.    if \nF \{\
+.        de IX
+.        tm Index:\\$1\t\\n%\t"\\$2"
+..
+.        if !\nF==2 \{\
+.            nr % 0
+.            nr F 2
+.        \}
+.    \}
 .\}
-.el \{\
+.rr rF
-.    de IX
-..
-.\}
 .\"
 .\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
 .\" Fear.  Run.  Save yourself.  No user-serviceable parts.
 .    \" fudge factors for nroff and troff
 .if n \{\
 .\}
 .rm #[ #] #H #V #F C
 .\" ========================================================================
 .\"
 .IX Title "LIBEV 3"
-.TH LIBEV 3 "2013-02-18" "libev-4.11" "libev - high performance full featured event loop"
+.TH LIBEV 3 "2020-01-22" "libev-4.31" "libev - high performance full featured event loop"
 .\" For nroff, turn off justification.  Always turn off hyphenation; it makes
 .\" way too many mistakes in technical documents.
 .if n .ad l
 .nh
 .SH "NAME"
 .SH "SYNOPSIS"
 .IX Header "SYNOPSIS"
 .Vb 1
 \&   #include <ev.h>
 .Ve
-.SS "\s-1EXAMPLE\s0 \s-1PROGRAM\s0"
+.SS "\s-1EXAMPLE PROGRAM\s0"
 .IX Subsection "EXAMPLE PROGRAM"
 .Vb 2
 \&   // a single header file is required
 \&   #include <ev.h>
 \&
 throughout this document.
 .SH "WHAT TO READ WHEN IN A HURRY"
 .IX Header "WHAT TO READ WHEN IN A HURRY"
 This manual tries to be very detailed, but unfortunately, this also makes
 it very long. If you just want to know the basics of libev, I suggest
-reading \*(L"\s-1ANATOMY\s0 \s-1OF\s0 A \s-1WATCHER\s0\*(R", then the \*(L"\s-1EXAMPLE\s0 \s-1PROGRAM\s0\*(R" above and
+reading \*(L"\s-1ANATOMY OF A WATCHER\*(R"\s0, then the \*(L"\s-1EXAMPLE PROGRAM\*(R"\s0 above and
-look up the missing functions in \*(L"\s-1GLOBAL\s0 \s-1FUNCTIONS\s0\*(R" and the \f(CW\*(C`ev_io\*(C'\fR and
+look up the missing functions in \*(L"\s-1GLOBAL FUNCTIONS\*(R"\s0 and the \f(CW\*(C`ev_io\*(C'\fR and
-\&\f(CW\*(C`ev_timer\*(C'\fR sections in \*(L"\s-1WATCHER\s0 \s-1TYPES\s0\*(R".
+\&\f(CW\*(C`ev_timer\*(C'\fR sections in \*(L"\s-1WATCHER TYPES\*(R"\s0.
 .SH "ABOUT LIBEV"
 .IX Header "ABOUT LIBEV"
 Libev is an event loop: you register interest in certain events (such as a
 file descriptor being readable or a timeout occurring), and it will manage
 these event sources and provide your program with events.
 watchers\fR, which are relatively small C structures you initialise with the
 details of the event, and then hand it over to libev by \fIstarting\fR the
 watcher.
 .SS "\s-1FEATURES\s0"
 .IX Subsection "FEATURES"
-Libev supports \f(CW\*(C`select\*(C'\fR, \f(CW\*(C`poll\*(C'\fR, the Linux-specific \f(CW\*(C`epoll\*(C'\fR, the
+Libev supports \f(CW\*(C`select\*(C'\fR, \f(CW\*(C`poll\*(C'\fR, the Linux-specific aio and \f(CW\*(C`epoll\*(C'\fR
-BSD-specific \f(CW\*(C`kqueue\*(C'\fR and the Solaris-specific event port mechanisms
+interfaces, the BSD-specific \f(CW\*(C`kqueue\*(C'\fR and the Solaris-specific event port
-for file descriptor events (\f(CW\*(C`ev_io\*(C'\fR), the Linux \f(CW\*(C`inotify\*(C'\fR interface
+mechanisms for file descriptor events (\f(CW\*(C`ev_io\*(C'\fR), the Linux \f(CW\*(C`inotify\*(C'\fR
-(for \f(CW\*(C`ev_stat\*(C'\fR), Linux eventfd/signalfd (for faster and cleaner
+interface (for \f(CW\*(C`ev_stat\*(C'\fR), Linux eventfd/signalfd (for faster and cleaner
 inter-thread wakeup (\f(CW\*(C`ev_async\*(C'\fR)/signal handling (\f(CW\*(C`ev_signal\*(C'\fR)) relative
 timers (\f(CW\*(C`ev_timer\*(C'\fR), absolute timers with customised rescheduling
 (\f(CW\*(C`ev_periodic\*(C'\fR), synchronous signals (\f(CW\*(C`ev_signal\*(C'\fR), process status
 change events (\f(CW\*(C`ev_child\*(C'\fR), and event watchers dealing with the event
 loop mechanism itself (\f(CW\*(C`ev_idle\*(C'\fR, \f(CW\*(C`ev_embed\*(C'\fR, \f(CW\*(C`ev_prepare\*(C'\fR and
 more info about various configuration options please have a look at
 \&\fB\s-1EMBED\s0\fR section in this manual. If libev was configured without support
 for multiple event loops, then all functions taking an initial argument of
 name \f(CW\*(C`loop\*(C'\fR (which is always of type \f(CW\*(C`struct ev_loop *\*(C'\fR) will not have
 this argument.
-.SS "\s-1TIME\s0 \s-1REPRESENTATION\s0"
+.SS "\s-1TIME REPRESENTATION\s0"
 .IX Subsection "TIME REPRESENTATION"
 Libev represents time as a single floating point number, representing
 the (fractional) number of seconds since the (\s-1POSIX\s0) epoch (in practice
 somewhere near the beginning of 1970, details are complicated, don't
 ask). This type is called \f(CW\*(C`ev_tstamp\*(C'\fR, which is what you should use
 When libev detects a usage error such as a negative timer interval, then
 it will print a diagnostic message and abort (via the \f(CW\*(C`assert\*(C'\fR mechanism,
 so \f(CW\*(C`NDEBUG\*(C'\fR will disable this checking): these are programming errors in
 the libev caller and need to be fixed there.
 .PP
+Via the \f(CW\*(C`EV_FREQUENT\*(C'\fR macro you can compile in and/or enable extensive
+consistency checking code inside libev that can be used to check for
+internal inconsistencies, suually caused by application bugs.
+.PP
-Libev also has a few internal error-checking \f(CW\*(C`assert\*(C'\fRions, and also has
+Libev also has a few internal error-checking \f(CW\*(C`assert\*(C'\fRions. These do not
-extensive consistency checking code. These do not trigger under normal
-circumstances, as they indicate either a bug in libev or worse.
+trigger under normal circumstances, as they indicate either a bug in libev
+or worse.
 .SH "GLOBAL FUNCTIONS"
 .IX Header "GLOBAL FUNCTIONS"
 These functions can be called anytime, even before initialising the
 library in any way.
 .IP "ev_tstamp ev_time ()" 4
 .Sp
 You could override this function in high-availability programs to, say,
 free some memory if it cannot allocate memory, to use a special allocator,
 or even to sleep a while and retry until some memory is available.
 .Sp
+Example: The following is the \f(CW\*(C`realloc\*(C'\fR function that libev itself uses
+which should work with \f(CW\*(C`realloc\*(C'\fR and \f(CW\*(C`free\*(C'\fR functions of all kinds and
+is probably a good basis for your own implementation.
+.Sp
+.Vb 5
+\&   static void *
+\&   ev_realloc_emul (void *ptr, long size) EV_NOEXCEPT
+\&   {
+\&     if (size)
+\&       return realloc (ptr, size);
+\&
+\&     free (ptr);
+\&     return 0;
+\&   }
+.Ve
+.Sp
 Example: Replace the libev allocator with one that waits a bit and then
-retries (example requires a standards-compliant \f(CW\*(C`realloc\*(C'\fR).
+retries.
 .Sp
-.Vb 6
+.Vb 8
 \&   static void *
 \&   persistent_realloc (void *ptr, size_t size)
 \&   {
+\&     if (!size)
+\&       {
+\&         free (ptr);
+\&         return 0;
+\&       }
+\&
 \&     for (;;)
 \&       {
 \&         void *newptr = realloc (ptr, size);
 \&
 \&         if (newptr)
 .IX Item "EVFLAG_NOENV"
 If this flag bit is or'ed into the flag value (or the program runs setuid
 or setgid) then libev will \fInot\fR look at the environment variable
 \&\f(CW\*(C`LIBEV_FLAGS\*(C'\fR. Otherwise (the default), this environment variable will
 override the flags completely if it is found in the environment. This is
-useful to try out specific backends to test their performance, or to work
+useful to try out specific backends to test their performance, to work
-around bugs.
+around bugs, or to make libev threadsafe (accessing environment variables
+cannot be done in a threadsafe way, but usually it works if no other
+thread modifies them).
 .ie n .IP """EVFLAG_FORKCHECK""" 4
 .el .IP "\f(CWEVFLAG_FORKCHECK\fR" 4
 .IX Item "EVFLAG_FORKCHECK"
 Instead of calling \f(CW\*(C`ev_loop_fork\*(C'\fR manually after a fork, you can also
 make libev check for a fork in each iteration by enabling this flag.
 .Sp
 This works by calling \f(CW\*(C`getpid ()\*(C'\fR on every iteration of the loop,
 and thus this might slow down your event loop if you do a lot of loop
 iterations and little real work, but is usually not noticeable (on my
-GNU/Linux system for example, \f(CW\*(C`getpid\*(C'\fR is actually a simple 5\-insn sequence
+GNU/Linux system for example, \f(CW\*(C`getpid\*(C'\fR is actually a simple 5\-insn
-without a system call and thus \fIvery\fR fast, but my GNU/Linux system also has
+sequence without a system call and thus \fIvery\fR fast, but my GNU/Linux
-\&\f(CW\*(C`pthread_atfork\*(C'\fR which is even faster).
+system also has \f(CW\*(C`pthread_atfork\*(C'\fR which is even faster). (Update: glibc
+versions 2.25 apparently removed the \f(CW\*(C`getpid\*(C'\fR optimisation again).
 .Sp
 The big advantage of this flag is that you can forget about fork (and
-forget about forgetting to tell libev about forking) when you use this
+forget about forgetting to tell libev about forking, although you still
-flag.
+have to ignore \f(CW\*(C`SIGPIPE\*(C'\fR) when you use this flag.
 .Sp
 This flag setting cannot be overridden or specified in the \f(CW\*(C`LIBEV_FLAGS\*(C'\fR
 environment variable.
 .ie n .IP """EVFLAG_NOINOTIFY""" 4
 .el .IP "\f(CWEVFLAG_NOINOTIFY\fR" 4
 want to handle signals only in specific threads and want to avoid libev
 unblocking the signals.
 .Sp
 It's also required by \s-1POSIX\s0 in a threaded program, as libev calls
 \&\f(CW\*(C`sigprocmask\*(C'\fR, whose behaviour is officially unspecified.
+.ie n .IP """EVFLAG_NOTIMERFD""" 4
+.el .IP "\f(CWEVFLAG_NOTIMERFD\fR" 4
+.IX Item "EVFLAG_NOTIMERFD"
+When this flag is specified, the libev will avoid using a \f(CW\*(C`timerfd\*(C'\fR to
+detect time jumps. It will still be able to detect time jumps, but takes
+longer and has a lower accuracy in doing so, but saves a file descriptor
+per loop.
 .Sp
-This flag's behaviour will become the default in future versions of libev.
+The current implementation only tries to use a \f(CW\*(C`timerfd\*(C'\fR when the first
+\&\f(CW\*(C`ev_periodic\*(C'\fR watcher is started and falls back on other methods if it
+cannot be created, but this behaviour might change in the future.
 .ie n .IP """EVBACKEND_SELECT""  (value 1, portable select backend)" 4
 .el .IP "\f(CWEVBACKEND_SELECT\fR  (value 1, portable select backend)" 4
-.IX Item "EVBACKEND_SELECT  (value 1, portable select backend)"
+.IX Item "EVBACKEND_SELECT (value 1, portable select backend)"
-This is your standard \fIselect\fR\|(2) backend. Not \fIcompletely\fR standard, as
+This is your standard \fBselect\fR\|(2) backend. Not \fIcompletely\fR standard, as
 libev tries to roll its own fd_set with no limits on the number of fds,
 but if that fails, expect a fairly low limit on the number of fds when
 using this backend. It doesn't scale too well (O(highest_fd)), but its
 usually the fastest backend for a low number of (low-numbered :) fds.
 .Sp
 This backend maps \f(CW\*(C`EV_READ\*(C'\fR to the \f(CW\*(C`readfds\*(C'\fR set and \f(CW\*(C`EV_WRITE\*(C'\fR to the
 \&\f(CW\*(C`writefds\*(C'\fR set (and to work around Microsoft Windows bugs, also onto the
 \&\f(CW\*(C`exceptfds\*(C'\fR set on that platform).
 .ie n .IP """EVBACKEND_POLL""    (value 2, poll backend, available everywhere except on windows)" 4
 .el .IP "\f(CWEVBACKEND_POLL\fR    (value 2, poll backend, available everywhere except on windows)" 4
-.IX Item "EVBACKEND_POLL    (value 2, poll backend, available everywhere except on windows)"
+.IX Item "EVBACKEND_POLL (value 2, poll backend, available everywhere except on windows)"
-And this is your standard \fIpoll\fR\|(2) backend. It's more complicated
+And this is your standard \fBpoll\fR\|(2) backend. It's more complicated
 than select, but handles sparse fds better and has no artificial
 limit on the number of fds you can use (except it will slow down
 considerably with a lot of inactive fds). It scales similarly to select,
 i.e. O(total_fds). See the entry for \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR, above, for
 performance tips.
 .Sp
 This backend maps \f(CW\*(C`EV_READ\*(C'\fR to \f(CW\*(C`POLLIN | POLLERR | POLLHUP\*(C'\fR, and
 \&\f(CW\*(C`EV_WRITE\*(C'\fR to \f(CW\*(C`POLLOUT | POLLERR | POLLHUP\*(C'\fR.
 .ie n .IP """EVBACKEND_EPOLL""   (value 4, Linux)" 4
 .el .IP "\f(CWEVBACKEND_EPOLL\fR   (value 4, Linux)" 4
-.IX Item "EVBACKEND_EPOLL   (value 4, Linux)"
+.IX Item "EVBACKEND_EPOLL (value 4, Linux)"
-Use the linux-specific \fIepoll\fR\|(7) interface (for both pre\- and post\-2.6.9
+Use the Linux-specific \fBepoll\fR\|(7) interface (for both pre\- and post\-2.6.9
 kernels).
 .Sp
 For few fds, this backend is a bit little slower than poll and select, but
 it scales phenomenally better. While poll and select usually scale like
 O(total_fds) where total_fds is the total number of fds (or the highest
 All this means that, in practice, \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR can be as fast or
 faster than epoll for maybe up to a hundred file descriptors, depending on
 the usage. So sad.
 .Sp
 While nominally embeddable in other event loops, this feature is broken in
-all kernel versions tested so far.
+a lot of kernel revisions, but probably(!) works in current versions.
+.Sp
+This backend maps \f(CW\*(C`EV_READ\*(C'\fR and \f(CW\*(C`EV_WRITE\*(C'\fR in the same way as
+\&\f(CW\*(C`EVBACKEND_POLL\*(C'\fR.
+.ie n .IP """EVBACKEND_LINUXAIO""   (value 64, Linux)" 4
+.el .IP "\f(CWEVBACKEND_LINUXAIO\fR   (value 64, Linux)" 4
+.IX Item "EVBACKEND_LINUXAIO (value 64, Linux)"
+Use the Linux-specific Linux \s-1AIO\s0 (\fInot\fR \f(CWaio(7)\fR but \f(CWio_submit(2)\fR) event interface available in post\-4.18 kernels (but libev
+only tries to use it in 4.19+).
+.Sp
+This is another Linux train wreck of an event interface.
+.Sp
+If this backend works for you (as of this writing, it was very
+experimental), it is the best event interface available on Linux and might
+be well worth enabling it \- if it isn't available in your kernel this will
+be detected and this backend will be skipped.
+.Sp
+This backend can batch oneshot requests and supports a user-space ring
+buffer to receive events. It also doesn't suffer from most of the design
+problems of epoll (such as not being able to remove event sources from
+the epoll set), and generally sounds too good to be true. Because, this
+being the Linux kernel, of course it suffers from a whole new set of
+limitations, forcing you to fall back to epoll, inheriting all its design
+issues.
+.Sp
+For one, it is not easily embeddable (but probably could be done using
+an event fd at some extra overhead). It also is subject to a system wide
+limit that can be configured in \fI/proc/sys/fs/aio\-max\-nr\fR. If no \s-1AIO\s0
+requests are left, this backend will be skipped during initialisation, and
+will switch to epoll when the loop is active.
+.Sp
+Most problematic in practice, however, is that not all file descriptors
+work with it. For example, in Linux 5.1, \s-1TCP\s0 sockets, pipes, event fds,
+files, \fI/dev/null\fR and many others are supported, but ttys do not work
+properly (a known bug that the kernel developers don't care about, see
+<https://lore.kernel.org/patchwork/patch/1047453/>), so this is not
+(yet?) a generic event polling interface.
+.Sp
+Overall, it seems the Linux developers just don't want it to have a
+generic event handling mechanism other than \f(CW\*(C`select\*(C'\fR or \f(CW\*(C`poll\*(C'\fR.
+.Sp
+To work around all these problem, the current version of libev uses its
+epoll backend as a fallback for file descriptor types that do not work. Or
+falls back completely to epoll if the kernel acts up.
 .Sp
 This backend maps \f(CW\*(C`EV_READ\*(C'\fR and \f(CW\*(C`EV_WRITE\*(C'\fR in the same way as
 \&\f(CW\*(C`EVBACKEND_POLL\*(C'\fR.
 .ie n .IP """EVBACKEND_KQUEUE""  (value 8, most \s-1BSD\s0 clones)" 4
 .el .IP "\f(CWEVBACKEND_KQUEUE\fR  (value 8, most \s-1BSD\s0 clones)" 4
-.IX Item "EVBACKEND_KQUEUE  (value 8, most BSD clones)"
+.IX Item "EVBACKEND_KQUEUE (value 8, most BSD clones)"
-Kqueue deserves special mention, as at the time of this writing, it
+Kqueue deserves special mention, as at the time this backend was
-was broken on all BSDs except NetBSD (usually it doesn't work reliably
+implemented, it was broken on all BSDs except NetBSD (usually it doesn't
-with anything but sockets and pipes, except on Darwin, where of course
+work reliably with anything but sockets and pipes, except on Darwin,
-it's completely useless). Unlike epoll, however, whose brokenness
+where of course it's completely useless). Unlike epoll, however, whose
-is by design, these kqueue bugs can (and eventually will) be fixed
+brokenness is by design, these kqueue bugs can be (and mostly have been)
-without \s-1API\s0 changes to existing programs. For this reason it's not being
+fixed without \s-1API\s0 changes to existing programs. For this reason it's not
-\&\*(L"auto-detected\*(R" unless you explicitly specify it in the flags (i.e. using
+being \*(L"auto-detected\*(R" on all platforms unless you explicitly specify it
-\&\f(CW\*(C`EVBACKEND_KQUEUE\*(C'\fR) or libev was compiled on a known-to-be-good (\-enough)
+in the flags (i.e. using \f(CW\*(C`EVBACKEND_KQUEUE\*(C'\fR) or libev was compiled on a
-system like NetBSD.
+known-to-be-good (\-enough) system like NetBSD.
 .Sp
 You still can embed kqueue into a normal poll or select backend and use it
 only for sockets (after having made sure that sockets work with kqueue on
 the target platform). See \f(CW\*(C`ev_embed\*(C'\fR watchers for more info.
 .Sp
 It scales in the same way as the epoll backend, but the interface to the
 kernel is more efficient (which says nothing about its actual speed, of
 course). While stopping, setting and starting an I/O watcher does never
 cause an extra system call as with \f(CW\*(C`EVBACKEND_EPOLL\*(C'\fR, it still adds up to
 two event changes per incident. Support for \f(CW\*(C`fork ()\*(C'\fR is very bad (you
-might have to leak fd's on fork, but it's more sane than epoll) and it
+might have to leak fds on fork, but it's more sane than epoll) and it
 drops fds silently in similarly hard-to-detect cases.
 .Sp
 This backend usually performs well under most conditions.
 .Sp
 While nominally embeddable in other event loops, this doesn't work
 everywhere, so you might need to test for this. And since it is broken
 almost everywhere, you should only use it when you have a lot of sockets
 (for which it usually works), by embedding it into another event loop
 (e.g. \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or \f(CW\*(C`EVBACKEND_POLL\*(C'\fR (but \f(CW\*(C`poll\*(C'\fR is of course
-also broken on \s-1OS\s0 X)) and, did I mention it, using it only for sockets.
+also broken on \s-1OS X\s0)) and, did I mention it, using it only for sockets.
 .Sp
 This backend maps \f(CW\*(C`EV_READ\*(C'\fR into an \f(CW\*(C`EVFILT_READ\*(C'\fR kevent with
 \&\f(CW\*(C`NOTE_EOF\*(C'\fR, and \f(CW\*(C`EV_WRITE\*(C'\fR into an \f(CW\*(C`EVFILT_WRITE\*(C'\fR kevent with
 \&\f(CW\*(C`NOTE_EOF\*(C'\fR.
 .ie n .IP """EVBACKEND_DEVPOLL"" (value 16, Solaris 8)" 4
 implementation). According to reports, \f(CW\*(C`/dev/poll\*(C'\fR only supports sockets
 and is not embeddable, which would limit the usefulness of this backend
 immensely.
 .ie n .IP """EVBACKEND_PORT""    (value 32, Solaris 10)" 4
 .el .IP "\f(CWEVBACKEND_PORT\fR    (value 32, Solaris 10)" 4
-.IX Item "EVBACKEND_PORT    (value 32, Solaris 10)"
+.IX Item "EVBACKEND_PORT (value 32, Solaris 10)"
 This uses the Solaris 10 event port mechanism. As with everything on Solaris,
 it's really slow, but it still scales very well (O(active_fds)).
 .Sp
 While this backend scales well, it requires one system call per active
 file descriptor per loop iteration. For small and medium numbers of file
 used if available.
 .Sp
 .Vb 1
 \&   struct ev_loop *loop = ev_loop_new (ev_recommended_backends () | EVBACKEND_KQUEUE);
 .Ve
+.Sp
+Example: Similarly, on linux, you mgiht want to take advantage of the
+linux aio backend if possible, but fall back to something else if that
+isn't available.
+.Sp
+.Vb 1
+\&   struct ev_loop *loop = ev_loop_new (ev_recommended_backends () | EVBACKEND_LINUXAIO);
+.Ve
 .RE
 .IP "ev_loop_destroy (loop)" 4
 .IX Item "ev_loop_destroy (loop)"
 Destroys an event loop object (frees all memory and kernel state
 etc.). None of the active event watchers will be stopped in the normal
 except in the rare occasion where you really need to free its resources.
 If you need dynamically allocated loops it is better to use \f(CW\*(C`ev_loop_new\*(C'\fR
 and \f(CW\*(C`ev_loop_destroy\*(C'\fR.
 .IP "ev_loop_fork (loop)" 4
 .IX Item "ev_loop_fork (loop)"
-This function sets a flag that causes subsequent \f(CW\*(C`ev_run\*(C'\fR iterations to
+This function sets a flag that causes subsequent \f(CW\*(C`ev_run\*(C'\fR iterations
-reinitialise the kernel state for backends that have one. Despite the
+to reinitialise the kernel state for backends that have one. Despite
-name, you can call it anytime, but it makes most sense after forking, in
+the name, you can call it anytime you are allowed to start or stop
-the child process. You \fImust\fR call it (or use \f(CW\*(C`EVFLAG_FORKCHECK\*(C'\fR) in the
+watchers (except inside an \f(CW\*(C`ev_prepare\*(C'\fR callback), but it makes most
-child before resuming or calling \f(CW\*(C`ev_run\*(C'\fR.
+sense after forking, in the child process. You \fImust\fR call it (or use
+\&\f(CW\*(C`EVFLAG_FORKCHECK\*(C'\fR) in the child before resuming or calling \f(CW\*(C`ev_run\*(C'\fR.
 .Sp
+In addition, if you want to reuse a loop (via this function or
+\&\f(CW\*(C`EVFLAG_FORKCHECK\*(C'\fR), you \fIalso\fR have to ignore \f(CW\*(C`SIGPIPE\*(C'\fR.
+.Sp
 Again, you \fIhave\fR to call it on \fIany\fR loop that you want to re-use after
 a fork, \fIeven if you do not plan to use the loop in the parent\fR. This is
 because some kernel interfaces *cough* \fIkqueue\fR *cough* do funny things
 during fork.
 .Sp
 On the other hand, you only need to call this function in the child
 with a watcher-specific start function (\f(CW\*(C`ev_TYPE_start (loop, watcher
 *)\*(C'\fR), and you can stop watching for events at any time by calling the
 corresponding stop function (\f(CW\*(C`ev_TYPE_stop (loop, watcher *)\*(C'\fR.
 .PP
 As long as your watcher is active (has been started but not stopped) you
-must not touch the values stored in it. Most specifically you must never
+must not touch the values stored in it except when explicitly documented
-reinitialise it or call its \f(CW\*(C`ev_TYPE_set\*(C'\fR macro.
+otherwise. Most specifically you must never reinitialise it or call its
+\&\f(CW\*(C`ev_TYPE_set\*(C'\fR macro.
 .PP
 Each and every callback receives the event loop pointer as first, the
 registered watcher structure as second, and a bitset of received events as
 third argument.
 .PP
 bug in your program.
 .Sp
 Libev will usually signal a few \*(L"dummy\*(R" events together with an error, for
 example it might indicate that a fd is readable or writable, and if your
 callbacks is well-written it can just attempt the operation and cope with
-the error from \fIread()\fR or \fIwrite()\fR. This will not work in multi-threaded
+the error from \fBread()\fR or \fBwrite()\fR. This will not work in multi-threaded
 programs, though, as the fd could already be closed and reused for another
 thing, so beware.
-.SS "\s-1GENERIC\s0 \s-1WATCHER\s0 \s-1FUNCTIONS\s0"
+.SS "\s-1GENERIC WATCHER FUNCTIONS\s0"
 .IX Subsection "GENERIC WATCHER FUNCTIONS"
 .ie n .IP """ev_init"" (ev_TYPE *watcher, callback)" 4
 .el .IP "\f(CWev_init\fR (ev_TYPE *watcher, callback)" 4
 .IX Item "ev_init (ev_TYPE *watcher, callback)"
 This macro initialises the generic portion of a watcher. The contents
 or might not have been clamped to the valid range.
 .Sp
 The default priority used by watchers when no priority has been set is
 always \f(CW0\fR, which is supposed to not be too high and not be too low :).
 .Sp
-See \*(L"\s-1WATCHER\s0 \s-1PRIORITY\s0 \s-1MODELS\s0\*(R", below, for a more thorough treatment of
+See \*(L"\s-1WATCHER PRIORITY MODELS\*(R"\s0, below, for a more thorough treatment of
 priorities.
 .IP "ev_invoke (loop, ev_TYPE *watcher, int revents)" 4
 .IX Item "ev_invoke (loop, ev_TYPE *watcher, int revents)"
 Invoke the \f(CW\*(C`watcher\*(C'\fR with the given \f(CW\*(C`loop\*(C'\fR and \f(CW\*(C`revents\*(C'\fR. Neither
 \&\f(CW\*(C`loop\*(C'\fR nor \f(CW\*(C`revents\*(C'\fR need to be valid as long as the watcher callback
 not started in the first place.
 .Sp
 See also \f(CW\*(C`ev_feed_fd_event\*(C'\fR and \f(CW\*(C`ev_feed_signal_event\*(C'\fR for related
 functions that do not need a watcher.
 .PP
-See also the \*(L"\s-1ASSOCIATING\s0 \s-1CUSTOM\s0 \s-1DATA\s0 \s-1WITH\s0 A \s-1WATCHER\s0\*(R" and \*(L"\s-1BUILDING\s0 \s-1YOUR\s0
+See also the \*(L"\s-1ASSOCIATING CUSTOM DATA WITH A WATCHER\*(R"\s0 and \*(L"\s-1BUILDING YOUR
-\&\s-1OWN\s0 \s-1COMPOSITE\s0 \s-1WATCHERS\s0\*(R" idioms.
+OWN COMPOSITE WATCHERS\*(R"\s0 idioms.
-.SS "\s-1WATCHER\s0 \s-1STATES\s0"
+.SS "\s-1WATCHER STATES\s0"
 .IX Subsection "WATCHER STATES"
 There are various watcher states mentioned throughout this manual \-
 active, pending and so on. In this section these states and the rules to
 transition between them will be described in more detail \- and while these
 rules might look complicated, they usually do \*(L"the right thing\*(R".
 .Sp
 While stopped (and not pending) the watcher is essentially in the
 initialised state, that is, it can be reused, moved, modified in any way
 you wish (but when you trash the memory block, you need to \f(CW\*(C`ev_TYPE_init\*(C'\fR
 it again).
-.SS "\s-1WATCHER\s0 \s-1PRIORITY\s0 \s-1MODELS\s0"
+.SS "\s-1WATCHER PRIORITY MODELS\s0"
 .IX Subsection "WATCHER PRIORITY MODELS"
 Many event loops support \fIwatcher priorities\fR, which are usually small
 integers that influence the ordering of event callback invocation
 between watchers in some way, all else being equal.
 .PP
-In libev, Watcher priorities can be set using \f(CW\*(C`ev_set_priority\*(C'\fR. See its
+In libev, watcher priorities can be set using \f(CW\*(C`ev_set_priority\*(C'\fR. See its
 description for the more technical details such as the actual priority
 range.
 .PP
 There are two common ways how these these priorities are being interpreted
 by event loops:
 .IX Header "WATCHER TYPES"
 This section describes each watcher in detail, but will not repeat
 information given in the last section. Any initialisation/set macros,
 functions and members specific to the watcher type are explained.
 .PP
-Members are additionally marked with either \fI[read\-only]\fR, meaning that,
+Most members are additionally marked with either \fI[read\-only]\fR, meaning
-while the watcher is active, you can look at the member and expect some
+that, while the watcher is active, you can look at the member and expect
-sensible content, but you must not modify it (you can modify it while the
+some sensible content, but you must not modify it (you can modify it while
-watcher is stopped to your hearts content), or \fI[read\-write]\fR, which
+the watcher is stopped to your hearts content), or \fI[read\-write]\fR, which
 means you can expect it to have some sensible content while the watcher
 is active, but you can also modify it. Modifying it may not do something
 sensible or take immediate effect (or do anything at all), but libev will
 not crash or malfunction in any way.
+.PP
+In any case, the documentation for each member will explain what the
+effects are, and if there are any additional access restrictions.
 .ie n .SS """ev_io"" \- is this file descriptor readable or writable?"
 .el .SS "\f(CWev_io\fP \- is this file descriptor readable or writable?"
 .IX Subsection "ev_io - is this file descriptor readable or writable?"
 I/O watchers check whether a file descriptor is readable or writable
 in each iteration of the event loop, or, more precisely, when reading
 But really, best use non-blocking mode.
 .PP
 \fIThe special problem of disappearing file descriptors\fR
 .IX Subsection "The special problem of disappearing file descriptors"
 .PP
-Some backends (e.g. kqueue, epoll) need to be told about closing a file
+Some backends (e.g. kqueue, epoll, linuxaio) need to be told about closing
-descriptor (either due to calling \f(CW\*(C`close\*(C'\fR explicitly or any other means,
+a file descriptor (either due to calling \f(CW\*(C`close\*(C'\fR explicitly or any other
-such as \f(CW\*(C`dup2\*(C'\fR). The reason is that you register interest in some file
+means, such as \f(CW\*(C`dup2\*(C'\fR). The reason is that you register interest in some
-descriptor, but when it goes away, the operating system will silently drop
+file descriptor, but when it goes away, the operating system will silently
-this interest. If another file descriptor with the same number then is
+drop this interest. If another file descriptor with the same number then
-registered with libev, there is no efficient way to see that this is, in
+is registered with libev, there is no efficient way to see that this is,
-fact, a different file descriptor.
+in fact, a different file descriptor.
 .PP
 To avoid having to explicitly tell libev about such cases, libev follows
 the following policy:  Each time \f(CW\*(C`ev_io_set\*(C'\fR is being called, libev
 will assume that this is potentially a new file descriptor, otherwise
 it is assumed that the file descriptor stays the same. That means that
 wish to read \- you would first have to request some data.
 .PP
 Since files are typically not-so-well supported by advanced notification
 mechanism, libev tries hard to emulate \s-1POSIX\s0 behaviour with respect
 to files, even though you should not use it. The reason for this is
-convenience: sometimes you want to watch \s-1STDIN\s0 or \s-1STDOUT\s0, which is
+convenience: sometimes you want to watch \s-1STDIN\s0 or \s-1STDOUT,\s0 which is
 usually a tty, often a pipe, but also sometimes files or special devices
 (for example, \f(CW\*(C`epoll\*(C'\fR on Linux works with \fI/dev/random\fR but not with
 \&\fI/dev/urandom\fR), and even though the file might better be served with
 asynchronous I/O instead of with non-blocking I/O, it is still useful when
 it \*(L"just works\*(R" instead of freezing.
 .PP
 So avoid file descriptors pointing to files when you know it (e.g. use
-libeio), but use them when it is convenient, e.g. for \s-1STDIN/STDOUT\s0, or
+libeio), but use them when it is convenient, e.g. for \s-1STDIN/STDOUT,\s0 or
 when you rarely read from a file instead of from a socket, and want to
 reuse the same code path.
 .PP
 \fIThe special problem of fork\fR
 .IX Subsection "The special problem of fork"
 .PP
-Some backends (epoll, kqueue) do not support \f(CW\*(C`fork ()\*(C'\fR at all or exhibit
+Some backends (epoll, kqueue, linuxaio, iouring) do not support \f(CW\*(C`fork ()\*(C'\fR
-useless behaviour. Libev fully supports fork, but needs to be told about
+at all or exhibit useless behaviour. Libev fully supports fork, but needs
-it in the child if you want to continue to use it in the child.
+to be told about it in the child if you want to continue to use it in the
+child.
 .PP
 To support fork in your child processes, you have to call \f(CW\*(C`ev_loop_fork
 ()\*(C'\fR after a fork in the child, enable \f(CW\*(C`EVFLAG_FORKCHECK\*(C'\fR, or resort to
 \&\f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or \f(CW\*(C`EVBACKEND_POLL\*(C'\fR.
 .PP
 \fIThe special problem of \s-1SIGPIPE\s0\fR
 .IX Subsection "The special problem of SIGPIPE"
 .PP
 While not really specific to libev, it is easy to forget about \f(CW\*(C`SIGPIPE\*(C'\fR:
 when writing to a pipe whose other end has been closed, your program gets
-sent a \s-1SIGPIPE\s0, which, by default, aborts your program. For most programs
+sent a \s-1SIGPIPE,\s0 which, by default, aborts your program. For most programs
 this is sensible behaviour, for daemons, this is usually undesirable.
 .PP
 So when you encounter spurious, unexplained daemon exits, make sure you
 ignore \s-1SIGPIPE\s0 (and maybe make sure you log the exit status of your daemon
 somewhere, as that would have given you a big clue).
 .PP
-\fIThe special problem of \fIaccept()\fIing when you can't\fR
+\fIThe special problem of \f(BIaccept()\fIing when you can't\fR
 .IX Subsection "The special problem of accept()ing when you can't"
 .PP
 Many implementations of the \s-1POSIX\s0 \f(CW\*(C`accept\*(C'\fR function (for example,
 found in post\-2004 Linux) have the peculiar behaviour of not removing a
 connection from the pending queue in all error cases.
 .PD 0
 .IP "ev_io_set (ev_io *, int fd, int events)" 4
 .IX Item "ev_io_set (ev_io *, int fd, int events)"
 .PD
 Configures an \f(CW\*(C`ev_io\*(C'\fR watcher. The \f(CW\*(C`fd\*(C'\fR is the file descriptor to
-receive events for and \f(CW\*(C`events\*(C'\fR is either \f(CW\*(C`EV_READ\*(C'\fR, \f(CW\*(C`EV_WRITE\*(C'\fR or
+receive events for and \f(CW\*(C`events\*(C'\fR is either \f(CW\*(C`EV_READ\*(C'\fR, \f(CW\*(C`EV_WRITE\*(C'\fR, both
-\&\f(CW\*(C`EV_READ | EV_WRITE\*(C'\fR, to express the desire to receive the given events.
+\&\f(CW\*(C`EV_READ | EV_WRITE\*(C'\fR or \f(CW0\fR, to express the desire to receive the given
+events.
+.Sp
+Note that setting the \f(CW\*(C`events\*(C'\fR to \f(CW0\fR and starting the watcher is
+supported, but not specially optimized \- if your program sometimes happens
+to generate this combination this is fine, but if it is easy to avoid
+starting an io watcher watching for no events you should do so.
+.IP "ev_io_modify (ev_io *, int events)" 4
+.IX Item "ev_io_modify (ev_io *, int events)"
+Similar to \f(CW\*(C`ev_io_set\*(C'\fR, but only changes the event mask. Using this might
+be faster with some backends, as libev can assume that the \f(CW\*(C`fd\*(C'\fR still
+refers to the same underlying file description, something it cannot do
+when using \f(CW\*(C`ev_io_set\*(C'\fR.
-.IP "int fd [read\-only]" 4
+.IP "int fd [no\-modify]" 4
-.IX Item "int fd [read-only]"
+.IX Item "int fd [no-modify]"
-The file descriptor being watched.
+The file descriptor being watched. While it can be read at any time, you
+must not modify this member even when the watcher is stopped \- always use
+\&\f(CW\*(C`ev_io_set\*(C'\fR for that.
-.IP "int events [read\-only]" 4
+.IP "int events [no\-modify]" 4
-.IX Item "int events [read-only]"
+.IX Item "int events [no-modify]"
-The events being watched.
+The set of events the fd is being watched for, among other flags. Remember
+that this is a bit set \- to test for \f(CW\*(C`EV_READ\*(C'\fR, use \f(CW\*(C`w\->events &
+EV_READ\*(C'\fR, and similarly for \f(CW\*(C`EV_WRITE\*(C'\fR.
+.Sp
+As with \f(CW\*(C`fd\*(C'\fR, you must not modify this member even when the watcher is
+stopped, always use \f(CW\*(C`ev_io_set\*(C'\fR or \f(CW\*(C`ev_io_modify\*(C'\fR for that.
 .PP
 \fIExamples\fR
 .IX Subsection "Examples"
 .PP
 Example: Call \f(CW\*(C`stdin_readable_cb\*(C'\fR when \s-1STDIN_FILENO\s0 has become, well
 .PP
 The relative timeouts are calculated relative to the \f(CW\*(C`ev_now ()\*(C'\fR
 time. This is usually the right thing as this timestamp refers to the time
 of the event triggering whatever timeout you are modifying/starting. If
 you suspect event processing to be delayed and you \fIneed\fR to base the
-timeout on the current time, use something like this to adjust for this:
+timeout on the current time, use something like the following to adjust
+for it:
 .PP
 .Vb 1
-\&   ev_timer_set (&timer, after + ev_now () \- ev_time (), 0.);
+\&   ev_timer_set (&timer, after + (ev_time () \- ev_now ()), 0.);
 .Ve
 .PP
 If the event loop is suspended for a long time, you can also force an
 update of the time returned by \f(CW\*(C`ev_now ()\*(C'\fR by calling \f(CW\*(C`ev_now_update
-()\*(C'\fR.
+()\*(C'\fR, although that will push the event time of all outstanding events
+further into the future.
 .PP
 \fIThe special problem of unsynchronised clocks\fR
 .IX Subsection "The special problem of unsynchronised clocks"
 .PP
 Modern systems have a variety of clocks \- libev itself uses the normal
 .IX Item "ev_timer_init (ev_timer *, callback, ev_tstamp after, ev_tstamp repeat)"
 .PD 0
 .IP "ev_timer_set (ev_timer *, ev_tstamp after, ev_tstamp repeat)" 4
 .IX Item "ev_timer_set (ev_timer *, ev_tstamp after, ev_tstamp repeat)"
 .PD
-Configure the timer to trigger after \f(CW\*(C`after\*(C'\fR seconds. If \f(CW\*(C`repeat\*(C'\fR
+Configure the timer to trigger after \f(CW\*(C`after\*(C'\fR seconds (fractional and
-is \f(CW0.\fR, then it will automatically be stopped once the timeout is
+negative values are supported). If \f(CW\*(C`repeat\*(C'\fR is \f(CW0.\fR, then it will
-reached. If it is positive, then the timer will automatically be
+automatically be stopped once the timeout is reached. If it is positive,
-configured to trigger again \f(CW\*(C`repeat\*(C'\fR seconds later, again, and again,
+then the timer will automatically be configured to trigger again \f(CW\*(C`repeat\*(C'\fR
-until stopped manually.
+seconds later, again, and again, until stopped manually.
 .Sp
 The timer itself will do a best-effort at avoiding drift, that is, if
 you configure a timer to trigger every 10 seconds, then it will normally
 trigger at exactly 10 second intervals. If, however, your program cannot
 keep up with the timer (because it takes longer than those 10 seconds to
 Periodic watchers are also timers of a kind, but they are very versatile
 (and unfortunately a bit complex).
 .PP
 Unlike \f(CW\*(C`ev_timer\*(C'\fR, periodic watchers are not based on real time (or
 relative time, the physical time that passes) but on wall clock time
-(absolute time, the thing you can read on your calender or clock). The
+(absolute time, the thing you can read on your calendar or clock). The
 difference is that wall clock time can run faster or slower than real
 time, and time jumps are not uncommon (e.g. when you adjust your
 wrist-watch).
 .PP
 You can tell a periodic watcher to trigger after some specific point
 \&\f(CW\*(C`ev_timer\*(C'\fR, which would still trigger roughly 10 seconds after starting
 it, as it uses a relative timeout).
 .PP
 \&\f(CW\*(C`ev_periodic\*(C'\fR watchers can also be used to implement vastly more complex
 timers, such as triggering an event on each \*(L"midnight, local time\*(R", or
-other complicated rules. This cannot be done with \f(CW\*(C`ev_timer\*(C'\fR watchers, as
+other complicated rules. This cannot easily be done with \f(CW\*(C`ev_timer\*(C'\fR
-those cannot react to time jumps.
+watchers, as those cannot react to time jumps.
 .PP
 As with timers, the callback is guaranteed to be invoked only when the
 point in time where it is supposed to trigger has passed. If multiple
 timers become ready during the same loop iteration then the ones with
 earlier time-out values are invoked before ones with later time-out values
 In this mode the values for \f(CW\*(C`interval\*(C'\fR and \f(CW\*(C`offset\*(C'\fR are both being
 ignored. Instead, each time the periodic watcher gets scheduled, the
 reschedule callback will be called with the watcher as first, and the
 current time as second argument.
 .Sp
-\&\s-1NOTE:\s0 \fIThis callback \s-1MUST\s0 \s-1NOT\s0 stop or destroy any periodic watcher, ever,
+\&\s-1NOTE:\s0 \fIThis callback \s-1MUST NOT\s0 stop or destroy any periodic watcher, ever,
 or make \s-1ANY\s0 other event loop modifications whatsoever, unless explicitly
 allowed by documentation here\fR.
 .Sp
 If you need to stop it, return \f(CW\*(C`now + 1e30\*(C'\fR (or so, fudge fudge) and stop
 it afterwards (e.g. by starting an \f(CW\*(C`ev_prepare\*(C'\fR watcher, which is the
 .Sp
 \&\s-1NOTE:\s0 \fIThis callback must always return a time that is higher than or
 equal to the passed \f(CI\*(C`now\*(C'\fI value\fR.
 .Sp
 This can be used to create very complex timers, such as a timer that
-triggers on \*(L"next midnight, local time\*(R". To do this, you would calculate the
+triggers on \*(L"next midnight, local time\*(R". To do this, you would calculate
-next midnight after \f(CW\*(C`now\*(C'\fR and return the timestamp value for this. How
+the next midnight after \f(CW\*(C`now\*(C'\fR and return the timestamp value for
-you do this is, again, up to you (but it is not trivial, which is the main
+this. Here is a (completely untested, no error checking) example on how to
-reason I omitted it as an example).
+do this:
+.Sp
+.Vb 1
+\&   #include <time.h>
+\&
+\&   static ev_tstamp
+\&   my_rescheduler (ev_periodic *w, ev_tstamp now)
+\&   {
+\&     time_t tnow = (time_t)now;
+\&     struct tm tm;
+\&     localtime_r (&tnow, &tm);
+\&
+\&     tm.tm_sec = tm.tm_min = tm.tm_hour = 0; // midnight current day
+\&     ++tm.tm_mday; // midnight next day
+\&
+\&     return mktime (&tm);
+\&   }
+.Ve
+.Sp
+Note: this code might run into trouble on days that have more then two
+midnights (beginning and end).
 .RE
 .RS 4
 .RE
 .IP "ev_periodic_again (loop, ev_periodic *)" 4
 .IX Item "ev_periodic_again (loop, ev_periodic *)"
 only within the same loop, i.e. you can watch for \f(CW\*(C`SIGINT\*(C'\fR in your
 default loop and for \f(CW\*(C`SIGIO\*(C'\fR in another loop, but you cannot watch for
 \&\f(CW\*(C`SIGINT\*(C'\fR in both the default loop and another loop at the same time. At
 the moment, \f(CW\*(C`SIGCHLD\*(C'\fR is permanently tied to the default loop.
 .PP
-When the first watcher gets started will libev actually register something
+Only after the first watcher for a signal is started will libev actually
-with the kernel (thus it coexists with your own signal handlers as long as
+register something with the kernel. It thus coexists with your own signal
-you don't register any with libev for the same signal).
+handlers as long as you don't register any with libev for the same signal.
 .PP
 If possible and supported, libev will install its handlers with
 \&\f(CW\*(C`SA_RESTART\*(C'\fR (or equivalent) behaviour enabled, so system calls should
 not be unduly interrupted. If you have a problem with system calls getting
 interrupted by signals you can block all signals in an \f(CW\*(C`ev_check\*(C'\fR watcher
 The signal the watcher watches out for.
 .PP
 \fIExamples\fR
 .IX Subsection "Examples"
 .PP
-Example: Try to exit cleanly on \s-1SIGINT\s0.
+Example: Try to exit cleanly on \s-1SIGINT.\s0
 .PP
 .Vb 5
 \&   static void
 \&   sigint_cb (struct ev_loop *loop, ev_signal *w, int revents)
 \&   {
 compilation environment, which means that on systems with large file
 support disabled by default, you get the 32 bit version of the stat
 structure. When using the library from programs that change the \s-1ABI\s0 to
 use 64 bit file offsets the programs will fail. In that case you have to
 compile libev with the same flags to get binary compatibility. This is
-obviously the case with any flags that change the \s-1ABI\s0, but the problem is
+obviously the case with any flags that change the \s-1ABI,\s0 but the problem is
 most noticeably displayed with ev_stat and large file support.
 .PP
 The solution for this is to lobby your distribution maker to make large
 file interfaces available by default (as e.g. FreeBSD does) and not
 optional. Libev cannot simply switch on large file support because it has
 .IX Subsection "ev_prepare and ev_check - customise your event loop!"
 Prepare and check watchers are often (but not always) used in pairs:
 prepare watchers get invoked before the process blocks and check watchers
 afterwards.
 .PP
-You \fImust not\fR call \f(CW\*(C`ev_run\*(C'\fR or similar functions that enter
+You \fImust not\fR call \f(CW\*(C`ev_run\*(C'\fR (or similar functions that enter the
-the current event loop from either \f(CW\*(C`ev_prepare\*(C'\fR or \f(CW\*(C`ev_check\*(C'\fR
+current event loop) or \f(CW\*(C`ev_loop_fork\*(C'\fR from either \f(CW\*(C`ev_prepare\*(C'\fR or
-watchers. Other loops than the current one are fine, however. The
+\&\f(CW\*(C`ev_check\*(C'\fR watchers. Other loops than the current one are fine,
-rationale behind this is that you do not need to check for recursion in
+however. The rationale behind this is that you do not need to check
-those watchers, i.e. the sequence will always be \f(CW\*(C`ev_prepare\*(C'\fR, blocking,
+for recursion in those watchers, i.e. the sequence will always be
-\&\f(CW\*(C`ev_check\*(C'\fR so if you have one watcher of each kind they will always be
+\&\f(CW\*(C`ev_prepare\*(C'\fR, blocking, \f(CW\*(C`ev_check\*(C'\fR so if you have one watcher of each
-called in pairs bracketing the blocking call.
+kind they will always be called in pairs bracketing the blocking call.
 .PP
 Their main purpose is to integrate other event mechanisms into libev and
 their use is somewhat advanced. They could be used, for example, to track
 variable changes, implement your own watchers, integrate net-snmp or a
 coroutine library and lots more. They are also occasionally useful if
 .Ve
 .PP
 Method 4: Do not use a prepare or check watcher because the module you
 want to embed is not flexible enough to support it. Instead, you can
 override their poll function. The drawback with this solution is that the
-main loop is now no longer controllable by \s-1EV\s0. The \f(CW\*(C`Glib::EV\*(C'\fR module uses
+main loop is now no longer controllable by \s-1EV.\s0 The \f(CW\*(C`Glib::EV\*(C'\fR module uses
 this approach, effectively embedding \s-1EV\s0 as a client into the horrible
 libglib event loop.
 .PP
 .Vb 4
 \&   static gint
 .PP
 .Vb 3
 \&   struct ev_loop *loop_hi = ev_default_init (0);
 \&   struct ev_loop *loop_lo = 0;
 \&   ev_embed embed;
 \&
 \&   // see if there is a chance of getting one that works
 \&   // (remember that a flags value of 0 means autodetection)
 \&   loop_lo = ev_embeddable_backends () & ev_recommended_backends ()
 \&     ? ev_loop_new (ev_embeddable_backends () & ev_recommended_backends ())
 \&     : 0;
 .PP
 .Vb 3
 \&   struct ev_loop *loop = ev_default_init (0);
 \&   struct ev_loop *loop_socket = 0;
 \&   ev_embed embed;
 \&
 \&   if (ev_supported_backends () & ~ev_recommended_backends () & EVBACKEND_KQUEUE)
 \&     if ((loop_socket = ev_loop_new (EVBACKEND_KQUEUE))
 \&       {
 \&         ev_embed_init (&embed, 0, loop_socket);
 \&         ev_embed_start (loop, &embed);
 of course.
 .PP
 \fIThe special problem of life after fork \- how is it possible?\fR
 .IX Subsection "The special problem of life after fork - how is it possible?"
 .PP
-Most uses of \f(CW\*(C`fork()\*(C'\fR consist of forking, then some simple calls to set
+Most uses of \f(CW\*(C`fork ()\*(C'\fR consist of forking, then some simple calls to set
 up/change the process environment, followed by a call to \f(CW\*(C`exec()\*(C'\fR. This
 sequence should be handled by libev without any problems.
 .PP
 This changes when the application actually wants to do event handling
 in the child, or both parent in child, in effect \*(L"continuing\*(R" after the
 is a time window between the event loop checking and resetting the async
 notification, and the callback being invoked.
 .SH "OTHER FUNCTIONS"
 .IX Header "OTHER FUNCTIONS"
 There are some other functions of possible interest. Described. Here. Now.
-.IP "ev_once (loop, int fd, int events, ev_tstamp timeout, callback)" 4
+.IP "ev_once (loop, int fd, int events, ev_tstamp timeout, callback, arg)" 4
-.IX Item "ev_once (loop, int fd, int events, ev_tstamp timeout, callback)"
+.IX Item "ev_once (loop, int fd, int events, ev_tstamp timeout, callback, arg)"
 This function combines a simple timer and an I/O watcher, calls your
 callback on whichever event happens first and automatically stops both
 watchers. This is useful if you want to wait for a single event on an fd
 or timeout without having to allocate/configure/start/stop/free one or
 more watchers yourself.
 \&\f(CW\*(C`EV_ERROR\*(C'\fR, \f(CW\*(C`EV_READ\*(C'\fR, \f(CW\*(C`EV_WRITE\*(C'\fR or \f(CW\*(C`EV_TIMER\*(C'\fR) and the \f(CW\*(C`arg\*(C'\fR
 value passed to \f(CW\*(C`ev_once\*(C'\fR. Note that it is possible to receive \fIboth\fR
 a timeout and an io event at the same time \- you probably should give io
 events precedence.
 .Sp
-Example: wait up to ten seconds for data to appear on \s-1STDIN_FILENO\s0.
+Example: wait up to ten seconds for data to appear on \s-1STDIN_FILENO.\s0
 .Sp
 .Vb 7
 \&   static void stdin_ready (int revents, void *arg)
 \&   {
 \&     if (revents & EV_READ)
 .SH "COMMON OR USEFUL IDIOMS (OR BOTH)"
 .IX Header "COMMON OR USEFUL IDIOMS (OR BOTH)"
 This section explains some common idioms that are not immediately
 obvious. Note that examples are sprinkled over the whole manual, and this
 section only contains stuff that wouldn't fit anywhere else.
-.SS "\s-1ASSOCIATING\s0 \s-1CUSTOM\s0 \s-1DATA\s0 \s-1WITH\s0 A \s-1WATCHER\s0"
+.SS "\s-1ASSOCIATING CUSTOM DATA WITH A WATCHER\s0"
 .IX Subsection "ASSOCIATING CUSTOM DATA WITH A WATCHER"
 Each watcher has, by default, a \f(CW\*(C`void *data\*(C'\fR member that you can read
 or modify at any time: libev will completely ignore it. This can be used
 to associate arbitrary data with your watcher. If you need more data and
 don't want to allocate memory separately and store a pointer to it in that
 \&   }
 .Ve
 .PP
 More interesting and less C\-conformant ways of casting your callback
 function type instead have been omitted.
-.SS "\s-1BUILDING\s0 \s-1YOUR\s0 \s-1OWN\s0 \s-1COMPOSITE\s0 \s-1WATCHERS\s0"
+.SS "\s-1BUILDING YOUR OWN COMPOSITE WATCHERS\s0"
 .IX Subsection "BUILDING YOUR OWN COMPOSITE WATCHERS"
 Another common scenario is to use some data structure with multiple
 embedded watchers, in effect creating your own watcher that combines
 multiple libev event sources into one \*(L"super-watcher\*(R":
 .PP
 \&   {
 \&     struct my_biggy big = (struct my_biggy *)
 \&       (((char *)w) \- offsetof (struct my_biggy, t2));
 \&   }
 .Ve
-.SS "\s-1AVOIDING\s0 \s-1FINISHING\s0 \s-1BEFORE\s0 \s-1RETURNING\s0"
+.SS "\s-1AVOIDING FINISHING BEFORE RETURNING\s0"
 .IX Subsection "AVOIDING FINISHING BEFORE RETURNING"
 Often you have structures like this in event-based programs:
 .PP
 .Vb 4
 \&  callback ()
 \&   ev_feed_event (EV_A_ watcher, 0);
 .Ve
 .PP
 This way, \f(CW\*(C`start_new_request\*(C'\fR can safely return before the callback is
 invoked, while not delaying callback invocation too much.
-.SS "\s-1MODEL/NESTED\s0 \s-1EVENT\s0 \s-1LOOP\s0 \s-1INVOCATIONS\s0 \s-1AND\s0 \s-1EXIT\s0 \s-1CONDITIONS\s0"
+.SS "\s-1MODEL/NESTED EVENT LOOP INVOCATIONS AND EXIT CONDITIONS\s0"
 .IX Subsection "MODEL/NESTED EVENT LOOP INVOCATIONS AND EXIT CONDITIONS"
 Often (especially in \s-1GUI\s0 toolkits) there are places where you have
 \&\fImodal\fR interaction, which is most easily implemented by recursively
 invoking \f(CW\*(C`ev_run\*(C'\fR.
 .PP
 \&   exit_main_loop = 1;
 \&
 \&   // exit both
 \&   exit_main_loop = exit_nested_loop = 1;
 .Ve
-.SS "\s-1THREAD\s0 \s-1LOCKING\s0 \s-1EXAMPLE\s0"
+.SS "\s-1THREAD LOCKING EXAMPLE\s0"
 .IX Subsection "THREAD LOCKING EXAMPLE"
 Here is a fictitious example of how to run an event loop in a different
 thread from where callbacks are being invoked and watchers are
 created/added/removed.
 .PP
 .PP
 Note that sending the \f(CW\*(C`ev_async\*(C'\fR watcher is required because otherwise
 an event loop currently blocking in the kernel will have no knowledge
 about the newly added timer. By waking up the loop it will pick up any new
 watchers in the next event loop iteration.
-.SS "\s-1THREADS\s0, \s-1COROUTINES\s0, \s-1CONTINUATIONS\s0, \s-1QUEUES\s0... \s-1INSTEAD\s0 \s-1OF\s0 \s-1CALLBACKS\s0"
+.SS "\s-1THREADS, COROUTINES, CONTINUATIONS, QUEUES... INSTEAD OF CALLBACKS\s0"
 .IX Subsection "THREADS, COROUTINES, CONTINUATIONS, QUEUES... INSTEAD OF CALLBACKS"
 While the overhead of a callback that e.g. schedules a thread is small, it
 is still an overhead. If you embed libev, and your main usage is with some
 kind of threads or coroutines, you might want to customise libev so that
 doesn't need callbacks anymore.
 You can do similar tricks if you have, say, threads with an event queue \-
 instead of storing a coroutine, you store the queue object and instead of
 switching to a coroutine, you push the watcher onto the queue and notify
 any waiters.
 .PP
-To embed libev, see \*(L"\s-1EMBEDDING\s0\*(R", but in short, it's easiest to create two
+To embed libev, see \*(L"\s-1EMBEDDING\*(R"\s0, but in short, it's easiest to create two
 files, \fImy_ev.h\fR and \fImy_ev.c\fR that include the respective libev files:
 .PP
 .Vb 4
 \&   // my_ev.h
 \&   #define EV_CB_DECLARE(type)   struct my_coro *cb;
-\&   #define EV_CB_INVOKE(watcher) switch_to ((watcher)\->cb);
+\&   #define EV_CB_INVOKE(watcher) switch_to ((watcher)\->cb)
 \&   #include "../libev/ev.h"
 \&
 \&   // my_ev.c
 \&   #define EV_H "my_ev.h"
 \&   #include "../libev/ev.c"
 The normal C \s-1API\s0 should work fine when used from \*(C+: both ev.h and the
 libev sources can be compiled as \*(C+. Therefore, code that uses the C \s-1API\s0
 will work fine.
 .PP
 Proper exception specifications might have to be added to callbacks passed
-to libev: exceptions may be thrown only from watcher callbacks, all
+to libev: exceptions may be thrown only from watcher callbacks, all other
-other callbacks (allocator, syserr, loop acquire/release and periodic
+callbacks (allocator, syserr, loop acquire/release and periodic reschedule
-reschedule callbacks) must not throw exceptions, and might need a \f(CW\*(C`throw
+callbacks) must not throw exceptions, and might need a \f(CW\*(C`noexcept\*(C'\fR
-()\*(C'\fR specification. If you have code that needs to be compiled as both C
+specification. If you have code that needs to be compiled as both C and
-and \*(C+ you can use the \f(CW\*(C`EV_THROW\*(C'\fR macro for this:
+\&\*(C+ you can use the \f(CW\*(C`EV_NOEXCEPT\*(C'\fR macro for this:
 .PP
 .Vb 6
 \&   static void
-\&   fatal_error (const char *msg) EV_THROW
+\&   fatal_error (const char *msg) EV_NOEXCEPT
 \&   {
 \&     perror (msg);
 \&     abort ();
 \&   }
 \&
 \&     void operator() (ev::io &w, int revents)
 \&     {
 \&       ...
 \&     }
 \&   }
 \&
 \&   myfunctor f;
 \&
 \&   ev::io w;
 \&   w.set (&f);
 .Ve
 gets automatically stopped and restarted when reconfiguring it with this
 method.
 .Sp
 For \f(CW\*(C`ev::embed\*(C'\fR watchers this method is called \f(CW\*(C`set_embed\*(C'\fR, to avoid
 clashing with the \f(CW\*(C`set (loop)\*(C'\fR method.
+.Sp
+For \f(CW\*(C`ev::io\*(C'\fR watchers there is an additional \f(CW\*(C`set\*(C'\fR method that acepts a
+new event mask only, and internally calls \f(CW\*(C`ev_io_modfify\*(C'\fR.
 .IP "w\->start ()" 4
 .IX Item "w->start ()"
 Starts the watcher. Note that there is no \f(CW\*(C`loop\*(C'\fR argument, as the
 constructor already stores the event loop.
 .IP "w\->start ([arguments])" 4
 there are additional modules that implement libev-compatible interfaces
 to \f(CW\*(C`libadns\*(C'\fR (\f(CW\*(C`EV::ADNS\*(C'\fR, but \f(CW\*(C`AnyEvent::DNS\*(C'\fR is preferred nowadays),
 \&\f(CW\*(C`Net::SNMP\*(C'\fR (\f(CW\*(C`Net::SNMP::EV\*(C'\fR) and the \f(CW\*(C`libglib\*(C'\fR event core (\f(CW\*(C`Glib::EV\*(C'\fR
 and \f(CW\*(C`EV::Glib\*(C'\fR).
 .Sp
-It can be found and installed via \s-1CPAN\s0, its homepage is at
+It can be found and installed via \s-1CPAN,\s0 its homepage is at
 <http://software.schmorp.de/pkg/EV>.
 .IP "Python" 4
 .IX Item "Python"
 Python bindings can be found at <http://code.google.com/p/pyev/>. It
 seems to be quite complete and well-documented.
 Roger Pack reports that using the link order \f(CW\*(C`\-lws2_32 \-lmsvcrt\-ruby\-190\*(C'\fR
 makes rev work even on mingw.
 .IP "Haskell" 4
 .IX Item "Haskell"
 A haskell binding to libev is available at
-http://hackage.haskell.org/cgi\-bin/hackage\-scripts/package/hlibev <http://hackage.haskell.org/cgi-bin/hackage-scripts/package/hlibev>.
+<http://hackage.haskell.org/cgi\-bin/hackage\-scripts/package/hlibev>.
 .IP "D" 4
 .IX Item "D"
 Leandro Lucarella has written a D language binding (\fIev.d\fR) for libev, to
 be found at <http://www.llucax.com.ar/proj/ev.d/index.html>.
 .IP "Ocaml" 4
 .IX Item "Ocaml"
 Erkki Seppala has written Ocaml bindings for libev, to be found at
-http://modeemi.cs.tut.fi/~flux/software/ocaml\-ev/ <http://modeemi.cs.tut.fi/~flux/software/ocaml-ev/>.
+<http://modeemi.cs.tut.fi/~flux/software/ocaml\-ev/>.
 .IP "Lua" 4
 .IX Item "Lua"
 Brian Maher has written a partial interface to libev for lua (at the
 time of this writing, only \f(CW\*(C`ev_io\*(C'\fR and \f(CW\*(C`ev_timer\*(C'\fR), to be found at
-http://github.com/brimworks/lua\-ev <http://github.com/brimworks/lua-ev>.
+<http://github.com/brimworks/lua\-ev>.
 .IP "Javascript" 4
 .IX Item "Javascript"
 Node.js (<http://nodejs.org>) uses libev as the underlying event library.
 .IP "Others" 4
 .IX Item "Others"
 .SS "\s-1FILESETS\s0"
 .IX Subsection "FILESETS"
 Depending on what features you need you need to include one or more sets of files
 in your application.
 .PP
-\fI\s-1CORE\s0 \s-1EVENT\s0 \s-1LOOP\s0\fR
+\fI\s-1CORE EVENT LOOP\s0\fR
 .IX Subsection "CORE EVENT LOOP"
 .PP
 To include only the libev core (all the \f(CW\*(C`ev_*\*(C'\fR functions), with manual
 configuration (no autoconf):
 .PP
 \&   ev_vars.h
 \&   ev_wrap.h
 \&
 \&   ev_win32.c      required on win32 platforms only
 \&
-\&   ev_select.c     only when select backend is enabled (which is enabled by default)
+\&   ev_select.c     only when select backend is enabled
-\&   ev_poll.c       only when poll backend is enabled (disabled by default)
+\&   ev_poll.c       only when poll backend is enabled
-\&   ev_epoll.c      only when the epoll backend is enabled (disabled by default)
+\&   ev_epoll.c      only when the epoll backend is enabled
+\&   ev_linuxaio.c   only when the linux aio backend is enabled
+\&   ev_iouring.c    only when the linux io_uring backend is enabled
-\&   ev_kqueue.c     only when the kqueue backend is enabled (disabled by default)
+\&   ev_kqueue.c     only when the kqueue backend is enabled
-\&   ev_port.c       only when the solaris port backend is enabled (disabled by default)
+\&   ev_port.c       only when the solaris port backend is enabled
 .Ve
 .PP
 \&\fIev.c\fR includes the backend files directly when enabled, so you only need
 to compile this single file.
 .PP
-\fI\s-1LIBEVENT\s0 \s-1COMPATIBILITY\s0 \s-1API\s0\fR
+\fI\s-1LIBEVENT COMPATIBILITY API\s0\fR
 .IX Subsection "LIBEVENT COMPATIBILITY API"
 .PP
-To include the libevent compatibility \s-1API\s0, also include:
+To include the libevent compatibility \s-1API,\s0 also include:
 .PP
 .Vb 1
 \&   #include "event.c"
 .Ve
 .PP
 .PP
 .Vb 1
 \&   #include "event.h"
 .Ve
 .PP
-in the files that want to use the libevent \s-1API\s0. This also includes \fIev.h\fR.
+in the files that want to use the libevent \s-1API.\s0 This also includes \fIev.h\fR.
 .PP
 You need the following additional files for this:
 .PP
 .Vb 2
 \&   event.h
 \&   event.c
 .Ve
 .PP
-\fI\s-1AUTOCONF\s0 \s-1SUPPORT\s0\fR
+\fI\s-1AUTOCONF SUPPORT\s0\fR
 .IX Subsection "AUTOCONF SUPPORT"
 .PP
 Instead of using \f(CW\*(C`EV_STANDALONE=1\*(C'\fR and providing your configuration in
 whatever way you want, you can also \f(CW\*(C`m4_include([libev.m4])\*(C'\fR in your
 \&\fIconfigure.ac\fR and leave \f(CW\*(C`EV_STANDALONE\*(C'\fR undefined. \fIev.c\fR will then
 For this of course you need the m4 file:
 .PP
 .Vb 1
 \&   libev.m4
 .Ve
-.SS "\s-1PREPROCESSOR\s0 \s-1SYMBOLS/MACROS\s0"
+.SS "\s-1PREPROCESSOR SYMBOLS/MACROS\s0"
 .IX Subsection "PREPROCESSOR SYMBOLS/MACROS"
 Libev can be configured via a variety of preprocessor symbols you have to
 define before including (or compiling) any of its files. The default in
 the absence of autoconf is documented for every option.
 .PP
-Symbols marked with \*(L"(h)\*(R" do not change the \s-1ABI\s0, and can have different
+Symbols marked with \*(L"(h)\*(R" do not change the \s-1ABI,\s0 and can have different
 values when compiling libev vs. including \fIev.h\fR, so it is permissible
 to redefine them before including \fIev.h\fR without breaking compatibility
-to a compiled library. All other symbols change the \s-1ABI\s0, which means all
+to a compiled library. All other symbols change the \s-1ABI,\s0 which means all
 users of libev and the libev code itself must be compiled with compatible
 settings.
 .IP "\s-1EV_COMPAT3\s0 (h)" 4
 .IX Item "EV_COMPAT3 (h)"
 Backwards compatibility is a major concern for libev. This is why this
 higher, as it simplifies linking (no need for \f(CW\*(C`\-lrt\*(C'\fR).
 .IP "\s-1EV_USE_NANOSLEEP\s0" 4
 .IX Item "EV_USE_NANOSLEEP"
 If defined to be \f(CW1\fR, libev will assume that \f(CW\*(C`nanosleep ()\*(C'\fR is available
 and will use it for delays. Otherwise it will use \f(CW\*(C`select ()\*(C'\fR.
+.IP "\s-1EV_USE_EVENTFD\s0" 4
+.IX Item "EV_USE_EVENTFD"
+If defined to be \f(CW1\fR, then libev will assume that \f(CW\*(C`eventfd ()\*(C'\fR is
+available and will probe for kernel support at runtime. This will improve
+\&\f(CW\*(C`ev_signal\*(C'\fR and \f(CW\*(C`ev_async\*(C'\fR performance and reduce resource consumption.
+If undefined, it will be enabled if the headers indicate GNU/Linux + Glibc
+2.7 or newer, otherwise disabled.
+.IP "\s-1EV_USE_SIGNALFD\s0" 4
+.IX Item "EV_USE_SIGNALFD"
+If defined to be \f(CW1\fR, then libev will assume that \f(CW\*(C`signalfd ()\*(C'\fR is
+available and will probe for kernel support at runtime. This enables
+the use of \s-1EVFLAG_SIGNALFD\s0 for faster and simpler signal handling. If
+undefined, it will be enabled if the headers indicate GNU/Linux + Glibc
+2.7 or newer, otherwise disabled.
+.IP "\s-1EV_USE_TIMERFD\s0" 4
+.IX Item "EV_USE_TIMERFD"
+If defined to be \f(CW1\fR, then libev will assume that \f(CW\*(C`timerfd ()\*(C'\fR is
+available and will probe for kernel support at runtime. This allows
+libev to detect time jumps accurately. If undefined, it will be enabled
+if the headers indicate GNU/Linux + Glibc 2.8 or newer and define
+\&\f(CW\*(C`TFD_TIMER_CANCEL_ON_SET\*(C'\fR, otherwise disabled.
 .IP "\s-1EV_USE_EVENTFD\s0" 4
 .IX Item "EV_USE_EVENTFD"
 If defined to be \f(CW1\fR, then libev will assume that \f(CW\*(C`eventfd ()\*(C'\fR is
 available and will probe for kernel support at runtime. This will improve
 \&\f(CW\*(C`ev_signal\*(C'\fR and \f(CW\*(C`ev_async\*(C'\fR performance and reduce resource consumption.
 If defined to be \f(CW1\fR, libev will compile in support for the Linux
 \&\f(CW\*(C`epoll\*(C'\fR(7) backend. Its availability will be detected at runtime,
 otherwise another method will be used as fallback. This is the preferred
 backend for GNU/Linux systems. If undefined, it will be enabled if the
 headers indicate GNU/Linux + Glibc 2.4 or newer, otherwise disabled.
+.IP "\s-1EV_USE_LINUXAIO\s0" 4
+.IX Item "EV_USE_LINUXAIO"
+If defined to be \f(CW1\fR, libev will compile in support for the Linux aio
+backend (\f(CW\*(C`EV_USE_EPOLL\*(C'\fR must also be enabled). If undefined, it will be
+enabled on linux, otherwise disabled.
+.IP "\s-1EV_USE_IOURING\s0" 4
+.IX Item "EV_USE_IOURING"
+If defined to be \f(CW1\fR, libev will compile in support for the Linux
+io_uring backend (\f(CW\*(C`EV_USE_EPOLL\*(C'\fR must also be enabled). Due to it's
+current limitations it has to be requested explicitly. If undefined, it
+will be enabled on linux, otherwise disabled.
 .IP "\s-1EV_USE_KQUEUE\s0" 4
 .IX Item "EV_USE_KQUEUE"
 If defined to be \f(CW1\fR, libev will compile in support for the \s-1BSD\s0 style
 \&\f(CW\*(C`kqueue\*(C'\fR(2) backend. Its actual availability will be detected at runtime,
 otherwise another method will be used as fallback. This is the preferred
 between threads, that is, threads can be used, but threads never run on
 different cpus (or different cpu cores). This reduces dependencies
 and makes libev faster.
 .IP "\s-1EV_NO_THREADS\s0" 4
 .IX Item "EV_NO_THREADS"
-If defined to be \f(CW1\fR, libev will assume that it will never be called
+If defined to be \f(CW1\fR, libev will assume that it will never be called from
-from different threads, which is a stronger assumption than \f(CW\*(C`EV_NO_SMP\*(C'\fR,
+different threads (that includes signal handlers), which is a stronger
-above. This reduces dependencies and makes libev faster.
+assumption than \f(CW\*(C`EV_NO_SMP\*(C'\fR, above. This reduces dependencies and makes
+libev faster.
 .IP "\s-1EV_ATOMIC_T\s0" 4
 .IX Item "EV_ATOMIC_T"
 Libev requires an integer type (suitable for storing \f(CW0\fR or \f(CW1\fR) whose
 access is atomic with respect to other threads or signal contexts. No
 such type is easily found in the C language, so you can provide your own
 all the priorities, so having many of them (hundreds) uses a lot of space
 and time, so using the defaults of five priorities (\-2 .. +2) is usually
 fine.
 .Sp
 If your embedding application does not need any priorities, defining these
-both to \f(CW0\fR will save some memory and \s-1CPU\s0.
+both to \f(CW0\fR will save some memory and \s-1CPU.\s0
-.IP "\s-1EV_PERIODIC_ENABLE\s0, \s-1EV_IDLE_ENABLE\s0, \s-1EV_EMBED_ENABLE\s0, \s-1EV_STAT_ENABLE\s0, \s-1EV_PREPARE_ENABLE\s0, \s-1EV_CHECK_ENABLE\s0, \s-1EV_FORK_ENABLE\s0, \s-1EV_SIGNAL_ENABLE\s0, \s-1EV_ASYNC_ENABLE\s0, \s-1EV_CHILD_ENABLE\s0." 4
+.IP "\s-1EV_PERIODIC_ENABLE, EV_IDLE_ENABLE, EV_EMBED_ENABLE, EV_STAT_ENABLE, EV_PREPARE_ENABLE, EV_CHECK_ENABLE, EV_FORK_ENABLE, EV_SIGNAL_ENABLE, EV_ASYNC_ENABLE, EV_CHILD_ENABLE.\s0" 4
 .IX Item "EV_PERIODIC_ENABLE, EV_IDLE_ENABLE, EV_EMBED_ENABLE, EV_STAT_ENABLE, EV_PREPARE_ENABLE, EV_CHECK_ENABLE, EV_FORK_ENABLE, EV_SIGNAL_ENABLE, EV_ASYNC_ENABLE, EV_CHILD_ENABLE."
 If undefined or defined to be \f(CW1\fR (and the platform supports it), then
 the respective watcher type is supported. If defined to be \f(CW0\fR, then it
 is not. Disabling watcher types mainly saves code size.
 .IP "\s-1EV_FEATURES\s0" 4
 called. If set to \f(CW2\fR, then the internal verification code will be
 called once per loop, which can slow down libev. If set to \f(CW3\fR, then the
 verification code will be called very frequently, which will slow down
 libev considerably.
 .Sp
+Verification errors are reported via C's \f(CW\*(C`assert\*(C'\fR mechanism, so if you
+disable that (e.g. by defining \f(CW\*(C`NDEBUG\*(C'\fR) then no errors will be reported.
+.Sp
 The default is \f(CW1\fR, unless \f(CW\*(C`EV_FEATURES\*(C'\fR overrides it, in which case it
 will be \f(CW0\fR.
 .IP "\s-1EV_COMMON\s0" 4
 .IX Item "EV_COMMON"
 By default, all watchers have a \f(CW\*(C`void *data\*(C'\fR member. By redefining
 and the way callbacks are invoked and set. Must expand to a struct member
 definition and a statement, respectively. See the \fIev.h\fR header file for
 their default definitions. One possible use for overriding these is to
 avoid the \f(CW\*(C`struct ev_loop *\*(C'\fR as first argument in all cases, or to use
 method calls instead of plain function calls in \*(C+.
-.SS "\s-1EXPORTED\s0 \s-1API\s0 \s-1SYMBOLS\s0"
+.SS "\s-1EXPORTED API SYMBOLS\s0"
 .IX Subsection "EXPORTED API SYMBOLS"
 If you need to re-export the \s-1API\s0 (e.g. via a \s-1DLL\s0) and you need a list of
 exported symbols, you can use the provided \fISymbol.*\fR files which list
 all public symbols, one per line:
 .PP
 \&   #include "ev_cpp.h"
 \&   #include "ev.c"
 .Ve
 .SH "INTERACTION WITH OTHER PROGRAMS, LIBRARIES OR THE ENVIRONMENT"
 .IX Header "INTERACTION WITH OTHER PROGRAMS, LIBRARIES OR THE ENVIRONMENT"
-.SS "\s-1THREADS\s0 \s-1AND\s0 \s-1COROUTINES\s0"
+.SS "\s-1THREADS AND COROUTINES\s0"
 .IX Subsection "THREADS AND COROUTINES"
 \fI\s-1THREADS\s0\fR
 .IX Subsection "THREADS"
 .PP
 All libev functions are reentrant and thread-safe unless explicitly
 An example use would be to communicate signals or other events that only
 work in the default loop by registering the signal watcher with the
 default loop and triggering an \f(CW\*(C`ev_async\*(C'\fR watcher from the default loop
 watcher callback into the event loop interested in the signal.
 .PP
-See also \*(L"\s-1THREAD\s0 \s-1LOCKING\s0 \s-1EXAMPLE\s0\*(R".
+See also \*(L"\s-1THREAD LOCKING EXAMPLE\*(R"\s0.
 .PP
 \fI\s-1COROUTINES\s0\fR
 .IX Subsection "COROUTINES"
 .PP
 Libev is very accommodating to coroutines (\*(L"cooperative threads\*(R"):
 that you must not do this from \f(CW\*(C`ev_periodic\*(C'\fR reschedule callbacks.
 .PP
 Care has been taken to ensure that libev does not keep local state inside
 \&\f(CW\*(C`ev_run\*(C'\fR, and other calls do not usually allow for coroutine switches as
 they do not call any callbacks.
-.SS "\s-1COMPILER\s0 \s-1WARNINGS\s0"
+.SS "\s-1COMPILER WARNINGS\s0"
 .IX Subsection "COMPILER WARNINGS"
 Depending on your compiler and compiler settings, you might get no or a
 lot of warnings when compiling libev code. Some people are apparently
 scared by this.
 .PP
 .PP
 If you need, for some reason, empty reports from valgrind for your project
 I suggest using suppression lists.
 .SH "PORTABILITY NOTES"
 .IX Header "PORTABILITY NOTES"
-.SS "\s-1GNU/LINUX\s0 32 \s-1BIT\s0 \s-1LIMITATIONS\s0"
+.SS "\s-1GNU/LINUX 32 BIT LIMITATIONS\s0"
 .IX Subsection "GNU/LINUX 32 BIT LIMITATIONS"
 GNU/Linux is the only common platform that supports 64 bit file/large file
 interfaces but \fIdisables\fR them by default.
 .PP
 That means that libev compiled in the default environment doesn't support
 files larger than 2GiB or so, which mainly affects \f(CW\*(C`ev_stat\*(C'\fR watchers.
 .PP
 Unfortunately, many programs try to work around this GNU/Linux issue
-by enabling the large file \s-1API\s0, which makes them incompatible with the
+by enabling the large file \s-1API,\s0 which makes them incompatible with the
 standard libev compiled for their system.
 .PP
 Likewise, libev cannot enable the large file \s-1API\s0 itself as this would
 suddenly make it incompatible to the default compile time environment,
 i.e. all programs not using special compile switches.
-.SS "\s-1OS/X\s0 \s-1AND\s0 \s-1DARWIN\s0 \s-1BUGS\s0"
+.SS "\s-1OS/X AND DARWIN BUGS\s0"
 .IX Subsection "OS/X AND DARWIN BUGS"
 The whole thing is a bug if you ask me \- basically any system interface
 you touch is broken, whether it is locales, poll, kqueue or even the
 OpenGL drivers.
 .PP
 .PP
 \fI\f(CI\*(C`select\*(C'\fI is buggy\fR
 .IX Subsection "select is buggy"
 .PP
 All that's left is \f(CW\*(C`select\*(C'\fR, and of course Apple found a way to fuck this
-one up as well: On \s-1OS/X\s0, \f(CW\*(C`select\*(C'\fR actively limits the number of file
+one up as well: On \s-1OS/X,\s0 \f(CW\*(C`select\*(C'\fR actively limits the number of file
 descriptors you can pass in to 1024 \- your program suddenly crashes when
 you use more.
 .PP
 There is an undocumented \*(L"workaround\*(R" for this \- defining
 \&\f(CW\*(C`_DARWIN_UNLIMITED_SELECT\*(C'\fR, which libev tries to use, so select \fIshould\fR
-work on \s-1OS/X\s0.
+work on \s-1OS/X.\s0
-.SS "\s-1SOLARIS\s0 \s-1PROBLEMS\s0 \s-1AND\s0 \s-1WORKAROUNDS\s0"
+.SS "\s-1SOLARIS PROBLEMS AND WORKAROUNDS\s0"
 .IX Subsection "SOLARIS PROBLEMS AND WORKAROUNDS"
 \fI\f(CI\*(C`errno\*(C'\fI reentrancy\fR
 .IX Subsection "errno reentrancy"
 .PP
 The default compile environment on Solaris is unfortunately so
 great.
 .PP
 If you can't get it to work, you can try running the program by setting
 the environment variable \f(CW\*(C`LIBEV_FLAGS=3\*(C'\fR to only allow \f(CW\*(C`poll\*(C'\fR and
 \&\f(CW\*(C`select\*(C'\fR backends.
-.SS "\s-1AIX\s0 \s-1POLL\s0 \s-1BUG\s0"
+.SS "\s-1AIX POLL BUG\s0"
 .IX Subsection "AIX POLL BUG"
 \&\s-1AIX\s0 unfortunately has a broken \f(CW\*(C`poll.h\*(C'\fR header. Libev works around
 this by trying to avoid the poll backend altogether (i.e. it's not even
 compiled in), which normally isn't a big problem as \f(CW\*(C`select\*(C'\fR works fine
-with large bitsets on \s-1AIX\s0, and \s-1AIX\s0 is dead anyway.
+with large bitsets on \s-1AIX,\s0 and \s-1AIX\s0 is dead anyway.
-.SS "\s-1WIN32\s0 \s-1PLATFORM\s0 \s-1LIMITATIONS\s0 \s-1AND\s0 \s-1WORKAROUNDS\s0"
+.SS "\s-1WIN32 PLATFORM LIMITATIONS AND WORKAROUNDS\s0"
 .IX Subsection "WIN32 PLATFORM LIMITATIONS AND WORKAROUNDS"
 \fIGeneral issues\fR
 .IX Subsection "General issues"
 .PP
 Win32 doesn't support any of the standards (e.g. \s-1POSIX\s0) that libev
 \&   #define EV_USE_SELECT 1
 \&   #define EV_SELECT_IS_WINSOCKET 1   /* forces EV_SELECT_USE_FD_SET, too */
 .Ve
 .PP
 Note that winsockets handling of fd sets is O(n), so you can easily get a
-complexity in the O(nA\*^X) range when using win32.
+complexity in the O(nX) range when using win32.
 .PP
 \fILimited number of file descriptors\fR
 .IX Subsection "Limited number of file descriptors"
 .PP
 Windows has numerous arbitrary (and low) limits on things.
 by calling \f(CW\*(C`_setmaxstdio\*(C'\fR, which can increase this limit to \f(CW2048\fR
 (another arbitrary limit), but is broken in many versions of the Microsoft
 runtime libraries. This might get you to about \f(CW512\fR or \f(CW2048\fR sockets
 (depending on windows version and/or the phase of the moon). To get more,
 you need to wrap all I/O functions and provide your own fd management, but
-the cost of calling select (O(nA\*^X)) will likely make this unworkable.
+the cost of calling select (O(nX)) will likely make this unworkable.
-.SS "\s-1PORTABILITY\s0 \s-1REQUIREMENTS\s0"
+.SS "\s-1PORTABILITY REQUIREMENTS\s0"
 .IX Subsection "PORTABILITY REQUIREMENTS"
 In addition to a working ISO-C implementation and of course the
 backend-specific APIs, libev relies on a few additional extensions:
 .ie n .IP """void (*)(ev_watcher_type *, int revents)"" must have compatible calling conventions regardless of ""ev_watcher_type *""." 4
 .el .IP "\f(CWvoid (*)(ev_watcher_type *, int revents)\fR must have compatible calling conventions regardless of \f(CWev_watcher_type *\fR." 4
 .IX Item "void (*)(ev_watcher_type *, int revents) must have compatible calling conventions regardless of ev_watcher_type *."
 Libev assumes not only that all watcher pointers have the same internal
-structure (guaranteed by \s-1POSIX\s0 but not by \s-1ISO\s0 C for example), but it also
+structure (guaranteed by \s-1POSIX\s0 but not by \s-1ISO C\s0 for example), but it also
 assumes that the same (machine) code can be used to call any watcher
 callback: The watcher callbacks have different type signatures, but libev
 calls them using an \f(CW\*(C`ev_watcher *\*(C'\fR internally.
+.IP "null pointers and integer zero are represented by 0 bytes" 4
+.IX Item "null pointers and integer zero are represented by 0 bytes"
+Libev uses \f(CW\*(C`memset\*(C'\fR to initialise structs and arrays to \f(CW0\fR bytes, and
+relies on this setting pointers and integers to null.
 .IP "pointer accesses must be thread-atomic" 4
 .IX Item "pointer accesses must be thread-atomic"
 Accessing a pointer value must be atomic, it must both be readable and
 writable in one piece \- this is the case on all current architectures.
 .ie n .IP """sig_atomic_t volatile"" must be thread-atomic as well" 4
 except the initial one, and run the signal handling loop in the initial
 thread as well.
 .ie n .IP """long"" must be large enough for common memory allocation sizes" 4
 .el .IP "\f(CWlong\fR must be large enough for common memory allocation sizes" 4
 .IX Item "long must be large enough for common memory allocation sizes"
-To improve portability and simplify its \s-1API\s0, libev uses \f(CW\*(C`long\*(C'\fR internally
+To improve portability and simplify its \s-1API,\s0 libev uses \f(CW\*(C`long\*(C'\fR internally
 instead of \f(CW\*(C`size_t\*(C'\fR when allocating its data structures. On non-POSIX
 systems (Microsoft...) this might be unexpectedly low, but is still at
 least 31 bits everywhere, which is enough for hundreds of millions of
 watchers.
 .ie n .IP """double"" must hold a time value in seconds with enough accuracy" 4
 .IX Item "double must hold a time value in seconds with enough accuracy"
 The type \f(CW\*(C`double\*(C'\fR is used to represent timestamps. It is required to
 have at least 51 bits of mantissa (and 9 bits of exponent), which is
 good enough for at least into the year 4000 with millisecond accuracy
 (the design goal for libev). This requirement is overfulfilled by
-implementations using \s-1IEEE\s0 754, which is basically all existing ones.
+implementations using \s-1IEEE 754,\s0 which is basically all existing ones.
 .Sp
-With \s-1IEEE\s0 754 doubles, you get microsecond accuracy until at least the
+With \s-1IEEE 754\s0 doubles, you get microsecond accuracy until at least the
 year 2255 (and millisecond accuracy till the year 287396 \- by then, libev
 is either obsolete or somebody patched it to use \f(CW\*(C`long double\*(C'\fR or
 something like that, just kidding).
 .PP
 If you know of other additional requirements drop me a note.
 calls in the current loop iteration and the loop is currently
 blocked. Checking for async and signal events involves iterating over all
 running async watchers or all signal numbers.
 .SH "PORTING FROM LIBEV 3.X TO 4.X"
 .IX Header "PORTING FROM LIBEV 3.X TO 4.X"
-The major version 4 introduced some incompatible changes to the \s-1API\s0.
+The major version 4 introduced some incompatible changes to the \s-1API.\s0
 .PP
 At the moment, the \f(CW\*(C`ev.h\*(C'\fR header file provides compatibility definitions
 for all changes, so most programs should still compile. The compatibility
 layer might be removed in later versions of libev, so better update to the
 new \s-1API\s0 early than late.
 .ie n .IP """EV_COMPAT3"" backwards compatibility mechanism" 4
 .el .IP "\f(CWEV_COMPAT3\fR backwards compatibility mechanism" 4
 .IX Item "EV_COMPAT3 backwards compatibility mechanism"
 The backward compatibility mechanism can be controlled by
-\&\f(CW\*(C`EV_COMPAT3\*(C'\fR. See \*(L"\s-1PREPROCESSOR\s0 \s-1SYMBOLS/MACROS\s0\*(R" in the \*(L"\s-1EMBEDDING\s0\*(R"
+\&\f(CW\*(C`EV_COMPAT3\*(C'\fR. See \*(L"\s-1PREPROCESSOR SYMBOLS/MACROS\*(R"\s0 in the \*(L"\s-1EMBEDDING\*(R"\s0
 section.
 .ie n .IP """ev_default_destroy"" and ""ev_default_fork"" have been removed" 4
 .el .IP "\f(CWev_default_destroy\fR and \f(CWev_default_fork\fR have been removed" 4
 .IX Item "ev_default_destroy and ev_default_fork have been removed"
 These calls can be replaced easily by their \f(CW\*(C`ev_loop_xxx\*(C'\fR counterparts:
 .SH "GLOSSARY"
 .IX Header "GLOSSARY"
 .IP "active" 4
 .IX Item "active"
 A watcher is active as long as it has been started and not yet stopped.
-See \*(L"\s-1WATCHER\s0 \s-1STATES\s0\*(R" for details.
+See \*(L"\s-1WATCHER STATES\*(R"\s0 for details.
 .IP "application" 4
 .IX Item "application"
 In this document, an application is whatever is using libev.
 .IP "backend" 4
 .IX Item "backend"
 The model used to describe how an event loop handles and processes
 watchers and events.
 .IP "pending" 4
 .IX Item "pending"
 A watcher is pending as soon as the corresponding event has been
-detected. See \*(L"\s-1WATCHER\s0 \s-1STATES\s0\*(R" for details.
+detected. See \*(L"\s-1WATCHER STATES\*(R"\s0 for details.
 .IP "real time" 4
 .IX Item "real time"
 The physical time that is observed. It is apparently strictly monotonic :)
 .IP "wall-clock time" 4
 .IX Item "wall-clock time"

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing libev/ev.3 (file contents): Revision 1.97 by root, Mon Feb 18 03:20:28 2013 UTC vs. Revision 1.120 by root, Wed Jan 22 13:33:44 2020 UTC

Diff Legend

Comparing libev/ev.3 (file contents):
Revision 1.97 by root, Mon Feb 18 03:20:28 2013 UTC vs.
Revision 1.120 by root, Wed Jan 22 13:33:44 2020 UTC