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