/* * Copyright (c) 2019 Cisco and/or its affiliates. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include <vnet/session/application.h> #include <vnet/session/application_interface.h> #include <vnet/session/session.h> /** * Pool of workers associated to apps */ static app_worker_t *app_workers; app_worker_t * app_worker_alloc (application_t * app) { app_worker_t *app_wrk; pool_get (app_workers, app_wrk); clib_memset (app_wrk, 0, sizeof (*app_wrk)); app_wrk->wrk_index = app_wrk - app_workers; app_wrk->app_index = app->app_index; app_wrk->wrk_map_index = ~0; app_wrk->connects_seg_manager = APP_INVALID_SEGMENT_MANAGER_INDEX; clib_spinlock_init (&app_wrk->detached_seg_managers_lock); APP_DBG ("New app %v worker %u", app->name, app_wrk->wrk_index); return app_wrk; } app_worker_t * app_worker_get (u32 wrk_index) { return pool_elt_at_index (app_workers, wrk_index); } app_worker_t * app_worker_get_if_valid (u32 wrk_index) { if (pool_is_free_index (app_workers, wrk_index)) return 0; return pool_elt_at_index (app_workers, wrk_index); } void app_worker_free (app_worker_t * app_wrk) { application_t *app = application_get (app_wrk->app_index); vnet_unlisten_args_t _a, *a = &_a; u64 handle, *handles = 0, *sm_indices = 0; segment_manager_t *sm; session_handle_t *sh; session_t *ls; u32 sm_index; int i; /* * Listener cleanup */ /* *INDENT-OFF* */ hash_foreach (handle, sm_index, app_wrk->listeners_table, ({ ls = listen_session_get_from_handle (handle); vec_add1 (handles, app_listen_session_handle (ls)); vec_add1 (sm_indices, sm_index); sm = segment_manager_get (sm_index); })); /* *INDENT-ON* */ for (i = 0; i < vec_len (handles); i++) { /* Cleanup listener */ a->app_index = app->app_index; a->wrk_map_index = app_wrk->wrk_map_index; a->handle = handles[i]; (void) vnet_unlisten (a); sm = segment_manager_get_if_valid (sm_indices[i]); if (sm && !segment_manager_app_detached (sm)) { sm->first_is_protected = 0; segment_manager_init_free (sm); } } vec_reset_length (handles); vec_free (sm_indices); hash_free (app_wrk->listeners_table); /* * Connects segment manager cleanup */ if (app_wrk->connects_seg_manager != APP_INVALID_SEGMENT_MANAGER_INDEX) { sm = segment_manager_get (app_wrk->connects_seg_manager); sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX; sm->first_is_protected = 0; segment_manager_init_free (sm); } /* * Half-open cleanup */ pool_foreach (sh, app_wrk->half_open_table) session_cleanup_half_open (*sh); pool_free (app_wrk->half_open_table); /* * Detached listener segment managers cleanup */ for (i = 0; i < vec_len (app_wrk->detached_seg_managers); i++) { sm = segment_manager_get (app_wrk->detached_seg_managers[i]); segment_manager_init_free (sm); } vec_free (app_wrk->detached_seg_managers); clib_spinlock_free (&app_wrk->detached_seg_managers_lock); if (CLIB_DEBUG) clib_memset (app_wrk, 0xfe, sizeof (*app_wrk)); pool_put (app_workers, app_wrk); } application_t * app_worker_get_app (u32 wrk_index) { app_worker_t *app_wrk; app_wrk = app_worker_get_if_valid (wrk_index); if (!app_wrk) return 0; return application_get_if_valid (app_wrk->app_index); } static segment_manager_t * app_worker_alloc_segment_manager (app_worker_t * app_wrk) { segment_manager_t *sm; sm = segment_manager_alloc (); sm->app_wrk_index = app_wrk->wrk_index; segment_manager_init (sm); return sm; } static int app_worker_alloc_session_fifos (segment_manager_t * sm, session_t * s) { svm_fifo_t *rx_fifo = 0, *tx_fifo = 0; int rv; if ((rv = segment_manager_alloc_session_fifos (sm, s->thread_index, &rx_fifo, &tx_fifo))) return rv; rx_fifo->shr->master_session_index = s->session_index; rx_fifo->master_thread_index = s->thread_index; tx_fifo->shr->master_session_index = s->session_index; tx_fifo->master_thread_index = s->thread_index; s->rx_fifo = rx_fifo; s->tx_fifo = tx_fifo; return 0; } int app_worker_init_listener (app_worker_t * app_wrk, session_t * ls) { segment_manager_t *sm; /* Allocate segment manager. All sessions derived out of a listen session * have fifos allocated by the same segment manager. */ if (!(sm = app_worker_alloc_segment_manager (app_wrk))) return SESSION_E_ALLOC; /* Keep track of the segment manager for the listener or this worker */ hash_set (app_wrk->listeners_table, listen_session_get_handle (ls), segment_manager_index (sm)); if (transport_connection_is_cless (session_get_transport (ls))) { if (ls->rx_fifo) return SESSION_E_NOSUPPORT; return app_worker_alloc_session_fifos (sm, ls); } return 0; } int app_worker_start_listen (app_worker_t * app_wrk, app_listener_t * app_listener) { session_t *ls; int rv; if (clib_bitmap_get (app_listener->workers, app_wrk->wrk_map_index)) return SESSION_E_ALREADY_LISTENING; app_listener->workers = clib_bitmap_set (app_listener->workers, app_wrk->wrk_map_index, 1); if (app_listener->session_index != SESSION_INVALID_INDEX) { ls = session_get (app_listener->session_index, 0); if ((rv = app_worker_init_listener (app_wrk, ls))) return rv; } if (app_listener->local_index != SESSION_INVALID_INDEX) { ls = session_get (app_listener->local_index, 0); if ((rv = app_worker_init_listener (app_wrk, ls))) return rv; } return 0; } static void app_worker_add_detached_sm (app_worker_t * app_wrk, u32 sm_index) { vec_add1 (app_wrk->detached_seg_managers, sm_index); } void app_worker_del_detached_sm (app_worker_t * app_wrk, u32 sm_index) { u32 i; clib_spinlock_lock (&app_wrk->detached_seg_managers_lock); for (i = 0; i < vec_len (app_wrk->detached_seg_managers); i++) { if (app_wrk->detached_seg_managers[i] == sm_index) { vec_del1 (app_wrk->detached_seg_managers, i); break; } } clib_spinlock_unlock (&app_wrk->detached_seg_managers_lock); } static void app_worker_stop_listen_session (app_worker_t * app_wrk, session_t * ls) { session_handle_t handle; segment_manager_t *sm; uword *sm_indexp; session_state_t *states = 0; handle = listen_session_get_handle (ls); sm_indexp = hash_get (app_wrk->listeners_table, handle); if (PREDICT_FALSE (!sm_indexp)) return; /* Dealloc fifos, if any (dgram listeners) */ if (ls->rx_fifo) { segment_manager_dealloc_fifos (ls->rx_fifo, ls->tx_fifo); ls->tx_fifo = ls->rx_fifo = 0; } /* Try to cleanup segment manager */ sm = segment_manager_get (*sm_indexp); if (sm) { segment_manager_app_detach (sm); if (!segment_manager_has_fifos (sm)) { /* Empty segment manager, cleanup it up */ segment_manager_free (sm); } else { /* Delete sessions in CREATED state */ vec_add1 (states, SESSION_STATE_CREATED); segment_manager_del_sessions_filter (sm, states); vec_free (states); /* Track segment manager in case app detaches and all the * outstanding sessions need to be closed */ app_worker_add_detached_sm (app_wrk, *sm_indexp); sm->flags |= SEG_MANAGER_F_DETACHED_LISTENER; } } hash_unset (app_wrk->listeners_table, handle); } int app_worker_stop_listen (app_worker_t * app_wrk, app_listener_t * al) { session_t *ls; if (!clib_bitmap_get (al->workers, app_wrk->wrk_map_index)) return 0; if (al->session_index != SESSION_INVALID_INDEX) { ls = listen_session_get (al->session_index); app_worker_stop_listen_session (app_wrk, ls); } if (al->local_index != SESSION_INVALID_INDEX) { ls = listen_session_get (al->local_index); app_worker_stop_listen_session (app_wrk, ls); } clib_bitmap_set_no_check (al->workers, app_wrk->wrk_map_index, 0); if (clib_bitmap_is_zero (al->workers)) app_listener_cleanup (al); return 0; } int app_worker_init_accepted (session_t * s) { app_worker_t *app_wrk; segment_manager_t *sm; session_t *listener; application_t *app; listener = listen_session_get_from_handle (s->listener_handle); app_wrk = application_listener_select_worker (listener); s->app_wrk_index = app_wrk->wrk_index; app = application_get (app_wrk->app_index); if (app->cb_fns.fifo_tuning_callback) s->flags |= SESSION_F_CUSTOM_FIFO_TUNING; sm = app_worker_get_listen_segment_manager (app_wrk, listener); if (app_worker_alloc_session_fifos (sm, s)) return -1; return 0; } int app_worker_accept_notify (app_worker_t * app_wrk, session_t * s) { application_t *app = application_get (app_wrk->app_index); return app->cb_fns.session_accept_callback (s); } int app_worker_init_connected (app_worker_t * app_wrk, session_t * s) { application_t *app = application_get (app_wrk->app_index); segment_manager_t *sm; if (app->cb_fns.fifo_tuning_callback) s->flags |= SESSION_F_CUSTOM_FIFO_TUNING; /* Allocate fifos for session, unless the app is a builtin proxy */ if (application_is_builtin_proxy (app)) return 0; sm = app_worker_get_connect_segment_manager (app_wrk); return app_worker_alloc_session_fifos (sm, s); } int app_worker_connect_notify (app_worker_t * app_wrk, session_t * s, session_error_t err, u32 opaque) { application_t *app = application_get (app_wrk->app_index); return app->cb_fns.session_connected_callback (app_wrk->wrk_index, opaque, s, err); } int app_worker_add_half_open (app_worker_t *app_wrk, session_handle_t sh) { session_handle_t *shp; ASSERT (vlib_get_thread_index () == 0); pool_get (app_wrk->half_open_table, shp); *shp = sh; return (shp - app_wrk->half_open_table); } int app_worker_del_half_open (app_worker_t *app_wrk, session_t *s) { application_t *app = application_get (app_wrk->app_index); ASSERT (vlib_get_thread_index () <= 1); pool_put_index (app_wrk->half_open_table, s->ho_index); if (app->cb_fns.half_open_cleanup_callback) app->cb_fns.half_open_cleanup_callback (s); return 0; } int app_worker_close_notify (app_worker_t * app_wrk, session_t * s) { application_t *app = application_get (app_wrk->app_index); app->cb_fns.session_disconnect_callback (s); return 0; } int app_worker_transport_closed_notify (app_worker_t * app_wrk, session_t * s) { application_t *app = application_get (app_wrk->app_index); if (app->cb_fns.session_transport_closed_callback) app->cb_fns.session_transport_closed_callback (s); return 0; } int app_worker_reset_notify (app_worker_t * app_wrk, session_t * s) { application_t *app = application_get (app_wrk->app_index); app->cb_fns.session_reset_callback (s); return 0; } int app_worker_cleanup_notify (app_worker_t * app_wrk, session_t * s, session_cleanup_ntf_t ntf) { application_t *app = application_get (app_wrk->app_index); if (app->cb_fns.session_cleanup_callback) app->cb_fns.session_cleanup_callback (s, ntf); return 0; } int app_worker_builtin_rx (app_worker_t * app_wrk, session_t * s) { application_t *app = application_get (app_wrk->app_index); app->cb_fns.builtin_app_rx_callback (s); return 0; } int app_worker_builtin_tx (app_worker_t * app_wrk, session_t * s) { application_t *app = application_get (app_wrk->app_index); if (!app->cb_fns.builtin_app_tx_callback) return 0; app->cb_fns.builtin_app_tx_callback (s); return 0; } int app_worker_migrate_notify (app_worker_t * app_wrk, session_t * s, session_handle_t new_sh) { application_t *app = application_get (app_wrk->app_index); app->cb_fns.session_migrate_callback (s, new_sh); return 0; } int app_worker_own_session (app_worker_t * app_wrk, session_t * s) { segment_manager_t *sm; svm_fifo_t *rxf, *txf; if (s->session_state == SESSION_STATE_LISTENING) return application_change_listener_owner (s, app_wrk); s->app_wrk_index = app_wrk->wrk_index; rxf = s->rx_fifo; txf = s->tx_fifo; if (!rxf || !txf) return 0; s->rx_fifo = 0; s->tx_fifo = 0; sm = app_worker_get_connect_segment_manager (app_wrk); if (app_worker_alloc_session_fifos (sm, s)) return -1; if (!svm_fifo_is_empty_cons (rxf)) svm_fifo_clone (s->rx_fifo, rxf); if (!svm_fifo_is_empty_cons (txf)) svm_fifo_clone (s->tx_fifo, txf); segment_manager_dealloc_fifos (rxf, txf); return 0; } int app_worker_connect_session (app_worker_t *app_wrk, session_endpoint_cfg_t *sep, session_handle_t *rsh) { sep->app_wrk_index = app_wrk->wrk_index; return session_open (sep, rsh); } int app_worker_session_fifo_tuning (app_worker_t * app_wrk, session_t * s, svm_fifo_t * f, session_ft_action_t act, u32 len) { application_t *app = application_get (app_wrk->app_index); return app->cb_fns.fifo_tuning_callback (s, f, act, len); } segment_manager_t * app_worker_get_connect_segment_manager (app_worker_t * app) { ASSERT (app->connects_seg_manager != (u32) ~ 0); return segment_manager_get (app->connects_seg_manager); } segment_manager_t * app_worker_get_listen_segment_manager (app_worker_t * app, session_t * listener) { uword *smp; smp = hash_get (app->listeners_table, listen_session_get_handle (listener)); ALWAYS_ASSERT (smp != 0); return segment_manager_get (*smp); } session_t * app_worker_first_listener (app_worker_t * app_wrk, u8 fib_proto, u8 transport_proto) { session_t *listener; u64 handle; u32 sm_index; u8 sst; sst = session_type_from_proto_and_ip (transport_proto, fib_proto == FIB_PROTOCOL_IP4); /* *INDENT-OFF* */ hash_foreach (handle, sm_index, app_wrk->listeners_table, ({ listener = listen_session_get_from_handle (handle); if (listener->session_type == sst && !(listener->flags & SESSION_F_PROXY)) return listener; })); /* *INDENT-ON* */ return 0; } session_t * app_worker_proxy_listener (app_worker_t * app_wrk, u8 fib_proto, u8 transport_proto) { session_t *listener; u64 handle; u32 sm_index; u8 sst; sst = session_type_from_proto_and_ip (transport_proto, fib_proto == FIB_PROTOCOL_IP4); /* *INDENT-OFF* */ hash_foreach (handle, sm_index, app_wrk->listeners_table, ({ listener = listen_session_get_from_handle (handle); if (listener->session_type == sst && (listener->flags & SESSION_F_PROXY)) return listener; })); /* *INDENT-ON* */ return 0; } /** * Send an API message to the external app, to map new segment */ int app_worker_add_segment_notify (app_worker_t * app_wrk, u64 segment_handle) { application_t *app = application_get (app_wrk->app_index); return app->cb_fns.add_segment_callback (app_wrk->wrk_index, segment_handle); } int app_worker_del_segment_notify (app_worker_t * app_wrk, u64 segment_handle) { application_t *app = application_get (app_wrk->app_index); return app->cb_fns.del_segment_callback (app_wrk->wrk_index, segment_handle); } static inline u8 app_worker_application_is_builtin (app_worker_t * app_wrk) { return app_wrk->app_is_builtin; } static inline int app_send_io_evt_rx (app_worker_t * app_wrk, session_t * s) { session_event_t *evt; svm_msg_q_msg_t msg; svm_msg_q_t *mq; if (app_worker_application_is_builtin (app_wrk)) return app_worker_builtin_rx (app_wrk, s); if (svm_fifo_has_event (s->rx_fifo)) return 0; mq = app_wrk->event_queue; svm_msg_q_lock (mq); if (PREDICT_FALSE (svm_msg_q_is_full (mq))) { clib_warning ("evt q full"); svm_msg_q_unlock (mq); return -1; } if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING))) { clib_warning ("evt q rings full"); svm_msg_q_unlock (mq); return -1; } msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING); evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg); evt->session_index = s->rx_fifo->shr->client_session_index; evt->event_type = SESSION_IO_EVT_RX; (void) svm_fifo_set_event (s->rx_fifo); svm_msg_q_add_and_unlock (mq, &msg); return 0; } static inline int app_send_io_evt_tx (app_worker_t * app_wrk, session_t * s) { svm_msg_q_t *mq; session_event_t *evt; svm_msg_q_msg_t msg; if (app_worker_application_is_builtin (app_wrk)) return app_worker_builtin_tx (app_wrk, s); mq = app_wrk->event_queue; svm_msg_q_lock (mq); if (PREDICT_FALSE (svm_msg_q_is_full (mq))) { clib_warning ("evt q full"); svm_msg_q_unlock (mq); return -1; } if (PREDICT_FALSE (svm_msg_q_ring_is_full (mq, SESSION_MQ_IO_EVT_RING))) { clib_warning ("evt q rings full"); svm_msg_q_unlock (mq); return -1; } msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING); evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg); evt->event_type = SESSION_IO_EVT_TX; evt->session_index = s->tx_fifo->shr->client_session_index; svm_msg_q_add_and_unlock (mq, &msg); return 0; } /* *INDENT-OFF* */ typedef int (app_send_evt_handler_fn) (app_worker_t *app, session_t *s); static app_send_evt_handler_fn * const app_send_evt_handler_fns[2] = { app_send_io_evt_rx, app_send_io_evt_tx, }; /* *INDENT-ON* */ /** * Send event to application * * Logic from queue perspective is blocking. However, if queue is full, * we return. */ int app_worker_lock_and_send_event (app_worker_t * app, session_t * s, u8 evt_type) { return app_send_evt_handler_fns[evt_type] (app, s); } u8 * format_app_worker_listener (u8 * s, va_list * args) { app_worker_t *app_wrk = va_arg (*args, app_worker_t *); u64 handle = va_arg (*args, u64); u32 sm_index = va_arg (*args, u32); int verbose = va_arg (*args, int); session_t *listener; const u8 *app_name; u8 *str; if (!app_wrk) { if (verbose) s = format (s, "%-" SESSION_CLI_ID_LEN "s%-25s%-10s%-15s%-15s%-10s", "Connection", "App", "Wrk", "API Client", "ListenerID", "SegManager"); else s = format (s, "%-" SESSION_CLI_ID_LEN "s%-25s%-10s", "Connection", "App", "Wrk"); return s; } app_name = application_name_from_index (app_wrk->app_index); listener = listen_session_get_from_handle (handle); str = format (0, "%U", format_session, listener, verbose); if (verbose) { u8 *buf; buf = format (0, "%u(%u)", app_wrk->wrk_map_index, app_wrk->wrk_index); s = format (s, "%-" SESSION_CLI_ID_LEN "v%-25v%-10v%-15u%-15u%-10u", str, app_name, buf, app_wrk->api_client_index, handle, sm_index); vec_free (buf); } else s = format (s, "%-" SESSION_CLI_ID_LEN "v%-25v%=10u", str, app_name, app_wrk->wrk_map_index); vec_free (str); return s; } u8 * format_app_worker (u8 * s, va_list * args) { app_worker_t *app_wrk = va_arg (*args, app_worker_t *); u32 indent = 1; s = format (s, "%U wrk-index %u app-index %u map-index %u " "api-client-index %d\n", format_white_space, indent, app_wrk->wrk_index, app_wrk->app_index, app_wrk->wrk_map_index, app_wrk->api_client_index); return s; } void app_worker_format_connects (app_worker_t * app_wrk, int verbose) { segment_manager_t *sm; /* Header */ if (!app_wrk) { segment_manager_format_sessions (0, verbose); return; } if (app_wrk->connects_seg_manager == (u32) ~ 0) return; sm = segment_manager_get (app_wrk->connects_seg_manager); segment_manager_format_sessions (sm, verbose); } /* * fd.io coding-style-patch-verification: ON * * Local Variables: * eval: (c-set-style "gnu") * End: */