vcl: cleanup bapi and wrk registration

Type: refactor

Signed-off-by: Florin Coras <fcoras@cisco.com>
Change-Id: I0391db5c3ad038265cb8ebf9de02925653e35959

1 files changed, 294 insertions, 55 deletions

diff --git a/src/vcl/vcl_bapi.c b/src/vcl/vcl_bapi.c
index 0e034fc097d..d3a27acaced 100644
--- a/src/vcl/vcl_bapi.c
+++ b/src/vcl/vcl_bapi.c
@@ -58,7 +58,7 @@ static void
 		    format_api_error, ntohl (mp->retval));
     }
   else
-    vcm->app_state = STATE_APP_ENABLED;
+    vcm->bapi_app_state = STATE_APP_ENABLED;
 }
 
 static u64
@@ -141,11 +141,11 @@ vl_api_app_attach_reply_t_handler (vl_api_app_attach_reply_t * mp)
     }
 
   vcm->app_index = clib_net_to_host_u32 (mp->app_index);
-  vcm->app_state = STATE_APP_ATTACHED;
+  vcm->bapi_app_state = STATE_APP_ATTACHED;
   return;
 
 failed:
-  vcm->app_state = STATE_APP_FAILED;
+  vcm->bapi_app_state = STATE_APP_FAILED;
   for (i = clib_max (n_fds - 1, 0); i < vec_len (fds); i++)
     close (fds[i]);
   vec_free (fds);
@@ -231,12 +231,12 @@ vl_api_app_worker_add_del_reply_t_handler (vl_api_app_worker_add_del_reply_t *
       if (rv != 0)
 	goto failed;
     }
-  vcm->app_state = STATE_APP_READY;
+  vcm->bapi_app_state = STATE_APP_READY;
   VDBG (0, "worker %u vpp-worker %u added", wrk_index, wrk->vpp_wrk_index);
   return;
 
 failed:
-  vcm->app_state = STATE_APP_FAILED;
+  vcm->bapi_app_state = STATE_APP_FAILED;
   for (i = clib_max (n_fds - 1, 0); i < vec_len (fds); i++)
     close (fds[i]);
   vec_free (fds);
@@ -248,7 +248,7 @@ static void
 {
   if (mp->retval)
     VDBG (0, "add cert failed: %U", format_api_error, ntohl (mp->retval));
-  vcm->app_state = STATE_APP_READY;
+  vcm->bapi_app_state = STATE_APP_READY;
 }
 
 static void
@@ -257,7 +257,7 @@ static void
 {
   if (mp->retval)
     VDBG (0, "add key failed: %U", format_api_error, ntohl (mp->retval));
-  vcm->app_state = STATE_APP_READY;
+  vcm->bapi_app_state = STATE_APP_READY;
 }
 
 #define foreach_sock_msg                                        	\
@@ -267,8 +267,8 @@ _(APPLICATION_TLS_CERT_ADD_REPLY, application_tls_cert_add_reply)  	\
 _(APPLICATION_TLS_KEY_ADD_REPLY, application_tls_key_add_reply)  	\
 _(APP_WORKER_ADD_DEL_REPLY, app_worker_add_del_reply)			\
 
-void
-vppcom_api_hookup (void)
+static void
+vcl_bapi_hookup (void)
 {
 #define _(N, n)                                                	\
     vl_msg_api_set_handlers(VL_API_##N, #n,                    	\
@@ -284,8 +284,8 @@ vppcom_api_hookup (void)
 /*
  * VPP-API message functions
  */
-void
-vppcom_send_session_enable_disable (u8 is_enable)
+static void
+vcl_bapi_send_session_enable_disable (u8 is_enable)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   vl_api_session_enable_disable_t *bmp;
@@ -293,14 +293,14 @@ vppcom_send_session_enable_disable (u8 is_enable)
   memset (bmp, 0, sizeof (*bmp));
 
   bmp->_vl_msg_id = ntohs (VL_API_SESSION_ENABLE_DISABLE);
-  bmp->client_index = wrk->my_client_index;
+  bmp->client_index = wrk->bapi_client_index;
   bmp->context = htonl (0xfeedface);
   bmp->is_enable = is_enable;
   vl_msg_api_send_shmem (wrk->vl_input_queue, (u8 *) & bmp);
 }
 
 void
-vppcom_app_send_attach (void)
+vcl_bapi_send_attach (void)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   u8 tls_engine = CRYPTO_ENGINE_OPENSSL;
@@ -315,7 +315,7 @@ vppcom_app_send_attach (void)
   memset (bmp, 0, sizeof (*bmp));
 
   bmp->_vl_msg_id = ntohs (VL_API_APP_ATTACH);
-  bmp->client_index = wrk->my_client_index;
+  bmp->client_index = wrk->bapi_client_index;
   bmp->context = htonl (0xfeedface);
   bmp->options[APP_OPTIONS_FLAGS] =
     APP_OPTIONS_FLAGS_ACCEPT_REDIRECT | APP_OPTIONS_FLAGS_ADD_SEGMENT |
@@ -343,7 +343,7 @@ vppcom_app_send_attach (void)
 }
 
 void
