#include <vnet/session/application.h>
#include <vnet/session/application_interface.h>
#include <vnet/session/application_namespace.h>
+#include <vnet/session/application_local.h>
#include <vnet/session/session.h>
static app_main_t app_main;
return 0; \
}
-static void
-application_local_listener_session_endpoint (local_session_t * ll,
- session_endpoint_t * sep)
-{
- sep->transport_proto =
- session_type_transport_proto (ll->listener_session_type);
- sep->port = ll->port;
- sep->is_ip4 = ll->listener_session_type & 1;
-}
-
static app_listener_t *
app_listener_alloc (application_t * app)
{
return pool_elt_at_index (app->listeners, app_listener_index);
}
+static app_listener_t *
+app_listener_get_if_valid (application_t * app, u32 app_listener_index)
+{
+ if (pool_is_free_index (app->listeners, app_listener_index))
+ return 0;
+ return pool_elt_at_index (app->listeners, app_listener_index);
+}
+
static void
app_listener_free (application_t * app, app_listener_t * app_listener)
{
clib_memset (app_listener, 0xfa, sizeof (*app_listener));
}
-local_session_t *
-application_local_listen_session_alloc (application_t * app)
-{
- local_session_t *ll;
- pool_get_zero (app->local_listen_sessions, ll);
- ll->session_index = ll - app->local_listen_sessions;
- ll->session_type = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE, 0);
- ll->app_index = app->app_index;
- ll->session_state = SESSION_STATE_LISTENING;
- return ll;
-}
-
-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));
-}
-
static u32
app_listener_id (app_listener_t * al)
{
app = application_get_if_valid (app_index);
if (!app)
return 0;
- return app_listener_get (app, app_listener_index);
+ return app_listener_get_if_valid (app, app_listener_index);
}
app_listener_t *
u32 table_index, fib_proto;
session_endpoint_t *sep;
session_handle_t handle;
- local_session_t *ll;
session_t *ls;
sep = (session_endpoint_t *) sep_ext;
handle = session_lookup_endpoint_listener (table_index, sep, 1);
if (handle != SESSION_INVALID_HANDLE)
{
- ll = application_get_local_listener_w_handle (handle);
- return app_listener_get_w_session ((session_t *) ll);
+ ls = listen_session_get_from_handle (handle);
+ return app_listener_get_w_session (ls);
}
}
app_listener_t ** listener)
{
app_listener_t *app_listener;
- local_session_t *ll = 0;
+ transport_connection_t *tc;
session_handle_t lh;
session_type_t st;
session_t *ls = 0;
if (application_has_local_scope (app)
&& session_endpoint_is_local ((session_endpoint_t *) sep))
{
+ session_type_t local_st;
u32 table_index;
- ll = application_local_listen_session_alloc (app);
- ll->port = sep->port;
- /* Store the original session type for the unbind */
- ll->listener_session_type = st;
+ local_st = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE,
+ sep->is_ip4);
+ ls = listen_session_alloc (0, local_st);
+ ls->app_index = app->app_index;
+ ls->app_wrk_index = sep->app_wrk_index;
+ lh = session_handle (ls);
+
+ if ((rv = session_listen (ls, sep)))
+ {
+ ls = session_get_from_handle (lh);
+ session_free (ls);
+ return rv;
+ }
+
+ ls = session_get_from_handle (lh);
+ app_listener = app_listener_get (app, al_index);
+ app_listener->local_index = ls->session_index;
+ ls->al_index = al_index;
+
table_index = application_local_session_table (app);
- lh = application_local_session_handle (ll);
session_lookup_add_session_endpoint (table_index,
(session_endpoint_t *) sep, lh);
- app_listener->local_index = ll->session_index;
- ll->al_index = app_listener->al_index;
}
if (application_has_global_scope (app))
* lookups, prior to establishing connection. Requests transport to
* build it's own specific listening connection.
*/
- ls = listen_session_new (0, st);
+ ls = listen_session_alloc (0, st);
ls->app_index = app->app_index;
ls->app_wrk_index = sep->app_wrk_index;
/* Listen pool can be reallocated if the transport is
* recursive (tls) */
- lh = session_handle (ls);
+ lh = listen_session_get_handle (ls);
if ((rv = session_listen (ls, sep)))
{
- ls = session_get_from_handle (lh);
+ ls = listen_session_get_from_handle (lh);
session_free (ls);
return rv;
}
- ls = session_get_from_handle (lh);
+ ls = listen_session_get_from_handle (lh);
app_listener = app_listener_get (app, al_index);
app_listener->session_index = ls->session_index;
ls->al_index = al_index;
+
+ /* Add to the global lookup table after transport was initialized.
+ * Lookup table needs to be populated only now because sessions
+ * with cut-through transport are are added to app local tables that
+ * are not related to network fibs, i.e., cannot be added as
+ * connections */
+ tc = session_get_transport (ls);
+ session_lookup_add_connection (tc, lh);
}
- if (!ll && !ls)
+ if (!ls)
{
app_listener_free (app, app_listener);
return -1;
app_listener_cleanup (app_listener_t * al)
{
application_t *app = application_get (al->app_index);
+ session_t *ls;
if (al->session_index != SESSION_INVALID_INDEX)
{
- session_t *ls = session_get (al->session_index, 0);
+ ls = session_get (al->session_index, 0);
session_stop_listen (ls);
- listen_session_del (ls);
+ listen_session_free (ls);
}
if (al->local_index != SESSION_INVALID_INDEX)
{
session_endpoint_t sep = SESSION_ENDPOINT_NULL;
- local_session_t *ll;
u32 table_index;
table_index = application_local_session_table (app);
- ll = application_get_local_listen_session (app, al->local_index);
- application_local_listener_session_endpoint (ll, &sep);
+ ls = listen_session_get (al->local_index);
+ ct_session_endpoint (ls, &sep);
session_lookup_del_session_endpoint (table_index, &sep);
- application_local_listen_session_free (app, ll);
+ session_stop_listen (ls);
+ listen_session_free (ls);
}
app_listener_free (app, al);
}
return listen_session_get (al->session_index);
}
+session_t *
+app_listener_get_local_session (app_listener_t * al)
+{
+ if (al->local_index == SESSION_INVALID_INDEX)
+ return 0;
+ return listen_session_get (al->local_index);
+}
+
static app_worker_map_t *
app_worker_map_alloc (application_t * app)
{
u8 is_valid;
if (st == SSVM_SEGMENT_MEMFD)
{
- is_valid = (session_manager_get_evt_q_segment () != 0);
+ is_valid = (session_main_get_evt_q_segment () != 0);
if (!is_valid)
clib_warning ("memfd seg: vpp's event qs IN binary api svm region");
return is_valid;
}
else if (st == SSVM_SEGMENT_SHM)
{
- is_valid = (session_manager_get_evt_q_segment () == 0);
+ is_valid = (session_main_get_evt_q_segment () == 0);
if (!is_valid)
clib_warning ("shm seg: vpp's event qs NOT IN binary api svm region");
return is_valid;
{
app_worker_map_t *wrk_map;
app_worker_t *app_wrk;
- u32 table_index;
- local_session_t *ll;
- session_endpoint_t sep;
/*
* The app event queue allocated in first segment is cleared with
/* *INDENT-ON* */
pool_free (app->worker_maps);
- /*
- * Free local listeners. Global table unbinds stop local listeners
- * as well, but if we have only local binds, these won't be cleaned up.
- * Don't bother with local accepted sessions, we clean them when
- * cleaning up the worker.
- */
- table_index = application_local_session_table (app);
- /* *INDENT-OFF* */
- pool_foreach (ll, app->local_listen_sessions, ({
- application_local_listener_session_endpoint (ll, &sep);
- session_lookup_del_session_endpoint (table_index, &sep);
- }));
- /* *INDENT-ON* */
- pool_free (app->local_listen_sessions);
-
/*
* Cleanup remaining state
*/
app_wrk->event_queue = segment_manager_event_queue (sm);
app_wrk->app_is_builtin = application_is_builtin (app);
- /*
- * Segment manager for local sessions
- */
- sm = segment_manager_new ();
- sm->app_wrk_index = app_wrk->wrk_index;
- app_wrk->local_segment_manager = segment_manager_index (sm);
- app_wrk->local_connects = hash_create (0, sizeof (u64));
-
*wrk = app_wrk;
return 0;
int
vnet_connect (vnet_connect_args_t * a)
{
- app_worker_t *server_wrk, *client_wrk;
+ app_worker_t *client_wrk;
application_t *client;
- local_session_t *ll;
- app_listener_t *al;
- u32 table_index;
- session_t *ls;
- u8 fib_proto;
- u64 lh;
if (session_endpoint_is_zero (&a->sep))
return VNET_API_ERROR_INVALID_VALUE;
*/
if (application_has_local_scope (client))
{
- table_index = application_local_session_table (client);
- lh = session_lookup_local_endpoint (table_index, &a->sep);
- if (lh == SESSION_DROP_HANDLE)
- return VNET_API_ERROR_APP_CONNECT_FILTERED;
-
- if (lh == SESSION_INVALID_HANDLE)
- goto global_scope;
-
- ll = application_get_local_listener_w_handle (lh);
- al = app_listener_get_w_session ((session_t *) ll);
-
- /*
- * Break loop if rule in local table points to connecting app. This
- * can happen if client is a generic proxy. Route connect through
- * global table instead.
- */
- if (al->app_index == a->app_index)
- goto global_scope;
-
- server_wrk = app_listener_select_worker (al);
- return app_worker_local_session_connect (client_wrk, server_wrk, ll,
- a->api_context);
- }
-
- /*
- * If nothing found, check the global scope for locally attached
- * destinations. Make sure first that we're allowed to.
- */
-
-global_scope:
- if (session_endpoint_is_local (&a->sep))
- return VNET_API_ERROR_SESSION_CONNECT;
+ int rv;
- if (!application_has_global_scope (client))
- return VNET_API_ERROR_APP_CONNECT_SCOPE;
-
- fib_proto = session_endpoint_fib_proto (&a->sep);
- table_index = application_session_table (client, fib_proto);
- ls = session_lookup_listener (table_index, &a->sep);
- if (ls)
- {
- al = app_listener_get_w_session (ls);
- server_wrk = app_listener_select_worker (al);
- ll = (local_session_t *) ls;
- return app_worker_local_session_connect (client_wrk, server_wrk, ll,
- a->api_context);
+ a->sep_ext.original_tp = a->sep_ext.transport_proto;
+ a->sep_ext.transport_proto = TRANSPORT_PROTO_NONE;
+ rv = app_worker_connect_session (client_wrk, &a->sep, a->api_context);
+ if (rv <= 0)
+ return rv;
}
-
/*
* Not connecting to a local server, propagate to transport
*/
if (!(app = application_get_if_valid (a->app_index)))
return VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
- al = app_listener_get_w_handle (a->handle);
+ if (!(al = app_listener_get_w_handle (a->handle)))
+ return -1;
+
if (al->app_index != app->app_index)
{
clib_warning ("app doesn't own handle %llu!", a->handle);
int
vnet_disconnect_session (vnet_disconnect_args_t * a)
{
- if (session_handle_is_local (a->handle))
- {
- app_worker_t *client_wrk, *server_wrk;
- local_session_t *ls;
- u32 wrk_index = ~0;
-
- /* Disconnect reply came to worker 1 not main thread */
- app_interface_check_thread_and_barrier (vnet_disconnect_session, a);
-
- if (!(ls = app_worker_get_local_session_from_handle (a->handle)))
- 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 == a->app_index)
- wrk_index = server_wrk->wrk_index;
- else if (client_wrk && client_wrk->app_index == a->app_index)
- wrk_index = client_wrk->wrk_index;
-
- if (wrk_index == ~0)
- {
- clib_warning ("app %u does not own session 0x%lx", a->app_index,
- application_local_session_handle (ls));
- return VNET_API_ERROR_INVALID_VALUE;
- }
-
- return app_worker_local_session_disconnect (wrk_index, ls);
- }
- else
- {
- app_worker_t *app_wrk;
- session_t *s;
+ app_worker_t *app_wrk;
+ session_t *s;
- s = session_get_from_handle_if_valid (a->handle);
- if (!s)
- return VNET_API_ERROR_INVALID_VALUE;
- app_wrk = app_worker_get (s->app_wrk_index);
- if (app_wrk->app_index != a->app_index)
- return VNET_API_ERROR_INVALID_VALUE;
+ s = session_get_from_handle_if_valid (a->handle);
+ if (!s)
+ return VNET_API_ERROR_INVALID_VALUE;
+ app_wrk = app_worker_get (s->app_wrk_index);
+ if (app_wrk->app_index != a->app_index)
+ return VNET_API_ERROR_INVALID_VALUE;
- /* We're peeking into another's thread pool. Make sure */
- ASSERT (s->session_index == session_index_from_handle (a->handle));
+ /* We're peeking into another's thread pool. Make sure */
+ ASSERT (s->session_index == session_index_from_handle (a->handle));
- session_close (s);
- }
+ session_close (s);
return 0;
}
return app->flags & APP_OPTIONS_FLAGS_USE_GLOBAL_SCOPE;
}
-u8
-application_use_mq_for_ctrl (application_t * app)
-{
- return app->flags & APP_OPTIONS_FLAGS_USE_MQ_FOR_CTRL_MSGS;
-}
-
static clib_error_t *
application_start_stop_proxy_fib_proto (application_t * app, u8 fib_proto,
u8 transport_proto, u8 is_start)
/* *INDENT-ON* */
}
-static void
-application_format_local_sessions (application_t * app, int verbose)
-{
- vlib_main_t *vm = vlib_get_main ();
- app_worker_map_t *wrk_map;
- app_worker_t *app_wrk;
- transport_proto_t tp;
- local_session_t *ls;
- u8 *conn = 0;
-
- if (!app)
- {
- app_worker_format_local_sessions (0, verbose);
- return;
- }
-
- /*
- * Format local listeners
- */
-
- /* *INDENT-OFF* */
- pool_foreach (ls, app->local_listen_sessions, ({
- tp = session_type_transport_proto (ls->listener_session_type);
- conn = format (0, "[L][%U] *:%u", format_transport_proto_short, tp,
- ls->port);
- vlib_cli_output (vm, "%-40v%-15u%-20s", conn, ls->app_wrk_index, "*");
- vec_reset_length (conn);
- }));
- /* *INDENT-ON* */
-
- /*
- * Format local accepted/connected sessions
- */
- /* *INDENT-OFF* */
- pool_foreach (wrk_map, app->worker_maps, ({
- app_wrk = app_worker_get (wrk_map->wrk_index);
- app_worker_format_local_sessions (app_wrk, verbose);
- }));
- /* *INDENT-ON* */
-}
-
-static void
-application_format_local_connects (application_t * app, int verbose)
-{
- app_worker_map_t *wrk_map;
- app_worker_t *app_wrk;
-
- if (!app)
- {
- app_worker_format_local_connects (0, verbose);
- return;
- }
-
- /* *INDENT-OFF* */
- pool_foreach (wrk_map, app->worker_maps, ({
- app_wrk = app_worker_get (wrk_map->wrk_index);
- app_worker_format_local_connects (app_wrk, verbose);
- }));
- /* *INDENT-ON* */
-}
-
u8 *
format_application (u8 * s, va_list * args)
{
}
void
-application_format_all_listeners (vlib_main_t * vm, int do_local, int verbose)
+application_format_all_listeners (vlib_main_t * vm, int verbose)
{
application_t *app;
return;
}
- if (do_local)
- {
- application_format_local_sessions (0, verbose);
- /* *INDENT-OFF* */
- pool_foreach (app, app_main.app_pool, ({
- application_format_local_sessions (app, verbose);
- }));
- /* *INDENT-ON* */
- }
- else
- {
- application_format_listeners (0, verbose);
+ application_format_listeners (0, verbose);
- /* *INDENT-OFF* */
- pool_foreach (app, app_main.app_pool, ({
- application_format_listeners (app, verbose);
- }));
- /* *INDENT-ON* */
- }
+ /* *INDENT-OFF* */
+ pool_foreach (app, app_main.app_pool, ({
+ application_format_listeners (app, verbose);
+ }));
+ /* *INDENT-ON* */
}
void
-application_format_all_clients (vlib_main_t * vm, int do_local, int verbose)
+application_format_all_clients (vlib_main_t * vm, int verbose)
{
application_t *app;
return;
}
- if (do_local)
- {
- application_format_local_connects (0, verbose);
-
- /* *INDENT-OFF* */
- pool_foreach (app, app_main.app_pool, ({
- application_format_local_connects (app, verbose);
- }));
- /* *INDENT-ON* */
- }
- else
- {
- application_format_connects (0, verbose);
+ application_format_connects (0, verbose);
- /* *INDENT-OFF* */
- pool_foreach (app, app_main.app_pool, ({
- application_format_connects (app, verbose);
- }));
- /* *INDENT-ON* */
- }
+ /* *INDENT-OFF* */
+ pool_foreach (app, app_main.app_pool, ({
+ application_format_connects (app, verbose);
+ }));
+ /* *INDENT-ON* */
}
static clib_error_t *
show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
vlib_cli_command_t * cmd)
{
- int do_server = 0, do_client = 0, do_local = 0;
+ int do_server = 0, do_client = 0;
application_t *app;
u32 app_index = ~0;
int verbose = 0;
do_server = 1;
else if (unformat (input, "client"))
do_client = 1;
- else if (unformat (input, "local"))
- do_local = 1;
else if (unformat (input, "%u", &app_index))
;
else if (unformat (input, "verbose"))
if (do_server)
{
- application_format_all_listeners (vm, do_local, verbose);
+ application_format_all_listeners (vm, verbose);
return 0;
}
if (do_client)
{
- application_format_all_clients (vm, do_local, verbose);
+ application_format_all_clients (vm, verbose);
return 0;
}
Code Review / vpp.git / blobdiff