format_api_error, ntohl (mp->retval));
}
else
- vcm->app_state = STATE_APP_ENABLED;
+ vcm->bapi_app_state = STATE_APP_ENABLED;
}
static u64
}
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);
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);
{
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
{
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 \
_(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, \
/*
* 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;
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;
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 |
}
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;
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;
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;
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;
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;
}
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;
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);
}
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;
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);
}
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));
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
*
vcl_cfg->max_workers);
}
else if (unformat (line_input, "api-prefix %s",
- &vcl_cfg->vpp_api_chroot))
+ &vcl_cfg->vpp_bapi_chroot))
{
- vec_terminate_c_string (vcl_cfg->vpp_api_chroot);
+ vec_terminate_c_string (vcl_cfg->vpp_bapi_chroot);
VCFG_DBG (0, "VCL<%d>: configured api-prefix (%s) ", getpid (),
- vcl_cfg->vpp_api_chroot);
+ vcl_cfg->vpp_bapi_chroot);
}
else if (unformat (line_input, "api-socket-name %s",
- &vcl_cfg->vpp_api_socket_name))
+ &vcl_cfg->vpp_bapi_socket_name))
{
- vec_terminate_c_string (vcl_cfg->vpp_api_socket_name);
+ vec_terminate_c_string (vcl_cfg->vpp_bapi_socket_name);
VCFG_DBG (0, "VCL<%d>: configured api-socket-name (%s)",
- getpid (), vcl_cfg->vpp_api_socket_name);
+ getpid (), vcl_cfg->vpp_bapi_socket_name);
}
else if (unformat (line_input, "vpp-api-q-length %d", &q_len))
{
else if (unformat (line_input, "namespace-id %v",
&vcl_cfg->namespace_id))
{
- u32 max_nsid_vec_len = vcl_max_nsid_len ();
+ u32 max_nsid_vec_len = vcl_bapi_max_nsid_len ();
u32 nsid_vec_len = vec_len (vcl_cfg->namespace_id);
if (nsid_vec_len > max_nsid_vec_len)
{
env_var_str = getenv (VPPCOM_ENV_API_PREFIX);
if (env_var_str)
{
- vcl_cfg->vpp_api_chroot = format (0, "%s", env_var_str);
- vec_terminate_c_string (vcl_cfg->vpp_api_chroot);
+ vcl_cfg->vpp_bapi_chroot = format (0, "%s", env_var_str);
+ vec_terminate_c_string (vcl_cfg->vpp_bapi_chroot);
VCFG_DBG (0, "VCL<%d>: configured api prefix (%s) from "
VPPCOM_ENV_API_PREFIX "!", getpid (), env_var_str);
}
env_var_str = getenv (VPPCOM_ENV_VPP_API_SOCKET);
if (env_var_str)
{
- vcm->cfg.vpp_api_socket_name = format (0, "%s%c", env_var_str, 0);
+ vcm->cfg.vpp_bapi_socket_name = format (0, "%s%c", env_var_str, 0);
VCFG_DBG (0, "VCL<%d>: configured api-socket-name (%s)", getpid (),
- vcl_cfg->vpp_api_socket_name);
+ vcl_cfg->vpp_bapi_socket_name);
}
}
vls_app_fork_child_handler (void)
{
vcl_worker_t *parent_wrk;
- int rv, parent_wrk_index;
- u8 *child_name;
+ int parent_wrk_index;
parent_wrk_index = vcl_get_worker_index ();
VDBG (0, "initializing forked child %u with parent wrk %u", getpid (),
parent_wrk_index);
/*
- * Allocate worker vcl
+ * Clear old state
*/
vcl_set_worker_index (~0);
- if (!vcl_worker_alloc_and_init ())
- VERR ("couldn't allocate new worker");
/*
- * Attach to binary api
+ * Allocate and register vcl worker with vpp
*/
- child_name = format (0, "%v-child-%u%c", vcm->app_name, getpid (), 0);
- vcl_cleanup_bapi ();
- vppcom_api_hookup ();
- vcm->app_state = STATE_APP_START;
- rv = vppcom_connect_to_vpp ((char *) child_name);
- vec_free (child_name);
- if (rv)
+ if (vppcom_worker_register ())
{
- VERR ("couldn't connect to VPP!");
+ VERR ("couldn't register new worker!");
return;
}
/*
- * Allocate/initialize vls worker
+ * Allocate/initialize vls worker and share sessions
*/
vls_worker_alloc ();
-
- /*
- * Register worker with vpp and share sessions
- */
- vcl_worker_register_with_vpp ();
parent_wrk = vcl_worker_get (parent_wrk_index);
vls_worker_copy_on_fork (parent_wrk);
parent_wrk->forked_child = vcl_get_worker_index ();
static pthread_key_t vcl_worker_stop_key;
-static const char *
-vppcom_app_state_str (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;
-}
-
-int
-vcl_wait_for_app_state_change (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->app_state == app_state)
- return VPPCOM_OK;
- if (vcm->app_state == STATE_APP_FAILED)
- return VPPCOM_ECONNABORTED;
- }
- VDBG (0, "timeout waiting for state %s (%d)",
- vppcom_app_state_str (app_state), app_state);
- vcl_evt (VCL_EVT_SESSION_TIMEOUT, vcm, app_state);
-
- return VPPCOM_ETIMEDOUT;
-}
-
vcl_mq_evt_conn_t *
vcl_mq_evt_conn_alloc (vcl_worker_t * wrk)
{
{
clib_spinlock_lock (&vcm->workers_lock);
if (notify_vpp)
- {
- /* Notify vpp that the worker is going away */
- if (wrk->wrk_index == vcl_get_worker_index ())
- vcl_send_app_worker_add_del (0 /* is_add */ );
- else
- vcl_send_child_worker_del (wrk);
-
- /* Disconnect the binary api */
- if (vec_len (vcm->workers) == 1)
- vppcom_disconnect_from_vpp ();
- else
- vl_client_send_disconnect (1 /* vpp should cleanup */ );
- }
+ vcl_bapi_app_worker_del (wrk);
if (wrk->mqs_epfd > 0)
close (wrk->mqs_epfd);
clib_spinlock_lock (&vcm->workers_lock);
- vcm->app_state = STATE_APP_ADDING_WORKER;
- vcl_send_app_worker_add_del (1 /* is_add */ );
- if (vcl_wait_for_app_state_change (STATE_APP_READY))
+ if (vcl_bapi_app_worker_add ())
{
VDBG (0, "failed to add worker to vpp");
+ clib_spinlock_unlock (&vcm->workers_lock);
return -1;
}
if (pthread_key_create (&vcl_worker_stop_key, vcl_worker_cleanup_cb))
return 0;
}
-int
-vcl_worker_set_bapi (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->my_client_index = vcm->workers[i].my_client_index;
- return 0;
- }
- }
- return -1;
-}
-
svm_msg_q_t *
vcl_worker_ctrl_mq (vcl_worker_t * wrk)
{
return wrk->ctrl_mq;
}
-void
-vcl_cleanup_bapi (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 ();
-}
-
int
vcl_session_read_ready (vcl_session_t * session)
{
STATE_APP_ADDING_TLS_DATA,
STATE_APP_FAILED,
STATE_APP_READY
-} app_state_t;
+} vcl_bapi_app_state_t;
typedef enum
{
f64 accept_timeout;
u32 event_ring_size;
char *event_log_path;
- u8 *vpp_api_filename;
- u8 *vpp_api_socket_name;
- u8 *vpp_api_chroot;
+ u8 *vpp_bapi_filename; /**< bapi shm transport file name */
+ u8 *vpp_bapi_socket_name; /**< bapi socket transport socket name */
+ u8 *vpp_bapi_chroot;
u32 tls_engine;
u8 mt_wrk_supported;
} vppcom_cfg_t;
/** Worker index in vpp*/
u32 vpp_wrk_index;
- /** API client handle */
- u32 my_client_index;
-
- /** State of the connection, shared between msg RX thread and main thread */
- volatile app_state_t wrk_state;
+ /** VPP bapi client handle */
+ u32 bapi_client_index;
/** VPP binary api input queue */
svm_queue_t *vl_input_queue;
/** App's index in vpp. It's used by vpp to identify the app */
u32 app_index;
- /** State of the connection, shared between msg RX thread and main thread */
- volatile app_state_t app_state;
-
u8 *app_name;
/** VCL configuration */
fifo_segment_main_t segment_main;
+ vcl_rpc_fn_t *wrk_rpc_fn;
+
+ /*
+ * Binary api context
+ */
+
+ /* State of the connection, shared between msg RX thread and main thread */
+ volatile vcl_bapi_app_state_t bapi_app_state;
+
+ /* VNET_API_ERROR_FOO -> "Foo" hash table */
+ uword *error_string_by_error_number;
+
#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;
-
- vcl_rpc_fn_t *wrk_rpc_fn;
-
} vppcom_main_t;
extern vppcom_main_t *vcm;
/*
* Helpers
*/
-int vcl_wait_for_app_state_change (app_state_t app_state);
vcl_mq_evt_conn_t *vcl_mq_evt_conn_alloc (vcl_worker_t * wrk);
u32 vcl_mq_evt_conn_index (vcl_worker_t * wrk, vcl_mq_evt_conn_t * mqc);
vcl_mq_evt_conn_t *vcl_mq_evt_conn_get (vcl_worker_t * wrk, u32 mq_conn_idx);
vcl_worker_t *vcl_worker_alloc_and_init (void);
void vcl_worker_cleanup (vcl_worker_t * wrk, u8 notify_vpp);
int vcl_worker_register_with_vpp (void);
-int vcl_worker_set_bapi (void);
svm_msg_q_t *vcl_worker_ctrl_mq (vcl_worker_t * wrk);
void vcl_flush_mq_events (void);
-void vcl_cleanup_bapi (void);
int vcl_session_cleanup (vcl_worker_t * wrk, vcl_session_t * session,
vcl_session_handle_t sh, u8 do_disconnect);
u32 wrk_index);
int vcl_send_worker_rpc (u32 dst_wrk_index, void *data, u32 data_len);
-/*
- * VCL Binary API
- */
-int vppcom_connect_to_vpp (const char *app_name);
-void vppcom_disconnect_from_vpp (void);
-void vppcom_init_error_string_table (void);
-void vppcom_send_session_enable_disable (u8 is_enable);
-void vppcom_app_send_attach (void);
-void vppcom_app_send_detach (void);
-void vcl_send_session_unlisten (vcl_worker_t * wrk, vcl_session_t * s);
-void vppcom_send_disconnect_session (u64 vpp_handle);
-void vppcom_api_hookup (void);
-void vppcom_send_application_tls_cert_add (vcl_session_t * session,
- char *cert, u32 cert_len);
-void vppcom_send_application_tls_key_add (vcl_session_t * session, char *key,
- u32 key_len);
-void vcl_send_app_worker_add_del (u8 is_add);
-void vcl_send_child_worker_del (vcl_worker_t * wrk);
-
int vcl_segment_attach (u64 segment_handle, char *name,
ssvm_segment_type_t type, int fd);
void vcl_segment_detach (u64 segment_handle);
+void vcl_send_session_unlisten (vcl_worker_t * wrk, vcl_session_t * s);
-u32 vcl_max_nsid_len (void);
+/*
+ * VCL Binary API
+ */
+int vcl_bapi_attach (void);
+int vcl_bapi_app_worker_add (void);
+void vcl_bapi_app_worker_del (vcl_worker_t * wrk);
+void vcl_bapi_disconnect_from_vpp (void);
+void vcl_bapi_send_application_tls_cert_add (vcl_session_t * session,
+ char *cert, u32 cert_len);
+void vcl_bapi_send_application_tls_key_add (vcl_session_t * session,
+ char *key, u32 key_len);
+u32 vcl_bapi_max_nsid_len (void);
+int vcl_bapi_worker_set (void);
-void vls_init ();
#endif /* SRC_VCL_VCL_PRIVATE_H_ */
/*
app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_LISTEN);
mp = (session_listen_msg_t *) app_evt->evt->data;
memset (mp, 0, sizeof (*mp));
- mp->client_index = wrk->my_client_index;
+ mp->client_index = wrk->bapi_client_index;
mp->context = s->session_index;
mp->wrk_index = wrk->vpp_wrk_index;
mp->is_ip4 = s->transport.is_ip4;
app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_CONNECT);
mp = (session_connect_msg_t *) app_evt->evt->data;
memset (mp, 0, sizeof (*mp));
- mp->client_index = wrk->my_client_index;
+ mp->client_index = wrk->bapi_client_index;
mp->context = s->session_index;
mp->wrk_index = wrk->vpp_wrk_index;
mp->is_ip4 = s->transport.is_ip4;
app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_UNLISTEN);
mp = (session_unlisten_msg_t *) app_evt->evt->data;
memset (mp, 0, sizeof (*mp));
- mp->client_index = wrk->my_client_index;
+ mp->client_index = wrk->bapi_client_index;
mp->wrk_index = wrk->vpp_wrk_index;
mp->handle = s->vpp_handle;
mp->context = wrk->wrk_index;
app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_DISCONNECT);
mp = (session_disconnect_msg_t *) app_evt->evt->data;
memset (mp, 0, sizeof (*mp));
- mp->client_index = wrk->my_client_index;
+ mp->client_index = wrk->bapi_client_index;
mp->handle = s->vpp_handle;
app_send_ctrl_evt_to_vpp (mq, app_evt);
}
app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_APP_DETACH);
mp = (session_app_detach_msg_t *) app_evt->evt->data;
memset (mp, 0, sizeof (*mp));
- mp->client_index = wrk->my_client_index;
+ mp->client_index = wrk->bapi_client_index;
app_send_ctrl_evt_to_vpp (mq, app_evt);
}
mq = vcl_session_vpp_evt_q (wrk, s);
app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_WORKER_UPDATE);
mp = (session_worker_update_msg_t *) app_evt->evt->data;
- mp->client_index = wrk->my_client_index;
+ mp->client_index = wrk->bapi_client_index;
mp->handle = s->vpp_handle;
mp->req_wrk_index = wrk->vpp_wrk_index;
mp->wrk_index = wrk_index;
mq = vcl_worker_ctrl_mq (wrk);
app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_APP_WRK_RPC);
mp = (session_app_wrk_rpc_msg_t *) app_evt->evt->data;
- mp->client_index = wrk->my_client_index;
+ mp->client_index = wrk->bapi_client_index;
mp->wrk_index = dst_wrk->vpp_wrk_index;
clib_memcpy (mp->data, data, data_len);
app_send_ctrl_evt_to_vpp (mq, app_evt);
vcl_handle_pending_wrk_updates (wrk);
}
-static int
-vppcom_app_session_enable (void)
-{
- int rv;
-
- if (vcm->app_state != STATE_APP_ENABLED)
- {
- vppcom_send_session_enable_disable (1 /* is_enabled == TRUE */ );
- rv = vcl_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
-vppcom_app_attach (void)
-{
- int rv;
-
- vppcom_app_send_attach ();
- rv = vcl_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 VPPCOM_OK;
-}
-
static int
vppcom_session_unbind (u32 session_handle)
{
if (state & STATE_VPP_CLOSING)
{
vpp_evt_q = vcl_session_vpp_evt_q (wrk, session);
- vcl_send_session_disconnected_reply (vpp_evt_q, wrk->my_client_index,
+ vcl_send_session_disconnected_reply (vpp_evt_q, wrk->bapi_client_index,
vpp_handle, 0);
VDBG (1, "session %u [0x%llx]: sending disconnect REPLY...",
session->session_index, vpp_handle);
vcm->main_cpu = pthread_self ();
vcm->main_pid = getpid ();
vcm->app_name = format (0, "%s", app_name);
- vppcom_init_error_string_table ();
fifo_segment_main_init (&vcm->segment_main, vcl_cfg->segment_baseva,
20 /* timeout in secs */ );
pool_alloc (vcm->workers, vcl_cfg->max_workers);
clib_spinlock_init (&vcm->workers_lock);
clib_rwlock_init (&vcm->segment_table_lock);
atexit (vppcom_app_exit);
+ vcl_elog_init (vcm);
/* Allocate default worker */
vcl_worker_alloc_and_init ();
- /* API hookup and connect to VPP */
- vcl_elog_init (vcm);
- vcm->app_state = STATE_APP_START;
- rv = vppcom_connect_to_vpp (app_name);
- if (rv)
- {
- VERR ("couldn't connect to VPP!");
- return rv;
- }
- VDBG (0, "sending session enable");
- rv = vppcom_app_session_enable ();
- if (rv)
- {
- VERR ("vppcom_app_session_enable() failed!");
- return rv;
- }
-
- VDBG (0, "sending app attach");
- rv = vppcom_app_attach ();
- if (rv)
- {
- VERR ("vppcom_app_attach() failed!");
- return rv;
- }
+ if ((rv = vcl_bapi_attach ()))
+ return rv;
VDBG (0, "app_name '%s', my_client_index %d (0x%x)", app_name,
- vcm->workers[0].my_client_index, vcm->workers[0].my_client_index);
+ vcm->workers[0].bapi_client_index, vcm->workers[0].bapi_client_index);
return VPPCOM_OK;
}
/* *INDENT-ON* */
vcl_send_app_detach (current_wrk);
- vppcom_disconnect_from_vpp ();
+ vcl_bapi_disconnect_from_vpp ();
vcl_worker_cleanup (current_wrk, 0 /* notify vpp */ );
vcl_elog_stop (vcm);
else if (state == STATE_DISCONNECT)
{
svm_msg_q_t *mq = vcl_session_vpp_evt_q (wrk, session);
- vcl_send_session_reset_reply (mq, wrk->my_client_index,
+ vcl_send_session_reset_reply (mq, wrk->bapi_client_index,
session->vpp_handle, 0);
}
else if (state == STATE_DETACHED)
return VPPCOM_OK;
}
-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
- */
- vppcom_send_application_tls_cert_add (session, cert, cert_len);
- vcm->app_state = STATE_APP_ADDING_TLS_DATA;
- vcl_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;
-
- vppcom_send_application_tls_key_add (session, key, key_len);
- vcm->app_state = STATE_APP_ADDING_TLS_DATA;
- vcl_wait_for_app_state_change (STATE_APP_READY);
- return VPPCOM_OK;
-}
-
static int
validate_args_session_accept_ (vcl_worker_t * wrk, vcl_session_t * ls)
{
int
vppcom_worker_register (void)
{
- vcl_worker_t *wrk;
- u8 *wrk_name = 0;
- int rv;
-
if (!vcl_worker_alloc_and_init ())
return VPPCOM_EEXIST;
- wrk = vcl_worker_get_current ();
- wrk_name = format (0, "%s-wrk-%u", vcm->app_name, wrk->wrk_index);
-
- rv = vppcom_connect_to_vpp ((char *) wrk_name);
- vec_free (wrk_name);
-
- if (rv)
- return VPPCOM_EFAULT;
-
if (vcl_worker_register_with_vpp ())
return VPPCOM_EEXIST;
Code Review / vpp.git / commitdiff