-vppcom_app_send_detach (void)
+vcl_bapi_send_detach (void)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   vl_api_application_detach_t *bmp;
@@ -351,13 +351,13 @@ vppcom_app_send_detach (void)
   memset (bmp, 0, sizeof (*bmp));
 
   bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_DETACH);
-  bmp->client_index = wrk->my_client_index;
+  bmp->client_index = wrk->bapi_client_index;
   bmp->context = htonl (0xfeedface);
   vl_msg_api_send_shmem (wrk->vl_input_queue, (u8 *) & bmp);
 }
 
-void
-vcl_send_app_worker_add_del (u8 is_add)
+static void
+vcl_bapi_send_app_worker_add_del (u8 is_add)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   vl_api_app_worker_add_del_t *mp;
@@ -366,7 +366,7 @@ vcl_send_app_worker_add_del (u8 is_add)
   memset (mp, 0, sizeof (*mp));
 
   mp->_vl_msg_id = ntohs (VL_API_APP_WORKER_ADD_DEL);
-  mp->client_index = wrk->my_client_index;
+  mp->client_index = wrk->bapi_client_index;
   mp->app_index = clib_host_to_net_u32 (vcm->app_index);
   mp->context = wrk->wrk_index;
   mp->is_add = is_add;
@@ -376,8 +376,8 @@ vcl_send_app_worker_add_del (u8 is_add)
   vl_msg_api_send_shmem (wrk->vl_input_queue, (u8 *) & mp);
 }
 
-void
-vcl_send_child_worker_del (vcl_worker_t * child_wrk)
+static void
+vcl_bapi_send_child_worker_del (vcl_worker_t * child_wrk)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   vl_api_app_worker_add_del_t *mp;
@@ -386,7 +386,7 @@ vcl_send_child_worker_del (vcl_worker_t * child_wrk)
   memset (mp, 0, sizeof (*mp));
 
   mp->_vl_msg_id = ntohs (VL_API_APP_WORKER_ADD_DEL);
-  mp->client_index = wrk->my_client_index;
+  mp->client_index = wrk->bapi_client_index;
   mp->app_index = clib_host_to_net_u32 (vcm->app_index);
   mp->context = wrk->wrk_index;
   mp->is_add = 0;
@@ -396,8 +396,8 @@ vcl_send_child_worker_del (vcl_worker_t * child_wrk)
 }
 
 void
