blob: 30edf3c32cc0ff6e4babb5ea0a80a5abac7626f2 [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 pool_put (app_workers, app_wrk);
113 if (CLIB_DEBUG)
114 clib_memset (app_wrk, 0xfe, sizeof (*app_wrk));
115}
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 Coras1219b2d2019-04-23 15:53:43 -0700153 if ((rv = segment_manager_alloc_session_fifos (sm, &rx_fifo, &tx_fifo)))
Florin Corasa27a46e2019-02-18 13:02:28 -0800154 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;
Florin Corasa27a46e2019-02-18 13:02:28 -0800164 return 0;
165}
166
Florin Coras623eb562019-02-03 19:28:34 -0800167int
Florin Corasd4295e62019-02-22 13:11:38 -0800168app_worker_init_listener (app_worker_t * app_wrk, session_t * ls)
Florin Coras623eb562019-02-03 19:28:34 -0800169{
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
Florin Corasc9940fc2019-02-05 20:55:11 -0800177 /* Keep track of the segment manager for the listener or this worker */
Florin Coras623eb562019-02-03 19:28:34 -0800178 hash_set (app_wrk->listeners_table, listen_session_get_handle (ls),
179 segment_manager_index (sm));
180
Florin Corasc9940fc2019-02-05 20:55:11 -0800181 if (session_transport_service_type (ls) == TRANSPORT_SERVICE_CL)
Florin Coras623eb562019-02-03 19:28:34 -0800182 {
Florin Corasa27a46e2019-02-18 13:02:28 -0800183 if (!ls->rx_fifo && app_worker_alloc_session_fifos (sm, ls))
Florin Coras623eb562019-02-03 19:28:34 -0800184 return -1;
185 }
186 return 0;
187}
188
189int
Florin Corasd4295e62019-02-22 13:11:38 -0800190app_worker_start_listen (app_worker_t * app_wrk,
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
Florin Coras2b81e3c2019-02-27 07:55:46 -0800218static void
219app_worker_stop_listen_session (app_worker_t * app_wrk, session_t * ls)
Florin Coras623eb562019-02-03 19:28:34 -0800220{
Florin Corasc9940fc2019-02-05 20:55:11 -0800221 session_handle_t handle;
Florin Coras623eb562019-02-03 19:28:34 -0800222 segment_manager_t *sm;
223 uword *sm_indexp;
Florin Coras2b81e3c2019-02-27 07:55:46 -0800224
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;
235 segment_manager_del_sessions (sm);
236 }
237 else
238 {
Florin Coras88001c62019-04-24 14:44:46 -0700239 segment_manager_init_free (sm);
Florin Coras2b81e3c2019-02-27 07:55:46 -0800240 }
241 hash_unset (app_wrk->listeners_table, handle);
242}
243
244int
245app_worker_stop_listen (app_worker_t * app_wrk, app_listener_t * al)
246{
Florin Corasd4295e62019-02-22 13:11:38 -0800247 session_t *ls;
Florin Coras623eb562019-02-03 19:28:34 -0800248
Florin Corasc9940fc2019-02-05 20:55:11 -0800249 if (!clib_bitmap_get (al->workers, app_wrk->wrk_map_index))
250 return 0;
251
252 if (al->session_index != SESSION_INVALID_INDEX)
Florin Coras623eb562019-02-03 19:28:34 -0800253 {
Florin Corasc9940fc2019-02-05 20:55:11 -0800254 ls = listen_session_get (al->session_index);
Florin Coras2b81e3c2019-02-27 07:55:46 -0800255 app_worker_stop_listen_session (app_wrk, ls);
Florin Coras623eb562019-02-03 19:28:34 -0800256 }
257
Florin Corasc9940fc2019-02-05 20:55:11 -0800258 if (al->local_index != SESSION_INVALID_INDEX)
Florin Coras623eb562019-02-03 19:28:34 -0800259 {
Florin Corasd4295e62019-02-22 13:11:38 -0800260 ls = listen_session_get (al->local_index);
Florin Coras2b81e3c2019-02-27 07:55:46 -0800261 app_worker_stop_listen_session (app_wrk, ls);
Florin Coras623eb562019-02-03 19:28:34 -0800262 }
Florin Corasc9940fc2019-02-05 20:55:11 -0800263
264 clib_bitmap_set_no_check (al->workers, app_wrk->wrk_map_index, 0);
265 if (clib_bitmap_is_zero (al->workers))
266 app_listener_cleanup (al);
Florin Coras623eb562019-02-03 19:28:34 -0800267
268 return 0;
269}
270
271int
Florin Corasa27a46e2019-02-18 13:02:28 -0800272app_worker_init_accepted (session_t * s)
273{
274 app_worker_t *app_wrk;
275 segment_manager_t *sm;
276 session_t *listener;
277
Nathan Skrzypczak2f0f96b2019-06-13 10:14:28 +0200278 listener = listen_session_get_from_handle (s->listener_handle);
Florin Corasa27a46e2019-02-18 13:02:28 -0800279 app_wrk = application_listener_select_worker (listener);
280 s->app_wrk_index = app_wrk->wrk_index;
Florin Coras2b81e3c2019-02-27 07:55:46 -0800281
Florin Corasa27a46e2019-02-18 13:02:28 -0800282 sm = app_worker_get_listen_segment_manager (app_wrk, listener);
Florin Coras2b81e3c2019-02-27 07:55:46 -0800283 if (app_worker_alloc_session_fifos (sm, s))
284 return -1;
285
286 return 0;
Florin Corasa27a46e2019-02-18 13:02:28 -0800287}
288
289int
290app_worker_accept_notify (app_worker_t * app_wrk, session_t * s)
291{
292 application_t *app = application_get (app_wrk->app_index);
293 return app->cb_fns.session_accept_callback (s);
294}
295
296int
297app_worker_init_connected (app_worker_t * app_wrk, session_t * s)
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 {
305 sm = app_worker_get_connect_segment_manager (app_wrk);
306 if (app_worker_alloc_session_fifos (sm, s))
307 return -1;
308 }
309 return 0;
310}
311
312int
313app_worker_connect_notify (app_worker_t * app_wrk, session_t * s, u32 opaque)
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
320int
Florin Corasbf7ce2c2019-03-06 14:44:42 -0800321app_worker_close_notify (app_worker_t * app_wrk, session_t * s)
322{
323 application_t *app = application_get (app_wrk->app_index);
324 app->cb_fns.session_disconnect_callback (s);
325 return 0;
326}
327
328int
Florin Coras692b9492019-07-12 15:01:53 -0700329app_worker_transport_closed_notify (app_worker_t * app_wrk, session_t * s)
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
337int
Florin Coras69b68ef2019-04-02 11:38:51 -0700338app_worker_reset_notify (app_worker_t * app_wrk, session_t * s)
339{
340 application_t *app = application_get (app_wrk->app_index);
341 app->cb_fns.session_reset_callback (s);
342 return 0;
343}
344
345int
Florin Coras70f26d52019-07-08 11:47:18 -0700346app_worker_cleanup_notify (app_worker_t * app_wrk, session_t * s,
347 session_cleanup_ntf_t ntf)
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
355int
Florin Corasbf7ce2c2019-03-06 14:44:42 -0800356app_worker_builtin_rx (app_worker_t * app_wrk, session_t * s)
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
363int
Florin Coras0e573f52019-05-07 16:28:16 -0700364app_worker_builtin_tx (app_worker_t * app_wrk, session_t * s)
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
375int
Florin Coras49568af2019-07-31 16:46:24 -0700376app_worker_migrate_notify (app_worker_t * app_wrk, session_t * s,
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
384int
Florin Coras623eb562019-02-03 19:28:34 -0800385app_worker_own_session (app_worker_t * app_wrk, session_t * s)
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
404 sm = app_worker_get_or_alloc_connect_segment_manager (app_wrk);
Florin Corasa27a46e2019-02-18 13:02:28 -0800405 if (app_worker_alloc_session_fifos (sm, s))
Florin Coras623eb562019-02-03 19:28:34 -0800406 return -1;
407
Sirshak Das28aa5392019-02-05 01:33:33 -0600408 if (!svm_fifo_is_empty_cons (rxf))
409 svm_fifo_clone (s->rx_fifo, rxf);
Florin Coras623eb562019-02-03 19:28:34 -0800410
Sirshak Das28aa5392019-02-05 01:33:33 -0600411 if (!svm_fifo_is_empty_cons (txf))
412 svm_fifo_clone (s->tx_fifo, txf);
413
Florin Coras19223e02019-03-03 14:56:05 -0800414 segment_manager_dealloc_fifos (rxf, txf);
Florin Coras623eb562019-02-03 19:28:34 -0800415
416 return 0;
417}
418
419int
Florin Corasc9940fc2019-02-05 20:55:11 -0800420app_worker_connect_session (app_worker_t * app, session_endpoint_t * sep,
421 u32 api_context)
Florin Coras623eb562019-02-03 19:28:34 -0800422{
423 int rv;
424
425 /* Make sure we have a segment manager for connects */
426 app_worker_alloc_connects_segment_manager (app);
427
428 if ((rv = session_open (app->wrk_index, sep, api_context)))
429 return rv;
430
431 return 0;
432}
433
434int
435app_worker_alloc_connects_segment_manager (app_worker_t * app_wrk)
436{
437 segment_manager_t *sm;
438
439 if (app_wrk->connects_seg_manager == APP_INVALID_SEGMENT_MANAGER_INDEX)
440 {
441 sm = app_worker_alloc_segment_manager (app_wrk);
442 if (sm == 0)
443 return -1;
444 app_wrk->connects_seg_manager = segment_manager_index (sm);
445 }
446 return 0;
447}
448
449segment_manager_t *
450app_worker_get_connect_segment_manager (app_worker_t * app)
451{
452 ASSERT (app->connects_seg_manager != (u32) ~ 0);
453 return segment_manager_get (app->connects_seg_manager);
454}
455
456segment_manager_t *
457app_worker_get_or_alloc_connect_segment_manager (app_worker_t * app_wrk)
458{
459 if (app_wrk->connects_seg_manager == (u32) ~ 0)
460 app_worker_alloc_connects_segment_manager (app_wrk);
461 return segment_manager_get (app_wrk->connects_seg_manager);
462}
463
464segment_manager_t *
465app_worker_get_listen_segment_manager (app_worker_t * app,
466 session_t * listener)
467{
468 uword *smp;
469 smp = hash_get (app->listeners_table, listen_session_get_handle (listener));
470 ASSERT (smp != 0);
471 return segment_manager_get (*smp);
472}
473
474session_t *
Florin Corasc9940fc2019-02-05 20:55:11 -0800475app_worker_first_listener (app_worker_t * app_wrk, u8 fib_proto,
Florin Coras623eb562019-02-03 19:28:34 -0800476 u8 transport_proto)
477{
478 session_t *listener;
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* */
Florin Corasc9940fc2019-02-05 20:55:11 -0800487 hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
Florin Coras623eb562019-02-03 19:28:34 -0800488 listener = listen_session_get_from_handle (handle);
489 if (listener->session_type == sst
Florin Corasd5c604d2019-03-18 09:06:35 -0700490 && !(listener->flags & SESSION_F_PROXY))
Florin Coras623eb562019-02-03 19:28:34 -0800491 return listener;
492 }));
493 /* *INDENT-ON* */
494
495 return 0;
496}
497
498session_t *
Florin Corasc9940fc2019-02-05 20:55:11 -0800499app_worker_proxy_listener (app_worker_t * app_wrk, u8 fib_proto,
Florin Coras623eb562019-02-03 19:28:34 -0800500 u8 transport_proto)
501{
502 session_t *listener;
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* */
Florin Corasc9940fc2019-02-05 20:55:11 -0800511 hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
Florin Coras623eb562019-02-03 19:28:34 -0800512 listener = listen_session_get_from_handle (handle);
Florin Corasd5c604d2019-03-18 09:06:35 -0700513 if (listener->session_type == sst && (listener->flags & SESSION_F_PROXY))
Florin Coras623eb562019-02-03 19:28:34 -0800514 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 */
524int
Florin Coras2b81e3c2019-02-27 07:55:46 -0800525app_worker_add_segment_notify (app_worker_t * app_wrk, u64 segment_handle)
Florin Coras623eb562019-02-03 19:28:34 -0800526{
Florin Coras623eb562019-02-03 19:28:34 -0800527 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
Florin Coras2b81e3c2019-02-27 07:55:46 -0800532int
533app_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
Florin Coras31c99552019-03-01 13:00:58 -0800540static inline u8
Florin Coras623eb562019-02-03 19:28:34 -0800541app_worker_application_is_builtin (app_worker_t * app_wrk)
542{
543 return app_wrk->app_is_builtin;
544}
545
546static inline int
Florin Coras2b5fed82019-07-25 14:51:09 -0700547app_send_io_evt_rx (app_worker_t * app_wrk, session_t * s)
Florin Coras623eb562019-02-03 19:28:34 -0800548{
549 session_event_t *evt;
550 svm_msg_q_msg_t msg;
551 svm_msg_q_t *mq;
552
Florin Coras5c290292019-09-19 08:19:44 -0700553 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 */
Florin Coras623eb562019-02-03 19:28:34 -0800558 if (PREDICT_FALSE (s->session_state != SESSION_STATE_READY
559 && s->session_state != SESSION_STATE_LISTENING))
Florin Coras096f2f82019-04-02 10:17:48 -0700560 return 0;
Florin Coras623eb562019-02-03 19:28:34 -0800561
Florin Coras653e43f2019-03-04 10:56:23 -0800562 if (svm_fifo_has_event (s->rx_fifo))
Florin Coras623eb562019-02-03 19:28:34 -0800563 return 0;
564
565 mq = app_wrk->event_queue;
Florin Coras2b5fed82019-07-25 14:51:09 -0700566 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 }
Florin Coras623eb562019-02-03 19:28:34 -0800574
575 if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
576 {
577 clib_warning ("evt q rings full");
Florin Coras2b5fed82019-07-25 14:51:09 -0700578 svm_msg_q_unlock (mq);
Florin Coras623eb562019-02-03 19:28:34 -0800579 return -1;
580 }
581
582 msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
Florin Coras623eb562019-02-03 19:28:34 -0800583 evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
Florin Corasc0737e92019-03-04 14:19:39 -0800584 evt->session_index = s->rx_fifo->client_session_index;
Florin Corasf6c43132019-03-01 12:41:21 -0800585 evt->event_type = SESSION_IO_EVT_RX;
Florin Coras623eb562019-02-03 19:28:34 -0800586
587 (void) svm_fifo_set_event (s->rx_fifo);
Florin Coras2b5fed82019-07-25 14:51:09 -0700588 svm_msg_q_add_and_unlock (mq, &msg);
Florin Coras623eb562019-02-03 19:28:34 -0800589
Florin Coras623eb562019-02-03 19:28:34 -0800590 return 0;
591}
592
593static inline int
Florin Coras2b5fed82019-07-25 14:51:09 -0700594app_send_io_evt_tx (app_worker_t * app_wrk, session_t * s)
Florin Coras623eb562019-02-03 19:28:34 -0800595{
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))
Florin Coras0e573f52019-05-07 16:28:16 -0700601 return app_worker_builtin_tx (app_wrk, s);
Florin Coras623eb562019-02-03 19:28:34 -0800602
603 mq = app_wrk->event_queue;
Florin Coras2b5fed82019-07-25 14:51:09 -0700604 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 }
Florin Coras623eb562019-02-03 19:28:34 -0800612
613 if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
614 {
615 clib_warning ("evt q rings full");
Florin Coras2b5fed82019-07-25 14:51:09 -0700616 svm_msg_q_unlock (mq);
Florin Coras623eb562019-02-03 19:28:34 -0800617 return -1;
618 }
619
620 msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
Florin Coras623eb562019-02-03 19:28:34 -0800621 evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
Florin Corasf6c43132019-03-01 12:41:21 -0800622 evt->event_type = SESSION_IO_EVT_TX;
Florin Corasc0737e92019-03-04 14:19:39 -0800623 evt->session_index = s->tx_fifo->client_session_index;
Florin Coras623eb562019-02-03 19:28:34 -0800624
Florin Coras2b5fed82019-07-25 14:51:09 -0700625 svm_msg_q_add_and_unlock (mq, &msg);
626 return 0;
Florin Coras623eb562019-02-03 19:28:34 -0800627}
628
629/* *INDENT-OFF* */
630typedef int (app_send_evt_handler_fn) (app_worker_t *app,
Florin Coras2b5fed82019-07-25 14:51:09 -0700631 session_t *s);
Florin Coras653e43f2019-03-04 10:56:23 -0800632static app_send_evt_handler_fn * const app_send_evt_handler_fns[2] = {
Florin Coras623eb562019-02-03 19:28:34 -0800633 app_send_io_evt_rx,
Florin Coras623eb562019-02-03 19:28:34 -0800634 app_send_io_evt_tx,
635};
636/* *INDENT-ON* */
637
638/**
639 * Send event to application
640 *
Florin Coras623eb562019-02-03 19:28:34 -0800641 * Logic from queue perspective is blocking. However, if queue is full,
642 * we return.
643 */
644int
645app_worker_lock_and_send_event (app_worker_t * app, session_t * s,
646 u8 evt_type)
647{
Florin Coras2b5fed82019-07-25 14:51:09 -0700648 return app_send_evt_handler_fns[evt_type] (app, s);
Florin Coras623eb562019-02-03 19:28:34 -0800649}
650
Florin Coras623eb562019-02-03 19:28:34 -0800651u8 *
652format_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);
658 session_t *listener;
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);
Florin Coras31c99552019-03-01 13:00:58 -0800675 str = format (0, "%U", format_session, listener, verbose);
Florin Coras623eb562019-02-03 19:28:34 -0800676
677 if (verbose)
678 {
679 char buf[32];
680 sprintf (buf, "%u(%u)", app_wrk->wrk_map_index, app_wrk->wrk_index);
681 s = format (s, "%-40s%-25s%=10s%-15u%-15u%-10u", str, app_name,
682 buf, app_wrk->api_client_index, handle, sm_index);
683 }
684 else
685 s = format (s, "%-40s%-25s%=10u", str, app_name, app_wrk->wrk_map_index);
686
687 return s;
688}
689
690u8 *
691format_app_worker (u8 * s, va_list * args)
692{
693 app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
694 u32 indent = 1;
695
696 s = format (s, "%U wrk-index %u app-index %u map-index %u "
697 "api-client-index %d\n", format_white_space, indent,
698 app_wrk->wrk_index, app_wrk->app_index, app_wrk->wrk_map_index,
699 app_wrk->api_client_index);
700 return s;
701}
702
703void
704app_worker_format_connects (app_worker_t * app_wrk, int verbose)
705{
Florin Coras623eb562019-02-03 19:28:34 -0800706 segment_manager_t *sm;
Florin Coras623eb562019-02-03 19:28:34 -0800707
708 /* Header */
709 if (!app_wrk)
710 {
Florin Coras88001c62019-04-24 14:44:46 -0700711 segment_manager_format_sessions (0, verbose);
Florin Coras623eb562019-02-03 19:28:34 -0800712 return;
713 }
714
715 if (app_wrk->connects_seg_manager == (u32) ~ 0)
716 return;
717
Florin Coras623eb562019-02-03 19:28:34 -0800718 sm = segment_manager_get (app_wrk->connects_seg_manager);
Florin Coras88001c62019-04-24 14:44:46 -0700719 segment_manager_format_sessions (sm, verbose);
Florin Coras623eb562019-02-03 19:28:34 -0800720}
721
Florin Coras623eb562019-02-03 19:28:34 -0800722/*
723 * fd.io coding-style-patch-verification: ON
724 *
725 * Local Variables:
726 * eval: (c-set-style "gnu")
727 * End:
728 */