event_int.h

Go to the documentation of this file.

/*
** Copyright (C) 2005 by Kevin L. Mitchell <klmitch@mit.edu>
**
** This program is free software; you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation; either version 2 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
**
** @(#)$Id: event_int.h,v 1.34 2005/12/29 04:33:58 klmitch Exp $
*/
#ifndef __include_event_int_h__
#define __include_event_int_h__

#define __EVENT_LIBRARY__ /* Inside the library */

#include "config.h"

#include "_stdint.h"
#include "event_err.h"
#include "event_version.h"
#include "gcc-attrs.h"
#include "event.h"
#include "sock.h"
#include "sig.h"
#include "tim.h"

#include <stdlib.h> /* for size_t, abort() */
#include <sys/types.h> /* for gettimeofday() */
#include <treeconf/treeconf.h>

#if !_GCA_PREREQ(3, 0)
# define __builtin_expect(expr, expect)         (expr)
#endif

#undef _gca_format
#if _GCA_PREREQ(2, 4)
# define _gca_format(archetype, index, first)                                 \
                __attribute__((format(archetype, index, first)))
#else
# define _gca_format(archetype, index, first)
#endif

#undef _gca_func
#undef _gca_have_func
#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L
# define _gca_func              __func__
# define _gca_have_func 1
#elif _GCA_PREREQ(2, 4)
# define _gca_func              __FUNCTION__
# define _gca_have_func 1
#else
# define _gca_func              ((const char *) 0)
# define _gca_have_func 0
#endif

#define RCSTAG(tag) static char rcsid[] _gca_unused = tag

#define EV_CTX_LTDLINIT         0x00000004

typedef struct _ev_varlist_s ev_varlist_t;

typedef struct _ev_overvars_s ev_overvars_t;

typedef struct _ev_attr_s _ev_attr_t;

typedef struct _ev_genlist_s ev_genlist_t;

typedef struct _ev_gendesc_s ev_gendesc_t;

typedef struct _ev_gens_s ev_gens_t;

struct _ev_varlist_s {
  ev_varlist_t         *vl_next;        
  ev_varlist_t        **vl_prev_p;      
  const char           *vl_name;        
  const char           *vl_default;     
  treeconf_nodown_t     vl_nodown;      
  treeconf_change_t     vl_change;      
  void                 *vl_assoc;       
};

struct _ev_overvars_s {
  ev_overvars_t        *ov_next;        
  ev_overvars_t       **ov_prev_p;      
  const char           *ov_name;        
  const char           *ov_value;       
};

struct _ev_attr_s {
  ev_magic_t            ea_magic;       
  const char           *ea_confpath;    
  const char           *ea_libpath;     
  const char           *ea_modlist;     
  ev_varlist_t         *ea_varlist;     
  ev_overvars_t        *ea_ovars;       
  struct _ev_engine_s  *ea_engines;     
};

#define EV_ATTR_MAGIC 0x492d393e

#define _ea(attr, field)        ((*(attr))->ea_ ## field)

#define ea_verify(attr)         ((attr) && *(attr) &&                         \
                                 _ea((attr), magic) == EV_ATTR_MAGIC)

#define ea_confpath(attr)       _ea((attr), confpath)

#define ea_libpath(attr)        _ea((attr), libpath)

#define ea_modlist(attr)        _ea((attr), modlist)

#define ea_varlist(attr)        _ea((attr), varlist)

#define ea_ovars(attr)          _ea((attr), ovars)

#define ea_engines(attr)        _ea((attr), engines)

struct _ev_genlist_s {
  unsigned int          gl_count;       
  ev_genhdr_t          *gl_list;        
};

struct _ev_gendesc_s {
  unsigned int          gd_type;        
  ev_magic_t            gd_magic;       
  size_t                gd_size;        
  ev_freegen_t          gd_release;     
  ev_genlist_t          gd_active;      
  ev_genlist_t          gd_free;        
};