-vppcom_send_application_tls_cert_add (vcl_session_t * session, char *cert,
-				      u32 cert_len)
+vcl_bapi_send_application_tls_cert_add (vcl_session_t * session, char *cert,
+					u32 cert_len)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   vl_api_application_tls_cert_add_t *cert_mp;
@@ -405,7 +405,7 @@ vppcom_send_application_tls_cert_add (vcl_session_t * session, char *cert,
   cert_mp = vl_msg_api_alloc (sizeof (*cert_mp) + cert_len);
   clib_memset (cert_mp, 0, sizeof (*cert_mp));
   cert_mp->_vl_msg_id = ntohs (VL_API_APPLICATION_TLS_CERT_ADD);
-  cert_mp->client_index = wrk->my_client_index;
+  cert_mp->client_index = wrk->bapi_client_index;
   cert_mp->context = session->session_index;
   cert_mp->cert_len = clib_host_to_net_u16 (cert_len);
   clib_memcpy_fast (cert_mp->cert, cert, cert_len);
@@ -413,8 +413,8 @@ vppcom_send_application_tls_cert_add (vcl_session_t * session, char *cert,
 }
 
 void
-vppcom_send_application_tls_key_add (vcl_session_t * session, char *key,
-				     u32 key_len)
+vcl_bapi_send_application_tls_key_add (vcl_session_t * session, char *key,
+				       u32 key_len)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   vl_api_application_tls_key_add_t *key_mp;
@@ -422,7 +422,7 @@ vppcom_send_application_tls_key_add (vcl_session_t * session, char *key,
   key_mp = vl_msg_api_alloc (sizeof (*key_mp) + key_len);
   clib_memset (key_mp, 0, sizeof (*key_mp));
   key_mp->_vl_msg_id = ntohs (VL_API_APPLICATION_TLS_KEY_ADD);
-  key_mp->client_index = wrk->my_client_index;
+  key_mp->client_index = wrk->bapi_client_index;
   key_mp->context = session->session_index;
   key_mp->key_len = clib_host_to_net_u16 (key_len);
   clib_memcpy_fast (key_mp->key, key, key_len);
@@ -430,14 +430,14 @@ vppcom_send_application_tls_key_add (vcl_session_t * session, char *key,
 }
 
 u32
-vcl_max_nsid_len (void)
+vcl_bapi_max_nsid_len (void)
 {
   vl_api_app_attach_t *mp;
   return (sizeof (mp->namespace_id) - 1);
 }
 
-void
-vppcom_init_error_string_table (void)
+static void
+vcl_bapi_init_error_string_table (void)
 {
   vcm->error_string_by_error_number = hash_create (0, sizeof (uword));
 
@@ -448,75 +448,314 @@ vppcom_init_error_string_table (void)
   hash_set (vcm->error_string_by_error_number, 99, "Misc");
 }
 
-int
-vppcom_connect_to_vpp (const char *app_name)
+static void
+vcl_bapi_cleanup (void)
+{
+  socket_client_main_t *scm = &socket_client_main;
+  api_main_t *am = vlibapi_get_main ();
+
+  am->my_client_index = ~0;
+  am->my_registration = 0;
+  am->vl_input_queue = 0;
+  am->msg_index_by_name_and_crc = 0;
+  scm->socket_fd = 0;
+
+  vl_client_api_unmap ();
+}
+
+static int
+vcl_bapi_connect_to_vpp (void)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   vppcom_cfg_t *vcl_cfg = &vcm->cfg;
+  int rv = VPPCOM_OK;
   api_main_t *am;
+  u8 *wrk_name;
+
+  wrk_name = format (0, "%s-wrk-%u%c", vcm->app_name, wrk->wrk_index, 0);
+
+  /* Make sure api is cleaned up in case this is a connect from a
+   * forked worker */
+  vcl_bapi_cleanup ();
 
   vlibapi_set_main (&wrk->bapi_api_ctx);
   vlibapi_set_memory_client_main (&wrk->bapi_shm_ctx);
-  vppcom_api_hookup ();
+  vcl_bapi_hookup ();
 
-  if (vcl_cfg->vpp_api_socket_name)
+  if (vcl_cfg->vpp_bapi_socket_name)
     {
       if (vl_socket_client_connect2 (&wrk->bapi_sock_ctx,
-				     (char *) vcl_cfg->vpp_api_socket_name,
-				     (char *) app_name,
+				     (char *) vcl_cfg->vpp_bapi_socket_name,
+				     (char *) wrk_name,
 				     0 /* default rx/tx buffer */ ))
 	{
-	  VERR ("app (%s) socket connect failed!", app_name);
-	  return VPPCOM_ECONNREFUSED;
+	  VERR ("app (%s) socket connect failed!", wrk_name);
+	  rv = VPPCOM_ECONNREFUSED;
+	  goto error;
 	}
 
       if (vl_socket_client_init_shm2 (&wrk->bapi_sock_ctx, 0,
 				      1 /* want_pthread */ ))
 	{
-	  VERR ("app (%s) init shm failed!", app_name);
-	  return VPPCOM_ECONNREFUSED;
+	  VERR ("app (%s) init shm failed!", wrk_name);
+	  rv = VPPCOM_ECONNREFUSED;
+	  goto error;
 	}
     }
   else
     {
-      if (!vcl_cfg->vpp_api_filename)
-	vcl_cfg->vpp_api_filename = format (0, "/vpe-api%c", 0);
+      if (!vcl_cfg->vpp_bapi_filename)
+	vcl_cfg->vpp_bapi_filename = format (0, "/vpe-api%c", 0);
 
-      vl_set_memory_root_path ((char *) vcl_cfg->vpp_api_chroot);
+      vl_set_memory_root_path ((char *) vcl_cfg->vpp_bapi_chroot);
 
       VDBG (0, "app (%s) connecting to VPP api (%s)...",
-	    app_name, vcl_cfg->vpp_api_filename);
+	    wrk_name, vcl_cfg->vpp_bapi_filename);
 
-      if (vl_client_connect_to_vlib ((char *) vcl_cfg->vpp_api_filename,
-				     app_name, vcm->cfg.vpp_api_q_length) < 0)
+      if (vl_client_connect_to_vlib ((char *) vcl_cfg->vpp_bapi_filename,
+				     (char *) wrk_name,
+				     vcm->cfg.vpp_api_q_length) < 0)
 	{
-	  VERR ("app (%s) connect failed!", app_name);
-	  return VPPCOM_ECONNREFUSED;
+	  VERR ("app (%s) connect failed!", wrk_name);
+	  rv = VPPCOM_ECONNREFUSED;
+	  goto error;
 	}
     }
 
   am = vlibapi_get_main ();
   wrk->vl_input_queue = am->shmem_hdr->vl_input_queue;
-  wrk->my_client_index = (u32) am->my_client_index;
-  wrk->wrk_state = STATE_APP_CONN_VPP;
+  wrk->bapi_client_index = (u32) am->my_client_index;
 
-  VDBG (0, "app (%s) is connected to VPP!", app_name);
+  VDBG (0, "app (%s) is connected to VPP!", wrk_name);
   vcl_evt (VCL_EVT_INIT, vcm);
-  return VPPCOM_OK;
+
+error:
+  vec_free (wrk_name);
+  return rv;
 }
 
 void
