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

861 lines
30 KiB

  1. /*
  2. * libev native API header
  3. *
  4. * Copyright (c) 2007-2020 Marc Alexander Lehmann <libev@schmorp.de>
  5. * All rights reserved.
  6. *
  7. * Redistribution and use in source and binary forms, with or without modifica-
  8. * tion, are permitted provided that the following conditions are met:
  9. *
  10. * 1. Redistributions of source code must retain the above copyright notice,
  11. * this list of conditions and the following disclaimer.
  12. *
  13. * 2. Redistributions in binary form must reproduce the above copyright
  14. * notice, this list of conditions and the following disclaimer in the
  15. * documentation and/or other materials provided with the distribution.
  16. *
  17. * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
  18. * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
  19. * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
  20. * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
  21. * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  22. * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  23. * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  24. * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
  25. * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  26. * OF THE POSSIBILITY OF SUCH DAMAGE.
  27. *
  28. * Alternatively, the contents of this file may be used under the terms of
  29. * the GNU General Public License ("GPL") version 2 or any later version,
  30. * in which case the provisions of the GPL are applicable instead of
  31. * the above. If you wish to allow the use of your version of this file
  32. * only under the terms of the GPL and not to allow others to use your
  33. * version of this file under the BSD license, indicate your decision
  34. * by deleting the provisions above and replace them with the notice
  35. * and other provisions required by the GPL. If you do not delete the
  36. * provisions above, a recipient may use your version of this file under
  37. * either the BSD or the GPL.
  38. */
  39. #ifndef EV_H_
  40. #define EV_H_
  41. #ifdef __cplusplus
  42. # define EV_CPP(x) x
  43. # if __cplusplus >= 201103L
  44. # define EV_NOEXCEPT noexcept
  45. # else
  46. # define EV_NOEXCEPT
  47. # endif
  48. #else
  49. # define EV_CPP(x)
  50. # define EV_NOEXCEPT
  51. #endif
  52. #define EV_THROW EV_NOEXCEPT /* pre-4.25, do not use in new code */
  53. EV_CPP(extern "C" {)
  54. /*****************************************************************************/
  55. /* pre-4.0 compatibility */
  56. #ifndef EV_COMPAT3
  57. # define EV_COMPAT3 1
  58. #endif
  59. #ifndef EV_FEATURES
  60. # if defined __OPTIMIZE_SIZE__
  61. # define EV_FEATURES 0x7c
  62. # else
  63. # define EV_FEATURES 0x7f
  64. # endif
  65. #endif
  66. #define EV_FEATURE_CODE ((EV_FEATURES) & 1)
  67. #define EV_FEATURE_DATA ((EV_FEATURES) & 2)
  68. #define EV_FEATURE_CONFIG ((EV_FEATURES) & 4)
  69. #define EV_FEATURE_API ((EV_FEATURES) & 8)
  70. #define EV_FEATURE_WATCHERS ((EV_FEATURES) & 16)
  71. #define EV_FEATURE_BACKENDS ((EV_FEATURES) & 32)
  72. #define EV_FEATURE_OS ((EV_FEATURES) & 64)
  73. /* these priorities are inclusive, higher priorities will be invoked earlier */
  74. #ifndef EV_MINPRI
  75. # define EV_MINPRI (EV_FEATURE_CONFIG ? -2 : 0)
  76. #endif
  77. #ifndef EV_MAXPRI
  78. # define EV_MAXPRI (EV_FEATURE_CONFIG ? +2 : 0)
  79. #endif
  80. #ifndef EV_MULTIPLICITY
  81. # define EV_MULTIPLICITY EV_FEATURE_CONFIG
  82. #endif
  83. #ifndef EV_PERIODIC_ENABLE
  84. # define EV_PERIODIC_ENABLE EV_FEATURE_WATCHERS
  85. #endif
  86. #ifndef EV_STAT_ENABLE
  87. # define EV_STAT_ENABLE EV_FEATURE_WATCHERS
  88. #endif
  89. #ifndef EV_PREPARE_ENABLE
  90. # define EV_PREPARE_ENABLE EV_FEATURE_WATCHERS
  91. #endif
  92. #ifndef EV_CHECK_ENABLE
  93. # define EV_CHECK_ENABLE EV_FEATURE_WATCHERS
  94. #endif
  95. #ifndef EV_IDLE_ENABLE
  96. # define EV_IDLE_ENABLE EV_FEATURE_WATCHERS
  97. #endif
  98. #ifndef EV_FORK_ENABLE
  99. # define EV_FORK_ENABLE EV_FEATURE_WATCHERS
  100. #endif
  101. #ifndef EV_CLEANUP_ENABLE
  102. # define EV_CLEANUP_ENABLE EV_FEATURE_WATCHERS
  103. #endif
  104. #ifndef EV_SIGNAL_ENABLE
  105. # define EV_SIGNAL_ENABLE EV_FEATURE_WATCHERS
  106. #endif
  107. #ifndef EV_CHILD_ENABLE
  108. # ifdef _WIN32
  109. # define EV_CHILD_ENABLE 0
  110. # else
  111. # define EV_CHILD_ENABLE EV_FEATURE_WATCHERS
  112. #endif
  113. #endif
  114. #ifndef EV_ASYNC_ENABLE
  115. # define EV_ASYNC_ENABLE EV_FEATURE_WATCHERS
  116. #endif
  117. #ifndef EV_EMBED_ENABLE
  118. # define EV_EMBED_ENABLE EV_FEATURE_WATCHERS
  119. #endif
  120. #ifndef EV_WALK_ENABLE
  121. # define EV_WALK_ENABLE 0 /* not yet */
  122. #endif
  123. /*****************************************************************************/
  124. #if EV_CHILD_ENABLE && !EV_SIGNAL_ENABLE
  125. # undef EV_SIGNAL_ENABLE
  126. # define EV_SIGNAL_ENABLE 1
  127. #endif
  128. /*****************************************************************************/
  129. #ifndef EV_TSTAMP_T
  130. # define EV_TSTAMP_T double
  131. #endif
  132. typedef EV_TSTAMP_T ev_tstamp;
  133. #include <string.h> /* for memmove */
  134. #ifndef EV_ATOMIC_T
  135. # include <signal.h>
  136. # define EV_ATOMIC_T sig_atomic_t volatile
  137. #endif
  138. #if EV_STAT_ENABLE
  139. # ifdef _WIN32
  140. # include <time.h>
  141. # include <sys/types.h>
  142. # endif
  143. # include <sys/stat.h>
  144. #endif
  145. /* support multiple event loops? */
  146. #if EV_MULTIPLICITY
  147. struct ev_loop;
  148. # define EV_P struct ev_loop *loop /* a loop as sole parameter in a declaration */
  149. # define EV_P_ EV_P, /* a loop as first of multiple parameters */
  150. # define EV_A loop /* a loop as sole argument to a function call */
  151. # define EV_A_ EV_A, /* a loop as first of multiple arguments */
  152. # define EV_DEFAULT_UC ev_default_loop_uc_ () /* the default loop, if initialised, as sole arg */
  153. # define EV_DEFAULT_UC_ EV_DEFAULT_UC, /* the default loop as first of multiple arguments */
  154. # define EV_DEFAULT ev_default_loop (0) /* the default loop as sole arg */
  155. # define EV_DEFAULT_ EV_DEFAULT, /* the default loop as first of multiple arguments */
  156. #else
  157. # define EV_P void
  158. # define EV_P_
  159. # define EV_A
  160. # define EV_A_
  161. # define EV_DEFAULT
  162. # define EV_DEFAULT_
  163. # define EV_DEFAULT_UC
  164. # define EV_DEFAULT_UC_
  165. # undef EV_EMBED_ENABLE
  166. #endif
  167. /* EV_INLINE is used for functions in header files */
  168. #if __STDC_VERSION__ >= 199901L || __GNUC__ >= 3
  169. # define EV_INLINE static inline
  170. #else
  171. # define EV_INLINE static
  172. #endif
  173. #ifdef EV_API_STATIC
  174. # define EV_API_DECL static
  175. #else
  176. # define EV_API_DECL extern
  177. #endif
  178. /* EV_PROTOTYPES can be used to switch of prototype declarations */
  179. #ifndef EV_PROTOTYPES
  180. # define EV_PROTOTYPES 1
  181. #endif
  182. /*****************************************************************************/
  183. #define EV_VERSION_MAJOR 4
  184. #define EV_VERSION_MINOR 33
  185. /* eventmask, revents, events... */
  186. enum {
  187. EV_UNDEF = (int)0xFFFFFFFF, /* guaranteed to be invalid */
  188. EV_NONE = 0x00, /* no events */
  189. EV_READ = 0x01, /* ev_io detected read will not block */
  190. EV_WRITE = 0x02, /* ev_io detected write will not block */
  191. EV__IOFDSET = 0x80, /* internal use only */
  192. EV_IO = EV_READ, /* alias for type-detection */
  193. EV_TIMER = 0x00000100, /* timer timed out */
  194. #if EV_COMPAT3
  195. EV_TIMEOUT = EV_TIMER, /* pre 4.0 API compatibility */
  196. #endif
  197. EV_PERIODIC = 0x00000200, /* periodic timer timed out */
  198. EV_SIGNAL = 0x00000400, /* signal was received */
  199. EV_CHILD = 0x00000800, /* child/pid had status change */
  200. EV_STAT = 0x00001000, /* stat data changed */
  201. EV_IDLE = 0x00002000, /* event loop is idling */
  202. EV_PREPARE = 0x00004000, /* event loop about to poll */
  203. EV_CHECK = 0x00008000, /* event loop finished poll */
  204. EV_EMBED = 0x00010000, /* embedded event loop needs sweep */
  205. EV_FORK = 0x00020000, /* event loop resumed in child */
  206. EV_CLEANUP = 0x00040000, /* event loop resumed in child */
  207. EV_ASYNC = 0x00080000, /* async intra-loop signal */
  208. EV_CUSTOM = 0x01000000, /* for use by user code */
  209. EV_ERROR = (int)0x80000000 /* sent when an error occurs */
  210. };
  211. /* can be used to add custom fields to all watchers, while losing binary compatibility */
  212. #ifndef EV_COMMON
  213. # define EV_COMMON void *data;
  214. #endif
  215. #ifndef EV_CB_DECLARE
  216. # define EV_CB_DECLARE(type) void (*cb)(EV_P_ struct type *w, int revents);
  217. #endif
  218. #ifndef EV_CB_INVOKE
  219. # define EV_CB_INVOKE(watcher,revents) (watcher)->cb (EV_A_ (watcher), (revents))
  220. #endif
  221. /* not official, do not use */
  222. #define EV_CB(type,name) void name (EV_P_ struct ev_ ## type *w, int revents)
  223. /*
  224. * struct member types:
  225. * private: you may look at them, but not change them,
  226. * and they might not mean anything to you.
  227. * ro: can be read anytime, but only changed when the watcher isn't active.
  228. * rw: can be read and modified anytime, even when the watcher is active.
  229. *
  230. * some internal details that might be helpful for debugging:
  231. *
  232. * active is either 0, which means the watcher is not active,
  233. * or the array index of the watcher (periodics, timers)
  234. * or the array index + 1 (most other watchers)
  235. * or simply 1 for watchers that aren't in some array.
  236. * pending is either 0, in which case the watcher isn't,
  237. * or the array index + 1 in the pendings array.
  238. */
  239. #if EV_MINPRI == EV_MAXPRI
  240. # define EV_DECL_PRIORITY
  241. #elif !defined (EV_DECL_PRIORITY)
  242. # define EV_DECL_PRIORITY int priority;
  243. #endif
  244. /* shared by all watchers */
  245. #define EV_WATCHER(type) \
  246. int active; /* private */ \
  247. int pending; /* private */ \
  248. EV_DECL_PRIORITY /* private */ \
  249. EV_COMMON /* rw */ \
  250. EV_CB_DECLARE (type) /* private */
  251. #define EV_WATCHER_LIST(type) \
  252. EV_WATCHER (type) \
  253. struct ev_watcher_list *next; /* private */
  254. #define EV_WATCHER_TIME(type) \
  255. EV_WATCHER (type) \
  256. ev_tstamp at; /* private */
  257. /* base class, nothing to see here unless you subclass */
  258. typedef struct ev_watcher
  259. {
  260. EV_WATCHER (ev_watcher)
  261. } ev_watcher;
  262. /* base class, nothing to see here unless you subclass */
  263. typedef struct ev_watcher_list
  264. {
  265. EV_WATCHER_LIST (ev_watcher_list)
  266. } ev_watcher_list;
  267. /* base class, nothing to see here unless you subclass */
  268. typedef struct ev_watcher_time
  269. {
  270. EV_WATCHER_TIME (ev_watcher_time)
  271. } ev_watcher_time;
  272. /* invoked when fd is either EV_READable or EV_WRITEable */
  273. /* revent EV_READ, EV_WRITE */
  274. typedef struct ev_io
  275. {
  276. EV_WATCHER_LIST (ev_io)
  277. int fd; /* ro */
  278. int events; /* ro */
  279. } ev_io;
  280. /* invoked after a specific time, repeatable (based on monotonic clock) */
  281. /* revent EV_TIMEOUT */
  282. typedef struct ev_timer
  283. {
  284. EV_WATCHER_TIME (ev_timer)
  285. ev_tstamp repeat; /* rw */
  286. } ev_timer;
  287. /* invoked at some specific time, possibly repeating at regular intervals (based on UTC) */
  288. /* revent EV_PERIODIC */
  289. typedef struct ev_periodic
  290. {
  291. EV_WATCHER_TIME (ev_periodic)
  292. ev_tstamp offset; /* rw */
  293. ev_tstamp interval; /* rw */
  294. ev_tstamp (*reschedule_cb)(struct ev_periodic *w, ev_tstamp now) EV_NOEXCEPT; /* rw */
  295. } ev_periodic;
  296. /* invoked when the given signal has been received */
  297. /* revent EV_SIGNAL */
  298. typedef struct ev_signal
  299. {
  300. EV_WATCHER_LIST (ev_signal)
  301. int signum; /* ro */
  302. } ev_signal;
  303. /* invoked when sigchld is received and waitpid indicates the given pid */
  304. /* revent EV_CHILD */
  305. /* does not support priorities */
  306. typedef struct ev_child
  307. {
  308. EV_WATCHER_LIST (ev_child)
  309. int flags; /* private */
  310. int pid; /* ro */
  311. int rpid; /* rw, holds the received pid */
  312. int rstatus; /* rw, holds the exit status, use the macros from sys/wait.h */
  313. } ev_child;
  314. #if EV_STAT_ENABLE
  315. /* st_nlink = 0 means missing file or other error */
  316. # ifdef _WIN32
  317. typedef struct _stati64 ev_statdata;
  318. # else
  319. typedef struct stat ev_statdata;
  320. # endif
  321. /* invoked each time the stat data changes for a given path */
  322. /* revent EV_STAT */
  323. typedef struct ev_stat
  324. {
  325. EV_WATCHER_LIST (ev_stat)
  326. ev_timer timer; /* private */
  327. ev_tstamp interval; /* ro */
  328. const char *path; /* ro */
  329. ev_statdata prev; /* ro */
  330. ev_statdata attr; /* ro */
  331. int wd; /* wd for inotify, fd for kqueue */
  332. } ev_stat;
  333. #endif
  334. /* invoked when the nothing else needs to be done, keeps the process from blocking */
  335. /* revent EV_IDLE */
  336. typedef struct ev_idle
  337. {
  338. EV_WATCHER (ev_idle)
  339. } ev_idle;
  340. /* invoked for each run of the mainloop, just before the blocking call */
  341. /* you can still change events in any way you like */
  342. /* revent EV_PREPARE */
  343. typedef struct ev_prepare
  344. {
  345. EV_WATCHER (ev_prepare)
  346. } ev_prepare;
  347. /* invoked for each run of the mainloop, just after the blocking call */
  348. /* revent EV_CHECK */
  349. typedef struct ev_check
  350. {
  351. EV_WATCHER (ev_check)
  352. } ev_check;
  353. /* the callback gets invoked before check in the child process when a fork was detected */
  354. /* revent EV_FORK */
  355. typedef struct ev_fork
  356. {
  357. EV_WATCHER (ev_fork)
  358. } ev_fork;
  359. /* is invoked just before the loop gets destroyed */
  360. /* revent EV_CLEANUP */
  361. typedef struct ev_cleanup
  362. {
  363. EV_WATCHER (ev_cleanup)
  364. } ev_cleanup;
  365. #if EV_EMBED_ENABLE
  366. /* used to embed an event loop inside another */
  367. /* the callback gets invoked when the event loop has handled events, and can be 0 */
  368. typedef struct ev_embed
  369. {
  370. EV_WATCHER (ev_embed)
  371. struct ev_loop *other; /* ro */
  372. #undef EV_IO_ENABLE
  373. #define EV_IO_ENABLE 1
  374. ev_io io; /* private */
  375. #undef EV_PREPARE_ENABLE
  376. #define EV_PREPARE_ENABLE 1
  377. ev_prepare prepare; /* private */
  378. ev_check check; /* unused */
  379. ev_timer timer; /* unused */
  380. ev_periodic periodic; /* unused */
  381. ev_idle idle; /* unused */
  382. ev_fork fork; /* private */
  383. ev_cleanup cleanup; /* unused */
  384. } ev_embed;
  385. #endif
  386. #if EV_ASYNC_ENABLE
  387. /* invoked when somebody calls ev_async_send on the watcher */
  388. /* revent EV_ASYNC */
  389. typedef struct ev_async
  390. {
  391. EV_WATCHER (ev_async)
  392. EV_ATOMIC_T sent; /* private */
  393. } ev_async;
  394. # define ev_async_pending(w) (+(w)->sent)
  395. #endif
  396. /* the presence of this union forces similar struct layout */
  397. union ev_any_watcher
  398. {
  399. struct ev_watcher w;
  400. struct ev_watcher_list wl;
  401. struct ev_io io;
  402. struct ev_timer timer;
  403. struct ev_periodic periodic;
  404. struct ev_signal signal;
  405. struct ev_child child;
  406. #if EV_STAT_ENABLE
  407. struct ev_stat stat;
  408. #endif
  409. #if EV_IDLE_ENABLE
  410. struct ev_idle idle;
  411. #endif
  412. struct ev_prepare prepare;
  413. struct ev_check check;
  414. #if EV_FORK_ENABLE
  415. struct ev_fork fork;
  416. #endif
  417. #if EV_CLEANUP_ENABLE
  418. struct ev_cleanup cleanup;
  419. #endif
  420. #if EV_EMBED_ENABLE
  421. struct ev_embed embed;
  422. #endif
  423. #if EV_ASYNC_ENABLE
  424. struct ev_async async;
  425. #endif
  426. };
  427. /* flag bits for ev_default_loop and ev_loop_new */
  428. enum {
  429. /* the default */
  430. EVFLAG_AUTO = 0x00000000U, /* not quite a mask */
  431. /* flag bits */
  432. EVFLAG_NOENV = 0x01000000U, /* do NOT consult environment */
  433. EVFLAG_FORKCHECK = 0x02000000U, /* check for a fork in each iteration */
  434. /* debugging/feature disable */
  435. EVFLAG_NOINOTIFY = 0x00100000U, /* do not attempt to use inotify */
  436. #if EV_COMPAT3
  437. EVFLAG_NOSIGFD = 0, /* compatibility to pre-3.9 */
  438. #endif
  439. EVFLAG_SIGNALFD = 0x00200000U, /* attempt to use signalfd */
  440. EVFLAG_NOSIGMASK = 0x00400000U, /* avoid modifying the signal mask */
  441. EVFLAG_NOTIMERFD = 0x00800000U /* avoid creating a timerfd */
  442. };
  443. /* method bits to be ored together */
  444. enum {
  445. EVBACKEND_SELECT = 0x00000001U, /* available just about anywhere */
  446. EVBACKEND_POLL = 0x00000002U, /* !win, !aix, broken on osx */
  447. EVBACKEND_EPOLL = 0x00000004U, /* linux */
  448. EVBACKEND_KQUEUE = 0x00000008U, /* bsd, broken on osx */
  449. EVBACKEND_DEVPOLL = 0x00000010U, /* solaris 8 */ /* NYI */
  450. EVBACKEND_PORT = 0x00000020U, /* solaris 10 */
  451. EVBACKEND_LINUXAIO = 0x00000040U, /* linux AIO, 4.19+ */
  452. EVBACKEND_IOURING = 0x00000080U, /* linux io_uring, 5.1+ */
  453. EVBACKEND_ALL = 0x000000FFU, /* all known backends */
  454. EVBACKEND_MASK = 0x0000FFFFU /* all future backends */
  455. };
  456. #if EV_PROTOTYPES
  457. EV_API_DECL int ev_version_major (void) EV_NOEXCEPT;
  458. EV_API_DECL int ev_version_minor (void) EV_NOEXCEPT;
  459. EV_API_DECL unsigned int ev_supported_backends (void) EV_NOEXCEPT;
  460. EV_API_DECL unsigned int ev_recommended_backends (void) EV_NOEXCEPT;
  461. EV_API_DECL unsigned int ev_embeddable_backends (void) EV_NOEXCEPT;
  462. EV_API_DECL ev_tstamp ev_time (void) EV_NOEXCEPT;
  463. EV_API_DECL void ev_sleep (ev_tstamp delay) EV_NOEXCEPT; /* sleep for a while */
  464. /* Sets the allocation function to use, works like realloc.
  465. * It is used to allocate and free memory.
  466. * If it returns zero when memory needs to be allocated, the library might abort
  467. * or take some potentially destructive action.
  468. * The default is your system realloc function.
  469. */
  470. EV_API_DECL void ev_set_allocator (void *(*cb)(void *ptr, long size) EV_NOEXCEPT) EV_NOEXCEPT;
  471. /* set the callback function to call on a
  472. * retryable syscall error
  473. * (such as failed select, poll, epoll_wait)
  474. */
  475. EV_API_DECL void ev_set_syserr_cb (void (*cb)(const char *msg) EV_NOEXCEPT) EV_NOEXCEPT;
  476. #if EV_MULTIPLICITY
  477. /* the default loop is the only one that handles signals and child watchers */
  478. /* you can call this as often as you like */
  479. EV_API_DECL struct ev_loop *ev_default_loop (unsigned int flags EV_CPP (= 0)) EV_NOEXCEPT;
  480. #ifdef EV_API_STATIC
  481. EV_API_DECL struct ev_loop *ev_default_loop_ptr;
  482. #endif
  483. EV_INLINE struct ev_loop *
  484. ev_default_loop_uc_ (void) EV_NOEXCEPT
  485. {
  486. extern struct ev_loop *ev_default_loop_ptr;
  487. return ev_default_loop_ptr;
  488. }
  489. EV_INLINE int
  490. ev_is_default_loop (EV_P) EV_NOEXCEPT
  491. {
  492. return EV_A == EV_DEFAULT_UC;
  493. }
  494. /* create and destroy alternative loops that don't handle signals */
  495. EV_API_DECL struct ev_loop *ev_loop_new (unsigned int flags EV_CPP (= 0)) EV_NOEXCEPT;
  496. EV_API_DECL ev_tstamp ev_now (EV_P) EV_NOEXCEPT; /* time w.r.t. timers and the eventloop, updated after each poll */
  497. #else
  498. EV_API_DECL int ev_default_loop (unsigned int flags EV_CPP (= 0)) EV_NOEXCEPT; /* returns true when successful */
  499. EV_API_DECL ev_tstamp ev_rt_now;
  500. EV_INLINE ev_tstamp
  501. ev_now (void) EV_NOEXCEPT
  502. {
  503. return ev_rt_now;
  504. }
  505. /* looks weird, but ev_is_default_loop (EV_A) still works if this exists */
  506. EV_INLINE int
  507. ev_is_default_loop (void) EV_NOEXCEPT
  508. {
  509. return 1;
  510. }
  511. #endif /* multiplicity */
  512. /* destroy event loops, also works for the default loop */
  513. EV_API_DECL void ev_loop_destroy (EV_P);
  514. /* this needs to be called after fork, to duplicate the loop */
  515. /* when you want to re-use it in the child */
  516. /* you can call it in either the parent or the child */
  517. /* you can actually call it at any time, anywhere :) */
  518. EV_API_DECL void ev_loop_fork (EV_P) EV_NOEXCEPT;
  519. EV_API_DECL unsigned int ev_backend (EV_P) EV_NOEXCEPT; /* backend in use by loop */
  520. EV_API_DECL void ev_now_update (EV_P) EV_NOEXCEPT; /* update event loop time */
  521. #if EV_WALK_ENABLE
  522. /* walk (almost) all watchers in the loop of a given type, invoking the */
  523. /* callback on every such watcher. The callback might stop the watcher, */
  524. /* but do nothing else with the loop */
  525. EV_API_DECL void ev_walk (EV_P_ int types, void (*cb)(EV_P_ int type, void *w)) EV_NOEXCEPT;
  526. #endif
  527. #endif /* prototypes */
  528. /* ev_run flags values */
  529. enum {
  530. EVRUN_NOWAIT = 1, /* do not block/wait */
  531. EVRUN_ONCE = 2 /* block *once* only */
  532. };
  533. /* ev_break how values */
  534. enum {
  535. EVBREAK_CANCEL = 0, /* undo unloop */
  536. EVBREAK_ONE = 1, /* unloop once */
  537. EVBREAK_ALL = 2 /* unloop all loops */
  538. };
  539. #if EV_PROTOTYPES
  540. EV_API_DECL int ev_run (EV_P_ int flags EV_CPP (= 0));
  541. EV_API_DECL void ev_break (EV_P_ int how EV_CPP (= EVBREAK_ONE)) EV_NOEXCEPT; /* break out of the loop */
  542. /*
  543. * ref/unref can be used to add or remove a refcount on the mainloop. every watcher
  544. * keeps one reference. if you have a long-running watcher you never unregister that
  545. * should not keep ev_loop from running, unref() after starting, and ref() before stopping.
  546. */
  547. EV_API_DECL void ev_ref (EV_P) EV_NOEXCEPT;
  548. EV_API_DECL void ev_unref (EV_P) EV_NOEXCEPT;
  549. /*
  550. * convenience function, wait for a single event, without registering an event watcher
  551. * if timeout is < 0, do wait indefinitely
  552. */
  553. EV_API_DECL void ev_once (EV_P_ int fd, int events, ev_tstamp timeout, void (*cb)(int revents, void *arg), void *arg) EV_NOEXCEPT;
  554. EV_API_DECL void ev_invoke_pending (EV_P); /* invoke all pending watchers */
  555. # if EV_FEATURE_API
  556. EV_API_DECL unsigned int ev_iteration (EV_P) EV_NOEXCEPT; /* number of loop iterations */
  557. EV_API_DECL unsigned int ev_depth (EV_P) EV_NOEXCEPT; /* #ev_loop enters - #ev_loop leaves */
  558. EV_API_DECL void ev_verify (EV_P) EV_NOEXCEPT; /* abort if loop data corrupted */
  559. EV_API_DECL void ev_set_io_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT; /* sleep at least this time, default 0 */
  560. EV_API_DECL void ev_set_timeout_collect_interval (EV_P_ ev_tstamp interval) EV_NOEXCEPT; /* sleep at least this time, default 0 */
  561. /* advanced stuff for threading etc. support, see docs */
  562. EV_API_DECL void ev_set_userdata (EV_P_ void *data) EV_NOEXCEPT;
  563. EV_API_DECL void *ev_userdata (EV_P) EV_NOEXCEPT;
  564. typedef void (*ev_loop_callback)(EV_P);
  565. EV_API_DECL void ev_set_invoke_pending_cb (EV_P_ ev_loop_callback invoke_pending_cb) EV_NOEXCEPT;
  566. /* C++ doesn't allow the use of the ev_loop_callback typedef here, so we need to spell it out */
  567. EV_API_DECL void ev_set_loop_release_cb (EV_P_ void (*release)(EV_P) EV_NOEXCEPT, void (*acquire)(EV_P) EV_NOEXCEPT) EV_NOEXCEPT;
  568. EV_API_DECL unsigned int ev_pending_count (EV_P) EV_NOEXCEPT; /* number of pending events, if any */
  569. /*
  570. * stop/start the timer handling.
  571. */
  572. EV_API_DECL void ev_suspend (EV_P) EV_NOEXCEPT;
  573. EV_API_DECL void ev_resume (EV_P) EV_NOEXCEPT;
  574. #endif
  575. #endif
  576. /* these may evaluate ev multiple times, and the other arguments at most once */
  577. /* either use ev_init + ev_TYPE_set, or the ev_TYPE_init macro, below, to first initialise a watcher */
  578. #define ev_init(ev,cb_) do { \
  579. ((ev_watcher *)(void *)(ev))->active = \
  580. ((ev_watcher *)(void *)(ev))->pending = 0; \
  581. ev_set_priority ((ev), 0); \
  582. ev_set_cb ((ev), cb_); \
  583. } while (0)
  584. #define ev_io_modify(ev,events_) do { (ev)->events = (ev)->events & EV__IOFDSET | (events_); } while (0)
  585. #define ev_io_set(ev,fd_,events_) do { (ev)->fd = (fd_); (ev)->events = (events_) | EV__IOFDSET; } while (0)
  586. #define ev_timer_set(ev,after_,repeat_) do { ((ev_watcher_time *)(ev))->at = (after_); (ev)->repeat = (repeat_); } while (0)
  587. #define ev_periodic_set(ev,ofs_,ival_,rcb_) do { (ev)->offset = (ofs_); (ev)->interval = (ival_); (ev)->reschedule_cb = (rcb_); } while (0)
  588. #define ev_signal_set(ev,signum_) do { (ev)->signum = (signum_); } while (0)
  589. #define ev_child_set(ev,pid_,trace_) do { (ev)->pid = (pid_); (ev)->flags = !!(trace_); } while (0)
  590. #define ev_stat_set(ev,path_,interval_) do { (ev)->path = (path_); (ev)->interval = (interval_); (ev)->wd = -2; } while (0)
  591. #define ev_idle_set(ev) /* nop, yes, this is a serious in-joke */
  592. #define ev_prepare_set(ev) /* nop, yes, this is a serious in-joke */
  593. #define ev_check_set(ev) /* nop, yes, this is a serious in-joke */
  594. #define ev_embed_set(ev,other_) do { (ev)->other = (other_); } while (0)
  595. #define ev_fork_set(ev) /* nop, yes, this is a serious in-joke */
  596. #define ev_cleanup_set(ev) /* nop, yes, this is a serious in-joke */
  597. #define ev_async_set(ev) /* nop, yes, this is a serious in-joke */
  598. #define ev_io_init(ev,cb,fd,events) do { ev_init ((ev), (cb)); ev_io_set ((ev),(fd),(events)); } while (0)
  599. #define ev_timer_init(ev,cb,after,repeat) do { ev_init ((ev), (cb)); ev_timer_set ((ev),(after),(repeat)); } while (0)
  600. #define ev_periodic_init(ev,cb,ofs,ival,rcb) do { ev_init ((ev), (cb)); ev_periodic_set ((ev),(ofs),(ival),(rcb)); } while (0)
  601. #define ev_signal_init(ev,cb,signum) do { ev_init ((ev), (cb)); ev_signal_set ((ev), (signum)); } while (0)
  602. #define ev_child_init(ev,cb,pid,trace) do { ev_init ((ev), (cb)); ev_child_set ((ev),(pid),(trace)); } while (0)
  603. #define ev_stat_init(ev,cb,path,interval) do { ev_init ((ev), (cb)); ev_stat_set ((ev),(path),(interval)); } while (0)
  604. #define ev_idle_init(ev,cb) do { ev_init ((ev), (cb)); ev_idle_set ((ev)); } while (0)
  605. #define ev_prepare_init(ev,cb) do { ev_init ((ev), (cb)); ev_prepare_set ((ev)); } while (0)
  606. #define ev_check_init(ev,cb) do { ev_init ((ev), (cb)); ev_check_set ((ev)); } while (0)
  607. #define ev_embed_init(ev,cb,other) do { ev_init ((ev), (cb)); ev_embed_set ((ev),(other)); } while (0)
  608. #define ev_fork_init(ev,cb) do { ev_init ((ev), (cb)); ev_fork_set ((ev)); } while (0)
  609. #define ev_cleanup_init(ev,cb) do { ev_init ((ev), (cb)); ev_cleanup_set ((ev)); } while (0)
  610. #define ev_async_init(ev,cb) do { ev_init ((ev), (cb)); ev_async_set ((ev)); } while (0)
  611. #define ev_is_pending(ev) (0 + ((ev_watcher *)(void *)(ev))->pending) /* ro, true when watcher is waiting for callback invocation */
  612. #define ev_is_active(ev) (0 + ((ev_watcher *)(void *)(ev))->active) /* ro, true when the watcher has been started */
  613. #define ev_cb_(ev) (ev)->cb /* rw */
  614. #define ev_cb(ev) (memmove (&ev_cb_ (ev), &((ev_watcher *)(ev))->cb, sizeof (ev_cb_ (ev))), (ev)->cb)
  615. #if EV_MINPRI == EV_MAXPRI
  616. # define ev_priority(ev) ((ev), EV_MINPRI)
  617. # define ev_set_priority(ev,pri) ((ev), (pri))
  618. #else
  619. # define ev_priority(ev) (+(((ev_watcher *)(void *)(ev))->priority))
  620. # define ev_set_priority(ev,pri) ( (ev_watcher *)(void *)(ev))->priority = (pri)
  621. #endif
  622. #define ev_periodic_at(ev) (+((ev_watcher_time *)(ev))->at)
  623. #ifndef ev_set_cb
  624. /* memmove is used here to avoid strict aliasing violations, and hopefully is optimized out by any reasonable compiler */
  625. # define ev_set_cb(ev,cb_) (ev_cb_ (ev) = (cb_), memmove (&((ev_watcher *)(ev))->cb, &ev_cb_ (ev), sizeof (ev_cb_ (ev))))
  626. #endif
  627. /* stopping (enabling, adding) a watcher does nothing if it is already running */
  628. /* stopping (disabling, deleting) a watcher does nothing unless it's already running */
  629. #if EV_PROTOTYPES
  630. /* feeds an event into a watcher as if the event actually occurred */
  631. /* accepts any ev_watcher type */
  632. EV_API_DECL void ev_feed_event (EV_P_ void *w, int revents) EV_NOEXCEPT;
  633. EV_API_DECL void ev_feed_fd_event (EV_P_ int fd, int revents) EV_NOEXCEPT;
  634. #if EV_SIGNAL_ENABLE
  635. EV_API_DECL void ev_feed_signal (int signum) EV_NOEXCEPT;
  636. EV_API_DECL void ev_feed_signal_event (EV_P_ int signum) EV_NOEXCEPT;
  637. #endif
  638. EV_API_DECL void ev_invoke (EV_P_ void *w, int revents);
  639. EV_API_DECL int ev_clear_pending (EV_P_ void *w) EV_NOEXCEPT;
  640. EV_API_DECL void ev_io_start (EV_P_ ev_io *w) EV_NOEXCEPT;
  641. EV_API_DECL void ev_io_stop (EV_P_ ev_io *w) EV_NOEXCEPT;
  642. EV_API_DECL void ev_timer_start (EV_P_ ev_timer *w) EV_NOEXCEPT;
  643. EV_API_DECL void ev_timer_stop (EV_P_ ev_timer *w) EV_NOEXCEPT;
  644. /* stops if active and no repeat, restarts if active and repeating, starts if inactive and repeating */
  645. EV_API_DECL void ev_timer_again (EV_P_ ev_timer *w) EV_NOEXCEPT;
  646. /* return remaining time */
  647. EV_API_DECL ev_tstamp ev_timer_remaining (EV_P_ ev_timer *w) EV_NOEXCEPT;
  648. #if EV_PERIODIC_ENABLE
  649. EV_API_DECL void ev_periodic_start (EV_P_ ev_periodic *w) EV_NOEXCEPT;
  650. EV_API_DECL void ev_periodic_stop (EV_P_ ev_periodic *w) EV_NOEXCEPT;
  651. EV_API_DECL void ev_periodic_again (EV_P_ ev_periodic *w) EV_NOEXCEPT;
  652. #endif
  653. /* only supported in the default loop */
  654. #if EV_SIGNAL_ENABLE
  655. EV_API_DECL void ev_signal_start (EV_P_ ev_signal *w) EV_NOEXCEPT;
  656. EV_API_DECL void ev_signal_stop (EV_P_ ev_signal *w) EV_NOEXCEPT;
  657. #endif
  658. /* only supported in the default loop */
  659. # if EV_CHILD_ENABLE
  660. EV_API_DECL void ev_child_start (EV_P_ ev_child *w) EV_NOEXCEPT;
  661. EV_API_DECL void ev_child_stop (EV_P_ ev_child *w) EV_NOEXCEPT;
  662. # endif
  663. # if EV_STAT_ENABLE
  664. EV_API_DECL void ev_stat_start (EV_P_ ev_stat *w) EV_NOEXCEPT;
  665. EV_API_DECL void ev_stat_stop (EV_P_ ev_stat *w) EV_NOEXCEPT;
  666. EV_API_DECL void ev_stat_stat (EV_P_ ev_stat *w) EV_NOEXCEPT;
  667. # endif
  668. # if EV_IDLE_ENABLE
  669. EV_API_DECL void ev_idle_start (EV_P_ ev_idle *w) EV_NOEXCEPT;
  670. EV_API_DECL void ev_idle_stop (EV_P_ ev_idle *w) EV_NOEXCEPT;
  671. # endif
  672. #if EV_PREPARE_ENABLE
  673. EV_API_DECL void ev_prepare_start (EV_P_ ev_prepare *w) EV_NOEXCEPT;
  674. EV_API_DECL void ev_prepare_stop (EV_P_ ev_prepare *w) EV_NOEXCEPT;
  675. #endif
  676. #if EV_CHECK_ENABLE
  677. EV_API_DECL void ev_check_start (EV_P_ ev_check *w) EV_NOEXCEPT;
  678. EV_API_DECL void ev_check_stop (EV_P_ ev_check *w) EV_NOEXCEPT;
  679. #endif
  680. # if EV_FORK_ENABLE
  681. EV_API_DECL void ev_fork_start (EV_P_ ev_fork *w) EV_NOEXCEPT;
  682. EV_API_DECL void ev_fork_stop (EV_P_ ev_fork *w) EV_NOEXCEPT;
  683. # endif
  684. # if EV_CLEANUP_ENABLE
  685. EV_API_DECL void ev_cleanup_start (EV_P_ ev_cleanup *w) EV_NOEXCEPT;
  686. EV_API_DECL void ev_cleanup_stop (EV_P_ ev_cleanup *w) EV_NOEXCEPT;
  687. # endif
  688. # if EV_EMBED_ENABLE
  689. /* only supported when loop to be embedded is in fact embeddable */
  690. EV_API_DECL void ev_embed_start (EV_P_ ev_embed *w) EV_NOEXCEPT;
  691. EV_API_DECL void ev_embed_stop (EV_P_ ev_embed *w) EV_NOEXCEPT;
  692. EV_API_DECL void ev_embed_sweep (EV_P_ ev_embed *w) EV_NOEXCEPT;
  693. # endif
  694. # if EV_ASYNC_ENABLE
  695. EV_API_DECL void ev_async_start (EV_P_ ev_async *w) EV_NOEXCEPT;
  696. EV_API_DECL void ev_async_stop (EV_P_ ev_async *w) EV_NOEXCEPT;
  697. EV_API_DECL void ev_async_send (EV_P_ ev_async *w) EV_NOEXCEPT;
  698. # endif
  699. #if EV_COMPAT3
  700. #define EVLOOP_NONBLOCK EVRUN_NOWAIT
  701. #define EVLOOP_ONESHOT EVRUN_ONCE
  702. #define EVUNLOOP_CANCEL EVBREAK_CANCEL
  703. #define EVUNLOOP_ONE EVBREAK_ONE
  704. #define EVUNLOOP_ALL EVBREAK_ALL
  705. #if EV_PROTOTYPES
  706. EV_INLINE void ev_loop (EV_P_ int flags) { ev_run (EV_A_ flags); }
  707. EV_INLINE void ev_unloop (EV_P_ int how ) { ev_break (EV_A_ how ); }
  708. EV_INLINE void ev_default_destroy (void) { ev_loop_destroy (EV_DEFAULT); }
  709. EV_INLINE void ev_default_fork (void) { ev_loop_fork (EV_DEFAULT); }
  710. #if EV_FEATURE_API
  711. EV_INLINE unsigned int ev_loop_count (EV_P) { return ev_iteration (EV_A); }
  712. EV_INLINE unsigned int ev_loop_depth (EV_P) { return ev_depth (EV_A); }
  713. EV_INLINE void ev_loop_verify (EV_P) { ev_verify (EV_A); }
  714. #endif
  715. #endif
  716. #else
  717. typedef struct ev_loop ev_loop;
  718. #endif
  719. #endif
  720. EV_CPP(})
  721. #endif