}
static int
-ssvm_segment_attach (char *name, ssvm_segment_type_t type, int fd)
+vcl_segment_attach (u64 segment_handle, char *name, ssvm_segment_type_t type,
+ int fd)
{
svm_fifo_segment_create_args_t _a, *a = &_a;
int rv;
if (type == SSVM_SEGMENT_MEMFD)
a->memfd_fd = fd;
- if ((rv = svm_fifo_segment_attach (a)))
+ if ((rv = svm_fifo_segment_attach (&vcm->segment_main, a)))
{
clib_warning ("svm_fifo_segment_attach ('%s') failed", name);
return rv;
}
+ vcl_segment_table_add (segment_handle, a->new_segment_indices[0]);
vec_reset_length (a->new_segment_indices);
return 0;
}
+static void
+vcl_segment_detach (u64 segment_handle)
+{
+ svm_fifo_segment_main_t *sm = &vcm->segment_main;
+ svm_fifo_segment_private_t *segment;
+ u32 segment_index;
+
+ segment_index = vcl_segment_table_lookup (segment_handle);
+ if (segment_index == (u32) ~ 0)
+ return;
+ segment = svm_fifo_segment_get_segment (sm, segment_index);
+ svm_fifo_segment_delete (sm, segment);
+ vcl_segment_table_del (segment_handle);
+}
+
+static u64
+vcl_vpp_worker_segment_handle (u32 wrk_index)
+{
+ return (VCL_INVALID_SEGMENT_HANDLE - wrk_index - 1);
+}
+
static void
vl_api_application_attach_reply_t_handler (vl_api_application_attach_reply_t *
mp)
{
vcl_worker_t *wrk = vcl_worker_get (0);
+ u64 segment_handle;
u32 n_fds = 0;
int *fds = 0;
wrk->app_event_queue = uword_to_pointer (mp->app_event_queue_address,
svm_msg_q_t *);
+ segment_handle = clib_net_to_host_u64 (mp->segment_handle);
+ if (segment_handle == VCL_INVALID_SEGMENT_HANDLE)
+ {
+ clib_warning ("invalid segment handle");
+ return;
+ }
+
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-mq-seg", SSVM_SEGMENT_MEMFD,
- fds[n_fds++]))
+ if (vcl_segment_attach (vcl_vpp_worker_segment_handle (0),
+ "vpp-mq-seg", SSVM_SEGMENT_MEMFD,
+ fds[n_fds++]))
return;
if (mp->fd_flags & SESSION_FD_F_MEMFD_SEGMENT)
- if (ssvm_segment_attach ((char *) mp->segment_name,
- SSVM_SEGMENT_MEMFD, fds[n_fds++]))
+ if (vcl_segment_attach (segment_handle, (char *) mp->segment_name,
+ SSVM_SEGMENT_MEMFD, fds[n_fds++]))
return;
if (mp->fd_flags & SESSION_FD_F_MQ_EVENTFD)
}
else
{
- if (ssvm_segment_attach ((char *) mp->segment_name, SSVM_SEGMENT_SHM,
- -1))
+ if (vcl_segment_attach (segment_handle, (char *) mp->segment_name,
+ SSVM_SEGMENT_SHM, -1))
return;
}
+ vcm->app_index = clib_net_to_host_u32 (mp->app_index);
vcm->app_state = STATE_APP_ATTACHED;
}
mp)
{
int n_fds = 0, *fds = 0;
+ u64 segment_handle;
vcl_worker_t *wrk;
u32 wrk_index;
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_index = mp->context;
+ wrk = vcl_worker_get_if_valid (wrk_index);
+ if (!wrk)
+ return;
+
+ wrk->vpp_wrk_index = clib_net_to_host_u32 (mp->wrk_index);
wrk->app_event_queue = uword_to_pointer (mp->app_event_queue_address,
svm_msg_q_t *);
+ segment_handle = clib_net_to_host_u64 (mp->segment_handle);
+ if (segment_handle == VCL_INVALID_SEGMENT_HANDLE)
+ {
+ clib_warning ("invalid segment handle");
+ goto failed;
+ }
+
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++]))
+ if (vcl_segment_attach (vcl_vpp_worker_segment_handle (wrk_index),
+ "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++]))
+ if (vcl_segment_attach (segment_handle, (char *) mp->segment_name,
+ SSVM_SEGMENT_MEMFD, fds[n_fds++]))
goto failed;
if (mp->fd_flags & SESSION_FD_F_MQ_EVENTFD)
}
else
{
- if (ssvm_segment_attach ((char *) mp->segment_name, SSVM_SEGMENT_SHM,
- -1))
+ if (vcl_segment_attach (segment_handle, (char *) mp->segment_name,
+ SSVM_SEGMENT_SHM, -1))
goto failed;
}
vcm->app_state = STATE_APP_READY;
vl_api_map_another_segment_t_handler (vl_api_map_another_segment_t * mp)
{
ssvm_segment_type_t seg_type = SSVM_SEGMENT_SHM;
+ u64 segment_handle;
int fd = -1;
- vcm->mounting_segment = 1;
-
if (mp->fd_flags)
{
vl_socket_client_recv_fd_msg (&fd, 1, 5);
seg_type = SSVM_SEGMENT_MEMFD;
}
- if (PREDICT_FALSE (ssvm_segment_attach ((char *) mp->segment_name,
- seg_type, fd)))
+ segment_handle = clib_net_to_host_u64 (mp->segment_handle);
+ if (segment_handle == VCL_INVALID_SEGMENT_HANDLE)
+ {
+ clib_warning ("invalid segment handle");
+ return;
+ }
+
+ if (vcl_segment_attach (segment_handle, (char *) mp->segment_name,
+ seg_type, fd))
{
clib_warning ("VCL<%d>: svm_fifo_segment_attach ('%s') failed",
getpid (), mp->segment_name);
VDBG (1, "VCL<%d>: mapped new segment '%s' size %d", getpid (),
mp->segment_name, mp->segment_size);
- vcm->mounting_segment = 0;
}
static void
vl_api_unmap_segment_t_handler (vl_api_unmap_segment_t * mp)
{
-
-/*
- * XXX Need segment_name to session_id hash,
- * XXX - have sessionID by handle hash currently
- */
-
- VDBG (1, "Unmapped segment '%s'", mp->segment_name);
+ u64 segment_handle = clib_net_to_host_u64 (mp->segment_handle);
+ vcl_segment_detach (segment_handle);
+ VDBG (1, "Unmapped segment: %d", segment_handle);
}
static void
vl_api_bind_sock_reply_t_handler (vl_api_bind_sock_reply_t * mp)
{
/* Expecting a similar message on mq. So ignore this */
- VDBG (1, "VCL<%d>: bapi msg vpp handle 0x%llx, sid %u: bind retval: %u!",
+ VDBG (0, "bapi msg vpp handle 0x%llx, sid %u: bind retval: %u!",
getpid (), mp->handle, mp->context, mp->retval);
}
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 |
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
{
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 = vcm->my_client_index;
- mp->app_api_index = clib_host_to_net_u32 (vcm->main_api_client_index);
- mp->context = wrk_index;
+ mp->client_index = wrk->my_client_index;
+ mp->app_index = clib_host_to_net_u32 (vcm->app_index);
+ mp->context = wrk->wrk_index;
mp->is_add = is_add;
if (!is_add)
- mp->wrk_index = clib_host_to_net_u32 (wrk_index);
+ mp->wrk_index = clib_host_to_net_u32 (wrk->vpp_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
+vcl_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;
+
+ 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->wrk_index;
+ mp->is_add = 0;
+ mp->wrk_index = clib_host_to_net_u32 (child_wrk->vpp_wrk_index);
+
+ vl_msg_api_send_shmem (wrk->vl_input_queue, (u8 *) & mp);
}
void
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 = wrk->vpp_wrk_index;
cmp->is_ip4 = session->transport.is_ip4;
cmp->port = session->transport.rmt_port;
cmp->proto = session->session_type;
clib_memcpy_fast (cmp->options, session->options, sizeof (cmp->options));
- vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & cmp);
+ 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
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 = wrk->vpp_wrk_index;
bmp->is_ip4 = session->transport.is_ip4;
bmp->port = session->transport.lcl_port;
bmp->proto = session->session_type;
clib_memcpy_fast (bmp->options, session->options, sizeof (bmp->options));
- vl_msg_api_send_shmem (vcm->vl_input_queue, (u8 *) & bmp);
+ vl_msg_api_send_shmem (wrk->vl_input_queue, (u8 *) & bmp);
}
void
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;
}
- 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;
+ 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);