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/application_local.h>
19 #include <vnet/session/session.h>
22 * Pool of workers associated to apps
24 static app_worker_t *app_workers;
27 app_worker_alloc (application_t * app)
29 app_worker_t *app_wrk;
30 pool_get (app_workers, app_wrk);
31 clib_memset (app_wrk, 0, sizeof (*app_wrk));
32 app_wrk->wrk_index = app_wrk - app_workers;
33 app_wrk->app_index = app->app_index;
34 app_wrk->wrk_map_index = ~0;
35 app_wrk->connects_seg_manager = APP_INVALID_SEGMENT_MANAGER_INDEX;
36 app_wrk->first_segment_manager = APP_INVALID_SEGMENT_MANAGER_INDEX;
37 app_wrk->local_segment_manager = APP_INVALID_SEGMENT_MANAGER_INDEX;
38 APP_DBG ("New app %v worker %u", app_get_name (app), app_wrk->wrk_index);
43 app_worker_get (u32 wrk_index)
45 return pool_elt_at_index (app_workers, wrk_index);
49 app_worker_get_if_valid (u32 wrk_index)
51 if (pool_is_free_index (app_workers, wrk_index))
53 return pool_elt_at_index (app_workers, wrk_index);
57 app_worker_free (app_worker_t * app_wrk)
59 application_t *app = application_get (app_wrk->app_index);
60 vnet_unlisten_args_t _a, *a = &_a;
61 u64 handle, *handles = 0;
62 segment_manager_t *sm;
73 hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
74 ls = listen_session_get_from_handle (handle);
75 al = app_listener_get (app, ls->al_index);
76 vec_add1 (handles, app_listener_handle (al));
77 sm = segment_manager_get (sm_index);
78 sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
82 for (i = 0; i < vec_len (handles); i++)
84 a->app_index = app->app_index;
85 a->wrk_map_index = app_wrk->wrk_map_index;
86 a->handle = handles[i];
87 /* seg manager is removed when unbind completes */
88 (void) vnet_unlisten (a);
92 * Connects segment manager cleanup
95 if (app_wrk->connects_seg_manager != APP_INVALID_SEGMENT_MANAGER_INDEX)
97 sm = segment_manager_get (app_wrk->connects_seg_manager);
98 sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
99 sm->first_is_protected = 0;
100 segment_manager_init_del (sm);
103 /* If first segment manager is used by a listener */
104 if (app_wrk->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX
105 && app_wrk->first_segment_manager != app_wrk->connects_seg_manager)
107 sm = segment_manager_get (app_wrk->first_segment_manager);
108 sm->first_is_protected = 0;
109 sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX;
110 /* .. and has no fifos, e.g. it might be used for redirected sessions,
112 if (!segment_manager_has_fifos (sm))
113 segment_manager_del (sm);
119 app_worker_local_sessions_free (app_wrk);
121 pool_put (app_workers, app_wrk);
123 clib_memset (app_wrk, 0xfe, sizeof (*app_wrk));
127 app_worker_get_app (u32 wrk_index)
129 app_worker_t *app_wrk;
130 app_wrk = app_worker_get_if_valid (wrk_index);
133 return application_get_if_valid (app_wrk->app_index);
136 static segment_manager_t *
137 app_worker_alloc_segment_manager (app_worker_t * app_wrk)
139 segment_manager_t *sm = 0;
141 /* If the first segment manager is not in use, don't allocate a new one */
142 if (app_wrk->first_segment_manager != APP_INVALID_SEGMENT_MANAGER_INDEX
143 && app_wrk->first_segment_manager_in_use == 0)
145 sm = segment_manager_get (app_wrk->first_segment_manager);
146 app_wrk->first_segment_manager_in_use = 1;
150 sm = segment_manager_new ();
151 sm->app_wrk_index = app_wrk->wrk_index;
157 app_worker_alloc_session_fifos (segment_manager_t * sm, session_t * s)
159 svm_fifo_t *rx_fifo = 0, *tx_fifo = 0;
160 u32 fifo_segment_index;
163 if ((rv = segment_manager_alloc_session_fifos (sm, &rx_fifo, &tx_fifo,
164 &fifo_segment_index)))
167 rx_fifo->master_session_index = s->session_index;
168 rx_fifo->master_thread_index = s->thread_index;
170 tx_fifo->master_session_index = s->session_index;
171 tx_fifo->master_thread_index = s->thread_index;
173 s->rx_fifo = rx_fifo;
174 s->tx_fifo = tx_fifo;
175 s->svm_segment_index = fifo_segment_index;
180 app_worker_init_listener (app_worker_t * app_wrk, session_t * ls)
182 segment_manager_t *sm;
184 /* Allocate segment manager. All sessions derived out of a listen session
185 * have fifos allocated by the same segment manager. */
186 if (!(sm = app_worker_alloc_segment_manager (app_wrk)))
189 /* Keep track of the segment manager for the listener or this worker */
190 hash_set (app_wrk->listeners_table, listen_session_get_handle (ls),
191 segment_manager_index (sm));
193 if (session_transport_service_type (ls) == TRANSPORT_SERVICE_CL)
195 if (!ls->rx_fifo && app_worker_alloc_session_fifos (sm, ls))
202 app_worker_start_listen (app_worker_t * app_wrk,
203 app_listener_t * app_listener)
207 if (clib_bitmap_get (app_listener->workers, app_wrk->wrk_map_index))
208 return VNET_API_ERROR_ADDRESS_IN_USE;
210 app_listener->workers = clib_bitmap_set (app_listener->workers,
211 app_wrk->wrk_map_index, 1);
213 if (app_listener->session_index != SESSION_INVALID_INDEX)
215 ls = session_get (app_listener->session_index, 0);
216 if (app_worker_init_listener (app_wrk, ls))
220 if (app_listener->local_index != SESSION_INVALID_INDEX)
222 ls = session_get (app_listener->local_index, 0);
223 if (app_worker_init_listener (app_wrk, ls))
231 app_worker_stop_listen (app_worker_t * app_wrk, app_listener_t * al)
233 session_handle_t handle;
234 segment_manager_t *sm;
238 if (!clib_bitmap_get (al->workers, app_wrk->wrk_map_index))
241 if (al->session_index != SESSION_INVALID_INDEX)
243 ls = listen_session_get (al->session_index);
244 handle = listen_session_get_handle (ls);
246 sm_indexp = hash_get (app_wrk->listeners_table, handle);
247 if (PREDICT_FALSE (!sm_indexp))
249 clib_warning ("listener handle was removed %llu!", handle);
253 sm = segment_manager_get (*sm_indexp);
254 if (app_wrk->first_segment_manager == *sm_indexp)
256 /* Delete sessions but don't remove segment manager */
257 app_wrk->first_segment_manager_in_use = 0;
258 segment_manager_del_sessions (sm);
262 segment_manager_init_del (sm);
264 hash_unset (app_wrk->listeners_table, handle);
267 if (al->local_index != SESSION_INVALID_INDEX)
269 local_session_t *local;
270 ls = listen_session_get (al->local_index);
271 handle = listen_session_get_handle (ls);
274 pool_foreach (local, app_wrk->local_sessions, ({
275 if (local->listener_index == ls->session_index)
276 app_worker_local_session_disconnect (app_wrk->wrk_index, local);
280 sm_indexp = hash_get (app_wrk->listeners_table, handle);
281 if (PREDICT_FALSE (!sm_indexp))
284 sm = segment_manager_get (*sm_indexp);
285 if (app_wrk->first_segment_manager == *sm_indexp)
287 /* Delete sessions but don't remove segment manager */
288 app_wrk->first_segment_manager_in_use = 0;
289 segment_manager_del_sessions (sm);
293 segment_manager_init_del (sm);
295 hash_unset (app_wrk->listeners_table, handle);
298 clib_bitmap_set_no_check (al->workers, app_wrk->wrk_map_index, 0);
299 if (clib_bitmap_is_zero (al->workers))
300 app_listener_cleanup (al);
306 app_worker_init_accepted (session_t * s)
308 app_worker_t *app_wrk;
309 segment_manager_t *sm;
312 listener = listen_session_get (s->listener_index);
313 app_wrk = application_listener_select_worker (listener);
314 s->app_wrk_index = app_wrk->wrk_index;
315 sm = app_worker_get_listen_segment_manager (app_wrk, listener);
316 return app_worker_alloc_session_fifos (sm, s);
320 app_worker_accept_notify (app_worker_t * app_wrk, session_t * s)
322 application_t *app = application_get (app_wrk->app_index);
323 return app->cb_fns.session_accept_callback (s);
327 app_worker_init_connected (app_worker_t * app_wrk, session_t * s)
329 application_t *app = application_get (app_wrk->app_index);
330 segment_manager_t *sm;
332 /* Allocate fifos for session, unless the app is a builtin proxy */
333 if (!application_is_builtin_proxy (app))
335 sm = app_worker_get_connect_segment_manager (app_wrk);
336 if (app_worker_alloc_session_fifos (sm, s))
343 app_worker_connect_notify (app_worker_t * app_wrk, session_t * s, u32 opaque)
345 application_t *app = application_get (app_wrk->app_index);
346 return app->cb_fns.session_connected_callback (app_wrk->wrk_index, opaque,
347 s, s == 0 /* is_fail */ );
351 app_worker_own_session (app_worker_t * app_wrk, session_t * s)
353 segment_manager_t *sm;
354 svm_fifo_t *rxf, *txf;
356 if (s->session_state == SESSION_STATE_LISTENING)
357 return application_change_listener_owner (s, app_wrk);
359 s->app_wrk_index = app_wrk->wrk_index;
370 sm = app_worker_get_or_alloc_connect_segment_manager (app_wrk);
371 if (app_worker_alloc_session_fifos (sm, s))
374 if (!svm_fifo_is_empty (rxf))
376 clib_memcpy_fast (s->rx_fifo->data, rxf->data, rxf->nitems);
377 s->rx_fifo->head = rxf->head;
378 s->rx_fifo->tail = rxf->tail;
379 s->rx_fifo->cursize = rxf->cursize;
382 if (!svm_fifo_is_empty (txf))
384 clib_memcpy_fast (s->tx_fifo->data, txf->data, txf->nitems);
385 s->tx_fifo->head = txf->head;
386 s->tx_fifo->tail = txf->tail;
387 s->tx_fifo->cursize = txf->cursize;
390 segment_manager_dealloc_fifos (rxf->segment_index, rxf, txf);
396 app_worker_connect_session (app_worker_t * app, session_endpoint_t * sep,
401 /* Make sure we have a segment manager for connects */
402 app_worker_alloc_connects_segment_manager (app);
404 if ((rv = session_open (app->wrk_index, sep, api_context)))
411 app_worker_alloc_connects_segment_manager (app_worker_t * app_wrk)
413 segment_manager_t *sm;
415 if (app_wrk->connects_seg_manager == APP_INVALID_SEGMENT_MANAGER_INDEX)
417 sm = app_worker_alloc_segment_manager (app_wrk);
420 app_wrk->connects_seg_manager = segment_manager_index (sm);
426 app_worker_get_connect_segment_manager (app_worker_t * app)
428 ASSERT (app->connects_seg_manager != (u32) ~ 0);
429 return segment_manager_get (app->connects_seg_manager);
433 app_worker_get_or_alloc_connect_segment_manager (app_worker_t * app_wrk)
435 if (app_wrk->connects_seg_manager == (u32) ~ 0)
436 app_worker_alloc_connects_segment_manager (app_wrk);
437 return segment_manager_get (app_wrk->connects_seg_manager);
441 app_worker_get_listen_segment_manager (app_worker_t * app,
442 session_t * listener)
445 smp = hash_get (app->listeners_table, listen_session_get_handle (listener));
447 return segment_manager_get (*smp);
451 app_worker_first_listener (app_worker_t * app_wrk, u8 fib_proto,
459 sst = session_type_from_proto_and_ip (transport_proto,
460 fib_proto == FIB_PROTOCOL_IP4);
463 hash_foreach (handle, sm_index, app_wrk->listeners_table, ({
464 listener = listen_session_get_from_handle (handle);
465 if (listener->session_type == sst
466 && listener->enqueue_epoch != SESSION_PROXY_LISTENER_INDEX)
475 app_worker_proxy_listener (app_worker_t * app_wrk, u8 fib_proto,
483 sst = session_type_from_proto_and_ip (transport_proto,
484 fib_proto == FIB_PROTOCOL_IP4);
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->enqueue_epoch == SESSION_PROXY_LISTENER_INDEX)
499 * Send an API message to the external app, to map new segment
502 app_worker_add_segment_notify (u32 app_wrk_index, u64 segment_handle)
504 app_worker_t *app_wrk = app_worker_get (app_wrk_index);
505 application_t *app = application_get (app_wrk->app_index);
506 return app->cb_fns.add_segment_callback (app_wrk->api_client_index,
511 app_worker_application_is_builtin (app_worker_t * app_wrk)
513 return app_wrk->app_is_builtin;
517 app_enqueue_evt (svm_msg_q_t * mq, svm_msg_q_msg_t * msg, u8 lock)
519 if (PREDICT_FALSE (svm_msg_q_is_full (mq)))
521 clib_warning ("evt q full");
522 svm_msg_q_free_msg (mq, msg);
524 svm_msg_q_unlock (mq);
530 svm_msg_q_add_and_unlock (mq, msg);
534 /* Even when not locking the ring, we must wait for queue mutex */
535 if (svm_msg_q_add (mq, msg, SVM_Q_WAIT))
537 clib_warning ("msg q add returned");
544 app_send_io_evt_rx (app_worker_t * app_wrk, session_t * s, u8 lock)
546 session_event_t *evt;
550 if (PREDICT_FALSE (s->session_state != SESSION_STATE_READY
551 && s->session_state != SESSION_STATE_LISTENING))
553 /* Session is closed so app will never clean up. Flush rx fifo */
554 if (s->session_state == SESSION_STATE_CLOSED)
555 svm_fifo_dequeue_drop_all (s->rx_fifo);
559 if (app_worker_application_is_builtin (app_wrk))
561 application_t *app = application_get (app_wrk->app_index);
562 return app->cb_fns.builtin_app_rx_callback (s);
565 if (svm_fifo_has_event (s->rx_fifo) || svm_fifo_is_empty (s->rx_fifo))
568 mq = app_wrk->event_queue;
572 if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
574 clib_warning ("evt q rings full");
576 svm_msg_q_unlock (mq);
580 msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
581 ASSERT (!svm_msg_q_msg_is_invalid (&msg));
583 evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
584 evt->fifo = s->rx_fifo;
585 evt->event_type = FIFO_EVENT_APP_RX;
587 (void) svm_fifo_set_event (s->rx_fifo);
589 if (app_enqueue_evt (mq, &msg, lock))
595 app_send_io_evt_tx (app_worker_t * app_wrk, session_t * s, u8 lock)
598 session_event_t *evt;
601 if (app_worker_application_is_builtin (app_wrk))
604 mq = app_wrk->event_queue;
608 if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING)))
610 clib_warning ("evt q rings full");
612 svm_msg_q_unlock (mq);
616 msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING);
617 ASSERT (!svm_msg_q_msg_is_invalid (&msg));
619 evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg);
620 evt->event_type = FIFO_EVENT_APP_TX;
621 evt->fifo = s->tx_fifo;
623 return app_enqueue_evt (mq, &msg, lock);
627 typedef int (app_send_evt_handler_fn) (app_worker_t *app,
630 static app_send_evt_handler_fn * const app_send_evt_handler_fns[3] = {
638 * Send event to application
640 * Logic from queue perspective is non-blocking. If there's
641 * not enough space to enqueue a message, we return.
644 app_worker_send_event (app_worker_t * app, session_t * s, u8 evt_type)
646 ASSERT (app && evt_type <= FIFO_EVENT_APP_TX);
647 return app_send_evt_handler_fns[evt_type] (app, s, 0 /* lock */ );
651 * Send event to application
653 * Logic from queue perspective is blocking. However, if queue is full,
657 app_worker_lock_and_send_event (app_worker_t * app, session_t * s,
660 return app_send_evt_handler_fns[evt_type] (app, s, 1 /* lock */ );
664 app_worker_get_local_segment_manager (app_worker_t * app_worker)
666 return segment_manager_get (app_worker->local_segment_manager);
670 app_worker_get_local_segment_manager_w_session (app_worker_t * app_wrk,
671 local_session_t * ls)
674 if (application_local_session_listener_has_transport (ls))
676 listener = listen_session_get (ls->listener_index);
677 return app_worker_get_listen_segment_manager (app_wrk, listener);
679 return segment_manager_get (app_wrk->local_segment_manager);
683 format_app_worker_listener (u8 * s, va_list * args)
685 app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
686 u64 handle = va_arg (*args, u64);
687 u32 sm_index = va_arg (*args, u32);
688 int verbose = va_arg (*args, int);
696 s = format (s, "%-40s%-25s%=10s%-15s%-15s%-10s", "Connection", "App",
697 "Wrk", "API Client", "ListenerID", "SegManager");
699 s = format (s, "%-40s%-25s%=10s", "Connection", "App", "Wrk");
704 app_name = application_name_from_index (app_wrk->app_index);
705 listener = listen_session_get_from_handle (handle);
706 str = format (0, "%U", format_stream_session, listener, verbose);
711 sprintf (buf, "%u(%u)", app_wrk->wrk_map_index, app_wrk->wrk_index);
712 s = format (s, "%-40s%-25s%=10s%-15u%-15u%-10u", str, app_name,
713 buf, app_wrk->api_client_index, handle, sm_index);
716 s = format (s, "%-40s%-25s%=10u", str, app_name, app_wrk->wrk_map_index);
722 format_app_worker (u8 * s, va_list * args)
724 app_worker_t *app_wrk = va_arg (*args, app_worker_t *);
727 s = format (s, "%U wrk-index %u app-index %u map-index %u "
728 "api-client-index %d\n", format_white_space, indent,
729 app_wrk->wrk_index, app_wrk->app_index, app_wrk->wrk_map_index,
730 app_wrk->api_client_index);
735 app_worker_format_connects (app_worker_t * app_wrk, int verbose)
737 svm_fifo_segment_private_t *fifo_segment;
738 vlib_main_t *vm = vlib_get_main ();
739 segment_manager_t *sm;
747 vlib_cli_output (vm, "%-40s%-20s%-15s%-10s", "Connection", "App",
748 "API Client", "SegManager");
750 vlib_cli_output (vm, "%-40s%-20s", "Connection", "App");
754 if (app_wrk->connects_seg_manager == (u32) ~ 0)
757 app_name = application_name_from_index (app_wrk->app_index);
759 /* Across all fifo segments */
760 sm = segment_manager_get (app_wrk->connects_seg_manager);
763 segment_manager_foreach_segment_w_lock (fifo_segment, sm, ({
767 fifo = svm_fifo_segment_get_fifo_list (fifo_segment);
770 u32 session_index, thread_index;
773 session_index = fifo->master_session_index;
774 thread_index = fifo->master_thread_index;
776 session = session_get (session_index, thread_index);
777 str = format (0, "%U", format_stream_session, session, verbose);
780 s = format (s, "%-40s%-20s%-15u%-10u", str, app_name,
781 app_wrk->api_client_index, app_wrk->connects_seg_manager);
783 s = format (s, "%-40s%-20s", str, app_name);
785 vlib_cli_output (vm, "%v", s);
786 vec_reset_length (s);
797 * fd.io coding-style-patch-verification: ON
800 * eval: (c-set-style "gnu")