FD.io VPP  v18.07.1-19-g511ce25
Vector Packet Processing
application.c
Go to the documentation of this file.
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 
19 #include <vnet/session/session.h>
20 
21 /**
22  * Pool from which we allocate all applications
23  */
25 
26 /**
27  * Hash table of apps by api client index
28  */
30 
31 /**
32  * Hash table of builtin apps by name
33  */
35 
36 static u8 *
38 {
39  u8 *app_name;
40 
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 static u8 *
53 {
54  if (!app->name)
55  return app_get_name_from_reg_index (app);
56  return app->name;
57 }
58 
59 u32
61 {
62  app_namespace_t *app_ns;
63  app_ns = app_namespace_get (app->ns_index);
65  return APP_INVALID_INDEX;
66  if (fib_proto == FIB_PROTOCOL_IP4)
67  return session_lookup_get_index_for_fib (fib_proto,
68  app_ns->ip4_fib_index);
69  else
70  return session_lookup_get_index_for_fib (fib_proto,
71  app_ns->ip6_fib_index);
72 }
73 
74 u32
76 {
77  app_namespace_t *app_ns;
78  if (!application_has_local_scope (app))
79  return APP_INVALID_INDEX;
80  app_ns = app_namespace_get (app->ns_index);
81  return app_ns->local_table_index;
82 }
83 
84 int
86 {
87  svm_queue_t *q;
88 
89  /* builtin servers are always OK */
90  if (app->api_client_index == ~0)
91  return 0;
92 
93  q = vl_api_client_index_to_input_queue (app->api_client_index);
94  if (!q)
95  return 1;
96 
97  if (q->cursize == q->maxsize)
98  return 1;
99  return 0;
100 }
101 
102 /**
103  * Returns app name
104  *
105  * Since the name is not stored per app, we generate it on the fly. It is
106  * the caller's responsibility to free the vector
107  */
108 u8 *
110 {
111  application_t *app = application_get (app_index);
112  if (!app)
113  return 0;
114  return app_get_name_from_reg_index (app);
115 }
116 
117 static void
119 {
120  if (app->api_client_index != APP_INVALID_INDEX)
121  hash_set (app_by_api_client_index, app->api_client_index, app->index);
122  else if (app->name)
123  hash_set_mem (app_by_name, app->name, app->index);
124 }
125 
126 static void
128 {
129  if (app->api_client_index != APP_INVALID_INDEX)
130  hash_unset (app_by_api_client_index, app->api_client_index);
131  else if (app->name)
132  hash_unset_mem (app_by_name, app->name);
133 }
134 
136 application_lookup (u32 api_client_index)
137 {
138  uword *p;
139  p = hash_get (app_by_api_client_index, api_client_index);
140  if (p)
141  return application_get (p[0]);
142 
143  return 0;
144 }
145 
148 {
149  uword *p;
150  p = hash_get_mem (app_by_name, name);
151  if (p)
152  return application_get (p[0]);
153 
154  return 0;
155 }
156 
159 {
160  application_t *app;
161  pool_get (app_pool, app);
162  memset (app, 0, sizeof (*app));
163  app->index = application_get_index (app);
164  app->connects_seg_manager = APP_INVALID_SEGMENT_MANAGER_INDEX;
165  app->first_segment_manager = APP_INVALID_SEGMENT_MANAGER_INDEX;
166  app->local_segment_manager = APP_INVALID_SEGMENT_MANAGER_INDEX;
167  if (CLIB_DEBUG > 1)
168  clib_warning ("[%d] New app (%d)", getpid (), app->index);
169  return app;
170 }
171 
172 void
174 {
175  vnet_unbind_args_t _a, *a = &_a;
176  u64 handle, *handles = 0;
177  segment_manager_t *sm;
178  u32 index;
179  int i;
180 
181  /*
182  * The app event queue allocated in first segment is cleared with
183  * the segment manager. No need to explicitly free it.
184  */
185  if (CLIB_DEBUG > 1)
186  clib_warning ("[%d] Delete app (%d)", getpid (), app->index);
187 
188  if (application_is_proxy (app))
190 
191  /*
192  * Listener cleanup
193  */
194 
195  /* *INDENT-OFF* */
196  hash_foreach (handle, index, app->listeners_table,
197  ({
198  vec_add1 (handles, handle);
199  sm = segment_manager_get (index);
200  sm->app_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
201  }));
202  /* *INDENT-ON* */
203 
204  for (i = 0; i < vec_len (handles); i++)
205  {
206  a->app_index = app->index;
207  a->handle = handles[i];
208  /* seg manager is removed when unbind completes */
209  vnet_unbind (a);
210  }
211 
212  /*
213  * Connects segment manager cleanup
214  */
215 
216  if (app->connects_seg_manager != APP_INVALID_SEGMENT_MANAGER_INDEX)
217  {
218  sm = segment_manager_get (app->connects_seg_manager);
219  sm->app_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
221  }
222 
223  /* If first segment manager is used by a listener */
224  if (app->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX
225  && app->first_segment_manager != app->connects_seg_manager)
226  {
227  sm = segment_manager_get (app->first_segment_manager);
228  /* .. and has no fifos, e.g. it might be used for redirected sessions,
229  * remove it */
230  if (!segment_manager_has_fifos (sm))
231  {
232  sm->app_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
233  segment_manager_del (sm);
234  }
235  }
236 
237  /*
238  * Local connections cleanup
239  */
241 
242  vec_free (app->tls_cert);
243  vec_free (app->tls_key);
244 
245  application_table_del (app);
246  vec_free (app->name);
247  pool_put (app_pool, app);
248 }
249 
250 static void
252 {
253  if (cb_fns->session_accept_callback == 0)
254  clib_warning ("No accept callback function provided");
255  if (cb_fns->session_connected_callback == 0)
256  clib_warning ("No session connected callback function provided");
257  if (cb_fns->session_disconnect_callback == 0)
258  clib_warning ("No session disconnect callback function provided");
259  if (cb_fns->session_reset_callback == 0)
260  clib_warning ("No session reset callback function provided");
261 }
262 
263 /**
264  * Check app config for given segment type
265  *
266  * Returns 1 on success and 0 otherwise
267  */
268 static u8
270 {
271  u8 is_valid;
272  if (st == SSVM_SEGMENT_MEMFD)
273  {
274  is_valid = (session_manager_get_evt_q_segment () != 0);
275  if (!is_valid)
276  clib_warning ("memfd seg: vpp's event qs IN binary api svm region");
277  return is_valid;
278  }
279  else if (st == SSVM_SEGMENT_SHM)
280  {
281  is_valid = (session_manager_get_evt_q_segment () == 0);
282  if (!is_valid)
283  clib_warning ("shm seg: vpp's event qs NOT IN binary api svm region");
284  return is_valid;
285  }
286  else
287  return 1;
288 }
289 
290 int
291 application_init (application_t * app, u32 api_client_index, u8 * app_name,
292  u64 * options, session_cb_vft_t * cb_fns)
293 {
295  u32 first_seg_size, prealloc_fifo_pairs;
298  segment_manager_t *sm;
299  int rv;
300 
301  /*
302  * Make sure we support the requested configuration
303  */
304 
305  if (!(options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_IS_BUILTIN))
306  {
307  reg = vl_api_client_index_to_registration (api_client_index);
308  if (!reg)
309  return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
311  seg_type = SSVM_SEGMENT_SHM;
312  }
313  else
314  {
315  seg_type = SSVM_SEGMENT_PRIVATE;
316  }
317 
318  if (!application_verify_cfg (seg_type))
319  return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
320 
321  /*
322  * Setup segment manager
323  */
324  sm = segment_manager_new ();
325  sm->app_index = app->index;
328  if (options[APP_OPTIONS_ADD_SEGMENT_SIZE])
329  {
330  props->add_segment_size = options[APP_OPTIONS_ADD_SEGMENT_SIZE];
331  props->add_segment = 1;
332  }
333  if (options[APP_OPTIONS_RX_FIFO_SIZE])
334  props->rx_fifo_size = options[APP_OPTIONS_RX_FIFO_SIZE];
335  if (options[APP_OPTIONS_TX_FIFO_SIZE])
336  props->tx_fifo_size = options[APP_OPTIONS_TX_FIFO_SIZE];
337  if (options[APP_OPTIONS_EVT_QUEUE_SIZE])
338  props->evt_q_size = options[APP_OPTIONS_EVT_QUEUE_SIZE];
339  if (options[APP_OPTIONS_TLS_ENGINE])
340  app->tls_engine = options[APP_OPTIONS_TLS_ENGINE];
341  props->segment_type = seg_type;
342 
343  first_seg_size = options[APP_OPTIONS_SEGMENT_SIZE];
344  prealloc_fifo_pairs = options[APP_OPTIONS_PREALLOC_FIFO_PAIRS];
345 
346  if ((rv = segment_manager_init (sm, first_seg_size, prealloc_fifo_pairs)))
347  return rv;
348  sm->first_is_protected = 1;
349 
350  /*
351  * Setup application
352  */
353  app->first_segment_manager = segment_manager_index (sm);
354  app->api_client_index = api_client_index;
355  app->flags = options[APP_OPTIONS_FLAGS];
356  app->cb_fns = *cb_fns;
357  app->ns_index = options[APP_OPTIONS_NAMESPACE];
358  app->listeners_table = hash_create (0, sizeof (u64));
359  app->local_connects = hash_create (0, sizeof (u64));
360  app->proxied_transports = options[APP_OPTIONS_PROXY_TRANSPORT];
361  app->event_queue = segment_manager_event_queue (sm);
362  app->name = vec_dup (app_name);
363 
364  /* If no scope enabled, default to global */
366  && !application_has_local_scope (app))
367  app->flags |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
368 
369  /* Check that the obvious things are properly set up */
370  application_verify_cb_fns (cb_fns);
371 
372  /* Add app to lookup by api_client_index table */
373  application_table_add (app);
374 
375  /*
376  * Segment manager for local sessions
377  */
378  sm = segment_manager_new ();
379  sm->app_index = app->index;
380  app->local_segment_manager = segment_manager_index (sm);
381 
382  return 0;
383 }
384 
387 {
388  if (index == APP_INVALID_INDEX)
389  return 0;
390  return pool_elt_at_index (app_pool, index);
391 }
392 
395 {
396  if (pool_is_free_index (app_pool, index))
397  return 0;
398 
399  return pool_elt_at_index (app_pool, index);
400 }
401 
402 u32
404 {
405  return app - app_pool;
406 }
407 
408 static segment_manager_t *
410 {
411  segment_manager_t *sm = 0;
412 
413  /* If the first segment manager is not in use, don't allocate a new one */
414  if (app->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX
415  && app->first_segment_manager_in_use == 0)
416  {
417  sm = segment_manager_get (app->first_segment_manager);
418  app->first_segment_manager_in_use = 1;
419  return sm;
420  }
421 
422  sm = segment_manager_new ();
423  sm->app_index = app->index;
424 
425  return sm;
426 }
427 
428 /**
429  * Start listening local transport endpoint for requested transport.
430  *
431  * Creates a 'dummy' stream session with state LISTENING to be used in session
432  * lookups, prior to establishing connection. Requests transport to build
433  * it's own specific listening connection.
434  */
435 int
437  session_handle_t * res)
438 {
439  segment_manager_t *sm;
440  stream_session_t *s;
441  session_handle_t handle;
442  session_type_t sst;
443 
444  sst = session_type_from_proto_and_ip (sep->transport_proto, sep->is_ip4);
445  s = listen_session_new (0, sst);
446  s->app_index = srv->index;
447 
448  /* Allocate segment manager. All sessions derived out of a listen session
449  * have fifos allocated by the same segment manager. */
450  if (!(sm = application_alloc_segment_manager (srv)))
451  goto err;
452 
453  /* Add to app's listener table. Useful to find all child listeners
454  * when app goes down, although, just for unbinding this is not needed */
455  handle = listen_session_get_handle (s);
456  hash_set (srv->listeners_table, handle, segment_manager_index (sm));
457 
458  if (stream_session_listen (s, sep))
459  {
460  segment_manager_del (sm);
461  hash_unset (srv->listeners_table, handle);
462  goto err;
463  }
464 
465  *res = handle;
466  return 0;
467 
468 err:
469  listen_session_del (s);
470  return -1;
471 }
472 
473 /**
474  * Stop listening on session associated to handle
475  */
476 int
478 {
479  stream_session_t *listener;
480  uword *indexp;
481  segment_manager_t *sm;
482 
483  if (srv && hash_get (srv->listeners_table, handle) == 0)
484  {
485  clib_warning ("app doesn't own handle %llu!", handle);
486  return -1;
487  }
488 
489  listener = listen_session_get_from_handle (handle);
490  stream_session_stop_listen (listener);
491 
492  indexp = hash_get (srv->listeners_table, handle);
493  ASSERT (indexp);
494 
495  sm = segment_manager_get (*indexp);
496  if (srv->first_segment_manager == *indexp)
497  {
498  /* Delete sessions but don't remove segment manager */
499  srv->first_segment_manager_in_use = 0;
501  }
502  else
503  {
505  }
506  hash_unset (srv->listeners_table, handle);
507  listen_session_del (listener);
508 
509  return 0;
510 }
511 
512 int
514  u32 api_context)
515 {
516  int rv;
517 
518  /* Make sure we have a segment manager for connects */
520 
521  if ((rv = session_open (app->index, sep, api_context)))
522  return rv;
523 
524  return 0;
525 }
526 
527 int
529 {
530  segment_manager_t *sm;
531 
532  if (app->connects_seg_manager == APP_INVALID_SEGMENT_MANAGER_INDEX)
533  {
535  if (sm == 0)
536  return -1;
537  app->connects_seg_manager = segment_manager_index (sm);
538  }
539  return 0;
540 }
541 
544 {
545  ASSERT (app->connects_seg_manager != (u32) ~ 0);
546  return segment_manager_get (app->connects_seg_manager);
547 }
548 
551  stream_session_t * s)
552 {
553  uword *smp;
554  smp = hash_get (app->listeners_table, listen_session_get_handle (s));
555  ASSERT (smp != 0);
556  return segment_manager_get (*smp);
557 }
558 
561 {
562  return segment_manager_get (app->local_segment_manager);
563 }
564 
567  local_session_t * ls)
568 {
569  stream_session_t *listener;
571  {
572  listener = listen_session_get (ls->listener_index);
573  return application_get_listen_segment_manager (app, listener);
574  }
575  return segment_manager_get (app->local_segment_manager);
576 }
577 
578 int
580 {
581  return (app->flags & APP_OPTIONS_FLAGS_IS_PROXY);
582 }
583 
584 int
586 {
587  return (app->flags & APP_OPTIONS_FLAGS_IS_BUILTIN);
588 }
589 
590 int
592 {
593  return (application_is_proxy (app) && application_is_builtin (app));
594 }
595 
596 /**
597  * Send an API message to the external app, to map new segment
598  */
599 int
601 {
602  application_t *app = application_get (app_index);
603  return app->cb_fns.add_segment_callback (app->api_client_index, fs);
604 }
605 
606 u8
608 {
609  return app->flags & APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
610 }
611 
612 u8
614 {
615  return app->flags & APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
616 }
617 
618 u32
620 {
621  return hash_elts (app->listeners_table);
622 }
623 
626  u8 transport_proto)
627 {
628  stream_session_t *listener;
629  u64 handle;
630  u32 sm_index;
631  u8 sst;
632 
633  sst = session_type_from_proto_and_ip (transport_proto,
634  fib_proto == FIB_PROTOCOL_IP4);
635 
636  /* *INDENT-OFF* */
637  hash_foreach (handle, sm_index, app->listeners_table, ({
638  listener = listen_session_get_from_handle (handle);
639  if (listener->session_type == sst
640  && listener->listener_index != SESSION_PROXY_LISTENER_INDEX)
641  return listener;
642  }));
643  /* *INDENT-ON* */
644 
645  return 0;
646 }
647 
650  u8 transport_proto)
651 {
652  stream_session_t *listener;
653  u64 handle;
654  u32 sm_index;
655  u8 sst;
656 
657  sst = session_type_from_proto_and_ip (transport_proto,
658  fib_proto == FIB_PROTOCOL_IP4);
659 
660  /* *INDENT-OFF* */
661  hash_foreach (handle, sm_index, app->listeners_table, ({
662  listener = listen_session_get_from_handle (handle);
663  if (listener->session_type == sst
664  && listener->listener_index == SESSION_PROXY_LISTENER_INDEX)
665  return listener;
666  }));
667  /* *INDENT-ON* */
668 
669  return 0;
670 }
671 
672 static clib_error_t *
674  u8 transport_proto, u8 is_start)
675 {
676  app_namespace_t *app_ns = app_namespace_get (app->ns_index);
677  u8 is_ip4 = (fib_proto == FIB_PROTOCOL_IP4);
680  stream_session_t *s;
681  u64 handle;
682 
683  if (is_start)
684  {
685  s = application_first_listener (app, fib_proto, transport_proto);
686  if (!s)
687  {
688  sep.is_ip4 = is_ip4;
689  sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
690  sep.sw_if_index = app_ns->sw_if_index;
691  sep.transport_proto = transport_proto;
692  application_start_listen (app, &sep, &handle);
693  s = listen_session_get_from_handle (handle);
694  s->listener_index = SESSION_PROXY_LISTENER_INDEX;
695  }
696  }
697  else
698  {
699  s = application_proxy_listener (app, fib_proto, transport_proto);
700  ASSERT (s);
701  }
702 
704 
705  if (!ip_is_zero (&tc->lcl_ip, 1))
706  {
707  u32 sti;
708  sep.is_ip4 = is_ip4;
709  sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
710  sep.transport_proto = transport_proto;
711  sep.port = 0;
712  sti = session_lookup_get_index_for_fib (fib_proto, sep.fib_index);
713  if (is_start)
714  session_lookup_add_session_endpoint (sti, &sep, s->session_index);
715  else
717  }
718 
719  return 0;
720 }
721 
722 static void
724  u8 transport_proto, u8 is_start)
725 {
727  app_namespace_t *app_ns;
728  app_ns = app_namespace_get (app->ns_index);
729  sep.is_ip4 = 1;
730  sep.transport_proto = transport_proto;
731  sep.port = 0;
732 
733  if (is_start)
734  {
735  session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
736  app->index);
737  sep.is_ip4 = 0;
738  session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
739  app->index);
740  }
741  else
742  {
743  session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
744  sep.is_ip4 = 0;
745  session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
746  }
747 }
748 
749 void
751  transport_proto_t transport_proto, u8 is_start)
752 {
753  if (application_has_local_scope (app))
754  application_start_stop_proxy_local_scope (app, transport_proto, is_start);
755 
757  {
759  transport_proto, is_start);
761  transport_proto, is_start);
762  }
763 }
764 
765 void
767 {
768  u16 transports = app->proxied_transports;
770 
772 
773  /* *INDENT-OFF* */
775  if (transports & (1 << tp))
776  application_start_stop_proxy (app, tp, 1);
777  }));
778  /* *INDENT-ON* */
779 }
780 
781 void
783 {
784  u16 transports = app->proxied_transports;
786 
788 
789  /* *INDENT-OFF* */
791  if (transports & (1 << tp))
792  application_start_stop_proxy (app, tp, 0);
793  }));
794  /* *INDENT-ON* */
795 }
796 
799 {
800  return &app->sm_properties;
801 }
802 
805 {
806  application_t *app = application_get (app_index);
807  return &app->sm_properties;
808 }
809 
812 {
813  local_session_t *s;
814  pool_get (app->local_sessions, s);
815  memset (s, 0, sizeof (*s));
816  s->app_index = app->index;
817  s->session_index = s - app->local_sessions;
819  return s;
820 }
821 
822 void
824 {
825  pool_put (app->local_sessions, s);
826  if (CLIB_DEBUG)
827  memset (s, 0xfc, sizeof (*s));
828 }
829 
832 {
833  return pool_elt_at_index (app->local_sessions, session_index);
834 }
835 
838 {
839  application_t *server;
840  u32 session_index, server_index;
841  local_session_parse_handle (handle, &server_index, &session_index);
842  server = application_get (server_index);
843  return application_get_local_session (server, session_index);
844 }
845 
846 always_inline void
848  session_endpoint_t * sep)
849 {
850  sep->transport_proto =
852  sep->port = ll->port;
853  sep->is_ip4 = ll->listener_session_type & 1;
854 }
855 
856 int
858  session_endpoint_t * sep,
859  session_handle_t * handle)
860 {
861  session_handle_t lh;
862  local_session_t *ll;
863  u32 table_index;
864 
865  table_index = application_local_session_table (server);
866 
867  /* An exact sep match, as opposed to session_lookup_local_listener */
868  lh = session_lookup_endpoint_listener (table_index, sep, 1);
869  if (lh != SESSION_INVALID_HANDLE)
870  return VNET_API_ERROR_ADDRESS_IN_USE;
871 
872  pool_get (server->local_listen_sessions, ll);
873  memset (ll, 0, sizeof (*ll));
875  ll->app_index = server->index;
876  ll->session_index = ll - server->local_listen_sessions;
877  ll->port = sep->port;
878  /* Store the original session type for the unbind */
880  session_type_from_proto_and_ip (sep->transport_proto, sep->is_ip4);
881  ll->transport_listener_index = ~0;
882 
883  *handle = application_local_session_handle (ll);
884  session_lookup_add_session_endpoint (table_index, sep, *handle);
885 
886  return 0;
887 }
888 
889 /**
890  * Clean up local session table. If we have a listener session use it to
891  * find the port and proto. If not, the handle must be a local table handle
892  * so parse it.
893  */
894 int
896 {
898  u32 table_index, ll_index, server_index;
899  stream_session_t *sl = 0;
900  local_session_t *ll, *ls;
901 
902  table_index = application_local_session_table (server);
903 
904  /* We have both local and global table binds. Figure from global what
905  * the sep we should be cleaning up is.
906  */
907  if (!session_handle_is_local (lh))
908  {
910  if (!sl || listen_session_get_local_session_endpoint (sl, &sep))
911  {
912  clib_warning ("broken listener");
913  return -1;
914  }
915  lh = session_lookup_endpoint_listener (table_index, &sep, 0);
916  if (lh == SESSION_INVALID_HANDLE)
917  return -1;
918  }
919 
920  local_session_parse_handle (lh, &server_index, &ll_index);
921  ASSERT (server->index == server_index);
922  if (!(ll = application_get_local_listen_session (server, ll_index)))
923  {
924  clib_warning ("no local listener");
925  return -1;
926  }
928  session_lookup_del_session_endpoint (table_index, &sep);
929 
930  /* *INDENT-OFF* */
931  pool_foreach (ls, server->local_sessions, ({
932  if (ls->listener_index == ll->session_index)
933  application_local_session_disconnect (server->index, ls);
934  }));
935  /* *INDENT-ON* */
936  pool_put_index (server->local_listen_sessions, ll->session_index);
937 
938  return 0;
939 }
940 
941 int
943  application_t * server,
944  local_session_t * ll, u32 opaque)
945 {
946  u32 seg_size, evt_q_sz, evt_q_elts, margin = 16 << 10;
947  segment_manager_properties_t *props, *cprops;
948  int rv, has_transport, seg_index;
950  segment_manager_t *sm;
951  local_session_t *ls;
952  svm_queue_t *sq, *cq;
953 
954  ls = application_alloc_local_session (server);
955 
957  cprops = application_segment_manager_properties (client);
958  evt_q_elts = props->evt_q_size + cprops->evt_q_size;
959  evt_q_sz = evt_q_elts * sizeof (session_fifo_event_t);
960  seg_size = props->rx_fifo_size + props->tx_fifo_size + evt_q_sz + margin;
961 
962  has_transport = session_has_transport ((stream_session_t *) ll);
963  if (!has_transport)
964  {
965  /* Local sessions don't have backing transport */
966  ls->port = ll->port;
968  }
969  else
970  {
971  stream_session_t *sl = (stream_session_t *) ll;
974  ls->port = tc->lcl_port;
975  sm = application_get_listen_segment_manager (server, sl);
976  }
977 
978  seg_index = segment_manager_add_segment (sm, seg_size);
979  if (seg_index < 0)
980  {
981  clib_warning ("failed to add new cut-through segment");
982  return seg_index;
983  }
984  seg = segment_manager_get_segment_w_lock (sm, seg_index);
985  sq = segment_manager_alloc_queue (seg, props->evt_q_size);
986  cq = segment_manager_alloc_queue (seg, cprops->evt_q_size);
987  ls->server_evt_q = pointer_to_uword (sq);
988  ls->client_evt_q = pointer_to_uword (cq);
989  rv = segment_manager_try_alloc_fifos (seg, props->rx_fifo_size,
990  props->tx_fifo_size,
991  &ls->server_rx_fifo,
992  &ls->server_tx_fifo);
993  if (rv)
994  {
995  clib_warning ("failed to add fifos in cut-through segment");
997  goto failed;
998  }
999  ls->server_rx_fifo->master_session_index = ls->session_index;
1000  ls->server_tx_fifo->master_session_index = ls->session_index;
1001  ls->server_rx_fifo->master_thread_index = ~0;
1002  ls->server_tx_fifo->master_thread_index = ~0;
1003  ls->svm_segment_index = seg_index;
1004  ls->listener_index = ll->session_index;
1005  ls->client_index = client->index;
1006  ls->client_opaque = opaque;
1008 
1009  if ((rv = server->cb_fns.add_segment_callback (server->api_client_index,
1010  &seg->ssvm)))
1011  {
1012  clib_warning ("failed to notify server of new segment");
1014  goto failed;
1015  }
1017  if ((rv = server->cb_fns.session_accept_callback ((stream_session_t *) ls)))
1018  {
1019  clib_warning ("failed to send accept cut-through notify to server");
1020  goto failed;
1021  }
1022  if (server->flags & APP_OPTIONS_FLAGS_IS_BUILTIN)
1024 
1025  return 0;
1026 
1027 failed:
1028  if (!has_transport)
1029  segment_manager_del_segment (sm, seg);
1030  return rv;
1031 }
1032 
1033 static uword
1035 {
1036  return ((uword) ls->app_index << 32 | (uword) ls->session_index);
1037 }
1038 
1039 static void
1041  u32 * session_index)
1042 {
1043  *app_index = key >> 32;
1044  *session_index = key & 0xFFFFFFFF;
1045 }
1046 
1047 int
1049 {
1051  application_t *client, *server;
1052  segment_manager_t *sm;
1053  int rv, is_fail = 0;
1054  uword client_key;
1055 
1056  client = application_get (ls->client_index);
1057  server = application_get (ls->app_index);
1060  if ((rv = client->cb_fns.add_segment_callback (client->api_client_index,
1061  &seg->ssvm)))
1062  {
1063  clib_warning ("failed to notify client %u of new segment",
1064  ls->client_index);
1067  is_fail = 1;
1068  }
1069  else
1070  {
1072  }
1073 
1074  client->cb_fns.session_connected_callback (client->index, ls->client_opaque,
1075  (stream_session_t *) ls,
1076  is_fail);
1077 
1078  client_key = application_client_local_connect_key (ls);
1079  hash_set (client->local_connects, client_key, client_key);
1080  return 0;
1081 }
1082 
1083 int
1085  application_t * server,
1086  local_session_t * ls)
1087 {
1089  segment_manager_t *sm;
1090  uword client_key;
1091  u8 has_transport;
1092 
1093  has_transport = session_has_transport ((stream_session_t *) ls);
1094  client_key = application_client_local_connect_key (ls);
1095  if (!has_transport)
1097  else
1099  (stream_session_t *) ls);
1100 
1102  if (client)
1103  hash_unset (client->local_connects, client_key);
1104 
1105  if (!has_transport)
1106  {
1107  server->cb_fns.del_segment_callback (server->api_client_index,
1108  &seg->ssvm);
1109  if (client)
1110  client->cb_fns.del_segment_callback (client->api_client_index,
1111  &seg->ssvm);
1112  segment_manager_del_segment (sm, seg);
1113  }
1114 
1115  application_free_local_session (server, ls);
1116 
1117  return 0;
1118 }
1119 
1120 int
1122 {
1123  application_t *client, *server;
1124 
1125  client = application_get_if_valid (ls->client_index);
1126  server = application_get (ls->app_index);
1127 
1129  return application_local_session_cleanup (client, server, ls);
1130 
1131  if (app_index == ls->client_index)
1132  {
1134  }
1135  else
1136  {
1137  if (!client)
1138  {
1139  return application_local_session_cleanup (client, server, ls);
1140  }
1141  else if (ls->session_state < SESSION_STATE_READY)
1142  {
1143  client->cb_fns.session_connected_callback (client->index,
1144  ls->client_opaque,
1145  (stream_session_t *) ls,
1146  1 /* is_fail */ );
1148  return application_local_session_cleanup (client, server, ls);
1149  }
1150  else
1151  {
1152  send_local_session_disconnect_callback (client->index, ls);
1153  }
1154  }
1155 
1157 
1158  return 0;
1159 }
1160 
1161 int
1163 {
1164  application_t *app;
1165  local_session_t *ls;
1166  app = application_get (app_index);
1167  ls = application_get_local_session (app, ls_index);
1168  return application_local_session_disconnect (app_index, ls);
1169 }
1170 
1171 void
1173 {
1174  u32 index, server_index, session_index, table_index;
1175  segment_manager_t *sm;
1176  u64 handle, *handles = 0;
1177  local_session_t *ls, *ll;
1178  application_t *server;
1179  session_endpoint_t sep;
1180  int i;
1181 
1182  /*
1183  * Local listens. Don't bother with local sessions, we clean them lower
1184  */
1185  table_index = application_local_session_table (app);
1186  /* *INDENT-OFF* */
1187  pool_foreach (ll, app->local_listen_sessions, ({
1188  application_local_listener_session_endpoint (ll, &sep);
1189  session_lookup_del_session_endpoint (table_index, &sep);
1190  }));
1191  /* *INDENT-ON* */
1192 
1193  /*
1194  * Local sessions
1195  */
1196  if (app->local_sessions)
1197  {
1198  /* *INDENT-OFF* */
1199  pool_foreach (ls, app->local_sessions, ({
1200  application_local_session_disconnect (app->index, ls);
1201  }));
1202  /* *INDENT-ON* */
1203  }
1204 
1205  /*
1206  * Local connects
1207  */
1208  vec_reset_length (handles);
1209  /* *INDENT-OFF* */
1210  hash_foreach (handle, index, app->local_connects, ({
1211  vec_add1 (handles, handle);
1212  }));
1213  /* *INDENT-ON* */
1214 
1215  for (i = 0; i < vec_len (handles); i++)
1216  {
1217  application_client_local_connect_key_parse (handles[i], &server_index,
1218  &session_index);
1219  server = application_get_if_valid (server_index);
1220  if (server)
1221  {
1222  ls = application_get_local_session (server, session_index);
1223  application_local_session_disconnect (app->index, ls);
1224  }
1225  }
1226 
1227  sm = segment_manager_get (app->local_segment_manager);
1228  sm->app_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
1229  segment_manager_del (sm);
1230 }
1231 
1232 clib_error_t *
1234 {
1235  application_t *app;
1236  app = application_get (a->app_index);
1237  if (!app)
1238  return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
1239  0, "app %u doesn't exist", a->app_index);
1240  app->tls_cert = vec_dup (a->cert);
1241  return 0;
1242 }
1243 
1244 clib_error_t *
1246 {
1247  application_t *app;
1248  app = application_get (a->app_index);
1249  if (!app)
1250  return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
1251  0, "app %u doesn't exist", a->app_index);
1252  app->tls_key = vec_dup (a->key);
1253  return 0;
1254 }
1255 
1256 u8 *
1257 format_application_listener (u8 * s, va_list * args)
1258 {
1259  application_t *app = va_arg (*args, application_t *);
1260  u64 handle = va_arg (*args, u64);
1261  u32 sm_index = va_arg (*args, u32);
1262  int verbose = va_arg (*args, int);
1263  stream_session_t *listener;
1264  u8 *app_name, *str;
1265 
1266  if (app == 0)
1267  {
1268  if (verbose)
1269  s = format (s, "%-40s%-20s%-15s%-15s%-10s", "Connection", "App",
1270  "API Client", "ListenerID", "SegManager");
1271  else
1272  s = format (s, "%-40s%-20s", "Connection", "App");
1273 
1274  return s;
1275  }
1276 
1277  app_name = app_get_name_from_reg_index (app);
1278  listener = listen_session_get_from_handle (handle);
1279  str = format (0, "%U", format_stream_session, listener, verbose);
1280 
1281  if (verbose)
1282  {
1283  s = format (s, "%-40s%-20s%-15u%-15u%-10u", str, app_name,
1284  app->api_client_index, handle, sm_index);
1285  }
1286  else
1287  s = format (s, "%-40s%-20s", str, app_name);
1288 
1289  vec_free (app_name);
1290  return s;
1291 }
1292 
1293 void
1295 {
1296  svm_fifo_segment_private_t *fifo_segment;
1298  segment_manager_t *sm;
1299  u8 *app_name, *s = 0;
1300 
1301  /* Header */
1302  if (app == 0)
1303  {
1304  if (verbose)
1305  vlib_cli_output (vm, "%-40s%-20s%-15s%-10s", "Connection", "App",
1306  "API Client", "SegManager");
1307  else
1308  vlib_cli_output (vm, "%-40s%-20s", "Connection", "App");
1309  return;
1310  }
1311 
1312  /* make sure */
1313  if (app->connects_seg_manager == (u32) ~ 0)
1314  return;
1315 
1316  app_name = app_get_name_from_reg_index (app);
1317 
1318  /* Across all fifo segments */
1319  sm = segment_manager_get (app->connects_seg_manager);
1320 
1321  /* *INDENT-OFF* */
1322  segment_manager_foreach_segment_w_lock (fifo_segment, sm, ({
1323  svm_fifo_t *fifo;
1324  u8 *str;
1325 
1326  fifo = svm_fifo_segment_get_fifo_list (fifo_segment);
1327  while (fifo)
1328  {
1329  u32 session_index, thread_index;
1330  stream_session_t *session;
1331 
1332  session_index = fifo->master_session_index;
1333  thread_index = fifo->master_thread_index;
1334 
1335  session = session_get (session_index, thread_index);
1336  str = format (0, "%U", format_stream_session, session, verbose);
1337 
1338  if (verbose)
1339  s = format (s, "%-40s%-20s%-15u%-10u", str, app_name,
1340  app->api_client_index, app->connects_seg_manager);
1341  else
1342  s = format (s, "%-40s%-20s", str, app_name);
1343 
1344  vlib_cli_output (vm, "%v", s);
1345  vec_reset_length (s);
1346  vec_free (str);
1347 
1348  fifo = fifo->next;
1349  }
1350  vec_free (s);
1351  }));
1352  /* *INDENT-ON* */
1353 
1354  vec_free (app_name);
1355 }
1356 
1357 void
1359 {
1361  local_session_t *ls;
1362  transport_proto_t tp;
1363  u8 *conn = 0;
1364 
1365  /* Header */
1366  if (app == 0)
1367  {
1368  vlib_cli_output (vm, "%-40s%-15s%-20s", "Connection", "ServerApp",
1369  "ClientApp");
1370  return;
1371  }
1372 
1373  /* *INDENT-OFF* */
1374  pool_foreach (ls, app->local_listen_sessions, ({
1375  tp = session_type_transport_proto(ls->listener_session_type);
1376  conn = format (0, "[L][%U] *:%u", format_transport_proto_short, tp,
1377  ls->port);
1378  vlib_cli_output (vm, "%-40v%-15u%-20s", conn, ls->app_index, "*");
1379  vec_reset_length (conn);
1380  }));
1381  pool_foreach (ls, app->local_sessions, ({
1382  tp = session_type_transport_proto(ls->listener_session_type);
1383  conn = format (0, "[L][%U] *:%u", format_transport_proto_short, tp,
1384  ls->port);
1385  vlib_cli_output (vm, "%-40v%-15u%-20u", conn, ls->app_index,
1386  ls->client_index);
1387  vec_reset_length (conn);
1388  }));
1389  /* *INDENT-ON* */
1390 
1391  vec_free (conn);
1392 }
1393 
1394 void
1396 {
1398  u32 app_index, session_index;
1399  application_t *server;
1400  local_session_t *ls;
1401  uword client_key;
1402  u64 value;
1403 
1404  /* Header */
1405  if (app == 0)
1406  {
1407  if (verbose)
1408  vlib_cli_output (vm, "%-40s%-15s%-20s%-10s", "Connection", "App",
1409  "Peer App", "SegManager");
1410  else
1411  vlib_cli_output (vm, "%-40s%-15s%-20s", "Connection", "App",
1412  "Peer App");
1413  return;
1414  }
1415 
1416  /* *INDENT-OFF* */
1417  hash_foreach (client_key, value, app->local_connects, ({
1418  application_client_local_connect_key_parse (client_key, &app_index,
1419  &session_index);
1420  server = application_get (app_index);
1421  ls = application_get_local_session (server, session_index);
1422  vlib_cli_output (vm, "%-40s%-15s%-20s", "TODO", ls->app_index, ls->client_index);
1423  }));
1424  /* *INDENT-ON* */
1425 }
1426 
1427 u8 *
1428 format_application (u8 * s, va_list * args)
1429 {
1430  application_t *app = va_arg (*args, application_t *);
1431  CLIB_UNUSED (int verbose) = va_arg (*args, int);
1433  const u8 *app_ns_name;
1434  u8 *app_name;
1435 
1436  if (app == 0)
1437  {
1438  if (verbose)
1439  s = format (s, "%-10s%-20s%-15s%-15s%-15s%-15s%-15s", "Index", "Name",
1440  "API Client", "Namespace", "Add seg size", "Rx-f size",
1441  "Tx-f size");
1442  else
1443  s = format (s, "%-10s%-20s%-15s%-40s", "Index", "Name", "API Client",
1444  "Namespace");
1445  return s;
1446  }
1447 
1448  app_name = app_get_name (app);
1449  app_ns_name = app_namespace_id_from_index (app->ns_index);
1451  if (verbose)
1452  s = format (s, "%-10u%-20s%-15d%-15u%-15U%-15U%-15U", app->index,
1453  app_name, app->api_client_index, app->ns_index,
1454  format_memory_size, props->add_segment_size,
1455  format_memory_size, props->rx_fifo_size, format_memory_size,
1456  props->tx_fifo_size);
1457  else
1458  s = format (s, "%-10u%-20s%-15d%-40s", app->index, app_name,
1459  app->api_client_index, app_ns_name);
1460  return s;
1461 }
1462 
1463 
1464 void
1465 application_format_all_listeners (vlib_main_t * vm, int do_local, int verbose)
1466 {
1467  application_t *app;
1468  u32 sm_index;
1469  u64 handle;
1470 
1471  if (!pool_elts (app_pool))
1472  {
1473  vlib_cli_output (vm, "No active server bindings");
1474  return;
1475  }
1476 
1477  if (do_local)
1478  {
1479  application_format_local_sessions (0, verbose);
1480  /* *INDENT-OFF* */
1481  pool_foreach (app, app_pool, ({
1482  if (!pool_elts (app->local_sessions)
1483  && !pool_elts(app->local_connects))
1484  continue;
1485  application_format_local_sessions (app, verbose);
1486  }));
1487  /* *INDENT-ON* */
1488  }
1489  else
1490  {
1491  vlib_cli_output (vm, "%U", format_application_listener, 0 /* header */ ,
1492  0, 0, verbose);
1493 
1494  /* *INDENT-OFF* */
1495  pool_foreach (app, app_pool, ({
1496  if (hash_elts (app->listeners_table) == 0)
1497  continue;
1498  hash_foreach (handle, sm_index, app->listeners_table, ({
1499  vlib_cli_output (vm, "%U", format_application_listener, app,
1500  handle, sm_index, verbose);
1501  }));
1502  }));
1503  /* *INDENT-ON* */
1504  }
1505 }
1506 
1507 void
1508 application_format_all_clients (vlib_main_t * vm, int do_local, int verbose)
1509 {
1510  application_t *app;
1511 
1512  if (!pool_elts (app_pool))
1513  {
1514  vlib_cli_output (vm, "No active apps");
1515  return;
1516  }
1517 
1518  if (do_local)
1519  {
1520  application_format_local_connects (0, verbose);
1521 
1522  /* *INDENT-OFF* */
1523  pool_foreach (app, app_pool, ({
1524  if (app->local_connects)
1525  application_format_local_connects (app, verbose);
1526  }));
1527  /* *INDENT-ON* */
1528  }
1529  else
1530  {
1531  application_format_connects (0, verbose);
1532 
1533  /* *INDENT-OFF* */
1534  pool_foreach (app, app_pool, ({
1535  if (app->connects_seg_manager == (u32)~0)
1536  continue;
1537  application_format_connects (app, verbose);
1538  }));
1539  /* *INDENT-ON* */
1540  }
1541 }
1542 
1543 static clib_error_t *
1545  vlib_cli_command_t * cmd)
1546 {
1547  int do_server = 0, do_client = 0, do_local = 0;
1548  application_t *app;
1549  int verbose = 0;
1550 
1552 
1553  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1554  {
1555  if (unformat (input, "server"))
1556  do_server = 1;
1557  else if (unformat (input, "client"))
1558  do_client = 1;
1559  else if (unformat (input, "local"))
1560  do_local = 1;
1561  else if (unformat (input, "verbose"))
1562  verbose = 1;
1563  else
1564  break;
1565  }
1566 
1567  if (do_server)
1568  application_format_all_listeners (vm, do_local, verbose);
1569 
1570  if (do_client)
1571  application_format_all_clients (vm, do_local, verbose);
1572 
1573  /* Print app related info */
1574  if (!do_server && !do_client)
1575  {
1576  vlib_cli_output (vm, "%U", format_application, 0, verbose);
1577  /* *INDENT-OFF* */
1578  pool_foreach (app, app_pool, ({
1579  vlib_cli_output (vm, "%U", format_application, app, verbose);
1580  }));
1581  /* *INDENT-ON* */
1582  }
1583 
1584  return 0;
1585 }
1586 
1587 /* *INDENT-OFF* */
1588 VLIB_CLI_COMMAND (show_app_command, static) =
1589 {
1590  .path = "show app",
1591  .short_help = "show app [server|client] [verbose]",
1592  .function = show_app_command_fn,
1593 };
1594 /* *INDENT-ON* */
1595 
1596 /*
1597  * fd.io coding-style-patch-verification: ON
1598  *
1599  * Local Variables:
1600  * eval: (c-set-style "gnu")
1601  * End:
1602  */
int application_open_session(application_t *app, session_endpoint_t *sep, u32 api_context)
Definition: application.c:513
static void application_table_add(application_t *app)
Definition: application.c:118
segment_manager_t * application_get_local_segment_manager_w_session(application_t *app, local_session_t *ls)
Definition: application.c:566
svm_queue_t * segment_manager_alloc_queue(svm_fifo_segment_private_t *segment, u32 queue_size)
Allocates shm queue in the first segment.
session_type_t listener_session_type
Has transport embedded when listener not purely local.
void application_free_local_session(application_t *app, local_session_t *s)
Definition: application.c:823
u8 * name
Client name.
Definition: api_common.h:51
#define hash_set(h, key, value)
Definition: hash.h:255
void segment_manager_segment_reader_unlock(segment_manager_t *sm)
void application_format_local_connects(application_t *app, int verbose)
Definition: application.c:1395
u32 application_n_listeners(application_t *app)
Definition: application.c:619
#define CLIB_UNUSED(x)
Definition: clib.h:79
static session_handle_t application_local_session_handle(local_session_t *ls)
Definition: application.h:235
#define hash_unset(h, key)
Definition: hash.h:261
a
Definition: bitmap.h:538
u64 session_lookup_endpoint_listener(u32 table_index, session_endpoint_t *sep, u8 use_rules)
Lookup listener for session endpoint in table.
u8 application_has_global_scope(application_t *app)
Definition: application.c:613
struct _transport_connection transport_connection_t
struct _segment_manager_properties segment_manager_properties_t
#define session_cli_return_if_not_enabled()
Definition: session.h:617
segment_manager_properties_t * application_get_segment_manager_properties(u32 app_index)
Definition: application.c:804
static clib_error_t * show_app_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: application.c:1544
unsigned long u64
Definition: types.h:89
int application_stop_listen(application_t *srv, session_handle_t handle)
Stop listening on session associated to handle.
Definition: application.c:477
clib_error_t * vnet_unbind(vnet_unbind_args_t *a)
int application_start_local_listen(application_t *server, session_endpoint_t *sep, session_handle_t *handle)
Definition: application.c:857
#define SESSION_PROXY_LISTENER_INDEX
Definition: session.h:27
application_t * application_lookup_name(const u8 *name)
Definition: application.c:147
application_t * application_new()
Definition: application.c:158
u32 session_lookup_get_index_for_fib(u32 fib_proto, u32 fib_index)
u32 client_index
Client data.
local_session_t * application_get_local_session_from_handle(session_handle_t handle)
Definition: application.c:837
application_t * application_lookup(u32 api_client_index)
Definition: application.c:136
int i
void application_local_sessions_del(application_t *app)
Definition: application.c:1172
#define hash_set_mem(h, key, value)
Definition: hash.h:275
svm_fifo_t * server_tx_fifo
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:419
u64 session_handle_t
Definition: session.h:91
segment_manager_properties_t * segment_manager_properties_init(segment_manager_properties_t *props)
#define segment_manager_foreach_segment_w_lock(VAR, SM, BODY)
struct _vnet_application_add_tls_cert_args_t vnet_app_add_tls_cert_args_t
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:228
clib_error_t * vnet_app_add_tls_cert(vnet_app_add_tls_cert_args_t *a)
Definition: application.c:1233
unsigned char u8
Definition: types.h:56
static stream_session_t * listen_session_get_from_handle(session_handle_t handle)
Definition: session.h:569
int segment_manager_init(segment_manager_t *sm, u32 first_seg_size, u32 prealloc_fifo_pairs)
Initializes segment manager based on options provided.
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
#define SESSION_ENDPOINT_NULL
struct _svm_fifo svm_fifo_t
segment_manager_t * application_get_listen_segment_manager(application_t *app, stream_session_t *s)
Definition: application.c:550
int application_is_proxy(application_t *app)
Definition: application.c:579
enum ssvm_segment_type_ ssvm_segment_type_t
#define pool_foreach(VAR, POOL, BODY)
Iterate through pool.
Definition: pool.h:443
static void application_table_del(application_t *app)
Definition: application.c:127
void application_format_local_sessions(application_t *app, int verbose)
Definition: application.c:1358
#define always_inline
Definition: clib.h:92
int application_local_session_connect_notify(local_session_t *ls)
Definition: application.c:1048
u32 transport_listener_index
struct _stream_session_cb_vft session_cb_vft_t
struct _vnet_unbind_args_t vnet_unbind_args_t
svm_fifo_segment_private_t * segment_manager_get_segment_w_lock(segment_manager_t *sm, u32 segment_index)
Reads a segment from the segment manager&#39;s pool and acquires reader lock.
#define hash_foreach(key_var, value_var, h, body)
Definition: hash.h:442
session_type_t session_type
Type.
u8 * format_memory_size(u8 *s, va_list *va)
Definition: std-formats.c:193
static stream_session_t * listen_session_get(u32 index)
Definition: session.h:592
#define transport_proto_foreach(VAR, BODY)
static u8 * app_get_name_from_reg_index(application_t *app)
Definition: application.c:37
unsigned int u32
Definition: types.h:88
static local_session_t * application_get_local_listen_session(application_t *app, u32 session_index)
Definition: application.h:242
struct _stream_session_t stream_session_t
segment_manager_t * segment_manager_new()
local_session_t * application_alloc_local_session(application_t *app)
Definition: application.c:811
int application_add_segment_notify(u32 app_index, ssvm_private_t *fs)
Send an API message to the external app, to map new segment.
Definition: application.c:600
static void application_verify_cb_fns(session_cb_vft_t *cb_fns)
Definition: application.c:251
int session_open(u32 app_index, session_endpoint_t *rmt, u32 opaque)
Ask transport to open connection to remote transport endpoint.
Definition: session.c:950
clib_error_t * vnet_app_add_tls_key(vnet_app_add_tls_key_args_t *a)
Definition: application.c:1245
static void listen_session_del(stream_session_t *s)
Definition: session.h:598
int application_is_builtin(application_t *app)
Definition: application.c:585
#define hash_get(h, key)
Definition: hash.h:249
u32 app_namespace_get_fib_index(app_namespace_t *app_ns, u8 fib_proto)
static svm_fifo_t * svm_fifo_segment_get_fifo_list(svm_fifo_segment_private_t *fifo_segment)
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:464
#define hash_unset_mem(h, key)
Definition: hash.h:291
#define VL_API_INVALID_FI
Definition: api_common.h:75
struct _session_endpoint session_endpoint_t
static void local_session_parse_handle(session_handle_t handle, u32 *server_index, u32 *session_index)
Definition: application.h:225
static u8 * app_get_name(application_t *app)
Definition: application.c:52
svm_fifo_t * server_rx_fifo
fifo pointers.
stream_session_t * application_proxy_listener(application_t *app, u8 fib_proto, u8 transport_proto)
Definition: application.c:649
static u8 session_handle_is_local(session_handle_t handle)
Definition: session.h:353
struct _unformat_input_t unformat_input_t
unsigned short u16
Definition: types.h:57
static application_t * app_pool
Pool from which we allocate all applications.
Definition: application.c:24
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:274
#define APP_INVALID_INDEX
Definition: application.h:135
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:373
svm_fifo_segment_private_t * segment_manager_get_segment(segment_manager_t *sm, u32 segment_index)
Reads a segment from the segment manager&#39;s pool without lock.
u8 segment_manager_has_fifos(segment_manager_t *sm)
stream_session_t * application_first_listener(application_t *app, u8 fib_proto, u8 transport_proto)
Definition: application.c:625
u32 svm_segment_index
Segment index where fifos were allocated.
static u8 application_local_session_listener_has_transport(local_session_t *ls)
Definition: application.h:258
app_namespace_t * app_namespace_get(u32 index)
u32 application_session_table(application_t *app, u8 fib_proto)
Definition: application.c:60
void segment_manager_del_segment(segment_manager_t *sm, svm_fifo_segment_private_t *fs)
Remove segment without lock.
u8 * application_name_from_index(u32 app_index)
Returns app name.
Definition: application.c:109
int segment_manager_add_segment(segment_manager_t *sm, u32 segment_size)
Adds segment to segment manager&#39;s pool.
volatile u8 session_state
State.
static stream_session_t * session_get(u32 si, u32 thread_index)
Definition: session.h:290
local_session_t * application_get_local_session(application_t *app, u32 session_index)
Definition: application.c:831
#define SEGMENT_MANAGER_INVALID_APP_INDEX
An API client registration, only in vpp/vlib.
Definition: api_common.h:44
u32 application_local_session_table(application_t *app)
Definition: application.c:75
#define UNFORMAT_END_OF_INPUT
Definition: format.h:144
static session_type_t session_type_from_proto_and_ip(transport_proto_t proto, u8 is_ip4)
Definition: session.h:386
vlib_main_t * vm
Definition: buffer.c:294
static transport_proto_t session_type_transport_proto(session_type_t st)
Definition: session.h:361
svm_queue_t * vl_api_client_index_to_input_queue(u32 index)
Definition: memory_api.c:754
u8 * format_stream_session(u8 *s, va_list *args)
Format stream session as per the following format.
Definition: session_cli.c:55
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:339
segment_manager_t * application_get_connect_segment_manager(application_t *app)
Definition: application.c:543
int session_lookup_del_session_endpoint(u32 table_index, session_endpoint_t *sep)
#define clib_warning(format, args...)
Definition: error.h:59
#define SESSION_INVALID_HANDLE
Definition: session_table.h:59
u16 port
Port for connection.
int application_start_listen(application_t *srv, session_endpoint_t *sep, session_handle_t *res)
Start listening local transport endpoint for requested transport.
Definition: application.c:436
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:271
struct _application application_t
const u8 * app_namespace_id_from_index(u32 index)
static uword * app_by_api_client_index
Hash table of apps by api client index.
Definition: application.c:29
static vl_api_registration_t * vl_api_client_index_to_registration(u32 index)
Definition: api.h:56
int session_lookup_add_session_endpoint(u32 table_index, session_endpoint_t *sep, u64 value)
static u32 vl_api_registration_file_index(vl_api_registration_t *reg)
Definition: api.h:65
static u8 session_has_transport(stream_session_t *s)
Definition: session.h:392
int application_local_session_disconnect_w_index(u32 app_index, u32 ls_index)
Definition: application.c:1162
int segment_manager_try_alloc_fifos(svm_fifo_segment_private_t *fifo_segment, u32 rx_fifo_size, u32 tx_fifo_size, svm_fifo_t **rx_fifo, svm_fifo_t **tx_fifo)
struct _app_namespace app_namespace_t
static u32 segment_manager_index(segment_manager_t *sm)
static segment_manager_t * application_alloc_segment_manager(application_t *app)
Definition: application.c:409
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:154
#define hash_create(elts, value_bytes)
Definition: hash.h:696
ssvm_private_t * session_manager_get_evt_q_segment(void)
Definition: session.c:1245
void segment_manager_init_del(segment_manager_t *sm)
#define pool_put_index(p, i)
Free pool element with given index.
Definition: pool.h:299
static uword hash_elts(void *v)
Definition: hash.h:118
#define ASSERT(truth)
static void application_client_local_connect_key_parse(uword key, u32 *app_index, u32 *session_index)
Definition: application.c:1040
static uword * app_by_name
Hash table of builtin apps by name.
Definition: application.c:34
u8 session_type_t
int application_stop_local_listen(application_t *server, session_handle_t lh)
Clean up local session table.
Definition: application.c:895
void application_remove_proxy(application_t *app)
Definition: application.c:782
struct _vnet_application_add_tls_key_args_t vnet_app_add_tls_key_args_t
int listen_session_get_local_session_endpoint(stream_session_t *listener, session_endpoint_t *sep)
Definition: session.c:1318
void application_del(application_t *app)
Definition: application.c:173
u32 application_get_index(application_t *app)
Definition: application.c:403
int application_local_session_disconnect(u32 app_index, local_session_t *ls)
Definition: application.c:1121
void application_format_all_listeners(vlib_main_t *vm, int do_local, int verbose)
Definition: application.c:1465
int stream_session_stop_listen(stream_session_t *s)
Ask transport to stop listening on local transport endpoint.
Definition: session.c:1061
static uword pointer_to_uword(const void *p)
Definition: types.h:131
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:23
u8 ip_is_zero(ip46_address_t *ip46_address, u8 is_ip4)
Definition: ip.c:20
void segment_manager_del(segment_manager_t *sm)
Removes segment manager.
void send_local_session_disconnect_callback(u32 app_index, local_session_t *ls)
Definition: session_api.c:232
u8 * format_application_listener(u8 *s, va_list *args)
Definition: application.c:1257
enum _transport_proto transport_proto_t
transport_connection_t * listen_session_get_transport(stream_session_t *s)
Definition: session.c:1311
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u8 * format_application(u8 *s, va_list *args)
Definition: application.c:1428
static stream_session_t * listen_session_new(u8 thread_index, session_type_t type)
Definition: session.h:582
application_t * application_get(u32 index)
Definition: application.c:386
u64 uword
Definition: types.h:112
u32 session_index
Session index.
void segment_manager_del_sessions(segment_manager_t *sm)
Initiate disconnects for all sessions &#39;owned&#39; by a segment manager.
struct _segment_manager segment_manager_t
struct _svm_queue svm_queue_t
static clib_error_t * application_start_stop_proxy_fib_proto(application_t *app, u8 fib_proto, u8 transport_proto, u8 is_start)
Definition: application.c:673
#define hash_get_mem(h, key)
Definition: hash.h:269
int application_init(application_t *app, u32 api_client_index, u8 *app_name, u64 *options, session_cb_vft_t *cb_fns)
Definition: application.c:291
static uword application_client_local_connect_key(local_session_t *ls)
Definition: application.c:1034
static void application_start_stop_proxy_local_scope(application_t *app, u8 transport_proto, u8 is_start)
Definition: application.c:723
#define clib_error_return_code(e, code, flags, args...)
Definition: error.h:93
int application_alloc_connects_segment_manager(application_t *app)
Definition: application.c:528
void application_setup_proxy(application_t *app)
Definition: application.c:766
static u8 application_verify_cfg(ssvm_segment_type_t st)
Check app config for given segment type.
Definition: application.c:269
int application_is_builtin_proxy(application_t *app)
Definition: application.c:591
int application_local_session_cleanup(application_t *client, application_t *server, local_session_t *ls)
Definition: application.c:1084
void application_start_stop_proxy(application_t *app, transport_proto_t transport_proto, u8 is_start)
Definition: application.c:750
int application_api_queue_is_full(application_t *app)
Definition: application.c:85
segment_manager_properties_t * application_segment_manager_properties(application_t *app)
Definition: application.c:798
static void application_local_listener_session_endpoint(local_session_t *ll, session_endpoint_t *sep)
Definition: application.c:847
#define APP_INVALID_SEGMENT_MANAGER_INDEX
Definition: application.h:137
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:681
static svm_queue_t * segment_manager_event_queue(segment_manager_t *sm)
segment_manager_t * application_get_local_segment_manager(application_t *app)
Definition: application.c:560
static segment_manager_t * segment_manager_get(u32 index)
static u64 listen_session_get_handle(stream_session_t *s)
Definition: session.h:562
application_t * application_get_if_valid(u32 index)
Definition: application.c:394
void application_format_connects(application_t *app, int verbose)
Definition: application.c:1294
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:972
void application_format_all_clients(vlib_main_t *vm, int do_local, int verbose)
Definition: application.c:1508
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:170
int application_local_session_connect(u32 table_index, application_t *client, application_t *server, local_session_t *ll, u32 opaque)
Definition: application.c:942
int stream_session_listen(stream_session_t *s, session_endpoint_t *sep)
Ask transport to listen on local transport endpoint.
Definition: session.c:1049
u8 application_has_local_scope(application_t *app)
Definition: application.c:607
u32 app_index
Server index.
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:128