}
fib_proto = session_endpoint_fib_proto (sep);
- table_index = application_session_table (app, fib_proto);
+ table_index = session_lookup_get_index_for_fib (fib_proto, sep->fib_index);
handle = session_lookup_endpoint_listener (table_index, sep, 1);
if (handle != SESSION_INVALID_HANDLE)
{
{
app_listener_t *app_listener;
transport_connection_t *tc;
+ u32 al_index, table_index;
session_handle_t lh;
session_type_t st;
session_t *ls = 0;
- u32 al_index;
int rv;
app_listener = app_listener_alloc (app);
&& session_endpoint_is_local ((session_endpoint_t *) sep))
{
session_type_t local_st;
- u32 table_index;
local_st = session_type_from_proto_and_ip (TRANSPORT_PROTO_NONE,
sep->is_ip4);
* connections */
tc = session_get_transport (ls);
if (!(tc->flags & TRANSPORT_CONNECTION_F_NO_LOOKUP))
- session_lookup_add_connection (tc, lh);
+ {
+ fib_protocol_t fib_proto;
+ fib_proto = session_endpoint_fib_proto ((session_endpoint_t *) sep);
+ table_index = session_lookup_get_index_for_fib (fib_proto,
+ sep->fib_index);
+ ASSERT (table_index != SESSION_TABLE_INVALID_INDEX);
+ session_lookup_add_session_endpoint (table_index,
+ (session_endpoint_t *) sep,
+ lh);
+ }
}
if (!ls)
{
ssvm_segment_type_t seg_type = SSVM_SEGMENT_MEMFD;
segment_manager_props_t *props;
- vl_api_registration_t *reg;
application_t *app;
u64 *options;
/*
* Make sure we support the requested configuration
*/
- if (!(options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_IS_BUILTIN))
- {
- reg = vl_api_client_index_to_registration (a->api_client_index);
- if (!reg)
- return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
- if (vl_api_registration_file_index (reg) == VL_API_INVALID_FI)
- seg_type = SSVM_SEGMENT_SHM;
- }
- else
- {
- seg_type = SSVM_SEGMENT_PRIVATE;
- }
+ if (options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_IS_BUILTIN)
+ seg_type = SSVM_SEGMENT_PRIVATE;
if ((options[APP_OPTIONS_FLAGS] & APP_OPTIONS_FLAGS_EVT_MQ_USE_EVENTFD)
&& seg_type != SSVM_SEGMENT_MEMFD)
if (!application_verify_cfg (seg_type))
return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
+ if (options[APP_OPTIONS_PREALLOC_FIFO_PAIRS]
+ && options[APP_OPTIONS_PREALLOC_FIFO_HDRS])
+ return VNET_API_ERROR_APP_UNSUPPORTED_CFG;
+
/* Check that the obvious things are properly set up */
application_verify_cb_fns (a->session_cb_vft);
segment_manager_props_init (props);
props->segment_size = options[APP_OPTIONS_SEGMENT_SIZE];
props->prealloc_fifos = options[APP_OPTIONS_PREALLOC_FIFO_PAIRS];
+ props->prealloc_fifo_hdrs = options[APP_OPTIONS_PREALLOC_FIFO_HDRS];
if (options[APP_OPTIONS_ADD_SEGMENT_SIZE])
{
props->add_segment_size = options[APP_OPTIONS_ADD_SEGMENT_SIZE];
props->use_mq_eventfd = 1;
if (options[APP_OPTIONS_TLS_ENGINE])
app->tls_engine = options[APP_OPTIONS_TLS_ENGINE];
+ if (options[APP_OPTIONS_MAX_FIFO_SIZE])
+ props->max_fifo_size = options[APP_OPTIONS_MAX_FIFO_SIZE];
+ if (options[APP_OPTIONS_HIGH_WATERMARK])
+ props->high_watermark = options[APP_OPTIONS_HIGH_WATERMARK];
+ if (options[APP_OPTIONS_LOW_WATERMARK])
+ props->low_watermark = options[APP_OPTIONS_LOW_WATERMARK];
+ if (options[APP_OPTIONS_PCT_FIRST_ALLOC])
+ props->pct_first_alloc = options[APP_OPTIONS_PCT_FIRST_ALLOC];
props->segment_type = seg_type;
/* Add app to lookup by api_client_index table */
app->app_index, api_client_index);
/* *INDENT-OFF* */
- pool_foreach (wrk_map, app->worker_maps, ({
+ pool_foreach (wrk_map, app->worker_maps) {
app_wrk = app_worker_get (wrk_map->wrk_index);
if (app_wrk->api_client_index == api_client_index)
vec_add1 (wrks, app_wrk->wrk_index);
- }));
+ }
/* *INDENT-ON* */
if (!vec_len (wrks))
sm = segment_manager_alloc ();
sm->app_wrk_index = app_wrk->wrk_index;
- if ((rv = segment_manager_init (sm, app->sm_properties.segment_size,
- app->sm_properties.prealloc_fifos)))
+ if ((rv = segment_manager_init_first (sm)))
{
app_worker_free (app_wrk);
return rv;
if (app)
return VNET_API_ERROR_APP_ALREADY_ATTACHED;
- if (a->api_client_index != APP_INVALID_INDEX)
+ /* Socket api sets the name and validates namespace prior to attach */
+ if (!a->use_sock_api)
{
- app_name = app_name_from_api_index (a->api_client_index);
- a->name = app_name;
- }
+ if (a->api_client_index != APP_INVALID_INDEX)
+ {
+ app_name = app_name_from_api_index (a->api_client_index);
+ a->name = app_name;
+ }
- secret = a->options[APP_OPTIONS_NAMESPACE_SECRET];
- if ((rv = app_validate_namespace (a->namespace_id, secret, &app_ns_index)))
- return rv;
- a->options[APP_OPTIONS_NAMESPACE] = app_ns_index;
+ secret = a->options[APP_OPTIONS_NAMESPACE_SECRET];
+ if ((rv = app_validate_namespace (a->namespace_id, secret,
+ &app_ns_index)))
+ return rv;
+ a->options[APP_OPTIONS_NAMESPACE] = app_ns_index;
+ }
if ((rv = application_alloc_and_init ((app_init_args_t *) a)))
return rv;
fs = segment_manager_get_segment_w_lock (sm, 0);
if (application_is_proxy (app))
- application_setup_proxy (app);
+ {
+ application_setup_proxy (app);
+ /* The segment manager pool is reallocated because a new listener
+ * is added. Re-grab segment manager to avoid dangling reference */
+ sm = segment_manager_get (app_wrk->first_segment_manager);
+ }
ASSERT (vec_len (fs->ssvm.name) <= 128);
a->segment = &fs->ssvm;
app = application_get_if_valid (a->app_index);
if (!app)
- return VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
+ return SESSION_E_NOAPP;
app_wrk = application_get_worker (app, a->wrk_map_index);
if (!app_wrk)
- return VNET_API_ERROR_INVALID_VALUE;
+ return SESSION_E_INVALID_APPWRK;
a->sep_ext.app_wrk_index = app_wrk->wrk_index;
session_endpoint_update_for_app (&a->sep_ext, app, 0 /* is_connect */ );
if (!session_endpoint_in_ns (&a->sep))
- return VNET_API_ERROR_INVALID_VALUE_2;
+ return SESSION_E_INVALID_NS;
/*
* Check if we already have an app listener
if (app_listener)
{
if (app_listener->app_index != app->app_index)
- return VNET_API_ERROR_ADDRESS_IN_USE;
- if (app_worker_start_listen (app_wrk, app_listener))
- return -1;
+ return SESSION_E_ALREADY_LISTENING;
+ if ((rv = app_worker_start_listen (app_wrk, app_listener)))
+ return rv;
a->handle = app_listener_handle (app_listener);
return 0;
}
ASSERT (vlib_thread_is_main_w_barrier ());
if (session_endpoint_is_zero (&a->sep))
- return VNET_API_ERROR_INVALID_VALUE;
+ return SESSION_E_INVALID_RMT_IP;
client = application_get (a->app_index);
session_endpoint_update_for_app (&a->sep_ext, client, 1 /* is_connect */ );
rv = app_worker_connect_session (client_wrk, &a->sep, a->api_context);
if (rv <= 0)
return rv;
+ a->sep_ext.transport_proto = a->sep_ext.original_tp;
}
/*
* Not connecting to a local server, propagate to transport
*/
- if (app_worker_connect_session (client_wrk, &a->sep, a->api_context))
- return VNET_API_ERROR_SESSION_CONNECT;
- return 0;
+ return app_worker_connect_session (client_wrk, &a->sep, a->api_context);
}
int
ASSERT (vlib_thread_is_main_w_barrier ());
if (!(app = application_get_if_valid (a->app_index)))
- return VNET_API_ERROR_APPLICATION_NOT_ATTACHED;
+ return SESSION_E_NOAPP;
if (!(al = app_listener_get_w_handle (a->handle)))
- return -1;
+ return SESSION_E_NOLISTEN;
if (al->app_index != app->app_index)
{
clib_warning ("app doesn't own handle %llu!", a->handle);
- return -1;
+ return SESSION_E_OWNER;
}
app_wrk = application_get_worker (app, a->wrk_map_index);
if (!app_wrk)
{
clib_warning ("no app %u worker %u", app->app_index, a->wrk_map_index);
- return -1;
+ return SESSION_E_INVALID_APPWRK;
}
return app_worker_stop_listen (app_wrk, al);
s = session_get_from_handle_if_valid (a->handle);
if (!s)
- return VNET_API_ERROR_INVALID_VALUE;
+ return SESSION_E_NOSESSION;
+
app_wrk = app_worker_get (s->app_wrk_index);
if (app_wrk->app_index != a->app_index)
- return VNET_API_ERROR_INVALID_VALUE;
+ return SESSION_E_OWNER;
/* We're peeking into another's thread pool. Make sure */
ASSERT (s->session_index == session_index_from_handle (a->handle));
app_worker_t *old_wrk = app_worker_get (s->app_wrk_index);
app_listener_t *app_listener;
application_t *app;
+ int rv;
if (!old_wrk)
- return -1;
+ return SESSION_E_INVALID_APPWRK;
hash_unset (old_wrk->listeners_table, listen_session_get_handle (s));
if (session_transport_service_type (s) == TRANSPORT_SERVICE_CL
app = application_get (old_wrk->app_index);
if (!app)
- return -1;
+ return SESSION_E_NOAPP;
app_listener = app_listener_get (app, s->al_index);
app_listener->workers = clib_bitmap_set (app_listener->workers,
old_wrk->wrk_map_index, 0);
- if (app_worker_start_listen (app_wrk, app_listener))
- return -1;
+ if ((rv = app_worker_start_listen (app_wrk, app_listener)))
+ return rv;
s->app_wrk_index = app_wrk->wrk_index;
}
/* *INDENT-OFF* */
- pool_foreach (wrk_map, app->worker_maps, ({
+ pool_foreach (wrk_map, app->worker_maps) {
app_wrk = app_worker_get (wrk_map->wrk_index);
if (hash_elts (app_wrk->listeners_table) == 0)
continue;
vlib_cli_output (vm, "%U", format_app_worker_listener, app_wrk,
handle, sm_index, verbose);
}));
- }));
+ }
/* *INDENT-ON* */
}
}
/* *INDENT-OFF* */
- pool_foreach (wrk_map, app->worker_maps, ({
+ pool_foreach (wrk_map, app->worker_maps) {
app_wrk = app_worker_get (wrk_map->wrk_index);
app_worker_format_connects (app_wrk, verbose);
- }));
+ }
/* *INDENT-ON* */
}
if (ckpair->cert_key_index == 0)
s = format (s, "DEFAULT (cert:%d, key:%d)", cert_len, key_len);
else
- s =
- format (s, "%d (cert:%d, key:%d)", ckpair->cert_key_index, cert_len,
- key_len);
+ s = format (s, "%d (cert:%d, key:%d)", ckpair->cert_key_index,
+ cert_len, key_len);
+ return s;
+}
+
+u8 *
+format_crypto_engine (u8 * s, va_list * args)
+{
+ u32 engine = va_arg (*args, u32);
+ switch (engine)
+ {
+ case CRYPTO_ENGINE_NONE:
+ return format (s, "none");
+ case CRYPTO_ENGINE_MBEDTLS:
+ return format (s, "mbedtls");
+ case CRYPTO_ENGINE_OPENSSL:
+ return format (s, "openssl");
+ case CRYPTO_ENGINE_PICOTLS:
+ return format (s, "picotls");
+ case CRYPTO_ENGINE_VPP:
+ return format (s, "vpp");
+ default:
+ return format (s, "unknown engine");
+ }
+ return s;
+}
+
+uword
+unformat_crypto_engine (unformat_input_t * input, va_list * args)
+{
+ u8 *a = va_arg (*args, u8 *);
+ if (unformat (input, "mbedtls"))
+ *a = CRYPTO_ENGINE_MBEDTLS;
+ else if (unformat (input, "openssl"))
+ *a = CRYPTO_ENGINE_OPENSSL;
+ else if (unformat (input, "picotls"))
+ *a = CRYPTO_ENGINE_PICOTLS;
+ else if (unformat (input, "vpp"))
+ *a = CRYPTO_ENGINE_VPP;
+ else
+ return 0;
+ return 1;
+}
+
+u8 *
+format_crypto_context (u8 * s, va_list * args)
+{
+ crypto_context_t *crctx = va_arg (*args, crypto_context_t *);
+ s = format (s, "[0x%x][sub%d,ckpair%x]", crctx->ctx_index,
+ crctx->n_subscribers, crctx->ckpair_index);
+ s = format (s, "[%U]", format_crypto_engine, crctx->crypto_engine);
return s;
}
props = application_segment_manager_properties (app);
if (!verbose)
{
- s = format (s, "%-10u%-20v%-40s", app->app_index, app_name,
+ s = format (s, "%-10u%-20v%-40v", app->app_index, app_name,
app_ns_name);
return s;
}
format_memory_size, props->tx_fifo_size);
/* *INDENT-OFF* */
- pool_foreach (wrk_map, app->worker_maps, ({
+ pool_foreach (wrk_map, app->worker_maps) {
app_wrk = app_worker_get (wrk_map->wrk_index);
s = format (s, "%U", format_app_worker, app_wrk);
- }));
+ }
/* *INDENT-ON* */
return s;
application_format_listeners (0, verbose);
/* *INDENT-OFF* */
- pool_foreach (app, app_main.app_pool, ({
+ pool_foreach (app, app_main.app_pool) {
application_format_listeners (app, verbose);
- }));
+ }
/* *INDENT-ON* */
}
application_format_connects (0, verbose);
/* *INDENT-OFF* */
- pool_foreach (app, app_main.app_pool, ({
+ pool_foreach (app, app_main.app_pool) {
application_format_connects (app, verbose);
- }));
+ }
/* *INDENT-ON* */
}
session_cli_return_if_not_enabled ();
/* *INDENT-OFF* */
- pool_foreach (ckpair, app_main.cert_key_pair_store, ({
+ pool_foreach (ckpair, app_main.cert_key_pair_store) {
vlib_cli_output (vm, "%U", format_cert_key_pair, ckpair);
- }));
+ }
+ /* *INDENT-ON* */
+ return 0;
+}
+
+static inline void
+appliction_format_app_mq (vlib_main_t * vm, application_t * app)
+{
+ app_worker_map_t *map;
+ app_worker_t *wrk;
+ /* *INDENT-OFF* */
+ pool_foreach (map, app->worker_maps) {
+ wrk = app_worker_get (map->wrk_index);
+ vlib_cli_output (vm, "[A%d][%d]%U", app->app_index,
+ map->wrk_index, format_svm_msg_q,
+ wrk->event_queue);
+ }
+ /* *INDENT-ON* */
+}
+
+static clib_error_t *
+appliction_format_all_app_mq (vlib_main_t * vm)
+{
+ application_t *app;
+ int i, n_threads;
+
+ n_threads = vec_len (vlib_mains);
+
+ for (i = 0; i < n_threads; i++)
+ {
+ vlib_cli_output (vm, "[Ctrl%d]%U", i, format_svm_msg_q,
+ session_main_get_vpp_event_queue (i));
+ }
+
+ /* *INDENT-OFF* */
+ pool_foreach (app, app_main.app_pool) {
+ appliction_format_app_mq (vm, app);
+ }
/* *INDENT-ON* */
return 0;
}
show_app_command_fn (vlib_main_t * vm, unformat_input_t * input,
vlib_cli_command_t * cmd)
{
- int do_server = 0, do_client = 0;
+ int do_server = 0, do_client = 0, do_mq = 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, "mq"))
+ do_mq = 1;
else if (unformat (input, "%u", &app_index))
;
else if (unformat (input, "verbose"))
format_unformat_error, input);
}
+ if (do_mq && app_index != ~0)
+ {
+ app = application_get_if_valid (app_index);
+ if (!app)
+ return clib_error_return (0, "No app with index %u", app_index);
+
+ appliction_format_app_mq (vm, app);
+ return 0;
+ }
+
+ if (do_mq)
+ {
+ appliction_format_all_app_mq (vm);
+ return 0;
+ }
+
if (do_server)
{
application_format_all_listeners (vm, verbose);
{
vlib_cli_output (vm, "%U", format_application, 0, 0);
/* *INDENT-OFF* */
- pool_foreach (app, app_main.app_pool, ({
+ pool_foreach (app, app_main.app_pool) {
vlib_cli_output (vm, "%U", format_application, app, 0);
- }));
+ }
/* *INDENT-ON* */
}
return 0;
}
-/*
- * Certificate store
- *
- */
+/* Certificate store */
static app_cert_key_pair_t *
app_cert_key_pair_alloc ()
app_cert_key_pair_t *ckpair;
if (!(ckpair = app_cert_key_pair_get_if_valid (index)))
return -1;
- vec_add1 (ckpair->app_interests, app_index);
+ if (vec_search (ckpair->app_interests, app_index) != ~0)
+ vec_add1 (ckpair->app_interests, app_index);
return 0;
}
}
clib_error_t *
-cert_key_pair_store_init (vlib_main_t * vm)
+application_init (vlib_main_t * vm)
{
/* Add a certificate with index 0 to support legacy apis */
(void) app_cert_key_pair_alloc ();
+ app_main.last_crypto_engine = CRYPTO_ENGINE_LAST;
+ app_main.app_by_name = hash_create_vec (0, sizeof (u8), sizeof (uword));
return 0;
}
/* *INDENT-OFF* */
-VLIB_INIT_FUNCTION (cert_key_pair_store_init);
+VLIB_INIT_FUNCTION (application_init);
VLIB_CLI_COMMAND (show_app_command, static) =
{
.path = "show app",
- .short_help = "show app [server|client] [verbose]",
+ .short_help = "show app [app_id] [server|client] [mq] [verbose]",
.function = show_app_command_fn,
};
};
/* *INDENT-ON* */
+crypto_engine_type_t
+app_crypto_engine_type_add (void)
+{
+ return (++app_main.last_crypto_engine);
+}
+
+u8
+app_crypto_engine_n_types (void)
+{
+ return (app_main.last_crypto_engine + 1);
+}
+
/*
* fd.io coding-style-patch-verification: ON
*