u32 sm_seg_index;
u32 client_context;
u64 vpp_handle;
- unix_shared_memory_queue_t *vpp_event_queue;
+ svm_queue_t *vpp_event_queue;
/* Socket configuration state */
/* TBD: covert 'is_*' vars to bit in u8 flags; */
int main_cpu;
/* vpe input queue */
- unix_shared_memory_queue_t *vl_input_queue;
+ svm_queue_t *vl_input_queue;
/* API client handle */
u32 my_client_index;
clib_bitmap_t *ex_bitmap;
/* Our event queue */
- unix_shared_memory_queue_t *app_event_queue;
+ svm_queue_t *app_event_queue;
/* unique segment name counter */
u32 unique_segment_index;
vcm->my_client_index, 0);
elog_track_register (&vcm->elog_main, &vcm->elog_track);
+ /* *INDENT-OFF* */
ELOG_TYPE_DECLARE (e) =
{
- .format = "connect_vpp:rv:%d",.format_args = "i4",};
+ .format = "connect_vpp:rv:%d",
+ .format_args = "i4",
+ };
struct
{
u32 data;
} *ed;
ed = ELOG_TRACK_DATA (&vcm->elog_main, e, vcm->elog_track);
ed->data = rv;
+ /* *INDENT-ON* */
}
return rv;
if (VPPCOM_DEBUG > 0)
clib_warning ("[%d] timeout waiting for state %s (%d)", getpid (),
vppcom_app_state_str (app_state), app_state);
+
+ if (VPPCOM_DEBUG > 0)
+ {
+ /* *INDENT-OFF* */
+ ELOG_TYPE_DECLARE (e) =
+ {
+ .format = "ERR: timeout state:%d",
+ .format_args = "i4",
+ };
+ struct
+ {
+ u32 data;
+ } *ed;
+
+ ed = ELOG_TRACK_DATA (&vcm->elog_main, e, vcm->elog_track);
+
+ ed->data = app_state;
+ /* *INDENT-ON* */
+ }
+
return VPPCOM_ETIMEDOUT;
}
if (VPPCOM_DEBUG > 0)
clib_warning ("[%d] timeout waiting for state 0x%x (%s)", getpid (),
state, vppcom_session_state_str (state));
+
+ if (VPPCOM_DEBUG > 0)
+ {
+ /* *INDENT-OFF* */
+ ELOG_TYPE_DECLARE (e) =
+ {
+ .format = "ERR: timeout state:%d",
+ .format_args = "i4",
+ };
+ struct
+ {
+ u32 data;
+ } *ed;
+
+ ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
+
+ ed->data = state;
+ /* *INDENT-ON* */
+ }
+
return VPPCOM_ETIMEDOUT;
}
if (VPPCOM_DEBUG > 0)
clib_warning ("[%d] timeout waiting for client_session_index", getpid ());
+
+ if (VPPCOM_DEBUG > 0)
+ {
+ /* *INDENT-OFF* */
+ ELOG_TYPE_DECLARE (e) =
+ {
+ .format = "ERR: timeout waiting for session index :%d",
+ .format_args = "i4",
+ };
+ struct
+ {
+ u32 data;
+ } *ed;
+
+ ed = ELOG_TRACK_DATA (&vcm->elog_main, e, vcm->elog_track);
+
+ ed->data = getpid();
+ /* *INDENT-ON* */
+ }
+
return VPPCOM_ETIMEDOUT;
}
}
vcm->app_event_queue =
- uword_to_pointer (mp->app_event_queue_address,
- unix_shared_memory_queue_t *);
+ uword_to_pointer (mp->app_event_queue_address, svm_queue_t *);
vcm->app_state = STATE_APP_ATTACHED;
}
*/
session->is_cut_thru = is_cut_thru;
session->vpp_event_queue = uword_to_pointer (mp->vpp_event_queue_address,
- unix_shared_memory_queue_t *);
+ svm_queue_t *);
rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
rx_fifo->client_session_index = session_index;
session->server_rx_fifo = rx_fifo;
session->server_tx_fifo = tx_fifo;
session->vpp_event_queue = uword_to_pointer (mp->vpp_event_queue_address,
- unix_shared_memory_queue_t *);
+ svm_queue_t *);
session->state = STATE_ACCEPT;
session->is_cut_thru = 0;
session->is_server = 1;
mp->handle, session_index, mp->is_ip4 ? "IPv4" : "IPv6",
format_ip46_address, &mp->ip, mp->is_ip4,
clib_net_to_host_u16 (mp->port), session->vpp_event_queue);
+
+ if (VPPCOM_DEBUG > 0)
+ {
+ session->elog_track.name =
+ (char *) format (0, "C:%d:S:%d%c", vcm->my_client_index,
+ session_index, 0);
+ elog_track_register (&vcm->elog_main, &session->elog_track);
+
+ if (session->peer_addr.is_ip4)
+ {
+ /* *INDENT-OFF* */
+ ELOG_TYPE_DECLARE (e) =
+ {
+ .format =
+ "client_accept:handle:%x addr:%d.%d.%d.%d:%d",
+ .format_args = "i8i1i1i1i1i2",
+ };
+
+ CLIB_PACKED (struct {
+ u64 handle; //8
+ u8 addr[4]; //4
+ u16 port; //2
+ }) * ed;
+
+ ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
+
+ ed->handle = mp->handle;
+ ed->addr[0] = session->peer_addr.ip46.ip4.as_u8[0];
+ ed->addr[1] = session->peer_addr.ip46.ip4.as_u8[1];
+ ed->addr[2] = session->peer_addr.ip46.ip4.as_u8[2];
+ ed->addr[3] = session->peer_addr.ip46.ip4.as_u8[3];
+ ed->port = session->peer_port;
+ /* *INDENT-ON* */
+ }
+ else
+ {
+ clib_warning ("ip6");
+ }
+ }
+
}
static void
{
vl_api_connect_session_reply_t *rmp;
u32 len;
- unix_shared_memory_queue_t *client_q;
+ svm_queue_t *client_q;
rmp = vl_msg_api_alloc (sizeof (*rmp));
memset (rmp, 0, sizeof (*rmp));
sizeof (rmp->lcl_ip));
rmp->is_ip4 = session->peer_addr.is_ip4;
rmp->lcl_port = session->peer_port;
- client_q = uword_to_pointer (session->client_queue_address,
- unix_shared_memory_queue_t *);
+ client_q = uword_to_pointer (session->client_queue_address, svm_queue_t *);
ASSERT (client_q);
vl_msg_api_send_shmem (client_q, (u8 *) & rmp);
}
clib_warning ("[%d] sid %u: Got a cut-thru connect request! "
"clib_fifo_elts %u!\n", getpid (), session_index,
clib_fifo_elts (vcm->client_session_index_fifo));
+
+ if (VPPCOM_DEBUG > 0)
+ {
+ session->elog_track.name =
+ (char *) format (0, "C:%d:S:%d%c", vcm->my_client_index,
+ session_index, 0);
+ elog_track_register (&vcm->elog_main, &session->elog_track);
+
+ /* *INDENT-OFF* */
+ ELOG_TYPE_DECLARE (e) =
+ {
+ .format = "cut-thru-connect:S:%d clib_fifo_elts:%d",
+ .format_args = "i4i4",
+ };
+
+ struct
+ {
+ u32 data[2];
+ } *ed;
+
+ ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
+
+ ed->data[0] = session_index;
+ ed->data[1] = clib_fifo_elts (vcm->client_session_index_fifo);
+ /* *INDENT-ON* */
+ }
+
clib_spinlock_unlock (&vcm->sessions_lockp);
}
getpid (), vpp_handle, session_index,
session->state, vppcom_session_state_str (session->state));
+ if (VPPCOM_DEBUG > 0)
+ {
+ /* *INDENT-OFF* */
+ ELOG_TYPE_DECLARE (e) =
+ {
+ .format = "unbind: handle:%x",
+ .format_args = "i8",
+ };
+
+ struct
+ {
+ u64 handle;
+ } *ed;
+
+ ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
+ ed->handle = vpp_handle;
+ /* *INDENT-ON* */
+ }
vppcom_send_unbind_sock (vpp_handle);
done:
if (VPPCOM_DEBUG > 0)
{
+ /* *INDENT-OFF* */
ELOG_TYPE_DECLARE (e) =
{
- .format = "app_detach:C:%d",.format_args = "i4",};
+ .format = "app_detach:C:%d",
+ .format_args = "i4",
+ };
+
struct
{
u32 data;
} *ed;
ed = ELOG_TRACK_DATA (&vcm->elog_main, e, vcm->elog_track);
ed->data = vcm->my_client_index;
+ /* *INDENT-ON* */
}
vppcom_app_detach ();
if (VPPCOM_DEBUG > 0)
clib_warning ("[%d] sid %u", getpid (), session_index);
+ if (VPPCOM_DEBUG > 0)
+ {
+ session->elog_track.name =
+ (char *) format (0, "C:%d:S:%d%c", vcm->my_client_index,
+ session_index, 0);
+ elog_track_register (&vcm->elog_main, &session->elog_track);
+
+ /* *INDENT-OFF* */
+ ELOG_TYPE_DECLARE (e) =
+ {
+ .format = "session_create:vrf:%d proto:%d state:%d is_nonblocking:%d",
+ .format_args = "i4i4i4i4",
+ };
+
+ struct
+ {
+ u32 data[4];
+ } *ed;
+
+ ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
+ ed->data[0] = session->vrf;
+ ed->data[1] = session->proto;
+ ed->data[2] = session->state;
+ ed->data[3] = session->is_nonblocking;
+ /* *INDENT-ON* */
+ }
+
return (int) session_index;
}
getpid (), vpp_handle, session_index);
}
done:
+
+ if (VPPCOM_DEBUG > 0)
+ {
+ /* *INDENT-OFF* */
+ ELOG_TYPE_DECLARE (e) =
+ {
+ .format = "session_close:rv:%d",
+ .format_args = "i4",
+ };
+
+ struct
+ {
+ u32 data;
+ } *ed;
+
+ ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
+ ed->data = rv;
+ /* *INDENT-ON* */
+ }
+
return rv;
}
clib_net_to_host_u16 (session->lcl_port),
session->proto ? "UDP" : "TCP");
+ if (VPPCOM_DEBUG > 0)
+ {
+ if (session->lcl_addr.is_ip4)
+ {
+ /* *INDENT-OFF* */
+ ELOG_TYPE_DECLARE (e) =
+ {
+ .format = "bind local:%s:%d.%d.%d.%d:%d ",
+ .format_args = "t1i1i1i1i1i2",
+ .n_enum_strings = 2,
+ .enum_strings = {"TCP", "UDP",},
+ };
+
+ CLIB_PACKED (struct {
+ u8 proto;
+ u8 addr[4];
+ u16 port;
+ }) * ed;
+
+ ed = ELOG_TRACK_DATA (&vcm->elog_main, e, session->elog_track);
+ ed->proto = session->proto;
+ ed->addr[0] = session->lcl_addr.ip46.ip4.as_u8[0];
+ ed->addr[1] = session->lcl_addr.ip46.ip4.as_u8[1];
+ ed->addr[2] = session->lcl_addr.ip46.ip4.as_u8[2];
+ ed->addr[3] = session->lcl_addr.ip46.ip4.as_u8[3];
+ ed->port = clib_net_to_host_u16 (session->lcl_port);
+ /* *INDENT-ON* */
+ }
+ }
+
clib_spinlock_unlock (&vcm->sessions_lockp);
done:
return rv;
ssvm_lock_non_recursive (sh, 1);
oldheap = ssvm_push_heap (sh);
event_q = client_session->vpp_event_queue =
- unix_shared_memory_queue_init (vcm->cfg.event_queue_size,
- sizeof (session_fifo_event_t),
- getpid (), 0 /* signal not sent */ );
+ svm_queue_init (vcm->cfg.event_queue_size,
+ sizeof (session_fifo_event_t),
+ getpid (), 0 /* signal not sent */ );
ssvm_pop_heap (oldheap);
ssvm_unlock_non_recursive (sh);
}
client_session->lcl_addr.is_ip4,
clib_net_to_host_u16 (client_session->lcl_port));
+ if (VPPCOM_DEBUG > 0)
+ {
+ client_session->elog_track.name =
+ (char *) format (0, "C:%d:S:%d%c", vcm->my_client_index,
+ client_session_index, 0);
+ elog_track_register (&vcm->elog_main, &client_session->elog_track);
+
+ /* *INDENT-OFF* */
+ ELOG_TYPE_DECLARE (e) =
+ {
+ .format = "accept cut-thru: listen_handle:%x from_handle:%x",
+ .format_args = "i8i8",
+ };
+
+ struct
+ {
+ u64 handle[2];
+ } *ed;
+
+ ed = ELOG_TRACK_DATA (&vcm->elog_main, e, client_session->elog_track);
+ ed->handle[0] = listen_vpp_handle;
+ ed->handle[1] = client_session->vpp_handle;
+ /* *INDENT-ON* */
+
+ if (client_session->lcl_addr.is_ip4)
+ {
+ /* *INDENT-OFF* */
+ ELOG_TYPE_DECLARE (e2) =
+ {
+ .format = "accept cut-thru: S:%d %d.%d.%d.%d:%d ",
+ .format_args = "i4i1i1i1i1i2",
+ };
+
+ CLIB_PACKED (struct {
+ u32 session;
+ u8 addr[4];
+ u16 port;
+ }) * ed2;
+
+ ed2 =
+ ELOG_TRACK_DATA (&vcm->elog_main, e2, client_session->elog_track);
+ ed2->session = client_session_index;
+ ed2->addr[0] = client_session->lcl_addr.ip46.ip4.as_u8[0];
+ ed2->addr[1] = client_session->lcl_addr.ip46.ip4.as_u8[1];
+ ed2->addr[2] = client_session->lcl_addr.ip46.ip4.as_u8[2];
+ ed2->addr[3] = client_session->lcl_addr.ip46.ip4.as_u8[3];
+ ed2->port = clib_net_to_host_u16 (client_session->lcl_port);
+ /* *INDENT-ON* */
+ }
+ }
+
clib_spinlock_unlock (&vcm->sessions_lockp);
rv = (int) client_session_index;
done:
session_fifo_event_t e;
for (i = 0; i < n_to_dequeue; i++)
- unix_shared_memory_queue_sub_raw (vcm->app_event_queue, (u8 *) & e);
+ svm_queue_sub_raw (vcm->app_event_queue, (u8 *) & e);
pthread_mutex_unlock (&vcm->app_event_queue->mutex);
}
{
session_t *session = 0;
svm_fifo_t *tx_fifo;
- unix_shared_memory_queue_t *q;
+ svm_queue_t *q;
session_fifo_event_t evt;
int rv, n_write;
char *fifo_str;
VCL_LOCK_AND_GET_SESSION (session_index, &session);
q = session->vpp_event_queue;
ASSERT (q);
- unix_shared_memory_queue_add (q, (u8 *) & evt,
- 0 /* do wait for mutex */ );
+ svm_queue_add (q, (u8 *) & evt, 0 /* do wait for mutex */ );
clib_spinlock_unlock (&vcm->sessions_lockp);
if (VPPCOM_DEBUG > 1)
clib_warning ("[%d] vpp handle 0x%llx, sid %u: "
clib_warning ("[%d] Created vep_idx %u / sid %u!",
getpid (), vep_idx, vep_idx);
+ if (VPPCOM_DEBUG > 0)
+ {
+ vep_session->elog_track.name =
+ (char *) format (0, "C:%d:VEP:%d%c", vcm->my_client_index,
+ vep_idx, 0);
+ elog_track_register (&vcm->elog_main, &vep_session->elog_track);
+
+ /* *INDENT-OFF* */
+ ELOG_TYPE_DECLARE (e) =
+ {
+ .format = "created epoll session:%d",
+ .format_args = "i4",
+ };
+
+ struct
+ {
+ u32 data;
+ } *ed;
+
+ ed = ELOG_TRACK_DATA (&vcm->elog_main, e, vep_session->elog_track);
+ ed->data = vep_idx;
+ /* *INDENT-ON* */
+ }
+
return (vep_idx);
}