vl_api_application_attach_reply_t_handler (vl_api_application_attach_reply_t *
mp)
{
+ vcl_worker_t *wrk = vcl_worker_get (0);
u32 n_fds = 0;
int *fds = 0;
return;
}
- vcm->app_event_queue = uword_to_pointer (mp->app_event_queue_address,
+ wrk->app_event_queue = uword_to_pointer (mp->app_event_queue_address,
svm_msg_q_t *);
if (mp->n_fds)
{
if (mp->fd_flags & SESSION_FD_F_MQ_EVENTFD)
{
- svm_msg_q_set_consumer_eventfd (vcm->app_event_queue, fds[n_fds]);
- if (vcm->mqs_epfd < 0)
- clib_unix_warning ("epoll_create() returned");
- vcl_mq_epoll_add_evfd (vcm->app_event_queue);
+ svm_msg_q_set_consumer_eventfd (wrk->app_event_queue, fds[n_fds]);
+ vcl_mq_epoll_add_evfd (wrk, wrk->app_event_queue);
n_fds++;
}
return;
}
+ vcm->app_index = clib_net_to_host_u32 (mp->app_index);
vcm->app_state = STATE_APP_ATTACHED;
}
+static void
+vl_api_app_worker_add_del_reply_t_handler (vl_api_app_worker_add_del_reply_t *
+ mp)
+{
+ int n_fds = 0, *fds = 0;
+ vcl_worker_t *wrk;
+ u32 wrk_index;
+
+ if (mp->retval)
+ {
+ clib_warning ("VCL<%d>: add/del worker failed: %U", getpid (),
+ format_api_error, ntohl (mp->retval));
+ 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 *);
+
+ if (mp->n_fds)
+ {
+ vec_validate (fds, mp->n_fds);
+ vl_socket_client_recv_fd_msg (fds, mp->n_fds, 5);
+
+ if (mp->fd_flags & SESSION_FD_F_VPP_MQ_SEGMENT)
+ if (ssvm_segment_attach ("vpp-worker-seg", SSVM_SEGMENT_MEMFD,
+ fds[n_fds++]))
+ goto failed;
+
+ if (mp->fd_flags & SESSION_FD_F_MEMFD_SEGMENT)
+ if (ssvm_segment_attach ((char *) mp->segment_name,
+ SSVM_SEGMENT_MEMFD, fds[n_fds++]))
+ goto failed;
+
+ if (mp->fd_flags & SESSION_FD_F_MQ_EVENTFD)
+ {
+ svm_msg_q_set_consumer_eventfd (wrk->app_event_queue, fds[n_fds]);
+ vcl_mq_epoll_add_evfd (wrk, wrk->app_event_queue);
+ n_fds++;
+ }
+
+ vec_free (fds);
+ }
+ else
+ {
+ if (ssvm_segment_attach ((char *) mp->segment_name, SSVM_SEGMENT_SHM,
+ -1))
+ goto failed;
+ }
+ vcm->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;
+}
+
static void
vl_api_application_detach_reply_t_handler (vl_api_application_detach_reply_t *
mp)
* 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
{
vcl_cut_through_registration_t *ctr;
u32 mqc_index = ~0;
+ vcl_worker_t *wrk;
int *fds = 0;
if (mp->n_fds)
vl_socket_client_recv_fd_msg (fds, mp->n_fds, 5);
}
- ctr = vcl_ct_registration_lock_and_alloc ();
+ wrk = vcl_worker_get (mp->wrk_index);
+ ctr = vcl_ct_registration_lock_and_alloc (wrk);
ctr->mq = uword_to_pointer (mp->evt_q_address, svm_msg_q_t *);
ctr->peer_mq = uword_to_pointer (mp->peer_evt_q_address, svm_msg_q_t *);
- VDBG (0, "Adding ct registration %u", vcl_ct_registration_index (ctr));
+ VDBG (0, "Adding ct registration %u", vcl_ct_registration_index (wrk, ctr));
if (mp->n_fds && (mp->fd_flags & SESSION_FD_F_MQ_EVENTFD))
{
svm_msg_q_set_consumer_eventfd (ctr->mq, fds[0]);
svm_msg_q_set_producer_eventfd (ctr->peer_mq, fds[1]);
- mqc_index = vcl_mq_epoll_add_evfd (ctr->mq);
+ mqc_index = vcl_mq_epoll_add_evfd (wrk, ctr->mq);
ctr->epoll_evt_conn_index = mqc_index;
vec_free (fds);
}
- vcl_ct_registration_lookup_add (mp->evt_q_address,
- vcl_ct_registration_index (ctr));
- vcl_ct_registration_unlock ();
+ vcl_ct_registration_lookup_add (wrk, mp->evt_q_address,
+ vcl_ct_registration_index (wrk, ctr));
+ vcl_ct_registration_unlock (wrk);
}
static void
VDBG (1, "VCL<%d>: sid %u: unbind succeeded!", getpid (), mp->context);
}
+static void
+vl_api_disconnect_session_reply_t_handler (vl_api_disconnect_session_reply_t *
+ mp)
+{
+ if (mp->retval)
+ clib_warning ("VCL<%d>: ERROR: sid %u: disconnect failed: %U",
+ getpid (), mp->context, format_api_error,
+ ntohl (mp->retval));
+}
+
+static void
+vl_api_connect_session_reply_t_handler (vl_api_connect_sock_reply_t * mp)
+{
+ if (mp->retval)
+ clib_warning ("VCL<%d>: ERROR: sid %u: connect failed: %U",
+ getpid (), mp->context, format_api_error,
+ ntohl (mp->retval));
+}
+
#define foreach_sock_msg \
_(SESSION_ENABLE_DISABLE_REPLY, session_enable_disable_reply) \
_(BIND_SOCK_REPLY, bind_sock_reply) \
_(UNBIND_SOCK_REPLY, unbind_sock_reply) \
+_(CONNECT_SESSION_REPLY, connect_session_reply) \
+_(DISCONNECT_SESSION_REPLY, disconnect_session_reply) \
_(APPLICATION_ATTACH_REPLY, application_attach_reply) \
_(APPLICATION_DETACH_REPLY, application_detach_reply) \
_(MAP_ANOTHER_SEGMENT, map_another_segment) \
_(UNMAP_SEGMENT, unmap_segment) \
_(APP_CUT_THROUGH_REGISTRATION_ADD, app_cut_through_registration_add) \
+_(APP_WORKER_ADD_DEL_REPLY, app_worker_add_del_reply) \
void
vppcom_api_hookup (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
-vppcom_send_connect_sock (vcl_session_t * session, u32 session_index)
+vcl_send_app_worker_add_del (u8 is_add)
{
+ vcl_worker_t *wrk = vcl_worker_get_current ();
+ vl_api_app_worker_add_del_t *mp;
+ u32 wrk_index = wrk->wrk_index;
+
+ mp = vl_msg_api_alloc (sizeof (*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->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 (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;
- /* Assumes caller as acquired the spinlock: vcm->sessions_lockp */
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->context = session_index;
-
+ cmp->client_index = wrk->my_client_index;
+ cmp->context = session->session_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, u32 session_index)
+vppcom_send_disconnect_session (u64 vpp_handle)
{
+ vcl_worker_t *wrk = vcl_worker_get_current ();
vl_api_disconnect_session_t *dmp;
- 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));
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
* of bind and listen locally via vppcom_session_bind() and
* vppcom_session_listen() */
void
-vppcom_send_bind_sock (vcl_session_t * session, u32 session_index)
+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->context = session_index;
+ bmp->client_index = wrk->my_client_index;
+ bmp->context = session->session_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->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