evt->event_type = evt_type;
switch (evt_type)
{
- case FIFO_EVENT_RPC:
+ case SESSION_CTRL_EVT_RPC:
evt->rpc_args.fp = data;
evt->rpc_args.arg = args;
break;
- case FIFO_EVENT_APP_TX:
+ case SESSION_IO_EVT_TX:
case SESSION_IO_EVT_TX_FLUSH:
- case FIFO_EVENT_BUILTIN_RX:
+ case SESSION_IO_EVT_BUILTIN_RX:
evt->fifo = data;
break;
- case FIFO_EVENT_BUILTIN_TX:
- case FIFO_EVENT_DISCONNECT:
+ case SESSION_IO_EVT_BUILTIN_TX:
+ case SESSION_CTRL_EVT_CLOSE:
evt->session_handle = session_handle ((session_t *) data);
break;
default:
session_send_ctrl_evt_to_thread (session_t * s, session_evt_type_t evt_type)
{
/* only event supported for now is disconnect */
- ASSERT (evt_type == FIFO_EVENT_DISCONNECT);
+ ASSERT (evt_type == SESSION_CTRL_EVT_CLOSE);
return session_send_evt_to_thread (s, 0, s->thread_index,
- FIFO_EVENT_DISCONNECT);
+ SESSION_CTRL_EVT_CLOSE);
}
void
session_send_rpc_evt_to_thread (u32 thread_index, void *fp, void *rpc_args)
{
if (thread_index != vlib_get_thread_index ())
- session_send_evt_to_thread (fp, rpc_args, thread_index, FIFO_EVENT_RPC);
+ session_send_evt_to_thread (fp, rpc_args, thread_index,
+ SESSION_CTRL_EVT_RPC);
else
{
void (*fnp) (void *) = fp;
session_manager_worker_t *wrk;
session_event_t *evt;
+ if (!session_has_transport (s))
+ {
+ /* Polling may not be enabled on main thread so close now */
+ session_transport_close (s);
+ return;
+ }
+
/* If we are in the handler thread, or being called with the worker barrier
* held, just append a new event to pending disconnects vector. */
if (vlib_thread_is_main_w_barrier () || thread_index == s->thread_index)
vec_add2 (wrk->pending_disconnects, evt, 1);
clib_memset (evt, 0, sizeof (*evt));
evt->session_handle = session_handle (s);
- evt->event_type = FIFO_EVENT_DISCONNECT;
+ evt->event_type = SESSION_CTRL_EVT_CLOSE;
}
else
- session_send_ctrl_evt_to_thread (s, FIFO_EVENT_DISCONNECT);
+ session_send_ctrl_evt_to_thread (s, SESSION_CTRL_EVT_CLOSE);
}
session_t *
session_free_w_fifos (s);
}
-int
-session_alloc_fifos (segment_manager_t * sm, session_t * s)
-{
- svm_fifo_t *server_rx_fifo = 0, *server_tx_fifo = 0;
- u32 fifo_segment_index;
- int rv;
-
- if ((rv = segment_manager_alloc_session_fifos (sm, &server_rx_fifo,
- &server_tx_fifo,
- &fifo_segment_index)))
- return rv;
- /* Initialize backpointers */
- server_rx_fifo->master_session_index = s->session_index;
- server_rx_fifo->master_thread_index = s->thread_index;
-
- server_tx_fifo->master_session_index = s->session_index;
- server_tx_fifo->master_thread_index = s->thread_index;
-
- s->rx_fifo = server_rx_fifo;
- s->tx_fifo = server_tx_fifo;
- s->svm_segment_index = fifo_segment_index;
- return 0;
-}
-
static session_t *
session_alloc_for_connection (transport_connection_t * tc)
{
return s;
}
-static int
-session_alloc_and_init (segment_manager_t * sm, transport_connection_t * tc,
- u8 alloc_fifos, session_t ** ret_s)
-{
- session_t *s;
- int rv;
-
- s = session_alloc_for_connection (tc);
- if (alloc_fifos && (rv = session_alloc_fifos (sm, s)))
- {
- session_free (s);
- *ret_s = 0;
- return rv;
- }
-
- /* Add to the main lookup table */
- session_lookup_add_connection (tc, session_handle (s));
-
- *ret_s = s;
- return 0;
-}
-
/**
* Discards bytes from buffer chain
*
}
u32
-stream_session_dequeue_drop (transport_connection_t * tc, u32 max_bytes)
+session_dequeue_drop (transport_connection_t * tc, u32 max_bytes)
{
session_t *s = session_get (tc->s_index, tc->thread_index);
return svm_fifo_dequeue_drop (s->tx_fifo, max_bytes);
/* *INDENT-OFF* */
SESSION_EVT_DBG(SESSION_EVT_ENQ, s, ({
- ed->data[0] = FIFO_EVENT_APP_RX;
+ ed->data[0] = SESSION_IO_EVT_RX;
ed->data[1] = svm_fifo_max_dequeue (s->rx_fifo);
}));
/* *INDENT-ON* */
if (PREDICT_FALSE (app_worker_lock_and_send_event (app_wrk, s,
- FIFO_EVENT_APP_RX)))
+ SESSION_IO_EVT_RX)))
return -1;
if (PREDICT_FALSE (svm_fifo_n_subscribers (s->rx_fifo)))
return session_notify_subscribers (app_wrk->app_index, s,
- s->rx_fifo, FIFO_EVENT_APP_RX);
+ s->rx_fifo, SESSION_IO_EVT_RX);
return 0;
}
return -1;
if (PREDICT_FALSE (app_worker_lock_and_send_event (app_wrk, s,
- FIFO_EVENT_APP_TX)))
+ SESSION_IO_EVT_TX)))
return -1;
if (PREDICT_FALSE (s->tx_fifo->n_subscribers))
return session_notify_subscribers (app_wrk->app_index, s,
- s->tx_fifo, FIFO_EVENT_APP_TX);
+ s->tx_fifo, SESSION_IO_EVT_TX);
svm_fifo_clear_tx_ntf (s->tx_fifo);
session_stream_connect_notify (transport_connection_t * tc, u8 is_fail)
{
u32 opaque = 0, new_ti, new_si;
- session_t *new_s = 0;
- segment_manager_t *sm;
app_worker_t *app_wrk;
- application_t *app;
- u8 alloc_fifos;
- int error = 0;
- u64 handle;
+ session_t *s = 0;
+ u64 ho_handle;
/*
* Find connection handle and cleanup half-open table
*/
- handle = session_lookup_half_open_handle (tc);
- if (handle == HALF_OPEN_LOOKUP_INVALID_VALUE)
+ ho_handle = session_lookup_half_open_handle (tc);
+ if (ho_handle == HALF_OPEN_LOOKUP_INVALID_VALUE)
{
SESSION_DBG ("half-open was removed!");
return -1;
/* Get the app's index from the handle we stored when opening connection
* and the opaque (api_context for external apps) from transport session
* index */
- app_wrk = app_worker_get_if_valid (handle >> 32);
+ app_wrk = app_worker_get_if_valid (ho_handle >> 32);
if (!app_wrk)
return -1;
+
opaque = tc->s_index;
- app = application_get (app_wrk->app_index);
- /*
- * Allocate new session with fifos (svm segments are allocated if needed)
- */
- if (!is_fail)
- {
- sm = app_worker_get_connect_segment_manager (app_wrk);
- alloc_fifos = !application_is_builtin_proxy (app);
- if (session_alloc_and_init (sm, tc, alloc_fifos, &new_s))
- {
- is_fail = 1;
- error = -1;
- }
- else
- {
- new_s->session_state = SESSION_STATE_CONNECTING;
- new_s->app_wrk_index = app_wrk->wrk_index;
- new_si = new_s->session_index;
- new_ti = new_s->thread_index;
- }
- }
+ if (is_fail)
+ return app_worker_connect_notify (app_wrk, s, opaque);
- /*
- * Notify client application
- */
- if (app->cb_fns.session_connected_callback (app_wrk->wrk_index, opaque,
- new_s, is_fail))
+ s = session_alloc_for_connection (tc);
+ s->session_state = SESSION_STATE_CONNECTING;
+ s->app_wrk_index = app_wrk->wrk_index;
+ new_si = s->session_index;
+ new_ti = s->thread_index;
+
+ if (app_worker_init_connected (app_wrk, s))
{
- SESSION_DBG ("failed to notify app");
- if (!is_fail)
- {
- new_s = session_get (new_si, new_ti);
- session_transport_close (new_s);
- }
+ session_free (s);
+ app_worker_connect_notify (app_wrk, 0, opaque);
+ return -1;
}
- else
+
+ if (app_worker_connect_notify (app_wrk, s, opaque))
{
- if (!is_fail)
- {
- new_s = session_get (new_si, new_ti);
- new_s->session_state = SESSION_STATE_READY;
- }
+ s = session_get (new_si, new_ti);
+ session_free_w_fifos (s);
+ return -1;
}
- return error;
+ s = session_get (new_si, new_ti);
+ s->session_state = SESSION_STATE_READY;
+ session_lookup_add_connection (tc, session_handle (s));
+
+ return 0;
}
typedef struct _session_switch_pool_args
return 0;
}
-int
-stream_session_accept_notify (transport_connection_t * tc)
-{
- app_worker_t *app_wrk;
- application_t *app;
- session_t *s;
-
- s = session_get (tc->s_index, tc->thread_index);
- app_wrk = app_worker_get_if_valid (s->app_wrk_index);
- if (!app_wrk)
- return -1;
- s->session_state = SESSION_STATE_ACCEPTING;
- app = application_get (app_wrk->app_index);
- return app->cb_fns.session_accept_callback (s);
-}
-
/**
* Notification from transport that connection is being closed.
*
switch (s->session_state)
{
+ case SESSION_STATE_CREATED:
+ /* Session was created but accept notification was not yet sent to the
+ * app. Cleanup everything. */
+ session_lookup_del_session (s);
+ session_free_w_fifos (s);
+ break;
case SESSION_STATE_ACCEPTING:
case SESSION_STATE_TRANSPORT_CLOSING:
/* If transport finishes or times out before we get a reply
app->cb_fns.session_reset_callback (s);
}
+int
+session_stream_accept_notify (transport_connection_t * tc)
+{
+ app_worker_t *app_wrk;
+ session_t *s;
+
+ s = session_get (tc->s_index, tc->thread_index);
+ app_wrk = app_worker_get_if_valid (s->app_wrk_index);
+ if (!app_wrk)
+ return -1;
+ s->session_state = SESSION_STATE_ACCEPTING;
+ return app_worker_accept_notify (app_wrk, s);
+}
+
/**
* Accept a stream session. Optionally ping the server by callback.
*/
session_stream_accept (transport_connection_t * tc, u32 listener_index,
u8 notify)
{
- session_t *s, *listener;
- app_worker_t *app_wrk;
- segment_manager_t *sm;
+ session_t *s;
int rv;
- /* Find the server */
- listener = listen_session_get (listener_index);
- app_wrk = application_listener_select_worker (listener);
+ s = session_alloc_for_connection (tc);
+ s->listener_index = listener_index;
+ s->session_state = SESSION_STATE_CREATED;
- sm = app_worker_get_listen_segment_manager (app_wrk, listener);
- if ((rv = session_alloc_and_init (sm, tc, 1, &s)))
+ if ((rv = app_worker_init_accepted (s)))
return rv;
- s->app_wrk_index = app_wrk->wrk_index;
- s->listener_index = listener_index;
+ session_lookup_add_connection (tc, session_handle (s));
/* Shoulder-tap the server */
if (notify)
{
- application_t *app = application_get (app_wrk->app_index);
- return app->cb_fns.session_accept_callback (s);
+ app_worker_t *app_wrk = app_worker_get (s->app_wrk_index);
+ return app_worker_accept_notify (app_wrk, s);
}
return 0;
{
transport_connection_t *tc;
transport_endpoint_cfg_t *tep;
- segment_manager_t *sm;
app_worker_t *app_wrk;
session_t *s;
- application_t *app;
int rv;
tep = session_endpoint_to_transport_cfg (rmt);
tc = transport_get_half_open (rmt->transport_proto, (u32) rv);
- /* For dgram type of service, allocate session and fifos now.
- */
+ /* For dgram type of service, allocate session and fifos now */
app_wrk = app_worker_get (app_wrk_index);
- sm = app_worker_get_connect_segment_manager (app_wrk);
-
- if (session_alloc_and_init (sm, tc, 1, &s))
- return -1;
+ s = session_alloc_for_connection (tc);
s->app_wrk_index = app_wrk->wrk_index;
s->session_state = SESSION_STATE_OPENED;
+ if (app_worker_init_connected (app_wrk, s))
+ {
+ session_free (s);
+ return -1;
+ }
- /* Tell the app about the new event fifo for this session */
- app = application_get (app_wrk->app_index);
- app->cb_fns.session_connected_callback (app_wrk->wrk_index, opaque, s, 0);
-
- return 0;
+ return app_worker_connect_notify (app_wrk, s, opaque);
}
int
int
session_listen (session_t * ls, session_endpoint_cfg_t * sep)
{
- transport_connection_t *tc;
transport_endpoint_t *tep;
u32 tc_index, s_index;
/* Transport bind/listen */
tep = session_endpoint_to_transport (sep);
s_index = ls->session_index;
- tc_index = transport_start_listen (sep->transport_proto, s_index, tep);
+ tc_index = transport_start_listen (session_get_transport_proto (ls),
+ s_index, tep);
if (tc_index == (u32) ~ 0)
return -1;
- /* Attach transport to session */
+ /* Attach transport to session. Lookup tables are populated by the app
+ * worker because local tables (for ct sessions) are not backed by a fib */
ls = listen_session_get (s_index);
ls->connection_index = tc_index;
- /* Add to the main lookup table after transport was initialized */
- tc = transport_get_listener (sep->transport_proto, tc_index);
- session_lookup_add_connection (tc, listen_session_get_handle (ls));
return 0;
}
u32 evt_q_length = 2048, evt_size = sizeof (session_event_t);
ssvm_private_t *eqs = &smm->evt_qs_segment;
api_main_t *am = &api_main;
- u64 eqs_size = 64 << 20;
+ uword eqs_size = 64 << 20;
pid_t vpp_pid = getpid ();
void *oldheap;
int i;
svm_msg_q_ring_cfg_t rc[SESSION_MQ_N_RINGS] = {
{evt_q_length, evt_size, 0}
,
- {evt_q_length << 1, 256, 0}
+ {evt_q_length >> 1, 256, 0}
};
cfg->consumer_pid = 0;
cfg->n_rings = 2;
;
else if (unformat (input, "evt_qs_memfd_seg"))
smm->evt_qs_use_memfd_seg = 1;
+ else if (unformat (input, "evt_qs_seg_size %U", unformat_memory_size,
+ &smm->evt_qs_segment_size))
+ ;
else
return clib_error_return (0, "unknown input `%U'",
format_unformat_error, input);
Code Review / vpp.git / blobdiff