vcl: refactor vcl session
[vpp.git] / src / vcl / vppcom.c
index 62d754b..3cd2e76 100644 (file)
@@ -22,9 +22,9 @@
 #include <vnet/session/application_interface.h>
 #include <vcl/vppcom.h>
 #include <vcl/vcl_event.h>
+#include <vcl/vcl_debug.h>
 #include <vlib/unix/unix.h>
 #include <vppinfra/vec_bootstrap.h>
-#include <vppinfra/elog.h>
 
 #define vl_typedefs            /* define message structures */
 #include <vpp/api/vpe_all_api_h.h>
@@ -133,10 +133,9 @@ do {                                            \
 
 typedef struct
 {
-  volatile session_state_t state;
-
-  svm_fifo_t *rx_fifo;
-  svm_fifo_t *tx_fifo;
+#define _(type, name) type name;
+  foreach_app_session_field
+#undef _
   u32 sndbuf_size;             // VPP-TBD: Hack until support setsockopt(SO_SNDBUF)
   u32 rcvbuf_size;             // VPP-TBD: Hack until support setsockopt(SO_RCVBUF)
   u32 user_mss;                        // VPP-TBD: Hack until support setsockopt(TCP_MAXSEG)
@@ -144,7 +143,6 @@ typedef struct
   u32 sm_seg_index;
   u32 client_context;
   u64 vpp_handle;
-  svm_queue_t *vpp_event_queue;
 
   /* Socket configuration state */
   u8 is_vep;
@@ -153,16 +151,13 @@ typedef struct
   u32 wait_cont_idx;
   vppcom_epoll_t vep;
   int libc_epfd;
-  vppcom_ip46_t lcl_addr;
-  vppcom_ip46_t peer_addr;
-  u16 lcl_port;                        // network order
-  u16 peer_port;               // network order
-  u8 proto;
   u64 client_queue_address;
   u64 options[16];
-  elog_track_t elog_track;
   vce_event_handler_reg_t *poll_reg;
-} session_t;
+#if VCL_ELOG
+  elog_track_t elog_track;
+#endif
+} vcl_session_t;
 
 typedef struct vppcom_cfg_t_
 {
@@ -207,7 +202,7 @@ typedef struct vppcom_main_t_
   u32 my_client_index;
   /* Session pool */
   clib_spinlock_t sessions_lockp;
-  session_t *sessions;
+  vcl_session_t *sessions;
 
   /* Hash table for disconnect processing */
   uword *session_index_by_vpp_handles;
@@ -237,9 +232,11 @@ typedef struct vppcom_main_t_
   /* IO thread */
   vppcom_session_io_thread_t session_io_thread;
 
+#ifdef VCL_ELOG
   /* VPP Event-logger */
   elog_main_t elog_main;
   elog_track_t elog_track;
+#endif
 
   /* VNET_API_ERROR_FOO -> "Foo" hash table */
   uword *error_string_by_error_number;
@@ -366,7 +363,7 @@ vppcom_session_state_str (session_state_t state)
  */
 
 static inline int
-vppcom_session_at_index (u32 session_index, session_t * volatile *sess)
+vppcom_session_at_index (u32 session_index, vcl_session_t * volatile *sess)
 {
   /* Assumes that caller has acquired spinlock: vcm->sessions_lockp */
   if (PREDICT_FALSE ((session_index == ~0) ||
@@ -390,12 +387,12 @@ vppcom_session_table_add_listener (u64 listener_handle, u32 value)
   hash_set (vcm->session_index_by_vpp_handles, listener_handle, value);
 }
 
-static inline session_t *
+static inline vcl_session_t *
 vppcom_session_table_lookup_listener (u64 listener_handle)
 {
   uword *p;
   u64 handle = listener_handle | (1ULL << 63);
-  session_t *session;
+  vcl_session_t *session;
 
   p = hash_get (vcm->session_index_by_vpp_handles, handle);
   if (!p)
@@ -406,14 +403,12 @@ vppcom_session_table_lookup_listener (u64 listener_handle)
     }
   if (pool_is_free_index (vcm->sessions, p[0]))
     {
-      if (VPPCOM_DEBUG > 1)
-       clib_warning ("VCL<%d>: invalid listen session, sid (%u)",
-                     getpid (), p[0]);
+      VDBG (1, "VCL<%d>: invalid listen session, sid (%u)", getpid (), p[0]);
       return 0;
     }
 
   session = pool_elt_at_index (vcm->sessions, p[0]);
-  ASSERT (session->state & STATE_LISTEN);
+  ASSERT (session->session_state & STATE_LISTEN);
   return session;
 }
 
@@ -424,26 +419,6 @@ vppcom_session_table_del_listener (u64 listener_handle)
   hash_unset (vcm->session_index_by_vpp_handles, listener_handle);
 }
 
-static void
-write_elog (void)
-{
-  elog_main_t *em = &vcm->elog_main;
-  char *chroot_file;
-  clib_error_t *error = 0;
-
-  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 (em, chroot_file, 1 /* flush ring */ );
-  if (error)
-    {
-      clib_error_report (error);
-    }
-  if (VPPCOM_DEBUG > 0)
-    clib_warning ("[%d] Event Log:'%s' ", getpid (), chroot_file);
-
-}
-
 static inline void
 vppcom_send_accept_session_reply (u64 handle, u32 context, int retval)
 {
@@ -468,9 +443,8 @@ vppcom_connect_to_vpp (char *app_name)
   if (!vcl_cfg->vpp_api_filename)
     vcl_cfg->vpp_api_filename = format (0, "/vpe-api%c", 0);
 
-  if (VPPCOM_DEBUG > 0)
-    clib_warning ("VCL<%d>: app (%s) connecting to VPP api (%s)...",
-                 getpid (), app_name, vcl_cfg->vpp_api_filename);
+  VDBG (0, "VCL<%d>: app (%s) connecting to VPP api (%s)...",
+       getpid (), app_name, vcl_cfg->vpp_api_filename);
 
   if (vl_client_connect_to_vlib ((char *) vcl_cfg->vpp_api_filename, app_name,
                                 vcm->cfg.vpp_api_q_length) < 0)
@@ -484,39 +458,10 @@ vppcom_connect_to_vpp (char *app_name)
       vcm->my_client_index = (u32) am->my_client_index;
       vcm->app_state = STATE_APP_CONN_VPP;
 
-      if (VPPCOM_DEBUG > 0)
-       clib_warning ("VCL<%d>: app (%s) is connected to VPP!",
-                     getpid (), app_name);
+      VDBG (0, "VCL<%d>: app (%s) is connected to VPP!", getpid (), app_name);
     }
 
-  if (VPPCOM_DEBUG > 0)
-    {
-      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);
-
-      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);
-
-      /* *INDENT-OFF* */
-      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;
-      /* *INDENT-ON* */
-    }
+  vcl_evt (VCL_EVT_INIT, vcm);
   return rv;
 }
 
@@ -557,28 +502,9 @@ vppcom_wait_for_app_state_change (app_state_t app_state)
       if (vcm->app_state == app_state)
        return VPPCOM_OK;
     }
-  if (VPPCOM_DEBUG > 0)
-    clib_warning ("VCL<%d>: timeout waiting for state %s (%d)", getpid (),
-                 vppcom_app_state_str (app_state), app_state);
-
-  if (VPPCOM_DEBUG > 0)
-    {
-      /* *INDENT-OFF* */
-      ELOG_TYPE_DECLARE (e) =
-       {
-         .format = "ERR: timeout state:%d",
-         .format_args = "i4",
-       };
-      struct
-      {
-       u32 data;
-      } *ed;
-
-      ed = ELOG_TRACK_DATA (&vcm->elog_main, e, vcm->elog_track);
-
-      ed->data = app_state;
-      /* *INDENT-ON* */
-    }
+  VDBG (0, "VCL<%d>: timeout waiting for state %s (%d)", getpid (),
+       vppcom_app_state_str (app_state), app_state);
+  vcl_evt (VCL_EVT_SESSION_TIMEOUT, vcm, app_state);
 
   return VPPCOM_ETIMEDOUT;
 }
@@ -589,7 +515,7 @@ vppcom_wait_for_session_state_change (u32 session_index,
                                      f64 wait_for_time)
 {
   f64 timeout = clib_time_now (&vcm->clib_time) + wait_for_time;
-  session_t *volatile session;
+  vcl_session_t *volatile session;
   int rv;
 
   do
@@ -601,12 +527,12 @@ vppcom_wait_for_session_state_change (u32 session_index,
          VCL_SESSION_UNLOCK ();
          return rv;
        }
-      if (session->state & state)
+      if (session->session_state & state)
        {
          VCL_SESSION_UNLOCK ();
          return VPPCOM_OK;
        }
-      if (session->state & STATE_FAILED)
+      if (session->session_state & STATE_FAILED)
        {
          VCL_SESSION_UNLOCK ();
          return VPPCOM_ECONNREFUSED;
@@ -616,28 +542,9 @@ vppcom_wait_for_session_state_change (u32 session_index,
     }
   while (clib_time_now (&vcm->clib_time) < timeout);
 
-  if (VPPCOM_DEBUG > 0)
-    clib_warning ("VCL<%d>: timeout waiting for state 0x%x (%s)", getpid (),
-                 state, vppcom_session_state_str (state));
-
-  if (VPPCOM_DEBUG > 0)
-    {
-      /* *INDENT-OFF* */
-      ELOG_TYPE_DECLARE (e) =
-       {
-         .format = "ERR: timeout state:%d",
-         .format_args = "i4",
-       };
-      struct
-      {
-       u32 data;
-      } *ed;
-
-      ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-
-      ed->data = state;
-      /* *INDENT-ON* */
-    }
+  VDBG (0, "VCL<%d>: timeout waiting for state 0x%x (%s)", getpid (), state,
+       vppcom_session_state_str (state));
+  vcl_evt (VCL_EVT_SESSION_TIMEOUT, session, session_state);
 
   return VPPCOM_ETIMEDOUT;
 }
@@ -670,10 +577,8 @@ vppcom_app_session_enable (void)
       rv = vppcom_wait_for_app_state_change (STATE_APP_ENABLED);
       if (PREDICT_FALSE (rv))
        {
-         if (VPPCOM_DEBUG > 0)
-           clib_warning ("VCL<%d>: application session enable timed out! "
-                         "returning %d (%s)",
-                         getpid (), rv, vppcom_retval_str (rv));
+         VDBG (0, "VCL<%d>: application session enable timed out! "
+               "returning %d (%s)", getpid (), rv, vppcom_retval_str (rv));
          return rv;
        }
     }
@@ -740,10 +645,8 @@ vppcom_app_attach (void)
   rv = vppcom_wait_for_app_state_change (STATE_APP_ATTACHED);
   if (PREDICT_FALSE (rv))
     {
-      if (VPPCOM_DEBUG > 0)
-       clib_warning ("VCL<%d>: application attach timed out! "
-                     "returning %d (%s)",
-                     getpid (), rv, vppcom_retval_str (rv));
+      VDBG (0, "VCL<%d>: application attach timed out! returning %d (%s)",
+           getpid (), rv, vppcom_retval_str (rv));
       return rv;
     }
 
@@ -846,9 +749,9 @@ vl_api_map_another_segment_t_handler (vl_api_map_another_segment_t * mp)
                    getpid (), mp->segment_name);
       return;
     }
-  if (VPPCOM_DEBUG > 1)
-    clib_warning ("VCL<%d>: mapped new segment '%s' size %d", getpid (),
-                 mp->segment_name, mp->segment_size);
+
+  VDBG (1, "VCL<%d>: mapped new segment '%s' size %d", getpid (),
+       mp->segment_name, mp->segment_size);
 }
 
 static void
@@ -859,8 +762,8 @@ vl_api_unmap_segment_t_handler (vl_api_unmap_segment_t * mp)
  * XXX Need segment_name to session_id hash,
  * XXX - have sessionID by handle hash currently
  */
-  if (VPPCOM_DEBUG > 1)
-    clib_warning ("Unmapped segment '%s'", mp->segment_name);
+
+  VDBG (1, "Unmapped segment '%s'", mp->segment_name);
 }
 
 static void
@@ -872,25 +775,22 @@ vl_api_disconnect_session_t_handler (vl_api_disconnect_session_t * mp)
   if (p)
     {
       int rv;
-      session_t *session = 0;
+      vcl_session_t *session = 0;
       u32 session_index = p[0];
 
       VCL_SESSION_LOCK_AND_GET (session_index, &session);
-      session->state = STATE_CLOSE_ON_EMPTY;
+      session->session_state = STATE_CLOSE_ON_EMPTY;
 
-      if (VPPCOM_DEBUG > 1)
-       clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
-                     "setting state to 0x%x (%s)",
-                     getpid (), mp->handle, session_index, session->state,
-                     vppcom_session_state_str (session->state));
+      VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: setting state to 0x%x "
+           "(%s)", getpid (), mp->handle, session_index,
+           session->session_state,
+           vppcom_session_state_str (session->session_state));
       VCL_SESSION_UNLOCK ();
       return;
 
     done:
-      if (VPPCOM_DEBUG > 1)
-       clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
-                     "session lookup failed!",
-                     getpid (), mp->handle, session_index);
+      VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: session lookup failed!",
+           getpid (), mp->handle, session_index);
     }
   else
     clib_warning ("VCL<%d>: vpp handle 0x%llx: session lookup by "
@@ -900,7 +800,7 @@ vl_api_disconnect_session_t_handler (vl_api_disconnect_session_t * mp)
 static void
 vl_api_reset_session_t_handler (vl_api_reset_session_t * mp)
 {
-  session_t *session = 0;
+  vcl_session_t *session = 0;
   vl_api_reset_session_reply_t *rmp;
   uword *p;
   int rv = 0;
@@ -924,13 +824,11 @@ vl_api_reset_session_t_handler (vl_api_reset_session_t * mp)
          /* TBD: should this disconnect immediately and
           * flush the fifos?
           */
-         session->state = STATE_CLOSE_ON_EMPTY;
+         session->session_state = STATE_CLOSE_ON_EMPTY;
 
-         if (VPPCOM_DEBUG > 1)
-           clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
-                         "state set to %d (%s)!", getpid (),
-                         mp->handle, p[0], session->state,
-                         vppcom_session_state_str (session->state));
+         VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: state set to %d "
+               "(%s)!", getpid (), mp->handle, p[0], session->session_state,
+               vppcom_session_state_str (session->session_state));
        }
       VCL_SESSION_UNLOCK ();
     }
@@ -953,7 +851,7 @@ vl_api_reset_session_t_handler (vl_api_reset_session_t * mp)
 static void
 vl_api_connect_session_reply_t_handler (vl_api_connect_session_reply_t * mp)
 {
-  session_t *session = 0;
+  vcl_session_t *session = 0;
   u32 session_index;
   svm_fifo_t *rx_fifo, *tx_fifo;
   int rv = VPPCOM_OK;
@@ -969,7 +867,7 @@ done:
                    format_api_error, ntohl (mp->retval));
       if (session)
        {
-         session->state = STATE_FAILED;
+         session->session_state = STATE_FAILED;
          session->vpp_handle = mp->handle;
        }
       else
@@ -997,8 +895,8 @@ done:
       *active_session_index = session_index;
       VCL_IO_SESSIONS_UNLOCK ();
     }
-  session->vpp_event_queue = uword_to_pointer (mp->vpp_event_queue_address,
-                                              svm_queue_t *);
+  session->vpp_evt_q = uword_to_pointer (mp->vpp_event_queue_address,
+                                        svm_queue_t *);
 
   rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
   rx_fifo->client_session_index = session_index;
@@ -1008,29 +906,25 @@ done:
   session->rx_fifo = rx_fifo;
   session->tx_fifo = tx_fifo;
   session->vpp_handle = mp->handle;
-  session->lcl_addr.is_ip4 = mp->is_ip4;
-  clib_memcpy (&session->lcl_addr.ip46, mp->lcl_ip,
-              sizeof (session->peer_addr.ip46));
-  session->lcl_port = mp->lcl_port;
-  session->state = STATE_CONNECT;
+  session->transport.is_ip4 = mp->is_ip4;
+  clib_memcpy (&session->transport.lcl_ip, mp->lcl_ip,
+              sizeof (session->transport.rmt_ip));
+  session->transport.lcl_port = mp->lcl_port;
+  session->session_state = STATE_CONNECT;
 
   /* Add it to lookup table */
   hash_set (vcm->session_index_by_vpp_handles, mp->handle, session_index);
 
-  if (VPPCOM_DEBUG > 1)
-    clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: connect succeeded!"
-                 " session_rx_fifo %p, refcnt %d,"
-                 " session_tx_fifo %p, refcnt %d",
-                 getpid (), mp->handle, session_index,
-                 session->rx_fifo,
-                 session->rx_fifo->refcnt,
-                 session->tx_fifo, session->tx_fifo->refcnt);
+  VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: connect succeeded! "
+       "session_rx_fifo %p, refcnt %d, session_tx_fifo %p, refcnt %d",
+       getpid (), mp->handle, session_index, session->rx_fifo,
+       session->rx_fifo->refcnt, session->tx_fifo, session->tx_fifo->refcnt);
 done_unlock:
   VCL_SESSION_UNLOCK ();
 }
 
 static void
