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   /* Once the first segment is mapped, don't remove it until unlisten */
 188   sm->first_is_protected = 1;
 189
 190   /* Keep track of the segment manager for the listener or this worker */
 191   hash_set (app_wrk->listeners_table, listen_session_get_handle (ls),
 192             segment_manager_index (sm));
 193
 194   if (transport_connection_is_cless (session_get_transport (ls)))
 195     {
 196       if (ls->rx_fifo)
 197         return SESSION_E_NOSUPPORT;
 198       return app_worker_alloc_session_fifos (sm, ls);
 199     }
 200   return 0;
 201 }
 202
 203 int
 204 app_worker_start_listen (app_worker_t * app_wrk,
 205                          app_listener_t * app_listener)
 206 {
 207   session_t *ls;
 208   int rv;
 209
 210   if (clib_bitmap_get (app_listener->workers, app_wrk->wrk_map_index))
 211     return SESSION_E_ALREADY_LISTENING;
 212
 213   app_listener->workers = clib_bitmap_set (app_listener->workers,
 214                                            app_wrk->wrk_map_index, 1);
 215
 216   if (app_listener->session_index != SESSION_INVALID_INDEX)
 217     {
 218       ls = session_get (app_listener->session_index, 0);
 219       if ((rv = app_worker_init_listener (app_wrk, ls)))
 220         return rv;
 221     }
 222
 223   if (app_listener->local_index != SESSION_INVALID_INDEX)
 224     {
 225       ls = session_get (app_listener->local_index, 0);
 226       if ((rv = app_worker_init_listener (app_wrk, ls)))
 227         return rv;
 228     }
 229
 230   return 0;
 231 }
 232
 233 static void
 234 app_worker_add_detached_sm (app_worker_t * app_wrk, u32 sm_index)
 235 {
 236   vec_add1 (app_wrk->detached_seg_managers, sm_index);
 237 }
 238
 239 void
 240 app_worker_del_detached_sm (app_worker_t * app_wrk, u32 sm_index)
 241 {
 242   u32 i;
 243
 244   clib_spinlock_lock (&app_wrk->detached_seg_managers_lock);
 245   for (i = 0; i < vec_len (app_wrk->detached_seg_managers); i++)
 246     {
 247       if (app_wrk->detached_seg_managers[i] == sm_index)
 248         {
 249           vec_del1 (app_wrk->detached_seg_managers, i);
 250           break;
 251         }
 252     }
 253   clib_spinlock_unlock (&app_wrk->detached_seg_managers_lock);
 254 }
 255
 256 static void
 257 app_worker_stop_listen_session (app_worker_t * app_wrk, session_t * ls)
 258 {
 259   session_handle_t handle;
 260   segment_manager_t *sm;
 261   uword *sm_indexp;
 262   session_state_t *states = 0;
 263
 264   handle = listen_session_get_handle (ls);
 265   sm_indexp = hash_get (app_wrk->listeners_table, handle);
 266   if (PREDICT_FALSE (!sm_indexp))
 267     return;
 268
 269   /* Dealloc fifos, if any (dgram listeners) */
 270   if (ls->rx_fifo)
 271     {
 272       segment_manager_dealloc_fifos (ls->rx_fifo, ls->tx_fifo);
 273       ls->tx_fifo = ls->rx_fifo = 0;
 274     }
 275
 276   /* Try to cleanup segment manager */
 277   sm = segment_manager_get (*sm_indexp);
 278   if (sm)
 279     {
 280       sm->first_is_protected = 0;
 281       segment_manager_app_detach (sm);
 282       if (!segment_manager_has_fifos (sm))
 283         {
 284           /* Empty segment manager, cleanup it up */
 285           segment_manager_free (sm);
 286         }
 287       else
 288         {
 289           /* Delete sessions in CREATED state */
 290           vec_add1 (states, SESSION_STATE_CREATED);
 291           segment_manager_del_sessions_filter (sm, states);
 292           vec_free (states);
 293
 294           /* Track segment manager in case app detaches and all the
 295            * outstanding sessions need to be closed */
 296           app_worker_add_detached_sm (app_wrk, *sm_indexp);
 297           sm->flags |= SEG_MANAGER_F_DETACHED_LISTENER;
 298         }
 299     }
 300
 301   hash_unset (app_wrk->listeners_table, handle);
 302 }
 303
 304 int
 305 app_worker_stop_listen (app_worker_t * app_wrk, app_listener_t * al)
 306 {
 307   session_t *ls;
 308
 309   if (!clib_bitmap_get (al->workers, app_wrk->wrk_map_index))
 310     return 0;
 311
 312   if (al->session_index != SESSION_INVALID_INDEX)
 313     {
 314       ls = listen_session_get (al->session_index);
 315       app_worker_stop_listen_session (app_wrk, ls);
 316     }
 317
 318   if (al->local_index != SESSION_INVALID_INDEX)
 319     {
 320       ls = listen_session_get (al->local_index);
 321       app_worker_stop_listen_session (app_wrk, ls);
 322     }
 323
 324   clib_bitmap_set_no_check (al->workers, app_wrk->wrk_map_index, 0);
 325   if (clib_bitmap_is_zero (al->workers))
 326     app_listener_cleanup (al);
 327
 328   return 0;
 329 }
 330
 331 int
 332 app_worker_init_accepted (session_t * s)
 333 {
 334   app_worker_t *app_wrk;
 335   segment_manager_t *sm;
 336   session_t *listener;
 337   application_t *app;
 338
 339   listener = listen_session_get_from_handle (s->listener_handle);
 340   app_wrk = application_listener_select_worker (listener);
 341   s->app_wrk_index = app_wrk->wrk_index;
 342
 343   app = application_get (app_wrk->app_index);
 344   if (app->cb_fns.fifo_tuning_callback)
 345     s->flags |= SESSION_F_CUSTOM_FIFO_TUNING;
 346
 347   sm = app_worker_get_listen_segment_manager (app_wrk, listener);
 348   if (app_worker_alloc_session_fifos (sm, s))
 349     return -1;
 350
 351   return 0;
 352 }
 353
 354 int
 355 app_worker_accept_notify (app_worker_t * app_wrk, session_t * s)
 356 {
 357   application_t *app = application_get (app_wrk->app_index);
 358   return app->cb_fns.session_accept_callback (s);
 359 }
 360
 361 int
 362 app_worker_init_connected (app_worker_t * app_wrk, session_t * s)
 363 {
 364   application_t *app = application_get (app_wrk->app_index);
 365   segment_manager_t *sm;
 366
 367   if (app->cb_fns.fifo_tuning_callback)
 368     s->flags |= SESSION_F_CUSTOM_FIFO_TUNING;
 369
 370   /* Allocate fifos for session, unless the app is a builtin proxy */
 371   if (application_is_builtin_proxy (app))
 372     return 0;
 373
 374   sm = app_worker_get_connect_segment_manager (app_wrk);
 375   return app_worker_alloc_session_fifos (sm, s);
 376 }
 377
 378 int
 379 app_worker_connect_notify (app_worker_t * app_wrk, session_t * s,
 380                            session_error_t err, u32 opaque)
 381 {
 382   application_t *app = application_get (app_wrk->app_index);
 383   return app->cb_fns.session_connected_callback (app_wrk->wrk_index, opaque,
 384                                                  s, err);
 385 }
 386
 387 int
 388 app_worker_add_half_open (app_worker_t *app_wrk, session_handle_t sh)
 389 {
 390   session_handle_t *shp;
 391
 392   ASSERT (vlib_get_thread_index () == 0);
 393   pool_get (app_wrk->half_open_table, shp);
 394   *shp = sh;
 395
 396   return (shp - app_wrk->half_open_table);
 397 }
 398
 399 int
 400 app_worker_del_half_open (app_worker_t *app_wrk, session_t *s)
 401 {
 402   application_t *app = application_get (app_wrk->app_index);
 403   ASSERT (vlib_get_thread_index () <= 1);
 404   pool_put_index (app_wrk->half_open_table, s->ho_index);
 405   if (app->cb_fns.half_open_cleanup_callback)
 406     app->cb_fns.half_open_cleanup_callback (s);
 407   return 0;
 408 }
 409
 410 int
 411 app_worker_close_notify (app_worker_t * app_wrk, session_t * s)
 412 {
 413   application_t *app = application_get (app_wrk->app_index);
 414   app->cb_fns.session_disconnect_callback (s);
 415   return 0;
 416 }
 417
 418 int
 419 app_worker_transport_closed_notify (app_worker_t * app_wrk, session_t * s)
 420 {
 421   application_t *app = application_get (app_wrk->app_index);
 422   if (app->cb_fns.session_transport_closed_callback)
 423     app->cb_fns.session_transport_closed_callback (s);
 424   return 0;
 425 }
 426
 427 int
 428 app_worker_reset_notify (app_worker_t * app_wrk, session_t * s)
 429 {
 430   application_t *app = application_get (app_wrk->app_index);
 431   app->cb_fns.session_reset_callback (s);
 432   return 0;
 433 }
 434
 435 int
 436 app_worker_cleanup_notify (app_worker_t * app_wrk, session_t * s,
 437                            session_cleanup_ntf_t ntf)
 438 {
 439   application_t *app = application_get (app_wrk->app_index);
 440   if (app->cb_fns.session_cleanup_callback)
 441     app->cb_fns.session_cleanup_callback (s, ntf);
 442   return 0;
 443 }
 444
 445 int
 446 app_worker_builtin_rx (app_worker_t * app_wrk, session_t * s)
 447 {
 448   application_t *app = application_get (app_wrk->app_index);
 449   app->cb_fns.builtin_app_rx_callback (s);
 450   return 0;
 451 }
 452
 453 int
 454 app_worker_builtin_tx (app_worker_t * app_wrk, session_t * s)
 455 {
 456   application_t *app = application_get (app_wrk->app_index);
 457
 458   if (!app->cb_fns.builtin_app_tx_callback)
 459     return 0;
 460
 461   app->cb_fns.builtin_app_tx_callback (s);
 462   return 0;
 463 }
 464
 465 int
 466 app_worker_migrate_notify (app_worker_t * app_wrk, session_t * s,
 467                            session_handle_t new_sh)
 468 {
 469   application_t *app = application_get (app_wrk->app_index);
 470   app->cb_fns.session_migrate_callback (s, new_sh);
 471   return 0;
 472 }
 473
 474 int
 475 app_worker_own_session (app_worker_t * app_wrk, session_t * s)
 476 {
 477   segment_manager_t *sm;
 478   svm_fifo_t *rxf, *txf;
 479
 480   if (s->session_state == SESSION_STATE_LISTENING)
 481     return application_change_listener_owner (s, app_wrk);
 482
 483   s->app_wrk_index = app_wrk->wrk_index;
 484
 485   rxf = s->rx_fifo;
 486   txf = s->tx_fifo;
 487
 488   if (!rxf || !txf)
 489     return 0;
 490
 491   s->rx_fifo = 0;
 492   s->tx_fifo = 0;
 493
 494   sm = app_worker_get_connect_segment_manager (app_wrk);
 495   if (app_worker_alloc_session_fifos (sm, s))
 496     return -1;
 497
 498   if (!svm_fifo_is_empty_cons (rxf))
 499     svm_fifo_clone (s->rx_fifo, rxf);
 500
 501   if (!svm_fifo_is_empty_cons (txf))
 502     svm_fifo_clone (s->tx_fifo, txf);
 503
 504   segment_manager_dealloc_fifos (rxf, txf);
 505
 506   return 0;
 507 }
 508
 509 int
 510 app_worker_connect_session (app_worker_t *app_wrk, session_endpoint_cfg_t *sep,
 511                             session_handle_t *rsh)
 512 {
 513   sep->app_wrk_index = app_wrk->wrk_index;
 514
 515   return session_open (sep, rsh);
 516 }
 517
 518 int
 519 app_worker_session_fifo_tuning (app_worker_t * app_wrk, session_t * s,
 520                                 svm_fifo_t * f,
 521                                 session_ft_action_t act, u32 len)
 522 {
 523   application_t *app = application_get (app_wrk->app_index);
 524   return app->cb_fns.fifo_tuning_callback (s, f, act, len);
 525 }
 526
 527 segment_manager_t *
 528 app_worker_get_connect_segment_manager (app_worker_t * app)
 529 {
 530   ASSERT (app->connects_seg_manager != (u32) ~ 0);
 531   return segment_manager_get (app->connects_seg_manager);
 532 }
 533
 534 segment_manager_t *
 535 app_worker_get_listen_segment_manager (app_worker_t * app,
 536                                        session_t * listener)
 537 {
 538   uword *smp;
 539   smp = hash_get (app->listeners_table, listen_session_get_handle (listener));
 540   ALWAYS_ASSERT (smp != 0);
 541   return segment_manager_get (*smp);
 542 }
 543
 544 session_t *
 545 app_worker_first_listener (app_worker_t * app_wrk, u8 fib_proto,
 546                            u8 transport_proto)
 547 {
 548   session_t *listener;
 549   u64 handle;
 550   u32 sm_index;
 551   u8 sst;
 552
 553   sst = session_type_from_proto_and_ip (transport_proto,
 554                                         fib_proto == FIB_PROTOCOL_IP4);
 555
 556   /* *INDENT-OFF* */
 557    hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
 558      listener = listen_session_get_from_handle (handle);
 559      if (listener->session_type == sst
 560          && !(listener->flags & SESSION_F_PROXY))
 561        return listener;
 562    }));
 563   /* *INDENT-ON* */
 564
 565   return 0;
 566 }
 567
 568 session_t *
 569 app_worker_proxy_listener (app_worker_t * app_wrk, u8 fib_proto,
 570                            u8 transport_proto)
 571 {
 572   session_t *listener;
 573   u64 handle;
 574   u32 sm_index;
 575   u8 sst;
 576
 577   sst = session_type_from_proto_and_ip (transport_proto,
 578                                         fib_proto == FIB_PROTOCOL_IP4);
 579
 580   /* *INDENT-OFF* */
 581    hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
 582      listener = listen_session_get_from_handle (handle);
 583      if (listener->session_type == sst && (listener->flags & SESSION_F_PROXY))
 584        return listener;
 585    }));
 586   /* *INDENT-ON* */
 587
 588   return 0;
 589 }
 590
 591 /**
 592  * Send an API message to the external app, to map new segment
 593  */
 594 int
 595 app_worker_add_segment_notify (app_worker_t * app_wrk, u64 segment_handle)
 596 {
 597   application_t *app = application_get (app_wrk->app_index);
 598
 599   return app->cb_fns.add_segment_callback (app_wrk->wrk_index,
 600                                            segment_handle);
 601 }
 602
 603 int
 604 app_worker_del_segment_notify (app_worker_t * app_wrk, u64 segment_handle)
 605 {
 606   application_t *app = application_get (app_wrk->app_index);
 607   return app->cb_fns.del_segment_callback (app_wrk->wrk_index,
 608                                            segment_handle);
 609 }
 610
 611 static inline u8
 612 app_worker_application_is_builtin (app_worker_t * app_wrk)
 613 {
 614   return app_wrk->app_is_builtin;
 615 }
 616
 617 static inline int
 618 app_send_io_evt_rx (app_worker_t * app_wrk, session_t * s)
 619 {
 620   session_event_t *evt;
 621   svm_msg_q_msg_t msg;
 622   svm_msg_q_t *mq;
 623
 624   if (app_worker_application_is_builtin (app_wrk))
 625     return app_worker_builtin_rx (app_wrk, s);
 626
 627   if (svm_fifo_has_event (s->rx_fifo))
 628     return 0;
 629
 630   mq = app_wrk->event_queue;
 631   svm_msg_q_lock (mq);
 632
 633   if (PREDICT_FALSE (svm_msg_q_is_full (mq)))
 634     {
 635       clib_warning ("evt q full");
 636       svm_msg_q_unlock (mq);
 637       return -1;
 638     }
 639
 640   if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
 641     {
 642       clib_warning ("evt q rings full");
 643       svm_msg_q_unlock (mq);
 644       return -1;
 645     }
 646
 647   msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
 648   evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
 649   evt->session_index = s->rx_fifo->shr->client_session_index;
 650   evt->event_type = SESSION_IO_EVT_RX;
 651
 652   (void) svm_fifo_set_event (s->rx_fifo);
 653   svm_msg_q_add_and_unlock (mq, &msg);
 654
 655   return 0;
 656 }
 657
 658 static inline int
 659 app_send_io_evt_tx (app_worker_t * app_wrk, session_t * s)
 660 {
 661   svm_msg_q_t *mq;
 662   session_event_t *evt;
 663   svm_msg_q_msg_t msg;
 664
 665   if (app_worker_application_is_builtin (app_wrk))
 666     return app_worker_builtin_tx (app_wrk, s);
 667
 668   mq = app_wrk->event_queue;
 669   svm_msg_q_lock (mq);
 670
 671   if (PREDICT_FALSE (svm_msg_q_is_full (mq)))
 672     {
 673       clib_warning ("evt q full");
 674       svm_msg_q_unlock (mq);
 675       return -1;
 676     }
 677
 678   if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
 679     {
 680       clib_warning ("evt q rings full");
 681       svm_msg_q_unlock (mq);
 682       return -1;
 683     }
 684
 685   msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
 686   evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
 687   evt->event_type = SESSION_IO_EVT_TX;
 688   evt->session_index = s->tx_fifo->shr->client_session_index;
 689
 690   svm_msg_q_add_and_unlock (mq, &msg);
 691   return 0;
 692 }
 693
 694 /* *INDENT-OFF* */
 695 typedef int (app_send_evt_handler_fn) (app_worker_t *app,
 696                                        session_t *s);
 697 static app_send_evt_handler_fn * const app_send_evt_handler_fns[2] = {
 698     app_send_io_evt_rx,
 699     app_send_io_evt_tx,
 700 };
 701 /* *INDENT-ON* */
 702
 703 /**
 704  * Send event to application
 705  *
 706  * Logic from queue perspective is blocking. However, if queue is full,
 707  * we return.
 708  */
 709 int
 710 app_worker_lock_and_send_event (app_worker_t * app, session_t * s,
 711                                 u8 evt_type)
 712 {
 713   return app_send_evt_handler_fns[evt_type] (app, s);
 714 }
 715
 716 u8 *
 717 format_app_worker_listener (u8 * s, va_list * args)
 718 {
 719   app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
 720   u64 handle = va_arg (*args, u64);
 721   u32 sm_index = va_arg (*args, u32);
 722   int verbose = va_arg (*args, int);
 723   session_t *listener;
 724   const u8 *app_name;
 725   u8 *str;
 726
 727   if (!app_wrk)
 728     {
 729       if (verbose)
 730         s = format (s, "%-" SESSION_CLI_ID_LEN "s%-25s%-10s%-15s%-15s%-10s",
 731                     "Connection", "App", "Wrk", "API Client", "ListenerID",
 732                     "SegManager");
 733       else
 734         s = format (s, "%-" SESSION_CLI_ID_LEN "s%-25s%-10s", "Connection",
 735                     "App", "Wrk");
 736
 737       return s;
 738     }
 739
 740   app_name = application_name_from_index (app_wrk->app_index);
 741   listener = listen_session_get_from_handle (handle);
 742   str = format (0, "%U", format_session, listener, verbose);
 743
 744   if (verbose)
 745     {
 746       u8 *buf;
 747       buf = format (0, "%u(%u)", app_wrk->wrk_map_index, app_wrk->wrk_index);
 748       s = format (s, "%-" SESSION_CLI_ID_LEN "v%-25v%-10v%-15u%-15u%-10u", str,
 749                   app_name, buf, app_wrk->api_client_index, handle, sm_index);
 750       vec_free (buf);
 751     }
 752   else
 753     s = format (s, "%-" SESSION_CLI_ID_LEN "v%-25v%=10u", str, app_name,
 754                 app_wrk->wrk_map_index);
 755
 756   vec_free (str);
 757
 758   return s;
 759 }
 760
 761 u8 *
 762 format_app_worker (u8 * s, va_list * args)
 763 {
 764   app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
 765   u32 indent = 1;
 766
 767   s = format (s, "%U wrk-index %u app-index %u map-index %u "
 768               "api-client-index %d\n", format_white_space, indent,
 769               app_wrk->wrk_index, app_wrk->app_index, app_wrk->wrk_map_index,
 770               app_wrk->api_client_index);
 771   return s;
 772 }
 773
 774 void
 775 app_worker_format_connects (app_worker_t * app_wrk, int verbose)
 776 {
 777   segment_manager_t *sm;
 778
 779   /* Header */
 780   if (!app_wrk)
 781     {
 782       segment_manager_format_sessions (0, verbose);
 783       return;
 784     }
 785
 786   if (app_wrk->connects_seg_manager == (u32) ~ 0)
 787     return;
 788
 789   sm = segment_manager_get (app_wrk->connects_seg_manager);
 790   segment_manager_format_sessions (sm, verbose);
 791 }
 792
 793 /*
 794  * fd.io coding-style-patch-verification: ON
 795  *
 796  * Local Variables:
 797  * eval: (c-set-style "gnu")
 798  * End:
 799  */