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