ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.c
Revision: 1.537
Committed: Sun May 14 19:02:31 2023 UTC (12 months, 1 week ago) by sf-exg
Content type: text/plain
Branch: MAIN
CVS Tags: HEAD
Changes since 1.536: +2 -2 lines
Log Message:
Fix typos.

Patch by Al Chu11.

File Contents

# User Rev Content
1 root 1.17 /*
2 root 1.36 * libev event processing core, watcher management
3     *
4 root 1.531 * Copyright (c) 2007-2020 Marc Alexander Lehmann <libev@schmorp.de>
5 root 1.17 * All rights reserved.
6     *
7 root 1.199 * Redistribution and use in source and binary forms, with or without modifica-
8     * tion, are permitted provided that the following conditions are met:
9 root 1.372 *
10 root 1.199 * 1. Redistributions of source code must retain the above copyright notice,
11     * this list of conditions and the following disclaimer.
12 root 1.372 *
13 root 1.199 * 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 root 1.372 *
17 root 1.199 * 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 root 1.17 *
28 root 1.199 * 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 root 1.17 */
39 root 1.87
40 root 1.536 #pragma clang diagnostic ignored "-Wunused-value"
41     #pragma clang diagnostic ignored "-Wcomment"
42     #pragma clang diagnostic ignored "-Wextern-initializer"
43    
44 root 1.220 /* this big block deduces configuration from config.h */
45 root 1.59 #ifndef EV_STANDALONE
46 root 1.133 # ifdef EV_CONFIG_H
47     # include EV_CONFIG_H
48     # else
49     # include "config.h"
50     # endif
51 root 1.60
52 root 1.469 # if HAVE_FLOOR
53     # ifndef EV_USE_FLOOR
54     # define EV_USE_FLOOR 1
55     # endif
56 root 1.373 # endif
57    
58 root 1.274 # if HAVE_CLOCK_SYSCALL
59     # ifndef EV_USE_CLOCK_SYSCALL
60     # define EV_USE_CLOCK_SYSCALL 1
61     # ifndef EV_USE_REALTIME
62     # define EV_USE_REALTIME 0
63     # endif
64     # ifndef EV_USE_MONOTONIC
65     # define EV_USE_MONOTONIC 1
66     # endif
67     # endif
68 root 1.416 # elif !defined EV_USE_CLOCK_SYSCALL
69 root 1.290 # define EV_USE_CLOCK_SYSCALL 0
70 root 1.274 # endif
71    
72 root 1.60 # if HAVE_CLOCK_GETTIME
73 root 1.97 # ifndef EV_USE_MONOTONIC
74     # define EV_USE_MONOTONIC 1
75     # endif
76     # ifndef EV_USE_REALTIME
77 root 1.279 # define EV_USE_REALTIME 0
78 root 1.97 # endif
79 root 1.126 # else
80     # ifndef EV_USE_MONOTONIC
81     # define EV_USE_MONOTONIC 0
82     # endif
83     # ifndef EV_USE_REALTIME
84     # define EV_USE_REALTIME 0
85     # endif
86 root 1.60 # endif
87    
88 root 1.343 # if HAVE_NANOSLEEP
89     # ifndef EV_USE_NANOSLEEP
90     # define EV_USE_NANOSLEEP EV_FEATURE_OS
91     # endif
92     # else
93     # undef EV_USE_NANOSLEEP
94 root 1.193 # define EV_USE_NANOSLEEP 0
95     # endif
96    
97 root 1.343 # if HAVE_SELECT && HAVE_SYS_SELECT_H
98     # ifndef EV_USE_SELECT
99 root 1.339 # define EV_USE_SELECT EV_FEATURE_BACKENDS
100 root 1.127 # endif
101 root 1.343 # else
102     # undef EV_USE_SELECT
103     # define EV_USE_SELECT 0
104 root 1.60 # endif
105    
106 root 1.343 # if HAVE_POLL && HAVE_POLL_H
107     # ifndef EV_USE_POLL
108 root 1.339 # define EV_USE_POLL EV_FEATURE_BACKENDS
109 root 1.127 # endif
110 root 1.343 # else
111     # undef EV_USE_POLL
112     # define EV_USE_POLL 0
113 root 1.60 # endif
114 root 1.127
115 root 1.343 # if HAVE_EPOLL_CTL && HAVE_SYS_EPOLL_H
116     # ifndef EV_USE_EPOLL
117 root 1.339 # define EV_USE_EPOLL EV_FEATURE_BACKENDS
118 root 1.127 # endif
119 root 1.343 # else
120     # undef EV_USE_EPOLL
121     # define EV_USE_EPOLL 0
122 root 1.60 # endif
123 root 1.127
124 root 1.491 # if HAVE_LINUX_AIO_ABI_H
125     # ifndef EV_USE_LINUXAIO
126 root 1.518 # define EV_USE_LINUXAIO 0 /* was: EV_FEATURE_BACKENDS, always off by default */
127 root 1.491 # endif
128     # else
129     # undef EV_USE_LINUXAIO
130     # define EV_USE_LINUXAIO 0
131     # endif
132    
133 root 1.511 # if HAVE_LINUX_FS_H && HAVE_SYS_TIMERFD_H && HAVE_KERNEL_RWF_T
134     # ifndef EV_USE_IOURING
135     # define EV_USE_IOURING EV_FEATURE_BACKENDS
136     # endif
137     # else
138     # undef EV_USE_IOURING
139     # define EV_USE_IOURING 0
140     # endif
141    
142 root 1.343 # if HAVE_KQUEUE && HAVE_SYS_EVENT_H
143     # ifndef EV_USE_KQUEUE
144 root 1.339 # define EV_USE_KQUEUE EV_FEATURE_BACKENDS
145 root 1.127 # endif
146 root 1.343 # else
147     # undef EV_USE_KQUEUE
148     # define EV_USE_KQUEUE 0
149 root 1.60 # endif
150 root 1.127
151 root 1.343 # if HAVE_PORT_H && HAVE_PORT_CREATE
152     # ifndef EV_USE_PORT
153 root 1.339 # define EV_USE_PORT EV_FEATURE_BACKENDS
154 root 1.127 # endif
155 root 1.343 # else
156     # undef EV_USE_PORT
157     # define EV_USE_PORT 0
158 root 1.118 # endif
159    
160 root 1.343 # if HAVE_INOTIFY_INIT && HAVE_SYS_INOTIFY_H
161     # ifndef EV_USE_INOTIFY
162 root 1.339 # define EV_USE_INOTIFY EV_FEATURE_OS
163 root 1.152 # endif
164 root 1.343 # else
165     # undef EV_USE_INOTIFY
166     # define EV_USE_INOTIFY 0
167 root 1.152 # endif
168    
169 root 1.343 # if HAVE_SIGNALFD && HAVE_SYS_SIGNALFD_H
170     # ifndef EV_USE_SIGNALFD
171 root 1.339 # define EV_USE_SIGNALFD EV_FEATURE_OS
172 root 1.303 # endif
173 root 1.343 # else
174     # undef EV_USE_SIGNALFD
175     # define EV_USE_SIGNALFD 0
176 root 1.303 # endif
177    
178 root 1.343 # if HAVE_EVENTFD
179     # ifndef EV_USE_EVENTFD
180 root 1.339 # define EV_USE_EVENTFD EV_FEATURE_OS
181 root 1.220 # endif
182 root 1.343 # else
183     # undef EV_USE_EVENTFD
184     # define EV_USE_EVENTFD 0
185 root 1.220 # endif
186 root 1.511
187 root 1.515 # if HAVE_SYS_TIMERFD_H
188     # ifndef EV_USE_TIMERFD
189     # define EV_USE_TIMERFD EV_FEATURE_OS
190     # endif
191     # else
192     # undef EV_USE_TIMERFD
193     # define EV_USE_TIMERFD 0
194     # endif
195    
196 root 1.29 #endif
197 root 1.17
198 root 1.483 /* OS X, in its infinite idiocy, actually HARDCODES
199     * a limit of 1024 into their select. Where people have brains,
200     * OS X engineers apparently have a vacuum. Or maybe they were
201     * ordered to have a vacuum, or they do anything for money.
202     * This might help. Or not.
203     * Note that this must be defined early, as other include files
204     * will rely on this define as well.
205     */
206     #define _DARWIN_UNLIMITED_SELECT 1
207    
208 root 1.1 #include <stdlib.h>
209 root 1.319 #include <string.h>
210 root 1.7 #include <fcntl.h>
211 root 1.16 #include <stddef.h>
212 root 1.1
213     #include <stdio.h>
214    
215 root 1.4 #include <assert.h>
216 root 1.1 #include <errno.h>
217 root 1.22 #include <sys/types.h>
218 root 1.71 #include <time.h>
219 root 1.326 #include <limits.h>
220 root 1.71
221 root 1.72 #include <signal.h>
222 root 1.71
223 root 1.152 #ifdef EV_H
224     # include EV_H
225     #else
226     # include "ev.h"
227     #endif
228    
229 root 1.410 #if EV_NO_THREADS
230     # undef EV_NO_SMP
231     # define EV_NO_SMP 1
232     # undef ECB_NO_THREADS
233     # define ECB_NO_THREADS 1
234     #endif
235     #if EV_NO_SMP
236     # undef EV_NO_SMP
237     # define ECB_NO_SMP 1
238     #endif
239    
240 root 1.103 #ifndef _WIN32
241 root 1.71 # include <sys/time.h>
242 root 1.45 # include <sys/wait.h>
243 root 1.140 # include <unistd.h>
244 root 1.103 #else
245 root 1.256 # include <io.h>
246 root 1.103 # define WIN32_LEAN_AND_MEAN
247 root 1.431 # include <winsock2.h>
248 root 1.103 # include <windows.h>
249     # ifndef EV_SELECT_IS_WINSOCKET
250     # define EV_SELECT_IS_WINSOCKET 1
251     # endif
252 root 1.331 # undef EV_AVOID_STDIO
253 root 1.45 #endif
254 root 1.103
255 root 1.220 /* this block tries to deduce configuration from header-defined symbols and defaults */
256 root 1.40
257 root 1.305 /* try to deduce the maximum number of signals on this platform */
258 root 1.416 #if defined EV_NSIG
259 root 1.305 /* use what's provided */
260 root 1.416 #elif defined NSIG
261 root 1.305 # define EV_NSIG (NSIG)
262 root 1.416 #elif defined _NSIG
263 root 1.305 # define EV_NSIG (_NSIG)
264 root 1.416 #elif defined SIGMAX
265 root 1.305 # define EV_NSIG (SIGMAX+1)
266 root 1.416 #elif defined SIG_MAX
267 root 1.305 # define EV_NSIG (SIG_MAX+1)
268 root 1.416 #elif defined _SIG_MAX
269 root 1.305 # define EV_NSIG (_SIG_MAX+1)
270 root 1.416 #elif defined MAXSIG
271 root 1.305 # define EV_NSIG (MAXSIG+1)
272 root 1.416 #elif defined MAX_SIG
273 root 1.305 # define EV_NSIG (MAX_SIG+1)
274 root 1.416 #elif defined SIGARRAYSIZE
275 root 1.336 # define EV_NSIG (SIGARRAYSIZE) /* Assume ary[SIGARRAYSIZE] */
276 root 1.416 #elif defined _sys_nsig
277 root 1.305 # define EV_NSIG (_sys_nsig) /* Solaris 2.5 */
278     #else
279 root 1.459 # define EV_NSIG (8 * sizeof (sigset_t) + 1)
280 root 1.305 #endif
281    
282 root 1.373 #ifndef EV_USE_FLOOR
283     # define EV_USE_FLOOR 0
284     #endif
285    
286 root 1.274 #ifndef EV_USE_CLOCK_SYSCALL
287 root 1.460 # if __linux && __GLIBC__ == 2 && __GLIBC_MINOR__ < 17
288 root 1.338 # define EV_USE_CLOCK_SYSCALL EV_FEATURE_OS
289 root 1.274 # else
290     # define EV_USE_CLOCK_SYSCALL 0
291     # endif
292     #endif
293    
294 root 1.470 #if !(_POSIX_TIMERS > 0)
295     # ifndef EV_USE_MONOTONIC
296     # define EV_USE_MONOTONIC 0
297     # endif
298     # ifndef EV_USE_REALTIME
299     # define EV_USE_REALTIME 0
300     # endif
301     #endif
302    
303 root 1.29 #ifndef EV_USE_MONOTONIC
304 root 1.416 # if defined _POSIX_MONOTONIC_CLOCK && _POSIX_MONOTONIC_CLOCK >= 0
305 root 1.338 # define EV_USE_MONOTONIC EV_FEATURE_OS
306 root 1.253 # else
307     # define EV_USE_MONOTONIC 0
308     # endif
309 root 1.37 #endif
310    
311 root 1.118 #ifndef EV_USE_REALTIME
312 root 1.279 # define EV_USE_REALTIME !EV_USE_CLOCK_SYSCALL
313 root 1.118 #endif
314    
315 root 1.193 #ifndef EV_USE_NANOSLEEP
316 root 1.253 # if _POSIX_C_SOURCE >= 199309L
317 root 1.338 # define EV_USE_NANOSLEEP EV_FEATURE_OS
318 root 1.253 # else
319     # define EV_USE_NANOSLEEP 0
320     # endif
321 root 1.193 #endif
322    
323 root 1.29 #ifndef EV_USE_SELECT
324 root 1.338 # define EV_USE_SELECT EV_FEATURE_BACKENDS
325 root 1.10 #endif
326    
327 root 1.59 #ifndef EV_USE_POLL
328 root 1.104 # ifdef _WIN32
329     # define EV_USE_POLL 0
330     # else
331 root 1.338 # define EV_USE_POLL EV_FEATURE_BACKENDS
332 root 1.104 # endif
333 root 1.41 #endif
334    
335 root 1.29 #ifndef EV_USE_EPOLL
336 root 1.220 # if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
337 root 1.338 # define EV_USE_EPOLL EV_FEATURE_BACKENDS
338 root 1.220 # else
339     # define EV_USE_EPOLL 0
340     # endif
341 root 1.10 #endif
342    
343 root 1.44 #ifndef EV_USE_KQUEUE
344     # define EV_USE_KQUEUE 0
345     #endif
346    
347 root 1.118 #ifndef EV_USE_PORT
348     # define EV_USE_PORT 0
349 root 1.40 #endif
350    
351 root 1.490 #ifndef EV_USE_LINUXAIO
352 root 1.492 # if __linux /* libev currently assumes linux/aio_abi.h is always available on linux */
353 root 1.518 # define EV_USE_LINUXAIO 0 /* was: 1, always off by default */
354 root 1.492 # else
355     # define EV_USE_LINUXAIO 0
356     # endif
357 root 1.490 #endif
358    
359 root 1.501 #ifndef EV_USE_IOURING
360 root 1.511 # if __linux /* later checks might disable again */
361     # define EV_USE_IOURING 1
362 root 1.501 # else
363     # define EV_USE_IOURING 0
364     # endif
365     #endif
366    
367 root 1.152 #ifndef EV_USE_INOTIFY
368 root 1.220 # if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 4))
369 root 1.338 # define EV_USE_INOTIFY EV_FEATURE_OS
370 root 1.220 # else
371     # define EV_USE_INOTIFY 0
372     # endif
373 root 1.152 #endif
374    
375 root 1.149 #ifndef EV_PID_HASHSIZE
376 root 1.338 # define EV_PID_HASHSIZE EV_FEATURE_DATA ? 16 : 1
377 root 1.149 #endif
378    
379 root 1.152 #ifndef EV_INOTIFY_HASHSIZE
380 root 1.338 # define EV_INOTIFY_HASHSIZE EV_FEATURE_DATA ? 16 : 1
381 root 1.152 #endif
382    
383 root 1.220 #ifndef EV_USE_EVENTFD
384     # if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
385 root 1.338 # define EV_USE_EVENTFD EV_FEATURE_OS
386 root 1.220 # else
387     # define EV_USE_EVENTFD 0
388     # endif
389     #endif
390    
391 root 1.303 #ifndef EV_USE_SIGNALFD
392 root 1.314 # if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 7))
393 root 1.338 # define EV_USE_SIGNALFD EV_FEATURE_OS
394 root 1.303 # else
395     # define EV_USE_SIGNALFD 0
396     # endif
397     #endif
398    
399 root 1.515 #ifndef EV_USE_TIMERFD
400     # if __linux && (__GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 8))
401     # define EV_USE_TIMERFD EV_FEATURE_OS
402     # else
403     # define EV_USE_TIMERFD 0
404     # endif
405     #endif
406    
407 root 1.249 #if 0 /* debugging */
408 root 1.250 # define EV_VERIFY 3
409 root 1.249 # define EV_USE_4HEAP 1
410     # define EV_HEAP_CACHE_AT 1
411     #endif
412    
413 root 1.250 #ifndef EV_VERIFY
414 root 1.338 # define EV_VERIFY (EV_FEATURE_API ? 1 : 0)
415 root 1.250 #endif
416    
417 root 1.243 #ifndef EV_USE_4HEAP
418 root 1.338 # define EV_USE_4HEAP EV_FEATURE_DATA
419 root 1.243 #endif
420    
421     #ifndef EV_HEAP_CACHE_AT
422 root 1.338 # define EV_HEAP_CACHE_AT EV_FEATURE_DATA
423 root 1.243 #endif
424    
425 root 1.481 #ifdef __ANDROID__
426 root 1.452 /* supposedly, android doesn't typedef fd_mask */
427     # undef EV_USE_SELECT
428     # define EV_USE_SELECT 0
429     /* supposedly, we need to include syscall.h, not sys/syscall.h, so just disable */
430     # undef EV_USE_CLOCK_SYSCALL
431     # define EV_USE_CLOCK_SYSCALL 0
432     #endif
433    
434     /* aix's poll.h seems to cause lots of trouble */
435     #ifdef _AIX
436     /* AIX has a completely broken poll.h header */
437     # undef EV_USE_POLL
438     # define EV_USE_POLL 0
439     #endif
440    
441 root 1.291 /* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */
442     /* which makes programs even slower. might work on other unices, too. */
443     #if EV_USE_CLOCK_SYSCALL
444 root 1.423 # include <sys/syscall.h>
445 root 1.291 # ifdef SYS_clock_gettime
446     # define clock_gettime(id, ts) syscall (SYS_clock_gettime, (id), (ts))
447     # undef EV_USE_MONOTONIC
448     # define EV_USE_MONOTONIC 1
449 root 1.501 # define EV_NEED_SYSCALL 1
450 root 1.291 # else
451     # undef EV_USE_CLOCK_SYSCALL
452     # define EV_USE_CLOCK_SYSCALL 0
453     # endif
454     #endif
455    
456 root 1.220 /* this block fixes any misconfiguration where we know we run into trouble otherwise */
457 root 1.40
458     #ifndef CLOCK_MONOTONIC
459     # undef EV_USE_MONOTONIC
460     # define EV_USE_MONOTONIC 0
461     #endif
462    
463 root 1.31 #ifndef CLOCK_REALTIME
464 root 1.40 # undef EV_USE_REALTIME
465 root 1.31 # define EV_USE_REALTIME 0
466     #endif
467 root 1.40
468 root 1.152 #if !EV_STAT_ENABLE
469 root 1.185 # undef EV_USE_INOTIFY
470 root 1.152 # define EV_USE_INOTIFY 0
471     #endif
472    
473 root 1.511 #if __linux && EV_USE_IOURING
474 root 1.512 # include <linux/version.h>
475     # if LINUX_VERSION_CODE < KERNEL_VERSION(4,14,0)
476 root 1.511 # undef EV_USE_IOURING
477     # define EV_USE_IOURING 0
478     # endif
479     #endif
480    
481 root 1.193 #if !EV_USE_NANOSLEEP
482 root 1.370 /* hp-ux has it in sys/time.h, which we unconditionally include above */
483 root 1.416 # if !defined _WIN32 && !defined __hpux
484 root 1.193 # include <sys/select.h>
485     # endif
486     #endif
487    
488 root 1.491 #if EV_USE_LINUXAIO
489     # include <sys/syscall.h>
490 root 1.502 # if SYS_io_getevents && EV_USE_EPOLL /* linuxaio backend requires epoll backend */
491     # define EV_NEED_SYSCALL 1
492     # else
493 root 1.491 # undef EV_USE_LINUXAIO
494     # define EV_USE_LINUXAIO 0
495 root 1.501 # endif
496     #endif
497    
498     #if EV_USE_IOURING
499     # include <sys/syscall.h>
500 root 1.533 # if !SYS_io_uring_register && __linux && !__alpha
501     # define SYS_io_uring_setup 425
502     # define SYS_io_uring_enter 426
503     # define SYS_io_uring_register 427
504 root 1.501 # endif
505 root 1.502 # if SYS_io_uring_setup && EV_USE_EPOLL /* iouring backend requires epoll backend */
506 root 1.501 # define EV_NEED_SYSCALL 1
507     # else
508     # undef EV_USE_IOURING
509     # define EV_USE_IOURING 0
510 root 1.491 # endif
511     #endif
512    
513 root 1.152 #if EV_USE_INOTIFY
514 root 1.273 # include <sys/statfs.h>
515 root 1.152 # include <sys/inotify.h>
516 root 1.263 /* some very old inotify.h headers don't have IN_DONT_FOLLOW */
517     # ifndef IN_DONT_FOLLOW
518     # undef EV_USE_INOTIFY
519     # define EV_USE_INOTIFY 0
520     # endif
521 root 1.152 #endif
522    
523 root 1.220 #if EV_USE_EVENTFD
524 root 1.515 /* our minimum requirement is glibc 2.7 which has the stub, but not the full header */
525 root 1.221 # include <stdint.h>
526 root 1.303 # ifndef EFD_NONBLOCK
527     # define EFD_NONBLOCK O_NONBLOCK
528     # endif
529     # ifndef EFD_CLOEXEC
530 root 1.311 # ifdef O_CLOEXEC
531     # define EFD_CLOEXEC O_CLOEXEC
532     # else
533     # define EFD_CLOEXEC 02000000
534     # endif
535 root 1.303 # endif
536 root 1.354 EV_CPP(extern "C") int (eventfd) (unsigned int initval, int flags);
537 root 1.220 #endif
538    
539 root 1.303 #if EV_USE_SIGNALFD
540 root 1.515 /* our minimum requirement is glibc 2.7 which has the stub, but not the full header */
541 root 1.314 # include <stdint.h>
542     # ifndef SFD_NONBLOCK
543     # define SFD_NONBLOCK O_NONBLOCK
544     # endif
545     # ifndef SFD_CLOEXEC
546     # ifdef O_CLOEXEC
547     # define SFD_CLOEXEC O_CLOEXEC
548     # else
549     # define SFD_CLOEXEC 02000000
550     # endif
551     # endif
552 root 1.515 EV_CPP (extern "C") int (signalfd) (int fd, const sigset_t *mask, int flags);
553 root 1.314
554     struct signalfd_siginfo
555     {
556     uint32_t ssi_signo;
557     char pad[128 - sizeof (uint32_t)];
558     };
559 root 1.303 #endif
560    
561 root 1.515 /* for timerfd, libev core requires TFD_TIMER_CANCEL_ON_SET &c */
562     #if EV_USE_TIMERFD
563     # include <sys/timerfd.h>
564     /* timerfd is only used for periodics */
565     # if !(defined (TFD_TIMER_CANCEL_ON_SET) && defined (TFD_CLOEXEC) && defined (TFD_NONBLOCK)) || !EV_PERIODIC_ENABLE
566     # undef EV_USE_TIMERFD
567     # define EV_USE_TIMERFD 0
568     # endif
569     #endif
570    
571 root 1.501 /*****************************************************************************/
572    
573 root 1.250 #if EV_VERIFY >= 3
574 root 1.340 # define EV_FREQUENT_CHECK ev_verify (EV_A)
575 root 1.248 #else
576     # define EV_FREQUENT_CHECK do { } while (0)
577     #endif
578    
579 root 1.176 /*
580 root 1.373 * This is used to work around floating point rounding problems.
581 root 1.177 * This value is good at least till the year 4000.
582 root 1.176 */
583 root 1.373 #define MIN_INTERVAL 0.0001220703125 /* 1/2**13, good till 4000 */
584     /*#define MIN_INTERVAL 0.00000095367431640625 /* 1/2**20, good till 2200 */
585 root 1.176
586 root 1.502 #define MIN_TIMEJUMP 1. /* minimum timejump that gets detected (if monotonic clock available) */
587     #define MAX_BLOCKTIME 59.743 /* never wait longer than this time (to detect time jumps) */
588 root 1.523 #define MAX_BLOCKTIME2 1500001.07 /* same, but when timerfd is used to detect jumps, also safe delay to not overflow */
589 root 1.502
590 root 1.505 /* find a portable timestamp that is "always" in the future but fits into time_t.
591 root 1.502 * this is quite hard, and we are mostly guessing - we handle 32 bit signed/unsigned time_t,
592 root 1.505 * and sizes larger than 32 bit, and maybe the unlikely floating point time_t */
593 root 1.502 #define EV_TSTAMP_HUGE \
594     (sizeof (time_t) >= 8 ? 10000000000000. \
595     : 0 < (time_t)4294967295 ? 4294967295. \
596     : 2147483647.) \
597 root 1.1
598 root 1.509 #ifndef EV_TS_CONST
599     # define EV_TS_CONST(nv) nv
600     # define EV_TS_TO_MSEC(a) a * 1e3 + 0.9999
601     # define EV_TS_FROM_USEC(us) us * 1e-6
602     # define EV_TV_SET(tv,t) do { tv.tv_sec = (long)t; tv.tv_usec = (long)((t - tv.tv_sec) * 1e6); } while (0)
603     # define EV_TS_SET(ts,t) do { ts.tv_sec = (long)t; ts.tv_nsec = (long)((t - ts.tv_sec) * 1e9); } while (0)
604     # define EV_TV_GET(tv) ((tv).tv_sec + (tv).tv_usec * 1e-6)
605     # define EV_TS_GET(ts) ((ts).tv_sec + (ts).tv_nsec * 1e-9)
606     #endif
607 root 1.347
608 root 1.391 /* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */
609     /* ECB.H BEGIN */
610     /*
611     * libecb - http://software.schmorp.de/pkg/libecb
612     *
613 root 1.526 * Copyright (©) 2009-2015,2018-2020 Marc Alexander Lehmann <libecb@schmorp.de>
614 root 1.391 * Copyright (©) 2011 Emanuele Giaquinta
615     * All rights reserved.
616     *
617     * Redistribution and use in source and binary forms, with or without modifica-
618     * tion, are permitted provided that the following conditions are met:
619     *
620     * 1. Redistributions of source code must retain the above copyright notice,
621     * this list of conditions and the following disclaimer.
622     *
623     * 2. Redistributions in binary form must reproduce the above copyright
624     * notice, this list of conditions and the following disclaimer in the
625     * documentation and/or other materials provided with the distribution.
626     *
627     * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
628     * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
629     * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
630     * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
631     * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
632     * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
633     * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
634     * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
635     * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
636     * OF THE POSSIBILITY OF SUCH DAMAGE.
637 root 1.467 *
638     * Alternatively, the contents of this file may be used under the terms of
639     * the GNU General Public License ("GPL") version 2 or any later version,
640     * in which case the provisions of the GPL are applicable instead of
641     * the above. If you wish to allow the use of your version of this file
642     * only under the terms of the GPL and not to allow others to use your
643     * version of this file under the BSD license, indicate your decision
644     * by deleting the provisions above and replace them with the notice
645     * and other provisions required by the GPL. If you do not delete the
646     * provisions above, a recipient may use your version of this file under
647     * either the BSD or the GPL.
648 root 1.391 */
649    
650     #ifndef ECB_H
651     #define ECB_H
652    
653 root 1.437 /* 16 bits major, 16 bits minor */
654 root 1.523 #define ECB_VERSION 0x00010008
655    
656     #include <string.h> /* for memcpy */
657 root 1.437
658 root 1.528 #if defined (_WIN32) && !defined (__MINGW32__)
659 root 1.391 typedef signed char int8_t;
660     typedef unsigned char uint8_t;
661 root 1.523 typedef signed char int_fast8_t;
662     typedef unsigned char uint_fast8_t;
663 root 1.391 typedef signed short int16_t;
664     typedef unsigned short uint16_t;
665 root 1.523 typedef signed int int_fast16_t;
666     typedef unsigned int uint_fast16_t;
667 root 1.391 typedef signed int int32_t;
668     typedef unsigned int uint32_t;
669 root 1.523 typedef signed int int_fast32_t;
670     typedef unsigned int uint_fast32_t;
671 root 1.391 #if __GNUC__
672     typedef signed long long int64_t;
673     typedef unsigned long long uint64_t;
674     #else /* _MSC_VER || __BORLANDC__ */
675     typedef signed __int64 int64_t;
676     typedef unsigned __int64 uint64_t;
677     #endif
678 root 1.523 typedef int64_t int_fast64_t;
679     typedef uint64_t uint_fast64_t;
680 root 1.437 #ifdef _WIN64
681     #define ECB_PTRSIZE 8
682     typedef uint64_t uintptr_t;
683     typedef int64_t intptr_t;
684     #else
685     #define ECB_PTRSIZE 4
686     typedef uint32_t uintptr_t;
687     typedef int32_t intptr_t;
688     #endif
689 root 1.391 #else
690     #include <inttypes.h>
691 root 1.479 #if (defined INTPTR_MAX ? INTPTR_MAX : ULONG_MAX) > 0xffffffffU
692 root 1.437 #define ECB_PTRSIZE 8
693     #else
694     #define ECB_PTRSIZE 4
695     #endif
696 root 1.391 #endif
697 root 1.379
698 sf-exg 1.475 #define ECB_GCC_AMD64 (__amd64 || __amd64__ || __x86_64 || __x86_64__)
699     #define ECB_MSVC_AMD64 (_M_AMD64 || _M_X64)
700    
701 root 1.523 #ifndef ECB_OPTIMIZE_SIZE
702     #if __OPTIMIZE_SIZE__
703     #define ECB_OPTIMIZE_SIZE 1
704     #else
705     #define ECB_OPTIMIZE_SIZE 0
706     #endif
707     #endif
708    
709 root 1.454 /* work around x32 idiocy by defining proper macros */
710 sf-exg 1.475 #if ECB_GCC_AMD64 || ECB_MSVC_AMD64
711 root 1.458 #if _ILP32
712 root 1.454 #define ECB_AMD64_X32 1
713     #else
714     #define ECB_AMD64 1
715     #endif
716     #endif
717    
718 root 1.379 /* many compilers define _GNUC_ to some versions but then only implement
719     * what their idiot authors think are the "more important" extensions,
720 root 1.391 * causing enormous grief in return for some better fake benchmark numbers.
721 root 1.379 * or so.
722     * we try to detect these and simply assume they are not gcc - if they have
723     * an issue with that they should have done it right in the first place.
724     */
725 root 1.474 #if !defined __GNUC_MINOR__ || defined __INTEL_COMPILER || defined __SUNPRO_C || defined __SUNPRO_CC || defined __llvm__ || defined __clang__
726     #define ECB_GCC_VERSION(major,minor) 0
727     #else
728     #define ECB_GCC_VERSION(major,minor) (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
729     #endif
730    
731     #define ECB_CLANG_VERSION(major,minor) (__clang_major__ > (major) || (__clang_major__ == (major) && __clang_minor__ >= (minor)))
732    
733     #if __clang__ && defined __has_builtin
734     #define ECB_CLANG_BUILTIN(x) __has_builtin (x)
735     #else
736     #define ECB_CLANG_BUILTIN(x) 0
737     #endif
738    
739     #if __clang__ && defined __has_extension
740     #define ECB_CLANG_EXTENSION(x) __has_extension (x)
741     #else
742     #define ECB_CLANG_EXTENSION(x) 0
743 root 1.379 #endif
744    
745 root 1.437 #define ECB_CPP (__cplusplus+0)
746     #define ECB_CPP11 (__cplusplus >= 201103L)
747 root 1.488 #define ECB_CPP14 (__cplusplus >= 201402L)
748     #define ECB_CPP17 (__cplusplus >= 201703L)
749 root 1.437
750 root 1.450 #if ECB_CPP
751 root 1.464 #define ECB_C 0
752     #define ECB_STDC_VERSION 0
753     #else
754     #define ECB_C 1
755     #define ECB_STDC_VERSION __STDC_VERSION__
756     #endif
757    
758     #define ECB_C99 (ECB_STDC_VERSION >= 199901L)
759     #define ECB_C11 (ECB_STDC_VERSION >= 201112L)
760 root 1.488 #define ECB_C17 (ECB_STDC_VERSION >= 201710L)
761 root 1.464
762     #if ECB_CPP
763 root 1.450 #define ECB_EXTERN_C extern "C"
764     #define ECB_EXTERN_C_BEG ECB_EXTERN_C {
765     #define ECB_EXTERN_C_END }
766     #else
767     #define ECB_EXTERN_C extern
768     #define ECB_EXTERN_C_BEG
769     #define ECB_EXTERN_C_END
770     #endif
771    
772 root 1.391 /*****************************************************************************/
773    
774     /* ECB_NO_THREADS - ecb is not used by multiple threads, ever */
775     /* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */
776    
777 root 1.410 #if ECB_NO_THREADS
778 root 1.439 #define ECB_NO_SMP 1
779 root 1.410 #endif
780    
781 root 1.437 #if ECB_NO_SMP
782 root 1.393 #define ECB_MEMORY_FENCE do { } while (0)
783 root 1.40 #endif
784    
785 root 1.476 /* http://www-01.ibm.com/support/knowledgecenter/SSGH3R_13.1.0/com.ibm.xlcpp131.aix.doc/compiler_ref/compiler_builtins.html */
786     #if __xlC__ && ECB_CPP
787     #include <builtins.h>
788     #endif
789    
790 root 1.479 #if 1400 <= _MSC_VER
791     #include <intrin.h> /* fence functions _ReadBarrier, also bit search functions _BitScanReverse */
792     #endif
793    
794 root 1.383 #ifndef ECB_MEMORY_FENCE
795 root 1.417 #if ECB_GCC_VERSION(2,5) || defined __INTEL_COMPILER || (__llvm__ && __GNUC__) || __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
796 root 1.496 #define ECB_MEMORY_FENCE_RELAXED __asm__ __volatile__ ("" : : : "memory")
797 root 1.404 #if __i386 || __i386__
798 root 1.383 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("lock; orb $0, -1(%%esp)" : : : "memory")
799 root 1.437 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
800 root 1.488 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("" : : : "memory")
801 sf-exg 1.475 #elif ECB_GCC_AMD64
802 root 1.437 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mfence" : : : "memory")
803     #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("" : : : "memory")
804 root 1.488 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("" : : : "memory")
805 root 1.392 #elif __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__
806 root 1.437 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory")
807 root 1.479 #elif defined __ARM_ARCH_2__ \
808     || defined __ARM_ARCH_3__ || defined __ARM_ARCH_3M__ \
809     || defined __ARM_ARCH_4__ || defined __ARM_ARCH_4T__ \
810     || defined __ARM_ARCH_5__ || defined __ARM_ARCH_5E__ \
811     || defined __ARM_ARCH_5T__ || defined __ARM_ARCH_5TE__ \
812     || defined __ARM_ARCH_5TEJ__
813     /* should not need any, unless running old code on newer cpu - arm doesn't support that */
814 root 1.417 #elif defined __ARM_ARCH_6__ || defined __ARM_ARCH_6J__ \
815 root 1.479 || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__ \
816     || defined __ARM_ARCH_6T2__
817 root 1.415 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")
818 root 1.417 #elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \
819 root 1.479 || defined __ARM_ARCH_7R__ || defined __ARM_ARCH_7M__
820 root 1.437 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")
821 root 1.464 #elif __aarch64__
822     #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb ish" : : : "memory")
823 root 1.477 #elif (__sparc || __sparc__) && !(__sparc_v8__ || defined __sparcv8)
824 root 1.437 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad" : : : "memory")
825     #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory")
826     #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore")
827 root 1.417 #elif defined __s390__ || defined __s390x__
828 root 1.408 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory")
829 root 1.417 #elif defined __mips__
830 root 1.458 /* GNU/Linux emulates sync on mips1 architectures, so we force its use */
831 root 1.456 /* anybody else who still uses mips1 is supposed to send in their version, with detection code. */
832     #define ECB_MEMORY_FENCE __asm__ __volatile__ (".set mips2; sync; .set mips0" : : : "memory")
833 root 1.419 #elif defined __alpha__
834 root 1.437 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mb" : : : "memory")
835     #elif defined __hppa__
836     #define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
837     #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
838     #elif defined __ia64__
839     #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mf" : : : "memory")
840 root 1.457 #elif defined __m68k__
841     #define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
842     #elif defined __m88k__
843     #define ECB_MEMORY_FENCE __asm__ __volatile__ ("tb1 0,%%r0,128" : : : "memory")
844     #elif defined __sh__
845     #define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
846 root 1.383 #endif
847     #endif
848     #endif
849    
850     #ifndef ECB_MEMORY_FENCE
851 root 1.437 #if ECB_GCC_VERSION(4,7)
852 root 1.442 /* see comment below (stdatomic.h) about the C11 memory model. */
853 root 1.437 #define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
854 root 1.464 #define ECB_MEMORY_FENCE_ACQUIRE __atomic_thread_fence (__ATOMIC_ACQUIRE)
855     #define ECB_MEMORY_FENCE_RELEASE __atomic_thread_fence (__ATOMIC_RELEASE)
856 root 1.496 #define ECB_MEMORY_FENCE_RELAXED __atomic_thread_fence (__ATOMIC_RELAXED)
857 root 1.450
858 root 1.474 #elif ECB_CLANG_EXTENSION(c_atomic)
859     /* see comment below (stdatomic.h) about the C11 memory model. */
860     #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
861     #define ECB_MEMORY_FENCE_ACQUIRE __c11_atomic_thread_fence (__ATOMIC_ACQUIRE)
862     #define ECB_MEMORY_FENCE_RELEASE __c11_atomic_thread_fence (__ATOMIC_RELEASE)
863 root 1.496 #define ECB_MEMORY_FENCE_RELAXED __c11_atomic_thread_fence (__ATOMIC_RELAXED)
864 root 1.450
865 root 1.437 #elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
866 root 1.383 #define ECB_MEMORY_FENCE __sync_synchronize ()
867 root 1.462 #elif _MSC_VER >= 1500 /* VC++ 2008 */
868     /* apparently, microsoft broke all the memory barrier stuff in Visual Studio 2008... */
869     #pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
870     #define ECB_MEMORY_FENCE _ReadWriteBarrier (); MemoryBarrier()
871     #define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier (); MemoryBarrier() /* according to msdn, _ReadBarrier is not a load fence */
872     #define ECB_MEMORY_FENCE_RELEASE _WriteBarrier (); MemoryBarrier()
873 root 1.389 #elif _MSC_VER >= 1400 /* VC++ 2005 */
874     #pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
875     #define ECB_MEMORY_FENCE _ReadWriteBarrier ()
876     #define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */
877     #define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()
878 root 1.417 #elif defined _WIN32
879 root 1.388 #include <WinNT.h>
880 root 1.391 #define ECB_MEMORY_FENCE MemoryBarrier () /* actually just xchg on x86... scary */
881 root 1.403 #elif __SUNPRO_C >= 0x5110 || __SUNPRO_CC >= 0x5110
882     #include <mbarrier.h>
883 root 1.496 #define ECB_MEMORY_FENCE __machine_rw_barrier ()
884     #define ECB_MEMORY_FENCE_ACQUIRE __machine_acq_barrier ()
885     #define ECB_MEMORY_FENCE_RELEASE __machine_rel_barrier ()
886     #define ECB_MEMORY_FENCE_RELAXED __compiler_barrier ()
887 root 1.413 #elif __xlC__
888 root 1.414 #define ECB_MEMORY_FENCE __sync ()
889 root 1.383 #endif
890     #endif
891    
892     #ifndef ECB_MEMORY_FENCE
893 root 1.437 #if ECB_C11 && !defined __STDC_NO_ATOMICS__
894     /* we assume that these memory fences work on all variables/all memory accesses, */
895     /* not just C11 atomics and atomic accesses */
896     #include <stdatomic.h>
897     #define ECB_MEMORY_FENCE atomic_thread_fence (memory_order_seq_cst)
898 root 1.496 #define ECB_MEMORY_FENCE_ACQUIRE atomic_thread_fence (memory_order_acquire)
899     #define ECB_MEMORY_FENCE_RELEASE atomic_thread_fence (memory_order_release)
900 root 1.437 #endif
901     #endif
902    
903     #ifndef ECB_MEMORY_FENCE
904 root 1.392 #if !ECB_AVOID_PTHREADS
905     /*
906     * if you get undefined symbol references to pthread_mutex_lock,
907     * or failure to find pthread.h, then you should implement
908     * the ECB_MEMORY_FENCE operations for your cpu/compiler
909     * OR provide pthread.h and link against the posix thread library
910     * of your system.
911     */
912     #include <pthread.h>
913     #define ECB_NEEDS_PTHREADS 1
914     #define ECB_MEMORY_FENCE_NEEDS_PTHREADS 1
915    
916     static pthread_mutex_t ecb_mf_lock = PTHREAD_MUTEX_INITIALIZER;
917     #define ECB_MEMORY_FENCE do { pthread_mutex_lock (&ecb_mf_lock); pthread_mutex_unlock (&ecb_mf_lock); } while (0)
918     #endif
919     #endif
920 root 1.383
921 root 1.417 #if !defined ECB_MEMORY_FENCE_ACQUIRE && defined ECB_MEMORY_FENCE
922 root 1.383 #define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
923 root 1.392 #endif
924    
925 root 1.417 #if !defined ECB_MEMORY_FENCE_RELEASE && defined ECB_MEMORY_FENCE
926 root 1.383 #define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
927     #endif
928    
929 root 1.496 #if !defined ECB_MEMORY_FENCE_RELAXED && defined ECB_MEMORY_FENCE
930     #define ECB_MEMORY_FENCE_RELAXED ECB_MEMORY_FENCE /* very heavy-handed */
931     #endif
932    
933 root 1.391 /*****************************************************************************/
934    
935 root 1.474 #if ECB_CPP
936 root 1.391 #define ecb_inline static inline
937     #elif ECB_GCC_VERSION(2,5)
938     #define ecb_inline static __inline__
939     #elif ECB_C99
940     #define ecb_inline static inline
941     #else
942     #define ecb_inline static
943     #endif
944    
945     #if ECB_GCC_VERSION(3,3)
946     #define ecb_restrict __restrict__
947     #elif ECB_C99
948     #define ecb_restrict restrict
949     #else
950     #define ecb_restrict
951     #endif
952    
953     typedef int ecb_bool;
954    
955     #define ECB_CONCAT_(a, b) a ## b
956     #define ECB_CONCAT(a, b) ECB_CONCAT_(a, b)
957     #define ECB_STRINGIFY_(a) # a
958     #define ECB_STRINGIFY(a) ECB_STRINGIFY_(a)
959 sf-exg 1.475 #define ECB_STRINGIFY_EXPR(expr) ((expr), ECB_STRINGIFY_ (expr))
960 root 1.391
961     #define ecb_function_ ecb_inline
962    
963 root 1.474 #if ECB_GCC_VERSION(3,1) || ECB_CLANG_VERSION(2,8)
964     #define ecb_attribute(attrlist) __attribute__ (attrlist)
965 root 1.379 #else
966     #define ecb_attribute(attrlist)
967 root 1.474 #endif
968 root 1.464
969 root 1.474 #if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_constant_p)
970     #define ecb_is_constant(expr) __builtin_constant_p (expr)
971     #else
972 root 1.464 /* possible C11 impl for integral types
973     typedef struct ecb_is_constant_struct ecb_is_constant_struct;
974     #define ecb_is_constant(expr) _Generic ((1 ? (struct ecb_is_constant_struct *)0 : (void *)((expr) - (expr)), ecb_is_constant_struct *: 0, default: 1)) */
975    
976 root 1.379 #define ecb_is_constant(expr) 0
977 root 1.474 #endif
978    
979     #if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_expect)
980     #define ecb_expect(expr,value) __builtin_expect ((expr),(value))
981     #else
982 root 1.379 #define ecb_expect(expr,value) (expr)
983 root 1.474 #endif
984    
985     #if ECB_GCC_VERSION(3,1) || ECB_CLANG_BUILTIN(__builtin_prefetch)
986     #define ecb_prefetch(addr,rw,locality) __builtin_prefetch (addr, rw, locality)
987     #else
988 root 1.379 #define ecb_prefetch(addr,rw,locality)
989     #endif
990    
991 root 1.391 /* no emulation for ecb_decltype */
992 root 1.474 #if ECB_CPP11
993     // older implementations might have problems with decltype(x)::type, work around it
994     template<class T> struct ecb_decltype_t { typedef T type; };
995     #define ecb_decltype(x) ecb_decltype_t<decltype (x)>::type
996     #elif ECB_GCC_VERSION(3,0) || ECB_CLANG_VERSION(2,8)
997     #define ecb_decltype(x) __typeof__ (x)
998 root 1.391 #endif
999    
1000 root 1.468 #if _MSC_VER >= 1300
1001 root 1.474 #define ecb_deprecated __declspec (deprecated)
1002 root 1.468 #else
1003     #define ecb_deprecated ecb_attribute ((__deprecated__))
1004     #endif
1005    
1006 root 1.476 #if _MSC_VER >= 1500
1007 sf-exg 1.475 #define ecb_deprecated_message(msg) __declspec (deprecated (msg))
1008     #elif ECB_GCC_VERSION(4,5)
1009     #define ecb_deprecated_message(msg) ecb_attribute ((__deprecated__ (msg))
1010     #else
1011     #define ecb_deprecated_message(msg) ecb_deprecated
1012     #endif
1013    
1014     #if _MSC_VER >= 1400
1015     #define ecb_noinline __declspec (noinline)
1016     #else
1017     #define ecb_noinline ecb_attribute ((__noinline__))
1018     #endif
1019    
1020 root 1.379 #define ecb_unused ecb_attribute ((__unused__))
1021     #define ecb_const ecb_attribute ((__const__))
1022     #define ecb_pure ecb_attribute ((__pure__))
1023    
1024 root 1.474 #if ECB_C11 || __IBMC_NORETURN
1025 root 1.476 /* http://www-01.ibm.com/support/knowledgecenter/SSGH3R_13.1.0/com.ibm.xlcpp131.aix.doc/language_ref/noreturn.html */
1026 root 1.437 #define ecb_noreturn _Noreturn
1027 sf-exg 1.475 #elif ECB_CPP11
1028     #define ecb_noreturn [[noreturn]]
1029     #elif _MSC_VER >= 1200
1030     /* http://msdn.microsoft.com/en-us/library/k6ktzx3s.aspx */
1031     #define ecb_noreturn __declspec (noreturn)
1032 root 1.437 #else
1033     #define ecb_noreturn ecb_attribute ((__noreturn__))
1034     #endif
1035    
1036 root 1.379 #if ECB_GCC_VERSION(4,3)
1037     #define ecb_artificial ecb_attribute ((__artificial__))
1038     #define ecb_hot ecb_attribute ((__hot__))
1039     #define ecb_cold ecb_attribute ((__cold__))
1040     #else
1041     #define ecb_artificial
1042     #define ecb_hot
1043     #define ecb_cold
1044     #endif
1045    
1046     /* put around conditional expressions if you are very sure that the */
1047     /* expression is mostly true or mostly false. note that these return */
1048     /* booleans, not the expression. */
1049     #define ecb_expect_false(expr) ecb_expect (!!(expr), 0)
1050     #define ecb_expect_true(expr) ecb_expect (!!(expr), 1)
1051 root 1.391 /* for compatibility to the rest of the world */
1052     #define ecb_likely(expr) ecb_expect_true (expr)
1053     #define ecb_unlikely(expr) ecb_expect_false (expr)
1054    
1055     /* count trailing zero bits and count # of one bits */
1056 root 1.474 #if ECB_GCC_VERSION(3,4) \
1057     || (ECB_CLANG_BUILTIN(__builtin_clz) && ECB_CLANG_BUILTIN(__builtin_clzll) \
1058     && ECB_CLANG_BUILTIN(__builtin_ctz) && ECB_CLANG_BUILTIN(__builtin_ctzll) \
1059     && ECB_CLANG_BUILTIN(__builtin_popcount))
1060 root 1.391 /* we assume int == 32 bit, long == 32 or 64 bit and long long == 64 bit */
1061     #define ecb_ld32(x) (__builtin_clz (x) ^ 31)
1062     #define ecb_ld64(x) (__builtin_clzll (x) ^ 63)
1063     #define ecb_ctz32(x) __builtin_ctz (x)
1064     #define ecb_ctz64(x) __builtin_ctzll (x)
1065     #define ecb_popcount32(x) __builtin_popcount (x)
1066     /* no popcountll */
1067     #else
1068 root 1.474 ecb_function_ ecb_const int ecb_ctz32 (uint32_t x);
1069     ecb_function_ ecb_const int
1070 root 1.391 ecb_ctz32 (uint32_t x)
1071     {
1072 root 1.479 #if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
1073     unsigned long r;
1074     _BitScanForward (&r, x);
1075     return (int)r;
1076     #else
1077 root 1.391 int r = 0;
1078    
1079     x &= ~x + 1; /* this isolates the lowest bit */
1080    
1081     #if ECB_branchless_on_i386
1082     r += !!(x & 0xaaaaaaaa) << 0;
1083     r += !!(x & 0xcccccccc) << 1;
1084     r += !!(x & 0xf0f0f0f0) << 2;
1085     r += !!(x & 0xff00ff00) << 3;
1086     r += !!(x & 0xffff0000) << 4;
1087     #else
1088     if (x & 0xaaaaaaaa) r += 1;
1089     if (x & 0xcccccccc) r += 2;
1090     if (x & 0xf0f0f0f0) r += 4;
1091     if (x & 0xff00ff00) r += 8;
1092     if (x & 0xffff0000) r += 16;
1093     #endif
1094    
1095     return r;
1096 root 1.479 #endif
1097 root 1.391 }
1098    
1099 root 1.474 ecb_function_ ecb_const int ecb_ctz64 (uint64_t x);
1100     ecb_function_ ecb_const int
1101 root 1.391 ecb_ctz64 (uint64_t x)
1102     {
1103 root 1.479 #if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
1104     unsigned long r;
1105     _BitScanForward64 (&r, x);
1106     return (int)r;
1107     #else
1108     int shift = x & 0xffffffff ? 0 : 32;
1109 root 1.391 return ecb_ctz32 (x >> shift) + shift;
1110 root 1.479 #endif
1111 root 1.391 }
1112    
1113 root 1.474 ecb_function_ ecb_const int ecb_popcount32 (uint32_t x);
1114     ecb_function_ ecb_const int
1115 root 1.391 ecb_popcount32 (uint32_t x)
1116     {
1117     x -= (x >> 1) & 0x55555555;
1118     x = ((x >> 2) & 0x33333333) + (x & 0x33333333);
1119     x = ((x >> 4) + x) & 0x0f0f0f0f;
1120     x *= 0x01010101;
1121    
1122     return x >> 24;
1123     }
1124    
1125 root 1.474 ecb_function_ ecb_const int ecb_ld32 (uint32_t x);
1126     ecb_function_ ecb_const int ecb_ld32 (uint32_t x)
1127 root 1.391 {
1128 root 1.479 #if 1400 <= _MSC_VER && (_M_IX86 || _M_X64 || _M_IA64 || _M_ARM)
1129     unsigned long r;
1130     _BitScanReverse (&r, x);
1131     return (int)r;
1132     #else
1133 root 1.391 int r = 0;
1134    
1135     if (x >> 16) { x >>= 16; r += 16; }
1136     if (x >> 8) { x >>= 8; r += 8; }
1137     if (x >> 4) { x >>= 4; r += 4; }
1138     if (x >> 2) { x >>= 2; r += 2; }
1139     if (x >> 1) { r += 1; }
1140    
1141     return r;
1142 root 1.479 #endif
1143 root 1.391 }
1144    
1145 root 1.474 ecb_function_ ecb_const int ecb_ld64 (uint64_t x);
1146     ecb_function_ ecb_const int ecb_ld64 (uint64_t x)
1147 root 1.391 {
1148 root 1.479 #if 1400 <= _MSC_VER && (_M_X64 || _M_IA64 || _M_ARM)
1149     unsigned long r;
1150     _BitScanReverse64 (&r, x);
1151     return (int)r;
1152     #else
1153 root 1.391 int r = 0;
1154    
1155     if (x >> 32) { x >>= 32; r += 32; }
1156    
1157     return r + ecb_ld32 (x);
1158 root 1.479 #endif
1159 root 1.391 }
1160     #endif
1161    
1162 root 1.474 ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x);
1163     ecb_function_ ecb_const ecb_bool ecb_is_pot32 (uint32_t x) { return !(x & (x - 1)); }
1164     ecb_function_ ecb_const ecb_bool ecb_is_pot64 (uint64_t x);
1165     ecb_function_ ecb_const ecb_bool ecb_is_pot64 (uint64_t x) { return !(x & (x - 1)); }
1166 root 1.437
1167 root 1.474 ecb_function_ ecb_const uint8_t ecb_bitrev8 (uint8_t x);
1168     ecb_function_ ecb_const uint8_t ecb_bitrev8 (uint8_t x)
1169 root 1.403 {
1170     return ( (x * 0x0802U & 0x22110U)
1171 root 1.474 | (x * 0x8020U & 0x88440U)) * 0x10101U >> 16;
1172 root 1.403 }
1173    
1174 root 1.474 ecb_function_ ecb_const uint16_t ecb_bitrev16 (uint16_t x);
1175     ecb_function_ ecb_const uint16_t ecb_bitrev16 (uint16_t x)
1176 root 1.403 {
1177     x = ((x >> 1) & 0x5555) | ((x & 0x5555) << 1);
1178     x = ((x >> 2) & 0x3333) | ((x & 0x3333) << 2);
1179     x = ((x >> 4) & 0x0f0f) | ((x & 0x0f0f) << 4);
1180     x = ( x >> 8 ) | ( x << 8);
1181    
1182     return x;
1183     }
1184    
1185 root 1.474 ecb_function_ ecb_const uint32_t ecb_bitrev32 (uint32_t x);
1186     ecb_function_ ecb_const uint32_t ecb_bitrev32 (uint32_t x)
1187 root 1.403 {
1188     x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);
1189     x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);
1190     x = ((x >> 4) & 0x0f0f0f0f) | ((x & 0x0f0f0f0f) << 4);
1191     x = ((x >> 8) & 0x00ff00ff) | ((x & 0x00ff00ff) << 8);
1192     x = ( x >> 16 ) | ( x << 16);
1193    
1194     return x;
1195     }
1196    
1197 root 1.391 /* popcount64 is only available on 64 bit cpus as gcc builtin */
1198     /* so for this version we are lazy */
1199 root 1.474 ecb_function_ ecb_const int ecb_popcount64 (uint64_t x);
1200     ecb_function_ ecb_const int
1201 root 1.391 ecb_popcount64 (uint64_t x)
1202     {
1203     return ecb_popcount32 (x) + ecb_popcount32 (x >> 32);
1204     }
1205    
1206 root 1.474 ecb_inline ecb_const uint8_t ecb_rotl8 (uint8_t x, unsigned int count);
1207     ecb_inline ecb_const uint8_t ecb_rotr8 (uint8_t x, unsigned int count);
1208     ecb_inline ecb_const uint16_t ecb_rotl16 (uint16_t x, unsigned int count);
1209     ecb_inline ecb_const uint16_t ecb_rotr16 (uint16_t x, unsigned int count);
1210     ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count);
1211     ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count);
1212     ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count);
1213     ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count);
1214    
1215     ecb_inline ecb_const uint8_t ecb_rotl8 (uint8_t x, unsigned int count) { return (x >> ( 8 - count)) | (x << count); }
1216     ecb_inline ecb_const uint8_t ecb_rotr8 (uint8_t x, unsigned int count) { return (x << ( 8 - count)) | (x >> count); }
1217     ecb_inline ecb_const uint16_t ecb_rotl16 (uint16_t x, unsigned int count) { return (x >> (16 - count)) | (x << count); }
1218     ecb_inline ecb_const uint16_t ecb_rotr16 (uint16_t x, unsigned int count) { return (x << (16 - count)) | (x >> count); }
1219     ecb_inline ecb_const uint32_t ecb_rotl32 (uint32_t x, unsigned int count) { return (x >> (32 - count)) | (x << count); }
1220     ecb_inline ecb_const uint32_t ecb_rotr32 (uint32_t x, unsigned int count) { return (x << (32 - count)) | (x >> count); }
1221     ecb_inline ecb_const uint64_t ecb_rotl64 (uint64_t x, unsigned int count) { return (x >> (64 - count)) | (x << count); }
1222     ecb_inline ecb_const uint64_t ecb_rotr64 (uint64_t x, unsigned int count) { return (x << (64 - count)) | (x >> count); }
1223 root 1.391
1224 root 1.523 #if ECB_CPP
1225    
1226     inline uint8_t ecb_ctz (uint8_t v) { return ecb_ctz32 (v); }
1227     inline uint16_t ecb_ctz (uint16_t v) { return ecb_ctz32 (v); }
1228     inline uint32_t ecb_ctz (uint32_t v) { return ecb_ctz32 (v); }
1229     inline uint64_t ecb_ctz (uint64_t v) { return ecb_ctz64 (v); }
1230    
1231     inline bool ecb_is_pot (uint8_t v) { return ecb_is_pot32 (v); }
1232     inline bool ecb_is_pot (uint16_t v) { return ecb_is_pot32 (v); }
1233     inline bool ecb_is_pot (uint32_t v) { return ecb_is_pot32 (v); }
1234     inline bool ecb_is_pot (uint64_t v) { return ecb_is_pot64 (v); }
1235    
1236     inline int ecb_ld (uint8_t v) { return ecb_ld32 (v); }
1237     inline int ecb_ld (uint16_t v) { return ecb_ld32 (v); }
1238     inline int ecb_ld (uint32_t v) { return ecb_ld32 (v); }
1239     inline int ecb_ld (uint64_t v) { return ecb_ld64 (v); }
1240    
1241     inline int ecb_popcount (uint8_t v) { return ecb_popcount32 (v); }
1242     inline int ecb_popcount (uint16_t v) { return ecb_popcount32 (v); }
1243     inline int ecb_popcount (uint32_t v) { return ecb_popcount32 (v); }
1244     inline int ecb_popcount (uint64_t v) { return ecb_popcount64 (v); }
1245    
1246     inline uint8_t ecb_bitrev (uint8_t v) { return ecb_bitrev8 (v); }
1247     inline uint16_t ecb_bitrev (uint16_t v) { return ecb_bitrev16 (v); }
1248     inline uint32_t ecb_bitrev (uint32_t v) { return ecb_bitrev32 (v); }
1249    
1250     inline uint8_t ecb_rotl (uint8_t v, unsigned int count) { return ecb_rotl8 (v, count); }
1251     inline uint16_t ecb_rotl (uint16_t v, unsigned int count) { return ecb_rotl16 (v, count); }
1252     inline uint32_t ecb_rotl (uint32_t v, unsigned int count) { return ecb_rotl32 (v, count); }
1253     inline uint64_t ecb_rotl (uint64_t v, unsigned int count) { return ecb_rotl64 (v, count); }
1254    
1255     inline uint8_t ecb_rotr (uint8_t v, unsigned int count) { return ecb_rotr8 (v, count); }
1256     inline uint16_t ecb_rotr (uint16_t v, unsigned int count) { return ecb_rotr16 (v, count); }
1257     inline uint32_t ecb_rotr (uint32_t v, unsigned int count) { return ecb_rotr32 (v, count); }
1258     inline uint64_t ecb_rotr (uint64_t v, unsigned int count) { return ecb_rotr64 (v, count); }
1259    
1260     #endif
1261    
1262 root 1.474 #if ECB_GCC_VERSION(4,3) || (ECB_CLANG_BUILTIN(__builtin_bswap32) && ECB_CLANG_BUILTIN(__builtin_bswap64))
1263 root 1.476 #if ECB_GCC_VERSION(4,8) || ECB_CLANG_BUILTIN(__builtin_bswap16)
1264     #define ecb_bswap16(x) __builtin_bswap16 (x)
1265     #else
1266 root 1.391 #define ecb_bswap16(x) (__builtin_bswap32 (x) >> 16)
1267 root 1.476 #endif
1268 root 1.391 #define ecb_bswap32(x) __builtin_bswap32 (x)
1269     #define ecb_bswap64(x) __builtin_bswap64 (x)
1270 root 1.476 #elif _MSC_VER
1271     #include <stdlib.h>
1272     #define ecb_bswap16(x) ((uint16_t)_byteswap_ushort ((uint16_t)(x)))
1273     #define ecb_bswap32(x) ((uint32_t)_byteswap_ulong ((uint32_t)(x)))
1274     #define ecb_bswap64(x) ((uint64_t)_byteswap_uint64 ((uint64_t)(x)))
1275 root 1.391 #else
1276 root 1.474 ecb_function_ ecb_const uint16_t ecb_bswap16 (uint16_t x);
1277     ecb_function_ ecb_const uint16_t
1278 root 1.391 ecb_bswap16 (uint16_t x)
1279     {
1280     return ecb_rotl16 (x, 8);
1281     }
1282    
1283 root 1.474 ecb_function_ ecb_const uint32_t ecb_bswap32 (uint32_t x);
1284     ecb_function_ ecb_const uint32_t
1285 root 1.391 ecb_bswap32 (uint32_t x)
1286     {
1287     return (((uint32_t)ecb_bswap16 (x)) << 16) | ecb_bswap16 (x >> 16);
1288     }
1289    
1290 root 1.474 ecb_function_ ecb_const uint64_t ecb_bswap64 (uint64_t x);
1291     ecb_function_ ecb_const uint64_t
1292 root 1.391 ecb_bswap64 (uint64_t x)
1293     {
1294     return (((uint64_t)ecb_bswap32 (x)) << 32) | ecb_bswap32 (x >> 32);
1295     }
1296     #endif
1297    
1298 root 1.474 #if ECB_GCC_VERSION(4,5) || ECB_CLANG_BUILTIN(__builtin_unreachable)
1299 root 1.391 #define ecb_unreachable() __builtin_unreachable ()
1300     #else
1301     /* this seems to work fine, but gcc always emits a warning for it :/ */
1302 root 1.474 ecb_inline ecb_noreturn void ecb_unreachable (void);
1303     ecb_inline ecb_noreturn void ecb_unreachable (void) { }
1304 root 1.391 #endif
1305    
1306     /* try to tell the compiler that some condition is definitely true */
1307 root 1.450 #define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
1308 root 1.391
1309 root 1.479 ecb_inline ecb_const uint32_t ecb_byteorder_helper (void);
1310     ecb_inline ecb_const uint32_t
1311 root 1.391 ecb_byteorder_helper (void)
1312     {
1313 root 1.450 /* the union code still generates code under pressure in gcc, */
1314     /* but less than using pointers, and always seems to */
1315     /* successfully return a constant. */
1316     /* the reason why we have this horrible preprocessor mess */
1317     /* is to avoid it in all cases, at least on common architectures */
1318     /* or when using a recent enough gcc version (>= 4.6) */
1319 root 1.479 #if (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__) \
1320     || ((__i386 || __i386__ || _M_IX86 || ECB_GCC_AMD64 || ECB_MSVC_AMD64) && !__VOS__)
1321     #define ECB_LITTLE_ENDIAN 1
1322     return 0x44332211;
1323     #elif (defined __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) \
1324     || ((__AARCH64EB__ || __MIPSEB__ || __ARMEB__) && !__VOS__)
1325     #define ECB_BIG_ENDIAN 1
1326     return 0x11223344;
1327 root 1.450 #else
1328     union
1329     {
1330 root 1.479 uint8_t c[4];
1331     uint32_t u;
1332     } u = { 0x11, 0x22, 0x33, 0x44 };
1333     return u.u;
1334 root 1.450 #endif
1335 root 1.391 }
1336    
1337 root 1.474 ecb_inline ecb_const ecb_bool ecb_big_endian (void);
1338 root 1.479 ecb_inline ecb_const ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11223344; }
1339 root 1.474 ecb_inline ecb_const ecb_bool ecb_little_endian (void);
1340 root 1.479 ecb_inline ecb_const ecb_bool ecb_little_endian (void) { return ecb_byteorder_helper () == 0x44332211; }
1341 root 1.391
1342 root 1.523 /*****************************************************************************/
1343     /* unaligned load/store */
1344    
1345     ecb_inline uint_fast16_t ecb_be_u16_to_host (uint_fast16_t v) { return ecb_little_endian () ? ecb_bswap16 (v) : v; }
1346     ecb_inline uint_fast32_t ecb_be_u32_to_host (uint_fast32_t v) { return ecb_little_endian () ? ecb_bswap32 (v) : v; }
1347     ecb_inline uint_fast64_t ecb_be_u64_to_host (uint_fast64_t v) { return ecb_little_endian () ? ecb_bswap64 (v) : v; }
1348    
1349     ecb_inline uint_fast16_t ecb_le_u16_to_host (uint_fast16_t v) { return ecb_big_endian () ? ecb_bswap16 (v) : v; }
1350     ecb_inline uint_fast32_t ecb_le_u32_to_host (uint_fast32_t v) { return ecb_big_endian () ? ecb_bswap32 (v) : v; }
1351     ecb_inline uint_fast64_t ecb_le_u64_to_host (uint_fast64_t v) { return ecb_big_endian () ? ecb_bswap64 (v) : v; }
1352    
1353     ecb_inline uint_fast16_t ecb_peek_u16_u (const void *ptr) { uint16_t v; memcpy (&v, ptr, sizeof (v)); return v; }
1354     ecb_inline uint_fast32_t ecb_peek_u32_u (const void *ptr) { uint32_t v; memcpy (&v, ptr, sizeof (v)); return v; }
1355     ecb_inline uint_fast64_t ecb_peek_u64_u (const void *ptr) { uint64_t v; memcpy (&v, ptr, sizeof (v)); return v; }
1356    
1357     ecb_inline uint_fast16_t ecb_peek_be_u16_u (const void *ptr) { return ecb_be_u16_to_host (ecb_peek_u16_u (ptr)); }
1358     ecb_inline uint_fast32_t ecb_peek_be_u32_u (const void *ptr) { return ecb_be_u32_to_host (ecb_peek_u32_u (ptr)); }
1359     ecb_inline uint_fast64_t ecb_peek_be_u64_u (const void *ptr) { return ecb_be_u64_to_host (ecb_peek_u64_u (ptr)); }
1360    
1361     ecb_inline uint_fast16_t ecb_peek_le_u16_u (const void *ptr) { return ecb_le_u16_to_host (ecb_peek_u16_u (ptr)); }
1362     ecb_inline uint_fast32_t ecb_peek_le_u32_u (const void *ptr) { return ecb_le_u32_to_host (ecb_peek_u32_u (ptr)); }
1363     ecb_inline uint_fast64_t ecb_peek_le_u64_u (const void *ptr) { return ecb_le_u64_to_host (ecb_peek_u64_u (ptr)); }
1364    
1365     ecb_inline uint_fast16_t ecb_host_to_be_u16 (uint_fast16_t v) { return ecb_little_endian () ? ecb_bswap16 (v) : v; }
1366     ecb_inline uint_fast32_t ecb_host_to_be_u32 (uint_fast32_t v) { return ecb_little_endian () ? ecb_bswap32 (v) : v; }
1367     ecb_inline uint_fast64_t ecb_host_to_be_u64 (uint_fast64_t v) { return ecb_little_endian () ? ecb_bswap64 (v) : v; }
1368    
1369     ecb_inline uint_fast16_t ecb_host_to_le_u16 (uint_fast16_t v) { return ecb_big_endian () ? ecb_bswap16 (v) : v; }
1370     ecb_inline uint_fast32_t ecb_host_to_le_u32 (uint_fast32_t v) { return ecb_big_endian () ? ecb_bswap32 (v) : v; }
1371     ecb_inline uint_fast64_t ecb_host_to_le_u64 (uint_fast64_t v) { return ecb_big_endian () ? ecb_bswap64 (v) : v; }
1372    
1373     ecb_inline void ecb_poke_u16_u (void *ptr, uint16_t v) { memcpy (ptr, &v, sizeof (v)); }
1374     ecb_inline void ecb_poke_u32_u (void *ptr, uint32_t v) { memcpy (ptr, &v, sizeof (v)); }
1375     ecb_inline void ecb_poke_u64_u (void *ptr, uint64_t v) { memcpy (ptr, &v, sizeof (v)); }
1376    
1377     ecb_inline void ecb_poke_be_u16_u (void *ptr, uint_fast16_t v) { ecb_poke_u16_u (ptr, ecb_host_to_be_u16 (v)); }
1378     ecb_inline void ecb_poke_be_u32_u (void *ptr, uint_fast32_t v) { ecb_poke_u32_u (ptr, ecb_host_to_be_u32 (v)); }
1379     ecb_inline void ecb_poke_be_u64_u (void *ptr, uint_fast64_t v) { ecb_poke_u64_u (ptr, ecb_host_to_be_u64 (v)); }
1380    
1381     ecb_inline void ecb_poke_le_u16_u (void *ptr, uint_fast16_t v) { ecb_poke_u16_u (ptr, ecb_host_to_le_u16 (v)); }
1382     ecb_inline void ecb_poke_le_u32_u (void *ptr, uint_fast32_t v) { ecb_poke_u32_u (ptr, ecb_host_to_le_u32 (v)); }
1383     ecb_inline void ecb_poke_le_u64_u (void *ptr, uint_fast64_t v) { ecb_poke_u64_u (ptr, ecb_host_to_le_u64 (v)); }
1384    
1385     #if ECB_CPP
1386    
1387     inline uint8_t ecb_bswap (uint8_t v) { return v; }
1388     inline uint16_t ecb_bswap (uint16_t v) { return ecb_bswap16 (v); }
1389     inline uint32_t ecb_bswap (uint32_t v) { return ecb_bswap32 (v); }
1390     inline uint64_t ecb_bswap (uint64_t v) { return ecb_bswap64 (v); }
1391    
1392     template<typename T> inline T ecb_be_to_host (T v) { return ecb_little_endian () ? ecb_bswap (v) : v; }
1393     template<typename T> inline T ecb_le_to_host (T v) { return ecb_big_endian () ? ecb_bswap (v) : v; }
1394     template<typename T> inline T ecb_peek (const void *ptr) { return *(const T *)ptr; }
1395     template<typename T> inline T ecb_peek_be (const void *ptr) { return ecb_be_to_host (ecb_peek <T> (ptr)); }
1396     template<typename T> inline T ecb_peek_le (const void *ptr) { return ecb_le_to_host (ecb_peek <T> (ptr)); }
1397     template<typename T> inline T ecb_peek_u (const void *ptr) { T v; memcpy (&v, ptr, sizeof (v)); return v; }
1398     template<typename T> inline T ecb_peek_be_u (const void *ptr) { return ecb_be_to_host (ecb_peek_u<T> (ptr)); }
1399     template<typename T> inline T ecb_peek_le_u (const void *ptr) { return ecb_le_to_host (ecb_peek_u<T> (ptr)); }
1400    
1401     template<typename T> inline T ecb_host_to_be (T v) { return ecb_little_endian () ? ecb_bswap (v) : v; }
1402     template<typename T> inline T ecb_host_to_le (T v) { return ecb_big_endian () ? ecb_bswap (v) : v; }
1403     template<typename T> inline void ecb_poke (void *ptr, T v) { *(T *)ptr = v; }
1404     template<typename T> inline void ecb_poke_be (void *ptr, T v) { return ecb_poke <T> (ptr, ecb_host_to_be (v)); }
1405     template<typename T> inline void ecb_poke_le (void *ptr, T v) { return ecb_poke <T> (ptr, ecb_host_to_le (v)); }
1406     template<typename T> inline void ecb_poke_u (void *ptr, T v) { memcpy (ptr, &v, sizeof (v)); }
1407     template<typename T> inline void ecb_poke_be_u (void *ptr, T v) { return ecb_poke_u<T> (ptr, ecb_host_to_be (v)); }
1408     template<typename T> inline void ecb_poke_le_u (void *ptr, T v) { return ecb_poke_u<T> (ptr, ecb_host_to_le (v)); }
1409    
1410     #endif
1411    
1412     /*****************************************************************************/
1413    
1414 root 1.391 #if ECB_GCC_VERSION(3,0) || ECB_C99
1415     #define ecb_mod(m,n) ((m) % (n) + ((m) % (n) < 0 ? (n) : 0))
1416     #else
1417     #define ecb_mod(m,n) ((m) < 0 ? ((n) - 1 - ((-1 - (m)) % (n))) : ((m) % (n)))
1418     #endif
1419    
1420 root 1.474 #if ECB_CPP
1421 root 1.398 template<typename T>
1422     static inline T ecb_div_rd (T val, T div)
1423     {
1424     return val < 0 ? - ((-val + div - 1) / div) : (val ) / div;
1425     }
1426     template<typename T>
1427     static inline T ecb_div_ru (T val, T div)
1428     {
1429     return val < 0 ? - ((-val ) / div) : (val + div - 1) / div;
1430     }
1431     #else
1432     #define ecb_div_rd(val,div) ((val) < 0 ? - ((-(val) + (div) - 1) / (div)) : ((val) ) / (div))
1433     #define ecb_div_ru(val,div) ((val) < 0 ? - ((-(val) ) / (div)) : ((val) + (div) - 1) / (div))
1434     #endif
1435    
1436 root 1.391 #if ecb_cplusplus_does_not_suck
1437     /* does not work for local types (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2008/n2657.htm) */
1438     template<typename T, int N>
1439     static inline int ecb_array_length (const T (&arr)[N])
1440     {
1441     return N;
1442     }
1443     #else
1444     #define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
1445     #endif
1446    
1447 root 1.523 /*****************************************************************************/
1448    
1449 root 1.479 ecb_function_ ecb_const uint32_t ecb_binary16_to_binary32 (uint32_t x);
1450     ecb_function_ ecb_const uint32_t
1451     ecb_binary16_to_binary32 (uint32_t x)
1452     {
1453     unsigned int s = (x & 0x8000) << (31 - 15);
1454     int e = (x >> 10) & 0x001f;
1455     unsigned int m = x & 0x03ff;
1456    
1457     if (ecb_expect_false (e == 31))
1458     /* infinity or NaN */
1459     e = 255 - (127 - 15);
1460     else if (ecb_expect_false (!e))
1461     {
1462     if (ecb_expect_true (!m))
1463     /* zero, handled by code below by forcing e to 0 */
1464     e = 0 - (127 - 15);
1465     else
1466     {
1467     /* subnormal, renormalise */
1468     unsigned int s = 10 - ecb_ld32 (m);
1469    
1470     m = (m << s) & 0x3ff; /* mask implicit bit */
1471     e -= s - 1;
1472     }
1473     }
1474    
1475     /* e and m now are normalised, or zero, (or inf or nan) */
1476     e += 127 - 15;
1477    
1478     return s | (e << 23) | (m << (23 - 10));
1479     }
1480    
1481     ecb_function_ ecb_const uint16_t ecb_binary32_to_binary16 (uint32_t x);
1482     ecb_function_ ecb_const uint16_t
1483     ecb_binary32_to_binary16 (uint32_t x)
1484     {
1485     unsigned int s = (x >> 16) & 0x00008000; /* sign bit, the easy part */
1486     unsigned int e = ((x >> 23) & 0x000000ff) - (127 - 15); /* the desired exponent */
1487     unsigned int m = x & 0x007fffff;
1488    
1489     x &= 0x7fffffff;
1490    
1491     /* if it's within range of binary16 normals, use fast path */
1492     if (ecb_expect_true (0x38800000 <= x && x <= 0x477fefff))
1493     {
1494     /* mantissa round-to-even */
1495     m += 0x00000fff + ((m >> (23 - 10)) & 1);
1496    
1497     /* handle overflow */
1498     if (ecb_expect_false (m >= 0x00800000))
1499     {
1500     m >>= 1;
1501     e += 1;
1502     }
1503    
1504     return s | (e << 10) | (m >> (23 - 10));
1505     }
1506    
1507     /* handle large numbers and infinity */
1508     if (ecb_expect_true (0x477fefff < x && x <= 0x7f800000))
1509     return s | 0x7c00;
1510    
1511     /* handle zero, subnormals and small numbers */
1512     if (ecb_expect_true (x < 0x38800000))
1513     {
1514     /* zero */
1515     if (ecb_expect_true (!x))
1516     return s;
1517    
1518     /* handle subnormals */
1519    
1520     /* too small, will be zero */
1521     if (e < (14 - 24)) /* might not be sharp, but is good enough */
1522     return s;
1523    
1524     m |= 0x00800000; /* make implicit bit explicit */
1525    
1526     /* very tricky - we need to round to the nearest e (+10) bit value */
1527     {
1528     unsigned int bits = 14 - e;
1529     unsigned int half = (1 << (bits - 1)) - 1;
1530     unsigned int even = (m >> bits) & 1;
1531    
1532     /* if this overflows, we will end up with a normalised number */
1533     m = (m + half + even) >> bits;
1534     }
1535    
1536     return s | m;
1537     }
1538    
1539     /* handle NaNs, preserve leftmost nan bits, but make sure we don't turn them into infinities */
1540     m >>= 13;
1541    
1542     return s | 0x7c00 | m | !m;
1543     }
1544    
1545 root 1.450 /*******************************************************************************/
1546     /* floating point stuff, can be disabled by defining ECB_NO_LIBM */
1547    
1548     /* basically, everything uses "ieee pure-endian" floating point numbers */
1549     /* the only noteworthy exception is ancient armle, which uses order 43218765 */
1550     #if 0 \
1551     || __i386 || __i386__ \
1552 sf-exg 1.475 || ECB_GCC_AMD64 \
1553 root 1.450 || __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__ \
1554     || defined __s390__ || defined __s390x__ \
1555     || defined __mips__ \
1556     || defined __alpha__ \
1557     || defined __hppa__ \
1558     || defined __ia64__ \
1559 root 1.457 || defined __m68k__ \
1560     || defined __m88k__ \
1561     || defined __sh__ \
1562 sf-exg 1.475 || defined _M_IX86 || defined ECB_MSVC_AMD64 || defined _M_IA64 \
1563 root 1.465 || (defined __arm__ && (defined __ARM_EABI__ || defined __EABI__ || defined __VFP_FP__ || defined _WIN32_WCE || defined __ANDROID__)) \
1564 root 1.466 || defined __aarch64__
1565 root 1.450 #define ECB_STDFP 1
1566     #else
1567     #define ECB_STDFP 0
1568     #endif
1569    
1570     #ifndef ECB_NO_LIBM
1571    
1572 root 1.458 #include <math.h> /* for frexp*, ldexp*, INFINITY, NAN */
1573    
1574 root 1.462 /* only the oldest of old doesn't have this one. solaris. */
1575     #ifdef INFINITY
1576     #define ECB_INFINITY INFINITY
1577     #else
1578     #define ECB_INFINITY HUGE_VAL
1579     #endif
1580    
1581     #ifdef NAN
1582 root 1.458 #define ECB_NAN NAN
1583     #else
1584 root 1.462 #define ECB_NAN ECB_INFINITY
1585 root 1.458 #endif
1586    
1587 root 1.474 #if ECB_C99 || _XOPEN_VERSION >= 600 || _POSIX_VERSION >= 200112L
1588     #define ecb_ldexpf(x,e) ldexpf ((x), (e))
1589 root 1.476 #define ecb_frexpf(x,e) frexpf ((x), (e))
1590 root 1.474 #else
1591 root 1.476 #define ecb_ldexpf(x,e) (float) ldexp ((double) (x), (e))
1592     #define ecb_frexpf(x,e) (float) frexp ((double) (x), (e))
1593 root 1.474 #endif
1594    
1595 root 1.450 /* convert a float to ieee single/binary32 */
1596 root 1.474 ecb_function_ ecb_const uint32_t ecb_float_to_binary32 (float x);
1597     ecb_function_ ecb_const uint32_t
1598 root 1.450 ecb_float_to_binary32 (float x)
1599     {
1600     uint32_t r;
1601    
1602     #if ECB_STDFP
1603     memcpy (&r, &x, 4);
1604     #else
1605     /* slow emulation, works for anything but -0 */
1606     uint32_t m;
1607     int e;
1608    
1609     if (x == 0e0f ) return 0x00000000U;
1610     if (x > +3.40282346638528860e+38f) return 0x7f800000U;
1611     if (x < -3.40282346638528860e+38f) return 0xff800000U;
1612     if (x != x ) return 0x7fbfffffU;
1613    
1614 root 1.476 m = ecb_frexpf (x, &e) * 0x1000000U;
1615 root 1.450
1616     r = m & 0x80000000U;
1617    
1618     if (r)
1619     m = -m;
1620    
1621     if (e <= -126)
1622     {
1623     m &= 0xffffffU;
1624     m >>= (-125 - e);
1625     e = -126;
1626     }
1627    
1628     r |= (e + 126) << 23;
1629     r |= m & 0x7fffffU;
1630     #endif
1631    
1632     return r;
1633     }
1634    
1635     /* converts an ieee single/binary32 to a float */
1636 root 1.474 ecb_function_ ecb_const float ecb_binary32_to_float (uint32_t x);
1637     ecb_function_ ecb_const float
1638 root 1.450 ecb_binary32_to_float (uint32_t x)
1639     {
1640     float r;
1641    
1642     #if ECB_STDFP
1643     memcpy (&r, &x, 4);
1644     #else
1645     /* emulation, only works for normals and subnormals and +0 */
1646     int neg = x >> 31;
1647     int e = (x >> 23) & 0xffU;
1648    
1649     x &= 0x7fffffU;
1650    
1651     if (e)
1652     x |= 0x800000U;
1653     else
1654     e = 1;
1655    
1656     /* we distrust ldexpf a bit and do the 2**-24 scaling by an extra multiply */
1657 root 1.474 r = ecb_ldexpf (x * (0.5f / 0x800000U), e - 126);
1658 root 1.450
1659     r = neg ? -r : r;
1660     #endif
1661    
1662     return r;
1663     }
1664    
1665     /* convert a double to ieee double/binary64 */
1666 root 1.474 ecb_function_ ecb_const uint64_t ecb_double_to_binary64 (double x);
1667     ecb_function_ ecb_const uint64_t
1668 root 1.450 ecb_double_to_binary64 (double x)
1669     {
1670     uint64_t r;
1671    
1672     #if ECB_STDFP
1673     memcpy (&r, &x, 8);
1674     #else
1675     /* slow emulation, works for anything but -0 */
1676     uint64_t m;
1677     int e;
1678    
1679     if (x == 0e0 ) return 0x0000000000000000U;
1680     if (x > +1.79769313486231470e+308) return 0x7ff0000000000000U;
1681     if (x < -1.79769313486231470e+308) return 0xfff0000000000000U;
1682     if (x != x ) return 0X7ff7ffffffffffffU;
1683    
1684     m = frexp (x, &e) * 0x20000000000000U;
1685    
1686     r = m & 0x8000000000000000;;
1687    
1688     if (r)
1689     m = -m;
1690    
1691     if (e <= -1022)
1692     {
1693     m &= 0x1fffffffffffffU;
1694     m >>= (-1021 - e);
1695     e = -1022;
1696     }
1697    
1698     r |= ((uint64_t)(e + 1022)) << 52;
1699     r |= m & 0xfffffffffffffU;
1700     #endif
1701    
1702     return r;
1703     }
1704    
1705     /* converts an ieee double/binary64 to a double */
1706 root 1.474 ecb_function_ ecb_const double ecb_binary64_to_double (uint64_t x);
1707     ecb_function_ ecb_const double
1708 root 1.450 ecb_binary64_to_double (uint64_t x)
1709     {
1710     double r;
1711    
1712     #if ECB_STDFP
1713     memcpy (&r, &x, 8);
1714     #else
1715     /* emulation, only works for normals and subnormals and +0 */
1716     int neg = x >> 63;
1717     int e = (x >> 52) & 0x7ffU;
1718    
1719     x &= 0xfffffffffffffU;
1720    
1721     if (e)
1722     x |= 0x10000000000000U;
1723     else
1724     e = 1;
1725    
1726     /* we distrust ldexp a bit and do the 2**-53 scaling by an extra multiply */
1727     r = ldexp (x * (0.5 / 0x10000000000000U), e - 1022);
1728    
1729     r = neg ? -r : r;
1730     #endif
1731    
1732     return r;
1733     }
1734    
1735 root 1.479 /* convert a float to ieee half/binary16 */
1736     ecb_function_ ecb_const uint16_t ecb_float_to_binary16 (float x);
1737     ecb_function_ ecb_const uint16_t
1738     ecb_float_to_binary16 (float x)
1739     {
1740     return ecb_binary32_to_binary16 (ecb_float_to_binary32 (x));
1741     }
1742    
1743     /* convert an ieee half/binary16 to float */
1744     ecb_function_ ecb_const float ecb_binary16_to_float (uint16_t x);
1745     ecb_function_ ecb_const float
1746     ecb_binary16_to_float (uint16_t x)
1747     {
1748     return ecb_binary32_to_float (ecb_binary16_to_binary32 (x));
1749     }
1750    
1751 root 1.450 #endif
1752    
1753 root 1.391 #endif
1754    
1755     /* ECB.H END */
1756 root 1.379
1757 root 1.392 #if ECB_MEMORY_FENCE_NEEDS_PTHREADS
1758 root 1.397 /* if your architecture doesn't need memory fences, e.g. because it is
1759 root 1.396 * single-cpu/core, or if you use libev in a project that doesn't use libev
1760 root 1.500 * from multiple threads, then you can define ECB_NO_THREADS when compiling
1761 sf-exg 1.402 * libev, in which cases the memory fences become nops.
1762 root 1.396 * alternatively, you can remove this #error and link against libpthread,
1763     * which will then provide the memory fences.
1764     */
1765     # error "memory fences not defined for your architecture, please report"
1766     #endif
1767    
1768     #ifndef ECB_MEMORY_FENCE
1769     # define ECB_MEMORY_FENCE do { } while (0)
1770     # define ECB_MEMORY_FENCE_ACQUIRE ECB_MEMORY_FENCE
1771     # define ECB_MEMORY_FENCE_RELEASE ECB_MEMORY_FENCE
1772 root 1.392 #endif
1773    
1774 root 1.379 #define inline_size ecb_inline
1775 root 1.169
1776 root 1.338 #if EV_FEATURE_CODE
1777 root 1.379 # define inline_speed ecb_inline
1778 root 1.338 #else
1779 root 1.500 # define inline_speed ecb_noinline static
1780 root 1.169 #endif
1781 root 1.40
1782 root 1.502 /*****************************************************************************/
1783     /* raw syscall wrappers */
1784    
1785     #if EV_NEED_SYSCALL
1786    
1787     #include <sys/syscall.h>
1788    
1789     /*
1790     * define some syscall wrappers for common architectures
1791     * this is mostly for nice looks during debugging, not performance.
1792     * our syscalls return < 0, not == -1, on error. which is good
1793     * enough for linux aio.
1794     * TODO: arm is also common nowadays, maybe even mips and x86
1795     * TODO: after implementing this, it suddenly looks like overkill, but its hard to remove...
1796     */
1797 root 1.519 #if __GNUC__ && __linux && ECB_AMD64 && !EV_FEATURE_CODE
1798 root 1.502 /* the costly errno access probably kills this for size optimisation */
1799    
1800     #define ev_syscall(nr,narg,arg1,arg2,arg3,arg4,arg5,arg6) \
1801     ({ \
1802     long res; \
1803     register unsigned long r6 __asm__ ("r9" ); \
1804     register unsigned long r5 __asm__ ("r8" ); \
1805     register unsigned long r4 __asm__ ("r10"); \
1806     register unsigned long r3 __asm__ ("rdx"); \
1807     register unsigned long r2 __asm__ ("rsi"); \
1808     register unsigned long r1 __asm__ ("rdi"); \
1809     if (narg >= 6) r6 = (unsigned long)(arg6); \
1810     if (narg >= 5) r5 = (unsigned long)(arg5); \
1811     if (narg >= 4) r4 = (unsigned long)(arg4); \
1812     if (narg >= 3) r3 = (unsigned long)(arg3); \
1813     if (narg >= 2) r2 = (unsigned long)(arg2); \
1814     if (narg >= 1) r1 = (unsigned long)(arg1); \
1815     __asm__ __volatile__ ( \
1816     "syscall\n\t" \
1817     : "=a" (res) \
1818     : "0" (nr), "r" (r1), "r" (r2), "r" (r3), "r" (r4), "r" (r5) \
1819     : "cc", "r11", "cx", "memory"); \
1820     errno = -res; \
1821     res; \
1822     })
1823    
1824     #endif
1825    
1826     #ifdef ev_syscall
1827     #define ev_syscall0(nr) ev_syscall (nr, 0, 0, 0, 0, 0, 0, 0)
1828     #define ev_syscall1(nr,arg1) ev_syscall (nr, 1, arg1, 0, 0, 0, 0, 0)
1829     #define ev_syscall2(nr,arg1,arg2) ev_syscall (nr, 2, arg1, arg2, 0, 0, 0, 0)
1830     #define ev_syscall3(nr,arg1,arg2,arg3) ev_syscall (nr, 3, arg1, arg2, arg3, 0, 0, 0)
1831     #define ev_syscall4(nr,arg1,arg2,arg3,arg4) ev_syscall (nr, 3, arg1, arg2, arg3, arg4, 0, 0)
1832     #define ev_syscall5(nr,arg1,arg2,arg3,arg4,arg5) ev_syscall (nr, 5, arg1, arg2, arg3, arg4, arg5, 0)
1833     #define ev_syscall6(nr,arg1,arg2,arg3,arg4,arg5,arg6) ev_syscall (nr, 6, arg1, arg2, arg3, arg4, arg5,arg6)
1834     #else
1835     #define ev_syscall0(nr) syscall (nr)
1836     #define ev_syscall1(nr,arg1) syscall (nr, arg1)
1837     #define ev_syscall2(nr,arg1,arg2) syscall (nr, arg1, arg2)
1838     #define ev_syscall3(nr,arg1,arg2,arg3) syscall (nr, arg1, arg2, arg3)
1839     #define ev_syscall4(nr,arg1,arg2,arg3,arg4) syscall (nr, arg1, arg2, arg3, arg4)
1840     #define ev_syscall5(nr,arg1,arg2,arg3,arg4,arg5) syscall (nr, arg1, arg2, arg3, arg4, arg5)
1841     #define ev_syscall6(nr,arg1,arg2,arg3,arg4,arg5,arg6) syscall (nr, arg1, arg2, arg3, arg4, arg5,arg6)
1842     #endif
1843    
1844     #endif
1845    
1846     /*****************************************************************************/
1847    
1848 root 1.295 #define NUMPRI (EV_MAXPRI - EV_MINPRI + 1)
1849    
1850     #if EV_MINPRI == EV_MAXPRI
1851     # define ABSPRI(w) (((W)w), 0)
1852     #else
1853     # define ABSPRI(w) (((W)w)->priority - EV_MINPRI)
1854     #endif
1855 root 1.42
1856 root 1.490 #define EMPTY /* required for microsofts broken pseudo-c compiler */
1857 root 1.103
1858 root 1.136 typedef ev_watcher *W;
1859     typedef ev_watcher_list *WL;
1860     typedef ev_watcher_time *WT;
1861 root 1.10
1862 root 1.229 #define ev_active(w) ((W)(w))->active
1863 root 1.228 #define ev_at(w) ((WT)(w))->at
1864    
1865 root 1.279 #if EV_USE_REALTIME
1866 root 1.194 /* sig_atomic_t is used to avoid per-thread variables or locking but still */
1867 sf-exg 1.345 /* giving it a reasonably high chance of working on typical architectures */
1868 root 1.279 static EV_ATOMIC_T have_realtime; /* did clock_gettime (CLOCK_REALTIME) work? */
1869     #endif
1870    
1871     #if EV_USE_MONOTONIC
1872 root 1.207 static EV_ATOMIC_T have_monotonic; /* did clock_gettime (CLOCK_MONOTONIC) work? */
1873 root 1.198 #endif
1874 root 1.54
1875 root 1.313 #ifndef EV_FD_TO_WIN32_HANDLE
1876     # define EV_FD_TO_WIN32_HANDLE(fd) _get_osfhandle (fd)
1877     #endif
1878     #ifndef EV_WIN32_HANDLE_TO_FD
1879 root 1.322 # define EV_WIN32_HANDLE_TO_FD(handle) _open_osfhandle (handle, 0)
1880 root 1.313 #endif
1881     #ifndef EV_WIN32_CLOSE_FD
1882     # define EV_WIN32_CLOSE_FD(fd) close (fd)
1883     #endif
1884    
1885 root 1.103 #ifdef _WIN32
1886 root 1.98 # include "ev_win32.c"
1887     #endif
1888 root 1.67
1889 root 1.53 /*****************************************************************************/
1890 root 1.1
1891 root 1.493 #if EV_USE_LINUXAIO
1892     # include <linux/aio_abi.h> /* probably only needed for aio_context_t */
1893     #endif
1894    
1895 root 1.373 /* define a suitable floor function (only used by periodics atm) */
1896    
1897     #if EV_USE_FLOOR
1898     # include <math.h>
1899     # define ev_floor(v) floor (v)
1900     #else
1901    
1902     #include <float.h>
1903    
1904     /* a floor() replacement function, should be independent of ev_tstamp type */
1905 root 1.500 ecb_noinline
1906 root 1.480 static ev_tstamp
1907 root 1.373 ev_floor (ev_tstamp v)
1908     {
1909     /* the choice of shift factor is not terribly important */
1910     #if FLT_RADIX != 2 /* assume FLT_RADIX == 10 */
1911     const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 10000000000000000000. : 1000000000.;
1912     #else
1913     const ev_tstamp shift = sizeof (unsigned long) >= 8 ? 18446744073709551616. : 4294967296.;
1914     #endif
1915    
1916 root 1.504 /* special treatment for negative arguments */
1917     if (ecb_expect_false (v < 0.))
1918     {
1919     ev_tstamp f = -ev_floor (-v);
1920    
1921     return f - (f == v ? 0 : 1);
1922     }
1923    
1924     /* argument too large for an unsigned long? then reduce it */
1925 root 1.500 if (ecb_expect_false (v >= shift))
1926 root 1.373 {
1927     ev_tstamp f;
1928    
1929     if (v == v - 1.)
1930 root 1.504 return v; /* very large numbers are assumed to be integer */
1931 root 1.373
1932     f = shift * ev_floor (v * (1. / shift));
1933     return f + ev_floor (v - f);
1934     }
1935    
1936     /* fits into an unsigned long */
1937     return (unsigned long)v;
1938     }
1939    
1940     #endif
1941    
1942     /*****************************************************************************/
1943    
1944 root 1.356 #ifdef __linux
1945     # include <sys/utsname.h>
1946     #endif
1947    
1948 root 1.500 ecb_noinline ecb_cold
1949 root 1.480 static unsigned int
1950 root 1.355 ev_linux_version (void)
1951     {
1952     #ifdef __linux
1953 root 1.359 unsigned int v = 0;
1954 root 1.355 struct utsname buf;
1955     int i;
1956     char *p = buf.release;
1957    
1958     if (uname (&buf))
1959     return 0;
1960    
1961     for (i = 3+1; --i; )
1962     {
1963     unsigned int c = 0;
1964    
1965     for (;;)
1966     {
1967     if (*p >= '0' && *p <= '9')
1968     c = c * 10 + *p++ - '0';
1969     else
1970     {
1971     p += *p == '.';
1972     break;
1973     }
1974     }
1975    
1976     v = (v << 8) | c;
1977     }
1978    
1979     return v;
1980     #else
1981     return 0;
1982     #endif
1983     }
1984    
1985     /*****************************************************************************/
1986    
1987 root 1.331 #if EV_AVOID_STDIO
1988 root 1.500 ecb_noinline ecb_cold
1989 root 1.480 static void
1990 root 1.331 ev_printerr (const char *msg)
1991     {
1992     write (STDERR_FILENO, msg, strlen (msg));
1993     }
1994     #endif
1995    
1996 root 1.486 static void (*syserr_cb)(const char *msg) EV_NOEXCEPT;
1997 root 1.69
1998 root 1.480 ecb_cold
1999     void
2000 root 1.486 ev_set_syserr_cb (void (*cb)(const char *msg) EV_NOEXCEPT) EV_NOEXCEPT
2001 root 1.69 {
2002     syserr_cb = cb;
2003     }
2004    
2005 root 1.500 ecb_noinline ecb_cold
2006 root 1.480 static void
2007 root 1.269 ev_syserr (const char *msg)
2008 root 1.69 {
2009 root 1.70 if (!msg)
2010     msg = "(libev) system error";
2011    
2012 root 1.69 if (syserr_cb)
2013 root 1.70 syserr_cb (msg);
2014 root 1.69 else
2015     {
2016 root 1.330 #if EV_AVOID_STDIO
2017 root 1.331 ev_printerr (msg);
2018     ev_printerr (": ");
2019 root 1.365 ev_printerr (strerror (errno));
2020 root 1.331 ev_printerr ("\n");
2021 root 1.330 #else
2022 root 1.70 perror (msg);
2023 root 1.330 #endif
2024 root 1.69 abort ();
2025     }
2026     }
2027    
2028 root 1.224 static void *
2029 root 1.486 ev_realloc_emul (void *ptr, long size) EV_NOEXCEPT
2030 root 1.224 {
2031     /* some systems, notably openbsd and darwin, fail to properly
2032 root 1.335 * implement realloc (x, 0) (as required by both ansi c-89 and
2033 root 1.224 * the single unix specification, so work around them here.
2034 root 1.447 * recently, also (at least) fedora and debian started breaking it,
2035     * despite documenting it otherwise.
2036 root 1.224 */
2037 root 1.333
2038 root 1.224 if (size)
2039     return realloc (ptr, size);
2040    
2041     free (ptr);
2042     return 0;
2043     }
2044    
2045 root 1.486 static void *(*alloc)(void *ptr, long size) EV_NOEXCEPT = ev_realloc_emul;
2046 root 1.69
2047 root 1.480 ecb_cold
2048     void
2049 root 1.486 ev_set_allocator (void *(*cb)(void *ptr, long size) EV_NOEXCEPT) EV_NOEXCEPT
2050 root 1.69 {
2051     alloc = cb;
2052     }
2053    
2054 root 1.150 inline_speed void *
2055 root 1.155 ev_realloc (void *ptr, long size)
2056 root 1.69 {
2057 root 1.224 ptr = alloc (ptr, size);
2058 root 1.69
2059     if (!ptr && size)
2060     {
2061 root 1.330 #if EV_AVOID_STDIO
2062 root 1.365 ev_printerr ("(libev) memory allocation failed, aborting.\n");
2063 root 1.330 #else
2064 root 1.365 fprintf (stderr, "(libev) cannot allocate %ld bytes, aborting.", size);
2065 root 1.330 #endif
2066 root 1.69 abort ();
2067     }
2068    
2069     return ptr;
2070     }
2071    
2072     #define ev_malloc(size) ev_realloc (0, (size))
2073     #define ev_free(ptr) ev_realloc ((ptr), 0)
2074    
2075     /*****************************************************************************/
2076    
2077 root 1.298 /* set in reify when reification needed */
2078     #define EV_ANFD_REIFY 1
2079    
2080 root 1.288 /* file descriptor info structure */
2081 root 1.53 typedef struct
2082     {
2083 root 1.68 WL head;
2084 root 1.288 unsigned char events; /* the events watched for */
2085 root 1.298 unsigned char reify; /* flag set when this ANFD needs reification (EV_ANFD_REIFY, EV__IOFDSET) */
2086 root 1.490 unsigned char emask; /* some backends store the actual kernel mask in here */
2087 root 1.502 unsigned char eflags; /* flags field for use by backends */
2088 root 1.269 #if EV_USE_EPOLL
2089 root 1.288 unsigned int egen; /* generation counter to counter epoll bugs */
2090 root 1.269 #endif
2091 root 1.357 #if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
2092 root 1.103 SOCKET handle;
2093     #endif
2094 root 1.357 #if EV_USE_IOCP
2095     OVERLAPPED or, ow;
2096     #endif
2097 root 1.53 } ANFD;
2098 root 1.1
2099 root 1.288 /* stores the pending event set for a given watcher */
2100 root 1.53 typedef struct
2101     {
2102     W w;
2103 root 1.288 int events; /* the pending event set for the given watcher */
2104 root 1.53 } ANPENDING;
2105 root 1.51
2106 root 1.155 #if EV_USE_INOTIFY
2107 root 1.241 /* hash table entry per inotify-id */
2108 root 1.152 typedef struct
2109     {
2110     WL head;
2111 root 1.155 } ANFS;
2112 root 1.152 #endif
2113    
2114 root 1.241 /* Heap Entry */
2115     #if EV_HEAP_CACHE_AT
2116 root 1.288 /* a heap element */
2117 root 1.241 typedef struct {
2118 root 1.243 ev_tstamp at;
2119 root 1.241 WT w;
2120     } ANHE;
2121    
2122 root 1.248 #define ANHE_w(he) (he).w /* access watcher, read-write */
2123     #define ANHE_at(he) (he).at /* access cached at, read-only */
2124     #define ANHE_at_cache(he) (he).at = (he).w->at /* update at from watcher */
2125 root 1.241 #else
2126 root 1.288 /* a heap element */
2127 root 1.241 typedef WT ANHE;
2128    
2129 root 1.248 #define ANHE_w(he) (he)
2130     #define ANHE_at(he) (he)->at
2131     #define ANHE_at_cache(he)
2132 root 1.241 #endif
2133    
2134 root 1.55 #if EV_MULTIPLICITY
2135 root 1.54
2136 root 1.80 struct ev_loop
2137     {
2138 root 1.86 ev_tstamp ev_rt_now;
2139 root 1.99 #define ev_rt_now ((loop)->ev_rt_now)
2140 root 1.80 #define VAR(name,decl) decl;
2141     #include "ev_vars.h"
2142     #undef VAR
2143     };
2144     #include "ev_wrap.h"
2145    
2146 root 1.116 static struct ev_loop default_loop_struct;
2147 sf-exg 1.402 EV_API_DECL struct ev_loop *ev_default_loop_ptr = 0; /* needs to be initialised to make it a definition despite extern */
2148 root 1.54
2149 root 1.53 #else
2150 root 1.54
2151 root 1.509 EV_API_DECL ev_tstamp ev_rt_now = EV_TS_CONST (0.); /* needs to be initialised to make it a definition despite extern */
2152 root 1.80 #define VAR(name,decl) static decl;
2153     #include "ev_vars.h"
2154     #undef VAR
2155    
2156 root 1.116 static int ev_default_loop_ptr;
2157 root 1.54
2158 root 1.51 #endif
2159 root 1.1
2160 root 1.338 #if EV_FEATURE_API
2161 root 1.500 # define EV_RELEASE_CB if (ecb_expect_false (release_cb)) release_cb (EV_A)
2162     # define EV_ACQUIRE_CB if (ecb_expect_false (acquire_cb)) acquire_cb (EV_A)
2163 root 1.297 # define EV_INVOKE_PENDING invoke_cb (EV_A)
2164     #else
2165 root 1.298 # define EV_RELEASE_CB (void)0
2166     # define EV_ACQUIRE_CB (void)0
2167 root 1.297 # define EV_INVOKE_PENDING ev_invoke_pending (EV_A)
2168     #endif
2169    
2170 root 1.353 #define EVBREAK_RECURSE 0x80
2171 root 1.298
2172 root 1.8 /*****************************************************************************/
2173    
2174 root 1.292 #ifndef EV_HAVE_EV_TIME
2175 root 1.141 ev_tstamp
2176 root 1.486 ev_time (void) EV_NOEXCEPT
2177 root 1.1 {
2178 root 1.29 #if EV_USE_REALTIME
2179 root 1.500 if (ecb_expect_true (have_realtime))
2180 root 1.279 {
2181     struct timespec ts;
2182     clock_gettime (CLOCK_REALTIME, &ts);
2183 root 1.505 return EV_TS_GET (ts);
2184 root 1.279 }
2185     #endif
2186    
2187 root 1.510 {
2188     struct timeval tv;
2189     gettimeofday (&tv, 0);
2190     return EV_TV_GET (tv);
2191     }
2192 root 1.1 }
2193 root 1.292 #endif
2194 root 1.1
2195 root 1.284 inline_size ev_tstamp
2196 root 1.1 get_clock (void)
2197     {
2198 root 1.29 #if EV_USE_MONOTONIC
2199 root 1.500 if (ecb_expect_true (have_monotonic))
2200 root 1.1 {
2201     struct timespec ts;
2202     clock_gettime (CLOCK_MONOTONIC, &ts);
2203 root 1.505 return EV_TS_GET (ts);
2204 root 1.1 }
2205     #endif
2206    
2207     return ev_time ();
2208     }
2209    
2210 root 1.85 #if EV_MULTIPLICITY
2211 root 1.51 ev_tstamp
2212 root 1.486 ev_now (EV_P) EV_NOEXCEPT
2213 root 1.51 {
2214 root 1.85 return ev_rt_now;
2215 root 1.51 }
2216 root 1.85 #endif
2217 root 1.51
2218 root 1.193 void
2219 root 1.486 ev_sleep (ev_tstamp delay) EV_NOEXCEPT
2220 root 1.193 {
2221 root 1.509 if (delay > EV_TS_CONST (0.))
2222 root 1.193 {
2223     #if EV_USE_NANOSLEEP
2224     struct timespec ts;
2225    
2226 root 1.348 EV_TS_SET (ts, delay);
2227 root 1.193 nanosleep (&ts, 0);
2228 root 1.416 #elif defined _WIN32
2229 root 1.482 /* maybe this should round up, as ms is very low resolution */
2230     /* compared to select (µs) or nanosleep (ns) */
2231 root 1.508 Sleep ((unsigned long)(EV_TS_TO_MSEC (delay)));
2232 root 1.193 #else
2233     struct timeval tv;
2234    
2235 root 1.257 /* here we rely on sys/time.h + sys/types.h + unistd.h providing select */
2236 root 1.302 /* something not guaranteed by newer posix versions, but guaranteed */
2237 root 1.257 /* by older ones */
2238 sf-exg 1.349 EV_TV_SET (tv, delay);
2239 root 1.193 select (0, 0, 0, 0, &tv);
2240     #endif
2241     }
2242     }
2243    
2244     /*****************************************************************************/
2245    
2246 root 1.233 #define MALLOC_ROUND 4096 /* prefer to allocate in chunks of this size, must be 2**n and >> 4 longs */
2247 root 1.232
2248 root 1.288 /* find a suitable new size for the given array, */
2249 sf-exg 1.345 /* hopefully by rounding to a nice-to-malloc size */
2250 root 1.284 inline_size int
2251 root 1.163 array_nextsize (int elem, int cur, int cnt)
2252     {
2253     int ncur = cur + 1;
2254    
2255     do
2256     ncur <<= 1;
2257     while (cnt > ncur);
2258    
2259 root 1.400 /* if size is large, round to MALLOC_ROUND - 4 * longs to accommodate malloc overhead */
2260 root 1.232 if (elem * ncur > MALLOC_ROUND - sizeof (void *) * 4)
2261 root 1.163 {
2262     ncur *= elem;
2263 root 1.232 ncur = (ncur + elem + (MALLOC_ROUND - 1) + sizeof (void *) * 4) & ~(MALLOC_ROUND - 1);
2264 root 1.163 ncur = ncur - sizeof (void *) * 4;
2265     ncur /= elem;
2266     }
2267    
2268     return ncur;
2269     }
2270    
2271 root 1.500 ecb_noinline ecb_cold
2272 root 1.480 static void *
2273 root 1.163 array_realloc (int elem, void *base, int *cur, int cnt)
2274     {
2275     *cur = array_nextsize (elem, *cur, cnt);
2276     return ev_realloc (base, elem * *cur);
2277     }
2278 root 1.29
2279 root 1.495 #define array_needsize_noinit(base,offset,count)
2280 root 1.490
2281 root 1.495 #define array_needsize_zerofill(base,offset,count) \
2282     memset ((void *)(base + offset), 0, sizeof (*(base)) * (count))
2283 root 1.265
2284 root 1.74 #define array_needsize(type,base,cur,cnt,init) \
2285 root 1.500 if (ecb_expect_false ((cnt) > (cur))) \
2286 root 1.69 { \
2287 root 1.480 ecb_unused int ocur_ = (cur); \
2288 root 1.163 (base) = (type *)array_realloc \
2289     (sizeof (type), (base), &(cur), (cnt)); \
2290 root 1.495 init ((base), ocur_, ((cur) - ocur_)); \
2291 root 1.1 }
2292    
2293 root 1.163 #if 0
2294 root 1.74 #define array_slim(type,stem) \
2295 root 1.67 if (stem ## max < array_roundsize (stem ## cnt >> 2)) \
2296     { \
2297     stem ## max = array_roundsize (stem ## cnt >> 1); \
2298 root 1.74 base = (type *)ev_realloc (base, sizeof (type) * (stem ## max));\
2299 root 1.67 fprintf (stderr, "slimmed down " # stem " to %d\n", stem ## max);/*D*/\
2300     }
2301 root 1.163 #endif
2302 root 1.67
2303 root 1.65 #define array_free(stem, idx) \
2304 root 1.280 ev_free (stem ## s idx); stem ## cnt idx = stem ## max idx = 0; stem ## s idx = 0
2305 root 1.65
2306 root 1.8 /*****************************************************************************/
2307    
2308 root 1.288 /* dummy callback for pending events */
2309 root 1.500 ecb_noinline
2310 root 1.480 static void
2311 root 1.288 pendingcb (EV_P_ ev_prepare *w, int revents)
2312     {
2313     }
2314    
2315 root 1.500 ecb_noinline
2316 root 1.480 void
2317 root 1.486 ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT
2318 root 1.1 {
2319 root 1.78 W w_ = (W)w;
2320 root 1.171 int pri = ABSPRI (w_);
2321 root 1.78
2322 root 1.500 if (ecb_expect_false (w_->pending))
2323 root 1.171 pendings [pri][w_->pending - 1].events |= revents;
2324     else
2325 root 1.32 {
2326 root 1.171 w_->pending = ++pendingcnt [pri];
2327 root 1.490 array_needsize (ANPENDING, pendings [pri], pendingmax [pri], w_->pending, array_needsize_noinit);
2328 root 1.171 pendings [pri][w_->pending - 1].w = w_;
2329     pendings [pri][w_->pending - 1].events = revents;
2330 root 1.32 }
2331 root 1.425
2332     pendingpri = NUMPRI - 1;
2333 root 1.1 }
2334    
2335 root 1.284 inline_speed void
2336     feed_reverse (EV_P_ W w)
2337     {
2338 root 1.490 array_needsize (W, rfeeds, rfeedmax, rfeedcnt + 1, array_needsize_noinit);
2339 root 1.284 rfeeds [rfeedcnt++] = w;
2340     }
2341    
2342     inline_size void
2343     feed_reverse_done (EV_P_ int revents)
2344     {
2345     do
2346     ev_feed_event (EV_A_ rfeeds [--rfeedcnt], revents);
2347     while (rfeedcnt);
2348     }
2349    
2350     inline_speed void
2351 root 1.51 queue_events (EV_P_ W *events, int eventcnt, int type)
2352 root 1.27 {
2353     int i;
2354    
2355     for (i = 0; i < eventcnt; ++i)
2356 root 1.78 ev_feed_event (EV_A_ events [i], type);
2357 root 1.27 }
2358    
2359 root 1.141 /*****************************************************************************/
2360    
2361 root 1.284 inline_speed void
2362 root 1.337 fd_event_nocheck (EV_P_ int fd, int revents)
2363 root 1.1 {
2364     ANFD *anfd = anfds + fd;
2365 root 1.136 ev_io *w;
2366 root 1.1
2367 root 1.136 for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
2368 root 1.1 {
2369 root 1.79 int ev = w->events & revents;
2370 root 1.1
2371     if (ev)
2372 root 1.78 ev_feed_event (EV_A_ (W)w, ev);
2373 root 1.1 }
2374     }
2375    
2376 root 1.298 /* do not submit kernel events for fds that have reify set */
2377     /* because that means they changed while we were polling for new events */
2378     inline_speed void
2379     fd_event (EV_P_ int fd, int revents)
2380     {
2381     ANFD *anfd = anfds + fd;
2382    
2383 root 1.500 if (ecb_expect_true (!anfd->reify))
2384 root 1.337 fd_event_nocheck (EV_A_ fd, revents);
2385 root 1.298 }
2386    
2387 root 1.79 void
2388 root 1.486 ev_feed_fd_event (EV_P_ int fd, int revents) EV_NOEXCEPT
2389 root 1.79 {
2390 root 1.168 if (fd >= 0 && fd < anfdmax)
2391 root 1.337 fd_event_nocheck (EV_A_ fd, revents);
2392 root 1.79 }
2393    
2394 root 1.288 /* make sure the external fd watch events are in-sync */
2395     /* with the kernel/libev internal state */
2396 root 1.284 inline_size void
2397 root 1.51 fd_reify (EV_P)
2398 root 1.9 {
2399     int i;
2400    
2401 sf-exg 1.537 /* most backends do not modify the fdchanges list in backend_modify.
2402 root 1.519 * except io_uring, which has fixed-size buffers which might force us
2403 root 1.524 * to handle events in backend_modify, causing fdchanges to be amended,
2404 root 1.519 * which could result in an endless loop.
2405     * to avoid this, we do not dynamically handle fds that were added
2406 root 1.524 * during fd_reify. that means that for those backends, fdchangecnt
2407 root 1.519 * might be non-zero during poll, which must cause them to not block.
2408     * to not put too much of a burden on other backends, this detail
2409     * needs to be handled in the backend.
2410     */
2411     int changecnt = fdchangecnt;
2412    
2413 root 1.371 #if EV_SELECT_IS_WINSOCKET || EV_USE_IOCP
2414 root 1.519 for (i = 0; i < changecnt; ++i)
2415 root 1.371 {
2416     int fd = fdchanges [i];
2417     ANFD *anfd = anfds + fd;
2418    
2419 root 1.374 if (anfd->reify & EV__IOFDSET && anfd->head)
2420 root 1.371 {
2421     SOCKET handle = EV_FD_TO_WIN32_HANDLE (fd);
2422    
2423     if (handle != anfd->handle)
2424     {
2425     unsigned long arg;
2426    
2427     assert (("libev: only socket fds supported in this configuration", ioctlsocket (handle, FIONREAD, &arg) == 0));
2428    
2429     /* handle changed, but fd didn't - we need to do it in two steps */
2430     backend_modify (EV_A_ fd, anfd->events, 0);
2431     anfd->events = 0;
2432     anfd->handle = handle;
2433     }
2434     }
2435     }
2436     #endif
2437    
2438 root 1.519 for (i = 0; i < changecnt; ++i)
2439 root 1.27 {
2440     int fd = fdchanges [i];
2441     ANFD *anfd = anfds + fd;
2442 root 1.136 ev_io *w;
2443 root 1.27
2444 root 1.350 unsigned char o_events = anfd->events;
2445     unsigned char o_reify = anfd->reify;
2446 root 1.27
2447 root 1.497 anfd->reify = 0;
2448 root 1.27
2449 root 1.500 /*if (ecb_expect_true (o_reify & EV_ANFD_REIFY)) probably a deoptimisation */
2450 root 1.350 {
2451     anfd->events = 0;
2452 root 1.184
2453 root 1.350 for (w = (ev_io *)anfd->head; w; w = (ev_io *)((WL)w)->next)
2454     anfd->events |= (unsigned char)w->events;
2455 root 1.27
2456 root 1.351 if (o_events != anfd->events)
2457 root 1.350 o_reify = EV__IOFDSET; /* actually |= */
2458     }
2459    
2460     if (o_reify & EV__IOFDSET)
2461     backend_modify (EV_A_ fd, o_events, anfd->events);
2462 root 1.27 }
2463    
2464 root 1.519 /* normally, fdchangecnt hasn't changed. if it has, then new fds have been added.
2465     * this is a rare case (see beginning comment in this function), so we copy them to the
2466     * front and hope the backend handles this case.
2467     */
2468     if (ecb_expect_false (fdchangecnt != changecnt))
2469     memmove (fdchanges, fdchanges + changecnt, (fdchangecnt - changecnt) * sizeof (*fdchanges));
2470    
2471     fdchangecnt -= changecnt;
2472 root 1.27 }
2473    
2474 root 1.288 /* something about the given fd changed */
2475 root 1.480 inline_size
2476     void
2477 root 1.183 fd_change (EV_P_ int fd, int flags)
2478 root 1.27 {
2479 root 1.183 unsigned char reify = anfds [fd].reify;
2480 root 1.527 anfds [fd].reify = reify | flags;
2481 root 1.27
2482 root 1.500 if (ecb_expect_true (!reify))
2483 root 1.183 {
2484     ++fdchangecnt;
2485 root 1.490 array_needsize (int, fdchanges, fdchangemax, fdchangecnt, array_needsize_noinit);
2486 root 1.183 fdchanges [fdchangecnt - 1] = fd;
2487     }
2488 root 1.9 }
2489    
2490 root 1.288 /* the given fd is invalid/unusable, so make sure it doesn't hurt us anymore */
2491 root 1.480 inline_speed ecb_cold void
2492 root 1.51 fd_kill (EV_P_ int fd)
2493 root 1.41 {
2494 root 1.136 ev_io *w;
2495 root 1.41
2496 root 1.136 while ((w = (ev_io *)anfds [fd].head))
2497 root 1.41 {
2498 root 1.51 ev_io_stop (EV_A_ w);
2499 root 1.78 ev_feed_event (EV_A_ (W)w, EV_ERROR | EV_READ | EV_WRITE);
2500 root 1.41 }
2501     }
2502    
2503 root 1.336 /* check whether the given fd is actually valid, for error recovery */
2504 root 1.480 inline_size ecb_cold int
2505 root 1.71 fd_valid (int fd)
2506     {
2507 root 1.103 #ifdef _WIN32
2508 root 1.322 return EV_FD_TO_WIN32_HANDLE (fd) != -1;
2509 root 1.71 #else
2510     return fcntl (fd, F_GETFD) != -1;
2511     #endif
2512     }
2513    
2514 root 1.19 /* called on EBADF to verify fds */
2515 root 1.500 ecb_noinline ecb_cold
2516 root 1.480 static void
2517 root 1.51 fd_ebadf (EV_P)
2518 root 1.19 {
2519     int fd;
2520    
2521     for (fd = 0; fd < anfdmax; ++fd)
2522 root 1.27 if (anfds [fd].events)
2523 root 1.254 if (!fd_valid (fd) && errno == EBADF)
2524 root 1.51 fd_kill (EV_A_ fd);
2525 root 1.41 }
2526    
2527     /* called on ENOMEM in select/poll to kill some fds and retry */
2528 root 1.500 ecb_noinline ecb_cold
2529 root 1.480 static void
2530 root 1.51 fd_enomem (EV_P)
2531 root 1.41 {
2532 root 1.62 int fd;
2533 root 1.41
2534 root 1.62 for (fd = anfdmax; fd--; )
2535 root 1.41 if (anfds [fd].events)
2536     {
2537 root 1.51 fd_kill (EV_A_ fd);
2538 root 1.307 break;
2539 root 1.41 }
2540 root 1.19 }
2541    
2542 root 1.130 /* usually called after fork if backend needs to re-arm all fds from scratch */
2543 root 1.500 ecb_noinline
2544 root 1.480 static void
2545 root 1.56 fd_rearm_all (EV_P)
2546     {
2547     int fd;
2548    
2549     for (fd = 0; fd < anfdmax; ++fd)
2550     if (anfds [fd].events)
2551     {
2552     anfds [fd].events = 0;
2553 root 1.268 anfds [fd].emask = 0;
2554 root 1.298 fd_change (EV_A_ fd, EV__IOFDSET | EV_ANFD_REIFY);
2555 root 1.56 }
2556     }
2557    
2558 root 1.336 /* used to prepare libev internal fd's */
2559     /* this is not fork-safe */
2560     inline_speed void
2561     fd_intern (int fd)
2562     {
2563     #ifdef _WIN32
2564     unsigned long arg = 1;
2565     ioctlsocket (EV_FD_TO_WIN32_HANDLE (fd), FIONBIO, &arg);
2566     #else
2567     fcntl (fd, F_SETFD, FD_CLOEXEC);
2568     fcntl (fd, F_SETFL, O_NONBLOCK);
2569     #endif
2570     }
2571    
2572 root 1.8 /*****************************************************************************/
2573    
2574 root 1.235 /*
2575 sf-exg 1.345 * the heap functions want a real array index. array index 0 is guaranteed to not
2576 root 1.241 * be in-use at any time. the first heap entry is at array [HEAP0]. DHEAP gives
2577     * the branching factor of the d-tree.
2578     */
2579    
2580     /*
2581 root 1.235 * at the moment we allow libev the luxury of two heaps,
2582     * a small-code-size 2-heap one and a ~1.5kb larger 4-heap
2583     * which is more cache-efficient.
2584     * the difference is about 5% with 50000+ watchers.
2585     */
2586 root 1.241 #if EV_USE_4HEAP
2587 root 1.235
2588 root 1.237 #define DHEAP 4
2589     #define HEAP0 (DHEAP - 1) /* index of first element in heap */
2590 root 1.247 #define HPARENT(k) ((((k) - HEAP0 - 1) / DHEAP) + HEAP0)
2591 root 1.248 #define UPHEAP_DONE(p,k) ((p) == (k))
2592 root 1.235
2593     /* away from the root */
2594 root 1.284 inline_speed void
2595 root 1.241 downheap (ANHE *heap, int N, int k)
2596 root 1.235 {
2597 root 1.241 ANHE he = heap [k];
2598     ANHE *E = heap + N + HEAP0;
2599 root 1.235
2600     for (;;)
2601     {
2602     ev_tstamp minat;
2603 root 1.241 ANHE *minpos;
2604 root 1.248 ANHE *pos = heap + DHEAP * (k - HEAP0) + HEAP0 + 1;
2605 root 1.235
2606 root 1.248 /* find minimum child */
2607 root 1.500 if (ecb_expect_true (pos + DHEAP - 1 < E))
2608 root 1.235 {
2609 root 1.245 /* fast path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
2610 root 1.506 if ( minat > ANHE_at (pos [1])) (minpos = pos + 1), (minat = ANHE_at (*minpos));
2611     if ( minat > ANHE_at (pos [2])) (minpos = pos + 2), (minat = ANHE_at (*minpos));
2612     if ( minat > ANHE_at (pos [3])) (minpos = pos + 3), (minat = ANHE_at (*minpos));
2613 root 1.235 }
2614 root 1.240 else if (pos < E)
2615 root 1.235 {
2616 root 1.241 /* slow path */ (minpos = pos + 0), (minat = ANHE_at (*minpos));
2617 root 1.506 if (pos + 1 < E && minat > ANHE_at (pos [1])) (minpos = pos + 1), (minat = ANHE_at (*minpos));
2618     if (pos + 2 < E && minat > ANHE_at (pos [2])) (minpos = pos + 2), (minat = ANHE_at (*minpos));
2619     if (pos + 3 < E && minat > ANHE_at (pos [3])) (minpos = pos + 3), (minat = ANHE_at (*minpos));
2620 root 1.235 }
2621 root 1.240 else
2622     break;
2623 root 1.235
2624 root 1.241 if (ANHE_at (he) <= minat)
2625 root 1.235 break;
2626    
2627 root 1.247 heap [k] = *minpos;
2628 root 1.241 ev_active (ANHE_w (*minpos)) = k;
2629 root 1.235
2630     k = minpos - heap;
2631     }
2632    
2633 root 1.247 heap [k] = he;
2634 root 1.241 ev_active (ANHE_w (he)) = k;
2635 root 1.235 }
2636    
2637 root 1.506 #else /* not 4HEAP */
2638 root 1.235
2639     #define HEAP0 1
2640 root 1.247 #define HPARENT(k) ((k) >> 1)
2641 root 1.248 #define UPHEAP_DONE(p,k) (!(p))
2642 root 1.235
2643 root 1.248 /* away from the root */
2644 root 1.284 inline_speed void
2645 root 1.248 downheap (ANHE *heap, int N, int k)
2646 root 1.1 {
2647 root 1.241 ANHE he = heap [k];
2648 root 1.1
2649 root 1.228 for (;;)
2650 root 1.1 {
2651 root 1.248 int c = k << 1;
2652 root 1.179
2653 root 1.309 if (c >= N + HEAP0)
2654 root 1.179 break;
2655    
2656 root 1.248 c += c + 1 < N + HEAP0 && ANHE_at (heap [c]) > ANHE_at (heap [c + 1])
2657     ? 1 : 0;
2658    
2659     if (ANHE_at (he) <= ANHE_at (heap [c]))
2660     break;
2661    
2662     heap [k] = heap [c];
2663 root 1.241 ev_active (ANHE_w (heap [k])) = k;
2664 root 1.248
2665     k = c;
2666 root 1.1 }
2667    
2668 root 1.243 heap [k] = he;
2669 root 1.248 ev_active (ANHE_w (he)) = k;
2670 root 1.1 }
2671 root 1.248 #endif
2672 root 1.1
2673 root 1.248 /* towards the root */
2674 root 1.284 inline_speed void
2675 root 1.248 upheap (ANHE *heap, int k)
2676 root 1.1 {
2677 root 1.241 ANHE he = heap [k];
2678 root 1.1
2679 root 1.179 for (;;)
2680 root 1.1 {
2681 root 1.248 int p = HPARENT (k);
2682 root 1.179
2683 root 1.248 if (UPHEAP_DONE (p, k) || ANHE_at (heap [p]) <= ANHE_at (he))
2684 root 1.179 break;
2685 root 1.1
2686 root 1.248 heap [k] = heap [p];
2687 root 1.241 ev_active (ANHE_w (heap [k])) = k;
2688 root 1.248 k = p;
2689 root 1.1 }
2690    
2691 root 1.241 heap [k] = he;
2692     ev_active (ANHE_w (he)) = k;
2693 root 1.1 }
2694    
2695 root 1.288 /* move an element suitably so it is in a correct place */
2696 root 1.284 inline_size void
2697 root 1.241 adjustheap (ANHE *heap, int N, int k)
2698 root 1.84 {
2699 root 1.310 if (k > HEAP0 && ANHE_at (heap [k]) <= ANHE_at (heap [HPARENT (k)]))
2700 root 1.247 upheap (heap, k);
2701     else
2702     downheap (heap, N, k);
2703 root 1.84 }
2704    
2705 root 1.248 /* rebuild the heap: this function is used only once and executed rarely */
2706 root 1.284 inline_size void
2707 root 1.248 reheap (ANHE *heap, int N)
2708     {
2709     int i;
2710 root 1.251
2711 root 1.248 /* we don't use floyds algorithm, upheap is simpler and is more cache-efficient */
2712     /* also, this is easy to implement and correct for both 2-heaps and 4-heaps */
2713     for (i = 0; i < N; ++i)
2714     upheap (heap, i + HEAP0);
2715     }
2716    
2717 root 1.8 /*****************************************************************************/
2718    
2719 root 1.522 /* associate signal watchers to a signal */
2720 root 1.7 typedef struct
2721     {
2722 root 1.307 EV_ATOMIC_T pending;
2723 root 1.306 #if EV_MULTIPLICITY
2724     EV_P;
2725     #endif
2726 root 1.68 WL head;
2727 root 1.7 } ANSIG;
2728    
2729 root 1.306 static ANSIG signals [EV_NSIG - 1];
2730 root 1.7
2731 root 1.207 /*****************************************************************************/
2732    
2733 root 1.336 #if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2734 root 1.207
2735 root 1.500 ecb_noinline ecb_cold
2736 root 1.480 static void
2737 root 1.207 evpipe_init (EV_P)
2738     {
2739 root 1.288 if (!ev_is_active (&pipe_w))
2740 root 1.207 {
2741 root 1.448 int fds [2];
2742    
2743 root 1.336 # if EV_USE_EVENTFD
2744 root 1.448 fds [0] = -1;
2745     fds [1] = eventfd (0, EFD_NONBLOCK | EFD_CLOEXEC);
2746     if (fds [1] < 0 && errno == EINVAL)
2747     fds [1] = eventfd (0, 0);
2748    
2749     if (fds [1] < 0)
2750     # endif
2751     {
2752     while (pipe (fds))
2753     ev_syserr ("(libev) error creating signal/async pipe");
2754    
2755     fd_intern (fds [0]);
2756 root 1.220 }
2757 root 1.448
2758     evpipe [0] = fds [0];
2759    
2760     if (evpipe [1] < 0)
2761     evpipe [1] = fds [1]; /* first call, set write fd */
2762 root 1.220 else
2763     {
2764 root 1.448 /* on subsequent calls, do not change evpipe [1] */
2765     /* so that evpipe_write can always rely on its value. */
2766     /* this branch does not do anything sensible on windows, */
2767     /* so must not be executed on windows */
2768 root 1.207
2769 root 1.448 dup2 (fds [1], evpipe [1]);
2770     close (fds [1]);
2771 root 1.220 }
2772 root 1.207
2773 root 1.455 fd_intern (evpipe [1]);
2774    
2775 root 1.448 ev_io_set (&pipe_w, evpipe [0] < 0 ? evpipe [1] : evpipe [0], EV_READ);
2776 root 1.288 ev_io_start (EV_A_ &pipe_w);
2777 root 1.210 ev_unref (EV_A); /* watcher should not keep loop alive */
2778 root 1.207 }
2779     }
2780    
2781 root 1.380 inline_speed void
2782 root 1.214 evpipe_write (EV_P_ EV_ATOMIC_T *flag)
2783 root 1.207 {
2784 root 1.424 ECB_MEMORY_FENCE; /* push out the write before this function was called, acquire flag */
2785    
2786 root 1.500 if (ecb_expect_true (*flag))
2787 root 1.387 return;
2788 root 1.383
2789     *flag = 1;
2790 root 1.384 ECB_MEMORY_FENCE_RELEASE; /* make sure flag is visible before the wakeup */
2791 root 1.383
2792     pipe_write_skipped = 1;
2793 root 1.378
2794 root 1.384 ECB_MEMORY_FENCE; /* make sure pipe_write_skipped is visible before we check pipe_write_wanted */
2795 root 1.214
2796 root 1.383 if (pipe_write_wanted)
2797     {
2798     int old_errno;
2799 root 1.378
2800 root 1.436 pipe_write_skipped = 0;
2801     ECB_MEMORY_FENCE_RELEASE;
2802 root 1.220
2803 root 1.383 old_errno = errno; /* save errno because write will clobber it */
2804 root 1.380
2805 root 1.220 #if EV_USE_EVENTFD
2806 root 1.448 if (evpipe [0] < 0)
2807 root 1.383 {
2808     uint64_t counter = 1;
2809 root 1.448 write (evpipe [1], &counter, sizeof (uint64_t));
2810 root 1.383 }
2811     else
2812 root 1.220 #endif
2813 root 1.383 {
2814 root 1.427 #ifdef _WIN32
2815     WSABUF buf;
2816     DWORD sent;
2817 root 1.485 buf.buf = (char *)&buf;
2818 root 1.427 buf.len = 1;
2819     WSASend (EV_FD_TO_WIN32_HANDLE (evpipe [1]), &buf, 1, &sent, 0, 0, 0);
2820     #else
2821 root 1.383 write (evpipe [1], &(evpipe [1]), 1);
2822 root 1.427 #endif
2823 root 1.383 }
2824 root 1.214
2825 root 1.383 errno = old_errno;
2826 root 1.207 }
2827     }
2828    
2829 root 1.288 /* called whenever the libev signal pipe */
2830     /* got some events (signal, async) */
2831 root 1.207 static void
2832     pipecb (EV_P_ ev_io *iow, int revents)
2833     {
2834 root 1.307 int i;
2835    
2836 root 1.378 if (revents & EV_READ)
2837     {
2838 root 1.220 #if EV_USE_EVENTFD
2839 root 1.448 if (evpipe [0] < 0)
2840 root 1.378 {
2841     uint64_t counter;
2842 root 1.448 read (evpipe [1], &counter, sizeof (uint64_t));
2843 root 1.378 }
2844     else
2845 root 1.220 #endif
2846 root 1.378 {
2847 root 1.427 char dummy[4];
2848     #ifdef _WIN32
2849     WSABUF buf;
2850     DWORD recvd;
2851 root 1.432 DWORD flags = 0;
2852 root 1.427 buf.buf = dummy;
2853     buf.len = sizeof (dummy);
2854 root 1.432 WSARecv (EV_FD_TO_WIN32_HANDLE (evpipe [0]), &buf, 1, &recvd, &flags, 0, 0);
2855 root 1.427 #else
2856     read (evpipe [0], &dummy, sizeof (dummy));
2857     #endif
2858 root 1.378 }
2859 root 1.220 }
2860 root 1.207
2861 root 1.378 pipe_write_skipped = 0;
2862    
2863 root 1.424 ECB_MEMORY_FENCE; /* push out skipped, acquire flags */
2864    
2865 root 1.369 #if EV_SIGNAL_ENABLE
2866 root 1.307 if (sig_pending)
2867 root 1.372 {
2868 root 1.307 sig_pending = 0;
2869 root 1.207
2870 root 1.436 ECB_MEMORY_FENCE;
2871 root 1.424
2872 root 1.307 for (i = EV_NSIG - 1; i--; )
2873 root 1.500 if (ecb_expect_false (signals [i].pending))
2874 root 1.307 ev_feed_signal_event (EV_A_ i + 1);
2875 root 1.207 }
2876 root 1.369 #endif
2877 root 1.207
2878 root 1.209 #if EV_ASYNC_ENABLE
2879 root 1.307 if (async_pending)
2880 root 1.207 {
2881 root 1.307 async_pending = 0;
2882 root 1.207
2883 root 1.436 ECB_MEMORY_FENCE;
2884 root 1.424
2885 root 1.207 for (i = asynccnt; i--; )
2886     if (asyncs [i]->sent)
2887     {
2888     asyncs [i]->sent = 0;
2889 root 1.436 ECB_MEMORY_FENCE_RELEASE;
2890 root 1.207 ev_feed_event (EV_A_ asyncs [i], EV_ASYNC);
2891     }
2892     }
2893 root 1.209 #endif
2894 root 1.207 }
2895    
2896     /*****************************************************************************/
2897    
2898 root 1.366 void
2899 root 1.486 ev_feed_signal (int signum) EV_NOEXCEPT
2900 root 1.7 {
2901 root 1.207 #if EV_MULTIPLICITY
2902 root 1.453 EV_P;
2903 root 1.449 ECB_MEMORY_FENCE_ACQUIRE;
2904 root 1.453 EV_A = signals [signum - 1].loop;
2905 root 1.366
2906     if (!EV_A)
2907     return;
2908 root 1.207 #endif
2909    
2910 root 1.366 signals [signum - 1].pending = 1;
2911     evpipe_write (EV_A_ &sig_pending);
2912     }
2913    
2914     static void
2915     ev_sighandler (int signum)
2916     {
2917 root 1.322 #ifdef _WIN32
2918 root 1.218 signal (signum, ev_sighandler);
2919 root 1.67 #endif
2920    
2921 root 1.366 ev_feed_signal (signum);
2922 root 1.7 }
2923    
2924 root 1.500 ecb_noinline
2925 root 1.480 void
2926 root 1.486 ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT
2927 root 1.79 {
2928 root 1.80 WL w;
2929    
2930 root 1.500 if (ecb_expect_false (signum <= 0 || signum >= EV_NSIG))
2931 root 1.307 return;
2932    
2933     --signum;
2934    
2935 root 1.79 #if EV_MULTIPLICITY
2936 root 1.307 /* it is permissible to try to feed a signal to the wrong loop */
2937     /* or, likely more useful, feeding a signal nobody is waiting for */
2938 root 1.79
2939 root 1.500 if (ecb_expect_false (signals [signum].loop != EV_A))
2940 root 1.306 return;
2941 root 1.307 #endif
2942 root 1.306
2943 root 1.307 signals [signum].pending = 0;
2944 root 1.438 ECB_MEMORY_FENCE_RELEASE;
2945 root 1.79
2946     for (w = signals [signum].head; w; w = w->next)
2947     ev_feed_event (EV_A_ (W)w, EV_SIGNAL);
2948     }
2949    
2950 root 1.303 #if EV_USE_SIGNALFD
2951     static void
2952     sigfdcb (EV_P_ ev_io *iow, int revents)
2953     {
2954 root 1.306 struct signalfd_siginfo si[2], *sip; /* these structs are big */
2955 root 1.303
2956     for (;;)
2957     {
2958     ssize_t res = read (sigfd, si, sizeof (si));
2959    
2960     /* not ISO-C, as res might be -1, but works with SuS */
2961     for (sip = si; (char *)sip < (char *)si + res; ++sip)
2962     ev_feed_signal_event (EV_A_ sip->ssi_signo);
2963    
2964     if (res < (ssize_t)sizeof (si))
2965     break;
2966     }
2967     }
2968     #endif
2969    
2970 root 1.336 #endif
2971    
2972 root 1.8 /*****************************************************************************/
2973    
2974 root 1.336 #if EV_CHILD_ENABLE
2975 root 1.182 static WL childs [EV_PID_HASHSIZE];
2976 root 1.71
2977 root 1.136 static ev_signal childev;
2978 root 1.59
2979 root 1.206 #ifndef WIFCONTINUED
2980     # define WIFCONTINUED(status) 0
2981     #endif
2982    
2983 root 1.288 /* handle a single child status event */
2984 root 1.284 inline_speed void
2985 root 1.216 child_reap (EV_P_ int chain, int pid, int status)
2986 root 1.47 {
2987 root 1.136 ev_child *w;
2988 root 1.206 int traced = WIFSTOPPED (status) || WIFCONTINUED (status);
2989 root 1.47
2990 root 1.338 for (w = (ev_child *)childs [chain & ((EV_PID_HASHSIZE) - 1)]; w; w = (ev_child *)((WL)w)->next)
2991 root 1.206 {
2992     if ((w->pid == pid || !w->pid)
2993     && (!traced || (w->flags & 1)))
2994     {
2995 root 1.216 ev_set_priority (w, EV_MAXPRI); /* need to do it *now*, this *must* be the same prio as the signal watcher itself */
2996 root 1.206 w->rpid = pid;
2997     w->rstatus = status;
2998     ev_feed_event (EV_A_ (W)w, EV_CHILD);
2999     }
3000     }
3001 root 1.47 }
3002    
3003 root 1.142 #ifndef WCONTINUED
3004     # define WCONTINUED 0
3005     #endif
3006    
3007 root 1.288 /* called on sigchld etc., calls waitpid */
3008 root 1.47 static void
3009 root 1.136 childcb (EV_P_ ev_signal *sw, int revents)
3010 root 1.22 {
3011     int pid, status;
3012    
3013 root 1.142 /* some systems define WCONTINUED but then fail to support it (linux 2.4) */
3014     if (0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED | WCONTINUED)))
3015     if (!WCONTINUED
3016     || errno != EINVAL
3017     || 0 >= (pid = waitpid (-1, &status, WNOHANG | WUNTRACED)))
3018     return;
3019    
3020 root 1.216 /* make sure we are called again until all children have been reaped */
3021 root 1.142 /* we need to do it this way so that the callback gets called before we continue */
3022     ev_feed_event (EV_A_ (W)sw, EV_SIGNAL);
3023 root 1.47
3024 root 1.216 child_reap (EV_A_ pid, pid, status);
3025 root 1.338 if ((EV_PID_HASHSIZE) > 1)
3026 root 1.216 child_reap (EV_A_ 0, pid, status); /* this might trigger a watcher twice, but feed_event catches that */
3027 root 1.22 }
3028    
3029 root 1.45 #endif
3030    
3031 root 1.22 /*****************************************************************************/
3032    
3033 root 1.515 #if EV_USE_TIMERFD
3034    
3035     static void periodics_reschedule (EV_P);
3036    
3037     static void
3038     timerfdcb (EV_P_ ev_io *iow, int revents)
3039     {
3040     struct itimerspec its = { 0 };
3041    
3042 root 1.523 its.it_value.tv_sec = ev_rt_now + (int)MAX_BLOCKTIME2;
3043 root 1.515 timerfd_settime (timerfd, TFD_TIMER_ABSTIME | TFD_TIMER_CANCEL_ON_SET, &its, 0);
3044    
3045     ev_rt_now = ev_time ();
3046     /* periodics_reschedule only needs ev_rt_now */
3047     /* but maybe in the future we want the full treatment. */
3048     /*
3049     now_floor = EV_TS_CONST (0.);
3050     time_update (EV_A_ EV_TSTAMP_HUGE);
3051     */
3052 root 1.525 #if EV_PERIODIC_ENABLE
3053 root 1.515 periodics_reschedule (EV_A);
3054 root 1.525 #endif
3055 root 1.515 }
3056    
3057     ecb_noinline ecb_cold
3058     static void
3059     evtimerfd_init (EV_P)
3060     {
3061     if (!ev_is_active (&timerfd_w))
3062     {
3063     timerfd = timerfd_create (CLOCK_REALTIME, TFD_NONBLOCK | TFD_CLOEXEC);
3064    
3065     if (timerfd >= 0)
3066     {
3067     fd_intern (timerfd); /* just to be sure */
3068    
3069     ev_io_init (&timerfd_w, timerfdcb, timerfd, EV_READ);
3070 root 1.516 ev_set_priority (&timerfd_w, EV_MINPRI);
3071 root 1.515 ev_io_start (EV_A_ &timerfd_w);
3072     ev_unref (EV_A); /* watcher should not keep loop alive */
3073    
3074     /* (re-) arm timer */
3075     timerfdcb (EV_A_ 0, 0);
3076     }
3077     }
3078     }
3079    
3080     #endif
3081    
3082     /*****************************************************************************/
3083    
3084 root 1.357 #if EV_USE_IOCP
3085     # include "ev_iocp.c"
3086     #endif
3087 root 1.118 #if EV_USE_PORT
3088     # include "ev_port.c"
3089     #endif
3090 root 1.44 #if EV_USE_KQUEUE
3091     # include "ev_kqueue.c"
3092     #endif
3093 root 1.493 #if EV_USE_EPOLL
3094     # include "ev_epoll.c"
3095     #endif
3096 root 1.490 #if EV_USE_LINUXAIO
3097     # include "ev_linuxaio.c"
3098     #endif
3099 root 1.501 #if EV_USE_IOURING
3100     # include "ev_iouring.c"
3101     #endif
3102 root 1.59 #if EV_USE_POLL
3103 root 1.41 # include "ev_poll.c"
3104     #endif
3105 root 1.29 #if EV_USE_SELECT
3106 root 1.1 # include "ev_select.c"
3107     #endif
3108    
3109 root 1.480 ecb_cold int
3110 root 1.486 ev_version_major (void) EV_NOEXCEPT
3111 root 1.24 {
3112     return EV_VERSION_MAJOR;
3113     }
3114    
3115 root 1.480 ecb_cold int
3116 root 1.486 ev_version_minor (void) EV_NOEXCEPT
3117 root 1.24 {
3118     return EV_VERSION_MINOR;
3119     }
3120    
3121 root 1.49 /* return true if we are running with elevated privileges and should ignore env variables */
3122 root 1.480 inline_size ecb_cold int
3123 root 1.51 enable_secure (void)
3124 root 1.41 {
3125 root 1.103 #ifdef _WIN32
3126 root 1.49 return 0;
3127     #else
3128 root 1.41 return getuid () != geteuid ()
3129     || getgid () != getegid ();
3130 root 1.49 #endif
3131 root 1.41 }
3132    
3133 root 1.480 ecb_cold
3134     unsigned int
3135 root 1.486 ev_supported_backends (void) EV_NOEXCEPT
3136 root 1.129 {
3137 root 1.130 unsigned int flags = 0;
3138 root 1.129
3139 root 1.520 if (EV_USE_PORT ) flags |= EVBACKEND_PORT;
3140     if (EV_USE_KQUEUE ) flags |= EVBACKEND_KQUEUE;
3141     if (EV_USE_EPOLL ) flags |= EVBACKEND_EPOLL;
3142     if (EV_USE_LINUXAIO ) flags |= EVBACKEND_LINUXAIO;
3143     if (EV_USE_IOURING && ev_linux_version () >= 0x050601) flags |= EVBACKEND_IOURING; /* 5.6.1+ */
3144     if (EV_USE_POLL ) flags |= EVBACKEND_POLL;
3145     if (EV_USE_SELECT ) flags |= EVBACKEND_SELECT;
3146    
3147 root 1.129 return flags;
3148     }
3149    
3150 root 1.480 ecb_cold
3151     unsigned int
3152 root 1.486 ev_recommended_backends (void) EV_NOEXCEPT
3153 root 1.1 {
3154 root 1.131 unsigned int flags = ev_supported_backends ();
3155 root 1.129
3156     #ifndef __NetBSD__
3157     /* kqueue is borked on everything but netbsd apparently */
3158     /* it usually doesn't work correctly on anything but sockets and pipes */
3159     flags &= ~EVBACKEND_KQUEUE;
3160     #endif
3161     #ifdef __APPLE__
3162 root 1.278 /* only select works correctly on that "unix-certified" platform */
3163     flags &= ~EVBACKEND_KQUEUE; /* horribly broken, even for sockets */
3164     flags &= ~EVBACKEND_POLL; /* poll is based on kqueue from 10.5 onwards */
3165 root 1.129 #endif
3166 root 1.342 #ifdef __FreeBSD__
3167     flags &= ~EVBACKEND_POLL; /* poll return value is unusable (http://forums.freebsd.org/archive/index.php/t-10270.html) */
3168     #endif
3169 root 1.129
3170 root 1.491 /* TODO: linuxaio is very experimental */
3171 root 1.494 #if !EV_RECOMMEND_LINUXAIO
3172 root 1.491 flags &= ~EVBACKEND_LINUXAIO;
3173 root 1.494 #endif
3174 root 1.532 /* TODO: iouring is super experimental */
3175 root 1.501 #if !EV_RECOMMEND_IOURING
3176     flags &= ~EVBACKEND_IOURING;
3177     #endif
3178 root 1.491
3179 root 1.129 return flags;
3180 root 1.51 }
3181    
3182 root 1.480 ecb_cold
3183     unsigned int
3184 root 1.486 ev_embeddable_backends (void) EV_NOEXCEPT
3185 root 1.134 {
3186 root 1.521 int flags = EVBACKEND_EPOLL | EVBACKEND_KQUEUE | EVBACKEND_PORT | EVBACKEND_IOURING;
3187 root 1.196
3188 root 1.192 /* epoll embeddability broken on all linux versions up to at least 2.6.23 */
3189 root 1.355 if (ev_linux_version () < 0x020620) /* disable it on linux < 2.6.32 */
3190     flags &= ~EVBACKEND_EPOLL;
3191 root 1.196
3192 root 1.502 /* EVBACKEND_LINUXAIO is theoretically embeddable, but suffers from a performance overhead */
3193    
3194 root 1.196 return flags;
3195 root 1.134 }
3196    
3197     unsigned int
3198 root 1.486 ev_backend (EV_P) EV_NOEXCEPT
3199 root 1.130 {
3200     return backend;
3201     }
3202    
3203 root 1.338 #if EV_FEATURE_API
3204 root 1.162 unsigned int
3205 root 1.486 ev_iteration (EV_P) EV_NOEXCEPT
3206 root 1.162 {
3207     return loop_count;
3208     }
3209    
3210 root 1.294 unsigned int
3211 root 1.486 ev_depth (EV_P) EV_NOEXCEPT
3212 root 1.294 {
3213     return loop_depth;
3214     }
3215    
3216 root 1.193 void
3217 root 1.486 ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT
3218 root 1.193 {
3219     io_blocktime = interval;
3220     }
3221    
3222     void
3223 root 1.486 ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT
3224 root 1.193 {
3225     timeout_blocktime = interval;
3226     }
3227    
3228 root 1.297 void
3229 root 1.486 ev_set_userdata (EV_P_ void *data) EV_NOEXCEPT
3230 root 1.297 {
3231     userdata = data;
3232     }
3233    
3234     void *
3235 root 1.486 ev_userdata (EV_P) EV_NOEXCEPT
3236 root 1.297 {
3237     return userdata;
3238     }
3239    
3240 root 1.379 void
3241 root 1.486 ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_NOEXCEPT
3242 root 1.297 {
3243     invoke_cb = invoke_pending_cb;
3244     }
3245    
3246 root 1.379 void
3247 root 1.486 ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_NOEXCEPT, void (*acquire)(EV_P) EV_NOEXCEPT) EV_NOEXCEPT
3248 root 1.297 {
3249 root 1.298 release_cb = release;
3250     acquire_cb = acquire;
3251 root 1.297 }
3252     #endif
3253    
3254 root 1.288 /* initialise a loop structure, must be zero-initialised */
3255 root 1.500 ecb_noinline ecb_cold
3256 root 1.480 static void
3257 root 1.486 loop_init (EV_P_ unsigned int flags) EV_NOEXCEPT
3258 root 1.51 {
3259 root 1.130 if (!backend)
3260 root 1.23 {
3261 root 1.366 origflags = flags;
3262    
3263 root 1.279 #if EV_USE_REALTIME
3264     if (!have_realtime)
3265     {
3266     struct timespec ts;
3267    
3268     if (!clock_gettime (CLOCK_REALTIME, &ts))
3269     have_realtime = 1;
3270     }
3271     #endif
3272    
3273 root 1.29 #if EV_USE_MONOTONIC
3274 root 1.279 if (!have_monotonic)
3275     {
3276     struct timespec ts;
3277    
3278     if (!clock_gettime (CLOCK_MONOTONIC, &ts))
3279     have_monotonic = 1;
3280     }
3281 root 1.1 #endif
3282    
3283 root 1.306 /* pid check not overridable via env */
3284     #ifndef _WIN32
3285     if (flags & EVFLAG_FORKCHECK)
3286     curpid = getpid ();
3287     #endif
3288    
3289     if (!(flags & EVFLAG_NOENV)
3290     && !enable_secure ()
3291     && getenv ("LIBEV_FLAGS"))
3292     flags = atoi (getenv ("LIBEV_FLAGS"));
3293    
3294 root 1.378 ev_rt_now = ev_time ();
3295     mn_now = get_clock ();
3296     now_floor = mn_now;
3297     rtmn_diff = ev_rt_now - mn_now;
3298 root 1.338 #if EV_FEATURE_API
3299 root 1.378 invoke_cb = ev_invoke_pending;
3300 root 1.297 #endif
3301 root 1.1
3302 root 1.378 io_blocktime = 0.;
3303     timeout_blocktime = 0.;
3304     backend = 0;
3305     backend_fd = -1;
3306     sig_pending = 0;
3307 root 1.307 #if EV_ASYNC_ENABLE
3308 root 1.378 async_pending = 0;
3309 root 1.307 #endif
3310 root 1.378 pipe_write_skipped = 0;
3311     pipe_write_wanted = 0;
3312 root 1.448 evpipe [0] = -1;
3313     evpipe [1] = -1;
3314 root 1.209 #if EV_USE_INOTIFY
3315 root 1.378 fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;
3316 root 1.209 #endif
3317 root 1.303 #if EV_USE_SIGNALFD
3318 root 1.378 sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;
3319 root 1.303 #endif
3320 root 1.515 #if EV_USE_TIMERFD
3321     timerfd = flags & EVFLAG_NOTIMERFD ? -1 : -2;
3322     #endif
3323 root 1.193
3324 root 1.366 if (!(flags & EVBACKEND_MASK))
3325 root 1.129 flags |= ev_recommended_backends ();
3326 root 1.41
3327 root 1.357 #if EV_USE_IOCP
3328 root 1.490 if (!backend && (flags & EVBACKEND_IOCP )) backend = iocp_init (EV_A_ flags);
3329 root 1.357 #endif
3330 root 1.118 #if EV_USE_PORT
3331 root 1.490 if (!backend && (flags & EVBACKEND_PORT )) backend = port_init (EV_A_ flags);
3332 root 1.118 #endif
3333 root 1.44 #if EV_USE_KQUEUE
3334 root 1.490 if (!backend && (flags & EVBACKEND_KQUEUE )) backend = kqueue_init (EV_A_ flags);
3335     #endif
3336 root 1.501 #if EV_USE_IOURING
3337     if (!backend && (flags & EVBACKEND_IOURING )) backend = iouring_init (EV_A_ flags);
3338     #endif
3339 root 1.490 #if EV_USE_LINUXAIO
3340     if (!backend && (flags & EVBACKEND_LINUXAIO)) backend = linuxaio_init (EV_A_ flags);
3341 root 1.44 #endif
3342 root 1.29 #if EV_USE_EPOLL
3343 root 1.490 if (!backend && (flags & EVBACKEND_EPOLL )) backend = epoll_init (EV_A_ flags);
3344 root 1.41 #endif
3345 root 1.59 #if EV_USE_POLL
3346 root 1.490 if (!backend && (flags & EVBACKEND_POLL )) backend = poll_init (EV_A_ flags);
3347 root 1.1 #endif
3348 root 1.29 #if EV_USE_SELECT
3349 root 1.490 if (!backend && (flags & EVBACKEND_SELECT )) backend = select_init (EV_A_ flags);
3350 root 1.1 #endif
3351 root 1.70
3352 root 1.288 ev_prepare_init (&pending_w, pendingcb);
3353    
3354 root 1.336 #if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
3355 root 1.288 ev_init (&pipe_w, pipecb);
3356     ev_set_priority (&pipe_w, EV_MAXPRI);
3357 root 1.336 #endif
3358 root 1.56 }
3359     }
3360    
3361 root 1.288 /* free up a loop structure */
3362 root 1.480 ecb_cold
3363     void
3364 root 1.422 ev_loop_destroy (EV_P)
3365 root 1.56 {
3366 root 1.65 int i;
3367    
3368 root 1.364 #if EV_MULTIPLICITY
3369 root 1.363 /* mimic free (0) */
3370     if (!EV_A)
3371     return;
3372 root 1.364 #endif
3373 root 1.363
3374 root 1.361 #if EV_CLEANUP_ENABLE
3375     /* queue cleanup watchers (and execute them) */
3376 root 1.500 if (ecb_expect_false (cleanupcnt))
3377 root 1.361 {
3378     queue_events (EV_A_ (W *)cleanups, cleanupcnt, EV_CLEANUP);
3379     EV_INVOKE_PENDING;
3380     }
3381     #endif
3382    
3383 root 1.359 #if EV_CHILD_ENABLE
3384 root 1.433 if (ev_is_default_loop (EV_A) && ev_is_active (&childev))
3385 root 1.359 {
3386     ev_ref (EV_A); /* child watcher */
3387     ev_signal_stop (EV_A_ &childev);
3388     }
3389     #endif
3390    
3391 root 1.288 if (ev_is_active (&pipe_w))
3392 root 1.207 {
3393 root 1.303 /*ev_ref (EV_A);*/
3394     /*ev_io_stop (EV_A_ &pipe_w);*/
3395 root 1.207
3396 root 1.448 if (evpipe [0] >= 0) EV_WIN32_CLOSE_FD (evpipe [0]);
3397     if (evpipe [1] >= 0) EV_WIN32_CLOSE_FD (evpipe [1]);
3398 root 1.207 }
3399    
3400 root 1.303 #if EV_USE_SIGNALFD
3401     if (ev_is_active (&sigfd_w))
3402 root 1.317 close (sigfd);
3403 root 1.303 #endif
3404    
3405 root 1.515 #if EV_USE_TIMERFD
3406     if (ev_is_active (&timerfd_w))
3407     close (timerfd);
3408     #endif