FD.io VPP  v20.05.1-6-gf53edbc3b
Vector Packet Processing
application_worker.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 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 
18 #include <vnet/session/session.h>
19 
20 /**
21  * Pool of workers associated to apps
22  */
24 
27 {
28  app_worker_t *app_wrk;
29  pool_get (app_workers, app_wrk);
30  clib_memset (app_wrk, 0, sizeof (*app_wrk));
31  app_wrk->wrk_index = app_wrk - app_workers;
32  app_wrk->app_index = app->app_index;
33  app_wrk->wrk_map_index = ~0;
36  APP_DBG ("New app %v worker %u", app->name, app_wrk->wrk_index);
37  return app_wrk;
38 }
39 
41 app_worker_get (u32 wrk_index)
42 {
43  return pool_elt_at_index (app_workers, wrk_index);
44 }
45 
48 {
49  if (pool_is_free_index (app_workers, wrk_index))
50  return 0;
51  return pool_elt_at_index (app_workers, wrk_index);
52 }
53 
54 void
56 {
57  application_t *app = application_get (app_wrk->app_index);
58  vnet_unlisten_args_t _a, *a = &_a;
59  u64 handle, *handles = 0, *sm_indices = 0;
61  session_t *ls;
62  u32 sm_index;
63  int i, j;
64 
65  /*
66  * Listener cleanup
67  */
68 
69  /* *INDENT-OFF* */
70  hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
71  ls = listen_session_get_from_handle (handle);
72  vec_add1 (handles, app_listen_session_handle (ls));
73  vec_add1 (sm_indices, sm_index);
74  sm = segment_manager_get (sm_index);
75  }));
76  /* *INDENT-ON* */
77 
78  for (i = 0; i < vec_len (handles); i++)
79  {
80  /* Cleanup listener */
81  a->app_index = app->app_index;
82  a->wrk_map_index = app_wrk->wrk_map_index;
83  a->handle = handles[i];
84  (void) vnet_unlisten (a);
85 
86  sm = segment_manager_get_if_valid (sm_indices[i]);
87  if (sm && !segment_manager_app_detached (sm))
88  {
89  sm->first_is_protected = 0;
91  }
92  }
93  vec_reset_length (handles);
94  vec_free (sm_indices);
95  hash_free (app_wrk->listeners_table);
96 
97  /*
98  * Connects segment manager cleanup
99  */
100 
102  {
104  sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
105  sm->first_is_protected = 0;
107  }
108 
109  /*
110  * Half-open cleanup
111  */
112 
113  for (i = 0; i < vec_len (app_wrk->half_open_table); i++)
114  {
115  if (!app_wrk->half_open_table[i])
116  continue;
117 
118  /* *INDENT-OFF* */
119  hash_foreach (handle, sm_index, app_wrk->half_open_table[i], ({
120  vec_add1 (handles, handle);
121  }));
122  /* *INDENT-ON* */
123 
124  for (j = 0; j < vec_len (handles); j++)
125  session_cleanup_half_open (i, handles[j]);
126 
127  hash_free (app_wrk->half_open_table[i]);
128  vec_reset_length (handles);
129  }
130 
131  vec_free (app_wrk->half_open_table);
132  vec_free (handles);
133 
134  /* If first segment manager is used by a listener that recently
135  * stopped listening, mark it as detached */
136  if (app_wrk->first_segment_manager != app_wrk->connects_seg_manager
138  {
139  sm->first_is_protected = 0;
140  sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
141  /* .. and has no fifos, e.g. it might be used for redirected sessions,
142  * remove it */
143  if (!segment_manager_has_fifos (sm))
145  }
146 
147  if (CLIB_DEBUG)
148  clib_memset (app_wrk, 0xfe, sizeof (*app_wrk));
149  pool_put (app_workers, app_wrk);
150 }
151 
154 {
155  app_worker_t *app_wrk;
156  app_wrk = app_worker_get_if_valid (wrk_index);
157  if (!app_wrk)
158  return 0;
159  return application_get_if_valid (app_wrk->app_index);
160 }
161 
162 static segment_manager_t *
164 {
165  segment_manager_t *sm = 0;
166 
167  /* If the first segment manager is not in use, don't allocate a new one */
169  && app_wrk->first_segment_manager_in_use == 0)
170  {
172  app_wrk->first_segment_manager_in_use = 1;
173  return sm;
174  }
175 
176  sm = segment_manager_alloc ();
177  sm->app_wrk_index = app_wrk->wrk_index;
178 
179  return sm;
180 }
181 
182 static int
184 {
185  svm_fifo_t *rx_fifo = 0, *tx_fifo = 0;
186  int rv;
187 
189  &rx_fifo, &tx_fifo)))
190  return rv;
191 
192  rx_fifo->master_session_index = s->session_index;
193  rx_fifo->master_thread_index = s->thread_index;
194 
195  tx_fifo->master_session_index = s->session_index;
196  tx_fifo->master_thread_index = s->thread_index;
197 
198  s->rx_fifo = rx_fifo;
199  s->tx_fifo = tx_fifo;
200  return 0;
201 }
202 
203 int
205 {
206  segment_manager_t *sm;
207 
208  /* Allocate segment manager. All sessions derived out of a listen session
209  * have fifos allocated by the same segment manager. */
210  if (!(sm = app_worker_alloc_segment_manager (app_wrk)))
211  return SESSION_E_ALLOC;
212 
213  /* Keep track of the segment manager for the listener or this worker */
215  segment_manager_index (sm));
216 
218  {
219  if (ls->rx_fifo)
220  return SESSION_E_NOSUPPORT;
221  return app_worker_alloc_session_fifos (sm, ls);
222  }
223  return 0;
224 }
225 
226 int
228  app_listener_t * app_listener)
229 {
230  session_t *ls;
231  int rv;
232 
233  if (clib_bitmap_get (app_listener->workers, app_wrk->wrk_map_index))
234  return SESSION_E_ALREADY_LISTENING;
235 
236  app_listener->workers = clib_bitmap_set (app_listener->workers,
237  app_wrk->wrk_map_index, 1);
238 
239  if (app_listener->session_index != SESSION_INVALID_INDEX)
240  {
241  ls = session_get (app_listener->session_index, 0);
242  if ((rv = app_worker_init_listener (app_wrk, ls)))
243  return rv;
244  }
245 
246  if (app_listener->local_index != SESSION_INVALID_INDEX)
247  {
248  ls = session_get (app_listener->local_index, 0);
249  if ((rv = app_worker_init_listener (app_wrk, ls)))
250  return rv;
251  }
252 
253  return 0;
254 }
255 
256 static void
258 {
259  session_handle_t handle;
260  segment_manager_t *sm;
261  uword *sm_indexp;
262 
263  handle = listen_session_get_handle (ls);
264  sm_indexp = hash_get (app_wrk->listeners_table, handle);
265  if (PREDICT_FALSE (!sm_indexp))
266  return;
267 
268  /* Dealloc fifos, if any (dgram listeners) */
269  if (ls->rx_fifo)
270  {
272  ls->tx_fifo = ls->rx_fifo = 0;
273  }
274 
275  /* Try to cleanup segment manager */
276  sm = segment_manager_get (*sm_indexp);
277  if (sm && app_wrk->first_segment_manager != *sm_indexp)
278  {
280  if (!segment_manager_has_fifos (sm))
282  }
283 
284  hash_unset (app_wrk->listeners_table, handle);
285 }
286 
287 int
289 {
290  session_t *ls;
291 
292  if (!clib_bitmap_get (al->workers, app_wrk->wrk_map_index))
293  return 0;
294 
296  {
298  app_worker_stop_listen_session (app_wrk, ls);
299  }
300 
302  {
303  ls = listen_session_get (al->local_index);
304  app_worker_stop_listen_session (app_wrk, ls);
305  }
306 
308  if (clib_bitmap_is_zero (al->workers))
310 
311  return 0;
312 }
313 
314 int
316 {
317  app_worker_t *app_wrk;
318  segment_manager_t *sm;
320  application_t *app;
321 
323  app_wrk = application_listener_select_worker (listener);
324  s->app_wrk_index = app_wrk->wrk_index;
325 
326  app = application_get (app_wrk->app_index);
327  if (app->cb_fns.fifo_tuning_callback)
328  s->flags |= SESSION_F_CUSTOM_FIFO_TUNING;
329 
330  sm = app_worker_get_listen_segment_manager (app_wrk, listener);
331  if (app_worker_alloc_session_fifos (sm, s))
332  return -1;
333 
334  return 0;
335 }
336 
337 int
339 {
340  application_t *app = application_get (app_wrk->app_index);
341  return app->cb_fns.session_accept_callback (s);
342 }
343 
344 int
346 {
347  application_t *app = application_get (app_wrk->app_index);
348  segment_manager_t *sm;
349 
350  /* Allocate fifos for session, unless the app is a builtin proxy */
351  if (!application_is_builtin_proxy (app))
352  {
354  return app_worker_alloc_session_fifos (sm, s);
355  }
356 
357  if (app->cb_fns.fifo_tuning_callback)
358  s->flags |= SESSION_F_CUSTOM_FIFO_TUNING;
359 
360  return 0;
361 }
362 
363 int
365  session_error_t err, u32 opaque)
366 {
367  application_t *app = application_get (app_wrk->app_index);
368  return app->cb_fns.session_connected_callback (app_wrk->wrk_index, opaque,
369  s, err);
370 }
371 
372 int
374  session_handle_t ho_handle,
375  session_handle_t wrk_handle)
376 {
377  ASSERT (vlib_get_thread_index () == 0);
378  vec_validate (app_wrk->half_open_table, tp);
379  hash_set (app_wrk->half_open_table[tp], ho_handle, wrk_handle);
380  return 0;
381 }
382 
383 int
385  session_handle_t ho_handle)
386 {
387  ASSERT (vlib_get_thread_index () == 0);
388  hash_unset (app_wrk->half_open_table[tp], ho_handle);
389  return 0;
390 }
391 
392 u64
394  session_handle_t ho_handle)
395 {
396  u64 *ho_wrk_handlep;
397 
398  /* No locking because all updates are done from main thread */
399  ho_wrk_handlep = hash_get (app_wrk->half_open_table[tp], ho_handle);
400  if (!ho_wrk_handlep)
401  return SESSION_INVALID_HANDLE;
402 
403  return *ho_wrk_handlep;
404 }
405 
406 int
408 {
409  application_t *app = application_get (app_wrk->app_index);
411  return 0;
412 }
413 
414 int
416 {
417  application_t *app = application_get (app_wrk->app_index);
420  return 0;
421 }
422 
423 int
425 {
426  application_t *app = application_get (app_wrk->app_index);
428  return 0;
429 }
430 
431 int
434 {
435  application_t *app = application_get (app_wrk->app_index);
437  app->cb_fns.session_cleanup_callback (s, ntf);
438  return 0;
439 }
440 
441 int
443 {
444  application_t *app = application_get (app_wrk->app_index);
446  return 0;
447 }
448 
449 int
451 {
452  application_t *app = application_get (app_wrk->app_index);
453 
455  return 0;
456 
458  return 0;
459 }
460 
461 int
463  session_handle_t new_sh)
464 {
465  application_t *app = application_get (app_wrk->app_index);
466  app->cb_fns.session_migrate_callback (s, new_sh);
467  return 0;
468 }
469 
470 int
472 {
473  segment_manager_t *sm;
474  svm_fifo_t *rxf, *txf;
475 
476  if (s->session_state == SESSION_STATE_LISTENING)
477  return application_change_listener_owner (s, app_wrk);
478 
479  s->app_wrk_index = app_wrk->wrk_index;
480 
481  rxf = s->rx_fifo;
482  txf = s->tx_fifo;
483 
484  if (!rxf || !txf)
485  return 0;
486 
487  s->rx_fifo = 0;
488  s->tx_fifo = 0;
489 
491  if (app_worker_alloc_session_fifos (sm, s))
492  return -1;
493 
494  if (!svm_fifo_is_empty_cons (rxf))
495  svm_fifo_clone (s->rx_fifo, rxf);
496 
497  if (!svm_fifo_is_empty_cons (txf))
498  svm_fifo_clone (s->tx_fifo, txf);
499 
501 
502  return 0;
503 }
504 
505 int
507  u32 api_context)
508 {
509  int rv;
510 
511  /* Make sure we have a segment manager for connects */
513  return SESSION_E_ALLOC;
514 
515  if ((rv = session_open (app_wrk->wrk_index, sep, api_context)))
516  return rv;
517 
518  return 0;
519 }
520 
521 int
523  svm_fifo_t * f,
525 {
526  application_t *app = application_get (app_wrk->app_index);
527  return app->cb_fns.fifo_tuning_callback (s, f, act, len);
528 }
529 
530 int
532 {
533  segment_manager_t *sm;
534 
536  {
537  sm = app_worker_alloc_segment_manager (app_wrk);
538  if (sm == 0)
539  return -1;
541  }
542  return 0;
543 }
544 
547 {
548  ASSERT (app->connects_seg_manager != (u32) ~ 0);
550 }
551 
554 {
555  if (app_wrk->connects_seg_manager == (u32) ~ 0)
557  return segment_manager_get (app_wrk->connects_seg_manager);
558 }
559 
563 {
564  uword *smp;
565  smp = hash_get (app->listeners_table, listen_session_get_handle (listener));
566  ALWAYS_ASSERT (smp != 0);
567  return segment_manager_get (*smp);
568 }
569 
570 session_t *
573 {
575  u64 handle;
576  u32 sm_index;
577  u8 sst;
578 
579  sst = session_type_from_proto_and_ip (transport_proto,
580  fib_proto == FIB_PROTOCOL_IP4);
581 
582  /* *INDENT-OFF* */
583  hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
584  listener = listen_session_get_from_handle (handle);
585  if (listener->session_type == sst
586  && !(listener->flags & SESSION_F_PROXY))
587  return listener;
588  }));
589  /* *INDENT-ON* */
590 
591  return 0;
592 }
593 
594 session_t *
597 {
599  u64 handle;
600  u32 sm_index;
601  u8 sst;
602 
603  sst = session_type_from_proto_and_ip (transport_proto,
604  fib_proto == FIB_PROTOCOL_IP4);
605 
606  /* *INDENT-OFF* */
607  hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
608  listener = listen_session_get_from_handle (handle);
609  if (listener->session_type == sst && (listener->flags & SESSION_F_PROXY))
610  return listener;
611  }));
612  /* *INDENT-ON* */
613 
614  return 0;
615 }
616 
617 /**
618  * Send an API message to the external app, to map new segment
619  */
620 int
621 app_worker_add_segment_notify (app_worker_t * app_wrk, u64 segment_handle)
622 {
623  application_t *app = application_get (app_wrk->app_index);
624 
625  return app->cb_fns.add_segment_callback (app_wrk->wrk_index,
626  segment_handle);
627 }
628 
629 int
630 app_worker_del_segment_notify (app_worker_t * app_wrk, u64 segment_handle)
631 {
632  application_t *app = application_get (app_wrk->app_index);
633  return app->cb_fns.del_segment_callback (app_wrk->wrk_index,
634  segment_handle);
635 }
636 
637 static inline u8
639 {
640  return app_wrk->app_is_builtin;
641 }
642 
643 static inline int
645 {
646  session_event_t *evt;
647  svm_msg_q_msg_t msg;
648  svm_msg_q_t *mq;
649 
650  if (app_worker_application_is_builtin (app_wrk))
651  return app_worker_builtin_rx (app_wrk, s);
652 
653  if (svm_fifo_has_event (s->rx_fifo))
654  return 0;
655 
656  mq = app_wrk->event_queue;
657  svm_msg_q_lock (mq);
658 
659  if (PREDICT_FALSE (svm_msg_q_is_full (mq)))
660  {
661  clib_warning ("evt q full");
662  svm_msg_q_unlock (mq);
663  return -1;
664  }
665 
667  {
668  clib_warning ("evt q rings full");
669  svm_msg_q_unlock (mq);
670  return -1;
671  }
672 
674  evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
675  evt->session_index = s->rx_fifo->client_session_index;
676  evt->event_type = SESSION_IO_EVT_RX;
677 
678  (void) svm_fifo_set_event (s->rx_fifo);
679  svm_msg_q_add_and_unlock (mq, &msg);
680 
681  return 0;
682 }
683 
684 static inline int
686 {
687  svm_msg_q_t *mq;
688  session_event_t *evt;
689  svm_msg_q_msg_t msg;
690 
691  if (app_worker_application_is_builtin (app_wrk))
692  return app_worker_builtin_tx (app_wrk, s);
693 
694  mq = app_wrk->event_queue;
695  svm_msg_q_lock (mq);
696 
697  if (PREDICT_FALSE (svm_msg_q_is_full (mq)))
698  {
699  clib_warning ("evt q full");
700  svm_msg_q_unlock (mq);
701  return -1;
702  }
703 
705  {
706  clib_warning ("evt q rings full");
707  svm_msg_q_unlock (mq);
708  return -1;
709  }
710 
712  evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
713  evt->event_type = SESSION_IO_EVT_TX;
714  evt->session_index = s->tx_fifo->client_session_index;
715 
716  svm_msg_q_add_and_unlock (mq, &msg);
717  return 0;
718 }
719 
720 /* *INDENT-OFF* */
722  session_t *s);
726 };
727 /* *INDENT-ON* */
728 
729 /**
730  * Send event to application
731  *
732  * Logic from queue perspective is blocking. However, if queue is full,
733  * we return.
734  */
735 int
737  u8 evt_type)
738 {
739  return app_send_evt_handler_fns[evt_type] (app, s);
740 }
741 
742 u8 *
743 format_app_worker_listener (u8 * s, va_list * args)
744 {
745  app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
746  u64 handle = va_arg (*args, u64);
747  u32 sm_index = va_arg (*args, u32);
748  int verbose = va_arg (*args, int);
750  const u8 *app_name;
751  u8 *str;
752 
753  if (!app_wrk)
754  {
755  if (verbose)
756  s = format (s, "%-40s%-25s%=10s%-15s%-15s%-10s", "Connection", "App",
757  "Wrk", "API Client", "ListenerID", "SegManager");
758  else
759  s = format (s, "%-40s%-25s%=10s", "Connection", "App", "Wrk");
760 
761  return s;
762  }
763 
764  app_name = application_name_from_index (app_wrk->app_index);
765  listener = listen_session_get_from_handle (handle);
766  str = format (0, "%U", format_session, listener, verbose);
767 
768  if (verbose)
769  {
770  u8 *buf;
771  buf = format (0, "%u(%u)", app_wrk->wrk_map_index, app_wrk->wrk_index);
772  s = format (s, "%-40s%-25s%=10v%-15u%-15u%-10u", str, app_name,
773  buf, app_wrk->api_client_index, handle, sm_index);
774  vec_free (buf);
775  }
776  else
777  s = format (s, "%-40s%-25s%=10u", str, app_name, app_wrk->wrk_map_index);
778 
779  return s;
780 }
781 
782 u8 *
783 format_app_worker (u8 * s, va_list * args)
784 {
785  app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
786  u32 indent = 1;
787 
788  s = format (s, "%U wrk-index %u app-index %u map-index %u "
789  "api-client-index %d\n", format_white_space, indent,
790  app_wrk->wrk_index, app_wrk->app_index, app_wrk->wrk_map_index,
791  app_wrk->api_client_index);
792  return s;
793 }
794 
795 void
796 app_worker_format_connects (app_worker_t * app_wrk, int verbose)
797 {
798  segment_manager_t *sm;
799 
800  /* Header */
801  if (!app_wrk)
802  {
803  segment_manager_format_sessions (0, verbose);
804  return;
805  }
806 
807  if (app_wrk->connects_seg_manager == (u32) ~ 0)
808  return;
809 
811  segment_manager_format_sessions (sm, verbose);
812 }
813 
814 /*
815  * fd.io coding-style-patch-verification: ON
816  *
817  * Local Variables:
818  * eval: (c-set-style "gnu")
819  * End:
820  */
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:507
int app_worker_init_accepted(session_t *s)
#define hash_set(h, key, value)
Definition: hash.h:255
void * svm_msg_q_msg_data(svm_msg_q_t *mq, svm_msg_q_msg_t *msg)
Get data for message in queue.
static u8 svm_msg_q_ring_is_full(svm_msg_q_t *mq, u32 ring_index)
int session_open(u32 app_wrk_index, session_endpoint_t *rmt, u32 opaque)
Ask transport to open connection to remote transport endpoint.
Definition: session.c:1287
int app_worker_init_connected(app_worker_t *app_wrk, session_t *s)
#define hash_unset(h, key)
Definition: hash.h:261
u8 * format_session(u8 *s, va_list *args)
Format stream session as per the following format.
Definition: session_cli.c:101
a
Definition: bitmap.h:538
transport_proto
Definition: session.api:22
svm_fifo_t * tx_fifo
struct _vnet_unlisten_args_t vnet_unlisten_args_t
int application_change_listener_owner(session_t *s, app_worker_t *app_wrk)
Definition: application.c:1108
u32 session_index
Index in thread pool where session was allocated.
static segment_manager_t * app_worker_alloc_segment_manager(app_worker_t *app_wrk)
unsigned long u64
Definition: types.h:89
session_t * app_worker_first_listener(app_worker_t *app_wrk, u8 fib_proto, u8 transport_proto)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
transport_connection_t * session_get_transport(session_t *s)
Definition: session.c:1617
svm_fifo_t * rx_fifo
Pointers to rx/tx buffers.
static session_t * listen_session_get_from_handle(session_handle_t handle)
Definition: session.h:571
void segment_manager_format_sessions(segment_manager_t *sm, int verbose)
int app_worker_builtin_tx(app_worker_t *app_wrk, session_t *s)
u64 app_worker_lookup_half_open(app_worker_t *app_wrk, transport_proto_t tp, session_handle_t ho_handle)
static int svm_fifo_is_empty_cons(svm_fifo_t *f)
Check if fifo is empty optimized for consumer.
Definition: svm_fifo.h:469
int app_worker_builtin_rx(app_worker_t *app_wrk, session_t *s)
u32 wrk_map_index
Worker index in app&#39;s map pool.
Definition: application.h:40
void segment_manager_free(segment_manager_t *sm)
Cleanup segment manager.
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
static session_t * session_get(u32 si, u32 thread_index)
Definition: session.h:301
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
int vnet_unlisten(vnet_unlisten_args_t *a)
Definition: application.c:1056
int app_worker_reset_notify(app_worker_t *app_wrk, session_t *s)
void(* session_reset_callback)(session_t *s)
Notify app that session was reset.
uword * listeners_table
Lookup tables for listeners.
Definition: application.h:52
u32 flags
Session flags.
u8 app_is_builtin
Definition: application.h:65
static u8 app_worker_application_is_builtin(app_worker_t *app_wrk)
#define pool_get(P, E)
Allocate an object E from a pool P (unspecified alignment).
Definition: pool.h:252
u32 connects_seg_manager
Segment manager used for outgoing connects issued by the app.
Definition: application.h:49
static int app_send_io_evt_tx(app_worker_t *app_wrk, session_t *s)
unsigned char u8
Definition: types.h:56
application_t * application_get_if_valid(u32 app_index)
Definition: application.c:434
#define vec_reset_length(v)
Reset vector length to zero NULL-pointer tolerant.
static uword clib_bitmap_set_no_check(uword *a, uword i, uword new_value)
Sets the ith bit of a bitmap to new_value.
Definition: bitmap.h:141
static int app_send_io_evt_rx(app_worker_t *app_wrk, session_t *s)
int app_worker_connect_session(app_worker_t *app_wrk, session_endpoint_t *sep, u32 api_context)
void(* session_migrate_callback)(session_t *s, session_handle_t new_sh)
Notify app that session pool migration happened.
enum session_ft_action_ session_ft_action_t
application_t * app_worker_get_app(u32 wrk_index)
int(* builtin_app_rx_callback)(session_t *session)
Direct RX callback for built-in application.
void svm_fifo_clone(svm_fifo_t *df, svm_fifo_t *sf)
Clones fifo.
Definition: svm_fifo.c:1188
u32 first_segment_manager
First segment manager has in the the first segment the application&#39;s event fifo.
Definition: application.h:59
static int app_worker_alloc_session_fifos(segment_manager_t *sm, session_t *s)
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:82
static uword clib_bitmap_is_zero(uword *ai)
predicate function; is an entire bitmap empty?
Definition: bitmap.h:57
u8 * format_white_space(u8 *s, va_list *va)
Definition: std-formats.c:129
int app_worker_cleanup_notify(app_worker_t *app_wrk, session_t *s, session_cleanup_ntf_t ntf)
u32 session_index
global listening session index
Definition: application.h:83
void session_cleanup_half_open(transport_proto_t tp, session_handle_t ho_handle)
Definition: session.c:286
#define hash_foreach(key_var, value_var, h, body)
Definition: hash.h:442
#define ALWAYS_ASSERT(truth)
unsigned int u32
Definition: types.h:88
app_worker_t * app_worker_alloc(application_t *app)
#define SESSION_INVALID_HANDLE
Definition: session_types.h:23
int app_worker_transport_closed_notify(app_worker_t *app_wrk, session_t *s)
int app_worker_connect_notify(app_worker_t *app_wrk, session_t *s, session_error_t err, u32 opaque)
int app_worker_del_segment_notify(app_worker_t *app_wrk, u64 segment_handle)
#define hash_get(h, key)
Definition: hash.h:249
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:534
void app_worker_free(app_worker_t *app_wrk)
u8 * format_app_worker_listener(u8 *s, va_list *args)
void segment_manager_app_detach(segment_manager_t *sm)
int app_worker_stop_listen(app_worker_t *app_wrk, app_listener_t *al)
const u8 * application_name_from_index(u32 app_index)
Returns app name for app-index.
Definition: application.c:360
#define hash_free(h)
Definition: hash.h:310
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:302
void segment_manager_init_free(segment_manager_t *sm)
Initiate segment manager cleanup.
u8 segment_manager_has_fifos(segment_manager_t *sm)
#define PREDICT_FALSE(x)
Definition: clib.h:118
int(* add_segment_callback)(u32 app_wrk_index, u64 segment_handle)
Notify server of new segment.
u32 wrk_index
Worker index in global worker pool.
Definition: application.h:37
segment_manager_t * app_worker_get_or_alloc_connect_segment_manager(app_worker_t *app_wrk)
#define SESSION_INVALID_INDEX
Definition: session_types.h:22
int() app_send_evt_handler_fn(app_worker_t *app, session_t *s)
static void app_worker_stop_listen_session(app_worker_t *app_wrk, session_t *ls)
static u64 listen_session_get_handle(session_t *s)
Definition: session.h:563
int(* del_segment_callback)(u32 app_wrk_index, u64 segment_handle)
Notify server of new segment.
u8 len
Definition: ip_types.api:92
int app_worker_accept_notify(app_worker_t *app_wrk, session_t *s)
#define SEGMENT_MANAGER_INVALID_APP_INDEX
static u8 svm_fifo_set_event(svm_fifo_t *f)
Set fifo event flag.
Definition: svm_fifo.h:699
session_t * app_worker_proxy_listener(app_worker_t *app_wrk, u8 fib_proto, u8 transport_proto)
int(* session_connected_callback)(u32 app_wrk_index, u32 opaque, session_t *s, session_error_t code)
Connection request callback.
session_handle_t listener_handle
Parent listener session index if the result of an accept.
int app_worker_migrate_notify(app_worker_t *app_wrk, session_t *s, session_handle_t new_sh)
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:218
static void svm_msg_q_unlock(svm_msg_q_t *mq)
Unlock message queue.
segment_manager_t * segment_manager_alloc(void)
void(* session_cleanup_callback)(session_t *s, session_cleanup_ntf_t ntf)
Notify app that session or transport are about to be removed.
int app_worker_del_half_open(app_worker_t *app_wrk, transport_proto_t tp, session_handle_t ho_handle)
sll srl srl sll sra u16x4 i
Definition: vector_sse42.h:317
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:380
#define clib_warning(format, args...)
Definition: error.h:59
u8 segment_manager_app_detached(segment_manager_t *sm)
clib_bitmap_t * workers
workers accepting connections
Definition: application.h:78
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:299
static uword clib_bitmap_get(uword *ai, uword i)
Gets the ith bit value from a bitmap.
Definition: bitmap.h:197
int app_worker_close_notify(app_worker_t *app_wrk, session_t *s)
static u8 transport_connection_is_cless(transport_connection_t *tc)
Definition: transport.h:214
int(* builtin_app_tx_callback)(session_t *session)
Direct TX callback for built-in application.
int app_worker_own_session(app_worker_t *app_wrk, session_t *s)
int segment_manager_alloc_session_fifos(segment_manager_t *sm, u32 thread_index, svm_fifo_t **rx_fifo, svm_fifo_t **tx_fifo)
application_t * application_get(u32 app_index)
Definition: application.c:426
int app_worker_add_half_open(app_worker_t *app_wrk, transport_proto_t tp, session_handle_t ho_handle, session_handle_t wrk_handle)
app_worker_t * app_worker_get_if_valid(u32 wrk_index)
#define ASSERT(truth)
void svm_msg_q_add_and_unlock(svm_msg_q_t *mq, svm_msg_q_msg_t *msg)
Producer enqueue one message to queue with mutex held.
app_worker_t * application_listener_select_worker(session_t *ls)
Definition: application.c:685
uword ** half_open_table
Per transport proto hash tables of half-open connection handles.
Definition: application.h:68
session_cb_vft_t cb_fns
Callbacks: shoulder-taps for the server/client.
Definition: application.h:98
enum _transport_proto transport_proto_t
static app_send_evt_handler_fn *const app_send_evt_handler_fns[2]
u8 thread_index
Index of the thread that allocated the session.
app_worker_t * app_worker_get(u32 wrk_index)
u32 app_index
App index in app pool.
Definition: application.h:92
u64 session_handle_t
void app_worker_format_connects(app_worker_t *app_wrk, int verbose)
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
void(* session_disconnect_callback)(session_t *s)
Notify app that session is closing.
volatile u8 session_state
State in session layer state machine.
segment_manager_t * app_worker_get_listen_segment_manager(app_worker_t *app, session_t *listener)
int app_worker_add_segment_notify(app_worker_t *app_wrk, u64 segment_handle)
Send an API message to the external app, to map new segment.
u8 * name
Name registered by builtin apps.
Definition: application.h:107
u64 uword
Definition: types.h:112
struct _segment_manager segment_manager_t
int app_worker_start_listen(app_worker_t *app_wrk, app_listener_t *app_listener)
segment_manager_t * segment_manager_get(u32 index)
void app_listener_cleanup(app_listener_t *al)
Definition: application.c:238
session_cleanup_ntf_t
void(* session_transport_closed_callback)(session_t *s)
Notify app that transport is closed.
u32 app_index
Index of owning app.
Definition: application.h:43
u8 * format_app_worker(u8 *s, va_list *args)
int app_worker_session_fifo_tuning(app_worker_t *app_wrk, session_t *s, svm_fifo_t *f, session_ft_action_t act, u32 len)
int app_worker_lock_and_send_event(app_worker_t *app, session_t *s, u8 evt_type)
Send event to application.
int(* fifo_tuning_callback)(session_t *s, svm_fifo_t *f, session_ft_action_t act, u32 bytes)
Delegate fifo-tuning-logic to application.
enum session_error_ session_error_t
u32 app_wrk_index
Index of the app worker that owns the session.
static int svm_fifo_has_event(svm_fifo_t *f)
Check if fifo has io event.
Definition: svm_fifo.h:685
int(* session_accept_callback)(session_t *new_session)
Notify server of newly accepted session.
int app_worker_init_listener(app_worker_t *app_wrk, session_t *ls)
static app_worker_t * app_workers
Pool of workers associated to apps.
int application_is_builtin_proxy(application_t *app)
Definition: application.c:1154
u32 api_client_index
API index for the worker.
Definition: application.h:63
struct _session_endpoint session_endpoint_t
static int svm_msg_q_lock(svm_msg_q_t *mq)
Lock, or block trying, the message queue.
svm_msg_q_t * event_queue
Application listens for events on this svm queue.
Definition: application.h:46
struct _svm_fifo svm_fifo_t
#define APP_INVALID_SEGMENT_MANAGER_INDEX
Definition: application.h:174
static u8 svm_msg_q_is_full(svm_msg_q_t *mq)
Check if message queue is full.
#define APP_DBG(_fmt, _args...)
Definition: application.h:29
segment_manager_t * app_worker_get_connect_segment_manager(app_worker_t *app)
svm_msg_q_msg_t svm_msg_q_alloc_msg_w_ring(svm_msg_q_t *mq, u32 ring_index)
Allocate message buffer on ring.
int app_worker_alloc_connects_segment_manager(app_worker_t *app_wrk)
static session_t * listen_session_get(u32 ls_index)
Definition: session.h:594
u8 first_segment_manager_in_use
Definition: application.h:60
segment_manager_t * segment_manager_get_if_valid(u32 index)