X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fsession%2Fapplication_worker.c;h=1793998f1e01944d1f42a797cf4dd8ee91c288ea;hb=d8f48e2166747b529aa23762ac314dd686590c89;hp=3bab3564ad9d4b2dd58462797b60f1ae71009c46;hpb=51a423dc2b0d4aad0bbd8f7e757d2ca49221ff83;p=vpp.git diff --git a/src/vnet/session/application_worker.c b/src/vnet/session/application_worker.c index 3bab3564ad9..1793998f1e0 100644 --- a/src/vnet/session/application_worker.c +++ b/src/vnet/session/application_worker.c @@ -22,110 +22,6 @@ */ static app_worker_t *app_workers; -static inline u64 -application_client_local_connect_key (local_session_t * ls) -{ - return (((u64) ls->app_wrk_index) << 32 | (u64) ls->session_index); -} - -static inline void -application_client_local_connect_key_parse (u64 key, u32 * app_wrk_index, - u32 * session_index) -{ - *app_wrk_index = key >> 32; - *session_index = key & 0xFFFFFFFF; -} - -local_session_t * -app_worker_local_session_alloc (app_worker_t * app_wrk) -{ - local_session_t *s; - pool_get (app_wrk->local_sessions, s); - clib_memset (s, 0, sizeof (*s)); - s->app_wrk_index = app_wrk->wrk_index; - s->session_index = s - app_wrk->local_sessions; - s->session_type = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE, 0); - return s; -} - -void -app_worker_local_session_free (app_worker_t * app_wrk, local_session_t * s) -{ - pool_put (app_wrk->local_sessions, s); - if (CLIB_DEBUG) - clib_memset (s, 0xfc, sizeof (*s)); -} - -local_session_t * -app_worker_get_local_session (app_worker_t * app_wrk, u32 session_index) -{ - if (pool_is_free_index (app_wrk->local_sessions, session_index)) - return 0; - return pool_elt_at_index (app_wrk->local_sessions, session_index); -} - -local_session_t * -app_worker_get_local_session_from_handle (session_handle_t handle) -{ - app_worker_t *server_wrk; - u32 session_index, server_wrk_index; - local_session_parse_handle (handle, &server_wrk_index, &session_index); - server_wrk = app_worker_get_if_valid (server_wrk_index); - if (!server_wrk) - return 0; - return app_worker_get_local_session (server_wrk, session_index); -} - -void -app_worker_local_sessions_free (app_worker_t * app_wrk) -{ - u32 index, server_wrk_index, session_index; - u64 handle, *handles = 0; - app_worker_t *server_wrk; - segment_manager_t *sm; - local_session_t *ls; - int i; - - /* - * Local sessions - */ - if (app_wrk->local_sessions) - { - /* *INDENT-OFF* */ - pool_foreach (ls, app_wrk->local_sessions, ({ - app_worker_local_session_disconnect (app_wrk->wrk_index, ls); - })); - /* *INDENT-ON* */ - } - - /* - * Local connects - */ - vec_reset_length (handles); - /* *INDENT-OFF* */ - hash_foreach (handle, index, app_wrk->local_connects, ({ - vec_add1 (handles, handle); - })); - /* *INDENT-ON* */ - - for (i = 0; i < vec_len (handles); i++) - { - application_client_local_connect_key_parse (handles[i], - &server_wrk_index, - &session_index); - server_wrk = app_worker_get_if_valid (server_wrk_index); - if (server_wrk) - { - ls = app_worker_get_local_session (server_wrk, session_index); - app_worker_local_session_disconnect (app_wrk->wrk_index, ls); - } - } - - sm = segment_manager_get (app_wrk->local_segment_manager); - sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX; - segment_manager_del (sm); -} - app_worker_t * app_worker_alloc (application_t * app) { @@ -137,8 +33,7 @@ app_worker_alloc (application_t * app) app_wrk->wrk_map_index = ~0; app_wrk->connects_seg_manager = APP_INVALID_SEGMENT_MANAGER_INDEX; app_wrk->first_segment_manager = APP_INVALID_SEGMENT_MANAGER_INDEX; - app_wrk->local_segment_manager = APP_INVALID_SEGMENT_MANAGER_INDEX; - APP_DBG ("New app %v worker %u", app_get_name (app), app_wrk->wrk_index); + APP_DBG ("New app %v worker %u", app->name, app_wrk->wrk_index); return app_wrk; } @@ -163,10 +58,9 @@ app_worker_free (app_worker_t * app_wrk) vnet_unlisten_args_t _a, *a = &_a; u64 handle, *handles = 0; segment_manager_t *sm; + session_t *ls; u32 sm_index; int i; - app_listener_t *al; - session_t *ls; /* * Listener cleanup @@ -175,8 +69,7 @@ app_worker_free (app_worker_t * app_wrk) /* *INDENT-OFF* */ hash_foreach (handle, sm_index, app_wrk->listeners_table, ({ ls = listen_session_get_from_handle (handle); - al = app_listener_get (app, ls->al_index); - vec_add1 (handles, app_listener_handle (al)); + vec_add1 (handles, app_listen_session_handle (ls)); sm = segment_manager_get (sm_index); sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX; })); @@ -199,7 +92,8 @@ app_worker_free (app_worker_t * app_wrk) { sm = segment_manager_get (app_wrk->connects_seg_manager); sm->app_wrk_index = SEGMENT_MANAGER_INVALID_APP_INDEX; - segment_manager_init_del (sm); + sm->first_is_protected = 0; + segment_manager_init_free (sm); } /* If first segment manager is used by a listener */ @@ -212,17 +106,12 @@ app_worker_free (app_worker_t * app_wrk) /* .. and has no fifos, e.g. it might be used for redirected sessions, * remove it */ if (!segment_manager_has_fifos (sm)) - segment_manager_del (sm); + segment_manager_free (sm); } - /* - * Local sessions - */ - app_worker_local_sessions_free (app_wrk); - - pool_put (app_workers, app_wrk); if (CLIB_DEBUG) clib_memset (app_wrk, 0xfe, sizeof (*app_wrk)); + pool_put (app_workers, app_wrk); } application_t * @@ -249,7 +138,7 @@ app_worker_alloc_segment_manager (app_worker_t * app_wrk) return sm; } - sm = segment_manager_new (); + sm = segment_manager_alloc (); sm->app_wrk_index = app_wrk->wrk_index; return sm; @@ -259,11 +148,10 @@ static int app_worker_alloc_session_fifos (segment_manager_t * sm, session_t * s) { svm_fifo_t *rx_fifo = 0, *tx_fifo = 0; - u32 fifo_segment_index; int rv; - if ((rv = segment_manager_alloc_session_fifos (sm, &rx_fifo, &tx_fifo, - &fifo_segment_index))) + if ((rv = segment_manager_alloc_session_fifos (sm, s->thread_index, + &rx_fifo, &tx_fifo))) return rv; rx_fifo->master_session_index = s->session_index; @@ -274,27 +162,13 @@ app_worker_alloc_session_fifos (segment_manager_t * sm, session_t * s) s->rx_fifo = rx_fifo; s->tx_fifo = tx_fifo; - s->svm_segment_index = fifo_segment_index; return 0; } int -app_worker_start_listen (app_worker_t * app_wrk, - app_listener_t * app_listener) +app_worker_init_listener (app_worker_t * app_wrk, session_t * ls) { segment_manager_t *sm; - session_t *ls; - - if (clib_bitmap_get (app_listener->workers, app_wrk->wrk_map_index)) - return VNET_API_ERROR_ADDRESS_IN_USE; - - app_listener->workers = clib_bitmap_set (app_listener->workers, - app_wrk->wrk_map_index, 1); - - if (app_listener->session_index == SESSION_INVALID_INDEX) - return 0; - - ls = session_get (app_listener->session_index, 0); /* Allocate segment manager. All sessions derived out of a listen session * have fifos allocated by the same segment manager. */ @@ -314,57 +188,78 @@ app_worker_start_listen (app_worker_t * app_wrk, } int -app_worker_stop_listen (app_worker_t * app_wrk, app_listener_t * al) +app_worker_start_listen (app_worker_t * app_wrk, + app_listener_t * app_listener) +{ + session_t *ls; + + if (clib_bitmap_get (app_listener->workers, app_wrk->wrk_map_index)) + return VNET_API_ERROR_ADDRESS_IN_USE; + + 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 (app_worker_init_listener (app_wrk, ls)) + return -1; + } + + if (app_listener->local_index != SESSION_INVALID_INDEX) + { + ls = session_get (app_listener->local_index, 0); + if (app_worker_init_listener (app_wrk, ls)) + return -1; + } + + return 0; +} + +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; + handle = listen_session_get_handle (ls); + sm_indexp = hash_get (app_wrk->listeners_table, handle); + if (PREDICT_FALSE (!sm_indexp)) + return; + + sm = segment_manager_get (*sm_indexp); + if (app_wrk->first_segment_manager == *sm_indexp) + { + /* Delete sessions but don't remove segment manager */ + app_wrk->first_segment_manager_in_use = 0; + segment_manager_del_sessions (sm); + } + else + { + segment_manager_init_free (sm); + } + 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) { - session_t *ls; - ls = listen_session_get (al->session_index); - handle = listen_session_get_handle (ls); - - sm_indexp = hash_get (app_wrk->listeners_table, handle); - if (PREDICT_FALSE (!sm_indexp)) - { - clib_warning ("listener handle was removed %llu!", handle); - return -1; - } - - sm = segment_manager_get (*sm_indexp); - if (app_wrk->first_segment_manager == *sm_indexp) - { - /* Delete sessions but don't remove segment manager */ - app_wrk->first_segment_manager_in_use = 0; - segment_manager_del_sessions (sm); - } - else - { - segment_manager_init_del (sm); - } - hash_unset (app_wrk->listeners_table, handle); + app_worker_stop_listen_session (app_wrk, ls); } if (al->local_index != SESSION_INVALID_INDEX) { - local_session_t *ll, *ls; - application_t *app; - - app = application_get (app_wrk->app_index); - ll = application_get_local_listen_session (app, al->local_index); - - /* *INDENT-OFF* */ - pool_foreach (ls, app_wrk->local_sessions, ({ - if (ls->listener_index == ll->session_index) - app_worker_local_session_disconnect (app_wrk->wrk_index, ls); - })); - /* *INDENT-ON* */ + 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); @@ -380,12 +275,21 @@ 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 (s->listener_index); + 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); - return app_worker_alloc_session_fifos (sm, s); + if (app_worker_alloc_session_fifos (sm, s)) + return -1; + + return 0; } int @@ -408,6 +312,10 @@ app_worker_init_connected (app_worker_t * app_wrk, session_t * s) if (app_worker_alloc_session_fifos (sm, s)) return -1; } + + if (app->cb_fns.fifo_tuning_callback) + s->flags |= SESSION_F_CUSTOM_FIFO_TUNING; + return 0; } @@ -419,6 +327,70 @@ app_worker_connect_notify (app_worker_t * app_wrk, session_t * s, u32 opaque) s, s == 0 /* is_fail */ ); } +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) { @@ -443,23 +415,13 @@ app_worker_own_session (app_worker_t * app_wrk, session_t * s) if (app_worker_alloc_session_fifos (sm, s)) return -1; - if (!svm_fifo_is_empty (rxf)) - { - clib_memcpy_fast (s->rx_fifo->data, rxf->data, rxf->nitems); - s->rx_fifo->head = rxf->head; - s->rx_fifo->tail = rxf->tail; - s->rx_fifo->cursize = rxf->cursize; - } + if (!svm_fifo_is_empty_cons (rxf)) + svm_fifo_clone (s->rx_fifo, rxf); - if (!svm_fifo_is_empty (txf)) - { - clib_memcpy_fast (s->tx_fifo->data, txf->data, txf->nitems); - s->tx_fifo->head = txf->head; - s->tx_fifo->tail = txf->tail; - s->tx_fifo->cursize = txf->cursize; - } + if (!svm_fifo_is_empty_cons (txf)) + svm_fifo_clone (s->tx_fifo, txf); - segment_manager_dealloc_fifos (rxf->segment_index, rxf, txf); + segment_manager_dealloc_fifos (rxf, txf); return 0; } @@ -479,6 +441,15 @@ app_worker_connect_session (app_worker_t * app, session_endpoint_t * sep, return 0; } +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); +} + int app_worker_alloc_connects_segment_manager (app_worker_t * app_wrk) { @@ -515,7 +486,7 @@ app_worker_get_listen_segment_manager (app_worker_t * app, { uword *smp; smp = hash_get (app->listeners_table, listen_session_get_handle (listener)); - ASSERT (smp != 0); + ALWAYS_ASSERT (smp != 0); return segment_manager_get (*smp); } @@ -535,7 +506,7 @@ app_worker_first_listener (app_worker_t * app_wrk, u8 fib_proto, hash_foreach (handle, sm_index, app_wrk->listeners_table, ({ listener = listen_session_get_from_handle (handle); if (listener->session_type == sst - && listener->enqueue_epoch != SESSION_PROXY_LISTENER_INDEX) + && !(listener->flags & SESSION_F_PROXY)) return listener; })); /* *INDENT-ON* */ @@ -558,8 +529,7 @@ app_worker_proxy_listener (app_worker_t * app_wrk, u8 fib_proto, /* *INDENT-OFF* */ hash_foreach (handle, sm_index, app_wrk->listeners_table, ({ listener = listen_session_get_from_handle (handle); - if (listener->session_type == sst - && listener->enqueue_epoch == SESSION_PROXY_LISTENER_INDEX) + if (listener->session_type == sst && (listener->flags & SESSION_F_PROXY)) return listener; })); /* *INDENT-ON* */ @@ -571,154 +541,120 @@ app_worker_proxy_listener (app_worker_t * app_wrk, u8 fib_proto, * Send an API message to the external app, to map new segment */ int -app_worker_add_segment_notify (u32 app_wrk_index, u64 segment_handle) +app_worker_add_segment_notify (app_worker_t * app_wrk, u64 segment_handle) { - app_worker_t *app_wrk = app_worker_get (app_wrk_index); application_t *app = application_get (app_wrk->app_index); - return app->cb_fns.add_segment_callback (app_wrk->api_client_index, + + return app->cb_fns.add_segment_callback (app_wrk->wrk_index, segment_handle); } -u8 -app_worker_application_is_builtin (app_worker_t * app_wrk) +int +app_worker_del_segment_notify (app_worker_t * app_wrk, u64 segment_handle) { - return app_wrk->app_is_builtin; + application_t *app = application_get (app_wrk->app_index); + return app->cb_fns.del_segment_callback (app_wrk->wrk_index, + segment_handle); } -static inline int -app_enqueue_evt (svm_msg_q_t * mq, svm_msg_q_msg_t * msg, u8 lock) +static inline u8 +app_worker_application_is_builtin (app_worker_t * app_wrk) { - if (PREDICT_FALSE (svm_msg_q_is_full (mq))) - { - clib_warning ("evt q full"); - svm_msg_q_free_msg (mq, msg); - if (lock) - svm_msg_q_unlock (mq); - return -1; - } - - if (lock) - { - svm_msg_q_add_and_unlock (mq, msg); - return 0; - } - - /* Even when not locking the ring, we must wait for queue mutex */ - if (svm_msg_q_add (mq, msg, SVM_Q_WAIT)) - { - clib_warning ("msg q add returned"); - return -1; - } - return 0; + return app_wrk->app_is_builtin; } static inline int -app_send_io_evt_rx (app_worker_t * app_wrk, session_t * s, u8 lock) +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); + + /* Make sure the session is in established state within external apps. + * Should be removed once we confirm closes to apps */ if (PREDICT_FALSE (s->session_state != SESSION_STATE_READY && s->session_state != SESSION_STATE_LISTENING)) - { - /* Session is closed so app will never clean up. Flush rx fifo */ - if (s->session_state == SESSION_STATE_CLOSED) - svm_fifo_dequeue_drop_all (s->rx_fifo); - return 0; - } - - if (app_worker_application_is_builtin (app_wrk)) - { - application_t *app = application_get (app_wrk->app_index); - return app->cb_fns.builtin_app_rx_callback (s); - } + return 0; - if (svm_fifo_has_event (s->rx_fifo) || svm_fifo_is_empty (s->rx_fifo)) + if (svm_fifo_has_event (s->rx_fifo)) return 0; mq = app_wrk->event_queue; - if (lock) - svm_msg_q_lock (mq); + 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"); - if (lock) - svm_msg_q_unlock (mq); + svm_msg_q_unlock (mq); return -1; } msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING); - ASSERT (!svm_msg_q_msg_is_invalid (&msg)); - evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg); - evt->fifo = s->rx_fifo; - evt->event_type = FIFO_EVENT_APP_RX; + evt->session_index = s->rx_fifo->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); - if (app_enqueue_evt (mq, &msg, lock)) - return -1; return 0; } static inline int -app_send_io_evt_tx (app_worker_t * app_wrk, session_t * s, u8 lock) +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 0; + return app_worker_builtin_tx (app_wrk, s); mq = app_wrk->event_queue; - if (lock) - svm_msg_q_lock (mq); + 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"); - if (lock) - svm_msg_q_unlock (mq); + svm_msg_q_unlock (mq); return -1; } msg = svm_msg_q_alloc_msg_w_ring (mq, SESSION_MQ_IO_EVT_RING); - ASSERT (!svm_msg_q_msg_is_invalid (&msg)); - evt = (session_event_t *) svm_msg_q_msg_data (mq, &msg); - evt->event_type = FIFO_EVENT_APP_TX; - evt->fifo = s->tx_fifo; + evt->event_type = SESSION_IO_EVT_TX; + evt->session_index = s->tx_fifo->client_session_index; - return app_enqueue_evt (mq, &msg, lock); + 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, - u8 lock); -static app_send_evt_handler_fn * const app_send_evt_handler_fns[3] = { + session_t *s); +static app_send_evt_handler_fn * const app_send_evt_handler_fns[2] = { app_send_io_evt_rx, - 0, app_send_io_evt_tx, }; /* *INDENT-ON* */ -/** - * Send event to application - * - * Logic from queue perspective is non-blocking. If there's - * not enough space to enqueue a message, we return. - */ -int -app_worker_send_event (app_worker_t * app, session_t * s, u8 evt_type) -{ - ASSERT (app && evt_type <= FIFO_EVENT_APP_TX); - return app_send_evt_handler_fns[evt_type] (app, s, 0 /* lock */ ); -} - /** * Send event to application * @@ -729,294 +665,7 @@ 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, 1 /* lock */ ); -} - -segment_manager_t * -app_worker_get_local_segment_manager (app_worker_t * app_worker) -{ - return segment_manager_get (app_worker->local_segment_manager); -} - -segment_manager_t * -app_worker_get_local_segment_manager_w_session (app_worker_t * app_wrk, - local_session_t * ls) -{ - session_t *listener; - if (application_local_session_listener_has_transport (ls)) - { - listener = listen_session_get (ls->listener_index); - return app_worker_get_listen_segment_manager (app_wrk, listener); - } - return segment_manager_get (app_wrk->local_segment_manager); -} - -int -app_worker_local_session_cleanup (app_worker_t * client_wrk, - app_worker_t * server_wrk, - local_session_t * ls) -{ - svm_fifo_segment_private_t *seg; - session_t *listener; - segment_manager_t *sm; - u64 client_key; - u8 has_transport; - - /* Retrieve listener transport type as it is the one that decides where - * the fifos are allocated */ - has_transport = application_local_session_listener_has_transport (ls); - if (!has_transport) - sm = app_worker_get_local_segment_manager_w_session (server_wrk, ls); - else - { - listener = listen_session_get (ls->listener_index); - sm = app_worker_get_listen_segment_manager (server_wrk, listener); - } - - seg = segment_manager_get_segment (sm, ls->svm_segment_index); - if (client_wrk) - { - client_key = application_client_local_connect_key (ls); - hash_unset (client_wrk->local_connects, client_key); - } - - if (!has_transport) - { - application_t *server = application_get (server_wrk->app_index); - u64 segment_handle = segment_manager_segment_handle (sm, seg); - server->cb_fns.del_segment_callback (server_wrk->api_client_index, - segment_handle); - if (client_wrk) - { - application_t *client = application_get (client_wrk->app_index); - client->cb_fns.del_segment_callback (client_wrk->api_client_index, - segment_handle); - } - segment_manager_del_segment (sm, seg); - } - - app_worker_local_session_free (server_wrk, ls); - - return 0; -} - -static void -application_local_session_fix_eventds (svm_msg_q_t * sq, svm_msg_q_t * cq) -{ - int fd; - - /* - * segment manager initializes only the producer eventds, since vpp is - * typically the producer. But for local sessions, we also pass to the - * apps the mqs they listen on for events from peer apps, so they are also - * consumer fds. - */ - fd = svm_msg_q_get_producer_eventfd (sq); - svm_msg_q_set_consumer_eventfd (sq, fd); - fd = svm_msg_q_get_producer_eventfd (cq); - svm_msg_q_set_consumer_eventfd (cq, fd); -} - -int -app_worker_local_session_connect (app_worker_t * client_wrk, - app_worker_t * server_wrk, - local_session_t * ll, u32 opaque) -{ - u32 seg_size, evt_q_sz, evt_q_elts, margin = 16 << 10; - u32 round_rx_fifo_sz, round_tx_fifo_sz, sm_index; - segment_manager_properties_t *props, *cprops; - int rv, has_transport, seg_index; - svm_fifo_segment_private_t *seg; - application_t *server, *client; - segment_manager_t *sm; - local_session_t *ls; - svm_msg_q_t *sq, *cq; - u64 segment_handle; - - ls = app_worker_local_session_alloc (server_wrk); - server = application_get (server_wrk->app_index); - client = application_get (client_wrk->app_index); - - props = application_segment_manager_properties (server); - cprops = application_segment_manager_properties (client); - evt_q_elts = props->evt_q_size + cprops->evt_q_size; - evt_q_sz = segment_manager_evt_q_expected_size (evt_q_elts); - round_rx_fifo_sz = 1 << max_log2 (props->rx_fifo_size); - round_tx_fifo_sz = 1 << max_log2 (props->tx_fifo_size); - seg_size = round_rx_fifo_sz + round_tx_fifo_sz + evt_q_sz + margin; - - has_transport = session_has_transport ((session_t *) ll); - if (!has_transport) - { - /* Local sessions don't have backing transport */ - ls->port = ll->port; - sm = app_worker_get_local_segment_manager (server_wrk); - } - else - { - session_t *sl = (session_t *) ll; - transport_connection_t *tc; - tc = listen_session_get_transport (sl); - ls->port = tc->lcl_port; - sm = app_worker_get_listen_segment_manager (server_wrk, sl); - } - - seg_index = segment_manager_add_segment (sm, seg_size); - if (seg_index < 0) - { - clib_warning ("failed to add new cut-through segment"); - return seg_index; - } - seg = segment_manager_get_segment_w_lock (sm, seg_index); - sq = segment_manager_alloc_queue (seg, props); - cq = segment_manager_alloc_queue (seg, cprops); - - if (props->use_mq_eventfd) - application_local_session_fix_eventds (sq, cq); - - ls->server_evt_q = pointer_to_uword (sq); - ls->client_evt_q = pointer_to_uword (cq); - rv = segment_manager_try_alloc_fifos (seg, props->rx_fifo_size, - props->tx_fifo_size, - &ls->rx_fifo, &ls->tx_fifo); - if (rv) - { - clib_warning ("failed to add fifos in cut-through segment"); - segment_manager_segment_reader_unlock (sm); - goto failed; - } - sm_index = segment_manager_index (sm); - ls->rx_fifo->ct_session_index = ls->session_index; - ls->tx_fifo->ct_session_index = ls->session_index; - ls->rx_fifo->segment_manager = sm_index; - ls->tx_fifo->segment_manager = sm_index; - ls->rx_fifo->segment_index = seg_index; - ls->tx_fifo->segment_index = seg_index; - ls->svm_segment_index = seg_index; - ls->listener_index = ll->session_index; - ls->client_wrk_index = client_wrk->wrk_index; - ls->client_opaque = opaque; - ls->listener_session_type = ll->session_type; - ls->session_state = SESSION_STATE_READY; - - segment_handle = segment_manager_segment_handle (sm, seg); - if ((rv = server->cb_fns.add_segment_callback (server_wrk->api_client_index, - segment_handle))) - { - clib_warning ("failed to notify server of new segment"); - segment_manager_segment_reader_unlock (sm); - goto failed; - } - segment_manager_segment_reader_unlock (sm); - if ((rv = server->cb_fns.session_accept_callback ((session_t *) ls))) - { - clib_warning ("failed to send accept cut-through notify to server"); - goto failed; - } - if (server->flags & APP_OPTIONS_FLAGS_IS_BUILTIN) - app_worker_local_session_connect_notify (ls); - - return 0; - -failed: - if (!has_transport) - segment_manager_del_segment (sm, seg); - return rv; -} - -int -app_worker_local_session_connect_notify (local_session_t * ls) -{ - svm_fifo_segment_private_t *seg; - app_worker_t *client_wrk, *server_wrk; - segment_manager_t *sm; - application_t *client; - int rv, is_fail = 0; - u64 segment_handle; - u64 client_key; - - client_wrk = app_worker_get (ls->client_wrk_index); - server_wrk = app_worker_get (ls->app_wrk_index); - client = application_get (client_wrk->app_index); - - sm = app_worker_get_local_segment_manager_w_session (server_wrk, ls); - seg = segment_manager_get_segment_w_lock (sm, ls->svm_segment_index); - segment_handle = segment_manager_segment_handle (sm, seg); - if ((rv = client->cb_fns.add_segment_callback (client_wrk->api_client_index, - segment_handle))) - { - clib_warning ("failed to notify client %u of new segment", - ls->client_wrk_index); - segment_manager_segment_reader_unlock (sm); - app_worker_local_session_disconnect (ls->client_wrk_index, ls); - is_fail = 1; - } - else - { - segment_manager_segment_reader_unlock (sm); - } - - client->cb_fns.session_connected_callback (client_wrk->wrk_index, - ls->client_opaque, - (session_t *) ls, is_fail); - - client_key = application_client_local_connect_key (ls); - hash_set (client_wrk->local_connects, client_key, client_key); - return 0; -} - -int -app_worker_local_session_disconnect (u32 app_wrk_index, local_session_t * ls) -{ - app_worker_t *client_wrk, *server_wrk; - - client_wrk = app_worker_get_if_valid (ls->client_wrk_index); - server_wrk = app_worker_get (ls->app_wrk_index); - - if (ls->session_state == SESSION_STATE_CLOSED) - return app_worker_local_session_cleanup (client_wrk, server_wrk, ls); - - if (app_wrk_index == ls->client_wrk_index) - { - mq_send_local_session_disconnected_cb (ls->app_wrk_index, ls); - } - else - { - if (!client_wrk) - { - return app_worker_local_session_cleanup (client_wrk, server_wrk, - ls); - } - else if (ls->session_state < SESSION_STATE_READY) - { - application_t *client = application_get (client_wrk->app_index); - client->cb_fns.session_connected_callback (client_wrk->wrk_index, - ls->client_opaque, - (session_t *) ls, - 1 /* is_fail */ ); - ls->session_state = SESSION_STATE_CLOSED; - return app_worker_local_session_cleanup (client_wrk, server_wrk, - ls); - } - else - { - mq_send_local_session_disconnected_cb (client_wrk->wrk_index, ls); - } - } - - ls->session_state = SESSION_STATE_CLOSED; - - return 0; -} - -int -app_worker_local_session_disconnect_w_index (u32 app_wrk_index, u32 ls_index) -{ - app_worker_t *app_wrk; - local_session_t *ls; - app_wrk = app_worker_get (app_wrk_index); - ls = app_worker_get_local_session (app_wrk, ls_index); - return app_worker_local_session_disconnect (app_wrk_index, ls); + return app_send_evt_handler_fns[evt_type] (app, s); } u8 * @@ -1043,7 +692,7 @@ format_app_worker_listener (u8 * s, va_list * args) app_name = application_name_from_index (app_wrk->app_index); listener = listen_session_get_from_handle (handle); - str = format (0, "%U", format_stream_session, listener, verbose); + str = format (0, "%U", format_session, listener, verbose); if (verbose) { @@ -1074,136 +723,20 @@ format_app_worker (u8 * s, va_list * args) void app_worker_format_connects (app_worker_t * app_wrk, int verbose) { - svm_fifo_segment_private_t *fifo_segment; - vlib_main_t *vm = vlib_get_main (); segment_manager_t *sm; - const u8 *app_name; - u8 *s = 0; /* Header */ if (!app_wrk) { - if (verbose) - vlib_cli_output (vm, "%-40s%-20s%-15s%-10s", "Connection", "App", - "API Client", "SegManager"); - else - vlib_cli_output (vm, "%-40s%-20s", "Connection", "App"); + segment_manager_format_sessions (0, verbose); return; } if (app_wrk->connects_seg_manager == (u32) ~ 0) return; - app_name = application_name_from_index (app_wrk->app_index); - - /* Across all fifo segments */ sm = segment_manager_get (app_wrk->connects_seg_manager); - - /* *INDENT-OFF* */ - segment_manager_foreach_segment_w_lock (fifo_segment, sm, ({ - svm_fifo_t *fifo; - u8 *str; - - fifo = svm_fifo_segment_get_fifo_list (fifo_segment); - while (fifo) - { - u32 session_index, thread_index; - session_t *session; - - session_index = fifo->master_session_index; - thread_index = fifo->master_thread_index; - - session = session_get (session_index, thread_index); - str = format (0, "%U", format_stream_session, session, verbose); - - if (verbose) - s = format (s, "%-40s%-20s%-15u%-10u", str, app_name, - app_wrk->api_client_index, app_wrk->connects_seg_manager); - else - s = format (s, "%-40s%-20s", str, app_name); - - vlib_cli_output (vm, "%v", s); - vec_reset_length (s); - vec_free (str); - - fifo = fifo->next; - } - vec_free (s); - })); - /* *INDENT-ON* */ -} - -void -app_worker_format_local_sessions (app_worker_t * app_wrk, int verbose) -{ - vlib_main_t *vm = vlib_get_main (); - app_worker_t *client_wrk; - local_session_t *ls; - transport_proto_t tp; - u8 *conn = 0; - - /* Header */ - if (app_wrk == 0) - { - vlib_cli_output (vm, "%-40s%-15s%-20s", "Connection", "ServerApp", - "ClientApp"); - return; - } - - if (!pool_elts (app_wrk->local_sessions) - && !pool_elts (app_wrk->local_connects)) - return; - - /* *INDENT-OFF* */ - pool_foreach (ls, app_wrk->local_sessions, ({ - tp = session_type_transport_proto(ls->listener_session_type); - conn = format (0, "[L][%U] *:%u", format_transport_proto_short, tp, - ls->port); - client_wrk = app_worker_get (ls->client_wrk_index); - vlib_cli_output (vm, "%-40v%-15u%-20u", conn, ls->app_index, - client_wrk->app_index); - vec_reset_length (conn); - })); - /* *INDENT-ON* */ - - vec_free (conn); -} - -void -app_worker_format_local_connects (app_worker_t * app, int verbose) -{ - vlib_main_t *vm = vlib_get_main (); - u32 app_wrk_index, session_index; - app_worker_t *server_wrk; - local_session_t *ls; - u64 client_key; - u64 value; - - /* Header */ - if (app == 0) - { - if (verbose) - vlib_cli_output (vm, "%-40s%-15s%-20s%-10s", "Connection", "App", - "Peer App", "SegManager"); - else - vlib_cli_output (vm, "%-40s%-15s%-20s", "Connection", "App", - "Peer App"); - return; - } - - if (!app->local_connects) - return; - - /* *INDENT-OFF* */ - hash_foreach (client_key, value, app->local_connects, ({ - application_client_local_connect_key_parse (client_key, &app_wrk_index, - &session_index); - server_wrk = app_worker_get (app_wrk_index); - ls = app_worker_get_local_session (server_wrk, session_index); - vlib_cli_output (vm, "%-40s%-15s%-20s", "TODO", ls->app_wrk_index, - ls->client_wrk_index); - })); - /* *INDENT-ON* */ + segment_manager_format_sessions (sm, verbose); } /*