2 * echo_client.c - vpp built-in echo client code
4 * Copyright (c) 2017-2019 by Cisco and/or its affiliates.
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at:
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
18 #include <hs_apps/echo_client.h>
20 static ec_main_t ec_main;
23 #define DBG(_fmt, _args...) \
25 clib_warning (_fmt, ##_args)
28 signal_evt_to_cli_i (void *codep)
30 ec_main_t *ecm = &ec_main;
33 ASSERT (vlib_get_thread_index () == 0);
34 code = pointer_to_uword (codep);
35 vlib_process_signal_event (ecm->vlib_main, ecm->cli_node_index, code, 0);
39 signal_evt_to_cli (int code)
41 if (vlib_get_thread_index () != 0)
42 session_send_rpc_evt_to_thread_force (
43 0, signal_evt_to_cli_i, uword_to_pointer ((uword) code, void *));
45 signal_evt_to_cli_i (uword_to_pointer ((uword) code, void *));
48 static inline ec_worker_t *
49 ec_worker_get (u32 thread_index)
51 return vec_elt_at_index (ec_main.wrk, thread_index);
54 static inline ec_session_t *
55 ec_session_alloc (ec_worker_t *wrk)
59 pool_get_zero (wrk->sessions, ecs);
60 ecs->data.session_index = ecs - wrk->sessions;
61 ecs->thread_index = wrk->thread_index;
66 static inline ec_session_t *
67 ec_session_get (ec_worker_t *wrk, u32 ec_index)
69 return pool_elt_at_index (wrk->sessions, ec_index);
73 send_data_chunk (ec_main_t *ecm, ec_session_t *es)
75 u8 *test_data = ecm->connect_test_data;
76 int test_buf_len, test_buf_offset, rv;
79 test_buf_len = vec_len (test_data);
80 ASSERT (test_buf_len > 0);
81 test_buf_offset = es->bytes_sent % test_buf_len;
83 clib_min (test_buf_len - test_buf_offset, es->bytes_to_send);
89 svm_fifo_t *f = es->data.tx_fifo;
90 rv = clib_min (svm_fifo_max_enqueue_prod (f), bytes_this_chunk);
91 svm_fifo_enqueue_nocopy (f, rv);
92 session_send_io_evt_to_thread_custom (
93 &es->vpp_session_index, es->thread_index, SESSION_IO_EVT_TX);
96 rv = app_send_stream (&es->data, test_data + test_buf_offset,
101 svm_fifo_t *f = es->data.tx_fifo;
102 u32 max_enqueue = svm_fifo_max_enqueue_prod (f);
104 if (max_enqueue < sizeof (session_dgram_hdr_t))
107 max_enqueue -= sizeof (session_dgram_hdr_t);
111 session_dgram_hdr_t hdr;
112 app_session_transport_t *at = &es->data.transport;
114 rv = clib_min (max_enqueue, bytes_this_chunk);
116 hdr.data_length = rv;
118 clib_memcpy_fast (&hdr.rmt_ip, &at->rmt_ip,
119 sizeof (ip46_address_t));
120 hdr.is_ip4 = at->is_ip4;
121 hdr.rmt_port = at->rmt_port;
122 clib_memcpy_fast (&hdr.lcl_ip, &at->lcl_ip,
123 sizeof (ip46_address_t));
124 hdr.lcl_port = at->lcl_port;
125 svm_fifo_enqueue (f, sizeof (hdr), (u8 *) & hdr);
126 svm_fifo_enqueue_nocopy (f, rv);
127 session_send_io_evt_to_thread_custom (
128 &es->vpp_session_index, es->thread_index, SESSION_IO_EVT_TX);
132 bytes_this_chunk = clib_min (bytes_this_chunk, max_enqueue);
133 bytes_this_chunk = clib_min (bytes_this_chunk, 1460);
134 rv = app_send_dgram (&es->data, test_data + test_buf_offset,
135 bytes_this_chunk, 0);
139 /* If we managed to enqueue data... */
142 /* Account for it... */
143 es->bytes_to_send -= rv;
144 es->bytes_sent += rv;
148 ELOG_TYPE_DECLARE (e) =
150 .format = "tx-enq: xfer %d bytes, sent %u remain %u",
151 .format_args = "i4i4i4",
157 ed = ELOG_DATA (&vlib_global_main.elog_main, e);
159 ed->data[1] = es->bytes_sent;
160 ed->data[2] = es->bytes_to_send;
166 receive_data_chunk (ec_worker_t *wrk, ec_session_t *es)
168 ec_main_t *ecm = &ec_main;
169 svm_fifo_t *rx_fifo = es->data.rx_fifo;
176 app_recv_stream (&es->data, wrk->rx_buf, vec_len (wrk->rx_buf));
179 app_recv_dgram (&es->data, wrk->rx_buf, vec_len (wrk->rx_buf));
183 n_read = svm_fifo_max_dequeue_cons (rx_fifo);
184 svm_fifo_dequeue_drop (rx_fifo, n_read);
191 ELOG_TYPE_DECLARE (e) =
193 .format = "rx-deq: %d bytes",
200 ed = ELOG_DATA (&vlib_global_main.elog_main, e);
201 ed->data[0] = n_read;
206 for (i = 0; i < n_read; i++)
208 if (wrk->rx_buf[i] != ((es->bytes_received + i) & 0xff))
210 clib_warning ("read %d error at byte %lld, 0x%x not 0x%x",
211 n_read, es->bytes_received + i, wrk->rx_buf[i],
212 ((es->bytes_received + i) & 0xff));
213 ecm->test_failed = 1;
217 ASSERT (n_read <= es->bytes_to_receive);
218 es->bytes_to_receive -= n_read;
219 es->bytes_received += n_read;
224 ec_node_fn (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *frame)
226 u32 *conn_indices, *conns_this_batch, nconns_this_batch;
227 int thread_index = vm->thread_index, i, delete_session;
228 ec_main_t *ecm = &ec_main;
233 if (ecm->run_test != EC_RUNNING)
236 wrk = ec_worker_get (thread_index);
237 conn_indices = wrk->conn_indices;
238 conns_this_batch = wrk->conns_this_batch;
240 if (((vec_len (conn_indices) == 0) && vec_len (conns_this_batch) == 0))
243 /* Grab another pile of connections */
244 if (PREDICT_FALSE (vec_len (conns_this_batch) == 0))
247 clib_min (ecm->connections_per_batch, vec_len (conn_indices));
249 ASSERT (nconns_this_batch > 0);
250 vec_validate (conns_this_batch, nconns_this_batch - 1);
251 clib_memcpy_fast (conns_this_batch,
252 conn_indices + vec_len (conn_indices) -
254 nconns_this_batch * sizeof (u32));
255 vec_dec_len (conn_indices, nconns_this_batch);
261 if (PREDICT_FALSE (ecm->prev_conns != ecm->connections_per_batch &&
262 ecm->prev_conns == vec_len (conns_this_batch)))
265 ecm->prev_conns = vec_len (conns_this_batch);
266 if (ecm->repeats == 500000)
268 clib_warning ("stuck clients");
273 ecm->prev_conns = vec_len (conns_this_batch);
278 * Handle connections in this batch
280 for (i = 0; i < vec_len (conns_this_batch); i++)
282 es = ec_session_get (wrk, conns_this_batch[i]);
286 if (es->bytes_to_send > 0)
288 send_data_chunk (ecm, es);
292 if (es->bytes_to_receive > 0)
297 if (PREDICT_FALSE (delete_session == 1))
299 clib_atomic_fetch_add (&ecm->tx_total, es->bytes_sent);
300 clib_atomic_fetch_add (&ecm->rx_total, es->bytes_received);
301 s = session_get_from_handle_if_valid (es->vpp_session_handle);
305 vnet_disconnect_args_t _a, *a = &_a;
306 a->handle = session_handle (s);
307 a->app_index = ecm->app_index;
308 vnet_disconnect_session (a);
310 vec_delete (conns_this_batch, 1, i);
312 clib_atomic_fetch_add (&ecm->ready_connections, -1);
316 clib_warning ("session AWOL?");
317 vec_delete (conns_this_batch, 1, i);
320 /* Kick the debug CLI process */
321 if (ecm->ready_connections == 0)
323 signal_evt_to_cli (EC_CLI_TEST_DONE);
328 wrk->conn_indices = conn_indices;
329 wrk->conns_this_batch = conns_this_batch;
333 VLIB_REGISTER_NODE (echo_clients_node) = {
334 .function = ec_node_fn,
335 .name = "echo-clients",
336 .type = VLIB_NODE_TYPE_INPUT,
337 .state = VLIB_NODE_STATE_DISABLED,
341 ec_reset_runtime_config (ec_main_t *ecm)
344 ecm->quic_streams = 1;
345 ecm->bytes_to_send = 8192;
347 ecm->fifo_size = 64 << 10;
348 ecm->connections_per_batch = 1000;
349 ecm->private_segment_count = 0;
350 ecm->private_segment_size = 256 << 20;
353 ecm->test_failed = 0;
354 ecm->tls_engine = CRYPTO_ENGINE_OPENSSL;
356 ecm->run_test = EC_STARTING;
357 ecm->ready_connections = 0;
358 ecm->connect_conn_index = 0;
361 ecm->barrier_acq_needed = 0;
362 ecm->prealloc_sessions = 0;
363 ecm->prealloc_fifos = 0;
365 ecm->appns_secret = 0;
366 ecm->attach_flags = 0;
367 ecm->syn_timeout = 20.0;
368 ecm->test_timeout = 20.0;
369 vec_free (ecm->connect_uri);
373 ec_init (vlib_main_t *vm)
375 ec_main_t *ecm = &ec_main;
376 vlib_thread_main_t *vtm = vlib_get_thread_main ();
381 ec_reset_runtime_config (ecm);
383 /* Store cli process node index for signaling */
384 ecm->cli_node_index = vlib_get_current_process (vm)->node_runtime.node_index;
387 if (vlib_num_workers ())
389 /* The request came over the binary api and the inband cli handler
390 * is not mp_safe. Drop the barrier to make sure the workers are not
393 if (vlib_thread_is_main_w_barrier ())
395 ecm->barrier_acq_needed = 1;
396 vlib_worker_thread_barrier_release (vm);
399 * There's a good chance that both the client and the server echo
400 * apps will be enabled so make sure the session queue node polls on
401 * the main thread as connections will probably be established on it.
403 vlib_node_set_state (vm, session_queue_node.index,
404 VLIB_NODE_STATE_POLLING);
407 /* App init done only once */
408 if (ecm->app_is_init)
412 /* Init test data. Big buffer */
413 vec_validate (ecm->connect_test_data, 4 * 1024 * 1024 - 1);
414 for (i = 0; i < vec_len (ecm->connect_test_data); i++)
415 ecm->connect_test_data[i] = i & 0xff;
417 num_threads = 1 /* main thread */ + vtm->n_threads;
418 vec_validate (ecm->wrk, num_threads);
419 vec_foreach (wrk, ecm->wrk)
421 vec_validate (wrk->rx_buf, vec_len (ecm->connect_test_data) - 1);
422 wrk->thread_index = wrk - ecm->wrk;
423 wrk->vpp_event_queue =
424 session_main_get_vpp_event_queue (wrk->thread_index);
427 ecm->app_is_init = 1;
429 vlib_worker_thread_barrier_sync (vm);
430 vnet_session_enable_disable (vm, 1 /* turn on session and transports */);
431 vlib_worker_thread_barrier_release (vm);
433 /* Turn on the builtin client input nodes */
434 for (i = 0; i < vtm->n_vlib_mains; i++)
435 vlib_node_set_state (vlib_get_main_by_index (i), echo_clients_node.index,
436 VLIB_NODE_STATE_POLLING);
442 ec_prealloc_sessions (ec_main_t *ecm)
444 u32 sessions_per_wrk, n_wrks;
447 n_wrks = vlib_num_workers () ? vlib_num_workers () : 1;
449 sessions_per_wrk = ecm->n_clients / n_wrks;
450 vec_foreach (wrk, ecm->wrk)
451 pool_init_fixed (wrk->sessions, 1.1 * sessions_per_wrk);
455 ec_worker_cleanup (ec_worker_t *wrk)
457 pool_free (wrk->sessions);
458 vec_free (wrk->conn_indices);
459 vec_free (wrk->conns_this_batch);
463 ec_cleanup (ec_main_t *ecm)
467 vec_foreach (wrk, ecm->wrk)
468 ec_worker_cleanup (wrk);
470 vec_free (ecm->connect_uri);
471 vec_free (ecm->appns_id);
473 if (ecm->barrier_acq_needed)
474 vlib_worker_thread_barrier_sync (ecm->vlib_main);
478 quic_ec_qsession_connected_callback (u32 app_index, u32 api_context,
479 session_t *s, session_error_t err)
481 session_endpoint_cfg_t sep = SESSION_ENDPOINT_CFG_NULL;
482 ec_main_t *ecm = &ec_main;
483 vnet_connect_args_t *a = 0;
484 session_handle_t handle;
488 DBG ("QUIC Connection handle %d", session_handle (s));
491 a->uri = (char *) ecm->connect_uri;
492 if (parse_uri (a->uri, &sep))
494 sep.parent_handle = handle = session_handle (s);
496 for (stream_n = 0; stream_n < ecm->quic_streams; stream_n++)
498 clib_memset (a, 0, sizeof (*a));
499 a->app_index = ecm->app_index;
500 a->api_context = -1 - api_context;
501 clib_memcpy (&a->sep_ext, &sep, sizeof (sep));
503 DBG ("QUIC opening stream %d", stream_n);
504 if ((rv = vnet_connect (a)))
506 clib_error ("Stream session %d opening failed: %d", stream_n, rv);
509 DBG ("QUIC stream %d connected", stream_n);
512 * 's' is no longer valid, its underlying pool could have been moved in
520 quic_ec_session_connected_callback (u32 app_index, u32 api_context,
521 session_t *s, session_error_t err)
523 ec_main_t *ecm = &ec_main;
528 if (PREDICT_FALSE (ecm->run_test != EC_STARTING))
533 clib_warning ("connection %d failed!", api_context);
534 ecm->run_test = EC_EXITING;
535 signal_evt_to_cli (EC_CLI_CONNECTS_FAILED);
539 if (s->listener_handle == SESSION_INVALID_HANDLE)
540 return quic_ec_qsession_connected_callback (app_index, api_context, s,
542 DBG ("STREAM Connection callback %d", api_context);
544 thread_index = s->thread_index;
545 ASSERT (thread_index == vlib_get_thread_index ()
546 || session_transport_service_type (s) == TRANSPORT_SERVICE_CL);
548 wrk = ec_worker_get (thread_index);
553 es = ec_session_alloc (wrk);
555 es->bytes_to_send = ecm->bytes_to_send;
556 es->bytes_to_receive = ecm->no_return ? 0ULL : ecm->bytes_to_send;
557 es->data.rx_fifo = s->rx_fifo;
558 es->data.rx_fifo->shr->client_session_index = es->data.session_index;
559 es->data.tx_fifo = s->tx_fifo;
560 es->data.tx_fifo->shr->client_session_index = es->data.session_index;
561 es->data.vpp_evt_q = wrk->vpp_event_queue;
562 es->vpp_session_handle = session_handle (s);
563 es->vpp_session_index = s->session_index;
564 s->opaque = es->data.session_index;
568 transport_connection_t *tc;
569 tc = session_get_transport (s);
570 clib_memcpy_fast (&es->data.transport, tc, sizeof (es->data.transport));
571 es->data.is_dgram = 1;
574 vec_add1 (wrk->conn_indices, es->data.session_index);
575 clib_atomic_fetch_add (&ecm->ready_connections, 1);
576 if (ecm->ready_connections == ecm->expected_connections)
578 ecm->run_test = EC_RUNNING;
579 /* Signal the CLI process that the action is starting... */
580 signal_evt_to_cli (EC_CLI_CONNECTS_DONE);
587 ec_session_connected_callback (u32 app_index, u32 api_context, session_t *s,
590 ec_main_t *ecm = &ec_main;
595 if (PREDICT_FALSE (ecm->run_test != EC_STARTING))
600 clib_warning ("connection %d failed!", api_context);
601 ecm->run_test = EC_EXITING;
602 signal_evt_to_cli (EC_CLI_CONNECTS_FAILED);
606 thread_index = s->thread_index;
607 ASSERT (thread_index == vlib_get_thread_index ()
608 || session_transport_service_type (s) == TRANSPORT_SERVICE_CL);
610 wrk = ec_worker_get (thread_index);
615 es = ec_session_alloc (wrk);
617 es->bytes_to_send = ecm->bytes_to_send;
618 es->bytes_to_receive = ecm->no_return ? 0ULL : ecm->bytes_to_send;
619 es->data.rx_fifo = s->rx_fifo;
620 es->data.rx_fifo->shr->client_session_index = es->data.session_index;
621 es->data.tx_fifo = s->tx_fifo;
622 es->data.tx_fifo->shr->client_session_index = es->data.session_index;
623 es->data.vpp_evt_q = wrk->vpp_event_queue;
624 es->vpp_session_handle = session_handle (s);
625 es->vpp_session_index = s->session_index;
626 s->opaque = es->data.session_index;
630 transport_connection_t *tc;
631 tc = session_get_transport (s);
632 clib_memcpy_fast (&es->data.transport, tc, sizeof (es->data.transport));
633 es->data.is_dgram = 1;
636 vec_add1 (wrk->conn_indices, es->data.session_index);
637 clib_atomic_fetch_add (&ecm->ready_connections, 1);
638 if (ecm->ready_connections == ecm->expected_connections)
640 ecm->run_test = EC_RUNNING;
641 /* Signal the CLI process that the action is starting... */
642 signal_evt_to_cli (EC_CLI_CONNECTS_DONE);
649 ec_session_reset_callback (session_t *s)
651 ec_main_t *ecm = &ec_main;
652 vnet_disconnect_args_t _a = { 0 }, *a = &_a;
654 if (s->session_state == SESSION_STATE_READY)
655 clib_warning ("Reset active connection %U", format_session, s, 2);
657 a->handle = session_handle (s);
658 a->app_index = ecm->app_index;
659 vnet_disconnect_session (a);
664 ec_session_accept_callback (session_t *s)
670 ec_session_disconnect_callback (session_t *s)
672 ec_main_t *ecm = &ec_main;
673 vnet_disconnect_args_t _a = { 0 }, *a = &_a;
674 a->handle = session_handle (s);
675 a->app_index = ecm->app_index;
676 vnet_disconnect_session (a);
681 ec_session_disconnect (session_t *s)
683 ec_main_t *ecm = &ec_main;
684 vnet_disconnect_args_t _a = { 0 }, *a = &_a;
685 a->handle = session_handle (s);
686 a->app_index = ecm->app_index;
687 vnet_disconnect_session (a);
691 ec_session_rx_callback (session_t *s)
693 ec_main_t *ecm = &ec_main;
697 if (PREDICT_FALSE (ecm->run_test != EC_RUNNING))
699 ec_session_disconnect (s);
703 wrk = ec_worker_get (s->thread_index);
704 es = ec_session_get (wrk, s->opaque);
706 receive_data_chunk (wrk, es);
708 if (svm_fifo_max_dequeue_cons (s->rx_fifo))
710 if (svm_fifo_set_event (s->rx_fifo))
711 session_send_io_evt_to_thread (s->rx_fifo, SESSION_IO_EVT_BUILTIN_RX);
717 ec_add_segment_callback (u32 app_index, u64 segment_handle)
719 /* New segments may be added */
724 ec_del_segment_callback (u32 app_index, u64 segment_handle)
729 static session_cb_vft_t ec_cb_vft = {
730 .session_reset_callback = ec_session_reset_callback,
731 .session_connected_callback = ec_session_connected_callback,
732 .session_accept_callback = ec_session_accept_callback,
733 .session_disconnect_callback = ec_session_disconnect_callback,
734 .builtin_app_rx_callback = ec_session_rx_callback,
735 .add_segment_callback = ec_add_segment_callback,
736 .del_segment_callback = ec_del_segment_callback,
739 static clib_error_t *
742 vnet_app_add_cert_key_pair_args_t _ck_pair, *ck_pair = &_ck_pair;
743 ec_main_t *ecm = &ec_main;
744 vnet_app_attach_args_t _a, *a = &_a;
749 clib_memset (a, 0, sizeof (*a));
750 clib_memset (options, 0, sizeof (options));
752 a->api_client_index = ~0;
753 a->name = format (0, "echo_client");
754 if (ecm->transport_proto == TRANSPORT_PROTO_QUIC)
755 ec_cb_vft.session_connected_callback = quic_ec_session_connected_callback;
756 a->session_cb_vft = &ec_cb_vft;
758 prealloc_fifos = ecm->prealloc_fifos ? ecm->expected_connections : 1;
760 options[APP_OPTIONS_ACCEPT_COOKIE] = 0x12345678;
761 options[APP_OPTIONS_SEGMENT_SIZE] = ecm->private_segment_size;
762 options[APP_OPTIONS_ADD_SEGMENT_SIZE] = ecm->private_segment_size;
763 options[APP_OPTIONS_RX_FIFO_SIZE] = ecm->fifo_size;
764 options[APP_OPTIONS_TX_FIFO_SIZE] = ecm->fifo_size;
765 options[APP_OPTIONS_PRIVATE_SEGMENT_COUNT] = ecm->private_segment_count;
766 options[APP_OPTIONS_PREALLOC_FIFO_PAIRS] = prealloc_fifos;
767 options[APP_OPTIONS_FLAGS] = APP_OPTIONS_FLAGS_IS_BUILTIN;
768 options[APP_OPTIONS_TLS_ENGINE] = ecm->tls_engine;
769 options[APP_OPTIONS_PCT_FIRST_ALLOC] = 100;
770 options[APP_OPTIONS_FLAGS] |= ecm->attach_flags;
773 options[APP_OPTIONS_NAMESPACE_SECRET] = ecm->appns_secret;
774 a->namespace_id = ecm->appns_id;
776 a->options = options;
778 if ((rv = vnet_application_attach (a)))
779 return clib_error_return (0, "attach returned %d", rv);
781 ecm->app_index = a->app_index;
784 clib_memset (ck_pair, 0, sizeof (*ck_pair));
785 ck_pair->cert = (u8 *) test_srv_crt_rsa;
786 ck_pair->key = (u8 *) test_srv_key_rsa;
787 ck_pair->cert_len = test_srv_crt_rsa_len;
788 ck_pair->key_len = test_srv_key_rsa_len;
789 vnet_app_add_cert_key_pair (ck_pair);
790 ecm->ckpair_index = ck_pair->index;
792 ecm->test_client_attached = 1;
800 ec_main_t *ecm = &ec_main;
801 vnet_app_detach_args_t _da, *da = &_da;
804 if (!ecm->test_client_attached)
807 da->app_index = ecm->app_index;
808 da->api_client_index = ~0;
809 rv = vnet_application_detach (da);
810 ecm->test_client_attached = 0;
812 vnet_app_del_cert_key_pair (ecm->ckpair_index);
818 ec_transport_needs_crypto (transport_proto_t proto)
820 return proto == TRANSPORT_PROTO_TLS || proto == TRANSPORT_PROTO_DTLS ||
821 proto == TRANSPORT_PROTO_QUIC;
825 ec_connect_rpc (void *args)
827 ec_main_t *ecm = &ec_main;
828 vnet_connect_args_t _a = {}, *a = &_a;
829 vlib_main_t *vm = vlib_get_main ();
830 int rv, needs_crypto;
833 n_clients = ecm->n_clients;
834 needs_crypto = ec_transport_needs_crypto (ecm->transport_proto);
835 clib_memcpy (&a->sep_ext, &ecm->connect_sep, sizeof (ecm->connect_sep));
836 a->sep_ext.transport_flags |= TRANSPORT_CFG_F_CONNECTED;
837 a->app_index = ecm->app_index;
839 ci = ecm->connect_conn_index;
841 vlib_worker_thread_barrier_sync (vm);
843 while (ci < n_clients)
845 /* Crude pacing for call setups */
846 if (ci - ecm->ready_connections > 128)
848 ecm->connect_conn_index = ci;
855 session_endpoint_alloc_ext_cfg (&a->sep_ext,
856 TRANSPORT_ENDPT_EXT_CFG_CRYPTO);
857 a->sep_ext.ext_cfg->crypto.ckpair_index = ecm->ckpair_index;
860 rv = vnet_connect (a);
863 clib_mem_free (a->sep_ext.ext_cfg);
867 clib_warning ("connect returned: %U", format_session_error, rv);
868 ecm->run_test = EC_EXITING;
869 signal_evt_to_cli (EC_CLI_CONNECTS_FAILED);
876 vlib_worker_thread_barrier_release (vm);
878 if (ci < ecm->expected_connections && ecm->run_test != EC_EXITING)
879 ec_program_connects ();
885 ec_program_connects (void)
887 session_send_rpc_evt_to_thread_force (0, ec_connect_rpc, 0);
890 #define ec_cli(_fmt, _args...) \
891 if (!ecm->no_output) \
892 vlib_cli_output (vm, _fmt, ##_args)
894 static clib_error_t *
895 ec_command_fn (vlib_main_t *vm, unformat_input_t *input,
896 vlib_cli_command_t *cmd)
898 unformat_input_t _line_input, *line_input = &_line_input;
899 char *default_uri = "tcp://6.0.1.1/1234", *transfer_type;
900 ec_main_t *ecm = &ec_main;
901 uword *event_data = 0, event_type;
902 clib_error_t *error = 0;
903 int rv, had_config = 1;
904 u64 tmp, total_bytes;
907 if (ecm->test_client_attached)
908 return clib_error_return (0, "failed: already running!");
912 error = clib_error_return (0, "failed init");
916 if (!unformat_user (input, unformat_line_input, line_input))
922 while (unformat_check_input (line_input) != UNFORMAT_END_OF_INPUT)
924 if (unformat (line_input, "uri %s", &ecm->connect_uri))
926 else if (unformat (line_input, "nclients %d", &ecm->n_clients))
928 else if (unformat (line_input, "quic-streams %d", &ecm->quic_streams))
930 else if (unformat (line_input, "mbytes %lld", &tmp))
931 ecm->bytes_to_send = tmp << 20;
932 else if (unformat (line_input, "gbytes %lld", &tmp))
933 ecm->bytes_to_send = tmp << 30;
934 else if (unformat (line_input, "bytes %U", unformat_memory_size,
935 &ecm->bytes_to_send))
937 else if (unformat (line_input, "test-timeout %f", &ecm->test_timeout))
939 else if (unformat (line_input, "syn-timeout %f", &ecm->syn_timeout))
941 else if (unformat (line_input, "no-return"))
943 else if (unformat (line_input, "fifo-size %d", &ecm->fifo_size))
944 ecm->fifo_size <<= 10;
945 else if (unformat (line_input, "private-segment-count %d",
946 &ecm->private_segment_count))
948 else if (unformat (line_input, "private-segment-size %U",
949 unformat_memory_size, &ecm->private_segment_size))
951 else if (unformat (line_input, "preallocate-fifos"))
952 ecm->prealloc_fifos = 1;
953 else if (unformat (line_input, "preallocate-sessions"))
954 ecm->prealloc_sessions = 1;
955 else if (unformat (line_input, "client-batch %d",
956 &ecm->connections_per_batch))
958 else if (unformat (line_input, "appns %_%v%_", &ecm->appns_id))
960 else if (unformat (line_input, "all-scope"))
961 ecm->attach_flags |= (APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE |
962 APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE);
963 else if (unformat (line_input, "local-scope"))
964 ecm->attach_flags = APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
965 else if (unformat (line_input, "global-scope"))
966 ecm->attach_flags = APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
967 else if (unformat (line_input, "secret %lu", &ecm->appns_secret))
969 else if (unformat (line_input, "no-output"))
971 else if (unformat (line_input, "test-bytes"))
973 else if (unformat (line_input, "tls-engine %d", &ecm->tls_engine))
977 error = clib_error_return (0, "failed: unknown input `%U'",
978 format_unformat_error, line_input);
985 ecm->expected_connections = ecm->n_clients * ecm->quic_streams;
987 if (!ecm->connect_uri)
989 clib_warning ("No uri provided. Using default: %s", default_uri);
990 ecm->connect_uri = format (0, "%s%c", default_uri, 0);
993 if ((rv = parse_uri ((char *) ecm->connect_uri, &ecm->connect_sep)))
995 error = clib_error_return (0, "Uri parse error: %d", rv);
998 ecm->transport_proto = ecm->connect_sep.transport_proto;
999 ecm->is_dgram = (ecm->transport_proto == TRANSPORT_PROTO_UDP);
1001 if (ecm->prealloc_sessions)
1002 ec_prealloc_sessions (ecm);
1004 if ((error = ec_attach ()))
1006 clib_error_report (error);
1011 * Start. Fire off connect requests
1014 ecm->syn_start_time = vlib_time_now (vm);
1015 ec_program_connects ();
1018 * Park until the sessions come up, or syn_timeout seconds pass
1021 vlib_process_wait_for_event_or_clock (vm, ecm->syn_timeout);
1022 event_type = vlib_process_get_events (vm, &event_data);
1026 ec_cli ("Timeout with only %d sessions active...",
1027 ecm->ready_connections);
1028 error = clib_error_return (0, "failed: syn timeout with %d sessions",
1029 ecm->ready_connections);
1032 case EC_CLI_CONNECTS_DONE:
1033 delta = vlib_time_now (vm) - ecm->syn_start_time;
1035 ec_cli ("%d three-way handshakes in %.2f seconds %.2f/s",
1036 ecm->n_clients, delta, ((f64) ecm->n_clients) / delta);
1039 case EC_CLI_CONNECTS_FAILED:
1040 error = clib_error_return (0, "failed: connect returned");
1044 ec_cli ("unexpected event(1): %d", event_type);
1045 error = clib_error_return (0, "failed: unexpected event(1): %d",
1051 * Wait for the sessions to finish or test_timeout seconds pass
1053 ecm->test_start_time = vlib_time_now (ecm->vlib_main);
1054 ec_cli ("Test started at %.6f", ecm->test_start_time);
1055 vlib_process_wait_for_event_or_clock (vm, ecm->test_timeout);
1056 event_type = vlib_process_get_events (vm, &event_data);
1060 ec_cli ("Timeout at %.6f with %d sessions still active...",
1061 vlib_time_now (ecm->vlib_main), ecm->ready_connections);
1062 error = clib_error_return (0, "failed: timeout with %d sessions",
1063 ecm->ready_connections);
1066 case EC_CLI_TEST_DONE:
1067 ecm->test_end_time = vlib_time_now (vm);
1068 ec_cli ("Test finished at %.6f", ecm->test_end_time);
1072 ec_cli ("unexpected event(2): %d", event_type);
1073 error = clib_error_return (0, "failed: unexpected event(2): %d",
1079 * Done. Compute stats
1081 delta = ecm->test_end_time - ecm->test_start_time;
1084 ec_cli ("zero delta-t?");
1085 error = clib_error_return (0, "failed: zero delta-t");
1089 total_bytes = (ecm->no_return ? ecm->tx_total : ecm->rx_total);
1090 transfer_type = ecm->no_return ? "half-duplex" : "full-duplex";
1091 ec_cli ("%lld bytes (%lld mbytes, %lld gbytes) in %.2f seconds", total_bytes,
1092 total_bytes / (1ULL << 20), total_bytes / (1ULL << 30), delta);
1093 ec_cli ("%.2f bytes/second %s", ((f64) total_bytes) / (delta),
1095 ec_cli ("%.4f gbit/second %s", (((f64) total_bytes * 8.0) / delta / 1e9),
1098 if (ecm->test_bytes && ecm->test_failed)
1099 error = clib_error_return (0, "failed: test bytes");
1106 ecm->run_test = EC_EXITING;
1107 vlib_process_wait_for_event_or_clock (vm, 10e-3);
1109 /* Detach the application, so we can use different fifo sizes next time */
1112 error = clib_error_return (0, "failed: app detach");
1113 ec_cli ("WARNING: app detach failed...");
1118 unformat_free (line_input);
1121 ec_cli ("test failed");
1126 VLIB_CLI_COMMAND (ec_command, static) = {
1127 .path = "test echo clients",
1129 "test echo clients [nclients %d][[m|g]bytes <bytes>]"
1130 "[test-timeout <time>][syn-timeout <time>][no-return][fifo-size <size>]"
1131 "[private-segment-count <count>][private-segment-size <bytes>[m|g]]"
1132 "[preallocate-fifos][preallocate-sessions][client-batch <batch-size>]"
1133 "[uri <tcp://ip/port>][test-bytes][no-output]",
1134 .function = ec_command_fn,
1139 ec_main_init (vlib_main_t *vm)
1141 ec_main_t *ecm = &ec_main;
1142 ecm->app_is_init = 0;
1146 VLIB_INIT_FUNCTION (ec_main_init);
1149 * fd.io coding-style-patch-verification: ON
1152 * eval: (c-set-style "gnu")