vcl: make vcl_evt code compile

To include vcl_evt code in the build,
make build VPP_EXTRA_CMAKE_ARGS=-DVPP_VCL_ELOG=ON

Type: fix

Change-Id: I45bd093001de6e3dd4d6894726a470cf1ded952b
Signed-off-by: Steven Luong <[email protected]>

diff --git a/src/vcl/vcl_bapi.c b/src/vcl/vcl_bapi.c
index 42704f4..edb7e6f 100644 (file)
--- a/src/vcl/vcl_bapi.c
+++ b/src/vcl/vcl_bapi.c
@@ -553,7 +553,6 @@ vcl_bapi_connect_to_vpp (void)
   wrk->api_client_handle = (u32) am->my_client_index;
 
   VDBG (0, "app (%s) is connected to VPP!", wrk_name);
-  vcl_evt (VCL_EVT_INIT, vcm);
 
 error:
   vec_free (wrk_name);
@@ -618,7 +617,7 @@ vcl_bapi_wait_for_wrk_state_change (vcl_bapi_app_state_t app_state)
     }
   VDBG (0, "timeout waiting for state %s, current state %d",
        vcl_bapi_app_state_str (app_state), wrk->bapi_app_state);
-  vcl_evt (VCL_EVT_SESSION_TIMEOUT, vcm, bapi_app_state);
+  //  vcl_evt (VCL_EVT_SESSION_TIMEOUT, vcm, bapi_app_state);
 
   return VPPCOM_ETIMEDOUT;
 }

diff --git a/src/vcl/vcl_debug.h b/src/vcl/vcl_debug.h
index 8ee716a..1238e0d 100644 (file)
--- a/src/vcl/vcl_debug.h
+++ b/src/vcl/vcl_debug.h
@@ -18,7 +18,12 @@
 
 #include <vppinfra/elog.h>
 
-#define VCL_ELOG       0
+#ifdef VPP_VCL_ELOG
+#define VCL_ELOG 1
+#else
+#define VCL_ELOG 0
+#endif
+
 #define VCL_DBG_ON     1
 
 #define VDBG(_lvl, _fmt, _args...)                                     \
@@ -59,117 +64,113 @@ typedef enum vcl_dbg_evt_
 #undef _
 } vcl_dbg_evt_e;
 
-#if VCL_ELOG
+#if (VCL_ELOG > 0)
 
-#define VCL_DECLARE_ETD(_s, _e, _size)                                 \
-  struct { u32 data[_size]; } * ed;                                    \
-  ed = ELOG_TRACK_DATA (&vcm->elog_main, _e, _s->elog_track)           \
+#define VCL_DECLARE_ETD(_s, _e, _size)                                        \
+  struct                                                                      \
+  {                                                                           \
+    u32 data[_size];                                                          \
+  } *ed;                                                                      \
+  ed = ELOG_TRACK_DATA (&vcm->elog_main, _e, _s->elog_track)
 
-#define VCL_EVT_INIT_HANDLER(_vcm, ...)                                        \
-{                                                                      \
-  _vcm->elog_track.name = (char *) format (0, "P:%d:C:%d%c", getpid (),        \
-                                          _vcm->my_client_index, 0);   \
-  elog_track_register (&_vcm->elog_main, &_vcm->elog_track);           \
-  ELOG_TYPE_DECLARE (e) =                                              \
-  {                                                                    \
-       .format = "connect_vpp:rv:%d",                                  \
-       .format_args = "i4",                                            \
-  };                                                                   \
-  struct { u32 data; } *ed;                                            \
-  ed = ELOG_TRACK_DATA (&_vcm->elog_main, e, _vcm->elog_track);                \
-  ed->data = (u32) rv;                                                 \
-}
+#define VCL_EVT_INIT_HANDLER(_vcm, ...)                                       \
+  {                                                                           \
+    _vcm->elog_track.name =                                                   \
+      (char *) format (0, "P:%d:C:%d%c", getpid (), _vcm->app_index, 0);      \
+    elog_track_register (&_vcm->elog_main, &_vcm->elog_track);                \
+  }
 
