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   transport_connection_t *tc = 0;
 419   int rv;
 420
 421   /* Make sure we have a segment manager for connects */
 422   if (app->connects_seg_manager == APP_INVALID_SEGMENT_MANAGER_INDEX)
 423     {
 424       sm = application_alloc_segment_manager (app);
 425       if (sm == 0)
 426         return -1;
 427       app->connects_seg_manager = segment_manager_index (sm);
 428     }
 429
 430   if ((rv = stream_session_open (app->index, sep, &tc)))
 431     return rv;
 432
 433   /* Store api_context for when the reply comes. Not the nicest thing
 434    * but better than allocating a separate half-open pool. */
 435   tc->s_index = api_context;
 436
 437   return 0;
 438 }
 439
 440 segment_manager_t *
 441 application_get_connect_segment_manager (application_t * app)
 442 {
 443   ASSERT (app->connects_seg_manager != (u32) ~ 0);
 444   return segment_manager_get (app->connects_seg_manager);
 445 }
 446
 447 segment_manager_t *
 448 application_get_listen_segment_manager (application_t * app,
 449                                         stream_session_t * s)
 450 {
 451   uword *smp;
 452   smp = hash_get (app->listeners_table, listen_session_get_handle (s));
 453   ASSERT (smp != 0);
 454   return segment_manager_get (*smp);
 455 }
 456
 457 int
 458 application_is_proxy (application_t * app)
 459 {
 460   return !(app->flags & APP_OPTIONS_FLAGS_IS_PROXY);
 461 }
 462
 463 int
 464 application_add_segment_notify (u32 app_index, u32 fifo_segment_index)
 465 {
 466   application_t *app = application_get (app_index);
 467   u32 seg_size = 0;
 468   u8 *seg_name;
 469
 470   /* Send an API message to the external app, to map new segment */
 471   ASSERT (app->cb_fns.add_segment_callback);
 472
 473   segment_manager_get_segment_info (fifo_segment_index, &seg_name, &seg_size);
 474   return app->cb_fns.add_segment_callback (app->api_client_index, seg_name,
 475                                            seg_size);
 476 }
 477
 478 u8
 479 application_has_local_scope (application_t * app)
 480 {
 481   return app->flags & APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
 482 }
 483
 484 u8
 485 application_has_global_scope (application_t * app)
 486 {
 487   return app->flags & APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
 488 }
 489
 490 u8 *
 491 format_application_listener (u8 * s, va_list * args)
 492 {
 493   application_t *app = va_arg (*args, application_t *);
 494   u64 handle = va_arg (*args, u64);
 495   u32 index = va_arg (*args, u32);
 496   int verbose = va_arg (*args, int);
 497   stream_session_t *listener;
 498   u8 *app_name, *str;
 499
 500   if (app == 0)
 501     {
 502       if (verbose)
 503         s = format (s, "%-40s%-20s%-15s%-15s%-10s", "Connection", "App",
 504                     "API Client", "ListenerID", "SegManager");
 505       else
 506         s = format (s, "%-40s%-20s", "Connection", "App");
 507
 508       return s;
 509     }
 510
 511   app_name = app_get_name_from_reg_index (app);
 512   listener = listen_session_get_from_handle (handle);
 513   str = format (0, "%U", format_stream_session, listener, verbose);
 514
 515   if (verbose)
 516     {
 517       s = format (s, "%-40s%-20s%-15u%-15u%-10u", str, app_name,
 518                   app->api_client_index, handle, index);
 519     }
 520   else
 521     s = format (s, "%-40s%-20s", str, app_name);
 522
 523   vec_free (app_name);
 524   return s;
 525 }
 526
 527 void
 528 application_format_connects (application_t * app, int verbose)
 529 {
 530   vlib_main_t *vm = vlib_get_main ();
 531   segment_manager_t *sm;
 532   u8 *app_name, *s = 0;
 533   int j;
 534
 535   /* Header */
 536   if (app == 0)
 537     {
 538       if (verbose)
 539         vlib_cli_output (vm, "%-40s%-20s%-15s%-10s", "Connection", "App",
 540                          "API Client", "SegManager");
 541       else
 542         vlib_cli_output (vm, "%-40s%-20s", "Connection", "App");
 543       return;
 544     }
 545
 546   /* make sure */
 547   if (app->connects_seg_manager == (u32) ~ 0)
 548     return;
 549
 550   app_name = app_get_name_from_reg_index (app);
 551
 552   /* Across all fifo segments */
 553   sm = segment_manager_get (app->connects_seg_manager);
 554   for (j = 0; j < vec_len (sm->segment_indices); j++)
 555     {
 556       svm_fifo_segment_private_t *fifo_segment;
 557       svm_fifo_t *fifo;
 558       u8 *str;
 559
 560       fifo_segment = svm_fifo_segment_get_segment (sm->segment_indices[j]);
 561       fifo = svm_fifo_segment_get_fifo_list (fifo_segment);
 562       while (fifo)
 563         {
 564           u32 session_index, thread_index;
 565           stream_session_t *session;
 566
 567           session_index = fifo->master_session_index;
 568           thread_index = fifo->master_thread_index;
 569
 570           session = session_get (session_index, thread_index);
 571           str = format (0, "%U", format_stream_session, session, verbose);
 572
 573           if (verbose)
 574             s = format (s, "%-40s%-20s%-15u%-10u", str, app_name,
 575                         app->api_client_index, app->connects_seg_manager);
 576           else
 577             s = format (s, "%-40s%-20s", str, app_name);
 578
 579           vlib_cli_output (vm, "%v", s);
 580           vec_reset_length (s);
 581           vec_free (str);
 582
 583           fifo = fifo->next;
 584         }
 585       vec_free (s);
 586     }
 587
 588   vec_free (app_name);
 589 }
 590
 591 u8 *
 592 format_application (u8 * s, va_list * args)
 593 {
 594   application_t *app = va_arg (*args, application_t *);
 595   CLIB_UNUSED (int verbose) = va_arg (*args, int);
 596   const u8 *app_ns_name;
 597   u8 *app_name;
 598
 599   if (app == 0)
 600     {
 601       if (verbose)
 602         s = format (s, "%-10s%-20s%-15s%-15s%-15s%-15s%-15s", "Index", "Name",
 603                     "Namespace", "API Client", "Add seg size", "Rx fifo size",
 604                     "Tx fifo size");
 605       else
 606         s =
 607           format (s, "%-10s%-20s%-15s%-20s", "Index", "Name", "Namespace",
 608                   "API Client");
 609       return s;
 610     }
 611
 612   app_name = app_get_name_from_reg_index (app);
 613   app_ns_name = app_namespace_id_from_index (app->ns_index);
 614   if (verbose)
 615     s =
 616       format (s, "%-10d%-20s%-15s%-15d%-15d%-15d%-15d", app->index, app_name,
 617               app_ns_name, app->api_client_index,
 618               app->sm_properties.add_segment_size,
 619               app->sm_properties.rx_fifo_size,
 620               app->sm_properties.tx_fifo_size);
 621   else
 622     s = format (s, "%-10d%-20s%-15s%-20d", app->index, app_name, app_ns_name,
 623                 app->api_client_index);
 624   return s;
 625 }
 626
 627 static clib_error_t *
 628 show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
 629                      vlib_cli_command_t * cmd)
 630 {
 631   application_t *app;
 632   int do_server = 0;
 633   int do_client = 0;
 634   int verbose = 0;
 635
 636   session_cli_return_if_not_enabled ();
 637
 638   while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
 639     {
 640       if (unformat (input, "server"))
 641         do_server = 1;
 642       else if (unformat (input, "client"))
 643         do_client = 1;
 644       else if (unformat (input, "verbose"))
 645         verbose = 1;
 646       else
 647         break;
 648     }
 649
 650   if (do_server)
 651     {
 652       u64 handle;
 653       u32 index;
 654       if (pool_elts (app_pool))
 655         {
 656           vlib_cli_output (vm, "%U", format_application_listener,
 657                            0 /* header */ , 0, 0,
 658                            verbose);
 659           /* *INDENT-OFF* */
 660           pool_foreach (app, app_pool,
 661           ({
 662             /* App's listener sessions */
 663             if (hash_elts (app->listeners_table) == 0)
 664               continue;
 665             hash_foreach (handle, index, app->listeners_table,
 666             ({
 667               vlib_cli_output (vm, "%U", format_application_listener, app,
 668                                        handle, index, verbose);
 669             }));
 670           }));
 671           /* *INDENT-ON* */
 672         }
 673       else
 674         vlib_cli_output (vm, "No active server bindings");
 675     }
 676
 677   if (do_client)
 678     {
 679       if (pool_elts (app_pool))
 680         {
 681           application_format_connects (0, verbose);
 682
 683           /* *INDENT-OFF* */
 684           pool_foreach (app, app_pool,
 685           ({
 686             if (app->connects_seg_manager == (u32)~0)
 687               continue;
 688             application_format_connects (app, verbose);
 689           }));
 690           /* *INDENT-ON* */
 691         }
 692       else
 693         vlib_cli_output (vm, "No active client bindings");
 694     }
 695
 696   /* Print app related info */
 697   if (!do_server && !do_client)
 698     {
 699       vlib_cli_output (vm, "%U", format_application, 0, verbose);
 700       /* *INDENT-OFF* */
 701       pool_foreach (app, app_pool, ({
 702         vlib_cli_output (vm, "%U", format_application, app, verbose);
 703       }));
 704       /* *INDENT-ON* */
 705     }
 706
 707   return 0;
 708 }
 709
 710 /* *INDENT-OFF* */
 711 VLIB_CLI_COMMAND (show_app_command, static) =
 712 {
 713   .path = "show app",
 714   .short_help = "show app [server|client] [verbose]",
 715   .function = show_app_command_fn,
 716 };
 717 /* *INDENT-ON* */
 718
 719 /*
 720  * fd.io coding-style-patch-verification: ON
 721  *
 722  * Local Variables:
 723  * eval: (c-set-style "gnu")
 724  * End:
 725  */