FD.io VPP  v21.06-1-gbb7418cf9
Vector Packet Processing
application.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017-2019 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 
20 #include <vnet/session/session.h>
21 
23 
24 #define app_interface_check_thread_and_barrier(_fn, _arg) \
25  if (PREDICT_FALSE (!vlib_thread_is_main_w_barrier ())) \
26  { \
27  vlib_rpc_call_main_thread (_fn, (u8 *) _arg, sizeof(*_arg)); \
28  return 0; \
29  }
30 
31 static app_listener_t *
33 {
34  app_listener_t *app_listener;
35  pool_get (app->listeners, app_listener);
36  clib_memset (app_listener, 0, sizeof (*app_listener));
37  app_listener->al_index = app_listener - app->listeners;
38  app_listener->app_index = app->app_index;
39  app_listener->session_index = SESSION_INVALID_INDEX;
40  app_listener->local_index = SESSION_INVALID_INDEX;
41  app_listener->ls_handle = SESSION_INVALID_HANDLE;
42  return app_listener;
43 }
44 
46 app_listener_get (application_t * app, u32 app_listener_index)
47 {
48  return pool_elt_at_index (app->listeners, app_listener_index);
49 }
50 
51 static void
53 {
54  clib_bitmap_free (app_listener->workers);
55  if (CLIB_DEBUG)
56  clib_memset (app_listener, 0xfa, sizeof (*app_listener));
57  pool_put (app->listeners, app_listener);
58 }
59 
62 {
63  return al->ls_handle;
64 }
65 
68 {
69  application_t *app;
70 
72  if (!app)
73  return 0;
74  return app_listener_get (app, ls->al_index);
75 }
76 
79 {
80  app_listener_t *al;
82  if (!al)
83  return listen_session_get_handle (ls);
84  return al->ls_handle;
85 }
86 
89 {
90  session_t *ls;
92  if (!ls)
93  return 0;
94  return app_listener_get_w_session (ls);
95 }
96 
99 {
100  u32 table_index, fib_proto;
101  session_endpoint_t *sep;
102  session_handle_t handle;
103  session_t *ls;
104  void *iface_ip;
105  ip46_address_t original_ip;
106 
107  sep = (session_endpoint_t *) sep_ext;
109  {
110  table_index = application_local_session_table (app);
111  handle = session_lookup_endpoint_listener (table_index, sep, 1);
112  if (handle != SESSION_INVALID_HANDLE)
113  {
114  ls = listen_session_get_from_handle (handle);
115  return app_listener_get_w_session (ls);
116  }
117  }
118 
119  fib_proto = session_endpoint_fib_proto (sep);
120  table_index = session_lookup_get_index_for_fib (fib_proto, sep->fib_index);
121  handle = session_lookup_endpoint_listener (table_index, sep, 1);
122  if (handle != SESSION_INVALID_HANDLE)
123  {
124  ls = listen_session_get_from_handle (handle);
125  return app_listener_get_w_session ((session_t *) ls);
126  }
127 
128  /*
129  * When binds to "inaddr_any", we add zero address in the local lookup table
130  * and interface address in the global lookup table. If local scope disable,
131  * the latter is the only clue to find the listener.
132  */
133  if (!application_has_local_scope (app) &&
134  ip_is_zero (&sep_ext->ip, sep_ext->is_ip4) &&
135  sep_ext->sw_if_index != ENDPOINT_INVALID_INDEX)
136  {
137  if ((iface_ip = ip_interface_get_first_ip (sep_ext->sw_if_index,
138  sep_ext->is_ip4)))
139  {
140  ip_copy (&original_ip, &sep_ext->ip, sep_ext->is_ip4);
141  ip_set (&sep_ext->ip, iface_ip, sep_ext->is_ip4);
142  handle = session_lookup_endpoint_listener (table_index, sep, 1);
143  ip_copy (&sep_ext->ip, &original_ip, sep_ext->is_ip4);
144  if (handle != SESSION_INVALID_HANDLE)
145  {
146  ls = listen_session_get_from_handle (handle);
147  return app_listener_get_w_session ((session_t *) ls);
148  }
149  }
150  }
151 
152  return 0;
153 }
154 
155 int
159 {
160  app_listener_t *app_listener;
162  u32 al_index, table_index;
163  session_handle_t lh;
164  session_type_t st;
165  session_t *ls = 0;
166  int rv;
167 
168  app_listener = app_listener_alloc (app);
169  al_index = app_listener->al_index;
170  st = session_type_from_proto_and_ip (sep->transport_proto, sep->is_ip4);
171 
172  /*
173  * Add session endpoint to local session table. Only binds to "inaddr_any"
174  * (i.e., zero address) are added to local scope table.
175  */
178  {
179  session_type_t local_st;
180 
181  local_st = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE,
182  sep->is_ip4);
183  ls = listen_session_alloc (0, local_st);
184  ls->app_index = app->app_index;
185  ls->app_wrk_index = sep->app_wrk_index;
186  lh = session_handle (ls);
187 
188  if ((rv = session_listen (ls, sep)))
189  {
190  ls = session_get_from_handle (lh);
191  session_free (ls);
192  return rv;
193  }
194 
195  ls = session_get_from_handle (lh);
196  app_listener = app_listener_get (app, al_index);
197  app_listener->local_index = ls->session_index;
198  app_listener->ls_handle = lh;
199  ls->al_index = al_index;
200 
201  table_index = application_local_session_table (app);
203  (session_endpoint_t *) sep, lh);
204  }
205 
207  {
208  /*
209  * Start listening on local endpoint for requested transport and scope.
210  * Creates a stream session with state LISTENING to be used in session
211  * lookups, prior to establishing connection. Requests transport to
212  * build it's own specific listening connection.
213  */
214  ls = listen_session_alloc (0, st);
215  ls->app_index = app->app_index;
216  ls->app_wrk_index = sep->app_wrk_index;
217 
218  /* Listen pool can be reallocated if the transport is
219  * recursive (tls) */
220  lh = listen_session_get_handle (ls);
221 
222  if ((rv = session_listen (ls, sep)))
223  {
225  session_free (ls);
226  return rv;
227  }
229  app_listener = app_listener_get (app, al_index);
230  app_listener->session_index = ls->session_index;
231  app_listener->ls_handle = lh;
232  ls->al_index = al_index;
233 
234  /* Add to the global lookup table after transport was initialized.
235  * Lookup table needs to be populated only now because sessions
236  * with cut-through transport are are added to app local tables that
237  * are not related to network fibs, i.e., cannot be added as
238  * connections */
239  tc = session_get_transport (ls);
240  if (!(tc->flags & TRANSPORT_CONNECTION_F_NO_LOOKUP))
241  {
242  fib_protocol_t fib_proto;
243  fib_proto = session_endpoint_fib_proto ((session_endpoint_t *) sep);
244  table_index = session_lookup_get_index_for_fib (fib_proto,
245  sep->fib_index);
246  ASSERT (table_index != SESSION_TABLE_INVALID_INDEX);
248  (session_endpoint_t *) sep,
249  lh);
250  }
251  }
252 
253  if (!ls)
254  {
255  app_listener_free (app, app_listener);
256  return -1;
257  }
258 
259  *listener = app_listener;
260  return 0;
261 }
262 
263 void
265 {
267  session_t *ls;
268 
270  {
271  ls = session_get (al->session_index, 0);
272  session_stop_listen (ls);
273  listen_session_free (ls);
274  }
276  {
278  u32 table_index;
279 
280  table_index = application_local_session_table (app);
281  ls = listen_session_get (al->local_index);
282  ct_session_endpoint (ls, &sep);
283  session_lookup_del_session_endpoint (table_index, &sep);
284  session_stop_listen (ls);
285  listen_session_free (ls);
286  }
287  app_listener_free (app, al);
288 }
289 
290 static app_worker_t *
292 {
293  u32 wrk_index;
294 
295  app = application_get (al->app_index);
296  wrk_index = clib_bitmap_next_set (al->workers, al->accept_rotor + 1);
297  if (wrk_index == ~0)
298  wrk_index = clib_bitmap_first_set (al->workers);
299 
300  ASSERT (wrk_index != ~0);
301  al->accept_rotor = wrk_index;
302  return application_get_worker (app, wrk_index);
303 }
304 
305 session_t *
307 {
309  return 0;
310 
311  return listen_session_get (al->session_index);
312 }
313 
314 session_t *
316 {
318  return 0;
319  return listen_session_get (al->local_index);
320 }
321 
322 static app_worker_map_t *
324 {
326  pool_get (app->worker_maps, map);
327  clib_memset (map, 0, sizeof (*map));
328  return map;
329 }
330 
331 static u32
333 {
334  return (map - app->worker_maps);
335 }
336 
337 static void
339 {
340  pool_put (app->worker_maps, map);
341 }
342 
343 static app_worker_map_t *
345 {
346  if (pool_is_free_index (app->worker_maps, map_index))
347  return 0;
348  return pool_elt_at_index (app->worker_maps, map_index);
349 }
350 
351 static const u8 *
353 {
354  return app->name;
355 }
356 
357 u32
359 {
360  app_namespace_t *app_ns;
361  app_ns = app_namespace_get (app->ns_index);
362  if (!application_has_global_scope (app))
363  return APP_INVALID_INDEX;
364  if (fib_proto == FIB_PROTOCOL_IP4)
365  return session_lookup_get_index_for_fib (fib_proto,
366  app_ns->ip4_fib_index);
367  else
368  return session_lookup_get_index_for_fib (fib_proto,
369  app_ns->ip6_fib_index);
370 }
371 
372 u32
374 {
375  app_namespace_t *app_ns;
376  if (!application_has_local_scope (app))
377  return APP_INVALID_INDEX;
378  app_ns = app_namespace_get (app->ns_index);
379  return app_ns->local_table_index;
380 }
381 
382 /**
383  * Returns app name for app-index
384  */
385 const u8 *
387 {
388  application_t *app = application_get (app_index);
389  if (!app)
390  return 0;
391  return app_get_name (app);
392 }
393 
394 static void
395 application_api_table_add (u32 app_index, u32 api_client_index)
396 {
397  if (api_client_index != APP_INVALID_INDEX)
398  hash_set (app_main.app_by_api_client_index, api_client_index, app_index);
399 }
400 
401 static void
402 application_api_table_del (u32 api_client_index)
403 {
404  hash_unset (app_main.app_by_api_client_index, api_client_index);
405 }
406 
407 static void
409 {
410  hash_set_mem (app_main.app_by_name, app->name, app->app_index);
411 }
412 
413 static void
415 {
416  hash_unset_mem (app_main.app_by_name, app->name);
417 }
418 
420 application_lookup (u32 api_client_index)
421 {
422  uword *p;
423  p = hash_get (app_main.app_by_api_client_index, api_client_index);
424  if (p)
425  return application_get_if_valid (p[0]);
426 
427  return 0;
428 }
429 
432 {
433  uword *p;
434  p = hash_get_mem (app_main.app_by_name, name);
435  if (p)
436  return application_get (p[0]);
437 
438  return 0;
439 }
440 
441 void
443 {
444  app_rx_mq_elt_t *head;
445 
446  if (!aw->pending_rx_mqs)
447  {
448  elt->next = elt->prev = elt;
449  aw->pending_rx_mqs = elt;
450  return;
451  }
452 
453  head = aw->pending_rx_mqs;
454 
455  ASSERT (head != elt);
456 
457  elt->prev = head->prev;
458  elt->next = head;
459 
460  head->prev->next = elt;
461  head->prev = elt;
462 }
463 
464 void
466 {
467  if (elt->next == elt)
468  {
469  elt->next = elt->prev = 0;
470  aw->pending_rx_mqs = 0;
471  return;
472  }
473 
474  if (elt == aw->pending_rx_mqs)
475  aw->pending_rx_mqs = elt->next;
476 
477  elt->next->prev = elt->prev;
478  elt->prev->next = elt->next;
479  elt->next = elt->prev = 0;
480 }
481 
483 
484 VLIB_NODE_FN (appsl_rx_mqs_input_node)
486 {
487  u32 thread_index = vm->thread_index, n_msgs = 0;
491  int __clib_unused rv;
494 
495  aw = &am->wrk[thread_index];
496  elt = aw->pending_rx_mqs;
497  if (!elt)
498  return 0;
499 
500  wrk = session_main_get_worker (thread_index);
501 
502  do
503  {
504  if (!(elt->flags & APP_RX_MQ_F_POSTPONED))
505  rv = read (svm_msg_q_get_eventfd (elt->mq), &buf, sizeof (buf));
507 
508  next = elt->next;
509  appsl_pending_rx_mqs_del (aw, elt);
510  if (!svm_msg_q_is_empty (elt->mq))
511  {
514  }
515  else
516  {
517  elt->flags = 0;
518  }
519  elt = next;
520  }
521  while (aw->pending_rx_mqs && elt != aw->pending_rx_mqs);
522 
523  if (aw->pending_rx_mqs)
524  vlib_node_set_interrupt_pending (vm, appsl_rx_mqs_input_node.index);
525 
526  if (n_msgs && wrk->state == SESSION_WRK_INTERRUPT)
528 
529  return n_msgs;
530 }
531 
532 VLIB_REGISTER_NODE (appsl_rx_mqs_input_node) = {
533  .name = "appsl-rx-mqs-input",
534  .type = VLIB_NODE_TYPE_INPUT,
535  .state = VLIB_NODE_STATE_DISABLED,
536 };
537 
538 static clib_error_t *
540 {
542  vlib_main_t *vm = vlib_get_main ();
543  app_main_t *am = &app_main;
544  app_rx_mq_elt_t *mqe;
545  application_t *app;
546  appsl_wrk_t *aw;
547 
548  ASSERT (vlib_get_thread_index () == handle->thread_index);
549  app = application_get_if_valid (handle->app_index);
550  if (!app)
551  return 0;
552 
553  mqe = &app->rx_mqs[handle->thread_index];
554  if ((mqe->flags & APP_RX_MQ_F_PENDING) || svm_msg_q_is_empty (mqe->mq))
555  return 0;
556 
557  aw = &am->wrk[handle->thread_index];
559  mqe->flags |= APP_RX_MQ_F_PENDING;
560 
561  vlib_node_set_interrupt_pending (vm, appsl_rx_mqs_input_node.index);
562 
563  return 0;
564 }
565 
566 static clib_error_t *
568 {
569  clib_warning ("should not be called");
570  return 0;
571 }
572 
573 static void
575 {
576  clib_file_t template = { 0 };
577  app_rx_mq_handle_t handle;
579  int fd;
580 
581  thread_index = mqe - app->rx_mqs;
582  fd = svm_msg_q_get_eventfd (mqe->mq);
583 
584  handle.app_index = app->app_index;
585  handle.thread_index = thread_index;
586 
587  template.read_function = app_rx_mq_fd_read_ready;
588  template.write_function = app_rx_mq_fd_write_ready;
589  template.file_descriptor = fd;
590  template.private_data = handle.as_u64;
591  template.polling_thread_index = thread_index;
592  template.description =
593  format (0, "app-%u-rx-mq-%u", app->app_index, thread_index);
594  mqe->file_index = clib_file_add (&file_main, &template);
595 }
596 
597 static void
599 {
600  u32 thread_index = mqe - app->rx_mqs;
601  app_main_t *am = &app_main;
602  appsl_wrk_t *aw;
603 
604  aw = &am->wrk[thread_index];
605 
606  session_wrk_handle_mq (session_main_get_worker (thread_index), mqe->mq);
607 
608  if (mqe->flags & APP_RX_MQ_F_PENDING)
609  appsl_pending_rx_mqs_del (aw, mqe);
610 
612 }
613 
614 svm_msg_q_t *
616 {
617  if (!app->rx_mqs)
618  return 0;
619 
620  return app->rx_mqs[mq_index].mq;
621 }
622 
623 static int
625 {
626  u32 evt_q_length, evt_size = sizeof (session_event_t);
627  fifo_segment_t *eqs = &app->rx_mqs_segment;
628  u32 n_mqs = vlib_num_workers () + 1;
630  int i;
631 
633  evt_q_length = clib_max (props->evt_q_size, 128);
634 
635  svm_msg_q_cfg_t _cfg, *cfg = &_cfg;
637  { evt_q_length, evt_size, 0 }, { evt_q_length >> 1, 256, 0 }
638  };
639  cfg->consumer_pid = 0;
640  cfg->n_rings = 2;
641  cfg->q_nitems = evt_q_length;
642  cfg->ring_cfgs = rc;
643 
644  eqs->ssvm.ssvm_size = svm_msg_q_size_to_alloc (cfg) * n_mqs + (1 << 20);
645  eqs->ssvm.name = format (0, "%s-rx-mqs-seg%c", app->name, 0);
646 
648  {
649  clib_warning ("failed to initialize queue segment");
650  return SESSION_E_SEG_CREATE;
651  }
652 
653  fifo_segment_init (eqs);
654 
655  /* Fifo segment filled only with mqs */
656  eqs->h->n_mqs = n_mqs;
657  vec_validate (app->rx_mqs, n_mqs - 1);
658 
659  for (i = 0; i < n_mqs; i++)
660  {
661  app->rx_mqs[i].mq = fifo_segment_msg_q_alloc (eqs, i, cfg);
662  if (svm_msg_q_alloc_eventfd (app->rx_mqs[i].mq))
663  {
664  clib_warning ("eventfd returned");
665  fifo_segment_cleanup (eqs);
666  ssvm_delete (&eqs->ssvm);
667  return SESSION_E_EVENTFD_ALLOC;
668  }
669  app_rx_mqs_epoll_add (app, &app->rx_mqs[i]);
670  app->rx_mqs[i].app_index = app->app_index;
671  }
672 
673  return 0;
674 }
675 
676 u8
678 {
680 }
681 
684 {
686  return &app->rx_mqs_segment;
688 }
689 
690 void
692 {
693  u8 state = is_en ? VLIB_NODE_STATE_INTERRUPT : VLIB_NODE_STATE_DISABLED;
694 
696  vlib_node_set_state (this_vlib_main, appsl_rx_mqs_input_node.index, state);
697 }
698 
699 static application_t *
701 {
702  application_t *app;
703  pool_get (app_main.app_pool, app);
704  clib_memset (app, 0, sizeof (*app));
705  app->app_index = app - app_main.app_pool;
706  return app;
707 }
708 
710 application_get (u32 app_index)
711 {
712  if (app_index == APP_INVALID_INDEX)
713  return 0;
714  return pool_elt_at_index (app_main.app_pool, app_index);
715 }
716 
719 {
720  if (pool_is_free_index (app_main.app_pool, app_index))
721  return 0;
722 
723  return pool_elt_at_index (app_main.app_pool, app_index);
724 }
725 
726 static void
728 {
729  if (cb_fns->session_accept_callback == 0)
730  clib_warning ("No accept callback function provided");
731  if (cb_fns->session_connected_callback == 0)
732  clib_warning ("No session connected callback function provided");
733  if (cb_fns->session_disconnect_callback == 0)
734  clib_warning ("No session disconnect callback function provided");
735  if (cb_fns->session_reset_callback == 0)
736  clib_warning ("No session reset callback function provided");
737 }
738 
739 /**
740  * Check app config for given segment type
741  *
742  * Returns 1 on success and 0 otherwise
743  */
744 static u8
746 {
747  u8 is_valid;
748  if (st == SSVM_SEGMENT_MEMFD)
749  {
750  is_valid = (session_main_get_evt_q_segment () != 0);
751  if (!is_valid)
752  clib_warning ("memfd seg: vpp's event qs IN binary api svm region");
753  return is_valid;
754  }
755  else if (st == SSVM_SEGMENT_SHM)
756  {
757  is_valid = (session_main_get_evt_q_segment () == 0);
758  if (!is_valid)
759  clib_warning ("shm seg: vpp's event qs NOT IN binary api svm region");
760  return is_valid;
761  }
762  else
763  return 1;
764 }
765 
766 static int
768 {
771  application_t *app;
772  u64 *options;
773 
774  app = application_alloc ();
775  options = a->options;
776  /*
777  * Make sure we support the requested configuration
778  */
779  if (options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_IS_BUILTIN)
780  seg_type = SSVM_SEGMENT_PRIVATE;
781 
782  if ((options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
783  && seg_type != SSVM_SEGMENT_MEMFD)
784  {
785  clib_warning ("mq eventfds can only be used if socket transport is "
786  "used for binary api");
787  return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
788  }
789 
790  if (!application_verify_cfg (seg_type))
791  return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
792 
794  && options[APP_OPTIONS_PREALLOC_FIFO_HDRS])
795  return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
796 
797  /* Check that the obvious things are properly set up */
798  application_verify_cb_fns (a->session_cb_vft);
799 
800  app->flags = options[APP_OPTIONS_FLAGS];
801  app->cb_fns = *a->session_cb_vft;
802  app->ns_index = options[APP_OPTIONS_NAMESPACE];
804  app->name = vec_dup (a->name);
805 
806  /* If no scope enabled, default to global */
808  && !application_has_local_scope (app))
809  app->flags |= APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
810 
813  props->segment_size = options[APP_OPTIONS_SEGMENT_SIZE];
814  props->prealloc_fifos = options[APP_OPTIONS_PREALLOC_FIFO_PAIRS];
815  props->prealloc_fifo_hdrs = options[APP_OPTIONS_PREALLOC_FIFO_HDRS];
816  if (options[APP_OPTIONS_ADD_SEGMENT_SIZE])
817  {
818  props->add_segment_size = options[APP_OPTIONS_ADD_SEGMENT_SIZE];
819  props->add_segment = 1;
820  }
821  if (options[APP_OPTIONS_RX_FIFO_SIZE])
822  props->rx_fifo_size = options[APP_OPTIONS_RX_FIFO_SIZE];
823  if (options[APP_OPTIONS_TX_FIFO_SIZE])
824  props->tx_fifo_size = options[APP_OPTIONS_TX_FIFO_SIZE];
825  if (options[APP_OPTIONS_EVT_QUEUE_SIZE])
826  props->evt_q_size = options[APP_OPTIONS_EVT_QUEUE_SIZE];
827  if (options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
828  props->use_mq_eventfd = 1;
829  if (options[APP_OPTIONS_TLS_ENGINE])
830  app->tls_engine = options[APP_OPTIONS_TLS_ENGINE];
831  if (options[APP_OPTIONS_MAX_FIFO_SIZE])
832  props->max_fifo_size = options[APP_OPTIONS_MAX_FIFO_SIZE];
833  if (options[APP_OPTIONS_HIGH_WATERMARK])
834  props->high_watermark = options[APP_OPTIONS_HIGH_WATERMARK];
835  if (options[APP_OPTIONS_LOW_WATERMARK])
836  props->low_watermark = options[APP_OPTIONS_LOW_WATERMARK];
837  if (options[APP_OPTIONS_PCT_FIRST_ALLOC])
838  props->pct_first_alloc = options[APP_OPTIONS_PCT_FIRST_ALLOC];
839  props->segment_type = seg_type;
840 
841  /* Add app to lookup by api_client_index table */
842  if (!application_is_builtin (app))
843  application_api_table_add (app->app_index, a->api_client_index);
844  else
846 
847  a->app_index = app->app_index;
848 
849  APP_DBG ("New app name: %v api index: %u index %u", app->name,
850  a->api_client_index, app->app_index);
851 
852  return 0;
853 }
854 
855 static void
857 {
858  app_worker_map_t *wrk_map;
859  app_worker_t *app_wrk;
860 
861  /*
862  * The app event queue allocated in first segment is cleared with
863  * the segment manager. No need to explicitly free it.
864  */
865  APP_DBG ("Delete app name %v index: %d", app->name, app->app_index);
866 
867  if (application_is_proxy (app))
869 
870  /*
871  * Free workers
872  */
873 
874  /* *INDENT-OFF* */
875  pool_flush (wrk_map, app->worker_maps, ({
876  app_wrk = app_worker_get (wrk_map->wrk_index);
877  app_worker_free (app_wrk);
878  }));
879  /* *INDENT-ON* */
880  pool_free (app->worker_maps);
881 
882  /*
883  * Free rx mqs if allocated
884  */
885  if (app->rx_mqs)
886  {
887  int i;
888  for (i = 0; i < vec_len (app->rx_mqs); i++)
889  app_rx_mqs_epoll_del (app, &app->rx_mqs[i]);
890 
893  vec_free (app->rx_mqs);
894  }
895 
896  /*
897  * Cleanup remaining state
898  */
899  if (application_is_builtin (app))
901  vec_free (app->name);
902  pool_put (app_main.app_pool, app);
903 }
904 
905 static void
907 {
908  vnet_app_worker_add_del_args_t _args = { 0 }, *args = &_args;
909  app_worker_map_t *wrk_map;
910  u32 *wrks = 0, *wrk_index;
911  app_worker_t *app_wrk;
912 
913  if (api_client_index == ~0)
914  {
915  application_free (app);
916  return;
917  }
918 
919  APP_DBG ("Detaching for app %v index %u api client index %u", app->name,
920  app->app_index, api_client_index);
921 
922  /* *INDENT-OFF* */
923  pool_foreach (wrk_map, app->worker_maps) {
924  app_wrk = app_worker_get (wrk_map->wrk_index);
925  if (app_wrk->api_client_index == api_client_index)
926  vec_add1 (wrks, app_wrk->wrk_index);
927  }
928  /* *INDENT-ON* */
929 
930  if (!vec_len (wrks))
931  {
932  clib_warning ("no workers for app %u api_index %u", app->app_index,
933  api_client_index);
934  return;
935  }
936 
937  args->app_index = app->app_index;
938  args->api_client_index = api_client_index;
939  vec_foreach (wrk_index, wrks)
940  {
941  app_wrk = app_worker_get (wrk_index[0]);
942  args->wrk_map_index = app_wrk->wrk_map_index;
943  args->is_add = 0;
945  }
946  vec_free (wrks);
947 }
948 
949 app_worker_t *
951 {
953  map = app_worker_map_get (app, wrk_map_index);
954  if (!map)
955  return 0;
956  return app_worker_get (map->wrk_index);
957 }
958 
959 app_worker_t *
961 {
962  return application_get_worker (app, 0);
963 }
964 
965 u32
967 {
968  return pool_elts (app->worker_maps);
969 }
970 
971 app_worker_t *
973 {
974  application_t *app;
975  app_listener_t *al;
976 
977  app = application_get (ls->app_index);
978  al = app_listener_get (app, ls->al_index);
979  return app_listener_select_worker (app, al);
980 }
981 
982 int
984 {
985  app_worker_map_t *wrk_map;
986  app_worker_t *app_wrk;
987  segment_manager_t *sm;
988  int rv;
989 
990  app_wrk = app_worker_alloc (app);
991  wrk_map = app_worker_map_alloc (app);
992  wrk_map->wrk_index = app_wrk->wrk_index;
993  app_wrk->wrk_map_index = app_worker_map_index (app, wrk_map);
994 
995  /*
996  * Setup first segment manager
997  */
998  sm = segment_manager_alloc ();
999  sm->app_wrk_index = app_wrk->wrk_index;
1000 
1001  if ((rv = segment_manager_init_first (sm)))
1002  {
1003  app_worker_free (app_wrk);
1004  return rv;
1005  }
1006  sm->first_is_protected = 1;
1007 
1008  /*
1009  * Setup app worker
1010  */
1012  app_wrk->listeners_table = hash_create (0, sizeof (u64));
1013  app_wrk->event_queue = segment_manager_event_queue (sm);
1014  app_wrk->app_is_builtin = application_is_builtin (app);
1015 
1016  *wrk = app_wrk;
1017 
1018  return 0;
1019 }
1020 
1021 int
1023 {
1024  fifo_segment_t *fs;
1025  app_worker_map_t *wrk_map;
1026  app_worker_t *app_wrk;
1027  segment_manager_t *sm;
1028  application_t *app;
1029  int rv;
1030 
1031  app = application_get (a->app_index);
1032  if (!app)
1033  return VNET_API_ERROR_INVALID_VALUE;
1034 
1035  if (a->is_add)
1036  {
1037  if ((rv = application_alloc_worker_and_init (app, &app_wrk)))
1038  return rv;
1039 
1040  /* Map worker api index to the app */
1041  app_wrk->api_client_index = a->api_client_index;
1042  application_api_table_add (app->app_index, a->api_client_index);
1043 
1044  sm = segment_manager_get (app_wrk->connects_seg_manager);
1046  a->segment = &fs->ssvm;
1047  a->segment_handle = segment_manager_segment_handle (sm, fs);
1049  a->evt_q = app_wrk->event_queue;
1050  a->wrk_map_index = app_wrk->wrk_map_index;
1051  }
1052  else
1053  {
1054  wrk_map = app_worker_map_get (app, a->wrk_map_index);
1055  if (!wrk_map)
1056  return VNET_API_ERROR_INVALID_VALUE;
1057 
1058  app_wrk = app_worker_get (wrk_map->wrk_index);
1059  if (!app_wrk)
1060  return VNET_API_ERROR_INVALID_VALUE;
1061 
1063  app_worker_free (app_wrk);
1064  app_worker_map_free (app, wrk_map);
1065  if (application_n_workers (app) == 0)
1066  application_free (app);
1067  }
1068  return 0;
1069 }
1070 
1071 static int
1072 app_validate_namespace (u8 * namespace_id, u64 secret, u32 * app_ns_index)
1073 {
1074  app_namespace_t *app_ns;
1075  if (vec_len (namespace_id) == 0)
1076  {
1077  /* Use default namespace */
1078  *app_ns_index = 0;
1079  return 0;
1080  }
1081 
1082  *app_ns_index = app_namespace_index_from_id (namespace_id);
1083  if (*app_ns_index == APP_NAMESPACE_INVALID_INDEX)
1084  return VNET_API_ERROR_APP_INVALID_NS;
1085  app_ns = app_namespace_get (*app_ns_index);
1086  if (!app_ns)
1087  return VNET_API_ERROR_APP_INVALID_NS;
1088  if (app_ns->ns_secret != secret)
1089  return VNET_API_ERROR_APP_WRONG_NS_SECRET;
1090  return 0;
1091 }
1092 
1093 static u8 *
1094 app_name_from_api_index (u32 api_client_index)
1095 {
1096  vl_api_registration_t *regp;
1097  regp = vl_api_client_index_to_registration (api_client_index);
1098  if (regp)
1099  return format (0, "%s", regp->name);
1100 
1101  clib_warning ("api client index %u does not have an api registration!",
1102  api_client_index);
1103  return format (0, "unknown");
1104 }
1105 
1106 /**
1107  * Attach application to vpp
1108  *
1109  * Allocates a vpp app, i.e., a structure that keeps back pointers
1110  * to external app and a segment manager for shared memory fifo based
1111  * communication with the external app.
1112  */
1113 int
1115 {
1116  fifo_segment_t *fs;
1117  application_t *app = 0;
1118  app_worker_t *app_wrk;
1119  segment_manager_t *sm;
1120  u32 app_ns_index = 0;
1121  u8 *app_name = 0;
1122  u64 secret;
1123  int rv;
1124 
1125  if (a->api_client_index != APP_INVALID_INDEX)
1126  app = application_lookup (a->api_client_index);
1127  else if (a->name)
1128  app = application_lookup_name (a->name);
1129  else
1130  return VNET_API_ERROR_INVALID_VALUE;
1131 
1132  if (app)
1133  return VNET_API_ERROR_APP_ALREADY_ATTACHED;
1134 
1135  /* Socket api sets the name and validates namespace prior to attach */
1136  if (!a->use_sock_api)
1137  {
1138  if (a->api_client_index != APP_INVALID_INDEX)
1139  {
1140  app_name = app_name_from_api_index (a->api_client_index);
1141  a->name = app_name;
1142  }
1143 
1144  secret = a->options[APP_OPTIONS_NAMESPACE_SECRET];
1145  if ((rv = app_validate_namespace (a->namespace_id, secret,
1146  &app_ns_index)))
1147  return rv;
1148  a->options[APP_OPTIONS_NAMESPACE] = app_ns_index;
1149  }
1150 
1151  if ((rv = application_alloc_and_init ((app_init_args_t *) a)))
1152  return rv;
1153 
1154  app = application_get (a->app_index);
1155  if ((rv = application_alloc_worker_and_init (app, &app_wrk)))
1156  return rv;
1157 
1158  a->app_evt_q = app_wrk->event_queue;
1159  app_wrk->api_client_index = a->api_client_index;
1160  sm = segment_manager_get (app_wrk->connects_seg_manager);
1162 
1163  if (application_is_proxy (app))
1164  {
1166  /* The segment manager pool is reallocated because a new listener
1167  * is added. Re-grab segment manager to avoid dangling reference */
1168  sm = segment_manager_get (app_wrk->connects_seg_manager);
1169  }
1170 
1171  ASSERT (vec_len (fs->ssvm.name) <= 128);
1172  a->segment = &fs->ssvm;
1173  a->segment_handle = segment_manager_segment_handle (sm, fs);
1174 
1176 
1178  rv = app_rx_mqs_alloc (app);
1179 
1180  vec_free (app_name);
1181  return rv;
1182 }
1183 
1184 /**
1185  * Detach application from vpp
1186  */
1187 int
1189 {
1190  application_t *app;
1191 
1192  app = application_get_if_valid (a->app_index);
1193  if (!app)
1194  {
1195  clib_warning ("app not attached");
1196  return VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
1197  }
1198 
1200  application_detach_process (app, a->api_client_index);
1201  return 0;
1202 }
1203 
1204 
1205 static u8
1207 {
1208  u8 is_lep = session_endpoint_is_local (sep);
1209  if (!is_lep && sep->sw_if_index != ENDPOINT_INVALID_INDEX
1210  && !ip_interface_has_address (sep->sw_if_index, &sep->ip, sep->is_ip4))
1211  {
1212  clib_warning ("sw_if_index %u not configured with ip %U",
1213  sep->sw_if_index, format_ip46_address, &sep->ip,
1214  sep->is_ip4);
1215  return 0;
1216  }
1217  return (is_lep || ip_is_local (sep->fib_index, &sep->ip, sep->is_ip4));
1218 }
1219 
1220 static void
1222  application_t * app, u8 is_connect)
1223 {
1224  app_namespace_t *app_ns;
1225  u32 ns_index, fib_index;
1226 
1227  ns_index = app->ns_index;
1228 
1229  /* App is a transport proto, so fetch the calling app's ns */
1230  if (app->flags & APP_OPTIONS_FLAGS_IS_TRANSPORT_APP)
1231  ns_index = sep->ns_index;
1232 
1233  app_ns = app_namespace_get (ns_index);
1234  if (!app_ns)
1235  return;
1236 
1237  /* Ask transport and network to bind to/connect using local interface
1238  * that "supports" app's namespace. This will fix our local connection
1239  * endpoint.
1240  */
1241 
1242  /* If in default namespace and user requested a fib index use it */
1243  if (ns_index == 0 && sep->fib_index != ENDPOINT_INVALID_INDEX)
1244  fib_index = sep->fib_index;
1245  else
1246  fib_index = sep->is_ip4 ? app_ns->ip4_fib_index : app_ns->ip6_fib_index;
1247  sep->peer.fib_index = fib_index;
1248  sep->fib_index = fib_index;
1249 
1250  if (!is_connect)
1251  {
1252  sep->sw_if_index = app_ns->sw_if_index;
1253  }
1254  else
1255  {
1256  if (app_ns->sw_if_index != APP_NAMESPACE_INVALID_INDEX
1257  && sep->peer.sw_if_index != ENDPOINT_INVALID_INDEX
1258  && sep->peer.sw_if_index != app_ns->sw_if_index)
1259  clib_warning ("Local sw_if_index different from app ns sw_if_index");
1260 
1261  sep->peer.sw_if_index = app_ns->sw_if_index;
1262  }
1263 }
1264 
1265 int
1267 {
1268  app_listener_t *app_listener;
1269  app_worker_t *app_wrk;
1270  application_t *app;
1271  int rv;
1272 
1274 
1275  app = application_get_if_valid (a->app_index);
1276  if (!app)
1277  return SESSION_E_NOAPP;
1278 
1279  app_wrk = application_get_worker (app, a->wrk_map_index);
1280  if (!app_wrk)
1281  return SESSION_E_INVALID_APPWRK;
1282 
1283  a->sep_ext.app_wrk_index = app_wrk->wrk_index;
1284 
1285  session_endpoint_update_for_app (&a->sep_ext, app, 0 /* is_connect */ );
1286  if (!session_endpoint_in_ns (&a->sep))
1287  return SESSION_E_INVALID_NS;
1288 
1289  /*
1290  * Check if we already have an app listener
1291  */
1292  app_listener = app_listener_lookup (app, &a->sep_ext);
1293  if (app_listener)
1294  {
1295  if (app_listener->app_index != app->app_index)
1296  return SESSION_E_ALREADY_LISTENING;
1297  if ((rv = app_worker_start_listen (app_wrk, app_listener)))
1298  return rv;
1299  a->handle = app_listener_handle (app_listener);
1300  return 0;
1301  }
1302 
1303  /*
1304  * Create new app listener
1305  */
1306  if ((rv = app_listener_alloc_and_init (app, &a->sep_ext, &app_listener)))
1307  return rv;
1308 
1309  if ((rv = app_worker_start_listen (app_wrk, app_listener)))
1310  {
1311  app_listener_cleanup (app_listener);
1312  return rv;
1313  }
1314 
1315  a->handle = app_listener_handle (app_listener);
1316  return 0;
1317 }
1318 
1319 int
1321 {
1322  app_worker_t *client_wrk;
1323  application_t *client;
1324 
1326 
1327  if (session_endpoint_is_zero (&a->sep))
1328  return SESSION_E_INVALID_RMT_IP;
1329 
1330  client = application_get (a->app_index);
1331  session_endpoint_update_for_app (&a->sep_ext, client, 1 /* is_connect */ );
1332  client_wrk = application_get_worker (client, a->wrk_map_index);
1333 
1334  a->sep_ext.opaque = a->api_context;
1335 
1336  /*
1337  * First check the local scope for locally attached destinations.
1338  * If we have local scope, we pass *all* connects through it since we may
1339  * have special policy rules even for non-local destinations, think proxy.
1340  */
1341  if (application_has_local_scope (client))
1342  {
1343  int rv;
1344 
1345  a->sep_ext.original_tp = a->sep_ext.transport_proto;
1346  a->sep_ext.transport_proto = TRANSPORT_PROTO_NONE;
1347  rv = app_worker_connect_session (client_wrk, &a->sep_ext, &a->sh);
1348  a->sep_ext.transport_proto = a->sep_ext.original_tp;
1349  if (!rv || rv != SESSION_E_LOCAL_CONNECT)
1350  return rv;
1351  }
1352  /*
1353  * Not connecting to a local server, propagate to transport
1354  */
1355  return app_worker_connect_session (client_wrk, &a->sep_ext, &a->sh);
1356 }
1357 
1358 int
1360 {
1361  app_worker_t *app_wrk;
1362  app_listener_t *al;
1363  application_t *app;
1364 
1366 
1367  if (!(app = application_get_if_valid (a->app_index)))
1368  return SESSION_E_NOAPP;
1369 
1370  if (!(al = app_listener_get_w_handle (a->handle)))
1371  return SESSION_E_NOLISTEN;
1372 
1373  if (al->app_index != app->app_index)
1374  {
1375  clib_warning ("app doesn't own handle %llu!", a->handle);
1376  return SESSION_E_OWNER;
1377  }
1378 
1379  app_wrk = application_get_worker (app, a->wrk_map_index);
1380  if (!app_wrk)
1381  {
1382  clib_warning ("no app %u worker %u", app->app_index, a->wrk_map_index);
1383  return SESSION_E_INVALID_APPWRK;
1384  }
1385 
1386  return app_worker_stop_listen (app_wrk, al);
1387 }
1388 
1389 int
1391 {
1392  app_worker_t *app_wrk;
1393  session_t *s;
1394 
1395  s = session_get_from_handle_if_valid (a->handle);
1396  if (!s)
1397  return SESSION_E_NOSESSION;
1398 
1399  app_wrk = app_worker_get (s->app_wrk_index);
1400  if (app_wrk->app_index != a->app_index)
1401  return SESSION_E_OWNER;
1402 
1403  /* We're peeking into another's thread pool. Make sure */
1404  ASSERT (s->session_index == session_index_from_handle (a->handle));
1405 
1406  session_half_close (s);
1407  return 0;
1408 }
1409 
1410 int
1412 {
1413  app_worker_t *app_wrk;
1414  session_t *s;
1415 
1416  s = session_get_from_handle_if_valid (a->handle);
1417  if (!s)
1418  return SESSION_E_NOSESSION;
1419 
1420  app_wrk = app_worker_get (s->app_wrk_index);
1421  if (app_wrk->app_index != a->app_index)
1422  return SESSION_E_OWNER;
1423 
1424  /* We're peeking into another's thread pool. Make sure */
1425  ASSERT (s->session_index == session_index_from_handle (a->handle));
1426 
1427  session_close (s);
1428  return 0;
1429 }
1430 
1431 int
1433 {
1434  app_worker_t *old_wrk = app_worker_get (s->app_wrk_index);
1435  app_listener_t *app_listener;
1436  application_t *app;
1437  int rv;
1438 
1439  if (!old_wrk)
1440  return SESSION_E_INVALID_APPWRK;
1441 
1444  && s->rx_fifo)
1446 
1447  app = application_get (old_wrk->app_index);
1448  if (!app)
1449  return SESSION_E_NOAPP;
1450 
1451  app_listener = app_listener_get (app, s->al_index);
1452 
1453  /* Only remove from lb for now */
1454  app_listener->workers = clib_bitmap_set (app_listener->workers,
1455  old_wrk->wrk_map_index, 0);
1456 
1457  if ((rv = app_worker_start_listen (app_wrk, app_listener)))
1458  return rv;
1459 
1460  s->app_wrk_index = app_wrk->wrk_index;
1461 
1462  return 0;
1463 }
1464 
1465 int
1467 {
1468  return (app->flags & APP_OPTIONS_FLAGS_IS_PROXY);
1469 }
1470 
1471 int
1473 {
1474  return (app->flags & APP_OPTIONS_FLAGS_IS_BUILTIN);
1475 }
1476 
1477 int
1479 {
1480  return (application_is_proxy (app) && application_is_builtin (app));
1481 }
1482 
1483 u8
1485 {
1486  return app->flags & APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
1487 }
1488 
1489 u8
1491 {
1492  return app->flags & APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
1493 }
1494 
1495 static clib_error_t *
1497  u8 transport_proto, u8 is_start)
1498 {
1499  app_namespace_t *app_ns = app_namespace_get (app->ns_index);
1500  u8 is_ip4 = (fib_proto == FIB_PROTOCOL_IP4);
1503  app_worker_t *app_wrk;
1504  app_listener_t *al;
1505  session_t *s;
1506  u32 flags;
1507 
1508  /* TODO decide if we want proxy to be enabled for all workers */
1509  app_wrk = application_get_default_worker (app);
1510  if (is_start)
1511  {
1512  s = app_worker_first_listener (app_wrk, fib_proto, transport_proto);
1513  if (!s)
1514  {
1515  sep.is_ip4 = is_ip4;
1516  sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
1517  sep.sw_if_index = app_ns->sw_if_index;
1518  sep.transport_proto = transport_proto;
1519  sep.app_wrk_index = app_wrk->wrk_index; /* only default */
1520 
1521  /* force global scope listener */
1522  flags = app->flags;
1523  app->flags &= ~APP_OPTIONS_FLAGS_USE_LOCAL_SCOPE;
1524  app_listener_alloc_and_init (app, &sep, &al);
1525  app->flags = flags;
1526 
1527  app_worker_start_listen (app_wrk, al);
1529  s->flags |= SESSION_F_PROXY;
1530  }
1531  }
1532  else
1533  {
1534  s = app_worker_proxy_listener (app_wrk, fib_proto, transport_proto);
1535  ASSERT (s);
1536  }
1537 
1539 
1540  if (!ip_is_zero (&tc->lcl_ip, 1))
1541  {
1542  u32 sti;
1543  sep.is_ip4 = is_ip4;
1544  sep.fib_index = app_namespace_get_fib_index (app_ns, fib_proto);
1545  sep.transport_proto = transport_proto;
1546  sep.port = 0;
1547  sti = session_lookup_get_index_for_fib (fib_proto, sep.fib_index);
1548  if (is_start)
1550  (session_endpoint_t *) & sep,
1551  s->session_index);
1552  else
1554  (session_endpoint_t *) & sep);
1555  }
1556 
1557  return 0;
1558 }
1559 
1560 static void
1562  u8 transport_proto, u8 is_start)
1563 {
1565  app_namespace_t *app_ns;
1566  app_ns = app_namespace_get (app->ns_index);
1567  sep.is_ip4 = 1;
1568  sep.transport_proto = transport_proto;
1569  sep.port = 0;
1570 
1571  if (is_start)
1572  {
1573  session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
1574  app->app_index);
1575  sep.is_ip4 = 0;
1576  session_lookup_add_session_endpoint (app_ns->local_table_index, &sep,
1577  app->app_index);
1578  }
1579  else
1580  {
1581  session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
1582  sep.is_ip4 = 0;
1583  session_lookup_del_session_endpoint (app_ns->local_table_index, &sep);
1584  }
1585 }
1586 
1587 void
1590 {
1591  if (application_has_local_scope (app))
1592  application_start_stop_proxy_local_scope (app, transport_proto, is_start);
1593 
1594  if (application_has_global_scope (app))
1595  {
1597  transport_proto, is_start);
1599  transport_proto, is_start);
1600  }
1601 }
1602 
1603 void
1605 {
1606  u16 transports = app->proxied_transports;
1607  transport_proto_t tp;
1608 
1609  ASSERT (application_is_proxy (app));
1610 
1611  /* *INDENT-OFF* */
1612  transport_proto_foreach (tp, ({
1613  if (transports & (1 << tp))
1614  application_start_stop_proxy (app, tp, 1);
1615  }));
1616  /* *INDENT-ON* */
1617 }
1618 
1619 void
1621 {
1622  u16 transports = app->proxied_transports;
1623  transport_proto_t tp;
1624 
1625  ASSERT (application_is_proxy (app));
1626 
1627  /* *INDENT-OFF* */
1628  transport_proto_foreach (tp, ({
1629  if (transports & (1 << tp))
1630  application_start_stop_proxy (app, tp, 0);
1631  }));
1632  /* *INDENT-ON* */
1633 }
1634 
1637 {
1638  return &app->sm_properties;
1639 }
1640 
1643 {
1644  application_t *app = application_get (app_index);
1645  return &app->sm_properties;
1646 }
1647 
1648 static void
1650 {
1651  vlib_main_t *vm = vlib_get_main ();
1652  app_worker_map_t *wrk_map;
1653  app_worker_t *app_wrk;
1654  u32 sm_index;
1655  u64 handle;
1656 
1657  if (!app)
1658  {
1659  vlib_cli_output (vm, "%U", format_app_worker_listener, 0 /* header */ ,
1660  0, 0, verbose);
1661  return;
1662  }
1663 
1664  /* *INDENT-OFF* */
1665  pool_foreach (wrk_map, app->worker_maps) {
1666  app_wrk = app_worker_get (wrk_map->wrk_index);
1667  if (hash_elts (app_wrk->listeners_table) == 0)
1668  continue;
1669  hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
1670  vlib_cli_output (vm, "%U", format_app_worker_listener, app_wrk,
1671  handle, sm_index, verbose);
1672  }));
1673  }
1674  /* *INDENT-ON* */
1675 }
1676 
1677 static void
1679 {
1680  app_worker_map_t *wrk_map;
1681  app_worker_t *app_wrk;
1682 
1683  if (!app)
1684  {
1685  app_worker_format_connects (0, verbose);
1686  return;
1687  }
1688 
1689  /* *INDENT-OFF* */
1690  pool_foreach (wrk_map, app->worker_maps) {
1691  app_wrk = app_worker_get (wrk_map->wrk_index);
1692  app_worker_format_connects (app_wrk, verbose);
1693  }
1694  /* *INDENT-ON* */
1695 }
1696 
1697 u8 *
1698 format_cert_key_pair (u8 * s, va_list * args)
1699 {
1700  app_cert_key_pair_t *ckpair = va_arg (*args, app_cert_key_pair_t *);
1701  int key_len = 0, cert_len = 0;
1702  cert_len = vec_len (ckpair->cert);
1703  key_len = vec_len (ckpair->key);
1704  if (ckpair->cert_key_index == 0)
1705  s = format (s, "DEFAULT (cert:%d, key:%d)", cert_len, key_len);
1706  else
1707  s = format (s, "%d (cert:%d, key:%d)", ckpair->cert_key_index,
1708  cert_len, key_len);
1709  return s;
1710 }
1711 
1712 u8 *
1713 format_crypto_engine (u8 * s, va_list * args)
1714 {
1715  u32 engine = va_arg (*args, u32);
1716  switch (engine)
1717  {
1718  case CRYPTO_ENGINE_NONE:
1719  return format (s, "none");
1720  case CRYPTO_ENGINE_MBEDTLS:
1721  return format (s, "mbedtls");
1722  case CRYPTO_ENGINE_OPENSSL:
1723  return format (s, "openssl");
1724  case CRYPTO_ENGINE_PICOTLS:
1725  return format (s, "picotls");
1726  case CRYPTO_ENGINE_VPP:
1727  return format (s, "vpp");
1728  default:
1729  return format (s, "unknown engine");
1730  }
1731  return s;
1732 }
1733 
1734 uword
1735 unformat_crypto_engine (unformat_input_t * input, va_list * args)
1736 {
1737  u8 *a = va_arg (*args, u8 *);
1738  if (unformat (input, "mbedtls"))
1739  *a = CRYPTO_ENGINE_MBEDTLS;
1740  else if (unformat (input, "openssl"))
1741  *a = CRYPTO_ENGINE_OPENSSL;
1742  else if (unformat (input, "picotls"))
1743  *a = CRYPTO_ENGINE_PICOTLS;
1744  else if (unformat (input, "vpp"))
1745  *a = CRYPTO_ENGINE_VPP;
1746  else
1747  return 0;
1748  return 1;
1749 }
1750 
1751 u8 *
1752 format_crypto_context (u8 * s, va_list * args)
1753 {
1754  crypto_context_t *crctx = va_arg (*args, crypto_context_t *);
1755  s = format (s, "[0x%x][sub%d,ckpair%x]", crctx->ctx_index,
1756  crctx->n_subscribers, crctx->ckpair_index);
1757  s = format (s, "[%U]", format_crypto_engine, crctx->crypto_engine);
1758  return s;
1759 }
1760 
1761 u8 *
1762 format_application (u8 * s, va_list * args)
1763 {
1764  application_t *app = va_arg (*args, application_t *);
1765  CLIB_UNUSED (int verbose) = va_arg (*args, int);
1766  segment_manager_props_t *props;
1767  const u8 *app_ns_name, *app_name;
1768  app_worker_map_t *wrk_map;
1769  app_worker_t *app_wrk;
1770 
1771  if (app == 0)
1772  {
1773  if (!verbose)
1774  s = format (s, "%-10s%-20s%-40s", "Index", "Name", "Namespace");
1775  return s;
1776  }
1777 
1778  app_name = app_get_name (app);
1779  app_ns_name = app_namespace_id_from_index (app->ns_index);
1781  if (!verbose)
1782  {
1783  s = format (s, "%-10u%-20v%-40v", app->app_index, app_name,
1784  app_ns_name);
1785  return s;
1786  }
1787 
1788  s = format (s, "app-name %v app-index %u ns-index %u seg-size %U\n",
1789  app_name, app->app_index, app->ns_index,
1790  format_memory_size, props->add_segment_size);
1791  s = format (s, "rx-fifo-size %U tx-fifo-size %U workers:\n",
1792  format_memory_size, props->rx_fifo_size,
1793  format_memory_size, props->tx_fifo_size);
1794 
1795  /* *INDENT-OFF* */
1796  pool_foreach (wrk_map, app->worker_maps) {
1797  app_wrk = app_worker_get (wrk_map->wrk_index);
1798  s = format (s, "%U", format_app_worker, app_wrk);
1799  }
1800  /* *INDENT-ON* */
1801 
1802  return s;
1803 }
1804 
1805 void
1807 {
1808  application_t *app;
1809 
1810  if (!pool_elts (app_main.app_pool))
1811  {
1812  vlib_cli_output (vm, "No active server bindings");
1813  return;
1814  }
1815 
1816  application_format_listeners (0, verbose);
1817 
1818  /* *INDENT-OFF* */
1819  pool_foreach (app, app_main.app_pool) {
1820  application_format_listeners (app, verbose);
1821  }
1822  /* *INDENT-ON* */
1823 }
1824 
1825 void
1827 {
1828  application_t *app;
1829 
1830  if (!pool_elts (app_main.app_pool))
1831  {
1832  vlib_cli_output (vm, "No active apps");
1833  return;
1834  }
1835 
1836  application_format_connects (0, verbose);
1837 
1838  /* *INDENT-OFF* */
1839  pool_foreach (app, app_main.app_pool) {
1840  application_format_connects (app, verbose);
1841  }
1842  /* *INDENT-ON* */
1843 }
1844 
1845 static clib_error_t *
1847  vlib_cli_command_t * cmd)
1848 {
1849  app_cert_key_pair_t *ckpair;
1851 
1852  /* *INDENT-OFF* */
1853  pool_foreach (ckpair, app_main.cert_key_pair_store) {
1854  vlib_cli_output (vm, "%U", format_cert_key_pair, ckpair);
1855  }
1856  /* *INDENT-ON* */
1857  return 0;
1858 }
1859 
1860 static inline void
1862 {
1864  app_worker_t *wrk;
1865  int i;
1866 
1867  /* *INDENT-OFF* */
1868  pool_foreach (map, app->worker_maps) {
1869  wrk = app_worker_get (map->wrk_index);
1870  vlib_cli_output (vm, "[A%d][%d]%U", app->app_index,
1872  wrk->event_queue);
1873  }
1874  /* *INDENT-ON* */
1875 
1876  for (i = 0; i < vec_len (app->rx_mqs); i++)
1877  vlib_cli_output (vm, "[A%d][R%d]%U", app->app_index, i, format_svm_msg_q,
1878  app->rx_mqs[i].mq);
1879 }
1880 
1881 static clib_error_t *
1883 {
1884  application_t *app;
1885  int i, n_threads;
1886 
1887  n_threads = vlib_get_n_threads ();
1888 
1889  for (i = 0; i < n_threads; i++)
1890  {
1891  vlib_cli_output (vm, "[Ctrl%d]%U", i, format_svm_msg_q,
1893  }
1894 
1895  /* *INDENT-OFF* */
1896  pool_foreach (app, app_main.app_pool) {
1897  appliction_format_app_mq (vm, app);
1898  }
1899  /* *INDENT-ON* */
1900  return 0;
1901 }
1902 
1903 static clib_error_t *
1905  vlib_cli_command_t * cmd)
1906 {
1907  int do_server = 0, do_client = 0, do_mq = 0;
1908  application_t *app;
1909  u32 app_index = ~0;
1910  int verbose = 0;
1911 
1913 
1914  while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
1915  {
1916  if (unformat (input, "server"))
1917  do_server = 1;
1918  else if (unformat (input, "client"))
1919  do_client = 1;
1920  else if (unformat (input, "mq"))
1921  do_mq = 1;
1922  else if (unformat (input, "%u", &app_index))
1923  ;
1924  else if (unformat (input, "verbose"))
1925  verbose = 1;
1926  else
1927  return clib_error_return (0, "unknown input `%U'",
1928  format_unformat_error, input);
1929  }
1930 
1931  if (do_mq && app_index != ~0)
1932  {
1933  app = application_get_if_valid (app_index);
1934  if (!app)
1935  return clib_error_return (0, "No app with index %u", app_index);
1936 
1937  appliction_format_app_mq (vm, app);
1938  return 0;
1939  }
1940 
1941  if (do_mq)
1942  {
1944  return 0;
1945  }
1946 
1947  if (do_server)
1948  {
1949  application_format_all_listeners (vm, verbose);
1950  return 0;
1951  }
1952 
1953  if (do_client)
1954  {
1955  application_format_all_clients (vm, verbose);
1956  return 0;
1957  }
1958 
1959  if (app_index != ~0)
1960  {
1961  app = application_get_if_valid (app_index);
1962  if (!app)
1963  return clib_error_return (0, "No app with index %u", app_index);
1964 
1965  vlib_cli_output (vm, "%U", format_application, app, /* verbose */ 1);
1966  return 0;
1967  }
1968 
1969  /* Print app related info */
1970  if (!do_server && !do_client)
1971  {
1972  vlib_cli_output (vm, "%U", format_application, 0, 0);
1973  /* *INDENT-OFF* */
1974  pool_foreach (app, app_main.app_pool) {
1975  vlib_cli_output (vm, "%U", format_application, app, 0);
1976  }
1977  /* *INDENT-ON* */
1978  }
1979 
1980  return 0;
1981 }
1982 
1983 /* Certificate store */
1984 
1985 static app_cert_key_pair_t *
1987 {
1988  app_cert_key_pair_t *ckpair;
1989  pool_get (app_main.cert_key_pair_store, ckpair);
1990  clib_memset (ckpair, 0, sizeof (*ckpair));
1991  ckpair->cert_key_index = ckpair - app_main.cert_key_pair_store;
1992  return ckpair;
1993 }
1994 
1997 {
1998  if (pool_is_free_index (app_main.cert_key_pair_store, index))
1999  return 0;
2000  return app_cert_key_pair_get (index);
2001 }
2002 
2005 {
2006  return pool_elt_at_index (app_main.cert_key_pair_store, index);
2007 }
2008 
2011 {
2012  /* To maintain legacy bapi */
2013  return app_cert_key_pair_get (0);
2014 }
2015 
2016 int
2018 {
2020  vec_validate (ckpair->cert, a->cert_len - 1);
2021  clib_memcpy_fast (ckpair->cert, a->cert, a->cert_len);
2022  vec_validate (ckpair->key, a->key_len - 1);
2023  clib_memcpy_fast (ckpair->key, a->key, a->key_len);
2024  a->index = ckpair->cert_key_index;
2025  return 0;
2026 }
2027 
2028 int
2030 {
2031  app_cert_key_pair_t *ckpair;
2032  if (!(ckpair = app_cert_key_pair_get_if_valid (index)))
2033  return -1;
2034  if (vec_search (ckpair->app_interests, app_index) != ~0)
2035  vec_add1 (ckpair->app_interests, app_index);
2036  return 0;
2037 }
2038 
2039 int
2041 {
2042  app_cert_key_pair_t *ckpair;
2043  application_t *app;
2044  u32 *app_index;
2045 
2046  if (!(ckpair = app_cert_key_pair_get_if_valid (index)))
2047  return (VNET_API_ERROR_INVALID_VALUE);
2048 
2049  vec_foreach (app_index, ckpair->app_interests)
2050  {
2051  if ((app = application_get_if_valid (*app_index))
2054  }
2055 
2056  vec_free (ckpair->cert);
2057  vec_free (ckpair->key);
2058  pool_put (app_main.cert_key_pair_store, ckpair);
2059  return 0;
2060 }
2061 
2062 clib_error_t *
2064 {
2065  app_main_t *am = &app_main;
2066  u32 n_workers;
2067 
2068  n_workers = vlib_num_workers ();
2069 
2070  /* Index 0 was originally used by legacy apis, maintain as invalid */
2071  (void) app_cert_key_pair_alloc ();
2073  am->app_by_name = hash_create_vec (0, sizeof (u8), sizeof (uword));
2074 
2075  vec_validate (am->wrk, n_workers);
2076 
2077  return 0;
2078 }
2079 
2080 /* *INDENT-OFF* */
2082 
2083 VLIB_CLI_COMMAND (show_app_command, static) =
2084 {
2085  .path = "show app",
2086  .short_help = "show app [app_id] [server|client] [mq] [verbose]",
2087  .function = show_app_command_fn,
2088 };
2089 
2090 VLIB_CLI_COMMAND (show_certificate_command, static) =
2091 {
2092  .path = "show app certificate",
2093  .short_help = "list app certs and keys present in store",
2094  .function = show_certificate_command_fn,
2095 };
2096 /* *INDENT-ON* */
2097 
2100 {
2101  return (++app_main.last_crypto_engine);
2102 }
2103 
2104 u8
2106 {
2107  return (app_main.last_crypto_engine + 1);
2108 }
2109 
2110 /*
2111  * fd.io coding-style-patch-verification: ON
2112  *
2113  * Local Variables:
2114  * eval: (c-set-style "gnu")
2115  * End:
2116  */
void session_half_close(session_t *s)
Initialize session half-closing procedure.
Definition: session.c:1481
int vnet_shutdown_session(vnet_shutdown_args_t *a)
Definition: application.c:1390
u32 segment_manager_index(segment_manager_t *sm)
#define vec_validate(V, I)
Make sure vector is long enough for given index (no header, unspecified alignment) ...
Definition: vec.h:524
vlib_main_t vlib_node_runtime_t vlib_frame_t * frame
Definition: application.c:486
static void application_name_table_del(application_t *app)
Definition: application.c:414
u8 ip_interface_has_address(u32 sw_if_index, ip46_address_t *ip, u8 is_ip4)
Definition: ip_interface.c:140
u32 flags
Flags.
Definition: application.h:114
n_msgs
Definition: application.c:506
u32 al_index
App listener index in app&#39;s listener pool if a listener.
struct _vnet_app_worker_add_del_args vnet_app_worker_add_del_args_t
#define ENDPOINT_INVALID_INDEX
#define APP_NAMESPACE_INVALID_INDEX
int svm_msg_q_alloc_eventfd(svm_msg_q_t *mq)
Allocate event fd for queue.
session_t * app_worker_proxy_listener(app_worker_t *app, u8 fib_proto, u8 transport_proto)
fifo_segment_header_t * h
fifo segment data
Definition: fifo_segment.h:70
u8 * name
Client name.
Definition: api_common.h:54
#define hash_set(h, key, value)
Definition: hash.h:255
void segment_manager_segment_reader_unlock(segment_manager_t *sm)
u64 segment_manager_segment_handle(segment_manager_t *sm, fifo_segment_t *segment)
#define CLIB_UNUSED(x)
Definition: clib.h:90
app_cert_key_pair_t * app_cert_key_pair_get_default()
Definition: application.c:2010
App sublayer per vpp worker state.
Definition: application.h:169
void ip_copy(ip46_address_t *dst, ip46_address_t *src, u8 is_ip4)
Definition: ip.c:83
static void application_detach_process(application_t *app, u32 api_client_index)
Definition: application.c:906
int vnet_app_add_cert_key_pair(vnet_app_add_cert_key_pair_args_t *a)
Definition: application.c:2017
u32 al_index
app listener index in app pool
Definition: application.h:83
#define hash_unset(h, key)
Definition: hash.h:261
vl_api_wireguard_peer_flags_t flags
Definition: wireguard.api:105
a
Definition: bitmap.h:544
#define SESSION_TABLE_INVALID_INDEX
Definition: session_table.h:56
uword ssvm_size
Definition: ssvm.h:84
transport_proto
Definition: session.api:22
u64 session_lookup_endpoint_listener(u32 table_index, session_endpoint_t *sep, u8 use_rules)
Lookup listener for session endpoint in table.
svm_fifo_t * tx_fifo
session_main_t session_main
Definition: session.c:25
u32 ns_index
Namespace the application belongs to.
Definition: application.h:129
u8 application_has_global_scope(application_t *app)
Definition: application.c:1490
int app_worker_connect_session(app_worker_t *app, session_endpoint_cfg_t *sep, session_handle_t *rsh)
struct _vnet_connect_args vnet_connect_args_t
#define pool_foreach(VAR, POOL)
Iterate through pool.
Definition: pool.h:534
struct _vnet_unlisten_args_t vnet_unlisten_args_t
struct app_rx_mq_elt_ * next
Definition: application.h:100
app_rx_mq_elt_t * rx_mqs
Fixed vector of rx mqs that can be a part of pending_rx_mqs linked list maintained by the app sublaye...
Definition: application.h:150
u32 thread_index
int application_change_listener_owner(session_t *s, app_worker_t *app_wrk)
Definition: application.c:1432
u32 session_index
Index in thread pool where session was allocated.
int session_stop_listen(session_t *s)
Ask transport to stop listening on local transport endpoint.
Definition: session.c:1454
#define session_cli_return_if_not_enabled()
Definition: session.h:727
session_worker_t * wrk
Definition: application.c:490
u8 ip_is_local(u32 fib_index, ip46_address_t *ip46_address, u8 is_ip4)
Checks that an ip is local to the requested fib.
Definition: ip.c:57
static clib_error_t * show_app_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: application.c:1904
unsigned long u64
Definition: types.h:89
transport_connection_t * listen_session_get_transport(session_t *s)
Definition: session.c:1780
static svm_msg_q_t * session_main_get_vpp_event_queue(u32 thread_index)
Definition: session.h:716
void * ip_interface_get_first_ip(u32 sw_if_index, u8 is_ip4)
Definition: ip_interface.c:174
crypto_engine_type_t app_crypto_engine_type_add(void)
Definition: application.c:2099
void ip_set(ip46_address_t *dst, void *src, u8 is_ip4)
Definition: ip.c:95
static void vlib_node_set_interrupt_pending(vlib_main_t *vm, u32 node_index)
Definition: node_funcs.h:249
static app_worker_t * app_listener_select_worker(application_t *app, app_listener_t *al)
Definition: application.c:291
app_cert_key_pair_t * app_cert_key_pair_get(u32 index)
Definition: application.c:2004
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
transport_connection_t * session_get_transport(session_t *s)
Definition: session.c:1745
application_t * application_lookup_name(const u8 *name)
Definition: application.c:431
svm_fifo_t * rx_fifo
Pointers to rx/tx buffers.
int segment_manager_init_first(segment_manager_t *sm)
Initializes segment manager based on options provided.
app_listener_t * app_listener_get_w_session(session_t *ls)
Definition: application.c:67
u64 private_data
Definition: file.h:64
app_rx_mq_elt_t * next
Definition: application.c:488
u32 session_lookup_get_index_for_fib(u32 fib_proto, u32 fib_index)
static session_t * listen_session_get_from_handle(session_handle_t handle)
Definition: session.h:630
u32 thread_index
Definition: main.h:213
int vnet_app_del_cert_key_pair(u32 index)
Definition: application.c:2040
#define vec_add1(V, E)
Add 1 element to end of vector (unspecified alignment).
Definition: vec.h:607
u8 * format_svm_msg_q(u8 *s, va_list *args)
Format message queue, shows msg count for each ring.
application_t * application_lookup(u32 api_client_index)
Definition: application.c:420
app_listener_t * app_listener_get(application_t *app, u32 app_listener_index)
Definition: application.c:46
static u8 svm_msg_q_is_empty(svm_msg_q_t *mq)
Check if message queue is empty.
app_listener_t * listeners
Pool of listeners for the app.
Definition: application.h:134
u32 wrk_map_index
Worker index in app&#39;s map pool.
Definition: application.h:40
session_handle_t app_listener_handle(app_listener_t *al)
Definition: application.c:61
static session_t * listen_session_alloc(u8 thread_index, session_type_t type)
Definition: session.h:643
u16 key_len
Definition: ikev2_types.api:95
static uword * clib_bitmap_set(uword *ai, uword i, uword value)
Sets the ith bit of a bitmap to new_value Removes trailing zeros from the bitmap. ...
Definition: bitmap.h:167
#define hash_set_mem(h, key, value)
Definition: hash.h:275
app_cert_key_pair_t * cert_key_pair_store
Pool from which we allocate certificates (key, cert)
Definition: application.h:195
static u8 session_endpoint_fib_proto(session_endpoint_t *sep)
Definition: session_types.h:92
static session_t * session_get(u32 si, u32 thread_index)
Definition: session.h:336
int vnet_unlisten(vnet_unlisten_args_t *a)
Definition: application.c:1359
string name[64]
Definition: fib.api:25
void(* session_reset_callback)(session_t *s)
Notify app that session was reset.
uword * listeners_table
Lookup tables for listeners.
Definition: application.h:57
#define VLIB_NODE_FN(node)
Definition: node.h:202
u32 flags
Session flags.
u8 app_is_builtin
Definition: application.h:62
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:255
u32 connects_seg_manager
Segment manager used for outgoing connects issued by the app.
Definition: application.h:54
appsl_wrk_t * wrk
App sublayer per-worker state.
Definition: application.h:205
void appsl_pending_rx_mqs_del(appsl_wrk_t *aw, app_rx_mq_elt_t *elt)
Definition: application.c:465
uword unformat_crypto_engine(unformat_input_t *input, va_list *args)
Definition: application.c:1735
vlib_node_registration_t session_queue_node
(constructor) VLIB_REGISTER_NODE (session_queue_node)
unsigned char u8
Definition: types.h:56
app_worker_t * application_get_worker(application_t *app, u32 wrk_map_index)
Definition: application.c:950
#define SESSION_ENDPOINT_NULL
Definition: session_types.h:67
static u8 session_endpoint_in_ns(session_endpoint_t *sep)
Definition: application.c:1206
application_t * application_get_if_valid(u32 app_index)
Definition: application.c:718
enum fib_protocol_t_ fib_protocol_t
Protocol Type.
struct _vnet_bind_args_t vnet_listen_args_t
segment_manager_props_t * application_segment_manager_properties(application_t *app)
Definition: application.c:1636
void ssvm_delete(ssvm_private_t *ssvm)
Definition: ssvm.c:445
svm_msg_q_t * fifo_segment_msg_q_alloc(fifo_segment_t *fs, u32 mq_index, svm_msg_q_cfg_t *cfg)
Allocate message queue on segment.
struct app_rx_mq_elt_ * prev
Definition: application.h:101
vlib_main_t vlib_node_runtime_t * node
Definition: application.c:485
static session_handle_t session_handle(session_t *s)
unsigned int u32
Definition: types.h:88
u32 ctx_index
index in crypto context pool
u8 session_type_t
#define foreach_vlib_main()
Definition: threads.h:237
static int application_alloc_and_init(app_init_args_t *a)
Definition: application.c:767
u32 app_index
owning app index
Definition: application.h:84
int application_is_proxy(application_t *app)
Definition: application.c:1466
int ssvm_server_init(ssvm_private_t *ssvm, ssvm_segment_type_t type)
Definition: ssvm.c:433
enum ssvm_segment_type_ ssvm_segment_type_t
static session_worker_t * session_main_get_worker(u32 thread_index)
Definition: session.h:702
app_rx_mq_elt_t * pending_rx_mqs
Linked list of mqs with pending messages.
Definition: application.h:172
#define VLIB_INIT_FUNCTION(x)
Definition: init.h:172
struct _vnet_disconnect_args_t vnet_disconnect_args_t
void segment_manager_dealloc_fifos(svm_fifo_t *rx_fifo, svm_fifo_t *tx_fifo)
u32 local_index
local listening session index
Definition: application.h:85
fifo_segment_t * session_main_get_evt_q_segment(void)
Definition: session.c:1676
u32 session_index
global listening session index
Definition: application.h:86
description fragment has unexpected format
Definition: map.api:433
#define hash_foreach(key_var, value_var, h, body)
Definition: hash.h:442
u8 * format_memory_size(u8 *s, va_list *va)
Definition: std-formats.c:209
#define clib_error_return(e, args...)
Definition: error.h:99
static int svm_msg_q_get_eventfd(svm_msg_q_t *mq)
clib_file_main_t file_main
Definition: main.c:63
#define vec_search(v, E)
Search a vector for the index of the entry that matches.
Definition: vec.h:1055
u32 app_namespace_index_from_id(const u8 *ns_id)
u16 proxied_transports
Definition: application.h:131
int __clib_unused rv
Definition: application.c:491
static int app_validate_namespace(u8 *namespace_id, u64 secret, u32 *app_ns_index)
Definition: application.c:1072
session_wrk_state_t state
Worker state.
Definition: session.h:116
#define SESSION_INVALID_HANDLE
Definition: session_types.h:23
u8 tls_engine
Preferred tls engine.
Definition: application.h:137
struct _vnet_app_attach_args_t vnet_app_attach_args_t
struct _session_endpoint_cfg session_endpoint_cfg_t
static const u8 * app_get_name(application_t *app)
Definition: application.c:352
#define pool_flush(VAR, POOL, BODY)
Remove all elements from a pool in a safe way.
Definition: pool.h:595
static app_main_t app_main
Definition: application.c:22
static void application_verify_cb_fns(session_cb_vft_t *cb_fns)
Definition: application.c:727
int application_is_builtin(application_t *app)
Definition: application.c:1472
#define hash_get(h, key)
Definition: hash.h:249
u32 app_namespace_get_fib_index(app_namespace_t *app_ns, u8 fib_proto)
static session_type_t session_type_from_proto_and_ip(transport_proto_t proto, u8 is_ip4)
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:553
#define hash_unset_mem(h, key)
Definition: hash.h:291
session_t * app_listener_get_local_session(app_listener_t *al)
Definition: application.c:315
static char * app_name
static uword clib_bitmap_first_set(uword *ai)
Return the lowest numbered set bit in a bitmap.
Definition: bitmap.h:391
static void application_api_table_del(u32 api_client_index)
Definition: application.c:402
static session_t * session_get_from_handle(session_handle_t handle)
Definition: session.h:356
session_t * app_listener_get_session(app_listener_t *al)
Definition: application.c:306
static clib_error_t * app_rx_mq_fd_read_ready(clib_file_t *cf)
Definition: application.c:539
uword svm_msg_q_size_to_alloc(svm_msg_q_cfg_t *cfg)
u32 app_index
Index of application that owns the listener.
struct _unformat_input_t unformat_input_t
unsigned short u16
Definition: types.h:57
const u8 * application_name_from_index(u32 app_index)
Returns app name for app-index.
Definition: application.c:386
u8 * format_crypto_engine(u8 *s, va_list *args)
Definition: application.c:1713
static u32 app_worker_map_index(application_t *app, app_worker_map_t *map)
Definition: application.c:332
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:305
#define APP_INVALID_INDEX
Definition: application.h:226
#define vec_dup(V)
Return copy of vector (no header, no alignment)
Definition: vec.h:444
struct _segment_manager_props segment_manager_props_t
appsl_rx_mqs_input_node index
Definition: application.c:524
app_namespace_t * app_namespace_get(u32 index)
static void appliction_format_app_mq(vlib_main_t *vm, application_t *app)
Definition: application.c:1861
u32 wrk_index
Worker index in global worker pool.
Definition: application.h:37
static clib_error_t * show_certificate_command_fn(vlib_main_t *vm, unformat_input_t *input, vlib_cli_command_t *cmd)
Definition: application.c:1846
u32 application_session_table(application_t *app, u8 fib_proto)
Definition: application.c:358
#define SESSION_INVALID_INDEX
Definition: session_types.h:22
app_worker_t * app_worker_alloc(application_t *app)
void fifo_segment_cleanup(fifo_segment_t *fs)
Definition: fifo_segment.c:826
session_handle_t app_listen_session_handle(session_t *ls)
Get app listener handle for listening session.
Definition: application.c:78
u32 n_subscribers
refcount of sessions using said context
u8 * format_cert_key_pair(u8 *s, va_list *args)
Definition: application.c:1698
static u64 listen_session_get_handle(session_t *s)
Definition: session.h:622
u8 * format_app_worker_listener(u8 *s, va_list *args)
fifo_segment_t rx_mqs_segment
Segment where rx mqs were allocated.
Definition: application.h:144
app_worker_map_t * worker_maps
Pool of mappings that keep track of workers associated to this app.
Definition: application.h:123
format_function_t format_ip46_address
Definition: ip46_address.h:50
int vnet_application_attach(vnet_app_attach_args_t *a)
Attach application to vpp.
Definition: application.c:1114
static session_t * session_get_from_handle_if_valid(session_handle_t handle)
Definition: session.h:365
#define pool_free(p)
Free a pool.
Definition: pool.h:447
An API client registration, only in vpp/vlib.
Definition: api_common.h:47
u32 n_rings
number of msg rings
Definition: message_queue.h:89
svm_msg_q_t * segment_manager_event_queue(segment_manager_t *sm)
u32 application_local_session_table(application_t *app)
Definition: application.c:373
svm_msg_q_t * application_rx_mq_get(application_t *app, u32 mq_index)
Definition: application.c:615
static void app_rx_mqs_epoll_del(application_t *app, app_rx_mq_elt_t *mqe)
Definition: application.c:598
int(* session_connected_callback)(u32 app_wrk_index, u32 opaque, session_t *s, session_error_t code)
Connection request callback.
app_cert_key_pair_t * app_cert_key_pair_get_if_valid(u32 index)
Definition: application.c:1996
ssvm_private_t ssvm
ssvm segment data
Definition: fifo_segment.h:69
#define VLIB_REGISTER_NODE(x,...)
Definition: node.h:169
#define UNFORMAT_END_OF_INPUT
Definition: format.h:137
u32 ckpair_index
certificate & key
uword * app_by_name
Hash table of builtin apps by name.
Definition: application.h:190
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:208
segment_manager_t * segment_manager_alloc(void)
static void app_listener_free(application_t *app, app_listener_t *app_listener)
Definition: application.c:52
int(* app_cert_key_pair_delete_callback)(app_cert_key_pair_t *ckpair)
Cert and key pair delete notification.
session_t * app_worker_first_listener(app_worker_t *app, u8 fib_proto, u8 transport_proto)
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:261
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:395
segment_manager_props_t sm_properties
Segment manager properties.
Definition: application.h:120
counters map
Definition: map.api:356
static application_t * application_alloc(void)
Definition: application.c:700
int session_lookup_del_session_endpoint(u32 table_index, session_endpoint_t *sep)
void session_free(session_t *s)
Definition: session.c:227
#define clib_warning(format, args...)
Definition: error.h:59
static void session_endpoint_update_for_app(session_endpoint_cfg_t *sep, application_t *app, u8 is_connect)
Definition: application.c:1221
Don&#39;t register connection in lookup.
struct _vnet_shutdown_args_t vnet_shutdown_args_t
svm_msg_q_t * mq
Definition: application.h:102
clib_bitmap_t * workers
workers accepting connections
Definition: application.h:81
struct _transport_connection transport_connection_t
u64 buf
Definition: application.c:493
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:302
const u8 * app_namespace_id_from_index(u32 index)
void application_format_all_clients(vlib_main_t *vm, int verbose)
Definition: application.c:1826
static vl_api_registration_t * vl_api_client_index_to_registration(u32 index)
Definition: api.h:79
int session_lookup_add_session_endpoint(u32 table_index, session_endpoint_t *sep, u64 value)
static u8 vlib_thread_is_main_w_barrier(void)
Definition: threads.h:506
static void application_name_table_add(application_t *app)
Definition: application.c:408
struct _app_namespace app_namespace_t
application_t * application_get(u32 app_index)
Definition: application.c:710
int vnet_app_add_cert_key_interest(u32 index, u32 app_index)
Ask for app cb on pair deletion.
Definition: application.c:2029
#define VLIB_CLI_COMMAND(x,...)
Definition: cli.h:163
segment_manager_props_t * application_get_segment_manager_properties(u32 app_index)
Definition: application.c:1642
vlib_node_registration_t appsl_rx_mqs_input_node
(constructor) VLIB_REGISTER_NODE (appsl_rx_mqs_input_node)
Definition: application.c:482
int session_listen(session_t *ls, session_endpoint_cfg_t *sep)
Ask transport to listen on session endpoint.
Definition: session.c:1425
static u32 session_index_from_handle(session_handle_t handle)
#define hash_create(elts, value_bytes)
Definition: hash.h:696
int app_listener_alloc_and_init(application_t *app, session_endpoint_cfg_t *sep, app_listener_t **listener)
Definition: application.c:156
appsl_wrk_t * aw
Definition: application.c:492
app_listener_t * app_listener_get_w_handle(session_handle_t handle)
Get app listener for listener session handle.
Definition: application.c:88
static uword hash_elts(void *v)
Definition: hash.h:118
#define ASSERT(truth)
vlib_main_t * vm
Definition: application.c:485
int application_alloc_worker_and_init(application_t *app, app_worker_t **wrk)
Definition: application.c:983
void vlib_cli_output(vlib_main_t *vm, char *fmt,...)
Definition: cli.c:716
segment_manager_props_t * segment_manager_props_init(segment_manager_props_t *props)
app_rx_mq_elt_t * elt
Definition: application.c:488
app_worker_t * application_listener_select_worker(session_t *ls)
Definition: application.c:972
u8 use_private_rx_mqs
Allocate private rx mqs for external apps.
Definition: session.h:214
static uword clib_file_add(clib_file_main_t *um, clib_file_t *template)
Definition: file.h:96
static void clib_file_del_by_index(clib_file_main_t *um, uword index)
Definition: file.h:119
static u8 * app_name_from_api_index(u32 api_client_index)
Definition: application.c:1094
void appsl_pending_rx_mqs_add_tail(appsl_wrk_t *aw, app_rx_mq_elt_t *elt)
Definition: application.c:442
int vnet_listen(vnet_listen_args_t *a)
Definition: application.c:1266
uword * app_by_api_client_index
Hash table of apps by api client index.
Definition: application.h:185
fifo_segment_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.
int vnet_application_detach(vnet_app_detach_args_t *a)
Detach application from vpp.
Definition: application.c:1188
void application_remove_proxy(application_t *app)
Definition: application.c:1620
session_cb_vft_t cb_fns
Callbacks: shoulder-taps for the server/client.
Definition: application.h:117
enum _transport_proto transport_proto_t
struct _vnet_app_add_cert_key_pair_args_ vnet_app_add_cert_key_pair_args_t
#define clib_bitmap_free(v)
Free a bitmap.
Definition: bitmap.h:92
static void vlib_node_set_state(vlib_main_t *vm, u32 node_index, vlib_node_state_t new_state)
Set node dispatch state.
Definition: node_funcs.h:175
static u32 vlib_get_n_threads()
Definition: global_funcs.h:23
static_always_inline void * clib_memcpy_fast(void *restrict dst, const void *restrict src, size_t n)
Definition: string.h:92
u32 accept_rotor
last worker to accept a connection
Definition: application.h:82
static clib_error_t * app_rx_mq_fd_write_ready(clib_file_t *cf)
Definition: application.c:567
struct _vnet_app_detach_args_t vnet_app_detach_args_t
int vnet_connect(vnet_connect_args_t *a)
Definition: application.c:1320
svm_msg_q_ring_cfg_t * ring_cfgs
array of ring cfgs
Definition: message_queue.h:90
#define clib_max(x, y)
Definition: clib.h:335
void application_enable_rx_mqs_nodes(u8 is_en)
Definition: application.c:691
static vlib_main_t * vlib_get_main(void)
Definition: global_funcs.h:38
u8 * name
Definition: ssvm.h:87
static void listen_session_free(session_t *s)
Definition: session.h:659
u8 ip_is_zero(ip46_address_t *ip46_address, u8 is_ip4)
Definition: ip.c:22
u32 app_index
App index in app pool.
Definition: application.h:111
struct _vlib_node_registration vlib_node_registration_t
#define hash_create_vec(elts, key_bytes, value_bytes)
Definition: hash.h:668
app_worker_t * app_worker_get(u32 wrk_index)
application_t * app_pool
Pool from which we allocate all applications.
Definition: application.h:180
u32 q_nitems
msg queue size (not rings)
Definition: message_queue.h:88
u64 session_handle_t
static void app_rx_mqs_epoll_add(application_t *app, app_rx_mq_elt_t *mqe)
Definition: application.c:574
static void application_free(application_t *app)
Definition: application.c:856
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
u8 * format_application(u8 *s, va_list *args)
Definition: application.c:1762
void(* session_disconnect_callback)(session_t *s)
Notify app that session is closing.
u8 * name
Name registered by builtin apps.
Definition: application.h:126
void session_close(session_t *s)
Initialize session closing procedure.
Definition: session.c:1496
u64 uword
Definition: types.h:112
session_handle_t ls_handle
session handle of the local or global listening session that also identifies the app listener ...
Definition: application.h:87
static u8 session_endpoint_is_zero(session_endpoint_t *sep)
static app_worker_map_t * app_worker_map_alloc(application_t *app)
Definition: application.c:323
u8 application_use_private_rx_mqs(void)
Definition: application.c:677
connectionless service
int vnet_disconnect_session(vnet_disconnect_args_t *a)
Definition: application.c:1411
app_worker_t * application_get_default_worker(application_t *app)
Definition: application.c:960
struct _segment_manager segment_manager_t
#define SESSION_ENDPOINT_CFG_NULL
Definition: session_types.h:77
segment_manager_t * segment_manager_get(u32 index)
u32 application_n_workers(application_t *app)
Definition: application.c:966
void app_listener_cleanup(app_listener_t *al)
Definition: application.c:264
int vnet_app_worker_add_del(vnet_app_worker_add_del_args_t *a)
Definition: application.c:1022
static void application_api_table_add(u32 app_index, u32 api_client_index)
Definition: application.c:395
static void application_format_listeners(application_t *app, int verbose)
Definition: application.c:1649
int app_worker_start_listen(app_worker_t *app_wrk, app_listener_t *lstnr)
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:1496
#define hash_get_mem(h, key)
Definition: hash.h:269
static int app_rx_mqs_alloc(application_t *app)
Definition: application.c:624
#define app_interface_check_thread_and_barrier(_fn, _arg)
Definition: application.c:24
u8 app_crypto_engine_n_types(void)
Definition: application.c:2105
u32 app_index
Index of owning app.
Definition: application.h:43
app_listener_t * app_listener_lookup(application_t *app, session_endpoint_cfg_t *sep_ext)
Definition: application.c:98
static struct option options[]
Definition: main.c:52
static void application_start_stop_proxy_local_scope(application_t *app, u8 transport_proto, u8 is_start)
Definition: application.c:1561
u8 * format_unformat_error(u8 *s, va_list *va)
Definition: unformat.c:91
int app_worker_stop_listen(app_worker_t *app_wrk, app_listener_t *al)
void app_worker_free(app_worker_t *app_wrk)
static app_cert_key_pair_t * app_cert_key_pair_alloc()
Definition: application.c:1986
vl_api_dhcp_client_state_t state
Definition: dhcp.api:201
static u32 vlib_num_workers()
Definition: threads.h:354
#define transport_proto_foreach(VAR, BODY)
Definition: transport.h:130
static app_worker_map_t * app_worker_map_get(application_t *app, u32 map_index)
Definition: application.c:344
#define vec_foreach(var, vec)
Vector iterator.
enum crypto_engine_type_ crypto_engine_type_t
u32 app_wrk_index
Index of the app worker that owns the session.
void application_setup_proxy(application_t *app)
Definition: application.c:1604
void app_worker_format_connects(app_worker_t *app_wrk, int verbose)
static u8 session_endpoint_is_local(session_endpoint_t *sep)
Definition: session_types.h:98
Definition: file.h:51
static u8 application_verify_cfg(ssvm_segment_type_t st)
Check app config for given segment type.
Definition: application.c:745
static void application_format_connects(application_t *app, int verbose)
Definition: application.c:1678
int(* session_accept_callback)(session_t *new_session)
Notify server of newly accepted session.
int application_is_builtin_proxy(application_t *app)
Definition: application.c:1478
u32 api_client_index
API index for the worker.
Definition: application.h:60
struct _session_endpoint session_endpoint_t
int session_wrk_handle_mq(session_worker_t *wrk, svm_msg_q_t *mq)
static void app_worker_map_free(application_t *app, app_worker_map_t *map)
Definition: application.c:338
int consumer_pid
pid of msg consumer
Definition: message_queue.h:87
int fifo_segment_init(fifo_segment_t *fs)
Initialize fifo segment shared header.
Definition: fifo_segment.c:295
void application_start_stop_proxy(application_t *app, transport_proto_t transport_proto, u8 is_start)
Definition: application.c:1588
svm_msg_q_t * event_queue
Application listens for events on this svm queue.
Definition: application.h:46
u8 * format_app_worker(u8 *s, va_list *args)
static transport_service_type_t session_transport_service_type(session_t *s)
void application_format_all_listeners(vlib_main_t *vm, int verbose)
Definition: application.c:1806
#define APP_DBG(_fmt, _args...)
Definition: application.h:29
clib_error_t * application_init(vlib_main_t *vm)
Definition: application.c:2063
fifo_segment_t * application_get_rx_mqs_segment(application_t *app)
Definition: application.c:683
crypto_engine_type_t last_crypto_engine
Definition: application.h:200
static session_t * listen_session_get(u32 ls_index)
Definition: session.h:653
uword unformat(unformat_input_t *i, const char *fmt,...)
Definition: unformat.c:978
u8 n_mqs
Num mqs for mqs segment.
Definition: fifo_types.h:148
static uword unformat_check_input(unformat_input_t *i)
Definition: format.h:163
static clib_error_t * appliction_format_all_app_mq(vlib_main_t *vm)
Definition: application.c:1882
void ct_session_endpoint(session_t *ll, session_endpoint_t *sep)
static app_listener_t * app_listener_alloc(application_t *app)
Definition: application.c:32
u8 * format_crypto_context(u8 *s, va_list *args)
Definition: application.c:1752
u8 application_has_local_scope(application_t *app)
Definition: application.c:1484
static uword pool_elts(void *v)
Number of active elements in a pool.
Definition: pool.h:127