return;
}
+ vcm->app_index = clib_net_to_host_u32 (mp->app_index);
vcm->app_state = STATE_APP_ATTACHED;
}
format_api_error, ntohl (mp->retval));
goto failed;
}
- wrk_index = clib_net_to_host_u32 (mp->wrk_index);
- if (mp->context != wrk_index)
- {
- clib_warning ("VCL<%d>: wrk numbering doesn't match ours: %u, vpp: %u",
- getpid (), mp->context, wrk_index);
- goto failed;
- }
+ wrk_index = mp->context;
wrk = vcl_worker_get (wrk_index);
+ wrk->vpp_wrk_index = clib_net_to_host_u32 (mp->wrk_index);
+
+ if (!mp->is_add)
+ return;
+
wrk->app_event_queue = uword_to_pointer (mp->app_event_queue_address,
svm_msg_q_t *);
goto failed;
}
vcm->app_state = STATE_APP_READY;
+ VDBG (0, "worker %u vpp-worker %u added", wrk_index, wrk->vpp_wrk_index);
return;
failed:
* XXX - have sessionID by handle hash currently
*/
- VDBG (1, "Unmapped segment '%s'", mp->segment_name);
+ VDBG (1, "Unmapped segment '%s'",
+ clib_net_to_host_u64 (mp->segment_handle));
}
static void
void
vppcom_send_session_enable_disable (u8 is_enable)
{
+ vcl_worker_t *wrk = vcl_worker_get_current ();
vl_api_session_enable_disable_t *bmp;
bmp = vl_msg_api_alloc (sizeof (*bmp));
memset (bmp, 0, sizeof (*bmp));
bmp->_vl_msg_id = ntohs (VL_API_SESSION_ENABLE_DISABLE);
- bmp->client_index = vcm->my_client_index;
+ bmp->client_index = wrk->my_client_index;
bmp->context = htonl (0xfeedface);
bmp->is_enable = is_enable;
- vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & bmp);
+ vl_msg_api_send_shmem (wrk->vl_input_queue, (u8 *) & bmp);
}
void
vppcom_app_send_attach (void)
{
+ vcl_worker_t *wrk = vcl_worker_get_current ();
vl_api_application_attach_t *bmp;
u8 nsid_len = vec_len (vcm->cfg.namespace_id);
u8 app_is_proxy = (vcm->cfg.app_proxy_transport_tcp ||
memset (bmp, 0, sizeof (*bmp));
bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_ATTACH);
- bmp->client_index = vcm->my_client_index;
+ bmp->client_index = wrk->my_client_index;
bmp->context = htonl (0xfeedface);
bmp->options[APP_OPTIONS_FLAGS] =
APP_OPTIONS_FLAGS_ACCEPT_REDIRECT | APP_OPTIONS_FLAGS_ADD_SEGMENT |
if (nsid_len)
{
bmp->namespace_id_len = nsid_len;
- clib_memcpy (bmp->namespace_id, vcm->cfg.namespace_id, nsid_len);
+ clib_memcpy_fast (bmp->namespace_id, vcm->cfg.namespace_id, nsid_len);
bmp->options[APP_OPTIONS_NAMESPACE_SECRET] = vcm->cfg.namespace_secret;
}
- vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & bmp);
+ vl_msg_api_send_shmem (wrk->vl_input_queue, (u8 *) & bmp);
}
void
vppcom_app_send_detach (void)
{
+ vcl_worker_t *wrk = vcl_worker_get_current ();
vl_api_application_detach_t *bmp;
bmp = vl_msg_api_alloc (sizeof (*bmp));
memset (bmp, 0, sizeof (*bmp));
bmp->_vl_msg_id = ntohs (VL_API_APPLICATION_DETACH);
- bmp->client_index = vcm->my_client_index;
+ bmp->client_index = wrk->my_client_index;
bmp->context = htonl (0xfeedface);
- vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & bmp);
+ vl_msg_api_send_shmem (wrk->vl_input_queue, (u8 *) & bmp);
}
void
memset (mp, 0, sizeof (*mp));
mp->_vl_msg_id = ntohs (VL_API_APP_WORKER_ADD_DEL);
- mp->client_index = vcm->my_client_index;
- mp->app_api_index = clib_host_to_net_u32 (vcm->my_client_index);
+ mp->client_index = wrk->my_client_index;
+ mp->app_index = clib_host_to_net_u32 (vcm->app_index);
mp->context = wrk_index;
mp->is_add = is_add;
if (!is_add)
mp->wrk_index = clib_host_to_net_u32 (wrk_index);
- vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & mp);
+ vl_msg_api_send_shmem (wrk->vl_input_queue, (u8 *) & mp);
}
void
vppcom_send_connect_sock (vcl_session_t * session)
{
+ vcl_worker_t *wrk = vcl_worker_get_current ();
vl_api_connect_sock_t *cmp;
cmp = vl_msg_api_alloc (sizeof (*cmp));
memset (cmp, 0, sizeof (*cmp));
cmp->_vl_msg_id = ntohs (VL_API_CONNECT_SOCK);
- cmp->client_index = vcm->my_client_index;
+ cmp->client_index = wrk->my_client_index;
cmp->context = session->session_index;
- cmp->wrk_index = vcl_get_worker_index ();
+ cmp->wrk_index = wrk->vpp_wrk_index;
cmp->is_ip4 = session->transport.is_ip4;
- clib_memcpy (cmp->ip, &session->transport.rmt_ip, sizeof (cmp->ip));
+ clib_memcpy_fast (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);
+ clib_memcpy_fast (cmp->options, session->options, sizeof (cmp->options));
+ vl_msg_api_send_shmem (wrk->vl_input_queue, (u8 *) & cmp);
}
void
vppcom_send_disconnect_session (u64 vpp_handle)
{
+ vcl_worker_t *wrk = vcl_worker_get_current ();
vl_api_disconnect_session_t *dmp;
dmp = vl_msg_api_alloc (sizeof (*dmp));
memset (dmp, 0, sizeof (*dmp));
dmp->_vl_msg_id = ntohs (VL_API_DISCONNECT_SESSION);
- dmp->client_index = vcm->my_client_index;
+ dmp->client_index = wrk->my_client_index;
dmp->handle = vpp_handle;
- vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & dmp);
+ vl_msg_api_send_shmem (wrk->vl_input_queue, (u8 *) & dmp);
}
/* VPP combines bind and listen as one operation. VCL manages the separation
void
vppcom_send_bind_sock (vcl_session_t * session)
{
+ vcl_worker_t *wrk = vcl_worker_get_current ();
vl_api_bind_sock_t *bmp;
/* Assumes caller has acquired spinlock: vcm->sessions_lockp */
memset (bmp, 0, sizeof (*bmp));
bmp->_vl_msg_id = ntohs (VL_API_BIND_SOCK);
- bmp->client_index = vcm->my_client_index;
+ bmp->client_index = wrk->my_client_index;
bmp->context = session->session_index;
- bmp->wrk_index = vcl_get_worker_index ();
+ bmp->wrk_index = wrk->vpp_wrk_index;
bmp->is_ip4 = session->transport.is_ip4;
- clib_memcpy (bmp->ip, &session->transport.lcl_ip, sizeof (bmp->ip));
+ clib_memcpy_fast (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);
+ clib_memcpy_fast (bmp->options, session->options, sizeof (bmp->options));
+ vl_msg_api_send_shmem (wrk->vl_input_queue, (u8 *) & bmp);
}
void
vppcom_send_unbind_sock (u64 vpp_handle)
{
+ vcl_worker_t *wrk = vcl_worker_get_current ();
vl_api_unbind_sock_t *ump;
ump = vl_msg_api_alloc (sizeof (*ump));
memset (ump, 0, sizeof (*ump));
ump->_vl_msg_id = ntohs (VL_API_UNBIND_SOCK);
- ump->client_index = vcm->my_client_index;
- ump->wrk_index = vcl_get_worker_index ();
+ ump->client_index = wrk->my_client_index;
+ ump->wrk_index = wrk->vpp_wrk_index;
ump->handle = vpp_handle;
- vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & ump);
+ vl_msg_api_send_shmem (wrk->vl_input_queue, (u8 *) & ump);
}
void
vppcom_send_accept_session_reply (u64 handle, u32 context, int retval)
{
+ vcl_worker_t *wrk = vcl_worker_get_current ();
vl_api_accept_session_reply_t *rmp;
rmp = vl_msg_api_alloc (sizeof (*rmp));
rmp->retval = htonl (retval);
rmp->context = context;
rmp->handle = handle;
- vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & rmp);
+ vl_msg_api_send_shmem (wrk->vl_input_queue, (u8 *) & rmp);
}
u32
int
vppcom_connect_to_vpp (char *app_name)
{
+ vcl_worker_t *wrk = vcl_worker_get_current ();
api_main_t *am = &api_main;
vppcom_cfg_t *vcl_cfg = &vcm->cfg;
if (vl_socket_client_connect ((char *) vcl_cfg->vpp_api_socket_name,
app_name, 0 /* default rx/tx buffer */ ))
{
- clib_warning ("VCL<%d>: app (%s) socket connect failed!",
- getpid (), app_name);
+ VERR ("app (%s) socket connect failed!", app_name);
return VPPCOM_ECONNREFUSED;
}
if (vl_socket_client_init_shm (0))
{
- clib_warning ("VCL<%d>: app (%s) init shm failed!",
- getpid (), app_name);
+ VERR ("app (%s) init shm failed!", app_name);
return VPPCOM_ECONNREFUSED;
}
}
if (!vcl_cfg->vpp_api_filename)
vcl_cfg->vpp_api_filename = format (0, "/vpe-api%c", 0);
- VDBG (0, "VCL<%d>: app (%s) connecting to VPP api (%s)...", getpid (),
+ VDBG (0, "app (%s) connecting to VPP api (%s)...",
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)
{
- clib_warning ("VCL<%d>: app (%s) connect failed!", getpid (),
- app_name);
+ VERR ("app (%s) connect failed!", app_name);
return VPPCOM_ECONNREFUSED;
}
}
- vcm->vl_input_queue = am->shmem_hdr->vl_input_queue;
- vcm->my_client_index = (u32) am->my_client_index;
- vcm->app_state = STATE_APP_CONN_VPP;
-
- VDBG (0, "VCL<%d>: app (%s) is connected to VPP!", getpid (), app_name);
+ 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;
+ VDBG (0, "app (%s) is connected to VPP!", app_name);
vcl_evt (VCL_EVT_INIT, vcm);
return VPPCOM_OK;
}
Code Review / vpp.git / blobdiff