X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fsession%2Fsession.c;h=b48459d5081da1af7ed67d7a9f6da6f3881642e7;hb=e2ea193171f4701aa575379da0e1bac16a85aa33;hp=133c91ca198f660d25ac95381d75114a12308c6f;hpb=86f04500ae027dc66e91519a006388e56df4ceff;p=vpp.git diff --git a/src/vnet/session/session.c b/src/vnet/session/session.c index 133c91ca198..b48459d5081 100644 --- a/src/vnet/session/session.c +++ b/src/vnet/session/session.c @@ -69,6 +69,7 @@ session_send_evt_to_thread (void *data, void *args, u32 thread_index, case FIFO_EVENT_BUILTIN_RX: evt->fifo = data; break; + case FIFO_EVENT_BUILTIN_TX: case FIFO_EVENT_DISCONNECT: evt->session_handle = session_handle ((stream_session_t *) data); break; @@ -89,10 +90,10 @@ session_send_io_evt_to_thread (svm_fifo_t * f, session_evt_type_t evt_type) } int -session_send_io_evt_to_thread_custom (svm_fifo_t * f, u32 thread_index, +session_send_io_evt_to_thread_custom (void *data, u32 thread_index, session_evt_type_t evt_type) { - return session_send_evt_to_thread (f, 0, thread_index, evt_type); + return session_send_evt_to_thread (data, 0, thread_index, evt_type); } int @@ -120,26 +121,24 @@ session_send_rpc_evt_to_thread (u32 thread_index, void *fp, void *rpc_args) stream_session_t * session_alloc (u32 thread_index) { - session_manager_main_t *smm = &session_manager_main; + session_manager_worker_t *wrk = &session_manager_main.wrk[thread_index]; stream_session_t *s; u8 will_expand = 0; - pool_get_aligned_will_expand (smm->sessions[thread_index], will_expand, + pool_get_aligned_will_expand (wrk->sessions, will_expand, CLIB_CACHE_LINE_BYTES); /* If we have peekers, let them finish */ if (PREDICT_FALSE (will_expand && vlib_num_workers ())) { - clib_rwlock_writer_lock (&smm->peekers_rw_locks[thread_index]); - pool_get_aligned (session_manager_main.sessions[thread_index], s, - CLIB_CACHE_LINE_BYTES); - clib_rwlock_writer_unlock (&smm->peekers_rw_locks[thread_index]); + clib_rwlock_writer_lock (&wrk->peekers_rw_locks); + pool_get_aligned (wrk->sessions, s, CLIB_CACHE_LINE_BYTES); + clib_rwlock_writer_unlock (&wrk->peekers_rw_locks); } else { - pool_get_aligned (session_manager_main.sessions[thread_index], s, - CLIB_CACHE_LINE_BYTES); + pool_get_aligned (wrk->sessions, s, CLIB_CACHE_LINE_BYTES); } - memset (s, 0, sizeof (*s)); - s->session_index = s - session_manager_main.sessions[thread_index]; + clib_memset (s, 0, sizeof (*s)); + s->session_index = s - wrk->sessions; s->thread_index = thread_index; return s; } @@ -147,9 +146,17 @@ session_alloc (u32 thread_index) void session_free (stream_session_t * s) { - pool_put (session_manager_main.sessions[s->thread_index], s); + pool_put (session_manager_main.wrk[s->thread_index].sessions, s); if (CLIB_DEBUG) - memset (s, 0xFA, sizeof (*s)); + clib_memset (s, 0xFA, sizeof (*s)); +} + +void +session_free_w_fifos (stream_session_t * s) +{ + segment_manager_dealloc_fifos (s->svm_segment_index, s->server_rx_fifo, + s->server_tx_fifo); + session_free (s); } int @@ -187,8 +194,7 @@ session_alloc_for_connection (transport_connection_t * tc) s = session_alloc (thread_index); s->session_type = session_type_from_proto_and_ip (tc->proto, tc->is_ip4); - s->session_state = SESSION_STATE_CONNECTING; - s->enqueue_epoch = ~0; + s->enqueue_epoch = (u64) ~ 0; /* Attach transport to session and vice versa */ s->connection_index = tc->c_index; @@ -382,22 +388,19 @@ session_enqueue_stream_connection (transport_connection_t * tc, { /* Queue RX event on this fifo. Eventually these will need to be flushed * by calling stream_server_flush_enqueue_events () */ - session_manager_main_t *smm = vnet_get_session_manager_main (); - u32 thread_index = s->thread_index; - u32 enqueue_epoch = smm->current_enqueue_epoch[tc->proto][thread_index]; + session_manager_worker_t *wrk; - if (s->enqueue_epoch != enqueue_epoch) + wrk = session_manager_get_worker (s->thread_index); + if (s->enqueue_epoch != wrk->current_enqueue_epoch[tc->proto]) { - s->enqueue_epoch = enqueue_epoch; - vec_add1 (smm->session_to_enqueue[tc->proto][thread_index], - s->session_index); + s->enqueue_epoch = wrk->current_enqueue_epoch[tc->proto]; + vec_add1 (wrk->session_to_enqueue[tc->proto], s->session_index); } } return enqueued; } - int session_enqueue_dgram_connection (stream_session_t * s, session_dgram_hdr_t * hdr, @@ -423,15 +426,13 @@ session_enqueue_dgram_connection (stream_session_t * s, { /* Queue RX event on this fifo. Eventually these will need to be flushed * by calling stream_server_flush_enqueue_events () */ - session_manager_main_t *smm = vnet_get_session_manager_main (); - u32 thread_index = s->thread_index; - u32 enqueue_epoch = smm->current_enqueue_epoch[proto][thread_index]; + session_manager_worker_t *wrk; - if (s->enqueue_epoch != enqueue_epoch) + wrk = session_manager_get_worker (s->thread_index); + if (s->enqueue_epoch != wrk->current_enqueue_epoch[proto]) { - s->enqueue_epoch = enqueue_epoch; - vec_add1 (smm->session_to_enqueue[proto][thread_index], - s->session_index); + s->enqueue_epoch = wrk->current_enqueue_epoch[proto]; + vec_add1 (wrk->session_to_enqueue[proto], s->session_index); } } return enqueued; @@ -530,12 +531,12 @@ session_dequeue_notify (stream_session_t * s) int session_manager_flush_enqueue_events (u8 transport_proto, u32 thread_index) { - session_manager_main_t *smm = &session_manager_main; + session_manager_worker_t *wrk = session_manager_get_worker (thread_index); stream_session_t *s; int i, errors = 0; u32 *indices; - indices = smm->session_to_enqueue[transport_proto][thread_index]; + indices = wrk->session_to_enqueue[transport_proto]; for (i = 0; i < vec_len (indices); i++) { @@ -550,8 +551,8 @@ session_manager_flush_enqueue_events (u8 transport_proto, u32 thread_index) } vec_reset_length (indices); - smm->session_to_enqueue[transport_proto][thread_index] = indices; - smm->current_enqueue_epoch[transport_proto][thread_index]++; + wrk->session_to_enqueue[transport_proto] = indices; + wrk->current_enqueue_epoch[transport_proto]++; return errors; } @@ -627,6 +628,7 @@ session_stream_connect_notify (transport_connection_t * tc, u8 is_fail) } 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; @@ -721,7 +723,7 @@ session_dgram_connect_notify (transport_connection_t * tc, return 0; } -void +int stream_session_accept_notify (transport_connection_t * tc) { app_worker_t *app_wrk; @@ -731,9 +733,9 @@ stream_session_accept_notify (transport_connection_t * tc) s = session_get (tc->s_index, tc->thread_index); app_wrk = app_worker_get_if_valid (s->app_wrk_index); if (!app_wrk) - return; + return -1; app = application_get (app_wrk->app_index); - app->cb_fns.session_accept_callback (s); + return app->cb_fns.session_accept_callback (s); } /** @@ -751,7 +753,9 @@ stream_session_disconnect_notify (transport_connection_t * tc) stream_session_t *s; s = session_get (tc->s_index, tc->thread_index); - s->session_state = SESSION_STATE_CLOSING; + if (s->session_state >= SESSION_STATE_TRANSPORT_CLOSING) + return; + s->session_state = SESSION_STATE_TRANSPORT_CLOSING; app_wrk = app_worker_get_if_valid (s->app_wrk_index); if (!app_wrk) return; @@ -773,10 +777,7 @@ stream_session_delete (stream_session_t * s) if ((rv = session_lookup_del_session (s))) clib_warning ("hash delete error, rv %d", rv); - /* Cleanup fifo segments */ - segment_manager_dealloc_fifos (s->svm_segment_index, s->server_rx_fifo, - s->server_tx_fifo); - session_free (s); + session_free_w_fifos (s); } /** @@ -793,10 +794,37 @@ stream_session_delete_notify (transport_connection_t * tc) stream_session_t *s; /* App might've been removed already */ - s = session_get_if_valid (tc->s_index, tc->thread_index); - if (!s) + if (!(s = session_get_if_valid (tc->s_index, tc->thread_index))) return; - stream_session_delete (s); + + /* Make sure we don't try to send anything more */ + svm_fifo_dequeue_drop_all (s->server_tx_fifo); + + switch (s->session_state) + { + case SESSION_STATE_TRANSPORT_CLOSING: + /* If transport finishes or times out before we get a reply + * from the app, do the whole disconnect since we might still + * have lingering events. Cleanup session table in advance + * because transport will soon be closed and closed sessions + * are assumed to have been removed from the lookup table */ + session_lookup_del_session (s); + stream_session_disconnect (s); + s->session_state = SESSION_STATE_CLOSED; + break; + case SESSION_STATE_CLOSING: + /* Cleanup lookup table. Transport needs to still be valid */ + session_lookup_del_session (s); + s->session_state = SESSION_STATE_CLOSED; + break; + case SESSION_STATE_CLOSED: + case SESSION_STATE_ACCEPTING: + stream_session_delete (s); + break; + default: + stream_session_delete (s); + break; + } } /** @@ -809,7 +837,10 @@ stream_session_reset_notify (transport_connection_t * tc) app_worker_t *app_wrk; application_t *app; s = session_get (tc->s_index, tc->thread_index); - s->session_state = SESSION_STATE_CLOSED; + svm_fifo_dequeue_drop_all (s->server_tx_fifo); + if (s->session_state >= SESSION_STATE_TRANSPORT_CLOSING) + return; + s->session_state = SESSION_STATE_TRANSPORT_CLOSING; app_wrk = app_worker_get (s->app_wrk_index); app = application_get (app_wrk->app_index); app->cb_fns.session_reset_callback (s); @@ -843,7 +874,7 @@ stream_session_accept (transport_connection_t * tc, u32 listener_index, if (notify) { application_t *app = application_get (app_wrk->app_index); - app->cb_fns.session_accept_callback (s); + return app->cb_fns.session_accept_callback (s); } return 0; @@ -853,14 +884,14 @@ int session_open_cl (u32 app_wrk_index, session_endpoint_t * rmt, u32 opaque) { transport_connection_t *tc; - transport_endpoint_t *tep; + transport_endpoint_cfg_t *tep; segment_manager_t *sm; app_worker_t *app_wrk; stream_session_t *s; application_t *app; int rv; - tep = session_endpoint_to_transport (rmt); + tep = session_endpoint_to_transport_cfg (rmt); rv = tp_vfts[rmt->transport_proto].open (tep); if (rv < 0) { @@ -891,11 +922,11 @@ int session_open_vc (u32 app_wrk_index, session_endpoint_t * rmt, u32 opaque) { transport_connection_t *tc; - transport_endpoint_t *tep; + transport_endpoint_cfg_t *tep; u64 handle; int rv; - tep = session_endpoint_to_transport (rmt); + tep = session_endpoint_to_transport_cfg (rmt); rv = tp_vfts[rmt->transport_proto].open (tep); if (rv < 0) { @@ -925,11 +956,13 @@ session_open_vc (u32 app_wrk_index, session_endpoint_t * rmt, u32 opaque) int session_open_app (u32 app_wrk_index, session_endpoint_t * rmt, u32 opaque) { - session_endpoint_extended_t *sep = (session_endpoint_extended_t *) rmt; + session_endpoint_cfg_t *sep = (session_endpoint_cfg_t *) rmt; + transport_endpoint_cfg_t *tep_cfg = session_endpoint_to_transport_cfg (sep); + sep->app_wrk_index = app_wrk_index; sep->opaque = opaque; - return tp_vfts[rmt->transport_proto].open ((transport_endpoint_t *) sep); + return tp_vfts[rmt->transport_proto].open (tep_cfg); } typedef int (*session_open_service_fn) (u32, session_endpoint_t *, u32); @@ -971,7 +1004,7 @@ session_open (u32 app_wrk_index, session_endpoint_t * rmt, u32 opaque) * @param sep Local endpoint to be listened on. */ int -session_listen (stream_session_t * ls, session_endpoint_extended_t * sep) +session_listen (stream_session_t * ls, session_endpoint_cfg_t * sep) { transport_connection_t *tc; transport_endpoint_t *tep; @@ -1033,7 +1066,7 @@ void stream_session_disconnect (stream_session_t * s) { u32 thread_index = vlib_get_thread_index (); - session_manager_main_t *smm = &session_manager_main; + session_manager_worker_t *wrk; session_event_t *evt; if (!s) @@ -1050,13 +1083,12 @@ stream_session_disconnect (stream_session_t * s) s->session_state = SESSION_STATE_CLOSING; /* If we are in the handler thread, or being called with the worker barrier - * held (api/cli), just append a new event to pending disconnects vector. */ - if ((thread_index == 0 && !vlib_get_current_process (vlib_get_main ())) - || thread_index == s->thread_index) + * held, just append a new event to pending disconnects vector. */ + if (vlib_thread_is_main_w_barrier () || thread_index == s->thread_index) { - ASSERT (s->thread_index == thread_index || thread_index == 0); - vec_add2 (smm->pending_disconnects[s->thread_index], evt, 1); - memset (evt, 0, sizeof (*evt)); + wrk = session_manager_get_worker (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; } @@ -1074,6 +1106,12 @@ stream_session_disconnect (stream_session_t * s) void stream_session_disconnect_transport (stream_session_t * s) { + /* If transport is already closed, just free the session */ + if (s->session_state == SESSION_STATE_CLOSED) + { + session_free_w_fifos (s); + return; + } s->session_state = SESSION_STATE_CLOSED; tp_vfts[session_get_transport_proto (s)].close (s->connection_index, s->thread_index); @@ -1097,9 +1135,7 @@ stream_session_cleanup (stream_session_t * s) s->thread_index); /* Since we called cleanup, no delete notification will come. So, make * sure the session is properly freed. */ - segment_manager_dealloc_fifos (s->svm_segment_index, s->server_rx_fifo, - s->server_tx_fifo); - session_free (s); + session_free_w_fifos (s); } transport_service_type_t @@ -1170,23 +1206,22 @@ session_vpp_event_queues_allocate (session_manager_main_t * smm) else oldheap = svm_push_data_heap (am->vlib_rp); - for (i = 0; i < vec_len (smm->vpp_event_queues); i++) + for (i = 0; i < vec_len (smm->wrk); i++) { svm_msg_q_cfg_t _cfg, *cfg = &_cfg; - u32 notif_q_size = clib_max (16, evt_q_length >> 4); svm_msg_q_ring_cfg_t rc[SESSION_MQ_N_RINGS] = { {evt_q_length, evt_size, 0} , - {notif_q_size, 256, 0} + {evt_q_length << 1, 256, 0} }; cfg->consumer_pid = 0; cfg->n_rings = 2; cfg->q_nitems = evt_q_length; cfg->ring_cfgs = rc; - smm->vpp_event_queues[i] = svm_msg_q_alloc (cfg); + smm->wrk[i].vpp_event_queue = svm_msg_q_alloc (cfg); if (smm->evt_qs_use_memfd_seg) { - if (svm_msg_q_alloc_consumer_eventfd (smm->vpp_event_queues[i])) + if (svm_msg_q_alloc_consumer_eventfd (smm->wrk[i].vpp_event_queue)) clib_warning ("eventfd returned"); } } @@ -1305,6 +1340,7 @@ session_manager_main_enable (vlib_main_t * vm) session_manager_main_t *smm = &session_manager_main; vlib_thread_main_t *vtm = vlib_get_thread_main (); u32 num_threads, preallocated_sessions_per_worker; + session_manager_worker_t *wrk; int i, j; num_threads = 1 /* main thread */ + vtm->n_threads; @@ -1312,34 +1348,32 @@ session_manager_main_enable (vlib_main_t * vm) if (num_threads < 1) return clib_error_return (0, "n_thread_stacks not set"); - /* configure per-thread ** vectors */ - vec_validate (smm->sessions, num_threads - 1); - vec_validate (smm->tx_buffers, num_threads - 1); - vec_validate (smm->pending_event_vector, num_threads - 1); - vec_validate (smm->pending_disconnects, num_threads - 1); - vec_validate (smm->free_event_vector, num_threads - 1); - vec_validate (smm->vpp_event_queues, num_threads - 1); - vec_validate (smm->peekers_rw_locks, num_threads - 1); - vec_validate_aligned (smm->ctx, num_threads - 1, CLIB_CACHE_LINE_BYTES); + /* Allocate cache line aligned worker contexts */ + vec_validate_aligned (smm->wrk, num_threads - 1, CLIB_CACHE_LINE_BYTES); for (i = 0; i < TRANSPORT_N_PROTO; i++) { - vec_validate (smm->current_enqueue_epoch[i], num_threads - 1); - vec_validate (smm->session_to_enqueue[i], num_threads - 1); for (j = 0; j < num_threads; j++) - smm->current_enqueue_epoch[i][j] = 1; + smm->wrk[j].current_enqueue_epoch[i] = 1; } for (i = 0; i < num_threads; i++) { - vec_validate (smm->free_event_vector[i], 0); - _vec_len (smm->free_event_vector[i]) = 0; - vec_validate (smm->pending_event_vector[i], 0); - _vec_len (smm->pending_event_vector[i]) = 0; - vec_validate (smm->pending_disconnects[i], 0); - _vec_len (smm->pending_disconnects[i]) = 0; + wrk = &smm->wrk[i]; + vec_validate (wrk->free_event_vector, 128); + _vec_len (wrk->free_event_vector) = 0; + vec_validate (wrk->pending_event_vector, 128); + _vec_len (wrk->pending_event_vector) = 0; + vec_validate (wrk->pending_disconnects, 128); + _vec_len (wrk->pending_disconnects) = 0; + vec_validate (wrk->postponed_event_vector, 128); + _vec_len (wrk->postponed_event_vector) = 0; + + wrk->last_vlib_time = vlib_time_now (vlib_mains[i]); + wrk->dispatch_period = 500e-6; + if (num_threads > 1) - clib_rwlock_init (&smm->peekers_rw_locks[i]); + clib_rwlock_init (&smm->wrk[i].peekers_rw_locks); } #if SESSION_DEBUG @@ -1359,7 +1393,7 @@ session_manager_main_enable (vlib_main_t * vm) { if (num_threads == 1) { - pool_init_fixed (smm->sessions[0], smm->preallocated_sessions); + pool_init_fixed (smm->wrk[0].sessions, smm->preallocated_sessions); } else { @@ -1370,7 +1404,7 @@ session_manager_main_enable (vlib_main_t * vm) for (j = 1; j < num_threads; j++) { - pool_init_fixed (smm->sessions[j], + pool_init_fixed (smm->wrk[j].sessions, preallocated_sessions_per_worker); } } @@ -1384,7 +1418,7 @@ session_manager_main_enable (vlib_main_t * vm) /* Enable transports */ transport_enable_disable (vm, 1); - + transport_init_tx_pacers_period (); return 0; }