ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/libev/ev.c
(Generate patch)

Comparing libev/ev.c (file contents):
Revision 1.445 by root, Sat Jun 2 11:15:29 2012 UTC vs.
Revision 1.462 by root, Sun Jan 5 02:59:36 2014 UTC

… …
241#elif defined SIGARRAYSIZE 241#elif defined SIGARRAYSIZE
242# define EV_NSIG (SIGARRAYSIZE) /* Assume ary[SIGARRAYSIZE] */ 242# define EV_NSIG (SIGARRAYSIZE) /* Assume ary[SIGARRAYSIZE] */
243#elif defined _sys_nsig 243#elif defined _sys_nsig
244# define EV_NSIG (_sys_nsig) /* Solaris 2.5 */ 244# define EV_NSIG (_sys_nsig) /* Solaris 2.5 */
245#else 245#else
246# error "unable to find value for NSIG, please report" 246# define EV_NSIG (8 * sizeof (sigset_t) + 1)
247/* to make it compile regardless, just remove the above line, */
248/* but consider reporting it, too! :) */
249# define EV_NSIG 65
250#endif 247#endif
251 248
252#ifndef EV_USE_FLOOR 249#ifndef EV_USE_FLOOR
253# define EV_USE_FLOOR 0 250# define EV_USE_FLOOR 0
254#endif 251#endif
255 252
256#ifndef EV_USE_CLOCK_SYSCALL 253#ifndef EV_USE_CLOCK_SYSCALL
257# if __linux && __GLIBC__ >= 2 254# if __linux && __GLIBC__ == 2 && __GLIBC_MINOR__ < 17
258# define EV_USE_CLOCK_SYSCALL EV_FEATURE_OS 255# define EV_USE_CLOCK_SYSCALL EV_FEATURE_OS
259# else 256# else
260# define EV_USE_CLOCK_SYSCALL 0 257# define EV_USE_CLOCK_SYSCALL 0
261# endif 258# endif
262#endif 259#endif
… …
355# define EV_USE_4HEAP EV_FEATURE_DATA 352# define EV_USE_4HEAP EV_FEATURE_DATA
356#endif 353#endif
357 354
358#ifndef EV_HEAP_CACHE_AT 355#ifndef EV_HEAP_CACHE_AT
359# define EV_HEAP_CACHE_AT EV_FEATURE_DATA 356# define EV_HEAP_CACHE_AT EV_FEATURE_DATA
357#endif
358
359#ifdef ANDROID
360/* supposedly, android doesn't typedef fd_mask */
361# undef EV_USE_SELECT
362# define EV_USE_SELECT 0
363/* supposedly, we need to include syscall.h, not sys/syscall.h, so just disable */
364# undef EV_USE_CLOCK_SYSCALL
365# define EV_USE_CLOCK_SYSCALL 0
366#endif
367
368/* aix's poll.h seems to cause lots of trouble */
369#ifdef _AIX
370/* AIX has a completely broken poll.h header */
371# undef EV_USE_POLL
372# define EV_USE_POLL 0
360#endif 373#endif
361 374
362/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */ 375/* on linux, we can use a (slow) syscall to avoid a dependency on pthread, */
363/* which makes programs even slower. might work on other unices, too. */ 376/* which makes programs even slower. might work on other unices, too. */
364#if EV_USE_CLOCK_SYSCALL 377#if EV_USE_CLOCK_SYSCALL
… …
372# define EV_USE_CLOCK_SYSCALL 0 385# define EV_USE_CLOCK_SYSCALL 0
373# endif 386# endif
374#endif 387#endif
375 388
376/* this block fixes any misconfiguration where we know we run into trouble otherwise */ 389/* this block fixes any misconfiguration where we know we run into trouble otherwise */
377
378#ifdef _AIX
379/* AIX has a completely broken poll.h header */
380# undef EV_USE_POLL
381# define EV_USE_POLL 0
382#endif
383 390
384#ifndef CLOCK_MONOTONIC 391#ifndef CLOCK_MONOTONIC
385# undef EV_USE_MONOTONIC 392# undef EV_USE_MONOTONIC
386# define EV_USE_MONOTONIC 0 393# define EV_USE_MONOTONIC 0
387#endif 394#endif
… …
475/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */ 482/* the following is ecb.h embedded into libev - use update_ev_c to update from an external copy */
476/* ECB.H BEGIN */ 483/* ECB.H BEGIN */
477/* 484/*
478 * libecb - http://software.schmorp.de/pkg/libecb 485 * libecb - http://software.schmorp.de/pkg/libecb
479 * 486 *
480 * Copyright (©) 2009-2012 Marc Alexander Lehmann <libecb@schmorp.de> 487 * Copyright (©) 2009-2013 Marc Alexander Lehmann <libecb@schmorp.de>
481 * Copyright (©) 2011 Emanuele Giaquinta 488 * Copyright (©) 2011 Emanuele Giaquinta
482 * All rights reserved. 489 * All rights reserved.
483 * 490 *
484 * Redistribution and use in source and binary forms, with or without modifica- 491 * Redistribution and use in source and binary forms, with or without modifica-
485 * tion, are permitted provided that the following conditions are met: 492 * tion, are permitted provided that the following conditions are met:
… …
505 512
506#ifndef ECB_H 513#ifndef ECB_H
507#define ECB_H 514#define ECB_H
508 515
509/* 16 bits major, 16 bits minor */ 516/* 16 bits major, 16 bits minor */
510#define ECB_VERSION 0x00010001 517#define ECB_VERSION 0x00010003
511 518
512#ifdef _WIN32 519#ifdef _WIN32
513 typedef signed char int8_t; 520 typedef signed char int8_t;
514 typedef unsigned char uint8_t; 521 typedef unsigned char uint8_t;
515 typedef signed short int16_t; 522 typedef signed short int16_t;
… …
530 #else 537 #else
531 #define ECB_PTRSIZE 4 538 #define ECB_PTRSIZE 4
532 typedef uint32_t uintptr_t; 539 typedef uint32_t uintptr_t;
533 typedef int32_t intptr_t; 540 typedef int32_t intptr_t;
534 #endif 541 #endif
535 typedef intptr_t ptrdiff_t;
536#else 542#else
537 #include <inttypes.h> 543 #include <inttypes.h>
538 #if UINTMAX_MAX > 0xffffffffU 544 #if UINTMAX_MAX > 0xffffffffU
539 #define ECB_PTRSIZE 8 545 #define ECB_PTRSIZE 8
540 #else 546 #else
541 #define ECB_PTRSIZE 4 547 #define ECB_PTRSIZE 4
548 #endif
549#endif
550
551/* work around x32 idiocy by defining proper macros */
552#if __amd64 || __x86_64 || _M_AMD64 || _M_X64
553 #if _ILP32
554 #define ECB_AMD64_X32 1
555 #else
556 #define ECB_AMD64 1
542 #endif 557 #endif
543#endif 558#endif
544 559
545/* many compilers define _GNUC_ to some versions but then only implement 560/* many compilers define _GNUC_ to some versions but then only implement
546 * what their idiot authors think are the "more important" extensions, 561 * what their idiot authors think are the "more important" extensions,
… …
560#define ECB_C (__STDC__+0) /* this assumes that __STDC__ is either empty or a number */ 575#define ECB_C (__STDC__+0) /* this assumes that __STDC__ is either empty or a number */
561#define ECB_C99 (__STDC_VERSION__ >= 199901L) 576#define ECB_C99 (__STDC_VERSION__ >= 199901L)
562#define ECB_C11 (__STDC_VERSION__ >= 201112L) 577#define ECB_C11 (__STDC_VERSION__ >= 201112L)
563#define ECB_CPP (__cplusplus+0) 578#define ECB_CPP (__cplusplus+0)
564#define ECB_CPP11 (__cplusplus >= 201103L) 579#define ECB_CPP11 (__cplusplus >= 201103L)
580
581#if ECB_CPP
582 #define ECB_EXTERN_C extern "C"
583 #define ECB_EXTERN_C_BEG ECB_EXTERN_C {
584 #define ECB_EXTERN_C_END }
585#else
586 #define ECB_EXTERN_C extern
587 #define ECB_EXTERN_C_BEG
588 #define ECB_EXTERN_C_END
589#endif
565 590
566/*****************************************************************************/ 591/*****************************************************************************/
567 592
568/* ECB_NO_THREADS - ecb is not used by multiple threads, ever */ 593/* ECB_NO_THREADS - ecb is not used by multiple threads, ever */
569/* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */ 594/* ECB_NO_SMP - ecb might be used in multiple threads, but only on a single cpu */
… …
592 || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__ 617 || defined __ARM_ARCH_6K__ || defined __ARM_ARCH_6ZK__
593 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory") 618 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mcr p15,0,%0,c7,c10,5" : : "r" (0) : "memory")
594 #elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \ 619 #elif defined __ARM_ARCH_7__ || defined __ARM_ARCH_7A__ \
595 || defined __ARM_ARCH_7M__ || defined __ARM_ARCH_7R__ 620 || defined __ARM_ARCH_7M__ || defined __ARM_ARCH_7R__
596 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory") 621 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("dmb" : : : "memory")
597 #elif __sparc || __sparc__ 622 #elif (__sparc || __sparc__) && !__sparcv8
598 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad" : : : "memory") 623 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad | #StoreStore | #StoreLoad" : : : "memory")
599 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory") 624 #define ECB_MEMORY_FENCE_ACQUIRE __asm__ __volatile__ ("membar #LoadStore | #LoadLoad" : : : "memory")
600 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore") 625 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("membar #LoadStore | #StoreStore")
601 #elif defined __s390__ || defined __s390x__ 626 #elif defined __s390__ || defined __s390x__
602 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory") 627 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("bcr 15,0" : : : "memory")
603 #elif defined __mips__ 628 #elif defined __mips__
629 /* GNU/Linux emulates sync on mips1 architectures, so we force its use */
630 /* anybody else who still uses mips1 is supposed to send in their version, with detection code. */
604 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("sync" : : : "memory") 631 #define ECB_MEMORY_FENCE __asm__ __volatile__ (".set mips2; sync; .set mips0" : : : "memory")
605 #elif defined __alpha__ 632 #elif defined __alpha__
606 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mb" : : : "memory") 633 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mb" : : : "memory")
607 #elif defined __hppa__ 634 #elif defined __hppa__
608 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory") 635 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
609 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("") 636 #define ECB_MEMORY_FENCE_RELEASE __asm__ __volatile__ ("")
610 #elif defined __ia64__ 637 #elif defined __ia64__
611 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mf" : : : "memory") 638 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("mf" : : : "memory")
639 #elif defined __m68k__
640 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
641 #elif defined __m88k__
642 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("tb1 0,%%r0,128" : : : "memory")
643 #elif defined __sh__
644 #define ECB_MEMORY_FENCE __asm__ __volatile__ ("" : : : "memory")
612 #endif 645 #endif
613 #endif 646 #endif
614#endif 647#endif
615 648
616#ifndef ECB_MEMORY_FENCE 649#ifndef ECB_MEMORY_FENCE
617 #if ECB_GCC_VERSION(4,7) 650 #if ECB_GCC_VERSION(4,7)
618 /* see comment below (stdatomic.h) about the C11 memory model. */ 651 /* see comment below (stdatomic.h) about the C11 memory model. */
619 #define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST) 652 #define ECB_MEMORY_FENCE __atomic_thread_fence (__ATOMIC_SEQ_CST)
653
654 /* The __has_feature syntax from clang is so misdesigned that we cannot use it
655 * without risking compile time errors with other compilers. We *could*
656 * define our own ecb_clang_has_feature, but I just can't be bothered to work
657 * around this shit time and again.
620 #elif defined __clang && __has_feature (cxx_atomic) 658 * #elif defined __clang && __has_feature (cxx_atomic)
621 /* see comment below (stdatomic.h) about the C11 memory model. */ 659 * // see comment below (stdatomic.h) about the C11 memory model.
622 #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST) 660 * #define ECB_MEMORY_FENCE __c11_atomic_thread_fence (__ATOMIC_SEQ_CST)
661 */
662
623 #elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__ 663 #elif ECB_GCC_VERSION(4,4) || defined __INTEL_COMPILER || defined __clang__
624 #define ECB_MEMORY_FENCE __sync_synchronize () 664 #define ECB_MEMORY_FENCE __sync_synchronize ()
665 #elif _MSC_VER >= 1500 /* VC++ 2008 */
666 /* apparently, microsoft broke all the memory barrier stuff in Visual Studio 2008... */
667 #pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
668 #define ECB_MEMORY_FENCE _ReadWriteBarrier (); MemoryBarrier()
669 #define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier (); MemoryBarrier() /* according to msdn, _ReadBarrier is not a load fence */
670 #define ECB_MEMORY_FENCE_RELEASE _WriteBarrier (); MemoryBarrier()
625 #elif _MSC_VER >= 1400 /* VC++ 2005 */ 671 #elif _MSC_VER >= 1400 /* VC++ 2005 */
626 #pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier) 672 #pragma intrinsic(_ReadBarrier,_WriteBarrier,_ReadWriteBarrier)
627 #define ECB_MEMORY_FENCE _ReadWriteBarrier () 673 #define ECB_MEMORY_FENCE _ReadWriteBarrier ()
628 #define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */ 674 #define ECB_MEMORY_FENCE_ACQUIRE _ReadWriteBarrier () /* according to msdn, _ReadBarrier is not a load fence */
629 #define ECB_MEMORY_FENCE_RELEASE _WriteBarrier () 675 #define ECB_MEMORY_FENCE_RELEASE _WriteBarrier ()
… …
935 ecb_inline void ecb_unreachable (void) ecb_noreturn; 981 ecb_inline void ecb_unreachable (void) ecb_noreturn;
936 ecb_inline void ecb_unreachable (void) { } 982 ecb_inline void ecb_unreachable (void) { }
937#endif 983#endif
938 984
939/* try to tell the compiler that some condition is definitely true */ 985/* try to tell the compiler that some condition is definitely true */
940#define ecb_assume(cond) do { if (!(cond)) ecb_unreachable (); } while (0) 986#define ecb_assume(cond) if (!(cond)) ecb_unreachable (); else 0
941 987
942ecb_inline unsigned char ecb_byteorder_helper (void) ecb_const; 988ecb_inline unsigned char ecb_byteorder_helper (void) ecb_const;
943ecb_inline unsigned char 989ecb_inline unsigned char
944ecb_byteorder_helper (void) 990ecb_byteorder_helper (void)
945{ 991{
946 const uint32_t u = 0x11223344; 992 /* the union code still generates code under pressure in gcc, */
947 return *(unsigned char *)&u; 993 /* but less than using pointers, and always seems to */
994 /* successfully return a constant. */
995 /* the reason why we have this horrible preprocessor mess */
996 /* is to avoid it in all cases, at least on common architectures */
997 /* or when using a recent enough gcc version (>= 4.6) */
998#if __i386 || __i386__ || _M_X86 || __amd64 || __amd64__ || _M_X64
999 return 0x44;
1000#elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
1001 return 0x44;
1002#elif __BYTE_ORDER__ && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
1003 return 0x11;
1004#else
1005 union
1006 {
1007 uint32_t i;
1008 uint8_t c;
1009 } u = { 0x11223344 };
1010 return u.c;
1011#endif
948} 1012}
949 1013
950ecb_inline ecb_bool ecb_big_endian (void) ecb_const; 1014ecb_inline ecb_bool ecb_big_endian (void) ecb_const;
951ecb_inline ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; } 1015ecb_inline ecb_bool ecb_big_endian (void) { return ecb_byteorder_helper () == 0x11; }
952ecb_inline ecb_bool ecb_little_endian (void) ecb_const; 1016ecb_inline ecb_bool ecb_little_endian (void) ecb_const;
… …
983 } 1047 }
984#else 1048#else
985 #define ecb_array_length(name) (sizeof (name) / sizeof (name [0])) 1049 #define ecb_array_length(name) (sizeof (name) / sizeof (name [0]))
986#endif 1050#endif
987 1051
1052/*******************************************************************************/
1053/* floating point stuff, can be disabled by defining ECB_NO_LIBM */
1054
1055/* basically, everything uses "ieee pure-endian" floating point numbers */
1056/* the only noteworthy exception is ancient armle, which uses order 43218765 */
1057#if 0 \
1058 || __i386 || __i386__ \
1059 || __amd64 || __amd64__ || __x86_64 || __x86_64__ \
1060 || __powerpc__ || __ppc__ || __powerpc64__ || __ppc64__ \
1061 || defined __arm__ && defined __ARM_EABI__ \
1062 || defined __s390__ || defined __s390x__ \
1063 || defined __mips__ \
1064 || defined __alpha__ \
1065 || defined __hppa__ \
1066 || defined __ia64__ \
1067 || defined __m68k__ \
1068 || defined __m88k__ \
1069 || defined __sh__ \
1070 || defined _M_IX86 || defined _M_AMD64 || defined _M_IA64
1071 #define ECB_STDFP 1
1072 #include <string.h> /* for memcpy */
1073#else
1074 #define ECB_STDFP 0
1075#endif
1076
1077#ifndef ECB_NO_LIBM
1078
1079 #include <math.h> /* for frexp*, ldexp*, INFINITY, NAN */
1080
1081 /* only the oldest of old doesn't have this one. solaris. */
1082 #ifdef INFINITY
1083 #define ECB_INFINITY INFINITY
1084 #else
1085 #define ECB_INFINITY HUGE_VAL
1086 #endif
1087
1088 #ifdef NAN
1089 #define ECB_NAN NAN
1090 #else
1091 #define ECB_NAN ECB_INFINITY
1092 #endif
1093
1094 /* converts an ieee half/binary16 to a float */
1095 ecb_function_ float ecb_binary16_to_float (uint16_t x) ecb_const;
1096 ecb_function_ float
1097 ecb_binary16_to_float (uint16_t x)
1098 {
1099 int e = (x >> 10) & 0x1f;
1100 int m = x & 0x3ff;
1101 float r;
1102
1103 if (!e ) r = ldexpf (m , -24);
1104 else if (e != 31) r = ldexpf (m + 0x400, e - 25);
1105 else if (m ) r = ECB_NAN;
1106 else r = ECB_INFINITY;
1107
1108 return x & 0x8000 ? -r : r;
1109 }
1110
1111 /* convert a float to ieee single/binary32 */
1112 ecb_function_ uint32_t ecb_float_to_binary32 (float x) ecb_const;
1113 ecb_function_ uint32_t
1114 ecb_float_to_binary32 (float x)
1115 {
1116 uint32_t r;
1117
1118 #if ECB_STDFP
1119 memcpy (&r, &x, 4);
1120 #else
1121 /* slow emulation, works for anything but -0 */
1122 uint32_t m;
1123 int e;
1124
1125 if (x == 0e0f ) return 0x00000000U;
1126 if (x > +3.40282346638528860e+38f) return 0x7f800000U;
1127 if (x < -3.40282346638528860e+38f) return 0xff800000U;
1128 if (x != x ) return 0x7fbfffffU;
1129
1130 m = frexpf (x, &e) * 0x1000000U;
1131
1132 r = m & 0x80000000U;
1133
1134 if (r)
1135 m = -m;
1136
1137 if (e <= -126)
1138 {
1139 m &= 0xffffffU;
1140 m >>= (-125 - e);
1141 e = -126;
1142 }
1143
1144 r |= (e + 126) << 23;
1145 r |= m & 0x7fffffU;
1146 #endif
1147
1148 return r;
1149 }
1150
1151 /* converts an ieee single/binary32 to a float */
1152 ecb_function_ float ecb_binary32_to_float (uint32_t x) ecb_const;
1153 ecb_function_ float
1154 ecb_binary32_to_float (uint32_t x)
1155 {
1156 float r;
1157
1158 #if ECB_STDFP
1159 memcpy (&r, &x, 4);
1160 #else
1161 /* emulation, only works for normals and subnormals and +0 */
1162 int neg = x >> 31;
1163 int e = (x >> 23) & 0xffU;
1164
1165 x &= 0x7fffffU;
1166
1167 if (e)
1168 x |= 0x800000U;
1169 else
1170 e = 1;
1171
1172 /* we distrust ldexpf a bit and do the 2**-24 scaling by an extra multiply */
1173 r = ldexpf (x * (0.5f / 0x800000U), e - 126);
1174
1175 r = neg ? -r : r;
1176 #endif
1177
1178 return r;
1179 }
1180
1181 /* convert a double to ieee double/binary64 */
1182 ecb_function_ uint64_t ecb_double_to_binary64 (double x) ecb_const;
1183 ecb_function_ uint64_t
1184 ecb_double_to_binary64 (double x)
1185 {
1186 uint64_t r;
1187
1188 #if ECB_STDFP
1189 memcpy (&r, &x, 8);
1190 #else
1191 /* slow emulation, works for anything but -0 */
1192 uint64_t m;
1193 int e;
1194
1195 if (x == 0e0 ) return 0x0000000000000000U;
1196 if (x > +1.79769313486231470e+308) return 0x7ff0000000000000U;
1197 if (x < -1.79769313486231470e+308) return 0xfff0000000000000U;
1198 if (x != x ) return 0X7ff7ffffffffffffU;
1199
1200 m = frexp (x, &e) * 0x20000000000000U;
1201
1202 r = m & 0x8000000000000000;;
1203
1204 if (r)
1205 m = -m;
1206
1207 if (e <= -1022)
1208 {
1209 m &= 0x1fffffffffffffU;
1210 m >>= (-1021 - e);
1211 e = -1022;
1212 }
1213
1214 r |= ((uint64_t)(e + 1022)) << 52;
1215 r |= m & 0xfffffffffffffU;
1216 #endif
1217
1218 return r;
1219 }
1220
1221 /* converts an ieee double/binary64 to a double */
1222 ecb_function_ double ecb_binary64_to_double (uint64_t x) ecb_const;
1223 ecb_function_ double
1224 ecb_binary64_to_double (uint64_t x)
1225 {
1226 double r;
1227
1228 #if ECB_STDFP
1229 memcpy (&r, &x, 8);
1230 #else
1231 /* emulation, only works for normals and subnormals and +0 */
1232 int neg = x >> 63;
1233 int e = (x >> 52) & 0x7ffU;
1234
1235 x &= 0xfffffffffffffU;
1236
1237 if (e)
1238 x |= 0x10000000000000U;
1239 else
1240 e = 1;
1241
1242 /* we distrust ldexp a bit and do the 2**-53 scaling by an extra multiply */
1243 r = ldexp (x * (0.5 / 0x10000000000000U), e - 1022);
1244
1245 r = neg ? -r : r;
1246 #endif
1247
1248 return r;
1249 }
1250
1251#endif
1252
988#endif 1253#endif
989 1254
990/* ECB.H END */ 1255/* ECB.H END */
991 1256
992#if ECB_MEMORY_FENCE_NEEDS_PTHREADS 1257#if ECB_MEMORY_FENCE_NEEDS_PTHREADS
… …
1191} 1456}
1192 1457
1193static void * 1458static void *
1194ev_realloc_emul (void *ptr, long size) EV_THROW 1459ev_realloc_emul (void *ptr, long size) EV_THROW
1195{ 1460{
1196#if __GLIBC__
1197 return realloc (ptr, size);
1198#else
1199 /* some systems, notably openbsd and darwin, fail to properly 1461 /* some systems, notably openbsd and darwin, fail to properly
1200 * implement realloc (x, 0) (as required by both ansi c-89 and 1462 * implement realloc (x, 0) (as required by both ansi c-89 and
1201 * the single unix specification, so work around them here. 1463 * the single unix specification, so work around them here.
1464 * recently, also (at least) fedora and debian started breaking it,
1465 * despite documenting it otherwise.
1202 */ 1466 */
1203 1467
1204 if (size) 1468 if (size)
1205 return realloc (ptr, size); 1469 return realloc (ptr, size);
1206 1470
1207 free (ptr); 1471 free (ptr);
1208 return 0; 1472 return 0;
1209#endif
1210} 1473}
1211 1474
1212static void *(*alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul; 1475static void *(*alloc)(void *ptr, long size) EV_THROW = ev_realloc_emul;
1213 1476
1214void ecb_cold 1477void ecb_cold
… …
1869static void noinline ecb_cold 2132static void noinline ecb_cold
1870evpipe_init (EV_P) 2133evpipe_init (EV_P)
1871{ 2134{
1872 if (!ev_is_active (&pipe_w)) 2135 if (!ev_is_active (&pipe_w))
1873 { 2136 {
2137 int fds [2];
2138
1874# if EV_USE_EVENTFD 2139# if EV_USE_EVENTFD
2140 fds [0] = -1;
1875 evfd = eventfd (0, EFD_NONBLOCK | EFD_CLOEXEC); 2141 fds [1] = eventfd (0, EFD_NONBLOCK | EFD_CLOEXEC);
1876 if (evfd < 0 && errno == EINVAL) 2142 if (fds [1] < 0 && errno == EINVAL)
1877 evfd = eventfd (0, 0); 2143 fds [1] = eventfd (0, 0);
1878 2144
1879 if (evfd >= 0) 2145 if (fds [1] < 0)
1880 {
1881 evpipe [0] = -1;
1882 fd_intern (evfd); /* doing it twice doesn't hurt */
1883 ev_io_set (&pipe_w, evfd, EV_READ);
1884 }
1885 else
1886# endif 2146# endif
1887 { 2147 {
1888 while (pipe (evpipe)) 2148 while (pipe (fds))
1889 ev_syserr ("(libev) error creating signal/async pipe"); 2149 ev_syserr ("(libev) error creating signal/async pipe");
1890 2150
1891 fd_intern (evpipe [0]); 2151 fd_intern (fds [0]);
1892 fd_intern (evpipe [1]);
1893 ev_io_set (&pipe_w, evpipe [0], EV_READ);
1894 } 2152 }
1895 2153
2154 evpipe [0] = fds [0];
2155
2156 if (evpipe [1] < 0)
2157 evpipe [1] = fds [1]; /* first call, set write fd */
2158 else
2159 {
2160 /* on subsequent calls, do not change evpipe [1] */
2161 /* so that evpipe_write can always rely on its value. */
2162 /* this branch does not do anything sensible on windows, */
2163 /* so must not be executed on windows */
2164
2165 dup2 (fds [1], evpipe [1]);
2166 close (fds [1]);
2167 }
2168
2169 fd_intern (evpipe [1]);
2170
2171 ev_io_set (&pipe_w, evpipe [0] < 0 ? evpipe [1] : evpipe [0], EV_READ);
1896 ev_io_start (EV_A_ &pipe_w); 2172 ev_io_start (EV_A_ &pipe_w);
1897 ev_unref (EV_A); /* watcher should not keep loop alive */ 2173 ev_unref (EV_A); /* watcher should not keep loop alive */
1898 } 2174 }
1899} 2175}
1900 2176
… …
1921 ECB_MEMORY_FENCE_RELEASE; 2197 ECB_MEMORY_FENCE_RELEASE;
1922 2198
1923 old_errno = errno; /* save errno because write will clobber it */ 2199 old_errno = errno; /* save errno because write will clobber it */
1924 2200
1925#if EV_USE_EVENTFD 2201#if EV_USE_EVENTFD
1926 if (evfd >= 0) 2202 if (evpipe [0] < 0)
1927 { 2203 {
1928 uint64_t counter = 1; 2204 uint64_t counter = 1;
1929 write (evfd, &counter, sizeof (uint64_t)); 2205 write (evpipe [1], &counter, sizeof (uint64_t));
1930 } 2206 }
1931 else 2207 else
1932#endif 2208#endif
1933 { 2209 {
1934#ifdef _WIN32 2210#ifdef _WIN32
… …
1954 int i; 2230 int i;
1955 2231
1956 if (revents & EV_READ) 2232 if (revents & EV_READ)
1957 { 2233 {
1958#if EV_USE_EVENTFD 2234#if EV_USE_EVENTFD
1959 if (evfd >= 0) 2235 if (evpipe [0] < 0)
1960 { 2236 {
1961 uint64_t counter; 2237 uint64_t counter;
1962 read (evfd, &counter, sizeof (uint64_t)); 2238 read (evpipe [1], &counter, sizeof (uint64_t));
1963 } 2239 }
1964 else 2240 else
1965#endif 2241#endif
1966 { 2242 {
1967 char dummy[4]; 2243 char dummy[4];
… …
2017 2293
2018void 2294void
2019ev_feed_signal (int signum) EV_THROW 2295ev_feed_signal (int signum) EV_THROW
2020{ 2296{
2021#if EV_MULTIPLICITY 2297#if EV_MULTIPLICITY
2298 EV_P;
2299 ECB_MEMORY_FENCE_ACQUIRE;
2022 EV_P = signals [signum - 1].loop; 2300 EV_A = signals [signum - 1].loop;
2023 2301
2024 if (!EV_A) 2302 if (!EV_A)
2025 return; 2303 return;
2026#endif 2304#endif
2027 2305
2028 if (!ev_active (&pipe_w))
2029 return;
2030
2031 signals [signum - 1].pending = 1; 2306 signals [signum - 1].pending = 1;
2032 evpipe_write (EV_A_ &sig_pending); 2307 evpipe_write (EV_A_ &sig_pending);
2033} 2308}
2034 2309
2035static void 2310static void
… …
2045void noinline 2320void noinline
2046ev_feed_signal_event (EV_P_ int signum) EV_THROW 2321ev_feed_signal_event (EV_P_ int signum) EV_THROW
2047{ 2322{
2048 WL w; 2323 WL w;
2049 2324
2050 if (expect_false (signum <= 0 || signum > EV_NSIG)) 2325 if (expect_false (signum <= 0 || signum >= EV_NSIG))
2051 return; 2326 return;
2052 2327
2053 --signum; 2328 --signum;
2054 2329
2055#if EV_MULTIPLICITY 2330#if EV_MULTIPLICITY
… …
2283{ 2558{
2284 return userdata; 2559 return userdata;
2285} 2560}
2286 2561
2287void 2562void
2288ev_set_invoke_pending_cb (EV_P_ void (*invoke_pending_cb)(EV_P)) EV_THROW 2563ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_THROW
2289{ 2564{
2290 invoke_cb = invoke_pending_cb; 2565 invoke_cb = invoke_pending_cb;
2291} 2566}
2292 2567
2293void 2568void
2294ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_THROW, void (*acquire)(EV_P) EV_THROW) EV_THROW 2569ev_set_loop_release_cb (EV_P_ ev_loop_callback_nothrow release, ev_loop_callback_nothrow acquire) EV_THROW
2295{ 2570{
2296 release_cb = release; 2571 release_cb = release;
2297 acquire_cb = acquire; 2572 acquire_cb = acquire;
2298} 2573}
2299#endif 2574#endif
… …
2353#if EV_ASYNC_ENABLE 2628#if EV_ASYNC_ENABLE
2354 async_pending = 0; 2629 async_pending = 0;
2355#endif 2630#endif
2356 pipe_write_skipped = 0; 2631 pipe_write_skipped = 0;
2357 pipe_write_wanted = 0; 2632 pipe_write_wanted = 0;
2633 evpipe [0] = -1;
2634 evpipe [1] = -1;
2358#if EV_USE_INOTIFY 2635#if EV_USE_INOTIFY
2359 fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2; 2636 fs_fd = flags & EVFLAG_NOINOTIFY ? -1 : -2;
2360#endif 2637#endif
2361#if EV_USE_SIGNALFD 2638#if EV_USE_SIGNALFD
2362 sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1; 2639 sigfd = flags & EVFLAG_SIGNALFD ? -2 : -1;
… …
2425 if (ev_is_active (&pipe_w)) 2702 if (ev_is_active (&pipe_w))
2426 { 2703 {
2427 /*ev_ref (EV_A);*/ 2704 /*ev_ref (EV_A);*/
2428 /*ev_io_stop (EV_A_ &pipe_w);*/ 2705 /*ev_io_stop (EV_A_ &pipe_w);*/
2429 2706
2430#if EV_USE_EVENTFD
2431 if (evfd >= 0)
2432 close (evfd);
2433#endif
2434
2435 if (evpipe [0] >= 0)
2436 {
2437 EV_WIN32_CLOSE_FD (evpipe [0]); 2707 if (evpipe [0] >= 0) EV_WIN32_CLOSE_FD (evpipe [0]);
2438 EV_WIN32_CLOSE_FD (evpipe [1]); 2708 if (evpipe [1] >= 0) EV_WIN32_CLOSE_FD (evpipe [1]);
2439 }
2440 } 2709 }
2441 2710
2442#if EV_USE_SIGNALFD 2711#if EV_USE_SIGNALFD
2443 if (ev_is_active (&sigfd_w)) 2712 if (ev_is_active (&sigfd_w))
2444 close (sigfd); 2713 close (sigfd);
… …
2530#endif 2799#endif
2531#if EV_USE_INOTIFY 2800#if EV_USE_INOTIFY
2532 infy_fork (EV_A); 2801 infy_fork (EV_A);
2533#endif 2802#endif
2534 2803
2804#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2535 if (ev_is_active (&pipe_w)) 2805 if (ev_is_active (&pipe_w))
2536 { 2806 {
2537 /* pipe_write_wanted must be false now, so modifying fd vars should be safe */ 2807 /* pipe_write_wanted must be false now, so modifying fd vars should be safe */
2538 2808
2539 ev_ref (EV_A); 2809 ev_ref (EV_A);
2540 ev_io_stop (EV_A_ &pipe_w); 2810 ev_io_stop (EV_A_ &pipe_w);
2541 2811
2542#if EV_USE_EVENTFD
2543 if (evfd >= 0)
2544 close (evfd);
2545#endif
2546
2547 if (evpipe [0] >= 0) 2812 if (evpipe [0] >= 0)
2548 {
2549 EV_WIN32_CLOSE_FD (evpipe [0]); 2813 EV_WIN32_CLOSE_FD (evpipe [0]);
2550 EV_WIN32_CLOSE_FD (evpipe [1]);
2551 }
2552 2814
2553#if EV_SIGNAL_ENABLE || EV_ASYNC_ENABLE
2554 evpipe_init (EV_A); 2815 evpipe_init (EV_A);
2555 /* iterate over everything, in case we missed something before */ 2816 /* iterate over everything, in case we missed something before */
2556 ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM); 2817 ev_feed_event (EV_A_ &pipe_w, EV_CUSTOM);
2557#endif
2558 } 2818 }
2819#endif
2559 2820
2560 postfork = 0; 2821 postfork = 0;
2561} 2822}
2562 2823
2563#if EV_MULTIPLICITY 2824#if EV_MULTIPLICITY
… …
3532#if EV_MULTIPLICITY 3793#if EV_MULTIPLICITY
3533 assert (("libev: a signal must not be attached to two different loops", 3794 assert (("libev: a signal must not be attached to two different loops",
3534 !signals [w->signum - 1].loop || signals [w->signum - 1].loop == loop)); 3795 !signals [w->signum - 1].loop || signals [w->signum - 1].loop == loop));
3535 3796
3536 signals [w->signum - 1].loop = EV_A; 3797 signals [w->signum - 1].loop = EV_A;
3798 ECB_MEMORY_FENCE_RELEASE;
3537#endif 3799#endif
3538 3800
3539 EV_FREQUENT_CHECK; 3801 EV_FREQUENT_CHECK;
3540 3802
3541#if EV_USE_SIGNALFD 3803#if EV_USE_SIGNALFD
… …
3696# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX) 3958# define EV_INOTIFY_BUFSIZE (sizeof (struct inotify_event) * 2 + NAME_MAX)
3697 3959
3698static void noinline 3960static void noinline
3699infy_add (EV_P_ ev_stat *w) 3961infy_add (EV_P_ ev_stat *w)
3700{ 3962{
3701 w->wd = inotify_add_watch (fs_fd, w->path, IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY | IN_DONT_FOLLOW | IN_MASK_ADD); 3963 w->wd = inotify_add_watch (fs_fd, w->path,
3964 IN_ATTRIB | IN_DELETE_SELF | IN_MOVE_SELF | IN_MODIFY
3965 | IN_CREATE | IN_DELETE | IN_MOVED_FROM | IN_MOVED_TO
3966 | IN_DONT_FOLLOW | IN_MASK_ADD);
3702 3967
3703 if (w->wd >= 0) 3968 if (w->wd >= 0)
3704 { 3969 {
3705 struct statfs sfs; 3970 struct statfs sfs;
3706 3971
… …
3710 3975
3711 if (!fs_2625) 3976 if (!fs_2625)
3712 w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL; 3977 w->timer.repeat = w->interval ? w->interval : DEF_STAT_INTERVAL;
3713 else if (!statfs (w->path, &sfs) 3978 else if (!statfs (w->path, &sfs)
3714 && (sfs.f_type == 0x1373 /* devfs */ 3979 && (sfs.f_type == 0x1373 /* devfs */
3980 || sfs.f_type == 0x4006 /* fat */
3981 || sfs.f_type == 0x4d44 /* msdos */
3715 || sfs.f_type == 0xEF53 /* ext2/3 */ 3982 || sfs.f_type == 0xEF53 /* ext2/3 */
3983 || sfs.f_type == 0x72b6 /* jffs2 */
3984 || sfs.f_type == 0x858458f6 /* ramfs */
3985 || sfs.f_type == 0x5346544e /* ntfs */
3716 || sfs.f_type == 0x3153464a /* jfs */ 3986 || sfs.f_type == 0x3153464a /* jfs */
3987 || sfs.f_type == 0x9123683e /* btrfs */
3717 || sfs.f_type == 0x52654973 /* reiser3 */ 3988 || sfs.f_type == 0x52654973 /* reiser3 */
3718 || sfs.f_type == 0x01021994 /* tempfs */ 3989 || sfs.f_type == 0x01021994 /* tmpfs */
3719 || sfs.f_type == 0x58465342 /* xfs */)) 3990 || sfs.f_type == 0x58465342 /* xfs */))
3720 w->timer.repeat = 0.; /* filesystem is local, kernel new enough */ 3991 w->timer.repeat = 0.; /* filesystem is local, kernel new enough */
3721 else 3992 else
3722 w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */ 3993 w->timer.repeat = w->interval ? w->interval : NFS_STAT_INTERVAL; /* remote, use reduced frequency */
3723 } 3994 }

Diff Legend

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