Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2000-2007 Niels Provos <provos@citi.umich.edu> |
| 3 | * Copyright (c) 2007-2012 Niels Provos and Nick Mathewson |
| 4 | * |
| 5 | * Redistribution and use in source and binary forms, with or without |
| 6 | * modification, are permitted provided that the following conditions |
| 7 | * are met: |
| 8 | * 1. Redistributions of source code must retain the above copyright |
| 9 | * notice, this list of conditions and the following disclaimer. |
| 10 | * 2. Redistributions in binary form must reproduce the above copyright |
| 11 | * notice, this list of conditions and the following disclaimer in the |
| 12 | * documentation and/or other materials provided with the distribution. |
| 13 | * 3. The name of the author may not be used to endorse or promote products |
| 14 | * derived from this software without specific prior written permission. |
| 15 | * |
| 16 | * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR |
| 17 | * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| 18 | * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| 19 | * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, |
| 20 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| 21 | * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| 22 | * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| 23 | * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| 24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| 25 | * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| 26 | */ |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 27 | #ifndef EVENT_INTERNAL_H_INCLUDED_ |
| 28 | #define EVENT_INTERNAL_H_INCLUDED_ |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 29 | |
| 30 | #ifdef __cplusplus |
| 31 | extern "C" { |
| 32 | #endif |
| 33 | |
| 34 | #include "event2/event-config.h" |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 35 | #include "evconfig-private.h" |
| 36 | |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 37 | #include <time.h> |
| 38 | #include <sys/queue.h> |
| 39 | #include "event2/event_struct.h" |
| 40 | #include "minheap-internal.h" |
| 41 | #include "evsignal-internal.h" |
| 42 | #include "mm-internal.h" |
| 43 | #include "defer-internal.h" |
| 44 | |
| 45 | /* map union members back */ |
| 46 | |
| 47 | /* mutually exclusive */ |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 48 | #define ev_signal_next ev_.ev_signal.ev_signal_next |
| 49 | #define ev_io_next ev_.ev_io.ev_io_next |
| 50 | #define ev_io_timeout ev_.ev_io.ev_timeout |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 51 | |
| 52 | /* used only by signals */ |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 53 | #define ev_ncalls ev_.ev_signal.ev_ncalls |
| 54 | #define ev_pncalls ev_.ev_signal.ev_pncalls |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 55 | |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 56 | #define ev_pri ev_evcallback.evcb_pri |
| 57 | #define ev_flags ev_evcallback.evcb_flags |
| 58 | #define ev_closure ev_evcallback.evcb_closure |
| 59 | #define ev_callback ev_evcallback.evcb_cb_union.evcb_callback |
| 60 | #define ev_arg ev_evcallback.evcb_arg |
| 61 | |
| 62 | /** @name Event closure codes |
| 63 | |
| 64 | Possible values for evcb_closure in struct event_callback |
| 65 | |
| 66 | @{ |
| 67 | */ |
| 68 | /** A regular event. Uses the evcb_callback callback */ |
| 69 | #define EV_CLOSURE_EVENT 0 |
| 70 | /** A signal event. Uses the evcb_callback callback */ |
| 71 | #define EV_CLOSURE_EVENT_SIGNAL 1 |
| 72 | /** A persistent non-signal event. Uses the evcb_callback callback */ |
| 73 | #define EV_CLOSURE_EVENT_PERSIST 2 |
| 74 | /** A simple callback. Uses the evcb_selfcb callback. */ |
| 75 | #define EV_CLOSURE_CB_SELF 3 |
| 76 | /** A finalizing callback. Uses the evcb_cbfinalize callback. */ |
| 77 | #define EV_CLOSURE_CB_FINALIZE 4 |
| 78 | /** A finalizing event. Uses the evcb_evfinalize callback. */ |
| 79 | #define EV_CLOSURE_EVENT_FINALIZE 5 |
| 80 | /** A finalizing event that should get freed after. Uses the evcb_evfinalize |
| 81 | * callback. */ |
| 82 | #define EV_CLOSURE_EVENT_FINALIZE_FREE 6 |
| 83 | /** @} */ |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 84 | |
| 85 | /** Structure to define the backend of a given event_base. */ |
| 86 | struct eventop { |
| 87 | /** The name of this backend. */ |
| 88 | const char *name; |
| 89 | /** Function to set up an event_base to use this backend. It should |
| 90 | * create a new structure holding whatever information is needed to |
| 91 | * run the backend, and return it. The returned pointer will get |
| 92 | * stored by event_init into the event_base.evbase field. On failure, |
| 93 | * this function should return NULL. */ |
| 94 | void *(*init)(struct event_base *); |
| 95 | /** Enable reading/writing on a given fd or signal. 'events' will be |
| 96 | * the events that we're trying to enable: one or more of EV_READ, |
| 97 | * EV_WRITE, EV_SIGNAL, and EV_ET. 'old' will be those events that |
| 98 | * were enabled on this fd previously. 'fdinfo' will be a structure |
| 99 | * associated with the fd by the evmap; its size is defined by the |
| 100 | * fdinfo field below. It will be set to 0 the first time the fd is |
| 101 | * added. The function should return 0 on success and -1 on error. |
| 102 | */ |
| 103 | int (*add)(struct event_base *, evutil_socket_t fd, short old, short events, void *fdinfo); |
| 104 | /** As "add", except 'events' contains the events we mean to disable. */ |
| 105 | int (*del)(struct event_base *, evutil_socket_t fd, short old, short events, void *fdinfo); |
| 106 | /** Function to implement the core of an event loop. It must see which |
| 107 | added events are ready, and cause event_active to be called for each |
| 108 | active event (usually via event_io_active or such). It should |
| 109 | return 0 on success and -1 on error. |
| 110 | */ |
| 111 | int (*dispatch)(struct event_base *, struct timeval *); |
| 112 | /** Function to clean up and free our data from the event_base. */ |
| 113 | void (*dealloc)(struct event_base *); |
| 114 | /** Flag: set if we need to reinitialize the event base after we fork. |
| 115 | */ |
| 116 | int need_reinit; |
| 117 | /** Bit-array of supported event_method_features that this backend can |
| 118 | * provide. */ |
| 119 | enum event_method_feature features; |
| 120 | /** Length of the extra information we should record for each fd that |
| 121 | has one or more active events. This information is recorded |
| 122 | as part of the evmap entry for each fd, and passed as an argument |
| 123 | to the add and del functions above. |
| 124 | */ |
| 125 | size_t fdinfo_len; |
| 126 | }; |
| 127 | |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 128 | #ifdef _WIN32 |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 129 | /* If we're on win32, then file descriptors are not nice low densely packed |
| 130 | integers. Instead, they are pointer-like windows handles, and we want to |
| 131 | use a hashtable instead of an array to map fds to events. |
| 132 | */ |
| 133 | #define EVMAP_USE_HT |
| 134 | #endif |
| 135 | |
| 136 | /* #define HT_CACHE_HASH_VALS */ |
| 137 | |
| 138 | #ifdef EVMAP_USE_HT |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 139 | #define HT_NO_CACHE_HASH_VALUES |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 140 | #include "ht-internal.h" |
| 141 | struct event_map_entry; |
| 142 | HT_HEAD(event_io_map, event_map_entry); |
| 143 | #else |
| 144 | #define event_io_map event_signal_map |
| 145 | #endif |
| 146 | |
| 147 | /* Used to map signal numbers to a list of events. If EVMAP_USE_HT is not |
| 148 | defined, this structure is also used as event_io_map, which maps fds to a |
| 149 | list of events. |
| 150 | */ |
| 151 | struct event_signal_map { |
| 152 | /* An array of evmap_io * or of evmap_signal *; empty entries are |
| 153 | * set to NULL. */ |
| 154 | void **entries; |
| 155 | /* The number of entries available in entries */ |
| 156 | int nentries; |
| 157 | }; |
| 158 | |
| 159 | /* A list of events waiting on a given 'common' timeout value. Ordinarily, |
| 160 | * events waiting for a timeout wait on a minheap. Sometimes, however, a |
| 161 | * queue can be faster. |
| 162 | **/ |
| 163 | struct common_timeout_list { |
| 164 | /* List of events currently waiting in the queue. */ |
| 165 | struct event_list events; |
| 166 | /* 'magic' timeval used to indicate the duration of events in this |
| 167 | * queue. */ |
| 168 | struct timeval duration; |
| 169 | /* Event that triggers whenever one of the events in the queue is |
| 170 | * ready to activate */ |
| 171 | struct event timeout_event; |
| 172 | /* The event_base that this timeout list is part of */ |
| 173 | struct event_base *base; |
| 174 | }; |
| 175 | |
| 176 | /** Mask used to get the real tv_usec value from a common timeout. */ |
| 177 | #define COMMON_TIMEOUT_MICROSECONDS_MASK 0x000fffff |
| 178 | |
| 179 | struct event_change; |
| 180 | |
| 181 | /* List of 'changes' since the last call to eventop.dispatch. Only maintained |
| 182 | * if the backend is using changesets. */ |
| 183 | struct event_changelist { |
| 184 | struct event_change *changes; |
| 185 | int n_changes; |
| 186 | int changes_size; |
| 187 | }; |
| 188 | |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 189 | #ifndef EVENT__DISABLE_DEBUG_MODE |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 190 | /* Global internal flag: set to one if debug mode is on. */ |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 191 | extern int event_debug_mode_on_; |
| 192 | #define EVENT_DEBUG_MODE_IS_ON() (event_debug_mode_on_) |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 193 | #else |
| 194 | #define EVENT_DEBUG_MODE_IS_ON() (0) |
| 195 | #endif |
| 196 | |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 197 | TAILQ_HEAD(evcallback_list, event_callback); |
| 198 | |
| 199 | /* Sets up an event for processing once */ |
| 200 | struct event_once { |
| 201 | LIST_ENTRY(event_once) next_once; |
| 202 | struct event ev; |
| 203 | |
| 204 | void (*cb)(evutil_socket_t, short, void *); |
| 205 | void *arg; |
| 206 | }; |
| 207 | |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 208 | struct event_base { |
| 209 | /** Function pointers and other data to describe this event_base's |
| 210 | * backend. */ |
| 211 | const struct eventop *evsel; |
| 212 | /** Pointer to backend-specific data. */ |
| 213 | void *evbase; |
| 214 | |
| 215 | /** List of changes to tell backend about at next dispatch. Only used |
| 216 | * by the O(1) backends. */ |
| 217 | struct event_changelist changelist; |
| 218 | |
| 219 | /** Function pointers used to describe the backend that this event_base |
| 220 | * uses for signals */ |
| 221 | const struct eventop *evsigsel; |
| 222 | /** Data to implement the common signal handelr code. */ |
| 223 | struct evsig_info sig; |
| 224 | |
| 225 | /** Number of virtual events */ |
| 226 | int virtual_event_count; |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 227 | /** Maximum number of virtual events active */ |
| 228 | int virtual_event_count_max; |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 229 | /** Number of total events added to this event_base */ |
| 230 | int event_count; |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 231 | /** Maximum number of total events added to this event_base */ |
| 232 | int event_count_max; |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 233 | /** Number of total events active in this event_base */ |
| 234 | int event_count_active; |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 235 | /** Maximum number of total events active in this event_base */ |
| 236 | int event_count_active_max; |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 237 | |
| 238 | /** Set if we should terminate the loop once we're done processing |
| 239 | * events. */ |
| 240 | int event_gotterm; |
| 241 | /** Set if we should terminate the loop immediately */ |
| 242 | int event_break; |
| 243 | /** Set if we should start a new instance of the loop immediately. */ |
| 244 | int event_continue; |
| 245 | |
| 246 | /** The currently running priority of events */ |
| 247 | int event_running_priority; |
| 248 | |
| 249 | /** Set if we're running the event_base_loop function, to prevent |
| 250 | * reentrant invocation. */ |
| 251 | int running_loop; |
| 252 | |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 253 | /** Set to the number of deferred_cbs we've made 'active' in the |
| 254 | * loop. This is a hack to prevent starvation; it would be smarter |
| 255 | * to just use event_config_set_max_dispatch_interval's max_callbacks |
| 256 | * feature */ |
| 257 | int n_deferreds_queued; |
| 258 | |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 259 | /* Active event management. */ |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 260 | /** An array of nactivequeues queues for active event_callbacks (ones |
| 261 | * that have triggered, and whose callbacks need to be called). Low |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 262 | * priority numbers are more important, and stall higher ones. |
| 263 | */ |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 264 | struct evcallback_list *activequeues; |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 265 | /** The length of the activequeues array */ |
| 266 | int nactivequeues; |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 267 | /** A list of event_callbacks that should become active the next time |
| 268 | * we process events, but not this time. */ |
| 269 | struct evcallback_list active_later_queue; |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 270 | |
| 271 | /* common timeout logic */ |
| 272 | |
| 273 | /** An array of common_timeout_list* for all of the common timeout |
| 274 | * values we know. */ |
| 275 | struct common_timeout_list **common_timeout_queues; |
| 276 | /** The number of entries used in common_timeout_queues */ |
| 277 | int n_common_timeouts; |
| 278 | /** The total size of common_timeout_queues. */ |
| 279 | int n_common_timeouts_allocated; |
| 280 | |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 281 | /** Mapping from file descriptors to enabled (added) events */ |
| 282 | struct event_io_map io; |
| 283 | |
| 284 | /** Mapping from signal numbers to enabled (added) events. */ |
| 285 | struct event_signal_map sigmap; |
| 286 | |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 287 | /** Priority queue of events with timeouts. */ |
| 288 | struct min_heap timeheap; |
| 289 | |
| 290 | /** Stored timeval: used to avoid calling gettimeofday/clock_gettime |
| 291 | * too often. */ |
| 292 | struct timeval tv_cache; |
| 293 | |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 294 | struct evutil_monotonic_timer monotonic_timer; |
| 295 | |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 296 | /** Difference between internal time (maybe from clock_gettime) and |
| 297 | * gettimeofday. */ |
| 298 | struct timeval tv_clock_diff; |
| 299 | /** Second in which we last updated tv_clock_diff, in monotonic time. */ |
| 300 | time_t last_updated_clock_diff; |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 301 | |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 302 | #ifndef EVENT__DISABLE_THREAD_SUPPORT |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 303 | /* threading support */ |
| 304 | /** The thread currently running the event_loop for this base */ |
| 305 | unsigned long th_owner_id; |
| 306 | /** A lock to prevent conflicting accesses to this event_base */ |
| 307 | void *th_base_lock; |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 308 | /** A condition that gets signalled when we're done processing an |
| 309 | * event with waiters on it. */ |
| 310 | void *current_event_cond; |
| 311 | /** Number of threads blocking on current_event_cond. */ |
| 312 | int current_event_waiters; |
| 313 | #endif |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 314 | /** The event whose callback is executing right now */ |
| 315 | struct event_callback *current_event; |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 316 | |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 317 | #ifdef _WIN32 |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 318 | /** IOCP support structure, if IOCP is enabled. */ |
| 319 | struct event_iocp_port *iocp; |
| 320 | #endif |
| 321 | |
| 322 | /** Flags that this base was configured with */ |
| 323 | enum event_base_config_flag flags; |
| 324 | |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 325 | struct timeval max_dispatch_time; |
| 326 | int max_dispatch_callbacks; |
| 327 | int limit_callbacks_after_prio; |
| 328 | |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 329 | /* Notify main thread to wake up break, etc. */ |
| 330 | /** True if the base already has a pending notify, and we don't need |
| 331 | * to add any more. */ |
| 332 | int is_notify_pending; |
| 333 | /** A socketpair used by some th_notify functions to wake up the main |
| 334 | * thread. */ |
| 335 | evutil_socket_t th_notify_fd[2]; |
| 336 | /** An event used by some th_notify functions to wake up the main |
| 337 | * thread. */ |
| 338 | struct event th_notify; |
| 339 | /** A function used to wake up the main thread from another thread. */ |
| 340 | int (*th_notify_fn)(struct event_base *base); |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 341 | |
| 342 | /** Saved seed for weak random number generator. Some backends use |
| 343 | * this to produce fairness among sockets. Protected by th_base_lock. */ |
| 344 | struct evutil_weakrand_state weakrand_seed; |
| 345 | |
| 346 | /** List of event_onces that have not yet fired. */ |
| 347 | LIST_HEAD(once_event_list, event_once) once_events; |
| 348 | |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 349 | }; |
| 350 | |
| 351 | struct event_config_entry { |
| 352 | TAILQ_ENTRY(event_config_entry) next; |
| 353 | |
| 354 | const char *avoid_method; |
| 355 | }; |
| 356 | |
| 357 | /** Internal structure: describes the configuration we want for an event_base |
| 358 | * that we're about to allocate. */ |
| 359 | struct event_config { |
| 360 | TAILQ_HEAD(event_configq, event_config_entry) entries; |
| 361 | |
| 362 | int n_cpus_hint; |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 363 | struct timeval max_dispatch_interval; |
| 364 | int max_dispatch_callbacks; |
| 365 | int limit_callbacks_after_prio; |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 366 | enum event_method_feature require_features; |
| 367 | enum event_base_config_flag flags; |
| 368 | }; |
| 369 | |
| 370 | /* Internal use only: Functions that might be missing from <sys/queue.h> */ |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 371 | #ifndef TAILQ_FIRST |
| 372 | #define TAILQ_FIRST(head) ((head)->tqh_first) |
| 373 | #endif |
| 374 | #ifndef TAILQ_END |
| 375 | #define TAILQ_END(head) NULL |
| 376 | #endif |
| 377 | #ifndef TAILQ_NEXT |
| 378 | #define TAILQ_NEXT(elm, field) ((elm)->field.tqe_next) |
| 379 | #endif |
| 380 | |
| 381 | #ifndef TAILQ_FOREACH |
| 382 | #define TAILQ_FOREACH(var, head, field) \ |
| 383 | for ((var) = TAILQ_FIRST(head); \ |
| 384 | (var) != TAILQ_END(head); \ |
| 385 | (var) = TAILQ_NEXT(var, field)) |
| 386 | #endif |
| 387 | |
| 388 | #ifndef TAILQ_INSERT_BEFORE |
| 389 | #define TAILQ_INSERT_BEFORE(listelm, elm, field) do { \ |
| 390 | (elm)->field.tqe_prev = (listelm)->field.tqe_prev; \ |
| 391 | (elm)->field.tqe_next = (listelm); \ |
| 392 | *(listelm)->field.tqe_prev = (elm); \ |
| 393 | (listelm)->field.tqe_prev = &(elm)->field.tqe_next; \ |
| 394 | } while (0) |
| 395 | #endif |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 396 | |
| 397 | #define N_ACTIVE_CALLBACKS(base) \ |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 398 | ((base)->event_count_active) |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 399 | |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 400 | int evsig_set_handler_(struct event_base *base, int evsignal, |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 401 | void (*fn)(int)); |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 402 | int evsig_restore_handler_(struct event_base *base, int evsignal); |
| 403 | |
| 404 | int event_add_nolock_(struct event *ev, |
| 405 | const struct timeval *tv, int tv_is_absolute); |
| 406 | /** Argument for event_del_nolock_. Tells event_del not to block on the event |
| 407 | * if it's running in another thread. */ |
| 408 | #define EVENT_DEL_NOBLOCK 0 |
| 409 | /** Argument for event_del_nolock_. Tells event_del to block on the event |
| 410 | * if it's running in another thread, regardless of its value for EV_FINALIZE |
| 411 | */ |
| 412 | #define EVENT_DEL_BLOCK 1 |
| 413 | /** Argument for event_del_nolock_. Tells event_del to block on the event |
| 414 | * if it is running in another thread and it doesn't have EV_FINALIZE set. |
| 415 | */ |
| 416 | #define EVENT_DEL_AUTOBLOCK 2 |
| 417 | /** Argument for event_del_nolock_. Tells event_del to procede even if the |
| 418 | * event is set up for finalization rather for regular use.*/ |
| 419 | #define EVENT_DEL_EVEN_IF_FINALIZING 3 |
| 420 | int event_del_nolock_(struct event *ev, int blocking); |
| 421 | int event_remove_timer_nolock_(struct event *ev); |
| 422 | |
| 423 | void event_active_nolock_(struct event *ev, int res, short count); |
| 424 | int event_callback_activate_(struct event_base *, struct event_callback *); |
| 425 | int event_callback_activate_nolock_(struct event_base *, struct event_callback *); |
| 426 | int event_callback_cancel_(struct event_base *base, |
| 427 | struct event_callback *evcb); |
| 428 | |
| 429 | void event_callback_finalize_nolock_(struct event_base *base, unsigned flags, struct event_callback *evcb, void (*cb)(struct event_callback *, void *)); |
| 430 | void event_callback_finalize_(struct event_base *base, unsigned flags, struct event_callback *evcb, void (*cb)(struct event_callback *, void *)); |
| 431 | int event_callback_finalize_many_(struct event_base *base, int n_cbs, struct event_callback **evcb, void (*cb)(struct event_callback *, void *)); |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 432 | |
| 433 | |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 434 | void event_active_later_(struct event *ev, int res); |
| 435 | void event_active_later_nolock_(struct event *ev, int res); |
| 436 | int event_callback_activate_later_nolock_(struct event_base *base, |
| 437 | struct event_callback *evcb); |
| 438 | int event_callback_cancel_nolock_(struct event_base *base, |
| 439 | struct event_callback *evcb, int even_if_finalizing); |
| 440 | void event_callback_init_(struct event_base *base, |
| 441 | struct event_callback *cb); |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 442 | |
| 443 | /* FIXME document. */ |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 444 | void event_base_add_virtual_(struct event_base *base); |
| 445 | void event_base_del_virtual_(struct event_base *base); |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 446 | |
| 447 | /** For debugging: unless assertions are disabled, verify the referential |
| 448 | integrity of the internal data structures of 'base'. This operation can |
| 449 | be expensive. |
| 450 | |
| 451 | Returns on success; aborts on failure. |
| 452 | */ |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 453 | void event_base_assert_ok_(struct event_base *base); |
| 454 | void event_base_assert_ok_nolock_(struct event_base *base); |
| 455 | |
| 456 | |
| 457 | /* Helper function: Call 'fn' exactly once every inserted or active event in |
| 458 | * the event_base 'base'. |
| 459 | * |
| 460 | * If fn returns 0, continue on to the next event. Otherwise, return the same |
| 461 | * value that fn returned. |
| 462 | * |
| 463 | * Requires that 'base' be locked. |
| 464 | */ |
| 465 | int event_base_foreach_event_nolock_(struct event_base *base, |
| 466 | event_base_foreach_event_cb cb, void *arg); |
| 467 | |
| 468 | /* Cleanup function to reset debug mode during shutdown. |
| 469 | * |
| 470 | * Calling this function doesn't mean it'll be possible to re-enable |
| 471 | * debug mode if any events were added. |
| 472 | */ |
| 473 | void event_disable_debug_mode(void); |
Christopher Wiley | e867981 | 2015-07-01 13:36:18 -0700 | [diff] [blame] | 474 | |
| 475 | #ifdef __cplusplus |
| 476 | } |
| 477 | #endif |
| 478 | |
Narayan Kamath | fc74cb4 | 2017-09-13 12:53:52 +0100 | [diff] [blame] | 479 | #endif /* EVENT_INTERNAL_H_INCLUDED_ */ |