-vppcom_send_connect_sock (session_t * session, u32 session_index)
+vppcom_send_connect_sock (vcl_session_t * session, u32 session_index)
 {
   vl_api_connect_sock_t *cmp;
 
@@ -1041,10 +935,10 @@ vppcom_send_connect_sock (session_t * session, u32 session_index)
   cmp->client_index = vcm->my_client_index;
   cmp->context = session_index;
 
-  cmp->is_ip4 = session->peer_addr.is_ip4;
-  clib_memcpy (cmp->ip, &session->peer_addr.ip46, sizeof (cmp->ip));
-  cmp->port = session->peer_port;
-  cmp->proto = session->proto;
+  cmp->is_ip4 = session->transport.is_ip4;
+  clib_memcpy (cmp->ip, &session->transport.rmt_ip, sizeof (cmp->ip));
+  cmp->port = session->transport.rmt_port;
+  cmp->proto = session->session_type;
   clib_memcpy (cmp->options, session->options, sizeof (cmp->options));
   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & cmp);
 }
@@ -1055,10 +949,8 @@ vppcom_send_disconnect_session_reply (u64 vpp_handle, u32 session_index,
 {
   vl_api_disconnect_session_reply_t *rmp;
 
-  if (VPPCOM_DEBUG > 1)
-    clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
-                 "sending disconnect msg",
-                 getpid (), vpp_handle, session_index);
+  VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: sending disconnect msg",
+       getpid (), vpp_handle, session_index);
 
   rmp = vl_msg_api_alloc (sizeof (*rmp));
   memset (rmp, 0, sizeof (*rmp));
@@ -1074,10 +966,8 @@ vppcom_send_disconnect_session (u64 vpp_handle, u32 session_index)
 {
   vl_api_disconnect_session_t *dmp;
 
-  if (VPPCOM_DEBUG > 1)
-    clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
-                 "sending disconnect msg",
-                 getpid (), vpp_handle, session_index);
+  VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: sending disconnect msg",
+       getpid (), vpp_handle, session_index);
 
   dmp = vl_msg_api_alloc (sizeof (*dmp));
   memset (dmp, 0, sizeof (*dmp));
@@ -1090,7 +980,7 @@ vppcom_send_disconnect_session (u64 vpp_handle, u32 session_index)
 static void
 vl_api_bind_sock_reply_t_handler (vl_api_bind_sock_reply_t * mp)
 {
-  session_t *session = 0;
+  vcl_session_t *session = 0;
   u32 session_index = mp->context;
   int rv;
 
@@ -1105,7 +995,7 @@ done:
       rv = vppcom_session_at_index (session_index, &session);
       if (rv == VPPCOM_OK)
        {
-         session->state = STATE_FAILED;
+         session->session_state = STATE_FAILED;
          session->vpp_handle = mp->handle;
        }
       else
@@ -1118,16 +1008,15 @@ done:
     }
 
   session->vpp_handle = mp->handle;
-  session->lcl_addr.is_ip4 = mp->lcl_is_ip4;
-  session->lcl_addr.ip46 = to_ip46 (mp->lcl_is_ip4 ? IP46_TYPE_IP4 :
-                                   IP46_TYPE_IP6, mp->lcl_ip);
-  session->lcl_port = mp->lcl_port;
+  session->transport.is_ip4 = mp->lcl_is_ip4;
+  session->transport.lcl_ip = to_ip46 (mp->lcl_is_ip4 ? IP46_TYPE_IP4 :
+                                      IP46_TYPE_IP6, mp->lcl_ip);
+  session->transport.lcl_port = mp->lcl_port;
   vppcom_session_table_add_listener (mp->handle, session_index);
-  session->state = STATE_LISTEN;
+  session->session_state = STATE_LISTEN;
 
-  if (VPPCOM_DEBUG > 1)
-    clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: bind succeeded!",
-                 getpid (), mp->handle, mp->context);
+  VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: bind succeeded!",
+       getpid (), mp->handle, mp->context);
 done_unlock:
   VCL_SESSION_UNLOCK ();
 }
@@ -1140,9 +1029,8 @@ vl_api_unbind_sock_reply_t_handler (vl_api_unbind_sock_reply_t * mp)
                  getpid (), mp->context, format_api_error,
                  ntohl (mp->retval));
 
-  else if (VPPCOM_DEBUG > 1)
-    clib_warning ("VCL<%d>: sid %u: unbind succeeded!",
-                 getpid (), mp->context);
+  else
+    VDBG (1, "VCL<%d>: sid %u: unbind succeeded!", getpid (), mp->context);
 }
 
 u8 *
@@ -1232,7 +1120,7 @@ static void
 vl_api_accept_session_t_handler (vl_api_accept_session_t * mp)
 {
   svm_fifo_t *rx_fifo, *tx_fifo;
-  session_t *session, *listen_session;
+  vcl_session_t *session, *listen_session;
   u32 session_index;
   vce_event_connect_request_t *ecr;
   vce_event_t *ev;
@@ -1284,18 +1172,18 @@ vl_api_accept_session_t_handler (vl_api_accept_session_t * mp)
   session->client_context = mp->context;
   session->rx_fifo = rx_fifo;
   session->tx_fifo = tx_fifo;
-  session->vpp_event_queue = uword_to_pointer (mp->vpp_event_queue_address,
-                                              svm_queue_t *);
-  session->state = STATE_ACCEPT;
-  session->peer_port = mp->port;
-  session->peer_addr.is_ip4 = mp->is_ip4;
-  session->peer_addr.ip46 = to_ip46 (mp->is_ip4 ? IP46_TYPE_IP4 :
-                                    IP46_TYPE_IP6, mp->ip);
+  session->vpp_evt_q = uword_to_pointer (mp->vpp_event_queue_address,
+                                        svm_queue_t *);
+  session->session_state = STATE_ACCEPT;
+  session->transport.rmt_port = mp->port;
+  session->transport.is_ip4 = mp->is_ip4;
+  session->transport.rmt_ip = to_ip46 (mp->is_ip4 ? IP46_TYPE_IP4 :
+                                      IP46_TYPE_IP6, mp->ip);
 
   /* Add it to lookup table */
   hash_set (vcm->session_index_by_vpp_handles, mp->handle, session_index);
-  session->lcl_port = listen_session->lcl_port;
-  session->lcl_addr = listen_session->lcl_addr;
+  session->transport.lcl_port = listen_session->transport.lcl_port;
+  session->transport.lcl_ip = listen_session->transport.lcl_ip;
 
   /* Create an event for handlers */
 
@@ -1314,62 +1202,21 @@ vl_api_accept_session_t_handler (vl_api_accept_session_t * mp)
   rv = vce_generate_event (&vcm->event_thread, ev_idx);
   ASSERT (rv == 0);
 
-  if (VPPCOM_DEBUG > 1)
-    clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: client accept "
-                 "request from %s address %U port %d queue %p!", getpid (),
-                 mp->handle, session_index, mp->is_ip4 ? "IPv4" : "IPv6",
-                 format_ip46_address, &mp->ip,
-                 mp->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
-                 clib_net_to_host_u16 (mp->port), session->vpp_event_queue);
-
-  if (VPPCOM_DEBUG > 0)
-    {
-      session->elog_track.name =
-       (char *) format (0, "C:%d:S:%d%c", vcm->my_client_index,
-                        session_index, 0);
-      elog_track_register (&vcm->elog_main, &session->elog_track);
-
-      if (session->peer_addr.is_ip4)
-       {
-          /* *INDENT-OFF* */
-         ELOG_TYPE_DECLARE (e) =
-         {
-           .format =
-           "client_accept:handle:%x addr:%d.%d.%d.%d:%d",
-           .format_args = "i8i1i1i1i1i2",
-         };
-
-         CLIB_PACKED (struct {
-           u64 handle; //8
-           u8 addr[4]; //4
-           u16 port;   //2
-         }) * ed;
-
-         ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-
-         ed->handle = mp->handle;
-         ed->addr[0] = session->peer_addr.ip46.ip4.as_u8[0];
-         ed->addr[1] = session->peer_addr.ip46.ip4.as_u8[1];
-         ed->addr[2] = session->peer_addr.ip46.ip4.as_u8[2];
-         ed->addr[3] = session->peer_addr.ip46.ip4.as_u8[3];
-         ed->port = clib_net_to_host_u16 (session->peer_port);
-         /* *INDENT-ON* */
-       }
-      else
-       {
-         clib_warning ("ip6");
-       }
-    }
+  VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: client accept request from %s"
+       " address %U port %d queue %p!", getpid (), mp->handle, session_index,
+       mp->is_ip4 ? "IPv4" : "IPv6", format_ip46_address, &mp->ip,
+       mp->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
+       clib_net_to_host_u16 (mp->port), session->vpp_evt_q);
 
+  vcl_evt (VCL_EVT_ACCEPT, session, listen_session, session_index);
   VCL_SESSION_UNLOCK ();
-
 }
 
 /* VPP combines bind and listen as one operation. VCL manages the separation
  * of bind and listen locally via vppcom_session_bind() and
  * vppcom_session_listen() */
 static void
-vppcom_send_bind_sock (session_t * session, u32 session_index)
+vppcom_send_bind_sock (vcl_session_t * session, u32 session_index)
 {
   vl_api_bind_sock_t *bmp;
 
@@ -1380,10 +1227,10 @@ vppcom_send_bind_sock (session_t * session, u32 session_index)
   bmp->_vl_msg_id = ntohs (VL_API_BIND_SOCK);
   bmp->client_index = vcm->my_client_index;
   bmp->context = session_index;
-  bmp->is_ip4 = session->lcl_addr.is_ip4;
-  clib_memcpy (bmp->ip, &session->lcl_addr.ip46, sizeof (bmp->ip));
-  bmp->port = session->lcl_port;
-  bmp->proto = session->proto;
+  bmp->is_ip4 = session->transport.is_ip4;
+  clib_memcpy (bmp->ip, &session->transport.lcl_ip, sizeof (bmp->ip));
+  bmp->port = session->transport.lcl_port;
+  bmp->proto = session->session_type;
   clib_memcpy (bmp->options, session->options, sizeof (bmp->options));
   vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & bmp);
 }
@@ -1405,47 +1252,23 @@ vppcom_send_unbind_sock (u64 vpp_handle)
 static int
 vppcom_session_unbind (u32 session_index)
 {
-  session_t *session = 0;
+  vcl_session_t *session = 0;
   int rv;
   u64 vpp_handle;
-  elog_track_t session_elog_track;
 
   VCL_SESSION_LOCK_AND_GET (session_index, &session);
 
   vpp_handle = session->vpp_handle;
   vppcom_session_table_del_listener (vpp_handle);
   session->vpp_handle = ~0;
-  session->state = STATE_DISCONNECT;
-  session_elog_track = session->elog_track;
+  session->session_state = STATE_DISCONNECT;
 
   VCL_SESSION_UNLOCK ();
 
-  if (VPPCOM_DEBUG > 1)
-    clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
-                 "sending unbind msg! new state 0x%x (%s)",
-                 getpid (), vpp_handle, session_index,
-                 STATE_DISCONNECT,
-                 vppcom_session_state_str (STATE_DISCONNECT));
-
-  if (VPPCOM_DEBUG > 0)
-    {
-      /* *INDENT-OFF* */
-      ELOG_TYPE_DECLARE (e) =
-      {
-       .format = "unbind: handle:%x",
-       .format_args = "i8",
-      };
-
-      struct
-      {
-       u64 handle;
-      } *ed;
-
-      ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session_elog_track);
-      ed->handle = vpp_handle;
-      /* *INDENT-ON* */
-    }
-
+  VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: sending unbind msg! new state"
+       " 0x%x (%s)", getpid (), vpp_handle, session_index, STATE_DISCONNECT,
+       vppcom_session_state_str (STATE_DISCONNECT));
+  vcl_evt (VCL_EVT_UNBIND, session);
   vppcom_send_unbind_sock (vpp_handle);
 
 done:
@@ -1456,23 +1279,18 @@ static inline int
 vppcom_session_disconnect (u32 session_index)
 {
   int rv;
-  session_t *session;
+  vcl_session_t *session;
   u64 vpp_handle;
   session_state_t state;
 
   VCL_SESSION_LOCK_AND_GET (session_index, &session);
 
   vpp_handle = session->vpp_handle;
-  state = session->state;
+  state = session->session_state;
   VCL_SESSION_UNLOCK ();
 
-  if (VPPCOM_DEBUG > 1)
-    {
-      clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u "
-                   "state 0x%x (%s)",
-                   getpid (), vpp_handle, session_index,
-                   state, vppcom_session_state_str (state));
-    }
+  VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u state 0x%x (%s)", getpid (),
+       vpp_handle, session_index, state, vppcom_session_state_str (state));
 
   if (PREDICT_FALSE (state & STATE_LISTEN))
     {
@@ -1491,20 +1309,16 @@ vppcom_session_disconnect (u32 session_index)
       //XXX alagalah - Check and drain here?
       vppcom_send_disconnect_session_reply (vpp_handle,
                                            session_index, 0 /* rv */ );
-      if (VPPCOM_DEBUG > 1)
-       clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
-                     "sending disconnect REPLY...",
-                     getpid (), vpp_handle, session_index);
+      VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: sending disconnect "
+           "REPLY...", getpid (), vpp_handle, session_index);
     }
 
   /* Otherwise, send a disconnect session msg...
    */
   else
     {
-      if (VPPCOM_DEBUG > 1)
-       clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
-                     "sending disconnect...",
-                     getpid (), vpp_handle, session_index);
+      VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: sending disconnect...",
+           getpid (), vpp_handle, session_index);
 
       vppcom_send_disconnect_session (vpp_handle, session_index);
     }
@@ -1582,19 +1396,16 @@ vppcom_cfg_heapsize (char *conf_fname)
   fp = fopen (conf_fname, "r");
   if (fp == NULL)
     {
-      if (VPPCOM_DEBUG > 0)
-       clib_warning ("VCL<%d>: using default heapsize %lld (0x%llx)",
-                     getpid (), vcl_cfg->heapsize, vcl_cfg->heapsize);
+      VDBG (0, "VCL<%d>: using default heapsize %lld (0x%llx)", getpid (),
+           vcl_cfg->heapsize, vcl_cfg->heapsize);
       goto defaulted;
     }
 
   argv = calloc (1, sizeof (char *));
   if (argv == NULL)
     {
-      if (VPPCOM_DEBUG > 0)
-       clib_warning ("VCL<%d>: calloc failed, using default "
-                     "heapsize %lld (0x%llx)",
-                     getpid (), vcl_cfg->heapsize, vcl_cfg->heapsize);
+      VDBG (0, "VCL<%d>: calloc failed, using default heapsize %lld (0x%llx)",
+           getpid (), vcl_cfg->heapsize, vcl_cfg->heapsize);
       goto defaulted;
     }
 
@@ -1611,22 +1422,18 @@ vppcom_cfg_heapsize (char *conf_fname)
          char **tmp = realloc (argv, argc * sizeof (char *));
          if (tmp == NULL)
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: realloc failed, "
-                             "using default heapsize %lld (0x%llx)",
-                             getpid (), vcl_cfg->heapsize,
-                             vcl_cfg->heapsize);
+             VDBG (0, "VCL<%d>: realloc failed, using default heapsize %lld "
+                   "(0x%llx)", getpid (), vcl_cfg->heapsize,
+                   vcl_cfg->heapsize);
              goto defaulted;
            }
          argv = tmp;
          arg = strndup (p, 1024);
          if (arg == NULL)
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: strndup failed, "
-                             "using default heapsize %lld (0x%llx)",
-                             getpid (), vcl_cfg->heapsize,
-                             vcl_cfg->heapsize);
+             VDBG (0, "VCL<%d>: strndup failed, using default heapsize %lld "
+                   "(0x%llx)", getpid (), vcl_cfg->heapsize,
+                   vcl_cfg->heapsize);
              goto defaulted;
            }
          argv[argc - 1] = arg;
@@ -1640,10 +1447,8 @@ vppcom_cfg_heapsize (char *conf_fname)
   char **tmp = realloc (argv, (argc + 1) * sizeof (char *));
   if (tmp == NULL)
     {
-      if (VPPCOM_DEBUG > 0)
-       clib_warning ("VCL<%d>: realloc failed, "
-                     "using default heapsize %lld (0x%llx)",
-                     getpid (), vcl_cfg->heapsize, vcl_cfg->heapsize);
+      VDBG (0, "VCL<%d>: realloc failed, using default heapsize %lld "
+           "(0x%llx)", getpid (), vcl_cfg->heapsize, vcl_cfg->heapsize);
       goto defaulted;
     }
   argv = tmp;
@@ -1669,11 +1474,9 @@ vppcom_cfg_heapsize (char *conf_fname)
            }
          if (size == 0)
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: parse error '%s %s', "
-                             "using default heapsize %lld (0x%llx)",
-                             getpid (), argv[i], argv[i + 1],
-                             vcl_cfg->heapsize, vcl_cfg->heapsize);
+             VDBG (0, "VCL<%d>: parse error '%s %s', using default "
+                   "heapsize %lld (0x%llx)", getpid (), argv[i], argv[i + 1],
+                   vcl_cfg->heapsize, vcl_cfg->heapsize);
              goto defaulted;
            }
 
@@ -1683,11 +1486,9 @@ vppcom_cfg_heapsize (char *conf_fname)
            vcl_cfg->heapsize = size << 20;
          else
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: parse error '%s %s', "
-                             "using default heapsize %lld (0x%llx)",
-                             getpid (), argv[i], argv[i + 1],
-                             vcl_cfg->heapsize, vcl_cfg->heapsize);
+             VDBG (0, "VCL<%d>: parse error '%s %s', using default "
+                   "heapsize %lld (0x%llx)", getpid (), argv[i], argv[i + 1],
+                   vcl_cfg->heapsize, vcl_cfg->heapsize);
              goto defaulted;
            }
        }
