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