-#define VCL_EVT_SESSION_INIT_HANDLER(_s, _s_index, ...)                        \
-{                                                                      \
-  _s->elog_track.name = (char *) format (0, "CI:%d:S:%d%c",            \
-                                        vcm->my_client_index,          \
-                                        _s_index, 0);                  \
-  elog_track_register (&vcm->elog_main, &_s->elog_track);              \
-}
+#define VCL_EVT_SESSION_INIT_HANDLER(_s, _s_index, ...)                       \
+  {                                                                           \
+    _s->elog_track.name =                                                     \
+      (char *) format (0, "CI:%d:S:%d%c", vcm->app_index, _s->_s_index, 0);   \
+    elog_track_register (&vcm->elog_main, &_s->elog_track);                   \
+  }
 
-#define VCL_EVT_BIND_HANDLER(_s, ...)                                  \
-{                                                                      \
-  if (_s->lcl_addr.is_ip4)                                             \
-    {                                                                  \
-      ELOG_TYPE_DECLARE (_e) =                                         \
+#define VCL_EVT_BIND_HANDLER(_s, ...)                                         \
+  {                                                                           \
+    if (_s->transport.is_ip4)                                                 \
+      {                                                                       \
+       ELOG_TYPE_DECLARE (_e) =                                                \
       {                                                                        \
        .format = "bind local:%s:%d.%d.%d.%d:%d ",                      \
        .format_args = "t1i1i1i1i1i2",                                  \
        .n_enum_strings = 2,                                            \
        .enum_strings = {"TCP", "UDP",},                                \
-      };                                                               \
-      CLIB_PACKED (struct {                                            \
-       u8 proto;                                                       \
-       u8 addr[4];                                                     \
-       u16 port;                                                       \
-      }) *ed;                                                          \
-      ed = ELOG_TRACK_DATA (&vcm->elog_main, _e, _s->elog_track);      \
-      ed->proto = _s->proto;                                           \
-      ed->addr[0] = _s->lcl_addr.ip46.ip4.as_u8[0];                    \
-      ed->addr[1] = _s->lcl_addr.ip46.ip4.as_u8[1];                    \
-      ed->addr[2] = _s->lcl_addr.ip46.ip4.as_u8[2];                    \
-      ed->addr[3] = _s->lcl_addr.ip46.ip4.as_u8[3];                    \
-      ed->port = clib_net_to_host_u16 (_s->lcl_port);                  \
-    }                                                                  \
-  else                                                                 \
-    {                                                                  \
-      /* TBD */                                                                \
-    }                                                                  \
-}
+      };                                       \
+       CLIB_PACKED (struct {                                                 \
+         u8 proto;                                                           \
+         u8 addr[4];                                                         \
+         u16 port;                                                           \
+       }) *                                                                  \
+         ed;                                                                 \
+       ed = ELOG_TRACK_DATA (&vcm->elog_main, _e, _s->elog_track);           \
+       ed->proto = _s->session_type;                                         \
+       ed->addr[0] = _s->transport.lcl_ip.ip4.as_u8[0];                      \
+       ed->addr[1] = _s->transport.lcl_ip.ip4.as_u8[1];                      \
+       ed->addr[2] = _s->transport.lcl_ip.ip4.as_u8[2];                      \
+       ed->addr[3] = _s->transport.lcl_ip.ip4.as_u8[3];                      \
+       ed->port = clib_net_to_host_u16 (_s->transport.lcl_port);             \
+      }                                                                       \
+    else                                                                      \
+      {                                                                       \
+       /* TBD */                                                             \
+      }                                                                       \
+  }
 