@@ -1728,9 +1529,8 @@ defaulted:
   clib_memcpy (vcl_mem, &_vppcom_main, sizeof (_vppcom_main));
   vcm = vcl_mem;
 
-  if (VPPCOM_DEBUG > 0)
-    clib_warning ("VCL<%d>: allocated VCL heap = %p, size %lld (0x%llx)",
-                 getpid (), heap, vcl_cfg->heapsize, vcl_cfg->heapsize);
+  VDBG (0, "VCL<%d>: allocated VCL heap = %p, size %lld (0x%llx)", getpid (),
+       heap, vcl_cfg->heapsize, vcl_cfg->heapsize);
 }
 
 static void
@@ -1748,25 +1548,22 @@ vppcom_cfg_read (char *conf_fname)
   fd = open (conf_fname, O_RDONLY);
   if (fd < 0)
     {
-      if (VPPCOM_DEBUG > 0)
-       clib_warning ("VCL<%d>: using default configuration.",
-                     getpid (), conf_fname);
+      VDBG (0, "VCL<%d>: using default configuration.", getpid (),
+           conf_fname);
       goto file_done;
     }
 
   if (fstat (fd, &s) < 0)
     {
-      if (VPPCOM_DEBUG > 0)
-       clib_warning ("VCL<%d>: failed to stat `%s', "
-                     "using default configuration", getpid (), conf_fname);
+      VDBG (0, "VCL<%d>: failed to stat `%s', using default configuration",
+           getpid (), conf_fname);
       goto file_done;
     }
 
   if (!(S_ISREG (s.st_mode) || S_ISLNK (s.st_mode)))
     {
-      if (VPPCOM_DEBUG > 0)
-       clib_warning ("VCL<%d>: not a regular file `%s', "
-                     "using default configuration", getpid (), conf_fname);
+      VDBG (0, "VCL<%d>: not a regular file `%s', using default "
+           "configuration", getpid (), conf_fname);
       goto file_done;
     }
 
@@ -1788,11 +1585,9 @@ vppcom_cfg_read (char *conf_fname)
          if (unformat (line_input, "heapsize %s", &chroot_path))
            {
              vec_terminate_c_string (chroot_path);
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured heapsize %s, "
-                             "actual heapsize %lld (0x%llx)",
-                             getpid (), chroot_path, vcl_cfg->heapsize,
-                             vcl_cfg->heapsize);
+             VDBG (0, "VCL<%d>: configured heapsize %s, actual heapsize %lld"
+                   " (0x%llx)", getpid (), chroot_path, vcl_cfg->heapsize,
+                   vcl_cfg->heapsize);
              vec_free (chroot_path);
            }
          else if (unformat (line_input, "api-prefix %s", &chroot_path))
@@ -1804,10 +1599,9 @@ vppcom_cfg_read (char *conf_fname)
                                                  chroot_path, 0);
              vl_set_memory_root_path ((char *) chroot_path);
 
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured api-prefix (%s) and "
-                             "api filename (%s)", getpid (), chroot_path,
-                             vcl_cfg->vpp_api_filename);
+             VDBG (0, "VCL<%d>: configured api-prefix (%s) and api filename"
+                   " (%s)", getpid (), chroot_path,
+                   vcl_cfg->vpp_api_filename);
              chroot_path = 0;  /* Don't vec_free() it! */
            }
          else if (unformat (line_input, "vpp-api-q-length %d", &q_len))
@@ -1822,200 +1616,159 @@ vppcom_cfg_read (char *conf_fname)
                {
                  vcl_cfg->vpp_api_q_length = q_len;
 
-                 if (VPPCOM_DEBUG > 0)
-                   clib_warning ("VCL<%d>: configured vpp-api-q-length %u",
-                                 getpid (), vcl_cfg->vpp_api_q_length);
+                 VDBG (0, "VCL<%d>: configured vpp-api-q-length %u",
+                       getpid (), vcl_cfg->vpp_api_q_length);
                }
            }
          else if (unformat (line_input, "uid %d", &uid))
            {
              vl_set_memory_uid (uid);
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured uid %d", getpid (), uid);
+             VDBG (0, "VCL<%d>: configured uid %d", getpid (), uid);
            }
          else if (unformat (line_input, "gid %d", &gid))
            {
              vl_set_memory_gid (gid);
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured gid %d", getpid (), gid);
+             VDBG (0, "VCL<%d>: configured gid %d", getpid (), gid);
            }
          else if (unformat (line_input, "segment-baseva 0x%lx",
                             &vcl_cfg->segment_baseva))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured segment_baseva 0x%lx",
-                             getpid (), vcl_cfg->segment_baseva);
+             VDBG (0, "VCL<%d>: configured segment_baseva 0x%lx", getpid (),
+                   vcl_cfg->segment_baseva);
            }
          else if (unformat (line_input, "segment-size 0x%lx",
                             &vcl_cfg->segment_size))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured segment_size 0x%lx (%ld)",
-                             getpid (), vcl_cfg->segment_size,
-                             vcl_cfg->segment_size);
+             VDBG (0, "VCL<%d>: configured segment_size 0x%lx (%ld)",
+                   getpid (), vcl_cfg->segment_size, vcl_cfg->segment_size);
            }
          else if (unformat (line_input, "segment-size %ld",
                             &vcl_cfg->segment_size))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured segment_size %ld (0x%lx)",
-                             getpid (), vcl_cfg->segment_size,
-                             vcl_cfg->segment_size);
+             VDBG (0, "VCL<%d>: configured segment_size %ld (0x%lx)",
+                   getpid (), vcl_cfg->segment_size, vcl_cfg->segment_size);
            }
          else if (unformat (line_input, "add-segment-size 0x%lx",
                             &vcl_cfg->add_segment_size))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning
-                 ("VCL<%d>: configured add_segment_size 0x%lx (%ld)",
-                  getpid (), vcl_cfg->add_segment_size,
-                  vcl_cfg->add_segment_size);
+             VDBG (0, "VCL<%d>: configured add_segment_size 0x%lx (%ld)",
+                   getpid (), vcl_cfg->add_segment_size,
+                   vcl_cfg->add_segment_size);
            }
          else if (unformat (line_input, "add-segment-size %ld",
                             &vcl_cfg->add_segment_size))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning
-                 ("VCL<%d>: configured add_segment_size %ld (0x%lx)",
-                  getpid (), vcl_cfg->add_segment_size,
-                  vcl_cfg->add_segment_size);
+             VDBG (0, "VCL<%d>: configured add_segment_size %ld (0x%lx)",
+                   getpid (), vcl_cfg->add_segment_size,
+                   vcl_cfg->add_segment_size);
            }
          else if (unformat (line_input, "preallocated-fifo-pairs %d",
                             &vcl_cfg->preallocated_fifo_pairs))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured preallocated_fifo_pairs "
-                             "%d (0x%x)", getpid (),
-                             vcl_cfg->preallocated_fifo_pairs,
-                             vcl_cfg->preallocated_fifo_pairs);
+             VDBG (0, "VCL<%d>: configured preallocated_fifo_pairs %d "
+                   "(0x%x)", getpid (), vcl_cfg->preallocated_fifo_pairs,
+                   vcl_cfg->preallocated_fifo_pairs);
            }
          else if (unformat (line_input, "rx-fifo-size 0x%lx",
                             &vcl_cfg->rx_fifo_size))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured rx_fifo_size 0x%lx (%ld)",
-                             getpid (), vcl_cfg->rx_fifo_size,
-                             vcl_cfg->rx_fifo_size);
+             VDBG (0, "VCL<%d>: configured rx_fifo_size 0x%lx (%ld)",
+                   getpid (), vcl_cfg->rx_fifo_size, vcl_cfg->rx_fifo_size);
            }
          else if (unformat (line_input, "rx-fifo-size %ld",
                             &vcl_cfg->rx_fifo_size))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured rx_fifo_size %ld (0x%lx)",
-                             getpid (), vcl_cfg->rx_fifo_size,
-                             vcl_cfg->rx_fifo_size);
+             VDBG (0, "VCL<%d>: configured rx_fifo_size %ld (0x%lx)",
+                   getpid (), vcl_cfg->rx_fifo_size, vcl_cfg->rx_fifo_size);
            }
          else if (unformat (line_input, "tx-fifo-size 0x%lx",
                             &vcl_cfg->tx_fifo_size))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured tx_fifo_size 0x%lx (%ld)",
-                             getpid (), vcl_cfg->tx_fifo_size,
-                             vcl_cfg->tx_fifo_size);
+             VDBG (0, "VCL<%d>: configured tx_fifo_size 0x%lx (%ld)",
+                   getpid (), vcl_cfg->tx_fifo_size, vcl_cfg->tx_fifo_size);
            }
          else if (unformat (line_input, "tx-fifo-size %ld",
                             &vcl_cfg->tx_fifo_size))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured tx_fifo_size %ld (0x%lx)",
-                             getpid (), vcl_cfg->tx_fifo_size,
-                             vcl_cfg->tx_fifo_size);
+             VDBG (0, "VCL<%d>: configured tx_fifo_size %ld (0x%lx)",
+                   getpid (), vcl_cfg->tx_fifo_size, vcl_cfg->tx_fifo_size);
            }
          else if (unformat (line_input, "event-queue-size 0x%lx",
                             &vcl_cfg->event_queue_size))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured event_queue_size "
-                             "0x%lx (%ld)",
-                             getpid (), vcl_cfg->event_queue_size,
-                             vcl_cfg->event_queue_size);
+             VDBG (0, "VCL<%d>: configured event_queue_size 0x%lx (%ld)",
+                   getpid (), vcl_cfg->event_queue_size,
+                   vcl_cfg->event_queue_size);
            }
          else if (unformat (line_input, "event-queue-size %ld",
                             &vcl_cfg->event_queue_size))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured event_queue_size "
-                             "%ld (0x%lx)",
-                             getpid (), vcl_cfg->event_queue_size,
-                             vcl_cfg->event_queue_size);
+             VDBG (0, "VCL<%d>: configured event_queue_size %ld (0x%lx)",
+                   getpid (), vcl_cfg->event_queue_size,
+                   vcl_cfg->event_queue_size);
            }
          else if (unformat (line_input, "listen-queue-size 0x%lx",
                             &vcl_cfg->listen_queue_size))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured listen_queue_size "
-                             "0x%lx (%ld)",
-                             getpid (), vcl_cfg->listen_queue_size,
-                             vcl_cfg->listen_queue_size);
+             VDBG (0, "VCL<%d>: configured listen_queue_size 0x%lx (%ld)",
+                   getpid (), vcl_cfg->listen_queue_size,
+                   vcl_cfg->listen_queue_size);
            }
          else if (unformat (line_input, "listen-queue-size %ld",
                             &vcl_cfg->listen_queue_size))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured listen_queue_size "
-                             "%ld (0x%lx)",
-                             getpid (), vcl_cfg->listen_queue_size,
-                             vcl_cfg->listen_queue_size);
+             VDBG (0, "VCL<%d>: configured listen_queue_size %ld (0x%lx)",
+                   getpid (), vcl_cfg->listen_queue_size,
+                   vcl_cfg->listen_queue_size);
            }
          else if (unformat (line_input, "app-timeout %f",
                             &vcl_cfg->app_timeout))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured app_timeout %f",
-                             getpid (), vcl_cfg->app_timeout);
+             VDBG (0, "VCL<%d>: configured app_timeout %f",
+                   getpid (), vcl_cfg->app_timeout);
            }
          else if (unformat (line_input, "session-timeout %f",
                             &vcl_cfg->session_timeout))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured session_timeout %f",
-                             getpid (), vcl_cfg->session_timeout);
+             VDBG (0, "VCL<%d>: configured session_timeout %f",
+                   getpid (), vcl_cfg->session_timeout);
            }
          else if (unformat (line_input, "accept-timeout %f",
                             &vcl_cfg->accept_timeout))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured accept_timeout %f",
-                             getpid (), vcl_cfg->accept_timeout);
+             VDBG (0, "VCL<%d>: configured accept_timeout %f",
+                   getpid (), vcl_cfg->accept_timeout);
            }
          else if (unformat (line_input, "app-proxy-transport-tcp"))
            {
              vcl_cfg->app_proxy_transport_tcp = 1;
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured "
-                             "app_proxy_transport_tcp (%d)",
-                             getpid (), vcl_cfg->app_proxy_transport_tcp);
+             VDBG (0, "VCL<%d>: configured app_proxy_transport_tcp (%d)",
+                   getpid (), vcl_cfg->app_proxy_transport_tcp);
            }
          else if (unformat (line_input, "app-proxy-transport-udp"))
            {
              vcl_cfg->app_proxy_transport_udp = 1;
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured "
-                             "app_proxy_transport_udp (%d)",
-                             getpid (), vcl_cfg->app_proxy_transport_udp);
+             VDBG (0, "VCL<%d>: configured app_proxy_transport_udp (%d)",
+                   getpid (), vcl_cfg->app_proxy_transport_udp);
            }
          else if (unformat (line_input, "app-scope-local"))
            {
              vcl_cfg->app_scope_local = 1;
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured app_scope_local (%d)",
-                             getpid (), vcl_cfg->app_scope_local);
+             VDBG (0, "VCL<%d>: configured app_scope_local (%d)",
+                   getpid (), vcl_cfg->app_scope_local);
            }
          else if (unformat (line_input, "app-scope-global"))
            {
              vcl_cfg->app_scope_global = 1;
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured app_scope_global (%d)",
-                             getpid (), vcl_cfg->app_scope_global);
+             VDBG (0, "VCL<%d>: configured app_scope_global (%d)",
+                   getpid (), vcl_cfg->app_scope_global);
            }
          else if (unformat (line_input, "namespace-secret %lu",
                             &vcl_cfg->namespace_secret))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning
-                 ("VCL<%d>: configured namespace_secret %lu (0x%lx)",
-                  getpid (), vcl_cfg->namespace_secret,
-                  vcl_cfg->namespace_secret);
+             VDBG (0, "VCL<%d>: configured namespace_secret %lu (0x%lx)",
+                   getpid (), vcl_cfg->namespace_secret,
+                   vcl_cfg->namespace_secret);
            }
          else if (unformat (line_input, "namespace-id %v",
                             &vcl_cfg->namespace_id))
@@ -2026,22 +1779,19 @@ vppcom_cfg_read (char *conf_fname)
              if (nsid_vec_len > max_nsid_vec_len)
                {
                  _vec_len (vcl_cfg->namespace_id) = max_nsid_vec_len;
-                 if (VPPCOM_DEBUG > 0)
-                   clib_warning ("VCL<%d>: configured namespace_id is "
-                                 "too long, truncated to %d characters!",
-                                 getpid (), max_nsid_vec_len);
+                 VDBG (0, "VCL<%d>: configured namespace_id is too long,"
+                       " truncated to %d characters!",
+                       getpid (), max_nsid_vec_len);
                }
 
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured namespace_id %v",
-                             getpid (), vcl_cfg->namespace_id);
+             VDBG (0, "VCL<%d>: configured namespace_id %v",
+                   getpid (), vcl_cfg->namespace_id);
            }
          else if (unformat (line_input, "}"))
            {
              vc_cfg_input = 0;
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: completed parsing vppcom config!",
-                             getpid ());
+             VDBG (0, "VCL<%d>: completed parsing vppcom config!",
+                   getpid ());
              goto input_done;
            }
          else
@@ -2093,9 +1843,8 @@ vppcom_app_create (char *app_name)
          else
            {
              vcm->debug = tmp;
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured VCL debug level (%u) from "
-                             VPPCOM_ENV_DEBUG "!", getpid (), vcm->debug);
+             VDBG (0, "VCL<%d>: configured VCL debug level (%u) from "
+                   VPPCOM_ENV_DEBUG "!", getpid (), vcm->debug);
            }
        }
       conf_fname = getenv (VPPCOM_ENV_CONF);
@@ -2118,10 +1867,9 @@ vppcom_app_create (char *app_name)
                                              env_var_str, 0);
          vl_set_memory_root_path ((char *) env_var_str);
 
-         if (VPPCOM_DEBUG > 0)
-           clib_warning ("VCL<%d>: configured api prefix (%s) and "
-                         "filename (%s) from " VPPCOM_ENV_API_PREFIX "!",
-                         getpid (), env_var_str, vcl_cfg->vpp_api_filename);
+         VDBG (0, "VCL<%d>: configured api prefix (%s) and filename (%s) "
+               "from " VPPCOM_ENV_API_PREFIX "!",
+               getpid (), env_var_str, vcl_cfg->vpp_api_filename);
        }
       env_var_str = getenv (VPPCOM_ENV_APP_NAMESPACE_ID);
       if (env_var_str)
@@ -2132,10 +1880,9 @@ vppcom_app_create (char *app_name)
          vec_validate (vcm->cfg.namespace_id, ns_id_vec_len - 1);
          clib_memcpy (vcm->cfg.namespace_id, env_var_str, ns_id_vec_len);
 
-         if (VPPCOM_DEBUG > 0)
-           clib_warning ("VCL<%d>: configured namespace_id (%v) from "
-                         VPPCOM_ENV_APP_NAMESPACE_ID
-                         "!", getpid (), vcm->cfg.namespace_id);
+         VDBG (0, "VCL<%d>: configured namespace_id (%v) from "
+               VPPCOM_ENV_APP_NAMESPACE_ID "!", getpid (),
+               vcm->cfg.namespace_id);
        }
       env_var_str = getenv (VPPCOM_ENV_APP_NAMESPACE_SECRET);
       if (env_var_str)
