src/vnet/session/application_worker.c

   1 /*
   2  * Copyright (c) 2019 Cisco and/or its affiliates.
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   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 <vnet/session/application.h>
  17 #include <vnet/session/application_interface.h>
  18 #include <vnet/session/session.h>
  19
  20 /**
  21  * Pool of workers associated to apps
  22  */
  23 static app_worker_t *app_workers;
  24
  25 app_worker_t *
  26 app_worker_alloc (application_t * app)
  27 {
  28   app_worker_t *app_wrk;
  29   pool_get (app_workers, app_wrk);
  30   clib_memset (app_wrk, 0, sizeof (*app_wrk));
  31   app_wrk->wrk_index = app_wrk - app_workers;
  32   app_wrk->app_index = app->app_index;
  33   app_wrk->wrk_map_index = ~0;
  34   app_wrk->connects_seg_manager = APP_INVALID_SEGMENT_MANAGER_INDEX;
  35   clib_spinlock_init (&app_wrk->detached_seg_managers_lock);
  36   APP_DBG ("New app %v worker %u", app->name, app_wrk->wrk_index);
  37   return app_wrk;
  38 }
  39
  40 app_worker_t *
  41 app_worker_get (u32 wrk_index)
  42 {
  43   return pool_elt_at_index (app_workers, wrk_index);
  44 }
  45
  46 app_worker_t *
  47 app_worker_get_if_valid (u32 wrk_index)
  48 {
  49   if (pool_is_free_index (app_workers, wrk_index))
  50     return 0;
  51   return pool_elt_at_index (app_workers, wrk_index);
  52 }
  53
  54 void
  55 app_worker_free (app_worker_t * app_wrk)
  56 {
  57   application_t *app = application_get (app_wrk->app_index);
  58   vnet_unlisten_args_t _a, *a = &_a;
  59   u64 handle, *handles = 0, *sm_indices = 0;
  60   segment_manager_t *sm;
  61   session_handle_t *sh;
  62   session_t *ls;
  63   u32 sm_index;
  64   int i;
  65
  66   /*
  67    *  Listener cleanup
  68    */
  69
  70   /* *INDENT-OFF* */
  71   hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
  72     ls = listen_session_get_from_handle (handle);
  73     vec_add1 (handles, app_listen_session_handle (ls));
  74     vec_add1 (sm_indices, sm_index);
  75     sm = segment_manager_get (sm_index);
  76   }));
  77   /* *INDENT-ON* */
  78
  79   for (i = 0; i < vec_len (handles); i++)
  80     {
  81       /* Cleanup listener */
  82       a->app_index = app->app_index;
  83       a->wrk_map_index = app_wrk->wrk_map_index;
  84       a->handle = handles[i];
  85       (void) vnet_unlisten (a);
  86
  87       sm = segment_manager_get_if_valid (sm_indices[i]);
  88       if (sm && !segment_manager_app_detached (sm))
  89         {
  90           sm->first_is_protected = 0;
  91           segment_manager_init_free (sm);
  92         }
  93     }
  94   vec_reset_length (handles);
  95   vec_free (sm_indices);
  96   hash_free (app_wrk->listeners_table);
  97
  98   /*
  99    * Connects segment manager cleanup
 100    */
 101
 102   if (app_wrk->connects_seg_manager != APP_INVALID_SEGMENT_MANAGER_INDEX)
 103     {
 104       sm = segment_manager_get (app_wrk->connects_seg_manager);
 105       sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
 106       sm->first_is_protected = 0;
 107       segment_manager_init_free (sm);
 108     }
 109
 110   /*
 111    * Half-open cleanup
 112    */
 113
 114   pool_foreach (sh, app_wrk->half_open_table)
 115     session_cleanup_half_open (*sh);
 116
 117   pool_free (app_wrk->half_open_table);
 118
 119   /*
 120    * Detached listener segment managers cleanup
 121    */
 122   for (i = 0; i < vec_len (app_wrk->detached_seg_managers); i++)
 123     {
 124       sm = segment_manager_get (app_wrk->detached_seg_managers[i]);
 125       segment_manager_init_free (sm);
 126     }
 127   vec_free (app_wrk->detached_seg_managers);
 128   clib_spinlock_free (&app_wrk->detached_seg_managers_lock);
 129
 130   if (CLIB_DEBUG)
 131     clib_memset (app_wrk, 0xfe, sizeof (*app_wrk));
 132   pool_put (app_workers, app_wrk);
 133 }
 134
 135 application_t *
 136 app_worker_get_app (u32 wrk_index)
 137 {
 138   app_worker_t *app_wrk;
 139   app_wrk = app_worker_get_if_valid (wrk_index);
 140   if (!app_wrk)
 141     return 0;
 142   return application_get_if_valid (app_wrk->app_index);
 143 }
 144
 145 static segment_manager_t *
 146 app_worker_alloc_segment_manager (app_worker_t * app_wrk)
 147 {
 148   segment_manager_t *sm;
 149
 150   sm = segment_manager_alloc ();
 151   sm->app_wrk_index = app_wrk->wrk_index;
 152   segment_manager_init (sm);
 153   return sm;
 154 }
 155
 156 static int
 157 app_worker_alloc_session_fifos (segment_manager_t * sm, session_t * s)
 158 {
 159   svm_fifo_t *rx_fifo = 0, *tx_fifo = 0;
 160   int rv;
 161
 162   if ((rv = segment_manager_alloc_session_fifos (sm, s->thread_index,
 163                                                  &rx_fifo, &tx_fifo)))
 164     return rv;
 165
 166   rx_fifo->shr->master_session_index = s->session_index;
 167   rx_fifo->master_thread_index = s->thread_index;
 168
 169   tx_fifo->shr->master_session_index = s->session_index;
 170   tx_fifo->master_thread_index = s->thread_index;
 171
 172   s->rx_fifo = rx_fifo;
 173   s->tx_fifo = tx_fifo;
 174   return 0;
 175 }
 176
 177 int
 178 app_worker_init_listener (app_worker_t * app_wrk, session_t * ls)
 179 {
 180   segment_manager_t *sm;
 181
 182   /* Allocate segment manager. All sessions derived out of a listen session
 183    * have fifos allocated by the same segment manager. */
 184   if (!(sm = app_worker_alloc_segment_manager (app_wrk)))
 185     return SESSION_E_ALLOC;
 186
 187   /* Keep track of the segment manager for the listener or this worker */
 188   hash_set (app_wrk->listeners_table, listen_session_get_handle (ls),
 189             segment_manager_index (sm));
 190
 191   if (transport_connection_is_cless (session_get_transport (ls)))
 192     {
 193       if (ls->rx_fifo)
 194         return SESSION_E_NOSUPPORT;
 195       return app_worker_alloc_session_fifos (sm, ls);
 196     }
 197   return 0;
 198 }
 199
 200 int
 201 app_worker_start_listen (app_worker_t * app_wrk,
 202                          app_listener_t * app_listener)
 203 {
 204   session_t *ls;
 205   int rv;
 206
 207   if (clib_bitmap_get (app_listener->workers, app_wrk->wrk_map_index))
 208     return SESSION_E_ALREADY_LISTENING;
 209
 210   app_listener->workers = clib_bitmap_set (app_listener->workers,
 211                                            app_wrk->wrk_map_index, 1);
 212
 213   if (app_listener->session_index != SESSION_INVALID_INDEX)
 214     {
 215       ls = session_get (app_listener->session_index, 0);
 216       if ((rv = app_worker_init_listener (app_wrk, ls)))
 217         return rv;
 218     }
 219
 220   if (app_listener->local_index != SESSION_INVALID_INDEX)
 221     {
 222       ls = session_get (app_listener->local_index, 0);
 223       if ((rv = app_worker_init_listener (app_wrk, ls)))
 224         return rv;
 225     }
 226
 227   return 0;
 228 }
 229
 230 static void
 231 app_worker_add_detached_sm (app_worker_t * app_wrk, u32 sm_index)
 232 {
 233   vec_add1 (app_wrk->detached_seg_managers, sm_index);
 234 }
 235
 236 void
 237 app_worker_del_detached_sm (app_worker_t * app_wrk, u32 sm_index)
 238 {
 239   u32 i;
 240
 241   clib_spinlock_lock (&app_wrk->detached_seg_managers_lock);
 242   for (i = 0; i < vec_len (app_wrk->detached_seg_managers); i++)
 243     {
 244       if (app_wrk->detached_seg_managers[i] == sm_index)
 245         {
 246           vec_del1 (app_wrk->detached_seg_managers, i);
 247           break;
 248         }
 249     }
 250   clib_spinlock_unlock (&app_wrk->detached_seg_managers_lock);
 251 }
 252
 253 static void
 254 app_worker_stop_listen_session (app_worker_t * app_wrk, session_t * ls)
 255 {
 256   session_handle_t handle;
 257   segment_manager_t *sm;
 258   uword *sm_indexp;
 259   session_state_t *states = 0;
 260
 261   handle = listen_session_get_handle (ls);
 262   sm_indexp = hash_get (app_wrk->listeners_table, handle);
 263   if (PREDICT_FALSE (!sm_indexp))
 264     return;
 265
 266   /* Dealloc fifos, if any (dgram listeners) */
 267   if (ls->rx_fifo)
 268     {
 269       segment_manager_dealloc_fifos (ls->rx_fifo, ls->tx_fifo);
 270       ls->tx_fifo = ls->rx_fifo = 0;
 271     }
 272
 273   /* Try to cleanup segment manager */
 274   sm = segment_manager_get (*sm_indexp);
 275   if (sm)
 276     {
 277       segment_manager_app_detach (sm);
 278       if (!segment_manager_has_fifos (sm))
 279         {
 280           /* Empty segment manager, cleanup it up */
 281           segment_manager_free (sm);
 282         }
 283       else
 284         {
 285           /* Delete sessions in CREATED state */
 286           vec_add1 (states, SESSION_STATE_CREATED);
 287           segment_manager_del_sessions_filter (sm, states);
 288           vec_free (states);
 289
 290           /* Track segment manager in case app detaches and all the
 291            * outstanding sessions need to be closed */
 292           app_worker_add_detached_sm (app_wrk, *sm_indexp);
 293           sm->flags |= SEG_MANAGER_F_DETACHED_LISTENER;
 294         }
 295     }
 296
 297   hash_unset (app_wrk->listeners_table, handle);
 298 }
 299
 300 int
 301 app_worker_stop_listen (app_worker_t * app_wrk, app_listener_t * al)
 302 {
 303   session_t *ls;
 304
 305   if (!clib_bitmap_get (al->workers, app_wrk->wrk_map_index))
 306     return 0;
 307
 308   if (al->session_index != SESSION_INVALID_INDEX)
 309     {
 310       ls = listen_session_get (al->session_index);
 311       app_worker_stop_listen_session (app_wrk, ls);
 312     }
 313
 314   if (al->local_index != SESSION_INVALID_INDEX)
 315     {
 316       ls = listen_session_get (al->local_index);
 317       app_worker_stop_listen_session (app_wrk, ls);
 318     }
 319
 320   clib_bitmap_set_no_check (al->workers, app_wrk->wrk_map_index, 0);
 321   if (clib_bitmap_is_zero (al->workers))
 322     app_listener_cleanup (al);
 323
 324   return 0;
 325 }
 326
 327 int
 328 app_worker_init_accepted (session_t * s)
 329 {
 330   app_worker_t *app_wrk;
 331   segment_manager_t *sm;
 332   session_t *listener;
 333   application_t *app;
 334
 335   listener = listen_session_get_from_handle (s->listener_handle);
 336   app_wrk = application_listener_select_worker (listener);
 337   s->app_wrk_index = app_wrk->wrk_index;
 338
 339   app = application_get (app_wrk->app_index);
 340   if (app->cb_fns.fifo_tuning_callback)
 341     s->flags |= SESSION_F_CUSTOM_FIFO_TUNING;
 342
 343   sm = app_worker_get_listen_segment_manager (app_wrk, listener);
 344   if (app_worker_alloc_session_fifos (sm, s))
 345     return -1;
 346
 347   return 0;
 348 }
 349
 350 int
 351 app_worker_accept_notify (app_worker_t * app_wrk, session_t * s)
 352 {
 353   application_t *app = application_get (app_wrk->app_index);
 354   return app->cb_fns.session_accept_callback (s);
 355 }
 356
 357 int
 358 app_worker_init_connected (app_worker_t * app_wrk, session_t * s)
 359 {
 360   application_t *app = application_get (app_wrk->app_index);
 361   segment_manager_t *sm;
 362
 363   if (app->cb_fns.fifo_tuning_callback)
 364     s->flags |= SESSION_F_CUSTOM_FIFO_TUNING;
 365
 366   /* Allocate fifos for session, unless the app is a builtin proxy */
 367   if (application_is_builtin_proxy (app))
 368     return 0;
 369
 370   sm = app_worker_get_connect_segment_manager (app_wrk);
 371   return app_worker_alloc_session_fifos (sm, s);
 372 }
 373
 374 int
 375 app_worker_connect_notify (app_worker_t * app_wrk, session_t * s,
 376                            session_error_t err, u32 opaque)
 377 {
 378   application_t *app = application_get (app_wrk->app_index);
 379   return app->cb_fns.session_connected_callback (app_wrk->wrk_index, opaque,
 380                                                  s, err);
 381 }
 382
 383 int
 384 app_worker_add_half_open (app_worker_t *app_wrk, session_handle_t sh)
 385 {
 386   session_handle_t *shp;
 387
 388   ASSERT (vlib_get_thread_index () == 0);
 389   pool_get (app_wrk->half_open_table, shp);
 390   *shp = sh;
 391
 392   return (shp - app_wrk->half_open_table);
 393 }
 394
 395 int
 396 app_worker_del_half_open (app_worker_t *app_wrk, u32 ho_index)
 397 {
 398   ASSERT (vlib_get_thread_index () == 0);
 399   pool_put_index (app_wrk->half_open_table, ho_index);
 400   return 0;
 401 }
 402
 403 int
 404 app_worker_close_notify (app_worker_t * app_wrk, session_t * s)
 405 {
 406   application_t *app = application_get (app_wrk->app_index);
 407   app->cb_fns.session_disconnect_callback (s);
 408   return 0;
 409 }
 410
 411 int
 412 app_worker_transport_closed_notify (app_worker_t * app_wrk, session_t * s)
 413 {
 414   application_t *app = application_get (app_wrk->app_index);
 415   if (app->cb_fns.session_transport_closed_callback)
 416     app->cb_fns.session_transport_closed_callback (s);
 417   return 0;
 418 }
 419
 420 int
 421 app_worker_reset_notify (app_worker_t * app_wrk, session_t * s)
 422 {
 423   application_t *app = application_get (app_wrk->app_index);
 424   app->cb_fns.session_reset_callback (s);
 425   return 0;
 426 }
 427
 428 int
 429 app_worker_cleanup_notify (app_worker_t * app_wrk, session_t * s,
 430                            session_cleanup_ntf_t ntf)
 431 {
 432   application_t *app = application_get (app_wrk->app_index);
 433   if (app->cb_fns.session_cleanup_callback)
 434     app->cb_fns.session_cleanup_callback (s, ntf);
 435   return 0;
 436 }
 437
 438 int
 439 app_worker_builtin_rx (app_worker_t * app_wrk, session_t * s)
 440 {
 441   application_t *app = application_get (app_wrk->app_index);
 442   app->cb_fns.builtin_app_rx_callback (s);
 443   return 0;
 444 }
 445
 446 int
 447 app_worker_builtin_tx (app_worker_t * app_wrk, session_t * s)
 448 {
 449   application_t *app = application_get (app_wrk->app_index);
 450
 451   if (!app->cb_fns.builtin_app_tx_callback)
 452     return 0;
 453
 454   app->cb_fns.builtin_app_tx_callback (s);
 455   return 0;
 456 }
 457
 458 int
 459 app_worker_migrate_notify (app_worker_t * app_wrk, session_t * s,
 460                            session_handle_t new_sh)
 461 {
 462   application_t *app = application_get (app_wrk->app_index);
 463   app->cb_fns.session_migrate_callback (s, new_sh);
 464   return 0;
 465 }
 466
 467 int
 468 app_worker_own_session (app_worker_t * app_wrk, session_t * s)
 469 {
 470   segment_manager_t *sm;
 471   svm_fifo_t *rxf, *txf;
 472
 473   if (s->session_state == SESSION_STATE_LISTENING)
 474     return application_change_listener_owner (s, app_wrk);
 475
 476   s->app_wrk_index = app_wrk->wrk_index;
 477
 478   rxf = s->rx_fifo;
 479   txf = s->tx_fifo;
 480
 481   if (!rxf || !txf)
 482     return 0;
 483
 484   s->rx_fifo = 0;
 485   s->tx_fifo = 0;
 486
 487   sm = app_worker_get_connect_segment_manager (app_wrk);
 488   if (app_worker_alloc_session_fifos (sm, s))
 489     return -1;
 490
 491   if (!svm_fifo_is_empty_cons (rxf))
 492     svm_fifo_clone (s->rx_fifo, rxf);
 493
 494   if (!svm_fifo_is_empty_cons (txf))
 495     svm_fifo_clone (s->tx_fifo, txf);
 496
 497   segment_manager_dealloc_fifos (rxf, txf);
 498
 499   return 0;
 500 }
 501
 502 int
 503 app_worker_connect_session (app_worker_t * app_wrk, session_endpoint_t * sep,
 504                             u32 api_context)
 505 {
 506   int rv;
 507
 508   if ((rv = session_open (app_wrk->wrk_index, sep, api_context)))
 509     return rv;
 510
 511   return 0;
 512 }
 513
 514 int
 515 app_worker_session_fifo_tuning (app_worker_t * app_wrk, session_t * s,
 516                                 svm_fifo_t * f,
 517                                 session_ft_action_t act, u32 len)
 518 {
 519   application_t *app = application_get (app_wrk->app_index);
 520   return app->cb_fns.fifo_tuning_callback (s, f, act, len);
 521 }
 522
 523 segment_manager_t *
 524 app_worker_get_connect_segment_manager (app_worker_t * app)
 525 {
 526   ASSERT (app->connects_seg_manager != (u32) ~ 0);
 527   return segment_manager_get (app->connects_seg_manager);
 528 }
 529
 530 segment_manager_t *
 531 app_worker_get_listen_segment_manager (app_worker_t * app,
 532                                        session_t * listener)
 533 {
 534   uword *smp;
 535   smp = hash_get (app->listeners_table, listen_session_get_handle (listener));
 536   ALWAYS_ASSERT (smp != 0);
 537   return segment_manager_get (*smp);
 538 }
 539
 540 session_t *
 541 app_worker_first_listener (app_worker_t * app_wrk, u8 fib_proto,
 542                            u8 transport_proto)
 543 {
 544   session_t *listener;
 545   u64 handle;
 546   u32 sm_index;
 547   u8 sst;
 548
 549   sst = session_type_from_proto_and_ip (transport_proto,
 550                                         fib_proto == FIB_PROTOCOL_IP4);
 551
 552   /* *INDENT-OFF* */
 553    hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
 554      listener = listen_session_get_from_handle (handle);
 555      if (listener->session_type == sst
 556          && !(listener->flags & SESSION_F_PROXY))
 557        return listener;
 558    }));
 559   /* *INDENT-ON* */
 560
 561   return 0;
 562 }
 563
 564 session_t *
 565 app_worker_proxy_listener (app_worker_t * app_wrk, u8 fib_proto,
 566                            u8 transport_proto)
 567 {
 568   session_t *listener;
 569   u64 handle;
 570   u32 sm_index;
 571   u8 sst;
 572
 573   sst = session_type_from_proto_and_ip (transport_proto,
 574                                         fib_proto == FIB_PROTOCOL_IP4);
 575
 576   /* *INDENT-OFF* */
 577    hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
 578      listener = listen_session_get_from_handle (handle);
 579      if (listener->session_type == sst && (listener->flags & SESSION_F_PROXY))
 580        return listener;
 581    }));
 582   /* *INDENT-ON* */
 583
 584   return 0;
 585 }
 586
 587 /**
 588  * Send an API message to the external app, to map new segment
 589  */
 590 int
 591 app_worker_add_segment_notify (app_worker_t * app_wrk, u64 segment_handle)
 592 {
 593   application_t *app = application_get (app_wrk->app_index);
 594
 595   return app->cb_fns.add_segment_callback (app_wrk->wrk_index,
 596                                            segment_handle);
 597 }
 598
 599 int
 600 app_worker_del_segment_notify (app_worker_t * app_wrk, u64 segment_handle)
 601 {
 602   application_t *app = application_get (app_wrk->app_index);
 603   return app->cb_fns.del_segment_callback (app_wrk->wrk_index,
 604                                            segment_handle);
 605 }
 606
 607 static inline u8
 608 app_worker_application_is_builtin (app_worker_t * app_wrk)
 609 {
 610   return app_wrk->app_is_builtin;
 611 }
 612
 613 static inline int
 614 app_send_io_evt_rx (app_worker_t * app_wrk, session_t * s)
 615 {
 616   session_event_t *evt;
 617   svm_msg_q_msg_t msg;
 618   svm_msg_q_t *mq;
 619
 620   if (app_worker_application_is_builtin (app_wrk))
 621     return app_worker_builtin_rx (app_wrk, s);
 622
 623   if (svm_fifo_has_event (s->rx_fifo))
 624     return 0;
 625
 626   mq = app_wrk->event_queue;
 627   svm_msg_q_lock (mq);
 628
 629   if (PREDICT_FALSE (svm_msg_q_is_full (mq)))
 630     {
 631       clib_warning ("evt q full");
 632       svm_msg_q_unlock (mq);
 633       return -1;
 634     }
 635
 636   if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
 637     {
 638       clib_warning ("evt q rings full");
 639       svm_msg_q_unlock (mq);
 640       return -1;
 641     }
 642
 643   msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
 644   evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
 645   evt->session_index = s->rx_fifo->shr->client_session_index;
 646   evt->event_type = SESSION_IO_EVT_RX;
 647
 648   (void) svm_fifo_set_event (s->rx_fifo);
 649   svm_msg_q_add_and_unlock (mq, &msg);
 650
 651   return 0;
 652 }
 653
 654 static inline int
 655 app_send_io_evt_tx (app_worker_t * app_wrk, session_t * s)
 656 {
 657   svm_msg_q_t *mq;
 658   session_event_t *evt;
 659   svm_msg_q_msg_t msg;
 660
 661   if (app_worker_application_is_builtin (app_wrk))
 662     return app_worker_builtin_tx (app_wrk, s);
 663
 664   mq = app_wrk->event_queue;
 665   svm_msg_q_lock (mq);
 666
 667   if (PREDICT_FALSE (svm_msg_q_is_full (mq)))
 668     {
 669       clib_warning ("evt q full");
 670       svm_msg_q_unlock (mq);
 671       return -1;
 672     }
 673
 674   if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
 675     {
 676       clib_warning ("evt q rings full");
 677       svm_msg_q_unlock (mq);
 678       return -1;
 679     }
 680
 681   msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
 682   evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
 683   evt->event_type = SESSION_IO_EVT_TX;
 684   evt->session_index = s->tx_fifo->shr->client_session_index;
 685
 686   svm_msg_q_add_and_unlock (mq, &msg);
 687   return 0;
 688 }
 689
 690 /* *INDENT-OFF* */
 691 typedef int (app_send_evt_handler_fn) (app_worker_t *app,
 692                                        session_t *s);
 693 static app_send_evt_handler_fn * const app_send_evt_handler_fns[2] = {
 694     app_send_io_evt_rx,
 695     app_send_io_evt_tx,
 696 };
 697 /* *INDENT-ON* */
 698
 699 /**
 700  * Send event to application
 701  *
 702  * Logic from queue perspective is blocking. However, if queue is full,
 703  * we return.
 704  */
 705 int
 706 app_worker_lock_and_send_event (app_worker_t * app, session_t * s,
 707                                 u8 evt_type)
 708 {
 709   return app_send_evt_handler_fns[evt_type] (app, s);
 710 }
 711
 712 u8 *
 713 format_app_worker_listener (u8 * s, va_list * args)
 714 {
 715   app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
 716   u64 handle = va_arg (*args, u64);
 717   u32 sm_index = va_arg (*args, u32);
 718   int verbose = va_arg (*args, int);
 719   session_t *listener;
 720   const u8 *app_name;
 721   u8 *str;
 722
 723   if (!app_wrk)
 724     {
 725       if (verbose)
 726         s = format (s, "%-40s%-25s%-10s%-15s%-15s%-10s", "Connection", "App",
 727                     "Wrk", "API Client", "ListenerID", "SegManager");
 728       else
 729         s = format (s, "%-40s%-25s%-10s", "Connection", "App", "Wrk");
 730
 731       return s;
 732     }
 733
 734   app_name = application_name_from_index (app_wrk->app_index);
 735   listener = listen_session_get_from_handle (handle);
 736   str = format (0, "%U", format_session, listener, verbose);
 737
 738   if (verbose)
 739     {
 740       u8 *buf;
 741       buf = format (0, "%u(%u)", app_wrk->wrk_map_index, app_wrk->wrk_index);
 742       s = format (s, "%-40v%-25v%-10v%-15u%-15u%-10u", str, app_name,
 743                   buf, app_wrk->api_client_index, handle, sm_index);
 744       vec_free (buf);
 745     }
 746   else
 747     s = format (s, "%-40v%-25v%=10u", str, app_name, app_wrk->wrk_map_index);
 748
 749   vec_free (str);
 750
 751   return s;
 752 }
 753
 754 u8 *
 755 format_app_worker (u8 * s, va_list * args)
 756 {
 757   app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
 758   u32 indent = 1;
 759
 760   s = format (s, "%U wrk-index %u app-index %u map-index %u "
 761               "api-client-index %d\n", format_white_space, indent,
 762               app_wrk->wrk_index, app_wrk->app_index, app_wrk->wrk_map_index,
 763               app_wrk->api_client_index);
 764   return s;
 765 }
 766
 767 void
 768 app_worker_format_connects (app_worker_t * app_wrk, int verbose)
 769 {
 770   segment_manager_t *sm;
 771
 772   /* Header */
 773   if (!app_wrk)
 774     {
 775       segment_manager_format_sessions (0, verbose);
 776       return;
 777     }
 778
 779   if (app_wrk->connects_seg_manager == (u32) ~ 0)
 780     return;
 781
 782   sm = segment_manager_get (app_wrk->connects_seg_manager);
 783   segment_manager_format_sessions (sm, verbose);
 784 }
 785
 786 /*
 787  * fd.io coding-style-patch-verification: ON
 788  *
 789  * Local Variables:
 790  * eval: (c-set-style "gnu")
 791  * End:
 792  */