-vppcom_disconnect_from_vpp (void)
+vcl_bapi_disconnect_from_vpp (void)
 {
   vcl_worker_t *wrk = vcl_worker_get_current ();
   vppcom_cfg_t *vcl_cfg = &vcm->cfg;
 
-  if (vcl_cfg->vpp_api_socket_name)
+  if (vcl_cfg->vpp_bapi_socket_name)
     vl_socket_client_disconnect2 (&wrk->bapi_sock_ctx);
   else
     vl_client_disconnect_from_vlib ();
 }
 
+static const char *
+vcl_bapi_app_state_str (vcl_bapi_app_state_t state)
+{
+  char *st;
+
+  switch (state)
+    {
+    case STATE_APP_START:
+      st = "STATE_APP_START";
+      break;
+
+    case STATE_APP_CONN_VPP:
+      st = "STATE_APP_CONN_VPP";
+      break;
+
+    case STATE_APP_ENABLED:
+      st = "STATE_APP_ENABLED";
+      break;
+
+    case STATE_APP_ATTACHED:
+      st = "STATE_APP_ATTACHED";
+      break;
+
+    default:
+      st = "UNKNOWN_APP_STATE";
+      break;
+    }
+
+  return st;
+}
+
+static int
+vcl_bapi_wait_for_app_state_change (vcl_bapi_app_state_t app_state)
+{
+  vcl_worker_t *wrk = vcl_worker_get_current ();
+  f64 timeout = clib_time_now (&wrk->clib_time) + vcm->cfg.app_timeout;
+
+  while (clib_time_now (&wrk->clib_time) < timeout)
+    {
+      if (vcm->bapi_app_state == app_state)
+	return VPPCOM_OK;
+      if (vcm->bapi_app_state == STATE_APP_FAILED)
+	return VPPCOM_ECONNABORTED;
+    }
+  VDBG (0, "timeout waiting for state %s (%d)",
+	vcl_bapi_app_state_str (app_state), app_state);
+  vcl_evt (VCL_EVT_SESSION_TIMEOUT, vcm, bapi_app_state);
+
+  return VPPCOM_ETIMEDOUT;
+}
+
+static int
+vcl_bapi_session_enable (void)
+{
+  int rv;
+
+  if (vcm->bapi_app_state != STATE_APP_ENABLED)
+    {
+      vcl_bapi_send_session_enable_disable (1 /* is_enabled == TRUE */ );
+      rv = vcl_bapi_wait_for_app_state_change (STATE_APP_ENABLED);
+      if (PREDICT_FALSE (rv))
+	{
+	  VDBG (0, "application session enable timed out! returning %d (%s)",
+		rv, vppcom_retval_str (rv));
+	  return rv;
+	}
+    }
+  return VPPCOM_OK;
+}
+
+static int
+vcl_bapi_init (void)
+{
+  int rv;
+
+  vcm->bapi_app_state = STATE_APP_START;
+  vcl_bapi_init_error_string_table ();
+  rv = vcl_bapi_connect_to_vpp ();
+  if (rv)
+    {
+      VERR ("couldn't connect to VPP!");
+      return rv;
+    }
+  VDBG (0, "sending session enable");
+  rv = vcl_bapi_session_enable ();
+  if (rv)
+    {
+      VERR ("vppcom_app_session_enable() failed!");
+      return rv;
+    }
+
+  return 0;
+}
+
+int
+vcl_bapi_attach (void)
+{
+  int rv;
+
+  /* API hookup and connect to VPP */
+  if ((rv = vcl_bapi_init ()))
+    return rv;
+
+  vcl_bapi_send_attach ();
+  rv = vcl_bapi_wait_for_app_state_change (STATE_APP_ATTACHED);
+  if (PREDICT_FALSE (rv))
+    {
+      VDBG (0, "application attach timed out! returning %d (%s)", rv,
+	    vppcom_retval_str (rv));
+      return rv;
+    }
+
+  return 0;
+}
+
+int
+vcl_bapi_app_worker_add (void)
+{
+  if (vcl_bapi_connect_to_vpp ())
+    return -1;
+
+  vcm->bapi_app_state = STATE_APP_ADDING_WORKER;
+  vcl_bapi_send_app_worker_add_del (1 /* is_add */ );
+  if (vcl_bapi_wait_for_app_state_change (STATE_APP_READY))
+    return -1;
+  return 0;
+}
+
+void
+vcl_bapi_app_worker_del (vcl_worker_t * wrk)
+{
+  /* Notify vpp that the worker is going away */
+  if (wrk->wrk_index == vcl_get_worker_index ())
+    vcl_bapi_send_app_worker_add_del (0 /* is_add */ );
+  else
+    vcl_bapi_send_child_worker_del (wrk);
+
+  /* Disconnect the binary api */
+  if (vec_len (vcm->workers) == 1)
+    vcl_bapi_disconnect_from_vpp ();
+  else
+    vl_client_send_disconnect (1 /* vpp should cleanup */ );
+}
+
+int
+vppcom_session_tls_add_cert (uint32_t session_handle, char *cert,
+			     uint32_t cert_len)
+{
+
+  vcl_worker_t *wrk = vcl_worker_get_current ();
+  vcl_session_t *session = 0;
+
+  session = vcl_session_get_w_handle (wrk, session_handle);
+  if (!session)
+    return VPPCOM_EBADFD;
+
+  if (cert_len == 0 || cert_len == ~0)
+    return VPPCOM_EBADFD;
+
+  /*
+   * Send listen request to vpp and wait for reply
+   */
+  vcl_bapi_send_application_tls_cert_add (session, cert, cert_len);
+  vcm->bapi_app_state = STATE_APP_ADDING_TLS_DATA;
+  vcl_bapi_wait_for_app_state_change (STATE_APP_READY);
+  return VPPCOM_OK;
+}
+
+int
+vppcom_session_tls_add_key (uint32_t session_handle, char *key,
+			    uint32_t key_len)
+{
+
+  vcl_worker_t *wrk = vcl_worker_get_current ();
+  vcl_session_t *session = 0;
+
+  session = vcl_session_get_w_handle (wrk, session_handle);
+  if (!session)
+    return VPPCOM_EBADFD;
+
+  if (key_len == 0 || key_len == ~0)
+    return VPPCOM_EBADFD;
+
+  vcl_bapi_send_application_tls_key_add (session, key, key_len);
+  vcm->bapi_app_state = STATE_APP_ADDING_TLS_DATA;
+  vcl_bapi_wait_for_app_state_change (STATE_APP_READY);
+  return VPPCOM_OK;
+}
+
+int
+vcl_bapi_worker_set (void)
+{
+  vcl_worker_t *wrk = vcl_worker_get_current ();
+  int i;
+
+  /* Find the first worker with the same pid */
+  for (i = 0; i < vec_len (vcm->workers); i++)
+    {
+      if (i == wrk->wrk_index)
+	continue;
+      if (vcm->workers[i].current_pid == wrk->current_pid)
+	{
+	  wrk->vl_input_queue = vcm->workers[i].vl_input_queue;
+	  wrk->bapi_client_index = vcm->workers[i].bapi_client_index;
+	  return 0;
+	}
+    }
+  return -1;
+}
+
 /*
  * fd.io coding-style-patch-verification: ON
  *