@@ -2149,46 +1896,38 @@ vppcom_app_create (char *app_name)
          else
            {
              vcm->cfg.namespace_secret = tmp;
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: configured namespace secret "
-                             "(%lu) from "
-                             VPPCOM_ENV_APP_NAMESPACE_SECRET
-                             "!", getpid (), vcm->cfg.namespace_secret);
+             VDBG (0, "VCL<%d>: configured namespace secret (%lu) from "
+                   VPPCOM_ENV_APP_NAMESPACE_SECRET "!", getpid (),
+                   vcm->cfg.namespace_secret);
            }
        }
       if (getenv (VPPCOM_ENV_APP_PROXY_TRANSPORT_TCP))
        {
          vcm->cfg.app_proxy_transport_tcp = 1;
-         if (VPPCOM_DEBUG > 0)
-           clib_warning ("VCL<%d>: configured app_proxy_transport_tcp "
-                         "(%u) from "
-                         VPPCOM_ENV_APP_PROXY_TRANSPORT_TCP
-                         "!", getpid (), vcm->cfg.app_proxy_transport_tcp);
+         VDBG (0, "VCL<%d>: configured app_proxy_transport_tcp (%u) from "
+               VPPCOM_ENV_APP_PROXY_TRANSPORT_TCP "!", getpid (),
+               vcm->cfg.app_proxy_transport_tcp);
        }
       if (getenv (VPPCOM_ENV_APP_PROXY_TRANSPORT_UDP))
        {
          vcm->cfg.app_proxy_transport_udp = 1;
-         if (VPPCOM_DEBUG > 0)
-           clib_warning ("VCL<%d>: configured app_proxy_transport_udp "
-                         "(%u) from "
-                         VPPCOM_ENV_APP_PROXY_TRANSPORT_UDP
-                         "!", getpid (), vcm->cfg.app_proxy_transport_udp);
+         VDBG (0, "VCL<%d>: configured app_proxy_transport_udp (%u) from "
+               VPPCOM_ENV_APP_PROXY_TRANSPORT_UDP "!", getpid (),
+               vcm->cfg.app_proxy_transport_udp);
        }
       if (getenv (VPPCOM_ENV_APP_SCOPE_LOCAL))
        {
          vcm->cfg.app_scope_local = 1;
-         if (VPPCOM_DEBUG > 0)
-           clib_warning ("VCL<%d>: configured app_scope_local (%u) from "
-                         VPPCOM_ENV_APP_SCOPE_LOCAL
-                         "!", getpid (), vcm->cfg.app_scope_local);
+         VDBG (0, "VCL<%d>: configured app_scope_local (%u) from "
+               VPPCOM_ENV_APP_SCOPE_LOCAL "!", getpid (),
+               vcm->cfg.app_scope_local);
        }
       if (getenv (VPPCOM_ENV_APP_SCOPE_GLOBAL))
        {
          vcm->cfg.app_scope_global = 1;
-         if (VPPCOM_DEBUG > 0)
-           clib_warning ("VCL<%d>: configured app_scope_global (%u) from "
-                         VPPCOM_ENV_APP_SCOPE_GLOBAL
-                         "!", getpid (), vcm->cfg.app_scope_global);
+         VDBG (0, "VCL<%d>: configured app_scope_global (%u) from "
+               VPPCOM_ENV_APP_SCOPE_GLOBAL "!", getpid (),
+               vcm->cfg.app_scope_global);
        }
 
       vcm->main_cpu = os_get_thread_index ();
@@ -2212,6 +1951,7 @@ vppcom_app_create (char *app_name)
 
       /* API hookup and connect to VPP */
       vppcom_api_hookup ();
+      vcl_elog_init (vcm);
       vcm->app_state = STATE_APP_START;
       rv = vppcom_connect_to_vpp (app_name);
       if (rv)
@@ -2225,8 +1965,7 @@ vppcom_app_create (char *app_name)
 
       rv = vce_start_event_thread (&(vcm->event_thread), 20);
 
-      if (VPPCOM_DEBUG > 0)
-       clib_warning ("VCL<%d>: sending session enable", getpid ());
+      VDBG (0, "VCL<%d>: sending session enable", getpid ());
 
       rv = vppcom_app_session_enable ();
       if (rv)
@@ -2236,8 +1975,7 @@ vppcom_app_create (char *app_name)
          return rv;
        }
 
-      if (VPPCOM_DEBUG > 0)
-       clib_warning ("VCL<%d>: sending app attach", getpid ());
+      VDBG (0, "VCL<%d>: sending app attach", getpid ());
 
       rv = vppcom_app_attach ();
       if (rv)
@@ -2247,10 +1985,8 @@ vppcom_app_create (char *app_name)
          return rv;
        }
 
-      if (VPPCOM_DEBUG > 0)
-       clib_warning ("VCL<%d>: app_name '%s', my_client_index %d (0x%x)",
-                     getpid (), app_name, vcm->my_client_index,
-                     vcm->my_client_index);
+      VDBG (0, "VCL<%d>: app_name '%s', my_client_index %d (0x%x)",
+           getpid (), app_name, vcm->my_client_index, vcm->my_client_index);
     }
 
   return VPPCOM_OK;
@@ -2265,27 +2001,9 @@ vppcom_app_destroy (void)
   if (vcm->my_client_index == ~0)
     return;
 
-  if (VPPCOM_DEBUG > 0)
-    clib_warning ("VCL<%d>: detaching from VPP, my_client_index %d (0x%x)",
-                 getpid (), vcm->my_client_index, vcm->my_client_index);
-
-  if (VPPCOM_DEBUG > 0)
-    {
-      /* *INDENT-OFF* */
-      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;
-      /* *INDENT-ON* */
-    }
+  VDBG (0, "VCL<%d>: detaching from VPP, my_client_index %d (0x%x)",
+       getpid (), vcm->my_client_index, vcm->my_client_index);
+  vcl_evt (VCL_EVT_DETACH, vcm);
 
   vppcom_app_detach ();
   orig_app_timeout = vcm->cfg.app_timeout;
@@ -2293,17 +2011,10 @@ vppcom_app_destroy (void)
   rv = vppcom_wait_for_app_state_change (STATE_APP_ENABLED);
   vcm->cfg.app_timeout = orig_app_timeout;
   if (PREDICT_FALSE (rv))
-    {
-      if (VPPCOM_DEBUG > 0)
-       clib_warning ("VCL<%d>: application detach timed out! "
-                     "returning %d (%s)",
-                     getpid (), rv, vppcom_retval_str (rv));
-    }
-
-  /* Finished with logging before client gets reset to ~0 */
-  if (VPPCOM_DEBUG > 0)
-    write_elog ();
+    VDBG (0, "VCL<%d>: application detach timed out! returning %d (%s)",
+         getpid (), rv, vppcom_retval_str (rv));
 
+  vcl_elog_stop (vcm);
   vl_client_disconnect_from_vlib ();
   vcm->my_client_index = ~0;
   vcm->app_state = STATE_APP_START;
@@ -2312,19 +2023,16 @@ vppcom_app_destroy (void)
 int
 vppcom_session_create (u8 proto, u8 is_nonblocking)
 {
-  session_t *session;
+  vcl_session_t *session;
   u32 session_index;
-  session_state_t state;
-  elog_track_t session_elog_track;
 
   VCL_SESSION_LOCK ();
   pool_get (vcm->sessions, session);
   memset (session, 0, sizeof (*session));
   session_index = session - vcm->sessions;
 
-  session->proto = proto;
-  session->state = STATE_START;
-  state = session->state;
+  session->session_type = proto;
+  session->session_state = STATE_START;
   session->vpp_handle = ~0;
 
   if (is_nonblocking)
@@ -2332,40 +2040,12 @@ vppcom_session_create (u8 proto, u8 is_nonblocking)
   else
     VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_NONBLOCK);
 
-  if (VPPCOM_DEBUG > 0)
-    {
-      session->elog_track.name =
-       (char *) format (0, "C:%d:S:%d%c", vcm->my_client_index,
-                        session_index, 0);
-      elog_track_register (&vcm->elog_main, &session->elog_track);
-      session_elog_track = session->elog_track;
-    }
+  vcl_evt (VCL_EVT_CREATE, session, session_type, session->session_state,
+          is_nonblocking, session_index);
 
   VCL_SESSION_UNLOCK ();
 
-  if (VPPCOM_DEBUG > 0)
-    clib_warning ("VCL<%d>: sid %u", getpid (), session_index);
-
-  if (VPPCOM_DEBUG > 0)
-    {
-      /* *INDENT-OFF* */
-      ELOG_TYPE_DECLARE (e) =
-      {
-       .format = "session_create:proto:%d state:%d is_nonblocking:%d",
-       .format_args = "i4i4i4",
-      };
-
-      struct
-      {
-       u32 data[3];
-      } *ed;
-
-      ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session_elog_track);
-      ed->data[0] = proto;
-      ed->data[1] = state;
-      ed->data[2] = is_nonblocking;
-      /* *INDENT-ON* */
-    }
+  VDBG (0, "VCL<%d>: sid %u", getpid (), session_index);
 
   return (int) session_index;
 }
@@ -2373,7 +2053,7 @@ vppcom_session_create (u8 proto, u8 is_nonblocking)
 int
 vppcom_session_close (uint32_t session_index)
 {
-  session_t *session = 0;
+  vcl_session_t *session = 0;
   int rv;
   u8 is_vep;
   u8 is_vep_session;
@@ -2382,30 +2062,16 @@ vppcom_session_close (uint32_t session_index)
   u64 vpp_handle;
   uword *p;
   session_state_t state;
-  elog_track_t session_elog_track;
 
   VCL_SESSION_LOCK_AND_GET (session_index, &session);
   is_vep = session->is_vep;
   is_vep_session = session->is_vep_session;
   next_sid = session->vep.next_sid;
   vep_idx = session->vep.vep_idx;
-  state = session->state;
+  state = session->session_state;
   vpp_handle = session->vpp_handle;
   VCL_SESSION_UNLOCK ();
 
-  /*
-   * Why two if(VPPCOM_DEBUG) checks?
-   *
-   * Eventually all clib_warnings need their own way of being
-   * logged and signalled (like severity) where event logging
-   * is a separate debugging tool. It will make the separation
-   * easier. ... parting is such sweet sorrow ...
-   */
-  if (VPPCOM_DEBUG > 0)
-    {
-      session_elog_track = session->elog_track;
-    }
-
   if (VPPCOM_DEBUG > 0)
     {
       if (is_vep)
@@ -2423,11 +2089,11 @@ vppcom_session_close (uint32_t session_index)
       while (next_sid != ~0)
        {
          rv = vppcom_epoll_ctl (session_index, EPOLL_CTL_DEL, next_sid, 0);
-         if ((VPPCOM_DEBUG > 0) && PREDICT_FALSE (rv < 0))
-           clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
-                         "EPOLL_CTL_DEL vep_idx %u failed! rv %d (%s)",
-                         getpid (), vpp_handle, next_sid, vep_idx,
-                         rv, vppcom_retval_str (rv));
+         if (PREDICT_FALSE (rv < 0))
+           VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: EPOLL_CTL_DEL "
+                 "vep_idx %u failed! rv %d (%s)",
+                 getpid (), vpp_handle, next_sid, vep_idx,
+                 rv, vppcom_retval_str (rv));
 
          VCL_SESSION_LOCK_AND_GET (session_index, &session);
          next_sid = session->vep.next_sid;
@@ -2439,24 +2105,21 @@ vppcom_session_close (uint32_t session_index)
       if (is_vep_session)
        {
          rv = vppcom_epoll_ctl (vep_idx, EPOLL_CTL_DEL, session_index, 0);
-         if ((VPPCOM_DEBUG > 0) && (rv < 0))
-           clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
-                         "EPOLL_CTL_DEL vep_idx %u failed! rv %d (%s)",
-                         getpid (), vpp_handle, session_index,
-                         vep_idx, rv, vppcom_retval_str (rv));
+         if (rv < 0)
+           VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: EPOLL_CTL_DEL "
+                 "vep_idx %u failed! rv %d (%s)",
+                 getpid (), vpp_handle, session_index,
+                 vep_idx, rv, vppcom_retval_str (rv));
        }
 
       if (state & STATE_LISTEN)
        {
          rv = vppcom_session_unbind (session_index);
          if (PREDICT_FALSE (rv < 0))
-           {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
-                             "listener unbind failed! rv %d (%s)",
-                             getpid (), vpp_handle, session_index,
-                             rv, vppcom_retval_str (rv));
-           }
+           VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: listener unbind "
+                 "failed! rv %d (%s)",
+                 getpid (), vpp_handle, session_index,
+                 rv, vppcom_retval_str (rv));
        }
 
       else if (state & (CLIENT_STATE_OPEN | SERVER_STATE_OPEN))
@@ -2493,24 +2156,7 @@ vppcom_session_close (uint32_t session_index)
     }
 done:
 
-  if (VPPCOM_DEBUG > 0)
-    {
-      /* *INDENT-OFF* */
-      ELOG_TYPE_DECLARE (e) =
-      {
-       .format = "session_close:rv:%d",
-       .format_args = "i4",
-      };
-
-      struct
-      {
-       u32 data;
-      } *ed;
-
-      ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session_elog_track);
-      ed->data = rv;
-      /* *INDENT-ON* */
-    }
+  vcl_evt (VCL_EVT_CLOSE, session, rv);
 
   return rv;
 }
@@ -2518,7 +2164,7 @@ done:
 int
 vppcom_session_bind (uint32_t session_index, vppcom_endpt_t * ep)
 {
-  session_t *session = 0;
+  vcl_session_t *session = 0;
   int rv;
 
   if (!ep || !ep->ip)
@@ -2535,50 +2181,19 @@ vppcom_session_bind (uint32_t session_index, vppcom_endpt_t * ep)
       goto done;
     }
 
-  session->lcl_addr.is_ip4 = ep->is_ip4;
-  session->lcl_addr.ip46 = to_ip46 (ep->is_ip4 ? IP46_TYPE_IP4 :
-                                   IP46_TYPE_IP6, ep->ip);
-  session->lcl_port = ep->port;
-
-  if (VPPCOM_DEBUG > 0)
-    clib_warning ("VCL<%d>: sid %u: binding to local %s address %U "
-                 "port %u, proto %s", getpid (), session_index,
-                 session->lcl_addr.is_ip4 ? "IPv4" : "IPv6",
-                 format_ip46_address, &session->lcl_addr.ip46,
-                 session->lcl_addr.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
-                 clib_net_to_host_u16 (session->lcl_port),
-                 session->proto ? "UDP" : "TCP");
-
-  if (VPPCOM_DEBUG > 0)
-    {
-      if (session->lcl_addr.is_ip4)
-       {
-         /* *INDENT-OFF* */
-         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, session->elog_track);
-         ed->proto = session->proto;
-         ed->addr[0] = session->lcl_addr.ip46.ip4.as_u8[0];
-         ed->addr[1] = session->lcl_addr.ip46.ip4.as_u8[1];
-         ed->addr[2] = session->lcl_addr.ip46.ip4.as_u8[2];
-         ed->addr[3] = session->lcl_addr.ip46.ip4.as_u8[3];
-         ed->port = clib_net_to_host_u16 (session->lcl_port);
-         /* *INDENT-ON* */
-       }
-    }
+  session->transport.is_ip4 = ep->is_ip4;
+  session->transport.lcl_ip = to_ip46 (ep->is_ip4 ? IP46_TYPE_IP4 :
+                                      IP46_TYPE_IP6, ep->ip);
+  session->transport.lcl_port = ep->port;
 
+  VDBG (0, "VCL<%d>: sid %u: binding to local %s address %U port %u, "
+       "proto %s", getpid (), session_index,
+       session->transport.is_ip4 ? "IPv4" : "IPv6",
+       format_ip46_address, &session->transport.lcl_ip,
+       session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
+       clib_net_to_host_u16 (session->transport.lcl_port),
+       session->session_type ? "UDP" : "TCP");
+  vcl_evt (VCL_EVT_BIND, session);
   VCL_SESSION_UNLOCK ();
 done:
   return rv;
@@ -2587,7 +2202,7 @@ done:
 int
 vppcom_session_listen (uint32_t listen_session_index, uint32_t q_len)
 {
-  session_t *listen_session = 0;
+  vcl_session_t *listen_session = 0;
   u64 listen_vpp_handle;
   int rv, retval;
 
@@ -2606,21 +2221,17 @@ vppcom_session_listen (uint32_t listen_session_index, uint32_t q_len)
     }
 
   listen_vpp_handle = listen_session->vpp_handle;
-  if (listen_session->state & STATE_LISTEN)
+  if (listen_session->session_state & STATE_LISTEN)
     {
       VCL_SESSION_UNLOCK ();
-      if (VPPCOM_DEBUG > 0)
-       clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
-                     "already in listen state!",
-                     getpid (), listen_vpp_handle, listen_session_index);
+      VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: already in listen state!",
+           getpid (), listen_vpp_handle, listen_session_index);
       rv = VPPCOM_OK;
       goto done;
     }
 
-  if (VPPCOM_DEBUG > 0)
-    clib_warning ("VCL<%d>: vpp handle 0x%llx, "
-                 "sid %u: sending VPP bind+listen request...",
-                 getpid (), listen_vpp_handle, listen_session_index);
+  VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: sending VPP bind+listen "
+       "request...", getpid (), listen_vpp_handle, listen_session_index);
 
   vppcom_send_bind_sock (listen_session, listen_session_index);
   VCL_SESSION_UNLOCK ();