-#define VCL_EVT_ACCEPT_HANDLER(_s, _ls, _s_idx, ...)                   \
-{                                                                      \
-  VCL_EVT_SESSION_INIT_HANDLER (_s, _s_idx);                           \
-  ELOG_TYPE_DECLARE (_e) =                                             \
-  {                                                                    \
-    .format = "accept: listen_handle:%x from_handle:%x",               \
-    .format_args = "i8i8",                                             \
-  };                                                                   \
-  struct { u64 handle[2];  } *ed;                                      \
-  ed = ELOG_TRACK_DATA (&vcm->elog_main, _e, _s->elog_track);          \
-  ed->handle[0] = _ls->vpp_handle;                                     \
-  ed->handle[1] = _s->vpp_handle;                                      \
-  if (_s->peer_addr.is_ip4)                                            \
-    {                                                                  \
-      ELOG_TYPE_DECLARE (_e) =                                         \
-      {                                                                        \
-       .format = "accept:S:%x addr:%d.%d.%d.%d:%d",                    \
-       .format_args = "i8i1i1i1i1i2",                                  \
-      };                                                               \
-      CLIB_PACKED (struct {                                            \
-       u32 s_idx;                                                      \
-       u8 addr[4];                                                     \
-       u16 port;                                                       \
-      }) * ed;                                                         \
-      ed = ELOG_TRACK_DATA (&vcm->elog_main, _e, _s->elog_track);      \
-      ed->s_idx = _s_idx;                                              \
-      ed->addr[0] = _s->peer_addr.ip46.ip4.as_u8[0];                   \
-      ed->addr[1] = _s->peer_addr.ip46.ip4.as_u8[1];                   \
-      ed->addr[2] = _s->peer_addr.ip46.ip4.as_u8[2];                   \
-      ed->addr[3] = _s->peer_addr.ip46.ip4.as_u8[3];                   \
-      ed->port = clib_net_to_host_u16 (_s->peer_port);                 \
-    }                                                                  \
-  else                                                                 \
-    {                                                                  \
-      /* TBD */                                                                \
-    }                                                                  \
-}
+#define VCL_EVT_ACCEPT_HANDLER(_s, _ls, _s_idx, ...)                          \
+  {                                                                           \
+    VCL_EVT_SESSION_INIT_HANDLER (_s, _s_idx);                                \
+    ELOG_TYPE_DECLARE (_e) = {                                                \
+      .format = "accept: listen_handle:%x from_handle:%x",                    \
+      .format_args = "i8i8",                                                  \
+    };                                                                        \
+    struct                                                                    \
+    {                                                                         \
+      u64 handle[2];                                                          \
+    } *ed;                                                                    \
+    ed = ELOG_TRACK_DATA (&vcm->elog_main, _e, _s->elog_track);               \
+    ed->handle[0] = _ls->vpp_handle;                                          \
+    ed->handle[1] = _s->vpp_handle;                                           \
+    if (_s->transport.is_ip4)                                                 \
+      {                                                                       \
+       ELOG_TYPE_DECLARE (_e) = {                                            \
+         .format = "accept:S:%x addr:%d.%d.%d.%d:%d",                        \
+         .format_args = "i8i1i1i1i1i2",                                      \
+       };                                                                    \
+       CLIB_PACKED (struct {                                                 \
+         u32 s_idx;                                                          \
+         u8 addr[4];                                                         \
+         u16 port;                                                           \
+       }) *                                                                  \
+         ed;                                                                 \
+       ed = ELOG_TRACK_DATA (&vcm->elog_main, _e, _s->elog_track);           \
+       ed->s_idx = _s->_s_idx;                                               \
+       ed->addr[0] = _s->transport.rmt_ip.ip4.as_u8[0];                      \
+       ed->addr[1] = _s->transport.rmt_ip.ip4.as_u8[1];                      \
+       ed->addr[2] = _s->transport.rmt_ip.ip4.as_u8[2];                      \
+       ed->addr[3] = _s->transport.rmt_ip.ip4.as_u8[3];                      \
+       ed->port = clib_net_to_host_u16 (_s->transport.rmt_port);             \
+      }                                                                       \
+    else                                                                      \
+      {                                                                       \
+       /* TBD */                                                             \
+      }                                                                       \
+  }
 
