int rv;
if (!svm_fifo_set_event (s->rx_fifo))
return;
- if ((rv =
- app_send_io_evt_to_vpp (s->vpp_evt_q, s->rx_fifo->master_session_index,
- SESSION_IO_EVT_RX, SVM_Q_WAIT)))
+ if ((rv = app_send_io_evt_to_vpp (s->vpp_evt_q,
+ s->rx_fifo->shr->master_session_index,
+ SESSION_IO_EVT_RX, SVM_Q_WAIT)))
ECHO_FAIL (ECHO_FAIL_SEND_IO_EVT, "app_send_io_evt_to_vpp errored %d",
rv);
svm_fifo_clear_deq_ntf (s->rx_fifo);
em->time_to_stop = 1;
}
-int
-connect_to_vpp (char *name)
+static int
+connect_to_vpp (echo_main_t *em)
{
- echo_main_t *em = &echo_main;
api_main_t *am = vlibapi_get_main ();
+ if (em->use_app_socket_api)
+ return echo_api_connect_app_socket (em);
+
if (em->use_sock_api)
{
- if (vl_socket_client_connect ((char *) em->socket_name, name,
- 0 /* default rx, tx buffer */ ))
+ if (vl_socket_client_connect ((char *) em->socket_name,
+ (char *) em->app_name,
+ 0 /* default rx, tx buffer */))
{
ECHO_FAIL (ECHO_FAIL_SOCKET_CONNECT, "socket connect failed");
return -1;
}
else
{
- if (vl_client_connect_to_vlib ("/vpe-api", name, 32) < 0)
+ if (vl_client_connect_to_vlib ("/vpe-api", (char *) em->app_name, 32) <
+ 0)
{
ECHO_FAIL (ECHO_FAIL_SHMEM_CONNECT, "shmem connect failed");
return -1;
end_evt_missing ? "True" : "False");
fformat (stdout, " \"rx_data\": %lld,\n", em->stats.rx_total);
fformat (stdout, " \"tx_data\": %lld,\n", em->stats.tx_total);
+ fformat (stdout, " \"rx_bits_per_second\": %.1f,\n",
+ em->stats.rx_total * 8 / deltat);
+ fformat (stdout, " \"tx_bits_per_second\": %.1f,\n",
+ em->stats.tx_total * 8 / deltat);
fformat (stdout, " \"closing\": {\n");
fformat (stdout, " \"reset\": { \"q\": %d, \"s\": %d },\n",
em->stats.reset_count.q, em->stats.reset_count.s);
em->stats.close_count.q, em->stats.close_count.s);
fformat (stdout, " \"send evt\": { \"q\": %d, \"s\": %d },\n",
em->stats.active_count.q, em->stats.active_count.s);
- fformat (stdout, " \"clean\": { \"q\": %d, \"s\": %d }\n",
+ fformat (stdout, " \"clean\": { \"q\": %d, \"s\": %d },\n",
em->stats.clean_count.q, em->stats.clean_count.s);
- fformat (stdout, " \"accepted\": { \"q\": %d, \"s\": %d }\n",
+ fformat (stdout, " \"accepted\": { \"q\": %d, \"s\": %d },\n",
em->stats.accepted_count.q, em->stats.accepted_count.s);
fformat (stdout, " \"connected\": { \"q\": %d, \"s\": %d }\n",
em->stats.connected_count.q, em->stats.connected_count.s);
- fformat (stdout, " }\n");
+ fformat (stdout, " },\n");
fformat (stdout, " \"results\": {\n");
- fformat (stdout, " \"has_failed\": \"%d\"\n", em->has_failed);
+ fformat (stdout, " \"has_failed\": \"%d\",\n", em->has_failed);
fformat (stdout, " \"fail_descr\": \"%v\"\n", em->fail_descr);
fformat (stdout, " }\n");
fformat (stdout, "}\n");
echo_notify_event (em, ECHO_EVT_LAST_BYTE);
}
+static void
+echo_session_detach_fifos (echo_session_t *s)
+{
+ echo_main_t *em = &echo_main;
+ fifo_segment_t *fs;
+
+ if (!s->rx_fifo)
+ return;
+
+ clib_spinlock_lock (&em->segment_handles_lock);
+
+ fs = fifo_segment_get_segment_if_valid (&em->segment_main,
+ s->rx_fifo->segment_index);
+
+ if (!fs)
+ goto done;
+
+ fifo_segment_free_client_fifo (fs, s->rx_fifo);
+ fifo_segment_free_client_fifo (fs, s->tx_fifo);
+
+done:
+ clib_spinlock_unlock (&em->segment_handles_lock);
+}
+
static void
echo_free_sessions (echo_main_t * em)
{
u32 *session_indexes = 0, *session_index;
/* *INDENT-OFF* */
- pool_foreach (s, em->sessions,
- ({
+ pool_foreach (s, em->sessions)
+ {
if (s->session_state == ECHO_SESSION_STATE_CLOSED)
- vec_add1 (session_indexes, s->session_index);}
- ));
+ vec_add1 (session_indexes, s->session_index);
+ }
/* *INDENT-ON* */
vec_foreach (session_index, session_indexes)
{
/* Free session */
s = pool_elt_at_index (em->sessions, *session_index);
+ echo_session_detach_fifos (s);
echo_session_handle_add_del (em, s->vpp_session_handle,
SESSION_INVALID_INDEX);
clib_memset (s, 0xfe, sizeof (*s));
em->proto_cb_vft->bound_uri_cb (mp, listen_session);
}
-static int
-echo_segment_is_not_mapped (u64 segment_handle)
-{
- echo_main_t *em = &echo_main;
- uword *segment_present;
- ECHO_LOG (3, "Check if segment mapped 0x%lx...", segment_handle);
- clib_spinlock_lock (&em->segment_handles_lock);
- segment_present = hash_get (em->shared_segment_handles, segment_handle);
- clib_spinlock_unlock (&em->segment_handles_lock);
- if (segment_present != 0)
- return 0;
- ECHO_LOG (2, "Segment not mapped (0x%lx)", segment_handle);
- return -1;
-}
-
static void
session_accepted_handler (session_accepted_msg_t * mp)
{
app_session_evt_t _app_evt, *app_evt = &_app_evt;
session_accepted_reply_msg_t *rmp;
- svm_fifo_t *rx_fifo, *tx_fifo;
echo_main_t *em = &echo_main;
echo_session_t *session, *ls;
"Unknown listener handle 0x%lx", mp->listener_handle);
return;
}
- if (echo_segment_is_not_mapped (mp->segment_handle))
+
+ /* Allocate local session and set it up */
+ session = echo_session_new (em);
+
+ if (echo_attach_session (mp->segment_handle, mp->server_rx_fifo,
+ mp->server_tx_fifo, mp->vpp_event_queue_address,
+ session))
{
ECHO_FAIL (ECHO_FAIL_ACCEPTED_WAIT_FOR_SEG_ALLOC,
"accepted wait_for_segment_allocation errored");
return;
}
- /* Allocate local session and set it up */
- session = echo_session_new (em);
session->vpp_session_handle = mp->handle;
- rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
- rx_fifo->client_session_index = session->session_index;
- tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
- tx_fifo->client_session_index = session->session_index;
-
- session->rx_fifo = rx_fifo;
- session->tx_fifo = tx_fifo;
-
/* session->transport needed by app_send_dgram */
clib_memcpy_fast (&session->transport.rmt_ip, &mp->rmt.ip,
sizeof (ip46_address_t));
session->transport.lcl_port = em->uri_elts.port;
session->vpp_session_handle = mp->handle;
- session->start = clib_time_now (&em->clib_time);
- session->vpp_evt_q = uword_to_pointer (mp->vpp_event_queue_address,
- svm_msg_q_t *);
session->listener_index = ls->session_index;
+ session->start = clib_time_now (&em->clib_time);
/* Add it to lookup table */
ECHO_LOG (2, "Accepted session 0x%lx S[%u] -> 0x%lx S[%u]",
echo_main_t *em = &echo_main;
echo_session_t *session;
u32 listener_index = htonl (mp->context);
- svm_fifo_t *rx_fifo, *tx_fifo;
clib_atomic_add_fetch (&em->max_sim_connects, 1);
}
session = echo_session_new (em);
- if (echo_segment_is_not_mapped (mp->segment_handle))
+
+ if (echo_attach_session (mp->segment_handle, mp->server_rx_fifo,
+ mp->server_tx_fifo, mp->vpp_event_queue_address,
+ session))
{
ECHO_FAIL (ECHO_FAIL_CONNECTED_WAIT_FOR_SEG_ALLOC,
"connected wait_for_segment_allocation errored");
return;
}
- rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
- rx_fifo->client_session_index = session->session_index;
- tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
- tx_fifo->client_session_index = session->session_index;
-
- session->rx_fifo = rx_fifo;
- session->tx_fifo = tx_fifo;
session->vpp_session_handle = mp->handle;
session->start = clib_time_now (&em->clib_time);
- session->vpp_evt_q = uword_to_pointer (mp->vpp_event_queue_address,
- svm_msg_q_t *);
session->listener_index = listener_index;
/* session->transport needed by app_send_dgram */
clib_memcpy_fast (&session->transport.lcl_ip, &mp->lcl.ip,
app_send_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt);
}
+static int
+echo_recv_fd (echo_main_t *em, int *fds, int n_fds)
+{
+ if (em->use_app_socket_api)
+ return echo_sapi_recv_fd (em, fds, n_fds);
+ return echo_bapi_recv_fd (em, fds, n_fds);
+}
+
static void
add_segment_handler (session_app_add_segment_msg_t * mp)
{
+ echo_main_t *em = &echo_main;
fifo_segment_main_t *sm = &echo_main.segment_main;
fifo_segment_create_args_t _a, *a = &_a;
- echo_main_t *em = &echo_main;
int *fds = 0, i;
char *seg_name = (char *) mp->segment_name;
u64 segment_handle = mp->segment_handle;
if (mp->fd_flags & SESSION_FD_F_MEMFD_SEGMENT)
{
vec_validate (fds, 1);
- if (vl_socket_client_recv_fd_msg (fds, 1, 5))
+ if (echo_recv_fd (em, fds, 1))
{
- ECHO_FAIL (ECHO_FAIL_VL_API_RECV_FD_MSG,
- "vl_socket_client_recv_fd_msg failed");
+ ECHO_LOG (0, "echo_recv_fd failed");
+ em->time_to_stop = 1;
goto failed;
}
- if (echo_ssvm_segment_attach (seg_name, SSVM_SEGMENT_MEMFD, fds[0]))
+ if (echo_segment_attach (segment_handle, seg_name, SSVM_SEGMENT_MEMFD,
+ fds[0]))
{
ECHO_FAIL (ECHO_FAIL_VL_API_SVM_FIFO_SEG_ATTACH,
"svm_fifo_segment_attach ('%s') "
goto failed;
}
}
- echo_segment_handle_add_del (em, segment_handle, 1 /* add */ );
ECHO_LOG (2, "Mapped segment 0x%lx", segment_handle);
return;
static void
del_segment_handler (session_app_del_segment_msg_t * mp)
{
- echo_main_t *em = &echo_main;
- echo_segment_handle_add_del (em, mp->segment_handle, 0 /* add */ );
+ echo_segment_detach (mp->segment_handle);
ECHO_LOG (2, "Unmaped segment 0x%lx", mp->segment_handle);
}
{
echo_rpc_msg_t *rpc;
svm_msg_q_msg_t msg;
- svm_msg_q_t *mq = em->rpc_msq_queue;
+ svm_msg_q_t *mq = &em->rpc_msq_queue;
while (em->state < STATE_DATA_DONE && !em->time_to_stop)
{
- svm_msg_q_lock (mq);
if (svm_msg_q_is_empty (mq) && svm_msg_q_timedwait (mq, 1))
{
- svm_msg_q_unlock (mq);
continue;
}
- svm_msg_q_sub_w_lock (mq, &msg);
+ svm_msg_q_sub_raw (mq, &msg);
rpc = svm_msg_q_msg_data (mq, &msg);
- svm_msg_q_unlock (mq);
((echo_rpc_t) rpc->fp) (em, &rpc->args);
svm_msg_q_free_msg (mq, &msg);
}
if (em->periodic_stats_delta)
echo_print_periodic_stats (em);
- svm_msg_q_lock (mq);
if (svm_msg_q_is_empty (mq) && svm_msg_q_timedwait (mq, 1))
{
- svm_msg_q_unlock (mq);
continue;
}
for (i = 0; i < svm_msg_q_size (mq); i++)
{
vec_add2 (msg_vec, msg, 1);
- svm_msg_q_sub_w_lock (mq, msg);
+ svm_msg_q_sub_raw (mq, msg);
}
- svm_msg_q_unlock (mq);
for (i = 0; i < vec_len (msg_vec); i++)
{
" nthreads N Use N busy loop threads for data [in addition to main & msg queue]\n"
" TX=1337[K|M|G]|RX Send 1337 [K|M|G]bytes, use TX=RX to reflect the data\n"
" RX=1337[K|M|G] Expect 1337 [K|M|G]bytes\n" "\n");
- for (i = 0; i < TRANSPORT_N_PROTO; i++)
+ for (i = 0; i < vec_len (em->available_proto_cb_vft); i++)
{
echo_proto_cb_vft_t *vft = em->available_proto_cb_vft[i];
if (vft && vft->print_usage_cb)
{
echo_main_t *em = &echo_main;
int i, rv;
- for (i = 0; i < TRANSPORT_N_PROTO; i++)
+ for (i = 0; i < vec_len (em->available_proto_cb_vft); i++)
{
echo_proto_cb_vft_t *vft = em->available_proto_cb_vft[i];
if (vft && vft->process_opts_cb)
echo_set_each_proto_defaults_before_opts (echo_main_t * em)
{
int i;
- for (i = 0; i < TRANSPORT_N_PROTO; i++)
+ for (i = 0; i < vec_len (em->available_proto_cb_vft); i++)
{
echo_proto_cb_vft_t *vft = em->available_proto_cb_vft[i];
if (vft && vft->set_defaults_before_opts_cb)
em->test_return_packets = RETURN_PACKETS_LOG_WRONG;
else if (unformat (a, "socket-name %s", &em->socket_name))
;
+ else if (unformat (a, "use-app-socket-api"))
+ em->use_app_socket_api = 1;
else if (unformat (a, "use-svm-api"))
em->use_sock_api = 0;
else if (unformat (a, "fifo-size %U", unformat_memory_size, &tmp))
}
}
+static int
+echo_needs_crypto (echo_main_t *em)
+{
+ u8 tr = em->uri_elts.transport_proto;
+ if (tr == TRANSPORT_PROTO_QUIC || tr == TRANSPORT_PROTO_TLS)
+ return 1;
+ return 0;
+}
+
void
echo_process_uri (echo_main_t * em)
{
clib_memset (em, 0, sizeof (*em));
}
+static int
+echo_detach (echo_main_t *em)
+{
+ if (em->use_app_socket_api)
+ return echo_sapi_detach (em);
+
+ echo_send_detach (em);
+ if (wait_for_state_change (em, STATE_DETACHED, TIMEOUT))
+ {
+ ECHO_FAIL (ECHO_FAIL_DETACH, "Couldn't detach from vpp");
+ return -1;
+ }
+ return 0;
+}
+
+static void
+echo_add_cert_key (echo_main_t *em)
+{
+ if (em->use_app_socket_api)
+ echo_sapi_add_cert_key (em);
+ else
+ {
+ echo_send_add_cert_key (em);
+ if (wait_for_state_change (em, STATE_ATTACHED, TIMEOUT))
+ {
+ ECHO_FAIL (ECHO_FAIL_APP_ATTACH,
+ "Couldn't add crypto context to vpp\n");
+ exit (1);
+ }
+ }
+}
+
+static int
+echo_del_cert_key (echo_main_t *em)
+{
+ if (em->use_app_socket_api)
+ return echo_sapi_del_cert_key (em);
+
+ echo_send_del_cert_key (em);
+ if (wait_for_state_change (em, STATE_CLEANED_CERT_KEY, TIMEOUT))
+ {
+ ECHO_FAIL (ECHO_FAIL_DEL_CERT_KEY, "Couldn't cleanup cert and key");
+ return -1;
+ }
+ return 0;
+}
+
+static void
+echo_disconnect (echo_main_t *em)
+{
+ if (em->use_app_socket_api)
+ return;
+
+ if (em->use_sock_api)
+ vl_socket_client_disconnect ();
+ else
+ vl_client_disconnect_from_vlib ();
+}
+
+static int
+echo_attach (echo_main_t *em)
+{
+ if (em->use_app_socket_api)
+ return echo_sapi_attach (em);
+ else
+ {
+ echo_api_hookup (em);
+ echo_send_attach (em);
+ if (wait_for_state_change (em, STATE_ATTACHED_NO_CERT, TIMEOUT))
+ {
+ ECHO_FAIL (ECHO_FAIL_ATTACH_TO_VPP,
+ "Couldn't attach to vpp, did you run <session enable> ?");
+ return -1;
+ }
+ }
+ return 0;
+}
+
int
main (int argc, char **argv)
{
echo_main_t *em = &echo_main;
fifo_segment_main_t *sm = &em->segment_main;
- char *app_name;
u64 i;
+ int *rv;
svm_msg_q_cfg_t _cfg, *cfg = &_cfg;
u32 rpc_queue_size = 256 << 10;
cfg->n_rings = 1;
cfg->q_nitems = rpc_queue_size;
cfg->ring_cfgs = rc;
- em->rpc_msq_queue = svm_msg_q_alloc (cfg);
+ svm_msg_q_attach (&em->rpc_msq_queue, svm_msg_q_alloc (cfg));
signal (SIGINT, stop_signal);
signal (SIGQUIT, stop_signal);
signal (SIGTERM, stop_signal);
- echo_api_hookup (em);
- app_name = em->i_am_master ? "echo_server" : "echo_client";
- if (connect_to_vpp (app_name))
+ em->app_name =
+ format (0, "%s%c", em->i_am_master ? "echo_server" : "echo_client", 0);
+
+ if (connect_to_vpp (em))
{
svm_region_exit ();
ECHO_FAIL (ECHO_FAIL_CONNECT_TO_VPP, "Couldn't connect to vpp");
echo_session_prealloc (em);
echo_notify_event (em, ECHO_EVT_START);
- echo_send_attach (em);
- if (wait_for_state_change (em, STATE_ATTACHED_NO_CERT, TIMEOUT))
- {
- ECHO_FAIL (ECHO_FAIL_ATTACH_TO_VPP,
- "Couldn't attach to vpp, did you run <session enable> ?");
- goto exit_on_error;
- }
+ if (echo_attach (em))
+ goto exit_on_error;
- if (em->uri_elts.transport_proto != TRANSPORT_PROTO_QUIC
- && em->uri_elts.transport_proto != TRANSPORT_PROTO_TLS)
- em->state = STATE_ATTACHED;
- else
+ if (echo_needs_crypto (em))
{
ECHO_LOG (2, "Adding crypto context %U", echo_format_crypto_engine,
em->crypto_engine);
- echo_send_add_cert_key (em);
- if (wait_for_state_change (em, STATE_ATTACHED, TIMEOUT))
- {
- ECHO_FAIL (ECHO_FAIL_APP_ATTACH,
- "Couldn't add crypto context to vpp\n");
- exit (1);
- }
+ echo_add_cert_key (em);
+ }
+ else
+ {
+ em->state = STATE_ATTACHED;
}
- if (pthread_create (&em->mq_thread_handle,
- NULL /*attr */ , echo_mq_thread_fn, 0))
+ if (pthread_create (&em->mq_thread_handle, NULL /*attr */, echo_mq_thread_fn,
+ 0))
{
ECHO_FAIL (ECHO_FAIL_PTHREAD_CREATE, "pthread create errored");
goto exit_on_error;
clients_run (em);
echo_notify_event (em, ECHO_EVT_EXIT);
echo_free_sessions (em);
- echo_send_del_cert_key (em);
- if (wait_for_state_change (em, STATE_CLEANED_CERT_KEY, TIMEOUT))
+ if (echo_needs_crypto (em))
{
- ECHO_FAIL (ECHO_FAIL_DEL_CERT_KEY, "Couldn't cleanup cert and key");
- goto exit_on_error;
+ if (echo_del_cert_key (em))
+ goto exit_on_error;
}
- echo_send_detach (em);
- if (wait_for_state_change (em, STATE_DETACHED, TIMEOUT))
- {
- ECHO_FAIL (ECHO_FAIL_DETACH, "Couldn't detach from vpp");
- goto exit_on_error;
- }
- int *rv;
+ if (echo_detach (em))
+ goto exit_on_error;
+
pthread_join (em->mq_thread_handle, (void **) &rv);
if (rv)
{
ECHO_FAIL (ECHO_FAIL_MQ_PTHREAD, "mq pthread errored %d", rv);
goto exit_on_error;
}
- if (em->use_sock_api)
- vl_socket_client_disconnect ();
- else
- vl_client_disconnect_from_vlib ();
+ echo_disconnect (em);
echo_assert_test_suceeded (em);
exit_on_error:
ECHO_LOG (1, "Test complete !\n");
else
print_global_stats (em);
vec_free (em->fail_descr);
+ vec_free (em->available_proto_cb_vft);
exit (em->has_failed);
}
Code Review / vpp.git / blobdiff