@@ -2631,11 +2242,9 @@ vppcom_session_listen (uint32_t listen_session_index, uint32_t q_len)
   VCL_SESSION_LOCK_AND_GET (listen_session_index, &listen_session);
   if (PREDICT_FALSE (retval))
     {
-      if (VPPCOM_DEBUG > 0)
-       clib_warning
-         ("VCL<%d>: vpp handle 0x%llx, sid %u: bind+listen failed! "
-          "returning %d (%s)", getpid (), listen_session->vpp_handle,
-          listen_session_index, retval, vppcom_retval_str (retval));
+      VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: bind+listen failed! "
+           "returning %d (%s)", getpid (), listen_session->vpp_handle,
+           listen_session_index, retval, vppcom_retval_str (retval));
       VCL_SESSION_UNLOCK ();
       rv = retval;
       goto done;
@@ -2652,7 +2261,7 @@ done:
 }
 
 int
-validate_args_session_accept_ (session_t * listen_session)
+validate_args_session_accept_ (vcl_session_t * listen_session)
 {
   u32 listen_session_index = listen_session - vcm->sessions;
 
@@ -2664,13 +2273,13 @@ validate_args_session_accept_ (session_t * listen_session)
       return VPPCOM_EBADFD;
     }
 
-  if (listen_session->state != STATE_LISTEN)
+  if (listen_session->session_state != STATE_LISTEN)
     {
       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
                    "not in listen state! state 0x%x (%s)", getpid (),
                    listen_session->vpp_handle, listen_session_index,
-                   listen_session->state,
-                   vppcom_session_state_str (listen_session->state));
+                   listen_session->session_state,
+                   vppcom_session_state_str (listen_session->session_state));
       return VPPCOM_EBADFD;
     }
   return VPPCOM_OK;
@@ -2680,8 +2289,8 @@ int
 vppcom_session_accept (uint32_t listen_session_index, vppcom_endpt_t * ep,
                       uint32_t flags)
 {
-  session_t *listen_session = 0;
-  session_t *client_session = 0;
+  vcl_session_t *listen_session = 0;
+  vcl_session_t *client_session = 0;
   u32 client_session_index = ~0;
   int rv;
   u64 listen_vpp_handle;
@@ -2775,23 +2384,22 @@ vppcom_session_accept (uint32_t listen_session_index, vppcom_endpt_t * ep,
   else
     VCL_SESS_ATTR_CLR (client_session->attr, VCL_SESS_ATTR_NONBLOCK);
 
-  if (VPPCOM_DEBUG > 0)
-    clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: Got a client request! "
-                 "vpp handle 0x%llx, sid %u, flags %d, is_nonblocking %u",
-                 getpid (), listen_vpp_handle, listen_session_index,
-                 client_session->vpp_handle, client_session_index,
-                 flags, VCL_SESS_ATTR_TEST (client_session->attr,
-                                            VCL_SESS_ATTR_NONBLOCK));
+  VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: Got a client request! "
+       "vpp handle 0x%llx, sid %u, flags %d, is_nonblocking %u",
+       getpid (), listen_vpp_handle, listen_session_index,
+       client_session->vpp_handle, client_session_index,
+       flags, VCL_SESS_ATTR_TEST (client_session->attr,
+                                  VCL_SESS_ATTR_NONBLOCK));
 
   if (ep)
     {
-      ep->is_ip4 = client_session->peer_addr.is_ip4;
-      ep->port = client_session->peer_port;
-      if (client_session->peer_addr.is_ip4)
-       clib_memcpy (ep->ip, &client_session->peer_addr.ip46.ip4,
+      ep->is_ip4 = client_session->transport.is_ip4;
+      ep->port = client_session->transport.rmt_port;
+      if (client_session->transport.is_ip4)
+       clib_memcpy (ep->ip, &client_session->transport.rmt_ip.ip4,
                     sizeof (ip4_address_t));
       else
-       clib_memcpy (ep->ip, &client_session->peer_addr.ip46.ip6,
+       clib_memcpy (ep->ip, &client_session->transport.rmt_ip.ip6,
                     sizeof (ip6_address_t));
     }
 
@@ -2799,76 +2407,24 @@ vppcom_session_accept (uint32_t listen_session_index, vppcom_endpt_t * ep,
                                    client_session->client_context,
                                    0 /* retval OK */ );
 
-  if (VPPCOM_DEBUG > 0)
-    clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: accepted vpp handle "
-                 "0x%llx, sid %u connection from peer %s address %U port %u "
-                 "to local %s address %U port %u",
-                 getpid (), listen_vpp_handle,
-                 listen_session_index, client_session->vpp_handle,
-                 client_session_index,
-                 client_session->peer_addr.is_ip4 ? "IPv4" : "IPv6",
-                 format_ip46_address, &client_session->peer_addr.ip46,
-                 client_session->peer_addr.is_ip4 ?
-                 IP46_TYPE_IP4 : IP46_TYPE_IP6,
-                 clib_net_to_host_u16 (client_session->peer_port),
-                 client_session->lcl_addr.is_ip4 ? "IPv4" : "IPv6",
-                 format_ip46_address, &client_session->lcl_addr.ip46,
-                 client_session->lcl_addr.is_ip4 ?
-                 IP46_TYPE_IP4 : IP46_TYPE_IP6,
-                 clib_net_to_host_u16 (client_session->lcl_port));
-
-  if (VPPCOM_DEBUG > 0)
-    {
-      client_session->elog_track.name =
-       (char *) format (0, "C:%d:S:%d%c", vcm->my_client_index,
-                        client_session_index, 0);
-      elog_track_register (&vcm->elog_main, &client_session->elog_track);
-
-      // Two elog entries due to 20-byte per entry constraint.
-      /* *INDENT-OFF* */
-      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, client_session->elog_track);
-      ed->handle[0] = listen_vpp_handle;
-      ed->handle[1] = client_session->vpp_handle;
-      /* *INDENT-ON* */
-
-      if (client_session->lcl_addr.is_ip4)
-       {
-          /* *INDENT-OFF* */
-         ELOG_TYPE_DECLARE (e2) =
-         {
-           .format = "accept: S:%d %d.%d.%d.%d:%d ",
-           .format_args = "i4i1i1i1i1i2",
-         };
-
-         CLIB_PACKED (struct {
-           u32 session;
-           u8 addr[4];
-           u16 port;
-         }) *ed2;
-
-         ed2 =
-           ELOG_TRACK_DATA (&vcm->elog_main, e2, client_session->elog_track);
-         ed2->session = client_session_index;
-         ed2->addr[0] = client_session->lcl_addr.ip46.ip4.as_u8[0];
-         ed2->addr[1] = client_session->lcl_addr.ip46.ip4.as_u8[1];
-         ed2->addr[2] = client_session->lcl_addr.ip46.ip4.as_u8[2];
-         ed2->addr[3] = client_session->lcl_addr.ip46.ip4.as_u8[3];
-         ed2->port = clib_net_to_host_u16 (client_session->lcl_port);
-         /* *INDENT-ON* */
-       }
-    }
-
+  VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: accepted vpp handle 0x%llx,"
+       " sid %u connection from peer %s address %U port %u to local %s address"
+       " %U port %u",
+       getpid (), listen_vpp_handle,
+       listen_session_index, client_session->vpp_handle,
+       client_session_index,
+       client_session->transport.is_ip4 ? "IPv4" : "IPv6",
+       format_ip46_address, &client_session->transport.rmt_ip,
+       client_session->transport.is_ip4 ?
+       IP46_TYPE_IP4 : IP46_TYPE_IP6,
+       clib_net_to_host_u16 (client_session->transport.rmt_port),
+       client_session->transport.is_ip4 ? "IPv4" : "IPv6",
+       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, listen_session,
+          client_session_index);
   VCL_SESSION_UNLOCK ();
 
   rv = (int) client_session_index;
@@ -2894,7 +2450,7 @@ done:
 int
 vppcom_session_connect (uint32_t session_index, vppcom_endpt_t * server_ep)
 {
-  session_t *session = 0;
+  vcl_session_t *session = 0;
   u64 vpp_handle = 0;
   int rv, retval = VPPCOM_OK;
 
@@ -2909,43 +2465,41 @@ vppcom_session_connect (uint32_t session_index, vppcom_endpt_t * server_ep)
       goto done;
     }
 
-  if (PREDICT_FALSE (session->state & CLIENT_STATE_OPEN))
+  if (PREDICT_FALSE (session->session_state & CLIENT_STATE_OPEN))
     {
-      if (VPPCOM_DEBUG > 0)
-       clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: session already "
-                     "connected to %s %U port %d proto %s, state 0x%x (%s)",
-                     getpid (), session->vpp_handle, session_index,
-                     session->peer_addr.is_ip4 ? "IPv4" : "IPv6",
-                     format_ip46_address,
-                     &session->peer_addr.ip46, session->peer_addr.is_ip4 ?
-                     IP46_TYPE_IP4 : IP46_TYPE_IP6,
-                     clib_net_to_host_u16 (session->peer_port),
-                     session->proto ? "UDP" : "TCP", session->state,
-                     vppcom_session_state_str (session->state));
+      VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: session already "
+           "connected to %s %U port %d proto %s, state 0x%x (%s)",
+           getpid (), session->vpp_handle, session_index,
+           session->transport.is_ip4 ? "IPv4" : "IPv6",
+           format_ip46_address,
+           &session->transport.rmt_ip, session->transport.is_ip4 ?
+           IP46_TYPE_IP4 : IP46_TYPE_IP6,
+           clib_net_to_host_u16 (session->transport.rmt_port),
+           session->session_type ? "UDP" : "TCP", session->session_state,
+           vppcom_session_state_str (session->session_state));
 
       VCL_SESSION_UNLOCK ();
       goto done;
     }
 
-  session->peer_addr.is_ip4 = server_ep->is_ip4;
-  if (session->peer_addr.is_ip4)
-    clib_memcpy (&session->peer_addr.ip46.ip4, server_ep->ip,
+  session->transport.is_ip4 = server_ep->is_ip4;
+  if (session->transport.is_ip4)
+    clib_memcpy (&session->transport.rmt_ip.ip4, server_ep->ip,
                 sizeof (ip4_address_t));
   else
-    clib_memcpy (&session->peer_addr.ip46.ip6, server_ep->ip,
+    clib_memcpy (&session->transport.rmt_ip.ip6, server_ep->ip,
                 sizeof (ip6_address_t));
-  session->peer_port = server_ep->port;
-
-  if (VPPCOM_DEBUG > 0)
-    clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: connecting to server "
-                 "%s %U port %d proto %s",
-                 getpid (), session->vpp_handle, session_index,
-                 session->peer_addr.is_ip4 ? "IPv4" : "IPv6",
-                 format_ip46_address,
-                 &session->peer_addr.ip46, session->peer_addr.is_ip4 ?
-                 IP46_TYPE_IP4 : IP46_TYPE_IP6,
-                 clib_net_to_host_u16 (session->peer_port),
-                 session->proto ? "UDP" : "TCP");
+  session->transport.rmt_port = server_ep->port;
+
+  VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: connecting to server %s %U "
+       "port %d proto %s",
+       getpid (), session->vpp_handle, session_index,
+       session->transport.is_ip4 ? "IPv4" : "IPv6",
+       format_ip46_address,
+       &session->transport.rmt_ip, session->transport.is_ip4 ?
+       IP46_TYPE_IP4 : IP46_TYPE_IP6,
+       clib_net_to_host_u16 (session->transport.rmt_port),
+       session->session_type ? "UDP" : "TCP");
 
   vppcom_send_connect_sock (session, session_index);
   VCL_SESSION_UNLOCK ();
@@ -2965,19 +2519,18 @@ done:
       if (VPPCOM_DEBUG > 0)
        {
          if (session)
-           clib_warning
-             ("VCL<%d>: vpp handle 0x%llx, sid %u: connect failed! "
-              "returning %d (%s)", getpid (), vpp_handle,
-              session_index, rv, vppcom_retval_str (rv));
+           clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: connect "
+                         "failed! returning %d (%s)", getpid (), vpp_handle,
+                         session_index, rv, vppcom_retval_str (rv));
          else
            clib_warning ("VCL<%d>: no session for sid %u: connect failed! "
                          "returning %d (%s)", getpid (),
                          session_index, rv, vppcom_retval_str (rv));
        }
     }
-  else if (VPPCOM_DEBUG > 0)
-    clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: connected!",
-                 getpid (), vpp_handle, session_index);
+  else
+    VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: connected!",
+         getpid (), vpp_handle, session_index);
 
   return rv;
 }
@@ -2986,7 +2539,7 @@ static inline int
 vppcom_session_read_internal (uint32_t session_index, void *buf, int n,
                              u8 peek)
 {
-  session_t *session = 0;
+  vcl_session_t *session = 0;
   svm_fifo_t *rx_fifo;
   int n_read = 0;
   int rv;
@@ -3002,7 +2555,7 @@ vppcom_session_read_internal (uint32_t session_index, void *buf, int n,
 
   is_nonblocking = VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK);
   rx_fifo = session->rx_fifo;
-  state = session->state;
+  state = session->session_state;
   vpp_handle = session->vpp_handle;
 
   if (PREDICT_FALSE (session->is_vep))
@@ -3019,12 +2572,10 @@ vppcom_session_read_internal (uint32_t session_index, void *buf, int n,
       VCL_SESSION_UNLOCK ();
       rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
 
-      if (VPPCOM_DEBUG > 0)
-       clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: %s session is "
-                     "not open! state 0x%x (%s), returning %d (%s)",
-                     getpid (), vpp_handle, session_index, state,
-                     vppcom_session_state_str (state),
-                     rv, vppcom_retval_str (rv));
+      VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: %s session is not open! "
+           "state 0x%x (%s), returning %d (%s)",
+           getpid (), vpp_handle, session_index, state,
+           vppcom_session_state_str (state), rv, vppcom_retval_str (rv));
       goto done;
     }
 
@@ -3052,19 +2603,16 @@ vppcom_session_read_internal (uint32_t session_index, void *buf, int n,
        {
          rv = VPPCOM_ECONNRESET;
 
-         if (VPPCOM_DEBUG > 1)
-           {
-             clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: Empty fifo "
-                           "with session state 0x%x (%s)!"
-                           "  Setting state to 0x%x (%s), returning %d (%s)",
-                           getpid (), session->vpp_handle, session_index,
-                           state, vppcom_session_state_str (state),
-                           STATE_DISCONNECT,
-                           vppcom_session_state_str (STATE_DISCONNECT), rv,
-                           vppcom_retval_str (rv));
-           }
+         VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: Empty fifo with "
+               "session state 0x%x (%s)! Setting state to 0x%x (%s), "
+               "returning %d (%s)",
+               getpid (), session->vpp_handle, session_index,
+               state, vppcom_session_state_str (state),
+               STATE_DISCONNECT,
+               vppcom_session_state_str (STATE_DISCONNECT), rv,
+               vppcom_retval_str (rv));
 
-         session->state = STATE_DISCONNECT;
+         session->session_state = STATE_DISCONNECT;
        }
       else
        rv = VPPCOM_EAGAIN;
@@ -3102,12 +2650,12 @@ vppcom_session_peek (uint32_t session_index, void *buf, int n)
 }
 
 static inline int
-vppcom_session_read_ready (session_t * session, u32 session_index)
+vppcom_session_read_ready (vcl_session_t * session, u32 session_index)
 {
   int ready = 0;
   u32 poll_et;
   int rv;
-  session_state_t state = session->state;
+  session_state_t state = session->session_state;
   u64 vpp_handle = session->vpp_handle;
 
   /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
@@ -3119,7 +2667,7 @@ vppcom_session_read_ready (session_t * session, u32 session_index)
       goto done;
     }
 
-  if (session->state & STATE_LISTEN)
+  if (session->session_state & STATE_LISTEN)
     {
       VCL_ACCEPT_FIFO_LOCK ();
       ready = clib_fifo_elts (vcm->client_session_index_fifo);
@@ -3132,12 +2680,11 @@ vppcom_session_read_ready (session_t * session, u32 session_index)
          rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET :
                VPPCOM_ENOTCONN);
 
-         if (VPPCOM_DEBUG > 1)
-           clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: session is "
-                         "not open! state 0x%x (%s), returning %d (%s)",
-                         getpid (), vpp_handle, session_index,
-                         state, vppcom_session_state_str (state),
-                         rv, vppcom_retval_str (rv));
+         VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: session is not open!"
+               " state 0x%x (%s), returning %d (%s)",
+               getpid (), vpp_handle, session_index,
+               state, vppcom_session_state_str (state),
+               rv, vppcom_retval_str (rv));
          goto done;
        }
 
@@ -3155,19 +2702,15 @@ vppcom_session_read_ready (session_t * session, u32 session_index)
        {
          rv = VPPCOM_ECONNRESET;
 
-         if (VPPCOM_DEBUG > 1)
-           {
-             clib_warning ("VCL<%d>: vpp handle 0x%llx, "
-                           "sid %u: Empty fifo with"
-                           " session state 0x%x (%s)! Setting state to "
-                           "0x%x (%s), returning %d (%s)",
-                           getpid (), session_index, vpp_handle,
-                           state, vppcom_session_state_str (state),
-                           STATE_DISCONNECT,
-                           vppcom_session_state_str (STATE_DISCONNECT), rv,
-                           vppcom_retval_str (rv));
-           }
-         session->state = STATE_DISCONNECT;
+         VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: Empty fifo with "
+               "session state 0x%x (%s)! Setting state to 0x%x (%s), "
+               "returning %d (%s)",
+               getpid (), session_index, vpp_handle,
+               state, vppcom_session_state_str (state),
+               STATE_DISCONNECT,
+               vppcom_session_state_str (STATE_DISCONNECT), rv,
+               vppcom_retval_str (rv));
+         session->session_state = STATE_DISCONNECT;
          goto done;
        }
     }
