src/vnet/session/application.c

   1 /*
   2  * Copyright (c) 2017 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 from which we allocate all applications
  22  */
  23 static application_t *app_pool;
  24
  25 /**
  26  * Hash table of apps by api client index
  27  */
  28 static uword *app_by_api_client_index;
  29
  30 /**
  31  * Default application event queue size
  32  */
  33 static u32 default_app_evt_queue_size = 128;
  34
  35 int
  36 application_api_queue_is_full (application_t * app)
  37 {
  38   unix_shared_memory_queue_t *q;
  39
  40   /* builtin servers are always OK */
  41   if (app->api_client_index == ~0)
  42     return 0;
  43
  44   q = vl_api_client_index_to_input_queue (app->api_client_index);
  45   if (!q)
  46     return 1;
  47
  48   if (q->cursize == q->maxsize)
  49     return 1;
  50   return 0;
  51 }
  52
  53 static void
  54 application_table_add (application_t * app)
  55 {
  56   hash_set (app_by_api_client_index, app->api_client_index, app->index);
  57 }
  58
  59 static void
  60 application_table_del (application_t * app)
  61 {
  62   hash_unset (app_by_api_client_index, app->api_client_index);
  63 }
  64
  65 application_t *
  66 application_lookup (u32 api_client_index)
  67 {
  68   uword *p;
  69   p = hash_get (app_by_api_client_index, api_client_index);
  70   if (p)
  71     return application_get (p[0]);
  72
  73   return 0;
  74 }
  75
  76 application_t *
  77 application_new ()
  78 {
  79   application_t *app;
  80   pool_get (app_pool, app);
  81   memset (app, 0, sizeof (*app));
  82   app->index = application_get_index (app);
  83   app->connects_seg_manager = ~0;
  84   app->first_segment_manager = ~0;
  85   if (CLIB_DEBUG > 1)
  86     clib_warning ("[%d] New app (%d)", getpid (), app->index);
  87   return app;
  88 }
  89
  90 void
  91 application_del (application_t * app)
  92 {
  93   segment_manager_t *sm;
  94   u64 handle;
  95   u32 index, *handles = 0;
  96   int i;
  97   vnet_unbind_args_t _a, *a = &_a;
  98
  99   /*
 100    * The app event queue allocated in first segment is cleared with
 101    * the segment manager. No need to explicitly free it.
 102    */
 103   if (CLIB_DEBUG > 1)
 104     clib_warning ("[%d] Delete app (%d)", getpid (), app->index);
 105
 106   /*
 107    * Cleanup segment managers
 108    */
 109   if (app->connects_seg_manager != (u32) ~ 0)
 110     {
 111       sm = segment_manager_get (app->connects_seg_manager);
 112       segment_manager_del (sm);
 113     }
 114
 115   /* *INDENT-OFF* */
 116   hash_foreach (handle, index, app->listeners_table,
 117   ({
 118     vec_add1 (handles, handle);
 119   }));
 120   /* *INDENT-ON* */
 121
 122   /* Actual listener cleanup */
 123   for (i = 0; i < vec_len (handles); i++)
 124     {
 125       a->app_index = app->index;
 126       a->handle = handles[i];
 127       /* seg manager is removed when unbind completes */
 128       vnet_unbind (a);
 129     }
 130
 131   if (app->first_segment_manager != ~0)
 132     {
 133       sm = segment_manager_get (app->first_segment_manager);
 134       segment_manager_first_segment_maybe_del (sm);
 135     }
 136
 137   application_table_del (app);
 138   pool_put (app_pool, app);
 139 }
 140
 141 static void
 142 application_verify_cb_fns (session_cb_vft_t * cb_fns)
 143 {
 144   if (cb_fns->session_accept_callback == 0)
 145     clib_warning ("No accept callback function provided");
 146   if (cb_fns->session_connected_callback == 0)
 147     clib_warning ("No session connected callback function provided");
 148   if (cb_fns->session_disconnect_callback == 0)
 149     clib_warning ("No session disconnect callback function provided");
 150   if (cb_fns->session_reset_callback == 0)
 151     clib_warning ("No session reset callback function provided");
 152 }
 153
 154 int
 155 application_init (application_t * app, u32 api_client_index, u64 * options,
 156                   session_cb_vft_t * cb_fns)
 157 {
 158   segment_manager_t *sm;
 159   segment_manager_properties_t *props;
 160   u32 app_evt_queue_size, first_seg_size;
 161   int rv;
 162
 163   app_evt_queue_size = options[APP_EVT_QUEUE_SIZE] > 0 ?
 164     options[APP_EVT_QUEUE_SIZE] : default_app_evt_queue_size;
 165
 166   /* Setup segment manager */
 167   sm = segment_manager_new ();
 168   sm->app_index = app->index;
 169   props = &app->sm_properties;
 170   props->add_segment_size = options[SESSION_OPTIONS_ADD_SEGMENT_SIZE];
 171   props->rx_fifo_size = options[SESSION_OPTIONS_RX_FIFO_SIZE];
 172   props->tx_fifo_size = options[SESSION_OPTIONS_TX_FIFO_SIZE];
 173   props->add_segment = props->add_segment_size != 0;
 174   props->preallocated_fifo_pairs = options[APP_OPTIONS_PREALLOC_FIFO_PAIRS];
 175   props->use_private_segment = options[APP_OPTIONS_FLAGS]
 176     & APP_OPTIONS_FLAGS_BUILTIN_APP;
 177   props->private_segment_count = options[APP_OPTIONS_PRIVATE_SEGMENT_COUNT];
 178   props->private_segment_size = options[APP_OPTIONS_PRIVATE_SEGMENT_SIZE];
 179
 180   first_seg_size = options[SESSION_OPTIONS_SEGMENT_SIZE];
 181   if ((rv = segment_manager_init (sm, props, first_seg_size)))
 182     return rv;
 183
 184   app->first_segment_manager = segment_manager_index (sm);
 185   app->api_client_index = api_client_index;
 186   app->flags = options[APP_OPTIONS_FLAGS];
 187   app->cb_fns = *cb_fns;
 188
 189   /* Allocate app event queue in the first shared-memory segment */
 190   app->event_queue = segment_manager_alloc_queue (sm, app_evt_queue_size);
 191
 192   /* Check that the obvious things are properly set up */
 193   application_verify_cb_fns (cb_fns);
 194
 195   /* Add app to lookup by api_client_index table */
 196   application_table_add (app);
 197
 198   return 0;
 199 }
 200
 201 application_t *
 202 application_get (u32 index)
 203 {
 204   return pool_elt_at_index (app_pool, index);
 205 }
 206
 207 application_t *
 208 application_get_if_valid (u32 index)
 209 {
 210   if (pool_is_free_index (app_pool, index))
 211     return 0;
 212
 213   return pool_elt_at_index (app_pool, index);
 214 }
 215
 216 u32
 217 application_get_index (application_t * app)
 218 {
 219   return app - app_pool;
 220 }
 221
 222 static segment_manager_t *
 223 application_alloc_segment_manager (application_t * app)
 224 {
 225   segment_manager_t *sm = 0;
 226
 227   if (app->first_segment_manager != (u32) ~ 0)
 228     {
 229       sm = segment_manager_get (app->first_segment_manager);
 230       return sm;
 231     }
 232
 233   sm = segment_manager_new ();
 234   if (segment_manager_init (sm, &app->sm_properties, 0))
 235     return 0;
 236   return sm;
 237 }
 238
 239 /**
 240  * Start listening local transport endpoint for requested transport.
 241  *
 242  * Creates a 'dummy' stream session with state LISTENING to be used in session
 243  * lookups, prior to establishing connection. Requests transport to build
 244  * it's own specific listening connection.
 245  */
 246 int
 247 application_start_listen (application_t * srv, session_type_t session_type,
 248                           transport_endpoint_t * tep, u64 * res)
 249 {
 250   segment_manager_t *sm;
 251   stream_session_t *s;
 252   u64 handle;
 253
 254   s = listen_session_new (session_type);
 255   s->app_index = srv->index;
 256
 257   if (stream_session_listen (s, tep))
 258     goto err;
 259
 260   /* Allocate segment manager. All sessions derived out of a listen session
 261    * have fifos allocated by the same segment manager. */
 262   sm = application_alloc_segment_manager (srv);
 263   if (sm == 0)
 264     goto err;
 265
 266   /* Add to app's listener table. Useful to find all child listeners
 267    * when app goes down, although, just for unbinding this is not needed */
 268   handle = listen_session_get_handle (s);
 269   hash_set (srv->listeners_table, handle, segment_manager_index (sm));
 270
 271   *res = handle;
 272   return 0;
 273
 274 err:
 275   listen_session_del (s);
 276   return -1;
 277 }
 278
 279 /**
 280  * Stop listening on session associated to handle
 281  */
 282 int
 283 application_stop_listen (application_t * srv, u64 handle)
 284 {
 285   stream_session_t *listener;
 286   uword *indexp;
 287   segment_manager_t *sm;
 288
 289   if (srv && hash_get (srv->listeners_table, handle) == 0)
 290     {
 291       clib_warning ("app doesn't own handle %llu!", handle);
 292       return -1;
 293     }
 294
 295   listener = listen_session_get_from_handle (handle);
 296   stream_session_stop_listen (listener);
 297
 298   indexp = hash_get (srv->listeners_table, handle);
 299   ASSERT (indexp);
 300
 301   sm = segment_manager_get (*indexp);
 302   segment_manager_del (sm);
 303   srv->first_segment_manager = ~0;
 304   hash_unset (srv->listeners_table, handle);
 305   listen_session_del (listener);
 306
 307   return 0;
 308 }
 309
 310 int
 311 application_open_session (application_t * app, session_type_t sst,
 312                           transport_endpoint_t * tep, u32 api_context)
 313 {
 314   segment_manager_t *sm;
 315   transport_connection_t *tc = 0;
 316   int rv;
 317
 318   /* Make sure we have a segment manager for connects */
 319   if (app->connects_seg_manager == (u32) ~ 0)
 320     {
 321       sm = application_alloc_segment_manager (app);
 322       if (sm == 0)
 323         return -1;
 324       app->connects_seg_manager = segment_manager_index (sm);
 325     }
 326
 327   if ((rv = stream_session_open (app->index, sst, tep, &tc)))
 328     return rv;
 329
 330   /* Store api_context for when the reply comes. Not the nicest thing
 331    * but better allocating a separate half-open pool.  */
 332   tc->s_index = api_context;
 333
 334   return 0;
 335 }
 336
 337 segment_manager_t *
 338 application_get_connect_segment_manager (application_t * app)
 339 {
 340   ASSERT (app->connects_seg_manager != (u32) ~ 0);
 341   return segment_manager_get (app->connects_seg_manager);
 342 }
 343
 344 segment_manager_t *
 345 application_get_listen_segment_manager (application_t * app,
 346                                         stream_session_t * s)
 347 {
 348   uword *smp;
 349   smp = hash_get (app->listeners_table, listen_session_get_handle (s));
 350   ASSERT (smp != 0);
 351   return segment_manager_get (*smp);
 352 }
 353
 354 static u8 *
 355 app_get_name_from_reg_index (application_t * app)
 356 {
 357   u8 *app_name;
 358
 359   vl_api_registration_t *regp;
 360   regp = vl_api_client_index_to_registration (app->api_client_index);
 361   if (!regp)
 362     app_name = format (0, "builtin-%d%c", app->index, 0);
 363   else
 364     app_name = format (0, "%s%c", regp->name, 0);
 365
 366   return app_name;
 367 }
 368
 369 u8 *
 370 format_application_listener (u8 * s, va_list * args)
 371 {
 372   application_t *app = va_arg (*args, application_t *);
 373   u64 handle = va_arg (*args, u64);
 374   u32 index = va_arg (*args, u32);
 375   int verbose = va_arg (*args, int);
 376   stream_session_t *listener;
 377   u8 *app_name, *str;
 378
 379   if (app == 0)
 380     {
 381       if (verbose)
 382         s = format (s, "%-40s%-20s%-15s%-15s%-10s", "Connection", "App",
 383                     "API Client", "ListenerID", "SegManager");
 384       else
 385         s = format (s, "%-40s%-20s", "Connection", "App");
 386
 387       return s;
 388     }
 389
 390   app_name = app_get_name_from_reg_index (app);
 391   listener = listen_session_get_from_handle (handle);
 392   str = format (0, "%U", format_stream_session, listener, verbose);
 393
 394   if (verbose)
 395     {
 396       s = format (s, "%-40s%-20s%-15u%-15u%-10u", str, app_name,
 397                   app->api_client_index, handle, index);
 398     }
 399   else
 400     s = format (s, "%-40s%-20s", str, app_name);
 401
 402   vec_free (app_name);
 403   return s;
 404 }
 405
 406 void
 407 application_format_connects (application_t * app, int verbose)
 408 {
 409   vlib_main_t *vm = vlib_get_main ();
 410   segment_manager_t *sm;
 411   u8 *app_name, *s = 0;
 412   int j;
 413
 414   /* Header */
 415   if (app == 0)
 416     {
 417       if (verbose)
 418         vlib_cli_output (vm, "%-40s%-20s%-15s%-10s", "Connection", "App",
 419                          "API Client", "SegManager");
 420       else
 421         vlib_cli_output (vm, "%-40s%-20s", "Connection", "App");
 422       return;
 423     }
 424
 425   /* make sure */
 426   if (app->connects_seg_manager == (u32) ~ 0)
 427     return;
 428
 429   app_name = app_get_name_from_reg_index (app);
 430
 431   /* Across all fifo segments */
 432   sm = segment_manager_get (app->connects_seg_manager);
 433   for (j = 0; j < vec_len (sm->segment_indices); j++)
 434     {
 435       svm_fifo_segment_private_t *fifo_segment;
 436       svm_fifo_t *fifo;
 437       u8 *str;
 438
 439       fifo_segment = svm_fifo_get_segment (sm->segment_indices[j]);
 440       fifo = svm_fifo_segment_get_fifo_list (fifo_segment);
 441       while (fifo)
 442         {
 443           u32 session_index, thread_index;
 444           stream_session_t *session;
 445
 446           session_index = fifo->master_session_index;
 447           thread_index = fifo->master_thread_index;
 448
 449           session = stream_session_get (session_index, thread_index);
 450           str = format (0, "%U", format_stream_session, session, verbose);
 451
 452           if (verbose)
 453             s = format (s, "%-40s%-20s%-15u%-10u", str, app_name,
 454                         app->api_client_index, app->connects_seg_manager);
 455           else
 456             s = format (s, "%-40s%-20s", str, app_name);
 457
 458           vlib_cli_output (vm, "%v", s);
 459           vec_reset_length (s);
 460           vec_free (str);
 461
 462           fifo = fifo->next;
 463         }
 464       vec_free (s);
 465     }
 466
 467   vec_free (app_name);
 468 }
 469
 470 u8 *
 471 format_application (u8 * s, va_list * args)
 472 {
 473   application_t *app = va_arg (*args, application_t *);
 474   CLIB_UNUSED (int verbose) = va_arg (*args, int);
 475   u8 *app_name;
 476
 477   if (app == 0)
 478     {
 479       if (verbose)
 480         s = format (s, "%-10s%-20s%-15s%-15s%-15s%-15s", "Index", "Name",
 481                     "API Client", "Add seg size", "Rx fifo size",
 482                     "Tx fifo size");
 483       else
 484         s = format (s, "%-10s%-20s%-20s", "Index", "Name", "API Client");
 485       return s;
 486     }
 487
 488   app_name = app_get_name_from_reg_index (app);
 489   if (verbose)
 490     s = format (s, "%-10d%-20s%-15d%-15d%-15d%-15d", app->index, app_name,
 491                 app->api_client_index, app->sm_properties.add_segment_size,
 492                 app->sm_properties.rx_fifo_size,
 493                 app->sm_properties.tx_fifo_size);
 494   else
 495     s = format (s, "%-10d%-20s%-20d", app->index, app_name,
 496                 app->api_client_index);
 497   return s;
 498 }
 499
 500 static clib_error_t *
 501 show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
 502                      vlib_cli_command_t * cmd)
 503 {
 504   application_t *app;
 505   int do_server = 0;
 506   int do_client = 0;
 507   int verbose = 0;
 508
 509   if (!session_manager_is_enabled ())
 510     {
 511       clib_error_return (0, "session layer is not enabled");
 512     }
 513
 514   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 515     {
 516       if (unformat (input, "server"))
 517         do_server = 1;
 518       else if (unformat (input, "client"))
 519         do_client = 1;
 520       else if (unformat (input, "verbose"))
 521         verbose = 1;
 522       else
 523         break;
 524     }
 525
 526   if (do_server)
 527     {
 528       u64 handle;
 529       u32 index;
 530       if (pool_elts (app_pool))
 531         {
 532           vlib_cli_output (vm, "%U", format_application_listener,
 533                            0 /* header */ , 0, 0,
 534                            verbose);
 535           /* *INDENT-OFF* */
 536           pool_foreach (app, app_pool,
 537           ({
 538             /* App's listener sessions */
 539             if (hash_elts (app->listeners_table) == 0)
 540               continue;
 541             hash_foreach (handle, index, app->listeners_table,
 542             ({
 543               vlib_cli_output (vm, "%U", format_application_listener, app,
 544                                        handle, index, verbose);
 545             }));
 546           }));
 547           /* *INDENT-ON* */
 548         }
 549       else
 550         vlib_cli_output (vm, "No active server bindings");
 551     }
 552
 553   if (do_client)
 554     {
 555       if (pool_elts (app_pool))
 556         {
 557           application_format_connects (0, verbose);
 558
 559           /* *INDENT-OFF* */
 560           pool_foreach (app, app_pool,
 561           ({
 562             if (app->connects_seg_manager == (u32)~0)
 563               continue;
 564             application_format_connects (app, verbose);
 565           }));
 566           /* *INDENT-ON* */
 567         }
 568       else
 569         vlib_cli_output (vm, "No active client bindings");
 570     }
 571
 572   /* Print app related info */
 573   if (!do_server && !do_client)
 574     {
 575       vlib_cli_output (vm, "%U", format_application, 0, verbose);
 576       pool_foreach (app, app_pool, (
 577                                      {
 578                                      vlib_cli_output (vm, "%U",
 579                                                       format_application, app,
 580                                                       verbose);
 581                                      }
 582                     ));
 583     }
 584
 585   return 0;
 586 }
 587
 588 /* *INDENT-OFF* */
 589 VLIB_CLI_COMMAND (show_app_command, static) =
 590 {
 591   .path = "show app",
 592   .short_help = "show app [server|client] [verbose]",
 593   .function = show_app_command_fn,
 594 };
 595 /* *INDENT-ON* */
 596
 597 /*
 598  * fd.io coding-style-patch-verification: ON
 599  *
 600  * Local Variables:
 601  * eval: (c-set-style "gnu")
 602  * End:
 603  */