X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fsession%2Fsession.c;h=069818ef1beceda200c5f1e926626f51284df8d7;hb=78cc4b0797a983d5d31b9127fea9c2b72ed081d7;hp=7b50950fe01738a0038d0cdfc17e167b4b062517;hpb=eb97e5f548b009ffa92efa3f778b4a7f6f40b7eb;p=vpp.git diff --git a/src/vnet/session/session.c b/src/vnet/session/session.c index 7b50950fe01..069818ef1be 100644 --- a/src/vnet/session/session.c +++ b/src/vnet/session/session.c @@ -121,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; } @@ -148,9 +146,9 @@ 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 @@ -196,7 +194,6 @@ 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 = (u64) ~ 0; /* Attach transport to session and vice versa */ @@ -391,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; - u64 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, @@ -432,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; - u64 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; @@ -539,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++) { @@ -559,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; } @@ -636,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; @@ -730,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; @@ -740,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); } /** @@ -812,19 +805,27 @@ stream_session_delete_notify (transport_connection_t * tc) 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 */ + * 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: + case SESSION_STATE_CLOSED_WAITING: + stream_session_delete (s); + break; + default: stream_session_delete (s); break; } - - s->session_state = SESSION_STATE_CLOSED; } /** @@ -837,7 +838,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); @@ -871,7 +875,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; @@ -881,14 +885,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) { @@ -919,11 +923,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) { @@ -953,11 +957,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); @@ -999,7 +1005,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; @@ -1061,7 +1067,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) @@ -1081,8 +1087,9 @@ stream_session_disconnect (stream_session_t * s) * held, just append a new event to pending disconnects vector. */ if (vlib_thread_is_main_w_barrier () || thread_index == s->thread_index) { - 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; } @@ -1106,7 +1113,18 @@ stream_session_disconnect_transport (stream_session_t * s) session_free_w_fifos (s); return; } - s->session_state = SESSION_STATE_CLOSED; + + /* If tx queue wasn't drained, change state to closed waiting for transport. + * This way, the transport, if it so wishes, can continue to try sending the + * outstanding data (in closed state it cannot). It MUST however at one + * point, either after sending everything or after a timeout, call delete + * notify. This will finally lead to the complete cleanup of the session. + */ + if (svm_fifo_max_dequeue (s->server_tx_fifo)) + s->session_state = SESSION_STATE_CLOSED_WAITING; + else + s->session_state = SESSION_STATE_CLOSED; + tp_vfts[session_get_transport_proto (s)].close (s->connection_index, s->thread_index); } @@ -1200,23 +1218,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"); } } @@ -1335,6 +1352,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; @@ -1342,34 +1360,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 @@ -1389,7 +1405,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 { @@ -1400,7 +1416,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); } } @@ -1414,7 +1430,7 @@ session_manager_main_enable (vlib_main_t * vm) /* Enable transports */ transport_enable_disable (vm, 1); - + transport_init_tx_pacers_period (); return 0; }