blob: a3dc32a5b1ef45c0cf59b880db9e7cb1277ba9b5 [file] [log] [blame]
Florin Coras623eb562019-02-03 19:28:34 -08001/*
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
16#include <vnet/session/application.h>
17#include <vnet/session/application_interface.h>
Florin Coras54a51fd2019-02-07 15:34:52 -080018#include <vnet/session/session.h>
Florin Coras623eb562019-02-03 19:28:34 -080019
20/**
21 * Pool of workers associated to apps
22 */
23static app_worker_t *app_workers;
24
Florin Coras623eb562019-02-03 19:28:34 -080025app_worker_t *
26app_worker_alloc (application_t * app)
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;
34 app_wrk->connects_seg_manager = APP_INVALID_SEGMENT_MANAGER_INDEX;
35 app_wrk->first_segment_manager = APP_INVALID_SEGMENT_MANAGER_INDEX;
Nathan Skrzypczakba65ca42019-05-16 16:35:40 +020036 APP_DBG ("New app %v worker %u", app->name, app_wrk->wrk_index);
Florin Coras623eb562019-02-03 19:28:34 -080037 return app_wrk;
38}
39
40app_worker_t *
41app_worker_get (u32 wrk_index)
42{
43 return pool_elt_at_index (app_workers, wrk_index);
44}
45
46app_worker_t *
47app_worker_get_if_valid (u32 wrk_index)
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
54void
55app_worker_free (app_worker_t * app_wrk)
56{
57 application_t *app = application_get (app_wrk->app_index);
Florin Corasc1a42652019-02-08 18:27:29 -080058 vnet_unlisten_args_t _a, *a = &_a;
Florin Coras623eb562019-02-03 19:28:34 -080059 u64 handle, *handles = 0;
60 segment_manager_t *sm;
Florin Coras87d66332019-06-11 12:31:31 -070061 session_t *ls;
Florin Coras623eb562019-02-03 19:28:34 -080062 u32 sm_index;
63 int i;
64
65 /*
66 * Listener cleanup
67 */
68
69 /* *INDENT-OFF* */
Florin Corasc9940fc2019-02-05 20:55:11 -080070 hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
71 ls = listen_session_get_from_handle (handle);
Florin Coras87d66332019-06-11 12:31:31 -070072 vec_add1 (handles, app_listen_session_handle (ls));
Florin Coras623eb562019-02-03 19:28:34 -080073 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 */
Florin Corasc1a42652019-02-08 18:27:29 -080084 (void) vnet_unlisten (a);
Florin Coras623eb562019-02-03 19:28:34 -080085 }
86
87 /*
88 * Connects segment manager cleanup
89 */
90
91 if (app_wrk->connects_seg_manager != APP_INVALID_SEGMENT_MANAGER_INDEX)
92 {
93 sm = segment_manager_get (app_wrk->connects_seg_manager);
94 sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
Florin Coras565115e2019-02-20 19:48:31 -080095 sm->first_is_protected = 0;
Florin Coras88001c62019-04-24 14:44:46 -070096 segment_manager_init_free (sm);
Florin Coras623eb562019-02-03 19:28:34 -080097 }
98
99 /* If first segment manager is used by a listener */
100 if (app_wrk->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX
101 && app_wrk->first_segment_manager != app_wrk->connects_seg_manager)
102 {
103 sm = segment_manager_get (app_wrk->first_segment_manager);
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))
Florin Coras88001c62019-04-24 14:44:46 -0700109 segment_manager_free (sm);
Florin Coras623eb562019-02-03 19:28:34 -0800110 }
111
Florin Coras623eb562019-02-03 19:28:34 -0800112 if (CLIB_DEBUG)
113 clib_memset (app_wrk, 0xfe, sizeof (*app_wrk));
BenoƮt Ganned4aeb842019-07-18 18:38:42 +0200114 pool_put (app_workers, app_wrk);
Florin Coras623eb562019-02-03 19:28:34 -0800115}
116
117application_t *
118app_worker_get_app (u32 wrk_index)
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
127static segment_manager_t *
128app_worker_alloc_segment_manager (app_worker_t * app_wrk)
129{
130 segment_manager_t *sm = 0;
131
132 /* If the first segment manager is not in use, don't allocate a new one */
133 if (app_wrk->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX
134 && app_wrk->first_segment_manager_in_use == 0)
135 {
136 sm = segment_manager_get (app_wrk->first_segment_manager);
137 app_wrk->first_segment_manager_in_use = 1;
138 return sm;
139 }
140
Florin Coras88001c62019-04-24 14:44:46 -0700141 sm = segment_manager_alloc ();
Florin Coras623eb562019-02-03 19:28:34 -0800142 sm->app_wrk_index = app_wrk->wrk_index;
143
144 return sm;
145}
146
Florin Corasa27a46e2019-02-18 13:02:28 -0800147static int
148app_worker_alloc_session_fifos (segment_manager_t * sm, session_t * s)
149{
150 svm_fifo_t *rx_fifo = 0, *tx_fifo = 0;
Florin Corasa27a46e2019-02-18 13:02:28 -0800151 int rv;
152
Florin Coras62ddc032019-12-08 18:30:42 -0800153 if ((rv = segment_manager_alloc_session_fifos (sm, s->thread_index,
154 &rx_fifo, &tx_fifo)))
Florin Corasa27a46e2019-02-18 13:02:28 -0800155 return rv;
156
157 rx_fifo->master_session_index = s->session_index;
158 rx_fifo->master_thread_index = s->thread_index;
159
160 tx_fifo->master_session_index = s->session_index;
161 tx_fifo->master_thread_index = s->thread_index;
162
163 s->rx_fifo = rx_fifo;
164 s->tx_fifo = tx_fifo;
Florin Corasa27a46e2019-02-18 13:02:28 -0800165 return 0;
166}
167
Florin Coras623eb562019-02-03 19:28:34 -0800168int
Florin Corasd4295e62019-02-22 13:11:38 -0800169app_worker_init_listener (app_worker_t * app_wrk, session_t * ls)
Florin Coras623eb562019-02-03 19:28:34 -0800170{
171 segment_manager_t *sm;
172
173 /* Allocate segment manager. All sessions derived out of a listen session
174 * have fifos allocated by the same segment manager. */
175 if (!(sm = app_worker_alloc_segment_manager (app_wrk)))
Florin Coras00e01d32019-10-21 16:07:46 -0700176 return SESSION_E_ALLOC;
Florin Coras623eb562019-02-03 19:28:34 -0800177
Florin Corasc9940fc2019-02-05 20:55:11 -0800178 /* Keep track of the segment manager for the listener or this worker */
Florin Coras623eb562019-02-03 19:28:34 -0800179 hash_set (app_wrk->listeners_table, listen_session_get_handle (ls),
180 segment_manager_index (sm));
181
Florin Coras87b7e3d2020-03-27 15:06:07 +0000182 if (transport_connection_is_cless (session_get_transport (ls)))
Florin Coras623eb562019-02-03 19:28:34 -0800183 {
Florin Coras87b7e3d2020-03-27 15:06:07 +0000184 if (ls->rx_fifo)
Florin Coras00e01d32019-10-21 16:07:46 -0700185 return SESSION_E_NOSUPPORT;
186 return app_worker_alloc_session_fifos (sm, ls);
Florin Coras623eb562019-02-03 19:28:34 -0800187 }
188 return 0;
189}
190
191int
Florin Corasd4295e62019-02-22 13:11:38 -0800192app_worker_start_listen (app_worker_t * app_wrk,
193 app_listener_t * app_listener)
194{
195 session_t *ls;
Florin Coras00e01d32019-10-21 16:07:46 -0700196 int rv;
Florin Corasd4295e62019-02-22 13:11:38 -0800197
198 if (clib_bitmap_get (app_listener->workers, app_wrk->wrk_map_index))
Florin Coras00e01d32019-10-21 16:07:46 -0700199 return SESSION_E_ALREADY_LISTENING;
Florin Corasd4295e62019-02-22 13:11:38 -0800200
201 app_listener->workers = clib_bitmap_set (app_listener->workers,
202 app_wrk->wrk_map_index, 1);
203
204 if (app_listener->session_index != SESSION_INVALID_INDEX)
205 {
206 ls = session_get (app_listener->session_index, 0);
Florin Coras00e01d32019-10-21 16:07:46 -0700207 if ((rv = app_worker_init_listener (app_wrk, ls)))
208 return rv;
Florin Corasd4295e62019-02-22 13:11:38 -0800209 }
210
211 if (app_listener->local_index != SESSION_INVALID_INDEX)
212 {
213 ls = session_get (app_listener->local_index, 0);
Florin Coras00e01d32019-10-21 16:07:46 -0700214 if ((rv = app_worker_init_listener (app_wrk, ls)))
215 return rv;
Florin Corasd4295e62019-02-22 13:11:38 -0800216 }
217
218 return 0;
219}
220
Florin Coras2b81e3c2019-02-27 07:55:46 -0800221static void
222app_worker_stop_listen_session (app_worker_t * app_wrk, session_t * ls)
Florin Coras623eb562019-02-03 19:28:34 -0800223{
Florin Corasc9940fc2019-02-05 20:55:11 -0800224 session_handle_t handle;
Florin Coras623eb562019-02-03 19:28:34 -0800225 segment_manager_t *sm;
226 uword *sm_indexp;
Florin Coras2b81e3c2019-02-27 07:55:46 -0800227
228 handle = listen_session_get_handle (ls);
229 sm_indexp = hash_get (app_wrk->listeners_table, handle);
230 if (PREDICT_FALSE (!sm_indexp))
231 return;
232
Florin Coras87b7e3d2020-03-27 15:06:07 +0000233 /* Dealloc fifos first, if any, to avoid cleanup attempt lower */
234 if (ls->rx_fifo)
235 {
236 segment_manager_dealloc_fifos (ls->rx_fifo, ls->tx_fifo);
237 ls->tx_fifo = ls->rx_fifo = 0;
238 }
239
Florin Coras2b81e3c2019-02-27 07:55:46 -0800240 sm = segment_manager_get (*sm_indexp);
241 if (app_wrk->first_segment_manager == *sm_indexp)
242 {
243 /* Delete sessions but don't remove segment manager */
244 app_wrk->first_segment_manager_in_use = 0;
245 segment_manager_del_sessions (sm);
246 }
247 else
248 {
Florin Coras88001c62019-04-24 14:44:46 -0700249 segment_manager_init_free (sm);
Florin Coras2b81e3c2019-02-27 07:55:46 -0800250 }
251 hash_unset (app_wrk->listeners_table, handle);
252}
253
254int
255app_worker_stop_listen (app_worker_t * app_wrk, app_listener_t * al)
256{
Florin Corasd4295e62019-02-22 13:11:38 -0800257 session_t *ls;
Florin Coras623eb562019-02-03 19:28:34 -0800258
Florin Corasc9940fc2019-02-05 20:55:11 -0800259 if (!clib_bitmap_get (al->workers, app_wrk->wrk_map_index))
260 return 0;
261
262 if (al->session_index != SESSION_INVALID_INDEX)
Florin Coras623eb562019-02-03 19:28:34 -0800263 {
Florin Corasc9940fc2019-02-05 20:55:11 -0800264 ls = listen_session_get (al->session_index);
Florin Coras2b81e3c2019-02-27 07:55:46 -0800265 app_worker_stop_listen_session (app_wrk, ls);
Florin Coras623eb562019-02-03 19:28:34 -0800266 }
267
Florin Corasc9940fc2019-02-05 20:55:11 -0800268 if (al->local_index != SESSION_INVALID_INDEX)
Florin Coras623eb562019-02-03 19:28:34 -0800269 {
Florin Corasd4295e62019-02-22 13:11:38 -0800270 ls = listen_session_get (al->local_index);
Florin Coras2b81e3c2019-02-27 07:55:46 -0800271 app_worker_stop_listen_session (app_wrk, ls);
Florin Coras623eb562019-02-03 19:28:34 -0800272 }
Florin Corasc9940fc2019-02-05 20:55:11 -0800273
274 clib_bitmap_set_no_check (al->workers, app_wrk->wrk_map_index, 0);
275 if (clib_bitmap_is_zero (al->workers))
276 app_listener_cleanup (al);
Florin Coras623eb562019-02-03 19:28:34 -0800277
278 return 0;
279}
280
281int
Florin Corasa27a46e2019-02-18 13:02:28 -0800282app_worker_init_accepted (session_t * s)
283{
284 app_worker_t *app_wrk;
285 segment_manager_t *sm;
286 session_t *listener;
Ryujiro Shibuyad8f48e22020-01-22 12:11:42 +0000287 application_t *app;
Florin Corasa27a46e2019-02-18 13:02:28 -0800288
Nathan Skrzypczak2f0f96b2019-06-13 10:14:28 +0200289 listener = listen_session_get_from_handle (s->listener_handle);
Florin Corasa27a46e2019-02-18 13:02:28 -0800290 app_wrk = application_listener_select_worker (listener);
291 s->app_wrk_index = app_wrk->wrk_index;
Florin Coras2b81e3c2019-02-27 07:55:46 -0800292
Ryujiro Shibuyad8f48e22020-01-22 12:11:42 +0000293 app = application_get (app_wrk->app_index);
294 if (app->cb_fns.fifo_tuning_callback)
295 s->flags |= SESSION_F_CUSTOM_FIFO_TUNING;
296
Florin Corasa27a46e2019-02-18 13:02:28 -0800297 sm = app_worker_get_listen_segment_manager (app_wrk, listener);
Florin Coras2b81e3c2019-02-27 07:55:46 -0800298 if (app_worker_alloc_session_fifos (sm, s))
299 return -1;
300
301 return 0;
Florin Corasa27a46e2019-02-18 13:02:28 -0800302}
303
304int
305app_worker_accept_notify (app_worker_t * app_wrk, session_t * s)
306{
307 application_t *app = application_get (app_wrk->app_index);
308 return app->cb_fns.session_accept_callback (s);
309}
310
311int
312app_worker_init_connected (app_worker_t * app_wrk, session_t * s)
313{
314 application_t *app = application_get (app_wrk->app_index);
315 segment_manager_t *sm;
316
317 /* Allocate fifos for session, unless the app is a builtin proxy */
318 if (!application_is_builtin_proxy (app))
319 {
320 sm = app_worker_get_connect_segment_manager (app_wrk);
Florin Coras00e01d32019-10-21 16:07:46 -0700321 return app_worker_alloc_session_fifos (sm, s);
Florin Corasa27a46e2019-02-18 13:02:28 -0800322 }
Ryujiro Shibuyad8f48e22020-01-22 12:11:42 +0000323
324 if (app->cb_fns.fifo_tuning_callback)
325 s->flags |= SESSION_F_CUSTOM_FIFO_TUNING;
326
Florin Corasa27a46e2019-02-18 13:02:28 -0800327 return 0;
328}
329
330int
Florin Coras00e01d32019-10-21 16:07:46 -0700331app_worker_connect_notify (app_worker_t * app_wrk, session_t * s,
332 session_error_t err, u32 opaque)
Florin Corasa27a46e2019-02-18 13:02:28 -0800333{
334 application_t *app = application_get (app_wrk->app_index);
335 return app->cb_fns.session_connected_callback (app_wrk->wrk_index, opaque,
Florin Coras00e01d32019-10-21 16:07:46 -0700336 s, err);
Florin Corasa27a46e2019-02-18 13:02:28 -0800337}
338
339int
Florin Corasbf7ce2c2019-03-06 14:44:42 -0800340app_worker_close_notify (app_worker_t * app_wrk, session_t * s)
341{
342 application_t *app = application_get (app_wrk->app_index);
343 app->cb_fns.session_disconnect_callback (s);
344 return 0;
345}
346
347int
Florin Coras692b9492019-07-12 15:01:53 -0700348app_worker_transport_closed_notify (app_worker_t * app_wrk, session_t * s)
349{
350 application_t *app = application_get (app_wrk->app_index);
351 if (app->cb_fns.session_transport_closed_callback)
352 app->cb_fns.session_transport_closed_callback (s);
353 return 0;
354}
355
356int
Florin Coras69b68ef2019-04-02 11:38:51 -0700357app_worker_reset_notify (app_worker_t * app_wrk, session_t * s)
358{
359 application_t *app = application_get (app_wrk->app_index);
360 app->cb_fns.session_reset_callback (s);
361 return 0;
362}
363
364int
Florin Coras70f26d52019-07-08 11:47:18 -0700365app_worker_cleanup_notify (app_worker_t * app_wrk, session_t * s,
366 session_cleanup_ntf_t ntf)
367{
368 application_t *app = application_get (app_wrk->app_index);
369 if (app->cb_fns.session_cleanup_callback)
370 app->cb_fns.session_cleanup_callback (s, ntf);
371 return 0;
372}
373
374int
Florin Corasbf7ce2c2019-03-06 14:44:42 -0800375app_worker_builtin_rx (app_worker_t * app_wrk, session_t * s)
376{
377 application_t *app = application_get (app_wrk->app_index);
378 app->cb_fns.builtin_app_rx_callback (s);
379 return 0;
380}
381
382int
Florin Coras0e573f52019-05-07 16:28:16 -0700383app_worker_builtin_tx (app_worker_t * app_wrk, session_t * s)
384{
385 application_t *app = application_get (app_wrk->app_index);
386
387 if (!app->cb_fns.builtin_app_tx_callback)
388 return 0;
389
390 app->cb_fns.builtin_app_tx_callback (s);
391 return 0;
392}
393
394int
Florin Coras49568af2019-07-31 16:46:24 -0700395app_worker_migrate_notify (app_worker_t * app_wrk, session_t * s,
396 session_handle_t new_sh)
397{
398 application_t *app = application_get (app_wrk->app_index);
399 app->cb_fns.session_migrate_callback (s, new_sh);
400 return 0;
401}
402
403int
Florin Coras623eb562019-02-03 19:28:34 -0800404app_worker_own_session (app_worker_t * app_wrk, session_t * s)
405{
406 segment_manager_t *sm;
407 svm_fifo_t *rxf, *txf;
408
409 if (s->session_state == SESSION_STATE_LISTENING)
410 return application_change_listener_owner (s, app_wrk);
411
412 s->app_wrk_index = app_wrk->wrk_index;
413
414 rxf = s->rx_fifo;
415 txf = s->tx_fifo;
416
417 if (!rxf || !txf)
418 return 0;
419
420 s->rx_fifo = 0;
421 s->tx_fifo = 0;
422
423 sm = app_worker_get_or_alloc_connect_segment_manager (app_wrk);
Florin Corasa27a46e2019-02-18 13:02:28 -0800424 if (app_worker_alloc_session_fifos (sm, s))
Florin Coras623eb562019-02-03 19:28:34 -0800425 return -1;
426
Sirshak Das28aa5392019-02-05 01:33:33 -0600427 if (!svm_fifo_is_empty_cons (rxf))
428 svm_fifo_clone (s->rx_fifo, rxf);
Florin Coras623eb562019-02-03 19:28:34 -0800429
Sirshak Das28aa5392019-02-05 01:33:33 -0600430 if (!svm_fifo_is_empty_cons (txf))
431 svm_fifo_clone (s->tx_fifo, txf);
432
Florin Coras19223e02019-03-03 14:56:05 -0800433 segment_manager_dealloc_fifos (rxf, txf);
Florin Coras623eb562019-02-03 19:28:34 -0800434
435 return 0;
436}
437
438int
Florin Corasc9940fc2019-02-05 20:55:11 -0800439app_worker_connect_session (app_worker_t * app, session_endpoint_t * sep,
440 u32 api_context)
Florin Coras623eb562019-02-03 19:28:34 -0800441{
442 int rv;
443
444 /* Make sure we have a segment manager for connects */
445 app_worker_alloc_connects_segment_manager (app);
446
447 if ((rv = session_open (app->wrk_index, sep, api_context)))
448 return rv;
449
450 return 0;
451}
452
453int
Ryujiro Shibuyad8f48e22020-01-22 12:11:42 +0000454app_worker_session_fifo_tuning (app_worker_t * app_wrk, session_t * s,
455 svm_fifo_t * f,
456 session_ft_action_t act, u32 len)
457{
458 application_t *app = application_get (app_wrk->app_index);
459 return app->cb_fns.fifo_tuning_callback (s, f, act, len);
460}
461
462int
Florin Coras623eb562019-02-03 19:28:34 -0800463app_worker_alloc_connects_segment_manager (app_worker_t * app_wrk)
464{
465 segment_manager_t *sm;
466
467 if (app_wrk->connects_seg_manager == APP_INVALID_SEGMENT_MANAGER_INDEX)
468 {
469 sm = app_worker_alloc_segment_manager (app_wrk);
470 if (sm == 0)
471 return -1;
472 app_wrk->connects_seg_manager = segment_manager_index (sm);
473 }
474 return 0;
475}
476
477segment_manager_t *
478app_worker_get_connect_segment_manager (app_worker_t * app)
479{
480 ASSERT (app->connects_seg_manager != (u32) ~ 0);
481 return segment_manager_get (app->connects_seg_manager);
482}
483
484segment_manager_t *
485app_worker_get_or_alloc_connect_segment_manager (app_worker_t * app_wrk)
486{
487 if (app_wrk->connects_seg_manager == (u32) ~ 0)
488 app_worker_alloc_connects_segment_manager (app_wrk);
489 return segment_manager_get (app_wrk->connects_seg_manager);
490}
491
492segment_manager_t *
493app_worker_get_listen_segment_manager (app_worker_t * app,
494 session_t * listener)
495{
496 uword *smp;
497 smp = hash_get (app->listeners_table, listen_session_get_handle (listener));
Dave Barach47d41ad2020-02-17 09:13:26 -0500498 ALWAYS_ASSERT (smp != 0);
Florin Coras623eb562019-02-03 19:28:34 -0800499 return segment_manager_get (*smp);
500}
501
502session_t *
Florin Corasc9940fc2019-02-05 20:55:11 -0800503app_worker_first_listener (app_worker_t * app_wrk, u8 fib_proto,
Florin Coras623eb562019-02-03 19:28:34 -0800504 u8 transport_proto)
505{
506 session_t *listener;
507 u64 handle;
508 u32 sm_index;
509 u8 sst;
510
511 sst = session_type_from_proto_and_ip (transport_proto,
512 fib_proto == FIB_PROTOCOL_IP4);
513
514 /* *INDENT-OFF* */
Florin Corasc9940fc2019-02-05 20:55:11 -0800515 hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
Florin Coras623eb562019-02-03 19:28:34 -0800516 listener = listen_session_get_from_handle (handle);
517 if (listener->session_type == sst
Florin Corasd5c604d2019-03-18 09:06:35 -0700518 && !(listener->flags & SESSION_F_PROXY))
Florin Coras623eb562019-02-03 19:28:34 -0800519 return listener;
520 }));
521 /* *INDENT-ON* */
522
523 return 0;
524}
525
526session_t *
Florin Corasc9940fc2019-02-05 20:55:11 -0800527app_worker_proxy_listener (app_worker_t * app_wrk, u8 fib_proto,
Florin Coras623eb562019-02-03 19:28:34 -0800528 u8 transport_proto)
529{
530 session_t *listener;
531 u64 handle;
532 u32 sm_index;
533 u8 sst;
534
535 sst = session_type_from_proto_and_ip (transport_proto,
536 fib_proto == FIB_PROTOCOL_IP4);
537
538 /* *INDENT-OFF* */
Florin Corasc9940fc2019-02-05 20:55:11 -0800539 hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
Florin Coras623eb562019-02-03 19:28:34 -0800540 listener = listen_session_get_from_handle (handle);
Florin Corasd5c604d2019-03-18 09:06:35 -0700541 if (listener->session_type == sst && (listener->flags & SESSION_F_PROXY))
Florin Coras623eb562019-02-03 19:28:34 -0800542 return listener;
543 }));
544 /* *INDENT-ON* */
545
546 return 0;
547}
548
549/**
550 * Send an API message to the external app, to map new segment
551 */
552int
Florin Coras2b81e3c2019-02-27 07:55:46 -0800553app_worker_add_segment_notify (app_worker_t * app_wrk, u64 segment_handle)
Florin Coras623eb562019-02-03 19:28:34 -0800554{
Florin Coras623eb562019-02-03 19:28:34 -0800555 application_t *app = application_get (app_wrk->app_index);
Florin Corasc4c4cf52019-08-24 18:17:34 -0700556
557 return app->cb_fns.add_segment_callback (app_wrk->wrk_index,
Florin Coras623eb562019-02-03 19:28:34 -0800558 segment_handle);
559}
560
Florin Coras2b81e3c2019-02-27 07:55:46 -0800561int
562app_worker_del_segment_notify (app_worker_t * app_wrk, u64 segment_handle)
563{
564 application_t *app = application_get (app_wrk->app_index);
Florin Corasc4c4cf52019-08-24 18:17:34 -0700565 return app->cb_fns.del_segment_callback (app_wrk->wrk_index,
Florin Coras2b81e3c2019-02-27 07:55:46 -0800566 segment_handle);
567}
568
Florin Coras31c99552019-03-01 13:00:58 -0800569static inline u8
Florin Coras623eb562019-02-03 19:28:34 -0800570app_worker_application_is_builtin (app_worker_t * app_wrk)
571{
572 return app_wrk->app_is_builtin;
573}
574
575static inline int
Florin Coras2b5fed82019-07-25 14:51:09 -0700576app_send_io_evt_rx (app_worker_t * app_wrk, session_t * s)
Florin Coras623eb562019-02-03 19:28:34 -0800577{
578 session_event_t *evt;
579 svm_msg_q_msg_t msg;
580 svm_msg_q_t *mq;
581
Florin Coras5c290292019-09-19 08:19:44 -0700582 if (app_worker_application_is_builtin (app_wrk))
583 return app_worker_builtin_rx (app_wrk, s);
584
Florin Coras653e43f2019-03-04 10:56:23 -0800585 if (svm_fifo_has_event (s->rx_fifo))
Florin Coras623eb562019-02-03 19:28:34 -0800586 return 0;
587
588 mq = app_wrk->event_queue;
Florin Coras2b5fed82019-07-25 14:51:09 -0700589 svm_msg_q_lock (mq);
590
591 if (PREDICT_FALSE (svm_msg_q_is_full (mq)))
592 {
593 clib_warning ("evt q full");
594 svm_msg_q_unlock (mq);
595 return -1;
596 }
Florin Coras623eb562019-02-03 19:28:34 -0800597
598 if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
599 {
600 clib_warning ("evt q rings full");
Florin Coras2b5fed82019-07-25 14:51:09 -0700601 svm_msg_q_unlock (mq);
Florin Coras623eb562019-02-03 19:28:34 -0800602 return -1;
603 }
604
605 msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
Florin Coras623eb562019-02-03 19:28:34 -0800606 evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
Florin Corasc0737e92019-03-04 14:19:39 -0800607 evt->session_index = s->rx_fifo->client_session_index;
Florin Corasf6c43132019-03-01 12:41:21 -0800608 evt->event_type = SESSION_IO_EVT_RX;
Florin Coras623eb562019-02-03 19:28:34 -0800609
610 (void) svm_fifo_set_event (s->rx_fifo);
Florin Coras2b5fed82019-07-25 14:51:09 -0700611 svm_msg_q_add_and_unlock (mq, &msg);
Florin Coras623eb562019-02-03 19:28:34 -0800612
Florin Coras623eb562019-02-03 19:28:34 -0800613 return 0;
614}
615
616static inline int
Florin Coras2b5fed82019-07-25 14:51:09 -0700617app_send_io_evt_tx (app_worker_t * app_wrk, session_t * s)
Florin Coras623eb562019-02-03 19:28:34 -0800618{
619 svm_msg_q_t *mq;
620 session_event_t *evt;
621 svm_msg_q_msg_t msg;
622
623 if (app_worker_application_is_builtin (app_wrk))
Florin Coras0e573f52019-05-07 16:28:16 -0700624 return app_worker_builtin_tx (app_wrk, s);
Florin Coras623eb562019-02-03 19:28:34 -0800625
626 mq = app_wrk->event_queue;
Florin Coras2b5fed82019-07-25 14:51:09 -0700627 svm_msg_q_lock (mq);
628
629 if (PREDICT_FALSE (svm_msg_q_is_full (mq)))
630 {
631 clib_warning ("evt q full");
632 svm_msg_q_unlock (mq);
633 return -1;
634 }
Florin Coras623eb562019-02-03 19:28:34 -0800635
636 if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
637 {
638 clib_warning ("evt q rings full");
Florin Coras2b5fed82019-07-25 14:51:09 -0700639 svm_msg_q_unlock (mq);
Florin Coras623eb562019-02-03 19:28:34 -0800640 return -1;
641 }
642
643 msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
Florin Coras623eb562019-02-03 19:28:34 -0800644 evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
Florin Corasf6c43132019-03-01 12:41:21 -0800645 evt->event_type = SESSION_IO_EVT_TX;
Florin Corasc0737e92019-03-04 14:19:39 -0800646 evt->session_index = s->tx_fifo->client_session_index;
Florin Coras623eb562019-02-03 19:28:34 -0800647
Florin Coras2b5fed82019-07-25 14:51:09 -0700648 svm_msg_q_add_and_unlock (mq, &msg);
649 return 0;
Florin Coras623eb562019-02-03 19:28:34 -0800650}
651
652/* *INDENT-OFF* */
653typedef int (app_send_evt_handler_fn) (app_worker_t *app,
Florin Coras2b5fed82019-07-25 14:51:09 -0700654 session_t *s);
Florin Coras653e43f2019-03-04 10:56:23 -0800655static app_send_evt_handler_fn * const app_send_evt_handler_fns[2] = {
Florin Coras623eb562019-02-03 19:28:34 -0800656 app_send_io_evt_rx,
Florin Coras623eb562019-02-03 19:28:34 -0800657 app_send_io_evt_tx,
658};
659/* *INDENT-ON* */
660
661/**
662 * Send event to application
663 *
Florin Coras623eb562019-02-03 19:28:34 -0800664 * Logic from queue perspective is blocking. However, if queue is full,
665 * we return.
666 */
667int
668app_worker_lock_and_send_event (app_worker_t * app, session_t * s,
669 u8 evt_type)
670{
Florin Coras2b5fed82019-07-25 14:51:09 -0700671 return app_send_evt_handler_fns[evt_type] (app, s);
Florin Coras623eb562019-02-03 19:28:34 -0800672}
673
Florin Coras623eb562019-02-03 19:28:34 -0800674u8 *
675format_app_worker_listener (u8 * s, va_list * args)
676{
677 app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
678 u64 handle = va_arg (*args, u64);
679 u32 sm_index = va_arg (*args, u32);
680 int verbose = va_arg (*args, int);
681 session_t *listener;
682 const u8 *app_name;
683 u8 *str;
684
685 if (!app_wrk)
686 {
687 if (verbose)
688 s = format (s, "%-40s%-25s%=10s%-15s%-15s%-10s", "Connection", "App",
689 "Wrk", "API Client", "ListenerID", "SegManager");
690 else
691 s = format (s, "%-40s%-25s%=10s", "Connection", "App", "Wrk");
692
693 return s;
694 }
695
696 app_name = application_name_from_index (app_wrk->app_index);
697 listener = listen_session_get_from_handle (handle);
Florin Coras31c99552019-03-01 13:00:58 -0800698 str = format (0, "%U", format_session, listener, verbose);
Florin Coras623eb562019-02-03 19:28:34 -0800699
700 if (verbose)
701 {
Dave Barach3e07a4a2020-04-04 10:05:48 -0400702 u8 *buf;
703 buf = format (0, "%u(%u)", app_wrk->wrk_map_index, app_wrk->wrk_index);
704 s = format (s, "%-40s%-25s%=10v%-15u%-15u%-10u", str, app_name,
Florin Coras623eb562019-02-03 19:28:34 -0800705 buf, app_wrk->api_client_index, handle, sm_index);
Dave Barach3e07a4a2020-04-04 10:05:48 -0400706 vec_free (buf);
Florin Coras623eb562019-02-03 19:28:34 -0800707 }
708 else
709 s = format (s, "%-40s%-25s%=10u", str, app_name, app_wrk->wrk_map_index);
710
711 return s;
712}
713
714u8 *
715format_app_worker (u8 * s, va_list * args)
716{
717 app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
718 u32 indent = 1;
719
720 s = format (s, "%U wrk-index %u app-index %u map-index %u "
721 "api-client-index %d\n", format_white_space, indent,
722 app_wrk->wrk_index, app_wrk->app_index, app_wrk->wrk_map_index,
723 app_wrk->api_client_index);
724 return s;
725}
726
727void
728app_worker_format_connects (app_worker_t * app_wrk, int verbose)
729{
Florin Coras623eb562019-02-03 19:28:34 -0800730 segment_manager_t *sm;
Florin Coras623eb562019-02-03 19:28:34 -0800731
732 /* Header */
733 if (!app_wrk)
734 {
Florin Coras88001c62019-04-24 14:44:46 -0700735 segment_manager_format_sessions (0, verbose);
Florin Coras623eb562019-02-03 19:28:34 -0800736 return;
737 }
738
739 if (app_wrk->connects_seg_manager == (u32) ~ 0)
740 return;
741
Florin Coras623eb562019-02-03 19:28:34 -0800742 sm = segment_manager_get (app_wrk->connects_seg_manager);
Florin Coras88001c62019-04-24 14:44:46 -0700743 segment_manager_format_sessions (sm, verbose);
Florin Coras623eb562019-02-03 19:28:34 -0800744}
745
Florin Coras623eb562019-02-03 19:28:34 -0800746/*
747 * fd.io coding-style-patch-verification: ON
748 *
749 * Local Variables:
750 * eval: (c-set-style "gnu")
751 * End:
752 */