cool.io 1.2.0-x86-mswin32-60

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (79) hide show
  1. data/.gitignore +26 -0
  2. data/.rspec +3 -0
  3. data/.travis.yml +5 -0
  4. data/CHANGES.md +177 -0
  5. data/Gemfile +4 -0
  6. data/LICENSE +20 -0
  7. data/README.md +172 -0
  8. data/Rakefile +81 -0
  9. data/cool.io.gemspec +28 -0
  10. data/examples/dslified_echo_client.rb +34 -0
  11. data/examples/dslified_echo_server.rb +24 -0
  12. data/examples/echo_client.rb +38 -0
  13. data/examples/echo_server.rb +27 -0
  14. data/examples/google.rb +9 -0
  15. data/examples/httpclient.rb +38 -0
  16. data/ext/cool.io/.gitignore +5 -0
  17. data/ext/cool.io/cool.io.h +58 -0
  18. data/ext/cool.io/cool.io_ext.c +25 -0
  19. data/ext/cool.io/ev_wrap.h +8 -0
  20. data/ext/cool.io/extconf.rb +73 -0
  21. data/ext/cool.io/iowatcher.c +189 -0
  22. data/ext/cool.io/libev.c +8 -0
  23. data/ext/cool.io/loop.c +301 -0
  24. data/ext/cool.io/stat_watcher.c +269 -0
  25. data/ext/cool.io/timer_watcher.c +219 -0
  26. data/ext/cool.io/utils.c +122 -0
  27. data/ext/cool.io/watcher.c +264 -0
  28. data/ext/cool.io/watcher.h +71 -0
  29. data/ext/http11_client/.gitignore +5 -0
  30. data/ext/http11_client/LICENSE +31 -0
  31. data/ext/http11_client/ext_help.h +14 -0
  32. data/ext/http11_client/extconf.rb +6 -0
  33. data/ext/http11_client/http11_client.c +300 -0
  34. data/ext/http11_client/http11_parser.c +403 -0
  35. data/ext/http11_client/http11_parser.h +48 -0
  36. data/ext/http11_client/http11_parser.rl +173 -0
  37. data/ext/iobuffer/extconf.rb +9 -0
  38. data/ext/iobuffer/iobuffer.c +765 -0
  39. data/ext/libev/Changes +388 -0
  40. data/ext/libev/LICENSE +36 -0
  41. data/ext/libev/README +58 -0
  42. data/ext/libev/README.embed +3 -0
  43. data/ext/libev/ev.c +4803 -0
  44. data/ext/libev/ev.h +845 -0
  45. data/ext/libev/ev_epoll.c +279 -0
  46. data/ext/libev/ev_kqueue.c +214 -0
  47. data/ext/libev/ev_poll.c +148 -0
  48. data/ext/libev/ev_port.c +185 -0
  49. data/ext/libev/ev_select.c +314 -0
  50. data/ext/libev/ev_vars.h +203 -0
  51. data/ext/libev/ev_win32.c +163 -0
  52. data/ext/libev/ev_wrap.h +200 -0
  53. data/ext/libev/test_libev_win32.c +123 -0
  54. data/lib/.gitignore +2 -0
  55. data/lib/cool.io.rb +32 -0
  56. data/lib/cool.io/async_watcher.rb +43 -0
  57. data/lib/cool.io/custom_require.rb +9 -0
  58. data/lib/cool.io/dns_resolver.rb +225 -0
  59. data/lib/cool.io/dsl.rb +135 -0
  60. data/lib/cool.io/eventmachine.rb +234 -0
  61. data/lib/cool.io/http_client.rb +427 -0
  62. data/lib/cool.io/io.rb +174 -0
  63. data/lib/cool.io/iowatcher.rb +17 -0
  64. data/lib/cool.io/listener.rb +93 -0
  65. data/lib/cool.io/loop.rb +130 -0
  66. data/lib/cool.io/meta.rb +49 -0
  67. data/lib/cool.io/server.rb +74 -0
  68. data/lib/cool.io/socket.rb +230 -0
  69. data/lib/cool.io/timer_watcher.rb +17 -0
  70. data/lib/cool.io/version.rb +5 -0
  71. data/lib/coolio.rb +2 -0
  72. data/spec/async_watcher_spec.rb +57 -0
  73. data/spec/dns_spec.rb +39 -0
  74. data/spec/spec_helper.rb +12 -0
  75. data/spec/stat_watcher_spec.rb +77 -0
  76. data/spec/timer_watcher_spec.rb +55 -0
  77. data/spec/unix_listener_spec.rb +25 -0
  78. data/spec/unix_server_spec.rb +25 -0
  79. metadata +200 -0
