Mirror of :pserver:anonymous@cvs.schmorp.de/schmorpforge libev http://software.schmorp.de/pkg/libev.html
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

3529 lines
159 KiB

14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
14 years ago
  1. .\" Automatically generated by Pod::Man 2.16 (Pod::Simple 3.05)
  2. .\"
  3. .\" Standard preamble:
  4. .\" ========================================================================
  5. .de Sh \" Subsection heading
  6. .br
  7. .if t .Sp
  8. .ne 5
  9. .PP
  10. \fB\\$1\fR
  11. .PP
  12. ..
  13. .de Sp \" Vertical space (when we can't use .PP)
  14. .if t .sp .5v
  15. .if n .sp
  16. ..
  17. .de Vb \" Begin verbatim text
  18. .ft CW
  19. .nf
  20. .ne \\$1
  21. ..
  22. .de Ve \" End verbatim text
  23. .ft R
  24. .fi
  25. ..
  26. .\" Set up some character translations and predefined strings. \*(-- will
  27. .\" give an unbreakable dash, \*(PI will give pi, \*(L" will give a left
  28. .\" double quote, and \*(R" will give a right double quote. \*(C+ will
  29. .\" give a nicer C++. Capital omega is used to do unbreakable dashes and
  30. .\" therefore won't be available. \*(C` and \*(C' expand to `' in nroff,
  31. .\" nothing in troff, for use with C<>.
  32. .tr \(*W-
  33. .ds C+ C\v'-.1v'\h'-1p'\s-2+\h'-1p'+\s0\v'.1v'\h'-1p'
  34. .ie n \{\
  35. . ds -- \(*W-
  36. . ds PI pi
  37. . if (\n(.H=4u)&(1m=24u) .ds -- \(*W\h'-12u'\(*W\h'-12u'-\" diablo 10 pitch
  38. . if (\n(.H=4u)&(1m=20u) .ds -- \(*W\h'-12u'\(*W\h'-8u'-\" diablo 12 pitch
  39. . ds L" ""
  40. . ds R" ""
  41. . ds C` ""
  42. . ds C' ""
  43. 'br\}
  44. .el\{\
  45. . ds -- \|\(em\|
  46. . ds PI \(*p
  47. . ds L" ``
  48. . ds R" ''
  49. 'br\}
  50. .\"
  51. .\" Escape single quotes in literal strings from groff's Unicode transform.
  52. .ie \n(.g .ds Aq \(aq
  53. .el .ds Aq '
  54. .\"
  55. .\" If the F register is turned on, we'll generate index entries on stderr for
  56. .\" titles (.TH), headers (.SH), subsections (.Sh), items (.Ip), and index
  57. .\" entries marked with X<> in POD. Of course, you'll have to process the
  58. .\" output yourself in some meaningful fashion.
  59. .ie \nF \{\
  60. . de IX
  61. . tm Index:\\$1\t\\n%\t"\\$2"
  62. ..
  63. . nr % 0
  64. . rr F
  65. .\}
  66. .el \{\
  67. . de IX
  68. ..
  69. .\}
  70. .\"
  71. .\" Accent mark definitions (@(#)ms.acc 1.5 88/02/08 SMI; from UCB 4.2).
  72. .\" Fear. Run. Save yourself. No user-serviceable parts.
  73. . \" fudge factors for nroff and troff
  74. .if n \{\
  75. . ds #H 0
  76. . ds #V .8m
  77. . ds #F .3m
  78. . ds #[ \f1
  79. . ds #] \fP
  80. .\}
  81. .if t \{\
  82. . ds #H ((1u-(\\\\n(.fu%2u))*.13m)
  83. . ds #V .6m
  84. . ds #F 0
  85. . ds #[ \&
  86. . ds #] \&
  87. .\}
  88. . \" simple accents for nroff and troff
  89. .if n \{\
  90. . ds ' \&
  91. . ds ` \&
  92. . ds ^ \&
  93. . ds , \&
  94. . ds ~ ~
  95. . ds /
  96. .\}
  97. .if t \{\
  98. . ds ' \\k:\h'-(\\n(.wu*8/10-\*(#H)'\'\h"|\\n:u"
  99. . ds ` \\k:\h'-(\\n(.wu*8/10-\*(#H)'\`\h'|\\n:u'
  100. . ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'^\h'|\\n:u'
  101. . ds , \\k:\h'-(\\n(.wu*8/10)',\h'|\\n:u'
  102. . ds ~ \\k:\h'-(\\n(.wu-\*(#H-.1m)'~\h'|\\n:u'
  103. . ds / \\k:\h'-(\\n(.wu*8/10-\*(#H)'\z\(sl\h'|\\n:u'
  104. .\}
  105. . \" troff and (daisy-wheel) nroff accents
  106. .ds : \\k:\h'-(\\n(.wu*8/10-\*(#H+.1m+\*(#F)'\v'-\*(#V'\z.\h'.2m+\*(#F'.\h'|\\n:u'\v'\*(#V'
  107. .ds 8 \h'\*(#H'\(*b\h'-\*(#H'
  108. .ds o \\k:\h'-(\\n(.wu+\w'\(de'u-\*(#H)/2u'\v'-.3n'\*(#[\z\(de\v'.3n'\h'|\\n:u'\*(#]
  109. .ds d- \h'\*(#H'\(pd\h'-\w'~'u'\v'-.25m'\f2\(hy\fP\v'.25m'\h'-\*(#H'
  110. .ds D- D\\k:\h'-\w'D'u'\v'-.11m'\z\(hy\v'.11m'\h'|\\n:u'
  111. .ds th \*(#[\v'.3m'\s+1I\s-1\v'-.3m'\h'-(\w'I'u*2/3)'\s-1o\s+1\*(#]
  112. .ds Th \*(#[\s+2I\s-2\h'-\w'I'u*3/5'\v'-.3m'o\v'.3m'\*(#]
  113. .ds ae a\h'-(\w'a'u*4/10)'e
  114. .ds Ae A\h'-(\w'A'u*4/10)'E
  115. . \" corrections for vroff
  116. .if v .ds ~ \\k:\h'-(\\n(.wu*9/10-\*(#H)'\s-2\u~\d\s+2\h'|\\n:u'
  117. .if v .ds ^ \\k:\h'-(\\n(.wu*10/11-\*(#H)'\v'-.4m'^\v'.4m'\h'|\\n:u'
  118. . \" for low resolution devices (crt and lpr)
  119. .if \n(.H>23 .if \n(.V>19 \
  120. \{\
  121. . ds : e
  122. . ds 8 ss
  123. . ds o a
  124. . ds d- d\h'-1'\(ga
  125. . ds D- D\h'-1'\(hy
  126. . ds th \o'bp'
  127. . ds Th \o'LP'
  128. . ds ae ae
  129. . ds Ae AE
  130. .\}
  131. .rm #[ #] #H #V #F C
  132. .\" ========================================================================
  133. .\"
  134. .IX Title "LIBEV 3"
  135. .TH LIBEV 3 "2008-05-22" "libev-3.41" "libev - high perfromance full featured event loop"
  136. .\" For nroff, turn off justification. Always turn off hyphenation; it makes
  137. .\" way too many mistakes in technical documents.
  138. .if n .ad l
  139. .nh
  140. .SH "NAME"
  141. libev \- a high performance full\-featured event loop written in C
  142. .SH "SYNOPSIS"
  143. .IX Header "SYNOPSIS"
  144. .Vb 1
  145. \& #include <ev.h>
  146. .Ve
  147. .Sh "\s-1EXAMPLE\s0 \s-1PROGRAM\s0"
  148. .IX Subsection "EXAMPLE PROGRAM"
  149. .Vb 2
  150. \& // a single header file is required
  151. \& #include <ev.h>
  152. \&
  153. \& // every watcher type has its own typedef\*(Aqd struct
  154. \& // with the name ev_<type>
  155. \& ev_io stdin_watcher;
  156. \& ev_timer timeout_watcher;
  157. \&
  158. \& // all watcher callbacks have a similar signature
  159. \& // this callback is called when data is readable on stdin
  160. \& static void
  161. \& stdin_cb (EV_P_ struct ev_io *w, int revents)
  162. \& {
  163. \& puts ("stdin ready");
  164. \& // for one\-shot events, one must manually stop the watcher
  165. \& // with its corresponding stop function.
  166. \& ev_io_stop (EV_A_ w);
  167. \&
  168. \& // this causes all nested ev_loop\*(Aqs to stop iterating
  169. \& ev_unloop (EV_A_ EVUNLOOP_ALL);
  170. \& }
  171. \&
  172. \& // another callback, this time for a time\-out
  173. \& static void
  174. \& timeout_cb (EV_P_ struct ev_timer *w, int revents)
  175. \& {
  176. \& puts ("timeout");
  177. \& // this causes the innermost ev_loop to stop iterating
  178. \& ev_unloop (EV_A_ EVUNLOOP_ONE);
  179. \& }
  180. \&
  181. \& int
  182. \& main (void)
  183. \& {
  184. \& // use the default event loop unless you have special needs
  185. \& struct ev_loop *loop = ev_default_loop (0);
  186. \&
  187. \& // initialise an io watcher, then start it
  188. \& // this one will watch for stdin to become readable
  189. \& ev_io_init (&stdin_watcher, stdin_cb, /*STDIN_FILENO*/ 0, EV_READ);
  190. \& ev_io_start (loop, &stdin_watcher);
  191. \&
  192. \& // initialise a timer watcher, then start it
  193. \& // simple non\-repeating 5.5 second timeout
  194. \& ev_timer_init (&timeout_watcher, timeout_cb, 5.5, 0.);
  195. \& ev_timer_start (loop, &timeout_watcher);
  196. \&
  197. \& // now wait for events to arrive
  198. \& ev_loop (loop, 0);
  199. \&
  200. \& // unloop was called, so exit
  201. \& return 0;
  202. \& }
  203. .Ve
  204. .SH "DESCRIPTION"
  205. .IX Header "DESCRIPTION"
  206. The newest version of this document is also available as an html-formatted
  207. web page you might find easier to navigate when reading it for the first
  208. time: <http://pod.tst.eu/http://cvs.schmorp.de/libev/ev.pod>.
  209. .PP
  210. Libev is an event loop: you register interest in certain events (such as a
  211. file descriptor being readable or a timeout occurring), and it will manage
  212. these event sources and provide your program with events.
  213. .PP
  214. To do this, it must take more or less complete control over your process
  215. (or thread) by executing the \fIevent loop\fR handler, and will then
  216. communicate events via a callback mechanism.
  217. .PP
  218. You register interest in certain events by registering so-called \fIevent
  219. watchers\fR, which are relatively small C structures you initialise with the
  220. details of the event, and then hand it over to libev by \fIstarting\fR the
  221. watcher.
  222. .Sh "\s-1FEATURES\s0"
  223. .IX Subsection "FEATURES"
  224. Libev supports \f(CW\*(C`select\*(C'\fR, \f(CW\*(C`poll\*(C'\fR, the Linux-specific \f(CW\*(C`epoll\*(C'\fR, the
  225. BSD-specific \f(CW\*(C`kqueue\*(C'\fR and the Solaris-specific event port mechanisms
  226. for file descriptor events (\f(CW\*(C`ev_io\*(C'\fR), the Linux \f(CW\*(C`inotify\*(C'\fR interface
  227. (for \f(CW\*(C`ev_stat\*(C'\fR), relative timers (\f(CW\*(C`ev_timer\*(C'\fR), absolute timers
  228. with customised rescheduling (\f(CW\*(C`ev_periodic\*(C'\fR), synchronous signals
  229. (\f(CW\*(C`ev_signal\*(C'\fR), process status change events (\f(CW\*(C`ev_child\*(C'\fR), and event
  230. watchers dealing with the event loop mechanism itself (\f(CW\*(C`ev_idle\*(C'\fR,
  231. \&\f(CW\*(C`ev_embed\*(C'\fR, \f(CW\*(C`ev_prepare\*(C'\fR and \f(CW\*(C`ev_check\*(C'\fR watchers) as well as
  232. file watchers (\f(CW\*(C`ev_stat\*(C'\fR) and even limited support for fork events
  233. (\f(CW\*(C`ev_fork\*(C'\fR).
  234. .PP
  235. It also is quite fast (see this
  236. benchmark comparing it to libevent
  237. for example).
  238. .Sh "\s-1CONVENTIONS\s0"
  239. .IX Subsection "CONVENTIONS"
  240. Libev is very configurable. In this manual the default (and most common)
  241. configuration will be described, which supports multiple event loops. For
  242. more info about various configuration options please have a look at
  243. \&\fB\s-1EMBED\s0\fR section in this manual. If libev was configured without support
  244. for multiple event loops, then all functions taking an initial argument of
  245. name \f(CW\*(C`loop\*(C'\fR (which is always of type \f(CW\*(C`struct ev_loop *\*(C'\fR) will not have
  246. this argument.
  247. .Sh "\s-1TIME\s0 \s-1REPRESENTATION\s0"
  248. .IX Subsection "TIME REPRESENTATION"
  249. Libev represents time as a single floating point number, representing the
  250. (fractional) number of seconds since the (\s-1POSIX\s0) epoch (somewhere near
  251. the beginning of 1970, details are complicated, don't ask). This type is
  252. called \f(CW\*(C`ev_tstamp\*(C'\fR, which is what you should use too. It usually aliases
  253. to the \f(CW\*(C`double\*(C'\fR type in C, and when you need to do any calculations on
  254. it, you should treat it as some floatingpoint value. Unlike the name
  255. component \f(CW\*(C`stamp\*(C'\fR might indicate, it is also used for time differences
  256. throughout libev.
  257. .SH "ERROR HANDLING"
  258. .IX Header "ERROR HANDLING"
  259. Libev knows three classes of errors: operating system errors, usage errors
  260. and internal errors (bugs).
  261. .PP
  262. When libev catches an operating system error it cannot handle (for example
  263. a syscall indicating a condition libev cannot fix), it calls the callback
  264. set via \f(CW\*(C`ev_set_syserr_cb\*(C'\fR, which is supposed to fix the problem or
  265. abort. The default is to print a diagnostic message and to call \f(CW\*(C`abort
  266. ()\*(C'\fR.
  267. .PP
  268. When libev detects a usage error such as a negative timer interval, then
  269. it will print a diagnostic message and abort (via the \f(CW\*(C`assert\*(C'\fR mechanism,
  270. so \f(CW\*(C`NDEBUG\*(C'\fR will disable this checking): these are programming errors in
  271. the libev caller and need to be fixed there.
  272. .PP
  273. Libev also has a few internal error-checking \f(CW\*(C`assert\*(C'\fRions, and also has
  274. extensive consistency checking code. These do not trigger under normal
  275. circumstances, as they indicate either a bug in libev or worse.
  276. .SH "GLOBAL FUNCTIONS"
  277. .IX Header "GLOBAL FUNCTIONS"
  278. These functions can be called anytime, even before initialising the
  279. library in any way.
  280. .IP "ev_tstamp ev_time ()" 4
  281. .IX Item "ev_tstamp ev_time ()"
  282. Returns the current time as libev would use it. Please note that the
  283. \&\f(CW\*(C`ev_now\*(C'\fR function is usually faster and also often returns the timestamp
  284. you actually want to know.
  285. .IP "ev_sleep (ev_tstamp interval)" 4
  286. .IX Item "ev_sleep (ev_tstamp interval)"
  287. Sleep for the given interval: The current thread will be blocked until
  288. either it is interrupted or the given time interval has passed. Basically
  289. this is a subsecond-resolution \f(CW\*(C`sleep ()\*(C'\fR.
  290. .IP "int ev_version_major ()" 4
  291. .IX Item "int ev_version_major ()"
  292. .PD 0
  293. .IP "int ev_version_minor ()" 4
  294. .IX Item "int ev_version_minor ()"
  295. .PD
  296. You can find out the major and minor \s-1ABI\s0 version numbers of the library
  297. you linked against by calling the functions \f(CW\*(C`ev_version_major\*(C'\fR and
  298. \&\f(CW\*(C`ev_version_minor\*(C'\fR. If you want, you can compare against the global
  299. symbols \f(CW\*(C`EV_VERSION_MAJOR\*(C'\fR and \f(CW\*(C`EV_VERSION_MINOR\*(C'\fR, which specify the
  300. version of the library your program was compiled against.
  301. .Sp
  302. These version numbers refer to the \s-1ABI\s0 version of the library, not the
  303. release version.
  304. .Sp
  305. Usually, it's a good idea to terminate if the major versions mismatch,
  306. as this indicates an incompatible change. Minor versions are usually
  307. compatible to older versions, so a larger minor version alone is usually
  308. not a problem.
  309. .Sp
  310. Example: Make sure we haven't accidentally been linked against the wrong
  311. version.
  312. .Sp
  313. .Vb 3
  314. \& assert (("libev version mismatch",
  315. \& ev_version_major () == EV_VERSION_MAJOR
  316. \& && ev_version_minor () >= EV_VERSION_MINOR));
  317. .Ve
  318. .IP "unsigned int ev_supported_backends ()" 4
  319. .IX Item "unsigned int ev_supported_backends ()"
  320. Return the set of all backends (i.e. their corresponding \f(CW\*(C`EV_BACKEND_*\*(C'\fR
  321. value) compiled into this binary of libev (independent of their
  322. availability on the system you are running on). See \f(CW\*(C`ev_default_loop\*(C'\fR for
  323. a description of the set values.
  324. .Sp
  325. Example: make sure we have the epoll method, because yeah this is cool and
  326. a must have and can we have a torrent of it please!!!11
  327. .Sp
  328. .Vb 2
  329. \& assert (("sorry, no epoll, no sex",
  330. \& ev_supported_backends () & EVBACKEND_EPOLL));
  331. .Ve
  332. .IP "unsigned int ev_recommended_backends ()" 4
  333. .IX Item "unsigned int ev_recommended_backends ()"
  334. Return the set of all backends compiled into this binary of libev and also
  335. recommended for this platform. This set is often smaller than the one
  336. returned by \f(CW\*(C`ev_supported_backends\*(C'\fR, as for example kqueue is broken on
  337. most BSDs and will not be autodetected unless you explicitly request it
  338. (assuming you know what you are doing). This is the set of backends that
  339. libev will probe for if you specify no backends explicitly.
  340. .IP "unsigned int ev_embeddable_backends ()" 4
  341. .IX Item "unsigned int ev_embeddable_backends ()"
  342. Returns the set of backends that are embeddable in other event loops. This
  343. is the theoretical, all-platform, value. To find which backends
  344. might be supported on the current system, you would need to look at
  345. \&\f(CW\*(C`ev_embeddable_backends () & ev_supported_backends ()\*(C'\fR, likewise for
  346. recommended ones.
  347. .Sp
  348. See the description of \f(CW\*(C`ev_embed\*(C'\fR watchers for more info.
  349. .IP "ev_set_allocator (void *(*cb)(void *ptr, long size))" 4
  350. .IX Item "ev_set_allocator (void *(*cb)(void *ptr, long size))"
  351. Sets the allocation function to use (the prototype is similar \- the
  352. semantics are identical to the \f(CW\*(C`realloc\*(C'\fR C89/SuS/POSIX function). It is
  353. used to allocate and free memory (no surprises here). If it returns zero
  354. when memory needs to be allocated (\f(CW\*(C`size != 0\*(C'\fR), the library might abort
  355. or take some potentially destructive action.
  356. .Sp
  357. Since some systems (at least OpenBSD and Darwin) fail to implement
  358. correct \f(CW\*(C`realloc\*(C'\fR semantics, libev will use a wrapper around the system
  359. \&\f(CW\*(C`realloc\*(C'\fR and \f(CW\*(C`free\*(C'\fR functions by default.
  360. .Sp
  361. You could override this function in high-availability programs to, say,
  362. free some memory if it cannot allocate memory, to use a special allocator,
  363. or even to sleep a while and retry until some memory is available.
  364. .Sp
  365. Example: Replace the libev allocator with one that waits a bit and then
  366. retries (example requires a standards-compliant \f(CW\*(C`realloc\*(C'\fR).
  367. .Sp
  368. .Vb 6
  369. \& static void *
  370. \& persistent_realloc (void *ptr, size_t size)
  371. \& {
  372. \& for (;;)
  373. \& {
  374. \& void *newptr = realloc (ptr, size);
  375. \&
  376. \& if (newptr)
  377. \& return newptr;
  378. \&
  379. \& sleep (60);
  380. \& }
  381. \& }
  382. \&
  383. \& ...
  384. \& ev_set_allocator (persistent_realloc);
  385. .Ve
  386. .IP "ev_set_syserr_cb (void (*cb)(const char *msg));" 4
  387. .IX Item "ev_set_syserr_cb (void (*cb)(const char *msg));"
  388. Set the callback function to call on a retryable syscall error (such
  389. as failed select, poll, epoll_wait). The message is a printable string
  390. indicating the system call or subsystem causing the problem. If this
  391. callback is set, then libev will expect it to remedy the sitution, no
  392. matter what, when it returns. That is, libev will generally retry the
  393. requested operation, or, if the condition doesn't go away, do bad stuff
  394. (such as abort).
  395. .Sp
  396. Example: This is basically the same thing that libev does internally, too.
  397. .Sp
  398. .Vb 6
  399. \& static void
  400. \& fatal_error (const char *msg)
  401. \& {
  402. \& perror (msg);
  403. \& abort ();
  404. \& }
  405. \&
  406. \& ...
  407. \& ev_set_syserr_cb (fatal_error);
  408. .Ve
  409. .SH "FUNCTIONS CONTROLLING THE EVENT LOOP"
  410. .IX Header "FUNCTIONS CONTROLLING THE EVENT LOOP"
  411. An event loop is described by a \f(CW\*(C`struct ev_loop *\*(C'\fR. The library knows two
  412. types of such loops, the \fIdefault\fR loop, which supports signals and child
  413. events, and dynamically created loops which do not.
  414. .IP "struct ev_loop *ev_default_loop (unsigned int flags)" 4
  415. .IX Item "struct ev_loop *ev_default_loop (unsigned int flags)"
  416. This will initialise the default event loop if it hasn't been initialised
  417. yet and return it. If the default loop could not be initialised, returns
  418. false. If it already was initialised it simply returns it (and ignores the
  419. flags. If that is troubling you, check \f(CW\*(C`ev_backend ()\*(C'\fR afterwards).
  420. .Sp
  421. If you don't know what event loop to use, use the one returned from this
  422. function.
  423. .Sp
  424. Note that this function is \fInot\fR thread-safe, so if you want to use it
  425. from multiple threads, you have to lock (note also that this is unlikely,
  426. as loops cannot bes hared easily between threads anyway).
  427. .Sp
  428. The default loop is the only loop that can handle \f(CW\*(C`ev_signal\*(C'\fR and
  429. \&\f(CW\*(C`ev_child\*(C'\fR watchers, and to do this, it always registers a handler
  430. for \f(CW\*(C`SIGCHLD\*(C'\fR. If this is a problem for your app you can either
  431. create a dynamic loop with \f(CW\*(C`ev_loop_new\*(C'\fR that doesn't do that, or you
  432. can simply overwrite the \f(CW\*(C`SIGCHLD\*(C'\fR signal handler \fIafter\fR calling
  433. \&\f(CW\*(C`ev_default_init\*(C'\fR.
  434. .Sp
  435. The flags argument can be used to specify special behaviour or specific
  436. backends to use, and is usually specified as \f(CW0\fR (or \f(CW\*(C`EVFLAG_AUTO\*(C'\fR).
  437. .Sp
  438. The following flags are supported:
  439. .RS 4
  440. .ie n .IP """EVFLAG_AUTO""" 4
  441. .el .IP "\f(CWEVFLAG_AUTO\fR" 4
  442. .IX Item "EVFLAG_AUTO"
  443. The default flags value. Use this if you have no clue (it's the right
  444. thing, believe me).
  445. .ie n .IP """EVFLAG_NOENV""" 4
  446. .el .IP "\f(CWEVFLAG_NOENV\fR" 4
  447. .IX Item "EVFLAG_NOENV"
  448. If this flag bit is ored into the flag value (or the program runs setuid
  449. or setgid) then libev will \fInot\fR look at the environment variable
  450. \&\f(CW\*(C`LIBEV_FLAGS\*(C'\fR. Otherwise (the default), this environment variable will
  451. override the flags completely if it is found in the environment. This is
  452. useful to try out specific backends to test their performance, or to work
  453. around bugs.
  454. .ie n .IP """EVFLAG_FORKCHECK""" 4
  455. .el .IP "\f(CWEVFLAG_FORKCHECK\fR" 4
  456. .IX Item "EVFLAG_FORKCHECK"
  457. Instead of calling \f(CW\*(C`ev_default_fork\*(C'\fR or \f(CW\*(C`ev_loop_fork\*(C'\fR manually after
  458. a fork, you can also make libev check for a fork in each iteration by
  459. enabling this flag.
  460. .Sp
  461. This works by calling \f(CW\*(C`getpid ()\*(C'\fR on every iteration of the loop,
  462. and thus this might slow down your event loop if you do a lot of loop
  463. iterations and little real work, but is usually not noticeable (on my
  464. GNU/Linux system for example, \f(CW\*(C`getpid\*(C'\fR is actually a simple 5\-insn sequence
  465. without a syscall and thus \fIvery\fR fast, but my GNU/Linux system also has
  466. \&\f(CW\*(C`pthread_atfork\*(C'\fR which is even faster).
  467. .Sp
  468. The big advantage of this flag is that you can forget about fork (and
  469. forget about forgetting to tell libev about forking) when you use this
  470. flag.
  471. .Sp
  472. This flag setting cannot be overriden or specified in the \f(CW\*(C`LIBEV_FLAGS\*(C'\fR
  473. environment variable.
  474. .ie n .IP """EVBACKEND_SELECT"" (value 1, portable select backend)" 4
  475. .el .IP "\f(CWEVBACKEND_SELECT\fR (value 1, portable select backend)" 4
  476. .IX Item "EVBACKEND_SELECT (value 1, portable select backend)"
  477. This is your standard \fIselect\fR\|(2) backend. Not \fIcompletely\fR standard, as
  478. libev tries to roll its own fd_set with no limits on the number of fds,
  479. but if that fails, expect a fairly low limit on the number of fds when
  480. using this backend. It doesn't scale too well (O(highest_fd)), but its
  481. usually the fastest backend for a low number of (low-numbered :) fds.
  482. .Sp
  483. To get good performance out of this backend you need a high amount of
  484. parallelity (most of the file descriptors should be busy). If you are
  485. writing a server, you should \f(CW\*(C`accept ()\*(C'\fR in a loop to accept as many
  486. connections as possible during one iteration. You might also want to have
  487. a look at \f(CW\*(C`ev_set_io_collect_interval ()\*(C'\fR to increase the amount of
  488. readiness notifications you get per iteration.
  489. .ie n .IP """EVBACKEND_POLL"" (value 2, poll backend, available everywhere except on windows)" 4
  490. .el .IP "\f(CWEVBACKEND_POLL\fR (value 2, poll backend, available everywhere except on windows)" 4
  491. .IX Item "EVBACKEND_POLL (value 2, poll backend, available everywhere except on windows)"
  492. And this is your standard \fIpoll\fR\|(2) backend. It's more complicated
  493. than select, but handles sparse fds better and has no artificial
  494. limit on the number of fds you can use (except it will slow down
  495. considerably with a lot of inactive fds). It scales similarly to select,
  496. i.e. O(total_fds). See the entry for \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR, above, for
  497. performance tips.
  498. .ie n .IP """EVBACKEND_EPOLL"" (value 4, Linux)" 4
  499. .el .IP "\f(CWEVBACKEND_EPOLL\fR (value 4, Linux)" 4
  500. .IX Item "EVBACKEND_EPOLL (value 4, Linux)"
  501. For few fds, this backend is a bit little slower than poll and select,
  502. but it scales phenomenally better. While poll and select usually scale
  503. like O(total_fds) where n is the total number of fds (or the highest fd),
  504. epoll scales either O(1) or O(active_fds). The epoll design has a number
  505. of shortcomings, such as silently dropping events in some hard-to-detect
  506. cases and requiring a syscall per fd change, no fork support and bad
  507. support for dup.
  508. .Sp
  509. While stopping, setting and starting an I/O watcher in the same iteration
  510. will result in some caching, there is still a syscall per such incident
  511. (because the fd could point to a different file description now), so its
  512. best to avoid that. Also, \f(CW\*(C`dup ()\*(C'\fR'ed file descriptors might not work
  513. very well if you register events for both fds.
  514. .Sp
  515. Please note that epoll sometimes generates spurious notifications, so you
  516. need to use non-blocking I/O or other means to avoid blocking when no data
  517. (or space) is available.
  518. .Sp
  519. Best performance from this backend is achieved by not unregistering all
  520. watchers for a file descriptor until it has been closed, if possible, i.e.
  521. keep at least one watcher active per fd at all times.
  522. .Sp
  523. While nominally embeddeble in other event loops, this feature is broken in
  524. all kernel versions tested so far.
  525. .ie n .IP """EVBACKEND_KQUEUE"" (value 8, most \s-1BSD\s0 clones)" 4
  526. .el .IP "\f(CWEVBACKEND_KQUEUE\fR (value 8, most \s-1BSD\s0 clones)" 4
  527. .IX Item "EVBACKEND_KQUEUE (value 8, most BSD clones)"
  528. Kqueue deserves special mention, as at the time of this writing, it
  529. was broken on all BSDs except NetBSD (usually it doesn't work reliably
  530. with anything but sockets and pipes, except on Darwin, where of course
  531. it's completely useless). For this reason it's not being \*(L"autodetected\*(R"
  532. unless you explicitly specify it explicitly in the flags (i.e. using
  533. \&\f(CW\*(C`EVBACKEND_KQUEUE\*(C'\fR) or libev was compiled on a known-to-be-good (\-enough)
  534. system like NetBSD.
  535. .Sp
  536. You still can embed kqueue into a normal poll or select backend and use it
  537. only for sockets (after having made sure that sockets work with kqueue on
  538. the target platform). See \f(CW\*(C`ev_embed\*(C'\fR watchers for more info.
  539. .Sp
  540. It scales in the same way as the epoll backend, but the interface to the
  541. kernel is more efficient (which says nothing about its actual speed, of
  542. course). While stopping, setting and starting an I/O watcher does never
  543. cause an extra syscall as with \f(CW\*(C`EVBACKEND_EPOLL\*(C'\fR, it still adds up to
  544. two event changes per incident, support for \f(CW\*(C`fork ()\*(C'\fR is very bad and it
  545. drops fds silently in similarly hard-to-detect cases.
  546. .Sp
  547. This backend usually performs well under most conditions.
  548. .Sp
  549. While nominally embeddable in other event loops, this doesn't work
  550. everywhere, so you might need to test for this. And since it is broken
  551. almost everywhere, you should only use it when you have a lot of sockets
  552. (for which it usually works), by embedding it into another event loop
  553. (e.g. \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or \f(CW\*(C`EVBACKEND_POLL\*(C'\fR) and using it only for
  554. sockets.
  555. .ie n .IP """EVBACKEND_DEVPOLL"" (value 16, Solaris 8)" 4
  556. .el .IP "\f(CWEVBACKEND_DEVPOLL\fR (value 16, Solaris 8)" 4
  557. .IX Item "EVBACKEND_DEVPOLL (value 16, Solaris 8)"
  558. This is not implemented yet (and might never be, unless you send me an
  559. implementation). According to reports, \f(CW\*(C`/dev/poll\*(C'\fR only supports sockets
  560. and is not embeddable, which would limit the usefulness of this backend
  561. immensely.
  562. .ie n .IP """EVBACKEND_PORT"" (value 32, Solaris 10)" 4
  563. .el .IP "\f(CWEVBACKEND_PORT\fR (value 32, Solaris 10)" 4
  564. .IX Item "EVBACKEND_PORT (value 32, Solaris 10)"
  565. This uses the Solaris 10 event port mechanism. As with everything on Solaris,
  566. it's really slow, but it still scales very well (O(active_fds)).
  567. .Sp
  568. Please note that solaris event ports can deliver a lot of spurious
  569. notifications, so you need to use non-blocking I/O or other means to avoid
  570. blocking when no data (or space) is available.
  571. .Sp
  572. While this backend scales well, it requires one system call per active
  573. file descriptor per loop iteration. For small and medium numbers of file
  574. descriptors a \*(L"slow\*(R" \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or \f(CW\*(C`EVBACKEND_POLL\*(C'\fR backend
  575. might perform better.
  576. .Sp
  577. On the positive side, ignoring the spurious readiness notifications, this
  578. backend actually performed to specification in all tests and is fully
  579. embeddable, which is a rare feat among the OS-specific backends.
  580. .ie n .IP """EVBACKEND_ALL""" 4
  581. .el .IP "\f(CWEVBACKEND_ALL\fR" 4
  582. .IX Item "EVBACKEND_ALL"
  583. Try all backends (even potentially broken ones that wouldn't be tried
  584. with \f(CW\*(C`EVFLAG_AUTO\*(C'\fR). Since this is a mask, you can do stuff such as
  585. \&\f(CW\*(C`EVBACKEND_ALL & ~EVBACKEND_KQUEUE\*(C'\fR.
  586. .Sp
  587. It is definitely not recommended to use this flag.
  588. .RE
  589. .RS 4
  590. .Sp
  591. If one or more of these are ored into the flags value, then only these
  592. backends will be tried (in the reverse order as listed here). If none are
  593. specified, all backends in \f(CW\*(C`ev_recommended_backends ()\*(C'\fR will be tried.
  594. .Sp
  595. The most typical usage is like this:
  596. .Sp
  597. .Vb 2
  598. \& if (!ev_default_loop (0))
  599. \& fatal ("could not initialise libev, bad $LIBEV_FLAGS in environment?");
  600. .Ve
  601. .Sp
  602. Restrict libev to the select and poll backends, and do not allow
  603. environment settings to be taken into account:
  604. .Sp
  605. .Vb 1
  606. \& ev_default_loop (EVBACKEND_POLL | EVBACKEND_SELECT | EVFLAG_NOENV);
  607. .Ve
  608. .Sp
  609. Use whatever libev has to offer, but make sure that kqueue is used if
  610. available (warning, breaks stuff, best use only with your own private
  611. event loop and only if you know the \s-1OS\s0 supports your types of fds):
  612. .Sp
  613. .Vb 1
  614. \& ev_default_loop (ev_recommended_backends () | EVBACKEND_KQUEUE);
  615. .Ve
  616. .RE
  617. .IP "struct ev_loop *ev_loop_new (unsigned int flags)" 4
  618. .IX Item "struct ev_loop *ev_loop_new (unsigned int flags)"
  619. Similar to \f(CW\*(C`ev_default_loop\*(C'\fR, but always creates a new event loop that is
  620. always distinct from the default loop. Unlike the default loop, it cannot
  621. handle signal and child watchers, and attempts to do so will be greeted by
  622. undefined behaviour (or a failed assertion if assertions are enabled).
  623. .Sp
  624. Note that this function \fIis\fR thread-safe, and the recommended way to use
  625. libev with threads is indeed to create one loop per thread, and using the
  626. default loop in the \*(L"main\*(R" or \*(L"initial\*(R" thread.
  627. .Sp
  628. Example: Try to create a event loop that uses epoll and nothing else.
  629. .Sp
  630. .Vb 3
  631. \& struct ev_loop *epoller = ev_loop_new (EVBACKEND_EPOLL | EVFLAG_NOENV);
  632. \& if (!epoller)
  633. \& fatal ("no epoll found here, maybe it hides under your chair");
  634. .Ve
  635. .IP "ev_default_destroy ()" 4
  636. .IX Item "ev_default_destroy ()"
  637. Destroys the default loop again (frees all memory and kernel state
  638. etc.). None of the active event watchers will be stopped in the normal
  639. sense, so e.g. \f(CW\*(C`ev_is_active\*(C'\fR might still return true. It is your
  640. responsibility to either stop all watchers cleanly yoursef \fIbefore\fR
  641. calling this function, or cope with the fact afterwards (which is usually
  642. the easiest thing, you can just ignore the watchers and/or \f(CW\*(C`free ()\*(C'\fR them
  643. for example).
  644. .Sp
  645. Note that certain global state, such as signal state, will not be freed by
  646. this function, and related watchers (such as signal and child watchers)
  647. would need to be stopped manually.
  648. .Sp
  649. In general it is not advisable to call this function except in the
  650. rare occasion where you really need to free e.g. the signal handling
  651. pipe fds. If you need dynamically allocated loops it is better to use
  652. \&\f(CW\*(C`ev_loop_new\*(C'\fR and \f(CW\*(C`ev_loop_destroy\*(C'\fR).
  653. .IP "ev_loop_destroy (loop)" 4
  654. .IX Item "ev_loop_destroy (loop)"
  655. Like \f(CW\*(C`ev_default_destroy\*(C'\fR, but destroys an event loop created by an
  656. earlier call to \f(CW\*(C`ev_loop_new\*(C'\fR.
  657. .IP "ev_default_fork ()" 4
  658. .IX Item "ev_default_fork ()"
  659. This function sets a flag that causes subsequent \f(CW\*(C`ev_loop\*(C'\fR iterations
  660. to reinitialise the kernel state for backends that have one. Despite the
  661. name, you can call it anytime, but it makes most sense after forking, in
  662. the child process (or both child and parent, but that again makes little
  663. sense). You \fImust\fR call it in the child before using any of the libev
  664. functions, and it will only take effect at the next \f(CW\*(C`ev_loop\*(C'\fR iteration.
  665. .Sp
  666. On the other hand, you only need to call this function in the child
  667. process if and only if you want to use the event library in the child. If
  668. you just fork+exec, you don't have to call it at all.
  669. .Sp
  670. The function itself is quite fast and it's usually not a problem to call
  671. it just in case after a fork. To make this easy, the function will fit in
  672. quite nicely into a call to \f(CW\*(C`pthread_atfork\*(C'\fR:
  673. .Sp
  674. .Vb 1
  675. \& pthread_atfork (0, 0, ev_default_fork);
  676. .Ve
  677. .IP "ev_loop_fork (loop)" 4
  678. .IX Item "ev_loop_fork (loop)"
  679. Like \f(CW\*(C`ev_default_fork\*(C'\fR, but acts on an event loop created by
  680. \&\f(CW\*(C`ev_loop_new\*(C'\fR. Yes, you have to call this on every allocated event loop
  681. after fork, and how you do this is entirely your own problem.
  682. .IP "int ev_is_default_loop (loop)" 4
  683. .IX Item "int ev_is_default_loop (loop)"
  684. Returns true when the given loop actually is the default loop, false otherwise.
  685. .IP "unsigned int ev_loop_count (loop)" 4
  686. .IX Item "unsigned int ev_loop_count (loop)"
  687. Returns the count of loop iterations for the loop, which is identical to
  688. the number of times libev did poll for new events. It starts at \f(CW0\fR and
  689. happily wraps around with enough iterations.
  690. .Sp
  691. This value can sometimes be useful as a generation counter of sorts (it
  692. \&\*(L"ticks\*(R" the number of loop iterations), as it roughly corresponds with
  693. \&\f(CW\*(C`ev_prepare\*(C'\fR and \f(CW\*(C`ev_check\*(C'\fR calls.
  694. .IP "unsigned int ev_backend (loop)" 4
  695. .IX Item "unsigned int ev_backend (loop)"
  696. Returns one of the \f(CW\*(C`EVBACKEND_*\*(C'\fR flags indicating the event backend in
  697. use.
  698. .IP "ev_tstamp ev_now (loop)" 4
  699. .IX Item "ev_tstamp ev_now (loop)"
  700. Returns the current \*(L"event loop time\*(R", which is the time the event loop
  701. received events and started processing them. This timestamp does not
  702. change as long as callbacks are being processed, and this is also the base
  703. time used for relative timers. You can treat it as the timestamp of the
  704. event occurring (or more correctly, libev finding out about it).
  705. .IP "ev_loop (loop, int flags)" 4
  706. .IX Item "ev_loop (loop, int flags)"
  707. Finally, this is it, the event handler. This function usually is called
  708. after you initialised all your watchers and you want to start handling
  709. events.
  710. .Sp
  711. If the flags argument is specified as \f(CW0\fR, it will not return until
  712. either no event watchers are active anymore or \f(CW\*(C`ev_unloop\*(C'\fR was called.
  713. .Sp
  714. Please note that an explicit \f(CW\*(C`ev_unloop\*(C'\fR is usually better than
  715. relying on all watchers to be stopped when deciding when a program has
  716. finished (especially in interactive programs), but having a program that
  717. automatically loops as long as it has to and no longer by virtue of
  718. relying on its watchers stopping correctly is a thing of beauty.
  719. .Sp
  720. A flags value of \f(CW\*(C`EVLOOP_NONBLOCK\*(C'\fR will look for new events, will handle
  721. those events and any outstanding ones, but will not block your process in
  722. case there are no events and will return after one iteration of the loop.
  723. .Sp
  724. A flags value of \f(CW\*(C`EVLOOP_ONESHOT\*(C'\fR will look for new events (waiting if
  725. neccessary) and will handle those and any outstanding ones. It will block
  726. your process until at least one new event arrives, and will return after
  727. one iteration of the loop. This is useful if you are waiting for some
  728. external event in conjunction with something not expressible using other
  729. libev watchers. However, a pair of \f(CW\*(C`ev_prepare\*(C'\fR/\f(CW\*(C`ev_check\*(C'\fR watchers is
  730. usually a better approach for this kind of thing.
  731. .Sp
  732. Here are the gory details of what \f(CW\*(C`ev_loop\*(C'\fR does:
  733. .Sp
  734. .Vb 10
  735. \& \- Before the first iteration, call any pending watchers.
  736. \& * If EVFLAG_FORKCHECK was used, check for a fork.
  737. \& \- If a fork was detected, queue and call all fork watchers.
  738. \& \- Queue and call all prepare watchers.
  739. \& \- If we have been forked, recreate the kernel state.
  740. \& \- Update the kernel state with all outstanding changes.
  741. \& \- Update the "event loop time".
  742. \& \- Calculate for how long to sleep or block, if at all
  743. \& (active idle watchers, EVLOOP_NONBLOCK or not having
  744. \& any active watchers at all will result in not sleeping).
  745. \& \- Sleep if the I/O and timer collect interval say so.
  746. \& \- Block the process, waiting for any events.
  747. \& \- Queue all outstanding I/O (fd) events.
  748. \& \- Update the "event loop time" and do time jump handling.
  749. \& \- Queue all outstanding timers.
  750. \& \- Queue all outstanding periodics.
  751. \& \- If no events are pending now, queue all idle watchers.
  752. \& \- Queue all check watchers.
  753. \& \- Call all queued watchers in reverse order (i.e. check watchers first).
  754. \& Signals and child watchers are implemented as I/O watchers, and will
  755. \& be handled here by queueing them when their watcher gets executed.
  756. \& \- If ev_unloop has been called, or EVLOOP_ONESHOT or EVLOOP_NONBLOCK
  757. \& were used, or there are no active watchers, return, otherwise
  758. \& continue with step *.
  759. .Ve
  760. .Sp
  761. Example: Queue some jobs and then loop until no events are outstanding
  762. anymore.
  763. .Sp
  764. .Vb 4
  765. \& ... queue jobs here, make sure they register event watchers as long
  766. \& ... as they still have work to do (even an idle watcher will do..)
  767. \& ev_loop (my_loop, 0);
  768. \& ... jobs done. yeah!
  769. .Ve
  770. .IP "ev_unloop (loop, how)" 4
  771. .IX Item "ev_unloop (loop, how)"
  772. Can be used to make a call to \f(CW\*(C`ev_loop\*(C'\fR return early (but only after it
  773. has processed all outstanding events). The \f(CW\*(C`how\*(C'\fR argument must be either
  774. \&\f(CW\*(C`EVUNLOOP_ONE\*(C'\fR, which will make the innermost \f(CW\*(C`ev_loop\*(C'\fR call return, or
  775. \&\f(CW\*(C`EVUNLOOP_ALL\*(C'\fR, which will make all nested \f(CW\*(C`ev_loop\*(C'\fR calls return.
  776. .Sp
  777. This \*(L"unloop state\*(R" will be cleared when entering \f(CW\*(C`ev_loop\*(C'\fR again.
  778. .IP "ev_ref (loop)" 4
  779. .IX Item "ev_ref (loop)"
  780. .PD 0
  781. .IP "ev_unref (loop)" 4
  782. .IX Item "ev_unref (loop)"
  783. .PD
  784. Ref/unref can be used to add or remove a reference count on the event
  785. loop: Every watcher keeps one reference, and as long as the reference
  786. count is nonzero, \f(CW\*(C`ev_loop\*(C'\fR will not return on its own. If you have
  787. a watcher you never unregister that should not keep \f(CW\*(C`ev_loop\*(C'\fR from
  788. returning, \fIev_unref()\fR after starting, and \fIev_ref()\fR before stopping it. For
  789. example, libev itself uses this for its internal signal pipe: It is not
  790. visible to the libev user and should not keep \f(CW\*(C`ev_loop\*(C'\fR from exiting if
  791. no event watchers registered by it are active. It is also an excellent
  792. way to do this for generic recurring timers or from within third-party
  793. libraries. Just remember to \fIunref after start\fR and \fIref before stop\fR
  794. (but only if the watcher wasn't active before, or was active before,
  795. respectively).
  796. .Sp
  797. Example: Create a signal watcher, but keep it from keeping \f(CW\*(C`ev_loop\*(C'\fR
  798. running when nothing else is active.
  799. .Sp
  800. .Vb 4
  801. \& struct ev_signal exitsig;
  802. \& ev_signal_init (&exitsig, sig_cb, SIGINT);
  803. \& ev_signal_start (loop, &exitsig);
  804. \& evf_unref (loop);
  805. .Ve
  806. .Sp
  807. Example: For some weird reason, unregister the above signal handler again.
  808. .Sp
  809. .Vb 2
  810. \& ev_ref (loop);
  811. \& ev_signal_stop (loop, &exitsig);
  812. .Ve
  813. .IP "ev_set_io_collect_interval (loop, ev_tstamp interval)" 4
  814. .IX Item "ev_set_io_collect_interval (loop, ev_tstamp interval)"
  815. .PD 0
  816. .IP "ev_set_timeout_collect_interval (loop, ev_tstamp interval)" 4
  817. .IX Item "ev_set_timeout_collect_interval (loop, ev_tstamp interval)"
  818. .PD
  819. These advanced functions influence the time that libev will spend waiting
  820. for events. Both are by default \f(CW0\fR, meaning that libev will try to
  821. invoke timer/periodic callbacks and I/O callbacks with minimum latency.
  822. .Sp
  823. Setting these to a higher value (the \f(CW\*(C`interval\*(C'\fR \fImust\fR be >= \f(CW0\fR)
  824. allows libev to delay invocation of I/O and timer/periodic callbacks to
  825. increase efficiency of loop iterations.
  826. .Sp
  827. The background is that sometimes your program runs just fast enough to
  828. handle one (or very few) event(s) per loop iteration. While this makes
  829. the program responsive, it also wastes a lot of \s-1CPU\s0 time to poll for new
  830. events, especially with backends like \f(CW\*(C`select ()\*(C'\fR which have a high
  831. overhead for the actual polling but can deliver many events at once.
  832. .Sp
  833. By setting a higher \fIio collect interval\fR you allow libev to spend more
  834. time collecting I/O events, so you can handle more events per iteration,
  835. at the cost of increasing latency. Timeouts (both \f(CW\*(C`ev_periodic\*(C'\fR and
  836. \&\f(CW\*(C`ev_timer\*(C'\fR) will be not affected. Setting this to a non-null value will
  837. introduce an additional \f(CW\*(C`ev_sleep ()\*(C'\fR call into most loop iterations.
  838. .Sp
  839. Likewise, by setting a higher \fItimeout collect interval\fR you allow libev
  840. to spend more time collecting timeouts, at the expense of increased
  841. latency (the watcher callback will be called later). \f(CW\*(C`ev_io\*(C'\fR watchers
  842. will not be affected. Setting this to a non-null value will not introduce
  843. any overhead in libev.
  844. .Sp
  845. Many (busy) programs can usually benefit by setting the io collect
  846. interval to a value near \f(CW0.1\fR or so, which is often enough for
  847. interactive servers (of course not for games), likewise for timeouts. It
  848. usually doesn't make much sense to set it to a lower value than \f(CW0.01\fR,
  849. as this approsaches the timing granularity of most systems.
  850. .IP "ev_loop_verify (loop)" 4
  851. .IX Item "ev_loop_verify (loop)"
  852. This function only does something when \f(CW\*(C`EV_VERIFY\*(C'\fR support has been
  853. compiled in. It tries to go through all internal structures and checks
  854. them for validity. If anything is found to be inconsistent, it will print
  855. an error message to standard error and call \f(CW\*(C`abort ()\*(C'\fR.
  856. .Sp
  857. This can be used to catch bugs inside libev itself: under normal
  858. circumstances, this function will never abort as of course libev keeps its
  859. data structures consistent.
  860. .SH "ANATOMY OF A WATCHER"
  861. .IX Header "ANATOMY OF A WATCHER"
  862. A watcher is a structure that you create and register to record your
  863. interest in some event. For instance, if you want to wait for \s-1STDIN\s0 to
  864. become readable, you would create an \f(CW\*(C`ev_io\*(C'\fR watcher for that:
  865. .PP
  866. .Vb 5
  867. \& static void my_cb (struct ev_loop *loop, struct ev_io *w, int revents)
  868. \& {
  869. \& ev_io_stop (w);
  870. \& ev_unloop (loop, EVUNLOOP_ALL);
  871. \& }
  872. \&
  873. \& struct ev_loop *loop = ev_default_loop (0);
  874. \& struct ev_io stdin_watcher;
  875. \& ev_init (&stdin_watcher, my_cb);
  876. \& ev_io_set (&stdin_watcher, STDIN_FILENO, EV_READ);
  877. \& ev_io_start (loop, &stdin_watcher);
  878. \& ev_loop (loop, 0);
  879. .Ve
  880. .PP
  881. As you can see, you are responsible for allocating the memory for your
  882. watcher structures (and it is usually a bad idea to do this on the stack,
  883. although this can sometimes be quite valid).
  884. .PP
  885. Each watcher structure must be initialised by a call to \f(CW\*(C`ev_init
  886. (watcher *, callback)\*(C'\fR, which expects a callback to be provided. This
  887. callback gets invoked each time the event occurs (or, in the case of io
  888. watchers, each time the event loop detects that the file descriptor given
  889. is readable and/or writable).
  890. .PP
  891. Each watcher type has its own \f(CW\*(C`ev_<type>_set (watcher *, ...)\*(C'\fR macro
  892. with arguments specific to this watcher type. There is also a macro
  893. to combine initialisation and setting in one call: \f(CW\*(C`ev_<type>_init
  894. (watcher *, callback, ...)\*(C'\fR.
  895. .PP
  896. To make the watcher actually watch out for events, you have to start it
  897. with a watcher-specific start function (\f(CW\*(C`ev_<type>_start (loop, watcher
  898. *)\*(C'\fR), and you can stop watching for events at any time by calling the
  899. corresponding stop function (\f(CW\*(C`ev_<type>_stop (loop, watcher *)\*(C'\fR.
  900. .PP
  901. As long as your watcher is active (has been started but not stopped) you
  902. must not touch the values stored in it. Most specifically you must never
  903. reinitialise it or call its \f(CW\*(C`set\*(C'\fR macro.
  904. .PP
  905. Each and every callback receives the event loop pointer as first, the
  906. registered watcher structure as second, and a bitset of received events as
  907. third argument.
  908. .PP
  909. The received events usually include a single bit per event type received
  910. (you can receive multiple events at the same time). The possible bit masks
  911. are:
  912. .ie n .IP """EV_READ""" 4
  913. .el .IP "\f(CWEV_READ\fR" 4
  914. .IX Item "EV_READ"
  915. .PD 0
  916. .ie n .IP """EV_WRITE""" 4
  917. .el .IP "\f(CWEV_WRITE\fR" 4
  918. .IX Item "EV_WRITE"
  919. .PD
  920. The file descriptor in the \f(CW\*(C`ev_io\*(C'\fR watcher has become readable and/or
  921. writable.
  922. .ie n .IP """EV_TIMEOUT""" 4
  923. .el .IP "\f(CWEV_TIMEOUT\fR" 4
  924. .IX Item "EV_TIMEOUT"
  925. The \f(CW\*(C`ev_timer\*(C'\fR watcher has timed out.
  926. .ie n .IP """EV_PERIODIC""" 4
  927. .el .IP "\f(CWEV_PERIODIC\fR" 4
  928. .IX Item "EV_PERIODIC"
  929. The \f(CW\*(C`ev_periodic\*(C'\fR watcher has timed out.
  930. .ie n .IP """EV_SIGNAL""" 4
  931. .el .IP "\f(CWEV_SIGNAL\fR" 4
  932. .IX Item "EV_SIGNAL"
  933. The signal specified in the \f(CW\*(C`ev_signal\*(C'\fR watcher has been received by a thread.
  934. .ie n .IP """EV_CHILD""" 4
  935. .el .IP "\f(CWEV_CHILD\fR" 4
  936. .IX Item "EV_CHILD"
  937. The pid specified in the \f(CW\*(C`ev_child\*(C'\fR watcher has received a status change.
  938. .ie n .IP """EV_STAT""" 4
  939. .el .IP "\f(CWEV_STAT\fR" 4
  940. .IX Item "EV_STAT"
  941. The path specified in the \f(CW\*(C`ev_stat\*(C'\fR watcher changed its attributes somehow.
  942. .ie n .IP """EV_IDLE""" 4
  943. .el .IP "\f(CWEV_IDLE\fR" 4
  944. .IX Item "EV_IDLE"
  945. The \f(CW\*(C`ev_idle\*(C'\fR watcher has determined that you have nothing better to do.
  946. .ie n .IP """EV_PREPARE""" 4
  947. .el .IP "\f(CWEV_PREPARE\fR" 4
  948. .IX Item "EV_PREPARE"
  949. .PD 0
  950. .ie n .IP """EV_CHECK""" 4
  951. .el .IP "\f(CWEV_CHECK\fR" 4
  952. .IX Item "EV_CHECK"
  953. .PD
  954. All \f(CW\*(C`ev_prepare\*(C'\fR watchers are invoked just \fIbefore\fR \f(CW\*(C`ev_loop\*(C'\fR starts
  955. to gather new events, and all \f(CW\*(C`ev_check\*(C'\fR watchers are invoked just after
  956. \&\f(CW\*(C`ev_loop\*(C'\fR has gathered them, but before it invokes any callbacks for any
  957. received events. Callbacks of both watcher types can start and stop as
  958. many watchers as they want, and all of them will be taken into account
  959. (for example, a \f(CW\*(C`ev_prepare\*(C'\fR watcher might start an idle watcher to keep
  960. \&\f(CW\*(C`ev_loop\*(C'\fR from blocking).
  961. .ie n .IP """EV_EMBED""" 4
  962. .el .IP "\f(CWEV_EMBED\fR" 4
  963. .IX Item "EV_EMBED"
  964. The embedded event loop specified in the \f(CW\*(C`ev_embed\*(C'\fR watcher needs attention.
  965. .ie n .IP """EV_FORK""" 4
  966. .el .IP "\f(CWEV_FORK\fR" 4
  967. .IX Item "EV_FORK"
  968. The event loop has been resumed in the child process after fork (see
  969. \&\f(CW\*(C`ev_fork\*(C'\fR).
  970. .ie n .IP """EV_ASYNC""" 4
  971. .el .IP "\f(CWEV_ASYNC\fR" 4
  972. .IX Item "EV_ASYNC"
  973. The given async watcher has been asynchronously notified (see \f(CW\*(C`ev_async\*(C'\fR).
  974. .ie n .IP """EV_ERROR""" 4
  975. .el .IP "\f(CWEV_ERROR\fR" 4
  976. .IX Item "EV_ERROR"
  977. An unspecified error has occured, the watcher has been stopped. This might
  978. happen because the watcher could not be properly started because libev
  979. ran out of memory, a file descriptor was found to be closed or any other
  980. problem. You best act on it by reporting the problem and somehow coping
  981. with the watcher being stopped.
  982. .Sp
  983. Libev will usually signal a few \*(L"dummy\*(R" events together with an error,
  984. for example it might indicate that a fd is readable or writable, and if
  985. your callbacks is well-written it can just attempt the operation and cope
  986. with the error from \fIread()\fR or \fIwrite()\fR. This will not work in multithreaded
  987. programs, though, so beware.
  988. .Sh "\s-1GENERIC\s0 \s-1WATCHER\s0 \s-1FUNCTIONS\s0"
  989. .IX Subsection "GENERIC WATCHER FUNCTIONS"
  990. In the following description, \f(CW\*(C`TYPE\*(C'\fR stands for the watcher type,
  991. e.g. \f(CW\*(C`timer\*(C'\fR for \f(CW\*(C`ev_timer\*(C'\fR watchers and \f(CW\*(C`io\*(C'\fR for \f(CW\*(C`ev_io\*(C'\fR watchers.
  992. .ie n .IP """ev_init"" (ev_TYPE *watcher, callback)" 4
  993. .el .IP "\f(CWev_init\fR (ev_TYPE *watcher, callback)" 4
  994. .IX Item "ev_init (ev_TYPE *watcher, callback)"
  995. This macro initialises the generic portion of a watcher. The contents
  996. of the watcher object can be arbitrary (so \f(CW\*(C`malloc\*(C'\fR will do). Only
  997. the generic parts of the watcher are initialised, you \fIneed\fR to call
  998. the type-specific \f(CW\*(C`ev_TYPE_set\*(C'\fR macro afterwards to initialise the
  999. type-specific parts. For each type there is also a \f(CW\*(C`ev_TYPE_init\*(C'\fR macro
  1000. which rolls both calls into one.
  1001. .Sp
  1002. You can reinitialise a watcher at any time as long as it has been stopped
  1003. (or never started) and there are no pending events outstanding.
  1004. .Sp
  1005. The callback is always of type \f(CW\*(C`void (*)(ev_loop *loop, ev_TYPE *watcher,
  1006. int revents)\*(C'\fR.
  1007. .ie n .IP """ev_TYPE_set"" (ev_TYPE *, [args])" 4
  1008. .el .IP "\f(CWev_TYPE_set\fR (ev_TYPE *, [args])" 4
  1009. .IX Item "ev_TYPE_set (ev_TYPE *, [args])"
  1010. This macro initialises the type-specific parts of a watcher. You need to
  1011. call \f(CW\*(C`ev_init\*(C'\fR at least once before you call this macro, but you can
  1012. call \f(CW\*(C`ev_TYPE_set\*(C'\fR any number of times. You must not, however, call this
  1013. macro on a watcher that is active (it can be pending, however, which is a
  1014. difference to the \f(CW\*(C`ev_init\*(C'\fR macro).
  1015. .Sp
  1016. Although some watcher types do not have type-specific arguments
  1017. (e.g. \f(CW\*(C`ev_prepare\*(C'\fR) you still need to call its \f(CW\*(C`set\*(C'\fR macro.
  1018. .ie n .IP """ev_TYPE_init"" (ev_TYPE *watcher, callback, [args])" 4
  1019. .el .IP "\f(CWev_TYPE_init\fR (ev_TYPE *watcher, callback, [args])" 4
  1020. .IX Item "ev_TYPE_init (ev_TYPE *watcher, callback, [args])"
  1021. This convinience macro rolls both \f(CW\*(C`ev_init\*(C'\fR and \f(CW\*(C`ev_TYPE_set\*(C'\fR macro
  1022. calls into a single call. This is the most convinient method to initialise
  1023. a watcher. The same limitations apply, of course.
  1024. .ie n .IP """ev_TYPE_start"" (loop *, ev_TYPE *watcher)" 4
  1025. .el .IP "\f(CWev_TYPE_start\fR (loop *, ev_TYPE *watcher)" 4
  1026. .IX Item "ev_TYPE_start (loop *, ev_TYPE *watcher)"
  1027. Starts (activates) the given watcher. Only active watchers will receive
  1028. events. If the watcher is already active nothing will happen.
  1029. .ie n .IP """ev_TYPE_stop"" (loop *, ev_TYPE *watcher)" 4
  1030. .el .IP "\f(CWev_TYPE_stop\fR (loop *, ev_TYPE *watcher)" 4
  1031. .IX Item "ev_TYPE_stop (loop *, ev_TYPE *watcher)"
  1032. Stops the given watcher again (if active) and clears the pending
  1033. status. It is possible that stopped watchers are pending (for example,
  1034. non-repeating timers are being stopped when they become pending), but
  1035. \&\f(CW\*(C`ev_TYPE_stop\*(C'\fR ensures that the watcher is neither active nor pending. If
  1036. you want to free or reuse the memory used by the watcher it is therefore a
  1037. good idea to always call its \f(CW\*(C`ev_TYPE_stop\*(C'\fR function.
  1038. .IP "bool ev_is_active (ev_TYPE *watcher)" 4
  1039. .IX Item "bool ev_is_active (ev_TYPE *watcher)"
  1040. Returns a true value iff the watcher is active (i.e. it has been started
  1041. and not yet been stopped). As long as a watcher is active you must not modify
  1042. it.
  1043. .IP "bool ev_is_pending (ev_TYPE *watcher)" 4
  1044. .IX Item "bool ev_is_pending (ev_TYPE *watcher)"
  1045. Returns a true value iff the watcher is pending, (i.e. it has outstanding
  1046. events but its callback has not yet been invoked). As long as a watcher
  1047. is pending (but not active) you must not call an init function on it (but
  1048. \&\f(CW\*(C`ev_TYPE_set\*(C'\fR is safe), you must not change its priority, and you must
  1049. make sure the watcher is available to libev (e.g. you cannot \f(CW\*(C`free ()\*(C'\fR
  1050. it).
  1051. .IP "callback ev_cb (ev_TYPE *watcher)" 4
  1052. .IX Item "callback ev_cb (ev_TYPE *watcher)"
  1053. Returns the callback currently set on the watcher.
  1054. .IP "ev_cb_set (ev_TYPE *watcher, callback)" 4
  1055. .IX Item "ev_cb_set (ev_TYPE *watcher, callback)"
  1056. Change the callback. You can change the callback at virtually any time
  1057. (modulo threads).
  1058. .IP "ev_set_priority (ev_TYPE *watcher, priority)" 4
  1059. .IX Item "ev_set_priority (ev_TYPE *watcher, priority)"
  1060. .PD 0
  1061. .IP "int ev_priority (ev_TYPE *watcher)" 4
  1062. .IX Item "int ev_priority (ev_TYPE *watcher)"
  1063. .PD
  1064. Set and query the priority of the watcher. The priority is a small
  1065. integer between \f(CW\*(C`EV_MAXPRI\*(C'\fR (default: \f(CW2\fR) and \f(CW\*(C`EV_MINPRI\*(C'\fR
  1066. (default: \f(CW\*(C`\-2\*(C'\fR). Pending watchers with higher priority will be invoked
  1067. before watchers with lower priority, but priority will not keep watchers
  1068. from being executed (except for \f(CW\*(C`ev_idle\*(C'\fR watchers).
  1069. .Sp
  1070. This means that priorities are \fIonly\fR used for ordering callback
  1071. invocation after new events have been received. This is useful, for
  1072. example, to reduce latency after idling, or more often, to bind two
  1073. watchers on the same event and make sure one is called first.
  1074. .Sp
  1075. If you need to suppress invocation when higher priority events are pending
  1076. you need to look at \f(CW\*(C`ev_idle\*(C'\fR watchers, which provide this functionality.
  1077. .Sp
  1078. You \fImust not\fR change the priority of a watcher as long as it is active or
  1079. pending.
  1080. .Sp
  1081. The default priority used by watchers when no priority has been set is
  1082. always \f(CW0\fR, which is supposed to not be too high and not be too low :).
  1083. .Sp
  1084. Setting a priority outside the range of \f(CW\*(C`EV_MINPRI\*(C'\fR to \f(CW\*(C`EV_MAXPRI\*(C'\fR is
  1085. fine, as long as you do not mind that the priority value you query might
  1086. or might not have been adjusted to be within valid range.
  1087. .IP "ev_invoke (loop, ev_TYPE *watcher, int revents)" 4
  1088. .IX Item "ev_invoke (loop, ev_TYPE *watcher, int revents)"
  1089. 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
  1090. \&\f(CW\*(C`loop\*(C'\fR nor \f(CW\*(C`revents\*(C'\fR need to be valid as long as the watcher callback
  1091. can deal with that fact.
  1092. .IP "int ev_clear_pending (loop, ev_TYPE *watcher)" 4
  1093. .IX Item "int ev_clear_pending (loop, ev_TYPE *watcher)"
  1094. If the watcher is pending, this function returns clears its pending status
  1095. and returns its \f(CW\*(C`revents\*(C'\fR bitset (as if its callback was invoked). If the
  1096. watcher isn't pending it does nothing and returns \f(CW0\fR.
  1097. .Sh "\s-1ASSOCIATING\s0 \s-1CUSTOM\s0 \s-1DATA\s0 \s-1WITH\s0 A \s-1WATCHER\s0"
  1098. .IX Subsection "ASSOCIATING CUSTOM DATA WITH A WATCHER"
  1099. Each watcher has, by default, a member \f(CW\*(C`void *data\*(C'\fR that you can change
  1100. and read at any time, libev will completely ignore it. This can be used
  1101. to associate arbitrary data with your watcher. If you need more data and
  1102. don't want to allocate memory and store a pointer to it in that data
  1103. member, you can also \*(L"subclass\*(R" the watcher type and provide your own
  1104. data:
  1105. .PP
  1106. .Vb 7
  1107. \& struct my_io
  1108. \& {
  1109. \& struct ev_io io;
  1110. \& int otherfd;
  1111. \& void *somedata;
  1112. \& struct whatever *mostinteresting;
  1113. \& }
  1114. .Ve
  1115. .PP
  1116. And since your callback will be called with a pointer to the watcher, you
  1117. can cast it back to your own type:
  1118. .PP
  1119. .Vb 5
  1120. \& static void my_cb (struct ev_loop *loop, struct ev_io *w_, int revents)
  1121. \& {
  1122. \& struct my_io *w = (struct my_io *)w_;
  1123. \& ...
  1124. \& }
  1125. .Ve
  1126. .PP
  1127. More interesting and less C\-conformant ways of casting your callback type
  1128. instead have been omitted.
  1129. .PP
  1130. Another common scenario is having some data structure with multiple
  1131. watchers:
  1132. .PP
  1133. .Vb 6
  1134. \& struct my_biggy
  1135. \& {
  1136. \& int some_data;
  1137. \& ev_timer t1;
  1138. \& ev_timer t2;
  1139. \& }
  1140. .Ve
  1141. .PP
  1142. In this case getting the pointer to \f(CW\*(C`my_biggy\*(C'\fR is a bit more complicated,
  1143. you need to use \f(CW\*(C`offsetof\*(C'\fR:
  1144. .PP
  1145. .Vb 1
  1146. \& #include <stddef.h>
  1147. \&
  1148. \& static void
  1149. \& t1_cb (EV_P_ struct ev_timer *w, int revents)
  1150. \& {
  1151. \& struct my_biggy big = (struct my_biggy *
  1152. \& (((char *)w) \- offsetof (struct my_biggy, t1));
  1153. \& }
  1154. \&
  1155. \& static void
  1156. \& t2_cb (EV_P_ struct ev_timer *w, int revents)
  1157. \& {
  1158. \& struct my_biggy big = (struct my_biggy *
  1159. \& (((char *)w) \- offsetof (struct my_biggy, t2));
  1160. \& }
  1161. .Ve
  1162. .SH "WATCHER TYPES"
  1163. .IX Header "WATCHER TYPES"
  1164. This section describes each watcher in detail, but will not repeat
  1165. information given in the last section. Any initialisation/set macros,
  1166. functions and members specific to the watcher type are explained.
  1167. .PP
  1168. Members are additionally marked with either \fI[read\-only]\fR, meaning that,
  1169. while the watcher is active, you can look at the member and expect some
  1170. sensible content, but you must not modify it (you can modify it while the
  1171. watcher is stopped to your hearts content), or \fI[read\-write]\fR, which
  1172. means you can expect it to have some sensible content while the watcher
  1173. is active, but you can also modify it. Modifying it may not do something
  1174. sensible or take immediate effect (or do anything at all), but libev will
  1175. not crash or malfunction in any way.
  1176. .ie n .Sh """ev_io"" \- is this file descriptor readable or writable?"
  1177. .el .Sh "\f(CWev_io\fP \- is this file descriptor readable or writable?"
  1178. .IX Subsection "ev_io - is this file descriptor readable or writable?"
  1179. I/O watchers check whether a file descriptor is readable or writable
  1180. in each iteration of the event loop, or, more precisely, when reading
  1181. would not block the process and writing would at least be able to write
  1182. some data. This behaviour is called level-triggering because you keep
  1183. receiving events as long as the condition persists. Remember you can stop
  1184. the watcher if you don't want to act on the event and neither want to
  1185. receive future events.
  1186. .PP
  1187. In general you can register as many read and/or write event watchers per
  1188. fd as you want (as long as you don't confuse yourself). Setting all file
  1189. descriptors to non-blocking mode is also usually a good idea (but not
  1190. required if you know what you are doing).
  1191. .PP
  1192. If you must do this, then force the use of a known-to-be-good backend
  1193. (at the time of this writing, this includes only \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR and
  1194. \&\f(CW\*(C`EVBACKEND_POLL\*(C'\fR).
  1195. .PP
  1196. Another thing you have to watch out for is that it is quite easy to
  1197. receive \*(L"spurious\*(R" readiness notifications, that is your callback might
  1198. be called with \f(CW\*(C`EV_READ\*(C'\fR but a subsequent \f(CW\*(C`read\*(C'\fR(2) will actually block
  1199. because there is no data. Not only are some backends known to create a
  1200. lot of those (for example solaris ports), it is very easy to get into
  1201. this situation even with a relatively standard program structure. Thus
  1202. it is best to always use non-blocking I/O: An extra \f(CW\*(C`read\*(C'\fR(2) returning
  1203. \&\f(CW\*(C`EAGAIN\*(C'\fR is far preferable to a program hanging until some data arrives.
  1204. .PP
  1205. If you cannot run the fd in non-blocking mode (for example you should not
  1206. play around with an Xlib connection), then you have to seperately re-test
  1207. whether a file descriptor is really ready with a known-to-be good interface
  1208. such as poll (fortunately in our Xlib example, Xlib already does this on
  1209. its own, so its quite safe to use).
  1210. .PP
  1211. \fIThe special problem of disappearing file descriptors\fR
  1212. .IX Subsection "The special problem of disappearing file descriptors"
  1213. .PP
  1214. Some backends (e.g. kqueue, epoll) need to be told about closing a file
  1215. descriptor (either by calling \f(CW\*(C`close\*(C'\fR explicitly or by any other means,
  1216. such as \f(CW\*(C`dup\*(C'\fR). The reason is that you register interest in some file
  1217. descriptor, but when it goes away, the operating system will silently drop
  1218. this interest. If another file descriptor with the same number then is
  1219. registered with libev, there is no efficient way to see that this is, in
  1220. fact, a different file descriptor.
  1221. .PP
  1222. To avoid having to explicitly tell libev about such cases, libev follows
  1223. the following policy: Each time \f(CW\*(C`ev_io_set\*(C'\fR is being called, libev
  1224. will assume that this is potentially a new file descriptor, otherwise
  1225. it is assumed that the file descriptor stays the same. That means that
  1226. you \fIhave\fR to call \f(CW\*(C`ev_io_set\*(C'\fR (or \f(CW\*(C`ev_io_init\*(C'\fR) when you change the
  1227. descriptor even if the file descriptor number itself did not change.
  1228. .PP
  1229. This is how one would do it normally anyway, the important point is that
  1230. the libev application should not optimise around libev but should leave
  1231. optimisations to libev.
  1232. .PP
  1233. \fIThe special problem of dup'ed file descriptors\fR
  1234. .IX Subsection "The special problem of dup'ed file descriptors"
  1235. .PP
  1236. Some backends (e.g. epoll), cannot register events for file descriptors,
  1237. but only events for the underlying file descriptions. That means when you
  1238. have \f(CW\*(C`dup ()\*(C'\fR'ed file descriptors or weirder constellations, and register
  1239. events for them, only one file descriptor might actually receive events.
  1240. .PP
  1241. There is no workaround possible except not registering events
  1242. for potentially \f(CW\*(C`dup ()\*(C'\fR'ed file descriptors, or to resort to
  1243. \&\f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or \f(CW\*(C`EVBACKEND_POLL\*(C'\fR.
  1244. .PP
  1245. \fIThe special problem of fork\fR
  1246. .IX Subsection "The special problem of fork"
  1247. .PP
  1248. Some backends (epoll, kqueue) do not support \f(CW\*(C`fork ()\*(C'\fR at all or exhibit
  1249. useless behaviour. Libev fully supports fork, but needs to be told about
  1250. it in the child.
  1251. .PP
  1252. To support fork in your programs, you either have to call
  1253. \&\f(CW\*(C`ev_default_fork ()\*(C'\fR or \f(CW\*(C`ev_loop_fork ()\*(C'\fR after a fork in the child,
  1254. enable \f(CW\*(C`EVFLAG_FORKCHECK\*(C'\fR, or resort to \f(CW\*(C`EVBACKEND_SELECT\*(C'\fR or
  1255. \&\f(CW\*(C`EVBACKEND_POLL\*(C'\fR.
  1256. .PP
  1257. \fIThe special problem of \s-1SIGPIPE\s0\fR
  1258. .IX Subsection "The special problem of SIGPIPE"
  1259. .PP
  1260. While not really specific to libev, it is easy to forget about \s-1SIGPIPE:\s0
  1261. when reading from a pipe whose other end has been closed, your program
  1262. gets send a \s-1SIGPIPE\s0, which, by default, aborts your program. For most
  1263. programs this is sensible behaviour, for daemons, this is usually
  1264. undesirable.
  1265. .PP
  1266. So when you encounter spurious, unexplained daemon exits, make sure you
  1267. ignore \s-1SIGPIPE\s0 (and maybe make sure you log the exit status of your daemon
  1268. somewhere, as that would have given you a big clue).
  1269. .PP
  1270. \fIWatcher-Specific Functions\fR
  1271. .IX Subsection "Watcher-Specific Functions"
  1272. .IP "ev_io_init (ev_io *, callback, int fd, int events)" 4
  1273. .IX Item "ev_io_init (ev_io *, callback, int fd, int events)"
  1274. .PD 0
  1275. .IP "ev_io_set (ev_io *, int fd, int events)" 4
  1276. .IX Item "ev_io_set (ev_io *, int fd, int events)"
  1277. .PD
  1278. Configures an \f(CW\*(C`ev_io\*(C'\fR watcher. The \f(CW\*(C`fd\*(C'\fR is the file descriptor to
  1279. rceeive events for and events is either \f(CW\*(C`EV_READ\*(C'\fR, \f(CW\*(C`EV_WRITE\*(C'\fR or
  1280. \&\f(CW\*(C`EV_READ | EV_WRITE\*(C'\fR to receive the given events.
  1281. .IP "int fd [read\-only]" 4
  1282. .IX Item "int fd [read-only]"
  1283. The file descriptor being watched.
  1284. .IP "int events [read\-only]" 4
  1285. .IX Item "int events [read-only]"
  1286. The events being watched.
  1287. .PP
  1288. \fIExamples\fR
  1289. .IX Subsection "Examples"
  1290. .PP
  1291. Example: Call \f(CW\*(C`stdin_readable_cb\*(C'\fR when \s-1STDIN_FILENO\s0 has become, well
  1292. readable, but only once. Since it is likely line-buffered, you could
  1293. attempt to read a whole line in the callback.
  1294. .PP
  1295. .Vb 6
  1296. \& static void
  1297. \& stdin_readable_cb (struct ev_loop *loop, struct ev_io *w, int revents)
  1298. \& {
  1299. \& ev_io_stop (loop, w);
  1300. \& .. read from stdin here (or from w\->fd) and haqndle any I/O errors
  1301. \& }
  1302. \&
  1303. \& ...
  1304. \& struct ev_loop *loop = ev_default_init (0);
  1305. \& struct ev_io stdin_readable;
  1306. \& ev_io_init (&stdin_readable, stdin_readable_cb, STDIN_FILENO, EV_READ);
  1307. \& ev_io_start (loop, &stdin_readable);
  1308. \& ev_loop (loop, 0);
  1309. .Ve
  1310. .ie n .Sh """ev_timer"" \- relative and optionally repeating timeouts"
  1311. .el .Sh "\f(CWev_timer\fP \- relative and optionally repeating timeouts"
  1312. .IX Subsection "ev_timer - relative and optionally repeating timeouts"
  1313. Timer watchers are simple relative timers that generate an event after a
  1314. given time, and optionally repeating in regular intervals after that.
  1315. .PP
  1316. The timers are based on real time, that is, if you register an event that
  1317. times out after an hour and you reset your system clock to january last
  1318. year, it will still time out after (roughly) and hour. \*(L"Roughly\*(R" because
  1319. detecting time jumps is hard, and some inaccuracies are unavoidable (the
  1320. monotonic clock option helps a lot here).
  1321. .PP
  1322. The relative timeouts are calculated relative to the \f(CW\*(C`ev_now ()\*(C'\fR
  1323. time. This is usually the right thing as this timestamp refers to the time
  1324. of the event triggering whatever timeout you are modifying/starting. If
  1325. you suspect event processing to be delayed and you \fIneed\fR to base the timeout
  1326. on the current time, use something like this to adjust for this:
  1327. .PP
  1328. .Vb 1
  1329. \& ev_timer_set (&timer, after + ev_now () \- ev_time (), 0.);
  1330. .Ve
  1331. .PP
  1332. The callback is guarenteed to be invoked only after its timeout has passed,
  1333. but if multiple timers become ready during the same loop iteration then
  1334. order of execution is undefined.
  1335. .PP
  1336. \fIWatcher-Specific Functions and Data Members\fR
  1337. .IX Subsection "Watcher-Specific Functions and Data Members"
  1338. .IP "ev_timer_init (ev_timer *, callback, ev_tstamp after, ev_tstamp repeat)" 4
  1339. .IX Item "ev_timer_init (ev_timer *, callback, ev_tstamp after, ev_tstamp repeat)"
  1340. .PD 0
  1341. .IP "ev_timer_set (ev_timer *, ev_tstamp after, ev_tstamp repeat)" 4
  1342. .IX Item "ev_timer_set (ev_timer *, ev_tstamp after, ev_tstamp repeat)"
  1343. .PD
  1344. Configure the timer to trigger after \f(CW\*(C`after\*(C'\fR seconds. If \f(CW\*(C`repeat\*(C'\fR
  1345. is \f(CW0.\fR, then it will automatically be stopped once the timeout is
  1346. reached. If it is positive, then the timer will automatically be
  1347. configured to trigger again \f(CW\*(C`repeat\*(C'\fR seconds later, again, and again,
  1348. until stopped manually.
  1349. .Sp
  1350. The timer itself will do a best-effort at avoiding drift, that is, if
  1351. you configure a timer to trigger every 10 seconds, then it will normally
  1352. trigger at exactly 10 second intervals. If, however, your program cannot
  1353. keep up with the timer (because it takes longer than those 10 seconds to
  1354. do stuff) the timer will not fire more than once per event loop iteration.
  1355. .IP "ev_timer_again (loop, ev_timer *)" 4
  1356. .IX Item "ev_timer_again (loop, ev_timer *)"
  1357. This will act as if the timer timed out and restart it again if it is
  1358. repeating. The exact semantics are:
  1359. .Sp
  1360. If the timer is pending, its pending status is cleared.
  1361. .Sp
  1362. If the timer is started but nonrepeating, stop it (as if it timed out).
  1363. .Sp
  1364. If the timer is repeating, either start it if necessary (with the
  1365. \&\f(CW\*(C`repeat\*(C'\fR value), or reset the running timer to the \f(CW\*(C`repeat\*(C'\fR value.
  1366. .Sp
  1367. This sounds a bit complicated, but here is a useful and typical
  1368. example: Imagine you have a tcp connection and you want a so-called idle
  1369. timeout, that is, you want to be called when there have been, say, 60
  1370. seconds of inactivity on the socket. The easiest way to do this is to
  1371. configure an \f(CW\*(C`ev_timer\*(C'\fR with a \f(CW\*(C`repeat\*(C'\fR value of \f(CW60\fR and then call
  1372. \&\f(CW\*(C`ev_timer_again\*(C'\fR each time you successfully read or write some data. If
  1373. you go into an idle state where you do not expect data to travel on the
  1374. socket, you can \f(CW\*(C`ev_timer_stop\*(C'\fR the timer, and \f(CW\*(C`ev_timer_again\*(C'\fR will
  1375. automatically restart it if need be.
  1376. .Sp
  1377. That means you can ignore the \f(CW\*(C`after\*(C'\fR value and \f(CW\*(C`ev_timer_start\*(C'\fR
  1378. altogether and only ever use the \f(CW\*(C`repeat\*(C'\fR value and \f(CW\*(C`ev_timer_again\*(C'\fR:
  1379. .Sp
  1380. .Vb 8
  1381. \& ev_timer_init (timer, callback, 0., 5.);
  1382. \& ev_timer_again (loop, timer);
  1383. \& ...
  1384. \& timer\->again = 17.;
  1385. \& ev_timer_again (loop, timer);
  1386. \& ...
  1387. \& timer\->again = 10.;
  1388. \& ev_timer_again (loop, timer);
  1389. .Ve
  1390. .Sp
  1391. This is more slightly efficient then stopping/starting the timer each time
  1392. you want to modify its timeout value.
  1393. .IP "ev_tstamp repeat [read\-write]" 4
  1394. .IX Item "ev_tstamp repeat [read-write]"
  1395. The current \f(CW\*(C`repeat\*(C'\fR value. Will be used each time the watcher times out
  1396. or \f(CW\*(C`ev_timer_again\*(C'\fR is called and determines the next timeout (if any),
  1397. which is also when any modifications are taken into account.
  1398. .PP
  1399. \fIExamples\fR
  1400. .IX Subsection "Examples"
  1401. .PP
  1402. Example: Create a timer that fires after 60 seconds.
  1403. .PP
  1404. .Vb 5
  1405. \& static void
  1406. \& one_minute_cb (struct ev_loop *loop, struct ev_timer *w, int revents)
  1407. \& {
  1408. \& .. one minute over, w is actually stopped right here
  1409. \& }
  1410. \&
  1411. \& struct ev_timer mytimer;
  1412. \& ev_timer_init (&mytimer, one_minute_cb, 60., 0.);
  1413. \& ev_timer_start (loop, &mytimer);
  1414. .Ve
  1415. .PP
  1416. Example: Create a timeout timer that times out after 10 seconds of
  1417. inactivity.
  1418. .PP
  1419. .Vb 5
  1420. \& static void
  1421. \& timeout_cb (struct ev_loop *loop, struct ev_timer *w, int revents)
  1422. \& {
  1423. \& .. ten seconds without any activity
  1424. \& }
  1425. \&
  1426. \& struct ev_timer mytimer;
  1427. \& ev_timer_init (&mytimer, timeout_cb, 0., 10.); /* note, only repeat used */
  1428. \& ev_timer_again (&mytimer); /* start timer */
  1429. \& ev_loop (loop, 0);
  1430. \&
  1431. \& // and in some piece of code that gets executed on any "activity":
  1432. \& // reset the timeout to start ticking again at 10 seconds
  1433. \& ev_timer_again (&mytimer);
  1434. .Ve
  1435. .ie n .Sh """ev_periodic"" \- to cron or not to cron?"
  1436. .el .Sh "\f(CWev_periodic\fP \- to cron or not to cron?"
  1437. .IX Subsection "ev_periodic - to cron or not to cron?"
  1438. Periodic watchers are also timers of a kind, but they are very versatile
  1439. (and unfortunately a bit complex).
  1440. .PP
  1441. Unlike \f(CW\*(C`ev_timer\*(C'\fR's, they are not based on real time (or relative time)
  1442. but on wallclock time (absolute time). You can tell a periodic watcher
  1443. to trigger after some specific point in time. For example, if you tell a
  1444. periodic watcher to trigger in 10 seconds (by specifiying e.g. \f(CW\*(C`ev_now ()
  1445. + 10.\*(C'\fR, that is, an absolute time not a delay) and then reset your system
  1446. clock to january of the previous year, then it will take more than year
  1447. to trigger the event (unlike an \f(CW\*(C`ev_timer\*(C'\fR, which would still trigger
  1448. roughly 10 seconds later as it uses a relative timeout).
  1449. .PP
  1450. \&\f(CW\*(C`ev_periodic\*(C'\fRs can also be used to implement vastly more complex timers,
  1451. such as triggering an event on each \*(L"midnight, local time\*(R", or other
  1452. complicated, rules.
  1453. .PP
  1454. As with timers, the callback is guarenteed to be invoked only when the
  1455. time (\f(CW\*(C`at\*(C'\fR) has passed, but if multiple periodic timers become ready
  1456. during the same loop iteration then order of execution is undefined.
  1457. .PP
  1458. \fIWatcher-Specific Functions and Data Members\fR
  1459. .IX Subsection "Watcher-Specific Functions and Data Members"
  1460. .IP "ev_periodic_init (ev_periodic *, callback, ev_tstamp at, ev_tstamp interval, reschedule_cb)" 4
  1461. .IX Item "ev_periodic_init (ev_periodic *, callback, ev_tstamp at, ev_tstamp interval, reschedule_cb)"
  1462. .PD 0
  1463. .IP "ev_periodic_set (ev_periodic *, ev_tstamp after, ev_tstamp repeat, reschedule_cb)" 4
  1464. .IX Item "ev_periodic_set (ev_periodic *, ev_tstamp after, ev_tstamp repeat, reschedule_cb)"
  1465. .PD
  1466. Lots of arguments, lets sort it out... There are basically three modes of
  1467. operation, and we will explain them from simplest to complex:
  1468. .RS 4
  1469. .IP "\(bu" 4
  1470. absolute timer (at = time, interval = reschedule_cb = 0)
  1471. .Sp
  1472. In this configuration the watcher triggers an event after the wallclock
  1473. time \f(CW\*(C`at\*(C'\fR has passed and doesn't repeat. It will not adjust when a time
  1474. jump occurs, that is, if it is to be run at January 1st 2011 then it will
  1475. run when the system time reaches or surpasses this time.
  1476. .IP "\(bu" 4
  1477. repeating interval timer (at = offset, interval > 0, reschedule_cb = 0)
  1478. .Sp
  1479. In this mode the watcher will always be scheduled to time out at the next
  1480. \&\f(CW\*(C`at + N * interval\*(C'\fR time (for some integer N, which can also be negative)
  1481. and then repeat, regardless of any time jumps.
  1482. .Sp
  1483. This can be used to create timers that do not drift with respect to system
  1484. time, for example, here is a \f(CW\*(C`ev_periodic\*(C'\fR that triggers each hour, on
  1485. the hour:
  1486. .Sp
  1487. .Vb 1
  1488. \& ev_periodic_set (&periodic, 0., 3600., 0);
  1489. .Ve
  1490. .Sp
  1491. This doesn't mean there will always be 3600 seconds in between triggers,
  1492. but only that the the callback will be called when the system time shows a
  1493. full hour (\s-1UTC\s0), or more correctly, when the system time is evenly divisible
  1494. by 3600.
  1495. .Sp
  1496. Another way to think about it (for the mathematically inclined) is that
  1497. \&\f(CW\*(C`ev_periodic\*(C'\fR will try to run the callback in this mode at the next possible
  1498. time where \f(CW\*(C`time = at (mod interval)\*(C'\fR, regardless of any time jumps.
  1499. .Sp
  1500. For numerical stability it is preferable that the \f(CW\*(C`at\*(C'\fR value is near
  1501. \&\f(CW\*(C`ev_now ()\*(C'\fR (the current time), but there is no range requirement for
  1502. this value, and in fact is often specified as zero.
  1503. .Sp
  1504. Note also that there is an upper limit to how often a timer can fire (cpu
  1505. speed for example), so if \f(CW\*(C`interval\*(C'\fR is very small then timing stability
  1506. will of course detoriate. Libev itself tries to be exact to be about one
  1507. millisecond (if the \s-1OS\s0 supports it and the machine is fast enough).
  1508. .IP "\(bu" 4
  1509. manual reschedule mode (at and interval ignored, reschedule_cb = callback)
  1510. .Sp
  1511. In this mode the values for \f(CW\*(C`interval\*(C'\fR and \f(CW\*(C`at\*(C'\fR are both being
  1512. ignored. Instead, each time the periodic watcher gets scheduled, the
  1513. reschedule callback will be called with the watcher as first, and the
  1514. current time as second argument.
  1515. .Sp
  1516. \&\s-1NOTE:\s0 \fIThis callback \s-1MUST\s0 \s-1NOT\s0 stop or destroy any periodic watcher,
  1517. ever, or make \s-1ANY\s0 event loop modifications whatsoever\fR.
  1518. .Sp
  1519. If you need to stop it, return \f(CW\*(C`now + 1e30\*(C'\fR (or so, fudge fudge) and stop
  1520. it afterwards (e.g. by starting an \f(CW\*(C`ev_prepare\*(C'\fR watcher, which is the
  1521. only event loop modification you are allowed to do).
  1522. .Sp
  1523. The callback prototype is \f(CW\*(C`ev_tstamp (*reschedule_cb)(struct ev_periodic
  1524. *w, ev_tstamp now)\*(C'\fR, e.g.:
  1525. .Sp
  1526. .Vb 4
  1527. \& static ev_tstamp my_rescheduler (struct ev_periodic *w, ev_tstamp now)
  1528. \& {
  1529. \& return now + 60.;
  1530. \& }
  1531. .Ve
  1532. .Sp
  1533. It must return the next time to trigger, based on the passed time value
  1534. (that is, the lowest time value larger than to the second argument). It
  1535. will usually be called just before the callback will be triggered, but
  1536. might be called at other times, too.
  1537. .Sp
  1538. \&\s-1NOTE:\s0 \fIThis callback must always return a time that is higher than or
  1539. equal to the passed \f(CI\*(C`now\*(C'\fI value\fR.
  1540. .Sp
  1541. This can be used to create very complex timers, such as a timer that
  1542. triggers on \*(L"next midnight, local time\*(R". To do this, you would calculate the
  1543. next midnight after \f(CW\*(C`now\*(C'\fR and return the timestamp value for this. How
  1544. you do this is, again, up to you (but it is not trivial, which is the main
  1545. reason I omitted it as an example).
  1546. .RE
  1547. .RS 4
  1548. .RE
  1549. .IP "ev_periodic_again (loop, ev_periodic *)" 4
  1550. .IX Item "ev_periodic_again (loop, ev_periodic *)"
  1551. Simply stops and restarts the periodic watcher again. This is only useful
  1552. when you changed some parameters or the reschedule callback would return
  1553. a different time than the last time it was called (e.g. in a crond like
  1554. program when the crontabs have changed).
  1555. .IP "ev_tstamp ev_periodic_at (ev_periodic *)" 4
  1556. .IX Item "ev_tstamp ev_periodic_at (ev_periodic *)"
  1557. When active, returns the absolute time that the watcher is supposed to
  1558. trigger next.
  1559. .IP "ev_tstamp offset [read\-write]" 4
  1560. .IX Item "ev_tstamp offset [read-write]"
  1561. When repeating, this contains the offset value, otherwise this is the
  1562. absolute point in time (the \f(CW\*(C`at\*(C'\fR value passed to \f(CW\*(C`ev_periodic_set\*(C'\fR).
  1563. .Sp
  1564. Can be modified any time, but changes only take effect when the periodic
  1565. timer fires or \f(CW\*(C`ev_periodic_again\*(C'\fR is being called.
  1566. .IP "ev_tstamp interval [read\-write]" 4
  1567. .IX Item "ev_tstamp interval [read-write]"
  1568. The current interval value. Can be modified any time, but changes only
  1569. take effect when the periodic timer fires or \f(CW\*(C`ev_periodic_again\*(C'\fR is being
  1570. called.
  1571. .IP "ev_tstamp (*reschedule_cb)(struct ev_periodic *w, ev_tstamp now) [read\-write]" 4
  1572. .IX Item "ev_tstamp (*reschedule_cb)(struct ev_periodic *w, ev_tstamp now) [read-write]"
  1573. The current reschedule callback, or \f(CW0\fR, if this functionality is
  1574. switched off. Can be changed any time, but changes only take effect when
  1575. the periodic timer fires or \f(CW\*(C`ev_periodic_again\*(C'\fR is being called.
  1576. .PP
  1577. \fIExamples\fR
  1578. .IX Subsection "Examples"
  1579. .PP
  1580. Example: Call a callback every hour, or, more precisely, whenever the
  1581. system clock is divisible by 3600. The callback invocation times have
  1582. potentially a lot of jittering, but good long-term stability.
  1583. .PP
  1584. .Vb 5
  1585. \& static void
  1586. \& clock_cb (struct ev_loop *loop, struct ev_io *w, int revents)
  1587. \& {
  1588. \& ... its now a full hour (UTC, or TAI or whatever your clock follows)
  1589. \& }
  1590. \&
  1591. \& struct ev_periodic hourly_tick;
  1592. \& ev_periodic_init (&hourly_tick, clock_cb, 0., 3600., 0);
  1593. \& ev_periodic_start (loop, &hourly_tick);
  1594. .Ve
  1595. .PP
  1596. Example: The same as above, but use a reschedule callback to do it:
  1597. .PP
  1598. .Vb 1
  1599. \& #include <math.h>
  1600. \&
  1601. \& static ev_tstamp
  1602. \& my_scheduler_cb (struct ev_periodic *w, ev_tstamp now)
  1603. \& {
  1604. \& return fmod (now, 3600.) + 3600.;
  1605. \& }
  1606. \&
  1607. \& ev_periodic_init (&hourly_tick, clock_cb, 0., 0., my_scheduler_cb);
  1608. .Ve
  1609. .PP
  1610. Example: Call a callback every hour, starting now:
  1611. .PP
  1612. .Vb 4
  1613. \& struct ev_periodic hourly_tick;
  1614. \& ev_periodic_init (&hourly_tick, clock_cb,
  1615. \& fmod (ev_now (loop), 3600.), 3600., 0);
  1616. \& ev_periodic_start (loop, &hourly_tick);
  1617. .Ve
  1618. .ie n .Sh """ev_signal"" \- signal me when a signal gets signalled!"
  1619. .el .Sh "\f(CWev_signal\fP \- signal me when a signal gets signalled!"
  1620. .IX Subsection "ev_signal - signal me when a signal gets signalled!"
  1621. Signal watchers will trigger an event when the process receives a specific
  1622. signal one or more times. Even though signals are very asynchronous, libev
  1623. will try it's best to deliver signals synchronously, i.e. as part of the
  1624. normal event processing, like any other event.
  1625. .PP
  1626. You can configure as many watchers as you like per signal. Only when the
  1627. first watcher gets started will libev actually register a signal watcher
  1628. with the kernel (thus it coexists with your own signal handlers as long
  1629. as you don't register any with libev). Similarly, when the last signal
  1630. watcher for a signal is stopped libev will reset the signal handler to
  1631. \&\s-1SIG_DFL\s0 (regardless of what it was set to before).
  1632. .PP
  1633. If possible and supported, libev will install its handlers with
  1634. \&\f(CW\*(C`SA_RESTART\*(C'\fR behaviour enabled, so syscalls should not be unduly
  1635. interrupted. If you have a problem with syscalls getting interrupted by
  1636. signals you can block all signals in an \f(CW\*(C`ev_check\*(C'\fR watcher and unblock
  1637. them in an \f(CW\*(C`ev_prepare\*(C'\fR watcher.
  1638. .PP
  1639. \fIWatcher-Specific Functions and Data Members\fR
  1640. .IX Subsection "Watcher-Specific Functions and Data Members"
  1641. .IP "ev_signal_init (ev_signal *, callback, int signum)" 4
  1642. .IX Item "ev_signal_init (ev_signal *, callback, int signum)"
  1643. .PD 0
  1644. .IP "ev_signal_set (ev_signal *, int signum)" 4
  1645. .IX Item "ev_signal_set (ev_signal *, int signum)"
  1646. .PD
  1647. Configures the watcher to trigger on the given signal number (usually one
  1648. of the \f(CW\*(C`SIGxxx\*(C'\fR constants).
  1649. .IP "int signum [read\-only]" 4
  1650. .IX Item "int signum [read-only]"
  1651. The signal the watcher watches out for.
  1652. .PP
  1653. \fIExamples\fR
  1654. .IX Subsection "Examples"
  1655. .PP
  1656. Example: Try to exit cleanly on \s-1SIGINT\s0 and \s-1SIGTERM\s0.
  1657. .PP
  1658. .Vb 5
  1659. \& static void
  1660. \& sigint_cb (struct ev_loop *loop, struct ev_signal *w, int revents)
  1661. \& {
  1662. \& ev_unloop (loop, EVUNLOOP_ALL);
  1663. \& }
  1664. \&
  1665. \& struct ev_signal signal_watcher;
  1666. \& ev_signal_init (&signal_watcher, sigint_cb, SIGINT);
  1667. \& ev_signal_start (loop, &sigint_cb);
  1668. .Ve
  1669. .ie n .Sh """ev_child"" \- watch out for process status changes"
  1670. .el .Sh "\f(CWev_child\fP \- watch out for process status changes"
  1671. .IX Subsection "ev_child - watch out for process status changes"
  1672. Child watchers trigger when your process receives a \s-1SIGCHLD\s0 in response to
  1673. some child status changes (most typically when a child of yours dies). It
  1674. is permissible to install a child watcher \fIafter\fR the child has been
  1675. forked (which implies it might have already exited), as long as the event
  1676. loop isn't entered (or is continued from a watcher).
  1677. .PP
  1678. Only the default event loop is capable of handling signals, and therefore
  1679. you can only rgeister child watchers in the default event loop.
  1680. .PP
  1681. \fIProcess Interaction\fR
  1682. .IX Subsection "Process Interaction"
  1683. .PP
  1684. Libev grabs \f(CW\*(C`SIGCHLD\*(C'\fR as soon as the default event loop is
  1685. initialised. This is necessary to guarantee proper behaviour even if
  1686. the first child watcher is started after the child exits. The occurance
  1687. of \f(CW\*(C`SIGCHLD\*(C'\fR is recorded asynchronously, but child reaping is done
  1688. synchronously as part of the event loop processing. Libev always reaps all
  1689. children, even ones not watched.
  1690. .PP
  1691. \fIOverriding the Built-In Processing\fR
  1692. .IX Subsection "Overriding the Built-In Processing"
  1693. .PP
  1694. Libev offers no special support for overriding the built-in child
  1695. processing, but if your application collides with libev's default child
  1696. handler, you can override it easily by installing your own handler for
  1697. \&\f(CW\*(C`SIGCHLD\*(C'\fR after initialising the default loop, and making sure the
  1698. default loop never gets destroyed. You are encouraged, however, to use an
  1699. event-based approach to child reaping and thus use libev's support for
  1700. that, so other libev users can use \f(CW\*(C`ev_child\*(C'\fR watchers freely.
  1701. .PP
  1702. \fIWatcher-Specific Functions and Data Members\fR
  1703. .IX Subsection "Watcher-Specific Functions and Data Members"
  1704. .IP "ev_child_init (ev_child *, callback, int pid, int trace)" 4
  1705. .IX Item "ev_child_init (ev_child *, callback, int pid, int trace)"
  1706. .PD 0
  1707. .IP "ev_child_set (ev_child *, int pid, int trace)" 4
  1708. .IX Item "ev_child_set (ev_child *, int pid, int trace)"
  1709. .PD
  1710. Configures the watcher to wait for status changes of process \f(CW\*(C`pid\*(C'\fR (or
  1711. \&\fIany\fR process if \f(CW\*(C`pid\*(C'\fR is specified as \f(CW0\fR). The callback can look
  1712. at the \f(CW\*(C`rstatus\*(C'\fR member of the \f(CW\*(C`ev_child\*(C'\fR watcher structure to see
  1713. the status word (use the macros from \f(CW\*(C`sys/wait.h\*(C'\fR and see your systems
  1714. \&\f(CW\*(C`waitpid\*(C'\fR documentation). The \f(CW\*(C`rpid\*(C'\fR member contains the pid of the
  1715. process causing the status change. \f(CW\*(C`trace\*(C'\fR must be either \f(CW0\fR (only
  1716. activate the watcher when the process terminates) or \f(CW1\fR (additionally
  1717. activate the watcher when the process is stopped or continued).
  1718. .IP "int pid [read\-only]" 4
  1719. .IX Item "int pid [read-only]"
  1720. The process id this watcher watches out for, or \f(CW0\fR, meaning any process id.
  1721. .IP "int rpid [read\-write]" 4
  1722. .IX Item "int rpid [read-write]"
  1723. The process id that detected a status change.
  1724. .IP "int rstatus [read\-write]" 4
  1725. .IX Item "int rstatus [read-write]"
  1726. The process exit/trace status caused by \f(CW\*(C`rpid\*(C'\fR (see your systems
  1727. \&\f(CW\*(C`waitpid\*(C'\fR and \f(CW\*(C`sys/wait.h\*(C'\fR documentation for details).
  1728. .PP
  1729. \fIExamples\fR
  1730. .IX Subsection "Examples"
  1731. .PP
  1732. Example: \f(CW\*(C`fork()\*(C'\fR a new process and install a child handler to wait for
  1733. its completion.
  1734. .PP
  1735. .Vb 1
  1736. \& ev_child cw;
  1737. \&
  1738. \& static void
  1739. \& child_cb (EV_P_ struct ev_child *w, int revents)
  1740. \& {
  1741. \& ev_child_stop (EV_A_ w);
  1742. \& printf ("process %d exited with status %x\en", w\->rpid, w\->rstatus);
  1743. \& }
  1744. \&
  1745. \& pid_t pid = fork ();
  1746. \&
  1747. \& if (pid < 0)
  1748. \& // error
  1749. \& else if (pid == 0)
  1750. \& {
  1751. \& // the forked child executes here
  1752. \& exit (1);
  1753. \& }
  1754. \& else
  1755. \& {
  1756. \& ev_child_init (&cw, child_cb, pid, 0);
  1757. \& ev_child_start (EV_DEFAULT_ &cw);
  1758. \& }
  1759. .Ve
  1760. .ie n .Sh """ev_stat"" \- did the file attributes just change?"
  1761. .el .Sh "\f(CWev_stat\fP \- did the file attributes just change?"
  1762. .IX Subsection "ev_stat - did the file attributes just change?"
  1763. This watches a filesystem path for attribute changes. That is, it calls
  1764. \&\f(CW\*(C`stat\*(C'\fR regularly (or when the \s-1OS\s0 says it changed) and sees if it changed
  1765. compared to the last time, invoking the callback if it did.
  1766. .PP
  1767. The path does not need to exist: changing from \*(L"path exists\*(R" to \*(L"path does
  1768. not exist\*(R" is a status change like any other. The condition \*(L"path does
  1769. not exist\*(R" is signified by the \f(CW\*(C`st_nlink\*(C'\fR field being zero (which is
  1770. otherwise always forced to be at least one) and all the other fields of
  1771. the stat buffer having unspecified contents.
  1772. .PP
  1773. The path \fIshould\fR be absolute and \fImust not\fR end in a slash. If it is
  1774. relative and your working directory changes, the behaviour is undefined.
  1775. .PP
  1776. Since there is no standard to do this, the portable implementation simply
  1777. calls \f(CW\*(C`stat (2)\*(C'\fR regularly on the path to see if it changed somehow. You
  1778. can specify a recommended polling interval for this case. If you specify
  1779. a polling interval of \f(CW0\fR (highly recommended!) then a \fIsuitable,
  1780. unspecified default\fR value will be used (which you can expect to be around
  1781. five seconds, although this might change dynamically). Libev will also
  1782. impose a minimum interval which is currently around \f(CW0.1\fR, but thats
  1783. usually overkill.
  1784. .PP
  1785. This watcher type is not meant for massive numbers of stat watchers,
  1786. as even with OS-supported change notifications, this can be
  1787. resource-intensive.
  1788. .PP
  1789. At the time of this writing, only the Linux inotify interface is
  1790. implemented (implementing kqueue support is left as an exercise for the
  1791. reader, note, however, that the author sees no way of implementing ev_stat
  1792. semantics with kqueue). Inotify will be used to give hints only and should
  1793. not change the semantics of \f(CW\*(C`ev_stat\*(C'\fR watchers, which means that libev
  1794. sometimes needs to fall back to regular polling again even with inotify,
  1795. but changes are usually detected immediately, and if the file exists there
  1796. will be no polling.
  1797. .PP
  1798. \fI\s-1ABI\s0 Issues (Largefile Support)\fR
  1799. .IX Subsection "ABI Issues (Largefile Support)"
  1800. .PP
  1801. Libev by default (unless the user overrides this) uses the default
  1802. compilation environment, which means that on systems with optionally
  1803. disabled large file support, you get the 32 bit version of the stat
  1804. structure. When using the library from programs that change the \s-1ABI\s0 to
  1805. use 64 bit file offsets the programs will fail. In that case you have to
  1806. compile libev with the same flags to get binary compatibility. This is
  1807. obviously the case with any flags that change the \s-1ABI\s0, but the problem is
  1808. most noticably with ev_stat and largefile support.
  1809. .PP
  1810. \fIInotify\fR
  1811. .IX Subsection "Inotify"
  1812. .PP
  1813. When \f(CW\*(C`inotify (7)\*(C'\fR support has been compiled into libev (generally only
  1814. available on Linux) and present at runtime, it will be used to speed up
  1815. change detection where possible. The inotify descriptor will be created lazily
  1816. when the first \f(CW\*(C`ev_stat\*(C'\fR watcher is being started.
  1817. .PP
  1818. Inotify presence does not change the semantics of \f(CW\*(C`ev_stat\*(C'\fR watchers
  1819. except that changes might be detected earlier, and in some cases, to avoid
  1820. making regular \f(CW\*(C`stat\*(C'\fR calls. Even in the presence of inotify support
  1821. there are many cases where libev has to resort to regular \f(CW\*(C`stat\*(C'\fR polling.
  1822. .PP
  1823. (There is no support for kqueue, as apparently it cannot be used to
  1824. implement this functionality, due to the requirement of having a file
  1825. descriptor open on the object at all times).
  1826. .PP
  1827. \fIThe special problem of stat time resolution\fR
  1828. .IX Subsection "The special problem of stat time resolution"
  1829. .PP
  1830. The \f(CW\*(C`stat ()\*(C'\fR syscall only supports full-second resolution portably, and
  1831. even on systems where the resolution is higher, many filesystems still
  1832. only support whole seconds.
  1833. .PP
  1834. That means that, if the time is the only thing that changes, you can
  1835. easily miss updates: on the first update, \f(CW\*(C`ev_stat\*(C'\fR detects a change and
  1836. calls your callback, which does something. When there is another update
  1837. within the same second, \f(CW\*(C`ev_stat\*(C'\fR will be unable to detect it as the stat
  1838. data does not change.
  1839. .PP
  1840. The solution to this is to delay acting on a change for slightly more
  1841. than a second (or till slightly after the next full second boundary), using
  1842. a roughly one-second-delay \f(CW\*(C`ev_timer\*(C'\fR (e.g. \f(CW\*(C`ev_timer_set (w, 0., 1.02);
  1843. ev_timer_again (loop, w)\*(C'\fR).
  1844. .PP
  1845. The \f(CW.02\fR offset is added to work around small timing inconsistencies
  1846. of some operating systems (where the second counter of the current time
  1847. might be be delayed. One such system is the Linux kernel, where a call to
  1848. \&\f(CW\*(C`gettimeofday\*(C'\fR might return a timestamp with a full second later than
  1849. a subsequent \f(CW\*(C`time\*(C'\fR call \- if the equivalent of \f(CW\*(C`time ()\*(C'\fR is used to
  1850. update file times then there will be a small window where the kernel uses
  1851. the previous second to update file times but libev might already execute
  1852. the timer callback).
  1853. .PP
  1854. \fIWatcher-Specific Functions and Data Members\fR
  1855. .IX Subsection "Watcher-Specific Functions and Data Members"
  1856. .IP "ev_stat_init (ev_stat *, callback, const char *path, ev_tstamp interval)" 4
  1857. .IX Item "ev_stat_init (ev_stat *, callback, const char *path, ev_tstamp interval)"
  1858. .PD 0
  1859. .IP "ev_stat_set (ev_stat *, const char *path, ev_tstamp interval)" 4
  1860. .IX Item "ev_stat_set (ev_stat *, const char *path, ev_tstamp interval)"
  1861. .PD
  1862. Configures the watcher to wait for status changes of the given
  1863. \&\f(CW\*(C`path\*(C'\fR. The \f(CW\*(C`interval\*(C'\fR is a hint on how quickly a change is expected to
  1864. be detected and should normally be specified as \f(CW0\fR to let libev choose
  1865. a suitable value. The memory pointed to by \f(CW\*(C`path\*(C'\fR must point to the same
  1866. path for as long as the watcher is active.
  1867. .Sp
  1868. The callback will receive \f(CW\*(C`EV_STAT\*(C'\fR when a change was detected, relative
  1869. to the attributes at the time the watcher was started (or the last change
  1870. was detected).
  1871. .IP "ev_stat_stat (loop, ev_stat *)" 4
  1872. .IX Item "ev_stat_stat (loop, ev_stat *)"
  1873. Updates the stat buffer immediately with new values. If you change the
  1874. watched path in your callback, you could call this function to avoid
  1875. detecting this change (while introducing a race condition if you are not
  1876. the only one changing the path). Can also be useful simply to find out the
  1877. new values.
  1878. .IP "ev_statdata attr [read\-only]" 4
  1879. .IX Item "ev_statdata attr [read-only]"
  1880. The most-recently detected attributes of the file. Although the type is
  1881. \&\f(CW\*(C`ev_statdata\*(C'\fR, this is usually the (or one of the) \f(CW\*(C`struct stat\*(C'\fR types
  1882. suitable for your system, but you can only rely on the POSIX-standardised
  1883. members to be present. If the \f(CW\*(C`st_nlink\*(C'\fR member is \f(CW0\fR, then there was
  1884. some error while \f(CW\*(C`stat\*(C'\fRing the file.
  1885. .IP "ev_statdata prev [read\-only]" 4
  1886. .IX Item "ev_statdata prev [read-only]"
  1887. The previous attributes of the file. The callback gets invoked whenever
  1888. \&\f(CW\*(C`prev\*(C'\fR != \f(CW\*(C`attr\*(C'\fR, or, more precisely, one or more of these members
  1889. differ: \f(CW\*(C`st_dev\*(C'\fR, \f(CW\*(C`st_ino\*(C'\fR, \f(CW\*(C`st_mode\*(C'\fR, \f(CW\*(C`st_nlink\*(C'\fR, \f(CW\*(C`st_uid\*(C'\fR,
  1890. \&\f(CW\*(C`st_gid\*(C'\fR, \f(CW\*(C`st_rdev\*(C'\fR, \f(CW\*(C`st_size\*(C'\fR, \f(CW\*(C`st_atime\*(C'\fR, \f(CW\*(C`st_mtime\*(C'\fR, \f(CW\*(C`st_ctime\*(C'\fR.
  1891. .IP "ev_tstamp interval [read\-only]" 4
  1892. .IX Item "ev_tstamp interval [read-only]"
  1893. The specified interval.
  1894. .IP "const char *path [read\-only]" 4
  1895. .IX Item "const char *path [read-only]"
  1896. The filesystem path that is being watched.
  1897. .PP
  1898. \fIExamples\fR
  1899. .IX Subsection "Examples"
  1900. .PP
  1901. Example: Watch \f(CW\*(C`/etc/passwd\*(C'\fR for attribute changes.
  1902. .PP
  1903. .Vb 10
  1904. \& static void
  1905. \& passwd_cb (struct ev_loop *loop, ev_stat *w, int revents)
  1906. \& {
  1907. \& /* /etc/passwd changed in some way */
  1908. \& if (w\->attr.st_nlink)
  1909. \& {
  1910. \& printf ("passwd current size %ld\en", (long)w\->attr.st_size);
  1911. \& printf ("passwd current atime %ld\en", (long)w\->attr.st_mtime);
  1912. \& printf ("passwd current mtime %ld\en", (long)w\->attr.st_mtime);
  1913. \& }
  1914. \& else
  1915. \& /* you shalt not abuse printf for puts */
  1916. \& puts ("wow, /etc/passwd is not there, expect problems. "
  1917. \& "if this is windows, they already arrived\en");
  1918. \& }
  1919. \&
  1920. \& ...
  1921. \& ev_stat passwd;
  1922. \&
  1923. \& ev_stat_init (&passwd, passwd_cb, "/etc/passwd", 0.);
  1924. \& ev_stat_start (loop, &passwd);
  1925. .Ve
  1926. .PP
  1927. Example: Like above, but additionally use a one-second delay so we do not
  1928. miss updates (however, frequent updates will delay processing, too, so
  1929. one might do the work both on \f(CW\*(C`ev_stat\*(C'\fR callback invocation \fIand\fR on
  1930. \&\f(CW\*(C`ev_timer\*(C'\fR callback invocation).
  1931. .PP
  1932. .Vb 2
  1933. \& static ev_stat passwd;
  1934. \& static ev_timer timer;
  1935. \&
  1936. \& static void
  1937. \& timer_cb (EV_P_ ev_timer *w, int revents)
  1938. \& {
  1939. \& ev_timer_stop (EV_A_ w);
  1940. \&
  1941. \& /* now it\*(Aqs one second after the most recent passwd change */
  1942. \& }
  1943. \&
  1944. \& static void
  1945. \& stat_cb (EV_P_ ev_stat *w, int revents)
  1946. \& {
  1947. \& /* reset the one\-second timer */
  1948. \& ev_timer_again (EV_A_ &timer);
  1949. \& }
  1950. \&
  1951. \& ...
  1952. \& ev_stat_init (&passwd, stat_cb, "/etc/passwd", 0.);
  1953. \& ev_stat_start (loop, &passwd);
  1954. \& ev_timer_init (&timer, timer_cb, 0., 1.02);
  1955. .Ve
  1956. .ie n .Sh """ev_idle"" \- when you've got nothing better to do..."
  1957. .el .Sh "\f(CWev_idle\fP \- when you've got nothing better to do..."
  1958. .IX Subsection "ev_idle - when you've got nothing better to do..."
  1959. Idle watchers trigger events when no other events of the same or higher
  1960. priority are pending (prepare, check and other idle watchers do not
  1961. count).
  1962. .PP
  1963. That is, as long as your process is busy handling sockets or timeouts
  1964. (or even signals, imagine) of the same or higher priority it will not be
  1965. triggered. But when your process is idle (or only lower-priority watchers
  1966. are pending), the idle watchers are being called once per event loop
  1967. iteration \- until stopped, that is, or your process receives more events
  1968. and becomes busy again with higher priority stuff.
  1969. .PP
  1970. The most noteworthy effect is that as long as any idle watchers are
  1971. active, the process will not block when waiting for new events.
  1972. .PP
  1973. Apart from keeping your process non-blocking (which is a useful
  1974. effect on its own sometimes), idle watchers are a good place to do
  1975. \&\*(L"pseudo-background processing\*(R", or delay processing stuff to after the
  1976. event loop has handled all outstanding events.
  1977. .PP
  1978. \fIWatcher-Specific Functions and Data Members\fR
  1979. .IX Subsection "Watcher-Specific Functions and Data Members"
  1980. .IP "ev_idle_init (ev_signal *, callback)" 4
  1981. .IX Item "ev_idle_init (ev_signal *, callback)"
  1982. Initialises and configures the idle watcher \- it has no parameters of any
  1983. kind. There is a \f(CW\*(C`ev_idle_set\*(C'\fR macro, but using it is utterly pointless,
  1984. believe me.
  1985. .PP
  1986. \fIExamples\fR
  1987. .IX Subsection "Examples"
  1988. .PP
  1989. Example: Dynamically allocate an \f(CW\*(C`ev_idle\*(C'\fR watcher, start it, and in the
  1990. callback, free it. Also, use no error checking, as usual.
  1991. .PP
  1992. .Vb 7
  1993. \& static void
  1994. \& idle_cb (struct ev_loop *loop, struct ev_idle *w, int revents)
  1995. \& {
  1996. \& free (w);
  1997. \& // now do something you wanted to do when the program has
  1998. \& // no longer anything immediate to do.
  1999. \& }
  2000. \&
  2001. \& struct ev_idle *idle_watcher = malloc (sizeof (struct ev_idle));
  2002. \& ev_idle_init (idle_watcher, idle_cb);
  2003. \& ev_idle_start (loop, idle_cb);
  2004. .Ve
  2005. .ie n .Sh """ev_prepare""\fP and \f(CW""ev_check"" \- customise your event loop!"
  2006. .el .Sh "\f(CWev_prepare\fP and \f(CWev_check\fP \- customise your event loop!"
  2007. .IX Subsection "ev_prepare and ev_check - customise your event loop!"
  2008. Prepare and check watchers are usually (but not always) used in tandem:
  2009. prepare watchers get invoked before the process blocks and check watchers
  2010. afterwards.
  2011. .PP
  2012. You \fImust not\fR call \f(CW\*(C`ev_loop\*(C'\fR or similar functions that enter
  2013. the current event loop from either \f(CW\*(C`ev_prepare\*(C'\fR or \f(CW\*(C`ev_check\*(C'\fR
  2014. watchers. Other loops than the current one are fine, however. The
  2015. rationale behind this is that you do not need to check for recursion in
  2016. those watchers, i.e. the sequence will always be \f(CW\*(C`ev_prepare\*(C'\fR, blocking,
  2017. \&\f(CW\*(C`ev_check\*(C'\fR so if you have one watcher of each kind they will always be
  2018. called in pairs bracketing the blocking call.
  2019. .PP
  2020. Their main purpose is to integrate other event mechanisms into libev and
  2021. their use is somewhat advanced. This could be used, for example, to track
  2022. variable changes, implement your own watchers, integrate net-snmp or a
  2023. coroutine library and lots more. They are also occasionally useful if
  2024. you cache some data and want to flush it before blocking (for example,
  2025. in X programs you might want to do an \f(CW\*(C`XFlush ()\*(C'\fR in an \f(CW\*(C`ev_prepare\*(C'\fR
  2026. watcher).
  2027. .PP
  2028. This is done by examining in each prepare call which file descriptors need
  2029. to be watched by the other library, registering \f(CW\*(C`ev_io\*(C'\fR watchers for
  2030. them and starting an \f(CW\*(C`ev_timer\*(C'\fR watcher for any timeouts (many libraries
  2031. provide just this functionality). Then, in the check watcher you check for
  2032. any events that occured (by checking the pending status of all watchers
  2033. and stopping them) and call back into the library. The I/O and timer
  2034. callbacks will never actually be called (but must be valid nevertheless,
  2035. because you never know, you know?).
  2036. .PP
  2037. As another example, the Perl Coro module uses these hooks to integrate
  2038. coroutines into libev programs, by yielding to other active coroutines
  2039. during each prepare and only letting the process block if no coroutines
  2040. are ready to run (it's actually more complicated: it only runs coroutines
  2041. with priority higher than or equal to the event loop and one coroutine
  2042. of lower priority, but only once, using idle watchers to keep the event
  2043. loop from blocking if lower-priority coroutines are active, thus mapping
  2044. low-priority coroutines to idle/background tasks).
  2045. .PP
  2046. It is recommended to give \f(CW\*(C`ev_check\*(C'\fR watchers highest (\f(CW\*(C`EV_MAXPRI\*(C'\fR)
  2047. priority, to ensure that they are being run before any other watchers
  2048. after the poll. Also, \f(CW\*(C`ev_check\*(C'\fR watchers (and \f(CW\*(C`ev_prepare\*(C'\fR watchers,
  2049. too) should not activate (\*(L"feed\*(R") events into libev. While libev fully
  2050. supports this, they might get executed before other \f(CW\*(C`ev_check\*(C'\fR watchers
  2051. did their job. As \f(CW\*(C`ev_check\*(C'\fR watchers are often used to embed other
  2052. (non-libev) event loops those other event loops might be in an unusable
  2053. state until their \f(CW\*(C`ev_check\*(C'\fR watcher ran (always remind yourself to
  2054. coexist peacefully with others).
  2055. .PP
  2056. \fIWatcher-Specific Functions and Data Members\fR
  2057. .IX Subsection "Watcher-Specific Functions and Data Members"
  2058. .IP "ev_prepare_init (ev_prepare *, callback)" 4
  2059. .IX Item "ev_prepare_init (ev_prepare *, callback)"
  2060. .PD 0
  2061. .IP "ev_check_init (ev_check *, callback)" 4
  2062. .IX Item "ev_check_init (ev_check *, callback)"
  2063. .PD
  2064. Initialises and configures the prepare or check watcher \- they have no
  2065. parameters of any kind. There are \f(CW\*(C`ev_prepare_set\*(C'\fR and \f(CW\*(C`ev_check_set\*(C'\fR
  2066. macros, but using them is utterly, utterly and completely pointless.
  2067. .PP
  2068. \fIExamples\fR
  2069. .IX Subsection "Examples"
  2070. .PP
  2071. There are a number of principal ways to embed other event loops or modules
  2072. into libev. Here are some ideas on how to include libadns into libev
  2073. (there is a Perl module named \f(CW\*(C`EV::ADNS\*(C'\fR that does this, which you could
  2074. use as a working example. Another Perl module named \f(CW\*(C`EV::Glib\*(C'\fR embeds a
  2075. Glib main context into libev, and finally, \f(CW\*(C`Glib::EV\*(C'\fR embeds \s-1EV\s0 into the
  2076. Glib event loop).
  2077. .PP
  2078. Method 1: Add \s-1IO\s0 watchers and a timeout watcher in a prepare handler,
  2079. and in a check watcher, destroy them and call into libadns. What follows
  2080. is pseudo-code only of course. This requires you to either use a low
  2081. priority for the check watcher or use \f(CW\*(C`ev_clear_pending\*(C'\fR explicitly, as
  2082. the callbacks for the IO/timeout watchers might not have been called yet.
  2083. .PP
  2084. .Vb 2
  2085. \& static ev_io iow [nfd];
  2086. \& static ev_timer tw;
  2087. \&
  2088. \& static void
  2089. \& io_cb (ev_loop *loop, ev_io *w, int revents)
  2090. \& {
  2091. \& }
  2092. \&
  2093. \& // create io watchers for each fd and a timer before blocking
  2094. \& static void
  2095. \& adns_prepare_cb (ev_loop *loop, ev_prepare *w, int revents)
  2096. \& {
  2097. \& int timeout = 3600000;
  2098. \& struct pollfd fds [nfd];
  2099. \& // actual code will need to loop here and realloc etc.
  2100. \& adns_beforepoll (ads, fds, &nfd, &timeout, timeval_from (ev_time ()));
  2101. \&
  2102. \& /* the callback is illegal, but won\*(Aqt be called as we stop during check */
  2103. \& ev_timer_init (&tw, 0, timeout * 1e\-3);
  2104. \& ev_timer_start (loop, &tw);
  2105. \&
  2106. \& // create one ev_io per pollfd
  2107. \& for (int i = 0; i < nfd; ++i)
  2108. \& {
  2109. \& ev_io_init (iow + i, io_cb, fds [i].fd,
  2110. \& ((fds [i].events & POLLIN ? EV_READ : 0)
  2111. \& | (fds [i].events & POLLOUT ? EV_WRITE : 0)));
  2112. \&
  2113. \& fds [i].revents = 0;
  2114. \& ev_io_start (loop, iow + i);
  2115. \& }
  2116. \& }
  2117. \&
  2118. \& // stop all watchers after blocking
  2119. \& static void
  2120. \& adns_check_cb (ev_loop *loop, ev_check *w, int revents)
  2121. \& {
  2122. \& ev_timer_stop (loop, &tw);
  2123. \&
  2124. \& for (int i = 0; i < nfd; ++i)
  2125. \& {
  2126. \& // set the relevant poll flags
  2127. \& // could also call adns_processreadable etc. here
  2128. \& struct pollfd *fd = fds + i;
  2129. \& int revents = ev_clear_pending (iow + i);
  2130. \& if (revents & EV_READ ) fd\->revents |= fd\->events & POLLIN;
  2131. \& if (revents & EV_WRITE) fd\->revents |= fd\->events & POLLOUT;
  2132. \&
  2133. \& // now stop the watcher
  2134. \& ev_io_stop (loop, iow + i);
  2135. \& }
  2136. \&
  2137. \& adns_afterpoll (adns, fds, nfd, timeval_from (ev_now (loop));
  2138. \& }
  2139. .Ve
  2140. .PP
  2141. Method 2: This would be just like method 1, but you run \f(CW\*(C`adns_afterpoll\*(C'\fR
  2142. in the prepare watcher and would dispose of the check watcher.
  2143. .PP
  2144. Method 3: If the module to be embedded supports explicit event
  2145. notification (adns does), you can also make use of the actual watcher
  2146. callbacks, and only destroy/create the watchers in the prepare watcher.
  2147. .PP
  2148. .Vb 5
  2149. \& static void
  2150. \& timer_cb (EV_P_ ev_timer *w, int revents)
  2151. \& {
  2152. \& adns_state ads = (adns_state)w\->data;
  2153. \& update_now (EV_A);
  2154. \&
  2155. \& adns_processtimeouts (ads, &tv_now);
  2156. \& }
  2157. \&
  2158. \& static void
  2159. \& io_cb (EV_P_ ev_io *w, int revents)
  2160. \& {
  2161. \& adns_state ads = (adns_state)w\->data;
  2162. \& update_now (EV_A);
  2163. \&
  2164. \& if (revents & EV_READ ) adns_processreadable (ads, w\->fd, &tv_now);
  2165. \& if (revents & EV_WRITE) adns_processwriteable (ads, w\->fd, &tv_now);
  2166. \& }
  2167. \&
  2168. \& // do not ever call adns_afterpoll
  2169. .Ve
  2170. .PP
  2171. Method 4: Do not use a prepare or check watcher because the module you
  2172. want to embed is too inflexible to support it. Instead, youc na override
  2173. their poll function. The drawback with this solution is that the main
  2174. loop is now no longer controllable by \s-1EV\s0. The \f(CW\*(C`Glib::EV\*(C'\fR module does
  2175. this.
  2176. .PP
  2177. .Vb 4
  2178. \& static gint
  2179. \& event_poll_func (GPollFD *fds, guint nfds, gint timeout)
  2180. \& {
  2181. \& int got_events = 0;
  2182. \&
  2183. \& for (n = 0; n < nfds; ++n)
  2184. \& // create/start io watcher that sets the relevant bits in fds[n] and increment got_events
  2185. \&
  2186. \& if (timeout >= 0)
  2187. \& // create/start timer
  2188. \&
  2189. \& // poll
  2190. \& ev_loop (EV_A_ 0);
  2191. \&
  2192. \& // stop timer again
  2193. \& if (timeout >= 0)
  2194. \& ev_timer_stop (EV_A_ &to);
  2195. \&
  2196. \& // stop io watchers again \- their callbacks should have set
  2197. \& for (n = 0; n < nfds; ++n)
  2198. \& ev_io_stop (EV_A_ iow [n]);
  2199. \&
  2200. \& return got_events;
  2201. \& }
  2202. .Ve
  2203. .ie n .Sh """ev_embed"" \- when one backend isn't enough..."
  2204. .el .Sh "\f(CWev_embed\fP \- when one backend isn't enough..."
  2205. .IX Subsection "ev_embed - when one backend isn't enough..."
  2206. This is a rather advanced watcher type that lets you embed one event loop
  2207. into another (currently only \f(CW\*(C`ev_io\*(C'\fR events are supported in the embedded
  2208. loop, other types of watchers might be handled in a delayed or incorrect
  2209. fashion and must not be used).
  2210. .PP
  2211. There are primarily two reasons you would want that: work around bugs and
  2212. prioritise I/O.
  2213. .PP
  2214. As an example for a bug workaround, the kqueue backend might only support
  2215. sockets on some platform, so it is unusable as generic backend, but you
  2216. still want to make use of it because you have many sockets and it scales
  2217. so nicely. In this case, you would create a kqueue-based loop and embed it
  2218. into your default loop (which might use e.g. poll). Overall operation will
  2219. be a bit slower because first libev has to poll and then call kevent, but
  2220. at least you can use both at what they are best.
  2221. .PP
  2222. As for prioritising I/O: rarely you have the case where some fds have
  2223. to be watched and handled very quickly (with low latency), and even
  2224. priorities and idle watchers might have too much overhead. In this case
  2225. you would put all the high priority stuff in one loop and all the rest in
  2226. a second one, and embed the second one in the first.
  2227. .PP
  2228. As long as the watcher is active, the callback will be invoked every time
  2229. there might be events pending in the embedded loop. The callback must then
  2230. call \f(CW\*(C`ev_embed_sweep (mainloop, watcher)\*(C'\fR to make a single sweep and invoke
  2231. their callbacks (you could also start an idle watcher to give the embedded
  2232. loop strictly lower priority for example). You can also set the callback
  2233. to \f(CW0\fR, in which case the embed watcher will automatically execute the
  2234. embedded loop sweep.
  2235. .PP
  2236. As long as the watcher is started it will automatically handle events. The
  2237. callback will be invoked whenever some events have been handled. You can
  2238. set the callback to \f(CW0\fR to avoid having to specify one if you are not
  2239. interested in that.
  2240. .PP
  2241. Also, there have not currently been made special provisions for forking:
  2242. when you fork, you not only have to call \f(CW\*(C`ev_loop_fork\*(C'\fR on both loops,
  2243. but you will also have to stop and restart any \f(CW\*(C`ev_embed\*(C'\fR watchers
  2244. yourself.
  2245. .PP
  2246. Unfortunately, not all backends are embeddable, only the ones returned by
  2247. \&\f(CW\*(C`ev_embeddable_backends\*(C'\fR are, which, unfortunately, does not include any
  2248. portable one.
  2249. .PP
  2250. So when you want to use this feature you will always have to be prepared
  2251. that you cannot get an embeddable loop. The recommended way to get around
  2252. this is to have a separate variables for your embeddable loop, try to
  2253. create it, and if that fails, use the normal loop for everything.
  2254. .PP
  2255. \fIWatcher-Specific Functions and Data Members\fR
  2256. .IX Subsection "Watcher-Specific Functions and Data Members"
  2257. .IP "ev_embed_init (ev_embed *, callback, struct ev_loop *embedded_loop)" 4
  2258. .IX Item "ev_embed_init (ev_embed *, callback, struct ev_loop *embedded_loop)"
  2259. .PD 0
  2260. .IP "ev_embed_set (ev_embed *, callback, struct ev_loop *embedded_loop)" 4
  2261. .IX Item "ev_embed_set (ev_embed *, callback, struct ev_loop *embedded_loop)"
  2262. .PD
  2263. Configures the watcher to embed the given loop, which must be
  2264. embeddable. If the callback is \f(CW0\fR, then \f(CW\*(C`ev_embed_sweep\*(C'\fR will be
  2265. invoked automatically, otherwise it is the responsibility of the callback
  2266. to invoke it (it will continue to be called until the sweep has been done,
  2267. if you do not want thta, you need to temporarily stop the embed watcher).
  2268. .IP "ev_embed_sweep (loop, ev_embed *)" 4
  2269. .IX Item "ev_embed_sweep (loop, ev_embed *)"
  2270. Make a single, non-blocking sweep over the embedded loop. This works
  2271. similarly to \f(CW\*(C`ev_loop (embedded_loop, EVLOOP_NONBLOCK)\*(C'\fR, but in the most
  2272. apropriate way for embedded loops.
  2273. .IP "struct ev_loop *other [read\-only]" 4
  2274. .IX Item "struct ev_loop *other [read-only]"
  2275. The embedded event loop.
  2276. .PP
  2277. \fIExamples\fR
  2278. .IX Subsection "Examples"
  2279. .PP
  2280. Example: Try to get an embeddable event loop and embed it into the default
  2281. event loop. If that is not possible, use the default loop. The default
  2282. loop is stored in \f(CW\*(C`loop_hi\*(C'\fR, while the mebeddable loop is stored in
  2283. \&\f(CW\*(C`loop_lo\*(C'\fR (which is \f(CW\*(C`loop_hi\*(C'\fR in the acse no embeddable loop can be
  2284. used).
  2285. .PP
  2286. .Vb 3
  2287. \& struct ev_loop *loop_hi = ev_default_init (0);
  2288. \& struct ev_loop *loop_lo = 0;
  2289. \& struct ev_embed embed;
  2290. \&
  2291. \& // see if there is a chance of getting one that works
  2292. \& // (remember that a flags value of 0 means autodetection)
  2293. \& loop_lo = ev_embeddable_backends () & ev_recommended_backends ()
  2294. \& ? ev_loop_new (ev_embeddable_backends () & ev_recommended_backends ())
  2295. \& : 0;
  2296. \&
  2297. \& // if we got one, then embed it, otherwise default to loop_hi
  2298. \& if (loop_lo)
  2299. \& {
  2300. \& ev_embed_init (&embed, 0, loop_lo);
  2301. \& ev_embed_start (loop_hi, &embed);
  2302. \& }
  2303. \& else
  2304. \& loop_lo = loop_hi;
  2305. .Ve
  2306. .PP
  2307. Example: Check if kqueue is available but not recommended and create
  2308. a kqueue backend for use with sockets (which usually work with any
  2309. kqueue implementation). Store the kqueue/socket\-only event loop in
  2310. \&\f(CW\*(C`loop_socket\*(C'\fR. (One might optionally use \f(CW\*(C`EVFLAG_NOENV\*(C'\fR, too).
  2311. .PP
  2312. .Vb 3
  2313. \& struct ev_loop *loop = ev_default_init (0);
  2314. \& struct ev_loop *loop_socket = 0;
  2315. \& struct ev_embed embed;
  2316. \&
  2317. \& if (ev_supported_backends () & ~ev_recommended_backends () & EVBACKEND_KQUEUE)
  2318. \& if ((loop_socket = ev_loop_new (EVBACKEND_KQUEUE))
  2319. \& {
  2320. \& ev_embed_init (&embed, 0, loop_socket);
  2321. \& ev_embed_start (loop, &embed);
  2322. \& }
  2323. \&
  2324. \& if (!loop_socket)
  2325. \& loop_socket = loop;
  2326. \&
  2327. \& // now use loop_socket for all sockets, and loop for everything else
  2328. .Ve
  2329. .ie n .Sh """ev_fork"" \- the audacity to resume the event loop after a fork"
  2330. .el .Sh "\f(CWev_fork\fP \- the audacity to resume the event loop after a fork"
  2331. .IX Subsection "ev_fork - the audacity to resume the event loop after a fork"
  2332. Fork watchers are called when a \f(CW\*(C`fork ()\*(C'\fR was detected (usually because
  2333. whoever is a good citizen cared to tell libev about it by calling
  2334. \&\f(CW\*(C`ev_default_fork\*(C'\fR or \f(CW\*(C`ev_loop_fork\*(C'\fR). The invocation is done before the
  2335. event loop blocks next and before \f(CW\*(C`ev_check\*(C'\fR watchers are being called,
  2336. and only in the child after the fork. If whoever good citizen calling
  2337. \&\f(CW\*(C`ev_default_fork\*(C'\fR cheats and calls it in the wrong process, the fork
  2338. handlers will be invoked, too, of course.
  2339. .PP
  2340. \fIWatcher-Specific Functions and Data Members\fR
  2341. .IX Subsection "Watcher-Specific Functions and Data Members"
  2342. .IP "ev_fork_init (ev_signal *, callback)" 4
  2343. .IX Item "ev_fork_init (ev_signal *, callback)"
  2344. Initialises and configures the fork watcher \- it has no parameters of any
  2345. kind. There is a \f(CW\*(C`ev_fork_set\*(C'\fR macro, but using it is utterly pointless,
  2346. believe me.
  2347. .ie n .Sh """ev_async"" \- how to wake up another event loop"
  2348. .el .Sh "\f(CWev_async\fP \- how to wake up another event loop"
  2349. .IX Subsection "ev_async - how to wake up another event loop"
  2350. In general, you cannot use an \f(CW\*(C`ev_loop\*(C'\fR from multiple threads or other
  2351. asynchronous sources such as signal handlers (as opposed to multiple event
  2352. loops \- those are of course safe to use in different threads).
  2353. .PP
  2354. Sometimes, however, you need to wake up another event loop you do not
  2355. control, for example because it belongs to another thread. This is what
  2356. \&\f(CW\*(C`ev_async\*(C'\fR watchers do: as long as the \f(CW\*(C`ev_async\*(C'\fR watcher is active, you
  2357. can signal it by calling \f(CW\*(C`ev_async_send\*(C'\fR, which is thread\- and signal
  2358. safe.
  2359. .PP
  2360. This functionality is very similar to \f(CW\*(C`ev_signal\*(C'\fR watchers, as signals,
  2361. too, are asynchronous in nature, and signals, too, will be compressed
  2362. (i.e. the number of callback invocations may be less than the number of
  2363. \&\f(CW\*(C`ev_async_sent\*(C'\fR calls).
  2364. .PP
  2365. Unlike \f(CW\*(C`ev_signal\*(C'\fR watchers, \f(CW\*(C`ev_async\*(C'\fR works with any event loop, not
  2366. just the default loop.
  2367. .PP
  2368. \fIQueueing\fR
  2369. .IX Subsection "Queueing"
  2370. .PP
  2371. \&\f(CW\*(C`ev_async\*(C'\fR does not support queueing of data in any way. The reason
  2372. is that the author does not know of a simple (or any) algorithm for a
  2373. multiple-writer-single-reader queue that works in all cases and doesn't
  2374. need elaborate support such as pthreads.
  2375. .PP
  2376. That means that if you want to queue data, you have to provide your own
  2377. queue. But at least I can tell you would implement locking around your
  2378. queue:
  2379. .IP "queueing from a signal handler context" 4
  2380. .IX Item "queueing from a signal handler context"
  2381. To implement race-free queueing, you simply add to the queue in the signal
  2382. handler but you block the signal handler in the watcher callback. Here is an example that does that for
  2383. some fictitiuous \s-1SIGUSR1\s0 handler:
  2384. .Sp
  2385. .Vb 1
  2386. \& static ev_async mysig;
  2387. \&
  2388. \& static void
  2389. \& sigusr1_handler (void)
  2390. \& {
  2391. \& sometype data;
  2392. \&
  2393. \& // no locking etc.
  2394. \& queue_put (data);
  2395. \& ev_async_send (EV_DEFAULT_ &mysig);
  2396. \& }
  2397. \&
  2398. \& static void
  2399. \& mysig_cb (EV_P_ ev_async *w, int revents)
  2400. \& {
  2401. \& sometype data;
  2402. \& sigset_t block, prev;
  2403. \&
  2404. \& sigemptyset (&block);
  2405. \& sigaddset (&block, SIGUSR1);
  2406. \& sigprocmask (SIG_BLOCK, &block, &prev);
  2407. \&
  2408. \& while (queue_get (&data))
  2409. \& process (data);
  2410. \&
  2411. \& if (sigismember (&prev, SIGUSR1)
  2412. \& sigprocmask (SIG_UNBLOCK, &block, 0);
  2413. \& }
  2414. .Ve
  2415. .Sp
  2416. (Note: pthreads in theory requires you to use \f(CW\*(C`pthread_setmask\*(C'\fR
  2417. instead of \f(CW\*(C`sigprocmask\*(C'\fR when you use threads, but libev doesn't do it
  2418. either...).
  2419. .IP "queueing from a thread context" 4
  2420. .IX Item "queueing from a thread context"
  2421. The strategy for threads is different, as you cannot (easily) block
  2422. threads but you can easily preempt them, so to queue safely you need to
  2423. employ a traditional mutex lock, such as in this pthread example:
  2424. .Sp
  2425. .Vb 2
  2426. \& static ev_async mysig;
  2427. \& static pthread_mutex_t mymutex = PTHREAD_MUTEX_INITIALIZER;
  2428. \&
  2429. \& static void
  2430. \& otherthread (void)
  2431. \& {
  2432. \& // only need to lock the actual queueing operation
  2433. \& pthread_mutex_lock (&mymutex);
  2434. \& queue_put (data);
  2435. \& pthread_mutex_unlock (&mymutex);
  2436. \&
  2437. \& ev_async_send (EV_DEFAULT_ &mysig);
  2438. \& }
  2439. \&
  2440. \& static void
  2441. \& mysig_cb (EV_P_ ev_async *w, int revents)
  2442. \& {
  2443. \& pthread_mutex_lock (&mymutex);
  2444. \&
  2445. \& while (queue_get (&data))
  2446. \& process (data);
  2447. \&
  2448. \& pthread_mutex_unlock (&mymutex);
  2449. \& }
  2450. .Ve
  2451. .PP
  2452. \fIWatcher-Specific Functions and Data Members\fR
  2453. .IX Subsection "Watcher-Specific Functions and Data Members"
  2454. .IP "ev_async_init (ev_async *, callback)" 4
  2455. .IX Item "ev_async_init (ev_async *, callback)"
  2456. Initialises and configures the async watcher \- it has no parameters of any
  2457. kind. There is a \f(CW\*(C`ev_asynd_set\*(C'\fR macro, but using it is utterly pointless,
  2458. believe me.
  2459. .IP "ev_async_send (loop, ev_async *)" 4
  2460. .IX Item "ev_async_send (loop, ev_async *)"
  2461. Sends/signals/activates the given \f(CW\*(C`ev_async\*(C'\fR watcher, that is, feeds
  2462. an \f(CW\*(C`EV_ASYNC\*(C'\fR event on the watcher into the event loop. Unlike
  2463. \&\f(CW\*(C`ev_feed_event\*(C'\fR, this call is safe to do in other threads, signal or
  2464. similar contexts (see the dicusssion of \f(CW\*(C`EV_ATOMIC_T\*(C'\fR in the embedding
  2465. section below on what exactly this means).
  2466. .Sp
  2467. This call incurs the overhead of a syscall only once per loop iteration,
  2468. so while the overhead might be noticable, it doesn't apply to repeated
  2469. calls to \f(CW\*(C`ev_async_send\*(C'\fR.
  2470. .IP "bool = ev_async_pending (ev_async *)" 4
  2471. .IX Item "bool = ev_async_pending (ev_async *)"
  2472. Returns a non-zero value when \f(CW\*(C`ev_async_send\*(C'\fR has been called on the
  2473. watcher but the event has not yet been processed (or even noted) by the
  2474. event loop.
  2475. .Sp
  2476. \&\f(CW\*(C`ev_async_send\*(C'\fR sets a flag in the watcher and wakes up the loop. When
  2477. the loop iterates next and checks for the watcher to have become active,
  2478. it will reset the flag again. \f(CW\*(C`ev_async_pending\*(C'\fR can be used to very
  2479. quickly check wether invoking the loop might be a good idea.
  2480. .Sp
  2481. Not that this does \fInot\fR check wether the watcher itself is pending, only
  2482. wether it has been requested to make this watcher pending.
  2483. .SH "OTHER FUNCTIONS"
  2484. .IX Header "OTHER FUNCTIONS"
  2485. There are some other functions of possible interest. Described. Here. Now.
  2486. .IP "ev_once (loop, int fd, int events, ev_tstamp timeout, callback)" 4
  2487. .IX Item "ev_once (loop, int fd, int events, ev_tstamp timeout, callback)"
  2488. This function combines a simple timer and an I/O watcher, calls your
  2489. callback on whichever event happens first and automatically stop both
  2490. watchers. This is useful if you want to wait for a single event on an fd
  2491. or timeout without having to allocate/configure/start/stop/free one or
  2492. more watchers yourself.
  2493. .Sp
  2494. If \f(CW\*(C`fd\*(C'\fR is less than 0, then no I/O watcher will be started and events
  2495. is being ignored. Otherwise, an \f(CW\*(C`ev_io\*(C'\fR watcher for the given \f(CW\*(C`fd\*(C'\fR and
  2496. \&\f(CW\*(C`events\*(C'\fR set will be craeted and started.
  2497. .Sp
  2498. If \f(CW\*(C`timeout\*(C'\fR is less than 0, then no timeout watcher will be
  2499. started. Otherwise an \f(CW\*(C`ev_timer\*(C'\fR watcher with after = \f(CW\*(C`timeout\*(C'\fR (and
  2500. repeat = 0) will be started. While \f(CW0\fR is a valid timeout, it is of
  2501. dubious value.
  2502. .Sp
  2503. The callback has the type \f(CW\*(C`void (*cb)(int revents, void *arg)\*(C'\fR and gets
  2504. passed an \f(CW\*(C`revents\*(C'\fR set like normal event callbacks (a combination of
  2505. \&\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_TIMEOUT\*(C'\fR) and the \f(CW\*(C`arg\*(C'\fR
  2506. value passed to \f(CW\*(C`ev_once\*(C'\fR:
  2507. .Sp
  2508. .Vb 7
  2509. \& static void stdin_ready (int revents, void *arg)
  2510. \& {
  2511. \& if (revents & EV_TIMEOUT)
  2512. \& /* doh, nothing entered */;
  2513. \& else if (revents & EV_READ)
  2514. \& /* stdin might have data for us, joy! */;
  2515. \& }
  2516. \&
  2517. \& ev_once (STDIN_FILENO, EV_READ, 10., stdin_ready, 0);
  2518. .Ve
  2519. .IP "ev_feed_event (ev_loop *, watcher *, int revents)" 4
  2520. .IX Item "ev_feed_event (ev_loop *, watcher *, int revents)"
  2521. Feeds the given event set into the event loop, as if the specified event
  2522. had happened for the specified watcher (which must be a pointer to an
  2523. initialised but not necessarily started event watcher).
  2524. .IP "ev_feed_fd_event (ev_loop *, int fd, int revents)" 4
  2525. .IX Item "ev_feed_fd_event (ev_loop *, int fd, int revents)"
  2526. Feed an event on the given fd, as if a file descriptor backend detected
  2527. the given events it.
  2528. .IP "ev_feed_signal_event (ev_loop *loop, int signum)" 4
  2529. .IX Item "ev_feed_signal_event (ev_loop *loop, int signum)"
  2530. Feed an event as if the given signal occured (\f(CW\*(C`loop\*(C'\fR must be the default
  2531. loop!).
  2532. .SH "LIBEVENT EMULATION"
  2533. .IX Header "LIBEVENT EMULATION"
  2534. Libev offers a compatibility emulation layer for libevent. It cannot
  2535. emulate the internals of libevent, so here are some usage hints:
  2536. .IP "\(bu" 4
  2537. Use it by including <event.h>, as usual.
  2538. .IP "\(bu" 4
  2539. The following members are fully supported: ev_base, ev_callback,
  2540. ev_arg, ev_fd, ev_res, ev_events.
  2541. .IP "\(bu" 4
  2542. Avoid using ev_flags and the EVLIST_*\-macros, while it is
  2543. maintained by libev, it does not work exactly the same way as in libevent (consider
  2544. it a private \s-1API\s0).
  2545. .IP "\(bu" 4
  2546. Priorities are not currently supported. Initialising priorities
  2547. will fail and all watchers will have the same priority, even though there
  2548. is an ev_pri field.
  2549. .IP "\(bu" 4
  2550. In libevent, the last base created gets the signals, in libev, the
  2551. first base created (== the default loop) gets the signals.
  2552. .IP "\(bu" 4
  2553. Other members are not supported.
  2554. .IP "\(bu" 4
  2555. The libev emulation is \fInot\fR \s-1ABI\s0 compatible to libevent, you need
  2556. to use the libev header file and library.
  2557. .SH "\*(C+ SUPPORT"
  2558. .IX Header " SUPPORT"
  2559. Libev comes with some simplistic wrapper classes for \*(C+ that mainly allow
  2560. you to use some convinience methods to start/stop watchers and also change
  2561. the callback model to a model using method callbacks on objects.
  2562. .PP
  2563. To use it,
  2564. .PP
  2565. .Vb 1
  2566. \& #include <ev++.h>
  2567. .Ve
  2568. .PP
  2569. This automatically includes \fIev.h\fR and puts all of its definitions (many
  2570. of them macros) into the global namespace. All \*(C+ specific things are
  2571. put into the \f(CW\*(C`ev\*(C'\fR namespace. It should support all the same embedding
  2572. options as \fIev.h\fR, most notably \f(CW\*(C`EV_MULTIPLICITY\*(C'\fR.
  2573. .PP
  2574. Care has been taken to keep the overhead low. The only data member the \*(C+
  2575. classes add (compared to plain C\-style watchers) is the event loop pointer
  2576. that the watcher is associated with (or no additional members at all if
  2577. you disable \f(CW\*(C`EV_MULTIPLICITY\*(C'\fR when embedding libev).
  2578. .PP
  2579. Currently, functions, and static and non-static member functions can be
  2580. used as callbacks. Other types should be easy to add as long as they only
  2581. need one additional pointer for context. If you need support for other
  2582. types of functors please contact the author (preferably after implementing
  2583. it).
  2584. .PP
  2585. Here is a list of things available in the \f(CW\*(C`ev\*(C'\fR namespace:
  2586. .ie n .IP """ev::READ""\fR, \f(CW""ev::WRITE"" etc." 4
  2587. .el .IP "\f(CWev::READ\fR, \f(CWev::WRITE\fR etc." 4
  2588. .IX Item "ev::READ, ev::WRITE etc."
  2589. These are just enum values with the same values as the \f(CW\*(C`EV_READ\*(C'\fR etc.
  2590. macros from \fIev.h\fR.
  2591. .ie n .IP """ev::tstamp""\fR, \f(CW""ev::now""" 4
  2592. .el .IP "\f(CWev::tstamp\fR, \f(CWev::now\fR" 4
  2593. .IX Item "ev::tstamp, ev::now"
  2594. Aliases to the same types/functions as with the \f(CW\*(C`ev_\*(C'\fR prefix.
  2595. .ie n .IP """ev::io""\fR, \f(CW""ev::timer""\fR, \f(CW""ev::periodic""\fR, \f(CW""ev::idle""\fR, \f(CW""ev::sig"" etc." 4
  2596. .el .IP "\f(CWev::io\fR, \f(CWev::timer\fR, \f(CWev::periodic\fR, \f(CWev::idle\fR, \f(CWev::sig\fR etc." 4
  2597. .IX Item "ev::io, ev::timer, ev::periodic, ev::idle, ev::sig etc."
  2598. For each \f(CW\*(C`ev_TYPE\*(C'\fR watcher in \fIev.h\fR there is a corresponding class of
  2599. the same name in the \f(CW\*(C`ev\*(C'\fR namespace, with the exception of \f(CW\*(C`ev_signal\*(C'\fR
  2600. which is called \f(CW\*(C`ev::sig\*(C'\fR to avoid clashes with the \f(CW\*(C`signal\*(C'\fR macro
  2601. defines by many implementations.
  2602. .Sp
  2603. All of those classes have these methods:
  2604. .RS 4
  2605. .IP "ev::TYPE::TYPE ()" 4
  2606. .IX Item "ev::TYPE::TYPE ()"
  2607. .PD 0
  2608. .IP "ev::TYPE::TYPE (struct ev_loop *)" 4
  2609. .IX Item "ev::TYPE::TYPE (struct ev_loop *)"
  2610. .IP "ev::TYPE::~TYPE" 4
  2611. .IX Item "ev::TYPE::~TYPE"
  2612. .PD
  2613. The constructor (optionally) takes an event loop to associate the watcher
  2614. with. If it is omitted, it will use \f(CW\*(C`EV_DEFAULT\*(C'\fR.
  2615. .Sp
  2616. The constructor calls \f(CW\*(C`ev_init\*(C'\fR for you, which means you have to call the
  2617. \&\f(CW\*(C`set\*(C'\fR method before starting it.
  2618. .Sp
  2619. It will not set a callback, however: You have to call the templated \f(CW\*(C`set\*(C'\fR
  2620. method to set a callback before you can start the watcher.
  2621. .Sp
  2622. (The reason why you have to use a method is a limitation in \*(C+ which does
  2623. not allow explicit template arguments for constructors).
  2624. .Sp
  2625. The destructor automatically stops the watcher if it is active.
  2626. .IP "w\->set<class, &class::method> (object *)" 4
  2627. .IX Item "w->set<class, &class::method> (object *)"
  2628. This method sets the callback method to call. The method has to have a
  2629. signature of \f(CW\*(C`void (*)(ev_TYPE &, int)\*(C'\fR, it receives the watcher as
  2630. first argument and the \f(CW\*(C`revents\*(C'\fR as second. The object must be given as
  2631. parameter and is stored in the \f(CW\*(C`data\*(C'\fR member of the watcher.
  2632. .Sp
  2633. This method synthesizes efficient thunking code to call your method from
  2634. the C callback that libev requires. If your compiler can inline your
  2635. callback (i.e. it is visible to it at the place of the \f(CW\*(C`set\*(C'\fR call and
  2636. your compiler is good :), then the method will be fully inlined into the
  2637. thunking function, making it as fast as a direct C callback.
  2638. .Sp
  2639. Example: simple class declaration and watcher initialisation
  2640. .Sp
  2641. .Vb 4
  2642. \& struct myclass
  2643. \& {
  2644. \& void io_cb (ev::io &w, int revents) { }
  2645. \& }
  2646. \&
  2647. \& myclass obj;
  2648. \& ev::io iow;
  2649. \& iow.set <myclass, &myclass::io_cb> (&obj);
  2650. .Ve
  2651. .IP "w\->set<function> (void *data = 0)" 4
  2652. .IX Item "w->set<function> (void *data = 0)"
  2653. Also sets a callback, but uses a static method or plain function as
  2654. callback. The optional \f(CW\*(C`data\*(C'\fR argument will be stored in the watcher's
  2655. \&\f(CW\*(C`data\*(C'\fR member and is free for you to use.
  2656. .Sp
  2657. The prototype of the \f(CW\*(C`function\*(C'\fR must be \f(CW\*(C`void (*)(ev::TYPE &w, int)\*(C'\fR.
  2658. .Sp
  2659. See the method\-\f(CW\*(C`set\*(C'\fR above for more details.
  2660. .Sp
  2661. Example:
  2662. .Sp
  2663. .Vb 2
  2664. \& static void io_cb (ev::io &w, int revents) { }
  2665. \& iow.set <io_cb> ();
  2666. .Ve
  2667. .IP "w\->set (struct ev_loop *)" 4
  2668. .IX Item "w->set (struct ev_loop *)"
  2669. Associates a different \f(CW\*(C`struct ev_loop\*(C'\fR with this watcher. You can only
  2670. do this when the watcher is inactive (and not pending either).
  2671. .IP "w\->set ([args])" 4
  2672. .IX Item "w->set ([args])"
  2673. Basically the same as \f(CW\*(C`ev_TYPE_set\*(C'\fR, with the same args. Must be
  2674. called at least once. Unlike the C counterpart, an active watcher gets
  2675. automatically stopped and restarted when reconfiguring it with this
  2676. method.
  2677. .IP "w\->start ()" 4
  2678. .IX Item "w->start ()"
  2679. Starts the watcher. Note that there is no \f(CW\*(C`loop\*(C'\fR argument, as the
  2680. constructor already stores the event loop.
  2681. .IP "w\->stop ()" 4
  2682. .IX Item "w->stop ()"
  2683. Stops the watcher if it is active. Again, no \f(CW\*(C`loop\*(C'\fR argument.
  2684. .ie n .IP "w\->again () (""ev::timer""\fR, \f(CW""ev::periodic"" only)" 4
  2685. .el .IP "w\->again () (\f(CWev::timer\fR, \f(CWev::periodic\fR only)" 4
  2686. .IX Item "w->again () (ev::timer, ev::periodic only)"
  2687. For \f(CW\*(C`ev::timer\*(C'\fR and \f(CW\*(C`ev::periodic\*(C'\fR, this invokes the corresponding
  2688. \&\f(CW\*(C`ev_TYPE_again\*(C'\fR function.
  2689. .ie n .IP "w\->sweep () (""ev::embed"" only)" 4
  2690. .el .IP "w\->sweep () (\f(CWev::embed\fR only)" 4
  2691. .IX Item "w->sweep () (ev::embed only)"
  2692. Invokes \f(CW\*(C`ev_embed_sweep\*(C'\fR.
  2693. .ie n .IP "w\->update () (""ev::stat"" only)" 4
  2694. .el .IP "w\->update () (\f(CWev::stat\fR only)" 4
  2695. .IX Item "w->update () (ev::stat only)"
  2696. Invokes \f(CW\*(C`ev_stat_stat\*(C'\fR.
  2697. .RE
  2698. .RS 4
  2699. .RE
  2700. .PP
  2701. Example: Define a class with an \s-1IO\s0 and idle watcher, start one of them in
  2702. the constructor.
  2703. .PP
  2704. .Vb 4
  2705. \& class myclass
  2706. \& {
  2707. \& ev::io io; void io_cb (ev::io &w, int revents);
  2708. \& ev:idle idle void idle_cb (ev::idle &w, int revents);
  2709. \&
  2710. \& myclass (int fd)
  2711. \& {
  2712. \& io .set <myclass, &myclass::io_cb > (this);
  2713. \& idle.set <myclass, &myclass::idle_cb> (this);
  2714. \&
  2715. \& io.start (fd, ev::READ);
  2716. \& }
  2717. \& };
  2718. .Ve
  2719. .SH "OTHER LANGUAGE BINDINGS"
  2720. .IX Header "OTHER LANGUAGE BINDINGS"
  2721. Libev does not offer other language bindings itself, but bindings for a
  2722. numbe rof languages exist in the form of third-party packages. If you know
  2723. any interesting language binding in addition to the ones listed here, drop
  2724. me a note.
  2725. .IP "Perl" 4
  2726. .IX Item "Perl"
  2727. The \s-1EV\s0 module implements the full libev \s-1API\s0 and is actually used to test
  2728. libev. \s-1EV\s0 is developed together with libev. Apart from the \s-1EV\s0 core module,
  2729. there are additional modules that implement libev-compatible interfaces
  2730. to \f(CW\*(C`libadns\*(C'\fR (\f(CW\*(C`EV::ADNS\*(C'\fR), \f(CW\*(C`Net::SNMP\*(C'\fR (\f(CW\*(C`Net::SNMP::EV\*(C'\fR) and the
  2731. \&\f(CW\*(C`libglib\*(C'\fR event core (\f(CW\*(C`Glib::EV\*(C'\fR and \f(CW\*(C`EV::Glib\*(C'\fR).
  2732. .Sp
  2733. It can be found and installed via \s-1CPAN\s0, its homepage is found at
  2734. <http://software.schmorp.de/pkg/EV>.
  2735. .IP "Ruby" 4
  2736. .IX Item "Ruby"
  2737. Tony Arcieri has written a ruby extension that offers access to a subset
  2738. of the libev \s-1API\s0 and adds filehandle abstractions, asynchronous \s-1DNS\s0 and
  2739. more on top of it. It can be found via gem servers. Its homepage is at
  2740. <http://rev.rubyforge.org/>.
  2741. .IP "D" 4
  2742. .IX Item "D"
  2743. Leandro Lucarella has written a D language binding (\fIev.d\fR) for libev, to
  2744. be found at <http://git.llucax.com.ar/?p=software/ev.d.git;a=summary>.
  2745. .SH "MACRO MAGIC"
  2746. .IX Header "MACRO MAGIC"
  2747. Libev can be compiled with a variety of options, the most fundamantal
  2748. of which is \f(CW\*(C`EV_MULTIPLICITY\*(C'\fR. This option determines whether (most)
  2749. functions and callbacks have an initial \f(CW\*(C`struct ev_loop *\*(C'\fR argument.
  2750. .PP
  2751. To make it easier to write programs that cope with either variant, the
  2752. following macros are defined:
  2753. .ie n .IP """EV_A""\fR, \f(CW""EV_A_""" 4
  2754. .el .IP "\f(CWEV_A\fR, \f(CWEV_A_\fR" 4
  2755. .IX Item "EV_A, EV_A_"
  2756. This provides the loop \fIargument\fR for functions, if one is required (\*(L"ev
  2757. loop argument\*(R"). The \f(CW\*(C`EV_A\*(C'\fR form is used when this is the sole argument,
  2758. \&\f(CW\*(C`EV_A_\*(C'\fR is used when other arguments are following. Example:
  2759. .Sp
  2760. .Vb 3
  2761. \& ev_unref (EV_A);
  2762. \& ev_timer_add (EV_A_ watcher);
  2763. \& ev_loop (EV_A_ 0);
  2764. .Ve
  2765. .Sp
  2766. It assumes the variable \f(CW\*(C`loop\*(C'\fR of type \f(CW\*(C`struct ev_loop *\*(C'\fR is in scope,
  2767. which is often provided by the following macro.
  2768. .ie n .IP """EV_P""\fR, \f(CW""EV_P_""" 4
  2769. .el .IP "\f(CWEV_P\fR, \f(CWEV_P_\fR" 4
  2770. .IX Item "EV_P, EV_P_"
  2771. This provides the loop \fIparameter\fR for functions, if one is required (\*(L"ev
  2772. loop parameter\*(R"). The \f(CW\*(C`EV_P\*(C'\fR form is used when this is the sole parameter,
  2773. \&\f(CW\*(C`EV_P_\*(C'\fR is used when other parameters are following. Example:
  2774. .Sp
  2775. .Vb 2
  2776. \& // this is how ev_unref is being declared
  2777. \& static void ev_unref (EV_P);
  2778. \&
  2779. \& // this is how you can declare your typical callback
  2780. \& static void cb (EV_P_ ev_timer *w, int revents)
  2781. .Ve
  2782. .Sp
  2783. It declares a parameter \f(CW\*(C`loop\*(C'\fR of type \f(CW\*(C`struct ev_loop *\*(C'\fR, quite
  2784. suitable for use with \f(CW\*(C`EV_A\*(C'\fR.
  2785. .ie n .IP """EV_DEFAULT""\fR, \f(CW""EV_DEFAULT_""" 4
  2786. .el .IP "\f(CWEV_DEFAULT\fR, \f(CWEV_DEFAULT_\fR" 4
  2787. .IX Item "EV_DEFAULT, EV_DEFAULT_"
  2788. Similar to the other two macros, this gives you the value of the default
  2789. loop, if multiple loops are supported (\*(L"ev loop default\*(R").
  2790. .ie n .IP """EV_DEFAULT_UC""\fR, \f(CW""EV_DEFAULT_UC_""" 4
  2791. .el .IP "\f(CWEV_DEFAULT_UC\fR, \f(CWEV_DEFAULT_UC_\fR" 4
  2792. .IX Item "EV_DEFAULT_UC, EV_DEFAULT_UC_"
  2793. Usage identical to \f(CW\*(C`EV_DEFAULT\*(C'\fR and \f(CW\*(C`EV_DEFAULT_\*(C'\fR, but requires that the
  2794. default loop has been initialised (\f(CW\*(C`UC\*(C'\fR == unchecked). Their behaviour
  2795. is undefined when the default loop has not been initialised by a previous
  2796. execution of \f(CW\*(C`EV_DEFAULT\*(C'\fR, \f(CW\*(C`EV_DEFAULT_\*(C'\fR or \f(CW\*(C`ev_default_init (...)\*(C'\fR.
  2797. .Sp
  2798. It is often prudent to use \f(CW\*(C`EV_DEFAULT\*(C'\fR when initialising the first
  2799. watcher in a function but use \f(CW\*(C`EV_DEFAULT_UC\*(C'\fR afterwards.
  2800. .PP
  2801. Example: Declare and initialise a check watcher, utilising the above
  2802. macros so it will work regardless of whether multiple loops are supported
  2803. or not.
  2804. .PP
  2805. .Vb 5
  2806. \& static void
  2807. \& check_cb (EV_P_ ev_timer *w, int revents)
  2808. \& {
  2809. \& ev_check_stop (EV_A_ w);
  2810. \& }
  2811. \&
  2812. \& ev_check check;
  2813. \& ev_check_init (&check, check_cb);
  2814. \& ev_check_start (EV_DEFAULT_ &check);
  2815. \& ev_loop (EV_DEFAULT_ 0);
  2816. .Ve
  2817. .SH "EMBEDDING"
  2818. .IX Header "EMBEDDING"
  2819. Libev can (and often is) directly embedded into host
  2820. applications. Examples of applications that embed it include the Deliantra
  2821. Game Server, the \s-1EV\s0 perl module, the \s-1GNU\s0 Virtual Private Ethernet (gvpe)
  2822. and rxvt-unicode.
  2823. .PP
  2824. The goal is to enable you to just copy the necessary files into your
  2825. source directory without having to change even a single line in them, so
  2826. you can easily upgrade by simply copying (or having a checked-out copy of
  2827. libev somewhere in your source tree).
  2828. .Sh "\s-1FILESETS\s0"
  2829. .IX Subsection "FILESETS"
  2830. Depending on what features you need you need to include one or more sets of files
  2831. in your app.
  2832. .PP
  2833. \fI\s-1CORE\s0 \s-1EVENT\s0 \s-1LOOP\s0\fR
  2834. .IX Subsection "CORE EVENT LOOP"
  2835. .PP
  2836. To include only the libev core (all the \f(CW\*(C`ev_*\*(C'\fR functions), with manual