src/vcl/vppcom.c

   1 /*
   2  * Copyright (c) 2017 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this
   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 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <svm/svm_fifo_segment.h>
  19 #include <vcl/vppcom.h>
  20 #include <vcl/vcl_debug.h>
  21 #include <vcl/vcl_private.h>
  22
  23 __thread uword __vcl_worker_index = ~0;
  24
  25 static u8 not_ready;
  26
  27 void
  28 sigsegv_signal (int signum)
  29 {
  30   not_ready = 1;
  31 }
  32
  33 static void
  34 vcl_wait_for_memory (void *mem)
  35 {
  36   u8 __clib_unused test;
  37   if (vcm->mounting_segment)
  38     {
  39       while (vcm->mounting_segment)
  40         ;
  41       return;
  42     }
  43   if (1 || vcm->debug)
  44     {
  45       usleep (1e5);
  46       return;
  47     }
  48   if (signal (SIGSEGV, sigsegv_signal))
  49     {
  50       perror ("signal()");
  51       return;
  52     }
  53   not_ready = 0;
  54
  55 again:
  56   test = *(u8 *) mem;
  57   if (not_ready)
  58     {
  59       not_ready = 0;
  60       usleep (1);
  61       goto again;
  62     }
  63
  64   signal (SIGSEGV, SIG_DFL);
  65 }
  66
  67 const char *
  68 vppcom_session_state_str (session_state_t state)
  69 {
  70   char *st;
  71
  72   switch (state)
  73     {
  74     case STATE_START:
  75       st = "STATE_START";
  76       break;
  77
  78     case STATE_CONNECT:
  79       st = "STATE_CONNECT";
  80       break;
  81
  82     case STATE_LISTEN:
  83       st = "STATE_LISTEN";
  84       break;
  85
  86     case STATE_ACCEPT:
  87       st = "STATE_ACCEPT";
  88       break;
  89
  90     case STATE_CLOSE_ON_EMPTY:
  91       st = "STATE_CLOSE_ON_EMPTY";
  92       break;
  93
  94     case STATE_DISCONNECT:
  95       st = "STATE_DISCONNECT";
  96       break;
  97
  98     case STATE_FAILED:
  99       st = "STATE_FAILED";
 100       break;
 101
 102     default:
 103       st = "UNKNOWN_STATE";
 104       break;
 105     }
 106
 107   return st;
 108 }
 109
 110 u8 *
 111 format_ip4_address (u8 * s, va_list * args)
 112 {
 113   u8 *a = va_arg (*args, u8 *);
 114   return format (s, "%d.%d.%d.%d", a[0], a[1], a[2], a[3]);
 115 }
 116
 117 u8 *
 118 format_ip6_address (u8 * s, va_list * args)
 119 {
 120   ip6_address_t *a = va_arg (*args, ip6_address_t *);
 121   u32 i, i_max_n_zero, max_n_zeros, i_first_zero, n_zeros, last_double_colon;
 122
 123   i_max_n_zero = ARRAY_LEN (a->as_u16);
 124   max_n_zeros = 0;
 125   i_first_zero = i_max_n_zero;
 126   n_zeros = 0;
 127   for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
 128     {
 129       u32 is_zero = a->as_u16[i] == 0;
 130       if (is_zero && i_first_zero >= ARRAY_LEN (a->as_u16))
 131         {
 132           i_first_zero = i;
 133           n_zeros = 0;
 134         }
 135       n_zeros += is_zero;
 136       if ((!is_zero && n_zeros > max_n_zeros)
 137           || (i + 1 >= ARRAY_LEN (a->as_u16) && n_zeros > max_n_zeros))
 138         {
 139           i_max_n_zero = i_first_zero;
 140           max_n_zeros = n_zeros;
 141           i_first_zero = ARRAY_LEN (a->as_u16);
 142           n_zeros = 0;
 143         }
 144     }
 145
 146   last_double_colon = 0;
 147   for (i = 0; i < ARRAY_LEN (a->as_u16); i++)
 148     {
 149       if (i == i_max_n_zero && max_n_zeros > 1)
 150         {
 151           s = format (s, "::");
 152           i += max_n_zeros - 1;
 153           last_double_colon = 1;
 154         }
 155       else
 156         {
 157           s = format (s, "%s%x",
 158                       (last_double_colon || i == 0) ? "" : ":",
 159                       clib_net_to_host_u16 (a->as_u16[i]));
 160           last_double_colon = 0;
 161         }
 162     }
 163
 164   return s;
 165 }
 166
 167 /* Format an IP46 address. */
 168 u8 *
 169 format_ip46_address (u8 * s, va_list * args)
 170 {
 171   ip46_address_t *ip46 = va_arg (*args, ip46_address_t *);
 172   ip46_type_t type = va_arg (*args, ip46_type_t);
 173   int is_ip4 = 1;
 174
 175   switch (type)
 176     {
 177     case IP46_TYPE_ANY:
 178       is_ip4 = ip46_address_is_ip4 (ip46);
 179       break;
 180     case IP46_TYPE_IP4:
 181       is_ip4 = 1;
 182       break;
 183     case IP46_TYPE_IP6:
 184       is_ip4 = 0;
 185       break;
 186     }
 187
 188   return is_ip4 ?
 189     format (s, "%U", format_ip4_address, &ip46->ip4) :
 190     format (s, "%U", format_ip6_address, &ip46->ip6);
 191 }
 192
 193 /*
 194  * VPPCOM Utility Functions
 195  */
 196
 197
 198 static svm_msg_q_t *
 199 vcl_session_vpp_evt_q (vcl_worker_t * wrk, vcl_session_t * s)
 200 {
 201   if (vcl_session_is_ct (s))
 202     return wrk->vpp_event_queues[0];
 203   else
 204     return wrk->vpp_event_queues[s->tx_fifo->master_thread_index];
 205 }
 206
 207 static void
 208 vcl_send_session_accepted_reply (svm_msg_q_t * mq, u32 context,
 209                                  session_handle_t handle, int retval)
 210 {
 211   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 212   session_accepted_reply_msg_t *rmp;
 213   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_ACCEPTED_REPLY);
 214   rmp = (session_accepted_reply_msg_t *) app_evt->evt->data;
 215   rmp->handle = handle;
 216   rmp->context = context;
 217   rmp->retval = retval;
 218   app_send_ctrl_evt_to_vpp (mq, app_evt);
 219 }
 220
 221 static void
 222 vcl_send_session_disconnected_reply (svm_msg_q_t * mq, u32 context,
 223                                      session_handle_t handle, int retval)
 224 {
 225   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 226   session_disconnected_reply_msg_t *rmp;
 227   app_alloc_ctrl_evt_to_vpp (mq, app_evt,
 228                              SESSION_CTRL_EVT_DISCONNECTED_REPLY);
 229   rmp = (session_disconnected_reply_msg_t *) app_evt->evt->data;
 230   rmp->handle = handle;
 231   rmp->context = context;
 232   rmp->retval = retval;
 233   app_send_ctrl_evt_to_vpp (mq, app_evt);
 234 }
 235
 236 static void
 237 vcl_send_session_reset_reply (svm_msg_q_t * mq, u32 context,
 238                               session_handle_t handle, int retval)
 239 {
 240   app_session_evt_t _app_evt, *app_evt = &_app_evt;
 241   session_reset_reply_msg_t *rmp;
 242   app_alloc_ctrl_evt_to_vpp (mq, app_evt, SESSION_CTRL_EVT_RESET_REPLY);
 243   rmp = (session_reset_reply_msg_t *) app_evt->evt->data;
 244   rmp->handle = handle;
 245   rmp->context = context;
 246   rmp->retval = retval;
 247   app_send_ctrl_evt_to_vpp (mq, app_evt);
 248 }
 249
 250 static u32
 251 vcl_session_accepted_handler (vcl_worker_t * wrk, session_accepted_msg_t * mp)
 252 {
 253   vcl_session_t *session, *listen_session;
 254   svm_fifo_t *rx_fifo, *tx_fifo;
 255   u32 vpp_wrk_index;
 256   svm_msg_q_t *evt_q;
 257
 258   session = vcl_session_alloc (wrk);
 259
 260   listen_session = vcl_session_table_lookup_listener (wrk,
 261                                                       mp->listener_handle);
 262   if (!listen_session)
 263     {
 264       svm_msg_q_t *evt_q;
 265       evt_q = uword_to_pointer (mp->vpp_event_queue_address, svm_msg_q_t *);
 266       clib_warning ("VCL<%d>: ERROR: couldn't find listen session: "
 267                     "unknown vpp listener handle %llx",
 268                     getpid (), mp->listener_handle);
 269       vcl_send_session_accepted_reply (evt_q, mp->context, mp->handle,
 270                                        VNET_API_ERROR_INVALID_ARGUMENT);
 271       vcl_session_free (wrk, session);
 272       return VCL_INVALID_SESSION_INDEX;
 273     }
 274
 275   rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
 276   tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
 277
 278   if (mp->server_event_queue_address)
 279     {
 280       session->vpp_evt_q = uword_to_pointer (mp->client_event_queue_address,
 281                                              svm_msg_q_t *);
 282       session->our_evt_q = uword_to_pointer (mp->server_event_queue_address,
 283                                              svm_msg_q_t *);
 284       vcl_wait_for_memory (session->vpp_evt_q);
 285       rx_fifo->master_session_index = session->session_index;
 286       tx_fifo->master_session_index = session->session_index;
 287       rx_fifo->master_thread_index = vcl_get_worker_index ();
 288       tx_fifo->master_thread_index = vcl_get_worker_index ();
 289       vec_validate (wrk->vpp_event_queues, 0);
 290       evt_q = uword_to_pointer (mp->vpp_event_queue_address, svm_msg_q_t *);
 291       wrk->vpp_event_queues[0] = evt_q;
 292     }
 293   else
 294     {
 295       session->vpp_evt_q = uword_to_pointer (mp->vpp_event_queue_address,
 296                                              svm_msg_q_t *);
 297       rx_fifo->client_session_index = session->session_index;
 298       tx_fifo->client_session_index = session->session_index;
 299       rx_fifo->client_thread_index = vcl_get_worker_index ();
 300       tx_fifo->client_thread_index = vcl_get_worker_index ();
 301       vpp_wrk_index = tx_fifo->master_thread_index;
 302       vec_validate (wrk->vpp_event_queues, vpp_wrk_index);
 303       wrk->vpp_event_queues[vpp_wrk_index] = session->vpp_evt_q;
 304     }
 305
 306   session->vpp_handle = mp->handle;
 307   session->client_context = mp->context;
 308   session->rx_fifo = rx_fifo;
 309   session->tx_fifo = tx_fifo;
 310
 311   session->session_state = STATE_ACCEPT;
 312   session->transport.rmt_port = mp->port;
 313   session->transport.is_ip4 = mp->is_ip4;
 314   clib_memcpy (&session->transport.rmt_ip, mp->ip, sizeof (ip46_address_t));
 315
 316   vcl_session_table_add_vpp_handle (wrk, mp->handle, session->session_index);
 317   session->transport.lcl_port = listen_session->transport.lcl_port;
 318   session->transport.lcl_ip = listen_session->transport.lcl_ip;
 319   session->session_type = listen_session->session_type;
 320   session->is_dgram = session->session_type == VPPCOM_PROTO_UDP;
 321
 322   VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: client accept request from %s"
 323         " address %U port %d queue %p!", getpid (), mp->handle,
 324         session->session_index,
 325         mp->is_ip4 ? "IPv4" : "IPv6", format_ip46_address, &mp->ip,
 326         mp->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
 327         clib_net_to_host_u16 (mp->port), session->vpp_evt_q);
 328   vcl_evt (VCL_EVT_ACCEPT, session, listen_session, session_index);
 329
 330   return session->session_index;
 331 }
 332
 333 static u32
 334 vcl_session_connected_handler (vcl_worker_t * wrk,
 335                                session_connected_msg_t * mp)
 336 {
 337   u32 session_index, vpp_wrk_index;
 338   svm_fifo_t *rx_fifo, *tx_fifo;
 339   vcl_session_t *session = 0;
 340   svm_msg_q_t *evt_q;
 341
 342   session_index = mp->context;
 343   session = vcl_session_get (wrk, session_index);
 344   if (!session)
 345     {
 346       clib_warning ("[%s] ERROR: vpp handle 0x%llx, sid %u: "
 347                     "Invalid session index (%u)!",
 348                     getpid (), mp->handle, session_index);
 349       return VCL_INVALID_SESSION_INDEX;
 350     }
 351   if (mp->retval)
 352     {
 353       clib_warning ("VCL<%d>: ERROR: sid %u: connect failed! %U", getpid (),
 354                     session_index, format_api_error, ntohl (mp->retval));
 355       session->session_state = STATE_FAILED;
 356       session->vpp_handle = mp->handle;
 357       return session_index;
 358     }
 359
 360   rx_fifo = uword_to_pointer (mp->server_rx_fifo, svm_fifo_t *);
 361   tx_fifo = uword_to_pointer (mp->server_tx_fifo, svm_fifo_t *);
 362   vcl_wait_for_memory (rx_fifo);
 363   rx_fifo->client_session_index = session_index;
 364   tx_fifo->client_session_index = session_index;
 365   rx_fifo->client_thread_index = vcl_get_worker_index ();
 366   tx_fifo->client_thread_index = vcl_get_worker_index ();
 367
 368   if (mp->client_event_queue_address)
 369     {
 370       session->vpp_evt_q = uword_to_pointer (mp->server_event_queue_address,
 371                                              svm_msg_q_t *);
 372       session->our_evt_q = uword_to_pointer (mp->client_event_queue_address,
 373                                              svm_msg_q_t *);
 374
 375       vec_validate (wrk->vpp_event_queues, 0);
 376       evt_q = uword_to_pointer (mp->vpp_event_queue_address, svm_msg_q_t *);
 377       wrk->vpp_event_queues[0] = evt_q;
 378     }
 379   else
 380     {
 381       session->vpp_evt_q = uword_to_pointer (mp->vpp_event_queue_address,
 382                                              svm_msg_q_t *);
 383       vpp_wrk_index = tx_fifo->master_thread_index;
 384       vec_validate (wrk->vpp_event_queues, vpp_wrk_index);
 385       wrk->vpp_event_queues[vpp_wrk_index] = session->vpp_evt_q;
 386     }
 387
 388   session->rx_fifo = rx_fifo;
 389   session->tx_fifo = tx_fifo;
 390   session->vpp_handle = mp->handle;
 391   session->transport.is_ip4 = mp->is_ip4;
 392   clib_memcpy (&session->transport.lcl_ip, mp->lcl_ip,
 393                sizeof (session->transport.lcl_ip));
 394   session->transport.lcl_port = mp->lcl_port;
 395   session->session_state = STATE_CONNECT;
 396
 397   /* Add it to lookup table */
 398   hash_set (wrk->session_index_by_vpp_handles, mp->handle, session_index);
 399
 400   VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: connect succeeded! "
 401         "session_rx_fifo %p, refcnt %d, session_tx_fifo %p, refcnt %d",
 402         getpid (), mp->handle, session_index, session->rx_fifo,
 403         session->rx_fifo->refcnt, session->tx_fifo, session->tx_fifo->refcnt);
 404
 405   return session_index;
 406 }
 407
 408 static u32
 409 vcl_session_reset_handler (vcl_worker_t * wrk,
 410                            session_reset_msg_t * reset_msg)
 411 {
 412   vcl_session_t *session;
 413   u32 sid;
 414
 415   sid = vcl_session_index_from_vpp_handle (wrk, reset_msg->handle);
 416   session = vcl_session_get (wrk, sid);
 417   if (!session)
 418     {
 419       VDBG (0, "request to reset unknown handle 0x%llx", reset_msg->handle);
 420       return VCL_INVALID_SESSION_INDEX;
 421     }
 422   session->session_state = STATE_CLOSE_ON_EMPTY;
 423   VDBG (0, "reset handle 0x%llx, sid %u ", reset_msg->handle, sid);
 424   vcl_send_session_reset_reply (vcl_session_vpp_evt_q (wrk, session),
 425                                 vcm->my_client_index, reset_msg->handle, 0);
 426   return sid;
 427 }
 428
 429 static u32
 430 vcl_session_bound_handler (vcl_worker_t * wrk, session_bound_msg_t * mp)
 431 {
 432   vcl_session_t *session;
 433   u32 sid = mp->context;
 434
 435   session = vcl_session_get (wrk, sid);
 436   if (mp->retval)
 437     {
 438       VDBG (0, "VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: bind failed: %U",
 439             getpid (), mp->handle, sid, format_api_error, ntohl (mp->retval));
 440       if (session)
 441         {
 442           session->session_state = STATE_FAILED;
 443           session->vpp_handle = mp->handle;
 444           return sid;
 445         }
 446       else
 447         {
 448           clib_warning ("[%s] ERROR: vpp handle 0x%llx, sid %u: "
 449                         "Invalid session index (%u)!",
 450                         getpid (), mp->handle, sid);
 451           return VCL_INVALID_SESSION_INDEX;
 452         }
 453     }
 454
 455   session->vpp_handle = mp->handle;
 456   session->transport.is_ip4 = mp->lcl_is_ip4;
 457   clib_memcpy (&session->transport.lcl_ip, mp->lcl_ip,
 458                sizeof (ip46_address_t));
 459   session->transport.lcl_port = mp->lcl_port;
 460   vcl_session_table_add_listener (wrk, mp->handle, sid);
 461   session->session_state = STATE_LISTEN;
 462
 463   if (session->is_dgram)
 464     {
 465       svm_fifo_t *rx_fifo, *tx_fifo;
 466       session->vpp_evt_q = uword_to_pointer (mp->vpp_evt_q, svm_msg_q_t *);
 467       rx_fifo = uword_to_pointer (mp->rx_fifo, svm_fifo_t *);
 468       rx_fifo->client_session_index = sid;
 469       tx_fifo = uword_to_pointer (mp->tx_fifo, svm_fifo_t *);
 470       tx_fifo->client_session_index = sid;
 471       session->rx_fifo = rx_fifo;
 472       session->tx_fifo = tx_fifo;
 473     }
 474
 475   VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: bind succeeded!",
 476         getpid (), mp->handle, sid);
 477   return sid;
 478 }
 479
 480 static int
 481 vcl_handle_mq_event (vcl_worker_t * wrk, session_event_t * e)
 482 {
 483   session_accepted_msg_t *accepted_msg;
 484   session_disconnected_msg_t *disconnected_msg;
 485   vcl_session_msg_t *vcl_msg;
 486   vcl_session_t *session;
 487   u64 handle;
 488   u32 sid;
 489
 490   switch (e->event_type)
 491     {
 492     case FIFO_EVENT_APP_RX:
 493     case FIFO_EVENT_APP_TX:
 494     case SESSION_IO_EVT_CT_RX:
 495     case SESSION_IO_EVT_CT_TX:
 496       vec_add1 (wrk->unhandled_evts_vector, *e);
 497       break;
 498     case SESSION_CTRL_EVT_ACCEPTED:
 499       accepted_msg = (session_accepted_msg_t *) e->data;
 500       handle = accepted_msg->listener_handle;
 501       session = vcl_session_table_lookup_listener (wrk, handle);
 502       if (!session)
 503         {
 504           clib_warning ("VCL<%d>: ERROR: couldn't find listen session:"
 505                         "listener handle %llx", getpid (), handle);
 506           break;
 507         }
 508
 509       clib_fifo_add2 (session->accept_evts_fifo, vcl_msg);
 510       vcl_msg->accepted_msg = *accepted_msg;
 511       break;
 512     case SESSION_CTRL_EVT_CONNECTED:
 513       vcl_session_connected_handler (wrk,
 514                                      (session_connected_msg_t *) e->data);
 515       break;
 516     case SESSION_CTRL_EVT_DISCONNECTED:
 517       disconnected_msg = (session_disconnected_msg_t *) e->data;
 518       sid = vcl_session_index_from_vpp_handle (wrk, disconnected_msg->handle);
 519       session = vcl_session_get (wrk, sid);
 520       if (!session)
 521         {
 522           VDBG (0, "request to disconnect unknown handle 0x%llx",
 523                 disconnected_msg->handle);
 524           break;
 525         }
 526       session->session_state = STATE_DISCONNECT;
 527       VDBG (0, "disconnected handle 0x%llx, sid %u", disconnected_msg->handle,
 528             sid);
 529       break;
 530     case SESSION_CTRL_EVT_RESET:
 531       vcl_session_reset_handler (wrk, (session_reset_msg_t *) e->data);
 532       break;
 533     case SESSION_CTRL_EVT_BOUND:
 534       vcl_session_bound_handler (wrk, (session_bound_msg_t *) e->data);
 535       break;
 536     default:
 537       clib_warning ("unhandled %u", e->event_type);
 538     }
 539   return VPPCOM_OK;
 540 }
 541
 542 static inline int
 543 vppcom_wait_for_session_state_change (u32 session_index,
 544                                       session_state_t state,
 545                                       f64 wait_for_time)
 546 {
 547   vcl_worker_t *wrk = vcl_worker_get_current ();
 548   f64 timeout = clib_time_now (&wrk->clib_time) + wait_for_time;
 549   vcl_session_t *volatile session;
 550   svm_msg_q_msg_t msg;
 551   session_event_t *e;
 552
 553   do
 554     {
 555       session = vcl_session_get (wrk, session_index);
 556       if (PREDICT_FALSE (!session))
 557         {
 558           return VPPCOM_EBADFD;
 559         }
 560       if (session->session_state & state)
 561         {
 562           return VPPCOM_OK;
 563         }
 564       if (session->session_state & STATE_FAILED)
 565         {
 566           return VPPCOM_ECONNREFUSED;
 567         }
 568
 569       if (svm_msg_q_sub (wrk->app_event_queue, &msg, SVM_Q_NOWAIT, 0))
 570         continue;
 571       e = svm_msg_q_msg_data (wrk->app_event_queue, &msg);
 572       vcl_handle_mq_event (wrk, e);
 573       svm_msg_q_free_msg (wrk->app_event_queue, &msg);
 574     }
 575   while (clib_time_now (&wrk->clib_time) < timeout);
 576
 577   VDBG (0, "VCL<%d>: timeout waiting for state 0x%x (%s)", getpid (), state,
 578         vppcom_session_state_str (state));
 579   vcl_evt (VCL_EVT_SESSION_TIMEOUT, session, session_state);
 580
 581   return VPPCOM_ETIMEDOUT;
 582 }
 583
 584 static int
 585 vppcom_app_session_enable (void)
 586 {
 587   int rv;
 588
 589   if (vcm->app_state != STATE_APP_ENABLED)
 590     {
 591       vppcom_send_session_enable_disable (1 /* is_enabled == TRUE */ );
 592       rv = vcl_wait_for_app_state_change (STATE_APP_ENABLED);
 593       if (PREDICT_FALSE (rv))
 594         {
 595           VDBG (0, "VCL<%d>: application session enable timed out! "
 596                 "returning %d (%s)", getpid (), rv, vppcom_retval_str (rv));
 597           return rv;
 598         }
 599     }
 600   return VPPCOM_OK;
 601 }
 602
 603 static int
 604 vppcom_app_attach (void)
 605 {
 606   int rv;
 607
 608   vppcom_app_send_attach ();
 609   rv = vcl_wait_for_app_state_change (STATE_APP_ATTACHED);
 610   if (PREDICT_FALSE (rv))
 611     {
 612       VDBG (0, "VCL<%d>: application attach timed out! returning %d (%s)",
 613             getpid (), rv, vppcom_retval_str (rv));
 614       return rv;
 615     }
 616
 617   return VPPCOM_OK;
 618 }
 619
 620 static int
 621 vppcom_session_unbind (u32 session_handle)
 622 {
 623   vcl_worker_t *wrk = vcl_worker_get_current ();
 624   vcl_session_t *session = 0;
 625   u64 vpp_handle;
 626
 627   session = vcl_session_get_w_handle (wrk, session_handle);
 628   if (!session)
 629     return VPPCOM_EBADFD;
 630
 631   vpp_handle = session->vpp_handle;
 632   vcl_session_table_del_listener (wrk, vpp_handle);
 633   session->vpp_handle = ~0;
 634   session->session_state = STATE_DISCONNECT;
 635
 636   VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: sending unbind msg! new state"
 637         " 0x%x (%s)", getpid (), vpp_handle, session_handle, STATE_DISCONNECT,
 638         vppcom_session_state_str (STATE_DISCONNECT));
 639   vcl_evt (VCL_EVT_UNBIND, session);
 640   vppcom_send_unbind_sock (vpp_handle);
 641
 642   return VPPCOM_OK;
 643 }
 644
 645 static int
 646 vppcom_session_disconnect (u32 session_handle)
 647 {
 648   vcl_worker_t *wrk = vcl_worker_get_current ();
 649   svm_msg_q_t *vpp_evt_q;
 650   vcl_session_t *session;
 651   session_state_t state;
 652   u64 vpp_handle;
 653
 654   session = vcl_session_get_w_handle (wrk, session_handle);
 655   if (!session)
 656     return VPPCOM_EBADFD;
 657
 658   vpp_handle = session->vpp_handle;
 659   state = session->session_state;
 660
 661   VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u state 0x%x (%s)", getpid (),
 662         vpp_handle, session_handle, state, vppcom_session_state_str (state));
 663
 664   if (PREDICT_FALSE (state & STATE_LISTEN))
 665     {
 666       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
 667                     "Cannot disconnect a listen socket!",
 668                     getpid (), vpp_handle, session_handle);
 669       return VPPCOM_EBADFD;
 670     }
 671
 672   if (state & STATE_CLOSE_ON_EMPTY)
 673     {
 674       vpp_evt_q = vcl_session_vpp_evt_q (wrk, session);
 675       vcl_send_session_disconnected_reply (vpp_evt_q, vcm->my_client_index,
 676                                            vpp_handle, 0);
 677       VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: sending disconnect "
 678             "REPLY...", getpid (), vpp_handle, session_handle);
 679     }
 680   else
 681     {
 682       VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: sending disconnect...",
 683             getpid (), vpp_handle, session_handle);
 684       vppcom_send_disconnect_session (vpp_handle);
 685     }
 686
 687   return VPPCOM_OK;
 688 }
 689
 690 /*
 691  * VPPCOM Public API functions
 692  */
 693 int
 694 vppcom_app_create (char *app_name)
 695 {
 696   vppcom_cfg_t *vcl_cfg = &vcm->cfg;
 697   int rv;
 698
 699   if (!vcm->is_init)
 700     {
 701       vcm->is_init = 1;
 702       vppcom_cfg (&vcm->cfg);
 703       vcl_cfg = &vcm->cfg;
 704
 705       vcm->main_cpu = pthread_self ();
 706       vppcom_init_error_string_table ();
 707       svm_fifo_segment_main_init (vcl_cfg->segment_baseva,
 708                                   20 /* timeout in secs */ );
 709       pool_init_fixed (vcm->workers, vcl_cfg->max_workers);
 710       clib_spinlock_init (&vcm->workers_lock);
 711       vcl_worker_alloc_and_init ();
 712     }
 713
 714   if (vcm->my_client_index == ~0)
 715     {
 716       /* API hookup and connect to VPP */
 717       vppcom_api_hookup ();
 718       vcl_elog_init (vcm);
 719       vcm->app_state = STATE_APP_START;
 720       rv = vppcom_connect_to_vpp (app_name);
 721       if (rv)
 722         {
 723           clib_warning ("VCL<%d>: ERROR: couldn't connect to VPP!",
 724                         getpid ());
 725           return rv;
 726         }
 727
 728       VDBG (0, "VCL<%d>: sending session enable", getpid ());
 729       rv = vppcom_app_session_enable ();
 730       if (rv)
 731         {
 732           clib_warning ("VCL<%d>: ERROR: vppcom_app_session_enable() "
 733                         "failed!", getpid ());
 734           return rv;
 735         }
 736
 737       VDBG (0, "VCL<%d>: sending app attach", getpid ());
 738       rv = vppcom_app_attach ();
 739       if (rv)
 740         {
 741           clib_warning ("VCL<%d>: ERROR: vppcom_app_attach() failed!",
 742                         getpid ());
 743           return rv;
 744         }
 745
 746       VDBG (0, "VCL<%d>: app_name '%s', my_client_index %d (0x%x)",
 747             getpid (), app_name, vcm->my_client_index, vcm->my_client_index);
 748     }
 749
 750   return VPPCOM_OK;
 751 }
 752
 753 void
 754 vppcom_app_destroy (void)
 755 {
 756   int rv;
 757   f64 orig_app_timeout;
 758
 759   if (vcm->my_client_index == ~0)
 760     return;
 761
 762   VDBG (0, "VCL<%d>: detaching from VPP, my_client_index %d (0x%x)",
 763         getpid (), vcm->my_client_index, vcm->my_client_index);
 764   vcl_evt (VCL_EVT_DETACH, vcm);
 765
 766   vppcom_app_send_detach ();
 767   orig_app_timeout = vcm->cfg.app_timeout;
 768   vcm->cfg.app_timeout = 2.0;
 769   rv = vcl_wait_for_app_state_change (STATE_APP_ENABLED);
 770   vcm->cfg.app_timeout = orig_app_timeout;
 771   if (PREDICT_FALSE (rv))
 772     VDBG (0, "VCL<%d>: application detach timed out! returning %d (%s)",
 773           getpid (), rv, vppcom_retval_str (rv));
 774
 775   vcl_elog_stop (vcm);
 776   vl_client_disconnect_from_vlib ();
 777   vcm->my_client_index = ~0;
 778   vcm->app_state = STATE_APP_START;
 779 }
 780
 781 int
 782 vppcom_session_create (u8 proto, u8 is_nonblocking)
 783 {
 784   vcl_worker_t *wrk = vcl_worker_get_current ();
 785   vcl_session_t *session;
 786
 787   session = vcl_session_alloc (wrk);
 788
 789   session->session_type = proto;
 790   session->session_state = STATE_START;
 791   session->vpp_handle = ~0;
 792   session->is_dgram = proto == VPPCOM_PROTO_UDP;
 793
 794   if (is_nonblocking)
 795     VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_NONBLOCK);
 796
 797   vcl_evt (VCL_EVT_CREATE, session, session_type, session->session_state,
 798            is_nonblocking, session_index);
 799
 800   VDBG (0, "VCL<%d>: sid %u", getpid (), session->session_index);
 801
 802   return vcl_session_handle (session);
 803 }
 804
 805 int
 806 vppcom_session_close (uint32_t session_handle)
 807 {
 808   vcl_worker_t *wrk = vcl_worker_get_current ();
 809   vcl_session_t *session = 0;
 810   u8 is_vep, is_vep_session;
 811   session_state_t state;
 812   u32 next_sh, vep_sh;
 813   int rv = VPPCOM_OK;
 814   u64 vpp_handle;
 815
 816   session = vcl_session_get_w_handle (wrk, session_handle);
 817   if (!session)
 818     return VPPCOM_EBADFD;
 819
 820   is_vep = session->is_vep;
 821   is_vep_session = session->is_vep_session;
 822   next_sh = session->vep.next_sh;
 823   vep_sh = session->vep.vep_sh;
 824   state = session->session_state;
 825   vpp_handle = session->vpp_handle;
 826
 827   if (VPPCOM_DEBUG > 0)
 828     {
 829       if (is_vep)
 830         clib_warning ("VCL<%d>: vep_idx %u / sid %u: "
 831                       "closing epoll session...",
 832                       getpid (), session_handle, session_handle);
 833       else
 834         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %d: "
 835                       "closing session...",
 836                       getpid (), vpp_handle, session_handle);
 837     }
 838
 839   if (is_vep)
 840     {
 841       while (next_sh != ~0)
 842         {
 843           rv = vppcom_epoll_ctl (session_handle, EPOLL_CTL_DEL, next_sh, 0);
 844           if (PREDICT_FALSE (rv < 0))
 845             VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: EPOLL_CTL_DEL "
 846                   "vep_idx %u failed! rv %d (%s)",
 847                   getpid (), vpp_handle, next_sh, vep_sh,
 848                   rv, vppcom_retval_str (rv));
 849
 850           next_sh = session->vep.next_sh;
 851         }
 852     }
 853   else
 854     {
 855       if (is_vep_session)
 856         {
 857           rv = vppcom_epoll_ctl (vep_sh, EPOLL_CTL_DEL, session_handle, 0);
 858           if (rv < 0)
 859             VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: EPOLL_CTL_DEL "
 860                   "vep_idx %u failed! rv %d (%s)",
 861                   getpid (), vpp_handle, session_handle,
 862                   vep_sh, rv, vppcom_retval_str (rv));
 863         }
 864
 865       if (state & STATE_LISTEN)
 866         {
 867           rv = vppcom_session_unbind (session_handle);
 868           if (PREDICT_FALSE (rv < 0))
 869             VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: listener unbind "
 870                   "failed! rv %d (%s)",
 871                   getpid (), vpp_handle, session_handle,
 872                   rv, vppcom_retval_str (rv));
 873         }
 874       else if (state & STATE_OPEN)
 875         {
 876           rv = vppcom_session_disconnect (session_handle);
 877           if (PREDICT_FALSE (rv < 0))
 878             clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
 879                           "session disconnect failed! rv %d (%s)",
 880                           getpid (), vpp_handle, session_handle,
 881                           rv, vppcom_retval_str (rv));
 882         }
 883     }
 884
 885   if (vcl_session_is_ct (session))
 886     {
 887       vcl_cut_through_registration_t *ctr;
 888       uword mq_addr;
 889
 890       mq_addr = pointer_to_uword (session->our_evt_q);
 891       ctr = vcl_ct_registration_lock_and_lookup (wrk, mq_addr);
 892       ASSERT (ctr);
 893       if (ctr->epoll_evt_conn_index != ~0)
 894         vcl_mq_epoll_del_evfd (wrk, ctr->epoll_evt_conn_index);
 895       VDBG (0, "Removing ct registration %u",
 896             vcl_ct_registration_index (wrk, ctr));
 897       vcl_ct_registration_del (wrk, ctr);
 898       vcl_ct_registration_lookup_del (wrk, mq_addr);
 899       vcl_ct_registration_unlock (wrk);
 900     }
 901
 902   if (vpp_handle != ~0)
 903     {
 904       vcl_session_table_del_vpp_handle (wrk, vpp_handle);
 905     }
 906   vcl_session_free (wrk, session);
 907
 908   if (VPPCOM_DEBUG > 0)
 909     {
 910       if (is_vep)
 911         clib_warning ("VCL<%d>: vep_idx %u / sid %u: epoll session removed.",
 912                       getpid (), session_handle, session_handle);
 913       else
 914         clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: session removed.",
 915                       getpid (), vpp_handle, session_handle);
 916     }
 917
 918   vcl_evt (VCL_EVT_CLOSE, session, rv);
 919
 920   return rv;
 921 }
 922
 923 int
 924 vppcom_session_bind (uint32_t session_handle, vppcom_endpt_t * ep)
 925 {
 926   vcl_worker_t *wrk = vcl_worker_get_current ();
 927   vcl_session_t *session = 0;
 928
 929   if (!ep || !ep->ip)
 930     return VPPCOM_EINVAL;
 931
 932   session = vcl_session_get_w_handle (wrk, session_handle);
 933   if (!session)
 934     return VPPCOM_EBADFD;
 935
 936   if (session->is_vep)
 937     {
 938       clib_warning ("VCL<%d>: ERROR: sid %u: cannot "
 939                     "bind to an epoll session!", getpid (), session_handle);
 940       return VPPCOM_EBADFD;
 941     }
 942
 943   session->transport.is_ip4 = ep->is_ip4;
 944   if (ep->is_ip4)
 945     clib_memcpy (&session->transport.lcl_ip.ip4, ep->ip,
 946                  sizeof (ip4_address_t));
 947   else
 948     clib_memcpy (&session->transport.lcl_ip.ip6, ep->ip,
 949                  sizeof (ip6_address_t));
 950   session->transport.lcl_port = ep->port;
 951
 952   VDBG (0, "VCL<%d>: sid %u: binding to local %s address %U port %u, "
 953         "proto %s", getpid (), session_handle,
 954         session->transport.is_ip4 ? "IPv4" : "IPv6",
 955         format_ip46_address, &session->transport.lcl_ip,
 956         session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
 957         clib_net_to_host_u16 (session->transport.lcl_port),
 958         session->session_type ? "UDP" : "TCP");
 959   vcl_evt (VCL_EVT_BIND, session);
 960
 961   if (session->session_type == VPPCOM_PROTO_UDP)
 962     vppcom_session_listen (session_handle, 10);
 963
 964   return VPPCOM_OK;
 965 }
 966
 967 int
 968 vppcom_session_listen (uint32_t listen_sh, uint32_t q_len)
 969 {
 970   vcl_worker_t *wrk = vcl_worker_get_current ();
 971   vcl_session_t *listen_session = 0;
 972   u64 listen_vpp_handle;
 973   int rv;
 974
 975   listen_session = vcl_session_get_w_handle (wrk, listen_sh);
 976   if (!listen_session)
 977     return VPPCOM_EBADFD;
 978
 979   if (q_len == 0 || q_len == ~0)
 980     q_len = vcm->cfg.listen_queue_size;
 981
 982   if (listen_session->is_vep)
 983     {
 984       clib_warning ("VCL<%d>: ERROR: sid %u: cannot listen on an "
 985                     "epoll session!", getpid (), listen_sh);
 986       return VPPCOM_EBADFD;
 987     }
 988
 989   listen_vpp_handle = listen_session->vpp_handle;
 990   if (listen_session->session_state & STATE_LISTEN)
 991     {
 992       VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: already in listen state!",
 993             getpid (), listen_vpp_handle, listen_sh);
 994       return VPPCOM_OK;
 995     }
 996
 997   VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: sending VPP bind+listen "
 998         "request...", getpid (), listen_vpp_handle, listen_sh);
 999