@@ -0,0 +1,3 @@
1
+ This file is now included in the main libev documentation, see
2
+
3
+ http://cvs.schmorp.de/libev/ev.html
data/ext/libev/ev.c ADDED
@@ -0,0 +1,4803 @@
1
+ /*
2
+ * libev event processing core, watcher management
3
+ *
4
+ * Copyright (c) 2007,2008,2009,2010,2011,2012 Marc Alexander Lehmann <libev@schmorp.de>
5
+ * All rights reserved.
6
+ *
7
+ * Redistribution and use in source and binary forms, with or without modifica-
8
+ * tion, are permitted provided that the following conditions are met:
9
+ *
10
+ * 1. Redistributions of source code must retain the above copyright notice,
11
+ * this list of conditions and the following disclaimer.
12
+ *
13
+ * 2. Redistributions in binary form must reproduce the above copyright
14
+ * notice, this list of conditions and the following disclaimer in the
15
+ * documentation and/or other materials provided with the distribution.
16
+ *
17
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
18
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
19
+ * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
20
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
21
+ * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
23
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
24
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
25
+ * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
26
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
27
+ *
28
+ * Alternatively, the contents of this file may be used under the terms of
29
+ * the GNU General Public License ("GPL") version 2 or any later version,
30
+ * in which case the provisions of the GPL are applicable instead of
31
+ * the above. If you wish to allow the use of your version of this file
32
+ * only under the terms of the GPL and not to allow others to use your
33
+ * version of this file under the BSD license, indicate your decision
34
+ * by deleting the provisions above and replace them with the notice
35
+ * and other provisions required by the GPL. If you do not delete the
36
+ * provisions above, a recipient may use your version of this file under
37
+ * either the BSD or the GPL.
38
+ */
39
+
40
+ /* this big block deduces configuration from config.h */
41
+ #ifndef EV_STANDALONE
42
+ # ifdef EV_CONFIG_H
43
+ # include EV_CONFIG_H
44
+ # else
45
+ # include "config.h"
46
+ # endif
47
+
48
+ #if HAVE_FLOOR
49
+ # ifndef EV_USE_FLOOR
50
+ # define EV_USE_FLOOR 1
51
+ # endif
52
+ #endif
53
+
54
+ # if HAVE_CLOCK_SYSCALL
55
+ # ifndef EV_USE_CLOCK_SYSCALL
56
+ # define EV_USE_CLOCK_SYSCALL 1
57
+ # ifndef EV_USE_REALTIME
58
+ # define EV_USE_REALTIME 0
59
+ # endif
60
+ # ifndef EV_USE_MONOTONIC
61
+ # define EV_USE_MONOTONIC 1
62
+ # endif
63
+ # endif
64
+ # elif !defined EV_USE_CLOCK_SYSCALL
65
+ # define EV_USE_CLOCK_SYSCALL 0
66
+ # endif
67
+
68
+ # if HAVE_CLOCK_GETTIME
69
+ # ifndef EV_USE_MONOTONIC
70
+ # define EV_USE_MONOTONIC 1
71
+ # endif
72
+ # ifndef EV_USE_REALTIME
73
+ # define EV_USE_REALTIME 0
74
+ # endif
75
+ # else
76
+ # ifndef EV_USE_MONOTONIC
77
+ # define EV_USE_MONOTONIC 0
78
+ # endif
79
+ # ifndef EV_USE_REALTIME
80
+ # define EV_USE_REALTIME 0
81
+ # endif
82
+ # endif
83
+
84
+ # if HAVE_NANOSLEEP
85
+ # ifndef EV_USE_NANOSLEEP
86
+ # define EV_USE_NANOSLEEP EV_FEATURE_OS
87
+ # endif
88
+ # else
89
+ # undef EV_USE_NANOSLEEP
90
+ # define EV_USE_NANOSLEEP 0
91
+ # endif
92
+
93
+ # if HAVE_SELECT && HAVE_SYS_SELECT_H
94
+ # ifndef EV_USE_SELECT
95
+ # define EV_USE_SELECT EV_FEATURE_BACKENDS
96
+ # endif
97
+ # else
98
+ # undef EV_USE_SELECT
99
+ # define EV_USE_SELECT 0
100
+ # endif
101
+
102
+ # if HAVE_POLL && HAVE_POLL_H
103
+ # ifndef EV_USE_POLL
104
+ # define EV_USE_POLL EV_FEATURE_BACKENDS
105
+ # endif
106
+ # else
107
+ # undef EV_USE_POLL
108
+ # define EV_USE_POLL 0
109
+ # endif
110
+
111
+ # if HAVE_EPOLL_CTL && HAVE_SYS_EPOLL_H
112
+ # ifndef EV_USE_EPOLL
113
+ # define EV_USE_EPOLL EV_FEATURE_BACKENDS
114
+ # endif
115
+ # else
116
+ # undef EV_USE_EPOLL
117
+ # define EV_USE_EPOLL 0
118
+ # endif
119
+
120
+ # if HAVE_KQUEUE && HAVE_SYS_EVENT_H
121
+ # ifndef EV_USE_KQUEUE
122
+ # define EV_USE_KQUEUE EV_FEATURE_BACKENDS
123
+ # endif
124
+ # else
125
+ # undef EV_USE_KQUEUE
126
+ # define EV_USE_KQUEUE 0
127
+ # endif
128
+
129
+ # if HAVE_PORT_H && HAVE_PORT_CREATE
130
+ # ifndef EV_USE_PORT
131
+ # define EV_USE_PORT EV_FEATURE_BACKENDS
132
+ # endif
133
+ # else
134
+ # undef EV_USE_PORT
135
+ # define EV_USE_PORT 0
136
+ # endif
137
+
138
+ # if HAVE_INOTIFY_INIT && HAVE_SYS_INOTIFY_H
139
+ # ifndef EV_USE_INOTIFY
140
+ # define EV_USE_INOTIFY EV_FEATURE_OS
141
+ # endif
142
+ # else
143
+ # undef EV_USE_INOTIFY
144
+ # define EV_USE_INOTIFY 0
145
+ # endif
146
+
147
+ # if HAVE_SIGNALFD && HAVE_SYS_SIGNALFD_H
148
+ # ifndef EV_USE_SIGNALFD
149
+ # define EV_USE_SIGNALFD EV_FEATURE_OS
150
+ # endif
151
+ # else
152
+ # undef EV_USE_SIGNALFD
153
+ # define EV_USE_SIGNALFD 0
154
+ # endif
155
+
156
+ # if HAVE_EVENTFD
157
+ # ifndef EV_USE_EVENTFD
158
+ # define EV_USE_EVENTFD EV_FEATURE_OS
159
+ # endif
160
+ # else
161
+ # undef EV_USE_EVENTFD
162
+ # define EV_USE_EVENTFD 0
163
+ # endif
164
+
165
+ #endif
166
+
167
+ #include <stdlib.h>
168
+ #include <string.h>
169
+ #include <fcntl.h>
170
+ #include <stddef.h>
171
+
172
+ #include <stdio.h>
173
+
174
+ #include <assert.h>
175
+ #include <errno.h>
176
+ #include <sys/types.h>
177
+ #include <time.h>
178
+ #include <limits.h>
179
+
180
+ #include <signal.h>
181
+
182
+ #ifdef EV_H
183
+ # include EV_H
184
+ #else
185
+ # include "ev.h"
186
+ #endif
187
+
188
+ #if EV_NO_THREADS
189
+ # undef EV_NO_SMP
190
+ # define EV_NO_SMP 1
191
+ # undef ECB_NO_THREADS
192
+ # define ECB_NO_THREADS 1
193
+ #endif
194
+ #if EV_NO_SMP
195
+ # undef EV_NO_SMP
196
+ # define ECB_NO_SMP 1
197
+ #endif
198
+
199
+ #ifndef _WIN32
200
+ # include <sys/time.h>
201
+ # include <sys/wait.h>
202
+ # include <unistd.h>
203
+ #else
204
+ # include <io.h>
205
+ # define WIN32_LEAN_AND_MEAN
206
+ # include <winsock2.h>
207
+ # include <windows.h>
208
+ # ifndef EV_SELECT_IS_WINSOCKET
209
+ # define EV_SELECT_IS_WINSOCKET 1
210
+ # endif
211
+ # undef EV_AVOID_STDIO
212
+ #endif
213
+
214
+ /* OS X, in its infinite idiocy, actually HARDCODES
215
+ * a limit of 1024 into their select. Where people have brains,
216
+ * OS X engineers apparently have a vacuum. Or maybe they were
217
+ * ordered to have a vacuum, or they do anything for money.
218
+ * This might help. Or not.
219
+ */
220
+ #define _DARWIN_UNLIMITED_SELECT 1
221
+
222
+ /* this block tries to deduce configuration from header-defined symbols and defaults */
223
+
224
+ /* try to deduce the maximum number of signals on this platform */
225
+ #if defined EV_NSIG
226
+ /* use what's provided */
227
+ #elif defined NSIG
228
+ # define EV_NSIG (NSIG)
229
+ #elif defined _NSIG
230
+ # define EV_NSIG (_NSIG)
231
+ #elif defined SIGMAX
232
+ # define EV_NSIG (SIGMAX+1)
233
+ #elif defined SIG_MAX
234
+ # define EV_NSIG (SIG_MAX+1)
235
+ #elif defined _SIG_MAX
236
+ # define EV_NSIG (_SIG_MAX+1)
237
+ #elif defined MAXSIG
238
+ # define EV_NSIG (MAXSIG+1)
239
+ #elif defined MAX_SIG
240
+ # define EV_NSIG (MAX_SIG+1)
241
+ #elif defined SIGARRAYSIZE
242
+ # define EV_NSIG (SIGARRAYSIZE) /* Assume ary[SIGARRAYSIZE] */
243
+ #elif defined _sys_nsig
244
+ # define EV_NSIG (_sys_nsig) /* Solaris 2.5 */
245
+ #else
246
+ # error "unable to find value for NSIG, please report"
247
+ /* to make it compile regardless, just remove the above line, */
248
+ /* but consider reporting it, too! :) */
249
+ # define EV_NSIG 65
250
+ #endif
251
+
252
+ #ifndef EV_USE_FLOOR
253
+ # define EV_USE_FLOOR 0
254
+ #endif
255
+
256
+ #ifndef EV_USE_CLOCK_SYSCALL
257
+ # if __linux && __GLIBC__ >= 2
258
+ # define EV_USE_CLOCK_SYSCALL EV_FEATURE_OS
259
+ # else
260
+ # define EV_USE_CLOCK_SYSCALL 0
261
+ # endif
262
+ #endif
263
+
264
+ #ifndef EV_USE_MONOTONIC
265
+ # if defined _POSIX_MONOTONIC_CLOCK && _POSIX_MONOTONIC_CLOCK >= 0
266
+ # define EV_USE_MONOTONIC EV_FEATURE_OS
267
+ # else
268
+ # define EV_USE_MONOTONIC 0
269
+ # endif
270
+ #endif
271
+
272
+ #ifndef EV_USE_REALTIME
273
+ # define EV_USE_REALTIME !EV_USE_CLOCK_SYSCALL
274
+ #endif
275
+
276
+ #ifndef EV_USE_NANOSLEEP
277
+ # if _POSIX_C_SOURCE >= 199309L
278
+ # define EV_USE_NANOSLEEP EV_FEATURE_OS
279
+ # else
280
+ # define EV_USE_NANOSLEEP 0
281
+ # endif
282
+ #endif
283
+
284
+ #ifndef EV_USE_SELECT
285
+ # define EV_USE_SELECT EV_FEATURE_BACKENDS
286
+ #endif
287
+
288
+ #ifndef EV_USE_POLL
289
+ # ifdef _WIN32
290
+ # define EV_USE_POLL 0
291
+ # else
292
+ # define EV_USE_POLL EV_FEATURE_BACKENDS
293
+ # endif
294
+ #endif
295
+
296
+ #ifndef EV_USE_EPOLL
297
+ # if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
298
+ # define EV_USE_EPOLL EV_FEATURE_BACKENDS
299
+ # else
300
+ # define EV_USE_EPOLL 0
301
+ # endif
302
+ #endif
303
+
304
+ #ifndef EV_USE_KQUEUE
305
+ # define EV_USE_KQUEUE 0
306
+ #endif
307
+
308
+ #ifndef EV_USE_PORT
309
+ # define EV_USE_PORT 0
310
+ #endif
311
+
312
+ #ifndef EV_USE_INOTIFY
313
+ # if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
314
+ # define EV_USE_INOTIFY EV_FEATURE_OS
315
+ # else
316
+ # define EV_USE_INOTIFY 0
317
+ # endif
318
+ #endif
319
+
320
+ #ifndef EV_PID_HASHSIZE
321
+ # define EV_PID_HASHSIZE EV_FEATURE_DATA ? 16 : 1
322
+ #endif
323
+
324
+ #ifndef EV_INOTIFY_HASHSIZE
325
+ # define EV_INOTIFY_HASHSIZE EV_FEATURE_DATA ? 16 : 1
326
+ #endif
327
+
328
+ #ifndef EV_USE_EVENTFD
329
+ # if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
330
+ # define EV_USE_EVENTFD EV_FEATURE_OS
331
+ # else
332
+ # define EV_USE_EVENTFD 0
333
+ # endif
334
+ #endif
335
+
336
+ #ifndef EV_USE_SIGNALFD
337
+ # if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
338
+ # define EV_USE_SIGNALFD EV_FEATURE_OS
339
+ # else
340
+ # define EV_USE_SIGNALFD 0
341
+ # endif
342
+ #endif
343
+
344
+ #if 0 /* debugging */
345
+ # define EV_VERIFY 3
346
+ # define EV_USE_4HEAP 1
347
+ # define EV_HEAP_CACHE_AT 1
348
+ #endif
349
+
350
+ #ifndef EV_VERIFY
351
+ # define EV_VERIFY (EV_FEATURE_API ? 1 : 0)
352
+ #endif
353
+
354
+ #ifndef EV_USE_4HEAP
355
+ # define EV_USE_4HEAP EV_FEATURE_DATA
356
+ #endif
357
+
358
+ #ifndef EV_HEAP_CACHE_AT
359
+ # define EV_HEAP_CACHE_AT EV_FEATURE_DATA
360
+ #endif
361
+
362
+ #ifdef ANDROID
363
+ /* supposedly, android doesn't typedef fd_mask */
364
+ # undef EV_USE_SELECT
365
+ # define EV_USE_SELECT 0
366
+ /* supposedly, we need to include syscall.h, not sys/syscall.h, so just disable */
367
+ # undef EV_USE_CLOCK_SYSCALL
368
+ # define EV_USE_CLOCK_SYSCALL 0
369
+ #endif
370
+
371
+ /* aix's poll.h seems to cause lots of trouble */
372
+ #ifdef _AIX
373
+ /* AIX has a completely broken poll.h header */
374
+ # undef EV_USE_POLL
375
+ # define EV_USE_POLL 0
376
+ #endif
377
+
378
+ /* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */
379
+ /* which makes programs even slower. might work on other unices, too. */
380
+ #if EV_USE_CLOCK_SYSCALL
381
+ # include <sys/syscall.h>
382
+ # ifdef SYS_clock_gettime
383
+ # define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))
384
+ # undef EV_USE_MONOTONIC
385
+ # define EV_USE_MONOTONIC 1
386
+ # else
387
+ # undef EV_USE_CLOCK_SYSCALL
388
+ # define EV_USE_CLOCK_SYSCALL 0
389
+ # endif
390
+ #endif
391
+
392
+ /* this block fixes any misconfiguration where we know we run into trouble otherwise */
393
+
394
+ #ifndef CLOCK_MONOTONIC
395
+ # undef EV_USE_MONOTONIC
396
+ # define EV_USE_MONOTONIC 0
397
+ #endif
398
+
399
+ #ifndef CLOCK_REALTIME
400
+ # undef EV_USE_REALTIME
401
+ # define EV_USE_REALTIME 0
402
+ #endif
403
+
404
+ #if !EV_STAT_ENABLE
405
+ # undef EV_USE_INOTIFY
406
+ # define EV_USE_INOTIFY 0
407
+ #endif
408
+
409
+ #if !EV_USE_NANOSLEEP
410
+ /* hp-ux has it in sys/time.h, which we unconditionally include above */
411
+ # if !defined _WIN32 && !defined __hpux
412
+ # include <sys/select.h>
413
+ # endif
414
+ #endif
415
+
416
+ #if EV_USE_INOTIFY
417
+ # include <sys/statfs.h>
418
+ # include <sys/inotify.h>
419
+ /* some very old inotify.h headers don't have IN_DONT_FOLLOW */
420
+ # ifndef IN_DONT_FOLLOW
421
+ # undef EV_USE_INOTIFY
422
+ # define EV_USE_INOTIFY 0
423
+ # endif
424
+ #endif
425
+
426
+ #if EV_USE_EVENTFD
427
+ /* our minimum requirement is glibc 2.7 which has the stub, but not the header */
428
+ # include <stdint.h>
429
+ # ifndef EFD_NONBLOCK
430
+ # define EFD_NONBLOCK O_NONBLOCK
431
+ # endif
432
+ # ifndef EFD_CLOEXEC
433
+ # ifdef O_CLOEXEC
434
+ # define EFD_CLOEXEC O_CLOEXEC
435
+ # else
436
+ # define EFD_CLOEXEC 02000000
437
+ # endif
438
+ # endif
439
+ EV_CPP(extern "C") int (eventfd) (unsigned int initval, int flags);
440
+ #endif
441
+
442
+ #if EV_USE_SIGNALFD
443
+ /* our minimum requirement is glibc 2.7 which has the stub, but not the header */
444
+ # include <stdint.h>
445
+ # ifndef SFD_NONBLOCK
446
+ # define SFD_NONBLOCK O_NONBLOCK
447
+ # endif
448
+ # ifndef SFD_CLOEXEC
449
+ # ifdef O_CLOEXEC
450
+ # define SFD_CLOEXEC O_CLOEXEC
451
+ # else
452
+ # define SFD_CLOEXEC 02000000
453
+ # endif
454
+ # endif
455
+ EV_CPP (extern "C") int signalfd (int fd, const sigset_t *mask, int flags);
456
+
457
+ struct signalfd_siginfo
458
+ {
459
+ uint32_t ssi_signo;
460
+ char pad[128 - sizeof (uint32_t)];
461
+ };
462
+ #endif
463
+
464
+ /**/
465
+
466
+ #if EV_VERIFY >= 3
467
+ # define EV_FREQUENT_CHECK ev_verify (EV_A)
468
+ #else
469
+ # define EV_FREQUENT_CHECK do { } while (0)
470
+ #endif
471
+
472
+ /*
473
+ * This is used to work around floating point rounding problems.
474
+ * This value is good at least till the year 4000.
475
+ */
476
+ #define MIN_INTERVAL 0.0001220703125 /* 1/2**13, good till 4000 */
477
+ /*#define MIN_INTERVAL 0.00000095367431640625 /* 1/2**20, good till 2200 */
478
+
479
+ #define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */
480
+ #define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
481
+
482
+ #define EV_TV_SET(tv,t) do { tv.tv_sec = (long)t; tv.tv_usec = (long)((t - tv.tv_sec) * 1e6); } while (0)
483
+ #define EV_TS_SET(ts,t) do { ts.tv_sec = (long)t; ts.tv_nsec = (long)((t - ts.tv_sec) * 1e9); } while (0)
484
+
485
+ /* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */
486
+ /* ECB.H BEGIN */
487
+ /*
488
+ * libecb - http://software.schmorp.de/pkg/libecb
489
+ *
490
+ * Copyright (©) 2009-2012 Marc Alexander Lehmann <libecb@schmorp.de>
491
+ * Copyright (©) 2011 Emanuele Giaquinta
492
+ * All rights reserved.
493
+ *
494
+ * Redistribution and use in source and binary forms, with or without modifica-
495
+ * tion, are permitted provided that the following conditions are met:
496
+ *
497
+ * 1. Redistributions of source code must retain the above copyright notice,
498
+ * this list of conditions and the following disclaimer.
499
+ *
500
+ * 2. Redistributions in binary form must reproduce the above copyright
501
+ * notice, this list of conditions and the following disclaimer in the
502
+ * documentation and/or other materials provided with the distribution.
503
+ *
504
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
505
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
506
+ * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
507
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
508
+ * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
509
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
510
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
511
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
512
+ * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
513
+ * OF THE POSSIBILITY OF SUCH DAMAGE.
514
+ */
515
+
516
+ #ifndef ECB_H
517
+ #define ECB_H
518
+
519
+ /* 16 bits major, 16 bits minor */
520
+ #define ECB_VERSION 0x00010003
521
+
522
+ #ifdef _WIN32
523
+ typedef signed char int8_t;
524
+ typedef unsigned char uint8_t;
525
+ typedef signed short int16_t;
526
+ typedef unsigned short uint16_t;
527
+ typedef signed int int32_t;
528
+ typedef unsigned int uint32_t;
529
+ #if __GNUC__
530
+ typedef signed long long int64_t;
531
+ typedef unsigned long long uint64_t;
532
+ #else /* _MSC_VER || __BORLANDC__ */
533
+ typedef signed __int64 int64_t;
534
+ typedef unsigned __int64 uint64_t;
535
+ #endif
536
+ #ifdef _WIN64
537
+ #define ECB_PTRSIZE 8
538
+ typedef uint64_t uintptr_t;
539
+ typedef int64_t intptr_t;
540
+ #else
541
+ #define ECB_PTRSIZE 4
542
+ typedef uint32_t uintptr_t;
543
+ typedef int32_t intptr_t;
544
+ #endif
545
+ #else
546
+ #include <inttypes.h>
547
+ #if UINTMAX_MAX > 0xffffffffU
548
+ #define ECB_PTRSIZE 8
549
+ #else
550
+ #define ECB_PTRSIZE 4
551
+ #endif
552
+ #endif
553
+
554
+ /* work around x32 idiocy by defining proper macros */
555
+ #if __x86_64 || _M_AMD64
556
+ #if __ILP32
557
+ #define ECB_AMD64_X32 1
558
+ #else
559
+ #define ECB_AMD64 1
560
+ #endif
561
+ #endif
562
+
563
+ /* many compilers define _GNUC_ to some versions but then only implement
564
+ * what their idiot authors think are the "more important" extensions,
565
+ * causing enormous grief in return for some better fake benchmark numbers.
566
+ * or so.
567
+ * we try to detect these and simply assume they are not gcc - if they have
568
+ * an issue with that they should have done it right in the first place.
569
+ */
570
+ #ifndef ECB_GCC_VERSION
571
+ #if !defined __GNUC_MINOR__ || defined __INTEL_COMPILER || defined __SUNPRO_C || defined __SUNPRO_CC || defined __llvm__ || defined __clang__
572
+ #define ECB_GCC_VERSION(major,minor) 0
573
+ #else
574
+ #define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
575
+ #endif
576
+ #endif
577
+
578
+ #define ECB_C (__STDC__+0) /* this assumes that __STDC__ is either empty or a number */
579
+ #define ECB_C99 (__STDC_VERSION__ >= 199901L)
580
+ #define ECB_C11 (__STDC_VERSION__ >= 201112L)
581
+ #define ECB_CPP (__cplusplus+0)
582
+ #define ECB_CPP11 (__cplusplus >= 201103L)
583
+
584
+ #if ECB_CPP
585
+ #define ECB_EXTERN_C extern "C"
586
+ #define ECB_EXTERN_C_BEG ECB_EXTERN_C {
587
+ #define ECB_EXTERN_C_END }
588
+ #else
589
+ #define ECB_EXTERN_C extern
590
+ #define ECB_EXTERN_C_BEG
591
+ #define ECB_EXTERN_C_END
592
+ #endif
593
+
594
+ /*****************************************************************************/
595
+
596
+ /* ECB_NO_THREADS - ecb is not used by multiple threads, ever */
597
+ /* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */
598
+
599
+ #if ECB_NO_THREADS
600
+ #define ECB_NO_SMP 1
601
+ #endif
602
+
603
+ #if ECB_NO_SMP
604
+ #define ECB_MEMORY_FENCE do { } while (0)
605
+ #endif
606
+
607
+ #ifndef ECB_MEMORY_FENCE
608
+ #if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
609
+ #if __i386 || __i386__
610
+ #define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")
611
+ #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
612
+ #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
613
+ #elif __amd64 || __amd64__ || __x86_64 || __x86_64__
614
+ #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")
615
+ #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
616
+ #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
617
+ #elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__
618
+ #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
619
+ #elif defined __ARM_ARCH_6__ || defined __ARM_ARCH_6J__ \
620
+ || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__
621
+ #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")
622
+ #elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \
623
+ || defined __ARM_ARCH_7M__ || defined __ARM_ARCH_7R__
624
+ #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")
625
+ #elif __sparc || __sparc__
626
+ #define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad" : : : "memory")
627
+ #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory")
628
+ #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore")
629
+ #elif defined __s390__ || defined __s390x__
630
+ #define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory")
631
+ #elif defined __mips__
632
+ #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
633
+ #elif defined __alpha__
634
+ #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mb" : : : "memory")
635
+ #elif defined __hppa__
636
+ #define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
637
+ #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
638
+ #elif defined __ia64__
639
+ #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mf" : : : "memory")
640
+ #endif
641
+ #endif
642
+ #endif
643
+
644
+ #ifndef ECB_MEMORY_FENCE
645
+ #if ECB_GCC_VERSION(4,7)
646
+ /* see comment below (stdatomic.h) about the C11 memory model. */
647
+ #define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
648
+
649
+ /* The __has_feature syntax from clang is so misdesigned that we cannot use it
650
+ * without risking compile time errors with other compilers. We *could*
651
+ * define our own ecb_clang_has_feature, but I just can't be bothered to work
652
+ * around this shit time and again.
653
+ * #elif defined __clang && __has_feature (cxx_atomic)
654
+ * // see comment below (stdatomic.h) about the C11 memory model.
655
+ * #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
656
+ */
657
+
658
+ #elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
659
+ #define ECB_MEMORY_FENCE __sync_synchronize ()
660
+ #elif _MSC_VER >= 1400 /* VC++ 2005 */
661
+ #pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
662
+ #define ECB_MEMORY_FENCE _ReadWriteBarrier ()
663
+ #define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */
664
+ #define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()
665
+ #elif defined _WIN32
666
+ #include <WinNT.h>
667
+ #define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */
668
+ #elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
669
+ #include <mbarrier.h>
670
+ #define ECB_MEMORY_FENCE __machine_rw_barrier ()
671
+ #define ECB_MEMORY_FENCE_ACQUIRE __machine_r_barrier ()
672
+ #define ECB_MEMORY_FENCE_RELEASE __machine_w_barrier ()
673
+ #elif __xlC__
674
+ #define ECB_MEMORY_FENCE __sync ()
675
+ #endif
676
+ #endif
677
+
678
+ #ifndef ECB_MEMORY_FENCE
679
+ #if ECB_C11 && !defined __STDC_NO_ATOMICS__
680
+ /* we assume that these memory fences work on all variables/all memory accesses, */
681
+ /* not just C11 atomics and atomic accesses */
682
+ #include <stdatomic.h>
683
+ /* Unfortunately, neither gcc 4.7 nor clang 3.1 generate any instructions for */
684
+ /* any fence other than seq_cst, which isn't very efficient for us. */
685
+ /* Why that is, we don't know - either the C11 memory model is quite useless */
686
+ /* for most usages, or gcc and clang have a bug */
687
+ /* I *currently* lean towards the latter, and inefficiently implement */
688
+ /* all three of ecb's fences as a seq_cst fence */
689
+ #define ECB_MEMORY_FENCE atomic_thread_fence (memory_order_seq_cst)
690
+ #endif
691
+ #endif
692
+
693
+ #ifndef ECB_MEMORY_FENCE
694
+ #if !ECB_AVOID_PTHREADS
695
+ /*
696
+ * if you get undefined symbol references to pthread_mutex_lock,
697
+ * or failure to find pthread.h, then you should implement
698
+ * the ECB_MEMORY_FENCE operations for your cpu/compiler
699
+ * OR provide pthread.h and link against the posix thread library
700
+ * of your system.
701
+ */
702
+ #include <pthread.h>
703
+ #define ECB_NEEDS_PTHREADS 1
704
+ #define ECB_MEMORY_FENCE_NEEDS_PTHREADS 1
705
+
706
+ static pthread_mutex_t ecb_mf_lock = PTHREAD_MUTEX_INITIALIZER;
707
+ #define ECB_MEMORY_FENCE do { pthread_mutex_lock (&ecb_mf_lock); pthread_mutex_unlock (&ecb_mf_lock); } while (0)
708
+ #endif
709
+ #endif
710
+
711
+ #if !defined ECB_MEMORY_FENCE_ACQUIRE && defined ECB_MEMORY_FENCE
712
+ #define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
713
+ #endif
714
+
715
+ #if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE
716
+ #define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
717
+ #endif
718
+
719
+ /*****************************************************************************/
720
+
721
+ #if __cplusplus
722
+ #define ecb_inline static inline
723
+ #elif ECB_GCC_VERSION(2,5)
724
+ #define ecb_inline static __inline__
725
+ #elif ECB_C99
726
+ #define ecb_inline static inline
727
+ #else
728
+ #define ecb_inline static
729
+ #endif
730
+
731
+ #if ECB_GCC_VERSION(3,3)
732
+ #define ecb_restrict __restrict__
733
+ #elif ECB_C99
734
+ #define ecb_restrict restrict
735
+ #else
736
+ #define ecb_restrict
737
+ #endif
738
+
739
+ typedef int ecb_bool;
740
+
741
+ #define ECB_CONCAT_(a, b) a ## b
742
+ #define ECB_CONCAT(a, b) ECB_CONCAT_(a, b)
743
+ #define ECB_STRINGIFY_(a) # a
744
+ #define ECB_STRINGIFY(a) ECB_STRINGIFY_(a)
745
+
746
+ #define ecb_function_ ecb_inline
747
+
748
+ #if ECB_GCC_VERSION(3,1)
749
+ #define ecb_attribute(attrlist) __attribute__(attrlist)
750
+ #define ecb_is_constant(expr) __builtin_constant_p (expr)
751
+ #define ecb_expect(expr,value) __builtin_expect ((expr),(value))
752
+ #define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality)
753
+ #else
754
+ #define ecb_attribute(attrlist)
755
+ #define ecb_is_constant(expr) 0
756
+ #define ecb_expect(expr,value) (expr)
757
+ #define ecb_prefetch(addr,rw,locality)
758
+ #endif
759
+
760
+ /* no emulation for ecb_decltype */
761
+ #if ECB_GCC_VERSION(4,5)
762
+ #define ecb_decltype(x) __decltype(x)
763
+ #elif ECB_GCC_VERSION(3,0)
764
+ #define ecb_decltype(x) __typeof(x)
765
+ #endif
766
+
767
+ #define ecb_noinline ecb_attribute ((__noinline__))
768
+ #define ecb_unused ecb_attribute ((__unused__))
769
+ #define ecb_const ecb_attribute ((__const__))
770
+ #define ecb_pure ecb_attribute ((__pure__))
771
+
772
+ #if ECB_C11
773
+ #define ecb_noreturn _Noreturn
774
+ #else
775
+ #define ecb_noreturn ecb_attribute ((__noreturn__))
776
+ #endif
777
+
778
+ #if ECB_GCC_VERSION(4,3)
779
+ #define ecb_artificial ecb_attribute ((__artificial__))
780
+ #define ecb_hot ecb_attribute ((__hot__))
781
+ #define ecb_cold ecb_attribute ((__cold__))
782
+ #else
783
+ #define ecb_artificial
784
+ #define ecb_hot
785
+ #define ecb_cold
786
+ #endif
787
+
788
+ /* put around conditional expressions if you are very sure that the */
789
+ /* expression is mostly true or mostly false. note that these return */
790
+ /* booleans, not the expression. */
791
+ #define ecb_expect_false(expr) ecb_expect (!!(expr), 0)
792
+ #define ecb_expect_true(expr) ecb_expect (!!(expr), 1)
793
+ /* for compatibility to the rest of the world */
794
+ #define ecb_likely(expr) ecb_expect_true (expr)
795
+ #define ecb_unlikely(expr) ecb_expect_false (expr)
796
+
797
+ /* count trailing zero bits and count # of one bits */
798
+ #if ECB_GCC_VERSION(3,4)
799
+ /* we assume int == 32 bit, long == 32 or 64 bit and long long == 64 bit */
800
+ #define ecb_ld32(x) (__builtin_clz (x) ^ 31)
801
+ #define ecb_ld64(x) (__builtin_clzll (x) ^ 63)
802
+ #define ecb_ctz32(x) __builtin_ctz (x)
803
+ #define ecb_ctz64(x) __builtin_ctzll (x)
804
+ #define ecb_popcount32(x) __builtin_popcount (x)
805
+ /* no popcountll */
806
+ #else
807
+ ecb_function_ int ecb_ctz32 (uint32_t x) ecb_const;
808
+ ecb_function_ int
809
+ ecb_ctz32 (uint32_t x)
810
+ {
811
+ int r = 0;
812
+
813
+ x &= ~x + 1; /* this isolates the lowest bit */
814
+
815
+ #if ECB_branchless_on_i386
816
+ r += !!(x & 0xaaaaaaaa) << 0;
817
+ r += !!(x & 0xcccccccc) << 1;
818
+ r += !!(x & 0xf0f0f0f0) << 2;
819
+ r += !!(x & 0xff00ff00) << 3;
820
+ r += !!(x & 0xffff0000) << 4;
821
+ #else
822
+ if (x & 0xaaaaaaaa) r += 1;
823
+ if (x & 0xcccccccc) r += 2;
824
+ if (x & 0xf0f0f0f0) r += 4;
825
+ if (x & 0xff00ff00) r += 8;
826
+ if (x & 0xffff0000) r += 16;
827
+ #endif
828
+
829
+ return r;
830
+ }
831
+
832
+ ecb_function_ int ecb_ctz64 (uint64_t x) ecb_const;
833
+ ecb_function_ int
834
+ ecb_ctz64 (uint64_t x)
835
+ {
836
+ int shift = x & 0xffffffffU ? 0 : 32;
837
+ return ecb_ctz32 (x >> shift) + shift;
838
+ }
839
+
840
+ ecb_function_ int ecb_popcount32 (uint32_t x) ecb_const;
841
+ ecb_function_ int
842
+ ecb_popcount32 (uint32_t x)
843
+ {
844
+ x -= (x >> 1) & 0x55555555;
845
+ x = ((x >> 2) & 0x33333333) + (x & 0x33333333);
846
+ x = ((x >> 4) + x) & 0x0f0f0f0f;
847
+ x *= 0x01010101;
848
+
849
+ return x >> 24;
850
+ }
851
+
852
+ ecb_function_ int ecb_ld32 (uint32_t x) ecb_const;
853
+ ecb_function_ int ecb_ld32 (uint32_t x)
854
+ {
855
+ int r = 0;
856
+
857
+ if (x >> 16) { x >>= 16; r += 16; }
858
+ if (x >> 8) { x >>= 8; r += 8; }
859
+ if (x >> 4) { x >>= 4; r += 4; }
860
+ if (x >> 2) { x >>= 2; r += 2; }
861
+ if (x >> 1) { r += 1; }
862
+
863
+ return r;
864
+ }
865
+
866
+ ecb_function_ int ecb_ld64 (uint64_t x) ecb_const;
867
+ ecb_function_ int ecb_ld64 (uint64_t x)
868
+ {
869
+ int r = 0;
870
+
871
+ if (x >> 32) { x >>= 32; r += 32; }
872
+
873
+ return r + ecb_ld32 (x);
874
+ }
875
+ #endif
876
+
877
+ ecb_function_ ecb_bool ecb_is_pot32 (uint32_t x) ecb_const;
878
+ ecb_function_ ecb_bool ecb_is_pot32 (uint32_t x) { return !(x & (x - 1)); }
879
+ ecb_function_ ecb_bool ecb_is_pot64 (uint64_t x) ecb_const;
880
+ ecb_function_ ecb_bool ecb_is_pot64 (uint64_t x) { return !(x & (x - 1)); }
881
+
882
+ ecb_function_ uint8_t ecb_bitrev8 (uint8_t x) ecb_const;
883
+ ecb_function_ uint8_t ecb_bitrev8 (uint8_t x)
884
+ {
885
+ return ( (x * 0x0802U & 0x22110U)
886
+ | (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;
887
+ }
888
+
889
+ ecb_function_ uint16_t ecb_bitrev16 (uint16_t x) ecb_const;
890
+ ecb_function_ uint16_t ecb_bitrev16 (uint16_t x)
891
+ {
892
+ x = ((x >> 1) & 0x5555) | ((x & 0x5555) << 1);
893
+ x = ((x >> 2) & 0x3333) | ((x & 0x3333) << 2);
894
+ x = ((x >> 4) & 0x0f0f) | ((x & 0x0f0f) << 4);
895
+ x = ( x >> 8 ) | ( x << 8);
896
+
897
+ return x;
898
+ }
899
+
900
+ ecb_function_ uint32_t ecb_bitrev32 (uint32_t x) ecb_const;
901
+ ecb_function_ uint32_t ecb_bitrev32 (uint32_t x)
902
+ {
903
+ x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);
904
+ x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);
905
+ x = ((x >> 4) & 0x0f0f0f0f) | ((x & 0x0f0f0f0f) << 4);
906
+ x = ((x >> 8) & 0x00ff00ff) | ((x & 0x00ff00ff) << 8);
907
+ x = ( x >> 16 ) | ( x << 16);
908
+
909
+ return x;
910
+ }
911
+
912
+ /* popcount64 is only available on 64 bit cpus as gcc builtin */
913
+ /* so for this version we are lazy */
914
+ ecb_function_ int ecb_popcount64 (uint64_t x) ecb_const;
915
+ ecb_function_ int
916
+ ecb_popcount64 (uint64_t x)
917
+ {
918
+ return ecb_popcount32 (x) + ecb_popcount32 (x >> 32);
919
+ }
920
+
921
+ ecb_inline uint8_t ecb_rotl8 (uint8_t x, unsigned int count) ecb_const;
922
+ ecb_inline uint8_t ecb_rotr8 (uint8_t x, unsigned int count) ecb_const;
923
+ ecb_inline uint16_t ecb_rotl16 (uint16_t x, unsigned int count) ecb_const;
924
+ ecb_inline uint16_t ecb_rotr16 (uint16_t x, unsigned int count) ecb_const;
925
+ ecb_inline uint32_t ecb_rotl32 (uint32_t x, unsigned int count) ecb_const;
926
+ ecb_inline uint32_t ecb_rotr32 (uint32_t x, unsigned int count) ecb_const;
927
+ ecb_inline uint64_t ecb_rotl64 (uint64_t x, unsigned int count) ecb_const;
928
+ ecb_inline uint64_t ecb_rotr64 (uint64_t x, unsigned int count) ecb_const;
929
+
930
+ ecb_inline uint8_t ecb_rotl8 (uint8_t x, unsigned int count) { return (x >> ( 8 - count)) | (x << count); }
931
+ ecb_inline uint8_t ecb_rotr8 (uint8_t x, unsigned int count) { return (x << ( 8 - count)) | (x >> count); }
932
+ ecb_inline uint16_t ecb_rotl16 (uint16_t x, unsigned int count) { return (x >> (16 - count)) | (x << count); }
933
+ ecb_inline uint16_t ecb_rotr16 (uint16_t x, unsigned int count) { return (x << (16 - count)) | (x >> count); }
934
+ ecb_inline uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) | (x << count); }
935
+ ecb_inline uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); }
936
+ ecb_inline uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }
937
+ ecb_inline uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }
938
+
939
+ #if ECB_GCC_VERSION(4,3)
940
+ #define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)
941
+ #define ecb_bswap32(x) __builtin_bswap32 (x)
942
+ #define ecb_bswap64(x) __builtin_bswap64 (x)
943
+ #else
944
+ ecb_function_ uint16_t ecb_bswap16 (uint16_t x) ecb_const;
945
+ ecb_function_ uint16_t
946
+ ecb_bswap16 (uint16_t x)
947
+ {
948
+ return ecb_rotl16 (x, 8);
949
+ }
950
+
951
+ ecb_function_ uint32_t ecb_bswap32 (uint32_t x) ecb_const;
952
+ ecb_function_ uint32_t
953
+ ecb_bswap32 (uint32_t x)
954
+ {
955
+ return (((uint32_t)ecb_bswap16 (x)) << 16) | ecb_bswap16 (x >> 16);
956
+ }
957
+
958
+ ecb_function_ uint64_t ecb_bswap64 (uint64_t x) ecb_const;
959
+ ecb_function_ uint64_t
960
+ ecb_bswap64 (uint64_t x)
961
+ {
962
+ return (((uint64_t)ecb_bswap32 (x)) << 32) | ecb_bswap32 (x >> 32);
963
+ }
964
+ #endif
965
+
966
+ #if ECB_GCC_VERSION(4,5)
967
+ #define ecb_unreachable() __builtin_unreachable ()
968
+ #else
969
+ /* this seems to work fine, but gcc always emits a warning for it :/ */
970
+ ecb_inline void ecb_unreachable (void) ecb_noreturn;
971
+ ecb_inline void ecb_unreachable (void) { }
972
+ #endif
973
+
974
+ /* try to tell the compiler that some condition is definitely true */
975
+ #define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
976
+
977
+ ecb_inline unsigned char ecb_byteorder_helper (void) ecb_const;
978
+ ecb_inline unsigned char
979
+ ecb_byteorder_helper (void)
980
+ {
981
+ /* the union code still generates code under pressure in gcc, */
982
+ /* but less than using pointers, and always seems to */
983
+ /* successfully return a constant. */
984
+ /* the reason why we have this horrible preprocessor mess */
985
+ /* is to avoid it in all cases, at least on common architectures */
986
+ /* or when using a recent enough gcc version (>= 4.6) */
987
+ #if __i386 || __i386__ || _M_X86 || __amd64 || __amd64__ || _M_X64
988
+ return 0x44;
989
+ #elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
990
+ return 0x44;
991
+ #elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
992
+ return 0x11;
993
+ #else
994
+ union
995
+ {
996
+ uint32_t i;
997
+ uint8_t c;
998
+ } u = { 0x11223344 };
999
+ return u.c;
1000
+ #endif
1001
+ }
1002
+
1003
+ ecb_inline ecb_bool ecb_big_endian (void) ecb_const;
1004
+ ecb_inline ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }
1005
+ ecb_inline ecb_bool ecb_little_endian (void) ecb_const;
1006
+ ecb_inline ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44; }
1007
+
1008
+ #if ECB_GCC_VERSION(3,0) || ECB_C99
1009
+ #define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
1010
+ #else
1011
+ #define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))
1012
+ #endif
1013
+
1014
+ #if __cplusplus
1015
+ template<typename T>
1016
+ static inline T ecb_div_rd (T val, T div)
1017
+ {
1018
+ return val < 0 ? - ((-val + div - 1) / div) : (val ) / div;
1019
+ }
1020
+ template<typename T>
1021
+ static inline T ecb_div_ru (T val, T div)
1022
+ {
1023
+ return val < 0 ? - ((-val ) / div) : (val + div - 1) / div;
1024
+ }
1025
+ #else
1026
+ #define ecb_div_rd(val,div) ((val) < 0 ? - ((-(val) + (div) - 1) / (div)) : ((val) ) / (div))
1027
+ #define ecb_div_ru(val,div) ((val) < 0 ? - ((-(val) ) / (div)) : ((val) + (div) - 1) / (div))
1028
+ #endif
1029
+
1030
+ #if ecb_cplusplus_does_not_suck
1031
+ /* does not work for local types (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm) */
1032
+ template<typename T, int N>
1033
+ static inline int ecb_array_length (const T (&arr)[N])
1034
+ {
1035
+ return N;
1036
+ }
1037
+ #else
1038
+ #define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
1039
+ #endif
1040
+
1041
+ /*******************************************************************************/
1042
+ /* floating point stuff, can be disabled by defining ECB_NO_LIBM */
1043
+
1044
+ /* basically, everything uses "ieee pure-endian" floating point numbers */
1045
+ /* the only noteworthy exception is ancient armle, which uses order 43218765 */
1046
+ #if 0 \
1047
+ || __i386 || __i386__ \
1048
+ || __amd64 || __amd64__ || __x86_64 || __x86_64__ \
1049
+ || __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__ \
1050
+ || defined __arm__ && defined __ARM_EABI__ \
1051
+ || defined __s390__ || defined __s390x__ \
1052
+ || defined __mips__ \
1053
+ || defined __alpha__ \
1054
+ || defined __hppa__ \
1055
+ || defined __ia64__ \
1056
+ || defined _M_IX86 || defined _M_AMD64 || defined _M_IA64
1057
+ #define ECB_STDFP 1
1058
+ #include <string.h> /* for memcpy */
1059
+ #else
1060
+ #define ECB_STDFP 0
1061
+ #include <math.h> /* for frexp*, ldexp* */
1062
+ #endif
1063
+
1064
+ #ifndef ECB_NO_LIBM
1065
+
1066
+ /* convert a float to ieee single/binary32 */
1067
+ ecb_function_ uint32_t ecb_float_to_binary32 (float x) ecb_const;
1068
+ ecb_function_ uint32_t
1069
+ ecb_float_to_binary32 (float x)
1070
+ {
1071
+ uint32_t r;
1072
+
1073
+ #if ECB_STDFP
1074
+ memcpy (&r, &x, 4);
1075
+ #else
1076
+ /* slow emulation, works for anything but -0 */
1077
+ uint32_t m;
1078
+ int e;
1079
+
1080
+ if (x == 0e0f ) return 0x00000000U;
1081
+ if (x > +3.40282346638528860e+38f) return 0x7f800000U;
1082
+ if (x < -3.40282346638528860e+38f) return 0xff800000U;
1083
+ if (x != x ) return 0x7fbfffffU;
1084
+
1085
+ m = frexpf (x, &e) * 0x1000000U;
1086
+
1087
+ r = m & 0x80000000U;
1088
+
1089
+ if (r)
1090
+ m = -m;
1091
+
1092
+ if (e <= -126)
1093
+ {
1094
+ m &= 0xffffffU;
1095
+ m >>= (-125 - e);
1096
+ e = -126;
1097
+ }
1098
+
1099
+ r |= (e + 126) << 23;
1100
+ r |= m & 0x7fffffU;
1101
+ #endif
1102
+
1103
+ return r;
1104
+ }
1105
+
1106
+ /* converts an ieee single/binary32 to a float */
1107
+ ecb_function_ float ecb_binary32_to_float (uint32_t x) ecb_const;
1108
+ ecb_function_ float
1109
+ ecb_binary32_to_float (uint32_t x)
1110
+ {
1111
+ float r;
1112
+
1113
+ #if ECB_STDFP
1114
+ memcpy (&r, &x, 4);
1115
+ #else
1116
+ /* emulation, only works for normals and subnormals and +0 */
1117
+ int neg = x >> 31;
1118
+ int e = (x >> 23) & 0xffU;
1119
+
1120
+ x &= 0x7fffffU;
1121
+
1122
+ if (e)
1123
+ x |= 0x800000U;
1124
+ else
1125
+ e = 1;
1126
+
1127
+ /* we distrust ldexpf a bit and do the 2**-24 scaling by an extra multiply */
1128
+ r = ldexpf (x * (0.5f / 0x800000U), e - 126);
1129
+
1130
+ r = neg ? -r : r;
1131
+ #endif
1132
+
1133
+ return r;
1134
+ }
1135
+
1136
+ /* convert a double to ieee double/binary64 */
1137
+ ecb_function_ uint64_t ecb_double_to_binary64 (double x) ecb_const;
1138
+ ecb_function_ uint64_t
1139
+ ecb_double_to_binary64 (double x)
1140
+ {
1141
+ uint64_t r;
1142
+
1143
+ #if ECB_STDFP
1144
+ memcpy (&r, &x, 8);
1145
+ #else
1146
+ /* slow emulation, works for anything but -0 */
1147
+ uint64_t m;
1148
+ int e;
1149
+
1150
+ if (x == 0e0 ) return 0x0000000000000000U;
1151
+ if (x > +1.79769313486231470e+308) return 0x7ff0000000000000U;
1152
+ if (x < -1.79769313486231470e+308) return 0xfff0000000000000U;
1153
+ if (x != x ) return 0X7ff7ffffffffffffU;
1154
+
1155
+ m = frexp (x, &e) * 0x20000000000000U;
1156
+
1157
+ r = m & 0x8000000000000000;;
1158
+
1159
+ if (r)
1160
+ m = -m;
1161
+
1162
+ if (e <= -1022)
1163
+ {
1164
+ m &= 0x1fffffffffffffU;
1165
+ m >>= (-1021 - e);
1166
+ e = -1022;
1167
+ }
1168
+
1169
+ r |= ((uint64_t)(e + 1022)) << 52;
1170
+ r |= m & 0xfffffffffffffU;
1171
+ #endif
1172
+
1173
+ return r;
1174
+ }
1175
+
1176
+ /* converts an ieee double/binary64 to a double */
1177
+ ecb_function_ double ecb_binary64_to_double (uint64_t x) ecb_const;
1178
+ ecb_function_ double
1179
+ ecb_binary64_to_double (uint64_t x)
1180
+ {
1181
+ double r;
1182
+
1183
+ #if ECB_STDFP
1184
+ memcpy (&r, &x, 8);
1185
+ #else
1186
+ /* emulation, only works for normals and subnormals and +0 */
1187
+ int neg = x >> 63;
1188
+ int e = (x >> 52) & 0x7ffU;
1189
+
1190
+ x &= 0xfffffffffffffU;
1191
+
1192
+ if (e)
1193
+ x |= 0x10000000000000U;
1194
+ else
1195
+ e = 1;
1196
+
1197
+ /* we distrust ldexp a bit and do the 2**-53 scaling by an extra multiply */
1198
+ r = ldexp (x * (0.5 / 0x10000000000000U), e - 1022);
1199
+
1200
+ r = neg ? -r : r;
1201
+ #endif
1202
+
1203
+ return r;
1204
+ }
1205
+
1206
+ #endif
1207
+
1208
+ #endif
1209
+
1210
+ /* ECB.H END */
1211
+
1212
+ #if ECB_MEMORY_FENCE_NEEDS_PTHREADS
1213
+ /* if your architecture doesn't need memory fences, e.g. because it is
1214
+ * single-cpu/core, or if you use libev in a project that doesn't use libev
1215
+ * from multiple threads, then you can define ECB_AVOID_PTHREADS when compiling
1216
+ * libev, in which cases the memory fences become nops.
1217
+ * alternatively, you can remove this #error and link against libpthread,
1218
+ * which will then provide the memory fences.
1219
+ */
1220
+ # error "memory fences not defined for your architecture, please report"
1221
+ #endif
1222
+
1223
+ #ifndef ECB_MEMORY_FENCE
1224
+ # define ECB_MEMORY_FENCE do { } while (0)
1225
+ # define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
1226
+ # define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
1227
+ #endif
1228
+
1229
+ #define expect_false(cond) ecb_expect_false (cond)
1230
+ #define expect_true(cond) ecb_expect_true (cond)
1231
+ #define noinline ecb_noinline
1232
+
1233
+ #define inline_size ecb_inline
1234
+
1235
+ #if EV_FEATURE_CODE
1236
+ # define inline_speed ecb_inline
1237
+ #else
1238
+ # define inline_speed static noinline
1239
+ #endif
1240
+
1241
+ #define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
1242
+
1243
+ #if EV_MINPRI == EV_MAXPRI
1244
+ # define ABSPRI(w) (((W)w), 0)
1245
+ #else
1246
+ # define ABSPRI(w) (((W)w)->priority - EV_MINPRI)
1247
+ #endif
1248
+
1249
+ #define EMPTY /* required for microsofts broken pseudo-c compiler */
1250
+ #define EMPTY2(a,b) /* used to suppress some warnings */
1251
+
1252
+ typedef ev_watcher *W;
1253
+ typedef ev_watcher_list *WL;
1254
+ typedef ev_watcher_time *WT;
1255
+
1256
+ #define ev_active(w) ((W)(w))->active
1257
+ #define ev_at(w) ((WT)(w))->at
1258
+
1259
+ #if EV_USE_REALTIME
1260
+ /* sig_atomic_t is used to avoid per-thread variables or locking but still */
1261
+ /* giving it a reasonably high chance of working on typical architectures */
1262
+ static EV_ATOMIC_T have_realtime; /* did clock_gettime (CLOCK_REALTIME) work? */
1263
+ #endif
1264
+
1265
+ #if EV_USE_MONOTONIC
1266
+ static EV_ATOMIC_T have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
1267
+ #endif
1268
+
1269
+ #ifndef EV_FD_TO_WIN32_HANDLE
1270
+ # define EV_FD_TO_WIN32_HANDLE(fd) _get_osfhandle (fd)
1271
+ #endif
1272
+ #ifndef EV_WIN32_HANDLE_TO_FD
1273
+ # define EV_WIN32_HANDLE_TO_FD(handle) _open_osfhandle (handle, 0)
1274
+ #endif
1275
+ #ifndef EV_WIN32_CLOSE_FD
1276
+ # define EV_WIN32_CLOSE_FD(fd) close (fd)
1277
+ #endif
1278
+
1279
+ #ifdef _WIN32
1280
+ # include "ev_win32.c"
1281
+ #endif
1282
+
1283
+ /*****************************************************************************/
1284
+
1285
+ /* define a suitable floor function (only used by periodics atm) */
1286
+
1287
+ #if EV_USE_FLOOR
1288
+ # include <math.h>
1289
+ # define ev_floor(v) floor (v)
1290
+ #else
1291
+
1292
+ #include <float.h>
1293
+
1294
+ /* a floor() replacement function, should be independent of ev_tstamp type */
1295
+ static ev_tstamp noinline
1296
+ ev_floor (ev_tstamp v)
1297
+ {
1298
+ /* the choice of shift factor is not terribly important */
1299
+ #if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */
1300
+ const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;
1301
+ #else
1302
+ const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;
1303
+ #endif
1304
+
1305
+ /* argument too large for an unsigned long? */
1306
+ if (expect_false (v >= shift))
1307
+ {
1308
+ ev_tstamp f;
1309
+
1310
+ if (v == v - 1.)
1311
+ return v; /* very large number */
1312
+
1313
+ f = shift * ev_floor (v * (1. / shift));
1314
+ return f + ev_floor (v - f);
1315
+ }
1316
+
1317
+ /* special treatment for negative args? */
1318
+ if (expect_false (v < 0.))
1319
+ {
1320
+ ev_tstamp f = -ev_floor (-v);
1321
+
1322
+ return f - (f == v ? 0 : 1);
1323
+ }
1324
+
1325
+ /* fits into an unsigned long */
1326
+ return (unsigned long)v;
1327
+ }
1328
+
1329
+ #endif
1330
+
1331
+ /*****************************************************************************/
1332
+
1333
+ #ifdef __linux
1334
+ # include <sys/utsname.h>
1335
+ #endif
1336
+
1337
+ static unsigned int noinline ecb_cold
1338
+ ev_linux_version (void)
1339
+ {
1340
+ #ifdef __linux
1341
+ unsigned int v = 0;
1342
+ struct utsname buf;
1343
+ int i;
1344
+ char *p = buf.release;
1345
+
1346
+ if (uname (&buf))
1347
+ return 0;
1348
+
1349
+ for (i = 3+1; --i; )
1350
+ {
1351
+ unsigned int c = 0;
1352
+
1353
+ for (;;)
1354
+ {
1355
+ if (*p >= '0' && *p <= '9')
1356
+ c = c * 10 + *p++ - '0';
1357
+ else
1358
+ {
1359
+ p += *p == '.';
1360
+ break;
1361
+ }
1362
+ }
1363
+
1364
+ v = (v << 8) | c;
1365
+ }
1366
+
1367
+ return v;
1368
+ #else
1369
+ return 0;
1370
+ #endif
1371
+ }
1372
+
1373
+ /*****************************************************************************/
1374
+
1375
+ #if EV_AVOID_STDIO
1376
+ static void noinline ecb_cold
1377
+ ev_printerr (const char *msg)
1378
+ {
1379
+ write (STDERR_FILENO, msg, strlen (msg));
1380
+ }
1381
+ #endif
1382
+
1383
+ static void (*syserr_cb)(const char *msg) EV_THROW;
1384
+
1385
+ void ecb_cold
1386
+ ev_set_syserr_cb (void (*cb)(const char *msg) EV_THROW) EV_THROW
1387
+ {
1388
+ syserr_cb = cb;
1389
+ }
1390
+
1391
+ static void noinline ecb_cold
1392
+ ev_syserr (const char *msg)
1393
+ {
1394
+ if (!msg)
1395
+ msg = "(libev) system error";
1396
+
1397
+ if (syserr_cb)
1398
+ syserr_cb (msg);
1399
+ else
1400
+ {
1401
+ #if EV_AVOID_STDIO
1402
+ ev_printerr (msg);
1403
+ ev_printerr (": ");
1404
+ ev_printerr (strerror (errno));
1405
+ ev_printerr ("\n");
1406
+ #else
1407
+ perror (msg);
1408
+ #endif
1409
+ abort ();
1410
+ }
1411
+ }
1412
+
1413
+ static void *
1414
+ ev_realloc_emul (void *ptr, long size) EV_THROW
1415
+ {
1416
+ /* some systems, notably openbsd and darwin, fail to properly
1417
+ * implement realloc (x, 0) (as required by both ansi c-89 and
1418
+ * the single unix specification, so work around them here.
1419
+ * recently, also (at least) fedora and debian started breaking it,
1420
+ * despite documenting it otherwise.
1421
+ */
1422
+
1423
+ if (size)
1424
+ return realloc (ptr, size);
1425
+
1426
+ free (ptr);
1427
+ return 0;
1428
+ }
1429
+
1430
+ static void *(*alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul;
1431
+
1432
+ void ecb_cold
1433
+ ev_set_allocator (void *(*cb)(void *ptr, long size) EV_THROW) EV_THROW
1434
+ {
1435
+ alloc = cb;
1436
+ }
1437
+
1438
+ inline_speed void *
1439
+ ev_realloc (void *ptr, long size)
1440
+ {
1441
+ ptr = alloc (ptr, size);
1442
+
1443
+ if (!ptr && size)
1444
+ {
1445
+ #if EV_AVOID_STDIO
1446
+ ev_printerr ("(libev) memory allocation failed, aborting.\n");
1447
+ #else
1448
+ fprintf (stderr, "(libev) cannot allocate %ld bytes, aborting.", size);
1449
+ #endif
1450
+ abort ();
1451
+ }
1452
+
1453
+ return ptr;
1454
+ }
1455
+
1456
+ #define ev_malloc(size) ev_realloc (0, (size))
1457
+ #define ev_free(ptr) ev_realloc ((ptr), 0)
1458
+
1459
+ /*****************************************************************************/
1460
+
1461
+ /* set in reify when reification needed */
1462
+ #define EV_ANFD_REIFY 1
1463
+
1464
+ /* file descriptor info structure */
1465
+ typedef struct
1466
+ {
1467
+ WL head;
1468
+ unsigned char events; /* the events watched for */
1469
+ unsigned char reify; /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */
1470
+ unsigned char emask; /* the epoll backend stores the actual kernel mask in here */
1471
+ unsigned char unused;
1472
+ #if EV_USE_EPOLL
1473
+ unsigned int egen; /* generation counter to counter epoll bugs */
1474
+ #endif
1475
+ #if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
1476
+ SOCKET handle;
1477
+ #endif
1478
+ #if EV_USE_IOCP
1479
+ OVERLAPPED or, ow;
1480
+ #endif
1481
+ } ANFD;
1482
+
1483
+ /* stores the pending event set for a given watcher */
1484
+ typedef struct
1485
+ {
1486
+ W w;
1487
+ int events; /* the pending event set for the given watcher */
1488
+ } ANPENDING;
1489
+
1490
+ #if EV_USE_INOTIFY
1491
+ /* hash table entry per inotify-id */
1492
+ typedef struct
1493
+ {
1494
+ WL head;
1495
+ } ANFS;
1496
+ #endif
1497
+
1498
+ /* Heap Entry */
1499
+ #if EV_HEAP_CACHE_AT
1500
+ /* a heap element */
1501
+ typedef struct {
1502
+ ev_tstamp at;
1503
+ WT w;
1504
+ } ANHE;
1505
+
1506
+ #define ANHE_w(he) (he).w /* access watcher, read-write */
1507
+ #define ANHE_at(he) (he).at /* access cached at, read-only */
1508
+ #define ANHE_at_cache(he) (he).at = (he).w->at /* update at from watcher */
1509
+ #else
1510
+ /* a heap element */
1511
+ typedef WT ANHE;
1512
+
1513
+ #define ANHE_w(he) (he)
1514
+ #define ANHE_at(he) (he)->at
1515
+ #define ANHE_at_cache(he)
1516
+ #endif
1517
+
1518
+ #if EV_MULTIPLICITY
1519
+
1520
+ struct ev_loop
1521
+ {
1522
+ ev_tstamp ev_rt_now;
1523
+ #define ev_rt_now ((loop)->ev_rt_now)
1524
+ #define VAR(name,decl) decl;
1525
+ #include "ev_vars.h"
1526
+ #undef VAR
1527
+ };
1528
+ #include "ev_wrap.h"
1529
+
1530
+ static struct ev_loop default_loop_struct;
1531
+ EV_API_DECL struct ev_loop *ev_default_loop_ptr = 0; /* needs to be initialised to make it a definition despite extern */
1532
+
1533
+ #else
1534
+
1535
+ EV_API_DECL ev_tstamp ev_rt_now = 0; /* needs to be initialised to make it a definition despite extern */
1536
+ #define VAR(name,decl) static decl;
1537
+ #include "ev_vars.h"
1538
+ #undef VAR
1539
+
1540
+ static int ev_default_loop_ptr;
1541
+
1542
+ #endif
1543
+
1544
+ #if EV_FEATURE_API
1545
+ # define EV_RELEASE_CB if (expect_false (release_cb)) release_cb (EV_A)
1546
+ # define EV_ACQUIRE_CB if (expect_false (acquire_cb)) acquire_cb (EV_A)
1547
+ # define EV_INVOKE_PENDING invoke_cb (EV_A)
1548
+ #else
1549
+ # define EV_RELEASE_CB (void)0
1550
+ # define EV_ACQUIRE_CB (void)0
1551
+ # define EV_INVOKE_PENDING ev_invoke_pending (EV_A)
1552
+ #endif
1553
+
1554
+ #define EVBREAK_RECURSE 0x80
1555
+
1556
+ /*****************************************************************************/
1557
+
1558
+ #ifndef EV_HAVE_EV_TIME
1559
+ ev_tstamp
1560
+ ev_time (void) EV_THROW
1561
+ {
1562
+ #if EV_USE_REALTIME
1563
+ if (expect_true (have_realtime))
1564
+ {
1565
+ struct timespec ts;
1566
+ clock_gettime (CLOCK_REALTIME, &ts);
1567
+ return ts.tv_sec + ts.tv_nsec * 1e-9;
1568
+ }
1569
+ #endif
1570
+
1571
+ struct timeval tv;
1572
+ gettimeofday (&tv, 0);
1573
+ return tv.tv_sec + tv.tv_usec * 1e-6;
1574
+ }
1575
+ #endif
1576
+
1577
+ inline_size ev_tstamp
1578
+ get_clock (void)
1579
+ {
1580
+ #if EV_USE_MONOTONIC
1581
+ if (expect_true (have_monotonic))
1582
+ {
1583
+ struct timespec ts;
1584
+ clock_gettime (CLOCK_MONOTONIC, &ts);
1585
+ return ts.tv_sec + ts.tv_nsec * 1e-9;
1586
+ }
1587
+ #endif
1588
+
1589
+ return ev_time ();
1590
+ }
1591
+
1592
+ #if EV_MULTIPLICITY
1593
+ ev_tstamp
1594
+ ev_now (EV_P) EV_THROW
1595
+ {
1596
+ return ev_rt_now;
1597
+ }
1598
+ #endif
1599
+
1600
+ void
1601
+ ev_sleep (ev_tstamp delay) EV_THROW
1602
+ {
1603
+ if (delay > 0.)
1604
+ {
1605
+ #if EV_USE_NANOSLEEP
1606
+ struct timespec ts;
1607
+
1608
+ EV_TS_SET (ts, delay);
1609
+ nanosleep (&ts, 0);
1610
+ #elif defined _WIN32
1611
+ Sleep ((unsigned long)(delay * 1e3));
1612
+ #else
1613
+ struct timeval tv;
1614
+
1615
+ /* here we rely on sys/time.h + sys/types.h + unistd.h providing select */
1616
+ /* something not guaranteed by newer posix versions, but guaranteed */
1617
+ /* by older ones */
1618
+ EV_TV_SET (tv, delay);
1619
+ select (0, 0, 0, 0, &tv);
1620
+ #endif
1621
+ }
1622
+ }
1623
+
1624
+ /*****************************************************************************/
1625
+
1626
+ #define MALLOC_ROUND 4096 /* prefer to allocate in chunks of this size, must be 2**n and >> 4 longs */
1627
+
1628
+ /* find a suitable new size for the given array, */
1629
+ /* hopefully by rounding to a nice-to-malloc size */
1630
+ inline_size int
1631
+ array_nextsize (int elem, int cur, int cnt)
1632
+ {
1633
+ int ncur = cur + 1;
1634
+
1635
+ do
1636
+ ncur <<= 1;
1637
+ while (cnt > ncur);
1638
+
1639
+ /* if size is large, round to MALLOC_ROUND - 4 * longs to accommodate malloc overhead */
1640
+ if (elem * ncur > MALLOC_ROUND - sizeof (void *) * 4)
1641
+ {
1642
+ ncur *= elem;
1643
+ ncur = (ncur + elem + (MALLOC_ROUND - 1) + sizeof (void *) * 4) & ~(MALLOC_ROUND - 1);
1644
+ ncur = ncur - sizeof (void *) * 4;
1645
+ ncur /= elem;
1646
+ }
1647
+
1648
+ return ncur;
1649
+ }
1650
+
1651
+ static void * noinline ecb_cold
1652
+ array_realloc (int elem, void *base, int *cur, int cnt)
1653
+ {
1654
+ *cur = array_nextsize (elem, *cur, cnt);
1655
+ return ev_realloc (base, elem * *cur);
1656
+ }
1657
+
1658
+ #define array_init_zero(base,count) \
1659
+ memset ((void *)(base), 0, sizeof (*(base)) * (count))
1660
+
1661
+ #define array_needsize(type,base,cur,cnt,init) \
1662
+ if (expect_false ((cnt) > (cur))) \
1663
+ { \
1664
+ int ecb_unused ocur_ = (cur); \
1665
+ (base) = (type *)array_realloc \
1666
+ (sizeof (type), (base), &(cur), (cnt)); \
1667
+ init ((base) + (ocur_), (cur) - ocur_); \
1668
+ }
1669
+
1670
+ #if 0
1671
+ #define array_slim(type,stem) \
1672
+ if (stem ## max < array_roundsize (stem ## cnt >> 2)) \
1673
+ { \
1674
+ stem ## max = array_roundsize (stem ## cnt >> 1); \
1675
+ base = (type *)ev_realloc (base, sizeof (type) * (stem ## max));\
1676
+ fprintf (stderr, "slimmed down " # stem " to %d\n", stem ## max);/*D*/\
1677
+ }
1678
+ #endif
1679
+
1680
+ #define array_free(stem, idx) \
1681
+ ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; stem ## s idx = 0
1682
+
1683
+ /*****************************************************************************/
1684
+
1685
+ /* dummy callback for pending events */
1686
+ static void noinline
1687
+ pendingcb (EV_P_ ev_prepare *w, int revents)
1688
+ {
1689
+ }
1690
+
1691
+ void noinline
1692
+ ev_feed_event (EV_P_ void *w, int revents) EV_THROW
1693
+ {
1694
+ W w_ = (W)w;
1695
+ int pri = ABSPRI (w_);
1696
+
1697
+ if (expect_false (w_->pending))
1698
+ pendings [pri][w_->pending - 1].events |= revents;
1699
+ else
1700
+ {
1701
+ w_->pending = ++pendingcnt [pri];
1702
+ array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, EMPTY2);
1703
+ pendings [pri][w_->pending - 1].w = w_;
1704
+ pendings [pri][w_->pending - 1].events = revents;
1705
+ }
1706
+
1707
+ pendingpri = NUMPRI - 1;
1708
+ }
1709
+
1710
+ inline_speed void
1711
+ feed_reverse (EV_P_ W w)
1712
+ {
1713
+ array_needsize (W, rfeeds, rfeedmax, rfeedcnt + 1, EMPTY2);
1714
+ rfeeds [rfeedcnt++] = w;
1715
+ }
1716
+
1717
+ inline_size void
1718
+ feed_reverse_done (EV_P_ int revents)
1719
+ {
1720
+ do
1721
+ ev_feed_event (EV_A_ rfeeds [--rfeedcnt], revents);
1722
+ while (rfeedcnt);
1723
+ }
1724
+
1725
+ inline_speed void
1726
+ queue_events (EV_P_ W *events, int eventcnt, int type)
1727
+ {
1728
+ int i;
1729
+
1730
+ for (i = 0; i < eventcnt; ++i)
1731
+ ev_feed_event (EV_A_ events [i], type);
1732
+ }
1733
+
1734
+ /*****************************************************************************/
1735
+
1736
+ inline_speed void
1737
+ fd_event_nocheck (EV_P_ int fd, int revents)
1738
+ {
1739
+ ANFD *anfd = anfds + fd;
1740
+ ev_io *w;
1741
+
1742
+ for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
1743
+ {
1744
+ int ev = w->events & revents;
1745
+
1746
+ if (ev)
1747
+ ev_feed_event (EV_A_ (W)w, ev);
1748
+ }
1749
+ }
1750
+
1751
+ /* do not submit kernel events for fds that have reify set */
1752
+ /* because that means they changed while we were polling for new events */
1753
+ inline_speed void
1754
+ fd_event (EV_P_ int fd, int revents)
1755
+ {
1756
+ ANFD *anfd = anfds + fd;
1757
+
1758
+ if (expect_true (!anfd->reify))
1759
+ fd_event_nocheck (EV_A_ fd, revents);
1760
+ }
1761
+
1762
+ void
1763
+ ev_feed_fd_event (EV_P_ int fd, int revents) EV_THROW
1764
+ {
1765
+ if (fd >= 0 && fd < anfdmax)
1766
+ fd_event_nocheck (EV_A_ fd, revents);
1767
+ }
1768
+
1769
+ /* make sure the external fd watch events are in-sync */
1770
+ /* with the kernel/libev internal state */
1771
+ inline_size void
1772
+ fd_reify (EV_P)
1773
+ {
1774
+ int i;
1775
+
1776
+ #if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
1777
+ for (i = 0; i < fdchangecnt; ++i)
1778
+ {
1779
+ int fd = fdchanges [i];
1780
+ ANFD *anfd = anfds + fd;
1781
+
1782
+ if (anfd->reify & EV__IOFDSET && anfd->head)
1783
+ {
1784
+ SOCKET handle = EV_FD_TO_WIN32_HANDLE (fd);
1785
+
1786
+ if (handle != anfd->handle)
1787
+ {
1788
+ unsigned long arg;
1789
+
1790
+ assert (("libev: only socket fds supported in this configuration", ioctlsocket (handle, FIONREAD, &arg) == 0));
1791
+
1792
+ /* handle changed, but fd didn't - we need to do it in two steps */
1793
+ backend_modify (EV_A_ fd, anfd->events, 0);
1794
+ anfd->events = 0;
1795
+ anfd->handle = handle;
1796
+ }
1797
+ }
1798
+ }
1799
+ #endif
1800
+
1801
+ for (i = 0; i < fdchangecnt; ++i)
1802
+ {
1803
+ int fd = fdchanges [i];
1804
+ ANFD *anfd = anfds + fd;
1805
+ ev_io *w;
1806
+
1807
+ unsigned char o_events = anfd->events;
1808
+ unsigned char o_reify = anfd->reify;
1809
+
1810
+ anfd->reify = 0;
1811
+
1812
+ /*if (expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */
1813
+ {
1814
+ anfd->events = 0;
1815
+
1816
+ for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
1817
+ anfd->events |= (unsigned char)w->events;
1818
+
1819
+ if (o_events != anfd->events)
1820
+ o_reify = EV__IOFDSET; /* actually |= */
1821
+ }
1822
+
1823
+ if (o_reify & EV__IOFDSET)
1824
+ backend_modify (EV_A_ fd, o_events, anfd->events);
1825
+ }
1826
+
1827
+ fdchangecnt = 0;
1828
+ }
1829
+
1830
+ /* something about the given fd changed */
1831
+ inline_size void
1832
+ fd_change (EV_P_ int fd, int flags)
1833
+ {
1834
+ unsigned char reify = anfds [fd].reify;
1835
+ anfds [fd].reify |= flags;
1836
+
1837
+ if (expect_true (!reify))
1838
+ {
1839
+ ++fdchangecnt;
1840
+ array_needsize (int, fdchanges, fdchangemax, fdchangecnt, EMPTY2);
1841
+ fdchanges [fdchangecnt - 1] = fd;
1842
+ }
1843
+ }
1844
+
1845
+ /* the given fd is invalid/unusable, so make sure it doesn't hurt us anymore */
1846
+ inline_speed void ecb_cold
1847
+ fd_kill (EV_P_ int fd)
1848
+ {
1849
+ ev_io *w;
1850
+
1851
+ while ((w = (ev_io *)anfds [fd].head))
1852
+ {
1853
+ ev_io_stop (EV_A_ w);
1854
+ ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
1855
+ }
1856
+ }
1857
+
1858
+ /* check whether the given fd is actually valid, for error recovery */
1859
+ inline_size int ecb_cold
1860
+ fd_valid (int fd)
1861
+ {
1862
+ #ifdef _WIN32
1863
+ return EV_FD_TO_WIN32_HANDLE (fd) != -1;
1864
+ #else
1865
+ return fcntl (fd, F_GETFD) != -1;
1866
+ #endif
1867
+ }
1868
+
1869
+ /* called on EBADF to verify fds */
1870
+ static void noinline ecb_cold
1871
+ fd_ebadf (EV_P)
1872
+ {
1873
+ int fd;
1874
+
1875
+ for (fd = 0; fd < anfdmax; ++fd)
1876
+ if (anfds [fd].events)
1877
+ if (!fd_valid (fd) && errno == EBADF)
1878
+ fd_kill (EV_A_ fd);
1879
+ }
1880
+
1881
+ /* called on ENOMEM in select/poll to kill some fds and retry */
1882
+ static void noinline ecb_cold
1883
+ fd_enomem (EV_P)
1884
+ {
1885
+ int fd;
1886
+
1887
+ for (fd = anfdmax; fd--; )
1888
+ if (anfds [fd].events)
1889
+ {
1890
+ fd_kill (EV_A_ fd);
1891
+ break;
1892
+ }
1893
+ }
1894
+
1895
+ /* usually called after fork if backend needs to re-arm all fds from scratch */
1896
+ static void noinline
1897
+ fd_rearm_all (EV_P)
1898
+ {
1899
+ int fd;
1900
+
1901
+ for (fd = 0; fd < anfdmax; ++fd)
1902
+ if (anfds [fd].events)
1903
+ {
1904
+ anfds [fd].events = 0;
1905
+ anfds [fd].emask = 0;
1906
+ fd_change (EV_A_ fd, EV__IOFDSET | EV_ANFD_REIFY);
1907
+ }
1908
+ }
1909
+
1910
+ /* used to prepare libev internal fd's */
1911
+ /* this is not fork-safe */
1912
+ inline_speed void
1913
+ fd_intern (int fd)
1914
+ {
1915
+ #ifdef _WIN32
1916
+ unsigned long arg = 1;
1917
+ ioctlsocket (EV_FD_TO_WIN32_HANDLE (fd), FIONBIO, &arg);
1918
+ #else
1919
+ fcntl (fd, F_SETFD, FD_CLOEXEC);
1920
+ fcntl (fd, F_SETFL, O_NONBLOCK);
1921
+ #endif
1922
+ }
1923
+
1924
+ /*****************************************************************************/
1925
+
1926
+ /*
1927
+ * the heap functions want a real array index. array index 0 is guaranteed to not
1928
+ * be in-use at any time. the first heap entry is at array [HEAP0]. DHEAP gives
1929
+ * the branching factor of the d-tree.
1930
+ */
1931
+
1932
+ /*
1933
+ * at the moment we allow libev the luxury of two heaps,
1934
+ * a small-code-size 2-heap one and a ~1.5kb larger 4-heap
1935
+ * which is more cache-efficient.
1936
+ * the difference is about 5% with 50000+ watchers.
1937
+ */
1938
+ #if EV_USE_4HEAP
1939
+
1940
+ #define DHEAP 4
1941
+ #define HEAP0 (DHEAP - 1) /* index of first element in heap */
1942
+ #define HPARENT(k) ((((k) - HEAP0 - 1) / DHEAP) + HEAP0)
1943
+ #define UPHEAP_DONE(p,k) ((p) == (k))
1944
+
1945
+ /* away from the root */
1946
+ inline_speed void
1947
+ downheap (ANHE *heap, int N, int k)
1948
+ {
1949
+ ANHE he = heap [k];
1950
+ ANHE *E = heap + N + HEAP0;
1951
+
1952
+ for (;;)
1953
+ {
1954
+ ev_tstamp minat;
1955
+ ANHE *minpos;
1956
+ ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;
1957
+
1958
+ /* find minimum child */
1959
+ if (expect_true (pos + DHEAP - 1 < E))
1960
+ {
1961
+ /* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
1962
+ if ( ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));
1963
+ if ( ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));
1964
+ if ( ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));
1965
+ }
1966
+ else if (pos < E)
1967
+ {
1968
+ /* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
1969
+ if (pos + 1 < E && ANHE_at (pos [1]) < minat) (minpos = pos + 1), (minat = ANHE_at (*minpos));
1970
+ if (pos + 2 < E && ANHE_at (pos [2]) < minat) (minpos = pos + 2), (minat = ANHE_at (*minpos));
1971
+ if (pos + 3 < E && ANHE_at (pos [3]) < minat) (minpos = pos + 3), (minat = ANHE_at (*minpos));
1972
+ }
1973
+ else
1974
+ break;
1975
+
1976
+ if (ANHE_at (he) <= minat)
1977
+ break;
1978
+
1979
+ heap [k] = *minpos;
1980
+ ev_active (ANHE_w (*minpos)) = k;
1981
+
1982
+ k = minpos - heap;
1983
+ }
1984
+
1985
+ heap [k] = he;
1986
+ ev_active (ANHE_w (he)) = k;
1987
+ }
1988
+
1989
+ #else /* 4HEAP */
1990
+
1991
+ #define HEAP0 1
1992
+ #define HPARENT(k) ((k) >> 1)
1993
+ #define UPHEAP_DONE(p,k) (!(p))
1994
+
1995
+ /* away from the root */
1996
+ inline_speed void
1997
+ downheap (ANHE *heap, int N, int k)
1998
+ {
1999
+ ANHE he = heap [k];
2000
+
2001
+ for (;;)
2002
+ {
2003
+ int c = k << 1;
2004
+
2005
+ if (c >= N + HEAP0)
2006
+ break;
2007
+
2008
+ c += c + 1 < N + HEAP0 && ANHE_at (heap [c]) > ANHE_at (heap [c + 1])
2009
+ ? 1 : 0;
2010
+
2011
+ if (ANHE_at (he) <= ANHE_at (heap [c]))
2012
+ break;
2013
+
2014
+ heap [k] = heap [c];
2015
+ ev_active (ANHE_w (heap [k])) = k;
2016
+
2017
+ k = c;
2018
+ }
2019
+
2020
+ heap [k] = he;
2021
+ ev_active (ANHE_w (he)) = k;
2022
+ }
2023
+ #endif
2024
+
2025
+ /* towards the root */
2026
+ inline_speed void
2027
+ upheap (ANHE *heap, int k)
2028
+ {
2029
+ ANHE he = heap [k];
2030
+
2031
+ for (;;)
2032
+ {
2033
+ int p = HPARENT (k);
2034
+
2035
+ if (UPHEAP_DONE (p, k) || ANHE_at (heap [p]) <= ANHE_at (he))
2036
+ break;
2037
+
2038
+ heap [k] = heap [p];
2039
+ ev_active (ANHE_w (heap [k])) = k;
2040
+ k = p;
2041
+ }
2042
+
2043
+ heap [k] = he;
2044
+ ev_active (ANHE_w (he)) = k;
2045
+ }
2046
+
2047
+ /* move an element suitably so it is in a correct place */
2048
+ inline_size void
2049
+ adjustheap (ANHE *heap, int N, int k)
2050
+ {
2051
+ if (k > HEAP0 && ANHE_at (heap [k]) <= ANHE_at (heap [HPARENT (k)]))
2052
+ upheap (heap, k);
2053
+ else
2054
+ downheap (heap, N, k);
2055
+ }
2056
+
2057
+ /* rebuild the heap: this function is used only once and executed rarely */
2058
+ inline_size void
2059
+ reheap (ANHE *heap, int N)
2060
+ {
2061
+ int i;
2062
+
2063
+ /* we don't use floyds algorithm, upheap is simpler and is more cache-efficient */
2064
+ /* also, this is easy to implement and correct for both 2-heaps and 4-heaps */
2065
+ for (i = 0; i < N; ++i)
2066
+ upheap (heap, i + HEAP0);
2067
+ }
2068
+
2069
+ /*****************************************************************************/
2070
+
2071
+ /* associate signal watchers to a signal signal */
2072
+ typedef struct
2073
+ {
2074
+ EV_ATOMIC_T pending;
2075
+ #if EV_MULTIPLICITY
2076
+ EV_P;
2077
+ #endif
2078
+ WL head;
2079
+ } ANSIG;
2080
+
2081
+ static ANSIG signals [EV_NSIG - 1];
2082
+
2083
+ /*****************************************************************************/
2084
+
2085
+ #if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2086
+
2087
+ static void noinline ecb_cold
2088
+ evpipe_init (EV_P)
2089
+ {
2090
+ if (!ev_is_active (&pipe_w))
2091
+ {
2092
+ int fds [2];
2093
+
2094
+ # if EV_USE_EVENTFD
2095
+ fds [0] = -1;
2096
+ fds [1] = eventfd (0, EFD_NONBLOCK | EFD_CLOEXEC);
2097
+ if (fds [1] < 0 && errno == EINVAL)
2098
+ fds [1] = eventfd (0, 0);
2099
+
2100
+ if (fds [1] < 0)
2101
+ # endif
2102
+ {
2103
+ while (pipe (fds))
2104
+ ev_syserr ("(libev) error creating signal/async pipe");
2105
+
2106
+ fd_intern (fds [0]);
2107
+ }
2108
+
2109
+ fd_intern (fds [1]);
2110
+
2111
+ evpipe [0] = fds [0];
2112
+
2113
+ if (evpipe [1] < 0)
2114
+ evpipe [1] = fds [1]; /* first call, set write fd */
2115
+ else
2116
+ {
2117
+ /* on subsequent calls, do not change evpipe [1] */
2118
+ /* so that evpipe_write can always rely on its value. */
2119
+ /* this branch does not do anything sensible on windows, */
2120
+ /* so must not be executed on windows */
2121
+
2122
+ dup2 (fds [1], evpipe [1]);
2123
+ close (fds [1]);
2124
+ }
2125
+
2126
+ ev_io_set (&pipe_w, evpipe [0] < 0 ? evpipe [1] : evpipe [0], EV_READ);
2127
+ ev_io_start (EV_A_ &pipe_w);
2128
+ ev_unref (EV_A); /* watcher should not keep loop alive */
2129
+ }
2130
+ }
2131
+
2132
+ inline_speed void
2133
+ evpipe_write (EV_P_ EV_ATOMIC_T *flag)
2134
+ {
2135
+ ECB_MEMORY_FENCE; /* push out the write before this function was called, acquire flag */
2136
+
2137
+ if (expect_true (*flag))
2138
+ return;
2139
+
2140
+ *flag = 1;
2141
+ ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */
2142
+
2143
+ pipe_write_skipped = 1;
2144
+
2145
+ ECB_MEMORY_FENCE; /* make sure pipe_write_skipped is visible before we check pipe_write_wanted */
2146
+
2147
+ if (pipe_write_wanted)
2148
+ {
2149
+ int old_errno;
2150
+
2151
+ pipe_write_skipped = 0;
2152
+ ECB_MEMORY_FENCE_RELEASE;
2153
+
2154
+ old_errno = errno; /* save errno because write will clobber it */
2155
+
2156
+ #if EV_USE_EVENTFD
2157
+ if (evpipe [0] < 0)
2158
+ {
2159
+ uint64_t counter = 1;
2160
+ write (evpipe [1], &counter, sizeof (uint64_t));
2161
+ }
2162
+ else
2163
+ #endif
2164
+ {
2165
+ #ifdef _WIN32
2166
+ WSABUF buf;
2167
+ DWORD sent;
2168
+ buf.buf = &buf;
2169
+ buf.len = 1;
2170
+ WSASend (EV_FD_TO_WIN32_HANDLE (evpipe [1]), &buf, 1, &sent, 0, 0, 0);
2171
+ #else
2172
+ write (evpipe [1], &(evpipe [1]), 1);
2173
+ #endif
2174
+ }
2175
+
2176
+ errno = old_errno;
2177
+ }
2178
+ }
2179
+
2180
+ /* called whenever the libev signal pipe */
2181
+ /* got some events (signal, async) */
2182
+ static void
2183
+ pipecb (EV_P_ ev_io *iow, int revents)
2184
+ {
2185
+ int i;
2186
+
2187
+ if (revents & EV_READ)
2188
+ {
2189
+ #if EV_USE_EVENTFD
2190
+ if (evpipe [0] < 0)
2191
+ {
2192
+ uint64_t counter;
2193
+ read (evpipe [1], &counter, sizeof (uint64_t));
2194
+ }
2195
+ else
2196
+ #endif
2197
+ {
2198
+ char dummy[4];
2199
+ #ifdef _WIN32
2200
+ WSABUF buf;
2201
+ DWORD recvd;
2202
+ DWORD flags = 0;
2203
+ buf.buf = dummy;
2204
+ buf.len = sizeof (dummy);
2205
+ WSARecv (EV_FD_TO_WIN32_HANDLE (evpipe [0]), &buf, 1, &recvd, &flags, 0, 0);
2206
+ #else
2207
+ read (evpipe [0], &dummy, sizeof (dummy));
2208
+ #endif
2209
+ }
2210
+ }
2211
+
2212
+ pipe_write_skipped = 0;
2213
+
2214
+ ECB_MEMORY_FENCE; /* push out skipped, acquire flags */
2215
+
2216
+ #if EV_SIGNAL_ENABLE
2217
+ if (sig_pending)
2218
+ {
2219
+ sig_pending = 0;
2220
+
2221
+ ECB_MEMORY_FENCE;
2222
+
2223
+ for (i = EV_NSIG - 1; i--; )
2224
+ if (expect_false (signals [i].pending))
2225
+ ev_feed_signal_event (EV_A_ i + 1);
2226
+ }
2227
+ #endif
2228
+
2229
+ #if EV_ASYNC_ENABLE
2230
+ if (async_pending)
2231
+ {
2232
+ async_pending = 0;
2233
+
2234
+ ECB_MEMORY_FENCE;
2235
+
2236
+ for (i = asynccnt; i--; )
2237
+ if (asyncs [i]->sent)
2238
+ {
2239
+ asyncs [i]->sent = 0;
2240
+ ECB_MEMORY_FENCE_RELEASE;
2241
+ ev_feed_event (EV_A_ asyncs [i], EV_ASYNC);
2242
+ }
2243
+ }
2244
+ #endif
2245
+ }
2246
+
2247
+ /*****************************************************************************/
2248
+
2249
+ void
2250
+ ev_feed_signal (int signum) EV_THROW
2251
+ {
2252
+ #if EV_MULTIPLICITY
2253
+ EV_P;
2254
+ ECB_MEMORY_FENCE_ACQUIRE;
2255
+ EV_A = signals [signum - 1].loop;
2256
+
2257
+ if (!EV_A)
2258
+ return;
2259
+ #endif
2260
+
2261
+ signals [signum - 1].pending = 1;
2262
+ evpipe_write (EV_A_ &sig_pending);
2263
+ }
2264
+
2265
+ static void
2266
+ ev_sighandler (int signum)
2267
+ {
2268
+ #ifdef _WIN32
2269
+ signal (signum, ev_sighandler);
2270
+ #endif
2271
+
2272
+ ev_feed_signal (signum);
2273
+ }
2274
+
2275
+ void noinline
2276
+ ev_feed_signal_event (EV_P_ int signum) EV_THROW
2277
+ {
2278
+ WL w;
2279
+
2280
+ if (expect_false (signum <= 0 || signum >= EV_NSIG))
2281
+ return;
2282
+
2283
+ --signum;
2284
+
2285
+ #if EV_MULTIPLICITY
2286
+ /* it is permissible to try to feed a signal to the wrong loop */
2287
+ /* or, likely more useful, feeding a signal nobody is waiting for */
2288
+
2289
+ if (expect_false (signals [signum].loop != EV_A))
2290
+ return;
2291
+ #endif
2292
+
2293
+ signals [signum].pending = 0;
2294
+ ECB_MEMORY_FENCE_RELEASE;
2295
+
2296
+ for (w = signals [signum].head; w; w = w->next)
2297
+ ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
2298
+ }
2299
+
2300
+ #if EV_USE_SIGNALFD
2301
+ static void
2302
+ sigfdcb (EV_P_ ev_io *iow, int revents)
2303
+ {
2304
+ struct signalfd_siginfo si[2], *sip; /* these structs are big */
2305
+
2306
+ for (;;)
2307
+ {
2308
+ ssize_t res = read (sigfd, si, sizeof (si));
2309
+
2310
+ /* not ISO-C, as res might be -1, but works with SuS */
2311
+ for (sip = si; (char *)sip < (char *)si + res; ++sip)
2312
+ ev_feed_signal_event (EV_A_ sip->ssi_signo);
2313
+
2314
+ if (res < (ssize_t)sizeof (si))
2315
+ break;
2316
+ }
2317
+ }
2318
+ #endif
2319
+
2320
+ #endif
2321
+
2322
+ /*****************************************************************************/
2323
+
2324
+ #if EV_CHILD_ENABLE
2325
+ static WL childs [EV_PID_HASHSIZE];
2326
+
2327
+ static ev_signal childev;
2328
+
2329
+ #ifndef WIFCONTINUED
2330
+ # define WIFCONTINUED(status) 0
2331
+ #endif
2332
+
2333
+ /* handle a single child status event */
2334
+ inline_speed void
2335
+ child_reap (EV_P_ int chain, int pid, int status)
2336
+ {
2337
+ ev_child *w;
2338
+ int traced = WIFSTOPPED (status) || WIFCONTINUED (status);
2339
+
2340
+ for (w = (ev_child *)childs [chain & ((EV_PID_HASHSIZE) - 1)]; w; w = (ev_child *)((WL)w)->next)
2341
+ {
2342
+ if ((w->pid == pid || !w->pid)
2343
+ && (!traced || (w->flags & 1)))
2344
+ {
2345
+ ev_set_priority (w, EV_MAXPRI); /* need to do it *now*, this *must* be the same prio as the signal watcher itself */
2346
+ w->rpid = pid;
2347
+ w->rstatus = status;
2348
+ ev_feed_event (EV_A_ (W)w, EV_CHILD);
2349
+ }
2350
+ }
2351
+ }
2352
+
2353
+ #ifndef WCONTINUED
2354
+ # define WCONTINUED 0
2355
+ #endif
2356
+
2357
+ /* called on sigchld etc., calls waitpid */
2358
+ static void
2359
+ childcb (EV_P_ ev_signal *sw, int revents)
2360
+ {
2361
+ int pid, status;
2362
+
2363
+ /* some systems define WCONTINUED but then fail to support it (linux 2.4) */
2364
+ if (0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED)))
2365
+ if (!WCONTINUED
2366
+ || errno != EINVAL
2367
+ || 0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED)))
2368
+ return;
2369
+
2370
+ /* make sure we are called again until all children have been reaped */
2371
+ /* we need to do it this way so that the callback gets called before we continue */
2372
+ ev_feed_event (EV_A_ (W)sw, EV_SIGNAL);
2373
+
2374
+ child_reap (EV_A_ pid, pid, status);
2375
+ if ((EV_PID_HASHSIZE) > 1)
2376
+ child_reap (EV_A_ 0, pid, status); /* this might trigger a watcher twice, but feed_event catches that */
2377
+ }
2378
+
2379
+ #endif
2380
+
2381
+ /*****************************************************************************/
2382
+
2383
+ #if EV_USE_IOCP
2384
+ # include "ev_iocp.c"
2385
+ #endif
2386
+ #if EV_USE_PORT
2387
+ # include "ev_port.c"
2388
+ #endif
2389
+ #if EV_USE_KQUEUE
2390
+ # include "ev_kqueue.c"
2391
+ #endif
2392
+ #if EV_USE_EPOLL
2393
+ # include "ev_epoll.c"
2394
+ #endif
2395
+ #if EV_USE_POLL
2396
+ # include "ev_poll.c"
2397
+ #endif
2398
+ #if EV_USE_SELECT
2399
+ # include "ev_select.c"
2400
+ #endif
2401
+
2402
+ int ecb_cold
2403
+ ev_version_major (void) EV_THROW
2404
+ {
2405
+ return EV_VERSION_MAJOR;
2406
+ }
2407
+
2408
+ int ecb_cold
2409
+ ev_version_minor (void) EV_THROW
2410
+ {
2411
+ return EV_VERSION_MINOR;
2412
+ }
2413
+
2414
+ /* return true if we are running with elevated privileges and should ignore env variables */
2415
+ int inline_size ecb_cold
2416
+ enable_secure (void)
2417
+ {
2418
+ #ifdef _WIN32
2419
+ return 0;
2420
+ #else
2421
+ return getuid () != geteuid ()
2422
+ || getgid () != getegid ();
2423
+ #endif
2424
+ }
2425
+
2426
+ unsigned int ecb_cold
2427
+ ev_supported_backends (void) EV_THROW
2428
+ {
2429
+ unsigned int flags = 0;
2430
+
2431
+ if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
2432
+ if (EV_USE_KQUEUE) flags |= EVBACKEND_KQUEUE;
2433
+ if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;
2434
+ if (EV_USE_POLL ) flags |= EVBACKEND_POLL;
2435
+ if (EV_USE_SELECT) flags |= EVBACKEND_SELECT;
2436
+
2437
+ return flags;
2438
+ }
2439
+
2440
+ unsigned int ecb_cold
2441
+ ev_recommended_backends (void) EV_THROW
2442
+ {
2443
+ unsigned int flags = ev_supported_backends ();
2444
+
2445
+ #ifndef __NetBSD__
2446
+ /* kqueue is borked on everything but netbsd apparently */
2447
+ /* it usually doesn't work correctly on anything but sockets and pipes */
2448
+ flags &= ~EVBACKEND_KQUEUE;
2449
+ #endif
2450
+ #ifdef __APPLE__
2451
+ /* only select works correctly on that "unix-certified" platform */
2452
+ flags &= ~EVBACKEND_KQUEUE; /* horribly broken, even for sockets */
2453
+ flags &= ~EVBACKEND_POLL; /* poll is based on kqueue from 10.5 onwards */
2454
+ #endif
2455
+ #ifdef __FreeBSD__
2456
+ flags &= ~EVBACKEND_POLL; /* poll return value is unusable (http://forums.freebsd.org/archive/index.php/t-10270.html) */
2457
+ #endif
2458
+
2459
+ return flags;
2460
+ }
2461
+
2462
+ unsigned int ecb_cold
2463
+ ev_embeddable_backends (void) EV_THROW
2464
+ {
2465
+ int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT;
2466
+
2467
+ /* epoll embeddability broken on all linux versions up to at least 2.6.23 */
2468
+ if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */
2469
+ flags &= ~EVBACKEND_EPOLL;
2470
+
2471
+ return flags;
2472
+ }
2473
+
2474
+ unsigned int
2475
+ ev_backend (EV_P) EV_THROW
2476
+ {
2477
+ return backend;
2478
+ }
2479
+
2480
+ #if EV_FEATURE_API
2481
+ unsigned int
2482
+ ev_iteration (EV_P) EV_THROW
2483
+ {
2484
+ return loop_count;
2485
+ }
2486
+
2487
+ unsigned int
2488
+ ev_depth (EV_P) EV_THROW
2489
+ {
2490
+ return loop_depth;
2491
+ }
2492
+
2493
+ void
2494
+ ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_THROW
2495
+ {
2496
+ io_blocktime = interval;
2497
+ }
2498
+
2499
+ void
2500
+ ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_THROW
2501
+ {
2502
+ timeout_blocktime = interval;
2503
+ }
2504
+
2505
+ void
2506
+ ev_set_userdata (EV_P_ void *data) EV_THROW
2507
+ {
2508
+ userdata = data;
2509
+ }
2510
+
2511
+ void *
2512
+ ev_userdata (EV_P) EV_THROW
2513
+ {
2514
+ return userdata;
2515
+ }
2516
+
2517
+ void
2518
+ ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) EV_THROW
2519
+ {
2520
+ invoke_cb = invoke_pending_cb;
2521
+ }
2522
+
2523
+ void
2524
+ ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_THROW, void (*acquire)(EV_P) EV_THROW) EV_THROW
2525
+ {
2526
+ release_cb = release;
2527
+ acquire_cb = acquire;
2528
+ }
2529
+ #endif
2530
+
2531
+ /* initialise a loop structure, must be zero-initialised */
2532
+ static void noinline ecb_cold
2533
+ loop_init (EV_P_ unsigned int flags) EV_THROW
2534
+ {
2535
+ if (!backend)
2536
+ {
2537
+ origflags = flags;
2538
+
2539
+ #if EV_USE_REALTIME
2540
+ if (!have_realtime)
2541
+ {
2542
+ struct timespec ts;
2543
+
2544
+ if (!clock_gettime (CLOCK_REALTIME, &ts))
2545
+ have_realtime = 1;
2546
+ }
2547
+ #endif
2548
+
2549
+ #if EV_USE_MONOTONIC
2550
+ if (!have_monotonic)
2551
+ {
2552
+ struct timespec ts;
2553
+
2554
+ if (!clock_gettime (CLOCK_MONOTONIC, &ts))
2555
+ have_monotonic = 1;
2556
+ }
2557
+ #endif
2558
+
2559
+ /* pid check not overridable via env */
2560
+ #ifndef _WIN32
2561
+ if (flags & EVFLAG_FORKCHECK)
2562
+ curpid = getpid ();
2563
+ #endif
2564
+
2565
+ if (!(flags & EVFLAG_NOENV)
2566
+ && !enable_secure ()
2567
+ && getenv ("LIBEV_FLAGS"))
2568
+ flags = atoi (getenv ("LIBEV_FLAGS"));
2569
+
2570
+ ev_rt_now = ev_time ();
2571
+ mn_now = get_clock ();
2572
+ now_floor = mn_now;
2573
+ rtmn_diff = ev_rt_now - mn_now;
2574
+ #if EV_FEATURE_API
2575
+ invoke_cb = ev_invoke_pending;
2576
+ #endif
2577
+
2578
+ io_blocktime = 0.;
2579
+ timeout_blocktime = 0.;
2580
+ backend = 0;
2581
+ backend_fd = -1;
2582
+ sig_pending = 0;
2583
+ #if EV_ASYNC_ENABLE
2584
+ async_pending = 0;
2585
+ #endif
2586
+ pipe_write_skipped = 0;
2587
+ pipe_write_wanted = 0;
2588
+ evpipe [0] = -1;
2589
+ evpipe [1] = -1;
2590
+ #if EV_USE_INOTIFY
2591
+ fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;
2592
+ #endif
2593
+ #if EV_USE_SIGNALFD
2594
+ sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;
2595
+ #endif
2596
+
2597
+ if (!(flags & EVBACKEND_MASK))
2598
+ flags |= ev_recommended_backends ();
2599
+
2600
+ #if EV_USE_IOCP
2601
+ if (!backend && (flags & EVBACKEND_IOCP )) backend = iocp_init (EV_A_ flags);
2602
+ #endif
2603
+ #if EV_USE_PORT
2604
+ if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);
2605
+ #endif
2606
+ #if EV_USE_KQUEUE
2607
+ if (!backend && (flags & EVBACKEND_KQUEUE)) backend = kqueue_init (EV_A_ flags);
2608
+ #endif
2609
+ #if EV_USE_EPOLL
2610
+ if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init (EV_A_ flags);
2611
+ #endif
2612
+ #if EV_USE_POLL
2613
+ if (!backend && (flags & EVBACKEND_POLL )) backend = poll_init (EV_A_ flags);
2614
+ #endif
2615
+ #if EV_USE_SELECT
2616
+ if (!backend && (flags & EVBACKEND_SELECT)) backend = select_init (EV_A_ flags);
2617
+ #endif
2618
+
2619
+ ev_prepare_init (&pending_w, pendingcb);
2620
+
2621
+ #if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2622
+ ev_init (&pipe_w, pipecb);
2623
+ ev_set_priority (&pipe_w, EV_MAXPRI);
2624
+ #endif
2625
+ }
2626
+ }
2627
+
2628
+ /* free up a loop structure */
2629
+ void ecb_cold
2630
+ ev_loop_destroy (EV_P)
2631
+ {
2632
+ int i;
2633
+
2634
+ #if EV_MULTIPLICITY
2635
+ /* mimic free (0) */
2636
+ if (!EV_A)
2637
+ return;
2638
+ #endif
2639
+
2640
+ #if EV_CLEANUP_ENABLE
2641
+ /* queue cleanup watchers (and execute them) */
2642
+ if (expect_false (cleanupcnt))
2643
+ {
2644
+ queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);
2645
+ EV_INVOKE_PENDING;
2646
+ }
2647
+ #endif
2648
+
2649
+ #if EV_CHILD_ENABLE
2650
+ if (ev_is_default_loop (EV_A) && ev_is_active (&childev))
2651
+ {
2652
+ ev_ref (EV_A); /* child watcher */
2653
+ ev_signal_stop (EV_A_ &childev);
2654
+ }
2655
+ #endif
2656
+
2657
+ if (ev_is_active (&pipe_w))
2658
+ {
2659
+ /*ev_ref (EV_A);*/
2660
+ /*ev_io_stop (EV_A_ &pipe_w);*/
2661
+
2662
+ if (evpipe [0] >= 0) EV_WIN32_CLOSE_FD (evpipe [0]);
2663
+ if (evpipe [1] >= 0) EV_WIN32_CLOSE_FD (evpipe [1]);
2664
+ }
2665
+
2666
+ #if EV_USE_SIGNALFD
2667
+ if (ev_is_active (&sigfd_w))
2668
+ close (sigfd);
2669
+ #endif
2670
+
2671
+ #if EV_USE_INOTIFY
2672
+ if (fs_fd >= 0)
2673
+ close (fs_fd);
2674
+ #endif
2675
+
2676
+ if (backend_fd >= 0)
2677
+ close (backend_fd);
2678
+
2679
+ #if EV_USE_IOCP
2680
+ if (backend == EVBACKEND_IOCP ) iocp_destroy (EV_A);
2681
+ #endif
2682
+ #if EV_USE_PORT
2683
+ if (backend == EVBACKEND_PORT ) port_destroy (EV_A);
2684
+ #endif
2685
+ #if EV_USE_KQUEUE
2686
+ if (backend == EVBACKEND_KQUEUE) kqueue_destroy (EV_A);
2687
+ #endif
2688
+ #if EV_USE_EPOLL
2689
+ if (backend == EVBACKEND_EPOLL ) epoll_destroy (EV_A);
2690
+ #endif
2691
+ #if EV_USE_POLL
2692
+ if (backend == EVBACKEND_POLL ) poll_destroy (EV_A);
2693
+ #endif
2694
+ #if EV_USE_SELECT
2695
+ if (backend == EVBACKEND_SELECT) select_destroy (EV_A);
2696
+ #endif
2697
+
2698
+ for (i = NUMPRI; i--; )
2699
+ {
2700
+ array_free (pending, [i]);
2701
+ #if EV_IDLE_ENABLE
2702
+ array_free (idle, [i]);
2703
+ #endif
2704
+ }
2705
+
2706
+ ev_free (anfds); anfds = 0; anfdmax = 0;
2707
+
2708
+ /* have to use the microsoft-never-gets-it-right macro */
2709
+ array_free (rfeed, EMPTY);
2710
+ array_free (fdchange, EMPTY);
2711
+ array_free (timer, EMPTY);
2712
+ #if EV_PERIODIC_ENABLE
2713
+ array_free (periodic, EMPTY);
2714
+ #endif
2715
+ #if EV_FORK_ENABLE
2716
+ array_free (fork, EMPTY);
2717
+ #endif
2718
+ #if EV_CLEANUP_ENABLE
2719
+ array_free (cleanup, EMPTY);
2720
+ #endif
2721
+ array_free (prepare, EMPTY);
2722
+ array_free (check, EMPTY);
2723
+ #if EV_ASYNC_ENABLE
2724
+ array_free (async, EMPTY);
2725
+ #endif
2726
+
2727
+ backend = 0;
2728
+
2729
+ #if EV_MULTIPLICITY
2730
+ if (ev_is_default_loop (EV_A))
2731
+ #endif
2732
+ ev_default_loop_ptr = 0;
2733
+ #if EV_MULTIPLICITY
2734
+ else
2735
+ ev_free (EV_A);
2736
+ #endif
2737
+ }
2738
+
2739
+ #if EV_USE_INOTIFY
2740
+ inline_size void infy_fork (EV_P);
2741
+ #endif
2742
+
2743
+ inline_size void
2744
+ loop_fork (EV_P)
2745
+ {
2746
+ #if EV_USE_PORT
2747
+ if (backend == EVBACKEND_PORT ) port_fork (EV_A);
2748
+ #endif
2749
+ #if EV_USE_KQUEUE
2750
+ if (backend == EVBACKEND_KQUEUE) kqueue_fork (EV_A);
2751
+ #endif
2752
+ #if EV_USE_EPOLL
2753
+ if (backend == EVBACKEND_EPOLL ) epoll_fork (EV_A);
2754
+ #endif
2755
+ #if EV_USE_INOTIFY
2756
+ infy_fork (EV_A);
2757
+ #endif
2758
+
2759
+ #if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2760
+ if (ev_is_active (&pipe_w))
2761
+ {
2762
+ /* pipe_write_wanted must be false now, so modifying fd vars should be safe */
2763
+
2764
+ ev_ref (EV_A);
2765
+ ev_io_stop (EV_A_ &pipe_w);
2766
+
2767
+ if (evpipe [0] >= 0)
2768
+ EV_WIN32_CLOSE_FD (evpipe [0]);
2769
+
2770
+ evpipe_init (EV_A);
2771
+ /* iterate over everything, in case we missed something before */
2772
+ ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
2773
+ }
2774
+ #endif
2775
+
2776
+ postfork = 0;
2777
+ }
2778
+
2779
+ #if EV_MULTIPLICITY
2780
+
2781
+ struct ev_loop * ecb_cold
2782
+ ev_loop_new (unsigned int flags) EV_THROW
2783
+ {
2784
+ EV_P = (struct ev_loop *)ev_malloc (sizeof (struct ev_loop));
2785
+
2786
+ memset (EV_A, 0, sizeof (struct ev_loop));
2787
+ loop_init (EV_A_ flags);
2788
+
2789
+ if (ev_backend (EV_A))
2790
+ return EV_A;
2791
+
2792
+ ev_free (EV_A);
2793
+ return 0;
2794
+ }
2795
+
2796
+ #endif /* multiplicity */
2797
+
2798
+ #if EV_VERIFY
2799
+ static void noinline ecb_cold
2800
+ verify_watcher (EV_P_ W w)
2801
+ {
2802
+ assert (("libev: watcher has invalid priority", ABSPRI (w) >= 0 && ABSPRI (w) < NUMPRI));
2803
+
2804
+ if (w->pending)
2805
+ assert (("libev: pending watcher not on pending queue", pendings [ABSPRI (w)][w->pending - 1].w == w));
2806
+ }
2807
+
2808
+ static void noinline ecb_cold
2809
+ verify_heap (EV_P_ ANHE *heap, int N)
2810
+ {
2811
+ int i;
2812
+
2813
+ for (i = HEAP0; i < N + HEAP0; ++i)
2814
+ {
2815
+ assert (("libev: active index mismatch in heap", ev_active (ANHE_w (heap [i])) == i));
2816
+ assert (("libev: heap condition violated", i == HEAP0 || ANHE_at (heap [HPARENT (i)]) <= ANHE_at (heap [i])));
2817
+ assert (("libev: heap at cache mismatch", ANHE_at (heap [i]) == ev_at (ANHE_w (heap [i]))));
2818
+
2819
+ verify_watcher (EV_A_ (W)ANHE_w (heap [i]));
2820
+ }
2821
+ }
2822
+
2823
+ static void noinline ecb_cold
2824
+ array_verify (EV_P_ W *ws, int cnt)
2825
+ {
2826
+ while (cnt--)
2827
+ {
2828
+ assert (("libev: active index mismatch", ev_active (ws [cnt]) == cnt + 1));
2829
+ verify_watcher (EV_A_ ws [cnt]);
2830
+ }
2831
+ }
2832
+ #endif
2833
+
2834
+ #if EV_FEATURE_API
2835
+ void ecb_cold
2836
+ ev_verify (EV_P) EV_THROW
2837
+ {
2838
+ #if EV_VERIFY
2839
+ int i;
2840
+ WL w, w2;
2841
+
2842
+ assert (activecnt >= -1);
2843
+
2844
+ assert (fdchangemax >= fdchangecnt);
2845
+ for (i = 0; i < fdchangecnt; ++i)
2846
+ assert (("libev: negative fd in fdchanges", fdchanges [i] >= 0));
2847
+
2848
+ assert (anfdmax >= 0);
2849
+ for (i = 0; i < anfdmax; ++i)
2850
+ {
2851
+ int j = 0;
2852
+
2853
+ for (w = w2 = anfds [i].head; w; w = w->next)
2854
+ {
2855
+ verify_watcher (EV_A_ (W)w);
2856
+
2857
+ if (j++ & 1)
2858
+ {
2859
+ assert (("libev: io watcher list contains a loop", w != w2));
2860
+ w2 = w2->next;
2861
+ }
2862
+
2863
+ assert (("libev: inactive fd watcher on anfd list", ev_active (w) == 1));
2864
+ assert (("libev: fd mismatch between watcher and anfd", ((ev_io *)w)->fd == i));
2865
+ }
2866
+ }
2867
+
2868
+ assert (timermax >= timercnt);
2869
+ verify_heap (EV_A_ timers, timercnt);
2870
+
2871
+ #if EV_PERIODIC_ENABLE
2872
+ assert (periodicmax >= periodiccnt);
2873
+ verify_heap (EV_A_ periodics, periodiccnt);
2874
+ #endif
2875
+
2876
+ for (i = NUMPRI; i--; )
2877
+ {
2878
+ assert (pendingmax [i] >= pendingcnt [i]);
2879
+ #if EV_IDLE_ENABLE
2880
+ assert (idleall >= 0);
2881
+ assert (idlemax [i] >= idlecnt [i]);
2882
+ array_verify (EV_A_ (W *)idles [i], idlecnt [i]);
2883
+ #endif
2884
+ }
2885
+
2886
+ #if EV_FORK_ENABLE
2887
+ assert (forkmax >= forkcnt);
2888
+ array_verify (EV_A_ (W *)forks, forkcnt);
2889
+ #endif
2890
+
2891
+ #if EV_CLEANUP_ENABLE
2892
+ assert (cleanupmax >= cleanupcnt);
2893
+ array_verify (EV_A_ (W *)cleanups, cleanupcnt);
2894
+ #endif
2895
+
2896
+ #if EV_ASYNC_ENABLE
2897
+ assert (asyncmax >= asynccnt);
2898
+ array_verify (EV_A_ (W *)asyncs, asynccnt);
2899
+ #endif
2900
+
2901
+ #if EV_PREPARE_ENABLE
2902
+ assert (preparemax >= preparecnt);
2903
+ array_verify (EV_A_ (W *)prepares, preparecnt);
2904
+ #endif
2905
+
2906
+ #if EV_CHECK_ENABLE
2907
+ assert (checkmax >= checkcnt);
2908
+ array_verify (EV_A_ (W *)checks, checkcnt);
2909
+ #endif
2910
+
2911
+ # if 0
2912
+ #if EV_CHILD_ENABLE
2913
+ for (w = (ev_child *)childs [chain & ((EV_PID_HASHSIZE) - 1)]; w; w = (ev_child *)((WL)w)->next)
2914
+ for (signum = EV_NSIG; signum--; ) if (signals [signum].pending)
2915
+ #endif
2916
+ # endif
2917
+ #endif
2918
+ }
2919
+ #endif
2920
+
2921
+ #if EV_MULTIPLICITY
2922
+ struct ev_loop * ecb_cold
2923
+ #else
2924
+ int
2925
+ #endif
2926
+ ev_default_loop (unsigned int flags) EV_THROW
2927
+ {
2928
+ if (!ev_default_loop_ptr)
2929
+ {
2930
+ #if EV_MULTIPLICITY
2931
+ EV_P = ev_default_loop_ptr = &default_loop_struct;
2932
+ #else
2933
+ ev_default_loop_ptr = 1;
2934
+ #endif
2935
+
2936
+ loop_init (EV_A_ flags);
2937
+
2938
+ if (ev_backend (EV_A))
2939
+ {
2940
+ #if EV_CHILD_ENABLE
2941
+ ev_signal_init (&childev, childcb, SIGCHLD);
2942
+ ev_set_priority (&childev, EV_MAXPRI);
2943
+ ev_signal_start (EV_A_ &childev);
2944
+ ev_unref (EV_A); /* child watcher should not keep loop alive */
2945
+ #endif
2946
+ }
2947
+ else
2948
+ ev_default_loop_ptr = 0;
2949
+ }
2950
+
2951
+ return ev_default_loop_ptr;
2952
+ }
2953
+
2954
+ void
2955
+ ev_loop_fork (EV_P) EV_THROW
2956
+ {
2957
+ postfork = 1;
2958
+ }
2959
+
2960
+ /*****************************************************************************/
2961
+
2962
+ void
2963
+ ev_invoke (EV_P_ void *w, int revents)
2964
+ {
2965
+ EV_CB_INVOKE ((W)w, revents);
2966
+ }
2967
+
2968
+ unsigned int
2969
+ ev_pending_count (EV_P) EV_THROW
2970
+ {
2971
+ int pri;
2972
+ unsigned int count = 0;
2973
+
2974
+ for (pri = NUMPRI; pri--; )
2975
+ count += pendingcnt [pri];
2976
+
2977
+ return count;
2978
+ }
2979
+
2980
+ void noinline
2981
+ ev_invoke_pending (EV_P)
2982
+ {
2983
+ pendingpri = NUMPRI;
2984
+
2985
+ while (pendingpri) /* pendingpri possibly gets modified in the inner loop */
2986
+ {
2987
+ --pendingpri;
2988
+
2989
+ while (pendingcnt [pendingpri])
2990
+ {
2991
+ ANPENDING *p = pendings [pendingpri] + --pendingcnt [pendingpri];
2992
+
2993
+ p->w->pending = 0;
2994
+ EV_CB_INVOKE (p->w, p->events);
2995
+ EV_FREQUENT_CHECK;
2996
+ }
2997
+ }
2998
+ }
2999
+
3000
+ #if EV_IDLE_ENABLE
3001
+ /* make idle watchers pending. this handles the "call-idle */
3002
+ /* only when higher priorities are idle" logic */
3003
+ inline_size void
3004
+ idle_reify (EV_P)
3005
+ {
3006
+ if (expect_false (idleall))
3007
+ {
3008
+ int pri;
3009
+
3010
+ for (pri = NUMPRI; pri--; )
3011
+ {
3012
+ if (pendingcnt [pri])
3013
+ break;
3014
+
3015
+ if (idlecnt [pri])
3016
+ {
3017
+ queue_events (EV_A_ (W *)idles [pri], idlecnt [pri], EV_IDLE);
3018
+ break;
3019
+ }
3020
+ }
3021
+ }
3022
+ }
3023
+ #endif
3024
+
3025
+ /* make timers pending */
3026
+ inline_size void
3027
+ timers_reify (EV_P)
3028
+ {
3029
+ EV_FREQUENT_CHECK;
3030
+
3031
+ if (timercnt && ANHE_at (timers [HEAP0]) < mn_now)
3032
+ {
3033
+ do
3034
+ {
3035
+ ev_timer *w = (ev_timer *)ANHE_w (timers [HEAP0]);
3036
+
3037
+ /*assert (("libev: inactive timer on timer heap detected", ev_is_active (w)));*/
3038
+
3039
+ /* first reschedule or stop timer */
3040
+ if (w->repeat)
3041
+ {
3042
+ ev_at (w) += w->repeat;
3043
+ if (ev_at (w) < mn_now)
3044
+ ev_at (w) = mn_now;
3045
+
3046
+ assert (("libev: negative ev_timer repeat value found while processing timers", w->repeat > 0.));
3047
+
3048
+ ANHE_at_cache (timers [HEAP0]);
3049
+ downheap (timers, timercnt, HEAP0);
3050
+ }
3051
+ else
3052
+ ev_timer_stop (EV_A_ w); /* nonrepeating: stop timer */
3053
+
3054
+ EV_FREQUENT_CHECK;
3055
+ feed_reverse (EV_A_ (W)w);
3056
+ }
3057
+ while (timercnt && ANHE_at (timers [HEAP0]) < mn_now);
3058
+
3059
+ feed_reverse_done (EV_A_ EV_TIMER);
3060
+ }
3061
+ }
3062
+
3063
+ #if EV_PERIODIC_ENABLE
3064
+
3065
+ static void noinline
3066
+ periodic_recalc (EV_P_ ev_periodic *w)
3067
+ {
3068
+ ev_tstamp interval = w->interval > MIN_INTERVAL ? w->interval : MIN_INTERVAL;
3069
+ ev_tstamp at = w->offset + interval * ev_floor ((ev_rt_now - w->offset) / interval);
3070
+
3071
+ /* the above almost always errs on the low side */
3072
+ while (at <= ev_rt_now)
3073
+ {
3074
+ ev_tstamp nat = at + w->interval;
3075
+
3076
+ /* when resolution fails us, we use ev_rt_now */
3077
+ if (expect_false (nat == at))
3078
+ {
3079
+ at = ev_rt_now;
3080
+ break;
3081
+ }
3082
+
3083
+ at = nat;
3084
+ }
3085
+
3086
+ ev_at (w) = at;
3087
+ }
3088
+
3089
+ /* make periodics pending */
3090
+ inline_size void
3091
+ periodics_reify (EV_P)
3092
+ {
3093
+ EV_FREQUENT_CHECK;
3094
+
3095
+ while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now)
3096
+ {
3097
+ do
3098
+ {
3099
+ ev_periodic *w = (ev_periodic *)ANHE_w (periodics [HEAP0]);
3100
+
3101
+ /*assert (("libev: inactive timer on periodic heap detected", ev_is_active (w)));*/
3102
+
3103
+ /* first reschedule or stop timer */
3104
+ if (w->reschedule_cb)
3105
+ {
3106
+ ev_at (w) = w->reschedule_cb (w, ev_rt_now);
3107
+
3108
+ assert (("libev: ev_periodic reschedule callback returned time in the past", ev_at (w) >= ev_rt_now));
3109
+
3110
+ ANHE_at_cache (periodics [HEAP0]);
3111
+ downheap (periodics, periodiccnt, HEAP0);
3112
+ }
3113
+ else if (w->interval)
3114
+ {
3115
+ periodic_recalc (EV_A_ w);
3116
+ ANHE_at_cache (periodics [HEAP0]);
3117
+ downheap (periodics, periodiccnt, HEAP0);
3118
+ }
3119
+ else
3120
+ ev_periodic_stop (EV_A_ w); /* nonrepeating: stop timer */
3121
+
3122
+ EV_FREQUENT_CHECK;
3123
+ feed_reverse (EV_A_ (W)w);
3124
+ }
3125
+ while (periodiccnt && ANHE_at (periodics [HEAP0]) < ev_rt_now);
3126
+
3127
+ feed_reverse_done (EV_A_ EV_PERIODIC);
3128
+ }
3129
+ }
3130
+
3131
+ /* simply recalculate all periodics */
3132
+ /* TODO: maybe ensure that at least one event happens when jumping forward? */
3133
+ static void noinline ecb_cold
3134
+ periodics_reschedule (EV_P)
3135
+ {
3136
+ int i;
3137
+
3138
+ /* adjust periodics after time jump */
3139
+ for (i = HEAP0; i < periodiccnt + HEAP0; ++i)
3140
+ {
3141
+ ev_periodic *w = (ev_periodic *)ANHE_w (periodics [i]);
3142
+
3143
+ if (w->reschedule_cb)
3144
+ ev_at (w) = w->reschedule_cb (w, ev_rt_now);
3145
+ else if (w->interval)
3146
+ periodic_recalc (EV_A_ w);
3147
+
3148
+ ANHE_at_cache (periodics [i]);
3149
+ }
3150
+
3151
+ reheap (periodics, periodiccnt);
3152
+ }
3153
+ #endif
3154
+
3155
+ /* adjust all timers by a given offset */
3156
+ static void noinline ecb_cold
3157
+ timers_reschedule (EV_P_ ev_tstamp adjust)
3158
+ {
3159
+ int i;
3160
+
3161
+ for (i = 0; i < timercnt; ++i)
3162
+ {
3163
+ ANHE *he = timers + i + HEAP0;
3164
+ ANHE_w (*he)->at += adjust;
3165
+ ANHE_at_cache (*he);
3166
+ }
3167
+ }
3168
+
3169
+ /* fetch new monotonic and realtime times from the kernel */
3170
+ /* also detect if there was a timejump, and act accordingly */
3171
+ inline_speed void
3172
+ time_update (EV_P_ ev_tstamp max_block)
3173
+ {
3174
+ #if EV_USE_MONOTONIC
3175
+ if (expect_true (have_monotonic))
3176
+ {
3177
+ int i;
3178
+ ev_tstamp odiff = rtmn_diff;
3179
+
3180
+ mn_now = get_clock ();
3181
+
3182
+ /* only fetch the realtime clock every 0.5*MIN_TIMEJUMP seconds */
3183
+ /* interpolate in the meantime */
3184
+ if (expect_true (mn_now - now_floor < MIN_TIMEJUMP * .5))
3185
+ {
3186
+ ev_rt_now = rtmn_diff + mn_now;
3187
+ return;
3188
+ }
3189
+
3190
+ now_floor = mn_now;
3191
+ ev_rt_now = ev_time ();
3192
+
3193
+ /* loop a few times, before making important decisions.
3194
+ * on the choice of "4": one iteration isn't enough,
3195
+ * in case we get preempted during the calls to
3196
+ * ev_time and get_clock. a second call is almost guaranteed
3197
+ * to succeed in that case, though. and looping a few more times
3198
+ * doesn't hurt either as we only do this on time-jumps or
3199
+ * in the unlikely event of having been preempted here.
3200
+ */
3201
+ for (i = 4; --i; )
3202
+ {
3203
+ ev_tstamp diff;
3204
+ rtmn_diff = ev_rt_now - mn_now;
3205
+
3206
+ diff = odiff - rtmn_diff;
3207
+
3208
+ if (expect_true ((diff < 0. ? -diff : diff) < MIN_TIMEJUMP))
3209
+ return; /* all is well */
3210
+
3211
+ ev_rt_now = ev_time ();
3212
+ mn_now = get_clock ();
3213
+ now_floor = mn_now;
3214
+ }
3215
+
3216
+ /* no timer adjustment, as the monotonic clock doesn't jump */
3217
+ /* timers_reschedule (EV_A_ rtmn_diff - odiff) */
3218
+ # if EV_PERIODIC_ENABLE
3219
+ periodics_reschedule (EV_A);
3220
+ # endif
3221
+ }
3222
+ else
3223
+ #endif
3224
+ {
3225
+ ev_rt_now = ev_time ();
3226
+
3227
+ if (expect_false (mn_now > ev_rt_now || ev_rt_now > mn_now + max_block + MIN_TIMEJUMP))
3228
+ {
3229
+ /* adjust timers. this is easy, as the offset is the same for all of them */
3230
+ timers_reschedule (EV_A_ ev_rt_now - mn_now);
3231
+ #if EV_PERIODIC_ENABLE
3232
+ periodics_reschedule (EV_A);
3233
+ #endif
3234
+ }
3235
+
3236
+ mn_now = ev_rt_now;
3237
+ }
3238
+ }
3239
+
3240
+ int
3241
+ ev_run (EV_P_ int flags)
3242
+ {
3243
+ #if EV_FEATURE_API
3244
+ ++loop_depth;
3245
+ #endif
3246
+
3247
+ assert (("libev: ev_loop recursion during release detected", loop_done != EVBREAK_RECURSE));
3248
+
3249
+ loop_done = EVBREAK_CANCEL;
3250
+
3251
+ EV_INVOKE_PENDING; /* in case we recurse, ensure ordering stays nice and clean */
3252
+
3253
+ do
3254
+ {
3255
+ #if EV_VERIFY >= 2
3256
+ ev_verify (EV_A);
3257
+ #endif
3258
+
3259
+ #ifndef _WIN32
3260
+ if (expect_false (curpid)) /* penalise the forking check even more */
3261
+ if (expect_false (getpid () != curpid))
3262
+ {
3263
+ curpid = getpid ();
3264
+ postfork = 1;
3265
+ }
3266
+ #endif
3267
+
3268
+ #if EV_FORK_ENABLE
3269
+ /* we might have forked, so queue fork handlers */
3270
+ if (expect_false (postfork))
3271
+ if (forkcnt)
3272
+ {
3273
+ queue_events (EV_A_ (W *)forks, forkcnt, EV_FORK);
3274
+ EV_INVOKE_PENDING;
3275
+ }
3276
+ #endif
3277
+
3278
+ #if EV_PREPARE_ENABLE
3279
+ /* queue prepare watchers (and execute them) */
3280
+ if (expect_false (preparecnt))
3281
+ {
3282
+ queue_events (EV_A_ (W *)prepares, preparecnt, EV_PREPARE);
3283
+ EV_INVOKE_PENDING;
3284
+ }
3285
+ #endif
3286
+
3287
+ if (expect_false (loop_done))
3288
+ break;
3289
+
3290
+ /* we might have forked, so reify kernel state if necessary */
3291
+ if (expect_false (postfork))
3292
+ loop_fork (EV_A);
3293
+
3294
+ /* update fd-related kernel structures */
3295
+ fd_reify (EV_A);
3296
+
3297
+ /* calculate blocking time */
3298
+ {
3299
+ ev_tstamp waittime = 0.;
3300
+ ev_tstamp sleeptime = 0.;
3301
+
3302
+ /* remember old timestamp for io_blocktime calculation */
3303
+ ev_tstamp prev_mn_now = mn_now;
3304
+
3305
+ /* update time to cancel out callback processing overhead */
3306
+ time_update (EV_A_ 1e100);
3307
+
3308
+ /* from now on, we want a pipe-wake-up */
3309
+ pipe_write_wanted = 1;
3310
+
3311
+ ECB_MEMORY_FENCE; /* make sure pipe_write_wanted is visible before we check for potential skips */
3312
+
3313
+ if (expect_true (!(flags & EVRUN_NOWAIT || idleall || !activecnt || pipe_write_skipped)))
3314
+ {
3315
+ waittime = MAX_BLOCKTIME;
3316
+
3317
+ if (timercnt)
3318
+ {
3319
+ ev_tstamp to = ANHE_at (timers [HEAP0]) - mn_now;
3320
+ if (waittime > to) waittime = to;
3321
+ }
3322
+
3323
+ #if EV_PERIODIC_ENABLE
3324
+ if (periodiccnt)
3325
+ {
3326
+ ev_tstamp to = ANHE_at (periodics [HEAP0]) - ev_rt_now;
3327
+ if (waittime > to) waittime = to;
3328
+ }
3329
+ #endif
3330
+
3331
+ /* don't let timeouts decrease the waittime below timeout_blocktime */
3332
+ if (expect_false (waittime < timeout_blocktime))
3333
+ waittime = timeout_blocktime;
3334
+
3335
+ /* at this point, we NEED to wait, so we have to ensure */
3336
+ /* to pass a minimum nonzero value to the backend */
3337
+ if (expect_false (waittime < backend_mintime))
3338
+ waittime = backend_mintime;
3339
+
3340
+ /* extra check because io_blocktime is commonly 0 */
3341
+ if (expect_false (io_blocktime))
3342
+ {
3343
+ sleeptime = io_blocktime - (mn_now - prev_mn_now);
3344
+
3345
+ if (sleeptime > waittime - backend_mintime)
3346
+ sleeptime = waittime - backend_mintime;
3347
+
3348
+ if (expect_true (sleeptime > 0.))
3349
+ {
3350
+ ev_sleep (sleeptime);
3351
+ waittime -= sleeptime;
3352
+ }
3353
+ }
3354
+ }
3355
+
3356
+ #if EV_FEATURE_API
3357
+ ++loop_count;
3358
+ #endif
3359
+ assert ((loop_done = EVBREAK_RECURSE, 1)); /* assert for side effect */
3360
+ backend_poll (EV_A_ waittime);
3361
+ assert ((loop_done = EVBREAK_CANCEL, 1)); /* assert for side effect */
3362
+
3363
+ pipe_write_wanted = 0; /* just an optimisation, no fence needed */
3364
+
3365
+ ECB_MEMORY_FENCE_ACQUIRE;
3366
+ if (pipe_write_skipped)
3367
+ {
3368
+ assert (("libev: pipe_w not active, but pipe not written", ev_is_active (&pipe_w)));
3369
+ ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
3370
+ }
3371
+
3372
+
3373
+ /* update ev_rt_now, do magic */
3374
+ time_update (EV_A_ waittime + sleeptime);
3375
+ }
3376
+
3377
+ /* queue pending timers and reschedule them */
3378
+ timers_reify (EV_A); /* relative timers called last */
3379
+ #if EV_PERIODIC_ENABLE
3380
+ periodics_reify (EV_A); /* absolute timers called first */
3381
+ #endif
3382
+
3383
+ #if EV_IDLE_ENABLE
3384
+ /* queue idle watchers unless other events are pending */
3385
+ idle_reify (EV_A);
3386
+ #endif
3387
+
3388
+ #if EV_CHECK_ENABLE
3389
+ /* queue check watchers, to be executed first */
3390
+ if (expect_false (checkcnt))
3391
+ queue_events (EV_A_ (W *)checks, checkcnt, EV_CHECK);
3392
+ #endif
3393
+
3394
+ EV_INVOKE_PENDING;
3395
+ }
3396
+ while (expect_true (
3397
+ activecnt
3398
+ && !loop_done
3399
+ && !(flags & (EVRUN_ONCE | EVRUN_NOWAIT))
3400
+ ));
3401
+
3402
+ if (loop_done == EVBREAK_ONE)
3403
+ loop_done = EVBREAK_CANCEL;
3404
+
3405
+ #if EV_FEATURE_API
3406
+ --loop_depth;
3407
+ #endif
3408
+
3409
+ return activecnt;
3410
+ }
3411
+
3412
+ void
3413
+ ev_break (EV_P_ int how) EV_THROW
3414
+ {
3415
+ loop_done = how;
3416
+ }
3417
+
3418
+ void
3419
+ ev_ref (EV_P) EV_THROW
3420
+ {
3421
+ ++activecnt;
3422
+ }
3423
+
3424
+ void
3425
+ ev_unref (EV_P) EV_THROW
3426
+ {
3427
+ --activecnt;
3428
+ }
3429
+
3430
+ void
3431
+ ev_now_update (EV_P) EV_THROW
3432
+ {
3433
+ time_update (EV_A_ 1e100);
3434
+ }
3435
+
3436
+ void
3437
+ ev_suspend (EV_P) EV_THROW
3438
+ {
3439
+ ev_now_update (EV_A);
3440
+ }
3441
+
3442
+ void
3443
+ ev_resume (EV_P) EV_THROW
3444
+ {
3445
+ ev_tstamp mn_prev = mn_now;
3446
+
3447
+ ev_now_update (EV_A);
3448
+ timers_reschedule (EV_A_ mn_now - mn_prev);
3449
+ #if EV_PERIODIC_ENABLE
3450
+ /* TODO: really do this? */
3451
+ periodics_reschedule (EV_A);
3452
+ #endif
3453
+ }
3454
+
3455
+ /*****************************************************************************/
3456
+ /* singly-linked list management, used when the expected list length is short */
3457
+
3458
+ inline_size void
3459
+ wlist_add (WL *head, WL elem)
3460
+ {
3461
+ elem->next = *head;
3462
+ *head = elem;
3463
+ }
3464
+
3465
+ inline_size void
3466
+ wlist_del (WL *head, WL elem)
3467
+ {
3468
+ while (*head)
3469
+ {
3470
+ if (expect_true (*head == elem))
3471
+ {
3472
+ *head = elem->next;
3473
+ break;
3474
+ }
3475
+
3476
+ head = &(*head)->next;
3477
+ }
3478
+ }
3479
+
3480
+ /* internal, faster, version of ev_clear_pending */
3481
+ inline_speed void
3482
+ clear_pending (EV_P_ W w)
3483
+ {
3484
+ if (w->pending)
3485
+ {
3486
+ pendings [ABSPRI (w)][w->pending - 1].w = (W)&pending_w;
3487
+ w->pending = 0;
3488
+ }
3489
+ }
3490
+
3491
+ int
3492
+ ev_clear_pending (EV_P_ void *w) EV_THROW
3493
+ {
3494
+ W w_ = (W)w;
3495
+ int pending = w_->pending;
3496
+
3497
+ if (expect_true (pending))
3498
+ {
3499
+ ANPENDING *p = pendings [ABSPRI (w_)] + pending - 1;
3500
+ p->w = (W)&pending_w;
3501
+ w_->pending = 0;
3502
+ return p->events;
3503
+ }
3504
+ else
3505
+ return 0;
3506
+ }
3507
+
3508
+ inline_size void
3509
+ pri_adjust (EV_P_ W w)
3510
+ {
3511
+ int pri = ev_priority (w);
3512
+ pri = pri < EV_MINPRI ? EV_MINPRI : pri;
3513
+ pri = pri > EV_MAXPRI ? EV_MAXPRI : pri;
3514
+ ev_set_priority (w, pri);
3515
+ }
3516
+
3517
+ inline_speed void
3518
+ ev_start (EV_P_ W w, int active)
3519
+ {
3520
+ pri_adjust (EV_A_ w);
3521
+ w->active = active;
3522
+ ev_ref (EV_A);
3523
+ }
3524
+
3525
+ inline_size void
3526
+ ev_stop (EV_P_ W w)
3527
+ {
3528
+ ev_unref (EV_A);
3529
+ w->active = 0;
3530
+ }
3531
+
3532
+ /*****************************************************************************/
3533
+
3534
+ void noinline
3535
+ ev_io_start (EV_P_ ev_io *w) EV_THROW
3536
+ {
3537
+ int fd = w->fd;
3538
+
3539
+ if (expect_false (ev_is_active (w)))
3540
+ return;
3541
+
3542
+ assert (("libev: ev_io_start called with negative fd", fd >= 0));
3543
+ assert (("libev: ev_io_start called with illegal event mask", !(w->events & ~(EV__IOFDSET | EV_READ | EV_WRITE))));
3544
+
3545
+ EV_FREQUENT_CHECK;
3546
+
3547
+ ev_start (EV_A_ (W)w, 1);
3548
+ array_needsize (ANFD, anfds, anfdmax, fd + 1, array_init_zero);
3549
+ wlist_add (&anfds[fd].head, (WL)w);
3550
+
3551
+ /* common bug, apparently */
3552
+ assert (("libev: ev_io_start called with corrupted watcher", ((WL)w)->next != (WL)w));
3553
+
3554
+ fd_change (EV_A_ fd, w->events & EV__IOFDSET | EV_ANFD_REIFY);
3555
+ w->events &= ~EV__IOFDSET;
3556
+
3557
+ EV_FREQUENT_CHECK;
3558
+ }
3559
+
3560
+ void noinline
3561
+ ev_io_stop (EV_P_ ev_io *w) EV_THROW
3562
+ {
3563
+ clear_pending (EV_A_ (W)w);
3564
+ if (expect_false (!ev_is_active (w)))
3565
+ return;
3566
+
3567
+ assert (("libev: ev_io_stop called with illegal fd (must stay constant after start!)", w->fd >= 0 && w->fd < anfdmax));
3568
+
3569
+ EV_FREQUENT_CHECK;
3570
+
3571
+ wlist_del (&anfds[w->fd].head, (WL)w);
3572
+ ev_stop (EV_A_ (W)w);
3573
+
3574
+ fd_change (EV_A_ w->fd, EV_ANFD_REIFY);
3575
+
3576
+ EV_FREQUENT_CHECK;
3577
+ }
3578
+
3579
+ void noinline
3580
+ ev_timer_start (EV_P_ ev_timer *w) EV_THROW
3581
+ {
3582
+ if (expect_false (ev_is_active (w)))
3583
+ return;
3584
+
3585
+ ev_at (w) += mn_now;
3586
+
3587
+ assert (("libev: ev_timer_start called with negative timer repeat value", w->repeat >= 0.));
3588
+
3589
+ EV_FREQUENT_CHECK;
3590
+
3591
+ ++timercnt;
3592
+ ev_start (EV_A_ (W)w, timercnt + HEAP0 - 1);
3593
+ array_needsize (ANHE, timers, timermax, ev_active (w) + 1, EMPTY2);
3594
+ ANHE_w (timers [ev_active (w)]) = (WT)w;
3595
+ ANHE_at_cache (timers [ev_active (w)]);
3596
+ upheap (timers, ev_active (w));
3597
+
3598
+ EV_FREQUENT_CHECK;
3599
+
3600
+ /*assert (("libev: internal timer heap corruption", timers [ev_active (w)] == (WT)w));*/
3601
+ }
3602
+
3603
+ void noinline
3604
+ ev_timer_stop (EV_P_ ev_timer *w) EV_THROW
3605
+ {
3606
+ clear_pending (EV_A_ (W)w);
3607
+ if (expect_false (!ev_is_active (w)))
3608
+ return;
3609
+
3610
+ EV_FREQUENT_CHECK;
3611
+
3612
+ {
3613
+ int active = ev_active (w);
3614
+
3615
+ assert (("libev: internal timer heap corruption", ANHE_w (timers [active]) == (WT)w));
3616
+
3617
+ --timercnt;
3618
+
3619
+ if (expect_true (active < timercnt + HEAP0))
3620
+ {
3621
+ timers [active] = timers [timercnt + HEAP0];
3622
+ adjustheap (timers, timercnt, active);
3623
+ }
3624
+ }
3625
+
3626
+ ev_at (w) -= mn_now;
3627
+
3628
+ ev_stop (EV_A_ (W)w);
3629
+
3630
+ EV_FREQUENT_CHECK;
3631
+ }
3632
+
3633
+ void noinline
3634
+ ev_timer_again (EV_P_ ev_timer *w) EV_THROW
3635
+ {
3636
+ EV_FREQUENT_CHECK;
3637
+
3638
+ clear_pending (EV_A_ (W)w);
3639
+
3640
+ if (ev_is_active (w))
3641
+ {
3642
+ if (w->repeat)
3643
+ {
3644
+ ev_at (w) = mn_now + w->repeat;
3645
+ ANHE_at_cache (timers [ev_active (w)]);
3646
+ adjustheap (timers, timercnt, ev_active (w));
3647
+ }
3648
+ else
3649
+ ev_timer_stop (EV_A_ w);
3650
+ }
3651
+ else if (w->repeat)
3652
+ {
3653
+ ev_at (w) = w->repeat;
3654
+ ev_timer_start (EV_A_ w);
3655
+ }
3656
+
3657
+ EV_FREQUENT_CHECK;
3658
+ }
3659
+
3660
+ ev_tstamp
3661
+ ev_timer_remaining (EV_P_ ev_timer *w) EV_THROW
3662
+ {
3663
+ return ev_at (w) - (ev_is_active (w) ? mn_now : 0.);
3664
+ }
3665
+
3666
+ #if EV_PERIODIC_ENABLE
3667
+ void noinline
3668
+ ev_periodic_start (EV_P_ ev_periodic *w) EV_THROW
3669
+ {
3670
+ if (expect_false (ev_is_active (w)))
3671
+ return;
3672
+
3673
+ if (w->reschedule_cb)
3674
+ ev_at (w) = w->reschedule_cb (w, ev_rt_now);
3675
+ else if (w->interval)
3676
+ {
3677
+ assert (("libev: ev_periodic_start called with negative interval value", w->interval >= 0.));
3678
+ periodic_recalc (EV_A_ w);
3679
+ }
3680
+ else
3681
+ ev_at (w) = w->offset;
3682
+
3683
+ EV_FREQUENT_CHECK;
3684
+
3685
+ ++periodiccnt;
3686
+ ev_start (EV_A_ (W)w, periodiccnt + HEAP0 - 1);
3687
+ array_needsize (ANHE, periodics, periodicmax, ev_active (w) + 1, EMPTY2);
3688
+ ANHE_w (periodics [ev_active (w)]) = (WT)w;
3689
+ ANHE_at_cache (periodics [ev_active (w)]);
3690
+ upheap (periodics, ev_active (w));
3691
+
3692
+ EV_FREQUENT_CHECK;
3693
+
3694
+ /*assert (("libev: internal periodic heap corruption", ANHE_w (periodics [ev_active (w)]) == (WT)w));*/
3695
+ }
3696
+
3697
+ void noinline
3698
+ ev_periodic_stop (EV_P_ ev_periodic *w) EV_THROW
3699
+ {
3700
+ clear_pending (EV_A_ (W)w);
3701
+ if (expect_false (!ev_is_active (w)))
3702
+ return;
3703
+
3704
+ EV_FREQUENT_CHECK;
3705
+
3706
+ {
3707
+ int active = ev_active (w);
3708
+
3709
+ assert (("libev: internal periodic heap corruption", ANHE_w (periodics [active]) == (WT)w));
3710
+
3711
+ --periodiccnt;
3712
+
3713
+ if (expect_true (active < periodiccnt + HEAP0))
3714
+ {
3715
+ periodics [active] = periodics [periodiccnt + HEAP0];
3716
+ adjustheap (periodics, periodiccnt, active);
3717
+ }
3718
+ }
3719
+
3720
+ ev_stop (EV_A_ (W)w);
3721
+
3722
+ EV_FREQUENT_CHECK;
3723
+ }
3724
+
3725
+ void noinline
3726
+ ev_periodic_again (EV_P_ ev_periodic *w) EV_THROW
3727
+ {
3728
+ /* TODO: use adjustheap and recalculation */
3729
+ ev_periodic_stop (EV_A_ w);
3730
+ ev_periodic_start (EV_A_ w);
3731
+ }
3732
+ #endif
3733
+
3734
+ #ifndef SA_RESTART
3735
+ # define SA_RESTART 0
3736
+ #endif
3737
+
3738
+ #if EV_SIGNAL_ENABLE
3739
+
3740
+ void noinline
3741
+ ev_signal_start (EV_P_ ev_signal *w) EV_THROW
3742
+ {
3743
+ if (expect_false (ev_is_active (w)))
3744
+ return;
3745
+
3746
+ assert (("libev: ev_signal_start called with illegal signal number", w->signum > 0 && w->signum < EV_NSIG));
3747
+
3748
+ #if EV_MULTIPLICITY
3749
+ assert (("libev: a signal must not be attached to two different loops",
3750
+ !signals [w->signum - 1].loop || signals [w->signum - 1].loop == loop));
3751
+
3752
+ signals [w->signum - 1].loop = EV_A;
3753
+ ECB_MEMORY_FENCE_RELEASE;
3754
+ #endif
3755
+
3756
+ EV_FREQUENT_CHECK;
3757
+
3758
+ #if EV_USE_SIGNALFD
3759
+ if (sigfd == -2)
3760
+ {
3761
+ sigfd = signalfd (-1, &sigfd_set, SFD_NONBLOCK | SFD_CLOEXEC);
3762
+ if (sigfd < 0 && errno == EINVAL)
3763
+ sigfd = signalfd (-1, &sigfd_set, 0); /* retry without flags */
3764
+
3765
+ if (sigfd >= 0)
3766
+ {
3767
+ fd_intern (sigfd); /* doing it twice will not hurt */
3768
+
3769
+ sigemptyset (&sigfd_set);
3770
+
3771
+ ev_io_init (&sigfd_w, sigfdcb, sigfd, EV_READ);
3772
+ ev_set_priority (&sigfd_w, EV_MAXPRI);
3773
+ ev_io_start (EV_A_ &sigfd_w);
3774
+ ev_unref (EV_A); /* signalfd watcher should not keep loop alive */
3775
+ }
3776
+ }
3777
+
3778
+ if (sigfd >= 0)
3779
+ {
3780
+ /* TODO: check .head */
3781
+ sigaddset (&sigfd_set, w->signum);
3782
+ sigprocmask (SIG_BLOCK, &sigfd_set, 0);
3783
+
3784
+ signalfd (sigfd, &sigfd_set, 0);
3785
+ }
3786
+ #endif
3787
+
3788
+ ev_start (EV_A_ (W)w, 1);
3789
+ wlist_add (&signals [w->signum - 1].head, (WL)w);
3790
+
3791
+ if (!((WL)w)->next)
3792
+ # if EV_USE_SIGNALFD
3793
+ if (sigfd < 0) /*TODO*/
3794
+ # endif
3795
+ {
3796
+ # ifdef _WIN32
3797
+ evpipe_init (EV_A);
3798
+
3799
+ signal (w->signum, ev_sighandler);
3800
+ # else
3801
+ struct sigaction sa;
3802
+
3803
+ evpipe_init (EV_A);
3804
+
3805
+ sa.sa_handler = ev_sighandler;
3806
+ sigfillset (&sa.sa_mask);
3807
+ sa.sa_flags = SA_RESTART; /* if restarting works we save one iteration */
3808
+ sigaction (w->signum, &sa, 0);
3809
+
3810
+ if (origflags & EVFLAG_NOSIGMASK)
3811
+ {
3812
+ sigemptyset (&sa.sa_mask);
3813
+ sigaddset (&sa.sa_mask, w->signum);
3814
+ sigprocmask (SIG_UNBLOCK, &sa.sa_mask, 0);
3815
+ }
3816
+ #endif
3817
+ }
3818
+
3819
+ EV_FREQUENT_CHECK;
3820
+ }
3821
+
3822
+ void noinline
3823
+ ev_signal_stop (EV_P_ ev_signal *w) EV_THROW
3824
+ {
3825
+ clear_pending (EV_A_ (W)w);
3826
+ if (expect_false (!ev_is_active (w)))
3827
+ return;
3828
+
3829
+ EV_FREQUENT_CHECK;
3830
+
3831
+ wlist_del (&signals [w->signum - 1].head, (WL)w);
3832
+ ev_stop (EV_A_ (W)w);
3833
+
3834
+ if (!signals [w->signum - 1].head)
3835
+ {
3836
+ #if EV_MULTIPLICITY
3837
+ signals [w->signum - 1].loop = 0; /* unattach from signal */
3838
+ #endif
3839
+ #if EV_USE_SIGNALFD
3840
+ if (sigfd >= 0)
3841
+ {
3842
+ sigset_t ss;
3843
+
3844
+ sigemptyset (&ss);
3845
+ sigaddset (&ss, w->signum);
3846
+ sigdelset (&sigfd_set, w->signum);
3847
+
3848
+ signalfd (sigfd, &sigfd_set, 0);
3849
+ sigprocmask (SIG_UNBLOCK, &ss, 0);
3850
+ }
3851
+ else
3852
+ #endif
3853
+ signal (w->signum, SIG_DFL);
3854
+ }
3855
+
3856
+ EV_FREQUENT_CHECK;
3857
+ }
3858
+
3859
+ #endif
3860
+
3861
+ #if EV_CHILD_ENABLE
3862
+
3863
+ void
3864
+ ev_child_start (EV_P_ ev_child *w) EV_THROW
3865
+ {
3866
+ #if EV_MULTIPLICITY
3867
+ assert (("libev: child watchers are only supported in the default loop", loop == ev_default_loop_ptr));
3868
+ #endif
3869
+ if (expect_false (ev_is_active (w)))
3870
+ return;
3871
+
3872
+ EV_FREQUENT_CHECK;
3873
+
3874
+ ev_start (EV_A_ (W)w, 1);
3875
+ wlist_add (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);
3876
+
3877
+ EV_FREQUENT_CHECK;
3878
+ }
3879
+
3880
+ void
3881
+ ev_child_stop (EV_P_ ev_child *w) EV_THROW
3882
+ {
3883
+ clear_pending (EV_A_ (W)w);
3884
+ if (expect_false (!ev_is_active (w)))
3885
+ return;
3886
+
3887
+ EV_FREQUENT_CHECK;
3888
+
3889
+ wlist_del (&childs [w->pid & ((EV_PID_HASHSIZE) - 1)], (WL)w);
3890
+ ev_stop (EV_A_ (W)w);
3891
+
3892
+ EV_FREQUENT_CHECK;
3893
+ }
3894
+
3895
+ #endif
3896
+
3897
+ #if EV_STAT_ENABLE
3898
+
3899
+ # ifdef _WIN32
3900
+ # undef lstat
3901
+ # define lstat(a,b) _stati64 (a,b)
3902
+ # endif
3903
+
3904
+ #define DEF_STAT_INTERVAL 5.0074891
3905
+ #define NFS_STAT_INTERVAL 30.1074891 /* for filesystems potentially failing inotify */
3906
+ #define MIN_STAT_INTERVAL 0.1074891
3907
+
3908
+ static void noinline stat_timer_cb (EV_P_ ev_timer *w_, int revents);
3909
+
3910
+ #if EV_USE_INOTIFY
3911
+
3912
+ /* the * 2 is to allow for alignment padding, which for some reason is >> 8 */
3913
+ # define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
3914
+
3915
+ static void noinline
3916
+ infy_add (EV_P_ ev_stat *w)
3917
+ {
3918
+ w->wd = inotify_add_watch (fs_fd, w->path,
3919
+ IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY
3920
+ | IN_CREATE | IN_DELETE | IN_MOVED_FROM | IN_MOVED_TO
3921
+ | IN_DONT_FOLLOW | IN_MASK_ADD);
3922
+
3923
+ if (w->wd >= 0)
3924
+ {
3925
+ struct statfs sfs;
3926
+
3927
+ /* now local changes will be tracked by inotify, but remote changes won't */
3928
+ /* unless the filesystem is known to be local, we therefore still poll */
3929
+ /* also do poll on <2.6.25, but with normal frequency */
3930
+
3931
+ if (!fs_2625)
3932
+ w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
3933
+ else if (!statfs (w->path, &sfs)
3934
+ && (sfs.f_type == 0x1373 /* devfs */
3935
+ || sfs.f_type == 0x4006 /* fat */
3936
+ || sfs.f_type == 0x4d44 /* msdos */
3937
+ || sfs.f_type == 0xEF53 /* ext2/3 */
3938
+ || sfs.f_type == 0x72b6 /* jffs2 */
3939
+ || sfs.f_type == 0x858458f6 /* ramfs */
3940
+ || sfs.f_type == 0x5346544e /* ntfs */
3941
+ || sfs.f_type == 0x3153464a /* jfs */
3942
+ || sfs.f_type == 0x9123683e /* btrfs */
3943
+ || sfs.f_type == 0x52654973 /* reiser3 */
3944
+ || sfs.f_type == 0x01021994 /* tmpfs */
3945
+ || sfs.f_type == 0x58465342 /* xfs */))
3946
+ w->timer.repeat = 0.; /* filesystem is local, kernel new enough */
3947
+ else
3948
+ w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */
3949
+ }
3950
+ else
3951
+ {
3952
+ /* can't use inotify, continue to stat */
3953
+ w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
3954
+
3955
+ /* if path is not there, monitor some parent directory for speedup hints */
3956
+ /* note that exceeding the hardcoded path limit is not a correctness issue, */
3957
+ /* but an efficiency issue only */
3958
+ if ((errno == ENOENT || errno == EACCES) && strlen (w->path) < 4096)
3959
+ {
3960
+ char path [4096];
3961
+ strcpy (path, w->path);
3962
+
3963
+ do
3964
+ {
3965
+ int mask = IN_MASK_ADD | IN_DELETE_SELF | IN_MOVE_SELF
3966
+ | (errno == EACCES ? IN_ATTRIB : IN_CREATE | IN_MOVED_TO);
3967
+
3968
+ char *pend = strrchr (path, '/');
3969
+
3970
+ if (!pend || pend == path)
3971
+ break;
3972
+
3973
+ *pend = 0;
3974
+ w->wd = inotify_add_watch (fs_fd, path, mask);
3975
+ }
3976
+ while (w->wd < 0 && (errno == ENOENT || errno == EACCES));
3977
+ }
3978
+ }
3979
+
3980
+ if (w->wd >= 0)
3981
+ wlist_add (&fs_hash [w->wd & ((EV_INOTIFY_HASHSIZE) - 1)].head, (WL)w);
3982
+
3983
+ /* now re-arm timer, if required */
3984
+ if (ev_is_active (&w->timer)) ev_ref (EV_A);
3985
+ ev_timer_again (EV_A_ &w->timer);
3986
+ if (ev_is_active (&w->timer)) ev_unref (EV_A);
3987
+ }
3988
+
3989
+ static void noinline
3990
+ infy_del (EV_P_ ev_stat *w)
3991
+ {
3992
+ int slot;
3993
+ int wd = w->wd;
3994
+
3995
+ if (wd < 0)
3996
+ return;
3997
+
3998
+ w->wd = -2;
3999
+ slot = wd & ((EV_INOTIFY_HASHSIZE) - 1);
4000
+ wlist_del (&fs_hash [slot].head, (WL)w);
4001
+
4002
+ /* remove this watcher, if others are watching it, they will rearm */
4003
+ inotify_rm_watch (fs_fd, wd);
4004
+ }
4005
+
4006
+ static void noinline
4007
+ infy_wd (EV_P_ int slot, int wd, struct inotify_event *ev)
4008
+ {
4009
+ if (slot < 0)
4010
+ /* overflow, need to check for all hash slots */
4011
+ for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot)
4012
+ infy_wd (EV_A_ slot, wd, ev);
4013
+ else
4014
+ {
4015
+ WL w_;
4016
+
4017
+ for (w_ = fs_hash [slot & ((EV_INOTIFY_HASHSIZE) - 1)].head; w_; )
4018
+ {
4019
+ ev_stat *w = (ev_stat *)w_;
4020
+ w_ = w_->next; /* lets us remove this watcher and all before it */
4021
+
4022
+ if (w->wd == wd || wd == -1)
4023
+ {
4024
+ if (ev->mask & (IN_IGNORED | IN_UNMOUNT | IN_DELETE_SELF))
4025
+ {
4026
+ wlist_del (&fs_hash [slot & ((EV_INOTIFY_HASHSIZE) - 1)].head, (WL)w);
4027
+ w->wd = -1;
4028
+ infy_add (EV_A_ w); /* re-add, no matter what */
4029
+ }
4030
+
4031
+ stat_timer_cb (EV_A_ &w->timer, 0);
4032
+ }
4033
+ }
4034
+ }
4035
+ }
4036
+
4037
+ static void
4038
+ infy_cb (EV_P_ ev_io *w, int revents)
4039
+ {
4040
+ char buf [EV_INOTIFY_BUFSIZE];
4041
+ int ofs;
4042
+ int len = read (fs_fd, buf, sizeof (buf));
4043
+
4044
+ for (ofs = 0; ofs < len; )
4045
+ {
4046
+ struct inotify_event *ev = (struct inotify_event *)(buf + ofs);
4047
+ infy_wd (EV_A_ ev->wd, ev->wd, ev);
4048
+ ofs += sizeof (struct inotify_event) + ev->len;
4049
+ }
4050
+ }
4051
+
4052
+ inline_size void ecb_cold
4053
+ ev_check_2625 (EV_P)
4054
+ {
4055
+ /* kernels < 2.6.25 are borked
4056
+ * http://www.ussg.indiana.edu/hypermail/linux/kernel/0711.3/1208.html
4057
+ */
4058
+ if (ev_linux_version () < 0x020619)
4059
+ return;
4060
+
4061
+ fs_2625 = 1;
4062
+ }
4063
+
4064
+ inline_size int
4065
+ infy_newfd (void)
4066
+ {
4067
+ #if defined IN_CLOEXEC && defined IN_NONBLOCK
4068
+ int fd = inotify_init1 (IN_CLOEXEC | IN_NONBLOCK);
4069
+ if (fd >= 0)
4070
+ return fd;
4071
+ #endif
4072
+ return inotify_init ();
4073
+ }
4074
+
4075
+ inline_size void
4076
+ infy_init (EV_P)
4077
+ {
4078
+ if (fs_fd != -2)
4079
+ return;
4080
+
4081
+ fs_fd = -1;
4082
+
4083
+ ev_check_2625 (EV_A);
4084
+
4085
+ fs_fd = infy_newfd ();
4086
+
4087
+ if (fs_fd >= 0)
4088
+ {
4089
+ fd_intern (fs_fd);
4090
+ ev_io_init (&fs_w, infy_cb, fs_fd, EV_READ);
4091
+ ev_set_priority (&fs_w, EV_MAXPRI);
4092
+ ev_io_start (EV_A_ &fs_w);
4093
+ ev_unref (EV_A);
4094
+ }
4095
+ }
4096
+
4097
+ inline_size void
4098
+ infy_fork (EV_P)
4099
+ {
4100
+ int slot;
4101
+
4102
+ if (fs_fd < 0)
4103
+ return;
4104
+
4105
+ ev_ref (EV_A);
4106
+ ev_io_stop (EV_A_ &fs_w);
4107
+ close (fs_fd);
4108
+ fs_fd = infy_newfd ();
4109
+
4110
+ if (fs_fd >= 0)
4111
+ {
4112
+ fd_intern (fs_fd);
4113
+ ev_io_set (&fs_w, fs_fd, EV_READ);
4114
+ ev_io_start (EV_A_ &fs_w);
4115
+ ev_unref (EV_A);
4116
+ }
4117
+
4118
+ for (slot = 0; slot < (EV_INOTIFY_HASHSIZE); ++slot)
4119
+ {
4120
+ WL w_ = fs_hash [slot].head;
4121
+ fs_hash [slot].head = 0;
4122
+
4123
+ while (w_)
4124
+ {
4125
+ ev_stat *w = (ev_stat *)w_;
4126
+ w_ = w_->next; /* lets us add this watcher */
4127
+
4128
+ w->wd = -1;
4129
+
4130
+ if (fs_fd >= 0)
4131
+ infy_add (EV_A_ w); /* re-add, no matter what */
4132
+ else
4133
+ {
4134
+ w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
4135
+ if (ev_is_active (&w->timer)) ev_ref (EV_A);
4136
+ ev_timer_again (EV_A_ &w->timer);
4137
+ if (ev_is_active (&w->timer)) ev_unref (EV_A);
4138
+ }
4139
+ }
4140
+ }
4141
+ }
4142
+
4143
+ #endif
4144
+
4145
+ #ifdef _WIN32
4146
+ # define EV_LSTAT(p,b) _stati64 (p, b)
4147
+ #else
4148
+ # define EV_LSTAT(p,b) lstat (p, b)
4149
+ #endif
4150
+
4151
+ void
4152
+ ev_stat_stat (EV_P_ ev_stat *w) EV_THROW
4153
+ {
4154
+ if (lstat (w->path, &w->attr) < 0)
4155
+ w->attr.st_nlink = 0;
4156
+ else if (!w->attr.st_nlink)
4157
+ w->attr.st_nlink = 1;
4158
+ }
4159
+
4160
+ static void noinline
4161
+ stat_timer_cb (EV_P_ ev_timer *w_, int revents)
4162
+ {
4163
+ ev_stat *w = (ev_stat *)(((char *)w_) - offsetof (ev_stat, timer));
4164
+
4165
+ ev_statdata prev = w->attr;
4166
+ ev_stat_stat (EV_A_ w);
4167
+
4168
+ /* memcmp doesn't work on netbsd, they.... do stuff to their struct stat */
4169
+ if (
4170
+ prev.st_dev != w->attr.st_dev
4171
+ || prev.st_ino != w->attr.st_ino
4172
+ || prev.st_mode != w->attr.st_mode
4173
+ || prev.st_nlink != w->attr.st_nlink
4174
+ || prev.st_uid != w->attr.st_uid
4175
+ || prev.st_gid != w->attr.st_gid
4176
+ || prev.st_rdev != w->attr.st_rdev
4177
+ || prev.st_size != w->attr.st_size
4178
+ || prev.st_atime != w->attr.st_atime
4179
+ || prev.st_mtime != w->attr.st_mtime
4180
+ || prev.st_ctime != w->attr.st_ctime
4181
+ ) {
4182
+ /* we only update w->prev on actual differences */
4183
+ /* in case we test more often than invoke the callback, */
4184
+ /* to ensure that prev is always different to attr */
4185
+ w->prev = prev;
4186
+
4187
+ #if EV_USE_INOTIFY
4188
+ if (fs_fd >= 0)
4189
+ {
4190
+ infy_del (EV_A_ w);
4191
+ infy_add (EV_A_ w);
4192
+ ev_stat_stat (EV_A_ w); /* avoid race... */
4193
+ }
4194
+ #endif
4195
+
4196
+ ev_feed_event (EV_A_ w, EV_STAT);
4197
+ }
4198
+ }
4199
+
4200
+ void
4201
+ ev_stat_start (EV_P_ ev_stat *w) EV_THROW
4202
+ {
4203
+ if (expect_false (ev_is_active (w)))
4204
+ return;
4205
+
4206
+ ev_stat_stat (EV_A_ w);
4207
+
4208
+ if (w->interval < MIN_STAT_INTERVAL && w->interval)
4209
+ w->interval = MIN_STAT_INTERVAL;
4210
+
4211
+ ev_timer_init (&w->timer, stat_timer_cb, 0., w->interval ? w->interval : DEF_STAT_INTERVAL);
4212
+ ev_set_priority (&w->timer, ev_priority (w));
4213
+
4214
+ #if EV_USE_INOTIFY
4215
+ infy_init (EV_A);
4216
+
4217
+ if (fs_fd >= 0)
4218
+ infy_add (EV_A_ w);
4219
+ else
4220
+ #endif
4221
+ {
4222
+ ev_timer_again (EV_A_ &w->timer);
4223
+ ev_unref (EV_A);
4224
+ }
4225
+
4226
+ ev_start (EV_A_ (W)w, 1);
4227
+
4228
+ EV_FREQUENT_CHECK;
4229
+ }
4230
+
4231
+ void
4232
+ ev_stat_stop (EV_P_ ev_stat *w) EV_THROW
4233
+ {
4234
+ clear_pending (EV_A_ (W)w);
4235
+ if (expect_false (!ev_is_active (w)))
4236
+ return;
4237
+
4238
+ EV_FREQUENT_CHECK;
4239
+
4240
+ #if EV_USE_INOTIFY
4241
+ infy_del (EV_A_ w);
4242
+ #endif
4243
+
4244
+ if (ev_is_active (&w->timer))
4245
+ {
4246
+ ev_ref (EV_A);
4247
+ ev_timer_stop (EV_A_ &w->timer);
4248
+ }
4249
+
4250
+ ev_stop (EV_A_ (W)w);
4251
+
4252
+ EV_FREQUENT_CHECK;
4253
+ }
4254
+ #endif
4255
+
4256
+ #if EV_IDLE_ENABLE
4257
+ void
4258
+ ev_idle_start (EV_P_ ev_idle *w) EV_THROW
4259
+ {
4260
+ if (expect_false (ev_is_active (w)))
4261
+ return;
4262
+
4263
+ pri_adjust (EV_A_ (W)w);
4264
+
4265
+ EV_FREQUENT_CHECK;
4266
+
4267
+ {
4268
+ int active = ++idlecnt [ABSPRI (w)];
4269
+
4270
+ ++idleall;
4271
+ ev_start (EV_A_ (W)w, active);
4272
+
4273
+ array_needsize (ev_idle *, idles [ABSPRI (w)], idlemax [ABSPRI (w)], active, EMPTY2);
4274
+ idles [ABSPRI (w)][active - 1] = w;
4275
+ }
4276
+
4277
+ EV_FREQUENT_CHECK;
4278
+ }
4279
+
4280
+ void
4281
+ ev_idle_stop (EV_P_ ev_idle *w) EV_THROW
4282
+ {
4283
+ clear_pending (EV_A_ (W)w);
4284
+ if (expect_false (!ev_is_active (w)))
4285
+ return;
4286
+
4287
+ EV_FREQUENT_CHECK;
4288
+
4289
+ {
4290
+ int active = ev_active (w);
4291
+
4292
+ idles [ABSPRI (w)][active - 1] = idles [ABSPRI (w)][--idlecnt [ABSPRI (w)]];
4293
+ ev_active (idles [ABSPRI (w)][active - 1]) = active;
4294
+
4295
+ ev_stop (EV_A_ (W)w);
4296
+ --idleall;
4297
+ }
4298
+
4299
+ EV_FREQUENT_CHECK;
4300
+ }
4301
+ #endif
4302
+
4303
+ #if EV_PREPARE_ENABLE
4304
+ void
4305
+ ev_prepare_start (EV_P_ ev_prepare *w) EV_THROW
4306
+ {
4307
+ if (expect_false (ev_is_active (w)))
4308
+ return;
4309
+
4310
+ EV_FREQUENT_CHECK;
4311
+
4312
+ ev_start (EV_A_ (W)w, ++preparecnt);
4313
+ array_needsize (ev_prepare *, prepares, preparemax, preparecnt, EMPTY2);
4314
+ prepares [preparecnt - 1] = w;
4315
+
4316
+ EV_FREQUENT_CHECK;
4317
+ }
4318
+
4319
+ void
4320
+ ev_prepare_stop (EV_P_ ev_prepare *w) EV_THROW
4321
+ {
4322
+ clear_pending (EV_A_ (W)w);
4323
+ if (expect_false (!ev_is_active (w)))
4324
+ return;
4325
+
4326
+ EV_FREQUENT_CHECK;
4327
+
4328
+ {
4329
+ int active = ev_active (w);
4330
+
4331
+ prepares [active - 1] = prepares [--preparecnt];
4332
+ ev_active (prepares [active - 1]) = active;
4333
+ }
4334
+
4335
+ ev_stop (EV_A_ (W)w);
4336
+
4337
+ EV_FREQUENT_CHECK;
4338
+ }
4339
+ #endif
4340
+
4341
+ #if EV_CHECK_ENABLE
4342
+ void
4343
+ ev_check_start (EV_P_ ev_check *w) EV_THROW
4344
+ {
4345
+ if (expect_false (ev_is_active (w)))
4346
+ return;
4347
+
4348
+ EV_FREQUENT_CHECK;
4349
+
4350
+ ev_start (EV_A_ (W)w, ++checkcnt);
4351
+ array_needsize (ev_check *, checks, checkmax, checkcnt, EMPTY2);
4352
+ checks [checkcnt - 1] = w;
4353
+
4354
+ EV_FREQUENT_CHECK;
4355
+ }
4356
+
4357
+ void
4358
+ ev_check_stop (EV_P_ ev_check *w) EV_THROW
4359
+ {
4360
+ clear_pending (EV_A_ (W)w);
4361
+ if (expect_false (!ev_is_active (w)))
4362
+ return;
4363
+
4364
+ EV_FREQUENT_CHECK;
4365
+
4366
+ {
4367
+ int active = ev_active (w);
4368
+
4369
+ checks [active - 1] = checks [--checkcnt];
4370
+ ev_active (checks [active - 1]) = active;
4371
+ }
4372
+
4373
+ ev_stop (EV_A_ (W)w);
4374
+
4375
+ EV_FREQUENT_CHECK;
4376
+ }
4377
+ #endif
4378
+
4379
+ #if EV_EMBED_ENABLE
4380
+ void noinline
4381
+ ev_embed_sweep (EV_P_ ev_embed *w) EV_THROW
4382
+ {
4383
+ ev_run (w->other, EVRUN_NOWAIT);
4384
+ }
4385
+
4386
+ static void
4387
+ embed_io_cb (EV_P_ ev_io *io, int revents)
4388
+ {
4389
+ ev_embed *w = (ev_embed *)(((char *)io) - offsetof (ev_embed, io));
4390
+
4391
+ if (ev_cb (w))
4392
+ ev_feed_event (EV_A_ (W)w, EV_EMBED);
4393
+ else
4394
+ ev_run (w->other, EVRUN_NOWAIT);
4395
+ }
4396
+
4397
+ static void
4398
+ embed_prepare_cb (EV_P_ ev_prepare *prepare, int revents)
4399
+ {
4400
+ ev_embed *w = (ev_embed *)(((char *)prepare) - offsetof (ev_embed, prepare));
4401
+
4402
+ {
4403
+ EV_P = w->other;
4404
+
4405
+ while (fdchangecnt)
4406
+ {
4407
+ fd_reify (EV_A);
4408
+ ev_run (EV_A_ EVRUN_NOWAIT);
4409
+ }
4410
+ }
4411
+ }
4412
+
4413
+ static void
4414
+ embed_fork_cb (EV_P_ ev_fork *fork_w, int revents)
4415
+ {
4416
+ ev_embed *w = (ev_embed *)(((char *)fork_w) - offsetof (ev_embed, fork));
4417
+
4418
+ ev_embed_stop (EV_A_ w);
4419
+
4420
+ {
4421
+ EV_P = w->other;
4422
+
4423
+ ev_loop_fork (EV_A);
4424
+ ev_run (EV_A_ EVRUN_NOWAIT);
4425
+ }
4426
+
4427
+ ev_embed_start (EV_A_ w);
4428
+ }
4429
+
4430
+ #if 0
4431
+ static void
4432
+ embed_idle_cb (EV_P_ ev_idle *idle, int revents)
4433
+ {
4434
+ ev_idle_stop (EV_A_ idle);
4435
+ }
4436
+ #endif
4437
+
4438
+ void
4439
+ ev_embed_start (EV_P_ ev_embed *w) EV_THROW
4440
+ {
4441
+ if (expect_false (ev_is_active (w)))
4442
+ return;
4443
+
4444
+ {
4445
+ EV_P = w->other;
4446
+ assert (("libev: loop to be embedded is not embeddable", backend & ev_embeddable_backends ()));
4447
+ ev_io_init (&w->io, embed_io_cb, backend_fd, EV_READ);
4448
+ }
4449
+
4450
+ EV_FREQUENT_CHECK;
4451
+
4452
+ ev_set_priority (&w->io, ev_priority (w));
4453
+ ev_io_start (EV_A_ &w->io);
4454
+
4455
+ ev_prepare_init (&w->prepare, embed_prepare_cb);
4456
+ ev_set_priority (&w->prepare, EV_MINPRI);
4457
+ ev_prepare_start (EV_A_ &w->prepare);
4458
+
4459
+ ev_fork_init (&w->fork, embed_fork_cb);
4460
+ ev_fork_start (EV_A_ &w->fork);
4461
+
4462
+ /*ev_idle_init (&w->idle, e,bed_idle_cb);*/
4463
+
4464
+ ev_start (EV_A_ (W)w, 1);
4465
+
4466
+ EV_FREQUENT_CHECK;
4467
+ }
4468
+
4469
+ void
4470
+ ev_embed_stop (EV_P_ ev_embed *w) EV_THROW
4471
+ {
4472
+ clear_pending (EV_A_ (W)w);
4473
+ if (expect_false (!ev_is_active (w)))
4474
+ return;
4475
+
4476
+ EV_FREQUENT_CHECK;
4477
+
4478
+ ev_io_stop (EV_A_ &w->io);
4479
+ ev_prepare_stop (EV_A_ &w->prepare);
4480
+ ev_fork_stop (EV_A_ &w->fork);
4481
+
4482
+ ev_stop (EV_A_ (W)w);
4483
+
4484
+ EV_FREQUENT_CHECK;
4485
+ }
4486
+ #endif
4487
+
4488
+ #if EV_FORK_ENABLE
4489
+ void
4490
+ ev_fork_start (EV_P_ ev_fork *w) EV_THROW
4491
+ {
4492
+ if (expect_false (ev_is_active (w)))
4493
+ return;
4494
+
4495
+ EV_FREQUENT_CHECK;
4496
+
4497
+ ev_start (EV_A_ (W)w, ++forkcnt);
4498
+ array_needsize (ev_fork *, forks, forkmax, forkcnt, EMPTY2);
4499
+ forks [forkcnt - 1] = w;
4500
+
4501
+ EV_FREQUENT_CHECK;
4502
+ }
4503
+
4504
+ void
4505
+ ev_fork_stop (EV_P_ ev_fork *w) EV_THROW
4506
+ {
4507
+ clear_pending (EV_A_ (W)w);
4508
+ if (expect_false (!ev_is_active (w)))
4509
+ return;
4510
+
4511
+ EV_FREQUENT_CHECK;
4512
+
4513
+ {
4514
+ int active = ev_active (w);
4515
+
4516
+ forks [active - 1] = forks [--forkcnt];
4517
+ ev_active (forks [active - 1]) = active;
4518
+ }
4519
+
4520
+ ev_stop (EV_A_ (W)w);
4521
+
4522
+ EV_FREQUENT_CHECK;
4523
+ }
4524
+ #endif
4525
+
4526
+ #if EV_CLEANUP_ENABLE
4527
+ void
4528
+ ev_cleanup_start (EV_P_ ev_cleanup *w) EV_THROW
4529
+ {
4530
+ if (expect_false (ev_is_active (w)))
4531
+ return;
4532
+
4533
+ EV_FREQUENT_CHECK;
4534
+
4535
+ ev_start (EV_A_ (W)w, ++cleanupcnt);
4536
+ array_needsize (ev_cleanup *, cleanups, cleanupmax, cleanupcnt, EMPTY2);
4537
+ cleanups [cleanupcnt - 1] = w;
4538
+
4539
+ /* cleanup watchers should never keep a refcount on the loop */
4540
+ ev_unref (EV_A);
4541
+ EV_FREQUENT_CHECK;
4542
+ }
4543
+
4544
+ void
4545
+ ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_THROW
4546
+ {
4547
+ clear_pending (EV_A_ (W)w);
4548
+ if (expect_false (!ev_is_active (w)))
4549
+ return;
4550
+
4551
+ EV_FREQUENT_CHECK;
4552
+ ev_ref (EV_A);
4553
+
4554
+ {
4555
+ int active = ev_active (w);
4556
+
4557
+ cleanups [active - 1] = cleanups [--cleanupcnt];
4558
+ ev_active (cleanups [active - 1]) = active;
4559
+ }
4560
+
4561
+ ev_stop (EV_A_ (W)w);
4562
+
4563
+ EV_FREQUENT_CHECK;
4564
+ }
4565
+ #endif
4566
+
4567
+ #if EV_ASYNC_ENABLE
4568
+ void
4569
+ ev_async_start (EV_P_ ev_async *w) EV_THROW
4570
+ {
4571
+ if (expect_false (ev_is_active (w)))
4572
+ return;
4573
+
4574
+ w->sent = 0;
4575
+
4576
+ evpipe_init (EV_A);
4577
+
4578
+ EV_FREQUENT_CHECK;
4579
+
4580
+ ev_start (EV_A_ (W)w, ++asynccnt);
4581
+ array_needsize (ev_async *, asyncs, asyncmax, asynccnt, EMPTY2);
4582
+ asyncs [asynccnt - 1] = w;
4583
+
4584
+ EV_FREQUENT_CHECK;
4585
+ }
4586
+
4587
+ void
4588
+ ev_async_stop (EV_P_ ev_async *w) EV_THROW
4589
+ {
4590
+ clear_pending (EV_A_ (W)w);
4591
+ if (expect_false (!ev_is_active (w)))
4592
+ return;
4593
+
4594
+ EV_FREQUENT_CHECK;
4595
+
4596
+ {
4597
+ int active = ev_active (w);
4598
+
4599
+ asyncs [active - 1] = asyncs [--asynccnt];
4600
+ ev_active (asyncs [active - 1]) = active;
4601
+ }
4602
+
4603
+ ev_stop (EV_A_ (W)w);
4604
+
4605
+ EV_FREQUENT_CHECK;
4606
+ }
4607
+
4608
+ void
4609
+ ev_async_send (EV_P_ ev_async *w) EV_THROW
4610
+ {
4611
+ w->sent = 1;
4612
+ evpipe_write (EV_A_ &async_pending);
4613
+ }
4614
+ #endif
4615
+
4616
+ /*****************************************************************************/
4617
+
4618
+ struct ev_once
4619
+ {
4620
+ ev_io io;
4621
+ ev_timer to;
4622
+ void (*cb)(int revents, void *arg);
4623
+ void *arg;
4624
+ };
4625
+
4626
+ static void
4627
+ once_cb (EV_P_ struct ev_once *once, int revents)
4628
+ {
4629
+ void (*cb)(int revents, void *arg) = once->cb;
4630
+ void *arg = once->arg;
4631
+
4632
+ ev_io_stop (EV_A_ &once->io);
4633
+ ev_timer_stop (EV_A_ &once->to);
4634
+ ev_free (once);
4635
+
4636
+ cb (revents, arg);
4637
+ }
4638
+
4639
+ static void
4640
+ once_cb_io (EV_P_ ev_io *w, int revents)
4641
+ {
4642
+ struct ev_once *once = (struct ev_once *)(((char *)w) - offsetof (struct ev_once, io));
4643
+
4644
+ once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->to));
4645
+ }
4646
+
4647
+ static void
4648
+ once_cb_to (EV_P_ ev_timer *w, int revents)
4649
+ {
4650
+ struct ev_once *once = (struct ev_once *)(((char *)w) - offsetof (struct ev_once, to));
4651
+
4652
+ once_cb (EV_A_ once, revents | ev_clear_pending (EV_A_ &once->io));
4653
+ }
4654
+
4655
+ void
4656
+ ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_THROW
4657
+ {
4658
+ struct ev_once *once = (struct ev_once *)ev_malloc (sizeof (struct ev_once));
4659
+
4660
+ if (expect_false (!once))
4661
+ {
4662
+ cb (EV_ERROR | EV_READ | EV_WRITE | EV_TIMER, arg);
4663
+ return;
4664
+ }
4665
+
4666
+ once->cb = cb;
4667
+ once->arg = arg;
4668
+
4669
+ ev_init (&once->io, once_cb_io);
4670
+ if (fd >= 0)
4671
+ {
4672
+ ev_io_set (&once->io, fd, events);
4673
+ ev_io_start (EV_A_ &once->io);
4674
+ }
4675
+
4676
+ ev_init (&once->to, once_cb_to);
4677
+ if (timeout >= 0.)
4678
+ {
4679
+ ev_timer_set (&once->to, timeout, 0.);
4680
+ ev_timer_start (EV_A_ &once->to);
4681
+ }
4682
+ }
4683
+
4684
+ /*****************************************************************************/
4685
+
4686
+ #if EV_WALK_ENABLE
4687
+ void ecb_cold
4688
+ ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_THROW
4689
+ {
4690
+ int i, j;
4691
+ ev_watcher_list *wl, *wn;
4692
+
4693
+ if (types & (EV_IO | EV_EMBED))
4694
+ for (i = 0; i < anfdmax; ++i)
4695
+ for (wl = anfds [i].head; wl; )
4696
+ {
4697
+ wn = wl->next;
4698
+
4699
+ #if EV_EMBED_ENABLE
4700
+ if (ev_cb ((ev_io *)wl) == embed_io_cb)
4701
+ {
4702
+ if (types & EV_EMBED)
4703
+ cb (EV_A_ EV_EMBED, ((char *)wl) - offsetof (struct ev_embed, io));
4704
+ }
4705
+ else
4706
+ #endif
4707
+ #if EV_USE_INOTIFY
4708
+ if (ev_cb ((ev_io *)wl) == infy_cb)
4709
+ ;
4710
+ else
4711
+ #endif
4712
+ if ((ev_io *)wl != &pipe_w)
4713
+ if (types & EV_IO)
4714
+ cb (EV_A_ EV_IO, wl);
4715
+
4716
+ wl = wn;
4717
+ }
4718
+
4719
+ if (types & (EV_TIMER | EV_STAT))
4720
+ for (i = timercnt + HEAP0; i-- > HEAP0; )
4721
+ #if EV_STAT_ENABLE
4722
+ /*TODO: timer is not always active*/
4723
+ if (ev_cb ((ev_timer *)ANHE_w (timers [i])) == stat_timer_cb)
4724
+ {
4725
+ if (types & EV_STAT)
4726
+ cb (EV_A_ EV_STAT, ((char *)ANHE_w (timers [i])) - offsetof (struct ev_stat, timer));
4727
+ }
4728
+ else
4729
+ #endif
4730
+ if (types & EV_TIMER)
4731
+ cb (EV_A_ EV_TIMER, ANHE_w (timers [i]));
4732
+
4733
+ #if EV_PERIODIC_ENABLE
4734
+ if (types & EV_PERIODIC)
4735
+ for (i = periodiccnt + HEAP0; i-- > HEAP0; )
4736
+ cb (EV_A_ EV_PERIODIC, ANHE_w (periodics [i]));
4737
+ #endif
4738
+
4739
+ #if EV_IDLE_ENABLE
4740
+ if (types & EV_IDLE)
4741
+ for (j = NUMPRI; j--; )
4742
+ for (i = idlecnt [j]; i--; )
4743
+ cb (EV_A_ EV_IDLE, idles [j][i]);
4744
+ #endif
4745
+
4746
+ #if EV_FORK_ENABLE
4747
+ if (types & EV_FORK)
4748
+ for (i = forkcnt; i--; )
4749
+ if (ev_cb (forks [i]) != embed_fork_cb)
4750
+ cb (EV_A_ EV_FORK, forks [i]);
4751
+ #endif
4752
+
4753
+ #if EV_ASYNC_ENABLE
4754
+ if (types & EV_ASYNC)
4755
+ for (i = asynccnt; i--; )
4756
+ cb (EV_A_ EV_ASYNC, asyncs [i]);
4757
+ #endif
4758
+
4759
+ #if EV_PREPARE_ENABLE
4760
+ if (types & EV_PREPARE)
4761
+ for (i = preparecnt; i--; )
4762
+ # if EV_EMBED_ENABLE
4763
+ if (ev_cb (prepares [i]) != embed_prepare_cb)
4764
+ # endif
4765
+ cb (EV_A_ EV_PREPARE, prepares [i]);
4766
+ #endif
4767
+
4768
+ #if EV_CHECK_ENABLE
4769
+ if (types & EV_CHECK)
4770
+ for (i = checkcnt; i--; )
4771
+ cb (EV_A_ EV_CHECK, checks [i]);
4772
+ #endif
4773
+
4774
+ #if EV_SIGNAL_ENABLE
4775
+ if (types & EV_SIGNAL)
4776
+ for (i = 0; i < EV_NSIG - 1; ++i)
4777
+ for (wl = signals [i].head; wl; )
4778
+ {
4779
+ wn = wl->next;
4780
+ cb (EV_A_ EV_SIGNAL, wl);
4781
+ wl = wn;
4782
+ }
4783
+ #endif
4784
+
4785
+ #if EV_CHILD_ENABLE
4786
+ if (types & EV_CHILD)
4787
+ for (i = (EV_PID_HASHSIZE); i--; )
4788
+ for (wl = childs [i]; wl; )
4789
+ {
4790
+ wn = wl->next;
4791
+ cb (EV_A_ EV_CHILD, wl);
4792
+ wl = wn;
4793
+ }
4794
+ #endif
4795
+ /* EV_STAT 0x00001000 /* stat data changed */
4796
+ /* EV_EMBED 0x00010000 /* embedded event loop needs sweep */
4797
+ }
4798
+ #endif
4799
+
4800
+ #if EV_MULTIPLICITY
4801
+ #include "ev_wrap.h"
4802
+ #endif
4803
+