diff --git a/src/vnet/session/session_api.c b/src/vnet/session/session_api.c
index b88438c..fc63428 100755
--- a/src/vnet/session/session_api.c
+++ b/src/vnet/session/session_api.c
@@ -293,14 +293,13 @@
   app_mq = app_wrk->event_queue;
   svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING,
 				       SVM_Q_WAIT, msg);
-  svm_msg_q_unlock (app_mq);
   evt = svm_msg_q_msg_data (app_mq, msg);
   memset (evt, 0, sizeof (*evt));
   evt->event_type = SESSION_CTRL_EVT_DISCONNECTED;
   mp = (session_disconnected_msg_t *) evt->data;
   mp->handle = application_local_session_handle (ls);
   mp->context = app->api_client_index;
-  svm_msg_q_add (app_mq, msg, SVM_Q_WAIT);
+  svm_msg_q_add_and_unlock (app_mq, msg);
 }
 
 static void
@@ -439,7 +438,6 @@
   app_mq = app_wrk->event_queue;
   svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING,
 				       SVM_Q_WAIT, msg);
-  svm_msg_q_unlock (app_mq);
 
   evt = svm_msg_q_msg_data (app_mq, msg);
   memset (evt, 0, sizeof (*evt));
@@ -508,7 +506,7 @@
       mp->client_event_queue_address = ls->client_evt_q;
       mp->server_event_queue_address = ls->server_evt_q;
     }
-  svm_msg_q_add (app_mq, msg, SVM_Q_WAIT);
+  svm_msg_q_add_and_unlock (app_mq, msg);
 
   return 0;
 }
@@ -527,14 +525,13 @@
   app_mq = app_wrk->event_queue;
   svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING,
 				       SVM_Q_WAIT, msg);
-  svm_msg_q_unlock (app_mq);
   evt = svm_msg_q_msg_data (app_mq, msg);
   memset (evt, 0, sizeof (*evt));
   evt->event_type = SESSION_CTRL_EVT_DISCONNECTED;
   mp = (session_disconnected_msg_t *) evt->data;
   mp->handle = session_handle (s);
   mp->context = app->api_client_index;
-  svm_msg_q_add (app_mq, msg, SVM_Q_WAIT);
+  svm_msg_q_add_and_unlock (app_mq, msg);
 }
 
 static void
@@ -549,13 +546,12 @@
   app_mq = app->event_queue;
   svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING,
 				       SVM_Q_WAIT, msg);
-  svm_msg_q_unlock (app_mq);
   evt = svm_msg_q_msg_data (app_mq, msg);
   memset (evt, 0, sizeof (*evt));
   evt->event_type = SESSION_CTRL_EVT_RESET;
   mp = (session_reset_msg_t *) evt->data;
   mp->handle = session_handle (s);
-  svm_msg_q_add (app_mq, msg, SVM_Q_WAIT);
+  svm_msg_q_add_and_unlock (app_mq, msg);
 }
 
 static int
@@ -582,7 +578,6 @@
 
   svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING,
 				       SVM_Q_WAIT, msg);
-  svm_msg_q_unlock (app_mq);
   evt = svm_msg_q_msg_data (app_mq, msg);
   memset (evt, 0, sizeof (*evt));
   evt->event_type = SESSION_CTRL_EVT_CONNECTED;
@@ -634,7 +629,7 @@
   mp->retval = is_fail ?
     clib_host_to_net_u32 (VNET_API_ERROR_SESSION_CONNECT) : 0;
 
-  svm_msg_q_add (app_mq, msg, SVM_Q_WAIT);
+  svm_msg_q_add_and_unlock (app_mq, msg);
   return 0;
 }
 
@@ -663,7 +658,6 @@
 
   svm_msg_q_lock_and_alloc_msg_w_ring (app_mq, SESSION_MQ_CTRL_EVT_RING,
 				       SVM_Q_WAIT, msg);
-  svm_msg_q_unlock (app_mq);
   evt = svm_msg_q_msg_data (app_mq, msg);
   memset (evt, 0, sizeof (*evt));
   evt->event_type = SESSION_CTRL_EVT_BOUND;
@@ -700,7 +694,7 @@
 
 done:
   mp->retval = rv;
-  svm_msg_q_add (app_mq, msg, SVM_Q_WAIT);
+  svm_msg_q_add_and_unlock (app_mq, msg);
   return 0;
 }
 
diff --git a/src/vnet/tcp/tcp_debug.h b/src/vnet/tcp/tcp_debug.h
index a52efe0..ccf12da 100755
--- a/src/vnet/tcp/tcp_debug.h
+++ b/src/vnet/tcp/tcp_debug.h
@@ -651,7 +651,11 @@
   ed->data[3] = tcp_bytes_out(_tc);					\
   ed->data[4] = tcp_flight_size (_tc);					\
 }
+#else
+#define TCP_EVT_CC_EVT_HANDLER(_tc, _sub_evt, ...)
+#endif
 
+#if TCP_DEBUG_CC > 1
 #define TCP_EVT_CC_RTX_HANDLER(_tc, offset, n_bytes, ...)		\
 {									\
   ELOG_TYPE_DECLARE (_e) =						\
@@ -772,7 +776,6 @@
 #define TCP_EVT_DUPACK_SENT_HANDLER(_tc, _btcp, ...)
 #define TCP_EVT_DUPACK_RCVD_HANDLER(_tc, ...)
 #define TCP_EVT_CC_PACK_HANDLER(_tc, ...)
-#define TCP_EVT_CC_EVT_HANDLER(_tc, _sub_evt, ...)
 #define TCP_EVT_CC_SCOREBOARD_HANDLER(_tc, ...)
 #define TCP_EVT_CC_SACKS_HANDLER(_tc, ...)
 #define TCP_EVT_CC_INPUT_HANDLER(_tc, _len, _written, ...)