struct _ev_gens_s {
  ev_gens_t            *gs_next;        
  ev_gens_t            *gs_prev;        
  unsigned int          gs_first;       
  unsigned int          gs_count;       
  ev_gendesc_t          gs_gens[1];     
};

extern const _ev_attr_t const *_ev_defattr;

extern ev_flags_t _ev_asflags;

#define EVAS_LOG        0x0001

#define EVAS_ABORT      0x0002

#define EVAS_LOOP       0x0004

#define EVAS_TRACE      0x0008  /* tracing function entry */

extern ev_log_t _ev_debuglog;

#define ev_log(flag, msg)                                                     \
do {                                                                          \
  if ((_ev_asflags & (flag)) && _ev_debuglog) /* if we can log messages */    \
    (_ev_debuglog)(__FILE__, __LINE__, _gca_func, (msg)); /* then do so */    \
} while (0)

#define ev_abort()                                                            \
do {                                                                          \
  if (_ev_asflags & EVAS_ABORT) /* If aborting demanded, abort... */          \
    abort();                                                                  \
  else /* Otherwise, just tell caller about assertion failure... */           \
    ev_return(EV_ERR_ASSERT);                                                 \
} while (0)

#define ev_assert(expr)                                                       \
do {                                                                          \
  if (__builtin_expect(!(expr), 0)) { /* check the assertion... */            \
    if (__builtin_expect(_ev_asflags & EVAS_LOOP, 0)) /* are we looping? */   \
      ev_abort(); /* OK, just break out of the loop */                        \
    _ev_asflags |= EVAS_LOOP; /* remember we've been here once before */      \
    ev_log(EVAS_LOG, "Assertion failure: " #expr); /* log assertion failure */\
    ev_abort(); /* OK, we're done; get out of here! */                        \
  }                                                                           \
} while (0)

#define ev_trace()      ev_log(EVAS_TRACE, "Function entry")

#define ev_init()                                                             \
do {                                                                          \
  initialize_evnt_error_table(); /* initialize the error table... */          \
  if (__builtin_expect(_ev_asflags & EVAS_LOOP, 0)) /* did we assert? */      \
    ev_abort(); /* if so, then get out of here! */                            \
  ev_trace(); /* log function entry... */                                     \
} while (0)

#define ev_return(val)                                                        \
do {                                                                          \
  ev_err_t _err = (val); /* save return value... */                           \
  _ev_debug(EVAS_TRACE, __FILE__, __LINE__, _gca_func,                        \
            "Function exit: " #val " (%u)", _err);                            \
  return _err;                                                                \
} while (0)

#define ev_gen_init(ctx, gen, gd)                                             \
do {                                                                          \
  ev_genhdr_t *_gen = (ev_genhdr_t *)(gen);                                   \
  ev_gendesc_t *_gd = (gd);                                                   \
  _gen->eg_type = _gd->gd_type;                                               \
  _gen->eg_flags = 0;                                                         \
  _gen->eg_next = 0;                                                          \
  _gen->eg_prev = 0;                                                          \
  _gen->eg_context = (ctx);                                                   \
  _gen->eg_ref = 0;                                                           \
  _gen->eg_callback = 0;                                                      \
  _gen->eg_calldata = 0;                                                      \
  _gen->eg_engdata.egd_int = 0;                                               \
  _gen->eg_magic = _gd->gd_magic; /* initialize magic number last */          \
} while (0)

#define tv_comp(tv1, tv2)       (((tv1)->tv_sec == (tv2)->tv_sec) ?           \
                                 ((tv1)->tv_usec - (tv2)->tv_usec) :          \
                                 ((tv1)->tv_sec  - (tv2)->tv_sec))

#define tt_node_fix(tim)                                                      \
do {                                                                          \
  ev_tim_t *_tim = (tim);                                                     \
  if (_tim->ti_node.tn_next)                                                  \
    _tim->ti_node.tn_next->ti_node.tn_prev = _tim;                            \
  if (_tim->ti_node.tn_prev)                                                  \
    _tim->ti_node.tn_prev->ti_node.tn_next = _tim;                            \
  if (_tim->ti_node.tn_left)                                                  \
    _tim->ti_node.tn_left->ti_node.tn_parent = _tim;                          \
  if (_tim->ti_node.tn_right)                                                 \
    _tim->ti_node.tn_right->ti_node.tn_parent = _tim;                         \
} while (0)

#define tt_node_init(tim, parent, prev)                                       \
do {                                                                          \
  ev_tim_t *_tim = (tim);                                                     \
  _tim->ti_node.tn_parent = (parent); /* initialize node structure */         \
  _tim->ti_node.tn_next = 0;                                                  \
  _tim->ti_node.tn_prev = (prev);                                             \
  _tim->ti_node.tn_left = 0;                                                  \
  _tim->ti_node.tn_right = 0;                                                 \
  if (_tim->ti_node.tn_prev) /* update previous node in thread */             \
    _tim->ti_node.tn_prev->ti_node.tn_next = _tim;                            \
} while (0)

#define ti_expire_comp(tim)                                                   \
do {                                                                          \
  struct timeval _c_tim;                                                      \
  ev_tim_t *_tim = (tim);                                                     \
  if (_tim->ti_type == TT_ABSOLUTE)                                           \
    _tim->ti_expire = _tim->ti_value; /* value is absolute time */            \
  else {                                                                      \
    gettimeofday(&_c_tim, 0); /* get the current time... */                   \
    /* compute the absolute time for expiration */                            \
    tim->ti_expire.tv_sec  = _c_tim.tv_sec  + _tim->ti_value.tv_sec;          \
    tim->ti_expire.tv_usec = _c_tim.tv_usec + _tim->ti_value.tv_usec;         \
  }                                                                           \
} while (0)

#define so_uevents_set(sock, flags)                                           \
                                _so_set((sock), _so_encev((flags),            \
                                                          _EV_SOCK_UEVENTS))

#define so_uevents_clr(sock, flags)                                           \
                                _so_clr((sock), _so_encev((flags),            \
                                                          _EV_SOCK_UEVENTS))

#define so_blocked_set(sock, flags)                                           \
                                _so_set((sock), _so_encev((flags),            \
                                                          _EV_SOCK_BLOCKED))

#define so_blocked_clr(sock, flags)                                           \
                                _so_clr((sock), _so_encev((flags),            \
                                                          _EV_SOCK_BLOCKED))

#define so_closed_set(sock, flags)                                            \
                                _so_set((sock), _so_encev((flags),            \
                                                          _EV_SOCK_CLOSED))

#define so_closed_clr(sock, flags)                                            \
                                _so_clr((sock), _so_encev((flags),            \
                                                          _EV_SOCK_CLOSED))

extern void _ev_debug(ev_flags_t flags, const char *file, int line,
                      const char *func, const char *fmt, ...)
     _gca_nonnull((2, 5)) _gca_format(printf, 5, 6);

extern ev_err_t _ev_gen_lookup(ev_ctx_t *ctx, unsigned int gentype,
                               ev_gendesc_t **gen)
     _gca_nonnull((1, 3));

extern ev_err_t _timer_insert(ev_ctx_t *ctx, ev_tim_t *tim)
     _gca_nonnull((1, 2));

extern ev_err_t _timer_heapify_up(ev_ctx_t *ctx, ev_tim_t *tim)
     _gca_nonnull((1, 2));

extern ev_err_t _timer_heapify_down(ev_ctx_t *ctx, ev_tim_t *tim)
     _gca_nonnull((1, 2));

extern ev_err_t _timer_untree(ev_ctx_t *ctx, ev_tim_t *tim)
     _gca_nonnull((1, 2));

#endif /* __include_event_int_h__ */

---