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 u32
 486 application_n_listeners (application_t * app)
 487 {
 488   return hash_elts (app->listeners_table);
 489 }
 490
 491 stream_session_t *
 492 application_first_listener (application_t * app)
 493 {
 494   u64 handle;
 495   u32 sm_index;
 496
 497   /* *INDENT-OFF* */
 498    hash_foreach (handle, sm_index, app->listeners_table, ({
 499      return listen_session_get_from_handle (handle);
 500    }));
 501   /* *INDENT-ON* */
 502
 503   return 0;
 504 }
 505
 506 u8 *
 507 format_application_listener (u8 * s, va_list * args)
 508 {
 509   application_t *app = va_arg (*args, application_t *);
 510   u64 handle = va_arg (*args, u64);
 511   u32 index = va_arg (*args, u32);
 512   int verbose = va_arg (*args, int);
 513   stream_session_t *listener;
 514   u8 *app_name, *str;
 515
 516   if (app == 0)
 517     {
 518       if (verbose)
 519         s = format (s, "%-40s%-20s%-15s%-15s%-10s", "Connection", "App",
 520                     "API Client", "ListenerID", "SegManager");
 521       else
 522         s = format (s, "%-40s%-20s", "Connection", "App");
 523
 524       return s;
 525     }
 526
 527   app_name = app_get_name_from_reg_index (app);
 528   listener = listen_session_get_from_handle (handle);
 529   str = format (0, "%U", format_stream_session, listener, verbose);
 530
 531   if (verbose)
 532     {
 533       s = format (s, "%-40s%-20s%-15u%-15u%-10u", str, app_name,
 534                   app->api_client_index, handle, index);
 535     }
 536   else
 537     s = format (s, "%-40s%-20s", str, app_name);
 538
 539   vec_free (app_name);
 540   return s;
 541 }
 542
 543 void
 544 application_format_connects (application_t * app, int verbose)
 545 {
 546   vlib_main_t *vm = vlib_get_main ();
 547   segment_manager_t *sm;
 548   u8 *app_name, *s = 0;
 549   int j;
 550
 551   /* Header */
 552   if (app == 0)
 553     {
 554       if (verbose)
 555         vlib_cli_output (vm, "%-40s%-20s%-15s%-10s", "Connection", "App",
 556                          "API Client", "SegManager");
 557       else
 558         vlib_cli_output (vm, "%-40s%-20s", "Connection", "App");
 559       return;
 560     }
 561
 562   /* make sure */
 563   if (app->connects_seg_manager == (u32) ~ 0)
 564     return;
 565
 566   app_name = app_get_name_from_reg_index (app);
 567
 568   /* Across all fifo segments */
 569   sm = segment_manager_get (app->connects_seg_manager);
 570   for (j = 0; j < vec_len (sm->segment_indices); j++)
 571     {
 572       svm_fifo_segment_private_t *fifo_segment;
 573       svm_fifo_t *fifo;
 574       u8 *str;
 575
 576       fifo_segment = svm_fifo_segment_get_segment (sm->segment_indices[j]);
 577       fifo = svm_fifo_segment_get_fifo_list (fifo_segment);
 578       while (fifo)
 579         {
 580           u32 session_index, thread_index;
 581           stream_session_t *session;
 582
 583           session_index = fifo->master_session_index;
 584           thread_index = fifo->master_thread_index;
 585
 586           session = session_get (session_index, thread_index);
 587           str = format (0, "%U", format_stream_session, session, verbose);
 588
 589           if (verbose)
 590             s = format (s, "%-40s%-20s%-15u%-10u", str, app_name,
 591                         app->api_client_index, app->connects_seg_manager);
 592           else
 593             s = format (s, "%-40s%-20s", str, app_name);
 594
 595           vlib_cli_output (vm, "%v", s);
 596           vec_reset_length (s);
 597           vec_free (str);
 598
 599           fifo = fifo->next;
 600         }
 601       vec_free (s);
 602     }
 603
 604   vec_free (app_name);
 605 }
 606
 607 u8 *
 608 format_application (u8 * s, va_list * args)
 609 {
 610   application_t *app = va_arg (*args, application_t *);
 611   CLIB_UNUSED (int verbose) = va_arg (*args, int);
 612   const u8 *app_ns_name;
 613   u8 *app_name;
 614
 615   if (app == 0)
 616     {
 617       if (verbose)
 618         s = format (s, "%-10s%-20s%-15s%-15s%-15s%-15s%-15s", "Index", "Name",
 619                     "Namespace", "API Client", "Add seg size", "Rx fifo size",
 620                     "Tx fifo size");
 621       else
 622         s =
 623           format (s, "%-10s%-20s%-15s%-20s", "Index", "Name", "Namespace",
 624                   "API Client");
 625       return s;
 626     }
 627
 628   app_name = app_get_name_from_reg_index (app);
 629   app_ns_name = app_namespace_id_from_index (app->ns_index);
 630   if (verbose)
 631     s =
 632       format (s, "%-10d%-20s%-15s%-15d%-15d%-15d%-15d", app->index, app_name,
 633               app_ns_name, app->api_client_index,
 634               app->sm_properties.add_segment_size,
 635               app->sm_properties.rx_fifo_size,
 636               app->sm_properties.tx_fifo_size);
 637   else
 638     s = format (s, "%-10d%-20s%-15s%-20d", app->index, app_name, app_ns_name,
 639                 app->api_client_index);
 640   return s;
 641 }
 642
 643 static clib_error_t *
 644 show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
 645                      vlib_cli_command_t * cmd)
 646 {
 647   application_t *app;
 648   int do_server = 0;
 649   int do_client = 0;
 650   int verbose = 0;
 651
 652   session_cli_return_if_not_enabled ();
 653
 654   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 655     {
 656       if (unformat (input, "server"))
 657         do_server = 1;
 658       else if (unformat (input, "client"))
 659         do_client = 1;
 660       else if (unformat (input, "verbose"))
 661         verbose = 1;
 662       else
 663         break;
 664     }
 665
 666   if (do_server)
 667     {
 668       u64 handle;
 669       u32 index;
 670       if (pool_elts (app_pool))
 671         {
 672           vlib_cli_output (vm, "%U", format_application_listener,
 673                            0 /* header */ , 0, 0,
 674                            verbose);
 675           /* *INDENT-OFF* */
 676           pool_foreach (app, app_pool,
 677           ({
 678             /* App's listener sessions */
 679             if (hash_elts (app->listeners_table) == 0)
 680               continue;
 681             hash_foreach (handle, index, app->listeners_table,
 682             ({
 683               vlib_cli_output (vm, "%U", format_application_listener, app,
 684                                        handle, index, verbose);
 685             }));
 686           }));
 687           /* *INDENT-ON* */
 688         }
 689       else
 690         vlib_cli_output (vm, "No active server bindings");
 691     }
 692
 693   if (do_client)
 694     {
 695       if (pool_elts (app_pool))
 696         {
 697           application_format_connects (0, verbose);
 698
 699           /* *INDENT-OFF* */
 700           pool_foreach (app, app_pool,
 701           ({
 702             if (app->connects_seg_manager == (u32)~0)
 703               continue;
 704             application_format_connects (app, verbose);
 705           }));
 706           /* *INDENT-ON* */
 707         }
 708       else
 709         vlib_cli_output (vm, "No active client bindings");
 710     }
 711
 712   /* Print app related info */
 713   if (!do_server && !do_client)
 714     {
 715       vlib_cli_output (vm, "%U", format_application, 0, verbose);
 716       /* *INDENT-OFF* */
 717       pool_foreach (app, app_pool, ({
 718         vlib_cli_output (vm, "%U", format_application, app, verbose);
 719       }));
 720       /* *INDENT-ON* */
 721     }
 722
 723   return 0;
 724 }
 725
 726 /* *INDENT-OFF* */
 727 VLIB_CLI_COMMAND (show_app_command, static) =
 728 {
 729   .path = "show app",
 730   .short_help = "show app [server|client] [verbose]",
 731   .function = show_app_command_fn,
 732 };
 733 /* *INDENT-ON* */
 734
 735 /*
 736  * fd.io coding-style-patch-verification: ON
 737  *
 738  * Local Variables:
 739  * eval: (c-set-style "gnu")
 740  * End:
 741  */