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   int fd;
 127   uint32_t txbuf_size;
 128   char *txbuf;
 129   uint32_t rxbuf_size;
 130   char *rxbuf;
 131   vcl_test_cfg_t cfg;
 132   vcl_test_stats_t stats;
 133   int session_index;
 134 } vcl_test_session_t;
 135
 136
 137 /*
 138  * TLS server cert and keys to be used for testing only
 139  */
 140 char vcl_test_crt_rsa[] =
 141   "-----BEGIN CERTIFICATE-----\r\n"
 142   "MIID5zCCAs+gAwIBAgIJALeMYCEHrTtJMA0GCSqGSIb3DQEBCwUAMIGJMQswCQYD\r\n"
 143   "VQQGEwJVUzELMAkGA1UECAwCQ0ExETAPBgNVBAcMCFNhbiBKb3NlMQ4wDAYDVQQK\r\n"
 144   "DAVDaXNjbzEOMAwGA1UECwwFZmQuaW8xFjAUBgNVBAMMDXRlc3R0bHMuZmQuaW8x\r\n"
 145   "IjAgBgkqhkiG9w0BCQEWE3ZwcC1kZXZAbGlzdHMuZmQuaW8wHhcNMTgwMzA1MjEx\r\n"
 146   "NTEyWhcNMjgwMzAyMjExNTEyWjCBiTELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAkNB\r\n"
 147   "MREwDwYDVQQHDAhTYW4gSm9zZTEOMAwGA1UECgwFQ2lzY28xDjAMBgNVBAsMBWZk\r\n"
 148   "LmlvMRYwFAYDVQQDDA10ZXN0dGxzLmZkLmlvMSIwIAYJKoZIhvcNAQkBFhN2cHAt\r\n"
 149   "ZGV2QGxpc3RzLmZkLmlvMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\r\n"
 150   "4C1k8a1DuStgggqT4o09fP9sJ2dC54bxhS/Xk2VEfaIZ222WSo4X/syRVfVy9Yah\r\n"
 151   "cpI1zJ/RDxaZSFhgA+nPZBrFMsrULkrdAOpOVj8eDEp9JuWdO2ODSoFnCvLxcYWB\r\n"
 152   "Yc5kHryJpEaGJl1sFQSesnzMFty/59ta0stk0Fp8r5NhIjWvSovGzPo6Bhz+VS2c\r\n"
 153   "ebIZh4x1t2hHaFcgm0qJoJ6DceReWCW8w+yOVovTolGGq+bpb2Hn7MnRSZ2K2NdL\r\n"
 154   "+aLXpkZbS/AODP1FF2vTO1mYL290LO7/51vJmPXNKSDYMy5EvILr5/VqtjsFCwRL\r\n"
 155   "Q4jcM/+GeHSAFWx4qIv0BwIDAQABo1AwTjAdBgNVHQ4EFgQUWa1SOB37xmT53tZQ\r\n"
 156   "aXuLLhRI7U8wHwYDVR0jBBgwFoAUWa1SOB37xmT53tZQaXuLLhRI7U8wDAYDVR0T\r\n"
 157   "BAUwAwEB/zANBgkqhkiG9w0BAQsFAAOCAQEAoUht13W4ya27NVzQuCMvqPWL3VM4\r\n"
 158   "3xbPFk02FaGz/WupPu276zGlzJAZrbuDcQowwwU1Ni1Yygxl96s1c2M5rHDTrOKG\r\n"
 159   "rK0hbkSFBo+i6I8u4HiiQ4rYmG0Hv6+sXn3of0HsbtDPGgWZoipPWDljPYEURu3e\r\n"
 160   "3HRe/Dtsj9CakBoSDzs8ndWaBR+f4sM9Tk1cjD46Gq2T/qpSPXqKxEUXlzhdCAn4\r\n"
 161   "twub17Bq2kykHpppCwPg5M+v30tHG/R2Go15MeFWbEJthFk3TZMjKL7UFs7fH+x2\r\n"
 162   "wSonXb++jY+KmCb93C+soABBizE57g/KmiR2IxQ/LMjDik01RSUIaM0lLA==\r\n"
 163   "-----END CERTIFICATE-----\r\n";
 164 uint32_t vcl_test_crt_rsa_len = sizeof (vcl_test_crt_rsa);
 165
 166 char vcl_test_key_rsa[] =
 167   "-----BEGIN PRIVATE KEY-----\r\n"
 168   "MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDgLWTxrUO5K2CC\r\n"
 169   "CpPijT18/2wnZ0LnhvGFL9eTZUR9ohnbbZZKjhf+zJFV9XL1hqFykjXMn9EPFplI\r\n"
 170   "WGAD6c9kGsUyytQuSt0A6k5WPx4MSn0m5Z07Y4NKgWcK8vFxhYFhzmQevImkRoYm\r\n"
 171   "XWwVBJ6yfMwW3L/n21rSy2TQWnyvk2EiNa9Ki8bM+joGHP5VLZx5shmHjHW3aEdo\r\n"
 172   "VyCbSomgnoNx5F5YJbzD7I5Wi9OiUYar5ulvYefsydFJnYrY10v5otemRltL8A4M\r\n"
 173   "/UUXa9M7WZgvb3Qs7v/nW8mY9c0pINgzLkS8guvn9Wq2OwULBEtDiNwz/4Z4dIAV\r\n"
 174   "bHioi/QHAgMBAAECggEBAMzGipP8+oT166U+NlJXRFifFVN1DvdhG9PWnOxGL+c3\r\n"
 175   "ILmBBC08WQzmHshPemBvR6DZkA1H23cV5JTiLWrFtC00CvhXsLRMrE5+uWotI6yE\r\n"
 176   "iofybMroHvD6/X5R510UX9hQ6MHu5ShLR5VZ9zXHz5MpTmB/60jG5dLx+jgcwBK8\r\n"
 177   "LuGv2YB/WCUwT9QJ3YU2eaingnXtz/MrFbkbltrqlnBdlD+kTtw6Yac9y1XuuQXc\r\n"
 178   "BPeulLNDuPolJVWbUvDBZrpt2dXTgz8ws1sv+wCNE0xwQJsqW4Nx3QkpibUL9RUr\r\n"
 179   "CVbKlNfa9lopT6nGKlgX69R/uH35yh9AOsfasro6w0ECgYEA82UJ8u/+ORah+0sF\r\n"
 180   "Q0FfW5MTdi7OAUHOz16pUsGlaEv0ERrjZxmAkHA/VRwpvDBpx4alCv0Hc39PFLIk\r\n"
 181   "nhSsM2BEuBkTAs6/GaoNAiBtQVE/hN7awNRWVmlieS0go3Y3dzaE9IUMyj8sPOFT\r\n"
 182   "5JdJ6BM69PHKCkY3dKdnnfpFEuECgYEA68mRpteunF1mdZgXs+WrN+uLlRrQR20F\r\n"
 183   "ZyMYiUCH2Dtn26EzA2moy7FipIIrQcX/j+KhYNGM3e7MU4LymIO29E18mn8JODnH\r\n"
 184   "sQOXzBTsf8A4yIVMkcuQD3bfb0JiUGYUPOidTp2N7IJA7+6Yc3vQOyb74lnKnJoO\r\n"
 185   "gougPT2wS+cCgYAn7muzb6xFsXDhyW0Tm6YJYBfRS9yAWEuVufINobeBZPSl2cN1\r\n"
 186   "Jrnw+HlrfTNbrJWuJmjtZJXUXQ6cVp2rUbjutNyRV4vG6iRwEXYQ40EJdkr1gZpi\r\n"
 187   "CHQhuShuuPih2MNAy7EEbM+sXrDjTBR3bFqzuHPzu7dp+BshCFX3lRfAAQKBgGQt\r\n"
 188   "K5i7IhCFDjb/+3IPLgOAK7mZvsvZ4eXD33TQ2eZgtut1PXtBtNl17/b85uv293Fm\r\n"
 189   "VDISVcsk3eLNS8zIiT6afUoWlxAwXEs0v5WRfjl4radkGvgGiJpJYvyeM67877RB\r\n"
 190   "EDSKc/X8ESLfOB44iGvZUEMG6zJFscx9DgN25iQZAoGAbyd+JEWwdVH9/K3IH1t2\r\n"
 191   "PBkZX17kNWv+iVM1WyFjbe++vfKZCrOJiyiqhDeEqgrP3AuNMlaaduC3VRC3G5oV\r\n"
 192   "Mj1tlhDWQ/qhvKdCKNdIVQYDE75nw+FRWV8yYkHAnXYW3tNoweDIwixE0hkPR1bc\r\n"
 193   "oEjPLVNtx8SOj/M4rhaPT3I=\r\n" "-----END PRIVATE KEY-----\r\n";
 194 uint32_t vcl_test_key_rsa_len = sizeof (vcl_test_key_rsa);
 195
 196 static inline void
 197 vcl_test_stats_accumulate (vcl_test_stats_t * accum, vcl_test_stats_t * incr)
 198 {
 199   accum->rx_xacts += incr->rx_xacts;
 200   accum->rx_bytes += incr->rx_bytes;
 201   accum->rx_eagain += incr->rx_eagain;
 202   accum->rx_incomp += incr->rx_incomp;
 203   accum->tx_xacts += incr->tx_xacts;
 204   accum->tx_bytes += incr->tx_bytes;
 205   accum->tx_eagain += incr->tx_eagain;
 206   accum->tx_incomp += incr->tx_incomp;
 207 }
 208
 209 static inline void
 210 vcl_test_cfg_init (vcl_test_cfg_t * cfg)
 211 {
 212   cfg->magic = VCL_TEST_CFG_CTRL_MAGIC;
 213   cfg->test = VCL_TEST_TYPE_NONE;
 214   cfg->ctrl_handle = ~0;
 215   cfg->num_test_sessions = 1;
 216   cfg->num_test_sessions_perq = 1;
 217   cfg->verbose = 0;
 218   cfg->rxbuf_size = VCL_TEST_CFG_RXBUF_SIZE_DEF;
 219   cfg->num_writes = VCL_TEST_CFG_NUM_WRITES_DEF;
 220   cfg->txbuf_size = VCL_TEST_CFG_TXBUF_SIZE_DEF;
 221   cfg->total_bytes = cfg->num_writes * cfg->txbuf_size;
 222 }
 223
 224 static inline int
 225 vcl_test_cfg_verify (vcl_test_cfg_t * cfg, vcl_test_cfg_t * valid_cfg)
 226 {
 227   /* Note: txbuf & rxbuf on server are the same buffer,
 228    *       so txbuf_size is not included in this check.
 229    */
 230   return ((cfg->magic == valid_cfg->magic)
 231           && (cfg->test == valid_cfg->test)
 232           && (cfg->verbose == valid_cfg->verbose)
 233           && (cfg->rxbuf_size == valid_cfg->rxbuf_size)
 234           && (cfg->num_writes == valid_cfg->num_writes)
 235           && (cfg->total_bytes == valid_cfg->total_bytes));
 236 }
 237
 238 static inline void
 239 vcl_test_buf_alloc (vcl_test_cfg_t * cfg, uint8_t is_rxbuf, uint8_t ** buf,
 240                     uint32_t * bufsize)
 241 {
 242   uint32_t alloc_size = is_rxbuf ? cfg->rxbuf_size : cfg->txbuf_size;
 243   uint8_t *lb = realloc (*buf, (size_t) alloc_size);
 244
 245   if (lb)
 246     {
 247       if (is_rxbuf)
 248         cfg->rxbuf_size = *bufsize = alloc_size;
 249       else
 250         cfg->txbuf_size = *bufsize = alloc_size;
 251
 252       *buf = lb;
 253     }
 254   else
 255     {
 256       vtwrn ("realloc failed. using buffer size %d instead of %u",
 257              *bufsize, alloc_size);
 258     }
 259 }
 260
 261 static inline void
 262 vcl_test_session_buf_alloc (vcl_test_session_t * socket)
 263 {
 264   socket->rxbuf_size = socket->cfg.rxbuf_size;
 265   socket->txbuf_size = socket->cfg.txbuf_size;
 266   vcl_test_buf_alloc (&socket->cfg, 0 /* is_rxbuf */ ,
 267                       (uint8_t **) & socket->txbuf, &socket->txbuf_size);
 268   vcl_test_buf_alloc (&socket->cfg, 1 /* is_rxbuf */ ,
 269                       (uint8_t **) & socket->rxbuf, &socket->rxbuf_size);
 270 }
 271
 272 static inline char *
 273 vcl_test_type_str (vcl_test_t t)
 274 {
 275   switch (t)
 276     {
 277     case VCL_TEST_TYPE_NONE:
 278       return "NONE";
 279
 280     case VCL_TEST_TYPE_ECHO:
 281       return "ECHO";
 282
 283     case VCL_TEST_TYPE_UNI:
 284       return "UNI";
 285
 286     case VCL_TEST_TYPE_BI:
 287       return "BI";
 288
 289     case VCL_TEST_TYPE_EXIT:
 290       return "EXIT";
 291
 292     default:
 293       return "Unknown";
 294     }
 295 }
 296
 297 static inline void
 298 vcl_test_cfg_dump (vcl_test_cfg_t * cfg, uint8_t is_client)
 299 {
 300   char *spc = "     ";
 301
 302   printf ("  test config (%p):\n"
 303           VCL_TEST_SEPARATOR_STRING
 304           "                 magic:  0x%08x\n"
 305           "               seq_num:  0x%08x\n"
 306           "%-5s             test:  %s (%d)\n"
 307           "           ctrl handle:  %d (0x%x)\n"
 308           "%-5s num test sockets:  %u (0x%08x)\n"
 309           "%-5s          verbose:  %s (%d)\n"
 310           "%-5s       rxbuf size:  %lu (0x%08lx)\n"
 311           "%-5s       txbuf size:  %lu (0x%08lx)\n"
 312           "%-5s       num writes:  %lu (0x%08lx)\n"
 313           "       client tx bytes:  %lu (0x%08lx)\n"
 314           VCL_TEST_SEPARATOR_STRING,
 315           (void *) cfg, cfg->magic, cfg->seq_num,
 316           is_client && (cfg->test == VCL_TEST_TYPE_UNI) ?
 317           "'" VCL_TEST_TOKEN_RUN_UNI "'" :
 318           is_client && (cfg->test == VCL_TEST_TYPE_BI) ?
 319           "'" VCL_TEST_TOKEN_RUN_BI "'" : spc,
 320           vcl_test_type_str (cfg->test), cfg->test,
 321           cfg->ctrl_handle, cfg->ctrl_handle,
 322           is_client ? "'" VCL_TEST_TOKEN_NUM_TEST_SESS "'" : spc,
 323           cfg->num_test_sessions, cfg->num_test_sessions,
 324           is_client ? "'" VCL_TEST_TOKEN_VERBOSE "'" : spc,
 325           cfg->verbose ? "on" : "off", cfg->verbose,
 326           is_client ? "'" VCL_TEST_TOKEN_RXBUF_SIZE "'" : spc,
 327           cfg->rxbuf_size, cfg->rxbuf_size,
 328           is_client ? "'" VCL_TEST_TOKEN_TXBUF_SIZE "'" : spc,
 329           cfg->txbuf_size, cfg->txbuf_size,
 330           is_client ? "'" VCL_TEST_TOKEN_NUM_WRITES "'" : spc,
 331           cfg->num_writes, cfg->num_writes,
 332           cfg->total_bytes, cfg->total_bytes);
 333 }
 334
 335 static inline void
 336 vcl_test_stats_dump (char *header, vcl_test_stats_t * stats,
 337                      uint8_t show_rx, uint8_t show_tx, uint8_t verbose)
 338 {
 339   struct timespec diff;
 340   double duration, rate;
 341   uint64_t total_bytes;
 342
 343   if ((stats->stop.tv_nsec - stats->start.tv_nsec) < 0)
 344     {
 345       diff.tv_sec = stats->stop.tv_sec - stats->start.tv_sec - 1;
 346       diff.tv_nsec = stats->stop.tv_nsec - stats->start.tv_nsec + 1e9;
 347     }
 348   else
 349     {
 350       diff.tv_sec = stats->stop.tv_sec - stats->start.tv_sec;
 351       diff.tv_nsec = stats->stop.tv_nsec - stats->start.tv_nsec;
 352     }
 353   duration = (double) diff.tv_sec + (1e-9 * diff.tv_nsec);
 354
 355   total_bytes = stats->tx_bytes + stats->rx_bytes;
 356   rate = (double) total_bytes *8 / duration / 1e9;
 357   printf ("\n%s: Streamed %lu bytes\n"
 358           "  in %lf seconds (%lf Gbps %s-duplex)!\n",
 359           header, total_bytes, duration, rate,
 360           (show_rx && show_tx) ? "full" : "half");
 361
 362   if (show_tx)
 363     {
 364       printf (VCL_TEST_SEPARATOR_STRING
 365               "  tx stats (0x%p):\n"
 366               VCL_TEST_SEPARATOR_STRING
 367               "         writes:  %lu (0x%08lx)\n"
 368               "       tx bytes:  %lu (0x%08lx)\n"
 369               "      tx eagain:  %u (0x%08x)\n"
 370               "  tx incomplete:  %u (0x%08x)\n",
 371               (void *) stats, stats->tx_xacts, stats->tx_xacts,
 372               stats->tx_bytes, stats->tx_bytes,
 373               stats->tx_eagain, stats->tx_eagain,
 374               stats->tx_incomp, stats->tx_incomp);
 375     }
 376   if (show_rx)
 377     {
 378       printf (VCL_TEST_SEPARATOR_STRING
 379               "  rx stats (0x%p):\n"
 380               VCL_TEST_SEPARATOR_STRING
 381               "          reads:  %lu (0x%08lx)\n"
 382               "       rx bytes:  %lu (0x%08lx)\n"
 383               "      rx eagain:  %u (0x%08x)\n"
 384               "  rx incomplete:  %u (0x%08x)\n",
 385               (void *) stats, stats->rx_xacts, stats->rx_xacts,
 386               stats->rx_bytes, stats->rx_bytes,
 387               stats->rx_eagain, stats->rx_eagain,
 388               stats->rx_incomp, stats->rx_incomp);
 389     }
 390   if (verbose)
 391     printf ("   start.tv_sec:  %ld\n"
 392             "  start.tv_nsec:  %ld\n"
 393             "    stop.tv_sec:  %ld\n"
 394             "   stop.tv_nsec:  %ld\n",
 395             stats->start.tv_sec, stats->start.tv_nsec,
 396             stats->stop.tv_sec, stats->stop.tv_nsec);
 397
 398   printf (VCL_TEST_SEPARATOR_STRING);
 399 }
 400
 401 static inline int
 402 vcl_comp_tspec (struct timespec *a, struct timespec *b)
 403 {
 404   if (a->tv_sec < b->tv_sec)
 405     return -1;
 406   else if (a->tv_sec > b->tv_sec)
 407     return 1;
 408   else if (a->tv_nsec < b->tv_nsec)
 409     return -1;
 410   else if (a->tv_nsec > b->tv_nsec)
 411     return 1;
 412   else
 413     return 0;
 414 }
 415
 416 static inline int
 417 vcl_test_read (int fd, uint8_t * buf, uint32_t nbytes,
 418                vcl_test_stats_t * stats)
 419 {
 420   int rx_bytes;
 421
 422   do
 423     {
 424       if (stats)
 425         stats->rx_xacts++;
 426       rx_bytes = vppcom_session_read (fd, buf, nbytes);
 427
 428       if (rx_bytes < 0)
 429         {
 430           errno = -rx_bytes;
 431           rx_bytes = -1;
 432         }
 433       if (stats)
 434         {
 435           if ((rx_bytes == 0) ||
 436               ((rx_bytes < 0)
 437                && ((errno == EAGAIN) || (errno == EWOULDBLOCK))))
 438             stats->rx_eagain++;
 439           else if (rx_bytes < nbytes)
 440             stats->rx_incomp++;
 441         }
 442     }
 443   while ((rx_bytes == 0) ||
 444          ((rx_bytes < 0) && ((errno == EAGAIN) || (errno == EWOULDBLOCK))));
 445
 446   if (rx_bytes < 0)
 447     {
 448       vterr ("vppcom_session_read()", -errno);
 449     }
 450   else if (stats)
 451     stats->rx_bytes += rx_bytes;
 452
 453   return (rx_bytes);
 454 }
 455
 456 static inline int
 457 vcl_test_read_ds (int fd, vppcom_data_segment_t * ds,
 458                   vcl_test_stats_t * stats)
 459 {
 460   int rx_bytes;
 461
 462   do
 463     {
 464       if (stats)
 465         stats->rx_xacts++;
 466       rx_bytes = vppcom_session_read_segments (fd, ds, 2, ~0);
 467
 468       if (rx_bytes < 0)
 469         {
 470           errno = -rx_bytes;
 471           rx_bytes = -1;
 472         }
 473       if (stats)
 474         {
 475           if ((rx_bytes == 0) ||
 476               ((rx_bytes < 0)
 477                && ((errno == EAGAIN) || (errno == EWOULDBLOCK))))
 478             stats->rx_eagain++;
 479         }
 480     }
 481   while ((rx_bytes == 0) ||
 482          ((rx_bytes < 0) && ((errno == EAGAIN) || (errno == EWOULDBLOCK))));
 483
 484   if (rx_bytes < 0)
 485     {
 486       vterr ("vppcom_session_read()", -errno);
 487     }
 488   else if (stats)
 489     stats->rx_bytes += rx_bytes;
 490
 491   return (rx_bytes);
 492 }
 493
 494 static inline int
 495 vcl_test_write (int fd, uint8_t * buf, uint32_t nbytes,
 496                 vcl_test_stats_t * stats, uint32_t verbose)
 497 {
 498   int tx_bytes = 0, nbytes_left = nbytes, rv;
 499
 500   do
 501     {
 502       if (stats)
 503         stats->tx_xacts++;
 504       rv = vppcom_session_write (fd, buf, nbytes_left);
 505       if (rv < 0)
 506         {
 507           errno = -rv;
 508           if ((errno == EAGAIN || errno == EWOULDBLOCK) && stats)
 509             stats->tx_eagain++;
 510           break;
 511         }
 512       tx_bytes += rv;
 513
 514       nbytes_left = nbytes_left - rv;
 515       buf += rv;
 516       if (stats)
 517         stats->tx_incomp++;
 518
 519     }
 520   while (tx_bytes != nbytes);
 521
 522   if (tx_bytes < 0)
 523     {
 524       vterr ("vpcom_session_write", -errno);
 525     }
 526   else if (stats)
 527     stats->tx_bytes += tx_bytes;
 528
 529   return (tx_bytes);
 530 }
 531
 532 static inline void
 533 dump_help (void)
 534 {
 535 #define INDENT "\n  "
 536
 537   printf ("CLIENT: Test configuration commands:"
 538           INDENT VCL_TEST_TOKEN_HELP
 539           "\t\t\tDisplay help."
 540           INDENT VCL_TEST_TOKEN_EXIT
 541           "\t\t\tExit test client & server."
 542           INDENT VCL_TEST_TOKEN_SHOW_CFG
 543           "\t\t\tShow the current test cfg."
 544           INDENT VCL_TEST_TOKEN_RUN_UNI
 545           "\t\t\tRun the Uni-directional test."
 546           INDENT VCL_TEST_TOKEN_RUN_BI
 547           "\t\t\tRun the Bi-directional test."
 548           INDENT VCL_TEST_TOKEN_VERBOSE
 549           "\t\t\tToggle verbose setting."
 550           INDENT VCL_TEST_TOKEN_RXBUF_SIZE
 551           "<rxbuf size>\tRx buffer size (bytes)."
 552           INDENT VCL_TEST_TOKEN_TXBUF_SIZE
 553           "<txbuf size>\tTx buffer size (bytes)."
 554           INDENT VCL_TEST_TOKEN_NUM_WRITES
 555           "<# of writes>\tNumber of txbuf writes to server." "\n");
 556 }
 557
 558 #endif /* __vcl_test_h__ */
 559
 560 /*
 561  * fd.io coding-style-patch-verification: ON
 562  *
 563  * Local Variables:
 564  * eval: (c-set-style "gnu")
 565  * End:
 566  */