src/vcl/vppcom.c

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