X-Git-Url: https://gerrit.fd.io/r/gitweb?a=blobdiff_plain;f=src%2Fvnet%2Fsession%2Fsession.h;h=b57053c7f59afc431c93ff40a8fc5db3242387df;hb=25579b4acd449e1bae30d2a20a44b77741c8e1fd;hp=98e8acb79c190e675a4b79c4e6ee67c289297ab9;hpb=b384b543313b6b47a277c903e9d4fcd4343054fa;p=vpp.git diff --git a/src/vnet/session/session.h b/src/vnet/session/session.h index 98e8acb79c1..b57053c7f59 100644 --- a/src/vnet/session/session.h +++ b/src/vnet/session/session.h @@ -25,6 +25,7 @@ #define HALF_OPEN_LOOKUP_INVALID_VALUE ((u64)~0) #define INVALID_INDEX ((u32)~0) #define SESSION_PROXY_LISTENER_INDEX ((u32)~0 - 1) +#define SESSION_LOCAL_HANDLE_PREFIX 0x7FFFFFFF /* TODO decide how much since we have pre-data as well */ #define MAX_HDRS_LEN 100 /* Max number of bytes for headers */ @@ -70,7 +71,8 @@ _(FIFO_FULL, "Packets dropped for lack of rx fifo space") \ _(EVENT_FIFO_FULL, "Events not sent for lack of event fifo space") \ _(API_QUEUE_FULL, "Sessions not created for lack of API queue space") \ _(NEW_SEG_NO_SPACE, "Created segment, couldn't allocate a fifo pair") \ -_(NO_SPACE, "Couldn't allocate a fifo pair") +_(NO_SPACE, "Couldn't allocate a fifo pair") \ +_(SEG_CREATE, "Couldn't create a new segment") typedef enum { @@ -86,12 +88,14 @@ typedef struct void *arg; } rpc_args_t; +typedef u64 session_handle_t; + /* *INDENT-OFF* */ typedef CLIB_PACKED (struct { union { svm_fifo_t * fifo; - u64 session_handle; + session_handle_t session_handle; rpc_args_t rpc_args; }; u8 event_type; @@ -99,17 +103,63 @@ typedef CLIB_PACKED (struct { }) session_fifo_event_t; /* *INDENT-ON* */ +typedef struct session_dgram_pre_hdr_ +{ + u32 data_length; + u32 data_offset; +} session_dgram_pre_hdr_t; + +/* *INDENT-OFF* */ +typedef CLIB_PACKED (struct session_dgram_header_ +{ + u32 data_length; + u32 data_offset; + ip46_address_t rmt_ip; + ip46_address_t lcl_ip; + u16 rmt_port; + u16 lcl_port; + u8 is_ip4; +}) session_dgram_hdr_t; +/* *INDENT-ON* */ + +#define SESSION_CONN_ID_LEN 37 +#define SESSION_CONN_HDR_LEN 45 + +STATIC_ASSERT (sizeof (session_dgram_hdr_t) == (SESSION_CONN_ID_LEN + 8), + "session conn id wrong length"); + +typedef struct session_tx_context_ +{ + CLIB_CACHE_LINE_ALIGN_MARK (cacheline0); + stream_session_t *s; + transport_proto_vft_t *transport_vft; + transport_connection_t *tc; + vlib_buffer_t *b; + u32 max_dequeue; + u32 snd_space; + u32 left_to_snd; + u32 tx_offset; + u32 max_len_to_snd; + u16 deq_per_first_buf; + u16 deq_per_buf; + u16 snd_mss; + u16 n_segs_per_evt; + u8 n_bufs_per_seg; + CLIB_CACHE_LINE_ALIGN_MARK (cacheline1); + session_dgram_hdr_t hdr; +} session_tx_context_t; + /* Forward definition */ typedef struct _session_manager_main session_manager_main_t; typedef int (session_fifo_rx_fn) (vlib_main_t * vm, vlib_node_runtime_t * node, - session_manager_main_t * smm, session_fifo_event_t * e0, stream_session_t * s0, - u32 thread_index, int *n_tx_pkts); + int *n_tx_pkts); extern session_fifo_rx_fn session_tx_fifo_peek_and_snd; extern session_fifo_rx_fn session_tx_fifo_dequeue_and_snd; +extern session_fifo_rx_fn session_tx_fifo_dequeue_internal; u8 session_node_lookup_fifo_event (svm_fifo_t * f, session_fifo_event_t * e); @@ -118,15 +168,8 @@ struct _session_manager_main /** Per worker thread session pools */ stream_session_t **sessions; - /** Per worker-thread count of threads peeking into the session pool */ - u32 *session_peekers; - - /** Per worker-thread rw peekers locks */ - clib_spinlock_t *peekers_readers_locks; - clib_spinlock_t *peekers_write_locks; - - /** Pool of listen sessions. Same type as stream sessions to ease lookups */ - stream_session_t **listen_sessions; + /** Per worker-thread session pool peekers rw locks */ + clib_rwlock_t *peekers_rw_locks; /** Per-proto, per-worker enqueue epoch counters */ u32 *current_enqueue_epoch[TRANSPORT_N_PROTO]; @@ -146,6 +189,9 @@ struct _session_manager_main /** per-worker postponed disconnects */ session_fifo_event_t **pending_disconnects; + /** per-worker session context */ + session_tx_context_t *ctx; + /** vpp fifo event queue */ svm_queue_t **vpp_event_queues; @@ -175,7 +221,7 @@ struct _session_manager_main /** Session ssvm segment configs*/ uword session_baseva; - u32 segment_timeout; + uword session_va_space_size; u32 evt_qs_segment_size; u8 evt_qs_use_memfd_seg; @@ -196,7 +242,7 @@ struct _session_manager_main /** Preallocate session config parameter */ u32 preallocated_sessions; -#if SESSION_DBG +#if SESSION_DEBUG /** * last event poll time by thread * Debug only. Will cause false cache-line sharing as-is @@ -208,6 +254,10 @@ struct _session_manager_main extern session_manager_main_t session_manager_main; extern vlib_node_registration_t session_queue_node; +extern vlib_node_registration_t session_queue_process_node; + +#define SESSION_Q_PROCESS_FLUSH_FRAMES 1 +#define SESSION_Q_PROCESS_STOP 2 /* * Session manager function @@ -233,6 +283,8 @@ stream_session_is_valid (u32 si, u8 thread_index) } stream_session_t *session_alloc (u32 thread_index); +int session_alloc_fifos (segment_manager_t * sm, stream_session_t * s); +void session_free (stream_session_t * s); always_inline stream_session_t * session_get (u32 si, u32 thread_index) @@ -254,38 +306,67 @@ session_get_if_valid (u64 si, u32 thread_index) return pool_elt_at_index (session_manager_main.sessions[thread_index], si); } -always_inline u64 +always_inline session_handle_t session_handle (stream_session_t * s) { return ((u64) s->thread_index << 32) | (u64) s->session_index; } always_inline u32 -session_index_from_handle (u64 handle) +session_index_from_handle (session_handle_t handle) { return handle & 0xFFFFFFFF; } always_inline u32 -session_thread_from_handle (u64 handle) +session_thread_from_handle (session_handle_t handle) { return handle >> 32; } always_inline void -session_parse_handle (u64 handle, u32 * index, u32 * thread_index) +session_parse_handle (session_handle_t handle, u32 * index, + u32 * thread_index) { *index = session_index_from_handle (handle); *thread_index = session_thread_from_handle (handle); } always_inline stream_session_t * -session_get_from_handle (u64 handle) +session_get_from_handle (session_handle_t handle) { session_manager_main_t *smm = &session_manager_main; - return - pool_elt_at_index (smm->sessions[session_thread_from_handle (handle)], - session_index_from_handle (handle)); + u32 session_index, thread_index; + session_parse_handle (handle, &session_index, &thread_index); + return pool_elt_at_index (smm->sessions[thread_index], session_index); +} + +always_inline stream_session_t * +session_get_from_handle_if_valid (session_handle_t handle) +{ + u32 session_index, thread_index; + session_parse_handle (handle, &session_index, &thread_index); + return session_get_if_valid (session_index, thread_index); +} + +always_inline u8 +session_handle_is_local (session_handle_t handle) +{ + if ((handle >> 32) == SESSION_LOCAL_HANDLE_PREFIX) + return 1; + return 0; +} + +always_inline transport_proto_t +session_type_transport_proto (session_type_t st) +{ + return (st >> 1); +} + +always_inline u8 +session_type_is_ip4 (session_type_t st) +{ + return (st & 1); } always_inline transport_proto_t @@ -294,12 +375,29 @@ session_get_transport_proto (stream_session_t * s) return (s->session_type >> 1); } +always_inline fib_protocol_t +session_get_fib_proto (stream_session_t * s) +{ + u8 is_ip4 = s->session_type & 1; + return (is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6); +} + always_inline session_type_t session_type_from_proto_and_ip (transport_proto_t proto, u8 is_ip4) { return (proto << 1 | is_ip4); } +always_inline u8 +session_has_transport (stream_session_t * s) +{ + return (session_get_transport_proto (s) != TRANSPORT_PROTO_NONE); +} + +transport_service_type_t session_transport_service_type (stream_session_t *); +transport_tx_fn_type_t session_transport_tx_fn_type (stream_session_t *); +u8 session_tx_is_dgram (stream_session_t * s); + /** * Acquires a lock that blocks a session pool from expanding. * @@ -316,11 +414,7 @@ session_pool_add_peeker (u32 thread_index) session_manager_main_t *smm = &session_manager_main; if (thread_index == vlib_get_thread_index ()) return; - clib_spinlock_lock_if_init (&smm->peekers_readers_locks[thread_index]); - smm->session_peekers[thread_index] += 1; - if (smm->session_peekers[thread_index] == 1) - clib_spinlock_lock_if_init (&smm->peekers_write_locks[thread_index]); - clib_spinlock_unlock_if_init (&smm->peekers_readers_locks[thread_index]); + clib_rwlock_reader_lock (&smm->peekers_rw_locks[thread_index]); } always_inline void @@ -329,12 +423,7 @@ session_pool_remove_peeker (u32 thread_index) session_manager_main_t *smm = &session_manager_main; if (thread_index == vlib_get_thread_index ()) return; - ASSERT (session_manager_main.session_peekers[thread_index] > 0); - clib_spinlock_lock_if_init (&smm->peekers_readers_locks[thread_index]); - smm->session_peekers[thread_index] -= 1; - if (smm->session_peekers[thread_index] == 0) - clib_spinlock_unlock_if_init (&smm->peekers_write_locks[thread_index]); - clib_spinlock_unlock_if_init (&smm->peekers_readers_locks[thread_index]); + clib_rwlock_reader_unlock (&smm->peekers_rw_locks[thread_index]); } /** @@ -360,33 +449,25 @@ session_get_from_handle_safe (u64 handle) } } -always_inline stream_session_t * -stream_session_listener_get (u8 sst, u64 si) -{ - return pool_elt_at_index (session_manager_main.listen_sessions[sst], si); -} - always_inline u32 -stream_session_get_index (stream_session_t * s) +transport_max_rx_enqueue (transport_connection_t * tc) { - if (s->session_state == SESSION_STATE_LISTENING) - return s - session_manager_main.listen_sessions[s->session_type]; - - return s - session_manager_main.sessions[s->thread_index]; + stream_session_t *s = session_get (tc->s_index, tc->thread_index); + return svm_fifo_max_enqueue (s->server_rx_fifo); } always_inline u32 -stream_session_max_rx_enqueue (transport_connection_t * tc) +transport_rx_fifo_size (transport_connection_t * tc) { stream_session_t *s = session_get (tc->s_index, tc->thread_index); - return svm_fifo_max_enqueue (s->server_rx_fifo); + return s->server_rx_fifo->nitems; } always_inline u32 -stream_session_rx_fifo_size (transport_connection_t * tc) +transport_tx_fifo_size (transport_connection_t * tc) { stream_session_t *s = session_get (tc->s_index, tc->thread_index); - return s->server_rx_fifo->nitems; + return s->server_tx_fifo->nitems; } always_inline u32 @@ -418,15 +499,16 @@ session_clone_safe (u32 session_index, u32 thread_index) transport_connection_t *session_get_transport (stream_session_t * s); -u32 stream_session_tx_fifo_max_dequeue (transport_connection_t * tc); +u32 session_tx_fifo_max_dequeue (transport_connection_t * tc); -stream_session_t *session_alloc (u32 thread_index); int session_enqueue_stream_connection (transport_connection_t * tc, vlib_buffer_t * b, u32 offset, u8 queue_event, u8 is_in_order); -int session_enqueue_dgram_connection (stream_session_t * s, vlib_buffer_t * b, - u8 proto, u8 queue_event); +int session_enqueue_dgram_connection (stream_session_t * s, + session_dgram_hdr_t * hdr, + vlib_buffer_t * b, u8 proto, + u8 queue_event); int stream_session_peek_bytes (transport_connection_t * tc, u8 * buffer, u32 offset, u32 max_bytes); u32 stream_session_dequeue_drop (transport_connection_t * tc, u32 max_bytes); @@ -448,6 +530,7 @@ int session_open (u32 app_index, session_endpoint_t * tep, u32 opaque); int stream_session_listen (stream_session_t * s, session_endpoint_t * tep); int stream_session_stop_listen (stream_session_t * s); void stream_session_disconnect (stream_session_t * s); +void stream_session_disconnect_transport (stream_session_t * s); void stream_session_cleanup (stream_session_t * s); void session_send_session_evt_to_thread (u64 session_handle, fifo_event_type_t evt_type, @@ -472,57 +555,48 @@ session_manager_get_vpp_event_queue (u32 thread_index) } int session_manager_flush_enqueue_events (u8 proto, u32 thread_index); +int session_manager_flush_all_enqueue_events (u8 transport_proto); always_inline u64 listen_session_get_handle (stream_session_t * s) { ASSERT (s->session_state == SESSION_STATE_LISTENING); - return ((u64) s->session_type << 32) | s->session_index; + return session_handle (s); } always_inline stream_session_t * -listen_session_get_from_handle (u64 handle) +listen_session_get_from_handle (session_handle_t handle) { - session_manager_main_t *smm = &session_manager_main; - stream_session_t *s; - u32 type, index; - type = handle >> 32; - index = handle & 0xFFFFFFFF; - - if (pool_is_free_index (smm->listen_sessions[type], index)) - return 0; + return session_get_from_handle (handle); +} - s = pool_elt_at_index (smm->listen_sessions[type], index); - ASSERT (s->session_state == SESSION_STATE_LISTENING); - return s; +always_inline void +listen_session_parse_handle (session_handle_t handle, u32 * index, + u32 * thread_index) +{ + session_parse_handle (handle, index, thread_index); } always_inline stream_session_t * -listen_session_new (session_type_t type) +listen_session_new (u8 thread_index, session_type_t type) { stream_session_t *s; - pool_get_aligned (session_manager_main.listen_sessions[type], s, - CLIB_CACHE_LINE_BYTES); - memset (s, 0, sizeof (*s)); - + s = session_alloc (thread_index); s->session_type = type; s->session_state = SESSION_STATE_LISTENING; - s->session_index = s - session_manager_main.listen_sessions[type]; - return s; } always_inline stream_session_t * -listen_session_get (session_type_t type, u32 index) +listen_session_get (u32 index) { - return pool_elt_at_index (session_manager_main.listen_sessions[type], - index); + return session_get (index, 0); } always_inline void listen_session_del (stream_session_t * s) { - pool_put (session_manager_main.listen_sessions[s->session_type], s); + session_free (s); } transport_connection_t *listen_session_get_transport (stream_session_t * s); @@ -531,25 +605,7 @@ int listen_session_get_local_session_endpoint (stream_session_t * listener, session_endpoint_t * sep); -always_inline stream_session_t * -session_manager_get_listener (u8 session_type, u32 index) -{ - return - pool_elt_at_index (session_manager_main.listen_sessions[session_type], - index); -} - -/** - * Set peek or dequeue function for given session type - * - * Reliable transport protocols will probably want to use a peek function - */ -always_inline void -session_manager_set_transport_rx_fn (session_type_t type, u8 is_peek) -{ - session_manager_main.session_tx_fns[type] = (is_peek) ? - session_tx_fifo_peek_and_snd : session_tx_fifo_dequeue_and_snd; -} +void session_flush_frames_main_thread (vlib_main_t * vm); always_inline u8 session_manager_is_enabled ()