-#define VCL_EVT_CREATE_HANDLER(_s, _proto, _state, _is_nb, _s_idx, ...)        \
-{                                                                      \
-  VCL_EVT_SESSION_INIT_HANDLER (_s, _s_idx);                           \
-  ELOG_TYPE_DECLARE (_e) =                                             \
-  {                                                                    \
-    .format = "create:proto:%d state:%d is_nonblk:%d idx: %d",         \
-    .format_args = "i4i4i4i4",                                         \
-  };                                                                   \
-  VCL_DECLARE_ETD (_s, _e, 4);                                         \
-  ed->data[0] = _proto;                                                        \
-  ed->data[1] = _state;                                                        \
-  ed->data[2] = _is_nb;                                                        \
-  ed->data[3] = _s_idx;                                                        \
-}
+#define VCL_EVT_CREATE_HANDLER(_s, _proto, _state, _is_nb, _s_idx, ...)       \
+  {                                                                           \
+    VCL_EVT_SESSION_INIT_HANDLER (_s, _s_idx);                                \
+    ELOG_TYPE_DECLARE (_e) = {                                                \
+      .format = "create:proto:%d state:%d is_nonblk:%d idx: %d",              \
+      .format_args = "i4i4i4i4",                                              \
+    };                                                                        \
+    VCL_DECLARE_ETD (_s, _e, 4);                                              \
+    ed->data[0] = _s->_proto;                                                 \
+    ed->data[1] = _s->_state;                                                 \
+    ed->data[2] = _is_nb;                                                     \
+    ed->data[3] = _s->_s_idx;                                                 \
+  }
 
 #define VCL_EVT_CLOSE_HANDLER(_s, _rv, ...)                            \
 {                                                                      \
@@ -182,16 +183,15 @@ typedef enum vcl_dbg_evt_
   ed->data[0] = _rv;                                                   \
 }
 
-#define VCL_EVT_SESSION_TIMEOUT_HANDLER(_s, _state, ...)               \
-{                                                                      \
-  ELOG_TYPE_DECLARE (_e) =                                             \
-  {                                                                    \
-    .format = "ERR: timeout state:%d",                                 \
-    .format_args = "i4",                                               \
-  };                                                                   \
-  VCL_DECLARE_ETD (_s, _e, 1);                                         \
-  ed->data[0] = _state;                                                        \
-}
+#define VCL_EVT_SESSION_TIMEOUT_HANDLER(_s, _state, ...)                      \
+  {                                                                           \
+    ELOG_TYPE_DECLARE (_e) = {                                                \
+      .format = "ERR: timeout state:%d",                                      \
+      .format_args = "i4",                                                    \
+    };                                                                        \
+    VCL_DECLARE_ETD (_s, _e, 1);                                              \
+    ed->data[0] = _s->_state;                                                 \
+  }
 
 #define VCL_EVT_TIMEOUT_HANDLER(_vcm, _state, ...)                     \
 {                                                                      \
@@ -205,17 +205,19 @@ typedef enum vcl_dbg_evt_
   ed->data[0] = _state;                                                        \
 }
 
-#define VCL_EVT_DETACH_HANDLER(_vcm, ...)                              \
-{                                                                      \
-  ELOG_TYPE_DECLARE (_e) =                                             \
-  {                                                                    \
-    .format = "app_detach:C:%d",                                       \
-    .format_args = "i4",                                               \
-  };                                                                   \
-  struct { u32 data; } * ed;                                           \
-  ed = ELOG_TRACK_DATA (&_vcm->elog_main, _e, _vcm->elog_track);       \
-  ed->data = _vcm->my_client_index;                                    \
-}
+#define VCL_EVT_DETACH_HANDLER(_vcm, ...)                                     \
+  {                                                                           \
+    ELOG_TYPE_DECLARE (_e) = {                                                \
+      .format = "app_detach:C:%d",                                            \
+      .format_args = "i4",                                                    \
+    };                                                                        \
+    struct                                                                    \
+    {                                                                         \
+      u32 data;                                                               \
+    } *ed;                                                                    \
+    ed = ELOG_TRACK_DATA (&_vcm->elog_main, _e, _vcm->elog_track);            \
+    ed->data = _vcm->app_index;                                               \
+  }
 
 #define VCL_EVT_UNBIND_HANDLER(_s, ...)                                        \
 {                                                                      \
@@ -229,17 +231,16 @@ typedef enum vcl_dbg_evt_
   ed->data = _s->vpp_handle;                                           \
 }
 
