src/plugins/hs_apps/vcl/vcl_test.h

   1 /*
   2  * Copyright (c) 2017-2019 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at:
   6  *
   7  *     http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  */
  15
  16 #ifndef __vcl_test_h__
  17 #define __vcl_test_h__
  18
  19 #include <netdb.h>
  20 #include <errno.h>
  21 #include <stdlib.h>
  22 #include <string.h>
  23 #include <vcl/vppcom.h>
  24
  25 #define vtfail(_fn, _rv)                                                \
  26 {                                                                       \
  27   errno = -_rv;                                                         \
  28   perror ("ERROR when calling " _fn);                                   \
  29   fprintf (stderr, "\nERROR: " _fn " failed (errno = %d)!\n", -_rv);    \
  30   exit (1);                                                             \
  31 }
  32
  33 #define vterr(_fn, _rv)                                                 \
  34 {                                                                       \
  35   errno = -_rv;                                                         \
  36   fprintf (stderr, "\nERROR: " _fn " failed (errno = %d)!\n", -_rv);    \
  37 }
  38
  39 #define vtwrn(_fmt, _args...)                                           \
  40   fprintf (stderr, "\nERROR: " _fmt "\n", ##_args)                      \
  41
  42 #define vtinf(_fmt, _args...)                                           \
  43   fprintf (stdout, "vt<w%u>: " _fmt "\n", __wrk_index, ##_args)
  44
  45 #define vt_atomic_add(_ptr, _val)                                       \
  46   __atomic_fetch_add (_ptr, _val, __ATOMIC_RELEASE)
  47
  48 #define VCL_TEST_TOKEN_HELP             "#H"
  49 #define VCL_TEST_TOKEN_EXIT             "#X"
  50 #define VCL_TEST_TOKEN_VERBOSE          "#V"
  51 #define VCL_TEST_TOKEN_TXBUF_SIZE       "#T:"
  52 #define VCL_TEST_TOKEN_NUM_TEST_SESS    "#I:"
  53 #define VCL_TEST_TOKEN_NUM_WRITES       "#N:"
  54 #define VCL_TEST_TOKEN_RXBUF_SIZE       "#R:"
  55 #define VCL_TEST_TOKEN_SHOW_CFG         "#C"
  56 #define VCL_TEST_TOKEN_RUN_UNI          "#U"
  57 #define VCL_TEST_TOKEN_RUN_BI           "#B"
  58
  59 #define VCL_TEST_SERVER_PORT            22000
  60 #define VCL_TEST_LOCALHOST_IPADDR       "127.0.0.1"
  61
  62 #define VCL_TEST_CFG_CTRL_MAGIC         0xfeedface
  63 #define VCL_TEST_CFG_NUM_WRITES_DEF     1000000
  64 #define VCL_TEST_CFG_TXBUF_SIZE_DEF     8192
  65 #define VCL_TEST_CFG_RXBUF_SIZE_DEF     (64*VCL_TEST_CFG_TXBUF_SIZE_DEF)
  66 #define VCL_TEST_CFG_BUF_SIZE_MIN       128
  67 #define VCL_TEST_CFG_MAX_TEST_SESS      32
  68 #define VCL_TEST_CFG_MAX_EPOLL_EVENTS   16
  69
  70 #define VCL_TEST_CTRL_LISTENER          (~0 - 1)
  71 #define VCL_TEST_DATA_LISTENER          (~0)
  72 #define VCL_TEST_DELAY_DISCONNECT       1
  73 #define VCL_TEST_SEPARATOR_STRING       \
  74   "  -----------------------------\n"
  75 typedef enum
  76 {
  77   VCL_TEST_TYPE_NONE,
  78   VCL_TEST_TYPE_ECHO,
  79   VCL_TEST_TYPE_UNI,
  80   VCL_TEST_TYPE_BI,
  81   VCL_TEST_TYPE_EXIT,
  82 } vcl_test_t;
  83
  84 typedef enum
  85 {
  86   VCL_TEST_CMD_SYNC,
  87   VCL_TEST_CMD_START,
  88   VCL_TEST_CMD_STOP,
  89 } vcl_test_cmd_t;
  90
  91 typedef struct __attribute__ ((packed))
  92 {
  93   uint32_t magic;
  94   uint32_t seq_num;
  95   uint32_t test;
  96   uint32_t cmd;
  97   uint32_t ctrl_handle;
  98   uint32_t num_test_sessions;
  99   uint32_t num_test_sessions_perq;
 100   uint32_t num_test_qsessions;
 101   uint32_t verbose;
 102   uint32_t address_ip6;
 103   uint32_t transport_udp;
 104   uint64_t rxbuf_size;
 105   uint64_t txbuf_size;
 106   uint64_t num_writes;
 107   uint64_t total_bytes;
 108 } vcl_test_cfg_t;
 109
 110 typedef struct
 111 {
 112   uint64_t rx_xacts;
 113   uint64_t rx_bytes;
 114   uint32_t rx_eagain;
 115   uint32_t rx_incomp;
 116   uint64_t tx_xacts;
 117   uint64_t tx_bytes;
 118   uint32_t tx_eagain;
 119   uint32_t tx_incomp;
 120   struct timespec start;
 121   struct timespec stop;
 122 } vcl_test_stats_t;
 123
 124 typedef struct
 125 {
 126   uint8_t is_alloc;
 127   uint8_t is_open;
 128   int fd;
 129   uint32_t txbuf_size;
 130   char *txbuf;
 131   uint32_t rxbuf_size;
 132   char *rxbuf;
 133   vcl_test_cfg_t cfg;
 134   vcl_test_stats_t stats;
 135   int session_index;
 136   vppcom_endpt_t endpt;
 137   uint8_t ip[16];
 138   vppcom_data_segment_t ds[2];
 139 } vcl_test_session_t;
 140
 141 /*
 142  * TLS server cert and keys to be used for testing only
 143  */
 144 char vcl_test_crt_rsa[] =
 145   "-----BEGIN CERTIFICATE-----\r\n"
 146   "MIID5zCCAs+gAwIBAgIJALeMYCEHrTtJMA0GCSqGSIb3DQEBCwUAMIGJMQswCQYD\r\n"
 147   "VQQGEwJVUzELMAkGA1UECAwCQ0ExETAPBgNVBAcMCFNhbiBKb3NlMQ4wDAYDVQQK\r\n"
 148   "DAVDaXNjbzEOMAwGA1UECwwFZmQuaW8xFjAUBgNVBAMMDXRlc3R0bHMuZmQuaW8x\r\n"
 149   "IjAgBgkqhkiG9w0BCQEWE3ZwcC1kZXZAbGlzdHMuZmQuaW8wHhcNMTgwMzA1MjEx\r\n"
 150   "NTEyWhcNMjgwMzAyMjExNTEyWjCBiTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNB\r\n"
 151   "MREwDwYDVQQHDAhTYW4gSm9zZTEOMAwGA1UECgwFQ2lzY28xDjAMBgNVBAsMBWZk\r\n"
 152   "LmlvMRYwFAYDVQQDDA10ZXN0dGxzLmZkLmlvMSIwIAYJKoZIhvcNAQkBFhN2cHAt\r\n"
 153   "ZGV2QGxpc3RzLmZkLmlvMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\r\n"
 154   "4C1k8a1DuStgggqT4o09fP9sJ2dC54bxhS/Xk2VEfaIZ222WSo4X/syRVfVy9Yah\r\n"
 155   "cpI1zJ/RDxaZSFhgA+nPZBrFMsrULkrdAOpOVj8eDEp9JuWdO2ODSoFnCvLxcYWB\r\n"
 156   "Yc5kHryJpEaGJl1sFQSesnzMFty/59ta0stk0Fp8r5NhIjWvSovGzPo6Bhz+VS2c\r\n"
 157   "ebIZh4x1t2hHaFcgm0qJoJ6DceReWCW8w+yOVovTolGGq+bpb2Hn7MnRSZ2K2NdL\r\n"
 158   "+aLXpkZbS/AODP1FF2vTO1mYL290LO7/51vJmPXNKSDYMy5EvILr5/VqtjsFCwRL\r\n"
 159   "Q4jcM/+GeHSAFWx4qIv0BwIDAQABo1AwTjAdBgNVHQ4EFgQUWa1SOB37xmT53tZQ\r\n"
 160   "aXuLLhRI7U8wHwYDVR0jBBgwFoAUWa1SOB37xmT53tZQaXuLLhRI7U8wDAYDVR0T\r\n"
 161   "BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAoUht13W4ya27NVzQuCMvqPWL3VM4\r\n"
 162   "3xbPFk02FaGz/WupPu276zGlzJAZrbuDcQowwwU1Ni1Yygxl96s1c2M5rHDTrOKG\r\n"
 163   "rK0hbkSFBo+i6I8u4HiiQ4rYmG0Hv6+sXn3of0HsbtDPGgWZoipPWDljPYEURu3e\r\n"
 164   "3HRe/Dtsj9CakBoSDzs8ndWaBR+f4sM9Tk1cjD46Gq2T/qpSPXqKxEUXlzhdCAn4\r\n"
 165   "twub17Bq2kykHpppCwPg5M+v30tHG/R2Go15MeFWbEJthFk3TZMjKL7UFs7fH+x2\r\n"
 166   "wSonXb++jY+KmCb93C+soABBizE57g/KmiR2IxQ/LMjDik01RSUIaM0lLA==\r\n"
 167   "-----END CERTIFICATE-----\r\n";
 168 uint32_t vcl_test_crt_rsa_len = sizeof (vcl_test_crt_rsa);
 169
 170 char vcl_test_key_rsa[] =
 171   "-----BEGIN PRIVATE KEY-----\r\n"
 172   "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDgLWTxrUO5K2CC\r\n"
 173   "CpPijT18/2wnZ0LnhvGFL9eTZUR9ohnbbZZKjhf+zJFV9XL1hqFykjXMn9EPFplI\r\n"
 174   "WGAD6c9kGsUyytQuSt0A6k5WPx4MSn0m5Z07Y4NKgWcK8vFxhYFhzmQevImkRoYm\r\n"
 175   "XWwVBJ6yfMwW3L/n21rSy2TQWnyvk2EiNa9Ki8bM+joGHP5VLZx5shmHjHW3aEdo\r\n"
 176   "VyCbSomgnoNx5F5YJbzD7I5Wi9OiUYar5ulvYefsydFJnYrY10v5otemRltL8A4M\r\n"
 177   "/UUXa9M7WZgvb3Qs7v/nW8mY9c0pINgzLkS8guvn9Wq2OwULBEtDiNwz/4Z4dIAV\r\n"
 178   "bHioi/QHAgMBAAECggEBAMzGipP8+oT166U+NlJXRFifFVN1DvdhG9PWnOxGL+c3\r\n"
 179   "ILmBBC08WQzmHshPemBvR6DZkA1H23cV5JTiLWrFtC00CvhXsLRMrE5+uWotI6yE\r\n"
 180   "iofybMroHvD6/X5R510UX9hQ6MHu5ShLR5VZ9zXHz5MpTmB/60jG5dLx+jgcwBK8\r\n"
 181   "LuGv2YB/WCUwT9QJ3YU2eaingnXtz/MrFbkbltrqlnBdlD+kTtw6Yac9y1XuuQXc\r\n"
 182   "BPeulLNDuPolJVWbUvDBZrpt2dXTgz8ws1sv+wCNE0xwQJsqW4Nx3QkpibUL9RUr\r\n"
 183   "CVbKlNfa9lopT6nGKlgX69R/uH35yh9AOsfasro6w0ECgYEA82UJ8u/+ORah+0sF\r\n"
 184   "Q0FfW5MTdi7OAUHOz16pUsGlaEv0ERrjZxmAkHA/VRwpvDBpx4alCv0Hc39PFLIk\r\n"
 185   "nhSsM2BEuBkTAs6/GaoNAiBtQVE/hN7awNRWVmlieS0go3Y3dzaE9IUMyj8sPOFT\r\n"
 186   "5JdJ6BM69PHKCkY3dKdnnfpFEuECgYEA68mRpteunF1mdZgXs+WrN+uLlRrQR20F\r\n"
 187   "ZyMYiUCH2Dtn26EzA2moy7FipIIrQcX/j+KhYNGM3e7MU4LymIO29E18mn8JODnH\r\n"
 188   "sQOXzBTsf8A4yIVMkcuQD3bfb0JiUGYUPOidTp2N7IJA7+6Yc3vQOyb74lnKnJoO\r\n"
 189   "gougPT2wS+cCgYAn7muzb6xFsXDhyW0Tm6YJYBfRS9yAWEuVufINobeBZPSl2cN1\r\n"
 190   "Jrnw+HlrfTNbrJWuJmjtZJXUXQ6cVp2rUbjutNyRV4vG6iRwEXYQ40EJdkr1gZpi\r\n"
 191   "CHQhuShuuPih2MNAy7EEbM+sXrDjTBR3bFqzuHPzu7dp+BshCFX3lRfAAQKBgGQt\r\n"
 192   "K5i7IhCFDjb/+3IPLgOAK7mZvsvZ4eXD33TQ2eZgtut1PXtBtNl17/b85uv293Fm\r\n"
 193   "VDISVcsk3eLNS8zIiT6afUoWlxAwXEs0v5WRfjl4radkGvgGiJpJYvyeM67877RB\r\n"
 194   "EDSKc/X8ESLfOB44iGvZUEMG6zJFscx9DgN25iQZAoGAbyd+JEWwdVH9/K3IH1t2\r\n"
 195   "PBkZX17kNWv+iVM1WyFjbe++vfKZCrOJiyiqhDeEqgrP3AuNMlaaduC3VRC3G5oV\r\n"
 196   "Mj1tlhDWQ/qhvKdCKNdIVQYDE75nw+FRWV8yYkHAnXYW3tNoweDIwixE0hkPR1bc\r\n"
 197   "oEjPLVNtx8SOj/M4rhaPT3I=\r\n" "-----END PRIVATE KEY-----\r\n";
 198 uint32_t vcl_test_key_rsa_len = sizeof (vcl_test_key_rsa);
 199
 200 static inline void
 201 vcl_test_stats_accumulate (vcl_test_stats_t * accum, vcl_test_stats_t * incr)
 202 {
 203   accum->rx_xacts += incr->rx_xacts;
 204   accum->rx_bytes += incr->rx_bytes;
 205   accum->rx_eagain += incr->rx_eagain;
 206   accum->rx_incomp += incr->rx_incomp;
 207   accum->tx_xacts += incr->tx_xacts;
 208   accum->tx_bytes += incr->tx_bytes;
 209   accum->tx_eagain += incr->tx_eagain;
 210   accum->tx_incomp += incr->tx_incomp;
 211 }
 212
 213 static inline void
 214 vcl_test_cfg_init (vcl_test_cfg_t * cfg)
 215 {
 216   cfg->magic = VCL_TEST_CFG_CTRL_MAGIC;
 217   cfg->test = VCL_TEST_TYPE_NONE;
 218   cfg->ctrl_handle = ~0;
 219   cfg->num_test_sessions = 1;
 220   cfg->num_test_sessions_perq = 1;
 221   cfg->verbose = 0;
 222   cfg->rxbuf_size = VCL_TEST_CFG_RXBUF_SIZE_DEF;
 223   cfg->num_writes = VCL_TEST_CFG_NUM_WRITES_DEF;
 224   cfg->txbuf_size = VCL_TEST_CFG_TXBUF_SIZE_DEF;
 225   cfg->total_bytes = cfg->num_writes * cfg->txbuf_size;
 226 }
 227
 228 static inline int
 229 vcl_test_cfg_verify (vcl_test_cfg_t * cfg, vcl_test_cfg_t * valid_cfg)
 230 {
 231   /* Note: txbuf & rxbuf on server are the same buffer,
 232    *       so txbuf_size is not included in this check.
 233    */
 234   return ((cfg->magic == valid_cfg->magic)
 235           && (cfg->test == valid_cfg->test)
 236           && (cfg->verbose == valid_cfg->verbose)
 237           && (cfg->rxbuf_size == valid_cfg->rxbuf_size)
 238           && (cfg->num_writes == valid_cfg->num_writes)
 239           && (cfg->total_bytes == valid_cfg->total_bytes));
 240 }
 241
 242 static inline void
 243 vcl_test_buf_alloc (vcl_test_cfg_t * cfg, uint8_t is_rxbuf, uint8_t ** buf,
 244                     uint32_t * bufsize)
 245 {
 246   uint32_t alloc_size = is_rxbuf ? cfg->rxbuf_size : cfg->txbuf_size;
 247   uint8_t *lb = realloc (*buf, (size_t) alloc_size);
 248
 249   if (lb)
 250     {
 251       if (is_rxbuf)
 252         cfg->rxbuf_size = *bufsize = alloc_size;
 253       else
 254         cfg->txbuf_size = *bufsize = alloc_size;
 255
 256       *buf = lb;
 257     }
 258   else
 259     {
 260       vtwrn ("realloc failed. using buffer size %d instead of %u",
 261              *bufsize, alloc_size);
 262     }
 263 }
 264
 265 static inline void
 266 vcl_test_session_buf_alloc (vcl_test_session_t * socket)
 267 {
 268   socket->rxbuf_size = socket->cfg.rxbuf_size;
 269   socket->txbuf_size = socket->cfg.txbuf_size;
 270   vcl_test_buf_alloc (&socket->cfg, 0 /* is_rxbuf */ ,
 271                       (uint8_t **) & socket->txbuf, &socket->txbuf_size);
 272   vcl_test_buf_alloc (&socket->cfg, 1 /* is_rxbuf */ ,
 273                       (uint8_t **) & socket->rxbuf, &socket->rxbuf_size);
 274 }
 275
 276 static inline char *
 277 vcl_test_type_str (vcl_test_t t)
 278 {
 279   switch (t)
 280     {
 281     case VCL_TEST_TYPE_NONE:
 282       return "NONE";
 283
 284     case VCL_TEST_TYPE_ECHO:
 285       return "ECHO";
 286
 287     case VCL_TEST_TYPE_UNI:
 288       return "UNI";
 289
 290     case VCL_TEST_TYPE_BI:
 291       return "BI";
 292
 293     case VCL_TEST_TYPE_EXIT:
 294       return "EXIT";
 295
 296     default:
 297       return "Unknown";
 298     }
 299 }
 300
 301 static inline void
 302 vcl_test_cfg_dump (vcl_test_cfg_t * cfg, uint8_t is_client)
 303 {
 304   char *spc = "     ";
 305
 306   printf ("  test config (%p):\n"
 307           VCL_TEST_SEPARATOR_STRING
 308           "                 magic:  0x%08x\n"
 309           "               seq_num:  0x%08x\n"
 310           "%-5s             test:  %s (%d)\n"
 311           "           ctrl handle:  %d (0x%x)\n"
 312           "%-5s num test sockets:  %u (0x%08x)\n"
 313           "%-5s          verbose:  %s (%d)\n"
 314           "%-5s       rxbuf size:  %lu (0x%08lx)\n"
 315           "%-5s       txbuf size:  %lu (0x%08lx)\n"
 316           "%-5s       num writes:  %lu (0x%08lx)\n"
 317           "       client tx bytes:  %lu (0x%08lx)\n"
 318           VCL_TEST_SEPARATOR_STRING,
 319           (void *) cfg, cfg->magic, cfg->seq_num,
 320           is_client && (cfg->test == VCL_TEST_TYPE_UNI) ?
 321           "'" VCL_TEST_TOKEN_RUN_UNI "'" :
 322           is_client && (cfg->test == VCL_TEST_TYPE_BI) ?
 323           "'" VCL_TEST_TOKEN_RUN_BI "'" : spc,
 324           vcl_test_type_str (cfg->test), cfg->test,
 325           cfg->ctrl_handle, cfg->ctrl_handle,
 326           is_client ? "'" VCL_TEST_TOKEN_NUM_TEST_SESS "'" : spc,
 327           cfg->num_test_sessions, cfg->num_test_sessions,
 328           is_client ? "'" VCL_TEST_TOKEN_VERBOSE "'" : spc,
 329           cfg->verbose ? "on" : "off", cfg->verbose,
 330           is_client ? "'" VCL_TEST_TOKEN_RXBUF_SIZE "'" : spc,
 331           cfg->rxbuf_size, cfg->rxbuf_size,
 332           is_client ? "'" VCL_TEST_TOKEN_TXBUF_SIZE "'" : spc,
 333           cfg->txbuf_size, cfg->txbuf_size,
 334           is_client ? "'" VCL_TEST_TOKEN_NUM_WRITES "'" : spc,
 335           cfg->num_writes, cfg->num_writes,
 336           cfg->total_bytes, cfg->total_bytes);
 337 }
 338
 339 static inline void
 340 vcl_test_stats_dump (char *header, vcl_test_stats_t * stats,
 341                      uint8_t show_rx, uint8_t show_tx, uint8_t verbose)
 342 {
 343   struct timespec diff;
 344   double duration, rate;
 345   uint64_t total_bytes;
 346
 347   if ((stats->stop.tv_nsec - stats->start.tv_nsec) < 0)
 348     {
 349       diff.tv_sec = stats->stop.tv_sec - stats->start.tv_sec - 1;
 350       diff.tv_nsec = stats->stop.tv_nsec - stats->start.tv_nsec + 1e9;
 351     }
 352   else
 353     {
 354       diff.tv_sec = stats->stop.tv_sec - stats->start.tv_sec;
 355       diff.tv_nsec = stats->stop.tv_nsec - stats->start.tv_nsec;
 356     }
 357   duration = (double) diff.tv_sec + (1e-9 * diff.tv_nsec);
 358
 359   total_bytes = stats->tx_bytes + stats->rx_bytes;
 360   rate = (double) total_bytes *8 / duration / 1e9;
 361   printf ("\n%s: Streamed %lu bytes\n"
 362           "  in %lf seconds (%lf Gbps %s-duplex)!\n",
 363           header, total_bytes, duration, rate,
 364           (show_rx && show_tx) ? "full" : "half");
 365
 366   if (show_tx)
 367     {
 368       printf (VCL_TEST_SEPARATOR_STRING
 369               "  tx stats (0x%p):\n"
 370               VCL_TEST_SEPARATOR_STRING
 371               "         writes:  %lu (0x%08lx)\n"
 372               "       tx bytes:  %lu (0x%08lx)\n"
 373               "      tx eagain:  %u (0x%08x)\n"
 374               "  tx incomplete:  %u (0x%08x)\n",
 375               (void *) stats, stats->tx_xacts, stats->tx_xacts,
 376               stats->tx_bytes, stats->tx_bytes,
 377               stats->tx_eagain, stats->tx_eagain,
 378               stats->tx_incomp, stats->tx_incomp);
 379     }
 380   if (show_rx)
 381     {
 382       printf (VCL_TEST_SEPARATOR_STRING
 383               "  rx stats (0x%p):\n"
 384               VCL_TEST_SEPARATOR_STRING
 385               "          reads:  %lu (0x%08lx)\n"
 386               "       rx bytes:  %lu (0x%08lx)\n"
 387               "      rx eagain:  %u (0x%08x)\n"
 388               "  rx incomplete:  %u (0x%08x)\n",
 389               (void *) stats, stats->rx_xacts, stats->rx_xacts,
 390               stats->rx_bytes, stats->rx_bytes,
 391               stats->rx_eagain, stats->rx_eagain,
 392               stats->rx_incomp, stats->rx_incomp);
 393     }
 394   if (verbose)
 395     printf ("   start.tv_sec:  %ld\n"
 396             "  start.tv_nsec:  %ld\n"
 397             "    stop.tv_sec:  %ld\n"
 398             "   stop.tv_nsec:  %ld\n",
 399             stats->start.tv_sec, stats->start.tv_nsec,
 400             stats->stop.tv_sec, stats->stop.tv_nsec);
 401
 402   printf (VCL_TEST_SEPARATOR_STRING);
 403 }
 404
 405 static inline int
 406 vcl_comp_tspec (struct timespec *a, struct timespec *b)
 407 {
 408   if (a->tv_sec < b->tv_sec)
 409     return -1;
 410   else if (a->tv_sec > b->tv_sec)
 411     return 1;
 412   else if (a->tv_nsec < b->tv_nsec)
 413     return -1;
 414   else if (a->tv_nsec > b->tv_nsec)
 415     return 1;
 416   else
 417     return 0;
 418 }
 419
 420 static inline int
 421 vcl_test_read (vcl_test_session_t *ts, void *buf, uint32_t nbytes)
 422 {
 423   vcl_test_stats_t *stats = &ts->stats;
 424   int rx_bytes;
 425
 426   do
 427     {
 428       stats->rx_xacts++;
 429       rx_bytes = vppcom_session_read (ts->fd, buf, nbytes);
 430
 431       if (rx_bytes < 0)
 432         {
 433           errno = -rx_bytes;
 434           rx_bytes = -1;
 435         }
 436       if ((rx_bytes == 0) ||
 437           ((rx_bytes < 0) && ((errno == EAGAIN) || (errno == EWOULDBLOCK))))
 438         stats->rx_eagain++;
 439       else if (rx_bytes < nbytes)
 440         stats->rx_incomp++;
 441     }
 442   while ((rx_bytes == 0) ||
 443          ((rx_bytes < 0) && ((errno == EAGAIN) || (errno == EWOULDBLOCK))));
 444
 445   if (rx_bytes < 0)
 446     {
 447       vterr ("vppcom_session_read()", -errno);
 448     }
 449   else
 450     stats->rx_bytes += rx_bytes;
 451
 452   return (rx_bytes);
 453 }
 454
 455 static inline int
 456 vcl_test_read_ds (vcl_test_session_t *ts)
 457 {
 458   vcl_test_stats_t *stats = &ts->stats;
 459   int rx_bytes;
 460
 461   do
 462     {
 463       stats->rx_xacts++;
 464       rx_bytes = vppcom_session_read_segments (ts->fd, ts->ds, 2, ~0);
 465
 466       if (rx_bytes < 0)
 467         {
 468           errno = -rx_bytes;
 469           rx_bytes = -1;
 470         }
 471           if ((rx_bytes == 0) ||
 472               ((rx_bytes < 0)
 473                && ((errno == EAGAIN) || (errno == EWOULDBLOCK))))
 474             stats->rx_eagain++;
 475     }
 476   while ((rx_bytes == 0) ||
 477          ((rx_bytes < 0) && ((errno == EAGAIN) || (errno == EWOULDBLOCK))));
 478
 479   if (rx_bytes < 0)
 480     {
 481       vterr ("vppcom_session_read()", -errno);
 482     }
 483   else
 484     stats->rx_bytes += rx_bytes;
 485
 486   return (rx_bytes);
 487 }
 488
 489 static inline int
 490 vcl_test_write (vcl_test_session_t *ts, void *buf, uint32_t nbytes)
 491 {
 492   int tx_bytes = 0, nbytes_left = nbytes, rv;
 493   vcl_test_stats_t *stats = &ts->stats;
 494
 495   do
 496     {
 497       stats->tx_xacts++;
 498       rv = vppcom_session_write (ts->fd, buf, nbytes_left);
 499       if (rv < 0)
 500         {
 501           errno = -rv;
 502           if ((errno == EAGAIN || errno == EWOULDBLOCK))
 503             stats->tx_eagain++;
 504           break;
 505         }
 506       tx_bytes += rv;
 507
 508       nbytes_left = nbytes_left - rv;
 509       buf += rv;
 510       stats->tx_incomp++;
 511     }
 512   while (tx_bytes != nbytes);
 513
 514   if (tx_bytes < 0)
 515     {
 516       vterr ("vpcom_session_write", -errno);
 517     }
 518   else
 519     stats->tx_bytes += tx_bytes;
 520
 521   return (tx_bytes);
 522 }
 523
 524 static inline void
 525 dump_help (void)
 526 {
 527 #define INDENT "\n  "
 528
 529   printf ("CLIENT: Test configuration commands:"
 530           INDENT VCL_TEST_TOKEN_HELP
 531           "\t\t\tDisplay help."
 532           INDENT VCL_TEST_TOKEN_EXIT
 533           "\t\t\tExit test client & server."
 534           INDENT VCL_TEST_TOKEN_SHOW_CFG
 535           "\t\t\tShow the current test cfg."
 536           INDENT VCL_TEST_TOKEN_RUN_UNI
 537           "\t\t\tRun the Uni-directional test."
 538           INDENT VCL_TEST_TOKEN_RUN_BI
 539           "\t\t\tRun the Bi-directional test."
 540           INDENT VCL_TEST_TOKEN_VERBOSE
 541           "\t\t\tToggle verbose setting."
 542           INDENT VCL_TEST_TOKEN_RXBUF_SIZE
 543           "<rxbuf size>\tRx buffer size (bytes)."
 544           INDENT VCL_TEST_TOKEN_TXBUF_SIZE
 545           "<txbuf size>\tTx buffer size (bytes)."
 546           INDENT VCL_TEST_TOKEN_NUM_WRITES
 547           "<# of writes>\tNumber of txbuf writes to server." "\n");
 548 }
 549
 550 #endif /* __vcl_test_h__ */
 551
 552 /*
 553  * fd.io coding-style-patch-verification: ON
 554  *
 555  * Local Variables:
 556  * eval: (c-set-style "gnu")
 557  * End:
 558  */