@@ -3191,7 +2734,7 @@ done:
 int
 vppcom_session_write (uint32_t session_index, void *buf, size_t n)
 {
-  session_t *session = 0;
+  vcl_session_t *session = 0;
   svm_fifo_t *tx_fifo = 0;
   svm_queue_t *q;
   session_fifo_event_t evt;
@@ -3207,7 +2750,7 @@ vppcom_session_write (uint32_t session_index, void *buf, size_t n)
   tx_fifo = session->tx_fifo;
   is_nonblocking = VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK);
   vpp_handle = session->vpp_handle;
-  state = session->state;
+  state = session->session_state;
 
   if (PREDICT_FALSE (session->is_vep))
     {
@@ -3220,18 +2763,17 @@ vppcom_session_write (uint32_t session_index, void *buf, size_t n)
       goto done;
     }
 
-  if (!(session->state & (SERVER_STATE_OPEN | CLIENT_STATE_OPEN)))
+  if (!(session->session_state & (SERVER_STATE_OPEN | CLIENT_STATE_OPEN)))
     {
       rv =
-       ((session->state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET :
+       ((session->session_state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET :
         VPPCOM_ENOTCONN);
 
       VCL_SESSION_UNLOCK ();
-      if (VPPCOM_DEBUG > 1)
-       clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
-                     "session is not open! state 0x%x (%s)",
-                     getpid (), vpp_handle, session_index,
-                     state, vppcom_session_state_str (state));
+      VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: session is not open! "
+           "state 0x%x (%s)",
+           getpid (), vpp_handle, session_index,
+           state, vppcom_session_state_str (state));
       goto done;
     }
 
@@ -3256,15 +2798,13 @@ vppcom_session_write (uint32_t session_index, void *buf, size_t n)
       evt.event_type = FIFO_EVENT_APP_TX;
 
       VCL_SESSION_LOCK_AND_GET (session_index, &session);
-      q = session->vpp_event_queue;
+      q = session->vpp_evt_q;
       ASSERT (q);
       svm_queue_add (q, (u8 *) & evt, 0 /* do wait for mutex */ );
       VCL_SESSION_UNLOCK ();
-      if (VPPCOM_DEBUG > 1)
-       clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
-                     "added FIFO_EVENT_APP_TX to "
-                     "vpp_event_q %p, n_write %d", getpid (),
-                     vpp_handle, session_index, q, n_write);
+      VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: added FIFO_EVENT_APP_TX "
+           "to vpp_event_q %p, n_write %d", getpid (),
+           vpp_handle, session_index, q, n_write);
     }
 
   if (n_write <= 0)
@@ -3276,24 +2816,21 @@ vppcom_session_write (uint32_t session_index, void *buf, size_t n)
       if (poll_et)
        session->vep.et_mask |= EPOLLOUT;
 
-      if (session->state & STATE_CLOSE_ON_EMPTY)
+      if (session->session_state & STATE_CLOSE_ON_EMPTY)
        {
          rv = VPPCOM_ECONNRESET;
 
-         if (VPPCOM_DEBUG > 1)
-           {
-             clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
-                           "Empty fifo with session state 0x%x (%s)!"
-                           "  Setting state to 0x%x (%s), returning %d (%s)",
-                           getpid (), session->vpp_handle, session_index,
-                           session->state,
-                           vppcom_session_state_str (session->state),
-                           STATE_DISCONNECT,
-                           vppcom_session_state_str (STATE_DISCONNECT), rv,
-                           vppcom_retval_str (rv));
-           }
-
-         session->state = STATE_DISCONNECT;
+         VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: Empty fifo with "
+               "session state 0x%x (%s)! Setting state to 0x%x (%s), "
+               "returning %d (%s)",
+               getpid (), session->vpp_handle, session_index,
+               session->session_state,
+               vppcom_session_state_str (session->session_state),
+               STATE_DISCONNECT,
+               vppcom_session_state_str (STATE_DISCONNECT), rv,
+               vppcom_retval_str (rv));
+
+         session->session_state = STATE_DISCONNECT;
        }
       else
        rv = VPPCOM_EAGAIN;
@@ -3319,7 +2856,7 @@ done:
 }
 
 static inline int
-vppcom_session_write_ready (session_t * session, u32 session_index)
+vppcom_session_write_ready (vcl_session_t * session, u32 session_index)
 {
   int ready;
   u32 poll_et;
@@ -3337,7 +2874,7 @@ vppcom_session_write_ready (session_t * session, u32 session_index)
       goto done;
     }
 
-  if (PREDICT_FALSE (session->state & STATE_LISTEN))
+  if (PREDICT_FALSE (session->session_state & STATE_LISTEN))
     {
       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
                    "cannot write to a listen session!",
@@ -3346,9 +2883,9 @@ vppcom_session_write_ready (session_t * session, u32 session_index)
       goto done;
     }
 
-  if (!(session->state & (SERVER_STATE_OPEN | CLIENT_STATE_OPEN)))
+  if (!(session->session_state & (SERVER_STATE_OPEN | CLIENT_STATE_OPEN)))
     {
-      session_state_t state = session->state;
+      session_state_t state = session->session_state;
 
       rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
 
@@ -3363,11 +2900,9 @@ vppcom_session_write_ready (session_t * session, u32 session_index)
 
   ready = svm_fifo_max_enqueue (session->tx_fifo);
 
-  if (VPPCOM_DEBUG > 3)
-    clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
-                 "peek %s (%p), ready = %d", getpid (),
-                 session->vpp_handle, session_index,
-                 session->tx_fifo, ready);
+  VDBG (3, "VCL<%d>: vpp handle 0x%llx, sid %u: peek %s (%p), ready = %d",
+       getpid (), session->vpp_handle, session_index, session->tx_fifo,
+       ready);
 
   if (ready == 0)
     {
@@ -3376,24 +2911,20 @@ vppcom_session_write_ready (session_t * session, u32 session_index)
       if (poll_et)
        session->vep.et_mask |= EPOLLOUT;
 
-      if (session->state & STATE_CLOSE_ON_EMPTY)
+      if (session->session_state & STATE_CLOSE_ON_EMPTY)
        {
          rv = VPPCOM_ECONNRESET;
 
-         if (VPPCOM_DEBUG > 1)
-           {
-             clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: "
-                           "Empty fifo with session "
-                           "state 0x%x (%s)! Setting state to 0x%x (%s), "
-                           "returning %d (%s)", getpid (),
-                           session->vpp_handle, session_index,
-                           session->state,
-                           vppcom_session_state_str (session->state),
-                           STATE_DISCONNECT,
-                           vppcom_session_state_str (STATE_DISCONNECT), rv,
-                           vppcom_retval_str (rv));
-           }
-         session->state = STATE_DISCONNECT;
+         VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: Empty fifo with "
+               "session state 0x%x (%s)! Setting state to 0x%x (%s), "
+               "returning %d (%s)", getpid (),
+               session->vpp_handle, session_index,
+               session->session_state,
+               vppcom_session_state_str (session->session_state),
+               STATE_DISCONNECT,
+               vppcom_session_state_str (STATE_DISCONNECT), rv,
+               vppcom_retval_str (rv));
+         session->session_state = STATE_DISCONNECT;
          goto done;
        }
     }
