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