1000   /*
1001    * Send listen request to vpp and wait for reply
1002    */
1003   vppcom_send_bind_sock (listen_session);
1004   rv = vppcom_wait_for_session_state_change (listen_session->session_index,
1005                                              STATE_LISTEN,
1006                                              vcm->cfg.session_timeout);
1007
1008   if (PREDICT_FALSE (rv))
1009     {
1010       listen_session = vcl_session_get_w_handle (wrk, listen_sh);
1011       VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: bind+listen failed! "
1012             "returning %d (%s)", getpid (), listen_session->vpp_handle,
1013             listen_sh, rv, vppcom_retval_str (rv));
1014       return rv;
1015     }
1016
1017   return VPPCOM_OK;
1018 }
1019
1020 static int
1021 validate_args_session_accept_ (vcl_worker_t * wrk,
1022                                vcl_session_t * listen_session)
1023 {
1024   /* Input validation - expects spinlock on sessions_lockp */
1025   if (listen_session->is_vep)
1026     {
1027       clib_warning ("VCL<%d>: ERROR: sid %u: cannot accept on an "
1028                     "epoll session!", getpid (),
1029                     listen_session->session_index);
1030       return VPPCOM_EBADFD;
1031     }
1032
1033   if (listen_session->session_state != STATE_LISTEN)
1034     {
1035       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
1036                     "not in listen state! state 0x%x (%s)", getpid (),
1037                     listen_session->vpp_handle, listen_session->session_index,
1038                     listen_session->session_state,
1039                     vppcom_session_state_str (listen_session->session_state));
1040       return VPPCOM_EBADFD;
1041     }
1042   return VPPCOM_OK;
1043 }
1044
1045 int
1046 vppcom_session_accept (uint32_t listen_session_handle, vppcom_endpt_t * ep,
1047                        uint32_t flags)
1048 {
1049   u32 client_session_index = ~0, listen_session_index;
1050   vcl_worker_t *wrk = vcl_worker_get_current ();
1051   session_accepted_msg_t accepted_msg;
1052   vcl_session_t *listen_session = 0;
1053   vcl_session_t *client_session = 0;
1054   svm_msg_q_t *vpp_evt_q;
1055   vcl_session_msg_t *evt;
1056   u64 listen_vpp_handle;
1057   svm_msg_q_msg_t msg;
1058   session_event_t *e;
1059   u8 is_nonblocking;
1060   int rv;
1061
1062   listen_session = vcl_session_get_w_handle (wrk, listen_session_handle);
1063   if (!listen_session)
1064     return VPPCOM_EBADFD;
1065
1066   listen_session_index = listen_session->session_index;
1067   if ((rv = validate_args_session_accept_ (wrk, listen_session)))
1068     return rv;
1069
1070   if (clib_fifo_elts (listen_session->accept_evts_fifo))
1071     {
1072       clib_fifo_sub2 (listen_session->accept_evts_fifo, evt);
1073       accepted_msg = evt->accepted_msg;
1074       goto handle;
1075     }
1076
1077   is_nonblocking = VCL_SESS_ATTR_TEST (listen_session->attr,
1078                                        VCL_SESS_ATTR_NONBLOCK);
1079   if (svm_msg_q_is_empty (wrk->app_event_queue) && is_nonblocking)
1080     return VPPCOM_EAGAIN;
1081
1082   while (1)
1083     {
1084       if (svm_msg_q_sub (wrk->app_event_queue, &msg, SVM_Q_WAIT, 0))
1085         return VPPCOM_EAGAIN;
1086
1087       e = svm_msg_q_msg_data (wrk->app_event_queue, &msg);
1088       if (e->event_type != SESSION_CTRL_EVT_ACCEPTED)
1089         {
1090           clib_warning ("discarded event: %u", e->event_type);
1091           svm_msg_q_free_msg (wrk->app_event_queue, &msg);
1092           continue;
1093         }
1094       clib_memcpy (&accepted_msg, e->data, sizeof (accepted_msg));
1095       svm_msg_q_free_msg (wrk->app_event_queue, &msg);
1096       break;
1097     }
1098
1099 handle:
1100
1101   client_session_index = vcl_session_accepted_handler (wrk, &accepted_msg);
1102   listen_session = vcl_session_get (wrk, listen_session_index);
1103   client_session = vcl_session_get (wrk, client_session_index);
1104
1105   if (flags & O_NONBLOCK)
1106     VCL_SESS_ATTR_SET (client_session->attr, VCL_SESS_ATTR_NONBLOCK);
1107
1108   listen_vpp_handle = listen_session->vpp_handle;
1109   VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: Got a client request! "
1110         "vpp handle 0x%llx, sid %u, flags %d, is_nonblocking %u",
1111         getpid (), listen_vpp_handle, listen_session_handle,
1112         client_session->vpp_handle, client_session_index,
1113         flags, VCL_SESS_ATTR_TEST (client_session->attr,
1114                                    VCL_SESS_ATTR_NONBLOCK));
1115
1116   if (ep)
1117     {
1118       ep->is_ip4 = client_session->transport.is_ip4;
1119       ep->port = client_session->transport.rmt_port;
1120       if (client_session->transport.is_ip4)
1121         clib_memcpy (ep->ip, &client_session->transport.rmt_ip.ip4,
1122                      sizeof (ip4_address_t));
1123       else
1124         clib_memcpy (ep->ip, &client_session->transport.rmt_ip.ip6,
1125                      sizeof (ip6_address_t));
1126     }
1127
1128   if (accepted_msg.server_event_queue_address)
1129     vpp_evt_q = uword_to_pointer (accepted_msg.vpp_event_queue_address,
1130                                   svm_msg_q_t *);
1131   else
1132     vpp_evt_q = client_session->vpp_evt_q;
1133
1134   vcl_send_session_accepted_reply (vpp_evt_q, client_session->client_context,
1135                                    client_session->vpp_handle, 0);
1136
1137   VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: accepted vpp handle 0x%llx, "
1138         "sid %u connection from peer %s address %U port %u to local %s "
1139         "address %U port %u", getpid (), listen_vpp_handle,
1140         listen_session_handle, client_session->vpp_handle,
1141         client_session_index,
1142         client_session->transport.is_ip4 ? "IPv4" : "IPv6",
1143         format_ip46_address, &client_session->transport.rmt_ip,
1144         client_session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
1145         clib_net_to_host_u16 (client_session->transport.rmt_port),
1146         client_session->transport.is_ip4 ? "IPv4" : "IPv6",
1147         format_ip46_address, &client_session->transport.lcl_ip,
1148         client_session->transport.is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
1149         clib_net_to_host_u16 (client_session->transport.lcl_port));
1150   vcl_evt (VCL_EVT_ACCEPT, client_session, listen_session,
1151            client_session_index);
1152
1153   return vcl_session_handle (client_session);
1154 }
1155
1156 int
1157 vppcom_session_connect (uint32_t session_handle, vppcom_endpt_t * server_ep)
1158 {
1159   vcl_worker_t *wrk = vcl_worker_get_current ();
1160   vcl_session_t *session = 0;
1161   u32 session_index;
1162   int rv;
1163
1164   session = vcl_session_get_w_handle (wrk, session_handle);
1165   if (!session)
1166     return VPPCOM_EBADFD;
1167   session_index = session->session_index;
1168
1169   if (PREDICT_FALSE (session->is_vep))
1170     {
1171       clib_warning ("VCL<%d>: ERROR: sid %u: cannot "
1172                     "connect on an epoll session!", getpid (),
1173                     session_handle);
1174       return VPPCOM_EBADFD;
1175     }
1176
1177   if (PREDICT_FALSE (session->session_state & CLIENT_STATE_OPEN))
1178     {
1179       VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: session already "
1180             "connected to %s %U port %d proto %s, state 0x%x (%s)",
1181             getpid (), session->vpp_handle, session_handle,
1182             session->transport.is_ip4 ? "IPv4" : "IPv6",
1183             format_ip46_address,
1184             &session->transport.rmt_ip, session->transport.is_ip4 ?
1185             IP46_TYPE_IP4 : IP46_TYPE_IP6,
1186             clib_net_to_host_u16 (session->transport.rmt_port),
1187             session->session_type ? "UDP" : "TCP", session->session_state,
1188             vppcom_session_state_str (session->session_state));
1189       return VPPCOM_OK;
1190     }
1191
1192   session->transport.is_ip4 = server_ep->is_ip4;
1193   if (session->transport.is_ip4)
1194     clib_memcpy (&session->transport.rmt_ip.ip4, server_ep->ip,
1195                  sizeof (ip4_address_t));
1196   else
1197     clib_memcpy (&session->transport.rmt_ip.ip6, server_ep->ip,
1198                  sizeof (ip6_address_t));
1199   session->transport.rmt_port = server_ep->port;
1200
1201   VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: connecting to server %s %U "
1202         "port %d proto %s",
1203         getpid (), session->vpp_handle, session_handle,
1204         session->transport.is_ip4 ? "IPv4" : "IPv6",
1205         format_ip46_address,
1206         &session->transport.rmt_ip, session->transport.is_ip4 ?
1207         IP46_TYPE_IP4 : IP46_TYPE_IP6,
1208         clib_net_to_host_u16 (session->transport.rmt_port),
1209         session->session_type ? "UDP" : "TCP");
1210
1211   /*
1212    * Send connect request and wait for reply from vpp
1213    */
1214   vppcom_send_connect_sock (session);
1215   rv = vppcom_wait_for_session_state_change (session_index, STATE_CONNECT,
1216                                              vcm->cfg.session_timeout);
1217
1218   session = vcl_session_get (wrk, session_index);
1219
1220   if (PREDICT_FALSE (rv))
1221     {
1222       if (VPPCOM_DEBUG > 0)
1223         {
1224           if (session)
1225             clib_warning ("VCL<%d>: vpp handle 0x%llx, sid %u: connect "
1226                           "failed! returning %d (%s)", getpid (),
1227                           session->vpp_handle, session_handle, rv,
1228                           vppcom_retval_str (rv));
1229           else
1230             clib_warning ("VCL<%d>: no session for sid %u: connect failed! "
1231                           "returning %d (%s)", getpid (),
1232                           session_handle, rv, vppcom_retval_str (rv));
1233         }
1234     }
1235   else
1236     VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: connected!",
1237           getpid (), session->vpp_handle, session_handle);
1238
1239   return rv;
1240 }
1241
1242 static u8
1243 vcl_is_rx_evt_for_session (session_event_t * e, u32 sid, u8 is_ct)
1244 {
1245   if (!is_ct)
1246     return (e->event_type == FIFO_EVENT_APP_RX
1247             && e->fifo->client_session_index == sid);
1248   else
1249     return (e->event_type == SESSION_IO_EVT_CT_TX);
1250 }
1251
1252 static inline u8
1253 vcl_session_is_readable (vcl_session_t * s)
1254 {
1255   return ((s->session_state & STATE_OPEN)
1256           || (s->session_state == STATE_LISTEN
1257               && s->session_type == VPPCOM_PROTO_UDP));
1258 }
1259
1260 static inline int
1261 vppcom_session_read_internal (uint32_t session_handle, void *buf, int n,
1262                               u8 peek)
1263 {
1264   vcl_worker_t *wrk = vcl_worker_get_current ();
1265   int n_read = 0, rv, is_nonblocking;
1266   vcl_session_t *s = 0;
1267   svm_fifo_t *rx_fifo;
1268   svm_msg_q_msg_t msg;
1269   session_event_t *e;
1270   svm_msg_q_t *mq;
1271   u8 is_ct;
1272
1273   if (PREDICT_FALSE (!buf))
1274     return VPPCOM_EINVAL;
1275
1276   s = vcl_session_get_w_handle (wrk, session_handle);
1277   if (PREDICT_FALSE (!s || s->is_vep))
1278     return VPPCOM_EBADFD;
1279
1280   if (PREDICT_FALSE (!vcl_session_is_readable (s)))
1281     {
1282       session_state_t state = s->session_state;
1283       rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
1284
1285       VDBG (0, "VCL<%d>: vpp handle 0x%llx, sid %u: %s session is not open! "
1286             "state 0x%x (%s), returning %d (%s)",
1287             getpid (), s->vpp_handle, session_handle, state,
1288             vppcom_session_state_str (state), rv, vppcom_retval_str (rv));
1289       return rv;
1290     }
1291
1292   is_nonblocking = VCL_SESS_ATTR_TEST (s->attr, VCL_SESS_ATTR_NONBLOCK);
1293   is_ct = vcl_session_is_ct (s);
1294   mq = is_ct ? s->our_evt_q : wrk->app_event_queue;
1295   rx_fifo = s->rx_fifo;
1296
1297   if (svm_fifo_is_empty (rx_fifo))
1298     {
1299       if (is_nonblocking)
1300         {
1301           svm_fifo_unset_event (rx_fifo);
1302           return VPPCOM_OK;
1303         }
1304       while (svm_fifo_is_empty (rx_fifo))
1305         {
1306           svm_fifo_unset_event (rx_fifo);
1307           svm_msg_q_lock (mq);
1308           if (svm_msg_q_is_empty (mq))
1309             svm_msg_q_wait (mq);
1310
1311           svm_msg_q_sub_w_lock (mq, &msg);
1312           e = svm_msg_q_msg_data (mq, &msg);
1313           svm_msg_q_unlock (mq);
1314           if (!vcl_is_rx_evt_for_session (e, s->session_index, is_ct))
1315             {
1316               vcl_handle_mq_event (wrk, e);
1317               svm_msg_q_free_msg (mq, &msg);
1318               continue;
1319             }
1320           svm_msg_q_free_msg (mq, &msg);
1321
1322           if (PREDICT_FALSE (s->session_state == STATE_CLOSE_ON_EMPTY))
1323             return 0;
1324         }
1325     }
1326
1327   if (s->is_dgram)
1328     n_read = app_recv_dgram_raw (rx_fifo, buf, n, &s->transport, 0, peek);
1329   else
1330     n_read = app_recv_stream_raw (rx_fifo, buf, n, 0, peek);
1331
1332   if (svm_fifo_is_empty (rx_fifo))
1333     svm_fifo_unset_event (rx_fifo);
1334
1335   if (is_ct && svm_fifo_want_tx_evt (rx_fifo))
1336     {
1337       svm_fifo_set_want_tx_evt (s->rx_fifo, 0);
1338       app_send_io_evt_to_vpp (s->vpp_evt_q, s->rx_fifo, SESSION_IO_EVT_CT_RX,
1339                               SVM_Q_WAIT);
1340     }
1341
1342   VDBG (2, "VCL<%d>: vpp handle 0x%llx, sid %u: read %d bytes from (%p)",
1343         getpid (), s->vpp_handle, session_handle, n_read, rx_fifo);
1344
1345   return n_read;
1346 }
1347
1348 int
1349 vppcom_session_read (uint32_t session_handle, void *buf, size_t n)
1350 {
1351   return (vppcom_session_read_internal (session_handle, buf, n, 0));
1352 }
1353
1354 static int
1355 vppcom_session_peek (uint32_t session_handle, void *buf, int n)
1356 {
1357   return (vppcom_session_read_internal (session_handle, buf, n, 1));
1358 }
1359
1360 int
1361 vppcom_session_read_segments (uint32_t session_handle,
1362                               vppcom_data_segments_t ds)
1363 {
1364   vcl_worker_t *wrk = vcl_worker_get_current ();
1365   int n_read = 0, rv, is_nonblocking;
1366   vcl_session_t *s = 0;
1367   svm_fifo_t *rx_fifo;
1368   svm_msg_q_msg_t msg;
1369   session_event_t *e;
1370   svm_msg_q_t *mq;
1371   u8 is_ct;
1372
1373   s = vcl_session_get_w_handle (wrk, session_handle);
1374   if (PREDICT_FALSE (!s || s->is_vep))
1375     return VPPCOM_EBADFD;
1376
1377   if (PREDICT_FALSE (!vcl_session_is_readable (s)))
1378     {
1379       session_state_t state = s->session_state;
1380       rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
1381       return rv;
1382     }
1383
1384   is_nonblocking = VCL_SESS_ATTR_TEST (s->attr, VCL_SESS_ATTR_NONBLOCK);
1385   is_ct = vcl_session_is_ct (s);
1386   mq = is_ct ? s->our_evt_q : wrk->app_event_queue;
1387   rx_fifo = s->rx_fifo;
1388
1389   if (svm_fifo_is_empty (rx_fifo))
1390     {
1391       if (is_nonblocking)
1392         {
1393           svm_fifo_unset_event (rx_fifo);
1394           return VPPCOM_OK;
1395         }
1396       while (svm_fifo_is_empty (rx_fifo))
1397         {
1398           svm_fifo_unset_event (rx_fifo);
1399           svm_msg_q_lock (mq);
1400           if (svm_msg_q_is_empty (mq))
1401             svm_msg_q_wait (mq);
1402
1403           svm_msg_q_sub_w_lock (mq, &msg);
1404           e = svm_msg_q_msg_data (mq, &msg);
1405           svm_msg_q_unlock (mq);
1406           if (!vcl_is_rx_evt_for_session (e, s->session_index, is_ct))
1407             {
1408               vcl_handle_mq_event (wrk, e);
1409               svm_msg_q_free_msg (mq, &msg);
1410               continue;
1411             }
1412           svm_msg_q_free_msg (mq, &msg);
1413
1414           if (PREDICT_FALSE (s->session_state == STATE_CLOSE_ON_EMPTY))
1415             return 0;
1416         }
1417     }
1418
1419   n_read = svm_fifo_segments (rx_fifo, (svm_fifo_segment_t *) ds);
1420   svm_fifo_unset_event (rx_fifo);
1421
1422   if (is_ct && n_read + svm_fifo_max_dequeue (rx_fifo) == rx_fifo->nitems)
1423     {
1424       /* If the peer is not polling send notification */
1425       if (!svm_fifo_has_event (s->rx_fifo))
1426         app_send_io_evt_to_vpp (s->vpp_evt_q, s->rx_fifo,
1427                                 SESSION_IO_EVT_CT_RX, SVM_Q_WAIT);
1428     }
1429
1430   return n_read;
1431 }
1432
1433 void
1434 vppcom_session_free_segments (uint32_t session_handle,
1435                               vppcom_data_segments_t ds)
1436 {
1437   vcl_worker_t *wrk = vcl_worker_get_current ();
1438   vcl_session_t *s;
1439
1440   s = vcl_session_get_w_handle (wrk, session_handle);
1441   if (PREDICT_FALSE (!s || s->is_vep))
1442     return;
1443
1444   svm_fifo_segments_free (s->rx_fifo, (svm_fifo_segment_t *) ds);
1445 }
1446
1447 static inline int
1448 vppcom_session_read_ready (vcl_session_t * session)
1449 {
1450   /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
1451   if (PREDICT_FALSE (session->is_vep))
1452     {
1453       clib_warning ("VCL<%d>: ERROR: sid %u: cannot read from an "
1454                     "epoll session!", getpid (), session->session_index);
1455       return VPPCOM_EBADFD;
1456     }
1457
1458   if (PREDICT_FALSE (!(session->session_state & (STATE_OPEN | STATE_LISTEN))))
1459     {
1460       session_state_t state = session->session_state;
1461       int rv;
1462
1463       rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
1464
1465       VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: session is not open!"
1466             " state 0x%x (%s), returning %d (%s)", getpid (),
1467             session->vpp_handle, session->session_index, state,
1468             vppcom_session_state_str (state), rv, vppcom_retval_str (rv));
1469       return rv;
1470     }
1471
1472   if (session->session_state & STATE_LISTEN)
1473     return clib_fifo_elts (session->accept_evts_fifo);
1474
1475   return svm_fifo_max_dequeue (session->rx_fifo);
1476 }
1477
1478 int
1479 vppcom_data_segment_copy (void *buf, vppcom_data_segments_t ds, u32 max_bytes)
1480 {
1481   u32 first_copy = clib_min (ds[0].len, max_bytes);
1482   clib_memcpy (buf, ds[0].data, first_copy);
1483   if (first_copy < max_bytes)
1484     {
1485       clib_memcpy (buf + first_copy, ds[1].data,
1486                    clib_min (ds[1].len, max_bytes - first_copy));
1487     }
1488   return 0;
1489 }
1490
1491 static u8
1492 vcl_is_tx_evt_for_session (session_event_t * e, u32 sid, u8 is_ct)
1493 {
1494   if (!is_ct)
1495     return (e->event_type == FIFO_EVENT_APP_TX
1496             && e->fifo->client_session_index == sid);
1497   else
1498     return (e->event_type == SESSION_IO_EVT_CT_RX);
1499 }
1500
1501 int
1502 vppcom_session_write (uint32_t session_handle, void *buf, size_t n)
1503 {
1504   vcl_worker_t *wrk = vcl_worker_get_current ();
1505   int rv, n_write, is_nonblocking;
1506   vcl_session_t *s = 0;
1507   svm_fifo_t *tx_fifo = 0;
1508   session_evt_type_t et;
1509   svm_msg_q_msg_t msg;
1510   session_event_t *e;
1511   svm_msg_q_t *mq;
1512   u8 is_ct;
1513
1514   if (PREDICT_FALSE (!buf))
1515     return VPPCOM_EINVAL;
1516
1517   s = vcl_session_get_w_handle (wrk, session_handle);
1518   if (PREDICT_FALSE (!s))
1519     return VPPCOM_EBADFD;
1520
1521   if (PREDICT_FALSE (s->is_vep))
1522     {
1523       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
1524                     "cannot write to an epoll session!",
1525                     getpid (), s->vpp_handle, session_handle);
1526
1527       return VPPCOM_EBADFD;
1528     }
1529
1530   if (PREDICT_FALSE (!(s->session_state & STATE_OPEN)))
1531     {
1532       session_state_t state = s->session_state;
1533       rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
1534       VDBG (1, "VCL<%d>: vpp handle 0x%llx, sid %u: session is not open! "
1535             "state 0x%x (%s)", getpid (), s->vpp_handle, session_handle,
1536             state, vppcom_session_state_str (state));
1537       return rv;
1538     }
1539
1540   tx_fifo = s->tx_fifo;
1541   is_ct = vcl_session_is_ct (s);
1542   is_nonblocking = VCL_SESS_ATTR_TEST (s->attr, VCL_SESS_ATTR_NONBLOCK);
1543   mq = is_ct ? s->our_evt_q : wrk->app_event_queue;
1544   if (svm_fifo_is_full (tx_fifo))
1545     {
1546       if (is_nonblocking)
1547         {
1548           return VPPCOM_EWOULDBLOCK;
1549         }
1550       while (svm_fifo_is_full (tx_fifo))
1551         {
1552           svm_fifo_set_want_tx_evt (tx_fifo, 1);
1553           svm_msg_q_lock (mq);
1554           svm_msg_q_wait (mq);
1555
1556           svm_msg_q_sub_w_lock (mq, &msg);
1557           e = svm_msg_q_msg_data (mq, &msg);
1558           svm_msg_q_unlock (mq);
1559
1560           if (!vcl_is_tx_evt_for_session (e, s->session_index, is_ct))
1561             vcl_handle_mq_event (wrk, e);
1562           svm_msg_q_free_msg (mq, &msg);
1563         }
1564     }
1565
1566   ASSERT (FIFO_EVENT_APP_TX + 1 == SESSION_IO_EVT_CT_TX);
1567   et = FIFO_EVENT_APP_TX + vcl_session_is_ct (s);
1568   if (s->is_dgram)
1569     n_write = app_send_dgram_raw (tx_fifo, &s->transport,
1570                                   s->vpp_evt_q, buf, n, et, SVM_Q_WAIT);
1571   else
1572     n_write = app_send_stream_raw (tx_fifo, s->vpp_evt_q, buf, n, et,
1573                                    SVM_Q_WAIT);
1574
1575   ASSERT (n_write > 0);
1576
1577   VDBG (2, "VCL<%d>: vpp handle 0x%llx, sid %u: wrote %d bytes", getpid (),
1578         s->vpp_handle, session_handle, n_write);
1579
1580   return n_write;
1581 }
1582
1583 static vcl_session_t *
1584 vcl_ct_session_get_from_fifo (vcl_worker_t * wrk, svm_fifo_t * f, u8 type)
1585 {
1586   vcl_session_t *s;
1587   s = vcl_session_get (wrk, f->client_session_index);
1588   if (s)
1589     {
1590       /* rx fifo */
1591       if (type == 0 && s->rx_fifo == f)
1592         return s;
1593       /* tx fifo */
1594       if (type == 1 && s->tx_fifo == f)
1595         return s;
1596     }
1597   s = vcl_session_get (wrk, f->master_session_index);
1598   if (s)
1599     {
1600       if (type == 0 && s->rx_fifo == f)
1601         return s;
1602       if (type == 1 && s->tx_fifo == f)
1603         return s;
1604     }
1605   return 0;
1606 }
1607
1608 static inline int
1609 vppcom_session_write_ready (vcl_session_t * session)
1610 {
1611   /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
1612   if (PREDICT_FALSE (session->is_vep))
1613     {
1614       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
1615                     "cannot write to an epoll session!",
1616                     getpid (), session->vpp_handle, session->session_index);
1617       return VPPCOM_EBADFD;
1618     }
1619
1620   if (PREDICT_FALSE (session->session_state & STATE_LISTEN))
1621     {
1622       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
1623                     "cannot write to a listen session!",
1624                     getpid (), session->vpp_handle, session->session_index);
1625       return VPPCOM_EBADFD;
1626     }
1627
1628   if (PREDICT_FALSE (!(session->session_state & STATE_OPEN)))
1629     {
1630       session_state_t state = session->session_state;
1631       int rv;
1632
1633       rv = ((state & STATE_DISCONNECT) ? VPPCOM_ECONNRESET : VPPCOM_ENOTCONN);
1634       clib_warning ("VCL<%d>: ERROR: vpp handle 0x%llx, sid %u: "
1635                     "session is not open! state 0x%x (%s), "
1636                     "returning %d (%s)", getpid (), session->vpp_handle,
1637                     session->session_index,
1638                     state, vppcom_session_state_str (state),
1639                     rv, vppcom_retval_str (rv));
1640       return rv;
1641     }
1642
1643   VDBG (3, "VCL<%d>: vpp handle 0x%llx, sid %u: peek %s (%p), ready = %d",
1644         getpid (), session->vpp_handle, session->session_index,
1645         session->tx_fifo, svm_fifo_max_enqueue (session->tx_fifo));
1646
1647   return svm_fifo_max_enqueue (session->tx_fifo);
1648 }
1649
1650 static inline int
1651 vcl_mq_dequeue_batch (vcl_worker_t * wrk, svm_msg_q_t * mq)
1652 {
1653   svm_msg_q_msg_t *msg;
1654   u32 n_msgs;
1655   int i;
1656
1657   n_msgs = svm_msg_q_size (mq);
1658   for (i = 0; i < n_msgs; i++)
1659     {
1660       vec_add2 (wrk->mq_msg_vector, msg, 1);
1661       svm_msg_q_sub_w_lock (mq, msg);
1662     }
1663   return n_msgs;
1664 }
1665
1666 #define vcl_fifo_rx_evt_valid_or_break(_fifo)                   \
1667 if (PREDICT_FALSE (svm_fifo_is_empty (_fifo)))                  \
1668   {                                                             \
1669     svm_fifo_unset_event (_fifo);                               \
1670     if (svm_fifo_is_empty (_fifo))                              \
1671       break;                                                    \
1672   }                                                             \
1673
1674 static void
1675 vcl_select_handle_mq_event (vcl_worker_t * wrk, session_event_t * e,
1676                             unsigned long n_bits, unsigned long *read_map,
1677                             unsigned long *write_map,
1678                             unsigned long *except_map, u32 * bits_set)
1679 {
1680   session_disconnected_msg_t *disconnected_msg;
1681   session_connected_msg_t *connected_msg;
1682   session_accepted_msg_t *accepted_msg;
1683   vcl_session_msg_t *vcl_msg;
1684   vcl_session_t *session;
1685   u64 handle;
1686   u32 sid;
1687
1688   switch (e->event_type)
1689     {
1690     case FIFO_EVENT_APP_RX:
1691       vcl_fifo_rx_evt_valid_or_break (e->fifo);
1692       sid = e->fifo->client_session_index;
1693       session = vcl_session_get (wrk, sid);
1694       if (!session)
1695         break;
1696       if (sid < n_bits && read_map)
1697         {
1698           clib_bitmap_set_no_check (read_map, sid, 1);
1699           *bits_set += 1;
1700         }
1701       break;
1702     case FIFO_EVENT_APP_TX:
1703       sid = e->fifo->client_session_index;
1704       session = vcl_session_get (wrk, sid);
1705       if (!session)
1706         break;
1707       if (sid < n_bits && write_map)
1708         {
1709           clib_bitmap_set_no_check (write_map, sid, 1);
1710           *bits_set += 1;
1711         }
1712       break;
1713     case SESSION_IO_EVT_CT_TX:
1714       vcl_fifo_rx_evt_valid_or_break (e->fifo);
1715       session = vcl_ct_session_get_from_fifo (wrk, e->fifo, 0);
1716       if (!session)
1717         break;
1718       sid = session->session_index;
1719       if (sid < n_bits && read_map)
1720         {
1721           clib_bitmap_set_no_check (read_map, sid, 1);
1722           *bits_set += 1;
1723         }
1724       break;
1725     case SESSION_IO_EVT_CT_RX:
1726       session = vcl_ct_session_get_from_fifo (wrk, e->fifo, 1);
1727       if (!session)
1728         break;
1729       sid = session->session_index;
1730       if (sid < n_bits && write_map)
1731         {
1732           clib_bitmap_set_no_check (write_map, sid, 1);
1733           *bits_set += 1;
1734         }
1735       break;
1736     case SESSION_CTRL_EVT_ACCEPTED:
1737       accepted_msg = (session_accepted_msg_t *) e->data;
1738       handle = accepted_msg->listener_handle;
1739       session = vcl_session_table_lookup_listener (wrk, handle);
1740       if (!session)
1741         {
1742           clib_warning ("VCL<%d>: ERROR: couldn't find listen session:"
1743                         "listener handle %llx", getpid (), handle);
1744           break;
1745         }
1746
1747       clib_fifo_add2 (session->accept_evts_fifo, vcl_msg);
1748       vcl_msg->accepted_msg = *accepted_msg;
1749       sid = session->session_index;
1750       if (sid < n_bits && read_map)
1751         {
1752           clib_bitmap_set_no_check (read_map, sid, 1);
1753           *bits_set += 1;
1754         }
1755       break;
1756     case SESSION_CTRL_EVT_CONNECTED:
1757       connected_msg = (session_connected_msg_t *) e->data;
1758       vcl_session_connected_handler (wrk, connected_msg);
1759       break;
1760     case SESSION_CTRL_EVT_DISCONNECTED:
1761       disconnected_msg = (session_disconnected_msg_t *) e->data;
1762       sid = vcl_session_index_from_vpp_handle (wrk, disconnected_msg->handle);
1763       if (sid < n_bits && except_map)
1764         {
1765           clib_bitmap_set_no_check (except_map, sid, 1);
1766           *bits_set += 1;
1767         }
1768       break;
1769     case SESSION_CTRL_EVT_RESET:
1770       sid = vcl_session_reset_handler (wrk, (session_reset_msg_t *) e->data);
1771       if (sid < n_bits && except_map)
1772         {
1773           clib_bitmap_set_no_check (except_map, sid, 1);
1774           *bits_set += 1;
1775         }
1776       break;
1777     default:
1778       clib_warning ("unhandled: %u", e->event_type);
1779       break;
1780     }
1781 }
1782
1783 static int
1784 vcl_select_handle_mq (vcl_worker_t * wrk, svm_msg_q_t * mq,
1785                       unsigned long n_bits, unsigned long *read_map,
1786                       unsigned long *write_map, unsigned long *except_map,
1787                       double time_to_wait, u32 * bits_set)
1788 {
1789   svm_msg_q_msg_t *msg;
1790   session_event_t *e;
1791   u32 i;
1792
1793   svm_msg_q_lock (mq);
1794   if (svm_msg_q_is_empty (mq))
1795     {
1796       if (*bits_set)
1797         {
1798           svm_msg_q_unlock (mq);
1799           return 0;
1800         }
1801
1802       if (!time_to_wait)
1803         {
1804           svm_msg_q_unlock (mq);
1805           return 0;
1806         }
1807       else if (time_to_wait < 0)
1808         {
1809           svm_msg_q_wait (mq);
1810         }
1811       else
1812         {
1813           if (svm_msg_q_timedwait (mq, time_to_wait))
1814             {
1815               svm_msg_q_unlock (mq);
1816               return 0;
1817             }
1818         }
1819     }
1820   vcl_mq_dequeue_batch (wrk, mq);
1821   svm_msg_q_unlock (mq);
1822
1823   for (i = 0; i < vec_len (wrk->mq_msg_vector); i++)
1824     {
1825       msg = vec_elt_at_index (wrk->mq_msg_vector, i);
1826       e = svm_msg_q_msg_data (mq, msg);
1827       vcl_select_handle_mq_event (wrk, e, n_bits, read_map, write_map,
1828                                   except_map, bits_set);
1829       svm_msg_q_free_msg (mq, msg);
1830     }
1831   vec_reset_length (wrk->mq_msg_vector);
1832   return *bits_set;
1833 }
1834
1835 static int
1836 vppcom_select_condvar (vcl_worker_t * wrk, unsigned long n_bits,
1837                        unsigned long *read_map, unsigned long *write_map,
1838                        unsigned long *except_map, double time_to_wait,
1839                        u32 * bits_set)
1840 {
1841   double total_wait = 0, wait_slice;
1842   vcl_cut_through_registration_t *cr;
1843
1844   time_to_wait = (time_to_wait == -1) ? 10e9 : time_to_wait;
1845   wait_slice = wrk->cut_through_registrations ? 10e-6 : time_to_wait;
1846   do
1847     {
1848       vcl_ct_registration_lock (wrk);
1849       /* *INDENT-OFF* */
1850       pool_foreach (cr, wrk->cut_through_registrations, ({
1851         vcl_select_handle_mq (wrk, cr->mq, n_bits, read_map, write_map, except_map,
1852                               0, bits_set);
1853       }));
1854       /* *INDENT-ON* */
1855       vcl_ct_registration_unlock (wrk);
1856
1857       vcl_select_handle_mq (wrk, wrk->app_event_queue, n_bits, read_map,
1858                             write_map, except_map, time_to_wait, bits_set);
1859       total_wait += wait_slice;
1860       if (*bits_set)
1861         return *bits_set;
1862     }
1863   while (total_wait < time_to_wait);
1864
1865   return 0;
1866 }
1867
1868 static int
1869 vppcom_select_eventfd (vcl_worker_t * wrk, unsigned long n_bits,
1870                        unsigned long *read_map, unsigned long *write_map,
1871                        unsigned long *except_map, double time_to_wait,
1872                        u32 * bits_set)
1873 {
1874   vcl_mq_evt_conn_t *mqc;
1875   int __clib_unused n_read;
1876   int n_mq_evts, i;
1877   u64 buf;
1878
1879   vec_validate (wrk->mq_events, pool_elts (wrk->mq_evt_conns));
1880   n_mq_evts = epoll_wait (wrk->mqs_epfd, wrk->mq_events,
1881                           vec_len (wrk->mq_events), time_to_wait);
1882   for (i = 0; i < n_mq_evts; i++)
1883     {
1884       mqc = vcl_mq_evt_conn_get (wrk, wrk->mq_events[i].data.u32);
1885       n_read = read (mqc->mq_fd, &buf, sizeof (buf));
1886       vcl_select_handle_mq (wrk, mqc->mq, n_bits, read_map, write_map,
1887                             except_map, 0, bits_set);
1888     }
1889
1890   return (n_mq_evts > 0 ? (int) *bits_set : 0);
1891 }
1892
1893 int
1894 vppcom_select (unsigned long n_bits, unsigned long *read_map,
1895                unsigned long *write_map, unsigned long *except_map,
1896                double time_to_wait)
1897 {
1898   u32 sid, minbits = clib_max (n_bits, BITS (uword)), bits_set = 0;
1899   vcl_worker_t *wrk = vcl_worker_get_current ();
1900   vcl_session_t *session = 0;
1901   int rv, i;
1902
1903   ASSERT (sizeof (clib_bitmap_t) == sizeof (long int));
1904
1905   if (n_bits && read_map)
1906     {
1907       clib_bitmap_validate (wrk->rd_bitmap, minbits);
1908       clib_memcpy (wrk->rd_bitmap, read_map,
1909                    vec_len (wrk->rd_bitmap) * sizeof (clib_bitmap_t));
1910       memset (read_map, 0, vec_len (wrk->rd_bitmap) * sizeof (clib_bitmap_t));
1911     }
1912   if (n_bits && write_map)
1913     {
1914       clib_bitmap_validate (wrk->wr_bitmap, minbits);
1915       clib_memcpy (wrk->wr_bitmap, write_map,
1916                    vec_len (wrk->wr_bitmap) * sizeof (clib_bitmap_t));
1917       memset (write_map, 0,
1918               vec_len (wrk->wr_bitmap) * sizeof (clib_bitmap_t));
1919     }
1920   if (n_bits && except_map)
1921     {
1922       clib_bitmap_validate (wrk->ex_bitmap, minbits);
1923       clib_memcpy (wrk->ex_bitmap, except_map,
1924                    vec_len (wrk->ex_bitmap) * sizeof (clib_bitmap_t));
1925       memset (except_map, 0,
1926               vec_len (wrk->ex_bitmap) * sizeof (clib_bitmap_t));
1927     }
1928
1929   if (!n_bits)
1930     return 0;
1931
1932   if (!write_map)
1933     goto check_rd;
1934
1935   /* *INDENT-OFF* */
1936   clib_bitmap_foreach (sid, wrk->wr_bitmap, ({
1937     if (!(session = vcl_session_get (wrk, sid)))
1938       {
1939         VDBG (0, "VCL<%d>: session %d specified in write_map is closed.",
1940               getpid (), sid);
1941         return VPPCOM_EBADFD;
1942       }
1943
1944     rv = svm_fifo_is_full (session->tx_fifo);
1945     if (!rv)
1946       {
1947         clib_bitmap_set_no_check (write_map, sid, 1);
1948         bits_set++;
1949       }
1950   }));
1951
1952 check_rd:
1953   if (!read_map)
1954     goto check_mq;
1955
1956   clib_bitmap_foreach (sid, wrk->rd_bitmap, ({
1957     if (!(session = vcl_session_get (wrk, sid)))
1958       {
1959         VDBG (0, "VCL<%d>: session %d specified in write_map is closed.",
1960               getpid (), sid);
1961         return VPPCOM_EBADFD;
1962       }
1963
1964     rv = vppcom_session_read_ready (session);
1965     if (rv)
1966       {
1967         clib_bitmap_set_no_check (read_map, sid, 1);
1968         bits_set++;
1969       }
1970   }));
1971   /* *INDENT-ON* */
1972
1973 check_mq:
1974
1975   for (i = 0; i < vec_len (wrk->unhandled_evts_vector); i++)
1976     {
1977       vcl_select_handle_mq_event (wrk, &wrk->unhandled_evts_vector[i], n_bits,
1978                                   read_map, write_map, except_map, &bits_set);
1979     }
1980   vec_reset_length (wrk->unhandled_evts_vector);
1981
1982   if (vcm->cfg.use_mq_eventfd)
1983     vppcom_select_eventfd (wrk, n_bits, read_map, write_map, except_map,
1984                            time_to_wait, &bits_set);
1985   else
1986     vppcom_select_condvar (wrk, n_bits, read_map, write_map, except_map,
1987                            time_to_wait, &bits_set);
1988
1989   return (bits_set);
1990 }
1991
1992 static inline void
1993 vep_verify_epoll_chain (vcl_worker_t * wrk, u32 vep_idx)
1994 {
1995   vcl_session_t *session;
1996   vppcom_epoll_t *vep;
1997   u32 sid = vep_idx;
1998
1999   if (VPPCOM_DEBUG <= 1)
2000     return;
2001
2002   /* Assumes caller has acquired spinlock: vcm->sessions_lockp */
2003   session = vcl_session_get (wrk, vep_idx);
2004   if (PREDICT_FALSE (!session))
2005     {
2006       clib_warning ("VCL<%d>: ERROR: Invalid vep_idx (%u)!",
2007                     getpid (), vep_idx);
2008       goto done;
2009     }
2010   if (PREDICT_FALSE (!session->is_vep))
2011     {
2012       clib_warning ("VCL<%d>: ERROR: vep_idx (%u) is not a vep!",
2013                     getpid (), vep_idx);
2014       goto done;
2015     }
2016   vep = &session->vep;
2017   clib_warning ("VCL<%d>: vep_idx (%u): Dumping epoll chain\n"
2018                 "{\n"
2019                 "   is_vep         = %u\n"
2020                 "   is_vep_session = %u\n"
2021                 "   next_sid       = 0x%x (%u)\n"
2022                 "   wait_cont_idx  = 0x%x (%u)\n"
2023                 "}\n", getpid (), vep_idx,
2024                 session->is_vep, session->is_vep_session,
2025                 vep->next_sh, vep->next_sh,
2026                 session->wait_cont_idx, session->wait_cont_idx);
2027
2028   for (sid = vep->next_sh; sid != ~0; sid = vep->next_sh)
2029     {
2030       session = vcl_session_get (wrk, sid);
2031       if (PREDICT_FALSE (!session))
2032         {
2033           clib_warning ("VCL<%d>: ERROR: Invalid sid (%u)!", getpid (), sid);
2034           goto done;
2035         }
2036       if (PREDICT_FALSE (session->is_vep))
2037         clib_warning ("VCL<%d>: ERROR: sid (%u) is a vep!",
2038                       getpid (), vep_idx);
2039       else if (PREDICT_FALSE (!session->is_vep_session))
2040         {
2041           clib_warning ("VCL<%d>: ERROR: session (%u) "
2042                         "is not a vep session!", getpid (), sid);
2043           goto done;
2044         }
2045       vep = &session->vep;
2046       if (PREDICT_FALSE (vep->vep_sh != vep_idx))
2047         clib_warning ("VCL<%d>: ERROR: session (%u) vep_idx (%u) != "
2048                       "vep_idx (%u)!", getpid (),
2049                       sid, session->vep.vep_sh, vep_idx);
2050       if (session->is_vep_session)
2051         {
2052           clib_warning ("vep_idx[%u]: sid 0x%x (%u)\n"
2053                         "{\n"
2054                         "   next_sid       = 0x%x (%u)\n"
2055                         "   prev_sid       = 0x%x (%u)\n"
2056                         "   vep_idx        = 0x%x (%u)\n"
2057                         "   ev.events      = 0x%x\n"
2058                         "   ev.data.u64    = 0x%llx\n"
2059                         "   et_mask        = 0x%x\n"
2060                         "}\n",
2061                         vep_idx, sid, sid,
2062                         vep->next_sh, vep->next_sh,
2063                         vep->prev_sh, vep->prev_sh,
2064                         vep->vep_sh, vep->vep_sh,
2065                         vep->ev.events, vep->ev.data.u64, vep->et_mask);
2066         }
2067     }
2068
2069 done:
2070   clib_warning ("VCL<%d>: vep_idx (%u): Dump complete!\n",
2071                 getpid (), vep_idx);
2072 }
2073
2074 int
2075 vppcom_epoll_create (void)
2076 {
2077   vcl_worker_t *wrk = vcl_worker_get_current ();
2078   vcl_session_t *vep_session;
2079
2080   vep_session = vcl_session_alloc (wrk);
2081
2082   vep_session->is_vep = 1;
2083   vep_session->vep.vep_sh = ~0;
2084   vep_session->vep.next_sh = ~0;
2085   vep_session->vep.prev_sh = ~0;
2086   vep_session->wait_cont_idx = ~0;
2087   vep_session->vpp_handle = ~0;
2088
2089   vcl_evt (VCL_EVT_EPOLL_CREATE, vep_session, vep_sh);
2090   VDBG (0, "VCL<%d>: Created vep_idx %u / sid %u!",
2091         getpid (), vep_session->session_index, vep_session->session_index);
2092
2093   return vcl_session_handle (vep_session);
2094 }
2095
2096 int
2097 vppcom_epoll_ctl (uint32_t vep_handle, int op, uint32_t session_handle,
2098                   struct epoll_event *event)
2099 {
2100   vcl_worker_t *wrk = vcl_worker_get_current ();
2101   vcl_session_t *vep_session;
2102   vcl_session_t *session;
2103   int rv = VPPCOM_OK;
2104
2105   if (vep_handle == session_handle)
2106     {
2107       clib_warning ("VCL<%d>: ERROR: vep_idx == session_index (%u)!",
2108                     getpid (), vep_handle);
2109       return VPPCOM_EINVAL;
2110     }
2111
2112   vep_session = vcl_session_get_w_handle (wrk, vep_handle);
2113   if (PREDICT_FALSE (!vep_session))
2114     {
2115       clib_warning ("VCL<%d>: ERROR: Invalid vep_idx (%u)!", vep_handle);
2116       return VPPCOM_EBADFD;
2117     }
2118   if (PREDICT_FALSE (!vep_session->is_vep))
2119     {
2120       clib_warning ("VCL<%d>: ERROR: vep_idx (%u) is not a vep!",
2121                     getpid (), vep_handle);
2122       return VPPCOM_EINVAL;
2123     }
2124
2125   ASSERT (vep_session->vep.vep_sh == ~0);
2126   ASSERT (vep_session->vep.prev_sh == ~0);
2127
2128   session = vcl_session_get_w_handle (wrk, session_handle);
2129   if (PREDICT_FALSE (!session))
2130     {
2131       VDBG (0, "VCL<%d>: ERROR: Invalid session_handle (%u)!",
2132             getpid (), session_handle);
2133       return VPPCOM_EBADFD;
2134     }
2135   if (PREDICT_FALSE (session->is_vep))
2136     {
2137       clib_warning ("ERROR: session_handle (%u) is a vep!", vep_handle);
2138       return VPPCOM_EINVAL;
2139     }
2140
2141   switch (op)
2142     {
2143     case EPOLL_CTL_ADD:
2144       if (PREDICT_FALSE (!event))
2145         {
2146           clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_ADD: NULL pointer to "
2147                         "epoll_event structure!", getpid ());
2148           return VPPCOM_EINVAL;
2149         }
2150       if (vep_session->vep.next_sh != ~0)
2151         {
2152           vcl_session_t *next_session;
2153           next_session = vcl_session_get_w_handle (wrk,
2154                                                    vep_session->vep.next_sh);
2155           if (PREDICT_FALSE (!next_session))
2156             {
2157               clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_ADD: Invalid "
2158                             "vep.next_sid (%u) on vep_idx (%u)!",
2159                             getpid (), vep_session->vep.next_sh, vep_handle);
2160               return VPPCOM_EBADFD;
2161             }
2162           ASSERT (next_session->vep.prev_sh == vep_handle);
2163           next_session->vep.prev_sh = session_handle;
2164         }
2165       session->vep.next_sh = vep_session->vep.next_sh;
2166       session->vep.prev_sh = vep_handle;
2167       session->vep.vep_sh = vep_handle;
2168       session->vep.et_mask = VEP_DEFAULT_ET_MASK;
2169       session->vep.ev = *event;
2170       session->is_vep = 0;
2171       session->is_vep_session = 1;
2172       vep_session->vep.next_sh = session_handle;
2173
2174       VDBG (1, "VCL<%d>: EPOLL_CTL_ADD: vep_idx %u, sid %u, events 0x%x, "
2175             "data 0x%llx!", getpid (), vep_handle, session_handle,
2176             event->events, event->data.u64);
2177       vcl_evt (VCL_EVT_EPOLL_CTLADD, session, event->events, event->data.u64);
2178       break;
2179
2180     case EPOLL_CTL_MOD:
2181       if (PREDICT_FALSE (!event))
2182         {
2183           clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_MOD: NULL pointer to "
2184                         "epoll_event structure!", getpid ());
2185           rv = VPPCOM_EINVAL;
2186           goto done;
2187         }
2188       else if (PREDICT_FALSE (!session->is_vep_session))
2189         {
2190           clib_warning ("VCL<%d>: ERROR: sid %u EPOLL_CTL_MOD: "
2191                         "not a vep session!", getpid (), session_handle);
2192           rv = VPPCOM_EINVAL;
2193           goto done;
2194         }
2195       else if (PREDICT_FALSE (session->vep.vep_sh != vep_handle))
2196         {
2197           clib_warning ("VCL<%d>: ERROR: sid %u EPOLL_CTL_MOD: "
2198                         "vep_idx (%u) != vep_idx (%u)!",
2199                         getpid (), session_handle,
2200                         session->vep.vep_sh, vep_handle);
2201           rv = VPPCOM_EINVAL;
2202           goto done;
2203         }
2204       session->vep.et_mask = VEP_DEFAULT_ET_MASK;
2205       session->vep.ev = *event;
2206       VDBG (1, "VCL<%d>: EPOLL_CTL_MOD: vep_idx %u, sid %u, events 0x%x,"
2207             " data 0x%llx!", getpid (), vep_handle, session_handle,
2208             event->events, event->data.u64);
2209       break;
2210
2211     case EPOLL_CTL_DEL:
2212       if (PREDICT_FALSE (!session->is_vep_session))
2213         {
2214           clib_warning ("VCL<%d>: ERROR: sid %u EPOLL_CTL_DEL: "
2215                         "not a vep session!", getpid (), session_handle);
2216           rv = VPPCOM_EINVAL;
2217           goto done;
2218         }
2219       else if (PREDICT_FALSE (session->vep.vep_sh != vep_handle))
2220         {
2221           clib_warning ("VCL<%d>: ERROR: sid %u EPOLL_CTL_DEL: "
2222                         "vep_idx (%u) != vep_idx (%u)!",
2223                         getpid (), session_handle,
2224                         session->vep.vep_sh, vep_handle);
2225           rv = VPPCOM_EINVAL;
2226           goto done;
2227         }
2228
2229       vep_session->wait_cont_idx =
2230         (vep_session->wait_cont_idx == session_handle) ?
2231         session->vep.next_sh : vep_session->wait_cont_idx;
2232
2233       if (session->vep.prev_sh == vep_handle)
2234         vep_session->vep.next_sh = session->vep.next_sh;
2235       else
2236         {
2237           vcl_session_t *prev_session;
2238           prev_session = vcl_session_get_w_handle (wrk, session->vep.prev_sh);
2239           if (PREDICT_FALSE (!prev_session))
2240             {
2241               clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_DEL: Invalid "
2242                             "vep.prev_sid (%u) on sid (%u)!",
2243                             getpid (), session->vep.prev_sh, session_handle);
2244               return VPPCOM_EBADFD;
2245             }
2246           ASSERT (prev_session->vep.next_sh == session_handle);
2247           prev_session->vep.next_sh = session->vep.next_sh;
2248         }
2249       if (session->vep.next_sh != ~0)
2250         {
2251           vcl_session_t *next_session;
2252           next_session = vcl_session_get_w_handle (wrk, session->vep.next_sh);
2253           if (PREDICT_FALSE (!next_session))
2254             {
2255               clib_warning ("VCL<%d>: ERROR: EPOLL_CTL_DEL: Invalid "
2256                             "vep.next_sid (%u) on sid (%u)!",
2257                             getpid (), session->vep.next_sh, session_handle);
2258               return VPPCOM_EBADFD;
2259             }
2260           ASSERT (next_session->vep.prev_sh == session_handle);
2261           next_session->vep.prev_sh = session->vep.prev_sh;
2262         }
2263
2264       memset (&session->vep, 0, sizeof (session->vep));
2265       session->vep.next_sh = ~0;
2266       session->vep.prev_sh = ~0;
2267       session->vep.vep_sh = ~0;
2268       session->is_vep_session = 0;
2269       VDBG (1, "VCL<%d>: EPOLL_CTL_DEL: vep_idx %u, sid %u!",
2270             getpid (), vep_handle, session_handle);
2271       vcl_evt (VCL_EVT_EPOLL_CTLDEL, session, vep_sh);
2272       break;
2273
2274     default:
2275       clib_warning ("VCL<%d>: ERROR: Invalid operation (%d)!", getpid (), op);
2276       rv = VPPCOM_EINVAL;
2277     }
2278
2279   vep_verify_epoll_chain (wrk, vep_handle);
2280
2281 done:
2282   return rv;
2283 }
2284
2285 static inline void
2286 vcl_epoll_wait_handle_mq_event (vcl_worker_t * wrk, session_event_t * e,
2287                                 struct epoll_event *events, u32 * num_ev)
2288 {
2289   session_disconnected_msg_t *disconnected_msg;
2290   session_connected_msg_t *connected_msg;
2291   session_accepted_msg_t *accepted_msg;
2292   u64 session_evt_data = ~0, handle;
2293   u32 sid = ~0, session_events;
2294   vcl_session_msg_t *vcl_msg;
2295   vcl_session_t *session;
2296   u8 add_event = 0;
2297
2298   switch (e->event_type)
2299     {
2300     case FIFO_EVENT_APP_RX:
2301       ASSERT (e->fifo->client_thread_index == vcl_get_worker_index ());
2302       vcl_fifo_rx_evt_valid_or_break (e->fifo);
2303       sid = e->fifo->client_session_index;
2304       session = vcl_session_get (wrk, sid);
2305       session_events = session->vep.ev.events;
2306       if (!(EPOLLIN & session->vep.ev.events))
2307         break;
2308       add_event = 1;
2309       events[*num_ev].events |= EPOLLIN;
2310       session_evt_data = session->vep.ev.data.u64;
2311       break;
2312     case FIFO_EVENT_APP_TX:
2313       sid = e->fifo->client_session_index;
2314       session = vcl_session_get (wrk, sid);
2315       session_events = session->vep.ev.events;
2316       if (!(EPOLLOUT & session_events))
2317         break;
2318       add_event = 1;
2319       events[*num_ev].events |= EPOLLOUT;
2320       session_evt_data = session->vep.ev.data.u64;
2321       break;
2322     case SESSION_IO_EVT_CT_TX:
2323       vcl_fifo_rx_evt_valid_or_break (e->fifo);
2324       session = vcl_ct_session_get_from_fifo (wrk, e->fifo, 0);
2325       sid = session->session_index;
2326       session_events = session->vep.ev.events;
2327       if (!(EPOLLIN & session->vep.ev.events))
2328         break;
2329       add_event = 1;
2330       events[*num_ev].events |= EPOLLIN;
2331       session_evt_data = session->vep.ev.data.u64;
2332       break;
2333     case SESSION_IO_EVT_CT_RX:
2334       session = vcl_ct_session_get_from_fifo (wrk, e->fifo, 1);
2335       sid = session->session_index;
2336       session_events = session->vep.ev.events;
2337       if (!(EPOLLOUT & session_events))
2338         break;
2339       add_event = 1;
2340       events[*num_ev].events |= EPOLLOUT;
2341       session_evt_data = session->vep.ev.data.u64;
2342       break;
2343     case SESSION_CTRL_EVT_ACCEPTED:
2344       accepted_msg = (session_accepted_msg_t *) e->data;
2345       handle = accepted_msg->listener_handle;
2346       session = vcl_session_table_lookup_listener (wrk, handle);
2347       if (!session)
2348         {
2349           clib_warning ("VCL<%d>: ERROR: couldn't find listen session:"
2350                         "listener handle %llx", getpid (), handle);
2351           break;
2352         }
2353
2354       clib_fifo_add2 (session->accept_evts_fifo, vcl_msg);
2355       vcl_msg->accepted_msg = *accepted_msg;
2356       session_events = session->vep.ev.events;
2357       if (!(EPOLLIN & session_events))
2358         break;
2359
2360       add_event = 1;
2361       events[*num_ev].events |= EPOLLIN;
2362       session_evt_data = session->vep.ev.data.u64;
2363       break;
2364     case SESSION_CTRL_EVT_CONNECTED:
2365       connected_msg = (session_connected_msg_t *) e->data;
2366       vcl_session_connected_handler (wrk, connected_msg);
2367       /* Generate EPOLLOUT because there's no connected event */
2368       sid = vcl_session_index_from_vpp_handle (wrk, connected_msg->handle);
2369       session = vcl_session_get (wrk, sid);
2370       session_events = session->vep.ev.events;
2371       if (EPOLLOUT & session_events)
2372         {
2373           add_event = 1;
2374           events[*num_ev].events |= EPOLLOUT;
2375           session_evt_data = session->vep.ev.data.u64;
2376         }
2377       break;
2378     case SESSION_CTRL_EVT_DISCONNECTED:
2379       disconnected_msg = (session_disconnected_msg_t *) e->data;
2380       sid = vcl_session_index_from_vpp_handle (wrk, disconnected_msg->handle);
2381       if (!(session = vcl_session_get (wrk, sid)))
2382         break;
2383       add_event = 1;
2384       events[*num_ev].events |= EPOLLHUP | EPOLLRDHUP;
2385       session_evt_data = session->vep.ev.data.u64;
2386       session_events = session->vep.ev.events;
2387       break;
2388     case SESSION_CTRL_EVT_RESET:
2389       sid = vcl_session_reset_handler (wrk, (session_reset_msg_t *) e->data);
2390       if (!(session = vcl_session_get (wrk, sid)))
2391         break;
2392       add_event = 1;
2393       events[*num_ev].events |= EPOLLHUP | EPOLLRDHUP;
2394       session_evt_data = session->vep.ev.data.u64;
2395       session_events = session->vep.ev.events;
2396       break;
2397     default:
2398       VDBG (0, "unhandled: %u", e->event_type);
2399       break;
2400     }
2401
2402   if (add_event)
2403     {
2404       events[*num_ev].data.u64 = session_evt_data;
2405       if (EPOLLONESHOT & session_events)
2406         {
2407           session = vcl_session_get (wrk, sid);
2408           session->vep.ev.events = 0;
2409         }
2410       *num_ev += 1;
2411     }
2412 }
2413
2414 static int
2415 vcl_epoll_wait_handle_mq (vcl_worker_t * wrk, svm_msg_q_t * mq,
2416                           struct epoll_event *events, u32 maxevents,
2417                           double wait_for_time, u32 * num_ev)
2418 {
2419   svm_msg_q_msg_t *msg;
2420   session_event_t *e;
2421   int i;
2422
2423   if (vec_len (wrk->mq_msg_vector) && svm_msg_q_is_empty (mq))
2424     goto handle_dequeued;
2425
2426   svm_msg_q_lock (mq);
2427   if (svm_msg_q_is_empty (mq))
2428     {
2429       if (!wait_for_time)
2430         {
2431           svm_msg_q_unlock (mq);
2432           return 0;
2433         }
2434       else if (wait_for_time < 0)
2435         {
2436           svm_msg_q_wait (mq);
2437         }
2438       else
2439         {
2440           if (svm_msg_q_timedwait (mq, wait_for_time / 1e3))
2441             {
2442               svm_msg_q_unlock (mq);
2443               return 0;
2444             }
2445         }
2446     }
2447   vcl_mq_dequeue_batch (wrk, mq);
2448   svm_msg_q_unlock (mq);
2449
2450 handle_dequeued:
2451   for (i = 0; i < vec_len (wrk->mq_msg_vector); i++)
2452     {
2453       msg = vec_elt_at_index (wrk->mq_msg_vector, i);
2454       e = svm_msg_q_msg_data (mq, msg);
2455       vcl_epoll_wait_handle_mq_event (wrk, e, events, num_ev);
2456       svm_msg_q_free_msg (mq, msg);
2457       if (*num_ev == maxevents)
2458         {
2459           i += 1;
2460           break;
2461         }
2462     }
2463   vec_delete (wrk->mq_msg_vector, i, 0);
2464
2465   return *num_ev;
2466 }
2467
2468 static int
2469 vppcom_epoll_wait_condvar (vcl_worker_t * wrk, struct epoll_event *events,
2470                            int maxevents, u32 n_evts, double wait_for_time)
2471 {
2472   vcl_cut_through_registration_t *cr;
2473   double total_wait = 0, wait_slice;
2474   int rv;
2475
2476   wait_for_time = (wait_for_time == -1) ? (double) 10e9 : wait_for_time;
2477   wait_slice = wrk->cut_through_registrations ? 10e-6 : wait_for_time;
2478
2479   do
2480     {
2481       vcl_ct_registration_lock (wrk);
2482       /* *INDENT-OFF* */
2483       pool_foreach (cr, wrk->cut_through_registrations, ({
2484         vcl_epoll_wait_handle_mq (wrk, cr->mq, events, maxevents, 0, &n_evts);
2485       }));
2486       /* *INDENT-ON* */
2487       vcl_ct_registration_unlock (wrk);
2488
2489       rv = vcl_epoll_wait_handle_mq (wrk, wrk->app_event_queue, events,
2490                                      maxevents, n_evts ? 0 : wait_slice,
2491                                      &n_evts);
2492       if (rv)
2493         total_wait += wait_slice;
2494       if (n_evts)
2495         return n_evts;
2496     }
2497   while (total_wait < wait_for_time);
2498   return n_evts;
2499 }
2500
2501 static int
2502 vppcom_epoll_wait_eventfd (vcl_worker_t * wrk, struct epoll_event *events,
2503                            int maxevents, u32 n_evts, double wait_for_time)
2504 {
2505   vcl_mq_evt_conn_t *mqc;
2506   int __clib_unused n_read;
2507   int n_mq_evts, i;
2508   u64 buf;
2509
2510   vec_validate (wrk->mq_events, pool_elts (wrk->mq_evt_conns));
2511   n_mq_evts = epoll_wait (wrk->mqs_epfd, wrk->mq_events,
2512                           vec_len (wrk->mq_events), wait_for_time);
2513   for (i = 0; i < n_mq_evts; i++)
2514     {
2515       mqc = vcl_mq_evt_conn_get (wrk, wrk->mq_events[i].data.u32);
2516       n_read = read (mqc->mq_fd, &buf, sizeof (buf));
2517       vcl_epoll_wait_handle_mq (wrk, mqc->mq, events, maxevents, 0, &n_evts);
2518     }
2519
2520   return (int) n_evts;
2521 }
2522
2523 int
2524 vppcom_epoll_wait (uint32_t vep_handle, struct epoll_event *events,
2525                    int maxevents, double wait_for_time)
2526 {
2527   vcl_worker_t *wrk = vcl_worker_get_current ();
2528   vcl_session_t *vep_session;
2529   u32 n_evts = 0;
2530   int i;
2531
2532   if (PREDICT_FALSE (maxevents <= 0))
2533     {
2534       clib_warning ("VCL<%d>: ERROR: Invalid maxevents (%d)!",
2535                     getpid (), maxevents);
2536       return VPPCOM_EINVAL;
2537     }
2538
2539   vep_session = vcl_session_get_w_handle (wrk, vep_handle);
2540   if (!vep_session)
2541     return VPPCOM_EBADFD;
2542
2543   if (PREDICT_FALSE (!vep_session->is_vep))
2544     {
2545       clib_warning ("VCL<%d>: ERROR: vep_idx (%u) is not a vep!",
2546                     getpid (), vep_handle);
2547       return VPPCOM_EINVAL;
2548     }
2549
2550   memset (events, 0, sizeof (*events) * maxevents);
2551
2552   if (vec_len (wrk->unhandled_evts_vector))
2553     {
2554       for (i = 0; i < vec_len (wrk->unhandled_evts_vector); i++)
2555         {
2556           vcl_epoll_wait_handle_mq_event (wrk, &wrk->unhandled_evts_vector[i],
2557                                           events, &n_evts);
2558           if (n_evts == maxevents)
2559             {
2560               i += 1;
2561               break;
2562             }
2563         }
2564
2565       vec_delete (wrk->unhandled_evts_vector, i, 0);
2566     }
2567
2568   if (vcm->cfg.use_mq_eventfd)
2569     return vppcom_epoll_wait_eventfd (wrk, events, maxevents, n_evts,
2570                                       wait_for_time);
2571
2572   return vppcom_epoll_wait_condvar (wrk, events, maxevents, n_evts,
2573                                     wait_for_time);
2574 }
2575
2576 int
2577 vppcom_session_attr (uint32_t session_handle, uint32_t op,
2578                      void *buffer, uint32_t * buflen)
2579 {
2580   vcl_worker_t *wrk = vcl_worker_get_current ();
2581   vcl_session_t *session;
2582   int rv = VPPCOM_OK;
2583   u32 *flags = buffer;
2584   vppcom_endpt_t *ep = buffer;
2585
2586   session = vcl_session_get_w_handle (wrk, session_handle);
2587   if (!session)
2588     return VPPCOM_EBADFD;
2589
2590   switch (op)
2591     {
2592     case VPPCOM_ATTR_GET_NREAD:
2593       rv = vppcom_session_read_ready (session);
2594       VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_NREAD: sid %u, nread = %d",
2595             getpid (), rv);
2596       break;
2597
2598     case VPPCOM_ATTR_GET_NWRITE:
2599       rv = vppcom_session_write_ready (session);
2600       VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_NWRITE: sid %u, nwrite = %d",
2601             getpid (), session_handle, rv);
2602       break;
2603
2604     case VPPCOM_ATTR_GET_FLAGS:
2605       if (PREDICT_TRUE (buffer && buflen && (*buflen >= sizeof (*flags))))
2606         {
2607           *flags = O_RDWR | (VCL_SESS_ATTR_TEST (session->attr,
2608                                                  VCL_SESS_ATTR_NONBLOCK));
2609           *buflen = sizeof (*flags);
2610           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_FLAGS: sid %u, flags = 0x%08x, "
2611                 "is_nonblocking = %u", getpid (),
2612                 session_handle, *flags,
2613                 VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK));
2614         }
2615       else
2616         rv = VPPCOM_EINVAL;
2617       break;
2618
2619     case VPPCOM_ATTR_SET_FLAGS:
2620       if (PREDICT_TRUE (buffer && buflen && (*buflen == sizeof (*flags))))
2621         {
2622           if (*flags & O_NONBLOCK)
2623             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_NONBLOCK);
2624           else
2625             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_NONBLOCK);
2626
2627           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_FLAGS: sid %u, flags = 0x%08x,"
2628                 " is_nonblocking = %u",
2629                 getpid (), session_handle, *flags,
2630                 VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_NONBLOCK));
2631         }
2632       else
2633         rv = VPPCOM_EINVAL;
2634       break;
2635
2636     case VPPCOM_ATTR_GET_PEER_ADDR:
2637       if (PREDICT_TRUE (buffer && buflen &&
2638                         (*buflen >= sizeof (*ep)) && ep->ip))
2639         {
2640           ep->is_ip4 = session->transport.is_ip4;
2641           ep->port = session->transport.rmt_port;
2642           if (session->transport.is_ip4)
2643             clib_memcpy (ep->ip, &session->transport.rmt_ip.ip4,
2644                          sizeof (ip4_address_t));
2645           else
2646             clib_memcpy (ep->ip, &session->transport.rmt_ip.ip6,
2647                          sizeof (ip6_address_t));
2648           *buflen = sizeof (*ep);
2649           VDBG (1, "VCL<%d>: VPPCOM_ATTR_GET_PEER_ADDR: sid %u, is_ip4 = %u, "
2650                 "addr = %U, port %u", getpid (),
2651                 session_handle, ep->is_ip4, format_ip46_address,
2652                 &session->transport.rmt_ip,
2653                 ep->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
2654                 clib_net_to_host_u16 (ep->port));
2655         }
2656       else
2657         rv = VPPCOM_EINVAL;
2658       break;
2659
2660     case VPPCOM_ATTR_GET_LCL_ADDR:
2661       if (PREDICT_TRUE (buffer && buflen &&
2662                         (*buflen >= sizeof (*ep)) && ep->ip))
2663         {
2664           ep->is_ip4 = session->transport.is_ip4;
2665           ep->port = session->transport.lcl_port;
2666           if (session->transport.is_ip4)
2667             clib_memcpy (ep->ip, &session->transport.lcl_ip.ip4,
2668                          sizeof (ip4_address_t));
2669           else
2670             clib_memcpy (ep->ip, &session->transport.lcl_ip.ip6,
2671                          sizeof (ip6_address_t));
2672           *buflen = sizeof (*ep);
2673           VDBG (1, "VCL<%d>: VPPCOM_ATTR_GET_LCL_ADDR: sid %u, is_ip4 = %u,"
2674                 " addr = %U port %d", getpid (),
2675                 session_handle, ep->is_ip4, format_ip46_address,
2676                 &session->transport.lcl_ip,
2677                 ep->is_ip4 ? IP46_TYPE_IP4 : IP46_TYPE_IP6,
2678                 clib_net_to_host_u16 (ep->port));
2679         }
2680       else
2681         rv = VPPCOM_EINVAL;
2682       break;
2683
2684     case VPPCOM_ATTR_GET_LIBC_EPFD:
2685       rv = session->libc_epfd;
2686       VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_LIBC_EPFD: libc_epfd %d",
2687             getpid (), rv);
2688       break;
2689
2690     case VPPCOM_ATTR_SET_LIBC_EPFD:
2691       if (PREDICT_TRUE (buffer && buflen &&
2692                         (*buflen == sizeof (session->libc_epfd))))
2693         {
2694           session->libc_epfd = *(int *) buffer;
2695           *buflen = sizeof (session->libc_epfd);
2696
2697           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_LIBC_EPFD: libc_epfd %d, "
2698                 "buflen %d", getpid (), session->libc_epfd, *buflen);
2699         }
2700       else
2701         rv = VPPCOM_EINVAL;
2702       break;
2703
2704     case VPPCOM_ATTR_GET_PROTOCOL:
2705       if (buffer && buflen && (*buflen >= sizeof (int)))
2706         {
2707           *(int *) buffer = session->session_type;
2708           *buflen = sizeof (int);
2709
2710           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_PROTOCOL: %d (%s), buflen %d",
2711                 getpid (), *(int *) buffer, *(int *) buffer ? "UDP" : "TCP",
2712                 *buflen);
2713         }
2714       else
2715         rv = VPPCOM_EINVAL;
2716       break;
2717
2718     case VPPCOM_ATTR_GET_LISTEN:
2719       if (buffer && buflen && (*buflen >= sizeof (int)))
2720         {
2721           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
2722                                                 VCL_SESS_ATTR_LISTEN);
2723           *buflen = sizeof (int);
2724
2725           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_LISTEN: %d, buflen %d",
2726                 getpid (), *(int *) buffer, *buflen);
2727         }
2728       else
2729         rv = VPPCOM_EINVAL;
2730       break;
2731
2732     case VPPCOM_ATTR_GET_ERROR:
2733       if (buffer && buflen && (*buflen >= sizeof (int)))
2734         {
2735           *(int *) buffer = 0;
2736           *buflen = sizeof (int);
2737
2738           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_ERROR: %d, buflen %d, #VPP-TBD#",
2739                 getpid (), *(int *) buffer, *buflen);
2740         }
2741       else
2742         rv = VPPCOM_EINVAL;
2743       break;
2744
2745     case VPPCOM_ATTR_GET_TX_FIFO_LEN:
2746       if (buffer && buflen && (*buflen >= sizeof (u32)))
2747         {
2748
2749           /* VPP-TBD */
2750           *(size_t *) buffer = (session->sndbuf_size ? session->sndbuf_size :
2751                                 session->tx_fifo ? session->tx_fifo->nitems :
2752                                 vcm->cfg.tx_fifo_size);
2753           *buflen = sizeof (u32);
2754
2755           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TX_FIFO_LEN: %u (0x%x), "
2756                 "buflen %d, #VPP-TBD#", getpid (),
2757                 *(size_t *) buffer, *(size_t *) buffer, *buflen);
2758         }
2759       else
2760         rv = VPPCOM_EINVAL;
2761       break;
2762
2763     case VPPCOM_ATTR_SET_TX_FIFO_LEN:
2764       if (buffer && buflen && (*buflen == sizeof (u32)))
2765         {
2766           /* VPP-TBD */
2767           session->sndbuf_size = *(u32 *) buffer;
2768           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TX_FIFO_LEN: %u (0x%x), "
2769                 "buflen %d, #VPP-TBD#", getpid (),
2770                 session->sndbuf_size, session->sndbuf_size, *buflen);
2771         }
2772       else
2773         rv = VPPCOM_EINVAL;
2774       break;
2775
2776     case VPPCOM_ATTR_GET_RX_FIFO_LEN:
2777       if (buffer && buflen && (*buflen >= sizeof (u32)))
2778         {
2779
2780           /* VPP-TBD */
2781           *(size_t *) buffer = (session->rcvbuf_size ? session->rcvbuf_size :
2782                                 session->rx_fifo ? session->rx_fifo->nitems :
2783                                 vcm->cfg.rx_fifo_size);
2784           *buflen = sizeof (u32);
2785
2786           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_RX_FIFO_LEN: %u (0x%x), "
2787                 "buflen %d, #VPP-TBD#", getpid (),
2788                 *(size_t *) buffer, *(size_t *) buffer, *buflen);
2789         }
2790       else
2791         rv = VPPCOM_EINVAL;
2792       break;
2793
2794     case VPPCOM_ATTR_SET_RX_FIFO_LEN:
2795       if (buffer && buflen && (*buflen == sizeof (u32)))
2796         {
2797           /* VPP-TBD */
2798           session->rcvbuf_size = *(u32 *) buffer;
2799           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_RX_FIFO_LEN: %u (0x%x), "
2800                 "buflen %d, #VPP-TBD#", getpid (),
2801                 session->sndbuf_size, session->sndbuf_size, *buflen);
2802         }
2803       else
2804         rv = VPPCOM_EINVAL;
2805       break;
2806
2807     case VPPCOM_ATTR_GET_REUSEADDR:
2808       if (buffer && buflen && (*buflen >= sizeof (int)))
2809         {
2810           /* VPP-TBD */
2811           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
2812                                                 VCL_SESS_ATTR_REUSEADDR);
2813           *buflen = sizeof (int);
2814
2815           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_REUSEADDR: %d, "
2816                 "buflen %d, #VPP-TBD#", getpid (), *(int *) buffer, *buflen);
2817         }
2818       else
2819         rv = VPPCOM_EINVAL;
2820       break;
2821
2822     case VPPCOM_ATTR_SET_REUSEADDR:
2823       if (buffer && buflen && (*buflen == sizeof (int)) &&
2824           !VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_LISTEN))
2825         {
2826           /* VPP-TBD */
2827           if (*(int *) buffer)
2828             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_REUSEADDR);
2829           else
2830             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_REUSEADDR);
2831
2832           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_REUSEADDR: %d, buflen %d,"
2833                 " #VPP-TBD#", getpid (),
2834                 VCL_SESS_ATTR_TEST (session->attr,
2835                                     VCL_SESS_ATTR_REUSEADDR), *buflen);
2836         }
2837       else
2838         rv = VPPCOM_EINVAL;
2839       break;
2840
2841     case VPPCOM_ATTR_GET_REUSEPORT:
2842       if (buffer && buflen && (*buflen >= sizeof (int)))
2843         {
2844           /* VPP-TBD */
2845           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
2846                                                 VCL_SESS_ATTR_REUSEPORT);
2847           *buflen = sizeof (int);
2848
2849           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_REUSEPORT: %d, buflen %d,"
2850                 " #VPP-TBD#", getpid (), *(int *) buffer, *buflen);
2851         }
2852       else
2853         rv = VPPCOM_EINVAL;
2854       break;
2855
2856     case VPPCOM_ATTR_SET_REUSEPORT:
2857       if (buffer && buflen && (*buflen == sizeof (int)) &&
2858           !VCL_SESS_ATTR_TEST (session->attr, VCL_SESS_ATTR_LISTEN))
2859         {
2860           /* VPP-TBD */
2861           if (*(int *) buffer)
2862             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_REUSEPORT);
2863           else
2864             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_REUSEPORT);
2865
2866           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_REUSEPORT: %d, buflen %d,"
2867                 " #VPP-TBD#", getpid (),
2868                 VCL_SESS_ATTR_TEST (session->attr,
2869                                     VCL_SESS_ATTR_REUSEPORT), *buflen);
2870         }
2871       else
2872         rv = VPPCOM_EINVAL;
2873       break;
2874
2875     case VPPCOM_ATTR_GET_BROADCAST:
2876       if (buffer && buflen && (*buflen >= sizeof (int)))
2877         {
2878           /* VPP-TBD */
2879           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
2880                                                 VCL_SESS_ATTR_BROADCAST);
2881           *buflen = sizeof (int);
2882
2883           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_BROADCAST: %d, buflen %d,"
2884                 " #VPP-TBD#", getpid (), *(int *) buffer, *buflen);
2885         }
2886       else
2887         rv = VPPCOM_EINVAL;
2888       break;
2889
2890     case VPPCOM_ATTR_SET_BROADCAST:
2891       if (buffer && buflen && (*buflen == sizeof (int)))
2892         {
2893           /* VPP-TBD */
2894           if (*(int *) buffer)
2895             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_BROADCAST);
2896           else
2897             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_BROADCAST);
2898
2899           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_BROADCAST: %d, buflen %d, "
2900                 "#VPP-TBD#", getpid (),
2901                 VCL_SESS_ATTR_TEST (session->attr,
2902                                     VCL_SESS_ATTR_BROADCAST), *buflen);
2903         }
2904       else
2905         rv = VPPCOM_EINVAL;
2906       break;
2907
2908     case VPPCOM_ATTR_GET_V6ONLY:
2909       if (buffer && buflen && (*buflen >= sizeof (int)))
2910         {
2911           /* VPP-TBD */
2912           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
2913                                                 VCL_SESS_ATTR_V6ONLY);
2914           *buflen = sizeof (int);
2915
2916           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_V6ONLY: %d, buflen %d, "
2917                 "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
2918         }
2919       else
2920         rv = VPPCOM_EINVAL;
2921       break;
2922
2923     case VPPCOM_ATTR_SET_V6ONLY:
2924       if (buffer && buflen && (*buflen == sizeof (int)))
2925         {
2926           /* VPP-TBD */
2927           if (*(int *) buffer)
2928             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_V6ONLY);
2929           else
2930             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_V6ONLY);
2931
2932           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_V6ONLY: %d, buflen %d, "
2933                 "#VPP-TBD#", getpid (),
2934                 VCL_SESS_ATTR_TEST (session->attr,
2935                                     VCL_SESS_ATTR_V6ONLY), *buflen);
2936         }
2937       else
2938         rv = VPPCOM_EINVAL;
2939       break;
2940
2941     case VPPCOM_ATTR_GET_KEEPALIVE:
2942       if (buffer && buflen && (*buflen >= sizeof (int)))
2943         {
2944           /* VPP-TBD */
2945           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
2946                                                 VCL_SESS_ATTR_KEEPALIVE);
2947           *buflen = sizeof (int);
2948
2949           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_KEEPALIVE: %d, buflen %d, "
2950                 "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
2951         }
2952       else
2953         rv = VPPCOM_EINVAL;
2954       break;
2955
2956     case VPPCOM_ATTR_SET_KEEPALIVE:
2957       if (buffer && buflen && (*buflen == sizeof (int)))
2958         {
2959           /* VPP-TBD */
2960           if (*(int *) buffer)
2961             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_KEEPALIVE);
2962           else
2963             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_KEEPALIVE);
2964
2965           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_KEEPALIVE: %d, buflen %d, "
2966                 "#VPP-TBD#", getpid (),
2967                 VCL_SESS_ATTR_TEST (session->attr,
2968                                     VCL_SESS_ATTR_KEEPALIVE), *buflen);
2969         }
2970       else
2971         rv = VPPCOM_EINVAL;
2972       break;
2973
2974     case VPPCOM_ATTR_GET_TCP_NODELAY:
2975       if (buffer && buflen && (*buflen >= sizeof (int)))
2976         {
2977           /* VPP-TBD */
2978           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
2979                                                 VCL_SESS_ATTR_TCP_NODELAY);
2980           *buflen = sizeof (int);
2981
2982           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TCP_NODELAY: %d, buflen %d, "
2983                 "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
2984         }
2985       else
2986         rv = VPPCOM_EINVAL;
2987       break;
2988
2989     case VPPCOM_ATTR_SET_TCP_NODELAY:
2990       if (buffer && buflen && (*buflen == sizeof (int)))
2991         {
2992           /* VPP-TBD */
2993           if (*(int *) buffer)
2994             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_TCP_NODELAY);
2995           else
2996             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_NODELAY);
2997
2998           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TCP_NODELAY: %d, buflen %d, "
2999                 "#VPP-TBD#", getpid (),
3000                 VCL_SESS_ATTR_TEST (session->attr,
3001                                     VCL_SESS_ATTR_TCP_NODELAY), *buflen);
3002         }
3003       else
3004         rv = VPPCOM_EINVAL;
3005       break;
3006
3007     case VPPCOM_ATTR_GET_TCP_KEEPIDLE:
3008       if (buffer && buflen && (*buflen >= sizeof (int)))
3009         {
3010           /* VPP-TBD */
3011           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
3012                                                 VCL_SESS_ATTR_TCP_KEEPIDLE);
3013           *buflen = sizeof (int);
3014
3015           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TCP_KEEPIDLE: %d, buflen %d, "
3016                 "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
3017         }
3018       else
3019         rv = VPPCOM_EINVAL;
3020       break;
3021
3022     case VPPCOM_ATTR_SET_TCP_KEEPIDLE:
3023       if (buffer && buflen && (*buflen == sizeof (int)))
3024         {
3025           /* VPP-TBD */
3026           if (*(int *) buffer)
3027             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_TCP_KEEPIDLE);
3028           else
3029             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_KEEPIDLE);
3030
3031           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TCP_KEEPIDLE: %d, buflen %d, "
3032                 "#VPP-TBD#", getpid (),
3033                 VCL_SESS_ATTR_TEST (session->attr,
3034                                     VCL_SESS_ATTR_TCP_KEEPIDLE), *buflen);
3035         }
3036       else
3037         rv = VPPCOM_EINVAL;
3038       break;
3039
3040     case VPPCOM_ATTR_GET_TCP_KEEPINTVL:
3041       if (buffer && buflen && (*buflen >= sizeof (int)))
3042         {
3043           /* VPP-TBD */
3044           *(int *) buffer = VCL_SESS_ATTR_TEST (session->attr,
3045                                                 VCL_SESS_ATTR_TCP_KEEPINTVL);
3046           *buflen = sizeof (int);
3047
3048           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TCP_KEEPINTVL: %d, buflen %d, "
3049                 "#VPP-TBD#", getpid (), *(int *) buffer, *buflen);
3050         }
3051       else
3052         rv = VPPCOM_EINVAL;
3053       break;
3054
3055     case VPPCOM_ATTR_SET_TCP_KEEPINTVL:
3056       if (buffer && buflen && (*buflen == sizeof (int)))
3057         {
3058           /* VPP-TBD */
3059           if (*(int *) buffer)
3060             VCL_SESS_ATTR_SET (session->attr, VCL_SESS_ATTR_TCP_KEEPINTVL);
3061           else
3062             VCL_SESS_ATTR_CLR (session->attr, VCL_SESS_ATTR_TCP_KEEPINTVL);
3063
3064           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TCP_KEEPINTVL: %d, buflen %d, "
3065                 "#VPP-TBD#", getpid (),
3066                 VCL_SESS_ATTR_TEST (session->attr,
3067                                     VCL_SESS_ATTR_TCP_KEEPINTVL), *buflen);
3068         }
3069       else
3070         rv = VPPCOM_EINVAL;
3071       break;
3072
3073     case VPPCOM_ATTR_GET_TCP_USER_MSS:
3074       if (buffer && buflen && (*buflen >= sizeof (u32)))
3075         {
3076           /* VPP-TBD */
3077           *(u32 *) buffer = session->user_mss;
3078           *buflen = sizeof (int);
3079
3080           VDBG (2, "VCL<%d>: VPPCOM_ATTR_GET_TCP_USER_MSS: %d, buflen %d,"
3081                 " #VPP-TBD#", getpid (), *(int *) buffer, *buflen);
3082         }
3083       else
3084         rv = VPPCOM_EINVAL;
3085       break;
3086
3087     case VPPCOM_ATTR_SET_TCP_USER_MSS:
3088       if (buffer && buflen && (*buflen == sizeof (u32)))
3089         {
3090           /* VPP-TBD */
3091           session->user_mss = *(u32 *) buffer;
3092
3093           VDBG (2, "VCL<%d>: VPPCOM_ATTR_SET_TCP_USER_MSS: %u, buflen %d, "
3094                 "#VPP-TBD#", getpid (), session->user_mss, *buflen);
3095         }
3096       else
3097         rv = VPPCOM_EINVAL;
3098       break;
3099
3100     default:
3101       rv = VPPCOM_EINVAL;
3102       break;
3103     }
3104
3105   return rv;
3106 }
3107
3108 int
3109 vppcom_session_recvfrom (uint32_t session_handle, void *buffer,
3110                          uint32_t buflen, int flags, vppcom_endpt_t * ep)
3111 {
3112   vcl_worker_t *wrk = vcl_worker_get_current ();
3113   int rv = VPPCOM_OK;
3114   vcl_session_t *session = 0;
3115
3116   if (ep)
3117     {
3118       session = vcl_session_get_w_handle (wrk, session_handle);
3119       if (PREDICT_FALSE (!session))
3120         {
3121           VDBG (0, "VCL<%d>: invalid session, sid (%u) has been closed!",
3122                 getpid (), session_handle);
3123           return VPPCOM_EBADFD;
3124         }
3125       ep->is_ip4 = session->transport.is_ip4;
3126       ep->port = session->transport.rmt_port;
3127     }
3128
3129   if (flags == 0)
3130     rv = vppcom_session_read (session_handle, buffer, buflen);
3131   else if (flags & MSG_PEEK)
3132     rv = vppcom_session_peek (session_handle, buffer, buflen);
3133   else
3134     {
3135       clib_warning ("VCL<%d>: Unsupport flags for recvfrom %d",
3136                     getpid (), flags);
3137       return VPPCOM_EAFNOSUPPORT;
3138     }
3139
3140   if (ep)
3141     {
3142       if (session->transport.is_ip4)
3143         clib_memcpy (ep->ip, &session->transport.rmt_ip.ip4,
3144                      sizeof (ip4_address_t));
3145       else
3146         clib_memcpy (ep->ip, &session->transport.rmt_ip.ip6,
3147                      sizeof (ip6_address_t));
3148     }
3149
3150   return rv;
3151 }
3152
3153 int
3154 vppcom_session_sendto (uint32_t session_handle, void *buffer,
3155                        uint32_t buflen, int flags, vppcom_endpt_t * ep)
3156 {
3157   if (!buffer)
3158     return VPPCOM_EINVAL;
3159
3160   if (ep)
3161     {
3162       // TBD
3163       return VPPCOM_EINVAL;
3164     }
3165
3166   if (flags)
3167     {
3168       // TBD check the flags and do the right thing
3169       VDBG (2, "VCL<%d>: handling flags 0x%u (%d) not implemented yet.",
3170             getpid (), flags, flags);
3171     }
3172
3173   return (vppcom_session_write (session_handle, buffer, buflen));
3174 }
3175
3176 int
3177 vppcom_poll (vcl_poll_t * vp, uint32_t n_sids, double wait_for_time)
3178 {
3179   vcl_worker_t *wrk = vcl_worker_get_current ();
3180   f64 timeout = clib_time_now (&wrk->clib_time) + wait_for_time;
3181   u32 i, keep_trying = 1;
3182   int rv, num_ev = 0;
3183
3184   VDBG (3, "VCL<%d>: vp %p, nsids %u, wait_for_time %f",
3185         getpid (), vp, n_sids, wait_for_time);
3186
3187   if (!vp)
3188     return VPPCOM_EFAULT;
3189
3190   do
3191     {
3192       vcl_session_t *session;
3193
3194       for (i = 0; i < n_sids; i++)
3195         {
3196           ASSERT (vp[i].revents);
3197
3198           session = vcl_session_get (wrk, vp[i].sid);
3199           if (!session)
3200             continue;
3201
3202           if (*vp[i].revents)
3203             *vp[i].revents = 0;
3204
3205           if (POLLIN & vp[i].events)
3206             {
3207               rv = vppcom_session_read_ready (session);
3208               if (rv > 0)
3209                 {
3210                   *vp[i].revents |= POLLIN;
3211                   num_ev++;
3212                 }
3213               else if (rv < 0)
3214                 {
3215                   switch (rv)
3216                     {
3217                     case VPPCOM_ECONNRESET:
3218                       *vp[i].revents = POLLHUP;
3219                       break;
3220
3221                     default:
3222                       *vp[i].revents = POLLERR;
3223                       break;
3224                     }
3225                   num_ev++;
3226                 }
3227             }
3228
3229           if (POLLOUT & vp[i].events)
3230             {
3231               rv = vppcom_session_write_ready (session);
3232               if (rv > 0)
3233                 {
3234                   *vp[i].revents |= POLLOUT;
3235                   num_ev++;
3236                 }
3237               else if (rv < 0)
3238                 {
3239                   switch (rv)
3240                     {
3241                     case VPPCOM_ECONNRESET:
3242                       *vp[i].revents = POLLHUP;
3243                       break;
3244
3245                     default:
3246                       *vp[i].revents = POLLERR;
3247                       break;
3248                     }
3249                   num_ev++;
3250                 }
3251             }
3252
3253           if (0)                // Note "done:" label used by VCL_SESSION_LOCK_AND_GET()
3254             {
3255               *vp[i].revents = POLLNVAL;
3256               num_ev++;
3257             }
3258         }
3259       if (wait_for_time != -1)
3260         keep_trying = (clib_time_now (&wrk->clib_time) <= timeout) ? 1 : 0;
3261     }
3262   while ((num_ev == 0) && keep_trying);
3263
3264   if (VPPCOM_DEBUG > 3)
3265     {
3266       clib_warning ("VCL<%d>: returning %d", getpid (), num_ev);
3267       for (i = 0; i < n_sids; i++)
3268         {
3269           clib_warning ("VCL<%d>: vp[%d].sid %d (0x%x), .events 0x%x, "
3270                         ".revents 0x%x", getpid (), i, vp[i].sid, vp[i].sid,
3271                         vp[i].events, *vp[i].revents);
3272         }
3273     }
3274   return num_ev;
3275 }
3276
3277 int
3278 vppcom_mq_epoll_fd (void)
3279 {
3280   vcl_worker_t *wrk = vcl_worker_get_current ();
3281   return wrk->mqs_epfd;
3282 }
3283
3284 int
3285 vppcom_session_index (uint32_t session_handle)
3286 {
3287   return session_handle & 0xFFFFFF;
3288 }
3289
3290 int
3291 vppcom_worker_register (void)
3292 {
3293   if (vcl_worker_alloc_and_init ())
3294     return VPPCOM_OK;
3295   return VPPCOM_EEXIST;
3296 }
3297
3298 /*
3299  * fd.io coding-style-patch-verification: ON
3300  *
3301  * Local Variables:
3302  * eval: (c-set-style "gnu")
3303  * End:
3304  */