src/vcl/vppcom.c

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