FD.io VPP  v19.04.1-1-ge4a0f9f
Vector Packet Processing
session.h
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2017-2019 Cisco and/or its affiliates.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at:
6  *
7  * http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 #ifndef __included_session_h__
16 #define __included_session_h__
17 
21 #include <svm/message_queue.h>
22 #include <svm/ssvm.h>
23 
24 #define foreach_session_input_error \
25 _(NO_SESSION, "No session drops") \
26 _(NO_LISTENER, "No listener for dst port drops") \
27 _(ENQUEUED, "Packets pushed into rx fifo") \
28 _(NOT_READY, "Session not ready packets") \
29 _(FIFO_FULL, "Packets dropped for lack of rx fifo space") \
30 _(EVENT_FIFO_FULL, "Events not sent for lack of event fifo space") \
31 _(API_QUEUE_FULL, "Sessions not created for lack of API queue space") \
32 _(NEW_SEG_NO_SPACE, "Created segment, couldn't allocate a fifo pair") \
33 _(NO_SPACE, "Couldn't allocate a fifo pair") \
34 _(SEG_CREATE, "Couldn't create a new segment")
35 
36 typedef enum
37 {
38 #define _(sym,str) SESSION_ERROR_##sym,
40 #undef _
43 
44 typedef struct session_tx_context_
45 {
46  CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
60  CLIB_CACHE_LINE_ALIGN_MARK (cacheline1);
63 
64 typedef struct session_worker_
65 {
66  CLIB_CACHE_LINE_ALIGN_MARK (cacheline0);
67 
68  /** Worker session pool */
70 
71  /** vpp event message queue for worker */
73 
74  /** Our approximation of a "complete" dispatch loop period */
76 
77  /** vlib_time_now last time around the track */
79 
80  /** Per-proto vector of sessions to enqueue */
81  u32 *session_to_enqueue[TRANSPORT_N_PROTO];
82 
83  /** Context for session tx */
85 
86  /** Vector of tx buffer free lists */
88 
89  /** Vector of partially read events */
90  session_event_t *free_event_vector;
91 
92  /** Vector of active event vectors */
93  session_event_t *pending_event_vector;
94 
95  /** Vector of postponed disconnects */
96  session_event_t *pending_disconnects;
97 
98  /** Vector of postponed events */
99  session_event_t *postponed_event_vector;
100 
101  /** Peekers rw lock */
103 
105 
107 
109  vlib_node_runtime_t * node,
110  session_worker_t * wrk,
111  session_event_t * e, int *n_tx_pkts);
112 
116 
117 u8 session_node_lookup_fifo_event (svm_fifo_t * f, session_event_t * e);
118 
119 typedef struct session_main_
120 {
121  /** Worker contexts */
123 
124  /** Event queues memfd segment initialized only if so configured */
126 
127  /** Unique segment name counter */
129 
130  /** Per transport rx function that can either dequeue or peek */
132 
133  /** Per session type output nodes. Could optimize to group nodes by
134  * fib but lookup would then require session type parsing in session node.
135  * Trade memory for speed, for now */
137 
138  /*
139  * Config parameters
140  */
141 
142  /** Session manager is enabled */
144 
145  /** vpp fifo event queue configured length */
147 
148  /** Session ssvm segment configs*/
153 
154  /** Session table size parameters */
163 
164  /** Transport table (preallocation) size parameters */
167 
168  /** Preallocate session config parameter */
170 
171 #if SESSION_DEBUG
172  /**
173  * last event poll time by thread
174  * Debug only. Will cause false cache-line sharing as-is
175  */
176  f64 *last_event_poll_by_thread;
177 #endif
178 
180 
185 
186 #define SESSION_Q_PROCESS_FLUSH_FRAMES 1
187 #define SESSION_Q_PROCESS_STOP 2
188 
190 session_is_valid (u32 si, u8 thread_index)
191 {
192  session_t *s;
193  s = pool_elt_at_index (session_main.wrk[thread_index].sessions, si);
195  return 1;
196 
197  if (s->thread_index != thread_index || s->session_index != si)
198  return 0;
199  return 1;
200 }
201 
202 session_t *session_alloc (u32 thread_index);
203 void session_free (session_t * s);
205 
207 session_get (u32 si, u32 thread_index)
208 {
209  ASSERT (session_is_valid (si, thread_index));
210  return pool_elt_at_index (session_main.wrk[thread_index].sessions, si);
211 }
212 
214 session_get_if_valid (u64 si, u32 thread_index)
215 {
216  if (thread_index >= vec_len (session_main.wrk))
217  return 0;
218 
219  if (pool_is_free_index (session_main.wrk[thread_index].sessions, si))
220  return 0;
221 
222  ASSERT (session_is_valid (si, thread_index));
223  return pool_elt_at_index (session_main.wrk[thread_index].sessions, si);
224 }
225 
228 {
230  u32 session_index, thread_index;
231  session_parse_handle (handle, &session_index, &thread_index);
232  return pool_elt_at_index (smm->wrk[thread_index].sessions, session_index);
233 }
234 
237 {
238  u32 session_index, thread_index;
239  session_parse_handle (handle, &session_index, &thread_index);
240  return session_get_if_valid (session_index, thread_index);
241 }
242 
244 
245 /**
246  * Acquires a lock that blocks a session pool from expanding.
247  *
248  * This is typically used for safely peeking into other threads'
249  * pools in order to clone elements. Lock should be dropped as soon
250  * as possible by calling @ref session_pool_remove_peeker.
251  *
252  * NOTE: Avoid using pool_elt_at_index while the lock is held because
253  * it may lead to free elt bitmap expansion/contraction!
254  */
255 always_inline void
257 {
258  session_worker_t *wrk = &session_main.wrk[thread_index];
259  if (thread_index == vlib_get_thread_index ())
260  return;
262 }
263 
264 always_inline void
266 {
267  session_worker_t *wrk = &session_main.wrk[thread_index];
268  if (thread_index == vlib_get_thread_index ())
269  return;
271 }
272 
273 /**
274  * Get session from handle and 'lock' pool resize if not in same thread
275  *
276  * Caller should drop the peek 'lock' as soon as possible.
277  */
280 {
281  u32 thread_index = session_thread_from_handle (handle);
282  session_worker_t *wrk = &session_main.wrk[thread_index];
283 
284  if (thread_index == vlib_get_thread_index ())
285  {
286  return pool_elt_at_index (wrk->sessions,
287  session_index_from_handle (handle));
288  }
289  else
290  {
291  session_pool_add_peeker (thread_index);
292  /* Don't use pool_elt_at index. See @ref session_pool_add_peeker */
293  return wrk->sessions + session_index_from_handle (handle);
294  }
295 }
296 
299 {
300  return (s - session_main.wrk[s->thread_index].sessions);
301 }
302 
304 session_clone_safe (u32 session_index, u32 thread_index)
305 {
306  session_t *old_s, *new_s;
307  u32 current_thread_index = vlib_get_thread_index ();
308 
309  /* If during the memcpy pool is reallocated AND the memory allocator
310  * decides to give the old chunk of memory to somebody in a hurry to
311  * scribble something on it, we have a problem. So add this thread as
312  * a session pool peeker.
313  */
314  session_pool_add_peeker (thread_index);
315  new_s = session_alloc (current_thread_index);
316  old_s = session_main.wrk[thread_index].sessions + session_index;
317  clib_memcpy_fast (new_s, old_s, sizeof (*new_s));
318  session_pool_remove_peeker (thread_index);
319  new_s->thread_index = current_thread_index;
320  new_s->session_index = session_get_index (new_s);
321  return new_s;
322 }
323 
324 int session_open (u32 app_index, session_endpoint_t * tep, u32 opaque);
327 void session_close (session_t * s);
331  session_evt_type_t evt_type);
334 int session_send_io_evt_to_thread_custom (void *data, u32 thread_index,
335  session_evt_type_t evt_type);
336 void session_send_rpc_evt_to_thread (u32 thread_index, void *fp,
337  void *rpc_args);
338 void session_send_rpc_evt_to_thread_force (u32 thread_index, void *fp,
339  void *rpc_args);
341 
342 
343 u8 *format_session (u8 * s, va_list * args);
344 uword unformat_session (unformat_input_t * input, va_list * args);
346  va_list * args);
347 
348 /*
349  * Interface to transport protos
350  */
351 
353  vlib_buffer_t * b, u32 offset,
354  u8 queue_event, u8 is_in_order);
356  session_dgram_hdr_t * hdr,
357  vlib_buffer_t * b, u8 proto,
358  u8 queue_event);
361  u32 old_thread_index,
362  session_t ** new_session);
368 int session_stream_accept (transport_connection_t * tc, u32 listener_index,
369  u8 notify);
370 void session_register_transport (transport_proto_t transport_proto,
371  const transport_proto_vft_t * vft, u8 is_ip4,
372  u32 output_node);
374  u32 offset, u32 max_bytes);
376 
379 {
380  session_t *s = session_get (tc->s_index, tc->thread_index);
381  return svm_fifo_max_enqueue (s->rx_fifo);
382 }
383 
386 {
387  session_t *s = session_get (tc->s_index, tc->thread_index);
388  return svm_fifo_max_dequeue (s->tx_fifo);
389 }
390 
393 {
394  session_t *s = session_get (tc->s_index, tc->thread_index);
395  return svm_fifo_max_dequeue (s->rx_fifo);
396 }
397 
400 {
401  session_t *s = session_get (tc->s_index, tc->thread_index);
402  return s->rx_fifo->nitems;
403 }
404 
407 {
408  session_t *s = session_get (tc->s_index, tc->thread_index);
409  return s->tx_fifo->nitems;
410 }
411 
414 {
415  session_t *s = session_get (tc->c_index, tc->thread_index);
416  return svm_fifo_has_ooo_data (s->rx_fifo);
417 }
418 
421 {
422  return session_main.wrk[thread_index].dispatch_period;
423 }
424 
426 transport_time_now (u32 thread_index)
427 {
428  return session_main.wrk[thread_index].last_vlib_time;
429 }
430 
431 always_inline void
433 {
434  session_t *s = session_get (tc->s_index, tc->thread_index);
435  if (svm_fifo_has_event (s->tx_fifo))
436  return;
438 }
439 
440 /*
441  * Listen sessions
442  */
443 
446 {
448  return session_handle (s);
449 }
450 
453 {
454  return session_get_from_handle (handle);
455 }
456 
457 always_inline void
459  u32 * thread_index)
460 {
461  session_parse_handle (handle, index, thread_index);
462 }
463 
466 {
467  session_t *s;
468  s = session_alloc (thread_index);
469  s->session_type = type;
471  return s;
472 }
473 
476 {
477  return session_get (ls_index, 0);
478 }
479 
480 always_inline void
482 {
483  session_free (s);
484 }
485 
487 
488 /*
489  * Session layer functions
490  */
491 
494 {
495  return &session_main;
496 }
497 
500 {
501  return &session_main.wrk[thread_index];
502 }
503 
506 {
507  return session_main.wrk[thread_index].vpp_event_queue;
508 }
509 
512 {
513  return session_main.is_enabled == 1;
514 }
515 
516 #define session_cli_return_if_not_enabled() \
517 do { \
518  if (!session_main.is_enabled) \
519  return clib_error_return(0, "session layer is not enabled"); \
520 } while (0)
521 
522 int session_main_flush_enqueue_events (u8 proto, u32 thread_index);
523 int session_main_flush_all_enqueue_events (u8 transport_proto);
526 void session_node_enable_disable (u8 is_en);
528 
529 #endif /* __included_session_h__ */
530 
531 /*
532  * fd.io coding-style-patch-verification: ON
533  *
534  * Local Variables:
535  * eval: (c-set-style "gnu")
536  * End:
537  */
transport_connection_t * session_get_transport(session_t *s)
Definition: session.c:1283
static u8 session_is_valid(u32 si, u8 thread_index)
Definition: session.h:190
static void clib_rwlock_reader_lock(clib_rwlock_t *p)
Definition: lock.h:139
u32 preallocated_sessions
Preallocate session config parameter.
Definition: session.h:169
int session_enqueue_dgram_connection(session_t *s, session_dgram_hdr_t *hdr, vlib_buffer_t *b, u8 proto, u8 queue_event)
Definition: session.c:408
uword evt_qs_segment_size
Definition: session.h:151
u32 session_tx_fifo_dequeue_drop(transport_connection_t *tc, u32 max_bytes)
Definition: session.c:453
int session_tx_fifo_peek_bytes(transport_connection_t *tc, u8 *buffer, u32 offset, u32 max_bytes)
Definition: session.c:445
int session_listen(session_t *s, session_endpoint_cfg_t *sep)
Ask transport to listen on session endpoint.
Definition: session.c:1017
session_type_t session_type
Type built from transport and network protocol types.
static u32 transport_rx_fifo_size(transport_connection_t *tc)
Definition: session.h:399
int session_stream_accept_notify(transport_connection_t *tc)
Definition: session.c:851
svm_msg_q_t * vpp_event_queue
vpp event message queue for worker
Definition: session.h:72
transport_connection_t * listen_session_get_transport(session_t *s)
Definition: session.c:1294
u8 * format_session(u8 *s, va_list *args)
Format stream session as per the following format.
Definition: session_cli.c:55
svm_fifo_t * tx_fifo
static f64 transport_time_now(u32 thread_index)
Definition: session.h:426
uword unformat_transport_connection(unformat_input_t *input, va_list *args)
Definition: session_cli.c:195
static u8 svm_fifo_has_ooo_data(svm_fifo_t *f)
Definition: svm_fifo.h:159
u32 session_index
Index in thread pool where session was allocated.
unsigned long u64
Definition: types.h:89
struct session_tx_context_ session_tx_context_t
static svm_msg_q_t * session_main_get_vpp_event_queue(u32 thread_index)
Definition: session.h:505
u32 configured_v4_halfopen_table_buckets
Definition: session.h:157
#define clib_memcpy_fast(a, b, c)
Definition: string.h:81
session_t * s
Definition: session.h:47
svm_fifo_t * rx_fifo
Pointers to rx/tx buffers.
session_worker_t * wrk
Worker contexts.
Definition: session.h:122
static session_t * session_get_if_valid(u64 si, u32 thread_index)
Definition: session.h:214
static u32 session_get_index(session_t *s)
Definition: session.h:298
static session_t * listen_session_get_from_handle(session_handle_t handle)
Definition: session.h:452
int session_stop_listen(session_t *s)
Ask transport to stop listening on local transport endpoint.
Definition: session.c:1045
session_evt_type_t
static session_t * listen_session_alloc(u8 thread_index, session_type_t type)
Definition: session.h:465
int session_stream_connect_notify(transport_connection_t *tc, u8 is_fail)
Definition: session.c:598
static u32 svm_fifo_max_enqueue(svm_fifo_t *f)
Definition: svm_fifo.h:147
static void session_pool_remove_peeker(u32 thread_index)
Definition: session.h:265
static session_t * session_get(u32 si, u32 thread_index)
Definition: session.h:207
u8 data[128]
Definition: ipsec.api:248
u32 unique_segment_name_counter
Unique segment name counter.
Definition: session.h:128
static session_t * session_clone_safe(u32 session_index, u32 thread_index)
Definition: session.h:304
u32 local_endpoints_table_memory
Transport table (preallocation) size parameters.
Definition: session.h:165
uword unformat_session(unformat_input_t *input, va_list *args)
Definition: session_cli.c:164
vlib_node_registration_t session_queue_node
(constructor) VLIB_REGISTER_NODE (session_queue_node)
static void session_parse_handle(session_handle_t handle, u32 *index, u32 *thread_index)
unsigned char u8
Definition: types.h:56
session_fifo_rx_fn session_tx_fifo_peek_and_snd
session_t * sessions
Worker session pool.
Definition: session.h:69
double f64
Definition: types.h:142
static session_handle_t session_handle(session_t *s)
struct _svm_fifo svm_fifo_t
CLIB_CACHE_LINE_ALIGN_MARK(cacheline0)
void session_transport_cleanup(session_t *s)
Cleanup transport and session state.
Definition: session.c:1131
session_t * session_alloc(u32 thread_index)
Definition: session.c:150
u8 session_type_t
u32 * tx_buffers
Vector of tx buffer free lists.
Definition: session.h:87
static session_worker_t * session_main_get_worker(u32 thread_index)
Definition: session.h:499
vlib_node_registration_t session_queue_pre_input_node
(constructor) VLIB_REGISTER_NODE (session_queue_pre_input_node)
void session_send_rpc_evt_to_thread(u32 thread_index, void *fp, void *rpc_args)
Definition: session.c:117
#define always_inline
Definition: clib.h:98
void session_transport_closed_notify(transport_connection_t *tc)
Notification from transport that session can be closed.
Definition: session.c:807
static u32 svm_fifo_max_dequeue(svm_fifo_t *f)
Definition: svm_fifo.h:129
u32 * session_type_to_next
Per session type output nodes.
Definition: session.h:136
int session_open(u32 app_index, session_endpoint_t *tep, u32 opaque)
Ask transport to open connection to remote transport endpoint.
Definition: session.c:1001
u32 last_tx_packets
Definition: session.h:104
uword session_baseva
Session ssvm segment configs.
Definition: session.h:149
int session_dequeue_notify(session_t *s)
Definition: session.c:529
unsigned int u32
Definition: types.h:88
session_event_t * free_event_vector
Vector of partially read events.
Definition: session.h:90
u64 session_segment_handle(session_t *s)
Definition: session.c:1226
struct _transport_proto_vft transport_proto_vft_t
struct _session_endpoint_cfg session_endpoint_cfg_t
u32 configured_v6_halfopen_table_memory
Definition: session.h:162
u32 configured_v6_session_table_buckets
Definition: session.h:159
#define pool_elt_at_index(p, i)
Returns pointer to element at given index.
Definition: pool.h:514
uword session_va_space_size
Definition: session.h:150
u32 configured_v4_session_table_buckets
Session table size parameters.
Definition: session.h:155
static void clib_rwlock_reader_unlock(clib_rwlock_t *p)
Definition: lock.h:157
static session_t * session_get_from_handle(session_handle_t handle)
Definition: session.h:227
transport_proto_vft_t * transport_vft
Definition: session.h:48
session_event_t * pending_disconnects
Vector of postponed disconnects.
Definition: session.h:96
void session_register_transport(transport_proto_t transport_proto, const transport_proto_vft_t *vft, u8 is_ip4, u32 output_node)
Initialize session layer for given transport proto and ip version.
Definition: session.c:1254
struct _unformat_input_t unformat_input_t
u32 configured_v6_halfopen_table_buckets
Definition: session.h:161
unsigned short u16
Definition: types.h:57
u32 configured_event_queue_length
vpp fifo event queue configured length
Definition: session.h:146
void session_free(session_t *s)
Definition: session.c:175
u8 is_enabled
Session manager is enabled.
Definition: session.h:143
static u32 transport_max_rx_dequeue(transport_connection_t *tc)
Definition: session.h:392
static session_t * session_get_from_handle_safe(u64 handle)
Get session from handle and &#39;lock&#39; pool resize if not in same thread.
Definition: session.h:279
session_fifo_rx_fn ** session_tx_fns
Per transport rx function that can either dequeue or peek.
Definition: session.h:131
static u64 listen_session_get_handle(session_t *s)
Definition: session.h:445
static void session_pool_add_peeker(u32 thread_index)
Acquires a lock that blocks a session pool from expanding.
Definition: session.h:256
int( session_fifo_rx_fn)(vlib_main_t *vm, vlib_node_runtime_t *node, session_worker_t *wrk, session_event_t *e, int *n_tx_pkts)
Definition: session.h:108
clib_rwlock_t peekers_rw_locks
Peekers rw lock.
Definition: session.h:102
static session_t * session_get_from_handle_if_valid(session_handle_t handle)
Definition: session.h:236
void session_node_enable_disable(u8 is_en)
Definition: session.c:1392
u8 evt_qs_use_memfd_seg
Definition: session.h:152
f64 dispatch_period
Our approximation of a "complete" dispatch loop period.
Definition: session.h:75
session_fifo_rx_fn session_tx_fifo_dequeue_and_snd
ssvm_private_t evt_qs_segment
Event queues memfd segment initialized only if so configured.
Definition: session.h:125
int session_dgram_connect_notify(transport_connection_t *tc, u32 old_thread_index, session_t **new_session)
Move dgram session to the right thread.
Definition: session.c:682
static_always_inline uword vlib_get_thread_index(void)
Definition: threads.h:212
Unidirectional shared-memory multi-ring message queue.
vlib_main_t * vm
Definition: buffer.c:312
session_main_t session_main
Definition: session.c:26
static u8 transport_rx_fifo_has_ooo_data(transport_connection_t *tc)
Definition: session.h:413
void session_free_w_fifos(session_t *s)
Definition: session.c:189
struct _transport_connection transport_connection_t
#define pool_is_free_index(P, I)
Use free bitmap to query whether given index is free.
Definition: pool.h:283
void session_transport_delete_notify(transport_connection_t *tc)
Notification from transport that connection is being deleted.
Definition: session.c:746
session_event_t * pending_event_vector
Vector of active event vectors.
Definition: session.h:93
struct session_worker_ session_worker_t
struct session_main_ session_main_t
static u32 session_thread_from_handle(session_handle_t handle)
clib_error_t * vnet_session_enable_disable(vlib_main_t *vm, u8 is_en)
Definition: session.c:1426
static u32 transport_max_tx_dequeue(transport_connection_t *tc)
Definition: session.h:385
static u32 session_index_from_handle(session_handle_t handle)
#define ASSERT(truth)
void session_transport_reset_notify(transport_connection_t *tc)
Notify application that connection has been reset.
Definition: session.c:836
int session_enqueue_notify(session_t *s)
Definition: session.c:523
void session_close(session_t *s)
Initialize session closing procedure.
Definition: session.c:1069
int session_send_io_evt_to_thread(svm_fifo_t *f, session_evt_type_t evt_type)
Definition: session.c:86
session_tx_context_t ctx
Context for session tx.
Definition: session.h:84
static void transport_add_tx_event(transport_connection_t *tc)
Definition: session.h:432
int session_send_io_evt_to_thread_custom(void *data, u32 thread_index, session_evt_type_t evt_type)
Definition: session.c:93
enum _transport_proto transport_proto_t
int session_enqueue_stream_connection(transport_connection_t *tc, vlib_buffer_t *b, u32 offset, u8 queue_event, u8 is_in_order)
Definition: session.c:355
u32 configured_v4_halfopen_table_memory
Definition: session.h:158
u32 configured_v4_session_table_memory
Definition: session.h:156
void session_send_rpc_evt_to_thread_force(u32 thread_index, void *fp, void *rpc_args)
Definition: session.c:109
session_dgram_hdr_t hdr
Definition: session.h:61
u8 thread_index
Index of the thread that allocated the session.
static void listen_session_free(session_t *s)
Definition: session.h:481
int session_stream_accept(transport_connection_t *tc, u32 listener_index, u8 notify)
Accept a stream session.
Definition: session.c:868
struct _vlib_node_registration vlib_node_registration_t
template key/value backing page structure
Definition: bihash_doc.h:44
u32 local_endpoints_table_buckets
Definition: session.h:166
u64 session_handle_t
#define vec_len(v)
Number of elements in vector (rvalue-only, NULL tolerant)
session_fifo_rx_fn session_tx_fifo_dequeue_internal
volatile u8 session_state
State in session layer state machine.
VLIB buffer representation.
Definition: buffer.h:102
u64 uword
Definition: types.h:112
int session_main_flush_all_enqueue_events(u8 transport_proto)
Definition: session.c:588
session_error_t
Definition: session.h:36
#define foreach_session_input_error
Definition: session.h:24
f64 last_vlib_time
vlib_time_now last time around the track
Definition: session.h:78
transport_connection_t * tc
Definition: session.h:49
u32 configured_v6_session_table_memory
Definition: session.h:160
vlib_node_registration_t session_queue_process_node
(constructor) VLIB_REGISTER_NODE (session_queue_process_node)
static int svm_fifo_has_event(svm_fifo_t *f)
Definition: svm_fifo.h:153
session_event_t * postponed_event_vector
Vector of postponed events.
Definition: session.h:99
int session_main_flush_enqueue_events(u8 proto, u32 thread_index)
Flushes queue of sessions that are to be notified of new data enqueued events.
Definition: session.c:559
u8 session_node_lookup_fifo_event(svm_fifo_t *f, session_event_t *e)
static session_main_t * vnet_get_session_main()
Definition: session.h:493
static u32 transport_max_rx_enqueue(transport_connection_t *tc)
Definition: session.h:378
struct _session_endpoint session_endpoint_t
void session_transport_close(session_t *s)
Notify transport the session can be disconnected.
Definition: session.c:1099
void session_transport_closing_notify(transport_connection_t *tc)
Notification from transport that connection is being closed.
Definition: session.c:724
ssvm_private_t * session_main_get_evt_q_segment(void)
Definition: session.c:1217
static u32 transport_tx_fifo_size(transport_connection_t *tc)
Definition: session.h:406
static session_t * listen_session_get(u32 ls_index)
Definition: session.h:475
void session_flush_frames_main_thread(vlib_main_t *vm)
Definition: session.c:1301
static f64 transport_dispatch_period(u32 thread_index)
Definition: session.h:420
static u8 session_main_is_enabled()
Definition: session.h:511
static void listen_session_parse_handle(session_handle_t handle, u32 *index, u32 *thread_index)
Definition: session.h:458