src/vcl/vppcom.c

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