X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvcl%2Fvcl_test_server.c;h=54f164e43c1514c94eff5faf8d2b377cd599ffdb;hb=c1f5a43;hp=98c36a43f3e493084090f122538d083ff25a6cfd;hpb=6a5adc369591fcac2447e9809deaa22f56b53911;p=vpp.git diff --git a/src/vcl/vcl_test_server.c b/src/vcl/vcl_test_server.c index 98c36a43f3e..54f164e43c1 100644 --- a/src/vcl/vcl_test_server.c +++ b/src/vcl/vcl_test_server.c @@ -26,6 +26,7 @@ #include #include #include +#include typedef struct { @@ -33,177 +34,186 @@ typedef struct int fd; uint8_t *buf; uint32_t buf_size; - sock_test_cfg_t cfg; - sock_test_stats_t stats; + vcl_test_cfg_t cfg; + vcl_test_stats_t stats; vppcom_endpt_t endpt; uint8_t ip[16]; -} sock_server_conn_t; + vppcom_data_segments_t ds; +} vcl_test_server_conn_t; typedef struct { - uint32_t port; + uint16_t port; uint32_t address_ip6; - uint32_t transport_udp; -} sock_server_cfg_t; + u8 proto; + u8 workers; + vppcom_endpt_t endpt; +} vcl_test_server_cfg_t; -#define SOCK_SERVER_MAX_TEST_CONN 10 -#define SOCK_SERVER_MAX_EPOLL_EVENTS 10 typedef struct { + uint32_t wrk_index; int listen_fd; - sock_server_cfg_t cfg; int epfd; - struct epoll_event listen_ev; - struct epoll_event wait_events[SOCK_SERVER_MAX_EPOLL_EVENTS]; - size_t num_conn; + struct epoll_event wait_events[VCL_TEST_CFG_MAX_EPOLL_EVENTS]; size_t conn_pool_size; - sock_server_conn_t *conn_pool; + vcl_test_server_conn_t *conn_pool; int nfds; - fd_set rd_fdset; - fd_set wr_fdset; - struct timeval timeout; -} sock_server_main_t; + pthread_t thread_handle; +} vcl_test_server_worker_t; + +typedef struct +{ + vcl_test_server_cfg_t cfg; + vcl_test_server_worker_t *workers; + + struct sockaddr_storage servaddr; + volatile int worker_fails; + volatile int active_workers; + u8 use_ds; +} vcl_test_server_main_t; -sock_server_main_t sock_server_main; +static __thread int __wrk_index = 0; + +static vcl_test_server_main_t vcl_server_main; static inline void -conn_pool_expand (size_t expand_size) +conn_pool_expand (vcl_test_server_worker_t * wrk, size_t expand_size) { - sock_server_main_t *ssm = &sock_server_main; - sock_server_conn_t *conn_pool; - size_t new_size = ssm->conn_pool_size + expand_size; + vcl_test_server_conn_t *conn_pool; + size_t new_size = wrk->conn_pool_size + expand_size; int i; - conn_pool = realloc (ssm->conn_pool, new_size * sizeof (*ssm->conn_pool)); + conn_pool = realloc (wrk->conn_pool, new_size * sizeof (*wrk->conn_pool)); if (conn_pool) { - for (i = ssm->conn_pool_size; i < new_size; i++) + for (i = wrk->conn_pool_size; i < new_size; i++) { - sock_server_conn_t *conn = &conn_pool[i]; + vcl_test_server_conn_t *conn = &conn_pool[i]; memset (conn, 0, sizeof (*conn)); - sock_test_cfg_init (&conn->cfg); - sock_test_buf_alloc (&conn->cfg, 1 /* is_rxbuf */ , - &conn->buf, &conn->buf_size); + vcl_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; } - ssm->conn_pool = conn_pool; - ssm->conn_pool_size = new_size; + wrk->conn_pool = conn_pool; + wrk->conn_pool_size = new_size; } else { - int errno_val = errno; - perror ("ERROR in conn_pool_expand()"); - fprintf (stderr, "SERVER: ERROR: Memory allocation " - "failed (errno = %d)!\n", errno_val); + vterr ("conn_pool_expand()", -errno); } } -static inline sock_server_conn_t * -conn_pool_alloc (void) +static inline vcl_test_server_conn_t * +conn_pool_alloc (vcl_test_server_worker_t * wrk) { - sock_server_main_t *ssm = &sock_server_main; - int i; + int i, expand = 0; - for (i = 0; i < ssm->conn_pool_size; i++) +again: + for (i = 0; i < wrk->conn_pool_size; i++) { - if (!ssm->conn_pool[i].is_alloc) + if (!wrk->conn_pool[i].is_alloc) { - ssm->conn_pool[i].endpt.ip = ssm->conn_pool[i].ip; - ssm->conn_pool[i].is_alloc = 1; - return (&ssm->conn_pool[i]); + wrk->conn_pool[i].endpt.ip = wrk->conn_pool[i].ip; + wrk->conn_pool[i].is_alloc = 1; + return (&wrk->conn_pool[i]); } } + if (expand == 0) + { + conn_pool_expand (wrk, 2 * wrk->conn_pool_size); + expand = 1; + goto again; + } + vtwrn ("Failed to allocate connection even after expand"); return 0; } static inline void -conn_pool_free (sock_server_conn_t * conn) +conn_pool_free (vcl_test_server_conn_t * conn) { conn->fd = 0; conn->is_alloc = 0; } static inline void -sync_config_and_reply (sock_server_conn_t * conn, sock_test_cfg_t * rx_cfg) +sync_config_and_reply (vcl_test_server_conn_t * conn, vcl_test_cfg_t * rx_cfg) { conn->cfg = *rx_cfg; - sock_test_buf_alloc (&conn->cfg, 1 /* is_rxbuf */ , - &conn->buf, &conn->buf_size); + vcl_test_buf_alloc (&conn->cfg, 1 /* is_rxbuf */ , + &conn->buf, &conn->buf_size); conn->cfg.txbuf_size = conn->cfg.rxbuf_size; if (conn->cfg.verbose) { - printf ("\nSERVER (fd %d): Replying to cfg message!\n", conn->fd); - sock_test_cfg_dump (&conn->cfg, 0 /* is_client */ ); + vtinf ("(fd %d): Replying to cfg message!\n", conn->fd); + vcl_test_cfg_dump (&conn->cfg, 0 /* is_client */ ); } (void) vcl_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, - sock_test_cfg_t * rx_cfg) +vts_server_start_stop (vcl_test_server_worker_t * wrk, + vcl_test_server_conn_t * conn, vcl_test_cfg_t * rx_cfg) { - sock_server_main_t *ssm = &sock_server_main; - int client_fd = conn->fd; - sock_test_t test = rx_cfg->test; + u8 is_bi = rx_cfg->test == VCL_TEST_TYPE_BI; + vcl_test_server_conn_t *tc; + char buf[64]; + int i; if (rx_cfg->ctrl_handle == conn->fd) { - int i; - clock_gettime (CLOCK_REALTIME, &conn->stats.stop); - - for (i = 0; i < ssm->conn_pool_size; i++) + for (i = 0; i < wrk->conn_pool_size; i++) { - sock_server_conn_t *tc = &ssm->conn_pool[i]; - - if (tc->cfg.ctrl_handle == conn->fd) + tc = &wrk->conn_pool[i]; + if (tc->cfg.ctrl_handle != conn->fd) + continue; + + vcl_test_stats_accumulate (&conn->stats, &tc->stats); + if (vcl_comp_tspec (&conn->stats.stop, &tc->stats.stop) < 0) + conn->stats.stop = tc->stats.stop; + /* Client delays sending of disconnect */ + conn->stats.stop.tv_sec -= VCL_TEST_DELAY_DISCONNECT; + if (conn->cfg.verbose) { - sock_test_stats_accumulate (&conn->stats, &tc->stats); - - if (conn->cfg.verbose) - { - static char buf[64]; - - sprintf (buf, "SERVER (fd %d) RESULTS", tc->fd); - sock_test_stats_dump (buf, &tc->stats, 1 /* show_rx */ , - test == SOCK_TEST_TYPE_BI - /* show tx */ , - conn->cfg.verbose); - } + sprintf (buf, "SERVER (fd %d) RESULTS", tc->fd); + vcl_test_stats_dump (buf, &tc->stats, 1 /* show_rx */ , + is_bi /* show tx */ , conn->cfg.verbose); } } - sock_test_stats_dump ("SERVER RESULTS", &conn->stats, 1 /* show_rx */ , - (test == SOCK_TEST_TYPE_BI) /* show_tx */ , - conn->cfg.verbose); - sock_test_cfg_dump (&conn->cfg, 0 /* is_client */ ); + 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 */ ); if (conn->cfg.verbose) { - printf (" sock server main\n" - SOCK_TEST_SEPARATOR_STRING - " buf: %p\n" - " buf size: %u (0x%08x)\n" - SOCK_TEST_SEPARATOR_STRING, - conn->buf, conn->buf_size, conn->buf_size); + vtinf (" vcl server main\n" + VCL_TEST_SEPARATOR_STRING + " buf: %p\n" + " buf size: %u (0x%08x)\n" + VCL_TEST_SEPARATOR_STRING, + conn->buf, conn->buf_size, conn->buf_size); } sync_config_and_reply (conn, rx_cfg); - printf ("\nSERVER (fd %d): %s-directional Stream Test Complete!\n" - SOCK_TEST_BANNER_STRING "\n", conn->fd, - test == SOCK_TEST_TYPE_BI ? "Bi" : "Uni"); + memset (&conn->stats, 0, sizeof (conn->stats)); } else { - printf ("\n" 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 == SOCK_TEST_TYPE_BI ? "Bi" : "Uni"); - - rx_cfg->ctrl_handle = (rx_cfg->ctrl_handle == ~0) ? conn->fd : - rx_cfg->ctrl_handle; + if (rx_cfg->ctrl_handle == ~0) + { + rx_cfg->ctrl_handle = conn->fd; + vtinf ("Set control fd %d for test!", conn->fd); + } + else + { + vtinf ("Starting %s-directional Stream Test (fd %d)!", + is_bi ? "Bi" : "Uni", conn->fd); + } sync_config_and_reply (conn, rx_cfg); @@ -213,128 +223,182 @@ stream_test_server_start_stop (sock_server_conn_t * conn, } } - static inline void -stream_test_server (sock_server_conn_t * conn, int rx_bytes) +vts_server_rx (vcl_test_server_conn_t * conn, int rx_bytes) { + vcl_test_server_main_t *vsm = &vcl_server_main; int client_fd = conn->fd; - sock_test_t test = conn->cfg.test; - - if (test == SOCK_TEST_TYPE_BI) - (void) vcl_test_write (client_fd, conn->buf, rx_bytes, &conn->stats, - conn->cfg.verbose); - if (conn->stats.rx_bytes >= conn->cfg.total_bytes) + if (conn->cfg.test == VCL_TEST_TYPE_BI) { - clock_gettime (CLOCK_REALTIME, &conn->stats.stop); + if (vsm->use_ds) + { + (void) vcl_test_write (client_fd, conn->ds[0].data, conn->ds[0].len, + &conn->stats, conn->cfg.verbose); + if (conn->ds[1].len) + (void) vcl_test_write (client_fd, conn->ds[1].data, + conn->ds[1].len, &conn->stats, + conn->cfg.verbose); + } + else + (void) vcl_test_write (client_fd, conn->buf, rx_bytes, &conn->stats, + conn->cfg.verbose); } + + if (vsm->use_ds) + vppcom_session_free_segments (conn->fd, conn->ds); + + if (conn->stats.rx_bytes >= conn->cfg.total_bytes) + clock_gettime (CLOCK_REALTIME, &conn->stats.stop); } -static inline void -new_client (void) +static void +vts_server_echo (vcl_test_server_conn_t * conn, int rx_bytes) { - sock_server_main_t *ssm = &sock_server_main; - int client_fd; - sock_server_conn_t *conn; + vcl_test_server_main_t *vsm = &vcl_server_main; + int tx_bytes, nbytes, pos; + + if (vsm->use_ds) + vppcom_data_segment_copy (conn->buf, conn->ds, rx_bytes); - if (ssm->conn_pool_size < (ssm->num_conn + SOCK_SERVER_MAX_TEST_CONN + 1)) - conn_pool_expand (SOCK_SERVER_MAX_TEST_CONN + 1); + /* If it looks vaguely like a string, make sure it's terminated */ + pos = rx_bytes < conn->buf_size ? rx_bytes : conn->buf_size - 1; + ((char *) conn->buf)[pos] = 0; + vtinf ("(fd %d): RX (%d bytes) - '%s'", conn->fd, rx_bytes, conn->buf); - conn = conn_pool_alloc (); + if (conn->cfg.verbose) + vtinf ("(fd %d): Echoing back", conn->fd); + + nbytes = strlen ((const char *) conn->buf) + 1; + tx_bytes = vcl_test_write (conn->fd, conn->buf, nbytes, &conn->stats, + conn->cfg.verbose); + if (tx_bytes >= 0) + vtinf ("(fd %d): TX (%d bytes) - '%s'", conn->fd, tx_bytes, conn->buf); +} + +static void +vts_new_client (vcl_test_server_worker_t * wrk) +{ + vcl_test_server_conn_t *conn; + struct epoll_event ev; + int rv, client_fd; + + conn = conn_pool_alloc (wrk); if (!conn) { - fprintf (stderr, "\nSERVER: ERROR: No free connections!\n"); + vtwrn ("No free connections!"); return; } - client_fd = vppcom_session_accept (ssm->listen_fd, &conn->endpt, 0); + client_fd = vppcom_session_accept (wrk->listen_fd, &conn->endpt, 0); if (client_fd < 0) { - int errno_val; - errno_val = errno = -client_fd; - perror ("ERROR in new_client()"); - fprintf (stderr, "SERVER: ERROR: accept failed " - "(errno = %d)!\n", errno_val); + vterr ("vppcom_session_accept()", client_fd); return; } - - printf ("SERVER: Got a connection -- fd = %d (0x%08x)!\n", - client_fd, client_fd); - conn->fd = client_fd; - { - struct epoll_event ev; - int rv; + vtinf ("Got a connection -- fd = %d (0x%08x)!", client_fd, client_fd); - ev.events = EPOLLIN; - ev.data.u64 = conn - ssm->conn_pool; - rv = vppcom_epoll_ctl (ssm->epfd, EPOLL_CTL_ADD, client_fd, &ev); - if (rv < 0) - { - int errno_val; - errno_val = errno = -rv; - perror ("ERROR in new_client()"); - fprintf (stderr, "SERVER: ERROR: epoll_ctl failed (errno = %d)!\n", - errno_val); - } - else - ssm->nfds++; - } + ev.events = EPOLLIN; + ev.data.u64 = conn - wrk->conn_pool; + rv = vppcom_epoll_ctl (wrk->epfd, EPOLL_CTL_ADD, client_fd, &ev); + if (rv < 0) + { + vterr ("vppcom_epoll_ctl()", rv); + return; + } + wrk->nfds++; } -void +static void print_usage_and_exit (void) { fprintf (stderr, - "sock_test_server [OPTIONS] \n" + "vcl_test_server [OPTIONS] \n" " OPTIONS\n" " -h Print this message and exit.\n" " -6 Use IPv6\n" + " -w Number of workers\n" " -u Use UDP transport layer\n"); exit (1); } -int -main (int argc, char **argv) +static void +vcl_test_init_endpoint_addr (vcl_test_server_main_t * vsm) { - sock_server_main_t *ssm = &sock_server_main; - int client_fd, rv, main_rv = 0; - int tx_bytes, rx_bytes, nbytes; - sock_server_conn_t *conn; - sock_test_cfg_t *rx_cfg; - uint32_t xtra = 0; - uint64_t xtra_bytes = 0; - struct sockaddr_storage servaddr; - int errno_val; - int c, v, i; - uint16_t port = SOCK_TEST_SERVER_PORT; - vppcom_endpt_t endpt; + struct sockaddr_storage *servaddr = &vsm->servaddr; + memset (servaddr, 0, sizeof (*servaddr)); - clib_mem_init_thread_safe (0, 64 << 20); + if (vsm->cfg.address_ip6) + { + struct sockaddr_in6 *server_addr = (struct sockaddr_in6 *) servaddr; + server_addr->sin6_family = AF_INET6; + server_addr->sin6_addr = in6addr_any; + server_addr->sin6_port = htons (vsm->cfg.port); + } + else + { + struct sockaddr_in *server_addr = (struct sockaddr_in *) servaddr; + server_addr->sin_family = AF_INET; + server_addr->sin_addr.s_addr = htonl (INADDR_ANY); + server_addr->sin_port = htons (vsm->cfg.port); + } + + if (vsm->cfg.address_ip6) + { + struct sockaddr_in6 *server_addr = (struct sockaddr_in6 *) servaddr; + vsm->cfg.endpt.is_ip4 = 0; + vsm->cfg.endpt.ip = (uint8_t *) & server_addr->sin6_addr; + vsm->cfg.endpt.port = (uint16_t) server_addr->sin6_port; + } + else + { + struct sockaddr_in *server_addr = (struct sockaddr_in *) servaddr; + vsm->cfg.endpt.is_ip4 = 1; + vsm->cfg.endpt.ip = (uint8_t *) & server_addr->sin_addr; + vsm->cfg.endpt.port = (uint16_t) server_addr->sin_port; + } +} + +static void +vcl_test_server_process_opts (vcl_test_server_main_t * vsm, int argc, + char **argv) +{ + int v, c; + + vsm->cfg.proto = VPPCOM_PROTO_TCP; opterr = 0; - while ((c = getopt (argc, argv, "6D")) != -1) + while ((c = getopt (argc, argv, "6Dsw:")) != -1) switch (c) { case '6': - ssm->cfg.address_ip6 = 1; + vsm->cfg.address_ip6 = 1; break; case 'D': - ssm->cfg.transport_udp = 1; + vsm->cfg.proto = VPPCOM_PROTO_UDP; break; + case 'w': + v = atoi (optarg); + if (v > 1) + vsm->cfg.workers = v; + else + vtwrn ("Invalid number of workers %d", v); + break; + case 's': + vsm->use_ds = 1; + break; case '?': switch (optopt) { default: if (isprint (optopt)) - fprintf (stderr, "SERVER: ERROR: Unknown " - "option `-%c'.\n", optopt); + vtwrn ("Unknown option `-%c'.", optopt); else - fprintf (stderr, "SERVER: ERROR: Unknown " - "option character `\\x%x'.\n", optopt); + vtwrn ("Unknown option character `\\x%x'.", optopt); } /* fall thru */ case 'h': @@ -349,301 +413,311 @@ main (int argc, char **argv) } if (sscanf (argv[optind], "%d", &v) == 1) - port = (uint16_t) v; + vsm->cfg.port = (uint16_t) v; else { fprintf (stderr, "SERVER: ERROR: Invalid port (%s)!\n", argv[optind]); print_usage_and_exit (); } - conn_pool_expand (SOCK_SERVER_MAX_TEST_CONN + 1); + vcl_test_init_endpoint_addr (vsm); +} - rv = vppcom_app_create ("vcl_test_server"); - if (rv) - { - errno_val = errno = -rv; - perror ("ERROR in main()"); - fprintf (stderr, "SERVER: ERROR: vppcom_app_create() failed " - "(errno = %d)!\n", errno_val); - return -1; - } - else +int +vts_handle_cfg (vcl_test_server_worker_t * wrk, vcl_test_cfg_t * rx_cfg, + vcl_test_server_conn_t * conn, int rx_bytes) +{ + if (rx_cfg->verbose) { - ssm->listen_fd = vppcom_session_create (ssm->cfg.transport_udp ? - VPPCOM_PROTO_UDP : - VPPCOM_PROTO_TCP, - 0 /* is_nonblocking */ ); + vtinf ("(fd %d): Received a cfg msg!", conn->fd); + vcl_test_cfg_dump (rx_cfg, 0 /* is_client */ ); } - if (ssm->listen_fd < 0) + + if (rx_bytes != sizeof (*rx_cfg)) { - errno_val = errno = -ssm->listen_fd; - perror ("ERROR in main()"); - fprintf (stderr, "SERVER: ERROR: vppcom_session_create() failed " - "(errno = %d)!\n", errno_val); + vtinf ("(fd %d): Invalid cfg msg size %d expected %lu!", conn->fd, + rx_bytes, sizeof (*rx_cfg)); + conn->cfg.rxbuf_size = 0; + conn->cfg.num_writes = 0; + if (conn->cfg.verbose) + { + vtinf ("(fd %d): Replying to cfg msg", conn->fd); + vcl_test_cfg_dump (rx_cfg, 0 /* is_client */ ); + } + vcl_test_write (conn->fd, (uint8_t *) & conn->cfg, + sizeof (conn->cfg), NULL, conn->cfg.verbose); return -1; } - memset (&servaddr, 0, sizeof (servaddr)); - - if (ssm->cfg.address_ip6) - { - struct sockaddr_in6 *server_addr = (struct sockaddr_in6 *) &servaddr; - server_addr->sin6_family = AF_INET6; - server_addr->sin6_addr = in6addr_any; - server_addr->sin6_port = htons (port); - } - else + switch (rx_cfg->test) { - struct sockaddr_in *server_addr = (struct sockaddr_in *) &servaddr; - server_addr->sin_family = AF_INET; - server_addr->sin_addr.s_addr = htonl (INADDR_ANY); - server_addr->sin_port = htons (port); - } + case VCL_TEST_TYPE_NONE: + case VCL_TEST_TYPE_ECHO: + sync_config_and_reply (conn, rx_cfg); + break; - if (ssm->cfg.address_ip6) - { - struct sockaddr_in6 *server_addr = (struct sockaddr_in6 *) &servaddr; - endpt.is_ip4 = 0; - endpt.ip = (uint8_t *) & server_addr->sin6_addr; - endpt.port = (uint16_t) server_addr->sin6_port; - } - else - { - struct sockaddr_in *server_addr = (struct sockaddr_in *) &servaddr; - endpt.is_ip4 = 1; - endpt.ip = (uint8_t *) & server_addr->sin_addr; - endpt.port = (uint16_t) server_addr->sin_port; - } + case VCL_TEST_TYPE_BI: + case VCL_TEST_TYPE_UNI: + vts_server_start_stop (wrk, conn, rx_cfg); + break; - rv = vppcom_session_bind (ssm->listen_fd, &endpt); - if (rv < 0) - { - errno_val = errno = -rv; - perror ("ERROR in main()"); - fprintf (stderr, "SERVER: ERROR: bind failed (errno = %d)!\n", - errno_val); - return -1; + case VCL_TEST_TYPE_EXIT: + vtinf ("Session fd %d closing!", conn->fd); + clock_gettime (CLOCK_REALTIME, &conn->stats.stop); + vppcom_session_close (conn->fd); + conn_pool_free (conn); + wrk->nfds--; + break; + + default: + vtwrn ("Unknown test type %d", rx_cfg->test); + vcl_test_cfg_dump (rx_cfg, 0 /* is_client */ ); + break; } - rv = vppcom_session_listen (ssm->listen_fd, 10); + return 0; +} + +static void +vts_worker_init (vcl_test_server_worker_t * wrk) +{ + vcl_test_server_main_t *vsm = &vcl_server_main; + struct epoll_event listen_ev; + int rv; + + __wrk_index = wrk->wrk_index; + + vtinf ("Initializing worker ..."); + + conn_pool_expand (wrk, VCL_TEST_CFG_MAX_TEST_SESS + 1); + if (wrk->wrk_index) + if (vppcom_worker_register ()) + vtfail ("vppcom_worker_register()", 1); + + wrk->listen_fd = vppcom_session_create (vsm->cfg.proto, + 0 /* is_nonblocking */ ); + if (wrk->listen_fd < 0) + vtfail ("vppcom_session_create()", wrk->listen_fd); + + rv = vppcom_session_bind (wrk->listen_fd, &vsm->cfg.endpt); if (rv < 0) - { - errno_val = errno = -rv; - perror ("ERROR in main()"); - fprintf (stderr, "SERVER: ERROR: listen failed " - "(errno = %d)!\n", errno_val); - return -1; - } + vtfail ("vppcom_session_bind()", rv); - ssm->epfd = vppcom_epoll_create (); - if (ssm->epfd < 0) + if (!(vsm->cfg.proto == VPPCOM_PROTO_UDP)) { - errno_val = errno = -ssm->epfd; - perror ("ERROR in main()"); - fprintf (stderr, "SERVER: ERROR: epoll_create failed (errno = %d)!\n", - errno_val); - return -1; + rv = vppcom_session_listen (wrk->listen_fd, 10); + if (rv < 0) + vtfail ("vppcom_session_listen()", rv); } - ssm->listen_ev.events = EPOLLIN; - ssm->listen_ev.data.u32 = ~0; - rv = vppcom_epoll_ctl (ssm->epfd, EPOLL_CTL_ADD, ssm->listen_fd, - &ssm->listen_ev); + wrk->epfd = vppcom_epoll_create (); + if (wrk->epfd < 0) + vtfail ("vppcom_epoll_create()", wrk->epfd); + + listen_ev.events = EPOLLIN; + listen_ev.data.u32 = ~0; + rv = vppcom_epoll_ctl (wrk->epfd, EPOLL_CTL_ADD, wrk->listen_fd, + &listen_ev); if (rv < 0) + vtfail ("vppcom_epoll_ctl", rv); + + vsm->active_workers += 1; + vtinf ("Waiting for a client to connect on port %d ...", vsm->cfg.port); +} + +static int +vts_conn_expect_config (vcl_test_server_conn_t * conn) +{ + if (conn->cfg.test == VCL_TEST_TYPE_ECHO) + return 1; + + return (conn->stats.rx_bytes < 128 + || conn->stats.rx_bytes > conn->cfg.total_bytes); +} + +static vcl_test_cfg_t * +vts_conn_read_config (vcl_test_server_conn_t * conn) +{ + vcl_test_server_main_t *vsm = &vcl_server_main; + + if (vsm->use_ds) { - errno_val = errno = -rv; - perror ("ERROR in main()"); - fprintf (stderr, "SERVER: ERROR: epoll_ctl failed " - "(errno = %d)!\n", errno_val); - return -1; + /* We could avoid the copy if the first segment is big enough but this + * just simplifies things */ + vppcom_data_segment_copy (conn->buf, conn->ds, sizeof (vcl_test_cfg_t)); } - printf ("\nSERVER: Waiting for a client to connect on port %d...\n", port); + return (vcl_test_cfg_t *) conn->buf; +} + +static inline int +vts_conn_read (vcl_test_server_conn_t * conn) +{ + vcl_test_server_main_t *vsm = &vcl_server_main; + if (vsm->use_ds) + return vcl_test_read_ds (conn->fd, conn->ds, &conn->stats); + else + return vcl_test_read (conn->fd, conn->buf, conn->buf_size, &conn->stats); +} + +static inline int +vts_conn_has_ascii (vcl_test_server_conn_t * conn) +{ + vcl_test_server_main_t *vsm = &vcl_server_main; + + if (vsm->use_ds) + return isascii (conn->ds[0].data[0]); + else + return isascii (conn->buf[0]); +} + +static void * +vts_worker_loop (void *arg) +{ + vcl_test_server_main_t *vsm = &vcl_server_main; + vcl_test_server_worker_t *wrk = arg; + vcl_test_server_conn_t *conn; + int i, rx_bytes, num_ev; + vcl_test_cfg_t *rx_cfg; + + if (wrk->wrk_index) + vts_worker_init (wrk); while (1) { - int num_ev; - num_ev = vppcom_epoll_wait (ssm->epfd, ssm->wait_events, - SOCK_SERVER_MAX_EPOLL_EVENTS, 60.0); + num_ev = vppcom_epoll_wait (wrk->epfd, wrk->wait_events, + VCL_TEST_CFG_MAX_EPOLL_EVENTS, 60000.0); if (num_ev < 0) { - errno = -num_ev; - perror ("epoll_wait()"); - fprintf (stderr, "\nSERVER: ERROR: epoll_wait() " - "failed -- aborting!\n"); - main_rv = -1; - goto done; + vterr ("vppcom_epoll_wait()", num_ev); + goto fail; } else if (num_ev == 0) { - fprintf (stderr, "\nSERVER: epoll_wait() timeout!\n"); + vtinf ("vppcom_epoll_wait() timeout!"); continue; } for (i = 0; i < num_ev; i++) { - conn = &ssm->conn_pool[ssm->wait_events[i].data.u32]; - if (ssm->wait_events[i].events & (EPOLLHUP | EPOLLRDHUP)) + conn = &wrk->conn_pool[wrk->wait_events[i].data.u32]; + if (wrk->wait_events[i].events & (EPOLLHUP | EPOLLRDHUP)) { vppcom_session_close (conn->fd); + wrk->nfds -= 1; + if (!wrk->nfds) + { + vtinf ("All client connections closed\n"); + goto done; + } continue; } - if (ssm->wait_events[i].data.u32 == ~0) + if (wrk->wait_events[i].data.u32 == ~0) { - new_client (); + vts_new_client (wrk); continue; } - client_fd = conn->fd; - if (EPOLLIN & ssm->wait_events[i].events) + if (EPOLLIN & wrk->wait_events[i].events) { - rx_bytes = vcl_test_read (client_fd, conn->buf, - conn->buf_size, &conn->stats); - if (rx_bytes > 0) + read_again: + rx_bytes = vts_conn_read (conn); + + if (rx_bytes <= 0) { - rx_cfg = (sock_test_cfg_t *) conn->buf; - if (rx_cfg->magic == SOCK_TEST_CFG_CTRL_MAGIC) + if (errno == ECONNRESET) { - if (rx_cfg->verbose) - { - printf ("SERVER (fd %d): Received a cfg message!\n", - client_fd); - sock_test_cfg_dump (rx_cfg, 0 /* is_client */ ); - } - - if (rx_bytes != sizeof (*rx_cfg)) - { - printf ("SERVER (fd %d): Invalid cfg message " - "size (%d)!\n Should be %lu bytes.\n", - client_fd, rx_bytes, sizeof (*rx_cfg)); - conn->cfg.rxbuf_size = 0; - conn->cfg.num_writes = 0; - if (conn->cfg.verbose) - { - printf ("SERVER (fd %d): Replying to " - "cfg message!\n", client_fd); - sock_test_cfg_dump (rx_cfg, 0 /* is_client */ ); - } - vcl_test_write (client_fd, (uint8_t *) & conn->cfg, - sizeof (conn->cfg), NULL, - conn->cfg.verbose); - continue; - } - - switch (rx_cfg->test) - { - case SOCK_TEST_TYPE_NONE: - case SOCK_TEST_TYPE_ECHO: - sync_config_and_reply (conn, rx_cfg); - break; - - case SOCK_TEST_TYPE_BI: - case SOCK_TEST_TYPE_UNI: - stream_test_server_start_stop (conn, rx_cfg); - break; - - case SOCK_TEST_TYPE_EXIT: - printf ("SERVER: Have a great day, " - "connection %d!\n", client_fd); - vppcom_session_close (client_fd); - conn_pool_free (conn); - printf ("SERVER: Closed client fd %d\n", client_fd); - ssm->nfds--; - if (!ssm->nfds) - { - printf ("SERVER: All client connections " - "closed.\n\nSERVER: " - "May the force be with you!\n\n"); - goto done; - } - break; - - default: - fprintf (stderr, - "SERVER: ERROR: Unknown test type!\n"); - sock_test_cfg_dump (rx_cfg, 0 /* is_client */ ); - break; - } - continue; + vtinf ("Connection reset by remote peer.\n"); + goto fail; } + else + continue; + } - else if ((conn->cfg.test == SOCK_TEST_TYPE_UNI) || - (conn->cfg.test == SOCK_TEST_TYPE_BI)) + if (vts_conn_expect_config (conn)) + { + rx_cfg = vts_conn_read_config (conn); + if (rx_cfg->magic == VCL_TEST_CFG_CTRL_MAGIC) { - stream_test_server (conn, rx_bytes); + if (vsm->use_ds) + vppcom_session_free_segments (conn->fd, conn->ds); + vts_handle_cfg (wrk, rx_cfg, conn, rx_bytes); + if (!wrk->nfds) + { + vtinf ("All client connections closed\n"); + goto done; + } continue; } - - else if (isascii (conn->buf[0])) - { - /* If it looks vaguely like a string, - * make sure it's terminated. - */ - ((char *) conn->buf)[rx_bytes < - conn->buf_size ? rx_bytes : - conn->buf_size - 1] = 0; - printf ("SERVER (fd %d): RX (%d bytes) - '%s'\n", - conn->fd, rx_bytes, conn->buf); - } } - else // rx_bytes < 0 + if ((conn->cfg.test == VCL_TEST_TYPE_UNI) + || (conn->cfg.test == VCL_TEST_TYPE_BI)) { - if (errno == ECONNRESET) - { - printf ("\nSERVER: Connection reset by remote peer.\n" - " Y'all have a great day now!\n\n"); - break; - } - else - continue; + vts_server_rx (conn, rx_bytes); + if (vppcom_session_attr (conn->fd, VPPCOM_ATTR_GET_NREAD, 0, + 0) > 0) + goto read_again; + continue; } - - if (isascii (conn->buf[0])) + if (vts_conn_has_ascii (conn)) { - /* If it looks vaguely like a string, - * make sure it's terminated - */ - ((char *) conn->buf)[rx_bytes < - conn->buf_size ? rx_bytes : - conn->buf_size - 1] = 0; - if (xtra) - fprintf (stderr, "SERVER: ERROR: " - "FIFO not drained in previous test!\n" - " extra chunks %u (0x%x)\n" - " extra bytes %lu (0x%lx)\n", - xtra, xtra, xtra_bytes, xtra_bytes); - - xtra = 0; - xtra_bytes = 0; - - if (conn->cfg.verbose) - printf ("SERVER (fd %d): Echoing back\n", client_fd); - - nbytes = strlen ((const char *) conn->buf) + 1; - - tx_bytes = vcl_test_write (client_fd, conn->buf, - nbytes, &conn->stats, - conn->cfg.verbose); - if (tx_bytes >= 0) - printf ("SERVER (fd %d): TX (%d bytes) - '%s'\n", - conn->fd, tx_bytes, conn->buf); + vts_server_echo (conn, rx_bytes); } - - else // Extraneous read data from non-echo tests??? + else { - xtra++; - xtra_bytes += rx_bytes; + vtwrn ("FIFO not drained! extra bytes %d", rx_bytes); } } + else + { + vtwrn ("Unhandled event"); + goto fail; + } } } +fail: + vsm->worker_fails -= 1; + done: - vppcom_session_close (ssm->listen_fd); - vppcom_app_destroy (); + vppcom_session_close (wrk->listen_fd); + if (wrk->conn_pool) + free (wrk->conn_pool); + vsm->active_workers -= 1; + return 0; +} - if (ssm->conn_pool) - free (ssm->conn_pool); +int +main (int argc, char **argv) +{ + vcl_test_server_main_t *vsm = &vcl_server_main; + int rv, i; + + clib_mem_init_thread_safe (0, 64 << 20); + vsm->cfg.port = VCL_TEST_SERVER_PORT; + vsm->cfg.workers = 1; + vsm->active_workers = 0; + vcl_test_server_process_opts (vsm, argc, argv); + + rv = vppcom_app_create ("vcl_test_server"); + if (rv) + vtfail ("vppcom_app_create()", rv); + + vsm->workers = calloc (vsm->cfg.workers, sizeof (*vsm->workers)); + vts_worker_init (&vsm->workers[0]); + for (i = 1; i < vsm->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]); + } + vts_worker_loop (&vsm->workers[0]); + + while (vsm->active_workers > 0) + ; + + vppcom_app_destroy (); + free (vsm->workers); - return main_rv; + return vsm->worker_fails; } /*