+application_local_session_free (app_worker_t * app, local_session_t * s)
+{
+ pool_put (app->local_sessions, s);
+ if (CLIB_DEBUG)
+ clib_memset (s, 0xfc, sizeof (*s));
+}
+
+local_session_t *
+application_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 *
+application_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 application_get_local_session (server_wrk, session_index);
+}
+
+local_session_t *
+application_local_listen_session_alloc (application_t * app)
+{
+ local_session_t *ll;
+ pool_get (app->local_listen_sessions, ll);
+ clib_memset (ll, 0, sizeof (*ll));
+ return ll;
+}
+
+u32
+application_local_listener_index (application_t * app, local_session_t * ll)
+{
+ return (ll - app->local_listen_sessions);
+}
+
+void
+application_local_listen_session_free (application_t * app,
+ local_session_t * ll)
+{
+ pool_put (app->local_listen_sessions, ll);
+ if (CLIB_DEBUG)
+ clib_memset (ll, 0xfb, sizeof (*ll));
+}
+
+int
+application_start_local_listen (application_t * app,
+ session_endpoint_cfg_t * sep_ext,
+ session_handle_t * handle)
+{
+ app_listener_t *app_listener;
+ session_endpoint_t *sep;
+ app_worker_t *app_wrk;
+ session_handle_t lh;
+ local_session_t *ll;
+ u32 table_index;
+
+ sep = (session_endpoint_t *) sep_ext;
+ table_index = application_local_session_table (app);
+ app_wrk = app_worker_get (sep_ext->app_wrk_index);
+
+ /* An exact sep match, as opposed to session_lookup_local_listener */
+ lh = session_lookup_endpoint_listener (table_index, sep, 1);
+ if (lh != SESSION_INVALID_HANDLE)
+ {
+ ll = application_get_local_listener_w_handle (lh);
+ if (ll->app_index != app->app_index)
+ return VNET_API_ERROR_ADDRESS_IN_USE;
+
+ if (ll->app_wrk_index == app_wrk->wrk_index)
+ return VNET_API_ERROR_ADDRESS_IN_USE;
+
+ app_listener = app_local_listener_get (app, ll->listener_db_index);
+ app_listener->workers = clib_bitmap_set (app_listener->workers,
+ app_wrk->wrk_map_index, 1);
+ *handle = application_local_session_handle (ll);
+ return 0;
+ }
+
+ ll = application_local_listen_session_alloc (app);
+ ll->session_type = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE, 0);
+ ll->app_wrk_index = app_wrk->app_index;
+ ll->session_index = application_local_listener_index (app, ll);
+ ll->port = sep_ext->port;
+ /* Store the original session type for the unbind */
+ ll->listener_session_type =
+ session_type_from_proto_and_ip (sep_ext->transport_proto,
+ sep_ext->is_ip4);
+ ll->transport_listener_index = ~0;
+ ll->app_index = app->app_index;
+
+ app_listener = app_local_listener_alloc (app);
+ ll->listener_db_index = app_listener->al_index;
+ app_listener->workers = clib_bitmap_set (app_listener->workers,
+ app_wrk->wrk_map_index, 1);
+
+ *handle = application_local_session_handle (ll);
+ session_lookup_add_session_endpoint (table_index, sep, *handle);
+
+ return 0;
+}
+
+/**
+ * Clean up local session table. If we have a listener session use it to
+ * find the port and proto. If not, the handle must be a local table handle
+ * so parse it.
+ */
+int
+application_stop_local_listen (u32 app_index, u32 wrk_map_index,
+ session_handle_t lh)
+{
+ session_endpoint_t sep = SESSION_ENDPOINT_NULL;
+ u32 table_index, ll_index, server_index;
+ app_listener_t *app_listener;
+ app_worker_t *server_wrk;
+ stream_session_t *sl = 0;
+ local_session_t *ll, *ls;
+ application_t *server;
+
+ server = application_get (app_index);
+ table_index = application_local_session_table (server);
+
+ /* We have both local and global table binds. Figure from global what
+ * the sep we should be cleaning up is.
+ */
+ if (!session_handle_is_local (lh))
+ {
+ sl = listen_session_get_from_handle (lh);
+ if (!sl || listen_session_get_local_session_endpoint (sl, &sep))
+ {
+ clib_warning ("broken listener");
+ return -1;
+ }
+ lh = session_lookup_endpoint_listener (table_index, &sep, 0);
+ if (lh == SESSION_INVALID_HANDLE)
+ return -1;
+ }
+
+ local_session_parse_handle (lh, &server_index, &ll_index);
+ if (PREDICT_FALSE (server_index != app_index))
+ {
+ clib_warning ("app %u does not own local handle 0x%lx", app_index, lh);
+ return -1;
+ }
+
+ ll = application_get_local_listen_session (server, ll_index);
+ if (PREDICT_FALSE (!ll))
+ {
+ clib_warning ("no local listener");
+ return -1;
+ }
+
+ app_listener = app_local_listener_get (server, ll->listener_db_index);
+ if (!clib_bitmap_get (app_listener->workers, wrk_map_index))
+ {
+ clib_warning ("app wrk %u not listening on handle %lu", wrk_map_index,
+ lh);
+ return -1;
+ }
+
+ server_wrk = application_get_worker (server, wrk_map_index);
+ /* *INDENT-OFF* */
+ pool_foreach (ls, server_wrk->local_sessions, ({
+ if (ls->listener_index == ll->session_index)
+ application_local_session_disconnect (server_wrk->app_index, ls);
+ }));
+ /* *INDENT-ON* */
+
+ clib_bitmap_set_no_check (app_listener->workers, wrk_map_index, 0);
+ if (clib_bitmap_is_zero (app_listener->workers))
+ {
+ app_local_listener_free (server, app_listener);
+ application_local_listener_session_endpoint (ll, &sep);
+ session_lookup_del_session_endpoint (table_index, &sep);
+ application_local_listen_session_free (server, ll);
+ }
+
+ 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
+application_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;
+ segment_manager_properties_t *props, *cprops;
+ u32 round_rx_fifo_sz, round_tx_fifo_sz;
+ 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;
+
+ ls = application_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 ((stream_session_t *) ll);
+ if (!has_transport)
+ {
+ /* Local sessions don't have backing transport */
+ ls->port = ll->port;
+ sm = application_get_local_segment_manager (server_wrk);
+ }
+ else
+ {
+ stream_session_t *sl = (stream_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->server_rx_fifo,
+ &ls->server_tx_fifo);
+ if (rv)
+ {
+ clib_warning ("failed to add fifos in cut-through segment");
+ segment_manager_segment_reader_unlock (sm);
+ goto failed;
+ }
+ ls->server_rx_fifo->ct_session_index = ls->session_index;
+ ls->server_tx_fifo->ct_session_index = ls->session_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;
+
+ if ((rv = server->cb_fns.add_segment_callback (server_wrk->api_client_index,
+ &seg->ssvm)))
+ {
+ 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 ((stream_session_t *) ls)))
+ {
+ clib_warning ("failed to send accept cut-through notify to server");
+ goto failed;
+ }
+ if (server->flags & APP_OPTIONS_FLAGS_IS_BUILTIN)
+ application_local_session_connect_notify (ls);
+
+ return 0;
+
+failed:
+ if (!has_transport)
+ segment_manager_del_segment (sm, seg);
+ return rv;
+}
+
+static uword
+application_client_local_connect_key (local_session_t * ls)
+{
+ return ((uword) ls->app_wrk_index << 32 | (uword) ls->session_index);
+}
+
+static void
+application_client_local_connect_key_parse (uword key, u32 * app_wrk_index,
+ u32 * session_index)
+{
+ *app_wrk_index = key >> 32;
+ *session_index = key & 0xFFFFFFFF;
+}
+
+int
+application_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;
+ uword 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 = application_get_local_segment_manager_w_session (server_wrk, ls);
+ seg = segment_manager_get_segment_w_lock (sm, ls->svm_segment_index);
+ if ((rv = client->cb_fns.add_segment_callback (client_wrk->api_client_index,
+ &seg->ssvm)))
+ {
+ clib_warning ("failed to notify client %u of new segment",
+ ls->client_wrk_index);
+ segment_manager_segment_reader_unlock (sm);
+ application_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,
+ (stream_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
+application_local_session_cleanup (app_worker_t * client_wrk,
+ app_worker_t * server_wrk,
+ local_session_t * ls)
+{
+ svm_fifo_segment_private_t *seg;
+ stream_session_t *listener;
+ segment_manager_t *sm;
+ uword 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 = application_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);
+ server->cb_fns.del_segment_callback (server_wrk->api_client_index,
+ &seg->ssvm);
+ if (client_wrk)
+ {
+ application_t *client = application_get (client_wrk->app_index);
+ client->cb_fns.del_segment_callback (client_wrk->api_client_index,
+ &seg->ssvm);
+ }
+ segment_manager_del_segment (sm, seg);
+ }
+
+ application_local_session_free (server_wrk, ls);
+
+ return 0;
+}
+
+int
+application_local_session_disconnect (u32 app_index, local_session_t * ls)
+{
+ app_worker_t *client_wrk, *server_wrk;
+ u8 is_server = 0, is_client = 0;
+ application_t *app;
+
+ app = application_get_if_valid (app_index);
+ if (!app)
+ return 0;
+
+ client_wrk = app_worker_get_if_valid (ls->client_wrk_index);
+ server_wrk = app_worker_get (ls->app_wrk_index);
+
+ if (server_wrk->app_index == app_index)
+ is_server = 1;
+ else if (client_wrk && client_wrk->app_index == app_index)
+ is_client = 1;
+
+ if (!is_server && !is_client)
+ {
+ clib_warning ("app %u is neither client nor server for session 0x%lx",
+ app_index, application_local_session_handle (ls));
+ return VNET_API_ERROR_INVALID_VALUE;
+ }
+
+ if (ls->session_state == SESSION_STATE_CLOSED)
+ return application_local_session_cleanup (client_wrk, server_wrk, ls);
+
+ if (app_index == ls->client_wrk_index)
+ {
+ mq_send_local_session_disconnected_cb (ls->app_wrk_index, ls);
+ }
+ else
+ {
+ if (!client_wrk)
+ {
+ return application_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,
+ (stream_session_t *) ls,
+ 1 /* is_fail */ );
+ ls->session_state = SESSION_STATE_CLOSED;
+ return application_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
+application_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 = application_get_local_session (app_wrk, ls_index);
+ return application_local_session_disconnect (app_wrk_index, ls);
+}
+
+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, ({
+ application_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 = application_get_local_session (server_wrk, session_index);
+ application_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);
+}
+
+clib_error_t *
+vnet_app_add_tls_cert (vnet_app_add_tls_cert_args_t * a)
+{
+ application_t *app;
+ app = application_get (a->app_index);
+ if (!app)
+ return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
+ 0, "app %u doesn't exist", a->app_index);
+ app->tls_cert = vec_dup (a->cert);
+ return 0;
+}
+
+clib_error_t *
+vnet_app_add_tls_key (vnet_app_add_tls_key_args_t * a)
+{
+ application_t *app;
+ app = application_get (a->app_index);
+ if (!app)
+ return clib_error_return_code (0, VNET_API_ERROR_APPLICATION_NOT_ATTACHED,
+ 0, "app %u doesn't exist", a->app_index);
+ app->tls_key = vec_dup (a->key);
+ return 0;
+}
+
+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);
+ stream_session_t *listener;
+ const u8 *app_name;
+ u8 *str;
+
+ if (!app_wrk)
+ {
+ if (verbose)
+ s = format (s, "%-40s%-25s%=10s%-15s%-15s%-10s", "Connection", "App",
+ "Wrk", "API Client", "ListenerID", "SegManager");
+ else
+ s = format (s, "%-40s%-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_stream_session, listener, verbose);
+
+ if (verbose)
+ {
+ char buf[32];
+ sprintf (buf, "%u(%u)", app_wrk->wrk_map_index, app_wrk->wrk_index);
+ s = format (s, "%-40s%-25s%=10s%-15u%-15u%-10u", str, app_name,
+ buf, app_wrk->api_client_index, handle, sm_index);
+ }
+ else
+ s = format (s, "%-40s%-25s%=10u", str, app_name, app_wrk->wrk_map_index);
+
+ return s;
+}
+
+static void
+application_format_listeners (application_t * app, int verbose)