cool.io 1.2.0-x86-mingw32
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.
- data/.gitignore +26 -0
- data/.rspec +3 -0
- data/.travis.yml +4 -0
- data/CHANGES.md +176 -0
- data/Gemfile +4 -0
- data/LICENSE +20 -0
- data/README.md +172 -0
- data/Rakefile +81 -0
- data/cool.io.gemspec +28 -0
- data/examples/dslified_echo_client.rb +34 -0
- data/examples/dslified_echo_server.rb +24 -0
- data/examples/echo_client.rb +38 -0
- data/examples/echo_server.rb +27 -0
- data/examples/google.rb +9 -0
- data/examples/httpclient.rb +38 -0
- data/ext/cool.io/.gitignore +5 -0
- data/ext/cool.io/cool.io.h +58 -0
- data/ext/cool.io/cool.io_ext.c +25 -0
- data/ext/cool.io/ev_wrap.h +8 -0
- data/ext/cool.io/extconf.rb +73 -0
- data/ext/cool.io/iowatcher.c +189 -0
- data/ext/cool.io/libev.c +8 -0
- data/ext/cool.io/loop.c +301 -0
- data/ext/cool.io/stat_watcher.c +269 -0
- data/ext/cool.io/timer_watcher.c +219 -0
- data/ext/cool.io/utils.c +122 -0
- data/ext/cool.io/watcher.c +264 -0
- data/ext/cool.io/watcher.h +71 -0
- data/ext/http11_client/.gitignore +5 -0
- data/ext/http11_client/LICENSE +31 -0
- data/ext/http11_client/ext_help.h +14 -0
- data/ext/http11_client/extconf.rb +6 -0
- data/ext/http11_client/http11_client.c +300 -0
- data/ext/http11_client/http11_parser.c +403 -0
- data/ext/http11_client/http11_parser.h +48 -0
- data/ext/http11_client/http11_parser.rl +173 -0
- data/ext/iobuffer/extconf.rb +9 -0
- data/ext/iobuffer/iobuffer.c +765 -0
- data/ext/libev/Changes +388 -0
- data/ext/libev/LICENSE +36 -0
- data/ext/libev/README +58 -0
- data/ext/libev/README.embed +3 -0
- data/ext/libev/ev.c +4803 -0
- data/ext/libev/ev.h +845 -0
- data/ext/libev/ev_epoll.c +279 -0
- data/ext/libev/ev_kqueue.c +214 -0
- data/ext/libev/ev_poll.c +148 -0
- data/ext/libev/ev_port.c +185 -0
- data/ext/libev/ev_select.c +314 -0
- data/ext/libev/ev_vars.h +203 -0
- data/ext/libev/ev_win32.c +163 -0
- data/ext/libev/ev_wrap.h +200 -0
- data/ext/libev/test_libev_win32.c +123 -0
- data/lib/.gitignore +2 -0
- data/lib/cool.io.rb +32 -0
- data/lib/cool.io/async_watcher.rb +43 -0
- data/lib/cool.io/custom_require.rb +9 -0
- data/lib/cool.io/dns_resolver.rb +225 -0
- data/lib/cool.io/dsl.rb +135 -0
- data/lib/cool.io/eventmachine.rb +234 -0
- data/lib/cool.io/http_client.rb +427 -0
- data/lib/cool.io/io.rb +174 -0
- data/lib/cool.io/iowatcher.rb +17 -0
- data/lib/cool.io/listener.rb +93 -0
- data/lib/cool.io/loop.rb +130 -0
- data/lib/cool.io/meta.rb +49 -0
- data/lib/cool.io/server.rb +74 -0
- data/lib/cool.io/socket.rb +230 -0
- data/lib/cool.io/timer_watcher.rb +17 -0
- data/lib/cool.io/version.rb +5 -0
- data/lib/coolio.rb +2 -0
- data/spec/async_watcher_spec.rb +57 -0
- data/spec/dns_spec.rb +39 -0
- data/spec/spec_helper.rb +12 -0
- data/spec/stat_watcher_spec.rb +77 -0
- data/spec/timer_watcher_spec.rb +55 -0
- data/spec/unix_listener_spec.rb +25 -0
- data/spec/unix_server_spec.rb +25 -0
- metadata +200 -0
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
|
+
|