@@ -3408,7 +2939,7 @@ vppcom_select (unsigned long n_bits, unsigned long *read_map,
               double time_to_wait)
 {
   u32 session_index;
-  session_t *session = 0;
+  vcl_session_t *session = 0;
   int rv, bits_set = 0;
   f64 timeout = clib_time_now (&vcm->clib_time) + time_to_wait;
   u32 minbits = clib_max (n_bits, BITS (uword));
@@ -3453,14 +2984,13 @@ vppcom_select (unsigned long n_bits, unsigned long *read_map,
                   if (rv < 0)
                     {
                       VCL_SESSION_UNLOCK();
-                      if (VPPCOM_DEBUG > 1)
-                        clib_warning ("VCL<%d>: session %d specified in "
-                                      "read_map is closed.", getpid (),
+                      VDBG (1, "VCL<%d>: session %d specified in read_map is"
+                         " closed.", getpid (),
                                       session_index);
                       bits_set = VPPCOM_EBADFD;
                       goto select_done;
                     }
-                  if (session->state & STATE_LISTEN)
+                  if (session->session_state & STATE_LISTEN)
                     {
                       vce_event_handler_reg_t *reg = 0;
                       vce_event_key_t evk;
@@ -3510,8 +3040,7 @@ vppcom_select (unsigned long n_bits, unsigned long *read_map,
                   if (rv < 0)
                     {
                       VCL_SESSION_UNLOCK();
-                      if (VPPCOM_DEBUG > 0)
-                        clib_warning ("VCL<%d>: session %d specified in "
+                      VDBG (0, "VCL<%d>: session %d specified in "
                                       "write_map is closed.", getpid (),
                                       session_index);
                       bits_set = VPPCOM_EBADFD;
@@ -3537,9 +3066,8 @@ vppcom_select (unsigned long n_bits, unsigned long *read_map,
                   if (rv < 0)
                     {
                       VCL_SESSION_UNLOCK();
-                      if (VPPCOM_DEBUG > 1)
-                        clib_warning ("VCL<%d>: session %d specified in "
-                                      "except_map is closed.", getpid (),
+                      VDBG (1, "VCL<%d>: session %d specified in except_map "
+                         "is closed.", getpid (),
                                       session_index);
                       bits_set = VPPCOM_EBADFD;
                       goto select_done;
@@ -3566,7 +3094,7 @@ select_done:
 static inline void
 vep_verify_epoll_chain (u32 vep_idx)
 {
-  session_t *session;
+  vcl_session_t *session;
   vppcom_epoll_t *vep;
   int rv;
   u32 sid = vep_idx;
@@ -3649,9 +3177,8 @@ done:
 int
 vppcom_epoll_create (void)
 {
-  session_t *vep_session;
+  vcl_session_t *vep_session;
   u32 vep_idx;
-  elog_track_t vep_elog_track;
 
   VCL_SESSION_LOCK ();
   pool_get (vcm->sessions, vep_session);
@@ -3666,40 +3193,11 @@ vppcom_epoll_create (void)
   vep_session->vpp_handle = ~0;
   vep_session->poll_reg = 0;
 
-  if (VPPCOM_DEBUG > 0)
-    {
-      vep_session->elog_track.name =
-       (char *) format (0, "C:%d:VEP:%d%c", vcm->my_client_index,
-                        vep_idx, 0);
-      elog_track_register (&vcm->elog_main, &vep_session->elog_track);
-      vep_elog_track = vep_session->elog_track;
-    }
-
+  vcl_evt (VCL_EVT_EPOLL_CREATE, vep_session, vep_idx);
   VCL_SESSION_UNLOCK ();
 
-  if (VPPCOM_DEBUG > 0)
-    clib_warning ("VCL<%d>: Created vep_idx %u / sid %u!",
-                 getpid (), vep_idx, vep_idx);
-
-  if (VPPCOM_DEBUG > 0)
-    {
-
-      /* *INDENT-OFF* */
-      ELOG_TYPE_DECLARE (e) =
-      {
-       .format = "created epoll session:%d",
-       .format_args = "i4",
-      };
-
-      struct
-      {
-       u32 data;
-      } *ed;
-
-      ed = ELOG_TRACK_DATA (&vcm->elog_main, e, vep_elog_track);
-      ed->data = vep_idx;
-      /* *INDENT-ON* */
-    }
+  VDBG (0, "VCL<%d>: Created vep_idx %u / sid %u!",
+       getpid (), vep_idx, vep_idx);
 
   return (vep_idx);
 }
@@ -3708,8 +3206,8 @@ int
 vppcom_epoll_ctl (uint32_t vep_idx, int op, uint32_t session_index,
                  struct epoll_event *event)
 {
-  session_t *vep_session;
-  session_t *session;
+  vcl_session_t *vep_session;
+  vcl_session_t *session;
   int rv;
 
   if (vep_idx == session_index)
@@ -3740,9 +3238,8 @@ vppcom_epoll_ctl (uint32_t vep_idx, int op, uint32_t session_index,
   rv = vppcom_session_at_index (session_index, &session);
   if (PREDICT_FALSE (rv))
     {
-      if (VPPCOM_DEBUG > 0)
-       clib_warning ("VCL<%d>: ERROR: Invalid session_index (%u)!",
-                     getpid (), session_index);
+      VDBG (0, "VCL<%d>: ERROR: Invalid session_index (%u)!",
+           getpid (), session_index);
       goto done;
     }
   if (PREDICT_FALSE (session->is_vep))
@@ -3764,7 +3261,7 @@ vppcom_epoll_ctl (uint32_t vep_idx, int op, uint32_t session_index,
        }
       if (vep_session->vep.next_sid != ~0)
        {
-         session_t *next_session;
+         vcl_session_t *next_session;
          rv = vppcom_session_at_index (vep_session->vep.next_sid,
                                        &next_session);
          if (PREDICT_FALSE (rv))
@@ -3787,7 +3284,7 @@ vppcom_epoll_ctl (uint32_t vep_idx, int op, uint32_t session_index,
       vep_session->vep.next_sid = session_index;
 
       /* VCL Event Register handler */
-      if (session->state & STATE_LISTEN)
+      if (session->session_state & STATE_LISTEN)
        {
          /* Register handler for connect_request event on listen_session_index */
          vce_event_key_t evk;
@@ -3798,31 +3295,11 @@ vppcom_epoll_ctl (uint32_t vep_idx, int op, uint32_t session_index,
                                  vce_poll_wait_connect_request_handler_fn,
                                  0 /* No callback args */ );
        }
-      if (VPPCOM_DEBUG > 1)
-       clib_warning ("VCL<%d>: EPOLL_CTL_ADD: vep_idx %u, "
-                     "sid %u, events 0x%x, data 0x%llx!",
-                     getpid (), vep_idx, session_index,
-                     event->events, event->data.u64);
-      if (VPPCOM_DEBUG > 0)
-       {
-          /* *INDENT-OFF* */
-         ELOG_TYPE_DECLARE (e) =
-           {
-             .format = "epoll_ctladd: events:%x data:%x",
-             .format_args = "i4i4i8",
-           };
-         struct
-         {
-           u32 events;
-           u64 event_data;
-         } *ed;
-
-         ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-
-         ed->events = event->events;
-         ed->event_data = event->data.u64;
-         /* *INDENT-ON* */
-       }
+      VDBG (1, "VCL<%d>: EPOLL_CTL_ADD: vep_idx %u, "
+           "sid %u, events 0x%x, data 0x%llx!",
+           getpid (), vep_idx, session_index,
+           event->events, event->data.u64);
+      vcl_evt (VCL_EVT_EPOLL_CTLADD, session, event->events, event->data.u64);
       break;
 
     case EPOLL_CTL_MOD:
@@ -3851,11 +3328,9 @@ vppcom_epoll_ctl (uint32_t vep_idx, int op, uint32_t session_index,
        }
       session->vep.et_mask = VEP_DEFAULT_ET_MASK;
       session->vep.ev = *event;
-      if (VPPCOM_DEBUG > 1)
-       clib_warning
-         ("VCL<%d>: EPOLL_CTL_MOD: vep_idx %u, sid %u, events 0x%x,"
-          " data 0x%llx!", getpid (), vep_idx, session_index, event->events,
-          event->data.u64);
+      VDBG (1, "VCL<%d>: EPOLL_CTL_MOD: vep_idx %u, sid %u, events 0x%x,"
+           " data 0x%llx!", getpid (), vep_idx, session_index, event->events,
+           event->data.u64);
       break;
 
     case EPOLL_CTL_DEL:
@@ -3877,7 +3352,7 @@ vppcom_epoll_ctl (uint32_t vep_idx, int op, uint32_t session_index,
        }
 
       /* VCL Event Un-register handler */
-      if ((session->state & STATE_LISTEN) && vep_session->poll_reg)
+      if ((session->session_state & STATE_LISTEN) && vep_session->poll_reg)
        {
          (void) vce_unregister_handler (&vcm->event_thread,
                                         vep_session->poll_reg);
@@ -3891,7 +3366,7 @@ vppcom_epoll_ctl (uint32_t vep_idx, int op, uint32_t session_index,
        vep_session->vep.next_sid = session->vep.next_sid;
       else
        {
-         session_t *prev_session;
+         vcl_session_t *prev_session;
          rv = vppcom_session_at_index (session->vep.prev_sid, &prev_session);
          if (PREDICT_FALSE (rv))
            {
@@ -3905,7 +3380,7 @@ vppcom_epoll_ctl (uint32_t vep_idx, int op, uint32_t session_index,
        }
       if (session->vep.next_sid != ~0)
        {
-         session_t *next_session;
+         vcl_session_t *next_session;
          rv = vppcom_session_at_index (session->vep.next_sid, &next_session);
          if (PREDICT_FALSE (rv))
            {
@@ -3923,27 +3398,9 @@ vppcom_epoll_ctl (uint32_t vep_idx, int op, uint32_t session_index,
       session->vep.prev_sid = ~0;
       session->vep.vep_idx = ~0;
       session->is_vep_session = 0;
-      if (VPPCOM_DEBUG > 1)
-       clib_warning ("VCL<%d>: EPOLL_CTL_DEL: vep_idx %u, sid %u!",
-                     getpid (), vep_idx, session_index);
-      if (VPPCOM_DEBUG > 0)
-       {
-          /* *INDENT-OFF* */
-         ELOG_TYPE_DECLARE (e) =
-           {
-             .format = "epoll_ctldel: vep:%d",
-             .format_args = "i4",
-           };
-         struct
-         {
-           u32 data;
-         } *ed;
-
-         ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-
-         ed->data = vep_idx;
-         /* *INDENT-ON* */
-       }
+      VDBG (1, "VCL<%d>: EPOLL_CTL_DEL: vep_idx %u, sid %u!",
+           getpid (), vep_idx, session_index);
+      vcl_evt (VCL_EVT_EPOLL_CTLDEL, session, vep_idx);
       break;
 
     default:
@@ -3962,8 +3419,7 @@ int
 vppcom_epoll_wait (uint32_t vep_idx, struct epoll_event *events,
                   int maxevents, double wait_for_time)
 {
-  session_t *vep_session;
-  elog_track_t vep_elog_track;
+  vcl_session_t *vep_session;
   int rv;
   f64 timeout = clib_time_now (&vcm->clib_time) + wait_for_time;
   u32 keep_trying = 1;
@@ -3983,7 +3439,6 @@ vppcom_epoll_wait (uint32_t vep_idx, struct epoll_event *events,
   vep_next_sid = vep_session->vep.next_sid;
   is_vep = vep_session->is_vep;
   wait_cont_idx = vep_session->wait_cont_idx;
-  vep_elog_track = vep_session->elog_track;
   VCL_SESSION_UNLOCK ();
 
   if (PREDICT_FALSE (!is_vep))
@@ -3995,27 +3450,8 @@ vppcom_epoll_wait (uint32_t vep_idx, struct epoll_event *events,
     }
   if (PREDICT_FALSE (vep_next_sid == ~0))
     {
-      if (VPPCOM_DEBUG > 1)
-       clib_warning ("VCL<%d>: WARNING: vep_idx (%u) is empty!",
-                     getpid (), vep_idx);
-      if (VPPCOM_DEBUG > 1)
-       {
-          /* *INDENT-OFF* */
-         ELOG_TYPE_DECLARE (e) =
-           {
-             .format = "WRN: vep_idx:%d empty",
-             .format_args = "i4",
-           };
-         struct
-         {
-           u32 data;
-         } *ed;
-
-         ed = ELOG_TRACK_DATA (&vcm->elog_main, e, vep_elog_track);
-
-         ed->data = vep_idx;
-         /* *INDENT-ON* */
-       }
+      VDBG (1, "VCL<%d>: WARNING: vep_idx (%u) is empty!",
+           getpid (), vep_idx);
       goto done;
     }
 
@@ -4023,8 +3459,7 @@ vppcom_epoll_wait (uint32_t vep_idx, struct epoll_event *events,
     {
       u32 sid;
       u32 next_sid = ~0;
-      session_t *session;
-      elog_track_t session_elog_track;
+      vcl_session_t *session;
 
       for (sid = (wait_cont_idx == ~0) ? vep_next_sid : wait_cont_idx;
           sid != ~0; sid = next_sid)
@@ -4043,64 +3478,19 @@ vppcom_epoll_wait (uint32_t vep_idx, struct epoll_event *events,
          session_vep_idx = session->vep.vep_idx;
          session_ev_data = session->vep.ev.data.u64;
 
-         if (VPPCOM_DEBUG > 0)
-           {
-             session_elog_track = session->elog_track;
-           }
-
          VCL_SESSION_UNLOCK ();
 
          if (PREDICT_FALSE (is_vep))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: ERROR: sid (%u) is a vep!",
-                             getpid (), vep_idx);
-             if (VPPCOM_DEBUG > 0)
-               {
-                  /* *INDENT-OFF* */
-                 ELOG_TYPE_DECLARE (e) =
-                   {
-                     .format = "ERR:vep_idx:%d is vep",
-                     .format_args = "i4",
-                   };
-                 struct
-                 {
-                   u32 data;
-                 } *ed;
-
-                 ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session_elog_track);
-
-                 ed->data = vep_idx;
-                 /* *INDENT-ON* */
-               }
-
+             VDBG (0, "VCL<%d>: ERROR: sid (%u) is a vep!",
+                   getpid (), vep_idx);
              rv = VPPCOM_EINVAL;
              goto done;
            }
          if (PREDICT_FALSE (!is_vep_session))
            {
-             if (VPPCOM_DEBUG > 0)
-               clib_warning ("VCL<%d>: ERROR: session (%u) is not "
-                             "a vep session!", getpid (), sid);
-             if (VPPCOM_DEBUG > 0)
-               {
-                  /* *INDENT-OFF* */
-                 ELOG_TYPE_DECLARE (e) =
-                   {
-                     .format = "ERR:SID:%d not vep",
-                     .format_args = "i4",
-                   };
-                 struct
-                 {
-                   u32 data;
-                 } *ed;
-
-                 ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session_elog_track);
-
-                 ed->data = sid;
-                 /* *INDENT-ON* */
-               }
-
+             VDBG (0, "VCL<%d>: ERROR: session (%u) is not "
+                   "a vep session!", getpid (), sid);
              rv = VPPCOM_EINVAL;
              goto done;
            }
@@ -4218,7 +3608,7 @@ int
 vppcom_session_attr (uint32_t session_index, uint32_t op,
                     void *buffer, uint32_t * buflen)
 {
-  session_t *session;
+  vcl_session_t *session;
   int rv = VPPCOM_OK;
   u32 *flags = buffer;
   vppcom_endpt_t *ep = buffer;
@@ -4231,53 +3621,14 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
     {
     case VPPCOM_ATTR_GET_NREAD:
       rv = vppcom_session_read_ready (session, session_index);
-      if (VPPCOM_DEBUG > 2)
-       clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_NREAD: sid %u, nread = %d",
-                     getpid (), rv);
-      if (VPPCOM_DEBUG > 0)
-       {
-          /* *INDENT-OFF* */
-         ELOG_TYPE_DECLARE (e) =
-           {
-             .format = "VPPCOM_ATTR_GET_NREAD: nread=%d",
-             .format_args = "i4",
-           };
-         struct
-         {
-           u32 data;
-         } *ed;
-
-         ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-
-         ed->data = rv;
-         /* *INDENT-ON* */
-       }
-
+      VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_NREAD: sid %u, nread = %d",
+           getpid (), rv);
       break;
 
     case VPPCOM_ATTR_GET_NWRITE:
       rv = vppcom_session_write_ready (session, session_index);
-      if (VPPCOM_DEBUG > 2)
-       clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_NWRITE: sid %u, nwrite = %d",
-                     getpid (), session_index, rv);
-      if (VPPCOM_DEBUG > 0)
-       {
-          /* *INDENT-OFF* */
-         ELOG_TYPE_DECLARE (e) =
-           {
-             .format = "VPPCOM_ATTR_GET_NWRITE: nwrite=%d",
-             .format_args = "i4",
-           };
-         struct
-         {
-           u32 data;
-         } *ed;
-
-         ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-
-         ed->data = rv;
-         /* *INDENT-ON* */
-       }
+      VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_NWRITE: sid %u, nwrite = %d",
+           getpid (), session_index, rv);
       break;
 
     case VPPCOM_ATTR_GET_FLAGS:
@@ -4286,33 +3637,10 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
          *flags = O_RDWR | (VCL_SESS_ATTR_TEST (session->attr,
                                                 VCL_SESS_ATTR_NONBLOCK));
          *buflen = sizeof (*flags);
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_FLAGS: sid %u, "
-                         "flags = 0x%08x, is_nonblocking = %u", getpid (),
-                         session_index, *flags,
-                         VCL_SESS_ATTR_TEST (session->attr,
-                                             VCL_SESS_ATTR_NONBLOCK));
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_GET_FLAGS: flags=%x is_nonblk=%d",
-                 .format_args = "i4i4",
-               };
-             struct
-             {
-               u32 flags;
-               u32 is_nonblk;
-             } *ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-
-             ed->flags = *flags;
-             ed->is_nonblk = VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK);
-             /* *INDENT-ON* */
-           }
-
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_FLAGS: sid %u, flags = 0x%08x, "
+               "is_nonblocking = %u", getpid (),
+               session_index, *flags,
+               VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK));
        }
       else
        rv = VPPCOM_EINVAL;
@@ -4326,32 +3654,10 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
          else
            VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_NONBLOCK);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_FLAGS: sid %u, "
-                         "flags = 0x%08x, is_nonblocking = %u",
-                         getpid (), session_index, *flags,
-                         VCL_SESS_ATTR_TEST (session->attr,
-                                             VCL_SESS_ATTR_NONBLOCK));
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_SET_FLAGS: flags=%x is_nonblk=%d",
-                 .format_args = "i4i4",
-               };
-             struct
-             {
-               u32 flags;
-               u32 is_nonblk;
-             } *ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-
-             ed->flags = *flags;
-             ed->is_nonblk = VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK);
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_FLAGS: sid %u, flags = 0x%08x,"
+               " is_nonblocking = %u",
+               getpid (), session_index, *flags,
+               VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK));
        }
       else
        rv = VPPCOM_EINVAL;
@@ -4361,64 +3667,21 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
       if (PREDICT_TRUE (buffer && buflen &&
                        (*buflen >= sizeof (*ep)) && ep->ip))
        {
-         ep->is_ip4 = session->peer_addr.is_ip4;
-         ep->port = session->peer_port;
-         if (session->peer_addr.is_ip4)
-           clib_memcpy (ep->ip, &session->peer_addr.ip46.ip4,
+         ep->is_ip4 = session->transport.is_ip4;
+         ep->port = session->transport.rmt_port;
+         if (session->transport.is_ip4)
+           clib_memcpy (ep->ip, &session->transport.rmt_ip.ip4,
                         sizeof (ip4_address_t));
          else
-           clib_memcpy (ep->ip, &session->peer_addr.ip46.ip6,
+           clib_memcpy (ep->ip, &session->transport.rmt_ip.ip6,
                         sizeof (ip6_address_t));
          *buflen = sizeof (*ep);
-         if (VPPCOM_DEBUG > 1)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_PEER_ADDR: sid %u, "
-                         "is_ip4 = %u, addr = %U, port %u", getpid (),
-                         session_index, ep->is_ip4, format_ip46_address,
-                         &session->peer_addr.ip46,
-                         ep->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
-                         clib_net_to_host_u16 (ep->port));
-         if (VPPCOM_DEBUG > 0)
-           {
-             if (ep->is_ip4)
-               {
-                    /* *INDENT-OFF* */
-                 ELOG_TYPE_DECLARE (e) =
-                   {
-                     .format = "VPPCOM_ATTR_GET_PEER_ADDR: addr:%d.%d.%d.%d:%d",
-                     .format_args = "i1i1i1i1i2",
-                   };
-                 CLIB_PACKED (struct {
-                   u8 addr[4]; //4
-                   u16 port;   //2
-                 }) * ed;
-
-                 ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-
-                 ed->addr[0] = session->peer_addr.ip46.ip4.as_u8[0];
-                 ed->addr[1] = session->peer_addr.ip46.ip4.as_u8[1];
-                 ed->addr[2] = session->peer_addr.ip46.ip4.as_u8[2];
-                 ed->addr[3] = session->peer_addr.ip46.ip4.as_u8[3];
-                 ed->port = clib_net_to_host_u16 (session->peer_port);
-                 /* *INDENT-ON* */
-               }
-             else
-               {
-                    /* *INDENT-OFF* */
-                 ELOG_TYPE_DECLARE (e) =
-                   {
-                     .format = "VPPCOM_ATTR_GET_PEER_ADDR: addr:IP6:%d",
-                     .format_args = "i2",
-                   };
-                 CLIB_PACKED (struct {
-                   u16 port;   //2
-                 }) * ed;
-
-                 ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-
-                 ed->port = clib_net_to_host_u16 (session->peer_port);
-                 /* *INDENT-ON* */
-               }
-           }
+         VDBG (1, "VCL<%d>: VPPCOM_ATTR_GET_PEER_ADDR: sid %u, is_ip4 = %u, "
+               "addr = %U, port %u", getpid (),
+               session_index, ep->is_ip4, format_ip46_address,
+               &session->transport.rmt_ip,
+               ep->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
+               clib_net_to_host_u16 (ep->port));
        }
       else
        rv = VPPCOM_EINVAL;
@@ -4428,64 +3691,21 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
       if (PREDICT_TRUE (buffer && buflen &&
                        (*buflen >= sizeof (*ep)) && ep->ip))
        {
-         ep->is_ip4 = session->lcl_addr.is_ip4;
-         ep->port = session->lcl_port;
-         if (session->lcl_addr.is_ip4)
-           clib_memcpy (ep->ip, &session->lcl_addr.ip46.ip4,
+         ep->is_ip4 = session->transport.is_ip4;
+         ep->port = session->transport.lcl_port;
+         if (session->transport.is_ip4)
+           clib_memcpy (ep->ip, &session->transport.lcl_ip.ip4,
                         sizeof (ip4_address_t));
          else
-           clib_memcpy (ep->ip, &session->lcl_addr.ip46.ip6,
+           clib_memcpy (ep->ip, &session->transport.lcl_ip.ip6,
                         sizeof (ip6_address_t));
          *buflen = sizeof (*ep);
-         if (VPPCOM_DEBUG > 1)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_LCL_ADDR: sid %u, "
-                         "is_ip4 = %u, addr = %U port %d", getpid (),
-                         session_index, ep->is_ip4, format_ip46_address,
-                         &session->lcl_addr.ip46,
-                         ep->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
-                         clib_net_to_host_u16 (ep->port));
-         if (VPPCOM_DEBUG > 0)
-           {
-             if (ep->is_ip4)
-               {
-                    /* *INDENT-OFF* */
-                 ELOG_TYPE_DECLARE (e) =
-                   {
-                     .format = "VPPCOM_ATTR_GET_LCL_ADDR: addr:%d.%d.%d.%d:%d",
-                     .format_args = "i1i1i1i1i2",
-                   };
-                 CLIB_PACKED (struct {
-                   u8 addr[4]; //4
-                   u16 port;   //2
-                 }) * ed;
-
-                 ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-
-                 ed->addr[0] = session->lcl_addr.ip46.ip4.as_u8[0];
-                 ed->addr[1] = session->lcl_addr.ip46.ip4.as_u8[1];
-                 ed->addr[2] = session->lcl_addr.ip46.ip4.as_u8[2];
-                 ed->addr[3] = session->lcl_addr.ip46.ip4.as_u8[3];
-                 ed->port = clib_net_to_host_u16 (session->peer_port);
-                 /* *INDENT-ON* */
-               }
-             else
-               {
-                    /* *INDENT-OFF* */
-                 ELOG_TYPE_DECLARE (e) =
-                   {
-                     .format = "VPPCOM_ATTR_GET_LCL_ADDR: addr:IP6:%d",
-                     .format_args = "i2",
-                   };
-                 CLIB_PACKED (struct {
-                   u16 port;   //2
-                 }) * ed;
-
-                 ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-
-                 ed->port = clib_net_to_host_u16 (session->peer_port);
-                 /* *INDENT-ON* */
-               }
-           }
+         VDBG (1, "VCL<%d>: VPPCOM_ATTR_GET_LCL_ADDR: sid %u, is_ip4 = %u,"
+               " addr = %U port %d", getpid (),
+               session_index, ep->is_ip4, format_ip46_address,
+               &session->transport.lcl_ip,
+               ep->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
+               clib_net_to_host_u16 (ep->port));
        }
       else
        rv = VPPCOM_EINVAL;
@@ -4493,26 +3713,8 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
 
     case VPPCOM_ATTR_GET_LIBC_EPFD:
       rv = session->libc_epfd;
-      if (VPPCOM_DEBUG > 2)
-       clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_LIBC_EPFD: libc_epfd %d",
-                     getpid (), rv);
-      if (VPPCOM_DEBUG > 0)
-       {
-          /* *INDENT-OFF* */
-         ELOG_TYPE_DECLARE (e) =
-           {
-             .format = "VPPCOM_ATTR_GET_LIBC_EPFD: libc_epfd=%d",
-             .format_args = "i4",
-           };
-         CLIB_PACKED (struct {
-           i32 data;
-         }) *ed;
-
-         ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-         ed->data = session->libc_epfd;
-         /* *INDENT-ON* */
-       }
-
+      VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_LIBC_EPFD: libc_epfd %d",
+           getpid (), rv);
       break;
 
     case VPPCOM_ATTR_SET_LIBC_EPFD:
@@ -4522,32 +3724,8 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
          session->libc_epfd = *(int *) buffer;
          *buflen = sizeof (session->libc_epfd);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_LIBC_EPFD: libc_epfd %d, "
-                         "buflen %d", getpid (), session->libc_epfd,
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_SET_LIBC_EPFD: libc_epfd=%s%d buflen=%d",
-                 .format_args = "t1i4i4",
-                 .n_enum_strings = 2,
-                 .enum_strings = {"", "-",},
-               };
-             CLIB_PACKED (struct {
-               u8 sign;
-               u32 data[2];
-             }) * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-
-             ed->sign = (session->libc_epfd < 0);
-             ed->data[0] = abs(session->libc_epfd);
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_LIBC_EPFD: libc_epfd %d, "
+               "buflen %d", getpid (), session->libc_epfd, *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -4556,34 +3734,12 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
     case VPPCOM_ATTR_GET_PROTOCOL:
       if (buffer && buflen && (*buflen >= sizeof (int)))
        {
-         *(int *) buffer = session->proto;
+         *(int *) buffer = session->session_type;
          *buflen = sizeof (int);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_PROTOCOL: %d (%s), "
-                         "buflen %d", getpid (), *(int *) buffer,
-                         *(int *) buffer ? "UDP" : "TCP", *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_GET_PROTOCOL: %s buflen=%d",
-                 .format_args = "t1i4",
-                 .n_enum_strings = 2,
-                 .enum_strings = {"TCP", "UDP",},
-               };
-
-             CLIB_PACKED (struct {
-               u8 proto;
-               u32 buflen;
-             }) * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->proto = session->proto;
-             ed->buflen = *(int *) buffer;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_PROTOCOL: %d (%s), buflen %d",
+               getpid (), *(int *) buffer, *(int *) buffer ? "UDP" : "TCP",
+               *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -4596,27 +3752,8 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
                                                VCL_SESS_ATTR_LISTEN);
          *buflen = sizeof (int);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_LISTEN: %d, "
-                         "buflen %d", getpid (), *(int *) buffer, *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_GET_LISTEN: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = *(int *) buffer;
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_LISTEN: %d, buflen %d",
+               getpid (), *(int *) buffer, *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -4628,28 +3765,8 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
          *(int *) buffer = 0;
          *buflen = sizeof (int);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_ERROR: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (),
-                         *(int *) buffer, *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_GET_ERROR: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = *(int *) buffer;
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_ERROR: %d, buflen %d, #VPP-TBD#",
+               getpid (), *(int *) buffer, *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -4665,28 +3782,9 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
                                vcm->cfg.tx_fifo_size);
          *buflen = sizeof (u32);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_TX_FIFO_LEN: %u (0x%x), "
-                         "buflen %d, #VPP-TBD#", getpid (),
-                         *(size_t *) buffer, *(size_t *) buffer, *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_GET_TX_FIFO_LEN: 0x%x buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = *(size_t *) buffer;
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TX_FIFO_LEN: %u (0x%x), "
+               "buflen %d, #VPP-TBD#", getpid (),
+               *(size_t *) buffer, *(size_t *) buffer, *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -4697,29 +3795,9 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
        {
          /* VPP-TBD */
          session->sndbuf_size = *(u32 *) buffer;
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_TX_FIFO_LEN: %u (0x%x), "
-                         "buflen %d, #VPP-TBD#", getpid (),
-                         session->sndbuf_size, session->sndbuf_size,
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_SET_TX_FIFO_LEN: 0x%x buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = session->sndbuf_size;
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TX_FIFO_LEN: %u (0x%x), "
+               "buflen %d, #VPP-TBD#", getpid (),
+               session->sndbuf_size, session->sndbuf_size, *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -4735,28 +3813,9 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
                                vcm->cfg.rx_fifo_size);
          *buflen = sizeof (u32);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_RX_FIFO_LEN: %u (0x%x), "
-                         "buflen %d, #VPP-TBD#", getpid (),
-                         *(size_t *) buffer, *(size_t *) buffer, *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_GET_RX_FIFO_LEN: 0x%x buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = *(size_t *) buffer;
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_RX_FIFO_LEN: %u (0x%x), "
+               "buflen %d, #VPP-TBD#", getpid (),
+               *(size_t *) buffer, *(size_t *) buffer, *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -4767,29 +3826,9 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
        {
          /* VPP-TBD */
          session->rcvbuf_size = *(u32 *) buffer;
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_RX_FIFO_LEN: %u (0x%x), "
-                         "buflen %d, #VPP-TBD#", getpid (),
-                         session->sndbuf_size, session->sndbuf_size,
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_SET_RX_FIFO_LEN: 0x%x buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = session->sndbuf_size;
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_RX_FIFO_LEN: %u (0x%x), "
+               "buflen %d, #VPP-TBD#", getpid (),
+               session->sndbuf_size, session->sndbuf_size, *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -4803,28 +3842,8 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
                                                VCL_SESS_ATTR_REUSEADDR);
          *buflen = sizeof (int);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_REUSEADDR: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_GET_REUSEADDR: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = *(int *) buffer;
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_REUSEADDR: %d, "
+               "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer, *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -4840,31 +3859,10 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
          else
            VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_REUSEADDR);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_REUSEADDR: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (),
-                         VCL_SESS_ATTR_TEST (session->attr,
-                                             VCL_SESS_ATTR_REUSEADDR),
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_SET_REUSEADDR: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = VCL_SESS_ATTR_TEST (session->attr,
-                                               VCL_SESS_ATTR_REUSEADDR);
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_REUSEADDR: %d, buflen %d,"
+               " #VPP-TBD#", getpid (),
+               VCL_SESS_ATTR_TEST (session->attr,
+                                   VCL_SESS_ATTR_REUSEADDR), *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -4878,28 +3876,8 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
                                                VCL_SESS_ATTR_REUSEPORT);
          *buflen = sizeof (int);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_REUSEPORT: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_GET_REUSEPORT: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = *(int *) buffer;
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_REUSEPORT: %d, buflen %d,"
+               " #VPP-TBD#", getpid (), *(int *) buffer, *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -4915,31 +3893,10 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
          else
            VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_REUSEPORT);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_REUSEPORT: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (),
-                         VCL_SESS_ATTR_TEST (session->attr,
-                                             VCL_SESS_ATTR_REUSEPORT),
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_SET_REUSEPORT: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = VCL_SESS_ATTR_TEST (session->attr,
-                                               VCL_SESS_ATTR_REUSEPORT);
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_REUSEPORT: %d, buflen %d,"
+               " #VPP-TBD#", getpid (),
+               VCL_SESS_ATTR_TEST (session->attr,
+                                   VCL_SESS_ATTR_REUSEPORT), *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -4953,28 +3910,8 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
                                                VCL_SESS_ATTR_BROADCAST);
          *buflen = sizeof (int);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_BROADCAST: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_GET_BROADCAST: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = *(int *) buffer;
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_BROADCAST: %d, buflen %d,"
+               " #VPP-TBD#", getpid (), *(int *) buffer, *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -4989,31 +3926,10 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
          else
            VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_BROADCAST);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_BROADCAST: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (),