-#define VCL_EVT_EPOLL_CREATE_HANDLER(_s, _s_idx, ...)                  \
-{                                                                      \
-  VCL_EVT_SESSION_INIT_HANDLER (_s, _s_idx);                           \
-  ELOG_TYPE_DECLARE (_e) =                                             \
-  {                                                                    \
-    .format = "create epoll vep_idx: %d",                              \
-    .format_args = "i4",                                               \
-  };                                                                   \
-  VCL_DECLARE_ETD (_s, _e, 1);                                         \
-  ed->data[0] = _s_idx;                                                        \
-}
+#define VCL_EVT_EPOLL_CREATE_HANDLER(_s, _s_idx, ...)                         \
+  {                                                                           \
+    VCL_EVT_SESSION_INIT_HANDLER (_s, _s_idx);                                \
+    ELOG_TYPE_DECLARE (_e) = {                                                \
+      .format = "create epoll vep_idx: %d",                                   \
+      .format_args = "i4",                                                    \
+    };                                                                        \
+    VCL_DECLARE_ETD (_s, _e, 1);                                              \
+    ed->data[0] = _s->_s_idx;                                                 \
+  }
 
 #define VCL_EVT_EPOLL_CTLADD_HANDLER(_s, _evts, _evt_data, ...)                \
 {                                                                      \
@@ -268,30 +269,29 @@ typedef enum vcl_dbg_evt_
   ed->data[0] = _vep_idx;                                              \
 }
 
-#define vcl_elog_init(_vcm)                                            \
-{                                                                      \
-  _vcm->elog_main.lock = clib_mem_alloc_aligned (CLIB_CACHE_LINE_BYTES,        \
-                                                CLIB_CACHE_LINE_BYTES);\
-  _vcm->elog_main.lock[0] = 0;                                         \
-  _vcm->elog_main.event_ring_size = _vcm->cfg.event_ring_size;         \
-  elog_init (&_vcm->elog_main, _vcm->elog_main.event_ring_size);       \
-  elog_enable_disable (&_vcm->elog_main, 1);                           \
-}
+#define vcl_elog_init(_vcm)                                                   \
+  {                                                                           \
+    _vcm->elog_main.lock =                                                    \
+      clib_mem_alloc_aligned (CLIB_CACHE_LINE_BYTES, CLIB_CACHE_LINE_BYTES);  \
+    _vcm->elog_main.lock[0] = 0;                                              \
+    _vcm->elog_main.event_ring_size = (128 << 10);                            \
+    elog_init (&_vcm->elog_main, _vcm->elog_main.event_ring_size);            \
+    elog_enable_disable (&_vcm->elog_main, 1);                                \
+  }
 
-#define vcl_elog_stop(_vcm)                                            \
-{                                                                      \
-  clib_error_t *error = 0;                                             \
-  char *chroot_file = (char *) format (0, "%s/%d-%d-vcl-elog%c",       \
-                                       _vcm->cfg.event_log_path,       \
-                                       _vcm->my_client_index,          \
-                                       getpid (), 0);                  \
-  error = elog_write_file (&_vcm->elog_main, chroot_file,              \
-                           1 /* flush ring */ );                       \
-  if (error)                                                           \
-    clib_error_report (error);                                         \
-  clib_warning ("[%d] Event Log:'%s' ", getpid (), chroot_file);       \
-  vec_free (chroot_file);                                              \
-}
+#define vcl_elog_stop(_vcm)                                                   \
+  {                                                                           \
+    clib_error_t *error = 0;                                                  \
+    char *chroot_file =                                                       \
+      (char *) format (0, "%s/%d-%d-vcl-elog%c", _vcm->cfg.event_log_path,    \
+                      _vcm->app_index, getpid (), 0);                        \
+    error =                                                                   \
+      elog_write_file (&_vcm->elog_main, chroot_file, 1 /* flush ring */);    \
+    if (error)                                                                \
+      clib_error_report (error);                                              \
+    clib_warning ("[%d] Event Log:'%s' ", getpid (), chroot_file);            \
+    vec_free (chroot_file);                                                   \
+  }
 
 #define CONCAT_HELPER(_a, _b) _a##_b
 #define CC(_a, _b) CONCAT_HELPER(_a, _b)

