static void
echo_assert_test_suceeded (echo_main_t * em)
{
- CHECK (em->n_clients * em->bytes_to_receive,
- em->stats.rx_total, "Not enough data received");
- CHECK (em->n_clients * em->bytes_to_send,
- em->stats.tx_total, "Not enough data sent");
+ CHECK (ECHO_FAIL_TEST_ASSERT_RX_TOTAL,
+ em->n_clients * em->bytes_to_receive, em->stats.rx_total,
+ "Invalid amount of data received");
+ CHECK (ECHO_FAIL_TEST_ASSERT_TX_TOTAL,
+ em->n_clients * em->bytes_to_send, em->stats.tx_total,
+ "Invalid amount of data sent");
clib_spinlock_lock (&em->sid_vpp_handles_lock);
- CHECK (0, hash_elts (em->session_index_by_vpp_handles),
+ CHECK (ECHO_FAIL_TEST_ASSERT_ALL_SESSIONS_CLOSED,
+ 0, hash_elts (em->session_index_by_vpp_handles),
"Some sessions are still open");
clib_spinlock_unlock (&em->sid_vpp_handles_lock);
}
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)))
- ECHO_FAIL ("app_send_io_evt_to_vpp errored %d", rv);
+ ECHO_FAIL (ECHO_FAIL_SEND_IO_EVT, "app_send_io_evt_to_vpp errored %d",
+ rv);
svm_fifo_clear_deq_ntf (s->rx_fifo);
}
if (vl_socket_client_connect ((char *) em->socket_name, name,
0 /* default rx, tx buffer */ ))
{
- ECHO_FAIL ("socket connect failed");
+ ECHO_FAIL (ECHO_FAIL_SOCKET_CONNECT, "socket connect failed");
return -1;
}
if (vl_socket_client_init_shm (0, 1 /* want_pthread */ ))
{
- ECHO_FAIL ("init shm api failed");
+ ECHO_FAIL (ECHO_FAIL_INIT_SHM_API, "init shm api failed");
return -1;
}
}
{
if (vl_client_connect_to_vlib ("/vpe-api", name, 32) < 0)
{
- ECHO_FAIL ("shmem connect failed");
+ ECHO_FAIL (ECHO_FAIL_SHMEM_CONNECT, "shmem connect failed");
return -1;
}
}
return 0;
}
-static void
-echo_event_didnt_happen (u8 e)
-{
- echo_main_t *em = &echo_main;
- u8 *s = format (0, "%U", echo_format_timing_event, e);
- ECHO_LOG (0, "Expected event %s to happen, but it did not!", s);
- em->has_failed = 1;
-}
-
static void
print_global_json_stats (echo_main_t * em)
{
em->timing.end_time - em->timing.start_time;
if (start_evt_missing)
- echo_event_didnt_happen (em->timing.start_event);
+ ECHO_FAIL (ECHO_FAIL_MISSING_START_EVENT,
+ "Expected event %v to happen, but it did not!", start_evt);
+
if (end_evt_missing)
- echo_event_didnt_happen (em->timing.end_event);
+ ECHO_FAIL (ECHO_FAIL_MISSING_END_EVENT,
+ "Expected event %v to happen, but it did not!", end_evt);
+
fformat (stdout, "vpp_echo JSON stats:\n{\n");
fformat (stdout, " \"role\": \"%s\",\n",
em->i_am_master ? "server" : "client");
fformat (stdout, " \"time\": \"%.9f\",\n", deltat);
- fformat (stdout, " \"start_evt\": \"%s\",\n", start_evt);
+ fformat (stdout, " \"start_evt\": \"%v\",\n", start_evt);
fformat (stdout, " \"start_evt_missing\": \"%s\",\n",
start_evt_missing ? "True" : "False");
- fformat (stdout, " \"end_evt\": \"%s\",\n", end_evt);
+ fformat (stdout, " \"end_evt\": \"%v\",\n", end_evt);
fformat (stdout, " \"end_evt_missing\": \"%s\",\n",
end_evt_missing ? "True" : "False");
fformat (stdout, " \"rx_data\": %lld,\n", em->stats.rx_total);
fformat (stdout, " \"clean\": { \"q\": %d, \"s\": %d }\n",
em->stats.clean_count.q, em->stats.clean_count.s);
fformat (stdout, " }\n");
+ fformat (stdout, " \"results\": {\n");
+ fformat (stdout, " \"has_failed\": \"%d\"\n", em->has_failed);
+ fformat (stdout, " \"fail_descr\": \"%v\"\n", em->fail_descr);
+ fformat (stdout, " }\n");
fformat (stdout, "}\n");
fflush (stdout);
+ vec_free (start_evt);
+ vec_free (end_evt);
}
static void
print_global_stats (echo_main_t * em)
{
- u8 *s;
+ u8 *start_evt =
+ format (0, "%U", echo_format_timing_event, em->timing.start_event);
+ u8 *end_evt =
+ format (0, "%U", echo_format_timing_event, em->timing.end_event);
u8 start_evt_missing = !(em->timing.events_sent & em->timing.start_event);
u8 end_evt_missing = !(em->timing.events_sent & em->timing.end_event);
f64 deltat = start_evt_missing || end_evt_missing ? 0 :
em->timing.end_time - em->timing.start_time;
if (start_evt_missing)
- echo_event_didnt_happen (em->timing.start_event);
+ ECHO_FAIL (ECHO_FAIL_MISSING_START_EVENT,
+ "Expected event %v to happen, but it did not!", start_evt);
+
if (end_evt_missing)
- echo_event_didnt_happen (em->timing.end_event);
- s = format (0, "%U:%U",
- echo_format_timing_event, em->timing.start_event,
- echo_format_timing_event, em->timing.end_event);
- fformat (stdout, "Timing %v\n", s);
+ ECHO_FAIL (ECHO_FAIL_MISSING_END_EVENT,
+ "Expected event %v to happen, but it did not!", end_evt);
+
+ fformat (stdout, "Timing %v:%v\n", start_evt, end_evt);
if (start_evt_missing)
- fformat (stdout, "Missing Start Timing Event (%U)!\n",
- echo_format_timing_event, em->timing.start_event);
+ fformat (stdout, "Missing Start Timing Event (%v)!\n", start_evt);
if (end_evt_missing)
- fformat (stdout, "Missing End Timing Event (%U)!\n",
- echo_format_timing_event, em->timing.end_event);
+ fformat (stdout, "Missing End Timing Event (%v)!\n", end_evt);
fformat (stdout, "-------- TX --------\n");
fformat (stdout, "%lld bytes (%lld mbytes, %lld gbytes) in %.6f seconds\n",
em->stats.tx_total, em->stats.tx_total / (1ULL << 20),
em->stats.active_count.s, em->stats.active_count.q);
fformat (stdout, "Discarded %d streams (and %d Quic conn)\n",
em->stats.clean_count.s, em->stats.clean_count.q);
+ if (em->has_failed)
+ fformat (stdout, "\nFailure Return Status: %d\n%v", em->has_failed,
+ em->fail_descr);
+ vec_free (start_evt);
+ vec_free (end_evt);
}
void
if (em->max_test_msg == 0)
ECHO_LOG (0, "Too many errors, hiding next ones");
if (em->test_return_packets == RETURN_PACKETS_ASSERT)
- ECHO_FAIL ("test-bytes errored");
+ ECHO_FAIL (ECHO_FAIL_TEST_BYTES_ERR, "test-bytes errored");
}
}
static void *
echo_data_thread_fn (void *arg)
{
- clib_mem_set_thread_index ();
+ clib_mem_set_thread_index (); /* First thing to do in client thread */
echo_main_t *em = &echo_main;
u32 N = em->n_clients;
u32 n = (N + em->n_rx_threads - 1) / em->n_rx_threads;
pthread_exit (0);
}
+static void
+session_unlisten_handler (session_unlisten_msg_t * mp)
+{
+ echo_session_t *listen_session;
+ echo_main_t *em = &echo_main;
+ listen_session = pool_elt_at_index (em->sessions, em->listen_session_index);
+ em->proto_cb_vft->cleanup_cb (listen_session, 0 /* parent_died */ );
+ em->state = STATE_DISCONNECTED;
+}
+
static void
session_bound_handler (session_bound_msg_t * mp)
{
echo_session_t *listen_session;
if (mp->retval)
{
- ECHO_FAIL ("bind failed: %U", format_api_error,
+ ECHO_FAIL (ECHO_FAIL_BIND, "bind failed: %U", format_api_error,
clib_net_to_host_u32 (mp->retval));
return;
}
if (wait_for_segment_allocation (mp->segment_handle))
{
- ECHO_FAIL ("wait_for_segment_allocation errored");
+ ECHO_FAIL (ECHO_FAIL_ACCEPTED_WAIT_FOR_SEG_ALLOC,
+ "accepted wait_for_segment_allocation errored");
return;
}
if (mp->retval)
{
- ECHO_FAIL ("connection failed with code: %U", format_api_error,
- clib_net_to_host_u32 (mp->retval));
+ if (em->proto_cb_vft->connected_cb)
+ em->
+ proto_cb_vft->connected_cb ((session_connected_bundled_msg_t *) mp,
+ listener_index, 1 /* is_failed */ );
return;
}
session = echo_session_new (em);
if (wait_for_segment_allocation (mp->segment_handle))
{
- ECHO_FAIL ("wait_for_segment_allocation errored");
+ ECHO_FAIL (ECHO_FAIL_CONNECTED_WAIT_FOR_SEG_ALLOC,
+ "connected wait_for_segment_allocation errored");
return;
}
echo_session_t *s;
ECHO_LOG (1, "passive close session 0x%lx", mp->handle);
if (!(s = echo_get_session_from_handle (em, mp->handle)))
- return;
+ {
+ ECHO_FAIL (ECHO_FAIL_SESSION_DISCONNECT, "Session 0x%lx not found",
+ mp->handle);
+ return;
+ }
em->proto_cb_vft->disconnected_cb (mp, s);
app_alloc_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt,
echo_session_t *s = 0;
ECHO_LOG (1, "Reset session 0x%lx", mp->handle);
if (!(s = echo_get_session_from_handle (em, mp->handle)))
- return;
+ {
+ ECHO_FAIL (ECHO_FAIL_SESSION_RESET, "Session 0x%lx not found",
+ mp->handle);
+ return;
+ }
em->proto_cb_vft->reset_cb (mp, s);
app_alloc_ctrl_evt_to_vpp (s->vpp_evt_q, app_evt,
switch (e->event_type)
{
case SESSION_CTRL_EVT_BOUND:
- session_bound_handler ((session_bound_msg_t *) e->data);
- break;
+ return session_bound_handler ((session_bound_msg_t *) e->data);
case SESSION_CTRL_EVT_ACCEPTED:
- session_accepted_handler ((session_accepted_msg_t *) e->data);
- break;
+ return session_accepted_handler ((session_accepted_msg_t *) e->data);
case SESSION_CTRL_EVT_CONNECTED:
- session_connected_handler ((session_connected_msg_t *) e->data);
- break;
+ return session_connected_handler ((session_connected_msg_t *) e->data);
case SESSION_CTRL_EVT_DISCONNECTED:
- session_disconnected_handler ((session_disconnected_msg_t *) e->data);
- break;
+ return session_disconnected_handler ((session_disconnected_msg_t *)
+ e->data);
case SESSION_CTRL_EVT_RESET:
- session_reset_handler ((session_reset_msg_t *) e->data);
- break;
+ return session_reset_handler ((session_reset_msg_t *) e->data);
+ case SESSION_CTRL_EVT_UNLISTEN_REPLY:
+ return session_unlisten_handler ((session_unlisten_msg_t *) e->data);
case SESSION_IO_EVT_RX:
break;
default:
{
echo_rpc_msg_t *rpc;
svm_msg_q_msg_t msg;
+ svm_msg_q_t *mq = em->rpc_msq_queue;
+
while (em->state < STATE_DATA_DONE && !em->time_to_stop)
{
- if (svm_msg_q_sub (em->rpc_msq_queue, &msg, SVM_Q_TIMEDWAIT, 1))
- continue;
- rpc = svm_msg_q_msg_data (em->rpc_msq_queue, &msg);
+ 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);
+ rpc = svm_msg_q_msg_data (mq, &msg);
+ svm_msg_q_unlock (mq);
((echo_rpc_t) rpc->fp) (rpc->arg, rpc->opaque);
- svm_msg_q_free_msg (em->rpc_msq_queue, &msg);
+ svm_msg_q_free_msg (mq, &msg);
}
}
+static inline int
+echo_mq_dequeue_batch (svm_msg_q_t * mq, svm_msg_q_msg_t * msg_vec,
+ u32 n_max_msg)
+{
+ svm_msg_q_msg_t *msg;
+ u32 n_msgs;
+ int i;
+
+ n_msgs = clib_min (svm_msg_q_size (mq), n_max_msg);
+ for (i = 0; i < n_msgs; i++)
+ {
+ vec_add2 (msg_vec, msg, 1);
+ svm_msg_q_sub_w_lock (mq, msg);
+ }
+ return n_msgs;
+}
+
static void *
echo_mq_thread_fn (void *arg)
{
- clib_mem_set_thread_index ();
+ clib_mem_set_thread_index (); /* First thing to do in client thread */
+ svm_msg_q_msg_t *msg_vec = 0;
echo_main_t *em = &echo_main;
session_event_t *e;
- svm_msg_q_msg_t msg;
- int rv;
+ svm_msg_q_msg_t *msg;
+ svm_msg_q_t *mq;
+ int i;
+
+ vec_validate (msg_vec, em->evt_q_size);
+ vec_reset_length (msg_vec);
wait_for_state_change (em, STATE_ATTACHED, 0);
- if (em->state < STATE_ATTACHED || !em->our_event_queue)
+ mq = em->app_mq;
+ if (em->state < STATE_ATTACHED || !mq)
{
- ECHO_FAIL ("Application failed to attach");
+ ECHO_FAIL (ECHO_FAIL_APP_ATTACH, "Application failed to attach");
pthread_exit (0);
}
- while (1)
+ while (em->state < STATE_DETACHED && !em->time_to_stop)
{
- if (!(rv = svm_msg_q_sub (em->our_event_queue,
- &msg, SVM_Q_TIMEDWAIT, 1)))
+ svm_msg_q_lock (mq);
+ if (svm_msg_q_is_empty (mq) && svm_msg_q_timedwait (mq, 1))
{
- e = svm_msg_q_msg_data (em->our_event_queue, &msg);
+ svm_msg_q_unlock (mq);
+ continue;
+ }
+ echo_mq_dequeue_batch (mq, msg_vec, ~0);
+ svm_msg_q_unlock (mq);
+
+ for (i = 0; i < vec_len (msg_vec); i++)
+ {
+ msg = vec_elt_at_index (msg_vec, i);
+ e = svm_msg_q_msg_data (mq, msg);
handle_mq_event (e);
- svm_msg_q_free_msg (em->our_event_queue, &msg);
+ svm_msg_q_free_msg (mq, msg); /* No lock, single thread dequeuing */
}
- if (rv == ETIMEDOUT
- && (em->time_to_stop || em->state == STATE_DETACHED))
- break;
+ vec_reset_length (msg_vec);
}
+ vec_free (msg_vec);
pthread_exit (0);
}
u64 i;
echo_notify_event (em, ECHO_EVT_FIRST_QCONNECT);
for (i = 0; i < em->n_connects; i++)
- echo_send_connect (em->uri, SESSION_INVALID_INDEX);
+ echo_send_connect (SESSION_INVALID_HANDLE, SESSION_INVALID_INDEX);
wait_for_state_change (em, STATE_READY, 0);
ECHO_LOG (1, "App is ready");
echo_process_rpcs (em);
static void
server_run (echo_main_t * em)
{
+ echo_session_t *ls;
echo_send_listen (em);
wait_for_state_change (em, STATE_READY, 0);
ECHO_LOG (1, "App is ready");
echo_process_rpcs (em);
/* Cleanup */
- echo_send_unbind (em);
+ ls = pool_elt_at_index (em->sessions, em->listen_session_index);
+ echo_send_unbind (em, ls);
if (wait_for_state_change (em, STATE_DISCONNECTED, TIMEOUT))
{
- ECHO_FAIL ("Timeout waiting for state disconnected");
+ ECHO_FAIL (ECHO_FAIL_SERVER_DISCONNECT_TIMEOUT,
+ "Timeout waiting for state disconnected");
return;
}
}
" use-svm-api Use SVM API to connect to VPP\n"
" test-bytes[:assert] Check data correctness when receiving (assert fails on first error)\n"
" fifo-size N Use N Kb fifos\n"
- " rx-buf N Use N Kb RX buffer\n"
- " tx-buf N Use N Kb TX test buffer\n"
+ " mq-size N Use N event slots for vpp_echo <-> vpp events\n"
+ " rx-buf N[Kb|Mb|GB] Use N[Kb|Mb|GB] RX buffer\n"
+ " tx-buf N[Kb|Mb|GB] Use N[Kb|Mb|GB] TX test buffer\n"
" appns NAMESPACE Use the namespace NAMESPACE\n"
" all-scope all-scope option\n"
" local-scope local-scope option\n"
em->use_sock_api = 0;
else if (unformat (a, "fifo-size %d", &tmp))
em->fifo_size = tmp << 10;
- else if (unformat (a, "rx-buf %d", &tmp))
- em->rx_buf_size = tmp << 10;
- else if (unformat (a, "tx-buf %d", &tmp))
- em->rx_buf_size = tmp << 10;
+ else if (unformat (a, "prealloc-fifos %u", &em->prealloc_fifo_pairs))
+ ;
+ else if (unformat (a, "rx-buf %U", unformat_data, &em->rx_buf_size))
+ ;
+ else if (unformat (a, "tx-buf %U", unformat_data, &em->tx_buf_size))
+ ;
+ else if (unformat (a, "mq-size %d", &em->evt_q_size))
+ ;
else if (unformat (a, "nclients %d", &em->n_clients))
{
em->n_sessions = em->n_clients + 1;
}
else if (unformat (a, "nthreads %d", &em->n_rx_threads))
;
+ else
+ if (unformat
+ (a, "crypto %U", echo_unformat_crypto_engine,
+ &em->crypto_ctx_engine))
+ ;
else if (unformat (a, "appns %_%v%_", &em->appns_id))
;
else if (unformat (a, "all-scope"))
&em->uri_elts.ip.ip6, &port))
em->uri_elts.is_ip4 = 0;
else
- ECHO_FAIL ("Unable to process uri");
+ ECHO_FAIL (ECHO_FAIL_INVALID_URI, "Unable to process uri");
em->uri_elts.port = clib_host_to_net_u16 (port);
unformat_free (input);
}
em->socket_name = format (0, "%s%c", API_SOCKET_FILE, 0);
em->use_sock_api = 1;
em->fifo_size = 64 << 10;
+ em->prealloc_fifo_pairs = 16;
em->n_clients = 1;
em->n_connects = 1;
em->n_sessions = 2;
em->time_to_stop = 0;
em->i_am_master = 1;
em->n_rx_threads = 4;
+ em->evt_q_size = 256;
em->test_return_packets = RETURN_PACKETS_NOTEST;
em->timing.start_event = ECHO_EVT_FIRST_QCONNECT;
em->timing.end_event = ECHO_EVT_LAST_BYTE;
em->tx_buf_size = 1 << 20;
em->data_source = ECHO_INVALID_DATA_SOURCE;
em->uri = format (0, "%s%c", "tcp://0.0.0.0/1234", 0);
+ em->crypto_ctx_engine = TLS_ENGINE_NONE;
echo_set_each_proto_defaults_before_opts (em);
echo_process_opts (argc, argv);
echo_process_uri (em);
em->proto_cb_vft = em->available_proto_cb_vft[em->uri_elts.transport_proto];
if (!em->proto_cb_vft)
{
- ECHO_FAIL ("Protocol %U is not supported",
+ ECHO_FAIL (ECHO_FAIL_PROTOCOL_NOT_SUPPORTED,
+ "Protocol %U is not supported",
format_transport_proto, em->uri_elts.transport_proto);
- exit (1);
+ goto exit_on_error;
}
if (em->proto_cb_vft->set_defaults_after_opts_cb)
em->proto_cb_vft->set_defaults_after_opts_cb ();
if (connect_to_vpp (app_name))
{
svm_region_exit ();
- ECHO_FAIL ("Couldn't connect to vpe, exiting...\n");
- exit (1);
+ ECHO_FAIL (ECHO_FAIL_CONNECT_TO_VPP, "Couldn't connect to vpp");
+ goto exit_on_error;
}
echo_session_prealloc (em);
echo_notify_event (em, ECHO_EVT_START);
echo_send_attach (em);
- if (wait_for_state_change (em, STATE_ATTACHED, TIMEOUT))
+ 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 (em->crypto_ctx_engine == TLS_ENGINE_NONE)
+ /* when no crypto engine specified, dont expect crypto ctx */
+ em->state = STATE_ATTACHED;
+ else
{
- ECHO_FAIL ("Couldn't attach to vpp, did you run <session enable> ?\n");
- exit (1);
+ ECHO_LOG (1, "Adding crypto context %U", echo_format_crypto_engine,
+ em->crypto_ctx_engine);
+ echo_send_add_crypto_ctx (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);
+ }
}
+
if (pthread_create (&em->mq_thread_handle,
NULL /*attr */ , echo_mq_thread_fn, 0))
{
- ECHO_FAIL ("pthread create errored\n");
- exit (1);
+ ECHO_FAIL (ECHO_FAIL_PTHREAD_CREATE, "pthread create errored");
+ goto exit_on_error;
}
+
for (i = 0; i < em->n_rx_threads; i++)
if (pthread_create (&em->data_thread_handles[i],
NULL /*attr */ , echo_data_thread_fn, (void *) i))
{
- ECHO_FAIL ("pthread create errored\n");
- exit (1);
+ ECHO_FAIL (ECHO_FAIL_PTHREAD_CREATE,
+ "pthread create errored (index %d)", i);
+ goto exit_on_error;
}
if (em->i_am_master)
server_run (em);
else
clients_run (em);
echo_notify_event (em, ECHO_EVT_EXIT);
- if (em->output_json)
- print_global_json_stats (em);
- else
- print_global_stats (em);
echo_free_sessions (em);
echo_assert_test_suceeded (em);
echo_send_detach (em);
if (wait_for_state_change (em, STATE_DETACHED, TIMEOUT))
{
- ECHO_FAIL ("ECHO-ERROR: Couldn't detach from vpp, exiting...\n");
- exit (1);
+ ECHO_FAIL (ECHO_FAIL_DETACH, "Couldn't detach from vpp");
+ goto exit_on_error;
}
int *rv;
pthread_join (em->mq_thread_handle, (void **) &rv);
if (rv)
{
- ECHO_FAIL ("mq pthread errored %d", rv);
- exit (1);
+ 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 ();
+exit_on_error:
ECHO_LOG (0, "Test complete !\n");
+ if (em->output_json)
+ print_global_json_stats (em);
+ else
+ print_global_stats (em);
+ vec_free (em->fail_descr);
exit (em->has_failed);
}