FD.io VPP  v19.08.3-2-gbabecb413
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;
61  session_t *ls;
62  u32 sm_index;
63  int i;
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  sm = segment_manager_get (sm_index);
74  sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
75  }));
76  /* *INDENT-ON* */
77 
78  for (i = 0; i < vec_len (handles); i++)
79  {
80  a->app_index = app->app_index;
81  a->wrk_map_index = app_wrk->wrk_map_index;
82  a->handle = handles[i];
83  /* seg manager is removed when unbind completes */
84  (void) vnet_unlisten (a);
85  }
86 
87  /*
88  * Connects segment manager cleanup
89  */
90 
92  {
94  sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
95  sm->first_is_protected = 0;
97  }
98 
99  /* If first segment manager is used by a listener */
101  && app_wrk->first_segment_manager != app_wrk->connects_seg_manager)
102  {
104  sm->first_is_protected = 0;
105  sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
106  /* .. and has no fifos, e.g. it might be used for redirected sessions,
107  * remove it */
108  if (!segment_manager_has_fifos (sm))
110  }
111 
112  if (CLIB_DEBUG)
113  clib_memset (app_wrk, 0xfe, sizeof (*app_wrk));
114  pool_put (app_workers, app_wrk);
115 }
116 
119 {
120  app_worker_t *app_wrk;
121  app_wrk = app_worker_get_if_valid (wrk_index);
122  if (!app_wrk)
123  return 0;
124  return application_get_if_valid (app_wrk->app_index);
125 }
126 
127 static segment_manager_t *
129 {
130  segment_manager_t *sm = 0;
131 
132  /* If the first segment manager is not in use, don't allocate a new one */
134  && app_wrk->first_segment_manager_in_use == 0)
135  {
137  app_wrk->first_segment_manager_in_use = 1;
138  return sm;
139  }
140 
141  sm = segment_manager_alloc ();
142  sm->app_wrk_index = app_wrk->wrk_index;
143 
144  return sm;
145 }
146 
147 static int
149 {
150  svm_fifo_t *rx_fifo = 0, *tx_fifo = 0;
151  int rv;
152 
153  if ((rv = segment_manager_alloc_session_fifos (sm, &rx_fifo, &tx_fifo)))
154  return rv;
155 
156  rx_fifo->master_session_index = s->session_index;
157  rx_fifo->master_thread_index = s->thread_index;
158 
159  tx_fifo->master_session_index = s->session_index;
160  tx_fifo->master_thread_index = s->thread_index;
161 
162  s->rx_fifo = rx_fifo;
163  s->tx_fifo = tx_fifo;
164  return 0;
165 }
166 
167 int
169 {
170  segment_manager_t *sm;
171 
172  /* Allocate segment manager. All sessions derived out of a listen session
173  * have fifos allocated by the same segment manager. */
174  if (!(sm = app_worker_alloc_segment_manager (app_wrk)))
175  return -1;
176 
177  /* Keep track of the segment manager for the listener or this worker */
179  segment_manager_index (sm));
180 
182  {
183  if (!ls->rx_fifo && app_worker_alloc_session_fifos (sm, ls))
184  return -1;
185  }
186  return 0;
187 }
188 
189 int
191  app_listener_t * app_listener)
192 {
193  session_t *ls;
194 
195  if (clib_bitmap_get (app_listener->workers, app_wrk->wrk_map_index))
196  return VNET_API_ERROR_ADDRESS_IN_USE;
197 
198  app_listener->workers = clib_bitmap_set (app_listener->workers,
199  app_wrk->wrk_map_index, 1);
200 
201  if (app_listener->session_index != SESSION_INVALID_INDEX)
202  {
203  ls = session_get (app_listener->session_index, 0);
204  if (app_worker_init_listener (app_wrk, ls))
205  return -1;
206  }
207 
208  if (app_listener->local_index != SESSION_INVALID_INDEX)
209  {
210  ls = session_get (app_listener->local_index, 0);
211  if (app_worker_init_listener (app_wrk, ls))
212  return -1;
213  }
214 
215  return 0;
216 }
217 
218 static void
220 {
221  session_handle_t handle;
222  segment_manager_t *sm;
223  uword *sm_indexp;
224 
225  handle = listen_session_get_handle (ls);
226  sm_indexp = hash_get (app_wrk->listeners_table, handle);
227  if (PREDICT_FALSE (!sm_indexp))
228  return;
229 
230  sm = segment_manager_get (*sm_indexp);
231  if (app_wrk->first_segment_manager == *sm_indexp)
232  {
233  /* Delete sessions but don't remove segment manager */
234  app_wrk->first_segment_manager_in_use = 0;
236  }
237  else
238  {
240  }
241  hash_unset (app_wrk->listeners_table, handle);
242 }
243 
244 int
246 {
247  session_t *ls;
248 
249  if (!clib_bitmap_get (al->workers, app_wrk->wrk_map_index))
250  return 0;
251 
253  {
255  app_worker_stop_listen_session (app_wrk, ls);
256  }
257 
259  {
260  ls = listen_session_get (al->local_index);
261  app_worker_stop_listen_session (app_wrk, ls);
262  }
263 
265  if (clib_bitmap_is_zero (al->workers))
267 
268  return 0;
269 }
270 
271 int
273 {
274  app_worker_t *app_wrk;
275  segment_manager_t *sm;
277 
279  app_wrk = application_listener_select_worker (listener);
280  s->app_wrk_index = app_wrk->wrk_index;
281 
282  sm = app_worker_get_listen_segment_manager (app_wrk, listener);
283  if (app_worker_alloc_session_fifos (sm, s))
284  return -1;
285 
286  return 0;
287 }
288 
289 int
291 {
292  application_t *app = application_get (app_wrk->app_index);
293  return app->cb_fns.session_accept_callback (s);
294 }
295 
296 int
298 {
299  application_t *app = application_get (app_wrk->app_index);
300  segment_manager_t *sm;
301 
302  /* Allocate fifos for session, unless the app is a builtin proxy */
303  if (!application_is_builtin_proxy (app))
304  {
306  if (app_worker_alloc_session_fifos (sm, s))
307  return -1;
308  }
309  return 0;
310 }
311 
312 int
314 {
315  application_t *app = application_get (app_wrk->app_index);
316  return app->cb_fns.session_connected_callback (app_wrk->wrk_index, opaque,
317  s, s == 0 /* is_fail */ );
318 }
319 
320 int
322 {
323  application_t *app = application_get (app_wrk->app_index);
324  app->cb_fns.session_disconnect_callback (s);
325  return 0;
326 }
327 
328 int
330 {
331  application_t *app = application_get (app_wrk->app_index);
332  if (app->cb_fns.session_transport_closed_callback)
333  app->cb_fns.session_transport_closed_callback (s);
334  return 0;
335 }
336 
337 int
339 {
340  application_t *app = application_get (app_wrk->app_index);
341  app->cb_fns.session_reset_callback (s);
342  return 0;
343 }
344 
345 int
348 {
349  application_t *app = application_get (app_wrk->app_index);
350  if (app->cb_fns.session_cleanup_callback)
351  app->cb_fns.session_cleanup_callback (s, ntf);
352  return 0;
353 }
354 
355 int
357 {
358  application_t *app = application_get (app_wrk->app_index);
359  app->cb_fns.builtin_app_rx_callback (s);
360  return 0;
361 }
362 
363 int
365 {
366  application_t *app = application_get (app_wrk->app_index);
367 
368  if (!app->cb_fns.builtin_app_tx_callback)
369  return 0;
370 
371  app->cb_fns.builtin_app_tx_callback (s);
372  return 0;
373 }
374 
375 int
377  session_handle_t new_sh)
378 {
379  application_t *app = application_get (app_wrk->app_index);
380  app->cb_fns.session_migrate_callback (s, new_sh);
381  return 0;
382 }
383 
384 int
386 {
387  segment_manager_t *sm;
388  svm_fifo_t *rxf, *txf;
389 
390  if (s->session_state == SESSION_STATE_LISTENING)
391  return application_change_listener_owner (s, app_wrk);
392 
393  s->app_wrk_index = app_wrk->wrk_index;
394 
395  rxf = s->rx_fifo;
396  txf = s->tx_fifo;
397 
398  if (!rxf || !txf)
399  return 0;
400 
401  s->rx_fifo = 0;
402  s->tx_fifo = 0;
403 
405  if (app_worker_alloc_session_fifos (sm, s))
406  return -1;
407 
408  if (!svm_fifo_is_empty_cons (rxf))
409  svm_fifo_clone (s->rx_fifo, rxf);
410 
411  if (!svm_fifo_is_empty_cons (txf))
412  svm_fifo_clone (s->tx_fifo, txf);
413 
415 
416  return 0;
417 }
418 
419 int
421  u32 api_context)
422 {
423  int rv;
424 
425  /* Make sure we have a segment manager for connects */
427 
428  if ((rv = session_open (app->wrk_index, sep, api_context)))
429  return rv;
430 
431  return 0;
432 }
433 
434 int
436 {
437  segment_manager_t *sm;
438 
440  {
441  sm = app_worker_alloc_segment_manager (app_wrk);
442  if (sm == 0)
443  return -1;
445  }
446  return 0;
447 }
448 
451 {
452  ASSERT (app->connects_seg_manager != (u32) ~ 0);
454 }
455 
458 {
459  if (app_wrk->connects_seg_manager == (u32) ~ 0)
461  return segment_manager_get (app_wrk->connects_seg_manager);
462 }
463 
467 {
468  uword *smp;
469  smp = hash_get (app->listeners_table, listen_session_get_handle (listener));
470  ALWAYS_ASSERT (smp != 0);
471  return segment_manager_get (*smp);
472 }
473 
474 session_t *
476  u8 transport_proto)
477 {
479  u64 handle;
480  u32 sm_index;
481  u8 sst;
482 
483  sst = session_type_from_proto_and_ip (transport_proto,
484  fib_proto == FIB_PROTOCOL_IP4);
485 
486  /* *INDENT-OFF* */
487  hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
488  listener = listen_session_get_from_handle (handle);
489  if (listener->session_type == sst
490  && !(listener->flags & SESSION_F_PROXY))
491  return listener;
492  }));
493  /* *INDENT-ON* */
494 
495  return 0;
496 }
497 
498 session_t *
500  u8 transport_proto)
501 {
503  u64 handle;
504  u32 sm_index;
505  u8 sst;
506 
507  sst = session_type_from_proto_and_ip (transport_proto,
508  fib_proto == FIB_PROTOCOL_IP4);
509 
510  /* *INDENT-OFF* */
511  hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
512  listener = listen_session_get_from_handle (handle);
513  if (listener->session_type == sst && (listener->flags & SESSION_F_PROXY))
514  return listener;
515  }));
516  /* *INDENT-ON* */
517 
518  return 0;
519 }
520 
521 /**
522  * Send an API message to the external app, to map new segment
523  */
524 int
525 app_worker_add_segment_notify (app_worker_t * app_wrk, u64 segment_handle)
526 {
527  application_t *app = application_get (app_wrk->app_index);
528  return app->cb_fns.add_segment_callback (app_wrk->api_client_index,
529  segment_handle);
530 }
531 
532 int
533 app_worker_del_segment_notify (app_worker_t * app_wrk, u64 segment_handle)
534 {
535  application_t *app = application_get (app_wrk->app_index);
536  return app->cb_fns.del_segment_callback (app_wrk->api_client_index,
537  segment_handle);
538 }
539 
540 static inline u8
542 {
543  return app_wrk->app_is_builtin;
544 }
545 
546 static inline int
548 {
549  session_event_t *evt;
550  svm_msg_q_msg_t msg;
551  svm_msg_q_t *mq;
552 
553  if (app_worker_application_is_builtin (app_wrk))
554  return app_worker_builtin_rx (app_wrk, s);
555 
556  /* Make sure the session is in established state within external apps.
557  * Should be removed once we confirm closes to apps */
558  if (PREDICT_FALSE (s->session_state != SESSION_STATE_READY
559  && s->session_state != SESSION_STATE_LISTENING))
560  return 0;
561 
562  if (svm_fifo_has_event (s->rx_fifo))
563  return 0;
564 
565  mq = app_wrk->event_queue;
566  svm_msg_q_lock (mq);
567 
568  if (PREDICT_FALSE (svm_msg_q_is_full (mq)))
569  {
570  clib_warning ("evt q full");
571  svm_msg_q_unlock (mq);
572  return -1;
573  }
574 
576  {
577  clib_warning ("evt q rings full");
578  svm_msg_q_unlock (mq);
579  return -1;
580  }
581 
583  evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
584  evt->session_index = s->rx_fifo->client_session_index;
585  evt->event_type = SESSION_IO_EVT_RX;
586 
587  (void) svm_fifo_set_event (s->rx_fifo);
588  svm_msg_q_add_and_unlock (mq, &msg);
589 
590  return 0;
591 }
592 
593 static inline int
595 {
596  svm_msg_q_t *mq;
597  session_event_t *evt;
598  svm_msg_q_msg_t msg;
599 
600  if (app_worker_application_is_builtin (app_wrk))
601  return app_worker_builtin_tx (app_wrk, s);
602 
603  mq = app_wrk->event_queue;
604  svm_msg_q_lock (mq);
605 
606  if (PREDICT_FALSE (svm_msg_q_is_full (mq)))
607  {
608  clib_warning ("evt q full");
609  svm_msg_q_unlock (mq);
610  return -1;
611  }
612 
614  {
615  clib_warning ("evt q rings full");
616  svm_msg_q_unlock (mq);
617  return -1;
618  }
619 
621  evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
622  evt->event_type = SESSION_IO_EVT_TX;
623  evt->session_index = s->tx_fifo->client_session_index;
624 
625  svm_msg_q_add_and_unlock (mq, &msg);
626  return 0;
627 }
628 
629 /* *INDENT-OFF* */
631  session_t *s);
635 };
636 /* *INDENT-ON* */
637 
638 /**
639  * Send event to application
640  *
641  * Logic from queue perspective is blocking. However, if queue is full,
642  * we return.
643  */
644 int
646  u8 evt_type)
647 {
648  return app_send_evt_handler_fns[evt_type] (app, s);
649 }
650 
651 u8 *
652 format_app_worker_listener (u8 * s, va_list * args)
653 {
654  app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
655  u64 handle = va_arg (*args, u64);
656  u32 sm_index = va_arg (*args, u32);
657  int verbose = va_arg (*args, int);
659  const u8 *app_name;
660  u8 *str;
661 
662  if (!app_wrk)
663  {
664  if (verbose)
665  s = format (s, "%-40s%-25s%=10s%-15s%-15s%-10s", "Connection", "App",
666  "Wrk", "API Client", "ListenerID", "SegManager");
667  else
668  s = format (s, "%-40s%-25s%=10s", "Connection", "App", "Wrk");
669 
670  return s;
671  }
672 
673  app_name = application_name_from_index (app_wrk->app_index);
674  listener = listen_session_get_from_handle (handle);
675  str = format (0, "%U", format_session, listener, verbose);
676 
677  if (verbose)
678  {
679  u8 *buf;
680  buf = format (0, "%u(%u)", app_wrk->wrk_map_index, app_wrk->wrk_index);
681  s = format (s, "%-40s%-25s%=10v%-15u%-15u%-10u", str, app_name,
682  buf, app_wrk->api_client_index, handle, sm_index);
683  vec_free (buf);
684  }
685  else
686  s = format (s, "%-40s%-25s%=10u", str, app_name, app_wrk->wrk_map_index);
687 
688  return s;
689 }
690 
691 u8 *
692 format_app_worker (u8 * s, va_list * args)
693 {
694  app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
695  u32 indent = 1;
696 
697  s = format (s, "%U wrk-index %u app-index %u map-index %u "
698  "api-client-index %d\n", format_white_space, indent,
699  app_wrk->wrk_index, app_wrk->app_index, app_wrk->wrk_map_index,
700  app_wrk->api_client_index);
701  return s;
702 }
703 
704 void
705 app_worker_format_connects (app_worker_t * app_wrk, int verbose)
706 {
707  segment_manager_t *sm;
708 
709  /* Header */
710  if (!app_wrk)
711  {
712  segment_manager_format_sessions (0, verbose);
713  return;
714  }
715 
716  if (app_wrk->connects_seg_manager == (u32) ~ 0)
717  return;
718 
720  segment_manager_format_sessions (sm, verbose);
721 }
722 
723 /*
724  * fd.io coding-style-patch-verification: ON
725  *
726  * Local Variables:
727  * eval: (c-set-style "gnu")
728  * End:
729  */
u32 segment_manager_index(segment_manager_t *sm)
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:1154
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:55
a
Definition: bitmap.h:538
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:1090
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)
int app_worker_connect_notify(app_worker_t *app_wrk, session_t *s, u32 opaque)
clib_memset(h->entries, 0, sizeof(h->entries[0]) *entries)
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:546
void segment_manager_format_sessions(segment_manager_t *sm, int verbose)
int app_worker_builtin_tx(app_worker_t *app_wrk, session_t *s)
static int svm_fifo_is_empty_cons(svm_fifo_t *f)
Check if fifo is empty optimized for consumer.
Definition: svm_fifo.h:565
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
int i
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:295
u8 * format(u8 *s, const char *fmt,...)
Definition: format.c:424
int vnet_unlisten(vnet_unlisten_args_t *a)
Definition: application.c:1039
int app_worker_reset_notify(app_worker_t *app_wrk, session_t *s)
uword * listeners_table
Lookup tables for listeners.
Definition: application.h:52
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:236
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:426
struct _svm_fifo svm_fifo_t
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, session_endpoint_t *sep, u32 api_context)
application_t * app_worker_get_app(u32 wrk_index)
void svm_fifo_clone(svm_fifo_t *df, svm_fifo_t *sf)
Clones fifo.
Definition: svm_fifo.c:1130
u32 first_segment_manager
First segment manager has in the the first segment the application&#39;s event fifo.
Definition: application.h:59
int segment_manager_alloc_session_fifos(segment_manager_t *sm, svm_fifo_t **rx_fifo, svm_fifo_t **tx_fifo)
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:79
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:80
#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)
int app_worker_transport_closed_notify(app_worker_t *app_wrk, session_t *s)
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:514
void app_worker_free(app_worker_t *app_wrk)
u8 * format_app_worker_listener(u8 *s, va_list *args)
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:352
#define pool_put(P, E)
Free an object E in pool P.
Definition: pool.h:286
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:112
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:538
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:748
session_t * app_worker_proxy_listener(app_worker_t *app_wrk, u8 fib_proto, u8 transport_proto)
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 void svm_msg_q_unlock(svm_msg_q_t *mq)
Unlock message queue.
segment_manager_t * segment_manager_alloc(void)
#define vec_free(V)
Free vector&#39;s memory (no header).
Definition: vec.h:341
#define clib_warning(format, args...)
Definition: error.h:59
clib_bitmap_t * workers
workers accepting connections
Definition: application.h:75
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:283
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)
int app_worker_own_session(app_worker_t *app_wrk, session_t *s)
application_t * application_get(u32 app_index)
Definition: application.c:418
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:666
session_cb_vft_t cb_fns
Callbacks: shoulder-taps for the server/client.
Definition: application.h:95
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:89
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)
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:104
u64 uword
Definition: types.h:112
void segment_manager_del_sessions(segment_manager_t *sm)
Initiate disconnects for all sessions &#39;owned&#39; by a segment manager.
connectionless service
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:230
session_cleanup_ntf_t
u32 app_index
Index of owning app.
Definition: application.h:43
u8 * format_app_worker(u8 *s, va_list *args)
int app_worker_lock_and_send_event(app_worker_t *app, session_t *s, u8 evt_type)
Send event to application.
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:734
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:1135
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
static transport_service_type_t session_transport_service_type(session_t *s)
#define APP_INVALID_SEGMENT_MANAGER_INDEX
Definition: application.h:169
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:569
u8 first_segment_manager_in_use
Definition: application.h:60