diff --git a/src/vcl/vcl_private.h b/src/vcl/vcl_private.h
index a66dbf3..61894d7 100644 (file)
--- a/src/vcl/vcl_private.h
+++ b/src/vcl/vcl_private.h
@@ -186,7 +186,7 @@ typedef struct vcl_session_
 
   i32 vpp_error;
 
-#if VCL_ELOG
+#if (VCL_ELOG > 0)
   elog_track_t elog_track;
 #endif
 
@@ -394,7 +394,7 @@ typedef struct vppcom_main_t_
   /* VNET_API_ERROR_FOO -> "Foo" hash table */
   uword *error_string_by_error_number;
 
-#ifdef VCL_ELOG
+#if (VCL_ELOG > 0)
   /* VPP Event-logger */
   elog_main_t elog_main;
   elog_track_t elog_track;

diff --git a/src/vcl/vppcom.c b/src/vcl/vppcom.c
index ee249b3..57b7214 100644 (file)
--- a/src/vcl/vppcom.c
+++ b/src/vcl/vppcom.c
@@ -16,7 +16,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <vcl/vppcom.h>
-#include <vcl/vcl_debug.h>
 #include <vcl/vcl_private.h>
 #include <svm/fifo_segment.h>
 
@@ -1493,6 +1492,7 @@ vppcom_app_create (const char *app_name)
   clib_rwlock_init (&vcm->segment_table_lock);
   atexit (vppcom_app_exit);
   vcl_elog_init (vcm);
+  vcl_evt (VCL_EVT_INIT, vcm);
 
   /* Allocate default worker */
   vcl_worker_alloc_and_init ();
@@ -1560,7 +1560,7 @@ vppcom_session_create (u8 proto, u8 is_nonblocking)
   if (is_nonblocking)
     vcl_session_set_attr (session, VCL_SESS_ATTR_NONBLOCK);
 
-  vcl_evt (VCL_EVT_CREATE, session, session_type, session->session_state,
+  vcl_evt (VCL_EVT_CREATE, session, session_type, session_state,
           is_nonblocking, session_index);
 
   VDBG (0, "created session %u", session->session_index);
@@ -1941,7 +1941,7 @@ handle:
        vcl_format_ip46_address, &client_session->transport.lcl_ip,
        client_session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
        clib_net_to_host_u16 (client_session->transport.lcl_port));
-  vcl_evt (VCL_EVT_ACCEPT, client_session, ls, client_session_index);
+  vcl_evt (VCL_EVT_ACCEPT, client_session, ls, session_index);
 
   /*
    * Session might have been closed already
@@ -3029,7 +3029,7 @@ vppcom_epoll_create (void)
   vep_session->vep.prev_sh = ~0;
   vep_session->vpp_handle = SESSION_INVALID_HANDLE;
 
-  vcl_evt (VCL_EVT_EPOLL_CREATE, vep_session, vep_session->session_index);
+  vcl_evt (VCL_EVT_EPOLL_CREATE, vep_session, session_index);
   VDBG (0, "Created vep_idx %u", vep_session->session_index);
 
   return vcl_session_handle (vep_session);
@@ -3287,7 +3287,7 @@ vppcom_epoll_ctl (uint32_t vep_handle, int op, uint32_t session_handle,
 
       VDBG (1, "EPOLL_CTL_DEL: vep_idx %u, sh %u!", vep_handle,
            session_handle);
-      vcl_evt (VCL_EVT_EPOLL_CTLDEL, s, vep_sh);
+      vcl_evt (VCL_EVT_EPOLL_CTLDEL, s, vep_handle);
       break;
 
     default:

diff --git a/src/vpp/vnet/config.h.in b/src/vpp/vnet/config.h.in
index e8548c9..d3012b3 100644 (file)
--- a/src/vpp/vnet/config.h.in
+++ b/src/vpp/vnet/config.h.in
@@ -20,5 +20,6 @@
 #cmakedefine VPP_IP_FIB_MTRIE_16
 #cmakedefine VPP_TCP_DEBUG_ALWAYS
 #cmakedefine VPP_SESSION_DEBUG
+#cmakedefine VPP_VCL_ELOG
 
 #endif