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:
7 * http://www.apache.org/licenses/LICENSE-2.0
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.
16 #include <vnet/session/application.h>
17 #include <vnet/session/application_interface.h>
18 #include <vnet/session/session.h>
21 * Pool of workers associated to apps
23 static app_worker_t *app_workers;
26 app_worker_alloc (application_t * app)
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;
36 APP_DBG ("New app %v worker %u", app->name, app_wrk->wrk_index);
41 app_worker_get (u32 wrk_index)
43 return pool_elt_at_index (app_workers, wrk_index);
47 app_worker_get_if_valid (u32 wrk_index)
49 if (pool_is_free_index (app_workers, wrk_index))
51 return pool_elt_at_index (app_workers, wrk_index);
55 app_worker_free (app_worker_t * app_wrk)
57 application_t *app = application_get (app_wrk->app_index);
58 vnet_unlisten_args_t _a, *a = &_a;
59 u64 handle, *handles = 0;
60 segment_manager_t *sm;
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;
78 for (i = 0; i < vec_len (handles); i++)
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);
88 * Connects segment manager cleanup
91 if (app_wrk->connects_seg_manager != APP_INVALID_SEGMENT_MANAGER_INDEX)
93 sm = segment_manager_get (app_wrk->connects_seg_manager);
94 sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
95 sm->first_is_protected = 0;
96 segment_manager_init_free (sm);
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)
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,
108 if (!segment_manager_has_fifos (sm))
109 segment_manager_free (sm);
112 pool_put (app_workers, app_wrk);
114 clib_memset (app_wrk, 0xfe, sizeof (*app_wrk));
118 app_worker_get_app (u32 wrk_index)
120 app_worker_t *app_wrk;
121 app_wrk = app_worker_get_if_valid (wrk_index);
124 return application_get_if_valid (app_wrk->app_index);
127 static segment_manager_t *
128 app_worker_alloc_segment_manager (app_worker_t * app_wrk)
130 segment_manager_t *sm = 0;
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)
136 sm = segment_manager_get (app_wrk->first_segment_manager);
137 app_wrk->first_segment_manager_in_use = 1;
141 sm = segment_manager_alloc ();
142 sm->app_wrk_index = app_wrk->wrk_index;
148 app_worker_alloc_session_fifos (segment_manager_t * sm, session_t * s)
150 svm_fifo_t *rx_fifo = 0, *tx_fifo = 0;
153 if ((rv = segment_manager_alloc_session_fifos (sm, &rx_fifo, &tx_fifo)))
156 rx_fifo->master_session_index = s->session_index;
157 rx_fifo->master_thread_index = s->thread_index;
159 tx_fifo->master_session_index = s->session_index;
160 tx_fifo->master_thread_index = s->thread_index;
162 s->rx_fifo = rx_fifo;
163 s->tx_fifo = tx_fifo;
168 app_worker_init_listener (app_worker_t * app_wrk, session_t * ls)
170 segment_manager_t *sm;
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)))
177 /* Keep track of the segment manager for the listener or this worker */
178 hash_set (app_wrk->listeners_table, listen_session_get_handle (ls),
179 segment_manager_index (sm));
181 if (session_transport_service_type (ls) == TRANSPORT_SERVICE_CL)
183 if (!ls->rx_fifo && app_worker_alloc_session_fifos (sm, ls))
190 app_worker_start_listen (app_worker_t * app_wrk,
191 app_listener_t * app_listener)
195 if (clib_bitmap_get (app_listener->workers, app_wrk->wrk_map_index))
196 return VNET_API_ERROR_ADDRESS_IN_USE;
198 app_listener->workers = clib_bitmap_set (app_listener->workers,
199 app_wrk->wrk_map_index, 1);
201 if (app_listener->session_index != SESSION_INVALID_INDEX)
203 ls = session_get (app_listener->session_index, 0);
204 if (app_worker_init_listener (app_wrk, ls))
208 if (app_listener->local_index != SESSION_INVALID_INDEX)
210 ls = session_get (app_listener->local_index, 0);
211 if (app_worker_init_listener (app_wrk, ls))
219 app_worker_stop_listen_session (app_worker_t * app_wrk, session_t * ls)
221 session_handle_t handle;
222 segment_manager_t *sm;
225 handle = listen_session_get_handle (ls);
226 sm_indexp = hash_get (app_wrk->listeners_table, handle);
227 if (PREDICT_FALSE (!sm_indexp))
230 sm = segment_manager_get (*sm_indexp);
231 if (app_wrk->first_segment_manager == *sm_indexp)
233 /* Delete sessions but don't remove segment manager */
234 app_wrk->first_segment_manager_in_use = 0;
235 segment_manager_del_sessions (sm);
239 segment_manager_init_free (sm);
241 hash_unset (app_wrk->listeners_table, handle);
245 app_worker_stop_listen (app_worker_t * app_wrk, app_listener_t * al)
249 if (!clib_bitmap_get (al->workers, app_wrk->wrk_map_index))
252 if (al->session_index != SESSION_INVALID_INDEX)
254 ls = listen_session_get (al->session_index);
255 app_worker_stop_listen_session (app_wrk, ls);
258 if (al->local_index != SESSION_INVALID_INDEX)
260 ls = listen_session_get (al->local_index);
261 app_worker_stop_listen_session (app_wrk, ls);
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);
272 app_worker_init_accepted (session_t * s)
274 app_worker_t *app_wrk;
275 segment_manager_t *sm;
278 listener = listen_session_get_from_handle (s->listener_handle);
279 app_wrk = application_listener_select_worker (listener);
280 s->app_wrk_index = app_wrk->wrk_index;
282 sm = app_worker_get_listen_segment_manager (app_wrk, listener);
283 if (app_worker_alloc_session_fifos (sm, s))
290 app_worker_accept_notify (app_worker_t * app_wrk, session_t * s)
292 application_t *app = application_get (app_wrk->app_index);
293 return app->cb_fns.session_accept_callback (s);
297 app_worker_init_connected (app_worker_t * app_wrk, session_t * s)
299 application_t *app = application_get (app_wrk->app_index);
300 segment_manager_t *sm;
302 /* Allocate fifos for session, unless the app is a builtin proxy */
303 if (!application_is_builtin_proxy (app))
305 sm = app_worker_get_connect_segment_manager (app_wrk);
306 if (app_worker_alloc_session_fifos (sm, s))
313 app_worker_connect_notify (app_worker_t * app_wrk, session_t * s, u32 opaque)
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 */ );
321 app_worker_close_notify (app_worker_t * app_wrk, session_t * s)
323 application_t *app = application_get (app_wrk->app_index);
324 app->cb_fns.session_disconnect_callback (s);
329 app_worker_transport_closed_notify (app_worker_t * app_wrk, session_t * s)
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);
338 app_worker_reset_notify (app_worker_t * app_wrk, session_t * s)
340 application_t *app = application_get (app_wrk->app_index);
341 app->cb_fns.session_reset_callback (s);
346 app_worker_cleanup_notify (app_worker_t * app_wrk, session_t * s,
347 session_cleanup_ntf_t ntf)
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);
356 app_worker_builtin_rx (app_worker_t * app_wrk, session_t * s)
358 application_t *app = application_get (app_wrk->app_index);
359 app->cb_fns.builtin_app_rx_callback (s);
364 app_worker_builtin_tx (app_worker_t * app_wrk, session_t * s)
366 application_t *app = application_get (app_wrk->app_index);
368 if (!app->cb_fns.builtin_app_tx_callback)
371 app->cb_fns.builtin_app_tx_callback (s);
376 app_worker_own_session (app_worker_t * app_wrk, session_t * s)
378 segment_manager_t *sm;
379 svm_fifo_t *rxf, *txf;
381 if (s->session_state == SESSION_STATE_LISTENING)
382 return application_change_listener_owner (s, app_wrk);
384 s->app_wrk_index = app_wrk->wrk_index;
395 sm = app_worker_get_or_alloc_connect_segment_manager (app_wrk);
396 if (app_worker_alloc_session_fifos (sm, s))
399 if (!svm_fifo_is_empty_cons (rxf))
400 svm_fifo_clone (s->rx_fifo, rxf);
402 if (!svm_fifo_is_empty_cons (txf))
403 svm_fifo_clone (s->tx_fifo, txf);
405 segment_manager_dealloc_fifos (rxf, txf);
411 app_worker_connect_session (app_worker_t * app, session_endpoint_t * sep,
416 /* Make sure we have a segment manager for connects */
417 app_worker_alloc_connects_segment_manager (app);
419 if ((rv = session_open (app->wrk_index, sep, api_context)))
426 app_worker_alloc_connects_segment_manager (app_worker_t * app_wrk)
428 segment_manager_t *sm;
430 if (app_wrk->connects_seg_manager == APP_INVALID_SEGMENT_MANAGER_INDEX)
432 sm = app_worker_alloc_segment_manager (app_wrk);
435 app_wrk->connects_seg_manager = segment_manager_index (sm);
441 app_worker_get_connect_segment_manager (app_worker_t * app)
443 ASSERT (app->connects_seg_manager != (u32) ~ 0);
444 return segment_manager_get (app->connects_seg_manager);
448 app_worker_get_or_alloc_connect_segment_manager (app_worker_t * app_wrk)
450 if (app_wrk->connects_seg_manager == (u32) ~ 0)
451 app_worker_alloc_connects_segment_manager (app_wrk);
452 return segment_manager_get (app_wrk->connects_seg_manager);
456 app_worker_get_listen_segment_manager (app_worker_t * app,
457 session_t * listener)
460 smp = hash_get (app->listeners_table, listen_session_get_handle (listener));
462 return segment_manager_get (*smp);
466 app_worker_first_listener (app_worker_t * app_wrk, u8 fib_proto,
474 sst = session_type_from_proto_and_ip (transport_proto,
475 fib_proto == FIB_PROTOCOL_IP4);
478 hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
479 listener = listen_session_get_from_handle (handle);
480 if (listener->session_type == sst
481 && !(listener->flags & SESSION_F_PROXY))
490 app_worker_proxy_listener (app_worker_t * app_wrk, u8 fib_proto,
498 sst = session_type_from_proto_and_ip (transport_proto,
499 fib_proto == FIB_PROTOCOL_IP4);
502 hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
503 listener = listen_session_get_from_handle (handle);
504 if (listener->session_type == sst && (listener->flags & SESSION_F_PROXY))
513 * Send an API message to the external app, to map new segment
516 app_worker_add_segment_notify (app_worker_t * app_wrk, u64 segment_handle)
518 application_t *app = application_get (app_wrk->app_index);
519 return app->cb_fns.add_segment_callback (app_wrk->api_client_index,
524 app_worker_del_segment_notify (app_worker_t * app_wrk, u64 segment_handle)
526 application_t *app = application_get (app_wrk->app_index);
527 return app->cb_fns.del_segment_callback (app_wrk->api_client_index,
532 app_worker_application_is_builtin (app_worker_t * app_wrk)
534 return app_wrk->app_is_builtin;
538 app_enqueue_evt (svm_msg_q_t * mq, svm_msg_q_msg_t * msg, u8 lock)
540 if (PREDICT_FALSE (svm_msg_q_is_full (mq)))
542 clib_warning ("evt q full");
543 svm_msg_q_free_msg (mq, msg);
545 svm_msg_q_unlock (mq);
551 svm_msg_q_add_and_unlock (mq, msg);
555 /* Even when not locking the ring, we must wait for queue mutex */
556 if (svm_msg_q_add (mq, msg, SVM_Q_WAIT))
558 clib_warning ("msg q add returned");
565 app_send_io_evt_rx (app_worker_t * app_wrk, session_t * s, u8 lock)
567 session_event_t *evt;
571 if (PREDICT_FALSE (s->session_state != SESSION_STATE_READY
572 && s->session_state != SESSION_STATE_LISTENING))
575 if (app_worker_application_is_builtin (app_wrk))
576 return app_worker_builtin_rx (app_wrk, s);
578 if (svm_fifo_has_event (s->rx_fifo))
581 mq = app_wrk->event_queue;
585 if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
587 clib_warning ("evt q rings full");
589 svm_msg_q_unlock (mq);
593 msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
594 ASSERT (!svm_msg_q_msg_is_invalid (&msg));
596 evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
597 evt->session_index = s->rx_fifo->client_session_index;
598 evt->event_type = SESSION_IO_EVT_RX;
600 (void) svm_fifo_set_event (s->rx_fifo);
602 if (app_enqueue_evt (mq, &msg, lock))
608 app_send_io_evt_tx (app_worker_t * app_wrk, session_t * s, u8 lock)
611 session_event_t *evt;
614 if (app_worker_application_is_builtin (app_wrk))
615 return app_worker_builtin_tx (app_wrk, s);
617 mq = app_wrk->event_queue;
621 if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
623 clib_warning ("evt q rings full");
625 svm_msg_q_unlock (mq);
629 msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
630 ASSERT (!svm_msg_q_msg_is_invalid (&msg));
632 evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
633 evt->event_type = SESSION_IO_EVT_TX;
634 evt->session_index = s->tx_fifo->client_session_index;
636 return app_enqueue_evt (mq, &msg, lock);
640 typedef int (app_send_evt_handler_fn) (app_worker_t *app,
643 static app_send_evt_handler_fn * const app_send_evt_handler_fns[2] = {
650 * Send event to application
652 * Logic from queue perspective is non-blocking. If there's
653 * not enough space to enqueue a message, we return.
656 app_worker_send_event (app_worker_t * app, session_t * s, u8 evt_type)
658 ASSERT (app && evt_type <= SESSION_IO_EVT_TX);
659 return app_send_evt_handler_fns[evt_type] (app, s, 0 /* lock */ );
663 * Send event to application
665 * Logic from queue perspective is blocking. However, if queue is full,
669 app_worker_lock_and_send_event (app_worker_t * app, session_t * s,
672 return app_send_evt_handler_fns[evt_type] (app, s, 1 /* lock */ );
676 format_app_worker_listener (u8 * s, va_list * args)
678 app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
679 u64 handle = va_arg (*args, u64);
680 u32 sm_index = va_arg (*args, u32);
681 int verbose = va_arg (*args, int);
689 s = format (s, "%-40s%-25s%=10s%-15s%-15s%-10s", "Connection", "App",
690 "Wrk", "API Client", "ListenerID", "SegManager");
692 s = format (s, "%-40s%-25s%=10s", "Connection", "App", "Wrk");
697 app_name = application_name_from_index (app_wrk->app_index);
698 listener = listen_session_get_from_handle (handle);
699 str = format (0, "%U", format_session, listener, verbose);
704 sprintf (buf, "%u(%u)", app_wrk->wrk_map_index, app_wrk->wrk_index);
705 s = format (s, "%-40s%-25s%=10s%-15u%-15u%-10u", str, app_name,
706 buf, app_wrk->api_client_index, handle, sm_index);
709 s = format (s, "%-40s%-25s%=10u", str, app_name, app_wrk->wrk_map_index);
715 format_app_worker (u8 * s, va_list * args)
717 app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
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);
728 app_worker_format_connects (app_worker_t * app_wrk, int verbose)
730 segment_manager_t *sm;
735 segment_manager_format_sessions (0, verbose);
739 if (app_wrk->connects_seg_manager == (u32) ~ 0)
742 sm = segment_manager_get (app_wrk->connects_seg_manager);
743 segment_manager_format_sessions (sm, verbose);
747 * fd.io coding-style-patch-verification: ON
750 * eval: (c-set-style "gnu")