-                         VCL_SESS_ATTR_TEST (session->attr,
-                                             VCL_SESS_ATTR_BROADCAST),
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_SET_BROADCAST: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = VCL_SESS_ATTR_TEST (session->attr,
-                                               VCL_SESS_ATTR_BROADCAST);
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_BROADCAST: %d, buflen %d, "
+               "#VPP-TBD#", getpid (),
+               VCL_SESS_ATTR_TEST (session->attr,
+                                   VCL_SESS_ATTR_BROADCAST), *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -5027,28 +3943,8 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
                                                VCL_SESS_ATTR_V6ONLY);
          *buflen = sizeof (int);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_V6ONLY: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_GET_V6ONLY: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = *(int *) buffer;
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_V6ONLY: %d, buflen %d, "
+               "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -5063,30 +3959,10 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
          else
            VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_V6ONLY);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_V6ONLY: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (),
-                         VCL_SESS_ATTR_TEST (session->attr,
-                                             VCL_SESS_ATTR_V6ONLY), *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_SET_V6ONLY: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = VCL_SESS_ATTR_TEST (session->attr,
-                                               VCL_SESS_ATTR_V6ONLY);
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_V6ONLY: %d, buflen %d, "
+               "#VPP-TBD#", getpid (),
+               VCL_SESS_ATTR_TEST (session->attr,
+                                   VCL_SESS_ATTR_V6ONLY), *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -5100,28 +3976,8 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
                                                VCL_SESS_ATTR_KEEPALIVE);
          *buflen = sizeof (int);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_KEEPALIVE: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_GET_KEEPALIVE: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = *(int *) buffer;
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_KEEPALIVE: %d, buflen %d, "
+               "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -5136,31 +3992,10 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
          else
            VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_KEEPALIVE);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_KEEPALIVE: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (),
-                         VCL_SESS_ATTR_TEST (session->attr,
-                                             VCL_SESS_ATTR_KEEPALIVE),
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_SET_KEEPALIVE: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = VCL_SESS_ATTR_TEST (session->attr,
-                                               VCL_SESS_ATTR_KEEPALIVE);
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_KEEPALIVE: %d, buflen %d, "
+               "#VPP-TBD#", getpid (),
+               VCL_SESS_ATTR_TEST (session->attr,
+                                   VCL_SESS_ATTR_KEEPALIVE), *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -5174,28 +4009,8 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
                                                VCL_SESS_ATTR_TCP_NODELAY);
          *buflen = sizeof (int);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_TCP_NODELAY: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_GET_TCP_NODELAY: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = *(int *) buffer;
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TCP_NODELAY: %d, buflen %d, "
+               "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -5210,31 +4025,10 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
          else
            VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_NODELAY);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_TCP_NODELAY: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (),
-                         VCL_SESS_ATTR_TEST (session->attr,
-                                             VCL_SESS_ATTR_TCP_NODELAY),
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_SET_TCP_NODELAY: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = VCL_SESS_ATTR_TEST (session->attr,
-                                               VCL_SESS_ATTR_TCP_NODELAY);
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TCP_NODELAY: %d, buflen %d, "
+               "#VPP-TBD#", getpid (),
+               VCL_SESS_ATTR_TEST (session->attr,
+                                   VCL_SESS_ATTR_TCP_NODELAY), *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -5248,28 +4042,8 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
                                                VCL_SESS_ATTR_TCP_KEEPIDLE);
          *buflen = sizeof (int);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_TCP_KEEPIDLE: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_GET_TCP_KEEPIDLE: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = *(int *) buffer;
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TCP_KEEPIDLE: %d, buflen %d, "
+               "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -5284,31 +4058,10 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
          else
            VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_KEEPIDLE);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_TCP_KEEPIDLE: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (),
-                         VCL_SESS_ATTR_TEST (session->attr,
-                                             VCL_SESS_ATTR_TCP_KEEPIDLE),
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_SET_TCP_KEEPIDLE: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = VCL_SESS_ATTR_TEST (session->attr,
-                                               VCL_SESS_ATTR_TCP_KEEPIDLE);
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TCP_KEEPIDLE: %d, buflen %d, "
+               "#VPP-TBD#", getpid (),
+               VCL_SESS_ATTR_TEST (session->attr,
+                                   VCL_SESS_ATTR_TCP_KEEPIDLE), *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -5322,28 +4075,8 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
                                                VCL_SESS_ATTR_TCP_KEEPINTVL);
          *buflen = sizeof (int);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_TCP_KEEPINTVL: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_GET_TCP_KEEPIDLE: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = *(int *) buffer;
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TCP_KEEPINTVL: %d, buflen %d, "
+               "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -5358,31 +4091,10 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
          else
            VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_KEEPINTVL);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_TCP_KEEPINTVL: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (),
-                         VCL_SESS_ATTR_TEST (session->attr,
-                                             VCL_SESS_ATTR_TCP_KEEPINTVL),
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_SET_TCP_KEEPINTVL: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = VCL_SESS_ATTR_TEST (session->attr,
-                                               VCL_SESS_ATTR_TCP_KEEPINTVL);
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TCP_KEEPINTVL: %d, buflen %d, "
+               "#VPP-TBD#", getpid (),
+               VCL_SESS_ATTR_TEST (session->attr,
+                                   VCL_SESS_ATTR_TCP_KEEPINTVL), *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -5395,28 +4107,8 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
          *(u32 *) buffer = session->user_mss;
          *buflen = sizeof (int);
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_GET_TCP_USER_MSS: %d, "
-                         "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer,
-                         *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_GET_TCP_USER_MSS: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = *(int *) buffer;
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TCP_USER_MSS: %d, buflen %d,"
+               " #VPP-TBD#", getpid (), *(int *) buffer, *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -5428,28 +4120,8 @@ vppcom_session_attr (uint32_t session_index, uint32_t op,
          /* VPP-TBD */
          session->user_mss = *(u32 *) buffer;
 
-         if (VPPCOM_DEBUG > 2)
-           clib_warning ("VCL<%d>: VPPCOM_ATTR_SET_TCP_USER_MSS: %u, "
-                         "buflen %d, #VPP-TBD#", getpid (),
-                         session->user_mss, *buflen);
-         if (VPPCOM_DEBUG > 0)
-           {
-                /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "VPPCOM_ATTR_SET_TCP_USER_MSS: %d buflen=%d",
-                 .format_args = "i4i4",
-               };
-
-             struct {
-               u32 data[2];
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
-             ed->data[0] = session->user_mss;
-             ed->data[1] = *buflen;
-             /* *INDENT-ON* */
-           }
+         VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TCP_USER_MSS: %u, buflen %d, "
+               "#VPP-TBD#", getpid (), session->user_mss, *buflen);
        }
       else
        rv = VPPCOM_EINVAL;
@@ -5470,7 +4142,7 @@ vppcom_session_recvfrom (uint32_t session_index, void *buffer,
                         uint32_t buflen, int flags, vppcom_endpt_t * ep)
 {
   int rv = VPPCOM_OK;
-  session_t *session = 0;
+  vcl_session_t *session = 0;
 
   if (ep)
     {
@@ -5479,38 +4151,19 @@ vppcom_session_recvfrom (uint32_t session_index, void *buffer,
       if (PREDICT_FALSE (rv))
        {
          VCL_SESSION_UNLOCK ();
-         if (VPPCOM_DEBUG > 0)
-           clib_warning ("VCL<%d>: invalid session, "
-                         "sid (%u) has been closed!",
-                         getpid (), session_index);
-         if (VPPCOM_DEBUG > 0)
-           {
-              /* *INDENT-OFF* */
-             ELOG_TYPE_DECLARE (e) =
-               {
-                 .format = "invalid session: %d closed",
-                 .format_args = "i4",
-               };
-
-             struct {
-               u32 data;
-             } * ed;
-
-             ed = ELOG_TRACK_DATA (&vcm->elog_main, e, vcm->elog_track);
-             ed->data = session_index;
-             /* *INDENT-ON* */
-           }
+         VDBG (0, "VCL<%d>: invalid session, sid (%u) has been closed!",
+               getpid (), session_index);
          rv = VPPCOM_EBADFD;
          VCL_SESSION_UNLOCK ();
          goto done;
        }
-      ep->is_ip4 = session->peer_addr.is_ip4;
-      ep->port = session->peer_port;
-      if (session->peer_addr.is_ip4)
-       clib_memcpy (ep->ip, &session->peer_addr.ip46.ip4,
+      ep->is_ip4 = session->transport.is_ip4;
+      ep->port = session->transport.rmt_port;
+      if (session->transport.is_ip4)
+       clib_memcpy (ep->ip, &session->transport.rmt_ip.ip4,
                     sizeof (ip4_address_t));
       else
-       clib_memcpy (ep->ip, &session->peer_addr.ip46.ip6,
+       clib_memcpy (ep->ip, &session->transport.rmt_ip.ip6,
                     sizeof (ip6_address_t));
       VCL_SESSION_UNLOCK ();
     }
@@ -5546,9 +4199,8 @@ vppcom_session_sendto (uint32_t session_index, void *buffer,
   if (flags)
     {
       // TBD check the flags and do the right thing
-      if (VPPCOM_DEBUG > 2)
-       clib_warning ("VCL<%d>: handling flags 0x%u (%d) "
-                     "not implemented yet.", getpid (), flags, flags);
+      VDBG (2, "VCL<%d>: handling flags 0x%u (%d) not implemented yet.",
+           getpid (), flags, flags);
     }
 
   return (vppcom_session_write (session_index, buffer, buflen));
@@ -5561,16 +4213,15 @@ vppcom_poll (vcl_poll_t * vp, uint32_t n_sids, double wait_for_time)
   u32 i, keep_trying = 1;
   int rv, num_ev = 0;
 
-  if (VPPCOM_DEBUG > 3)
-    clib_warning ("VCL<%d>: vp %p, nsids %u, wait_for_time %f",
-                 getpid (), vp, n_sids, wait_for_time);
+  VDBG (3, "VCL<%d>: vp %p, nsids %u, wait_for_time %f",
+       getpid (), vp, n_sids, wait_for_time);
 
   if (!vp)
     return VPPCOM_EFAULT;
 
   do
     {
-      session_t *session;
+      vcl_session_t *session;
 
       for (i = 0; i < n_sids; i++)
        {
@@ -5670,7 +4321,7 @@ vppcom_session_io_thread_fn (void *arg)
   u32 *session_indexes = 0, *session_index;
   int i, rv;
   u32 bytes = 0;
-  session_t *session;
+  vcl_session_t *session;
 
   while (1)
     {
@@ -5771,7 +4422,7 @@ vce_registered_listener_connect_handler_fn (void *arg)
   vce_event_t *ev;
   vppcom_endpt_t ep;
 
-  session_t *new_session;
+  vcl_session_t *new_session;
   int rv;
 
   vppcom_session_listener_t *session_listener =
@@ -5783,13 +4434,13 @@ vce_registered_listener_connect_handler_fn (void *arg)
   VCL_EVENTS_UNLOCK ();
   VCL_SESSION_LOCK_AND_GET (ecr->accepted_session_index, &new_session);
 
-  ep.is_ip4 = new_session->peer_addr.is_ip4;
-  ep.port = new_session->peer_port;
-  if (new_session->peer_addr.is_ip4)
-    clib_memcpy (&ep.ip, &new_session->peer_addr.ip46.ip4,
+  ep.is_ip4 = new_session->transport.is_ip4;
+  ep.port = new_session->transport.rmt_port;
+  if (new_session->transport.is_ip4)
+    clib_memcpy (&ep.ip, &new_session->transport.rmt_ip.ip4,
                 sizeof (ip4_address_t));
   else
-    clib_memcpy (&ep.ip, &new_session->peer_addr.ip46.ip6,
+    clib_memcpy (&ep.ip, &new_session->transport.rmt_ip.ip6,
                 sizeof (ip6_address_t));
 
   vppcom_send_accept_session_reply (new_session->vpp_handle,