"Fossies" - the Fresh Open Source Software Archive

Member "libev-4.33/ev_vars.h" (27 Dec 2019, 7549 Bytes) of package /linux/misc/libev-4.33.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "ev_vars.h" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 4.31_vs_4.33.

    1 /*
    2  * loop member variable declarations
    3  *
    4  * Copyright (c) 2007,2008,2009,2010,2011,2012,2013,2019 Marc Alexander Lehmann <libev@schmorp.de>
    5  * All rights reserved.
    6  *
    7  * Redistribution and use in source and binary forms, with or without modifica-
    8  * tion, are permitted provided that the following conditions are met:
    9  *
   10  *   1.  Redistributions of source code must retain the above copyright notice,
   11  *       this list of conditions and the following disclaimer.
   12  *
   13  *   2.  Redistributions in binary form must reproduce the above copyright
   14  *       notice, this list of conditions and the following disclaimer in the
   15  *       documentation and/or other materials provided with the distribution.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
   18  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MER-
   19  * CHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
   20  * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPE-
   21  * CIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
   22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
   23  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
   24  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTH-
   25  * ERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
   26  * OF THE POSSIBILITY OF SUCH DAMAGE.
   27  *
   28  * Alternatively, the contents of this file may be used under the terms of
   29  * the GNU General Public License ("GPL") version 2 or any later version,
   30  * in which case the provisions of the GPL are applicable instead of
   31  * the above. If you wish to allow the use of your version of this file
   32  * only under the terms of the GPL and not to allow others to use your
   33  * version of this file under the BSD license, indicate your decision
   34  * by deleting the provisions above and replace them with the notice
   35  * and other provisions required by the GPL. If you do not delete the
   36  * provisions above, a recipient may use your version of this file under
   37  * either the BSD or the GPL.
   38  */
   39 
   40 #define VARx(type,name) VAR(name, type name)
   41 
   42 VARx(ev_tstamp, now_floor) /* last time we refreshed rt_time */
   43 VARx(ev_tstamp, mn_now)    /* monotonic clock "now" */
   44 VARx(ev_tstamp, rtmn_diff) /* difference realtime - monotonic time */
   45 
   46 /* for reverse feeding of events */
   47 VARx(W *, rfeeds)
   48 VARx(int, rfeedmax)
   49 VARx(int, rfeedcnt)
   50 
   51 VAR (pendings, ANPENDING *pendings [NUMPRI])
   52 VAR (pendingmax, int pendingmax [NUMPRI])
   53 VAR (pendingcnt, int pendingcnt [NUMPRI])
   54 VARx(int, pendingpri) /* highest priority currently pending */
   55 VARx(ev_prepare, pending_w) /* dummy pending watcher */
   56 
   57 VARx(ev_tstamp, io_blocktime)
   58 VARx(ev_tstamp, timeout_blocktime)
   59 
   60 VARx(int, backend)
   61 VARx(int, activecnt) /* total number of active events ("refcount") */
   62 VARx(EV_ATOMIC_T, loop_done)  /* signal by ev_break */
   63 
   64 VARx(int, backend_fd)
   65 VARx(ev_tstamp, backend_mintime) /* assumed typical timer resolution */
   66 VAR (backend_modify, void (*backend_modify)(EV_P_ int fd, int oev, int nev))
   67 VAR (backend_poll  , void (*backend_poll)(EV_P_ ev_tstamp timeout))
   68 
   69 VARx(ANFD *, anfds)
   70 VARx(int, anfdmax)
   71 
   72 VAR (evpipe, int evpipe [2])
   73 VARx(ev_io, pipe_w)
   74 VARx(EV_ATOMIC_T, pipe_write_wanted)
   75 VARx(EV_ATOMIC_T, pipe_write_skipped)
   76 
   77 #if !defined(_WIN32) || EV_GENWRAP
   78 VARx(pid_t, curpid)
   79 #endif
   80 
   81 VARx(char, postfork)  /* true if we need to recreate kernel state after fork */
   82 
   83 #if EV_USE_SELECT || EV_GENWRAP
   84 VARx(void *, vec_ri)
   85 VARx(void *, vec_ro)
   86 VARx(void *, vec_wi)
   87 VARx(void *, vec_wo)
   88 #if defined(_WIN32) || EV_GENWRAP
   89 VARx(void *, vec_eo)
   90 #endif
   91 VARx(int, vec_max)
   92 #endif
   93 
   94 #if EV_USE_POLL || EV_GENWRAP
   95 VARx(struct pollfd *, polls)
   96 VARx(int, pollmax)
   97 VARx(int, pollcnt)
   98 VARx(int *, pollidxs) /* maps fds into structure indices */
   99 VARx(int, pollidxmax)
  100 #endif
  101 
  102 #if EV_USE_EPOLL || EV_GENWRAP
  103 VARx(struct epoll_event *, epoll_events)
  104 VARx(int, epoll_eventmax)
  105 VARx(int *, epoll_eperms)
  106 VARx(int, epoll_epermcnt)
  107 VARx(int, epoll_epermmax)
  108 #endif
  109 
  110 #if EV_USE_LINUXAIO || EV_GENWRAP
  111 VARx(aio_context_t, linuxaio_ctx)
  112 VARx(int, linuxaio_iteration)
  113 VARx(struct aniocb **, linuxaio_iocbps)
  114 VARx(int, linuxaio_iocbpmax)
  115 VARx(struct iocb **, linuxaio_submits)
  116 VARx(int, linuxaio_submitcnt)
  117 VARx(int, linuxaio_submitmax)
  118 VARx(ev_io, linuxaio_epoll_w)
  119 #endif
  120 
  121 #if EV_USE_IOURING || EV_GENWRAP
  122 VARx(int, iouring_fd)
  123 VARx(unsigned, iouring_to_submit);
  124 VARx(int, iouring_entries)
  125 VARx(int, iouring_max_entries)
  126 VARx(void *, iouring_sq_ring)
  127 VARx(void *, iouring_cq_ring)
  128 VARx(void *, iouring_sqes)
  129 VARx(uint32_t, iouring_sq_ring_size)
  130 VARx(uint32_t, iouring_cq_ring_size)
  131 VARx(uint32_t, iouring_sqes_size)
  132 VARx(uint32_t, iouring_sq_head)
  133 VARx(uint32_t, iouring_sq_tail)
  134 VARx(uint32_t, iouring_sq_ring_mask)
  135 VARx(uint32_t, iouring_sq_ring_entries)
  136 VARx(uint32_t, iouring_sq_flags)
  137 VARx(uint32_t, iouring_sq_dropped)
  138 VARx(uint32_t, iouring_sq_array)
  139 VARx(uint32_t, iouring_cq_head)
  140 VARx(uint32_t, iouring_cq_tail)
  141 VARx(uint32_t, iouring_cq_ring_mask)
  142 VARx(uint32_t, iouring_cq_ring_entries)
  143 VARx(uint32_t, iouring_cq_overflow)
  144 VARx(uint32_t, iouring_cq_cqes)
  145 VARx(ev_tstamp, iouring_tfd_to)
  146 VARx(int, iouring_tfd)
  147 VARx(ev_io, iouring_tfd_w)
  148 #endif
  149 
  150 #if EV_USE_KQUEUE || EV_GENWRAP
  151 VARx(pid_t, kqueue_fd_pid)
  152 VARx(struct kevent *, kqueue_changes)
  153 VARx(int, kqueue_changemax)
  154 VARx(int, kqueue_changecnt)
  155 VARx(struct kevent *, kqueue_events)
  156 VARx(int, kqueue_eventmax)
  157 #endif
  158 
  159 #if EV_USE_PORT || EV_GENWRAP
  160 VARx(struct port_event *, port_events)
  161 VARx(int, port_eventmax)
  162 #endif
  163 
  164 #if EV_USE_IOCP || EV_GENWRAP
  165 VARx(HANDLE, iocp)
  166 #endif
  167 
  168 VARx(int *, fdchanges)
  169 VARx(int, fdchangemax)
  170 VARx(int, fdchangecnt)
  171 
  172 VARx(ANHE *, timers)
  173 VARx(int, timermax)
  174 VARx(int, timercnt)
  175 
  176 #if EV_PERIODIC_ENABLE || EV_GENWRAP
  177 VARx(ANHE *, periodics)
  178 VARx(int, periodicmax)
  179 VARx(int, periodiccnt)
  180 #endif
  181 
  182 #if EV_IDLE_ENABLE || EV_GENWRAP
  183 VAR (idles, ev_idle **idles [NUMPRI])
  184 VAR (idlemax, int idlemax [NUMPRI])
  185 VAR (idlecnt, int idlecnt [NUMPRI])
  186 #endif
  187 VARx(int, idleall) /* total number */
  188 
  189 VARx(struct ev_prepare **, prepares)
  190 VARx(int, preparemax)
  191 VARx(int, preparecnt)
  192 
  193 VARx(struct ev_check **, checks)
  194 VARx(int, checkmax)
  195 VARx(int, checkcnt)
  196 
  197 #if EV_FORK_ENABLE || EV_GENWRAP
  198 VARx(struct ev_fork **, forks)
  199 VARx(int, forkmax)
  200 VARx(int, forkcnt)
  201 #endif
  202 
  203 #if EV_CLEANUP_ENABLE || EV_GENWRAP
  204 VARx(struct ev_cleanup **, cleanups)
  205 VARx(int, cleanupmax)
  206 VARx(int, cleanupcnt)
  207 #endif
  208 
  209 #if EV_ASYNC_ENABLE || EV_GENWRAP
  210 VARx(EV_ATOMIC_T, async_pending)
  211 VARx(struct ev_async **, asyncs)
  212 VARx(int, asyncmax)
  213 VARx(int, asynccnt)
  214 #endif
  215 
  216 #if EV_USE_INOTIFY || EV_GENWRAP
  217 VARx(int, fs_fd)
  218 VARx(ev_io, fs_w)
  219 VARx(char, fs_2625) /* whether we are running in linux 2.6.25 or newer */
  220 VAR (fs_hash, ANFS fs_hash [EV_INOTIFY_HASHSIZE])
  221 #endif
  222 
  223 VARx(EV_ATOMIC_T, sig_pending)
  224 #if EV_USE_SIGNALFD || EV_GENWRAP
  225 VARx(int, sigfd)
  226 VARx(ev_io, sigfd_w)
  227 VARx(sigset_t, sigfd_set)
  228 #endif
  229 
  230 #if EV_USE_TIMERFD || EV_GENWRAP
  231 VARx(int, timerfd) /* timerfd for time jump detection */
  232 VARx(ev_io, timerfd_w)
  233 #endif
  234 
  235 VARx(unsigned int, origflags) /* original loop flags */
  236 
  237 #if EV_FEATURE_API || EV_GENWRAP
  238 VARx(unsigned int, loop_count) /* total number of loop iterations/blocks */
  239 VARx(unsigned int, loop_depth) /* #ev_run enters - #ev_run leaves */
  240 
  241 VARx(void *, userdata)
  242 /* C++ doesn't support the ev_loop_callback typedef here. stinks. */
  243 VAR (release_cb, void (*release_cb)(EV_P) EV_NOEXCEPT)
  244 VAR (acquire_cb, void (*acquire_cb)(EV_P) EV_NOEXCEPT)
  245 VAR (invoke_cb , ev_loop_callback invoke_cb)
  246 #endif
  247 
  248 #undef VARx
  249