diff options
Diffstat (limited to 'src/plugins/hs_apps/vcl')
| -rw-r--r-- | src/plugins/hs_apps/vcl/sock_test_client.c | 160 | ||||
| -rw-r--r-- | src/plugins/hs_apps/vcl/sock_test_server.c | 74 | ||||
| -rw-r--r-- | src/plugins/hs_apps/vcl/vcl_test.h | 217 | ||||
| -rw-r--r-- | src/plugins/hs_apps/vcl/vcl_test_client.c | 731 | ||||
| -rw-r--r-- | src/plugins/hs_apps/vcl/vcl_test_protos.c | 109 | ||||
| -rw-r--r-- | src/plugins/hs_apps/vcl/vcl_test_server.c | 103 |
6 files changed, 826 insertions, 568 deletions
diff --git a/src/plugins/hs_apps/vcl/sock_test_client.c b/src/plugins/hs_apps/vcl/sock_test_client.c index 35252da21bc..c8815692184 100644 --- a/src/plugins/hs_apps/vcl/sock_test_client.c +++ b/src/plugins/hs_apps/vcl/sock_test_client.c @@ -46,17 +46,17 @@ sock_test_cfg_sync (vcl_test_session_t * socket) { sock_client_main_t *scm = &sock_client_main; vcl_test_session_t *ctrl = &scm->ctrl_socket; - vcl_test_cfg_t *rl_cfg = (vcl_test_cfg_t *) socket->rxbuf; + hs_test_cfg_t *rl_cfg = (hs_test_cfg_t *) socket->rxbuf; int rx_bytes, tx_bytes; if (socket->cfg.verbose) - vcl_test_cfg_dump (&socket->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&socket->cfg, 1 /* is_client */); ctrl->cfg.seq_num = ++scm->cfg_seq_num; if (socket->cfg.verbose) { stinf ("(fd %d): Sending config sent to server.\n", socket->fd); - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); } tx_bytes = sock_test_write (socket->fd, (uint8_t *) & ctrl->cfg, sizeof (ctrl->cfg), NULL, ctrl->cfg.verbose); @@ -64,21 +64,21 @@ sock_test_cfg_sync (vcl_test_session_t * socket) stabrt ("(fd %d): write test cfg failed (%d)!", socket->fd, tx_bytes); rx_bytes = sock_test_read (socket->fd, (uint8_t *) socket->rxbuf, - sizeof (vcl_test_cfg_t), NULL); + sizeof (hs_test_cfg_t), NULL); if (rx_bytes < 0) return rx_bytes; - if (rl_cfg->magic != VCL_TEST_CFG_CTRL_MAGIC) + if (rl_cfg->magic != HS_TEST_CFG_CTRL_MAGIC) stabrt ("(fd %d): Bad server reply cfg -- aborting!\n", socket->fd); - if ((rx_bytes != sizeof (vcl_test_cfg_t)) - || !vcl_test_cfg_verify (rl_cfg, &ctrl->cfg)) + if ((rx_bytes != sizeof (hs_test_cfg_t)) || + !hs_test_cfg_verify (rl_cfg, &ctrl->cfg)) stabrt ("(fd %d): Invalid config received from server!\n", socket->fd); if (socket->cfg.verbose) { stinf ("(fd %d): Got config back from server.", socket->fd); - vcl_test_cfg_dump (rl_cfg, 1 /* is_client */ ); + hs_test_cfg_dump (rl_cfg, 1 /* is_client */); } ctrl->cfg.ctrl_handle = ((ctrl->cfg.ctrl_handle == ~0) ? rl_cfg->ctrl_handle : ctrl->cfg.ctrl_handle); @@ -263,27 +263,25 @@ echo_test_client (void) vcl_test_stats_dump ("CLIENT RESULTS", &ctrl->stats, 1 /* show_rx */ , 1 /* show tx */ , ctrl->cfg.verbose); - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); if (ctrl->cfg.verbose > 1) { - stinf (" ctrl socket info\n" - VCL_TEST_SEPARATOR_STRING + stinf (" ctrl socket info\n" HS_TEST_SEPARATOR_STRING " fd: %d (0x%08x)\n" " rxbuf: %p\n" " rxbuf size: %u (0x%08x)\n" " txbuf: %p\n" - " txbuf size: %u (0x%08x)\n" - VCL_TEST_SEPARATOR_STRING, - ctrl->fd, (uint32_t) ctrl->fd, - ctrl->rxbuf, ctrl->rxbuf_size, ctrl->rxbuf_size, - ctrl->txbuf, ctrl->txbuf_size, ctrl->txbuf_size); + " txbuf size: %u (0x%08x)\n" HS_TEST_SEPARATOR_STRING, + ctrl->fd, (uint32_t) ctrl->fd, ctrl->rxbuf, ctrl->rxbuf_size, + ctrl->rxbuf_size, ctrl->txbuf, ctrl->txbuf_size, + ctrl->txbuf_size); } } } static void -stream_test_client (vcl_test_t test) +stream_test_client (hs_test_t test) { sock_client_main_t *scm = &sock_client_main; vcl_test_session_t *ctrl = &scm->ctrl_socket; @@ -292,7 +290,7 @@ stream_test_client (vcl_test_t test) uint32_t i, n; fd_set wr_fdset, rd_fdset; fd_set _wfdset, *wfdset = &_wfdset; - fd_set _rfdset, *rfdset = (test == VCL_TEST_TYPE_BI) ? &_rfdset : 0; + fd_set _rfdset, *rfdset = (test == HS_TEST_TYPE_BI) ? &_rfdset : 0; ctrl->cfg.total_bytes = ctrl->cfg.num_writes * ctrl->cfg.txbuf_size; ctrl->cfg.ctrl_handle = ~0; @@ -300,7 +298,7 @@ stream_test_client (vcl_test_t test) stinf ("\n" SOCK_TEST_BANNER_STRING "CLIENT (fd %d): %s-directional Stream Test!\n\n" "CLIENT (fd %d): Sending config to server on ctrl socket...\n", - ctrl->fd, test == VCL_TEST_TYPE_BI ? "Bi" : "Uni", ctrl->fd); + ctrl->fd, test == HS_TEST_TYPE_BI ? "Bi" : "Uni", ctrl->fd); if (sock_test_cfg_sync (ctrl)) stabrt ("test cfg sync failed -- aborting!"); @@ -352,8 +350,7 @@ stream_test_client (vcl_test_t test) (tsock->stats.stop.tv_nsec == 0))) continue; - if ((test == VCL_TEST_TYPE_BI) && - FD_ISSET (tsock->fd, rfdset) && + if ((test == HS_TEST_TYPE_BI) && FD_ISSET (tsock->fd, rfdset) && (tsock->stats.rx_bytes < ctrl->cfg.total_bytes)) { (void) sock_test_read (tsock->fd, @@ -372,9 +369,9 @@ stream_test_client (vcl_test_t test) tsock->fd); } - if (((test == VCL_TEST_TYPE_UNI) && + if (((test == HS_TEST_TYPE_UNI) && (tsock->stats.tx_bytes >= ctrl->cfg.total_bytes)) || - ((test == VCL_TEST_TYPE_BI) && + ((test == HS_TEST_TYPE_BI) && (tsock->stats.rx_bytes >= ctrl->cfg.total_bytes))) { clock_gettime (CLOCK_REALTIME, &tsock->stats.stop); @@ -399,40 +396,39 @@ stream_test_client (vcl_test_t test) snprintf (buf, sizeof (buf), "CLIENT (fd %d) RESULTS", tsock->fd); vcl_test_stats_dump (buf, &tsock->stats, - test == VCL_TEST_TYPE_BI /* show_rx */ , - 1 /* show tx */ , ctrl->cfg.verbose); + test == HS_TEST_TYPE_BI /* show_rx */, + 1 /* show tx */, ctrl->cfg.verbose); } vcl_test_stats_accumulate (&ctrl->stats, &tsock->stats); } vcl_test_stats_dump ("CLIENT RESULTS", &ctrl->stats, - test == VCL_TEST_TYPE_BI /* show_rx */ , - 1 /* show tx */ , ctrl->cfg.verbose); - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + test == HS_TEST_TYPE_BI /* show_rx */, 1 /* show tx */, + ctrl->cfg.verbose); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); if (ctrl->cfg.verbose) { - stinf (" ctrl socket info\n" - VCL_TEST_SEPARATOR_STRING + stinf (" ctrl socket info\n" HS_TEST_SEPARATOR_STRING " fd: %d (0x%08x)\n" " rxbuf: %p\n" " rxbuf size: %u (0x%08x)\n" " txbuf: %p\n" - " txbuf size: %u (0x%08x)\n" - VCL_TEST_SEPARATOR_STRING, - ctrl->fd, (uint32_t) ctrl->fd, - ctrl->rxbuf, ctrl->rxbuf_size, ctrl->rxbuf_size, - ctrl->txbuf, ctrl->txbuf_size, ctrl->txbuf_size); + " txbuf size: %u (0x%08x)\n" HS_TEST_SEPARATOR_STRING, + ctrl->fd, (uint32_t) ctrl->fd, ctrl->rxbuf, ctrl->rxbuf_size, + ctrl->rxbuf_size, ctrl->txbuf, ctrl->txbuf_size, + ctrl->txbuf_size); } - ctrl->cfg.test = VCL_TEST_TYPE_ECHO; + ctrl->cfg.test = HS_TEST_TYPE_ECHO; if (sock_test_cfg_sync (ctrl)) stabrt ("post-test cfg sync failed!"); - stinf ("(fd %d): %s-directional Stream Test Complete!\n" - SOCK_TEST_BANNER_STRING "\n", ctrl->fd, - test == VCL_TEST_TYPE_BI ? "Bi" : "Uni"); + stinf ( + "(fd %d): %s-directional Stream Test Complete!\n" SOCK_TEST_BANNER_STRING + "\n", + ctrl->fd, test == HS_TEST_TYPE_BI ? "Bi" : "Uni"); } static void @@ -448,24 +444,24 @@ exit_client (void) for (i = 0; i < ctrl->cfg.num_test_sessions; i++) { tsock = &scm->test_socket[i]; - tsock->cfg.test = VCL_TEST_TYPE_EXIT; + tsock->cfg.test = HS_TEST_TYPE_EXIT; /* coverity[COPY_PASTE_ERROR] */ if (ctrl->cfg.verbose) { stinf ("\(fd %d): Sending exit cfg to server...\n", tsock->fd); - vcl_test_cfg_dump (&tsock->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&tsock->cfg, 1 /* is_client */); } (void) sock_test_write (tsock->fd, (uint8_t *) & tsock->cfg, sizeof (tsock->cfg), &tsock->stats, ctrl->cfg.verbose); } - ctrl->cfg.test = VCL_TEST_TYPE_EXIT; + ctrl->cfg.test = HS_TEST_TYPE_EXIT; if (ctrl->cfg.verbose) { stinf ("\n(fd %d): Sending exit cfg to server...\n", ctrl->fd); - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); } (void) sock_test_write (ctrl->fd, (uint8_t *) & ctrl->cfg, sizeof (ctrl->cfg), &ctrl->stats, @@ -557,7 +553,7 @@ cfg_txbuf_size_set (void) ctrl->cfg.total_bytes = ctrl->cfg.num_writes * ctrl->cfg.txbuf_size; vcl_test_buf_alloc (&ctrl->cfg, 0 /* is_rxbuf */ , (uint8_t **) & ctrl->txbuf, &ctrl->txbuf_size); - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); } else stabrt ("Invalid txbuf size (%lu) < minimum buf size (%u)!", @@ -576,7 +572,7 @@ cfg_num_writes_set (void) { ctrl->cfg.num_writes = num_writes; ctrl->cfg.total_bytes = ctrl->cfg.num_writes * ctrl->cfg.txbuf_size; - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); } else stabrt ("Invalid num writes: %u", num_writes); @@ -596,7 +592,7 @@ cfg_num_test_sockets_set (void) ctrl->cfg.num_test_sessions = num_test_sockets; sock_test_connect_test_sockets (num_test_sockets); - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); } else stabrt ("Invalid num test sockets: %u, (%d max)\n", num_test_sockets, @@ -616,7 +612,7 @@ cfg_rxbuf_size_set (void) ctrl->cfg.rxbuf_size = rxbuf_size; vcl_test_buf_alloc (&ctrl->cfg, 1 /* is_rxbuf */ , (uint8_t **) & ctrl->rxbuf, &ctrl->rxbuf_size); - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); } else stabrt ("Invalid rxbuf size (%lu) < minimum buf size (%u)!", @@ -630,19 +626,19 @@ cfg_verbose_toggle (void) vcl_test_session_t *ctrl = &scm->ctrl_socket; ctrl->cfg.verbose = ctrl->cfg.verbose ? 0 : 1; - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); } -static vcl_test_t +static hs_test_t parse_input () { sock_client_main_t *scm = &sock_client_main; vcl_test_session_t *ctrl = &scm->ctrl_socket; - vcl_test_t rv = VCL_TEST_TYPE_NONE; + hs_test_t rv = HS_TEST_TYPE_NONE; if (!strncmp (VCL_TEST_TOKEN_EXIT, ctrl->txbuf, strlen (VCL_TEST_TOKEN_EXIT))) - rv = VCL_TEST_TYPE_EXIT; + rv = HS_TEST_TYPE_EXIT; else if (!strncmp (VCL_TEST_TOKEN_HELP, ctrl->txbuf, strlen (VCL_TEST_TOKEN_HELP))) @@ -672,16 +668,16 @@ parse_input () strlen (VCL_TEST_TOKEN_RXBUF_SIZE))) cfg_rxbuf_size_set (); - else if (!strncmp (VCL_TEST_TOKEN_RUN_UNI, ctrl->txbuf, - strlen (VCL_TEST_TOKEN_RUN_UNI))) - rv = ctrl->cfg.test = VCL_TEST_TYPE_UNI; + else if (!strncmp (HS_TEST_TOKEN_RUN_UNI, ctrl->txbuf, + strlen (HS_TEST_TOKEN_RUN_UNI))) + rv = ctrl->cfg.test = HS_TEST_TYPE_UNI; - else if (!strncmp (VCL_TEST_TOKEN_RUN_BI, ctrl->txbuf, - strlen (VCL_TEST_TOKEN_RUN_BI))) - rv = ctrl->cfg.test = VCL_TEST_TYPE_BI; + else if (!strncmp (HS_TEST_TOKEN_RUN_BI, ctrl->txbuf, + strlen (HS_TEST_TOKEN_RUN_BI))) + rv = ctrl->cfg.test = HS_TEST_TYPE_BI; else - rv = VCL_TEST_TYPE_ECHO; + rv = HS_TEST_TYPE_ECHO; return rv; } @@ -713,9 +709,9 @@ main (int argc, char **argv) sock_client_main_t *scm = &sock_client_main; vcl_test_session_t *ctrl = &scm->ctrl_socket; int c, rv; - vcl_test_t post_test = VCL_TEST_TYPE_NONE; + hs_test_t post_test = HS_TEST_TYPE_NONE; - vcl_test_cfg_init (&ctrl->cfg); + hs_test_cfg_init (&ctrl->cfg); vcl_test_session_buf_alloc (ctrl); opterr = 0; @@ -749,7 +745,7 @@ main (int argc, char **argv) break; case 'X': - post_test = VCL_TEST_TYPE_EXIT; + post_test = HS_TEST_TYPE_EXIT; break; case 'E': @@ -760,7 +756,7 @@ main (int argc, char **argv) print_usage_and_exit (); } strncpy (ctrl->txbuf, optarg, ctrl->txbuf_size); - ctrl->cfg.test = VCL_TEST_TYPE_ECHO; + ctrl->cfg.test = HS_TEST_TYPE_ECHO; break; case 'I': @@ -836,11 +832,11 @@ main (int argc, char **argv) break; case 'U': - ctrl->cfg.test = VCL_TEST_TYPE_UNI; + ctrl->cfg.test = HS_TEST_TYPE_UNI; break; case 'B': - ctrl->cfg.test = VCL_TEST_TYPE_BI; + ctrl->cfg.test = HS_TEST_TYPE_BI; break; case 'V': @@ -928,54 +924,54 @@ main (int argc, char **argv) sock_test_connect_test_sockets (ctrl->cfg.num_test_sessions); - while (ctrl->cfg.test != VCL_TEST_TYPE_EXIT) + while (ctrl->cfg.test != HS_TEST_TYPE_EXIT) { if (scm->dump_cfg) { - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); scm->dump_cfg = 0; } switch (ctrl->cfg.test) { - case VCL_TEST_TYPE_ECHO: + case HS_TEST_TYPE_ECHO: echo_test_client (); break; - case VCL_TEST_TYPE_UNI: - case VCL_TEST_TYPE_BI: + case HS_TEST_TYPE_UNI: + case HS_TEST_TYPE_BI: stream_test_client (ctrl->cfg.test); break; - case VCL_TEST_TYPE_EXIT: + case HS_TEST_TYPE_EXIT: continue; - case VCL_TEST_TYPE_NONE: + case HS_TEST_TYPE_NONE: default: break; } switch (post_test) { - case VCL_TEST_TYPE_EXIT: + case HS_TEST_TYPE_EXIT: switch (ctrl->cfg.test) { - case VCL_TEST_TYPE_EXIT: - case VCL_TEST_TYPE_UNI: - case VCL_TEST_TYPE_BI: - case VCL_TEST_TYPE_ECHO: - ctrl->cfg.test = VCL_TEST_TYPE_EXIT; + case HS_TEST_TYPE_EXIT: + case HS_TEST_TYPE_UNI: + case HS_TEST_TYPE_BI: + case HS_TEST_TYPE_ECHO: + ctrl->cfg.test = HS_TEST_TYPE_EXIT; continue; - case VCL_TEST_TYPE_NONE: + case HS_TEST_TYPE_NONE: default: break; } break; - case VCL_TEST_TYPE_NONE: - case VCL_TEST_TYPE_ECHO: - case VCL_TEST_TYPE_UNI: - case VCL_TEST_TYPE_BI: + case HS_TEST_TYPE_NONE: + case HS_TEST_TYPE_ECHO: + case HS_TEST_TYPE_UNI: + case HS_TEST_TYPE_BI: default: break; } diff --git a/src/plugins/hs_apps/vcl/sock_test_server.c b/src/plugins/hs_apps/vcl/sock_test_server.c index d516c1722db..2356a4eadca 100644 --- a/src/plugins/hs_apps/vcl/sock_test_server.c +++ b/src/plugins/hs_apps/vcl/sock_test_server.c @@ -37,7 +37,7 @@ typedef struct int fd; uint8_t *buf; uint32_t buf_size; - vcl_test_cfg_t cfg; + hs_test_cfg_t cfg; vcl_test_stats_t stats; } sock_server_conn_t; @@ -87,7 +87,7 @@ conn_pool_expand (size_t expand_size) { sock_server_conn_t *conn = &conn_pool[i]; memset (conn, 0, sizeof (*conn)); - vcl_test_cfg_init (&conn->cfg); + hs_test_cfg_init (&conn->cfg); vcl_test_buf_alloc (&conn->cfg, 1 /* is_rxbuf */ , &conn->buf, &conn->buf_size); conn->cfg.txbuf_size = conn->cfg.rxbuf_size; @@ -123,7 +123,7 @@ conn_pool_free (sock_server_conn_t * conn) } static inline void -sync_config_and_reply (sock_server_conn_t * conn, vcl_test_cfg_t * rx_cfg) +sync_config_and_reply (sock_server_conn_t *conn, hs_test_cfg_t *rx_cfg) { conn->cfg = *rx_cfg; vcl_test_buf_alloc (&conn->cfg, 1 /* is_rxbuf */ , @@ -133,19 +133,18 @@ sync_config_and_reply (sock_server_conn_t * conn, vcl_test_cfg_t * rx_cfg) if (conn->cfg.verbose) { stinf ("(fd %d): Replying to cfg message!\n", conn->fd); - vcl_test_cfg_dump (&conn->cfg, 0 /* is_client */ ); + hs_test_cfg_dump (&conn->cfg, 0 /* is_client */); } (void) sock_test_write (conn->fd, (uint8_t *) & conn->cfg, sizeof (conn->cfg), NULL, conn->cfg.verbose); } static void -stream_test_server_start_stop (sock_server_conn_t * conn, - vcl_test_cfg_t * rx_cfg) +stream_test_server_start_stop (sock_server_conn_t *conn, hs_test_cfg_t *rx_cfg) { sock_server_main_t *ssm = &sock_server_main; int client_fd = conn->fd; - vcl_test_t test = rx_cfg->test; + hs_test_t test = rx_cfg->test; if (rx_cfg->ctrl_handle == conn->fd) { @@ -166,39 +165,37 @@ stream_test_server_start_stop (sock_server_conn_t * conn, snprintf (buf, sizeof (buf), "SERVER (fd %d) RESULTS", tc->fd); - vcl_test_stats_dump (buf, &tc->stats, 1 /* show_rx */ , - test == VCL_TEST_TYPE_BI - /* show tx */ , + vcl_test_stats_dump (buf, &tc->stats, 1 /* show_rx */, + test == HS_TEST_TYPE_BI + /* show tx */, conn->cfg.verbose); } } } - vcl_test_stats_dump ("SERVER RESULTS", &conn->stats, 1 /* show_rx */ , - (test == VCL_TEST_TYPE_BI) /* show_tx */ , + vcl_test_stats_dump ("SERVER RESULTS", &conn->stats, 1 /* show_rx */, + (test == HS_TEST_TYPE_BI) /* show_tx */, conn->cfg.verbose); - vcl_test_cfg_dump (&conn->cfg, 0 /* is_client */ ); + hs_test_cfg_dump (&conn->cfg, 0 /* is_client */); if (conn->cfg.verbose) { - stinf (" sock server main\n" - VCL_TEST_SEPARATOR_STRING + stinf (" sock server main\n" HS_TEST_SEPARATOR_STRING " buf: %p\n" - " buf size: %u (0x%08x)\n" - VCL_TEST_SEPARATOR_STRING, + " buf size: %u (0x%08x)\n" HS_TEST_SEPARATOR_STRING, conn->buf, conn->buf_size, conn->buf_size); } sync_config_and_reply (conn, rx_cfg); - stinf ("SERVER (fd %d): %s-directional Stream Test Complete!\n" - SOCK_TEST_BANNER_STRING "\n", conn->fd, - test == VCL_TEST_TYPE_BI ? "Bi" : "Uni"); + stinf ("SERVER (fd %d): %s-directional Stream Test " + "Complete!\n" SOCK_TEST_BANNER_STRING "\n", + conn->fd, test == HS_TEST_TYPE_BI ? "Bi" : "Uni"); } else { stinf (SOCK_TEST_BANNER_STRING "SERVER (fd %d): %s-directional Stream Test!\n" " Sending client the test cfg to start streaming data...\n", - client_fd, test == VCL_TEST_TYPE_BI ? "Bi" : "Uni"); + client_fd, test == HS_TEST_TYPE_BI ? "Bi" : "Uni"); rx_cfg->ctrl_handle = (rx_cfg->ctrl_handle == ~0) ? conn->fd : rx_cfg->ctrl_handle; @@ -216,9 +213,9 @@ static inline void stream_test_server (sock_server_conn_t * conn, int rx_bytes) { int client_fd = conn->fd; - vcl_test_t test = conn->cfg.test; + hs_test_t test = conn->cfg.test; - if (test == VCL_TEST_TYPE_BI) + if (test == HS_TEST_TYPE_BI) (void) sock_test_write (client_fd, conn->buf, rx_bytes, &conn->stats, conn->cfg.verbose); @@ -373,15 +370,14 @@ sts_server_echo (sock_server_conn_t * conn, int rx_bytes) } static int -sts_handle_cfg (vcl_test_cfg_t * rx_cfg, sock_server_conn_t * conn, - int rx_bytes) +sts_handle_cfg (hs_test_cfg_t *rx_cfg, sock_server_conn_t *conn, int rx_bytes) { sock_server_main_t *ssm = &sock_server_main; if (rx_cfg->verbose) { stinf ("(fd %d): Received a cfg message!\n", conn->fd); - vcl_test_cfg_dump (rx_cfg, 0 /* is_client */ ); + hs_test_cfg_dump (rx_cfg, 0 /* is_client */); } if (rx_bytes != sizeof (*rx_cfg)) @@ -393,7 +389,7 @@ sts_handle_cfg (vcl_test_cfg_t * rx_cfg, sock_server_conn_t * conn, if (conn->cfg.verbose) { stinf ("(fd %d): Replying to cfg message!\n", conn->fd); - vcl_test_cfg_dump (rx_cfg, 0 /* is_client */ ); + hs_test_cfg_dump (rx_cfg, 0 /* is_client */); } sock_test_write (conn->fd, (uint8_t *) & conn->cfg, sizeof (conn->cfg), NULL, conn->cfg.verbose); @@ -402,23 +398,23 @@ sts_handle_cfg (vcl_test_cfg_t * rx_cfg, sock_server_conn_t * conn, switch (rx_cfg->test) { - case VCL_TEST_TYPE_NONE: + case HS_TEST_TYPE_NONE: sync_config_and_reply (conn, rx_cfg); break; - case VCL_TEST_TYPE_ECHO: + case HS_TEST_TYPE_ECHO: if (socket_server_echo_af_unix_init (ssm)) goto done; sync_config_and_reply (conn, rx_cfg); break; - case VCL_TEST_TYPE_BI: - case VCL_TEST_TYPE_UNI: + case HS_TEST_TYPE_BI: + case HS_TEST_TYPE_UNI: stream_test_server_start_stop (conn, rx_cfg); break; - case VCL_TEST_TYPE_EXIT: + case HS_TEST_TYPE_EXIT: stinf ("Have a great day connection %d!", conn->fd); close (conn->fd); conn_pool_free (conn); @@ -428,7 +424,7 @@ sts_handle_cfg (vcl_test_cfg_t * rx_cfg, sock_server_conn_t * conn, default: stinf ("ERROR: Unknown test type!\n"); - vcl_test_cfg_dump (rx_cfg, 0 /* is_client */ ); + hs_test_cfg_dump (rx_cfg, 0 /* is_client */); break; } @@ -439,7 +435,7 @@ done: static int sts_conn_expect_config (sock_server_conn_t * conn) { - if (conn->cfg.test == VCL_TEST_TYPE_ECHO) + if (conn->cfg.test == HS_TEST_TYPE_ECHO) return 1; return (conn->stats.rx_bytes < 128 @@ -452,7 +448,7 @@ main (int argc, char **argv) int client_fd, rv, main_rv = 0, rx_bytes, c, v, i; sock_server_main_t *ssm = &sock_server_main; sock_server_conn_t *conn; - vcl_test_cfg_t *rx_cfg; + hs_test_cfg_t *rx_cfg; struct sockaddr_storage servaddr; uint16_t port = VCL_TEST_SERVER_PORT; uint32_t servaddr_size; @@ -605,8 +601,8 @@ main (int argc, char **argv) if (sts_conn_expect_config (conn)) { - rx_cfg = (vcl_test_cfg_t *) conn->buf; - if (rx_cfg->magic == VCL_TEST_CFG_CTRL_MAGIC) + rx_cfg = (hs_test_cfg_t *) conn->buf; + if (rx_cfg->magic == HS_TEST_CFG_CTRL_MAGIC) { sts_handle_cfg (rx_cfg, conn, rx_bytes); if (!ssm->nfds) @@ -619,8 +615,8 @@ main (int argc, char **argv) } } - if ((conn->cfg.test == VCL_TEST_TYPE_UNI) - || (conn->cfg.test == VCL_TEST_TYPE_BI)) + if ((conn->cfg.test == HS_TEST_TYPE_UNI) || + (conn->cfg.test == HS_TEST_TYPE_BI)) { stream_test_server (conn, rx_bytes); if (ioctl (conn->fd, FIONREAD)) diff --git a/src/plugins/hs_apps/vcl/vcl_test.h b/src/plugins/hs_apps/vcl/vcl_test.h index 4f67e03f72b..0ce27ef84e2 100644 --- a/src/plugins/hs_apps/vcl/vcl_test.h +++ b/src/plugins/hs_apps/vcl/vcl_test.h @@ -16,6 +16,7 @@ #ifndef __vcl_test_h__ #define __vcl_test_h__ +#include <hs_apps/hs_test.h> #include <netdb.h> #include <errno.h> #include <stdlib.h> @@ -46,67 +47,18 @@ #define vt_atomic_add(_ptr, _val) \ __atomic_fetch_add (_ptr, _val, __ATOMIC_RELEASE) -#define VCL_TEST_TOKEN_HELP "#H" -#define VCL_TEST_TOKEN_EXIT "#X" -#define VCL_TEST_TOKEN_VERBOSE "#V" -#define VCL_TEST_TOKEN_TXBUF_SIZE "#T:" -#define VCL_TEST_TOKEN_NUM_TEST_SESS "#I:" -#define VCL_TEST_TOKEN_NUM_WRITES "#N:" -#define VCL_TEST_TOKEN_RXBUF_SIZE "#R:" -#define VCL_TEST_TOKEN_SHOW_CFG "#C" -#define VCL_TEST_TOKEN_RUN_UNI "#U" -#define VCL_TEST_TOKEN_RUN_BI "#B" - #define VCL_TEST_SERVER_PORT 22000 #define VCL_TEST_LOCALHOST_IPADDR "127.0.0.1" -#define VCL_TEST_CFG_CTRL_MAGIC 0xfeedface -#define VCL_TEST_CFG_NUM_WRITES_DEF 1000000 -#define VCL_TEST_CFG_TXBUF_SIZE_DEF 8192 -#define VCL_TEST_CFG_RXBUF_SIZE_DEF (64*VCL_TEST_CFG_TXBUF_SIZE_DEF) #define VCL_TEST_CFG_BUF_SIZE_MIN 128 -#define VCL_TEST_CFG_MAX_TEST_SESS 512 +#define VCL_TEST_CFG_MAX_TEST_SESS ((uint32_t) 1e6) +#define VCL_TEST_CFG_MAX_SELECT_SESS 512 +#define VCL_TEST_CFG_INIT_TEST_SESS 512 #define VCL_TEST_CFG_MAX_EPOLL_EVENTS 16 #define VCL_TEST_CTRL_LISTENER (~0 - 1) #define VCL_TEST_DATA_LISTENER (~0) #define VCL_TEST_DELAY_DISCONNECT 1 -#define VCL_TEST_SEPARATOR_STRING \ - " -----------------------------\n" -typedef enum -{ - VCL_TEST_TYPE_NONE, - VCL_TEST_TYPE_ECHO, - VCL_TEST_TYPE_UNI, - VCL_TEST_TYPE_BI, - VCL_TEST_TYPE_EXIT, -} vcl_test_t; - -typedef enum -{ - VCL_TEST_CMD_SYNC, - VCL_TEST_CMD_START, - VCL_TEST_CMD_STOP, -} vcl_test_cmd_t; - -typedef struct __attribute__ ((packed)) -{ - uint32_t magic; - uint32_t seq_num; - uint32_t test; - uint32_t cmd; - uint32_t ctrl_handle; - uint32_t num_test_sessions; - uint32_t num_test_sessions_perq; - uint32_t num_test_qsessions; - uint32_t verbose; - uint32_t address_ip6; - uint32_t transport_udp; - uint64_t rxbuf_size; - uint64_t txbuf_size; - uint64_t num_writes; - uint64_t total_bytes; -} vcl_test_cfg_t; typedef struct { @@ -124,9 +76,10 @@ typedef struct typedef struct vcl_test_session { - uint8_t is_alloc; - uint8_t is_open; uint8_t is_done; + uint8_t is_alloc : 1; + uint8_t is_open : 1; + uint8_t noblk_connect : 1; int fd; int (*read) (struct vcl_test_session *ts, void *buf, uint32_t buflen); int (*write) (struct vcl_test_session *ts, void *buf, uint32_t buflen); @@ -134,10 +87,11 @@ typedef struct vcl_test_session uint32_t rxbuf_size; char *txbuf; char *rxbuf; - vcl_test_cfg_t cfg; + hs_test_cfg_t cfg; vcl_test_stats_t stats; vcl_test_stats_t old_stats; int session_index; + struct vcl_test_session *next; vppcom_endpt_t endpt; uint8_t ip[16]; vppcom_data_segment_t ds[2]; @@ -154,7 +108,7 @@ vcl_test_worker_index (void) typedef struct { - int (*init) (vcl_test_cfg_t *cfg); + int (*init) (hs_test_cfg_t *cfg); int (*open) (vcl_test_session_t *ts, vppcom_endpt_t *endpt); int (*listen) (vcl_test_session_t *ts, vppcom_endpt_t *endpt); int (*accept) (int listen_fd, vcl_test_session_t *ts); @@ -172,7 +126,7 @@ typedef struct { const vcl_test_proto_vft_t *protos[VPPCOM_PROTO_SRTP + 1]; uint32_t ckpair_index; - vcl_test_cfg_t cfg; + hs_test_cfg_t cfg; vcl_test_wrk_t *wrk; } vcl_test_main_t; @@ -198,37 +152,8 @@ vcl_test_stats_accumulate (vcl_test_stats_t * accum, vcl_test_stats_t * incr) } static inline void -vcl_test_cfg_init (vcl_test_cfg_t * cfg) -{ - cfg->magic = VCL_TEST_CFG_CTRL_MAGIC; - cfg->test = VCL_TEST_TYPE_NONE; - cfg->ctrl_handle = ~0; - cfg->num_test_sessions = 1; - cfg->num_test_sessions_perq = 1; - cfg->verbose = 0; - cfg->rxbuf_size = VCL_TEST_CFG_RXBUF_SIZE_DEF; - cfg->num_writes = VCL_TEST_CFG_NUM_WRITES_DEF; - cfg->txbuf_size = VCL_TEST_CFG_TXBUF_SIZE_DEF; - cfg->total_bytes = cfg->num_writes * cfg->txbuf_size; -} - -static inline int -vcl_test_cfg_verify (vcl_test_cfg_t * cfg, vcl_test_cfg_t * valid_cfg) -{ - /* Note: txbuf & rxbuf on server are the same buffer, - * so txbuf_size is not included in this check. - */ - return ((cfg->magic == valid_cfg->magic) - && (cfg->test == valid_cfg->test) - && (cfg->verbose == valid_cfg->verbose) - && (cfg->rxbuf_size == valid_cfg->rxbuf_size) - && (cfg->num_writes == valid_cfg->num_writes) - && (cfg->total_bytes == valid_cfg->total_bytes)); -} - -static inline void -vcl_test_buf_alloc (vcl_test_cfg_t * cfg, uint8_t is_rxbuf, uint8_t ** buf, - uint32_t * bufsize) +vcl_test_buf_alloc (hs_test_cfg_t *cfg, uint8_t is_rxbuf, uint8_t **buf, + uint32_t *bufsize) { uint32_t alloc_size = is_rxbuf ? cfg->rxbuf_size : cfg->txbuf_size; uint8_t *lb = realloc (*buf, (size_t) alloc_size); @@ -269,69 +194,6 @@ vcl_test_session_buf_free (vcl_test_session_t *ts) ts->txbuf = 0; } -static inline char * -vcl_test_type_str (vcl_test_t t) -{ - switch (t) - { - case VCL_TEST_TYPE_NONE: - return "NONE"; - - case VCL_TEST_TYPE_ECHO: - return "ECHO"; - - case VCL_TEST_TYPE_UNI: - return "UNI"; - - case VCL_TEST_TYPE_BI: - return "BI"; - - case VCL_TEST_TYPE_EXIT: - return "EXIT"; - - default: - return "Unknown"; - } -} - -static inline void -vcl_test_cfg_dump (vcl_test_cfg_t * cfg, uint8_t is_client) -{ - char *spc = " "; - - printf (" test config (%p):\n" - VCL_TEST_SEPARATOR_STRING - " magic: 0x%08x\n" - " seq_num: 0x%08x\n" - "%-5s test: %s (%d)\n" - " ctrl handle: %d (0x%x)\n" - "%-5s num test sockets: %u (0x%08x)\n" - "%-5s verbose: %s (%d)\n" - "%-5s rxbuf size: %lu (0x%08lx)\n" - "%-5s txbuf size: %lu (0x%08lx)\n" - "%-5s num writes: %lu (0x%08lx)\n" - " client tx bytes: %lu (0x%08lx)\n" - VCL_TEST_SEPARATOR_STRING, - (void *) cfg, cfg->magic, cfg->seq_num, - is_client && (cfg->test == VCL_TEST_TYPE_UNI) ? - "'" VCL_TEST_TOKEN_RUN_UNI "'" : - is_client && (cfg->test == VCL_TEST_TYPE_BI) ? - "'" VCL_TEST_TOKEN_RUN_BI "'" : spc, - vcl_test_type_str (cfg->test), cfg->test, - cfg->ctrl_handle, cfg->ctrl_handle, - is_client ? "'" VCL_TEST_TOKEN_NUM_TEST_SESS "'" : spc, - cfg->num_test_sessions, cfg->num_test_sessions, - is_client ? "'" VCL_TEST_TOKEN_VERBOSE "'" : spc, - cfg->verbose ? "on" : "off", cfg->verbose, - is_client ? "'" VCL_TEST_TOKEN_RXBUF_SIZE "'" : spc, - cfg->rxbuf_size, cfg->rxbuf_size, - is_client ? "'" VCL_TEST_TOKEN_TXBUF_SIZE "'" : spc, - cfg->txbuf_size, cfg->txbuf_size, - is_client ? "'" VCL_TEST_TOKEN_NUM_WRITES "'" : spc, - cfg->num_writes, cfg->num_writes, - cfg->total_bytes, cfg->total_bytes); -} - static inline void vcl_test_stats_dump (char *header, vcl_test_stats_t * stats, uint8_t show_rx, uint8_t show_tx, uint8_t verbose) @@ -361,31 +223,27 @@ vcl_test_stats_dump (char *header, vcl_test_stats_t * stats, if (show_tx) { - printf (VCL_TEST_SEPARATOR_STRING - " tx stats (0x%p):\n" - VCL_TEST_SEPARATOR_STRING + printf (HS_TEST_SEPARATOR_STRING + " tx stats (0x%p):\n" HS_TEST_SEPARATOR_STRING " writes: %lu (0x%08lx)\n" " tx bytes: %lu (0x%08lx)\n" " tx eagain: %u (0x%08x)\n" " tx incomplete: %u (0x%08x)\n", (void *) stats, stats->tx_xacts, stats->tx_xacts, - stats->tx_bytes, stats->tx_bytes, - stats->tx_eagain, stats->tx_eagain, - stats->tx_incomp, stats->tx_incomp); + stats->tx_bytes, stats->tx_bytes, stats->tx_eagain, + stats->tx_eagain, stats->tx_incomp, stats->tx_incomp); } if (show_rx) { - printf (VCL_TEST_SEPARATOR_STRING - " rx stats (0x%p):\n" - VCL_TEST_SEPARATOR_STRING + printf (HS_TEST_SEPARATOR_STRING + " rx stats (0x%p):\n" HS_TEST_SEPARATOR_STRING " reads: %lu (0x%08lx)\n" " rx bytes: %lu (0x%08lx)\n" " rx eagain: %u (0x%08x)\n" " rx incomplete: %u (0x%08x)\n", (void *) stats, stats->rx_xacts, stats->rx_xacts, - stats->rx_bytes, stats->rx_bytes, - stats->rx_eagain, stats->rx_eagain, - stats->rx_incomp, stats->rx_incomp); + stats->rx_bytes, stats->rx_bytes, stats->rx_eagain, + stats->rx_eagain, stats->rx_incomp, stats->rx_incomp); } if (verbose) printf (" start.tv_sec: %ld\n" @@ -395,7 +253,7 @@ vcl_test_stats_dump (char *header, vcl_test_stats_t * stats, stats->start.tv_sec, stats->start.tv_nsec, stats->stop.tv_sec, stats->stop.tv_nsec); - printf (VCL_TEST_SEPARATOR_STRING); + printf (HS_TEST_SEPARATOR_STRING); } static inline double @@ -567,25 +425,18 @@ dump_help (void) { #define INDENT "\n " - printf ("CLIENT: Test configuration commands:" - INDENT VCL_TEST_TOKEN_HELP - "\t\t\tDisplay help." - INDENT VCL_TEST_TOKEN_EXIT - "\t\t\tExit test client & server." - INDENT VCL_TEST_TOKEN_SHOW_CFG - "\t\t\tShow the current test cfg." - INDENT VCL_TEST_TOKEN_RUN_UNI - "\t\t\tRun the Uni-directional test." - INDENT VCL_TEST_TOKEN_RUN_BI - "\t\t\tRun the Bi-directional test." - INDENT VCL_TEST_TOKEN_VERBOSE - "\t\t\tToggle verbose setting." - INDENT VCL_TEST_TOKEN_RXBUF_SIZE - "<rxbuf size>\tRx buffer size (bytes)." - INDENT VCL_TEST_TOKEN_TXBUF_SIZE - "<txbuf size>\tTx buffer size (bytes)." - INDENT VCL_TEST_TOKEN_NUM_WRITES - "<# of writes>\tNumber of txbuf writes to server." "\n"); + printf ( + "CLIENT: Test configuration commands:" INDENT VCL_TEST_TOKEN_HELP + "\t\t\tDisplay help." INDENT VCL_TEST_TOKEN_EXIT + "\t\t\tExit test client & server." INDENT VCL_TEST_TOKEN_SHOW_CFG + "\t\t\tShow the current test cfg." INDENT HS_TEST_TOKEN_RUN_UNI + "\t\t\tRun the Uni-directional test." INDENT HS_TEST_TOKEN_RUN_BI + "\t\t\tRun the Bi-directional test." INDENT VCL_TEST_TOKEN_VERBOSE + "\t\t\tToggle verbose setting." INDENT VCL_TEST_TOKEN_RXBUF_SIZE + "<rxbuf size>\tRx buffer size (bytes)." INDENT VCL_TEST_TOKEN_TXBUF_SIZE + "<txbuf size>\tTx buffer size (bytes)." INDENT VCL_TEST_TOKEN_NUM_WRITES + "<# of writes>\tNumber of txbuf writes to server." + "\n"); } #endif /* __vcl_test_h__ */ diff --git a/src/plugins/hs_apps/vcl/vcl_test_client.c b/src/plugins/hs_apps/vcl/vcl_test_client.c index 4a9fb46e5b8..a4a10b562ff 100644 --- a/src/plugins/hs_apps/vcl/vcl_test_client.c +++ b/src/plugins/hs_apps/vcl/vcl_test_client.c @@ -26,18 +26,34 @@ #include <pthread.h> #include <signal.h> -typedef struct +typedef struct vtc_worker_ vcl_test_client_worker_t; +typedef int (vtc_worker_run_fn) (vcl_test_client_worker_t *wrk); + +struct vtc_worker_ { vcl_test_session_t *sessions; vcl_test_session_t *qsessions; uint32_t n_sessions; uint32_t wrk_index; - fd_set wr_fdset; - fd_set rd_fdset; - int max_fd_index; + union + { + struct + { + fd_set wr_fdset; + fd_set rd_fdset; + int max_fd_index; + }; + struct + { + uint32_t epoll_sh; + struct epoll_event ep_evts[VCL_TEST_CFG_MAX_EPOLL_EVENTS]; + vcl_test_session_t *next_to_send; + }; + }; pthread_t thread_handle; - vcl_test_cfg_t cfg; -} vcl_test_client_worker_t; + vtc_worker_run_fn *wrk_run_fn; + hs_test_cfg_t cfg; +}; typedef struct { @@ -46,13 +62,17 @@ typedef struct vppcom_endpt_t server_endpt; uint32_t cfg_seq_num; uint8_t dump_cfg; - vcl_test_t post_test; + hs_test_t post_test; uint8_t proto; uint8_t incremental_stats; uint32_t n_workers; volatile int active_workers; volatile int test_running; - struct sockaddr_storage server_addr; + union + { + struct in_addr v4; + struct in6_addr v6; + } server_addr; } vcl_test_client_main_t; vcl_test_client_main_t vcl_client_main; @@ -65,14 +85,14 @@ vcl_test_main_t vcl_test_main; static int vtc_cfg_sync (vcl_test_session_t * ts) { - vcl_test_cfg_t *rx_cfg = (vcl_test_cfg_t *) ts->rxbuf; + hs_test_cfg_t *rx_cfg = (hs_test_cfg_t *) ts->rxbuf; int rx_bytes, tx_bytes; vt_atomic_add (&ts->cfg.seq_num, 1); if (ts->cfg.verbose) { vtinf ("(fd %d): Sending config to server.", ts->fd); - vcl_test_cfg_dump (&ts->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ts->cfg, 1 /* is_client */); } tx_bytes = ts->write (ts, &ts->cfg, sizeof (ts->cfg)); if (tx_bytes < 0) @@ -81,50 +101,48 @@ vtc_cfg_sync (vcl_test_session_t * ts) return tx_bytes; } - rx_bytes = ts->read (ts, ts->rxbuf, sizeof (vcl_test_cfg_t)); + rx_bytes = ts->read (ts, ts->rxbuf, sizeof (hs_test_cfg_t)); if (rx_bytes < 0) return rx_bytes; - if (rx_cfg->magic != VCL_TEST_CFG_CTRL_MAGIC) + if (rx_cfg->magic != HS_TEST_CFG_CTRL_MAGIC) { vtwrn ("(fd %d): Bad server reply cfg -- aborting!", ts->fd); return -1; } - if ((rx_bytes != sizeof (vcl_test_cfg_t)) - || !vcl_test_cfg_verify (rx_cfg, &ts->cfg)) + if ((rx_bytes != sizeof (hs_test_cfg_t)) || + !hs_test_cfg_verify (rx_cfg, &ts->cfg)) { vtwrn ("(fd %d): Invalid config received from server!", ts->fd); - if (rx_bytes != sizeof (vcl_test_cfg_t)) + if (rx_bytes != sizeof (hs_test_cfg_t)) { vtinf ("\tRx bytes %d != cfg size %lu", rx_bytes, - sizeof (vcl_test_cfg_t)); + sizeof (hs_test_cfg_t)); } else { - vcl_test_cfg_dump (rx_cfg, 1 /* is_client */ ); + hs_test_cfg_dump (rx_cfg, 1 /* is_client */); vtinf ("(fd %d): Valid config sent to server.", ts->fd); - vcl_test_cfg_dump (&ts->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ts->cfg, 1 /* is_client */); } return -1; } if (ts->cfg.verbose) { vtinf ("(fd %d): Got config back from server.", ts->fd); - vcl_test_cfg_dump (rx_cfg, 1 /* is_client */ ); + hs_test_cfg_dump (rx_cfg, 1 /* is_client */); } return 0; } static int -vtc_connect_test_sessions (vcl_test_client_worker_t * wrk) +vtc_worker_alloc_sessions (vcl_test_client_worker_t *wrk) { - vcl_test_client_main_t *vcm = &vcl_client_main; - vcl_test_main_t *vt = &vcl_test_main; - const vcl_test_proto_vft_t *tp; vcl_test_session_t *ts; uint32_t n_test_sessions; - int i, rv; + struct timespec now; + int i, j; n_test_sessions = wrk->cfg.num_test_sessions; if (n_test_sessions < 1) @@ -148,62 +166,33 @@ vtc_connect_test_sessions (vcl_test_client_worker_t * wrk) return errno; } - tp = vt->protos[vcm->proto]; + clock_gettime (CLOCK_REALTIME, &now); for (i = 0; i < n_test_sessions; i++) { ts = &wrk->sessions[i]; memset (ts, 0, sizeof (*ts)); ts->session_index = i; + ts->old_stats.stop = now; ts->cfg = wrk->cfg; vcl_test_session_buf_alloc (ts); - rv = tp->open (&wrk->sessions[i], &vcm->server_endpt); - if (rv < 0) - return rv; - } - wrk->n_sessions = n_test_sessions; - -done: - vtinf ("All test sessions (%d) connected!", n_test_sessions); - return 0; -} - -static int -vtc_worker_test_setup (vcl_test_client_worker_t * wrk) -{ - vcl_test_cfg_t *cfg = &wrk->cfg; - vcl_test_session_t *ts; - struct timespec now; - uint32_t sidx; - int i, j; - - FD_ZERO (&wrk->wr_fdset); - FD_ZERO (&wrk->rd_fdset); - - clock_gettime (CLOCK_REALTIME, &now); - - for (i = 0; i < cfg->num_test_sessions; i++) - { - ts = &wrk->sessions[i]; - ts->old_stats.stop = now; - switch (cfg->test) + switch (ts->cfg.test) { - case VCL_TEST_TYPE_UNI: - case VCL_TEST_TYPE_BI: + case HS_TEST_TYPE_UNI: + case HS_TEST_TYPE_BI: for (j = 0; j < ts->txbuf_size; j++) ts->txbuf[j] = j & 0xff; break; default: break; } - - FD_SET (vppcom_session_index (ts->fd), &wrk->wr_fdset); - FD_SET (vppcom_session_index (ts->fd), &wrk->rd_fdset); - sidx = vppcom_session_index (ts->fd); - wrk->max_fd_index = vtc_max (sidx, wrk->max_fd_index); } - wrk->max_fd_index += 1; + wrk->n_sessions = n_test_sessions; + +done: + + vtinf ("All test sessions (%d) initialized!", n_test_sessions); return 0; } @@ -227,16 +216,13 @@ vtc_worker_init (vcl_test_client_worker_t * wrk) } vt_atomic_add (&vcm->active_workers, 1); } - rv = vtc_connect_test_sessions (wrk); + rv = vtc_worker_alloc_sessions (wrk); if (rv) { - vterr ("vtc_connect_test_sessions ()", rv); + vterr ("vtc_worker_alloc_sessions ()", rv); return rv; } - if (vtc_worker_test_setup (wrk)) - return -1; - return 0; } @@ -253,8 +239,7 @@ vtc_accumulate_stats (vcl_test_client_worker_t * wrk, while (__sync_lock_test_and_set (&stats_lock, 1)) ; - if (ctrl->cfg.test == VCL_TEST_TYPE_BI - || ctrl->cfg.test == VCL_TEST_TYPE_ECHO) + if (ctrl->cfg.test == HS_TEST_TYPE_BI || ctrl->cfg.test == HS_TEST_TYPE_ECHO) show_rx = 1; for (i = 0; i < wrk->cfg.num_test_sessions; i++) @@ -308,32 +293,90 @@ vtc_inc_stats_check (vcl_test_session_t *ts) } } -static void * -vtc_worker_loop (void *arg) +static void +vtc_worker_start_transfer (vcl_test_client_worker_t *wrk) +{ + vtinf ("Worker %u starting transfer ...", wrk->wrk_index); + + if (wrk->wrk_index == 0) + { + vcl_test_client_main_t *vcm = &vcl_client_main; + vcl_test_session_t *ctrl = &vcm->ctrl_session; + + clock_gettime (CLOCK_REALTIME, &ctrl->stats.start); + } +} + +static int +vtc_session_check_is_done (vcl_test_session_t *ts, uint8_t check_rx) +{ + if ((!check_rx && ts->stats.tx_bytes >= ts->cfg.total_bytes) || + (check_rx && ts->stats.rx_bytes >= ts->cfg.total_bytes)) + { + clock_gettime (CLOCK_REALTIME, &ts->stats.stop); + ts->is_done = 1; + return 1; + } + return 0; +} + +static int +vtc_worker_connect_sessions_select (vcl_test_client_worker_t *wrk) +{ + vcl_test_client_main_t *vcm = &vcl_client_main; + vcl_test_main_t *vt = &vcl_test_main; + const vcl_test_proto_vft_t *tp; + vcl_test_session_t *ts; + uint32_t sidx; + int i, rv; + + tp = vt->protos[vcm->proto]; + + FD_ZERO (&wrk->wr_fdset); + FD_ZERO (&wrk->rd_fdset); + + for (i = 0; i < wrk->cfg.num_test_sessions; i++) + { + ts = &wrk->sessions[i]; + + rv = tp->open (&wrk->sessions[i], &vcm->server_endpt); + if (rv < 0) + return rv; + + FD_SET (vppcom_session_index (ts->fd), &wrk->wr_fdset); + FD_SET (vppcom_session_index (ts->fd), &wrk->rd_fdset); + sidx = vppcom_session_index (ts->fd); + wrk->max_fd_index = vtc_max (sidx, wrk->max_fd_index); + } + wrk->max_fd_index += 1; + + vtinf ("All test sessions (%d) connected!", wrk->cfg.num_test_sessions); + + return 0; +} + +static int +vtc_worker_run_select (vcl_test_client_worker_t *wrk) { vcl_test_client_main_t *vcm = &vcl_client_main; - vcl_test_session_t *ctrl = &vcm->ctrl_session; - vcl_test_client_worker_t *wrk = arg; - uint32_t n_active_sessions; fd_set _wfdset, *wfdset = &_wfdset; fd_set _rfdset, *rfdset = &_rfdset; + uint32_t n_active_sessions; vcl_test_session_t *ts; int i, rv, check_rx = 0; - rv = vtc_worker_init (wrk); + rv = vtc_worker_connect_sessions_select (wrk); if (rv) { - vterr ("vtc_worker_init()", rv); - return 0; + vterr ("vtc_worker_connect_sessions()", rv); + return rv; } - vtinf ("Starting test ..."); + check_rx = wrk->cfg.test != HS_TEST_TYPE_UNI; + n_active_sessions = wrk->cfg.num_test_sessions; - if (wrk->wrk_index == 0) - clock_gettime (CLOCK_REALTIME, &ctrl->stats.start); + vtc_worker_start_transfer (wrk); - check_rx = wrk->cfg.test != VCL_TEST_TYPE_UNI; - n_active_sessions = wrk->cfg.num_test_sessions; while (n_active_sessions && vcm->test_running) { _wfdset = wrk->wr_fdset; @@ -344,7 +387,7 @@ vtc_worker_loop (void *arg) if (rv < 0) { vterr ("vppcom_select()", rv); - goto exit; + break; } else if (rv == 0) continue; @@ -355,29 +398,29 @@ vtc_worker_loop (void *arg) if (ts->is_done) continue; - if (FD_ISSET (vppcom_session_index (ts->fd), rfdset) - && ts->stats.rx_bytes < ts->cfg.total_bytes) + if (FD_ISSET (vppcom_session_index (ts->fd), rfdset) && + ts->stats.rx_bytes < ts->cfg.total_bytes) { rv = ts->read (ts, ts->rxbuf, ts->rxbuf_size); if (rv < 0) - goto exit; + break; } - if (FD_ISSET (vppcom_session_index (ts->fd), wfdset) - && ts->stats.tx_bytes < ts->cfg.total_bytes) + if (FD_ISSET (vppcom_session_index (ts->fd), wfdset) && + ts->stats.tx_bytes < ts->cfg.total_bytes) { rv = ts->write (ts, ts->txbuf, ts->cfg.txbuf_size); if (rv < 0) { vtwrn ("vppcom_test_write (%d) failed -- aborting test", ts->fd); - goto exit; + break; } if (vcm->incremental_stats) vtc_inc_stats_check (ts); } - if ((!check_rx && ts->stats.tx_bytes >= ts->cfg.total_bytes) - || (check_rx && ts->stats.rx_bytes >= ts->cfg.total_bytes)) + if ((!check_rx && ts->stats.tx_bytes >= ts->cfg.total_bytes) || + (check_rx && ts->stats.rx_bytes >= ts->cfg.total_bytes)) { clock_gettime (CLOCK_REALTIME, &ts->stats.stop); ts->is_done = 1; @@ -385,59 +428,343 @@ vtc_worker_loop (void *arg) } } } -exit: + + return 0; +} + +static void +vtc_worker_epoll_send_add (vcl_test_client_worker_t *wrk, + vcl_test_session_t *ts) +{ + if (!wrk->next_to_send) + { + wrk->next_to_send = ts; + } + else + { + ts->next = wrk->next_to_send; + wrk->next_to_send = ts->next; + } +} + +static void +vtc_worker_epoll_send_del (vcl_test_client_worker_t *wrk, + vcl_test_session_t *ts, vcl_test_session_t *prev) +{ + if (!prev) + { + wrk->next_to_send = ts->next; + } + else + { + prev->next = ts->next; + } +} + +static int +vtc_worker_connect_sessions_epoll (vcl_test_client_worker_t *wrk) +{ + vcl_test_client_main_t *vcm = &vcl_client_main; + vcl_test_main_t *vt = &vcl_test_main; + const vcl_test_proto_vft_t *tp; + struct timespec start, end; + uint32_t n_connected = 0; + vcl_test_session_t *ts; + struct epoll_event ev; + int i, ci = 0, rv, n_ev; + double diff; + + tp = vt->protos[vcm->proto]; + wrk->epoll_sh = vppcom_epoll_create (); + + ev.events = EPOLLET | EPOLLOUT; + + clock_gettime (CLOCK_REALTIME, &start); + + while (n_connected < wrk->cfg.num_test_sessions) + { + /* + * Try to connect more sessions if under pending threshold + */ + while ((ci - n_connected) < 16 && ci < wrk->cfg.num_test_sessions) + { + ts = &wrk->sessions[ci]; + ts->noblk_connect = 1; + rv = tp->open (&wrk->sessions[ci], &vcm->server_endpt); + if (rv < 0) + { + vtwrn ("open: %d", rv); + return rv; + } + + ev.data.u64 = ci; + rv = vppcom_epoll_ctl (wrk->epoll_sh, EPOLL_CTL_ADD, ts->fd, &ev); + if (rv < 0) + { + vtwrn ("vppcom_epoll_ctl: %d", rv); + return rv; + } + ci += 1; + } + + /* + * Handle connected events + */ + n_ev = + vppcom_epoll_wait (wrk->epoll_sh, wrk->ep_evts, + VCL_TEST_CFG_MAX_EPOLL_EVENTS, 0 /* timeout */); + if (n_ev < 0) + { + vterr ("vppcom_epoll_wait() returned", n_ev); + return -1; + } + else if (n_ev == 0) + { + continue; + } + + for (i = 0; i < n_ev; i++) + { + ts = &wrk->sessions[wrk->ep_evts[i].data.u32]; + if (!(wrk->ep_evts[i].events & EPOLLOUT)) + { + vtwrn ("connect failed"); + return -1; + } + if (ts->is_open) + { + vtwrn ("connection already open?"); + return -1; + } + ts->is_open = 1; + n_connected += 1; + } + } + + clock_gettime (CLOCK_REALTIME, &end); + + diff = vcl_test_time_diff (&start, &end); + vtinf ("Connected (%u) connected in %.2f seconds (%u CPS)!", + wrk->cfg.num_test_sessions, diff, + (uint32_t) ((double) wrk->cfg.num_test_sessions / diff)); + + ev.events = EPOLLET | EPOLLIN | EPOLLOUT; + + for (i = 0; i < wrk->cfg.num_test_sessions; i++) + { + ts = &wrk->sessions[i]; + + /* No data to be sent */ + if (ts->cfg.total_bytes == 0) + { + n_connected -= 1; + clock_gettime (CLOCK_REALTIME, &ts->stats.stop); + ts->is_done = 1; + continue; + } + + ev.data.u64 = i; + rv = vppcom_epoll_ctl (wrk->epoll_sh, EPOLL_CTL_MOD, ts->fd, &ev); + if (rv < 0) + { + vtwrn ("vppcom_epoll_ctl: %d", rv); + return rv; + } + vtc_worker_epoll_send_add (wrk, ts); + } + + return n_connected; +} + +static int +vtc_worker_run_epoll (vcl_test_client_worker_t *wrk) +{ + vcl_test_client_main_t *vcm = &vcl_client_main; + uint32_t n_active_sessions, max_writes = 16, n_writes = 0; + vcl_test_session_t *ts, *prev = 0; + int i, rv, check_rx = 0, n_ev; + + rv = vtc_worker_connect_sessions_epoll (wrk); + if (rv < 0) + { + vterr ("vtc_worker_connect_sessions()", rv); + return rv; + } + + n_active_sessions = rv; + check_rx = wrk->cfg.test != HS_TEST_TYPE_UNI; + + vtc_worker_start_transfer (wrk); + ts = wrk->next_to_send; + + while (n_active_sessions && vcm->test_running) + { + /* + * Try to write + */ + if (!ts) + { + ts = wrk->next_to_send; + if (!ts) + goto get_epoll_evts; + } + + rv = ts->write (ts, ts->txbuf, ts->cfg.txbuf_size); + if (rv > 0) + { + if (vcm->incremental_stats) + vtc_inc_stats_check (ts); + if (vtc_session_check_is_done (ts, check_rx)) + n_active_sessions -= 1; + } + else if (rv == 0) + { + vtc_worker_epoll_send_del (wrk, ts, prev); + } + else + { + vtwrn ("vppcom_test_write (%d) failed -- aborting test", ts->fd); + return -1; + } + prev = ts; + ts = ts->next; + n_writes += 1; + + if (rv > 0 && n_writes < max_writes) + continue; + + get_epoll_evts: + + /* + * Grab new events + */ + + n_ev = + vppcom_epoll_wait (wrk->epoll_sh, wrk->ep_evts, + VCL_TEST_CFG_MAX_EPOLL_EVENTS, 0 /* timeout */); + if (n_ev < 0) + { + vterr ("vppcom_epoll_wait()", n_ev); + break; + } + else if (n_ev == 0) + { + continue; + } + + for (i = 0; i < n_ev; i++) + { + ts = &wrk->sessions[wrk->ep_evts[i].data.u32]; + + if (ts->is_done) + continue; + + if (wrk->ep_evts[i].events & (EPOLLERR | EPOLLHUP | EPOLLRDHUP)) + { + vtinf ("%u finished before reading all data?", ts->fd); + break; + } + if ((wrk->ep_evts[i].events & EPOLLIN) && + ts->stats.rx_bytes < ts->cfg.total_bytes) + { + rv = ts->read (ts, ts->rxbuf, ts->rxbuf_size); + if (rv < 0) + break; + if (vtc_session_check_is_done (ts, check_rx)) + n_active_sessions -= 1; + } + if ((wrk->ep_evts[i].events & EPOLLOUT) && + ts->stats.tx_bytes < ts->cfg.total_bytes) + { + vtc_worker_epoll_send_add (wrk, ts); + } + } + + n_writes = 0; + } + + return 0; +} + +static inline int +vtc_worker_run (vcl_test_client_worker_t *wrk) +{ + int rv; + + vtinf ("Worker %u starting test ...", wrk->wrk_index); + + rv = wrk->wrk_run_fn (wrk); + vtinf ("Worker %d done ...", wrk->wrk_index); + + return rv; +} + +static void * +vtc_worker_loop (void *arg) +{ + vcl_test_client_main_t *vcm = &vcl_client_main; + vcl_test_session_t *ctrl = &vcm->ctrl_session; + vcl_test_client_worker_t *wrk = arg; + + if (vtc_worker_init (wrk)) + goto done; + + if (vtc_worker_run (wrk)) + goto done; + vtc_accumulate_stats (wrk, ctrl); sleep (VCL_TEST_DELAY_DISCONNECT); vtc_worker_sessions_exit (wrk); + +done: + if (wrk->wrk_index) vt_atomic_add (&vcm->active_workers, -1); + return 0; } static void vtc_print_stats (vcl_test_session_t * ctrl) { - int is_echo = ctrl->cfg.test == VCL_TEST_TYPE_ECHO; + int is_echo = ctrl->cfg.test == HS_TEST_TYPE_ECHO; int show_rx = 0; char buf[64]; - if (ctrl->cfg.test == VCL_TEST_TYPE_BI - || ctrl->cfg.test == VCL_TEST_TYPE_ECHO) + if (ctrl->cfg.test == HS_TEST_TYPE_BI || ctrl->cfg.test == HS_TEST_TYPE_ECHO) show_rx = 1; vcl_test_stats_dump ("CLIENT RESULTS", &ctrl->stats, show_rx, 1 /* show tx */ , ctrl->cfg.verbose); - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); if (ctrl->cfg.verbose) { - vtinf (" ctrl session info\n" - VCL_TEST_SEPARATOR_STRING + vtinf (" ctrl session info\n" HS_TEST_SEPARATOR_STRING " fd: %d (0x%08x)\n" " rxbuf: %p\n" " rxbuf size: %u (0x%08x)\n" " txbuf: %p\n" - " txbuf size: %u (0x%08x)\n" - VCL_TEST_SEPARATOR_STRING, - ctrl->fd, (uint32_t) ctrl->fd, - ctrl->rxbuf, ctrl->rxbuf_size, ctrl->rxbuf_size, - ctrl->txbuf, ctrl->txbuf_size, ctrl->txbuf_size); + " txbuf size: %u (0x%08x)\n" HS_TEST_SEPARATOR_STRING, + ctrl->fd, (uint32_t) ctrl->fd, ctrl->rxbuf, ctrl->rxbuf_size, + ctrl->rxbuf_size, ctrl->txbuf, ctrl->txbuf_size, + ctrl->txbuf_size); } if (is_echo) snprintf (buf, sizeof (buf), "Echo"); else snprintf (buf, sizeof (buf), "%s-directional Stream", - ctrl->cfg.test == VCL_TEST_TYPE_BI ? "Bi" : "Uni"); + ctrl->cfg.test == HS_TEST_TYPE_BI ? "Bi" : "Uni"); } static void vtc_echo_client (vcl_test_client_main_t * vcm) { vcl_test_session_t *ctrl = &vcm->ctrl_session; - vcl_test_cfg_t *cfg = &ctrl->cfg; + hs_test_cfg_t *cfg = &ctrl->cfg; int rv; cfg->total_bytes = strlen (ctrl->txbuf) + 1; @@ -457,12 +784,12 @@ static void vtc_stream_client (vcl_test_client_main_t * vcm) { vcl_test_session_t *ctrl = &vcm->ctrl_session; - vcl_test_cfg_t *cfg = &ctrl->cfg; + hs_test_cfg_t *cfg = &ctrl->cfg; vcl_test_client_worker_t *wrk; uint32_t i, n_conn, n_conn_per_wrk; vtinf ("%s-directional Stream Test Starting!", - ctrl->cfg.test == VCL_TEST_TYPE_BI ? "Bi" : "Uni"); + ctrl->cfg.test == HS_TEST_TYPE_BI ? "Bi" : "Uni"); memset (&ctrl->stats, 0, sizeof (vcl_test_stats_t)); cfg->total_bytes = cfg->num_writes * cfg->txbuf_size; @@ -480,7 +807,7 @@ vtc_stream_client (vcl_test_client_main_t * vcm) } vcm->test_running = 1; - ctrl->cfg.cmd = VCL_TEST_CMD_START; + ctrl->cfg.cmd = HS_TEST_CMD_START; if (vtc_cfg_sync (ctrl)) { vtwrn ("test cfg sync failed -- aborting!"); @@ -490,8 +817,12 @@ vtc_stream_client (vcl_test_client_main_t * vcm) for (i = 1; i < vcm->n_workers; i++) { wrk = &vcm->workers[i]; - pthread_create (&wrk->thread_handle, NULL, vtc_worker_loop, - (void *) wrk); + if (pthread_create (&wrk->thread_handle, NULL, vtc_worker_loop, + (void *) wrk)) + { + vtwrn ("pthread_create failed -- aborting!"); + return; + } } vtc_worker_loop (&vcm->workers[0]); @@ -499,7 +830,7 @@ vtc_stream_client (vcl_test_client_main_t * vcm) ; vtinf ("Sending config on ctrl session (fd %d) for stats...", ctrl->fd); - ctrl->cfg.cmd = VCL_TEST_CMD_STOP; + ctrl->cfg.cmd = HS_TEST_CMD_STOP; if (vtc_cfg_sync (ctrl)) { vtwrn ("test cfg sync failed -- aborting!"); @@ -508,8 +839,8 @@ vtc_stream_client (vcl_test_client_main_t * vcm) vtc_print_stats (ctrl); - ctrl->cfg.cmd = VCL_TEST_CMD_SYNC; - ctrl->cfg.test = VCL_TEST_TYPE_ECHO; + ctrl->cfg.cmd = HS_TEST_CMD_SYNC; + ctrl->cfg.test = HS_TEST_TYPE_ECHO; ctrl->cfg.total_bytes = 0; if (vtc_cfg_sync (ctrl)) vtwrn ("post-test cfg sync failed!"); @@ -529,7 +860,7 @@ cfg_txbuf_size_set (void) ctrl->cfg.total_bytes = ctrl->cfg.num_writes * ctrl->cfg.txbuf_size; vcl_test_buf_alloc (&ctrl->cfg, 0 /* is_rxbuf */ , (uint8_t **) & ctrl->txbuf, &ctrl->txbuf_size); - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); } else vtwrn ("Invalid txbuf size (%lu) < minimum buf size (%u)!", @@ -548,7 +879,7 @@ cfg_num_writes_set (void) { ctrl->cfg.num_writes = num_writes; ctrl->cfg.total_bytes = ctrl->cfg.num_writes * ctrl->cfg.txbuf_size; - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); } else { @@ -568,7 +899,7 @@ cfg_num_test_sessions_set (void) (num_test_sessions <= VCL_TEST_CFG_MAX_TEST_SESS)) { ctrl->cfg.num_test_sessions = num_test_sessions; - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); } else { @@ -590,7 +921,7 @@ cfg_rxbuf_size_set (void) ctrl->cfg.rxbuf_size = rxbuf_size; vcl_test_buf_alloc (&ctrl->cfg, 1 /* is_rxbuf */ , (uint8_t **) & ctrl->rxbuf, &ctrl->rxbuf_size); - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); } else vtwrn ("Invalid rxbuf size (%lu) < minimum buf size (%u)!", @@ -604,20 +935,19 @@ cfg_verbose_toggle (void) vcl_test_session_t *ctrl = &vcm->ctrl_session; ctrl->cfg.verbose = ctrl->cfg.verbose ? 0 : 1; - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); - + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); } -static vcl_test_t +static hs_test_t parse_input () { vcl_test_client_main_t *vcm = &vcl_client_main; vcl_test_session_t *ctrl = &vcm->ctrl_session; - vcl_test_t rv = VCL_TEST_TYPE_NONE; + hs_test_t rv = HS_TEST_TYPE_NONE; if (!strncmp (VCL_TEST_TOKEN_EXIT, ctrl->txbuf, strlen (VCL_TEST_TOKEN_EXIT))) - rv = VCL_TEST_TYPE_EXIT; + rv = HS_TEST_TYPE_EXIT; else if (!strncmp (VCL_TEST_TOKEN_HELP, ctrl->txbuf, strlen (VCL_TEST_TOKEN_HELP))) @@ -647,16 +977,16 @@ parse_input () strlen (VCL_TEST_TOKEN_RXBUF_SIZE))) cfg_rxbuf_size_set (); - else if (!strncmp (VCL_TEST_TOKEN_RUN_UNI, ctrl->txbuf, - strlen (VCL_TEST_TOKEN_RUN_UNI))) - rv = ctrl->cfg.test = VCL_TEST_TYPE_UNI; + else if (!strncmp (HS_TEST_TOKEN_RUN_UNI, ctrl->txbuf, + strlen (HS_TEST_TOKEN_RUN_UNI))) + rv = ctrl->cfg.test = HS_TEST_TYPE_UNI; - else if (!strncmp (VCL_TEST_TOKEN_RUN_BI, ctrl->txbuf, - strlen (VCL_TEST_TOKEN_RUN_BI))) - rv = ctrl->cfg.test = VCL_TEST_TYPE_BI; + else if (!strncmp (HS_TEST_TOKEN_RUN_BI, ctrl->txbuf, + strlen (HS_TEST_TOKEN_RUN_BI))) + rv = ctrl->cfg.test = HS_TEST_TYPE_BI; else - rv = VCL_TEST_TYPE_ECHO; + rv = HS_TEST_TYPE_ECHO; return rv; } @@ -682,6 +1012,7 @@ print_usage_and_exit (void) " -T <txbuf-size> Test Cfg: tx buffer size.\n" " -U Run Uni-directional test.\n" " -B Run Bi-directional test.\n" + " -b <bytes> Total number of bytes transferred\n" " -V Verbose mode.\n" " -I <N> Use N sessions.\n" " -s <N> Use N sessions.\n" @@ -697,7 +1028,7 @@ vtc_process_opts (vcl_test_client_main_t * vcm, int argc, char **argv) int c, v; opterr = 0; - while ((c = getopt (argc, argv, "chnp:w:XE:I:N:R:T:UBV6DLs:q:S")) != -1) + while ((c = getopt (argc, argv, "chnp:w:xXE:I:N:R:T:b:UBV6DLs:q:S")) != -1) switch (c) { case 'c': @@ -752,7 +1083,11 @@ vtc_process_opts (vcl_test_client_main_t * vcm, int argc, char **argv) break; case 'X': - vcm->post_test = VCL_TEST_TYPE_EXIT; + vcm->post_test = HS_TEST_TYPE_EXIT; + break; + + case 'x': + vcm->post_test = HS_TEST_TYPE_NONE; break; case 'E': @@ -763,7 +1098,7 @@ vtc_process_opts (vcl_test_client_main_t * vcm, int argc, char **argv) print_usage_and_exit (); } strncpy (ctrl->txbuf, optarg, ctrl->txbuf_size); - ctrl->cfg.test = VCL_TEST_TYPE_ECHO; + ctrl->cfg.test = HS_TEST_TYPE_ECHO; break; case 'N': @@ -822,13 +1157,28 @@ vtc_process_opts (vcl_test_client_main_t * vcm, int argc, char **argv) print_usage_and_exit (); } break; + case 'b': + if (sscanf (optarg, "0x%lu", &ctrl->cfg.total_bytes) != 1) + if (sscanf (optarg, "%ld", &ctrl->cfg.total_bytes) != 1) + { + vtwrn ("Invalid value for option -%c!", c); + print_usage_and_exit (); + } + if (ctrl->cfg.total_bytes % ctrl->cfg.txbuf_size) + { + vtwrn ("total bytes must be mutliple of txbuf size(0x%lu)!", + ctrl->cfg.txbuf_size); + print_usage_and_exit (); + } + ctrl->cfg.num_writes = ctrl->cfg.total_bytes / ctrl->cfg.txbuf_size; + break; case 'U': - ctrl->cfg.test = VCL_TEST_TYPE_UNI; + ctrl->cfg.test = HS_TEST_TYPE_UNI; break; case 'B': - ctrl->cfg.test = VCL_TEST_TYPE_BI; + ctrl->cfg.test = HS_TEST_TYPE_BI; break; case 'V': @@ -882,9 +1232,9 @@ vtc_process_opts (vcl_test_client_main_t * vcm, int argc, char **argv) print_usage_and_exit (); } - if (argc < (optind + 2)) + if (argc > (optind + 2)) { - vtwrn ("Insufficient number of arguments!"); + vtwrn ("Invalid number of arguments!"); print_usage_and_exit (); } @@ -895,26 +1245,25 @@ vtc_process_opts (vcl_test_client_main_t * vcm, int argc, char **argv) memset (&vcm->server_addr, 0, sizeof (vcm->server_addr)); if (ctrl->cfg.address_ip6) { - struct sockaddr_in6 *sddr6 = (struct sockaddr_in6 *) &vcm->server_addr; - sddr6->sin6_family = AF_INET6; - inet_pton (AF_INET6, argv[optind++], &(sddr6->sin6_addr)); - sddr6->sin6_port = htons (atoi (argv[optind])); + struct in6_addr *in6 = &vcm->server_addr.v6; + inet_pton (AF_INET6, argv[optind++], in6); vcm->server_endpt.is_ip4 = 0; - vcm->server_endpt.ip = (uint8_t *) & sddr6->sin6_addr; - vcm->server_endpt.port = (uint16_t) sddr6->sin6_port; + vcm->server_endpt.ip = (uint8_t *) in6; } else { - struct sockaddr_in *saddr4 = (struct sockaddr_in *) &vcm->server_addr; - saddr4->sin_family = AF_INET; - inet_pton (AF_INET, argv[optind++], &(saddr4->sin_addr)); - saddr4->sin_port = htons (atoi (argv[optind])); + struct in_addr *in4 = &vcm->server_addr.v4; + inet_pton (AF_INET, argv[optind++], in4); vcm->server_endpt.is_ip4 = 1; - vcm->server_endpt.ip = (uint8_t *) & saddr4->sin_addr; - vcm->server_endpt.port = (uint16_t) saddr4->sin_port; + vcm->server_endpt.ip = (uint8_t *) in4; } + + if (argc == optind + 1) + vcm->server_endpt.port = htons (atoi (argv[optind])); + else + vcm->server_endpt.port = htons (VCL_TEST_SERVER_PORT); } static void @@ -944,10 +1293,14 @@ vtc_ctrl_session_exit (void) vcl_test_session_t *ctrl = &vcm->ctrl_session; int verbose = ctrl->cfg.verbose; - ctrl->cfg.test = VCL_TEST_TYPE_EXIT; + /* Only clients exits, server can accept new connections */ + if (vcm->post_test == HS_TEST_TYPE_EXIT_CLIENT) + return; + + ctrl->cfg.test = HS_TEST_TYPE_EXIT; vtinf ("(fd %d): Sending exit cfg to server...", ctrl->fd); if (verbose) - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); (void) vcl_test_write (ctrl, (uint8_t *) &ctrl->cfg, sizeof (ctrl->cfg)); sleep (1); } @@ -976,7 +1329,7 @@ vtc_ctrl_session_init (vcl_test_client_main_t *vcm, vcl_test_session_t *ctrl) ctrl->read = vcl_test_read; ctrl->write = vcl_test_write; - ctrl->cfg.cmd = VCL_TEST_CMD_SYNC; + ctrl->cfg.cmd = HS_TEST_CMD_SYNC; rv = vtc_cfg_sync (ctrl); if (rv) { @@ -984,7 +1337,7 @@ vtc_ctrl_session_init (vcl_test_client_main_t *vcm, vcl_test_session_t *ctrl) return rv; } - ctrl->cfg.ctrl_handle = ((vcl_test_cfg_t *) ctrl->rxbuf)->ctrl_handle; + ctrl->cfg.ctrl_handle = ((hs_test_cfg_t *) ctrl->rxbuf)->ctrl_handle; memset (&ctrl->stats, 0, sizeof (ctrl->stats)); return 0; @@ -1015,6 +1368,24 @@ vt_incercept_sigs (void) } } +static void +vtc_alloc_workers (vcl_test_client_main_t *vcm) +{ + vcl_test_main_t *vt = &vcl_test_main; + vtc_worker_run_fn *run_fn; + + vcm->workers = calloc (vcm->n_workers, sizeof (vcl_test_client_worker_t)); + vt->wrk = calloc (vcm->n_workers, sizeof (vcl_test_wrk_t)); + + if (vcm->ctrl_session.cfg.num_test_sessions > VCL_TEST_CFG_MAX_SELECT_SESS) + run_fn = vtc_worker_run_epoll; + else + run_fn = vtc_worker_run_select; + + for (int i = 0; i < vcm->n_workers; i++) + vcm->workers[i].wrk_run_fn = run_fn; +} + int main (int argc, char **argv) { @@ -1024,13 +1395,14 @@ main (int argc, char **argv) int rv; vcm->n_workers = 1; - vcl_test_cfg_init (&ctrl->cfg); + vcm->post_test = HS_TEST_TYPE_EXIT_CLIENT; + + hs_test_cfg_init (&ctrl->cfg); + vt_incercept_sigs (); vcl_test_session_buf_alloc (ctrl); vtc_process_opts (vcm, argc, argv); - vt_incercept_sigs (); - vcm->workers = calloc (vcm->n_workers, sizeof (vcl_test_client_worker_t)); - vt->wrk = calloc (vcm->n_workers, sizeof (vcl_test_wrk_t)); + vtc_alloc_workers (vcm); rv = vppcom_app_create ("vcl_test_client"); if (rv < 0) @@ -1038,62 +1410,67 @@ main (int argc, char **argv) /* Protos like tls/dtls/quic need init */ if (vt->protos[vcm->proto]->init) - vt->protos[vcm->proto]->init (&ctrl->cfg); + { + rv = vt->protos[vcm->proto]->init (&ctrl->cfg); + if (rv) + vtfail ("client init failed", rv); + } if ((rv = vtc_ctrl_session_init (vcm, ctrl))) vtfail ("vppcom_session_create() ctrl session", rv); /* Update ctrl port to data port */ - vcm->server_endpt.port += 1; + vcm->server_endpt.port = hs_make_data_port (vcm->server_endpt.port); - while (ctrl->cfg.test != VCL_TEST_TYPE_EXIT) + while (ctrl->cfg.test != HS_TEST_TYPE_EXIT) { if (vcm->dump_cfg) { - vcl_test_cfg_dump (&ctrl->cfg, 1 /* is_client */ ); + hs_test_cfg_dump (&ctrl->cfg, 1 /* is_client */); vcm->dump_cfg = 0; } switch (ctrl->cfg.test) { - case VCL_TEST_TYPE_ECHO: + case HS_TEST_TYPE_ECHO: vtc_echo_client (vcm); break; - case VCL_TEST_TYPE_UNI: - case VCL_TEST_TYPE_BI: + case HS_TEST_TYPE_UNI: + case HS_TEST_TYPE_BI: vtc_stream_client (vcm); break; - case VCL_TEST_TYPE_EXIT: + case HS_TEST_TYPE_EXIT: continue; - case VCL_TEST_TYPE_NONE: + case HS_TEST_TYPE_NONE: default: break; } switch (vcm->post_test) { - case VCL_TEST_TYPE_EXIT: + case HS_TEST_TYPE_EXIT: + case HS_TEST_TYPE_EXIT_CLIENT: switch (ctrl->cfg.test) { - case VCL_TEST_TYPE_EXIT: - case VCL_TEST_TYPE_UNI: - case VCL_TEST_TYPE_BI: - case VCL_TEST_TYPE_ECHO: - ctrl->cfg.test = VCL_TEST_TYPE_EXIT; + case HS_TEST_TYPE_EXIT: + case HS_TEST_TYPE_UNI: + case HS_TEST_TYPE_BI: + case HS_TEST_TYPE_ECHO: + ctrl->cfg.test = HS_TEST_TYPE_EXIT; continue; - case VCL_TEST_TYPE_NONE: + case HS_TEST_TYPE_NONE: default: break; } break; - case VCL_TEST_TYPE_NONE: - case VCL_TEST_TYPE_ECHO: - case VCL_TEST_TYPE_UNI: - case VCL_TEST_TYPE_BI: + case HS_TEST_TYPE_NONE: + case HS_TEST_TYPE_ECHO: + case HS_TEST_TYPE_UNI: + case HS_TEST_TYPE_BI: default: break; } diff --git a/src/plugins/hs_apps/vcl/vcl_test_protos.c b/src/plugins/hs_apps/vcl/vcl_test_protos.c index 60ee09265c9..cd1ac2b24f4 100644 --- a/src/plugins/hs_apps/vcl/vcl_test_protos.c +++ b/src/plugins/hs_apps/vcl/vcl_test_protos.c @@ -21,16 +21,15 @@ vt_tcp_connect (vcl_test_session_t *ts, vppcom_endpt_t *endpt) uint32_t flags, flen; int rv; - ts->fd = vppcom_session_create (VPPCOM_PROTO_TCP, 0 /* is_nonblocking */); + ts->fd = vppcom_session_create (VPPCOM_PROTO_TCP, ts->noblk_connect); if (ts->fd < 0) { vterr ("vppcom_session_create()", ts->fd); return ts->fd; } - /* Connect is blocking */ rv = vppcom_session_connect (ts->fd, endpt); - if (rv < 0) + if (rv < 0 && rv != VPPCOM_EINPROGRESS) { vterr ("vppcom_session_connect()", rv); return rv; @@ -38,10 +37,14 @@ vt_tcp_connect (vcl_test_session_t *ts, vppcom_endpt_t *endpt) ts->read = vcl_test_read; ts->write = vcl_test_write; - flags = O_NONBLOCK; - flen = sizeof (flags); - vppcom_session_attr (ts->fd, VPPCOM_ATTR_SET_FLAGS, &flags, &flen); - vtinf ("Test session %d (fd %d) connected.", ts->session_index, ts->fd); + + if (!ts->noblk_connect) + { + flags = O_NONBLOCK; + flen = sizeof (flags); + vppcom_session_attr (ts->fd, VPPCOM_ATTR_SET_FLAGS, &flags, &flen); + vtinf ("Test session %d (fd %d) connected.", ts->session_index, ts->fd); + } return 0; } @@ -108,16 +111,15 @@ vt_udp_connect (vcl_test_session_t *ts, vppcom_endpt_t *endpt) uint32_t flags, flen; int rv; - ts->fd = vppcom_session_create (VPPCOM_PROTO_UDP, 0 /* is_nonblocking */); + ts->fd = vppcom_session_create (VPPCOM_PROTO_UDP, ts->noblk_connect); if (ts->fd < 0) { vterr ("vppcom_session_create()", ts->fd); return ts->fd; } - /* Connect is blocking */ rv = vppcom_session_connect (ts->fd, endpt); - if (rv < 0) + if (rv < 0 && rv != VPPCOM_EINPROGRESS) { vterr ("vppcom_session_connect()", rv); return rv; @@ -125,10 +127,14 @@ vt_udp_connect (vcl_test_session_t *ts, vppcom_endpt_t *endpt) ts->read = vcl_test_read; ts->write = vcl_test_write; - flags = O_NONBLOCK; - flen = sizeof (flags); - vppcom_session_attr (ts->fd, VPPCOM_ATTR_SET_FLAGS, &flags, &flen); - vtinf ("Test session %d (fd %d) connected.", ts->session_index, ts->fd); + + if (!ts->noblk_connect) + { + flags = O_NONBLOCK; + flen = sizeof (flags); + vppcom_session_attr (ts->fd, VPPCOM_ATTR_SET_FLAGS, &flags, &flen); + vtinf ("Test session %d (fd %d) connected.", ts->session_index, ts->fd); + } return 0; } @@ -270,7 +276,7 @@ vt_add_cert_key_pair () } static int -vt_tls_init (vcl_test_cfg_t *cfg) +vt_tls_init (hs_test_cfg_t *cfg) { return vt_add_cert_key_pair (); } @@ -282,7 +288,7 @@ vt_tls_connect (vcl_test_session_t *ts, vppcom_endpt_t *endpt) uint32_t flags, flen, ckp_len; int rv; - ts->fd = vppcom_session_create (VPPCOM_PROTO_TLS, 0 /* is_nonblocking */); + ts->fd = vppcom_session_create (VPPCOM_PROTO_TLS, ts->noblk_connect); if (ts->fd < 0) { vterr ("vppcom_session_create()", ts->fd); @@ -293,9 +299,8 @@ vt_tls_connect (vcl_test_session_t *ts, vppcom_endpt_t *endpt) vppcom_session_attr (ts->fd, VPPCOM_ATTR_SET_CKPAIR, &vt->ckpair_index, &ckp_len); - /* Connect is blocking */ rv = vppcom_session_connect (ts->fd, endpt); - if (rv < 0) + if (rv < 0 && rv != VPPCOM_EINPROGRESS) { vterr ("vppcom_session_connect()", rv); return rv; @@ -303,10 +308,14 @@ vt_tls_connect (vcl_test_session_t *ts, vppcom_endpt_t *endpt) ts->read = vcl_test_read; ts->write = vcl_test_write; - flags = O_NONBLOCK; - flen = sizeof (flags); - vppcom_session_attr (ts->fd, VPPCOM_ATTR_SET_FLAGS, &flags, &flen); - vtinf ("Test session %d (fd %d) connected.", ts->session_index, ts->fd); + + if (!ts->noblk_connect) + { + flags = O_NONBLOCK; + flen = sizeof (flags); + vppcom_session_attr (ts->fd, VPPCOM_ATTR_SET_FLAGS, &flags, &flen); + vtinf ("Test session %d (fd %d) connected.", ts->session_index, ts->fd); + } return 0; } @@ -375,7 +384,7 @@ static const vcl_test_proto_vft_t vcl_test_tls = { VCL_TEST_REGISTER_PROTO (VPPCOM_PROTO_TLS, vcl_test_tls); static int -vt_dtls_init (vcl_test_cfg_t *cfg) +vt_dtls_init (hs_test_cfg_t *cfg) { return vt_add_cert_key_pair (); } @@ -387,7 +396,7 @@ vt_dtls_connect (vcl_test_session_t *ts, vppcom_endpt_t *endpt) uint32_t flags, flen, ckp_len; int rv; - ts->fd = vppcom_session_create (VPPCOM_PROTO_DTLS, 0 /* is_nonblocking */); + ts->fd = vppcom_session_create (VPPCOM_PROTO_DTLS, ts->noblk_connect); if (ts->fd < 0) { vterr ("vppcom_session_create()", ts->fd); @@ -398,9 +407,8 @@ vt_dtls_connect (vcl_test_session_t *ts, vppcom_endpt_t *endpt) vppcom_session_attr (ts->fd, VPPCOM_ATTR_SET_CKPAIR, &vt->ckpair_index, &ckp_len); - /* Connect is blocking */ rv = vppcom_session_connect (ts->fd, endpt); - if (rv < 0) + if (rv < 0 && rv != VPPCOM_EINPROGRESS) { vterr ("vppcom_session_connect()", rv); return rv; @@ -408,10 +416,14 @@ vt_dtls_connect (vcl_test_session_t *ts, vppcom_endpt_t *endpt) ts->read = vcl_test_read; ts->write = vcl_test_write; - flags = O_NONBLOCK; - flen = sizeof (flags); - vppcom_session_attr (ts->fd, VPPCOM_ATTR_SET_FLAGS, &flags, &flen); - vtinf ("Test session %d (fd %d) connected.", ts->session_index, ts->fd); + + if (!ts->noblk_connect) + { + flags = O_NONBLOCK; + flen = sizeof (flags); + vppcom_session_attr (ts->fd, VPPCOM_ATTR_SET_FLAGS, &flags, &flen); + vtinf ("Test session %d (fd %d) connected.", ts->session_index, ts->fd); + } return 0; } @@ -480,7 +492,7 @@ static const vcl_test_proto_vft_t vcl_test_dtls = { VCL_TEST_REGISTER_PROTO (VPPCOM_PROTO_DTLS, vcl_test_dtls); static int -vt_quic_init (vcl_test_cfg_t *cfg) +vt_quic_init (hs_test_cfg_t *cfg) { vcl_test_main_t *vt = &vcl_test_main; @@ -568,7 +580,7 @@ vt_quic_connect (vcl_test_session_t *ts, vppcom_endpt_t *endpt) /* Make sure qsessions are initialized */ vt_quic_maybe_init_wrk (vt, wrk, endpt); - ts->fd = vppcom_session_create (VPPCOM_PROTO_QUIC, 0 /* is_nonblocking */); + ts->fd = vppcom_session_create (VPPCOM_PROTO_QUIC, ts->noblk_connect); if (ts->fd < 0) { vterr ("vppcom_session_create()", ts->fd); @@ -579,21 +591,23 @@ vt_quic_connect (vcl_test_session_t *ts, vppcom_endpt_t *endpt) tq = &wrk->qsessions[ts->session_index / vt->cfg.num_test_sessions_perq]; rv = vppcom_session_stream_connect (ts->fd, tq->fd); - if (rv < 0) + if (rv < 0 && rv != VPPCOM_EINPROGRESS) { vterr ("vppcom_session_stream_connect()", rv); return rv; } - flags = O_NONBLOCK; - flen = sizeof (flags); - vppcom_session_attr (ts->fd, VPPCOM_ATTR_SET_FLAGS, &flags, &flen); - ts->read = vcl_test_read; ts->write = vcl_test_write; - vtinf ("Test (quic stream) session %d (fd %d) connected.", ts->session_index, - ts->fd); + if (!ts->noblk_connect) + { + flags = O_NONBLOCK; + flen = sizeof (flags); + vppcom_session_attr (ts->fd, VPPCOM_ATTR_SET_FLAGS, &flags, &flen); + vtinf ("Test (quic stream) session %d (fd %d) connected.", + ts->session_index, ts->fd); + } return 0; } @@ -864,7 +878,7 @@ vt_srtp_connect (vcl_test_session_t *ts, vppcom_endpt_t *endpt) uint32_t flags, flen; int rv; - ts->fd = vppcom_session_create (VPPCOM_PROTO_SRTP, 0 /* is_nonblocking */); + ts->fd = vppcom_session_create (VPPCOM_PROTO_SRTP, ts->noblk_connect); if (ts->fd < 0) { vterr ("vppcom_session_create()", ts->fd); @@ -873,9 +887,8 @@ vt_srtp_connect (vcl_test_session_t *ts, vppcom_endpt_t *endpt) vt_session_add_srtp_policy (ts, 1 /* is connect */); - /* Connect is blocking */ rv = vppcom_session_connect (ts->fd, endpt); - if (rv < 0) + if (rv < 0 && rv != VPPCOM_EINPROGRESS) { vterr ("vppcom_session_connect()", rv); return rv; @@ -883,10 +896,14 @@ vt_srtp_connect (vcl_test_session_t *ts, vppcom_endpt_t *endpt) ts->read = vt_srtp_read; ts->write = vt_srtp_write; - flags = O_NONBLOCK; - flen = sizeof (flags); - vppcom_session_attr (ts->fd, VPPCOM_ATTR_SET_FLAGS, &flags, &flen); - vtinf ("Test session %d (fd %d) connected.", ts->session_index, ts->fd); + + if (!ts->noblk_connect) + { + flags = O_NONBLOCK; + flen = sizeof (flags); + vppcom_session_attr (ts->fd, VPPCOM_ATTR_SET_FLAGS, &flags, &flen); + vtinf ("Test session %d (fd %d) connected.", ts->session_index, ts->fd); + } vt_srtp_session_init (ts, 1 /* is connect */); diff --git a/src/plugins/hs_apps/vcl/vcl_test_server.c b/src/plugins/hs_apps/vcl/vcl_test_server.c index 93c244484c8..d17a2089ba7 100644 --- a/src/plugins/hs_apps/vcl/vcl_test_server.c +++ b/src/plugins/hs_apps/vcl/vcl_test_server.c @@ -28,6 +28,17 @@ #include <vppinfra/mem.h> #include <pthread.h> +/* + * XXX: Unfortunately libepoll-shim requires some hacks to work, one of these + * defines 'close' as a macro. This collides with vcl test callback 'close'. + * Undef the 'close' macro on FreeBSD if it exists. + */ +#ifdef __FreeBSD__ +#ifdef close +#undef close +#endif +#endif /* __FreeBSD__ */ + typedef struct { uint16_t port; @@ -106,7 +117,7 @@ again: conn->endpt.ip = wrk->conn_pool[i].ip; conn->is_alloc = 1; conn->session_index = i; - vcl_test_cfg_init (&conn->cfg); + hs_test_cfg_init (&conn->cfg); return (&wrk->conn_pool[i]); } } @@ -130,7 +141,7 @@ conn_pool_free (vcl_test_session_t *ts) } static inline void -sync_config_and_reply (vcl_test_session_t *conn, vcl_test_cfg_t *rx_cfg) +sync_config_and_reply (vcl_test_session_t *conn, hs_test_cfg_t *rx_cfg) { conn->cfg = *rx_cfg; vcl_test_buf_alloc (&conn->cfg, 1 /* is_rxbuf */, (uint8_t **) &conn->rxbuf, @@ -140,7 +151,7 @@ sync_config_and_reply (vcl_test_session_t *conn, vcl_test_cfg_t *rx_cfg) if (conn->cfg.verbose) { vtinf ("(fd %d): Replying to cfg message!\n", conn->fd); - vcl_test_cfg_dump (&conn->cfg, 0 /* is_client */ ); + hs_test_cfg_dump (&conn->cfg, 0 /* is_client */); } (void) vcl_test_write (conn, &conn->cfg, sizeof (conn->cfg)); } @@ -185,14 +196,14 @@ vts_wrk_cleanup_all (vcl_test_server_worker_t *wrk) static void vts_test_cmd (vcl_test_server_worker_t *wrk, vcl_test_session_t *conn, - vcl_test_cfg_t *rx_cfg) + hs_test_cfg_t *rx_cfg) { - u8 is_bi = rx_cfg->test == VCL_TEST_TYPE_BI; + u8 is_bi = rx_cfg->test == HS_TEST_TYPE_BI; vcl_test_session_t *tc; char buf[64]; int i; - if (rx_cfg->cmd == VCL_TEST_CMD_STOP) + if (rx_cfg->cmd == HS_TEST_CMD_STOP) { struct timespec stop; clock_gettime (CLOCK_REALTIME, &stop); @@ -232,25 +243,25 @@ vts_test_cmd (vcl_test_server_worker_t *wrk, vcl_test_session_t *conn, vcl_test_stats_dump ("SERVER RESULTS", &conn->stats, 1 /* show_rx */ , is_bi /* show_tx */ , conn->cfg.verbose); - vcl_test_cfg_dump (&conn->cfg, 0 /* is_client */ ); + hs_test_cfg_dump (&conn->cfg, 0 /* is_client */); if (conn->cfg.verbose) { - vtinf (" vcl server main\n" VCL_TEST_SEPARATOR_STRING + vtinf (" vcl server main\n" HS_TEST_SEPARATOR_STRING " buf: %p\n" - " buf size: %u (0x%08x)\n" VCL_TEST_SEPARATOR_STRING, + " buf size: %u (0x%08x)\n" HS_TEST_SEPARATOR_STRING, conn->rxbuf, conn->rxbuf_size, conn->rxbuf_size); } sync_config_and_reply (conn, rx_cfg); memset (&conn->stats, 0, sizeof (conn->stats)); } - else if (rx_cfg->cmd == VCL_TEST_CMD_SYNC) + else if (rx_cfg->cmd == HS_TEST_CMD_SYNC) { rx_cfg->ctrl_handle = conn->fd; vtinf ("Set control fd %d for test!", conn->fd); sync_config_and_reply (conn, rx_cfg); } - else if (rx_cfg->cmd == VCL_TEST_CMD_START) + else if (rx_cfg->cmd == HS_TEST_CMD_START) { vtinf ("Starting %s-directional Stream Test (fd %d)!", is_bi ? "Bi" : "Uni", conn->fd); @@ -268,7 +279,7 @@ vts_server_process_rx (vcl_test_session_t *conn, int rx_bytes) { vcl_test_server_main_t *vsm = &vcl_server_main; - if (conn->cfg.test == VCL_TEST_TYPE_BI) + if (conn->cfg.test == HS_TEST_TYPE_BI) { if (vsm->use_ds) { @@ -373,8 +384,9 @@ vts_accept_client (vcl_test_server_worker_t *wrk, int listen_fd) if (tp->accept (listen_fd, conn)) return 0; - vtinf ("Got a connection -- fd = %d (0x%08x) on listener fd = %d (0x%08x)", - conn->fd, conn->fd, listen_fd, listen_fd); + if (conn->cfg.num_test_sessions < VCL_TEST_CFG_MAX_SELECT_SESS) + vtinf ("Got a connection -- fd = %d (0x%08x) on listener fd = %d (0x%08x)", + conn->fd, conn->fd, listen_fd, listen_fd); ev.events = EPOLLET | EPOLLIN; ev.data.u64 = conn - wrk->conn_pool; @@ -502,31 +514,33 @@ vcl_test_server_process_opts (vcl_test_server_main_t * vsm, int argc, print_usage_and_exit (); } - if (argc < (optind + 1)) + if (argc > (optind + 1)) { - fprintf (stderr, "SERVER: ERROR: Insufficient number of arguments!\n"); + fprintf (stderr, "Incorrect number of arguments!\n"); print_usage_and_exit (); } - - if (sscanf (argv[optind], "%d", &v) == 1) - vsm->server_cfg.port = (uint16_t) v; - else + else if (argc > 1 && argc == (optind + 1)) { - fprintf (stderr, "SERVER: ERROR: Invalid port (%s)!\n", argv[optind]); - print_usage_and_exit (); + if (sscanf (argv[optind], "%d", &v) == 1) + vsm->server_cfg.port = (uint16_t) v; + else + { + fprintf (stderr, "Invalid port (%s)!\n", argv[optind]); + print_usage_and_exit (); + } } vcl_test_init_endpoint_addr (vsm); } int -vts_handle_ctrl_cfg (vcl_test_server_worker_t *wrk, vcl_test_cfg_t *rx_cfg, +vts_handle_ctrl_cfg (vcl_test_server_worker_t *wrk, hs_test_cfg_t *rx_cfg, vcl_test_session_t *conn, int rx_bytes) { if (rx_cfg->verbose) { vtinf ("(fd %d): Received a cfg msg!", conn->fd); - vcl_test_cfg_dump (rx_cfg, 0 /* is_client */ ); + hs_test_cfg_dump (rx_cfg, 0 /* is_client */); } if (rx_bytes != sizeof (*rx_cfg)) @@ -538,7 +552,7 @@ vts_handle_ctrl_cfg (vcl_test_server_worker_t *wrk, vcl_test_cfg_t *rx_cfg, if (conn->cfg.verbose) { vtinf ("(fd %d): Replying to cfg msg", conn->fd); - vcl_test_cfg_dump (rx_cfg, 0 /* is_client */ ); + hs_test_cfg_dump (rx_cfg, 0 /* is_client */); } conn->write (conn, &conn->cfg, sizeof (conn->cfg)); return -1; @@ -546,27 +560,28 @@ vts_handle_ctrl_cfg (vcl_test_server_worker_t *wrk, vcl_test_cfg_t *rx_cfg, switch (rx_cfg->test) { - case VCL_TEST_TYPE_NONE: - case VCL_TEST_TYPE_ECHO: + case HS_TEST_TYPE_NONE: + case HS_TEST_TYPE_ECHO: sync_config_and_reply (conn, rx_cfg); break; - case VCL_TEST_TYPE_BI: - case VCL_TEST_TYPE_UNI: + case HS_TEST_TYPE_BI: + case HS_TEST_TYPE_UNI: vts_test_cmd (wrk, conn, rx_cfg); break; - case VCL_TEST_TYPE_EXIT: + case HS_TEST_TYPE_EXIT: vtinf ("Ctrl session fd %d closing!", conn->fd); vts_session_cleanup (conn); wrk->nfds--; if (wrk->nfds) vts_wrk_cleanup_all (wrk); + vcl_server_main.ctrl = 0; break; default: vtwrn ("Unknown test type %d", rx_cfg->test); - vcl_test_cfg_dump (rx_cfg, 0 /* is_client */ ); + hs_test_cfg_dump (rx_cfg, 0 /* is_client */); break; } @@ -586,7 +601,7 @@ vts_worker_init (vcl_test_server_worker_t * wrk) vtinf ("Initializing worker ..."); - conn_pool_expand (wrk, VCL_TEST_CFG_MAX_TEST_SESS + 1); + conn_pool_expand (wrk, VCL_TEST_CFG_INIT_TEST_SESS + 1); if (wrk->wrk_index) if (vppcom_worker_register ()) vtfail ("vppcom_worker_register()", 1); @@ -648,7 +663,7 @@ vts_worker_loop (void *arg) vcl_test_server_worker_t *wrk = arg; vcl_test_session_t *conn; int i, rx_bytes, num_ev; - vcl_test_cfg_t *rx_cfg; + hs_test_cfg_t *rx_cfg; if (wrk->wrk_index) vts_worker_init (wrk); @@ -675,13 +690,13 @@ vts_worker_loop (void *arg) */ if (ep_evts[i].events & (EPOLLHUP | EPOLLRDHUP)) { - vts_session_cleanup (conn); - wrk->nfds--; - if (!wrk->nfds) + if (conn == vsm->ctrl) { - vtinf ("All client connections closed\n"); - goto done; + vtinf ("ctrl session went away"); + vsm->ctrl = 0; } + vts_session_cleanup (conn); + wrk->nfds--; continue; } @@ -699,6 +714,10 @@ vts_worker_loop (void *arg) vsm->ctrl = vts_accept_ctrl (wrk, vsm->ctrl_listen_fd); continue; } + + /* at this point ctrl session must be valid */ + ASSERT (vsm->ctrl); + if (ep_evts[i].data.u32 == VCL_TEST_DATA_LISTENER) { conn = vts_accept_client (wrk, wrk->listener.fd); @@ -718,8 +737,8 @@ vts_worker_loop (void *arg) if (!wrk->wrk_index && conn->fd == vsm->ctrl->fd) { rx_bytes = conn->read (conn, conn->rxbuf, conn->rxbuf_size); - rx_cfg = (vcl_test_cfg_t *) conn->rxbuf; - if (rx_cfg->magic == VCL_TEST_CFG_CTRL_MAGIC) + rx_cfg = (hs_test_cfg_t *) conn->rxbuf; + if (rx_cfg->magic == HS_TEST_CFG_CTRL_MAGIC) { vts_handle_ctrl_cfg (wrk, rx_cfg, conn, rx_bytes); if (!wrk->nfds) @@ -847,13 +866,15 @@ main (int argc, char **argv) vts_ctrl_session_init (&vsm->workers[0]); /* Update ctrl port to data port */ - vsm->server_cfg.endpt.port += 1; + vsm->server_cfg.endpt.port = hs_make_data_port (vsm->server_cfg.endpt.port); vts_worker_init (&vsm->workers[0]); for (i = 1; i < vsm->server_cfg.workers; i++) { vsm->workers[i].wrk_index = i; rv = pthread_create (&vsm->workers[i].thread_handle, NULL, vts_worker_loop, (void *) &vsm->workers[i]); + if (rv) + vtfail ("pthread_create()", rv); } vts_worker_loop (&vsm->workers[0]); |